lyrebird 1.0.0.alpha2 → 1.0.0

data/test/lyrebird/namespaces_test.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Lyrebird
+  class NamespacesTest < Minitest::Test
+    def test_saml_assertion_ns
+      assert_equal "urn:oasis:names:tc:SAML:2.0:assertion", SAML_ASSERTION_NS
+    end
+
+    def test_saml_protocol_ns
+      assert_equal "urn:oasis:names:tc:SAML:2.0:protocol", SAML_PROTOCOL_NS
+    end
+
+    def test_xmldsig_ns
+      assert_equal "http://www.w3.org/2000/09/xmldsig#", XMLDSIG_NS
+    end
+
+    def test_enveloped_sig
+      expected = "http://www.w3.org/2000/09/xmldsig#enveloped-signature"
+      assert_equal expected, ENVELOPED_SIG
+    end
+
+    def test_exc_c14n
+      assert_equal "http://www.w3.org/2001/10/xml-exc-c14n#", EXC_C14N
+    end
+
+    def test_sha256_digest
+      assert_equal "http://www.w3.org/2001/04/xmlenc#sha256", SHA256_DIGEST
+    end
+
+    def test_rsa_sha256
+      expected = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"
+      assert_equal expected, RSA_SHA256
+    end
+
+    def test_cm_bearer
+      assert_equal "urn:oasis:names:tc:SAML:2.0:cm:bearer", CM_BEARER
+    end
+
+    def test_attr_name_format
+      expected = "urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified"
+      assert_equal expected, ATTR_NAME_FORMAT
+    end
+
+    def test_status_success
+      assert_equal "urn:oasis:names:tc:SAML:2.0:status:Success", STATUS_SUCCESS
+    end
+
+    def test_xmlenc_ns
+      assert_equal "http://www.w3.org/2001/04/xmlenc#", XMLENC_NS
+    end
+
+    def test_aes256_cbc
+      assert_equal "http://www.w3.org/2001/04/xmlenc#aes256-cbc", AES256_CBC
+    end
+
+    def test_rsa_oaep
+      expected = "http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p"
+      assert_equal expected, RSA_OAEP
+    end
+  end
+end

data/test/lyrebird/response_test.rb

@@ -4,6 +4,13 @@ require "test_helper"
 
 module Lyrebird
   class ResponseTest < Minitest::Test
+    NAMESPACES = {
+      "saml" => SAML_ASSERTION_NS,
+      "samlp" => SAML_PROTOCOL_NS,
+      "ds" => XMLDSIG_NS,
+      "xenc" => XMLENC_NS
+    }.freeze
+
     def setup
       @response = Response.new
       @root = @response.document.root
@@ -12,7 +19,8 @@ module Lyrebird
     def test_build_with_defaults
       response = Response.build
       root = response.document.root
-      assert_equal DEFAULTS.issuer, root.elements["saml:Issuer"].text
+      issuer = root.at_xpath("saml:Issuer", NAMESPACES)
+      assert_equal DEFAULTS.issuer, issuer.text
     end
 
     def test_build_with_kwargs
@@ -20,7 +28,7 @@ module Lyrebird
       refute_equal issuer, DEFAULTS.issuer
       response = Response.build(issuer: issuer)
       root = response.document.root
-      assert_equal issuer, root.elements["saml:Issuer"].text
+      assert_equal issuer, root.at_xpath("saml:Issuer", NAMESPACES).text
     end
 
     def test_build_with_block
@@ -28,7 +36,7 @@ module Lyrebird
       refute_equal issuer, DEFAULTS.issuer
       response = Response.build { |r| r.issuer = issuer }
       root = response.document.root
-      assert_equal issuer, root.elements["saml:Issuer"].text
+      assert_equal issuer, root.at_xpath("saml:Issuer", NAMESPACES).text
     end
 
     def test_build_with_kwargs_and_block
@@ -43,9 +51,9 @@ module Lyrebird
       end
 
       root = response.document.root
-      assert_equal issuer, root.elements["saml:Issuer"].text
-      name_id = root.elements["saml:Assertion/saml:Subject/saml:NameID"]
-      assert_equal email, name_id.text
+      assert_equal issuer, root.at_xpath("saml:Issuer", NAMESPACES).text
+      xpath = "saml:Assertion/saml:Subject/saml:NameID"
+      assert_equal email, root.at_xpath(xpath, NAMESPACES).text
     end
 
     def test_build_with_attributes_block
@@ -60,12 +68,15 @@ module Lyrebird
       end
 
       root = response.document.root
-      statement = root.elements["saml:Assertion/saml:AttributeStatement"]
-      email_element = statement.elements["saml:Attribute[@Name='email']"]
-      role_element = statement.elements["saml:Attribute[@Name='role']"]
+      statement_xpath = "saml:Assertion/saml:AttributeStatement"
+      statement = root.at_xpath(statement_xpath, NAMESPACES)
+      email_xpath = "saml:Attribute[@Name='email']/saml:AttributeValue"
+      role_xpath = "saml:Attribute[@Name='role']/saml:AttributeValue"
+      email_element = statement.at_xpath(email_xpath, NAMESPACES)
+      role_element = statement.at_xpath(role_xpath, NAMESPACES)
 
-      assert_equal email, email_element.elements["saml:AttributeValue"].text
-      assert_equal role, role_element.elements["saml:AttributeValue"].text
+      assert_equal email, email_element.text
+      assert_equal role, role_element.text
     end
 
     def test_build_with_attributes_hash
@@ -76,9 +87,10 @@ module Lyrebird
       end
 
       root = response.document.root
-      statement = root.elements["saml:Assertion/saml:AttributeStatement"]
-      email_element = statement.elements["saml:Attribute[@Name='email']"]
-      assert_equal email, email_element.elements["saml:AttributeValue"].text
+      statement_xpath = "saml:Assertion/saml:AttributeStatement"
+      attr_xpath = "saml:Attribute[@Name='email']/saml:AttributeValue"
+      statement = root.at_xpath(statement_xpath, NAMESPACES)
+      assert_equal email, statement.at_xpath(attr_xpath, NAMESPACES).text
     end
 
     def test_mimic_returns_base64
@@ -90,66 +102,66 @@ module Lyrebird
 
     def test_root_name
       assert_equal "Response", @root.name
-      assert_equal "samlp", @root.prefix
+      assert_equal "samlp", @root.namespace.prefix
     end
 
     def test_root_namespace
-      assert_equal SAML_PROTOCOL_NS, @root.namespace
+      assert_equal SAML_PROTOCOL_NS, @root.namespace.href
     end
 
     def test_saml_namespace_declared
-      assert_equal SAML_ASSERTION_NS, @root.namespace("saml")
+      assert_equal SAML_ASSERTION_NS, @root.namespaces["xmlns:saml"]
     end
 
     def test_root_id
-      assert @root.attributes["ID"].start_with?("_")
+      assert @root["ID"].start_with?("_")
     end
 
     def test_root_version
-      assert_equal "2.0", @root.attributes["Version"]
+      assert_equal "2.0", @root["Version"]
     end
 
     def test_root_issue_instant
-      instant = Time.iso8601(@root.attributes["IssueInstant"])
+      instant = Time.iso8601(@root["IssueInstant"])
       assert_in_delta Time.now.to_i, instant.to_i, 1
     end
 
     def test_destination_default
-      assert_equal DEFAULTS.recipient, @root.attributes["Destination"]
+      assert_equal DEFAULTS.recipient, @root["Destination"]
     end
 
     def test_destination_override
       destination = "https://test.example.com/acs"
       refute_equal destination, DEFAULTS.recipient
       root = Response.new(destination: destination).document.root
-      assert_equal destination, root.attributes["Destination"]
+      assert_equal destination, root["Destination"]
     end
 
     def test_in_response_to_default
-      assert_equal DEFAULTS.in_response_to, @root.attributes["InResponseTo"]
+      assert_equal DEFAULTS.in_response_to, @root["InResponseTo"]
     end
 
     def test_in_response_to_override
       in_response_to = "_test_request"
       refute_equal in_response_to, DEFAULTS.in_response_to
       root = Response.new(in_response_to: in_response_to).document.root
-      assert_equal in_response_to, root.attributes["InResponseTo"]
+      assert_equal in_response_to, root["InResponseTo"]
     end
 
     def test_destination_omitted_when_nil
       root = Response.new(destination: nil).document.root
-      assert_nil root.attributes["Destination"]
+      assert_nil root["Destination"]
     end
 
     def test_in_response_to_omitted_when_nil
       root = Response.new(in_response_to: nil).document.root
-      assert_nil root.attributes["InResponseTo"]
+      assert_nil root["InResponseTo"]
     end
 
     def test_issuer
-      issuer = @root.elements["saml:Issuer"]
+      issuer = @root.at_xpath("saml:Issuer", NAMESPACES)
       assert_equal "Issuer", issuer.name
-      assert_equal "saml", issuer.prefix
+      assert_equal "saml", issuer.namespace.prefix
       assert_equal DEFAULTS.issuer, issuer.text
     end
 
@@ -157,40 +169,39 @@ module Lyrebird
       url = "https://test.idp.example.com"
       refute_equal url, DEFAULTS.issuer
       root = Response.new(issuer: url).document.root
-      issuer = root.elements["saml:Issuer"]
+      issuer = root.at_xpath("saml:Issuer", NAMESPACES)
       assert_equal url, issuer.text
     end
 
     def test_status
-      status = @root.elements["samlp:Status"]
+      status = @root.at_xpath("samlp:Status", NAMESPACES)
       assert_equal "Status", status.name
-      assert_equal "samlp", status.prefix
+      assert_equal "samlp", status.namespace.prefix
     end
 
     def test_status_code
-      status_code = @root.elements["samlp:Status/samlp:StatusCode"]
+      status_code = @root.at_xpath("samlp:Status/samlp:StatusCode", NAMESPACES)
       assert_equal "StatusCode", status_code.name
-      assert_equal "samlp", status_code.prefix
-      assert_equal STATUS_SUCCESS, status_code.attributes["Value"]
+      assert_equal "samlp", status_code.namespace.prefix
+      assert_equal STATUS_SUCCESS, status_code["Value"]
     end
 
     def test_assertion_embedded
-      assertion = @root.elements["saml:Assertion"]
+      assertion = @root.at_xpath("saml:Assertion", NAMESPACES)
       assert_equal "Assertion", assertion.name
-      assert_equal "saml", assertion.prefix
+      assert_equal "saml", assertion.namespace.prefix
     end
 
     def test_assertion_has_id
-      assertion = @root.elements["saml:Assertion"]
-      assert assertion.attributes["ID"].start_with?("_")
+      assertion = @root.at_xpath("saml:Assertion", NAMESPACES)
+      assert assertion["ID"].start_with?("_")
     end
 
     def test_assertion_inherits_issuer
       url = "https://test.idp.example.com"
       refute_equal url, DEFAULTS.issuer
       root = Response.new(issuer: url).document.root
-      assertion = root.elements["saml:Assertion"]
-      issuer = assertion.elements["saml:Issuer"]
+      issuer = root.at_xpath("saml:Assertion/saml:Issuer", NAMESPACES)
       assert_equal url, issuer.text
     end
 
@@ -198,43 +209,42 @@ module Lyrebird
       email = "test@example.com"
       refute_equal email, DEFAULTS.name_id
       root = Response.new(name_id: email).document.root
-      assertion = root.elements["saml:Assertion"]
-      name_id = assertion.elements["saml:Subject/saml:NameID"]
-      assert_equal email, name_id.text
+      xpath = "saml:Assertion/saml:Subject/saml:NameID"
+      assert_equal email, root.at_xpath(xpath, NAMESPACES).text
     end
 
     def test_unsigned_by_default
-      assert_nil @root.elements["ds:Signature"]
-      assert_nil @root.elements["saml:Assertion/ds:Signature"]
+      assert_nil @root.at_xpath("ds:Signature", NAMESPACES)
+      assert_nil @root.at_xpath("saml:Assertion/ds:Signature", NAMESPACES)
     end
 
     def test_sign_with_signs_response_and_assertion
-      root = Response.new(sign_with: Certificate.generate).document.root
-      refute_nil root.elements["ds:Signature"]
-      refute_nil root.elements["saml:Assertion/ds:Signature"]
+      root = Response.new(sign_with: Certificate.build).document.root
+      refute_nil root.at_xpath("ds:Signature", NAMESPACES)
+      refute_nil root.at_xpath("saml:Assertion/ds:Signature", NAMESPACES)
     end
 
     def test_not_encrypted_by_default
-      assert_nil @root.elements["saml:EncryptedAssertion"]
+      assert_nil @root.at_xpath("saml:EncryptedAssertion", NAMESPACES)
     end
 
     def test_encrypt_with_creates_encrypted_assertion
-      root = Response.new(encrypt_with: Certificate.generate).document.root
-      ea = root.elements["saml:EncryptedAssertion"]
+      root = Response.new(encrypt_with: Certificate.build).document.root
+      ea = root.at_xpath("saml:EncryptedAssertion", NAMESPACES)
       assert_equal "EncryptedAssertion", ea.name
-      assert_equal "saml", ea.prefix
+      assert_equal "saml", ea.namespace.prefix
     end
 
     def test_encrypt_with_removes_plain_assertion
-      root = Response.new(encrypt_with: Certificate.generate).document.root
-      assert_nil root.elements["saml:Assertion"]
+      root = Response.new(encrypt_with: Certificate.build).document.root
+      assert_nil root.at_xpath("saml:Assertion", NAMESPACES)
     end
 
     def test_encrypt_with_contains_encrypted_data
-      root = Response.new(encrypt_with: Certificate.generate).document.root
-      ed = root.elements["saml:EncryptedAssertion/xenc:EncryptedData"]
+      root = Response.new(encrypt_with: Certificate.build).document.root
+      xpath = "saml:EncryptedAssertion/xenc:EncryptedData"
+      ed = root.at_xpath(xpath, NAMESPACES)
       assert_equal "EncryptedData", ed.name
     end
-
   end
 end

data/test/lyrebird/signature_test.rb

@@ -4,18 +4,26 @@ require "test_helper"
 
 module Lyrebird
   class SignatureTest < Minitest::Test
+    NS = { "ds" => XMLDSIG_NS, "saml" => SAML_ASSERTION_NS }.freeze
+
     def setup
-      @certificate = Certificate.generate
-      @assertion = Assertion.new.document
-      @element = @assertion.root
-      Signature.new(@element, @certificate).sign!
-      @signature = @element.elements["ds:Signature"]
-      @signed_info = @signature.elements["ds:SignedInfo"]
-      @reference = @signed_info.elements["ds:Reference"]
+      unless defined?(@@certificate)
+        @@certificate = Certificate.build
+        @@assertion = Assertion.new.document
+        @@element = @@assertion.root
+        Signature.new(@@element, @@certificate).sign!
+      end
+
+      @certificate = @@certificate
+      @assertion = @@assertion
+      @element = @@element
+      @signature = @element.at_xpath("ds:Signature", NS)
+      @signed_info = @signature.at_xpath("ds:SignedInfo", NS)
+      @reference = @signed_info.at_xpath("ds:Reference", NS)
     end
 
     def test_sign_inserts_after_issuer
-      children = @element.elements.to_a
+      children = @element.element_children
       issuer_index = children.index { |e| e.name == "Issuer" }
       signature_index = children.index { |e| e.name == "Signature" }
       assert_equal issuer_index + 1, signature_index
@@ -23,12 +31,12 @@ module Lyrebird
 
     def test_signature_element
       assert_equal "Signature", @signature.name
-      assert_equal "ds", @signature.prefix
-      assert_equal XMLDSIG_NS, @signature.namespace
+      assert_equal "ds", @signature.namespace.prefix
+      assert_equal XMLDSIG_NS, @signature.namespace.href
     end
 
     def test_signature_element_children
-      children = @signature.elements.to_a
+      children = @signature.element_children
       assert_equal 3, children.size
       assert_equal "SignedInfo", children[0].name
       assert_equal "SignatureValue", children[1].name
@@ -37,101 +45,127 @@ module Lyrebird
 
     def test_signed_info_element
       assert_equal "SignedInfo", @signed_info.name
-      assert_equal "ds", @signed_info.prefix
+      assert_equal "ds", @signed_info.namespace.prefix
     end
 
     def test_canonicalization_method
-      cm = @signed_info.elements["ds:CanonicalizationMethod"]
+      cm = @signed_info.at_xpath("ds:CanonicalizationMethod", NS)
       assert_equal "CanonicalizationMethod", cm.name
-      assert_equal EXC_C14N, cm.attributes["Algorithm"]
+      assert_equal EXC_C14N, cm["Algorithm"]
     end
 
     def test_signature_method
-      sm = @signed_info.elements["ds:SignatureMethod"]
+      sm = @signed_info.at_xpath("ds:SignatureMethod", NS)
       assert_equal "SignatureMethod", sm.name
-      assert_equal RSA_SHA256, sm.attributes["Algorithm"]
+      assert_equal RSA_SHA256, sm["Algorithm"]
     end
 
     def test_reference_element
       assert_equal "Reference", @reference.name
-      assert_equal "ds", @reference.prefix
+      assert_equal "ds", @reference.namespace.prefix
     end
 
     def test_reference_uri
-      element_id = @element.attributes["ID"]
-      assert_equal "##{element_id}", @reference.attributes["URI"]
+      assert_equal "##{@element["ID"]}", @reference["URI"]
     end
 
     def test_transforms_element
-      transforms = @reference.elements["ds:Transforms"]
+      transforms = @reference.at_xpath("ds:Transforms", NS)
       assert_equal "Transforms", transforms.name
-      assert_equal "ds", transforms.prefix
+      assert_equal "ds", transforms.namespace.prefix
     end
 
     def test_enveloped_signature_transform
-      transforms = @reference.elements["ds:Transforms"]
-      transform = transforms.elements.to_a("ds:Transform")[0]
-      assert_equal ENVELOPED_SIG, transform.attributes["Algorithm"]
+      transforms = @reference.xpath("ds:Transforms/ds:Transform", NS)
+      assert_equal ENVELOPED_SIG, transforms[0]["Algorithm"]
     end
 
     def test_c14n_transform
-      transforms = @reference.elements["ds:Transforms"]
-      transform = transforms.elements.to_a("ds:Transform")[1]
-      assert_equal EXC_C14N, transform.attributes["Algorithm"]
+      transforms = @reference.xpath("ds:Transforms/ds:Transform", NS)
+      assert_equal EXC_C14N, transforms[1]["Algorithm"]
     end
 
     def test_digest_method_element
-      digest_method = @reference.elements["ds:DigestMethod"]
+      digest_method = @reference.at_xpath("ds:DigestMethod", NS)
       assert_equal "DigestMethod", digest_method.name
-      assert_equal "ds", digest_method.prefix
+      assert_equal "ds", digest_method.namespace.prefix
     end
 
     def test_digest_method_algorithm
-      digest_method = @reference.elements["ds:DigestMethod"]
-      assert_equal SHA256_DIGEST, digest_method.attributes["Algorithm"]
+      digest_method = @reference.at_xpath("ds:DigestMethod", NS)
+      assert_equal SHA256_DIGEST, digest_method["Algorithm"]
     end
 
     def test_digest_value_element
-      digest_value = @reference.elements["ds:DigestValue"]
+      digest_value = @reference.at_xpath("ds:DigestValue", NS)
       assert_equal "DigestValue", digest_value.name
-      assert_equal "ds", digest_value.prefix
+      assert_equal "ds", digest_value.namespace.prefix
     end
 
     def test_digest_value_is_base64
-      digest_value = @reference.elements["ds:DigestValue"]
+      digest_value = @reference.at_xpath("ds:DigestValue", NS)
       decoded = Base64.strict_decode64(digest_value.text)
       assert_equal 32, decoded.bytesize
     end
 
     def test_signature_value_element
-      sv = @signature.elements["ds:SignatureValue"]
+      sv = @signature.at_xpath("ds:SignatureValue", NS)
       assert_equal "SignatureValue", sv.name
-      assert_equal "ds", sv.prefix
+      assert_equal "ds", sv.namespace.prefix
     end
 
     def test_signature_value_is_base64
-      sv = @signature.elements["ds:SignatureValue"]
+      sv = @signature.at_xpath("ds:SignatureValue", NS)
       decoded = Base64.strict_decode64(sv.text)
       assert_equal 256, decoded.bytesize
     end
 
     def test_key_info_element
-      ki = @signature.elements["ds:KeyInfo"]
+      ki = @signature.at_xpath("ds:KeyInfo", NS)
       assert_equal "KeyInfo", ki.name
-      assert_equal "ds", ki.prefix
+      assert_equal "ds", ki.namespace.prefix
     end
 
     def test_x509_data_element
-      x509_data = @signature.elements["ds:KeyInfo/ds:X509Data"]
+      x509_data = @signature.at_xpath("ds:KeyInfo/ds:X509Data", NS)
       assert_equal "X509Data", x509_data.name
-      assert_equal "ds", x509_data.prefix
+      assert_equal "ds", x509_data.namespace.prefix
     end
 
     def test_x509_certificate_element
-      cert = @signature.elements["ds:KeyInfo/ds:X509Data/ds:X509Certificate"]
+      xpath = "ds:KeyInfo/ds:X509Data/ds:X509Certificate"
+      cert = @signature.at_xpath(xpath, NS)
       assert_equal "X509Certificate", cert.name
-      assert_equal "ds", cert.prefix
+      assert_equal "ds", cert.namespace.prefix
       assert_equal @certificate.base64, cert.text
     end
+
+    def test_digest_verifies
+      assertion = @assertion.dup
+      element = assertion.root
+      signature = element.at_xpath("ds:Signature", NS)
+      reference = signature.at_xpath("ds:SignedInfo/ds:Reference", NS)
+
+      signature.remove
+      c14n = Nokogiri::XML::XML_C14N_EXCLUSIVE_1_0
+      canonical = element.canonicalize(c14n)
+      computed = OpenSSL::Digest::SHA256.digest(canonical)
+
+      digest_value = reference.at_xpath("ds:DigestValue", NS)
+      expected = Base64.strict_decode64(digest_value.text)
+      assert_equal expected, computed
+    end
+
+    def test_signature_verifies
+      c14n = Nokogiri::XML::XML_C14N_EXCLUSIVE_1_0
+      canonical = @signed_info.canonicalize(c14n)
+
+      sig_value = @signature.at_xpath("ds:SignatureValue", NS)
+      signature_bytes = Base64.strict_decode64(sig_value.text)
+
+      public_key = @certificate.x509.public_key
+      verified = public_key.verify("SHA256", signature_bytes, canonical)
+      assert verified
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lyrebird
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha2
+  version: 1.0.0
 platform: ruby
 authors:
 - Josh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-27 00:00:00.000000000 Z
+date: 2026-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ostruct
+  name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rexml
+  name: ostruct
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-saml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description:
 email:
 executables: []
@@ -88,6 +116,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
 - ".github/workflows/publish.yml"
+- LICENSE.md
 - README.md
 - Rakefile
 - lib/lyrebird.rb
@@ -107,11 +136,14 @@ files:
 - test/lyrebird/defaults_test.rb
 - test/lyrebird/encryption_test.rb
 - test/lyrebird/id_test.rb
+- test/lyrebird/integration_test.rb
+- test/lyrebird/namespaces_test.rb
 - test/lyrebird/response_test.rb
 - test/lyrebird/signature_test.rb
 - test/test_helper.rb
-homepage:
-licenses: []
+homepage: https://github.com/simplesaml/lyrebird
+licenses:
+- MIT
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -124,9 +156,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.4.19
 signing_key: