veriform 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d487a0eb69dec625c5b1a3504ca9efbcc13f2ec2
+  data.tar.gz: 1bb60e85054d6c70f692ccdc33311faac9bf57e7
+SHA512:
+  metadata.gz: a36d7843ddb5fbb7dc80f48f396f00f0e11972a130c37e6334f56e2f9bc333854117ae7a7639e6a84a6d988ba663ac77195eb7ecf58d5cb2907ad0e94da66a45
+  data.tar.gz: 06f7d19d295d31c700b42a9463cf384015a014145712fec5e1638d9598e32a662b153c6473663497851e2e5d7c7f3dd33fda0a8a86d944211af2f085ea738e17

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.rakeTasks
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--format=documentation
+--order random
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,40 @@
+AllCops:
+  DisplayCopNames: true
+
+#
+# Style
+#
+
+Style/ModuleFunction:
+  Enabled: false
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+#
+# Metrics
+#
+
+Metrics/AbcSize:
+  Max: 30
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Max: 100
+
+Metrics/CyclomaticComplexity:
+  Max: 25
+
+Metrics/LineLength:
+  Max: 128
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/PerceivedComplexity:
+  Max: 25

data/.ruby-version

@@ -0,0 +1 @@
+2.4.1

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+ruby RUBY_VERSION
+
+gemspec
+
+group :development, :test do
+  gem "benchmark-ips"
+  gem "guard-rspec"
+  gem "rake"
+  gem "rspec", "~> 3.5"
+  gem "rubocop", "0.49.1"
+  gem "tjson", "~> 0.5"
+end

data/Guardfile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, cmd: "GUARD_RSPEC=1 bundle exec rspec --no-profile" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper)  { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/README.md

@@ -0,0 +1,76 @@
+# veriform.rb [![Latest Version][gem-shield]][gem-link] [![Build Status][build-image]][build-link] [![MIT licensed][license-image]][license-link]
+
+[gem-shield]: https://badge.fury.io/rb/veriform.svg
+[gem-link]: https://rubygems.org/gems/veriform
+[build-image]: https://secure.travis-ci.org/zcred/veriform.svg?branch=master
+[build-link]: http://travis-ci.org/zcred/veriform
+[license-image]: https://img.shields.io/badge/license-MIT-blue.svg
+[license-link]: https://github.com/zcred/veriform/blob/master/LICENSE.txt
+
+Ruby implementation of **Veriform**: a cryptographically verifiable data
+serialization format inspired by Protocol Buffers, useful for things like
+credentials, transparency logs, and "blockchain" applications.
+
+For more information, see the [toplevel README.md].
+
+[toplevel README.md]: https://github.com/zcred/veriform/blob/master/README.md
+
+## Help and Discussion
+
+Have questions? Want to suggest a feature or change?
+
+* [Gitter]: web-based chat about zcred projects including **Veriform**
+* [Google Group]: join via web or email ([zcred+subscribe@googlegroups.com])
+
+[Gitter]: https://gitter.im/zcred/Lobby
+[Google Group]: https://groups.google.com/forum/#!forum/zcred
+[zcred+subscribe@googlegroups.com]: mailto:zcred+subscribe@googlegroups.com
+
+## Requirements
+
+This library is tested against the following MRI versions:
+
+- 2.2
+- 2.3
+- 2.4
+
+Other Ruby versions may work, but are not officially supported.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "veriform"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install veriform
+
+## API
+
+### Veriform.parse
+
+To parse a **veriform** message, use the `Veriform.parse` method:
+
+```ruby
+>> Veriform.parse("\x15\x07\x02\x03\x55".b)
+=> {1=>{24=>42}}
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/zcred/veriform
+
+## Copyright
+
+Copyright (c) 2017 [The Zcred Developers][AUTHORS].
+See [LICENSE.txt] for further details.
+
+[AUTHORS]: https://github.com/zcred/zcred/blob/master/AUTHORS.md
+[LICENSE.txt]: https://github.com/zcred/veriform/blob/master/LICENSE.txt

data/Rakefile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new
+
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+
+task default: %w[spec rubocop]
+
+task :bench do
+  require "benchmark/ips"
+  require "veriform"
+
+  Benchmark.ips do |b|
+    input = "\xE9\xF4\x81\x80\x80\x80@".dup.force_encoding("BINARY").freeze
+
+    b.report("vint64 encode") { Veriform::Varint.encode(281_474_976_741_993) }
+    b.report("vint64 decode") { Veriform::Varint.decode(input) }
+
+    b.compare!
+  end
+end

data/lib/veriform.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "veriform/version"
+require "veriform/exceptions"
+
+require "veriform/decoder"
+require "veriform/object"
+require "veriform/parser"
+require "veriform/varint"
+require "veriform/zhash"
+
+# Cryptographically verifiable data serialization format inspired by Protocol Buffers
+module Veriform
+  # Parse the given self-describing Veriform message
+  #
+  # @param message [String] binary encoded Veriform message
+  #
+  # @return [Veriform::Object] `::Hash`-like object representing message
+  def self.parse(message)
+    parser = Veriform::Parser.new(Veriform::Decoder.new)
+    parser.parse(message)
+    parser.finish
+  end
+end

data/lib/veriform/decoder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Veriform
+  # Build Veriform::Objects from Veriform's self-describing messages
+  class Decoder
+    # Create a new decoder object which will construct a Veriform::Object tree
+    def initialize
+      @stack = [Veriform::Object.new]
+    end
+
+    # Add a uint64 to the current object
+    def uint64(id, value)
+      raise TypeError, "expected Integer, got #{value.class}" unless value.is_a?(Integer)
+      @stack.last[id] = value
+    end
+
+    # Add binary data to the current object
+    def binary(id, value)
+      raise TypeError, "expected String, got #{value.class}" unless value.is_a?(String)
+      raise EncodingError, "expected BINARY encoding, got #{value.encoding}" unless value.encoding == Encoding::BINARY
+      @stack.last[id] = value
+    end
+
+    # Push down the internal stack, constructing a new Veriform::Object
+    def begin_nested
+      @stack << Veriform::Object.new
+    end
+
+    # Complete the pushdown, adding the newly constructed object to the next one in the stack
+    def end_nested(id)
+      value = @stack.pop
+      raise StateError, "not inside a nested message" if @stack.empty?
+      @stack.last[id] = value
+    end
+
+    # Finish decoding, returning the parent Veriform::Object
+    def finish
+      result = @stack.pop
+      raise StateError, "objects remaining in stack" unless @stack.empty?
+      result
+    end
+  end
+end

data/lib/veriform/exceptions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Veriform
+  # Base class of all Veriform errors
+  Error = Class.new(StandardError)
+
+  # Generic parse error
+  ParseError = Class.new(Error)
+
+  # Data is not in the correct character encoding
+  EncodingError = Class.new(ParseError)
+
+  # Unexpected end of input
+  TruncatedMessageError = Class.new(ParseError)
+
+  # Message is larger than our maximum configured size
+  OversizeMessageError = Class.new(ParseError)
+
+  # Nested message structure is too deep
+  DepthError = Class.new(ParseError)
+
+  # Parser is in the wrong state to perform the given task
+  StateError = Class.new(ParseError)
+
+  # Field repeated in message
+  DuplicateFieldError = Class.new(ParseError)
+end

data/lib/veriform/object.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Veriform
+  # Key/value pairs ala JSON objects or Protobuf messages
+  class Object
+    extend Enumerable
+    extend Forwardable
+
+    # Delegate certain Hash functions to the underlying hash
+    def_delegators :@fields, :each, :keys
+
+    # Create a Veriform::Object from a TJSON::Object
+    def self.from_tjson(obj)
+      raise TypeError, "expected TJSON::Object, got #{obj.class}" unless obj.is_a?(TJSON::Object)
+
+      new.tap do |result|
+        obj.each do |key, value|
+          result[Integer(key, 10)] = value.is_a?(TJSON::Object) ? from_tjson(value) : value
+        end
+      end
+    end
+
+    # Create a new Veriform::Object
+    #
+    # @return [Veriform::Object]
+    def initialize
+      @fields = {}
+    end
+
+    # Retrieve the value associated with a field identifier in a Veriform::Object
+    #
+    # @param key [Integer] field identifier
+    #
+    # @return [Object] value associated with this key
+    def [](key)
+      @fields[key]
+    end
+
+    # Sets the value associated with a field identifier
+    #
+    # @param key [Integer] field identifier
+    # @param value [Object] value associated with the given key
+    #
+    # @raise [TypeError] non-Integer key given
+    # @raise [Veriform::DuplicateFieldError] attempt to set field that's already been set
+    #
+    # @return [Object] newly set value
+    def []=(key, value)
+      raise TypeError, "key must be an integer: #{key.inspect}" unless key.is_a?(Integer)
+      raise RangeError, "key must be positive: #{key.inspect}" if key < 0
+      raise DuplicateFieldError, "duplicate field ID: #{key}" if @fields.key?(key)
+
+      @fields[key] = value
+    end
+
+    # Return a hash representation of this object (and its children).
+    # This is akin to an `#as_json` method as seen in e.g. Rails.
+    #
+    # @return [Hash] a hash representation of this object
+    def to_h
+      result = {}
+
+      @fields.each do |k, v|
+        result[k] = v.is_a?(self.class) ? v.to_h : v
+      end
+
+      result
+    end
+
+    # Compare two Veriform::Objects by value for equality
+    def eql?(other)
+      return false unless other.is_a?(self.class)
+      return false unless keys.length == other.keys.length
+
+      keys.each do |key|
+        return false unless self[key].eql?(other[key])
+      end
+
+      true
+    end
+
+    alias == eql?
+  end
+end

data/lib/veriform/parser.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Veriform
+  # Parses encoded Veriform messages, invoking callbacks in the given handler
+  # (i.e. this is a "push parser" which supports different backends)
+  class Parser
+    # Default maximum length of a Veriform message. This is a conservative choice
+    # as Veriform's main intended use is a credential format.
+    MAX_LENGTH = 1024
+
+    # Default maximum depth (i.e. number of levels of child objects)
+    MAX_DEPTH = 8
+
+    # Create a new message parser with the given parse event handler
+    def initialize(handler, max_length = MAX_LENGTH, max_depth = MAX_DEPTH)
+      @handler = handler
+      @max_length = max_length
+      @max_depth = max_depth
+      @remaining = []
+    end
+
+    # Parse the given Veriform message, invoking callbacks as necessary
+    def parse(msg)
+      raise OversizeMessageError, "length #{msg.length} exceeds max of #{@max_length}" if msg.length > @max_length
+      raise EncodingError, "expected BINARY encoding, got #{msg.encoding}" unless msg.encoding == Encoding::BINARY
+      @remaining << msg
+
+      raise DepthError, "exceeded max depth of #{@max_depth}" if @remaining.size > @max_depth
+
+      until @remaining.last.empty?
+        id, wiretype = parse_field_prefix
+
+        case wiretype
+        when 0 then parse_uint64(id)
+        when 2 then parse_message(id)
+        when 3 then parse_binary(id)
+        else raise ParseError, "unknown wiretype: #{wiretype.inspect}"
+        end
+      end
+
+      @remaining.pop
+
+      true
+    end
+
+    # Finish parsing, returning the resulting object produced by the builder
+    def finish
+      @handler.finish
+    end
+
+    private
+
+    # Parse a varint which also stores a wiretype
+    def parse_field_prefix
+      result, remaining = Veriform::Varint.decode(@remaining.pop)
+      @remaining << remaining
+      wiretype = result & 0x7
+      [result >> 3, wiretype]
+    end
+
+    # Parse an unsigned 64-bit integer
+    def parse_uint64(id)
+      value, remaining = Veriform::Varint.decode(@remaining.pop)
+      @remaining << remaining
+      @handler.uint64(id, value)
+    end
+
+    # Parse a data type stored with a length prefix
+    def parse_length_prefixed_data
+      length, remaining = Veriform::Varint.decode(@remaining.pop)
+      raise TruncatedMessageError, "not enough bytes remaining in input" if remaining.bytesize < length
+      data = remaining.byteslice(0, length)
+      @remaining << remaining.byteslice(length, remaining.bytesize - length)
+      data
+    end
+
+    # Parse a nested message
+    def parse_message(id)
+      @handler.begin_nested
+      parse(parse_length_prefixed_data)
+      @handler.end_nested(id)
+    end
+
+    # Parse length-prefixed binary data
+    def parse_binary(id)
+      @handler.binary(id, parse_length_prefixed_data)
+    end
+  end
+end

data/lib/veriform/varint.rb

@@ -0,0 +1,106 @@
+# encoding: binary
+# frozen_string_literal: true
+
+module Veriform
+  # Little Endian 64-bit Unsigned Prefix Varints
+  module Varint
+    # Maximum value we can encode as a vint64
+    MAX = (2**64) - 1
+
+    # :nodoc: Lookup table for the number of trailing zeroes in a byte
+    CTZ_TABLE = [8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0].freeze
+
+    # Encode the given unsignedinteger value as a vint64
+    #
+    # @param value [Integer] unsigned integer value to encode as a vint64
+    #
+    # @raise [TypeError] non-integer value given
+    # @raise [ArgumentError] value outside the unsigned 64-bit integer range
+    #
+    # @return [String] serialized vint64 value
+    def self.encode(value)
+      raise TypeError, "value must be an Integer" unless value.is_a?(Integer)
+      raise ArgumentError, "value must be zero or greater" if value < 0
+      raise ArgumentError, "value must be in the 64-bit unsigned range" if value > MAX
+
+      length = 1
+      result = (value << 1) | 1
+      max = 1 << 7
+
+      while value >= max
+        # 9-byte special case
+        return [0, value].pack("CQ<") if length == 8
+
+        result <<= 1
+        max <<= 7
+        length += 1
+      end
+
+      [result].pack("Q<")[0, length].force_encoding(Encoding::BINARY)
+    end
+
+    # Decode a vint64-serialized value into an unsignedinteger
+    #
+    # @param input [String] serialized vint64 to decode
+    #
+    # @raise [TypeError] non-String input given
+    # @raise [ArgumentError] empty input given
+    #
+    # @return [Array<Integer, String>] decoded integer and remaining data
+    def self.decode(input)
+      raise TypeError, "input must be a String" unless input.is_a?(String)
+      raise ArgumentError, "input cannot be empty" if input.empty?
+
+      prefix = input.getbyte(0)
+      input_len = input.bytesize
+
+      # 9-byte special case
+      if prefix.zero?
+        raise TruncatedMessageError, "not enough bytes to decode varint" if input_len < 9
+        length = 9
+        result = decode_le64(input[1, 8])
+      else
+        # Count trailing zeroes
+        length = CTZ_TABLE[prefix] + 1
+        result = decode_le64(input[0, length]) >> length
+        raise TruncatedMessageError, "not enough bytes to decode varint" if input_len < length
+      end
+
+      if length > 1 && result < (1 << (7 * (length - 1)))
+        raise ParseError, "malformed varint"
+      end
+
+      [result, input.byteslice(length, input_len - length)]
+    end
+
+    class << self
+      private
+
+      # Decode a little endian integer (without allocating memory, unlike pack)
+      def decode_le64(bytes)
+        result = 0
+
+        (bytes.bytesize - 1).downto(0) do |i|
+          result = (result << 8) | bytes.getbyte(i)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/veriform/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Veriform
+  VERSION = "0.0.0"
+end

data/lib/veriform/zhash.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Veriform
+  # Computes astructured hash of a Veriform message
+  class Zhash
+    # One character "tag" values used to separate zhash domains
+    module Tags
+      # "Objects" represent Veriform messages
+      OBJECT = "O"
+
+      # 8-bit clean binary data
+      BINARY = "d"
+
+      # 64-bit unsigned integers
+      UINT64 = "u"
+    end
+
+    # By default we compute zhashes using SHA-256
+    DEFAULT_HASH_ALGORITHM = Digest::SHA256
+
+    # Calculate the zhash digest of the given object
+    #
+    # @param algorithm [Class] a class which behaves like a `Digest`
+    #
+    # @return [String] bytestring containing the resulting digest
+    def self.digest(object, algorithm: DEFAULT_HASH_ALGORITHM)
+      new(algorithm: algorithm).digest(object)
+    end
+
+    # Calculate an object's zhash digest, hex encoding the result.
+    # Takes the same parameters as `Veriform::Zhash.digest`
+    #
+    # @return [String] hex encoded string containing the resulting digest
+    def self.hexdigest(object, **args)
+      digest(object, **args).unpack("H*").first
+    end
+
+    # Create a new `Zhash` instance
+    #
+    # @param algorithm [Class] a class which behaves like a `Digest` (i.e. implements `reset`, `update`, `digest`)
+    #
+    # @return [Veriform::Zhash]
+    def initialize(algorithm: DEFAULT_HASH_ALGORITHM)
+      @algorithm = algorithm
+      @hasher = algorithm.new
+    end
+
+    # Compute the zhash of any object allowed in a Veriform message
+    #
+    # @param object [Veriform::Object, String, Integer] object to compute a Zhash from
+    #
+    # @return [String] bytestring containing the resulting digest
+    def digest(object)
+      case object
+      when Veriform::Object, Hash then object_digest(object)
+      when String then binary_digest(object)
+      when Integer then uint64_digest(object)
+      else raise TypeError, "can't compute zhash of #{object.class}"
+      end
+    end
+
+    # Calculate an object's zhash digest, hex encoding the result.
+    # Takes the same parameters as `Veriform::Zhash#digest`
+    #
+    # @return [String] hex encoded string containing the resulting digest
+    def hexdigest(object)
+      digest(object).unpack("H*").first
+    end
+
+    private
+
+    # Compute digest of a `Veriform::Object`
+    def object_digest(message)
+      hasher = @algorithm.new
+      hasher.update Tags::OBJECT
+
+      message.keys.sort.each do |key|
+        hasher.update(encode_uint64(key))
+        hasher.update(digest(message[key]))
+      end
+
+      hasher.digest
+    end
+
+    # Compute digest of a bytestring
+    def binary_digest(bytes)
+      raise EncodingError, "expected BINARY encoding, got #{value.encoding}" unless bytes.encoding == Encoding::BINARY
+      compute_tagged_digest(Tags::BINARY, bytes)
+    end
+
+    # Compute digest of an `Integer`
+    def uint64_digest(value)
+      compute_tagged_digest(Tags::UINT64, encode_uint64(value))
+    end
+
+    # Compute a hash of the given bytes, tweaking the first byte of the
+    # resulting digest with the given domain separator tag.
+    def compute_tagged_digest(tag, bytes)
+      raise ArgumentError, "tag must be 1-byte" if tag.bytesize != 1
+      @hasher.reset
+      @hasher.update(tag)
+      @hasher.update(bytes)
+      @hasher.digest
+    end
+
+    # Encode a uin64 value as little endian
+    #
+    # @param value [Integer] a positive, up-to-64-bit integer value
+    #
+    # @return [String] a bytestring containing a little endian-encoded value
+    def encode_uint64(value)
+      raise TypeError, "expected Integer, got #{value.class}" unless value.is_a?(Integer)
+      raise RangeError, "integer value must be positive" if value < 0
+      raise RangeError, "integer value exceeds 2**64-1" if value > 18_446_744_073_709_551_615
+      [value].pack("Q<")
+    end
+  end
+end

data/veriform.gemspec

@@ -0,0 +1,28 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "veriform/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "veriform"
+  spec.version       = Veriform::VERSION
+  spec.authors       = ["Tony Arcieri"]
+  spec.email         = ["bascule@gmail.com"]
+  spec.summary       = "Cryptographically verifiable data serialization format inspired by Protocol Buffers"
+  spec.description   = <<-DESCRIPTION.strip.gsub(/\s+/, " ")
+    Cryptographically verifiable data serialization format inspired by Protocol Buffers,
+    useful for things like credentials, transparency logs, and blockchain applications.
+    Misuse-resistant symmetric encryption using the AES-SIV (RFC 5297)
+  DESCRIPTION
+  spec.homepage      = "https://github.com/zcred/veriform/tree/master/ruby/"
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.2.2"
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: veriform
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Tony Arcieri
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+description: Cryptographically verifiable data serialization format inspired by Protocol
+  Buffers, useful for things like credentials, transparency logs, and blockchain applications.
+  Misuse-resistant symmetric encryption using the AES-SIV (RFC 5297)
+email:
+- bascule@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- lib/veriform.rb
+- lib/veriform/decoder.rb
+- lib/veriform/exceptions.rb
+- lib/veriform/object.rb
+- lib/veriform/parser.rb
+- lib/veriform/varint.rb
+- lib/veriform/version.rb
+- lib/veriform/zhash.rb
+- veriform.gemspec
+homepage: https://github.com/zcred/veriform/tree/master/ruby/
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Cryptographically verifiable data serialization format inspired by Protocol
+  Buffers
+test_files: []