cryptoconditions_ruby 0.5.1

data/lib/cryptoconditions_ruby/crypto.rb

@@ -0,0 +1,168 @@
+require 'base64'
+require 'base32'
+require 'rbnacl'
+
+module CryptoconditionsRuby
+  module Crypto
+    def self.get_encoder(encoding)
+      case encoding
+      when 'base58' then Base58Encoder
+      when 'base64' then Base64Encoder
+      when 'base32' then Base32Encoder
+      when 'base16' then Base16Encoder
+      when 'hex' then HexEncoder
+      when 'bytes' then RawEncoder
+      else
+        raise Exceptions::UnknownEncodingError, 'Unknown or unsupported encoding'
+      end
+    end
+
+    module Helpers
+      def ed25519_generate_key_pair
+        sk = Ed25519SigningKey.generate
+        private_value_base58 = sk.encode('base58')
+        public_value_compressed_base58 = sk.get_verifying_key.encode('base58')
+        [private_value_base58, public_value_compressed_base58]
+      end
+
+      def base64_add_padding(data)
+        data = data.encode('utf-8') if data.is_a?(String)
+        missing_padding = (4 - data.length) % 4
+        data += '=' * missing_padding if missing_padding
+        data
+      end
+
+      def base64_remove_padding(data)
+        data = data.encode('utf-8') if data.is_a?(String)
+        data.sub(/=+\Z/, '')
+      end
+    end
+
+    class Base58Encoder
+      def encode(data)
+        CryptoconditionsRuby::Utils::Base58.encode(data)
+      end
+
+      def decode(data)
+        CryptoconditionsRuby::Utils::Base58.decode(data)
+      end
+    end
+
+    class Base64Encoder
+      def encode(data)
+        Base64.encode64(data).strip
+      end
+
+      def decode(data)
+        Base64.decode64(data)
+      end
+    end
+
+    class Base32Encoder
+      def encode(data)
+        Base32.encode(data)
+      end
+
+      def decode(data)
+        Base32.decode(data)
+      end
+    end
+
+    class Base16Encoder
+      def encode(data)
+        CryptoconditionsRuby::Utils::Base16.encode(data)
+      end
+
+      def decode(data)
+        CryptoconditionsRuby::Utils::Base16.decode(data)
+      end
+    end
+
+    class HexEncoder
+      def encode(data)
+        data.to_s.unpack('H*')[0]
+      end
+
+      def decode(data)
+        [data].pack('H*')
+      end
+    end
+
+    class RawEncoder
+      def encode(data)
+        data
+      end
+
+      def decode(data)
+        data
+      end
+    end
+
+    class Ed25519SigningKey < ::RbNaCl::SigningKey
+      CryptoKeypair = Struct.new(:private_key, :public_key)
+
+      attr_accessor :key, :encoder, :encoding
+      private :key, :encoder, :encoding
+
+      def initialize(key = nil, encoding = nil)
+        @key = key
+        @encoding = encoding || 'base58'
+        @encoder = Crypto.get_encoder(@encoding)
+        super(@encoder.new.decode(@key))
+      end
+
+      def self.generate
+        encoder = Base58Encoder.new
+        new(encoder.encode(::RbNaCl::Random.random_bytes(RbNaCl::Signatures::Ed25519::SEEDBYTES)))
+      end
+
+      def get_verifying_key
+        Ed25519VerifyingKey.new(encoder.new.encode(verify_key.to_s), encoding)
+      end
+
+      def sign(data, encoding = nil)
+        encoder = Crypto.get_encoder(encoding || 'base58')
+        encoder.new.encode(super(data))
+      end
+
+      def encode(encoding = 'base58')
+        encoder = Crypto.get_encoder(encoding).new
+        encoder.encode(self.to_s)
+      end
+
+      private
+
+      def generate_signing_key
+        if key
+          ::RbNaCl::SigningKey.new(key)
+        else
+          ::RbNaCl::SigningKey.generate
+        end
+      end
+    end
+
+    class Ed25519VerifyingKey < ::RbNaCl::VerifyKey
+      attr_accessor :key, :encoder
+      private :key, :encoder
+
+      def initialize(key = nil, encoding = nil)
+        @key = key
+        encoding = encoding || 'base58'
+        @encoder = Crypto.get_encoder(encoding)
+        super(@encoder.new.decode(@key))
+      end
+
+      def verify(signature, data, encoding = 'base58')
+        encoder = Crypto.get_encoder(encoding)
+        super(encoder.new.decode(signature), data)
+      rescue ::RbNaCl::BadSignatureError
+        false
+      end
+
+      def encode(encoding = 'base58')
+        encoder = Crypto.get_encoder(encoding).new
+        encoder.encode(self.to_s)
+      end
+    end
+  end
+end

data/lib/cryptoconditions_ruby/exceptions.rb

@@ -0,0 +1,8 @@
+module CryptoconditionsRuby
+  module Exceptions
+    class ParsingError < StandardError; end
+    class UnsupportedTypeError < StandardError; end
+    class ValidationError < StandardError; end
+    class UnknownEncodingError < StandardError; end
+  end
+end

data/lib/cryptoconditions_ruby/fulfillment.rb

@@ -0,0 +1,138 @@
+require 'base64'
+
+module CryptoconditionsRuby
+  FULFILLMENT_REGEX = /^cf:([1-9a-f][0-9a-f]{0,3}|0):[a-zA-Z0-9_-]*$/
+
+  class Fulfillment
+    extend Crypto::Helpers
+    include Crypto::Helpers
+    TYPE_ID = nil
+    REGEX = FULFILLMENT_REGEX
+    FEATURE_BITMASK = nil
+
+    def self.from_uri(serialized_fulfillment)
+      return serialized_fulfillment if serialized_fulfillment.is_a?(Fulfillment)
+
+      unless serialized_fulfillment.is_a?(String)
+        raise TypeError, 'Serialized fulfillment must be a string'
+      end
+
+      pieces = serialized_fulfillment.split(':', -1)
+
+      unless pieces.first == 'cf'
+        raise TypeError, 'Serialized fulfillment must start with "cf:"'
+      end
+
+      unless serialized_fulfillment.match(Fulfillment::REGEX)
+        raise TypeError, 'Invalid fulfillment format'
+      end
+
+      type_id = pieces[1].to_i(16)
+      payload = Base64.urlsafe_decode64(base64_add_padding(pieces[2]))
+
+      cls = TypeRegistry.get_class_from_type_id(type_id)
+      fulfillment = cls.new
+
+      fulfillment.parse_payload(Utils::Reader.from_source(payload), payload.length)
+      fulfillment
+    end
+
+    def self.from_binary(reader)
+      reader = Utils::Reader.from_source(reader)
+
+      cls_type = reader.read_uint16
+      cls = TypeRegistry.get_class_from_type_id(cls_type)
+
+      fulfillment = cls.new
+      payload_length = reader.read_length_prefix
+      fulfillment.parse_payload(reader, payload_length)
+      fulfillment
+    end
+
+    def self.from_dict(data)
+      cls_type = data['type_id']
+      cls = TypeRegistry.get_class_from_type_id(cls_type)
+      fulfillment = cls.new
+      fulfillment.parse_dict(data)
+      fulfillment
+    end
+
+    def type_id
+      self.class::TYPE_ID
+    end
+
+    def bitmask
+      self.class::FEATURE_BITMASK
+    end
+
+    def condition
+      condition = Condition.new
+      condition.type_id = type_id
+      condition.bitmask = bitmask
+      condition.hash = generate_hash
+      condition.max_fulfillment_length = calculate_max_fulfillment_length
+      condition
+    end
+
+    def condition_uri
+      condition.serialize_uri
+    end
+
+    def condition_binary
+      condition.serialize_binary
+    end
+
+    def generate_hash
+      raise 'Implement me'
+    end
+
+    def calculate_max_fulfillment_length
+      predictor = Utils::Predictor.new
+      write_payload(predictor)
+      predictor.size
+    end
+
+    def serialize_uri
+      format(
+        'cf:%x:%s',
+        type_id,
+        base64_remove_padding(
+          Base64.urlsafe_encode64(serialize_payload)
+        )
+      )
+    end
+
+    def serialize_binary
+      writer = Utils::Writer.new
+      writer.write_uint16(type_id)
+      writer.write_var_octet_string(serialize_payload)
+      writer.buffer
+    end
+
+    def serialize_payload
+      writer = Utils::Writer.new
+      write_payload(writer)
+      writer.buffer
+    end
+
+    def write_payload(_writer)
+      raise 'Implement me'
+    end
+
+    def parse_payload(_reader, *_args)
+      raise 'Implement me'
+    end
+
+    def to_dict
+      raise 'Implement me'
+    end
+
+    def parse_dict(_data)
+      raise 'Implement me'
+    end
+
+    def validate(**_kwargs)
+      raise 'Implement me'
+    end
+  end
+end

data/lib/cryptoconditions_ruby/type_registry.rb

@@ -0,0 +1,27 @@
+class CryptoconditionsRuby::TypeRegistry
+  MAX_SAFE_INTEGER_JS = 2 ** 53 - 1
+
+  def self.registered_types
+    @registered_types ||=[]
+  end
+
+  def self.get_class_from_type_id(type_id)
+    if type_id > MAX_SAFE_INTEGER_JS
+      raise TypeError.new("Type #{type_id} is not supported")
+    end
+
+    type = registered_types.find do |registered_type|
+      type_id == registered_type['type_id']
+    end
+
+    if type
+      type['class']
+    else
+      raise TypeError.new("Type #{type_id} is not supported")
+    end
+  end
+
+  def self.register_type(cls)
+    registered_types.push({'type_id' => cls::TYPE_ID, 'class' => cls})
+  end
+end

data/lib/cryptoconditions_ruby/types/base_sha_256_fulfillment.rb

@@ -0,0 +1,15 @@
+module CryptoconditionsRuby
+  module Types
+    class BaseSha256Fulfillment < Fulfillment
+      def generate_hash
+        hasher = Utils::Hasher.new('sha256')
+        write_hash_payload(hasher)
+        hasher.digest
+      end
+
+      def write_hash_payload(_hasher)
+        raise 'Implement me'
+      end
+    end
+  end
+end

data/lib/cryptoconditions_ruby/types/ed25519_fulfillment.rb

@@ -0,0 +1,79 @@
+module CryptoconditionsRuby
+  module Types
+    class Ed25519Fulfillment < Fulfillment
+      TYPE_ID = 4
+      FEATURE_BITMASK = 0x20
+      PUBKEY_LENGTH = 32
+      SIGNATURE_LENGTH = 64
+      FULFILLMENT_LENGTH = PUBKEY_LENGTH + SIGNATURE_LENGTH
+
+      attr_accessor :public_key, :signature
+      private :signature
+      def initialize(public_key = nil)
+        if public_key
+          public_key = Crypto::Ed25519VerifyingKey.new(public_key) if public_key.is_a?(String)
+          raise TypeError unless public_key.is_a?(Crypto::Ed25519VerifyingKey)
+        end
+        @public_key = public_key
+        @signature = nil
+      end
+
+      def write_common_header(writer)
+        writer.write_var_octet_string(public_key)
+      end
+
+      def sign(message, private_key)
+        sk = private_key
+        vk = sk.get_verifying_key
+
+        self.public_key = vk
+
+        self.signature = sk.sign(message, 'bytes')
+      end
+
+      def generate_hash
+        raise StandardError, 'Requires a public publicKey' unless public_key
+        public_key.to_s
+      end
+
+      def parse_payload(reader, *_args)
+        self.public_key = Crypto::Ed25519VerifyingKey.new(
+          Utils::Base58.encode(reader.read_octet_string(Ed25519Fulfillment::PUBKEY_LENGTH))
+        )
+        self.signature = reader.read_octet_string(Ed25519Fulfillment::SIGNATURE_LENGTH)
+      end
+
+      def write_payload(writer)
+        writer.tap do |w|
+          w.write_octet_string(public_key.to_s, Ed25519Fulfillment::PUBKEY_LENGTH)
+          w.write_octet_string(signature, Ed25519Fulfillment::SIGNATURE_LENGTH)
+        end
+      end
+
+      def calculate_max_fulfillment_length
+        Ed25519Fulfillment::FULFILLMENT_LENGTH
+      end
+
+      def to_dict
+        {
+          'type' => 'fulfillment',
+          'type_id' => TYPE_ID,
+          'bitmask' => bitmask,
+          'public_key' => Utils::Base58.encode(public_key.to_s),
+          'signature' => (Utils::Base58.encode(signature) if signature)
+        }
+      end
+
+      def parse_dict(data)
+        self.public_key = Crypto::Ed25519VerifyingKey.new(data['public_key'])
+        self.signature = (Utils::Base58.decode(data['signature']) if data['signature'])
+      end
+
+      def validate(message: nil, **_kwargs)
+        return false unless message && signature
+
+        public_key.verify(signature, message, 'bytes')
+      end
+    end
+  end
+end

data/lib/cryptoconditions_ruby/types/inverted_threshold_sha_256_fulfillment.rb

@@ -0,0 +1,15 @@
+module CryptoconditionsRuby
+  CONDITION = 'condition'.freeze
+  FULFILLMENT = 'fulfillment'.freeze
+
+  module Types
+    class InvertedThresholdSha256Fulfillment < ThresholdSha256Fulfillment
+      TYPE_ID = 98
+      FEATURE_BITMASK = 0x09
+
+      def validate(message: nil, **kwargs)
+        !super
+      end
+    end
+  end
+end

data/lib/cryptoconditions_ruby/types/preimage_sha_256_fulfillment.rb

@@ -0,0 +1,64 @@
+module CryptoconditionsRuby
+  module Types
+    class PreimageSha256Fulfillment < BaseSha256Fulfillment
+      TYPE_ID = 0
+      FEATURE_BITMASK = 0x03
+
+      attr_accessor :preimage
+      private :preimage
+      def initialize(preimage = nil)
+        if preimage && !preimage.respond_to?(:bytes)
+          raise TypeError, "Preimage must be bytes, was #{preimage.class.name}"
+        end
+        @preimage = preimage
+      end
+
+      def bitmask
+        FEATURE_BITMASK
+      end
+
+      def write_hash_payload(hasher)
+        unless hasher.is_a?(Utils::Hasher)
+          raise TypeError, 'hasher must be a Hasher instance'
+        end
+        unless preimage
+          raise TypeError, 'Could not calculate hash, no preimage provided'
+        end
+        hasher.write(preimage)
+      end
+
+      def parse_payload(reader, payload_size)
+        unless reader.is_a?(Utils::Reader)
+          raise TypeError, 'reader must be a Reader instance'
+        end
+        self.preimage = reader.read(payload_size)
+      end
+
+      def write_payload(writer)
+        unless [Utils::Writer, Utils::Predictor].include?(writer.class)
+          raise TypeError, 'writer must be a Writer instance'
+        end
+        raise TypeError, 'Preimage must be specified' unless preimage
+        writer.write(preimage)
+        writer
+      end
+
+      def to_dict
+        {
+          'type' => 'fulfillment',
+          'type_id' => TYPE_ID,
+          'bitmask' => bitmask,
+          'preimage' => preimage
+        }
+      end
+
+      def parse_dict(data)
+        self.preimage = data['preimage'].encode
+      end
+
+      def validate(**_kwargs)
+        true
+      end
+    end
+  end
+end