immudb 0.1.0

data/lib/immudb/interceptor.rb

@@ -0,0 +1,31 @@
+# Copyright 2021 CodeNotary, Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#       http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Immudb
+  class Interceptor < GRPC::ClientInterceptor
+    attr_accessor :token
+
+    def request_response(request: nil, call: nil, method: nil, metadata: nil)
+      metadata["authorization"] = "Bearer #{token}" if token
+      begin
+        super
+      rescue GRPC::Unknown => e
+        raise Error, e.details
+      end
+    end
+
+    # hide token
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/immudb/kv.rb

@@ -0,0 +1,25 @@
+# Copyright 2021 CodeNotary, Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#       http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Immudb
+  class KV
+    def initialize(key, value)
+      @key = key
+      @value = value
+    end
+
+    def digest
+      valdigest = Digest::SHA256.digest(@value.nil? ? "" : @value)
+      Digest::SHA256.digest(@key + valdigest)
+    end
+  end
+end

data/lib/immudb/linear_proof.rb

@@ -0,0 +1,23 @@
+# Copyright 2021 CodeNotary, Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#       http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Immudb
+  class LinearProof
+    attr_reader :sourceTxID, :targetTxID, :terms
+
+    def initialize(sourceTxID, targetTxID, terms)
+      @sourceTxID = sourceTxID
+      @targetTxID = targetTxID
+      @terms = terms
+    end
+  end
+end

data/lib/immudb/root_service.rb

@@ -0,0 +1,36 @@
+# Copyright 2021 CodeNotary, Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#       http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Immudb
+  class RootService
+    def initialize
+      @dbname = nil
+      @cache = nil
+      @service = nil
+    end
+
+    def init(dbname, service)
+      @dbname = dbname
+      @service = service
+      state = @service.current_state(Google::Protobuf::Empty.new)
+      @cache = state
+    end
+
+    def get
+      @cache ||= @service.current_state(Google::Protobuf::Empty.new)
+    end
+
+    def set(root)
+      @cache = root
+    end
+  end
+end

data/lib/immudb/sql_result.rb

@@ -0,0 +1,15 @@
+module Immudb
+  class SqlResult
+    attr_reader :columns, :rows, :column_types
+
+    def initialize(columns, rows, column_types)
+      @columns = columns
+      @rows = rows
+      @column_types = column_types
+    end
+
+    def to_a
+      @rows.map { |r| @columns.zip(r).to_h }
+    end
+  end
+end

data/lib/immudb/state.rb

@@ -0,0 +1,26 @@
+# Copyright 2021 CodeNotary, Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#       http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Immudb
+  class State
+    # names must match Schema::ImmutableState
+    attr_reader :db, :txId, :txHash, :publicKey, :signature
+
+    def initialize(db:, txId:, txHash:, publicKey:, signature:)
+      @db = db
+      @txId = txId
+      @txHash = txHash
+      @publicKey = publicKey
+      @signature = signature
+    end
+  end
+end

data/lib/immudb/store.rb

@@ -0,0 +1,227 @@
+# Copyright 2021 CodeNotary, Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#       http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Immudb
+  class Store
+    class << self
+      def tx_from(stx)
+        entries = []
+        stx.entries.each do |e|
+          i = TXe.new
+          i.h_value = digest_from(e.hValue)
+          i.v_off = e.vOff
+          i.value_len = e.vLen.to_i
+          i.set_key(e.key)
+          entries << i
+        end
+        tx = new_tx_with_entries(entries)
+        tx.ID = stx.metadata.id
+        tx.PrevAlh = digest_from(stx.metadata.prevAlh)
+        tx.Ts = stx.metadata.ts
+        tx.BlTxID = stx.metadata.blTxId
+        tx.BlRoot = digest_from(stx.metadata.blRoot)
+        tx.build_hash_tree
+        tx.calc_alh
+        tx
+      end
+
+      def tx_metadata_from(txmFrom)
+        txm = TxMetadata.new
+        txm.iD = txmFrom.id
+        txm.prevAlh = digest_from(txmFrom.prevAlh)
+        txm.ts = txmFrom.ts
+        txm.nEntries = txmFrom.nentries.to_i
+        txm.eh = digest_from(txmFrom.eH)
+        txm.blTxID = txmFrom.blTxId
+        txm.blRoot = digest_from(txmFrom.blRoot)
+        txm
+      end
+
+      def encode_key(key)
+        SET_KEY_PREFIX + key
+      end
+
+      def encode_kv(key, value)
+        KV.new(SET_KEY_PREFIX + key, PLAIN_VALUE_PREFIX + value)
+      end
+
+      def encode_reference(key, referencedKey, atTx)
+        refVal = REFERENCE_VALUE_PREFIX + [atTx].pack("Q>") + SET_KEY_PREFIX + referencedKey
+        KV.new(SET_KEY_PREFIX + key, refVal)
+      end
+
+      def linear_proof_from(lp)
+        LinearProof.new(lp.sourceTxId, lp.TargetTxId, lp.terms)
+      end
+
+      def digest_from(sliced_digest)
+        sliced_digest[0, 32]
+      end
+
+      def digests_from(sliced_terms)
+        sliced_terms.map(&:dup)
+      end
+
+      def verify_inclusion(proof, digest, root)
+        return false if proof.nil?
+        leaf = LEAF_PREFIX + digest
+        calc_root = Digest::SHA256.digest(leaf)
+        i = proof.leaf
+        r = proof.width - 1
+        proof.terms.to_a.each do |t|
+          b = NODE_PREFIX
+          if i % 2 == 0 && i != r
+            b = b + calc_root + t
+          else
+            b = b + t + calc_root
+          end
+          calc_root = Digest::SHA256.digest(b)
+          i = i.div(2)
+          r = r.div(2)
+        end
+        i == r && root == calc_root
+      end
+
+      def verify_dual_proof(proof, sourceTxID, targetTxID, sourceAlh, targetAlh)
+        if proof.nil? || proof.sourceTxMetadata.nil? || proof.targetTxMetadata.nil? || proof.sourceTxMetadata.iD != sourceTxID || proof.targetTxMetadata.iD != targetTxID
+          return false
+        end
+        if proof.sourceTxMetadata.iD == 0 || proof.sourceTxMetadata.iD > proof.targetTxMetadata.iD
+          return false
+        end
+        if sourceAlh != proof.sourceTxMetadata.alh
+          return false
+        end
+        if targetAlh != proof.targetTxMetadata.alh
+          return false
+        end
+        if sourceTxID < proof.targetTxMetadata.blTxID && !verify_inclusion_aht(proof.inclusionProof, sourceTxID, proof.targetTxMetadata.blTxID, leaf_for(sourceAlh), proof.targetTxMetadata.blRoot)
+          return false
+        end
+        if proof.sourceTxMetadata.blTxID > 0 && !verify_consistency(proof.consistencyProof, proof.sourceTxMetadata.blTxID, proof.targetTxMetadata.blTxID, proof.sourceTxMetadata.blRoot, proof.targetTxMetadata.blRoot)
+          return false
+        end
+        if proof.targetTxMetadata.blTxID > 0 && !verify_last_inclusion(proof.lastInclusionProof, proof.targetTxMetadata.blTxID, leaf_for(proof.targetBlTxAlh), proof.targetTxMetadata.blRoot)
+          return false
+        end
+        if sourceTxID < proof.targetTxMetadata.blTxID
+          verify_linear_proof(proof.linearProof, proof.targetTxMetadata.blTxID, targetTxID, proof.targetBlTxAlh, targetAlh)
+        else
+          verify_linear_proof(proof.linearProof, sourceTxID, targetTxID, sourceAlh, targetAlh)
+        end
+      end
+
+      private
+
+      def new_tx_with_entries(entries)
+        tx = Tx.new
+        tx.ID = 0
+        tx.entries = entries
+        tx.nentries = entries.length
+        tx.htree = HTree.new(entries.length)
+        tx
+      end
+
+      def leaf_for(d)
+        b = LEAF_PREFIX + d
+        Digest::SHA256.digest(b)
+      end
+
+      def verify_inclusion_aht(iproof, i, j, iLeaf, jRoot)
+        if i > j || i == 0 || i < j && iproof.length == 0
+          return false
+        end
+        i1 = i - 1
+        j1 = j - 1
+        ciRoot = iLeaf
+        iproof.each do |h|
+          if i1 % 2 == 0 && i1 != j1
+            b = NODE_PREFIX + ciRoot + h
+          else
+            b = NODE_PREFIX + h + ciRoot
+          end
+          ciRoot = Digest::SHA256.digest(b)
+          i1 = i1 >> 1
+          j1 = j1 >> 1
+        end
+        jRoot == ciRoot
+      end
+
+      def verify_consistency(cproof, i, j, iRoot, jRoot)
+        if i > j || i == 0 || (i < j && cproof.length == 0)
+          return false
+        end
+        if i == j && cproof.length == 0
+          return iRoot == jRoot
+        end
+
+        fn = i - 1
+        sn = j - 1
+        while fn % 2 == 1
+          fn = fn >> 1
+          sn = sn >> 1
+        end
+        ciRoot, cjRoot = cproof[0], cproof[0]
+        cproof[1..-1].each do |h|
+          if fn % 2 == 1 || fn == sn
+            b = NODE_PREFIX + h + ciRoot
+            ciRoot = Digest::SHA256.digest(b)
+            b = NODE_PREFIX + h + cjRoot
+            cjRoot = Digest::SHA256.digest(b)
+            while fn % 2 == 0 && fn != 0
+              fn = fn >> 1
+              sn = sn >> 1
+            end
+          else
+            b = NODE_PREFIX + cjRoot + h
+            cjRoot = Digest::SHA256.digest(b)
+          end
+          fn = fn >> 1
+          sn = sn >> 1
+        end
+        iRoot == ciRoot && jRoot == cjRoot
+      end
+
+      def verify_last_inclusion(iproof, i, leaf, root)
+        if i == 0
+          return false
+        end
+        i1 = i - 1
+        iroot = leaf
+        iproof.each do |h|
+          b = NODE_PREFIX + h + iroot
+          iroot = Digest::SHA256.digest(b)
+          i1 >>= 1
+        end
+        root == iroot
+      end
+
+      def verify_linear_proof(proof, sourceTxID, targetTxID, sourceAlh, targetAlh)
+        if proof.nil? || proof.sourceTxID != sourceTxID || proof.targetTxID != targetTxID
+          return false
+        end
+
+        if proof.sourceTxID == 0 || proof.sourceTxID > proof.targetTxID || proof.terms.length == 0 || sourceAlh != proof.terms[0]
+          return false
+        end
+
+        calculatedAlh = proof.terms[0]
+        (1...proof.terms.length).each do |i|
+          bs = [proof.sourceTxID + i].pack("Q>") + calculatedAlh + proof.terms[i]
+          calculatedAlh = Digest::SHA256.digest(bs)
+        end
+
+        targetAlh == calculatedAlh
+      end
+    end
+  end
+end

data/lib/immudb/tx.rb

@@ -0,0 +1,56 @@
+# Copyright 2021 CodeNotary, Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#       http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Immudb
+  class Tx
+    attr_accessor :ID, :Ts, :BlTxID, :BlRoot, :PrevAlh, :nentries, :entries, :htree, :Alh
+
+    def build_hash_tree
+      digests = []
+      @entries.each do |e|
+        digests << e.digest
+      end
+      @htree.build_with(digests)
+    end
+
+    def calc_alh
+      calc_innerhash
+      bi = [@ID].pack("Q>") + @PrevAlh + @InnerHash
+      @Alh = Digest::SHA256.digest(bi)
+    end
+
+    def calc_innerhash
+      bj = [@Ts, @nentries].pack("Q>L>") + eh
+      bj += [@BlTxID].pack("Q>") + @BlRoot
+      @InnerHash = Digest::SHA256.digest(bj)
+    end
+
+    def eh
+      @htree.root
+    end
+
+    def proof(key)
+      kindex = nil
+      # find index of element holding given key
+      @entries.each_with_index do |v, k|
+        if v.key == key
+          kindex = k
+          break
+        end
+      end
+      if kindex.nil?
+        raise KeyError
+      end
+      @htree.inclusion_proof(kindex)
+    end
+  end
+end

data/lib/immudb/tx_metadata.rb

@@ -0,0 +1,26 @@
+# Copyright 2021 CodeNotary, Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#       http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Immudb
+  class TxMetadata
+    attr_accessor :iD, :prevAlh, :ts, :nEntries, :eh, :blTxID, :blRoot
+
+    def alh
+      bi = [@iD].pack("Q>") + @prevAlh
+      bj = [@ts.to_i, @nEntries.to_i].pack("Q>L>")
+      bj = bj + @eh + [@blTxID].pack("Q>") + @blRoot
+      inner_hash = Digest::SHA256.digest(bj)
+      bi = bi + inner_hash
+      Digest::SHA256.digest(bi)
+    end
+  end
+end

data/lib/immudb/txe.rb

@@ -0,0 +1,27 @@
+# Copyright 2021 CodeNotary, Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#       http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Immudb
+  class TXe
+    attr_accessor :key_len, :key, :value_len, :h_value, :v_off
+
+    def set_key(key)
+      @key = key.dup
+      @key_len = key.length
+    end
+
+    def digest
+      b = @key + @h_value
+      Digest::SHA256.digest(b)
+    end
+  end
+end

data/lib/immudb/version.rb

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

data/lib/immudb.rb

@@ -0,0 +1,35 @@
+# stdlib
+require "net/http"
+require "openssl"
+require "time"
+
+# grpc
+require "immudb/grpc/schema_pb"
+require "immudb/grpc/schema_services_pb"
+
+# modules
+require "immudb/client"
+require "immudb/constants"
+require "immudb/dual_proof"
+require "immudb/htree"
+require "immudb/inclusion_proof"
+require "immudb/interceptor"
+require "immudb/kv"
+require "immudb/linear_proof"
+require "immudb/root_service"
+require "immudb/sql_result"
+require "immudb/state"
+require "immudb/store"
+require "immudb/tx"
+require "immudb/tx_metadata"
+require "immudb/txe"
+require "immudb/version"
+
+module Immudb
+  class Error < StandardError; end
+  class VerificationError < Error
+    def message
+      "Verification failed"
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: immudb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-12-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: grpc
+  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'
+description:
+email: andrew@ankane.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/immudb.rb
+- lib/immudb/client.rb
+- lib/immudb/constants.rb
+- lib/immudb/dual_proof.rb
+- lib/immudb/grpc/schema_pb.rb
+- lib/immudb/grpc/schema_services_pb.rb
+- lib/immudb/htree.rb
+- lib/immudb/inclusion_proof.rb
+- lib/immudb/interceptor.rb
+- lib/immudb/kv.rb
+- lib/immudb/linear_proof.rb
+- lib/immudb/root_service.rb
+- lib/immudb/sql_result.rb
+- lib/immudb/state.rb
+- lib/immudb/store.rb
+- lib/immudb/tx.rb
+- lib/immudb/tx_metadata.rb
+- lib/immudb/txe.rb
+- lib/immudb/version.rb
+homepage: https://github.com/ankane/immudb-ruby
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key:
+specification_version: 4
+summary: Ruby client for immudb
+test_files: []