hide-protocol 0.8.0-aarch64-linux → 0.9.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 718d313c9adab619e4d06d2368453982f93ac7a31bec8d131902e29ff711aa9d
-  data.tar.gz: 8160e42099bb755e1f720339a61afccc54dab5b83648ddcd2d0b1ad964ec966c
+  metadata.gz: 30e1877e19a676b20598217324038d73c36c0751f1c62d545e838740f5838cd4
+  data.tar.gz: 5e75d57cd0c20cad9e8159bb8b4a2a0eca25f4d4eb632c9efe2397ec0e807538
 SHA512:
-  metadata.gz: cfc27fab7c908e624bd490681970eb7e328ab7e3d9dc1fb96120521b778af1c3cecc019e05174ef5e7cb8e6c47f27f2e617803cc5c27b1b2c0089a7e4ab2501a
-  data.tar.gz: 4ac6e0176c0e34b25073d3ebab7b0017c6e6d0be7d4ad228cd818a30820249055114e8cfe714b92c62daec25db48b9f8c8a7b01a408ba387bfd02bfd126a0592
+  metadata.gz: b3bd36b9988e09371c4d0256296c91c9f998219631214ed52f8fb3a809ad01ba8b037a5034741d1412fe46edc6d16ce056dd745c10f858b308466085248373e6
+  data.tar.gz: c3f139adf55e86ed865a7b704afdb7dd4f160421ea2080915dc373472dddce27d190b77a7a395a0dde8e5ad4e24f520c73d2a2f26c89d2873d6a46afa18cb93b

data/README.md

@@ -103,12 +103,20 @@ written before signatures existed carries no signing seed and raises
 | `Hide.epoch_public_key(chain, epoch)` | the public key to encrypt to for `epoch` |
 | `Hide.verify_inclusion(leaf, index, size, path, root)` | `nil` |
 | `Hide.verify_consistency(old_size, new_size, path, old_root, new_root)` | `nil` |
+| `Hide.verify_identity_pinned(log, recovery_binding, pinned_root)` | `Integer` — devices trusted, after checking the log against the 32-byte root you pinned |
+| `Hide.verify_epoch_chain_bound(log, recovery_binding, pinned_root, chain, epoch_binding)` | `Integer` — epochs held, after proving the chain belongs to that identity |
+| `Hide.verify_checkpoint(note, origin, log_public)` | `[size, root]` — tree size and 32-byte root of a signed checkpoint note |
 
 A cryptographic verify **raises** on failure (`MalformedError` if the bytes did
 not decode, `AuthenticationError` if they decoded but did not verify) and never
 returns `false`. The one boolean is `identity_trusts_device`: the log is
 verified first, so `false` means "not a member", never "did not verify".
 
+`verify_identity_pinned` is the relying-party check (spec §16): a recovery key
+taken from the same untrusted source as the log cannot catch a Recover appended
+under a stranger's key, but a `recovery_binding` checked against a root you
+trust out of band does.
+
 ## Native library
 
 The core is located in this order:
@@ -150,5 +158,5 @@ closes — including when the block raises. A closed handle raises
 
 - Repository: <https://github.com/hide-protocol/hide>
 - Documentation: [docs/](https://github.com/hide-protocol/hide/tree/main/docs)
-- Specification: [spec/hide-0.1.md](https://github.com/hide-protocol/hide/blob/main/spec/hide-0.1.md)
+- Specification: [spec/hide-1.md](https://github.com/hide-protocol/hide/blob/main/spec/hide-1.md)
 - [CHANGELOG](https://github.com/hide-protocol/hide/blob/main/CHANGELOG.md)

data/lib/hide_protocol/binding.rb

@@ -122,6 +122,15 @@ module Hide
       ],
       hide_transparency_verify_consistency: [
         [UINT64, UINT64, VOIDP, SIZE_T, VOIDP, SIZE_T, VOIDP, SIZE_T], INT32
+      ],
+      hide_identity_verify_pinned: [
+        [VOIDP, SIZE_T, VOIDP, SIZE_T, VOIDP, SIZE_T, VOIDP], INT32
+      ],
+      hide_epoch_verify_bound: [
+        [VOIDP, SIZE_T, VOIDP, SIZE_T, VOIDP, SIZE_T, VOIDP, SIZE_T, VOIDP, SIZE_T, VOIDP], INT32
+      ],
+      hide_checkpoint_verify: [
+        [VOIDP, SIZE_T, VOIDP, VOIDP, SIZE_T, VOIDP, VOIDP], INT32
       ]
     }.freeze
 
@@ -189,5 +198,17 @@ module Hide
       slot[0, WORD] = "\x00" * WORD
       slot
     end
+
+    # A slot for a uint64_t out-parameter. Always 8 bytes, unlike a size_t
+    # slot, so it is read with "Q" rather than WORD_PACK.
+    def self.uint64_slot
+      slot = Fiddle::Pointer.malloc(8, Fiddle::RUBY_FREE)
+      slot[0, 8] = "\x00" * 8
+      slot
+    end
+
+    def self.read_uint64(slot)
+      slot[0, 8].unpack1("Q")
+    end
   end
 end

data/lib/hide_protocol.rb

@@ -292,6 +292,77 @@ module Hide
       nil
     end
 
+    # Verifies an identity log against the root the caller pinned out of band.
+    #
+    # recovery_binding establishes the recovery key, so a log extended by a
+    # Recover under a stranger's key fails — a bare verify_identity with a
+    # recovery key taken from the same untrusted source does not catch that.
+    # Returns how many devices the log trusts now; raises MalformedError for
+    # bytes that do not decode and AuthenticationError for a log that is not
+    # this identity's.
+    def verify_identity_pinned(log, recovery_binding, pinned_root)
+      bytes = binary(log, "log")
+      binding = binary(recovery_binding, "recovery binding")
+      root = binary(pinned_root, "pinned root")
+      slot = Binding.pointer_slot
+      check(Binding.call(
+              :hide_identity_verify_pinned,
+              buffer_arg(bytes), bytes.bytesize,
+              buffer_arg(binding), binding.bytesize,
+              buffer_arg(root), root.bytesize,
+              slot
+            ))
+      Binding.read_count(slot)
+    end
+
+    # Verifies that an epoch chain belongs to the pinned identity.
+    #
+    # epoch_binding must be signed by a device the log trusts now, over this
+    # exact chain. Returns how many epochs the chain holds.
+    def verify_epoch_chain_bound(log, recovery_binding, pinned_root, chain, epoch_binding)
+      bytes = binary(log, "log")
+      binding = binary(recovery_binding, "recovery binding")
+      root = binary(pinned_root, "pinned root")
+      chain_bytes = binary(chain, "chain")
+      epoch_bytes = binary(epoch_binding, "epoch binding")
+      slot = Binding.pointer_slot
+      check(Binding.call(
+              :hide_epoch_verify_bound,
+              buffer_arg(bytes), bytes.bytesize,
+              buffer_arg(binding), binding.bytesize,
+              buffer_arg(root), root.bytesize,
+              buffer_arg(chain_bytes), chain_bytes.bytesize,
+              buffer_arg(epoch_bytes), epoch_bytes.bytesize,
+              slot
+            ))
+      Binding.read_count(slot)
+    end
+
+    # Verifies a signed checkpoint note from the log named origin, under the
+    # log's 1984-byte public key. Returns [size, root]: the tree size and its
+    # 32-byte root. Raises AuthenticationError when the note was altered,
+    # names another origin, or is not signed under log_public.
+    def verify_checkpoint(note, origin, log_public)
+      bytes = binary(note, "note")
+      key = binary(log_public, "log public key")
+      size = Binding.uint64_slot
+      out = Binding.empty_buffer
+      begin
+        check(Binding.call(
+                :hide_checkpoint_verify,
+                buffer_arg(bytes), bytes.bytesize,
+                cstring(origin.to_s),
+                buffer_arg(key), key.bytesize,
+                size, out
+              ))
+      rescue StandardError
+        # On failure the core leaves out untouched; freeing it releases the scratch space.
+        Binding.take(out)
+        raise
+      end
+      [Binding.read_uint64(size), Binding.take(out)]
+    end
+
     def check(code)
       return if code == Binding::OK
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hide-protocol
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.1
 platform: aarch64-linux
 authors:
 - HIDE contributors