xmldsig 0.6.2 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea438669a6cdd47452ce9ec1554ec4b45cbd2f99
-  data.tar.gz: df71150ef40324eb26842dae1c3651000d7e4608
+  metadata.gz: ed8fb3a4e6485ddf83e241026a3847b5b2a77eec
+  data.tar.gz: 600207fd49308dd772ce99a861868d240d9f6848
 SHA512:
-  metadata.gz: 08a8db423fede0282b26616d7ff75db36bfee05e00e3e9a4d9b71b56192b7f6d1a62e5a5a6234566044d1dd21bc5b8795a3e7950ca94c181a99f83bebc1152f6
-  data.tar.gz: 7803d8c5e39bb1fb3bfb1b63ff2a5942c1f96f26a0f8e6f6f0ec47073b2538d2d8cecda8a56fb7e5ec323fd7f1da1b6c3c3bde2f555c4945ebb621f5eb7749eb
+  metadata.gz: 099249a39a5cd6e7cdeed766deac4c5217d32c810197b722e3bea3996fa1adc5715a78d811cb204d6afca0036e8e2a78dd252d2909b485994832e72af19816aa
+  data.tar.gz: f26a7d2699aa4f2cc261d06874ed4f97e38ff2cdc55a5e6d480cf71f42f8bf11004b78b19f67e78cb5228fd082a8832e1e7c052976915a0bdb73e5eec5b13fe2

data/lib/xmldsig/version.rb

@@ -1,3 +1,3 @@
 module Xmldsig
-  VERSION = '0.6.2'
+  VERSION = '0.6.3'
 end

data/spec/lib/xmldsig/reference_spec.rb

@@ -6,13 +6,13 @@ describe Xmldsig::Reference do
 
   describe "#digest_value" do
     it "returns the digest value in the xml" do
-      reference.digest_value.should == Base64.decode64("ftoSYFdze1AWgGHF5N9i9SFKThXkqH2AdyzA3/epbJw=")
+      expect(reference.digest_value).to eq(Base64.decode64("ftoSYFdze1AWgGHF5N9i9SFKThXkqH2AdyzA3/epbJw="))
     end
   end
 
   describe "#document" do
     it "returns the document" do
-      reference.document.should == document
+      expect(reference.document).to eq(document)
     end
   end
 
@@ -21,20 +21,22 @@ describe Xmldsig::Reference do
 
     it "sets the correct digest value" do
       reference.sign
-      reference.digest_value.should == Base64.decode64("ftoSYFdze1AWgGHF5N9i9SFKThXkqH2AdyzA3/epbJw=")
+      expect(reference.digest_value).to eq(Base64.decode64("ftoSYFdze1AWgGHF5N9i9SFKThXkqH2AdyzA3/epbJw="))
     end
   end
 
   describe "#referenced_node" do
     it "returns the referenced_node by id" do
-      reference.referenced_node.to_s.should ==
+      expect(reference.referenced_node.to_s).to eq(
         document.at_xpath("//*[@ID='foo']").to_s
+      )
     end
 
     it "returns the referenced node by parent" do
-      reference.stub(:reference_uri).and_return("")
-      reference.referenced_node.to_s.should ==
+      allow(reference).to receive(:reference_uri).and_return("")
+      expect(reference.referenced_node.to_s).to eq(
         document.root.to_s
+      )
     end
 
     it "returns the reference node when using WS-Security style id attribute" do
@@ -43,9 +45,9 @@ describe Xmldsig::Reference do
       node['wsu:Id'] = node['ID']
       node.remove_attribute('ID')
 
-      reference.referenced_node.
-        attribute_with_ns('Id', Xmldsig::NAMESPACES['wsu']).value.
-        should == 'foo'
+      expect(reference.referenced_node.
+        attribute_with_ns('Id', Xmldsig::NAMESPACES['wsu']).value).
+        to eq('foo')
     end
 
     it "returns the reference node when using a custom id attribute" do
@@ -54,8 +56,9 @@ describe Xmldsig::Reference do
       node.set_attribute('MyID', 'foo')
       reference = Xmldsig::Reference.new(document.at_xpath('//ds:Reference', Xmldsig::NAMESPACES), 'MyID')
 
-      reference.referenced_node.to_s.should ==
+      expect(reference.referenced_node.to_s).to eq(
         document.at_xpath("//*[@MyID='foo']").to_s
+      )
     end
 
     it "raises ReferencedNodeNotFound when the refenced node is not present" do
@@ -79,7 +82,7 @@ describe Xmldsig::Reference do
 
   describe "#reference_uri" do
     it "returns the reference uri" do
-      reference.reference_uri.should == "#foo"
+      expect(reference.reference_uri).to eq("#foo")
     end
   end
 
@@ -92,11 +95,11 @@ describe Xmldsig::Reference do
         match = algorithm.match(/\d+/)[0].to_i
         case match
         when 512
-          reference.digest_method.should == Digest::SHA512
+          expect(reference.digest_method).to eq(Digest::SHA512)
         when 256
-          reference.digest_method.should == Digest::SHA256
+          expect(reference.digest_method).to eq(Digest::SHA256)
         when 1
-          reference.digest_method.should == Digest::SHA1
+          expect(reference.digest_method).to eq(Digest::SHA1)
         end
       end
     end
@@ -105,6 +108,6 @@ describe Xmldsig::Reference do
   it 'defaults to SHA256 for invalid algorithms' do
     document = Nokogiri::XML::Document.parse(IO.read("spec/fixtures/unsigned-invalid.xml"))
     reference = Xmldsig::Reference.new(document.at_xpath('//ds:Reference', Xmldsig::NAMESPACES))
-    reference.digest_method.should == Digest::SHA256
+    expect(reference.digest_method).to eq(Digest::SHA256)
   end
 end

data/spec/lib/xmldsig/signature_spec.rb

@@ -18,27 +18,27 @@ describe Xmldsig::Signature do
     end
 
     it "sets the digest value" do
-      signature.references.first.digest_value.should == Base64.decode64("ftoSYFdze1AWgGHF5N9i9SFKThXkqH2AdyzA3/epbJw=")
+      expect(signature.references.first.digest_value).to eq(Base64.decode64("ftoSYFdze1AWgGHF5N9i9SFKThXkqH2AdyzA3/epbJw="))
     end
 
     it "sets the signature value" do
-      signature.signature_value.should == Base64.decode64("
+      expect(signature.signature_value).to eq(Base64.decode64("
         E3yyqsSoxRkhYEuaEtR+SLg85gU5B4a7xUXA+d2Zn6j7F6z73dOd8iYHOusB
         Ty3C/3ujbmPhHKg8uX9kUE8b+YoOqZt4z9pdxAq44nJEuijwi4doIPpHWirv
         BnSoP5IoL0DYzGVrgj8udRzfAw5nNeV7wSrBZEn+yrxmUPJoUZc=
-      ")
+      "))
     end
 
     it "accepts a block" do
       signature.sign do |data, signature_algorithm|
-        signature_algorithm.should == "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"
+        expect(signature_algorithm).to eq("http://www.w3.org/2001/04/xmldsig-more#rsa-sha256")
         private_key.sign(OpenSSL::Digest::SHA256.new, data)
       end
-      signature.signature_value.should == Base64.decode64("
+      expect(signature.signature_value).to eq(Base64.decode64("
         E3yyqsSoxRkhYEuaEtR+SLg85gU5B4a7xUXA+d2Zn6j7F6z73dOd8iYHOusB
         Ty3C/3ujbmPhHKg8uX9kUE8b+YoOqZt4z9pdxAq44nJEuijwi4doIPpHWirv
         BnSoP5IoL0DYzGVrgj8udRzfAw5nNeV7wSrBZEn+yrxmUPJoUZc=
-      ")
+      "))
     end
 
     describe "multiple references" do
@@ -46,55 +46,57 @@ describe Xmldsig::Signature do
 
       it "can sign the document" do
         signature.sign(private_key)
-        signature.should be_valid(certificate)
+        expect(signature).to be_valid(certificate)
       end
 
       it "gets a digest per reference" do
-        signature.references.count.should be == 2
+        expect(signature.references.count).to eq(2)
         signature.sign(private_key)
-        signature.references[0].digest_value.should be == Base64.decode64("P1nUq8Y/LPmd+EON/mcNMNRjT78=")
-        signature.references[1].digest_value.should be == Base64.decode64("RoGAaQeuNJuDMWcgsD7RuGbFACo=")
+        expect(signature.references[0].digest_value).to eq(Base64.decode64("P1nUq8Y/LPmd+EON/mcNMNRjT78="))
+        expect(signature.references[1].digest_value).to eq(Base64.decode64("RoGAaQeuNJuDMWcgsD7RuGbFACo="))
       end
     end
   end
 
   describe "#signed_info" do
     it "returns the canonicalized signed info element" do
-      signature.signed_info.to_s.should ==
+      expect(signature.signed_info.to_s).to eq(
           document.at_xpath("//ds:SignedInfo", Xmldsig::NAMESPACES).to_s
+      )
     end
   end
 
   describe "#signature_value" do
     it "returns the signature value" do
-      signature.signature_value.should ==
+      expect(signature.signature_value).to eq(
           Base64.decode64(document.at_xpath("//ds:SignatureValue", Xmldsig::NAMESPACES).content)
+      )
     end
   end
 
   describe "#valid?" do
     it "returns true with the correct certificate" do
-      signature.valid?(certificate).should be == true
+      expect(signature.valid?(certificate)).to eq(true)
     end
 
     it "returns false if the xml changed" do
-      signature.references.first.stub(:document).and_return(
+      allow(signature.references.first).to receive(:document).and_return(
         Nokogiri::XML::Document.parse(File.read("spec/fixtures/signed.xml").gsub("\s\s", "\s"))
       )
       signature.valid?(certificate)
-      signature.errors.should include(:digest_value)
+      expect(signature.errors).to include(:digest_value)
     end
 
     it "returns false with a difference certificate" do
-      signature.valid?(other_certificate).should be == false
+      expect(signature.valid?(other_certificate)).to eq(false)
     end
 
     it "accepts a block" do
       signature.valid? do |signature_value, data, signature_algorithm|
-        signature_algorithm.should == "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"
+        expect(signature_algorithm).to eq("http://www.w3.org/2001/04/xmldsig-more#rsa-sha256")
         certificate.public_key.verify(OpenSSL::Digest::SHA256.new, signature_value, data)
       end
-      signature.errors.should be_empty
+      expect(signature.errors).to be_empty
     end
   end
 
@@ -108,9 +110,9 @@ describe Xmldsig::Signature do
         signature.sign do |data, signature_algorithm|
           case algorithm
           when "sha1"
-            signature_algorithm.should == "http://www.w3.org/2000/09/xmldsig#rsa-#{algorithm}"
+            expect(signature_algorithm).to eq("http://www.w3.org/2000/09/xmldsig#rsa-#{algorithm}")
           else
-            signature_algorithm.should == "http://www.w3.org/2001/04/xmldsig-more#rsa-#{algorithm}"
+            expect(signature_algorithm).to eq("http://www.w3.org/2001/04/xmldsig-more#rsa-#{algorithm}")
           end
           private_key.sign(OpenSSL::Digest.new(algorithm).new, data)
         end

data/spec/lib/xmldsig/signed_document_spec.rb

@@ -12,7 +12,7 @@ describe Xmldsig::SignedDocument do
   describe "#initialize" do
     it "sets the document to a nokogiri document" do
       document = described_class.new(signed_xml)
-      document.document.should be_a(Nokogiri::XML::Document)
+      expect(document.document).to be_a(Nokogiri::XML::Document)
     end
 
     it "raises on badly formed XML" do
@@ -24,13 +24,13 @@ describe Xmldsig::SignedDocument do
       EOXML
       expect {
         described_class.new(badly_formed)
-      }.to raise_error
+      }.to raise_error(Nokogiri::XML::SyntaxError)
     end
 
     it "accepts a nokogiri document" do
       doc             = Nokogiri::XML(unsigned_xml)
       signed_document = described_class.new(doc)
-      signed_document.document.should be_a(Nokogiri::XML::Document)
+      expect(signed_document.document).to be_a(Nokogiri::XML::Document)
     end
   end
 
@@ -39,59 +39,59 @@ describe Xmldsig::SignedDocument do
     let(:unsigned_document) { Xmldsig::SignedDocument.new(unsigned_xml) }
 
     it "returns only the signed nodes" do
-      signed_document.signatures.should be_all { |signature| signature.is_a?(Xmldsig::Signature) }
+      expect(signed_document.signatures).to be_all { |signature| signature.is_a?(Xmldsig::Signature) }
     end
 
     it "returns the outer signatures first" do
-      unsigned_document.signatures.first.references.first.reference_uri.should == '#foo'
+      expect(unsigned_document.signatures.first.references.first.reference_uri).to eq('#foo')
     end
   end
 
   describe "#signed_nodes" do
     it "returns only the signed nodes" do
-      signed_document.signed_nodes.collect(&:name).should == %w(Foo)
+      expect(signed_document.signed_nodes.collect(&:name)).to eq(%w(Foo))
     end
   end
 
   describe "#validate" do
     it "returns true if the signature and digest value are correct" do
-      signed_document.validate(certificate).should be == true
+      expect(signed_document.validate(certificate)).to eq(true)
     end
 
     it "returns false if the certificate is not valid" do
-      signed_document.validate(other_certificate).should be == false
+      expect(signed_document.validate(other_certificate)).to eq(false)
     end
 
     it "returns false if there are no signatures and validation is strict" do
       xml_without_signature = Xmldsig::SignedDocument.new('<foo></foo>')
-      xml_without_signature.validate(certificate).should be == false
+      expect(xml_without_signature.validate(certificate)).to eq(false)
     end
 
     it "accepts a block" do
-      signed_document.validate do |signature_value, data|
+      expect(signed_document.validate do |signature_value, data|
         certificate.public_key.verify(OpenSSL::Digest::SHA256.new, signature_value, data)
-      end.should be == true
+      end).to eq(true)
     end
 
     it "validates a document with a http://www.w3.org/2001/10/xml-exc-c14n#WithComments transform" do
       unsigned_xml_with_comments       = File.read("spec/fixtures/signed_xml-exc-c14n#with_comments.xml")
       unsigned_documents_with_comments = Xmldsig::SignedDocument.new(unsigned_xml_with_comments)
       signed_xml_with_comments         = unsigned_documents_with_comments.sign(private_key)
-      Xmldsig::SignedDocument.new(signed_xml_with_comments).validate(certificate).should be == true
+      expect(Xmldsig::SignedDocument.new(signed_xml_with_comments).validate(certificate)).to eq(true)
     end
   end
 
   describe "#sign" do
     it "returns a signed document" do
       signed_document = unsigned_document.sign(private_key)
-      Xmldsig::SignedDocument.new(signed_document).validate(certificate).should be == true
+      expect(Xmldsig::SignedDocument.new(signed_document).validate(certificate)).to eq(true)
     end
 
     it "accepts a block" do
       signed_document = unsigned_document.sign do |data|
         private_key.sign(OpenSSL::Digest::SHA256.new, data)
       end
-      Xmldsig::SignedDocument.new(signed_document).validate(certificate).should be == true
+      expect(Xmldsig::SignedDocument.new(signed_document).validate(certificate)).to eq(true)
     end
 
     context 'with the force false' do
@@ -102,9 +102,9 @@ describe Xmldsig::SignedDocument do
       let(:signed_document) { Xmldsig::SignedDocument.new(signed_xml) }
 
       it 'only signs the root signature and leaves the nested signature intact' do
-        signed_document.signatures.first.valid?(certificate).should be == true
-        signed_document.signatures.last.valid?(certificate).should be == false
-        signed_document.signatures.last.signature_value.should be == unsigned_document.signatures.last.signature_value
+        expect(signed_document.signatures.first.valid?(certificate)).to eq(true)
+        expect(signed_document.signatures.last.valid?(certificate)).to eq(false)
+        expect(signed_document.signatures.last.signature_value).to eq(unsigned_document.signatures.last.signature_value)
       end
     end
 
@@ -116,9 +116,9 @@ describe Xmldsig::SignedDocument do
       let(:signed_document) { Xmldsig::SignedDocument.new(signed_xml) }
 
       it 'only signs the root signature and leaves the nested signature intact' do
-        signed_document.signatures.first.valid?(certificate).should be == true
-        signed_document.signatures.last.valid?(certificate).should be == true
-        signed_document.signatures.last.signature_value.should be != unsigned_document.signatures.last.signature_value
+        expect(signed_document.signatures.first.valid?(certificate)).to eq(true)
+        expect(signed_document.signatures.last.valid?(certificate)).to eq(true)
+        expect(signed_document.signatures.last.signature_value).to_not be(unsigned_document.signatures.last.signature_value)
       end
     end
   end
@@ -129,17 +129,17 @@ describe Xmldsig::SignedDocument do
     let(:signed_document) { unsigned_document.sign(private_key) }
 
     it "when signed should be valid" do
-      Xmldsig::SignedDocument.new(signed_document).validate(certificate).should be == true
+      expect(Xmldsig::SignedDocument.new(signed_document).validate(certificate)).to eq(true)
     end
 
     it "should sign 2 elements" do
-      unsigned_document.signed_nodes.count.should == 2
+      expect(unsigned_document.signed_nodes.count).to eq(2)
     end
 
     it "allows individual signs" do
       unsigned_document.signatures.last.sign(private_key)
-      unsigned_document.validate(certificate).should be == false
-      unsigned_document.signatures.last.valid?(certificate).should be == true
+      expect(unsigned_document.validate(certificate)).to eq(false)
+      expect(unsigned_document.signatures.last.valid?(certificate)).to eq(true)
     end
   end
 

data/spec/lib/xmldsig/transforms/enveloped_signature_spec.rb

@@ -10,9 +10,9 @@ describe Xmldsig::Transforms::EnvelopedSignature do
     described_class.new(node_with_nested_signature, nil).transform
 
     remaining_signatures = node_with_nested_signature.xpath('descendant::ds:Signature', Xmldsig::NAMESPACES)
-    remaining_signatures.count.should == 1
+    expect(remaining_signatures.count).to eq(1)
     signature = Xmldsig::Signature.new(remaining_signatures.first)
 
-    signature.references.first.reference_uri.should == '#baz'
+    expect(signature.references.first.reference_uri).to eq('#baz')
   end
 end

data/spec/lib/xmldsig/transforms/transform_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Xmldsig::Transforms::Transform do
 
   it "raises a warning when transform is called" do
-    described_class.any_instance.should_receive(:warn)
+    expect_any_instance_of(described_class).to receive(:warn)
     described_class.new(nil,nil).transform
   end
 

data/spec/lib/xmldsig_spec.rb

@@ -12,11 +12,11 @@ describe Xmldsig do
         let(:signed_document) { unsigned_document.sign(private_key) }
 
         it "should be signable an validateable" do
-          Xmldsig::SignedDocument.new(signed_document).validate(certificate).should be == true
+          expect(Xmldsig::SignedDocument.new(signed_document).validate(certificate)).to eq(true)
         end
 
         it 'should have at least 1 signature element' do
-          Xmldsig::SignedDocument.new(signed_document).signatures.count.should >= 1
+          expect(Xmldsig::SignedDocument.new(signed_document).signatures.count).to be >= 1
         end
       end
     end
@@ -30,7 +30,7 @@ describe Xmldsig do
         let(:certificate) { OpenSSL::X509::Certificate.new(File.read(document.gsub('.txt', '.cert'))) }
 
         it "should be validateable" do
-          signed_document.validate(certificate).should be == true
+          expect(signed_document.validate(certificate)).to eq(true)
         end
       end
     end
@@ -64,11 +64,11 @@ describe Xmldsig do
       let(:signed_document) { unsigned_document.sign(private_key) }
 
       it "should be signable an validateable" do
-        Xmldsig::SignedDocument.new(signed_document, :id_attr => 'MyID').validate(certificate).should be == true
+        expect(Xmldsig::SignedDocument.new(signed_document, :id_attr => 'MyID').validate(certificate)).to eq(true)
       end
 
       it 'should have a signature element' do
-        Xmldsig::SignedDocument.new(signed_document, :id_attr => 'MyID').signatures.count.should == 1
+        expect(Xmldsig::SignedDocument.new(signed_document, :id_attr => 'MyID').signatures.count).to eq(1)
       end
     end
 
@@ -77,7 +77,7 @@ describe Xmldsig do
       let(:signed_document) { Xmldsig::SignedDocument.new(signed_xml, :id_attr => 'MyID') }
 
       it "should be validateable" do
-        signed_document.validate(certificate).should be == true
+        expect(signed_document.validate(certificate)).to eq(true)
       end
     end
   end

data/spec/spec_helper.rb

@@ -10,7 +10,6 @@ SimpleCov.start
 require 'xmldsig'
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 

data/xmldsig.gemspec

@@ -16,5 +16,5 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Xmldsig::VERSION
 
-  gem.add_dependency("nokogiri", '~> 1.6.8')
+  gem.add_dependency("nokogiri", '>= 1.6.8', '< 2.0.0')
 end

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: xmldsig
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.3
 platform: ruby
 authors:
 - benoist
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-05 00:00:00.000000000 Z
+date: 2017-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.8
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.8
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 description: This gem is a (partial) implementation of the XMLDsig specification
 email:
 - benoist.claassen@gmail.com