oydid 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c74b5cd9e592efe1514c9110cff25a131ddc0a45727e035d48656bc0c20d2f8
-  data.tar.gz: bd936eb03e018e15ae334907c7087629f48f17c2cc54bdeebb8a81542e2f2af9
+  metadata.gz: 072b6ccce2a1b7bf3c607aa01d3a3c97cfd37f8e41d52bb9db529d539ccb6eda
+  data.tar.gz: 75ccf1a0357d60e629dac7ea3a046cfe0933693a04b5179bf0db7b54929abc6b
 SHA512:
-  metadata.gz: 8fddcdf2ce2328ba9329263b1de2826cec3c3d4947c7cd5e599972798cffb10887e8bf2205d208961494a7296a818c90a4fea679f2b9b1c01109645c8fde59bf
-  data.tar.gz: fdaab3ac52a14b4313db2d7d52058a41bdd6b72b2ca580441f5620a246d73d2fdf753a0530aef76d44520d8347573852aa6e3ae27d173371d54b09eeb86c874c
+  metadata.gz: c936a18cf7106ae73e76fb30fc5ee789a50330a342dfa9624f29bd03574cde42b9c8a4b6a710e0f7e3ed9c6865fb8ec49aaac2cf7cd24c5d5330405e4f20cd81
+  data.tar.gz: 3d6c15c81d795cd470f75031722f211aac478dc239a1ece245a64e1b00144d7d37eadfe3c5db8dab4ebfd487e685011f50615f5c40d05ea502d59762cbb51a1f

data/VERSION

@@ -1 +1 @@
-0.9.1
+0.9.2

data/lib/oydid/basic.rb

@@ -338,7 +338,7 @@ class Oydid
                 return [nil, msg]
                 exit
             end
-            pubKey = did_document["doc"]["key"].split(":").first rescue nil
+            pubKey = did_document["doc"]["key"].split(":")[0] rescue nil
             if pubKey.nil?
                 return [nil, "cannot resolve " + did.to_s]
             else
@@ -367,9 +367,9 @@ class Oydid
         # get current public key
         case key_type
         when "doc"
-            keys = [did_document["doc"]["key"].split(":").first] rescue nil
+            keys = [did_document["doc"]["key"].split(":")[0]] rescue nil
         when "rev"
-            keys = [did_document["doc"]["key"].split(":").last] rescue nil
+            keys = [did_document["doc"]["key"].split(":")[1]] rescue nil
         else
             return [nil, "invalid key type: " + key_type]
         end

data/lib/oydid/log.rb

@@ -361,7 +361,7 @@ class Oydid
                     currentDID["verification"] += JSON.pretty_generate(doc) + "\n"
                     currentDID["verification"] += "(Details: https://ownyourdata.github.io/oydid/#calculate_hash)" + "\n\n"
                 end
-                current_public_doc_key = currentDID["doc"]["key"].split(":").first rescue ""
+                current_public_doc_key = currentDID["doc"]["key"].split(":")[0] rescue ""
 
             when 0 # TERMINATE
                 currentDID["termination_log_id"] = i
@@ -506,7 +506,7 @@ class Oydid
                                             return currentDID
                                         end
                                         next_doc = next_doc.first["doc"]
-                                        if pubKeys.include?(next_doc["key"].split(":").first)
+                                        if pubKeys.include?(next_doc["key"].split(":")[0])
                                             currentDID["verification"] += "⚠️  no key rotation in updated DID Document" + "\n"
                                         end
                                         currentDID["verification"] += "\n"

data/lib/oydid.rb

@@ -383,8 +383,8 @@ class Oydid
                 old_privateKey = nil
                 old_revocationKey = nil
                 old_did_key = did_info["doc"]["key"].to_s
-                old_publicDocKey = old_did_key.split(":").first.to_s
-                old_publicRevKey = old_did_key.split(":").last.to_s
+                old_publicDocKey = old_did_key.split(":")[0].to_s
+                old_publicRevKey = old_did_key.split(":")[1].to_s
 
                 verified, vmsg = verify_revocation_log(did_info, options[:log_revoke_old],
                                                        "log_revoke_old", options)
@@ -460,6 +460,16 @@ class Oydid
             publicKey = public_key(privateKey, options).first
             pubRevoKey = public_key(revocationKey, options).first
         end
+        # The "key" field is the control field of a did:oyd: it names who may
+        # update the document (slot 0) and who may revoke it (slot 1) - nothing
+        # else. Keys that are content rather than control (key agreement above
+        # all) belong in the payload as verification methods, where they are
+        # covered by the identifier hash just the same.
+        #
+        # The field is positional and has exactly two slots. Readers must use an
+        # explicit index; .last would silently return the wrong key if a third
+        # slot were ever appended, and the mistake would only surface at
+        # revocation time. A spec enforces this across the repository.
         did_key = publicKey + ":" + pubRevoKey
 
         # the document is assembled once, in the first phase of a CMSM flow -
@@ -512,6 +522,10 @@ class Oydid
         end
 
         if revocationKey.to_s == ""
+            if options[:cmsm]
+                err = cmsm_verify_signature(subDidHash, cmsm_sig_rev, pubRevoKey, "key-rev")
+                return [nil, nil, nil, err] if !err.nil?
+            end
             signedSubDidHash = cmsm_sig_rev
         else
             signedSubDidHash = sign(subDidHash, revocationKey, LOG_HASH_OPTIONS).first
@@ -534,6 +548,8 @@ class Oydid
                                       cmsm_sig_rev, cmsm_sig_doc, cmsm_sig_create,
                                   did_old, cmsm_log_revoke_old), options)
             end
+            err = cmsm_verify_signature(l2_doc, cmsm_sig_doc, publicKey, "key-doc")
+            return [nil, nil, nil, err] if !err.nil?
             l2_sig = cmsm_sig_doc
         else
             l2_sig = sign(l2_doc, privateKey, options).first
@@ -595,6 +611,8 @@ class Oydid
                                           cmsm_sig_rev, cmsm_sig_doc, cmsm_sig_create,
                                           did_old, cmsm_log_revoke_old), options)
                 end
+                err = cmsm_verify_signature(l1_doc, cmsm_sig_create, old_publicDocKey, "key-doc-old")
+                return [nil, nil, nil, err] if !err.nil?
                 l1_sig = cmsm_sig_create
             else
                 l1_sig = sign(l1_doc, old_privateKey, options).first
@@ -628,6 +646,8 @@ class Oydid
                                           cmsm_sig_rev, cmsm_sig_doc, cmsm_sig_create,
                                   did_old, cmsm_log_revoke_old), options)
                 end
+                err = cmsm_verify_signature(l1_doc, cmsm_sig_create, publicKey, "key-doc")
+                return [nil, nil, nil, err] if !err.nil?
                 l1_sig = cmsm_sig_create
             else
                 l1_sig = sign(l1_doc, privateKey, options).first
@@ -736,7 +756,7 @@ class Oydid
         end
 
         did_key = did_info["doc"]["key"].to_s
-        pubRevKey = did_key.split(":").last.to_s
+        pubRevKey = did_key.split(":")[1].to_s
         subDid = {"doc": did_info["doc"]["doc"], "key": did_key}.to_json
         subDidHash = multi_hash(canonical(subDid), LOG_HASH_OPTIONS).first
 
@@ -776,6 +796,23 @@ class Oydid
     # state of a CMSM flow that has to survive between phases. Deliberately only
     # inputs and collected signatures - no derived hashes: every phase recomputes
     # r1 / l2_doc / the DID from these values, so there is nothing to keep in sync.
+    # A signature collected in a CMSM phase is only worth something if it was
+    # really made with the key the challenge named. Without this check the flow
+    # takes anything: the log entries are built from whatever the client sent and
+    # only fail on resolution - by which point the DID exists and has claimed the
+    # public key, which lets anyone permanently burn a key they do not hold.
+    #
+    # The message starts with "CMSM " so that the REST layers report it as a
+    # client error (400), not as a server fault.
+    def self.cmsm_verify_signature(value, signature, public_key, with)
+        if public_key.to_s == ""
+            return "CMSM cannot verify the " + with.to_s + " signature: no public key in session"
+        end
+        success, _msg = (verify(value, signature, public_key) rescue [false, ""])
+        return nil if success == true
+        "CMSM signature for " + with.to_s + " is invalid"
+    end
+
     def self.cmsm_state(publicKey, pubRevoKey, revocationKey, did_doc, ts, doc_location, sig_rev, sig_doc, sig_create, did_old = nil, log_revoke_old = nil)
         {
             publicKey: publicKey,

data/spec/oydid_spec.rb

@@ -807,6 +807,51 @@ describe "OYDID handling" do
   # Which identifier a resolved DID document announces as its own. An update
   # mints a new did:oyd, but the identifier a relying party holds is the one it
   # asked for - that is the one the document has to carry.
+  # The "key" field is positional: "<public document key>:<public revocation key>".
+  # Reading it with .first/.last works only as long as it has exactly two slots -
+  # the day a third one is added (e.g. a key agreement key), .last silently
+  # returns the wrong key and the error only surfaces at revocation time.
+  # Every read must therefore use an explicit index.
+  describe "positional access to the key field" do
+    repo_root = File.expand_path("../../..", __FILE__)
+    sources = %w[
+      ruby-gem/lib
+      cli
+      repository/app
+      uni-registrar-driver-did-oyd/app
+    ].map { |d| File.join(repo_root, d) }.select { |d| File.directory?(d) }
+
+    ruby_files = sources.flat_map { |d| Dir.glob(File.join(d, "**", "*.rb")) }
+
+    it "finds sources to scan" do
+      skip "running outside the repository checkout" if ruby_files.empty?
+      expect(ruby_files).not_to be_empty
+    end
+
+    it "never reads a split key field with .last" do
+      skip "running outside the repository checkout" if ruby_files.empty?
+      offenders = ruby_files.flat_map do |file|
+        File.readlines(file).each_with_index.filter_map do |line, i|
+          "#{file.sub(repo_root + "/", "")}:#{i + 1}" if line =~ /split\((["'])\:\1\)\.last/
+        end
+      end
+      expect(offenders).to eq []
+    end
+
+    it "never reads a split key field with .first" do
+      skip "running outside the repository checkout" if ruby_files.empty?
+      offenders = ruby_files.flat_map do |file|
+        File.readlines(file).each_with_index.filter_map do |line, i|
+          next unless line =~ /split\((["'])\:\1\)\.first/
+          # the DID identifier itself is also colon-separated and legitimately
+          # read with .first - only the key field is at issue here
+          "#{file.sub(repo_root + "/", "")}:#{i + 1}" if line.include?('"key"') || line.include?("'key'") || line =~ /_key(s)?\.split/
+        end
+      end
+      expect(offenders).to eq []
+    end
+  end
+
   describe "document_id" do
     let(:first_did)  { "zQmSE1hzumtZ7AoK1qhHf4t5kiKsujMsJSHqoXtWrdd7K7W" }
     let(:second_did) { "zQmfEb3KgYZjZUPLTHPmFPdcV6peF5itB5NmJ9N6gaxxE8K" }
@@ -858,4 +903,103 @@ describe "OYDID handling" do
     end
   end
 
+
+  describe "CMSM signature verification" do
+    # An in-memory stand-in for the session store the repository provides, so
+    # these examples run without a database and without the network.
+    class MemoryCmsmStore
+      def initialize; @data = {}; end
+      def set(session, payload); @data[session] = payload; end
+      def get(session); @data[session]; end
+      def delete(session); @data.delete(session); end
+    end
+
+    let(:store) { MemoryCmsmStore.new }
+    let(:priv)  { Oydid.generate_private_key("", "ed25519-priv", {}).first }
+    let(:pub)   { Oydid.public_key(priv, {}).first }
+
+    def cmsm_options(extra = {})
+      { cmsm: true, key_type: "ed25519", cmsm_store: store,
+        return_secrets: true, skip_publish: true }.merge(extra)
+    end
+
+    # phase 1: hand over the public key, receive session and value to sign
+    def start_flow
+      status, msg = Oydid.create({ "key" => pub }, cmsm_options)
+      expect(msg).to eq("cmsm")
+      status.transform_keys(&:to_s)
+    end
+
+    describe "cmsm_verify_signature" do
+      it "accepts a signature made with the named key" do
+        signature = Oydid.sign("hello", priv, {}).first
+        expect(Oydid.cmsm_verify_signature("hello", signature, pub, "key-doc")).to be_nil
+      end
+
+      it "rejects a signature over a different value" do
+        signature = Oydid.sign("hello", priv, {}).first
+        msg = Oydid.cmsm_verify_signature("goodbye", signature, pub, "key-doc")
+        expect(msg).to eq("CMSM signature for key-doc is invalid")
+      end
+
+      it "rejects a signature made with a different key" do
+        other = Oydid.generate_private_key("", "ed25519-priv", {}).first
+        signature = Oydid.sign("hello", other, {}).first
+        expect(Oydid.cmsm_verify_signature("hello", signature, pub, "key-doc")).not_to be_nil
+      end
+
+      it "rejects nonsense instead of raising" do
+        expect(Oydid.cmsm_verify_signature("hello", "not-a-signature", pub, "key-doc")).not_to be_nil
+      end
+
+      it "refuses to verify without a public key" do
+        signature = Oydid.sign("hello", priv, {}).first
+        msg = Oydid.cmsm_verify_signature("hello", signature, "", "key-doc")
+        expect(msg).to include("no public key in session")
+      end
+
+      # the message is what the REST layers match on to answer 400 instead of 500
+      it "phrases failures as client errors" do
+        msg = Oydid.cmsm_verify_signature("hello", "zBogus", pub, "key-rev")
+        expect(msg).to start_with("CMSM ")
+      end
+    end
+
+    describe "a running flow" do
+      it "advances when the signature is correct" do
+        phase1 = start_flow
+        signature = Oydid.sign(phase1["sign"], priv, {}).first
+
+        status, msg = Oydid.create({}, cmsm_options(cmsm_session: phase1["session"], sig: signature))
+
+        expect(msg).to eq("cmsm")
+        expect(status.transform_keys(&:to_s)["session"]).to eq(phase1["session"])
+      end
+
+      # Before this check the flow took any signature, built the log entries from
+      # it and answered 200. The DID did not resolve, but it had claimed the
+      # public key - so anyone could burn a key they did not hold.
+      it "refuses a signature the client cannot have made" do
+        phase1 = start_flow
+        forged = Oydid.sign(phase1["sign"],
+                            Oydid.generate_private_key("", "ed25519-priv", {}).first, {}).first
+
+        status, msg = Oydid.create({}, cmsm_options(cmsm_session: phase1["session"], sig: forged))
+
+        expect(status).to be_nil
+        expect(msg).to eq("CMSM signature for key-doc is invalid")
+      end
+
+      it "refuses a signature over a value from another flow" do
+        phase1 = start_flow
+        other  = start_flow
+        signature = Oydid.sign(other["sign"], priv, {}).first
+
+        status, msg = Oydid.create({}, cmsm_options(cmsm_session: phase1["session"], sig: signature))
+
+        expect(status).to be_nil
+        expect(msg).to start_with("CMSM ")
+      end
+    end
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: oydid
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - Christoph Fabianek
 bindir: bin
 cert_chain: []
-date: 2026-08-26 00:00:00.000000000 Z
+date: 2026-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: simple_dag