kl-ruby-saml 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4884c1dba78f622165653342c8a88d480cdcaf31
-  data.tar.gz: 9d464006e257f4fc8d2a33b7cac07e07cef67782
+  metadata.gz: f44b4e601309171d6735398f138704b4ff54cea2
+  data.tar.gz: 525052e90ee9d5aa368972a8e1921a609f5aca2d
 SHA512:
-  metadata.gz: ac0bf85d00dcd02969bb8e1fe31a6888eb6c662b23999482bccb930f6323f1a7c21fa9243347cd71259bad702468e77359cd95cd1cdb27574baa677d20f5d4d8
-  data.tar.gz: 181f794dc678fad271057c6bc7738f7d58a747876a037b8548c1034d984080b33b02843c74004c8400bc5b1e0f4538953cf42cbbda13fc855285a42c5b3f089a
+  metadata.gz: 5094f8cd2198ebc0d0914c84325b2f13aa54ea51e766fc59ce66d5c03438b677998014d5559b5598a58467876ac7fbf95549932c802484eb7fc7729c24009230
+  data.tar.gz: f3c2aa6a89a0af160d3087f86106a16d651103cae3cc2503cdfab66cec4bc1db238948abebd156b28c52827ad13a06d044fda3e2be51e63d32c0a61a81205c52

data/Gemfile

@@ -5,6 +5,6 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'timecop'
 gem 'json'
+gem 'timecop'
 

data/README.md

@@ -376,8 +376,8 @@ The settings related to sign are stored in the `security` attribute of the setti
   settings.security[:logout_responses_signed] = true     # Enable or not signature on Logout Response
   settings.security[:metadata_signed]         = true     # Enable or not signature on Metadata
 
-  settings.security[:digest_method]    = XMLSecurity::Document::SHA1
-  settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA1
+  settings.security[:digest_method]    = KlXMLSecurity::Document::SHA1
+  settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA1
 
   # Embeded signature or HTTP GET parameter signature
   # Note that metadata signature is always embedded regardless of this value.

data/lib/{xml_security.rb → kl_xml_security.rb}

@@ -31,7 +31,7 @@ require "digest/sha1"
 require "digest/sha2"
 require "onelogin/kl-ruby-saml/validation_error"
 
-module XMLSecurity
+module KlXMLSecurity
 
   class BaseDocument < REXML::Document
     REXML::Document::entity_expansion_limit = 0
@@ -110,7 +110,7 @@ module XMLSecurity
     #</Signature>
     def sign_document(private_key, certificate, signature_method = RSA_SHA1, digest_method = SHA1)
       noko = Nokogiri.parse(self.to_s) do |options|
-        options = XMLSecurity::BaseDocument::NOKOGIRI_OPTIONS
+        options = KlXMLSecurity::BaseDocument::NOKOGIRI_OPTIONS
       end
 
       signature_element = REXML::Element.new("ds:Signature").add_namespace('ds', DSIG)
@@ -134,7 +134,7 @@ module XMLSecurity
 
       # add SignatureValue
       noko_sig_element = Nokogiri.parse(signature_element.to_s) do |options|
-        options = XMLSecurity::BaseDocument::NOKOGIRI_OPTIONS
+        options = KlXMLSecurity::BaseDocument::NOKOGIRI_OPTIONS
       end
 
       noko_signed_info_element = noko_sig_element.at_xpath('//ds:Signature/ds:SignedInfo', 'ds' => DSIG)
@@ -211,7 +211,7 @@ module XMLSecurity
       cert = OpenSSL::X509::Certificate.new(cert_text)
 
       if options[:fingerprint_alg]
-        fingerprint_alg = XMLSecurity::BaseDocument.new.algorithm(options[:fingerprint_alg]).new
+        fingerprint_alg = KlXMLSecurity::BaseDocument.new.algorithm(options[:fingerprint_alg]).new
       else
         fingerprint_alg = OpenSSL::Digest::SHA1.new
       end
@@ -233,7 +233,7 @@ module XMLSecurity
       inclusive_namespaces = extract_inclusive_namespaces
 
       document = Nokogiri.parse(self.to_s) do |options|
-        options = XMLSecurity::BaseDocument::NOKOGIRI_OPTIONS
+        options = KlXMLSecurity::BaseDocument::NOKOGIRI_OPTIONS
       end
 
       # create a working copy so we don't modify the original

data/lib/onelogin/kl-ruby-saml/authrequest.rb

@@ -70,7 +70,7 @@ module OneLogin
             :relay_state => relay_state,
             :sig_alg => params['SigAlg']
           )
-          sign_algorithm = XMLSecurity::BaseDocument.new.algorithm(settings.security[:signature_method])
+          sign_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(settings.security[:signature_method])
           signature = settings.get_sp_key.sign(sign_algorithm.new, url_string)
           params['Signature'] = encode(signature)
         end
@@ -89,7 +89,7 @@ module OneLogin
       def create_authentication_xml_doc(settings)
         time = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
 
-        request_doc = XMLSecurity::Document.new
+        request_doc = KlXMLSecurity::Document.new
         request_doc.uuid = uuid
 
         root = request_doc.add_element "samlp:AuthnRequest", { "xmlns:samlp" => "urn:oasis:names:tc:SAML:2.0:protocol", "xmlns:saml" => "urn:oasis:names:tc:SAML:2.0:assertion" }

data/lib/onelogin/kl-ruby-saml/logoutrequest.rb

@@ -68,7 +68,7 @@ module OneLogin
             :relay_state => relay_state,
             :sig_alg => params['SigAlg']
           )
-          sign_algorithm = XMLSecurity::BaseDocument.new.algorithm(settings.security[:signature_method])
+          sign_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(settings.security[:signature_method])
           signature = settings.get_sp_key.sign(sign_algorithm.new, url_string)
           params['Signature'] = encode(signature)
         end
@@ -87,7 +87,7 @@ module OneLogin
       def create_logout_request_xml_doc(settings)
         time = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
 
-        request_doc = XMLSecurity::Document.new
+        request_doc = KlXMLSecurity::Document.new
         request_doc.uuid = uuid
 
         root = request_doc.add_element "samlp:LogoutRequest", { "xmlns:samlp" => "urn:oasis:names:tc:SAML:2.0:protocol", "xmlns:saml" => "urn:oasis:names:tc:SAML:2.0:assertion" }

data/lib/onelogin/kl-ruby-saml/logoutresponse.rb

@@ -1,4 +1,4 @@
-require "xml_security"
+require "kl_xml_security"
 require "onelogin/kl-ruby-saml/saml_message"
 
 require "time"
@@ -44,7 +44,7 @@ module OneLogin
 
         @options = options
         @response = decode_raw_saml(response)
-        @document = XMLSecurity::SignedDocument.new(@response)
+        @document = KlXMLSecurity::SignedDocument.new(@response)
       end
 
       # Append the cause to the errors array, and based on the value of soft, return false or raise

data/lib/onelogin/kl-ruby-saml/metadata.rb

@@ -18,7 +18,7 @@ module OneLogin
       # @return [String] XML Metadata of the Service Provider
       #
       def generate(settings, pretty_print=false)
-        meta_doc = XMLSecurity::Document.new
+        meta_doc = KlXMLSecurity::Document.new
         namespaces = {
             "xmlns:md" => "urn:oasis:names:tc:SAML:2.0:metadata"
         }

data/lib/onelogin/kl-ruby-saml/response.rb

@@ -1,4 +1,4 @@
-require "xml_security"
+require "kl_xml_security"
 require "onelogin/kl-ruby-saml/attributes"
 
 require "time"
@@ -52,7 +52,7 @@ module OneLogin
         end
 
         @response = decode_raw_saml(response)
-        @document = XMLSecurity::SignedDocument.new(@response, @errors)
+        @document = KlXMLSecurity::SignedDocument.new(@response, @errors)
 
         if assertion_encrypted?
           @decrypted_document = generate_decrypted_document
@@ -623,7 +623,7 @@ module OneLogin
       end
 
       # Generates the decrypted_document
-      # @return [XMLSecurity::SignedDocument] The SAML Response with the assertion decrypted
+      # @return [KlXMLSecurity::SignedDocument] The SAML Response with the assertion decrypted
       #
       def generate_decrypted_document
         if settings.nil? || !settings.get_sp_key
@@ -632,7 +632,7 @@ module OneLogin
 
         # Marshal at Ruby 1.8.7 throw an Exception
         if RUBY_VERSION < "1.9"
-          document_copy = XMLSecurity::SignedDocument.new(response, errors)
+          document_copy = KlXMLSecurity::SignedDocument.new(response, errors)
         else
           document_copy = Marshal.load(Marshal.dump(document))
         end
@@ -641,8 +641,8 @@ module OneLogin
       end
 
       # Obtains a SAML Response with the EncryptedAssertion element decrypted
-      # @param document_copy [XMLSecurity::SignedDocument] A copy of the original SAML Response with the encrypted assertion
-      # @return [XMLSecurity::SignedDocument] The SAML Response with the assertion decrypted
+      # @param document_copy [KlXMLSecurity::SignedDocument] A copy of the original SAML Response with the encrypted assertion
+      # @return [KlXMLSecurity::SignedDocument] The SAML Response with the assertion decrypted
       #
       def decrypt_assertion_from_document(document_copy)
         response_node = REXML::XPath.first(
@@ -657,7 +657,7 @@ module OneLogin
         )
         response_node.add(decrypt_assertion(encrypted_assertion_node))
         encrypted_assertion_node.remove
-        XMLSecurity::SignedDocument.new(response_node.to_s)
+        KlXMLSecurity::SignedDocument.new(response_node.to_s)
       end
 
       # Checks if the SAML Response contains or not an EncryptedAssertion element

data/lib/onelogin/kl-ruby-saml/saml_message.rb

@@ -65,7 +65,7 @@ module OneLogin
       def valid_saml?(document, soft = true)
         begin
           xml = Nokogiri::XML(document.to_s) do |config|
-            config.options = XMLSecurity::BaseDocument::NOKOGIRI_OPTIONS
+            config.options = KlXMLSecurity::BaseDocument::NOKOGIRI_OPTIONS
           end
         rescue Exception => error
           return false if soft

data/lib/onelogin/kl-ruby-saml/settings.rb

@@ -1,4 +1,4 @@
-require "xml_security"
+require "kl_xml_security"
 require "onelogin/kl-ruby-saml/attribute_service"
 require "onelogin/kl-ruby-saml/utils"
 
@@ -107,7 +107,7 @@ module OneLogin
         idp_cert_fingerprint || begin
           idp_cert = get_idp_cert
           if idp_cert
-            fingerprint_alg = XMLSecurity::BaseDocument.new.algorithm(idp_cert_fingerprint_algorithm).new
+            fingerprint_alg = KlXMLSecurity::BaseDocument.new.algorithm(idp_cert_fingerprint_algorithm).new
             fingerprint_alg.hexdigest(idp_cert.to_der).upcase.scan(/../).join(":")
           end
         end
@@ -145,7 +145,7 @@ module OneLogin
       DEFAULTS = {
         :assertion_consumer_service_binding        => "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST".freeze,
         :single_logout_service_binding             => "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect".freeze,
-        :idp_cert_fingerprint_algorithm            => XMLSecurity::Document::SHA1,
+        :idp_cert_fingerprint_algorithm            => KlXMLSecurity::Document::SHA1,
         :compress_request                          => true,
         :compress_response                         => true,
         :soft                                      => true,
@@ -155,8 +155,8 @@ module OneLogin
           :logout_responses_signed  => false,
           :metadata_signed          => false,
           :embed_sign               => false,
-          :digest_method            => XMLSecurity::Document::SHA1,
-          :signature_method         => XMLSecurity::Document::RSA_SHA1
+          :digest_method            => KlXMLSecurity::Document::SHA1,
+          :signature_method         => KlXMLSecurity::Document::RSA_SHA1
         }.freeze,
         :double_quote_xml_attribute_values         => false,
       }.freeze

data/lib/onelogin/kl-ruby-saml/slo_logoutresponse.rb

@@ -73,7 +73,7 @@ module OneLogin
             :relay_state => relay_state,
             :sig_alg => params['SigAlg']
           )
-          sign_algorithm = XMLSecurity::BaseDocument.new.algorithm(settings.security[:signature_method])
+          sign_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(settings.security[:signature_method])
           signature = settings.get_sp_key.sign(sign_algorithm.new, url_string)
           params['Signature'] = encode(signature)
         end
@@ -94,7 +94,7 @@ module OneLogin
       def create_logout_response_xml_doc(settings, request_id = nil, logout_message = nil)
         time = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
 
-        response_doc = XMLSecurity::Document.new
+        response_doc = KlXMLSecurity::Document.new
         response_doc.uuid = uuid
 
         root = response_doc.add_element 'samlp:LogoutResponse', { 'xmlns:samlp' => 'urn:oasis:names:tc:SAML:2.0:protocol', "xmlns:saml" => "urn:oasis:names:tc:SAML:2.0:assertion" }

data/lib/onelogin/kl-ruby-saml/utils.rb

@@ -70,7 +70,7 @@ module OneLogin
       #
       def self.verify_signature(params)
         cert, sig_alg, signature, query_string = [:cert, :sig_alg, :signature, :query_string].map { |k| params[k]}
-        signature_algorithm = XMLSecurity::BaseDocument.new.algorithm(sig_alg)
+        signature_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(sig_alg)
         return cert.public_key.verify(signature_algorithm.new, Base64.decode64(signature), query_string)
       end
 

data/lib/onelogin/kl-ruby-saml/version.rb

@@ -1,5 +1,5 @@
 module OneLogin
   module KlRubySaml
-    VERSION = '0.0.4'
+    VERSION = '0.0.5'
   end
 end

data/test/logoutrequest_test.rb

@@ -103,8 +103,8 @@ class RequestTest < Minitest::Test
 
       it "create a signed logout request with 256 digest and signature method" do
         settings.compress_request = false
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA256
-        settings.security[:digest_method] = XMLSecurity::Document::SHA256
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA256
+        settings.security[:digest_method] = KlXMLSecurity::Document::SHA256
 
         params = OneLogin::KlRubySaml::Logoutrequest.new.create_params(settings)
         request_xml = Base64.decode64(params["SAMLRequest"])
@@ -116,8 +116,8 @@ class RequestTest < Minitest::Test
 
       it "create a signed logout request with 512 digest and signature method RSA_SHA384" do
         settings.compress_request = false
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA384
-        settings.security[:digest_method] = XMLSecurity::Document::SHA512
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA384
+        settings.security[:digest_method] = KlXMLSecurity::Document::SHA512
 
         params = OneLogin::KlRubySaml::Logoutrequest.new.create_params(settings)
         request_xml = Base64.decode64(params["SAMLRequest"])
@@ -141,67 +141,67 @@ class RequestTest < Minitest::Test
       end
 
       it "create a signature parameter with RSA_SHA1 / SHA1 and validate it" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA1
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA1
 
         params = OneLogin::KlRubySaml::Logoutrequest.new.create_params(settings, :RelayState => 'http://example.com')
         assert params['SAMLRequest']
         assert params[:RelayState]
         assert params['Signature']
-        assert_equal params['SigAlg'], XMLSecurity::Document::RSA_SHA1
+        assert_equal params['SigAlg'], KlXMLSecurity::Document::RSA_SHA1
 
         query_string = "SAMLRequest=#{CGI.escape(params['SAMLRequest'])}"
         query_string << "&RelayState=#{CGI.escape(params[:RelayState])}"
         query_string << "&SigAlg=#{CGI.escape(params['SigAlg'])}"
 
-        signature_algorithm = XMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
+        signature_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
         assert_equal signature_algorithm, OpenSSL::Digest::SHA1
         assert cert.public_key.verify(signature_algorithm.new, Base64.decode64(params['Signature']), query_string)
       end
 
       it "create a signature parameter with RSA_SHA256 / SHA256 and validate it" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA256
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA256
 
         params = OneLogin::KlRubySaml::Logoutrequest.new.create_params(settings, :RelayState => 'http://example.com')
         assert params['Signature']
-        assert_equal params['SigAlg'], XMLSecurity::Document::RSA_SHA256
+        assert_equal params['SigAlg'], KlXMLSecurity::Document::RSA_SHA256
 
         query_string = "SAMLRequest=#{CGI.escape(params['SAMLRequest'])}"
         query_string << "&RelayState=#{CGI.escape(params[:RelayState])}"
         query_string << "&SigAlg=#{CGI.escape(params['SigAlg'])}"
 
-        signature_algorithm = XMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
+        signature_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
         assert_equal signature_algorithm, OpenSSL::Digest::SHA256 
         assert cert.public_key.verify(signature_algorithm.new, Base64.decode64(params['Signature']), query_string) 
       end
 
       it "create a signature parameter with RSA_SHA384 / SHA384 and validate it" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA384
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA384
 
         params = OneLogin::KlRubySaml::Logoutrequest.new.create_params(settings, :RelayState => 'http://example.com')
         assert params['Signature']
-        assert_equal params['SigAlg'], XMLSecurity::Document::RSA_SHA384
+        assert_equal params['SigAlg'], KlXMLSecurity::Document::RSA_SHA384
 
         query_string = "SAMLRequest=#{CGI.escape(params['SAMLRequest'])}"
         query_string << "&RelayState=#{CGI.escape(params[:RelayState])}"
         query_string << "&SigAlg=#{CGI.escape(params['SigAlg'])}"
 
-        signature_algorithm = XMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
+        signature_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
         assert_equal signature_algorithm, OpenSSL::Digest::SHA384 
         assert cert.public_key.verify(signature_algorithm.new, Base64.decode64(params['Signature']), query_string) 
       end
 
       it "create a signature parameter with RSA_SHA512 / SHA512 and validate it" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA512
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA512
 
         params = OneLogin::KlRubySaml::Logoutrequest.new.create_params(settings, :RelayState => 'http://example.com')
         assert params['Signature']
-        assert_equal params['SigAlg'], XMLSecurity::Document::RSA_SHA512
+        assert_equal params['SigAlg'], KlXMLSecurity::Document::RSA_SHA512
 
         query_string = "SAMLRequest=#{CGI.escape(params['SAMLRequest'])}"
         query_string << "&RelayState=#{CGI.escape(params[:RelayState])}"
         query_string << "&SigAlg=#{CGI.escape(params['SigAlg'])}"
 
-        signature_algorithm = XMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
+        signature_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
         assert_equal signature_algorithm, OpenSSL::Digest::SHA512 
         assert cert.public_key.verify(signature_algorithm.new, Base64.decode64(params['Signature']), query_string) 
       end

data/test/logoutresponse_test.rb

@@ -215,7 +215,7 @@ class KlRubySamlTest < Minitest::Test
         end
 
         it "return true when valid RSA_SHA1 Signature" do
-          settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA1
+          settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA1
           params['RelayState'] = params[:RelayState]
           options = {}
           options[:get_params] = params
@@ -224,7 +224,7 @@ class KlRubySamlTest < Minitest::Test
         end
 
         it "return true when valid RSA_SHA256 Signature" do
-          settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA256
+          settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA256
           params['RelayState'] = params[:RelayState]
           options = {}
           options[:get_params] = params
@@ -233,7 +233,7 @@ class KlRubySamlTest < Minitest::Test
         end
 
         it "return false when invalid RSA_SHA1 Signature" do
-          settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA1
+          settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA1
           params['RelayState'] = 'http://invalid.example.com'
           options = {}
           options[:get_params] = params
@@ -242,7 +242,7 @@ class KlRubySamlTest < Minitest::Test
         end
 
         it "raise when invalid RSA_SHA1 Signature" do
-          settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA1
+          settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA1
           settings.soft = false
           params['RelayState'] = 'http://invalid.example.com'
           options = {}

data/test/metadata_test.rb

@@ -174,7 +174,7 @@ class MetadataTest < Minitest::Test
         assert_match %r[<ds:SignatureValue>([a-zA-Z0-9/+=]+)</ds:SignatureValue>]m, xml_text
         assert_match %r[<ds:SignatureMethod Algorithm='http://www.w3.org/2000/09/xmldsig#rsa-sha1'/>], xml_text
         assert_match %r[<ds:DigestMethod Algorithm='http://www.w3.org/2000/09/xmldsig#sha1'/>], xml_text
-        signed_metadata = XMLSecurity::SignedDocument.new(xml_text)
+        signed_metadata = KlXMLSecurity::SignedDocument.new(xml_text)
         assert signed_metadata.validate_document(ruby_saml_cert_fingerprint, false)        
 
         assert validate_xml!(xml_text, "saml-schema-metadata-2.0.xsd")
@@ -182,8 +182,8 @@ class MetadataTest < Minitest::Test
 
       describe "when digest and signature methods are specified" do
         before do
-          settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA256
-          settings.security[:digest_method] = XMLSecurity::Document::SHA512
+          settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA256
+          settings.security[:digest_method] = KlXMLSecurity::Document::SHA512
         end
 
         it "creates a signed metadata with specified digest and signature methods" do
@@ -191,7 +191,7 @@ class MetadataTest < Minitest::Test
           assert_match %r[<ds:SignatureMethod Algorithm='http://www.w3.org/2001/04/xmldsig-more#rsa-sha256'/>], xml_text
           assert_match %r[<ds:DigestMethod Algorithm='http://www.w3.org/2001/04/xmldsig-more#sha512'/>], xml_text
 
-          signed_metadata_2 = XMLSecurity::SignedDocument.new(xml_text)
+          signed_metadata_2 = KlXMLSecurity::SignedDocument.new(xml_text)
 
           assert signed_metadata_2.validate_document(ruby_saml_cert_fingerprint, false)          
 

data/test/request_test.rb

@@ -191,8 +191,8 @@ class RequestTest < Minitest::Test
       end
 
       it "create a signed request with 256 digest and signature methods" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA256
-        settings.security[:digest_method] = XMLSecurity::Document::SHA512
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA256
+        settings.security[:digest_method] = KlXMLSecurity::Document::SHA512
 
         params = OneLogin::KlRubySaml::Authrequest.new.create_params(settings)
 
@@ -217,36 +217,36 @@ class RequestTest < Minitest::Test
       end
       
       it "create a signature parameter with RSA_SHA1 and validate it" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA1
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA1
 
         params = OneLogin::KlRubySaml::Authrequest.new.create_params(settings, :RelayState => 'http://example.com')
         assert params['SAMLRequest']
         assert params[:RelayState]
         assert params['Signature']
-        assert_equal params['SigAlg'], XMLSecurity::Document::RSA_SHA1
+        assert_equal params['SigAlg'], KlXMLSecurity::Document::RSA_SHA1
 
         query_string = "SAMLRequest=#{CGI.escape(params['SAMLRequest'])}"
         query_string << "&RelayState=#{CGI.escape(params[:RelayState])}"
         query_string << "&SigAlg=#{CGI.escape(params['SigAlg'])}"
 
-        signature_algorithm = XMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
+        signature_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
         assert_equal signature_algorithm, OpenSSL::Digest::SHA1
 
         assert cert.public_key.verify(signature_algorithm.new, Base64.decode64(params['Signature']), query_string)
       end
 
       it "create a signature parameter with RSA_SHA256 and validate it" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA256
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA256
 
         params = OneLogin::KlRubySaml::Authrequest.new.create_params(settings, :RelayState => 'http://example.com')
         assert params['Signature']
-        assert_equal params['SigAlg'], XMLSecurity::Document::RSA_SHA256
+        assert_equal params['SigAlg'], KlXMLSecurity::Document::RSA_SHA256
 
         query_string = "SAMLRequest=#{CGI.escape(params['SAMLRequest'])}"
         query_string << "&RelayState=#{CGI.escape(params[:RelayState])}"
         query_string << "&SigAlg=#{CGI.escape(params['SigAlg'])}"
 
-        signature_algorithm = XMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
+        signature_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
         assert_equal signature_algorithm, OpenSSL::Digest::SHA256
         assert cert.public_key.verify(signature_algorithm.new, Base64.decode64(params['Signature']), query_string)        
       end

data/test/response_test.rb

@@ -43,7 +43,7 @@ class KlRubySamlTest < Minitest::Test
     end
 
     it "be able to parse a document which contains ampersands" do
-      XMLSecurity::SignedDocument.any_instance.stubs(:digests_match?).returns(true)
+      KlXMLSecurity::SignedDocument.any_instance.stubs(:digests_match?).returns(true)
       OneLogin::KlRubySaml::Response.any_instance.stubs(:validate_conditions).returns(true)
 
       ampersands_response = OneLogin::KlRubySaml::Response.new(ampersands_document)
@@ -301,7 +301,7 @@ class KlRubySamlTest < Minitest::Test
           no_signature_response.stubs(:validate_subject_confirmation).returns(true)
           no_signature_response.settings = settings
           no_signature_response.settings.idp_cert_fingerprint = "28:74:9B:E8:1F:E8:10:9C:A8:7C:A9:C3:E3:C5:01:6C:92:1C:B4:BA"
-          XMLSecurity::SignedDocument.any_instance.expects(:validate_signature).returns(true)
+          KlXMLSecurity::SignedDocument.any_instance.expects(:validate_signature).returns(true)
           assert no_signature_response.is_valid?
         end
 
@@ -870,7 +870,7 @@ class KlRubySamlTest < Minitest::Test
       it 'Sign an unsigned SAML Response XML and initiate the SAML object with it' do
         xml = Base64.decode64(fixture("test_sign.xml"))
 
-        document = XMLSecurity::Document.new(xml)
+        document = KlXMLSecurity::Document.new(xml)
 
         formated_cert = OneLogin::KlRubySaml::Utils.format_cert(ruby_saml_cert_text)
         cert = OpenSSL::X509::Certificate.new(formated_cert)

data/test/settings_test.rb

@@ -67,14 +67,14 @@ class SettingsTest < Minitest::Test
       settings = OneLogin::KlRubySaml::Settings.new
       settings.security[:authn_requests_signed] = true
       settings.security[:embed_sign] = true
-      settings.security[:digest_method] = XMLSecurity::Document::SHA256
-      settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA256
+      settings.security[:digest_method] = KlXMLSecurity::Document::SHA256
+      settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA256
 
       new_settings = OneLogin::KlRubySaml::Settings.new
       assert_equal new_settings.security[:authn_requests_signed], false
       assert_equal new_settings.security[:embed_sign], false
-      assert_equal new_settings.security[:digest_method], XMLSecurity::Document::SHA1
-      assert_equal new_settings.security[:signature_method], XMLSecurity::Document::RSA_SHA1
+      assert_equal new_settings.security[:digest_method], KlXMLSecurity::Document::SHA1
+      assert_equal new_settings.security[:signature_method], KlXMLSecurity::Document::RSA_SHA1
     end
 
     describe "#single_logout_service_url" do

data/test/slo_logoutrequest_test.rb

@@ -221,7 +221,7 @@ class KlRubySamlTest < Minitest::Test
       end
 
       it "return true when valid RSA_SHA1 Signature" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA1
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA1
         params = OneLogin::KlRubySaml::Logoutrequest.new.create_params(settings, :RelayState => 'http://example.com')
         params['RelayState'] = params[:RelayState]
         options = {}
@@ -232,7 +232,7 @@ class KlRubySamlTest < Minitest::Test
       end
 
       it "return true when valid RSA_SHA256 Signature" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA256
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA256
         params = OneLogin::KlRubySaml::Logoutrequest.new.create_params(settings, :RelayState => 'http://example.com')
         options = {}
         options[:get_params] = params
@@ -243,7 +243,7 @@ class KlRubySamlTest < Minitest::Test
       end
 
       it "return false when invalid RSA_SHA1 Signature" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA1
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA1
         params = OneLogin::KlRubySaml::Logoutrequest.new.create_params(settings, :RelayState => 'http://example.com')
         params['RelayState'] = 'http://invalid.exampcle.com'
         params[:RelayState] = params['RelayState']
@@ -256,7 +256,7 @@ class KlRubySamlTest < Minitest::Test
       end
 
       it "raise when invalid RSA_SHA1 Signature" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA1
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA1
         settings.soft = false
         params = OneLogin::KlRubySaml::Logoutrequest.new.create_params(settings, :RelayState => 'http://example.com')
         params['RelayState'] = 'http://invalid.exampcle.com'

data/test/slo_logoutresponse_test.rb

@@ -70,8 +70,8 @@ class SloLogoutresponseTest < Minitest::Test
       end
 
       it "create a signed logout response with 256 digest and signature methods" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA256
-        settings.security[:digest_method] = XMLSecurity::Document::SHA256
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA256
+        settings.security[:digest_method] = KlXMLSecurity::Document::SHA256
 
         params = OneLogin::KlRubySaml::SloLogoutresponse.new.create_params(settings, logout_request.id, "Custom Logout Message")
 
@@ -82,8 +82,8 @@ class SloLogoutresponseTest < Minitest::Test
       end
 
       it "create a signed logout response with 512 digest and signature method RSA_SHA384" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA384
-        settings.security[:digest_method] = XMLSecurity::Document::SHA512
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA384
+        settings.security[:digest_method] = KlXMLSecurity::Document::SHA512
         logout_request.settings = settings
 
         params = OneLogin::KlRubySaml::SloLogoutresponse.new.create_params(settings, logout_request.id, "Custom Logout Message")
@@ -106,76 +106,76 @@ class SloLogoutresponseTest < Minitest::Test
       end
 
       it "create a signature parameter with RSA_SHA1 and validate it" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA1
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA1
 
         params = OneLogin::KlRubySaml::SloLogoutresponse.new.create_params(settings, logout_request.id, "Custom Logout Message", :RelayState => 'http://example.com')
         assert params['SAMLResponse']
         assert params[:RelayState]
         assert params['Signature']
-        assert_equal params['SigAlg'], XMLSecurity::Document::RSA_SHA1
+        assert_equal params['SigAlg'], KlXMLSecurity::Document::RSA_SHA1
 
         query_string = "SAMLResponse=#{CGI.escape(params['SAMLResponse'])}"
         query_string << "&RelayState=#{CGI.escape(params[:RelayState])}"
         query_string << "&SigAlg=#{CGI.escape(params['SigAlg'])}"
 
-        signature_algorithm = XMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
+        signature_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
         assert_equal signature_algorithm, OpenSSL::Digest::SHA1
         assert cert.public_key.verify(signature_algorithm.new, Base64.decode64(params['Signature']), query_string)
       end
 
       it "create a signature parameter with RSA_SHA256 /SHA256 and validate it" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA256
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA256
 
         params = OneLogin::KlRubySaml::SloLogoutresponse.new.create_params(settings, logout_request.id, "Custom Logout Message", :RelayState => 'http://example.com')
         assert params['SAMLResponse']
         assert params[:RelayState]
         assert params['Signature']
 
-        assert_equal params['SigAlg'], XMLSecurity::Document::RSA_SHA256
+        assert_equal params['SigAlg'], KlXMLSecurity::Document::RSA_SHA256
 
         query_string = "SAMLResponse=#{CGI.escape(params['SAMLResponse'])}"
         query_string << "&RelayState=#{CGI.escape(params[:RelayState])}"
         query_string << "&SigAlg=#{CGI.escape(params['SigAlg'])}"
 
-        signature_algorithm = XMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
+        signature_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
         assert_equal signature_algorithm, OpenSSL::Digest::SHA256
         assert cert.public_key.verify(signature_algorithm.new, Base64.decode64(params['Signature']), query_string)
       end
 
       it "create a signature parameter with RSA_SHA384 / SHA384 and validate it" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA384
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA384
 
         params = OneLogin::KlRubySaml::SloLogoutresponse.new.create_params(settings, logout_request.id, "Custom Logout Message", :RelayState => 'http://example.com')
         assert params['SAMLResponse']
         assert params[:RelayState]
         assert params['Signature']
 
-        assert_equal params['SigAlg'], XMLSecurity::Document::RSA_SHA384
+        assert_equal params['SigAlg'], KlXMLSecurity::Document::RSA_SHA384
 
         query_string = "SAMLResponse=#{CGI.escape(params['SAMLResponse'])}"
         query_string << "&RelayState=#{CGI.escape(params[:RelayState])}"
         query_string << "&SigAlg=#{CGI.escape(params['SigAlg'])}"
 
-        signature_algorithm = XMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
+        signature_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
         assert_equal signature_algorithm, OpenSSL::Digest::SHA384
         assert cert.public_key.verify(signature_algorithm.new, Base64.decode64(params['Signature']), query_string)
       end
 
       it "create a signature parameter with RSA_SHA512 / SHA512 and validate it" do
-        settings.security[:signature_method] = XMLSecurity::Document::RSA_SHA512
+        settings.security[:signature_method] = KlXMLSecurity::Document::RSA_SHA512
 
         params = OneLogin::KlRubySaml::SloLogoutresponse.new.create_params(settings, logout_request.id, "Custom Logout Message", :RelayState => 'http://example.com')
         assert params['SAMLResponse']
         assert params[:RelayState]
         assert params['Signature']
 
-        assert_equal params['SigAlg'], XMLSecurity::Document::RSA_SHA512
+        assert_equal params['SigAlg'], KlXMLSecurity::Document::RSA_SHA512
 
         query_string = "SAMLResponse=#{CGI.escape(params['SAMLResponse'])}"
         query_string << "&RelayState=#{CGI.escape(params[:RelayState])}"
         query_string << "&SigAlg=#{CGI.escape(params['SigAlg'])}"
 
-        signature_algorithm = XMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
+        signature_algorithm = KlXMLSecurity::BaseDocument.new.algorithm(params['SigAlg'])
         assert_equal signature_algorithm, OpenSSL::Digest::SHA512
         assert cert.public_key.verify(signature_algorithm.new, Base64.decode64(params['Signature']), query_string)
       end

data/test/xml_security_test.rb

@@ -1,14 +1,14 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
-require 'xml_security'
+require 'kl_xml_security'
 require 'timecop'
 
 class XmlSecurityTest < Minitest::Test
-  include XMLSecurity
+  include KlXMLSecurity
 
   describe "XmlSecurity" do
 
     let(:decoded_response) { Base64.decode64(response_document_without_recipient) }
-    let(:document) { XMLSecurity::SignedDocument.new(decoded_response) }
+    let(:document) { KlXMLSecurity::SignedDocument.new(decoded_response) }
     let(:settings) { OneLogin::KlRubySaml::Settings.new() }
 
     before do
@@ -31,7 +31,7 @@ class XmlSecurityTest < Minitest::Test
 
     it "not raise an error when softly validating the document and the X509Certificate is missing" do
       decoded_response.sub!(/<ds:X509Certificate>.*<\/ds:X509Certificate>/, "")
-      mod_document = XMLSecurity::SignedDocument.new(decoded_response)
+      mod_document = KlXMLSecurity::SignedDocument.new(decoded_response)
       assert !mod_document.validate_document("a fingerprint", true) # The fingerprint isn't relevant to this test
     end
 
@@ -54,7 +54,7 @@ class XmlSecurityTest < Minitest::Test
     it "should raise Key validation error" do
       decoded_response.sub!("<ds:DigestValue>pJQ7MS/ek4KRRWGmv/H43ReHYMs=</ds:DigestValue>",
                     "<ds:DigestValue>b9xsAXLsynugg3Wc1CI3kpWku+0=</ds:DigestValue>")
-      mod_document = XMLSecurity::SignedDocument.new(decoded_response)
+      mod_document = KlXMLSecurity::SignedDocument.new(decoded_response)
       base64cert = mod_document.elements["//ds:X509Certificate"].text
       exception = assert_raises(OneLogin::KlRubySaml::ValidationError) do
         mod_document.validate_signature(base64cert, false)
@@ -64,14 +64,14 @@ class XmlSecurityTest < Minitest::Test
     end
 
     it "correctly obtain the digest method with alternate namespace declaration" do
-      adfs_document = XMLSecurity::SignedDocument.new(fixture(:adfs_response_xmlns, false))
+      adfs_document = KlXMLSecurity::SignedDocument.new(fixture(:adfs_response_xmlns, false))
       base64cert = adfs_document.elements["//X509Certificate"].text
       assert adfs_document.validate_signature(base64cert, false)
     end
 
     it "raise validation error when the X509Certificate is missing" do
       decoded_response.sub!(/<ds:X509Certificate>.*<\/ds:X509Certificate>/, "")
-      mod_document = XMLSecurity::SignedDocument.new(decoded_response)
+      mod_document = KlXMLSecurity::SignedDocument.new(decoded_response)
       exception = assert_raises(OneLogin::KlRubySaml::ValidationError) do
         mod_document.validate_document("a fingerprint", false) # The fingerprint isn't relevant to this test
       end
@@ -82,46 +82,46 @@ class XmlSecurityTest < Minitest::Test
   describe "#canon_algorithm" do
     it "C14N_EXCLUSIVE_1_0" do
       canon_algorithm = Nokogiri::XML::XML_C14N_EXCLUSIVE_1_0
-      assert_equal canon_algorithm, XMLSecurity::BaseDocument.new.canon_algorithm("http://www.w3.org/2001/10/xml-exc-c14n#")
-      assert_equal canon_algorithm, XMLSecurity::BaseDocument.new.canon_algorithm("http://www.w3.org/2001/10/xml-exc-c14n#WithComments")
-      assert_equal canon_algorithm, XMLSecurity::BaseDocument.new.canon_algorithm("other")
+      assert_equal canon_algorithm, KlXMLSecurity::BaseDocument.new.canon_algorithm("http://www.w3.org/2001/10/xml-exc-c14n#")
+      assert_equal canon_algorithm, KlXMLSecurity::BaseDocument.new.canon_algorithm("http://www.w3.org/2001/10/xml-exc-c14n#WithComments")
+      assert_equal canon_algorithm, KlXMLSecurity::BaseDocument.new.canon_algorithm("other")
     end
 
     it "C14N_1_0" do
       canon_algorithm = Nokogiri::XML::XML_C14N_1_0
-      assert_equal canon_algorithm, XMLSecurity::BaseDocument.new.canon_algorithm("http://www.w3.org/TR/2001/REC-xml-c14n-20010315")
+      assert_equal canon_algorithm, KlXMLSecurity::BaseDocument.new.canon_algorithm("http://www.w3.org/TR/2001/REC-xml-c14n-20010315")
     end
 
     it "XML_C14N_1_1" do
       canon_algorithm = Nokogiri::XML::XML_C14N_1_1
-      assert_equal canon_algorithm, XMLSecurity::BaseDocument.new.canon_algorithm("http://www.w3.org/2006/12/xml-c14n11")
+      assert_equal canon_algorithm, KlXMLSecurity::BaseDocument.new.canon_algorithm("http://www.w3.org/2006/12/xml-c14n11")
     end
   end
 
   describe "#algorithm" do    
     it "SHA1" do
       alg = OpenSSL::Digest::SHA1
-      assert_equal alg, XMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2000/09/xmldsig#rsa-sha1")
-      assert_equal alg, XMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2000/09/xmldsig#sha1")
-      assert_equal alg, XMLSecurity::BaseDocument.new.algorithm("other")
+      assert_equal alg, KlXMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2000/09/xmldsig#rsa-sha1")
+      assert_equal alg, KlXMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2000/09/xmldsig#sha1")
+      assert_equal alg, KlXMLSecurity::BaseDocument.new.algorithm("other")
     end
 
     it "SHA256" do
       alg = OpenSSL::Digest::SHA256
-      assert_equal alg, XMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#rsa-sha256")
-      assert_equal alg, XMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#sha256")
+      assert_equal alg, KlXMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#rsa-sha256")
+      assert_equal alg, KlXMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#sha256")
     end
 
     it "SHA384" do
       alg = OpenSSL::Digest::SHA384
-      assert_equal alg, XMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#rsa-sha384")
-      assert_equal alg, XMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#sha384")
+      assert_equal alg, KlXMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#rsa-sha384")
+      assert_equal alg, KlXMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#sha384")
     end
 
     it "SHA512" do
       alg = OpenSSL::Digest::SHA512
-      assert_equal alg, XMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#rsa-sha512")
-      assert_equal alg, XMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#sha512")
+      assert_equal alg, KlXMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#rsa-sha512")
+      assert_equal alg, KlXMLSecurity::BaseDocument.new.algorithm("http://www.w3.org/2001/04/xmldsig-more#sha512")
     end        
   end
 
@@ -133,53 +133,53 @@ class XmlSecurityTest < Minitest::Test
       sha1_fingerprint_downcase = "f13c6b80905a030e6c913e5d15faddb016454872"
 
       assert response_fingerprint_test.document.validate_document(sha1_fingerprint)
-      assert response_fingerprint_test.document.validate_document(sha1_fingerprint, true, :fingerprint_alg => XMLSecurity::Document::SHA1)
+      assert response_fingerprint_test.document.validate_document(sha1_fingerprint, true, :fingerprint_alg => KlXMLSecurity::Document::SHA1)
 
       assert response_fingerprint_test.document.validate_document(sha1_fingerprint_downcase)
-      assert response_fingerprint_test.document.validate_document(sha1_fingerprint_downcase, true, :fingerprint_alg => XMLSecurity::Document::SHA1)
+      assert response_fingerprint_test.document.validate_document(sha1_fingerprint_downcase, true, :fingerprint_alg => KlXMLSecurity::Document::SHA1)
     end
 
     it "validate using SHA256" do
       sha256_fingerprint = "C4:C6:BD:41:EC:AD:57:97:CE:7B:7D:80:06:C3:E4:30:53:29:02:0B:DD:2D:47:02:9E:BD:85:AD:93:02:45:21"
 
       assert !response_fingerprint_test.document.validate_document(sha256_fingerprint)
-      assert response_fingerprint_test.document.validate_document(sha256_fingerprint, true, :fingerprint_alg => XMLSecurity::Document::SHA256)
+      assert response_fingerprint_test.document.validate_document(sha256_fingerprint, true, :fingerprint_alg => KlXMLSecurity::Document::SHA256)
     end
 
     it "validate using SHA384" do
       sha384_fingerprint = "98:FE:17:90:31:E7:68:18:8A:65:4D:DA:F5:76:E2:09:97:BE:8B:E3:7E:AA:8D:63:64:7C:0C:38:23:9A:AC:A2:EC:CE:48:A6:74:4D:E0:4C:50:80:40:B4:8D:55:14:14"
 
       assert !response_fingerprint_test.document.validate_document(sha384_fingerprint)
-      assert response_fingerprint_test.document.validate_document(sha384_fingerprint, true, :fingerprint_alg => XMLSecurity::Document::SHA384)
+      assert response_fingerprint_test.document.validate_document(sha384_fingerprint, true, :fingerprint_alg => KlXMLSecurity::Document::SHA384)
     end
 
     it "validate using SHA512" do
       sha512_fingerprint = "5A:AE:BA:D0:BA:9D:1E:25:05:01:1E:1A:C9:E9:FF:DB:ED:FA:6E:F7:52:EB:45:49:BD:DB:06:D8:A3:7E:CC:63:3A:04:A2:DD:DF:EE:61:05:D9:58:95:2A:77:17:30:4B:EB:4A:9F:48:4A:44:1C:D0:9E:0B:1E:04:77:FD:A3:D2"
 
       assert !response_fingerprint_test.document.validate_document(sha512_fingerprint)
-      assert response_fingerprint_test.document.validate_document(sha512_fingerprint, true, :fingerprint_alg => XMLSecurity::Document::SHA512)
+      assert response_fingerprint_test.document.validate_document(sha512_fingerprint, true, :fingerprint_alg => KlXMLSecurity::Document::SHA512)
     end
 
   end
 
   describe "Signature Algorithms" do
     it "validate using SHA1" do
-      document = XMLSecurity::SignedDocument.new(fixture(:adfs_response_sha1, false))
+      document = KlXMLSecurity::SignedDocument.new(fixture(:adfs_response_sha1, false))
       assert document.validate_document("F1:3C:6B:80:90:5A:03:0E:6C:91:3E:5D:15:FA:DD:B0:16:45:48:72")
     end
 
     it "validate using SHA256" do
-      document = XMLSecurity::SignedDocument.new(fixture(:adfs_response_sha256, false))
+      document = KlXMLSecurity::SignedDocument.new(fixture(:adfs_response_sha256, false))
       assert document.validate_document("28:74:9B:E8:1F:E8:10:9C:A8:7C:A9:C3:E3:C5:01:6C:92:1C:B4:BA")
     end
 
     it "validate using SHA384" do
-      document = XMLSecurity::SignedDocument.new(fixture(:adfs_response_sha384, false))
+      document = KlXMLSecurity::SignedDocument.new(fixture(:adfs_response_sha384, false))
       assert document.validate_document("F1:3C:6B:80:90:5A:03:0E:6C:91:3E:5D:15:FA:DD:B0:16:45:48:72")
     end
 
     it "validate using SHA512" do
-      document = XMLSecurity::SignedDocument.new(fixture(:adfs_response_sha512, false))
+      document = KlXMLSecurity::SignedDocument.new(fixture(:adfs_response_sha512, false))
       assert document.validate_document("F1:3C:6B:80:90:5A:03:0E:6C:91:3E:5D:15:FA:DD:B0:16:45:48:72")
     end
   end
@@ -189,7 +189,7 @@ class XmlSecurityTest < Minitest::Test
     describe "#extract_inclusive_namespaces" do
       it "support explicit namespace resolution for exclusive canonicalization" do
         response = fixture(:open_saml_response, false)
-        document = XMLSecurity::SignedDocument.new(response)
+        document = KlXMLSecurity::SignedDocument.new(response)
         inclusive_namespaces = document.send(:extract_inclusive_namespaces)
 
         assert_equal %w[ xs ], inclusive_namespaces
@@ -197,7 +197,7 @@ class XmlSecurityTest < Minitest::Test
 
       it "support implicit namespace resolution for exclusive canonicalization" do
         response = fixture(:no_signature_ns, false)
-        document = XMLSecurity::SignedDocument.new(response)
+        document = KlXMLSecurity::SignedDocument.new(response)
         inclusive_namespaces = document.send(:extract_inclusive_namespaces)
 
         assert_equal %w[ #default saml ds xs xsi ], inclusive_namespaces
@@ -219,14 +219,14 @@ class XmlSecurityTest < Minitest::Test
         response = fixture(:no_signature_ns, false)
         response.slice! %r{<InclusiveNamespaces xmlns="http://www.w3.org/2001/10/xml-exc-c14n#" PrefixList="#default saml ds xs xsi"/>}
 
-        document = XMLSecurity::SignedDocument.new(response)
+        document = KlXMLSecurity::SignedDocument.new(response)
         inclusive_namespaces = document.send(:extract_inclusive_namespaces)
 
         assert inclusive_namespaces.empty?
       end
     end
 
-    describe "XMLSecurity::DSIG" do
+    describe "KlXMLSecurity::DSIG" do
       before do
         settings.idp_sso_target_url = "https://idp.example.com/sso"
         settings.protocol_binding = "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST"
@@ -241,13 +241,13 @@ class XmlSecurityTest < Minitest::Test
         request = OneLogin::KlRubySaml::Authrequest.new.create_authentication_xml_doc(settings)
         request.sign_document(ruby_saml_key, ruby_saml_cert)
         # verify our signature
-        signed_doc = XMLSecurity::SignedDocument.new(request.to_s)
+        signed_doc = KlXMLSecurity::SignedDocument.new(request.to_s)
         assert signed_doc.validate_document(ruby_saml_cert_fingerprint, false)
 
         request2 = OneLogin::KlRubySaml::Authrequest.new.create_authentication_xml_doc(settings)
         request2.sign_document(ruby_saml_key, ruby_saml_cert_text)
         # verify our signature
-        signed_doc2 = XMLSecurity::SignedDocument.new(request2.to_s)
+        signed_doc2 = KlXMLSecurity::SignedDocument.new(request2.to_s)
         assert signed_doc2.validate_document(ruby_saml_cert_fingerprint, false)
       end
 
@@ -256,7 +256,7 @@ class XmlSecurityTest < Minitest::Test
         request.sign_document(ruby_saml_key, ruby_saml_cert_text)
 
         # verify our signature
-        signed_doc = XMLSecurity::SignedDocument.new(request.to_s)
+        signed_doc = KlXMLSecurity::SignedDocument.new(request.to_s)
         assert signed_doc.validate_document(ruby_saml_cert_fingerprint, false)
       end
 
@@ -264,13 +264,13 @@ class XmlSecurityTest < Minitest::Test
         logout_request = OneLogin::KlRubySaml::Logoutrequest.new.create_logout_request_xml_doc(settings)
         logout_request.sign_document(ruby_saml_key, ruby_saml_cert)
         # verify our signature
-        signed_doc = XMLSecurity::SignedDocument.new(logout_request.to_s)
+        signed_doc = KlXMLSecurity::SignedDocument.new(logout_request.to_s)
         assert signed_doc.validate_document(ruby_saml_cert_fingerprint, false)
 
         logout_request2 = OneLogin::KlRubySaml::Logoutrequest.new.create_logout_request_xml_doc(settings)
         logout_request2.sign_document(ruby_saml_key, ruby_saml_cert_text)
         # verify our signature
-        signed_doc2 = XMLSecurity::SignedDocument.new(logout_request2.to_s)
+        signed_doc2 = KlXMLSecurity::SignedDocument.new(logout_request2.to_s)
         signed_doc2.validate_document(ruby_saml_cert_fingerprint, false)        
         assert signed_doc2.validate_document(ruby_saml_cert_fingerprint, false)
       end
@@ -279,13 +279,13 @@ class XmlSecurityTest < Minitest::Test
         logout_response = OneLogin::KlRubySaml::SloLogoutresponse.new.create_logout_response_xml_doc(settings, 'request_id_example', "Custom Logout Message")
         logout_response.sign_document(ruby_saml_key, ruby_saml_cert)
         # verify our signature
-        signed_doc = XMLSecurity::SignedDocument.new(logout_response.to_s)
+        signed_doc = KlXMLSecurity::SignedDocument.new(logout_response.to_s)
         assert signed_doc.validate_document(ruby_saml_cert_fingerprint, false)
 
         logout_response2 = OneLogin::KlRubySaml::SloLogoutresponse.new.create_logout_response_xml_doc(settings, 'request_id_example', "Custom Logout Message")
         logout_response2.sign_document(ruby_saml_key, ruby_saml_cert_text)
         # verify our signature
-        signed_doc2 = XMLSecurity::SignedDocument.new(logout_response2.to_s)
+        signed_doc2 = KlXMLSecurity::SignedDocument.new(logout_response2.to_s)
         signed_doc2.validate_document(ruby_saml_cert_fingerprint, false)        
         assert signed_doc2.validate_document(ruby_saml_cert_fingerprint, false)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kl-ruby-saml
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - OneLogin LLC
@@ -170,6 +170,7 @@ files:
 - gemfiles/nokogiri-1.5.gemfile
 - kl-ruby-saml.gemspec
 - lib/kl-ruby-saml.rb
+- lib/kl_xml_security.rb
 - lib/onelogin/kl-ruby-saml.rb
 - lib/onelogin/kl-ruby-saml/attribute_service.rb
 - lib/onelogin/kl-ruby-saml/attributes.rb
@@ -200,7 +201,6 @@ files:
 - lib/schemas/xenc-schema.xsd
 - lib/schemas/xml.xsd
 - lib/schemas/xmldsig-core-schema.xsd
-- lib/xml_security.rb
 - test/certificates/certificate1
 - test/certificates/certificate_without_head_foot
 - test/certificates/formatted_certificate