oydid 0.9.5 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aa2cc9a77716310c41f0bda9dae80ca4939602b778384c79d874e63e8a27000
-  data.tar.gz: cef9d037771c87c0bb4fb3614696c53c6a4b9d358f016f074defc37d88c810bd
+  metadata.gz: e80efb72fffc8f0a7e8ec1abb8a28376dad2f3463f581bd97719044d32f1f806
+  data.tar.gz: ac2fad7ca40541d40ec8b616704bc2225e4ebe144641805347fc7716682cdc8b
 SHA512:
-  metadata.gz: 43b1ef66a0a911c316a9c0a20d5018595ece344545faf4b986040210b10245f3557da15c5ade1681402ad816d918c75fd788fae5d788a5ba8a2469a39e5b7ee1
-  data.tar.gz: c08146faf1769b6f782e50bbd23468629e7a9069c9e20e9c6bee90cf0dce9a68f494aeceeb57b23d972bd331a73c1643a58bcac91cb73df2238eff33df0061e5
+  metadata.gz: d0886bb19bc142e297bc454117fec9c904e4ad4ad9b8fec49e359c1824333af1fee5a086dfb05788415eadfc7cb1e16a720ec7bca35bcd58dce2799aded1d4f8
+  data.tar.gz: 1e6d067d6f0c7fcf0a824965b253e4f98108efbb7356775e25a46954c3d37e94bf65c34d9295127fd6c61be9a2bf010e09a997f8c25524b6255f67b49621069e

data/VERSION

@@ -1 +1 @@
-0.9.5
+0.9.7

data/lib/oydid/basic.rb

@@ -1272,6 +1272,29 @@ class Oydid
         end
     end
 
+    # Where a document would be written: the explicit doc_location, the generic
+    # location, or the default repository - the same fallbacks publish uses.
+    def self.write_location(options)
+        loc = options[:doc_location].to_s
+        loc = options[:location].to_s if loc == ""
+        loc = DEFAULT_LOCATION if loc == ""
+        loc
+    end
+
+    # Ask a repository whether a public key already controls an active DID.
+    # Only a clear "yes" counts: a repository that does not know the endpoint
+    # (404), a non-HTTP location or an unreachable host must not block a create -
+    # the write path enforces the rule in any case, this is the early exit.
+    def self.key_in_active_use?(public_key, location, options = {})
+        return false if public_key.to_s == ""
+        return false unless location.to_s.start_with?("http")
+        retVal = HTTParty.get(location.to_s + "/key/" + public_key.to_s)
+        return false if retVal.code != 200
+        retVal.parsed_response["active"] == true
+    rescue StandardError
+        false
+    end
+
     def self.retrieve_document(doc_identifier, doc_file, doc_location, options)
         # in-process callers can supply the DID document directly (e.g. read from
         # a local database) to avoid any HTTP/file lookup

data/lib/oydid/didcomm.rb

@@ -3,6 +3,11 @@
 
 class Oydid
 
+    # jwt-eddsa normalises the algorithm name to 'EdDSA' in the JOSE header, but
+    # dcsm writes an explicit 'ED25519' header. Accept both spellings of the same
+    # Ed25519 signature algorithm when verifying.
+    ED25519_ALGS = ['EdDSA', 'ED25519'].freeze
+
     # DIDComm Plain Message ---------------------
     def self.dcpm(payload, options)
         dcDoc = {}
@@ -24,7 +29,9 @@ class Oydid
         code, length, digest = multi_decode(private_key_encoded).first.unpack('SCa*')
         case Multicodecs[code].name
         when 'ed25519-priv'
-            private_key = RbNaCl::Signatures::Ed25519::SigningKey.new(digest)
+            # jwt-eddsa signs with an Ed25519::SigningKey from the ed25519 gem;
+            # an RbNaCl signing key is rejected with JWT::EncodeError.
+            private_key = Ed25519::SigningKey.new(digest)
             token = JWT.encode payload, private_key, 'ED25519', { typ: 'JWM', kid: options[:sign_did].to_s, alg: 'ED25519' }
         else
             token = nil
@@ -33,18 +40,67 @@ class Oydid
         return [token, error]
     end
 
+    # w3c() mixes string keys at the top level with symbol keys inside a
+    # verification method, so read every attribute through this helper.
+    def self.dd_attr(hash, key)
+        return nil unless hash.is_a?(Hash)
+        hash[key].nil? ? hash[key.to_sym] : hash[key]
+    end
+
+    # The 'authentication' section of a DID document may embed a verification
+    # method or - which is how did:oyd resolves it - reference one by id. Only
+    # keys listed there may be used to authenticate the DID subject, so a
+    # document without an authentication section is rejected rather than
+    # silently falling back to some other key.
+    def self.authentication_key(didDocument)
+        verification_methods = dd_attr(didDocument, "verificationMethod") || []
+        entry = (dd_attr(didDocument, "authentication") || []).first
+        vm = case entry
+             when Hash   then entry
+             when String then verification_methods.find { |v| dd_attr(v, "id").to_s == entry }
+             end
+        key = dd_attr(vm, "publicKeyMultibase")
+        if key.to_s == ""
+            return [nil, "no authentication key in DID document"]
+        end
+        return [key, ""]
+    end
+
+    # A DID may be written with or without the default location and with the
+    # location separator in either spelling, so compare the normalised forms.
+    # A fragment ("#key-doc") names a key within the DID, not another subject.
+    def self.same_did?(one, other)
+        percent_encode(one.to_s.split("#").first.to_s) ==
+            percent_encode(other.to_s.split("#").first.to_s)
+    end
+
+    # Verifying a token proves that whoever controls the DID named in its own
+    # 'kid' header signed it - not that the expected party did. Callers that
+    # read the result as an authorisation have to say which DID they expect,
+    # which is what options[:expect_did] is for. Checked before resolving, so a
+    # token from a foreign DID costs no network round trip.
     def self.dcsm_verify(token, options)
         error = ""
         decoded_payload = JWT.decode token, nil, false
         pubkey_did = decoded_payload.last["kid"]
+        if options[:expect_did].to_s != "" && !same_did?(pubkey_did, options[:expect_did])
+            return [nil, "token was signed by " + pubkey_did.to_s +
+                         ", expected " + options[:expect_did].to_s]
+        end
         result, msg = Oydid.read(pubkey_did, options)
-        public_key_encoded = Oydid.w3c(result, options)["authentication"].first["publicKeyMultibase"]
+        if result.nil?
+            return [nil, msg.to_s == "" ? "cannot resolve " + pubkey_did.to_s : msg.to_s]
+        end
+        public_key_encoded, error = authentication_key(Oydid.w3c(result, options))
+        if public_key_encoded.nil?
+            return [nil, error]
+        end
         begin
             code, length, digest = multi_decode(public_key_encoded).first.unpack('CCa*')
             case Multicodecs[code].name
             when 'ed25519-pub'
-                public_key = RbNaCl::Signatures::Ed25519::VerifyKey.new(digest)
-                payload = JWT.decode token.to_s, public_key, true, { algorithm: 'ED25519' }
+                public_key = Ed25519::VerifyKey.new(digest)
+                payload = JWT.decode token.to_s, public_key, true, { algorithms: ED25519_ALGS }
             else
                 payload = nil
                 error = "unsupported key codec"
@@ -61,7 +117,7 @@ class Oydid
         code, length, digest = multi_decode(private_key_encoded).first.unpack('SCa*')
         case Multicodecs[code].name
         when 'ed25519-priv'
-            private_key = RbNaCl::Signatures::Ed25519::SigningKey.new(digest)
+            private_key = Ed25519::SigningKey.new(digest)
             token = JWT.encode payload, private_key, 'ED25519'
         when 'p256-priv'
             group = OpenSSL::PKey::EC::Group.new('prime256v1')
@@ -98,8 +154,8 @@ class Oydid
         code, length, digest = Oydid.multi_decode(public_key_encoded).first.unpack('CCa*')
         case Multicodecs[code].name
         when 'ed25519-pub'
-            public_key = RbNaCl::Signatures::Ed25519::VerifyKey.new(digest)
-            payload = JWT.decode token.to_s, public_key, true, { algorithm: 'ED25519' }
+            public_key = Ed25519::VerifyKey.new(digest)
+            payload = JWT.decode token.to_s, public_key, true, { algorithms: ED25519_ALGS }
         else
             payload = nil
             error = "unsupported key codec"
@@ -108,12 +164,24 @@ class Oydid
     end
 
     # signing for JWS ---------------------------
+    # An empty HMAC key is no key at all: OpenSSL::HMAC.digest('SHA256', '', data)
+    # returns a valid digest, so anyone can recompute the signature. jwt >= 3.2.0
+    # refuses it (CVE-2026-45363), earlier versions happily accepted forged
+    # tokens - most notably via the CLI, where a missing --hmac_secret arrives
+    # here as "". Reject it ourselves so the behaviour does not depend on which
+    # jwt version a consumer resolves.
     def self.msg_sign(payload, hmac_secret)
+        if hmac_secret.to_s == ""
+            return [nil, "HMAC secret must not be empty"]
+        end
         token = JWT.encode payload, hmac_secret, 'HS256'
         return [token, ""]
     end
 
     def self.msg_verify_jws(token, hmac_secret)
+        if hmac_secret.to_s == ""
+            return [nil, "HMAC secret must not be empty"]
+        end
         begin
             decoded_token = JWT.decode token, hmac_secret, true, { algorithm: 'HS256' }
             return [decoded_token, ""]

data/lib/oydid/vc.rb

@@ -58,7 +58,7 @@ class Oydid
             if retVal.code == 401
                 msg = "unauthorized (valid Bearer token required)"
             else
-                msg = retVal.parsed_response("error").to_s rescue "invalid response from " + vc_url.to_s
+                msg = http_error_message(retVal, vc_url)
             end
             return [nil, msg]
         end
@@ -338,7 +338,7 @@ class Oydid
             headers: { 'Content-Type' => 'application/json' },
             body: vc_data.to_json )
         if retVal.code != 200
-            err_msg = retVal.parsed_response("error").to_s rescue "invalid response from " + vc_url.to_s
+            err_msg = http_error_message(retVal, vc_url)
             return [nil, err_msg]
         end
         return [retVal["identifier"], ""]
@@ -355,7 +355,7 @@ class Oydid
         vp_url = vp_location.sub(/(\/)+$/,'') + "/presentations/" + identifier
         retVal = HTTParty.get(vp_url)
         if retVal.code != 200
-            msg = retVal.parsed_response("error").to_s rescue "invalid response from " + vp_url.to_s
+            msg = http_error_message(retVal, vp_url)
             return [nil, msg]
         end
         return [retVal.parsed_response, ""]
@@ -451,7 +451,7 @@ class Oydid
             headers: { 'Content-Type' => 'application/json' },
             body: vp_data.to_json )
         if retVal.code != 200
-            err_msg = retVal.parsed_response("error").to_s rescue "invalid response from " + vp_url.to_s
+            err_msg = http_error_message(retVal, vp_url)
             return [nil, err_msg]
         end
         return [vp["identifier"], ""]

data/lib/oydid.rb

@@ -39,6 +39,12 @@ class Oydid
     JWS_SECURITY_SUITE = "https://w3id.org/security/suites/jws-2020/v1"
     DEFAULT_PUBLIC_RESOLVER = "https://dev.uniresolver.io/1.0/identifiers/"
 
+    # A public key controls at most one active DID at a time. The repository
+    # enforces this when a document is written; the constant lives here so every
+    # caller (repository, registrar driver, CLI) can recognise the rejection by
+    # comparison instead of searching the message text.
+    KEY_IN_USE_ERROR = "public key already controls an active DID"
+
     # Single-byte multicodec codes for the intermediate BLAKE2b digest sizes
     # (17-23 bytes), needed to keep a did:oyd identifier short enough for the
     # 50 character URL limit of the EU Digital Product Passport registry.
@@ -278,6 +284,25 @@ class Oydid
                 else
                     return [nil, nil, nil, "CMSM accepts at most two public keys"]
                 end
+
+                # Reject a reused document key before the client signs anything.
+                # The repository enforces the rule when the document is written,
+                # but a CMSM flow only writes after three signatures - with a
+                # secure element that is three round trips to hardware for a
+                # request that cannot succeed. A repository that does not know
+                # the endpoint answers 404 and the flow continues as before.
+                #
+                # Only for create: a non-rotating UPDATE legitimately carries
+                # the document key of the version it replaces, and that is the
+                # most common form of update.
+                #
+                # skip_publish means the caller is the repository itself: its own
+                # database, not the one at doc_location, decides - it checks in
+                # its CMSM controller before the flow starts.
+                if mode.to_s == "create" && !options[:skip_publish] &&
+                   key_in_active_use?(publicKey, write_location(options), options)
+                    return [nil, nil, nil, KEY_IN_USE_ERROR]
+                end
             else
                 # continue a persisted flow: the request carries the session and
                 # exactly one new signature, which fills the next open slot
@@ -731,7 +756,7 @@ class Oydid
                 headers: { 'Content-Type' => 'application/json' },
                 body: did_data.to_json )
             if retVal.code != 200
-                err_msg = retVal.parsed_response("error").to_s rescue "invalid response from " + doc_location.to_s + "/doc"
+                err_msg = http_error_message(retVal, doc_location.to_s + "/doc")
                 return [false, err_msg]
             end
         else
@@ -894,7 +919,7 @@ class Oydid
                 headers: { 'Content-Type' => 'application/json' },
                 body: my_body.to_json )
             if retVal.code != 200
-                err_msg = retVal.parsed_response("error").to_s rescue "invalid response from " + doc_location.to_s + "/cmsm"
+                err_msg = http_error_message(retVal, doc_location.to_s + "/cmsm")
                 return [nil, err_msg]
             end
         else
@@ -1084,7 +1109,7 @@ class Oydid
             body: {"log": log}.to_json )
         code = retVal.code rescue 500
         if code != 200
-            err_msg = retVal.parsed_response["error"].to_s rescue "invalid response from " + source_location.to_s + "/log"
+            err_msg = http_error_message(retVal, source_location.to_s + "/log")
             return ["", err_msg]
         end
         log_hash = retVal.parsed_response["log"] rescue ""
@@ -1306,7 +1331,7 @@ class Oydid
                 headers: { 'Content-Type' => 'application/json' },
                 body: {"log": revoc_log}.to_json )
             if retVal.code != 200
-                msg = retVal.parsed_response("error").to_s rescue "invalid response from " + doc_location.to_s + "/log/" + did_hash.to_s
+                msg = http_error_message(retVal, doc_location.to_s + "/log/" + did_hash.to_s)
                 return [nil, msg]
             end
         else

data/spec/oydid_spec.rb

@@ -701,6 +701,39 @@ describe "OYDID handling" do
       expect(msg).to start_with("invalid response from")
       expect(Oydid.upstream_error?(msg)).to be false
     end
+
+    # Only the reading paths used the helper. The writing ones built their
+    # message with parsed_response("error") - round brackets, so an
+    # ArgumentError, so the surrounding rescue swallowed whatever the
+    # repository had said. A rejected create then read as "invalid response
+    # from .../doc" and the actual reason never reached the caller.
+    it "passes the repository's error through when writing a DID" do
+      stub_request(:post, "https://oydid.ownyourdata.eu/doc").to_return(
+        status: 400,
+        headers: { "Content-Type" => "application/json" },
+        body: { "error" => "public key already controls an active DID" }.to_json)
+
+      retVal, msg = Oydid.create({ "id" => "spec" },
+                                 { doc_pwd: "spec-doc-pwd", rev_pwd: "spec-rev-pwd",
+                                   location: "https://oydid.ownyourdata.eu",
+                                   digest: "sha2-256", encode: "base58btc" })
+
+      expect(retVal).to be_nil
+      expect(msg).to eq("public key already controls an active DID")
+    end
+
+    it "marks a 5xx while writing as an upstream error" do
+      stub_request(:post, "https://oydid.ownyourdata.eu/doc").to_return(status: 502, body: "")
+
+      retVal, msg = Oydid.create({ "id" => "spec" },
+                                 { doc_pwd: "spec-doc-pwd", rev_pwd: "spec-rev-pwd",
+                                   location: "https://oydid.ownyourdata.eu",
+                                   digest: "sha2-256", encode: "base58btc" })
+
+      expect(retVal).to be_nil
+      expect(Oydid.upstream_error?(msg)).to be true
+      expect(msg).to include("502")
+    end
   end
 
   # main functionds
@@ -1114,6 +1147,79 @@ describe "OYDID handling" do
       status.transform_keys(&:to_s)
     end
 
+    # The write path rejects a reused document key, but a CMSM flow only writes
+    # after three signatures. With a secure element those are three round trips
+    # to hardware for a request that cannot succeed, so phase 1 asks first.
+    describe "document key already in use" do
+      let(:key_url) { "https://oydid.ownyourdata.eu/key/" + pub }
+
+      def remote_options(extra = {})
+        cmsm_options({ skip_publish: false,
+                       location: "https://oydid.ownyourdata.eu" }.merge(extra))
+      end
+
+      it "stops phase 1 when the repository reports the key as active" do
+        stub_request(:get, key_url).to_return(
+          status: 200,
+          headers: { "Content-Type" => "application/json" },
+          body: { "active" => true, "did" => "zQmSpec" }.to_json)
+
+        status, msg = Oydid.create({ "key" => pub }, remote_options)
+
+        expect(status).to be_nil
+        expect(msg).to eq(Oydid::KEY_IN_USE_ERROR)
+      end
+
+      it "continues when the key controls only revoked DIDs" do
+        stub_request(:get, key_url).to_return(
+          status: 200,
+          headers: { "Content-Type" => "application/json" },
+          body: { "active" => false }.to_json)
+
+        status, msg = Oydid.create({ "key" => pub }, remote_options)
+
+        expect(msg).to eq("cmsm")
+        expect(status.transform_keys(&:to_s)["with"]).to eq("key-doc")
+      end
+
+      # A repository that predates the endpoint answers 404. That must not stop
+      # a create - the write path still enforces the rule.
+      it "continues when the repository does not know the endpoint" do
+        stub_request(:get, key_url).to_return(status: 404, body: "")
+
+        status, msg = Oydid.create({ "key" => pub }, remote_options)
+
+        expect(msg).to eq("cmsm")
+      end
+
+      # A non-rotating update legitimately carries the document key of the
+      # version it replaces - the most common form of update. The guardrail is
+      # about create only, so the update path must not even ask.
+      it "asks nobody on update" do
+        stub_request(:get, key_url).to_return(
+          status: 200,
+          headers: { "Content-Type" => "application/json" },
+          body: { "active" => true }.to_json)
+        stub_request(:get, %r{\Ahttps://oydid\.ownyourdata\.eu/doc/}).to_return(status: 404, body: "")
+
+        status, msg = Oydid.update({ "key" => pub }, "did:oyd:zQmSpecUnknownDid", remote_options)
+
+        expect(status).to be_nil
+        expect(msg).not_to eq(Oydid::KEY_IN_USE_ERROR)
+        expect(a_request(:get, key_url)).not_to have_been_made
+      end
+
+      # skip_publish means the repository itself is calling: its own database
+      # decides, and asking the public repository about a local key would be
+      # both wrong and a needless request.
+      it "asks nobody when the caller stores the DID itself" do
+        status, msg = Oydid.create({ "key" => pub }, cmsm_options)
+
+        expect(msg).to eq("cmsm")
+        expect(a_request(:get, %r{/key/})).not_to have_been_made
+      end
+    end
+
     describe "cmsm_verify_signature" do
       it "accepts a signature made with the named key" do
         signature = Oydid.sign("hello", priv, {}).first
@@ -1186,4 +1292,116 @@ describe "OYDID handling" do
       end
     end
   end
+  # These four defects together made the whole DIDComm branch unusable and, in
+  # the HMAC case, forgeable. Nothing in the suite touched it before.
+  describe "DIDComm signing" do
+    let(:priv) { Oydid.generate_private_key("didcomm-spec-pwd", "ed25519-priv", {}).first }
+    let(:pub)  { Oydid.public_key(priv, {}).first }
+
+    # jwt < 3.2.0 verified an HS256 token against an empty key, so anybody could
+    # forge one (CVE-2026-45363). The CLI reaches here with "" whenever
+    # --hmac_secret is omitted, so the gem refuses the empty key itself.
+    it "refuses to sign with an empty HMAC secret" do
+      token, msg = Oydid.msg_sign({ "a" => 1 }, "")
+
+      expect(token).to be_nil
+      expect(msg).to eq("HMAC secret must not be empty")
+    end
+
+    it "refuses to verify a token forged with an empty HMAC key" do
+      header  = Base64.urlsafe_encode64('{"alg":"HS256"}').delete("=")
+      payload = Base64.urlsafe_encode64('{"sub":"attacker"}').delete("=")
+      digest  = OpenSSL::HMAC.digest("SHA256", "", "#{header}.#{payload}")
+      forged  = "#{header}.#{payload}.#{Base64.urlsafe_encode64(digest).delete('=')}"
+
+      decoded, msg = Oydid.msg_verify_jws(forged, "")
+
+      expect(decoded).to be_nil
+      expect(msg).to eq("HMAC secret must not be empty")
+    end
+
+    it "still round-trips an HMAC signature with a real secret" do
+      token, = Oydid.msg_sign({ "a" => 1 }, "s3cr3t")
+      decoded, msg = Oydid.msg_verify_jws(token, "s3cr3t")
+
+      expect(msg).to eq("")
+      expect(decoded.first).to eq({ "a" => 1 })
+    end
+
+    # jwt-eddsa signs with Ed25519::SigningKey; handing it the RbNaCl key raised
+    # JWT::EncodeError, so "oydid jws" could not produce a token at all.
+    it "signs a DIDComm message with the Ed25519 document key" do
+      token, msg = Oydid.dcsm({ "a" => 1 }, priv, { sign_did: "did:oyd:zSpec" })
+
+      expect(msg).to eq("")
+      _, _, digest = Oydid.multi_decode(pub).first.unpack("CCa*")
+      decoded = JWT.decode(token, Ed25519::VerifyKey.new(digest), true,
+                           { algorithms: Oydid::ED25519_ALGS })
+      expect(decoded.first).to eq({ "a" => 1 })
+      expect(decoded.last["kid"]).to eq("did:oyd:zSpec")
+    end
+
+    # w3c() lists "authentication" as a reference and uses symbol keys inside a
+    # verification method - the old code indexed a String with "publicKeyMultibase".
+    describe "authentication_key" do
+      let(:didDocument) do
+        { "authentication" => ["did:oyd:zSpec#key-doc"],
+          "verificationMethod" => [
+            { id: "did:oyd:zSpec#key-rev", publicKeyMultibase: "z6MkRev" },
+            { id: "did:oyd:zSpec#key-doc", publicKeyMultibase: "z6MkDoc" }
+          ] }
+      end
+
+      it "dereferences a referenced verification method" do
+        key, msg = Oydid.authentication_key(didDocument)
+
+        expect(key).to eq("z6MkDoc")
+        expect(msg).to eq("")
+      end
+
+      it "accepts an embedded verification method" do
+        key, = Oydid.authentication_key(
+          { "authentication" => [{ "publicKeyMultibase" => "z6MkEmbedded" }] })
+
+        expect(key).to eq("z6MkEmbedded")
+      end
+
+      # a DID created without --authentication has no such section; report it
+      # instead of raising NoMethodError on nil
+      it "reports a document without an authentication section" do
+        key, msg = Oydid.authentication_key(didDocument.reject { |k, _| k == "authentication" })
+
+        expect(key).to be_nil
+        expect(msg).to eq("no authentication key in DID document")
+      end
+    end
+
+    # dcsm_verify takes the public key from the token's own kid header, so a
+    # green result on its own says nothing about *who* signed. --expect-did is
+    # what turns it into an authorisation check.
+    describe "expect_did" do
+      let(:token) { Oydid.dcsm({ "a" => 1 }, priv, { sign_did: "did:oyd:zSigner" }).first }
+
+      it "treats the two spellings of the location separator as one DID" do
+        expect(Oydid.same_did?("did:oyd:zAbc%40example.com", "did:oyd:zAbc@example.com")).to be true
+      end
+
+      it "ignores a key fragment" do
+        expect(Oydid.same_did?("did:oyd:zAbc#key-doc", "did:oyd:zAbc")).to be true
+      end
+
+      it "separates different DIDs" do
+        expect(Oydid.same_did?("did:oyd:zAbc", "did:oyd:zDef")).to be false
+      end
+
+      # webmock lets no unstubbed request through, so this also shows that the
+      # mismatch is caught before the DID is resolved
+      it "refuses a token signed by another DID without resolving it" do
+        payload, msg = Oydid.dcsm_verify(token, { expect_did: "did:oyd:zSomeoneElse" })
+
+        expect(payload).to be_nil
+        expect(msg).to eq("token was signed by did:oyd:zSigner, expected did:oyd:zSomeoneElse")
+      end
+    end
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: oydid
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.7
 platform: ruby
 authors:
 - Christoph Fabianek
 bindir: bin
 cert_chain: []
-date: 2026-09-02 00:00:00.000000000 Z
+date: 2026-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: simple_dag
@@ -41,16 +41,22 @@ dependencies:
   name: jwt
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 3.1.2
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 3.1.2
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: jwt-eddsa
   requirement: !ruby/object:Gem::Requirement
@@ -97,16 +103,22 @@ dependencies:
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.19.9
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 2.18.1
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.19.9
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 2.18.1
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: json-ld
   requirement: !ruby/object:Gem::Requirement