murky_waters 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: de7e1e125358b97341f115548b95ca34ab2ebc55
+  data.tar.gz: 840f25e5a769c54375602c0fe4f57963f74136ca
+SHA512:
+  metadata.gz: c96dcc782f362b34e515310fffd874e4bf6003f839f8f4e291f438583d3e4c739f7dec22b774475f12d455a8eb03c3c51110e9e63458634628875d24716e4d44
+  data.tar.gz: 639cba30e0f6060d756a7a0040fdf6adec676cbbee08f7cdd5e253fd13afd102ef50d44f9c226fc26ecc39f3b3726d1eb4d1ab4bc1d205215304dd72b2897a88

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at wouter@youdo.co.nz. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in murky_waters.gemspec
+gemspec

data/README.md

@@ -0,0 +1,131 @@
+# MurkyWaters
+
+MurkyWaters is a simple implementation of a merkle tree backed dictionary.
+
+You can use this as an you would any ordinary dictionary structure with the added functionality
+that you can generate verifiable proofs of the dictionary structure and presence of leaf nodes in the dictionary. Proofs for individual leaves can exist with zero-knowledge of the contents of other leaves in the dictionary.
+
+In short, this can allow you to provide proof of knowledge of some subset of a larger set of data without leaking any information.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'murky_waters'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install murky_waters
+
+## Usage
+
+To construct a new Merkle tree backed ordered dictionary
+
+### Basics
+```ruby
+    # A new, empty Merkle tree dictionary
+    dict = Murky::Dict()
+
+    # Specify a custom backing dictionary, default implementation is Hash
+    dict = Murky::Dict(data: acts_like_a_dictionary)
+
+    # Specify a custom digest class, must #respond_to?(:digest)
+    dict = Murky::Dict(digest: Digest::SHA256)
+```
+
+To accesss, add and remove data to be indexed in our dict
+
+```ruby
+  dict["hello"] = "world"  # Add data
+  dict.delete("hello")     # Delete data
+  dict["hello"]            # Retrieve data
+  dict.siblings("hello")   # => [
+                           #  "OLpNd02wZa5e2XMKG/8rFMUKFVUq/yy6F+c3Rd09eKc=\n",
+                           #  "GySoYGQjpOMz62o7F56Al67mVjB9IP5GxpBmbQvp3wc=\n"
+                           # ]
+
+  dict.root                # "anajKi18I3C9TlVEcU//hZsw9i4sknlYCTspTQXxCr0=\n" # The merkle root/signature of our entire dictionary contents
+```
+
+### Proofs
+```ruby
+  # Generate a proof that "hello" exists inside of our dictionary and a merkle root/signature for our entire dictionary contents
+  dict.proof("hello")
+  #  => #<Murky::Proof:0x007f9d1ef5c810
+  # @digest=
+  #  #<Digest::SHA256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855>,
+  # @root="anajKi18I3C9TlVEcU//hZsw9i4sknlYCTspTQXxCr0=\n",
+  # @siblings=
+  #  ["47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\n",
+  #   "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\n",
+  #   "qZDReXdlGqrjRUZy3nSfWXY6y8KYxwb+A7K6/Xg7Nxc=\n",
+  #   "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\n",
+  #   "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\n",
+  #   "jqwjgWe5ZVi9USkRcycxwiXtFtSLbycfKHJRJ8Scm3A=\n",
+  #   "ujOfV44N03rF/+m6+eONFRPJYmstEnhsh2YcKdIUyVU=\n"],
+  # @valid=true>
+```
+### Verification
+```ruby
+  # Perform a verification for a root, and a merkle path/sibling list and some value.
+  It verifies that this value resides in the dictionary represented by our root signature. From this we can conclude that the size, shape and order of the tree for this merkle root are unchanged from when this proof was generated and that our value does indeed exist within the dictionary.
+
+  # Murky.verify(root, siblings, value) # => true/false
+  Murky.verify(
+    "EpU7Zx9tzTCGGyQtNQgC5Iu8IxRlXFjwG7KCjqfuRwI=\n",
+    [
+      "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\n",
+      "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\n",
+      "qZDReXdlGqrjRUZy3nSfWXY6y8KYxwb+A7K6/Xg7Nxc=\n",
+      "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\n",
+      "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\n",
+      "jqwjgWe5ZVi9USkRcycxwiXtFtSLbycfKHJRJ8Scm3A=\n",
+      "ujOfV44N03rF/+m6+eONFRPJYmstEnhsh2YcKdIUyVU=\n"
+    ],
+    "world"
+  ) # => true if verification passes
+```
+A tree can optionally be backed by any dictionary like data structure to store the real leaf data.
+The prerequisites of this structure are that:
+  * It is hash-like (implements #[]= and #[])
+  * It is ordered
+  * It implements #keys
+  * It implements #values
+
+You can pass this structure into the constuctor of the Murky::Dict. E.g
+
+```ruby
+Murky::Dict(data: {foo: :bar})
+```
+### Saving and restoring proofs
+
+Proofs can be saved to, and restored from a file.
+E.g
+
+```ruby
+  dict.proof(:my_value).output("/Users/pico/Desktop/proof.txt")
+
+  proof = Murky::Proof.from_file("/Users/pico/Desktop/proof.txt")
+  proof.valid? #=> true
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wouterken/murky_waters. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Code of Conduct
+
+Everyone interacting in the MurkyWaters project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/murky_waters/blob/master/CODE_OF_CONDUCT.md).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "murky"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/murky/dict.rb

@@ -0,0 +1,100 @@
+module Murky
+  class Dict
+    attr_reader :root
+
+    def initialize(data: {}, digest: Digest::SHA256.new)
+      @root    = nil
+      @digest  = digest
+      @changed = !data.size.zero?
+      define_singleton_method(:data, ->{data})
+    end
+
+    def keys
+      data.keys
+    end
+
+    def values
+      data.values
+    end
+
+    def include?(key)
+      data.include?(key)
+    end
+
+    def height
+      Math.ceil(Math.log(@size, 2))
+    end
+
+    def sign(value)
+      @digest.digest(value.to_s)
+    end
+
+    def []=(key, value)
+      @changed = true
+      data[key] = value
+    end
+
+    def [](key)
+      data[key]
+    end
+
+    def delete(key)
+      @changed = true
+      data.delete(key)
+    end
+
+    def root
+      @root = @changed ? compute_root : @root
+    end
+
+    def proof(key)
+      Proof.new({
+        root:      root,
+        siblings:  siblings(key),
+        signature: sign(data[key]),
+        digest:    @digest
+      })
+    end
+
+    def siblings(key)
+      return [] if !include?(key)
+      signature = sign(data[key])
+      siblings = []
+      compute_root do |left_sig, right_sig|
+        case
+        when left_sig  === signature then siblings << right_sig
+        when right_sig === signature then siblings << left_sig
+        else next
+        end
+        signature = sign(Murky.xor(left_sig,right_sig))
+      end
+      return siblings
+    end
+
+    def to_s
+      "Murky::Dict(#{data.to_s})"
+    end
+
+    def inspect
+      "Murky::Dict(#{data.inspect})"
+    end
+
+    private
+      def compute_root(values=self.values, from_bottom=0, &block)
+        if values.length == 1
+          @changed = false
+          return sign(values[0])
+        end
+        compute_root(values.each_slice(2).map do |left, right|
+          ls, rs = sign(left),sign(right)
+          block[ls, rs] if block_given?
+          Murky.xor(ls, rs)
+        end, from_bottom + 1, &block)
+      end
+  end
+
+  module_function
+    def Dict(*args)
+      Dict.new(*args)
+    end
+end

data/lib/murky/proof.rb

@@ -0,0 +1,53 @@
+module Murky
+  class Proof
+    attr_reader :root, :siblings, :signature
+
+    FILE_HEADER  = "#{?= * 20} BEGIN MURKY PROOF #{?= * 20} "
+    FILE_FOOTER  = "#{?= * 20} BEGIN MURKY PROOF #{?= * 20} "
+    INPUT_REGEXP = %r{#{FILE_HEADER}\n(.*?)\n#{FILE_FOOTER}}m
+
+    def initialize(root:, siblings:, signature:, digest:)
+      @digest    = digest
+      @root      = root
+      @siblings  = siblings
+      @signature = signature
+      @valid = root == siblings.reduce(signature) do |mem, sibling|
+        sign Murky.xor(mem,sibling)
+      end
+    end
+
+    def sign(value)
+      @digest.digest(value.to_s)
+    end
+
+    def valid?
+      @valid
+    end
+
+    def self.base64_encode(value)
+      Base64.encode64(value)
+    end
+
+    def self.base64_decode(value)
+      Base64.decode64(value)
+    end
+
+    def output(filename)
+      IO.write(
+        filename,
+        "#{FILE_HEADER}\n" <<
+        (
+          [self.class.base64_encode(root)] +
+          siblings.map(&self.class.method(:base64_encode)) +
+          [self.class.base64_encode(@signature)]
+        ).join <<
+        "#{FILE_FOOTER}"
+      )
+    end
+
+    def self.from_file(filename, digest: Digest::SHA256)
+      root, *siblings, signature = IO.read(filename)[INPUT_REGEXP, 1].split("\n").map(&method(:base64_decode))
+      Murky::Proof.new(root: root, siblings: siblings, signature: signature, digest: digest)
+    end
+  end
+end

data/lib/murky/version.rb

@@ -0,0 +1,3 @@
+module Murky
+  VERSION = "0.1.0"
+end

data/lib/murky.rb

@@ -0,0 +1,23 @@
+require 'murky/version'
+require 'murky/dict'
+require 'murky/proof'
+require 'base64'
+
+module Murky
+  module_function
+    def verify(root, siblings, value, digest: Digest::SHA256.new)
+      Proof.new(
+        root: root,
+        siblings: siblings,
+        signature: digest.digest(value.to_s),
+        digest: digest
+      ).valid?
+    end
+
+    def xor(s1, s2)
+      s2, s1 = [s1, s2].sort_by(&:bytesize)
+      s1.bytes.zip(s2.bytes).map do |x,y|
+        ((x || 0) ^ (y || 0)).chr
+      end.join
+    end
+end

data/murky_waters.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "murky/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "murky_waters"
+  spec.version       = Murky::VERSION
+  spec.authors       = ["Wouter Coppieters"]
+  spec.email         = ["wouter@youdo.co.nz"]
+
+  spec.summary       = "Merkle Tree backed Dictionary"
+  spec.description   = "A simple implementation of a Merkle Tree backed Dictionary"
+  spec.homepage      = "https://github.com/wouterken/murky_waters"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # spec.metadata["allowed_push_host"] = "http://mygemserver.com"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency "pry"
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~>5.8.4"
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: murky_waters
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wouter Coppieters
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.8.4
+description: A simple implementation of a Merkle Tree backed Dictionary
+email:
+- wouter@youdo.co.nz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/murky.rb
+- lib/murky/dict.rb
+- lib/murky/proof.rb
+- lib/murky/version.rb
+- murky_waters.gemspec
+homepage: https://github.com/wouterken/murky_waters
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Merkle Tree backed Dictionary
+test_files: []