json_web_token 0.1.1 → 0.1.2

data/spec/json_web_token/jws_spec.rb

@@ -4,12 +4,12 @@ require 'support/ecdsa_key'
 module JsonWebToken
   describe Jws do
     context 'w payload' do
-      let(:payload) { 'payload' }
-      context '#message_signature' do
-        shared_examples_for 'w #validate' do
-          it 'is verified' do
-            jws = Jws.message_signature(header, payload, signing_key)
-            expect(Jws.validate jws, algorithm, verifying_key).to eql jws
+      let(:payload) { '{"iss":"joe","exp":1300819380,"http://example.com/is_root":true}' }
+      context '#sign' do
+        shared_examples_for 'does #verify' do
+          it 'w a jws' do
+            jws = Jws.sign(header, payload, signing_key)
+            expect(Jws.verify jws, algorithm, verifying_key).to eql jws
           end
         end
 
@@ -18,23 +18,31 @@ module JsonWebToken
           let(:verifying_key) { signing_key }
           context "w HS256 'alg' header parameter" do
             let(:header) { {alg: 'HS256'} }
-            describe 'w passing a matching algorithm to #validate' do
+            context 'w passing a matching algorithm to #verify' do
               let(:algorithm) { 'HS256' }
-              it_behaves_like 'w #validate'
+              it_behaves_like 'does #verify'
 
-              describe 'w/o passing key to #validate' do
+              describe 'w/o passing key to #verify' do
                 it "returns 'Invalid'" do
-                  jws = Jws.message_signature(header, payload, signing_key)
-                  expect(Jws.validate jws, algorithm, nil).to eql 'Invalid'
+                  jws = Jws.sign(header, payload, signing_key)
+                  expect(Jws.verify jws, algorithm, nil).to be false
+                end
+              end
+
+              describe 'w passing a changed key to #verify' do
+                let(:changed_key) { 'gZH75aKtMN3Yj0iPS4hcgUuTwjAzZr9Z' }
+                it "returns 'Invalid'" do
+                  jws = Jws.sign(header, payload, signing_key)
+                  expect(Jws.verify jws, algorithm, changed_key).to be false
                 end
               end
             end
 
-            describe 'w/o passing a matching algorithm to #validate' do
+            describe 'w/o passing a matching algorithm to #verify' do
               let(:algorithm) { 'RS256' }
               it 'raises' do
-                jws = Jws.message_signature(header, payload, signing_key)
-                expect { Jws.validate(jws, algorithm, verifying_key) }
+                jws = Jws.sign(header, payload, signing_key)
+                expect { Jws.verify(jws, algorithm, verifying_key) }
                   .to raise_error(RuntimeError, "Algorithm not matching 'alg' header parameter")
               end
             end
@@ -46,35 +54,35 @@ module JsonWebToken
           let(:verifying_key) { signing_key.public_key }
           context "w RS256 'alg' header parameter" do
             let(:header) { {alg: 'RS256'} }
-            describe 'w passing a matching algorithm to #validate' do
+            describe 'w passing a matching algorithm to #verify' do
               let(:algorithm) { 'RS256' }
-              it_behaves_like 'w #validate'
+              it_behaves_like 'does #verify'
             end
           end
         end
 
         context "w ES256 'alg' header parameter" do
           let(:header) { {alg: 'ES256'} }
-          describe 'w passing a matching algorithm to #validate' do
+          describe 'w passing a matching algorithm to #verify' do
             let(:algorithm) { 'ES256' }
-            it 'is verified' do
+            it 'w a jws' do
               private_key = EcdsaKey.curve_new('256')
               public_key_str = EcdsaKey.public_key_str(private_key)
               public_key = EcdsaKey.public_key_new('256', public_key_str)
 
-              jws = Jws.message_signature(header, payload, private_key)
-              expect(Jws.validate jws, algorithm, public_key).to eql jws
+              jws = Jws.sign(header, payload, private_key)
+              expect(Jws.verify jws, algorithm, public_key).to eql jws
             end
           end
         end
       end
 
       context 'header validation' do
-        let(:signing_key) { 'signing_key' }
+        let(:signing_key) { 'gZH75aKtMN3Yj0iPS4hcgUuTwjAzZr9C' }
         describe "w/o a recognized 'alg' header parameter" do
           let(:header) { {alg: 'HS257'} }
           it 'raises' do
-            expect { Jws.message_signature(header, payload, signing_key) }
+            expect { Jws.sign(header, payload, signing_key) }
               .to raise_error(RuntimeError, 'Unrecognized algorithm')
           end
         end
@@ -82,29 +90,29 @@ module JsonWebToken
         describe "w/o a required 'alg' header parameter" do
           let(:header) { {typ: 'JWT'} }
           it 'raises' do
-            expect { Jws.message_signature(header, payload, signing_key) }
+            expect { Jws.sign(header, payload, signing_key) }
               .to raise_error(RuntimeError, "Missing required 'alg' header parameter")
           end
         end
       end
 
-      context '#unsecured_jws' do
+      context '#unsecured_message' do
         context 'w valid header' do
           let(:header) { {alg: 'none'} }
-          describe 'w passing a matching algorithm to #validate' do
+          describe 'w passing a matching algorithm to #verify' do
             let(:algorithm) { 'none' }
-            it 'is verified' do
-              jws = Jws.unsecured_jws(header, payload)
-              expect(Jws.validate jws, algorithm).to eql jws
+            it 'w a jws' do
+              jws = Jws.unsecured_message(header, payload)
+              expect(Jws.verify jws, algorithm).to eql jws
             end
           end
 
-          describe 'w/o passing a matching algorithm to #validate' do
+          describe 'w/o passing a matching algorithm to #verify' do
             let(:algorithm) { 'HS256' }
             let(:verifying_key) { 'gZH75aKtMN3Yj0iPS4hcgUuTwjAzZr9C' }
             it 'raises' do
-              jws = Jws.unsecured_jws(header, payload)
-              expect { Jws.validate(jws, algorithm, verifying_key) }
+              jws = Jws.unsecured_message(header, payload)
+              expect { Jws.verify(jws, algorithm, verifying_key) }
                 .to raise_error(RuntimeError, "Algorithm not matching 'alg' header parameter")
             end
           end
@@ -113,7 +121,7 @@ module JsonWebToken
         describe 'w invalid header' do
           let(:header) { {alg: 'HS256'} }
           it 'raises' do
-            expect { Jws.unsecured_jws(header, payload) }
+            expect { Jws.unsecured_message(header, payload) }
               .to raise_error(RuntimeError, "Invalid 'alg' header parameter")
           end
         end

data/spec/json_web_token/jwt_spec.rb

@@ -4,71 +4,81 @@ require 'support/plausible_jwt'
 
 module JsonWebToken
   describe Jwt do
-    context '#create' do
-      shared_examples_for 'w #validate' do
-        it 'is verified' do
-          jwt = Jwt.create(claims, create_options)
-          expect(Jwt.validate jwt, validate_options).to include(claims)
+    context '#sign' do
+      shared_examples_for 'does #verify' do
+        it 'w a claims set' do
+          jwt = Jwt.sign(claims, sign_options)
+          expect(Jwt.verify jwt, verify_options).to include(claims)
         end
       end
 
-      shared_examples_for 'return message signature' do
-        it 'plausible' do
-          jwt = Jwt.create(claims, create_options)
+      shared_examples_for 'return a jwt' do
+        it 'that is plausible' do
+          jwt = Jwt.sign(claims, sign_options)
           expect(plausible_message_signature? jwt).to be true
         end
       end
 
       context 'w claims' do
-        let(:claims) { {exp: 'tomorrow'} }
+        let(:claims) { { iss: 'joe', exp: 1300819380, 'http://example.com/is_root': true} }
         context 'w HS256 keys' do
           let(:signing_key) { 'gZH75aKtMN3Yj0iPS4hcgUuTwjAzZr9C' }
           let(:verifying_key) { signing_key }
-          let(:validate_options) { {key: verifying_key} }
+          let(:verify_options) { {key: verifying_key} }
           describe 'default header' do
-            let(:create_options) { {key: signing_key} }
-            it_behaves_like 'w #validate'
-            it_behaves_like 'return message signature'
+            let(:sign_options) { {key: signing_key} }
+            it_behaves_like 'does #verify'
+            it_behaves_like 'return a jwt'
           end
 
           describe 'w alg option' do
-            let(:create_options) { {alg: 'HS256', key: signing_key} }
-            it_behaves_like 'w #validate'
-            it_behaves_like 'return message signature'
+            let(:sign_options) { {alg: 'HS256', key: signing_key} }
+            it_behaves_like 'does #verify'
+            it_behaves_like 'return a jwt'
           end
 
           describe 'w alg: nil option' do
-            let(:create_options) { {alg: nil, key: signing_key} }
-            it_behaves_like 'w #validate'
-            it_behaves_like 'return message signature'
+            let(:sign_options) { {alg: nil, key: signing_key} }
+            it_behaves_like 'does #verify'
+            it_behaves_like 'return a jwt'
           end
 
           describe "w alg empty string option" do
-            let(:create_options) { {alg: '', key: signing_key} }
-            it_behaves_like 'w #validate'
-            it_behaves_like 'return message signature'
+            let(:sign_options) { {alg: '', key: signing_key} }
+            it_behaves_like 'does #verify'
+            it_behaves_like 'return a jwt'
           end
 
           describe "w alg: 'none' option" do
-            let(:create_options) { {alg: 'none', key: signing_key} }
+            let(:sign_options) { {alg: 'none', key: signing_key} }
             it 'raises' do
-              jwt = Jwt.create(claims, create_options)
-              expect { Jwt.validate(jwt, validate_options) }
+              jwt = Jwt.sign(claims, sign_options)
+              expect { Jwt.verify(jwt, verify_options) }
                 .to raise_error(RuntimeError, "Algorithm not matching 'alg' header parameter")
             end
           end
         end
 
+        describe 'w HS256 key changed' do
+          let(:sign_options) { {alg: 'HS256', key: 'gZH75aKtMN3Yj0iPS4hcgUuTwjAzZr9C'} }
+          let(:changed_key) { 'gZH75aKtMN3Yj0iPS4hcgUuTwjAzZr9Z' }
+          let(:verify_options) { {key: verifying_key} }
+          it 'raises' do
+            jwt = Jwt.sign(claims, sign_options)
+            expect(Jwt.verify jwt, {key: changed_key}).to include(error: 'invalid')
+          end
+        end
+
         context 'w RS256 keys' do
           let(:signing_key) { OpenSSL::PKey::RSA.generate(2048) }
           let(:verifying_key) { signing_key.public_key }
-          let(:validate_options) { {alg: 'RS256', key: verifying_key} }
+          let(:verify_options) { {alg: 'RS256', key: verifying_key} }
           describe 'passing matching options' do
-            let(:create_options) { {alg: 'RS256', key: signing_key} }
-            it_behaves_like 'w #validate'
+            let(:sign_options) { {alg: 'RS256', key: signing_key} }
+            it_behaves_like 'does #verify'
 
             it 'plausible' do
-              jwt = Jwt.create(claims, create_options)
+              jwt = Jwt.sign(claims, sign_options)
               expect(plausible_message_signature? jwt, 256).to be true
             end
           end
@@ -76,17 +86,17 @@ module JsonWebToken
 
         context "w ES256 'alg' header parameter" do
           let(:algorithm) { 'ES256' }
-          describe 'w passing a matching algorithm to #validate' do
+          describe 'w passing a matching algorithm to #verify' do
             it 'is verified and plausible' do
               private_key = EcdsaKey.curve_new('256')
               public_key_str = EcdsaKey.public_key_str(private_key)
               public_key = EcdsaKey.public_key_new('256', public_key_str)
 
-              create_options = {alg: algorithm, key: private_key}
-              jwt = Jwt.create(claims, create_options)
+              sign_options = {alg: algorithm, key: private_key}
+              jwt = Jwt.sign(claims, sign_options)
 
-              validate_options = {alg: algorithm, key: public_key}
-              expect(Jwt.validate jwt, validate_options).to include(claims)
+              verify_options = {alg: algorithm, key: public_key}
+              expect(Jwt.verify jwt, verify_options).to include(claims)
 
               expect(plausible_message_signature? jwt, 64).to be true
             end
@@ -95,20 +105,20 @@ module JsonWebToken
 
         context 'w/o key' do
           context "w alg: 'none' header parameter" do
-            let(:create_options) { {alg: 'none'} }
-            describe "w validate alg: 'none'" do
-              let(:validate_options) { {alg: 'none'} }
-              it 'validates a plausible unsecured jws' do
-                jwt = Jwt.create(claims, create_options)
-                expect(Jwt.validate jwt, validate_options).to include(claims)
-                expect(plausible_unsecured_jws? jwt).to be true
+            let(:sign_options) { {alg: 'none'} }
+            describe "w verify alg: 'none'" do
+              let(:verify_options) { {alg: 'none'} }
+              it 'verifies a plausible unsecured jws' do
+                jwt = Jwt.sign(claims, sign_options)
+                expect(Jwt.verify jwt, verify_options).to include(claims)
+                expect(plausible_unsecured_message? jwt).to be true
               end
             end
 
-            describe 'w default validate alg' do
+            describe 'w default verify alg' do
               it 'raises' do
-                jwt = Jwt.create(claims, create_options)
-                expect { Jwt.validate(jwt) }
+                jwt = Jwt.sign(claims, sign_options)
+                expect { Jwt.verify(jwt) }
                   .to raise_error(RuntimeError, "Algorithm not matching 'alg' header parameter")
               end
             end
@@ -120,7 +130,7 @@ module JsonWebToken
         let(:options) { {key: 'gZH75aKtMN3Yj0iPS4hcgUuTwjAzZr9C'} }
         shared_examples_for 'w/o claims' do
           it 'raises' do
-            expect { Jwt.create(claims, options) }
+            expect { Jwt.sign(claims, options) }
               .to raise_error(RuntimeError, 'Claims blank')
           end
         end

data/spec/json_web_token/util_spec.rb

@@ -2,14 +2,14 @@ require 'json_web_token/util'
 
 module JsonWebToken
   describe Util do
-    describe '#constant_time_compare' do
+    describe '#constant_time_compare?' do
       it 'guards against empty or nil strings' do
-        expect(Util.constant_time_compare 'a', 'a').to be true
+        expect(Util.constant_time_compare? 'a', 'a').to be true
 
-        expect(Util.constant_time_compare 'a', 'b').to be false
-        expect(Util.constant_time_compare 'a', 'A').to be false
-        expect(Util.constant_time_compare '', '').to be false
-        expect(Util.constant_time_compare nil, nil).to be false
+        expect(Util.constant_time_compare? 'a', 'b').to be false
+        expect(Util.constant_time_compare? 'a', 'A').to be false
+        expect(Util.constant_time_compare? '', '').to be false
+        expect(Util.constant_time_compare? nil, nil).to be false
       end
     end
 

data/spec/json_web_token_spec.rb

@@ -37,7 +37,7 @@ describe JsonWebToken do
 
     describe 'w/o key w default header alg' do
       it 'raises' do
-        expect { JsonWebToken.create(claims) }.to raise_error(RuntimeError, 'Invalid key')
+        expect { JsonWebToken.create(claims) }.to raise_error(RuntimeError, 'Invalid shared key')
       end
     end
   end

data/spec/support/plausible_jwt.rb

@@ -9,7 +9,7 @@ def plausible_message_signature?(str, bytesize = 32)
   mac.bytesize == bytesize && mac.class == String
 end
 
-def plausible_unsecured_jws?(str)
+def plausible_unsecured_message?(str)
   return false unless str.end_with?('.')
   str.split('.').length == 2
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_web_token
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Gary Fleshman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-13 00:00:00.000000000 Z
+date: 2015-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -44,7 +44,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.3'
-description: Ruby implementation of the JSON Web Token Standard Track RFC 4627
+description: Ruby implementation of the JSON Web Token standard, RFC 7519
 email: gfleshman@newforge-tech.com
 executables: []
 extensions: []
@@ -108,3 +108,4 @@ signing_key:
 specification_version: 4
 summary: JSON Web Token for Ruby
 test_files: []
+has_rdoc: