hash-merkle-tree 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8e8fac845ce12a9f3566c344b5f6582ddd7c000cf924400287fa29fdcbde8553
+  data.tar.gz: 9e872429d89cfe67a2c3540d9a56499d0e15dcfc0529b8792112ff20e6b69eca
+SHA512:
+  metadata.gz: 4df0bfb1416ebeb82b258e8acae15571f688e99c7253d5a0cecf0cdfaab428ad9d6c0000379c51257f2fca8161f18018ce927f9b3d1238aa5521dd1ab211a14f
+  data.tar.gz: 027ee8861d0501d3696dc7baf8d4011b14721eac444001f0d703bbbcbe1e0101f324a71046f3582ee815ffe4b739d701fe8d39c637eba99ef512fe9fcb543575

data/README.md

@@ -0,0 +1,66 @@
+This repo contains an implementation of "Merkle Hash Trees" (MHT).
+In cryptography and computer science, a hash tree or Merkle Hash Tree
+is a tree in which every "leaf" (node) is labelled with the cryptographic hash of 
+a data block, and every node that is not a leaf (called a branch, inner node, or inode) 
+is labelled with the cryptographic hash of the labels of its child nodes.
+Specifically, it implements the variant described in
+[RFC6962](http://tools.ietf.org/html/rfc6962)
+
+
+## Basic Usage
+
+Assume that you have such an object, named
+`data`, and we'll look at how to use the MHT.
+
+    data = %w[a b c d e f g h i j k l m n o p q r s t u v w x y z]
+
+We'll create a new MHT:
+
+    tree = Merkle::HashTree.new(data, Digest::SHA256)
+
+The `Merkle::HashTree` constructor takes exactly two arguments: an object that
+implements the data access interface we'll talk about later, and a class (or
+object) which implements the same `digest` method signature as the core
+`Digest::Base` class.  Typically, this will simply be a `Digest` subclass,
+such as `Digest::MD5`, `Digest::SHA1`, or (as in the example above)
+`Digest::SHA256`.  This second argument is the way that the MHT calculates
+hashes in the tree -- it simply calls the `#digest` method on whatever you
+pass in as the second argument, passing in a string and expecting raw octets
+out the other end.
+
+Once we have our MHT object, we can start to do things with it.
+For example, we can get the hash of the "head" of the tree:
+
+
+    tree.head_build   # => "<some long string of octets>"
+
+
+We can also ask for a "consistency proof", we need to specify an index(n) of the last
+element of sub_tree (as a result sub_tree will be `data[0...n]`):
+
+
+    consistency_proof = tree.consistency_proof_build(10)   # => ["<hash>", "<hash>", ... ]
+
+    
+ You can test it checking sum with hash head of the tree. Or use:
+
+
+    tree.consistency_proof_build_head(consistency_proof)   # => "<some long string of octets>"
+
+
+There are also such things as "audit proofs", which you get by specifying a single leaf index:
+
+
+    audit_proof = tree.audit_proof_build(10)   # => [ { value: "<hash>", position: "left" }, { value: "<hash>", position: "right" }, ... ]
+
+
+In this example, the audit proof will return a list of hashes
+that demonstrate that leaf `10` is in the tree and hasn't been removed or altered.
+You can test it checking sum with hash head of the tree. Or use:
+
+
+    tree.audit_proof_build_head(audit_proof, data[10])   # => "<some long string of octets>"
+  
+  
+
+

data/lib/algorithm.rb

@@ -0,0 +1,95 @@
+module Merkle
+  module Algorithm
+    class << self
+      def merkle_tree(array, digest, &block)
+        # Define it here since we have to add &block and digest params to every method call (DRY..)
+        merkle_tree_method = -> (arg) { merkle_tree(arg, digest, &block) }
+
+        case array.size
+        when 1
+          return array.first
+        when 2
+          # This yeild for define audit_proof method. To build audit_proof_elements
+          # we have to know pair of <searching> elements, so case array.size = 2 is what actually need.
+          # Basicly we just need to handle this case and we will have a new audit_proof algorithm!
+          yield(array) if block_given?
+
+          return node_hash(digest, array.first, array.last)
+        else
+          cons = array.size.even? ? 2 : 1
+
+          merkle_tree_method.call(
+            [
+              merkle_tree_method.call(array[0...(array.size - cons)]),
+              merkle_tree_method.call(array[(array.size - cons)..])
+            ]
+          )
+        end
+      end
+
+      def audit_proof(array, index, digest = nil)
+        audit_proof_path = Array.new
+        element = array[index]
+
+        # This block is inside case with two elements.
+        # We have to handle pairs only with our element and add neibour of our element to the path
+        # Then we have to update our element
+        merkle_tree(array, digest) do |pair_of_elements|
+          if pair_of_elements.include?(element)
+            audit_proof_path << begin 
+              if pair_of_elements.first == element 
+                {
+                   position: 'right',
+                   value: pair_of_elements.last
+                }
+              else
+                {
+                  position: 'left',
+                  value: pair_of_elements.first
+                }
+              end
+            end
+  
+            element = node_hash(digest, pair_of_elements.first, pair_of_elements.last)
+          end
+        end
+  
+        audit_proof_path
+      end
+
+      # Culculate a head of tree using audit_proof path
+      def consistency_proof(array, index, digest = nil)
+        sub_array = array[0..index]
+
+        audit_proof(sub_array, index, digest).map{ |e| e[:value] }
+      end
+
+      # Culculate a head of tree using audit_proof path
+      # By this method we can verify is the element a part of the tree or not depends on returned head
+      def audit_proof_build_head(audit_proof_path, element, digest = nil) 
+        audit_proof_path.inject(element) do |element, node|
+          case node[:position]
+          when 'right'
+            node_hash(digest, element, node[:value])
+          when 'left'
+            node_hash(digest, node[:value], element)
+          end
+        end
+      end
+
+      # Culculate a head of sub-tree using consistency_proof path
+      # By this method we can verify is the tree includes sub-tree
+      def consistency_proof_build_head(consistency_proof_path, digest = nil) 
+        consistency_proof_path.inject('') do |result, consistency_path_element|
+          node_hash(digest, consistency_path_element, result)
+        end
+      end
+
+      private def node_hash(digest, hash1, hash2)
+        summary_hash = hash1 + hash2
+
+        digest ? digest.digest("\x01" + summary_hash) : summary_hash
+      end
+    end
+  end
+end

data/lib/hash_tree.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'algorithm'
+
+module Merkle
+  class HashTree
+    ALGORITHM_CLASS = Merkle::Algorithm
+
+    def initialize(incoming_data, digest = nil)
+      @algorithm     = ALGORITHM_CLASS
+      @digest        = digest
+      @incoming_data = incoming_data
+      @hashed_data   = incoming_data_to_hashes
+    end
+
+    attr_reader :hashed_data, :incoming_data, :digest, :algorithm, :head, :audit_proof,
+                :consistency_proof, :consistency_proof_head, :audit_proof_head
+
+    def head_build
+      @head =
+        algorithm.merkle_tree(hashed_data, digest)
+    end
+
+    def audit_proof_build(index)
+      @audit_proof =
+        algorithm.audit_proof(hashed_data, index, digest)
+    end
+
+    def audit_proof_build_head(audit_proof_path, element)
+      @audit_proof_head =
+        algorithm.audit_proof_build_head(audit_proof_path, element, digest)
+    end
+
+    def consistency_proof_build(index)
+      @consistency_proof =
+        algorithm.consistency_proof(hashed_data, index, digest)
+    end
+
+    def consistency_proof_build_head(consistency_proof_path)
+      @consistency_proof_head =
+        algorithm.consistency_proof_build_head(consistency_proof_path, digest)
+    end
+
+    private def incoming_data_to_hashes
+      digest ? incoming_data.map! { |el| digest.digest("\u0001#{el}") } : incoming_data
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Merkle
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: hash-merkle-tree
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- tavrelkate
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: Implementation of Hash Merkle Tree, audit and consistensy proofs
+email:
+- tavrelkate@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/algorithm.rb
+- lib/hash_tree.rb
+- lib/version.rb
+homepage: https://github.com/tavrelkate/hash-merkle-tree
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: Implementation of Hash Merkle Tree, audit and consistensy proofs
+test_files: []