Support for ED25519

README.md

@@ -144,6 +144,27 @@ decoded_token = JWT.decode token, ecdsa_public, true, { :algorithm => 'ES256' }
 puts decoded_token
 ```
 
+**EDDSA**
+
+* ED25519 
+
+```ruby 
+private_key = RbNaCl::Signatures::Ed25519::SigningKey.new("abcdefghijklmnopqrstuvwxyzABCDEF")
+public_key = private_key.verify_key
+token = JWT.encode payload, private_key, 'ED25519' 
+
+# eyJhbGciOiJFRDI1NTE5In0.eyJ0ZXN0IjoiZGF0YSJ9.-Ki0vxVOlsPXovPsYRT_9OXrLSgQd4RDAgCLY_PLmcP4q32RYy-yUUmX82ycegdekR9wo26me1wOzjmSU5nTCQ
+puts token
+
+decoded_token = JWT.decode token, public_key, true, {:algorithm => 'ED25519' } 
+# Array
+# [
+#  {"test"=>"data"}, # payload
+#  {"alg"=>"ED25519"} # header
+# ]
+
+```
+
 **RSASSA-PSS**
 
 Not implemented.

lib/jwt/signature.rb

@@ -17,7 +17,8 @@ module Signature
     HMAC_ALGORITHMS = %w[HS256 HS512256 HS384 HS512].freeze
     RSA_ALGORITHMS = %w[RS256 RS384 RS512].freeze
     ECDSA_ALGORITHMS = %w[ES256 ES384 ES512].freeze
-
+    EDDSA_ALGORITHMS = %w[ED25519].freeze
+
     NAMED_CURVES = {
       'prime256v1' => 'ES256',
       'secp384r1' => 'ES384',
@@ -31,6 +32,8 @@ def sign(algorithm, msg, key)
         sign_rsa(algorithm, msg, key)
       elsif ECDSA_ALGORITHMS.include?(algorithm)
         sign_ecdsa(algorithm, msg, key)
+      elsif EDDSA_ALGORITHMS.include?(algorithm)
+        sign_eddsa(algorithm, msg, key)
       else
         raise NotImplementedError, 'Unsupported signing method'
       end
@@ -43,6 +46,8 @@ def verify(algo, key, signing_input, signature)
         SecurityUtils.verify_rsa(algo, key, signing_input, signature)
       elsif ECDSA_ALGORITHMS.include?(algo)
         verify_ecdsa(algo, key, signing_input, signature)
+      elsif EDDSA_ALGORITHMS.include?(algo)
+        verify_eddsa(algo, key, signing_input, signature)
       else
         raise JWT::VerificationError, 'Algorithm not supported'
       end
@@ -70,7 +75,11 @@ def sign_ecdsa(algorithm, msg, private_key)
       digest = OpenSSL::Digest.new(algorithm.sub('ES', 'sha'))
       SecurityUtils.asn1_to_raw(private_key.dsa_sign_asn1(digest.digest(msg)), private_key)
     end
-
+    def sign_eddsa(algorithm, msg, private_key)
+      raise EncodeError, "Key given is a #{private_key.class} but has to be an RbNaCl::Signatures::Ed25519::SigningKey" if private_key.class != RbNaCl::Signatures::Ed25519::SigningKey
+      raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{private_key.primitive} signing key was provided"  if algorithm.downcase.to_sym != private_key.primitive
+      private_key.sign(msg) 
+    end
     def sign_hmac(algorithm, msg, key)
       authenticator, padded_key = SecurityUtils.rbnacl_fixup(algorithm, key)
       if authenticator && padded_key
@@ -79,13 +88,16 @@ def sign_hmac(algorithm, msg, key)
         OpenSSL::HMAC.digest(OpenSSL::Digest.new(algorithm.sub('HS', 'sha')), key, msg)
       end
     end
-
+    def verify_eddsa(algorithm, public_key,signing_input, signature)
+      raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{public_key.primitive} verification key was provided" if algorithm.downcase.to_sym != public_key.primitive
+      raise DecodeError, "key given is a #{public_key.class} but has to be a RbNaCl::Signatures::Ed25519::VerifyKey" if public_key.class != RbNaCl::Signatures::Ed25519::VerifyKey
+      public_key.verify(signature, signing_input)
+    end
     def verify_ecdsa(algorithm, public_key, signing_input, signature)
       key_algorithm = NAMED_CURVES[public_key.group.curve_name]
       if algorithm != key_algorithm
         raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{key_algorithm} verification key was provided"
       end
-
       digest = OpenSSL::Digest.new(algorithm.sub('ES', 'sha'))
       public_key.dsa_verify_asn1(digest.digest(signing_input), SecurityUtils.raw_to_asn1(signature, public_key))
     end

spec/jwt_spec.rb

@@ -19,6 +19,8 @@
       'ES384_public' => OpenSSL::PKey.read(File.read(File.join(CERT_PATH, 'ec384-public.pem'))),
       'ES512_private' => OpenSSL::PKey.read(File.read(File.join(CERT_PATH, 'ec512-private.pem'))),
       'ES512_public' => OpenSSL::PKey.read(File.read(File.join(CERT_PATH, 'ec512-public.pem'))),
+      'ED25519_private' =>  RbNaCl::Signatures::Ed25519::SigningKey.new("abcdefghijklmnopqrstuvwxyzABCDEF"),
+      'ED25519_public' => RbNaCl::Signatures::Ed25519::SigningKey.new("abcdefghijklmnopqrstuvwxyzABCDEF").verify_key,  
       'NONE' => 'eyJhbGciOiJub25lIn0.eyJ1c2VyX2lkIjoic29tZUB1c2VyLnRsZCJ9.',
       'HS256' => 'eyJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjoic29tZUB1c2VyLnRsZCJ9.kWOVtIOpWcG7JnyJG0qOkTDbOy636XrrQhMm_8JrRQ8',
       'HS512256' => 'eyJhbGciOiJIUzUxMjI1NiJ9.eyJ1c2VyX2lkIjoic29tZUB1c2VyLnRsZCJ9.Ds_4ibvf7z4QOBoKntEjDfthy3WJ-3rKMspTEcHE2bA',
@@ -132,7 +134,42 @@
     end
   end
 
-  %w[ES256 ES384 ES512].each do |alg|
+  %w[ED25519].each do |alg|
+    context "alg: #{alg}" do
+      before(:each) do
+        data[alg] = JWT.encode payload, data["#{alg}_private"], alg
+      end
+
+      let(:wrong_key) { OpenSSL::PKey.read(File.read(File.join(CERT_PATH, 'ec256-wrong-public.pem'))) }
+
+      it 'should generate a valid token' do
+        jwt_payload, header = JWT.decode data[alg], data["#{alg}_public"], true, algorithm: alg
+
+        expect(header['alg']).to eq alg
+        expect(jwt_payload).to eq payload
+      end
+
+      it 'should decode a valid token' do
+        jwt_payload, header = JWT.decode data[alg], data["#{alg}_public"], true, algorithm: alg
+
+        expect(header['alg']).to eq alg
+        expect(jwt_payload).to eq payload
+      end
+
+      it 'wrong key should raise JWT::DecodeError' do
+        expect do
+          JWT.decode data[alg], wrong_key
+        end.to raise_error JWT::DecodeError
+      end
+
+      it 'wrong key and verify = false should not raise JWT::DecodeError' do
+        expect do
+          JWT.decode data[alg], wrong_key, false
+        end.not_to raise_error
+      end
+    end
+  end
+  %w[ES256 ES384 ES512 ].each do |alg|
     context "alg: #{alg}" do
       before(:each) do
         data[alg] = JWT.encode payload, data["#{alg}_private"], alg