hyperledger-fabric-sdk 0.1.0 → 0.1.1

data/lib/fabric/crypto_suite.rb

@@ -0,0 +1,145 @@
+require 'openssl'
+
+module Fabric
+  class CryptoSuite
+    DEFAULT_KEY_SIZE = 256
+    DEFAULT_DIGEST_ALGORITHM = 'SHA256'.freeze
+    DEFAULT_AES_KEY_SIZE = 128
+
+    EC_CURVES = { 256 => 'prime256v1', 384 => 'secp384r1' }.freeze
+
+    CIPHER = 'aes-256-cbc'.freeze
+
+    attr_reader :key_size, :digest_algorithm, :digest, :curve, :cipher
+
+    def initialize(opts = {})
+      @key_size = opts[:key_size] || DEFAULT_KEY_SIZE
+      @digest_algorithm = opts[:digest_algorithm] || DEFAULT_DIGEST_ALGORITHM
+      @digest = OpenSSL::Digest.new digest_algorithm
+      @curve = EC_CURVES[key_size]
+      @cipher = opts[:cipher] || CIPHER
+    end
+
+    def sign(private_key, message)
+      digest = digest message
+      key = pkey_from_private_key private_key
+      signature = key.dsa_sign_asn1 digest
+      sequence = OpenSSL::ASN1.decode signature
+      sequence = prevent_malleability sequence, key.group.order
+
+      sequence.to_der
+    end
+
+    def generate_private_key
+      key = OpenSSL::PKey::EC.new curve
+      key.generate_key!
+
+      key.private_key.to_i.to_s(16).downcase
+    end
+
+    def generate_csr(private_key, attrs = [])
+      key = pkey_from_private_key private_key
+
+      req = OpenSSL::X509::Request.new
+      req.public_key = key
+      req.subject = OpenSSL::X509::Name.new attrs
+      req.sign key, @digest
+
+      req
+    end
+
+    def generate_nonce(length = 24)
+      OpenSSL::Random.random_bytes length
+    end
+
+    def hexdigest(message)
+      @digest.hexdigest message
+    end
+
+    def digest(message)
+      @digest.digest message
+    end
+
+    def encode_hex(bytes)
+      bytes.unpack('H*').first
+    end
+
+    def decode_hex(string)
+      [string].pack('H*')
+    end
+
+    def keccak256(bytes)
+      Digest::SHA3.new(256).digest bytes
+    end
+
+    def restore_public_key(private_key)
+      private_bn = OpenSSL::BN.new private_key, 16
+      group = OpenSSL::PKey::EC::Group.new curve
+      public_bn = group.generator.mul(private_bn).to_bn
+      public_bn = OpenSSL::PKey::EC::Point.new(group, public_bn).to_bn
+
+      public_bn.to_s(16).downcase
+    end
+
+    def address_from_public_key(public_key)
+      bytes = decode_hex public_key
+      address_bytes = keccak256(bytes[1..-1])[-20..-1]
+
+      encode_hex address_bytes
+    end
+
+    def build_shared_key(private_key, public_key)
+      pkey = pkey_from_private_key private_key
+      public_bn = OpenSSL::BN.new public_key, 16
+      group = OpenSSL::PKey::EC::Group.new curve
+      public_point = OpenSSL::PKey::EC::Point.new group, public_bn
+
+      encode_hex pkey.dh_compute_key(public_point)
+    end
+
+    def encrypt(secret, data)
+      aes = OpenSSL::Cipher.new cipher
+      aes.encrypt
+      aes.key = decode_hex(secret)
+      iv = aes.random_iv
+      aes.iv = iv
+
+      Base64.strict_encode64(iv + aes.update(data) + aes.final)
+    end
+
+    def decrypt(secret, data)
+      return unless data
+
+      encrypted_data = Base64.strict_decode64 data
+      aes = OpenSSL::Cipher.new cipher
+      aes.decrypt
+      aes.key = decode_hex(secret)
+      aes.iv = encrypted_data[0..15]
+      encrypted_data = encrypted_data[16..-1]
+
+      aes.update(encrypted_data) + aes.final
+    end
+
+    private
+
+    def pkey_from_private_key(private_key)
+      public_key = restore_public_key private_key
+      key = OpenSSL::PKey::EC.new curve
+      key.private_key = OpenSSL::BN.new private_key, 16
+      key.public_key = OpenSSL::PKey::EC::Point.new key.group,
+                                                    OpenSSL::BN.new(public_key, 16)
+
+      key
+    end
+
+    def prevent_malleability(sequence, order)
+      half_order = order >> 1
+
+      if (half_key = sequence.value[1].value) > half_order
+        sequence.value[1].value = order - half_key
+      end
+
+      sequence
+    end
+  end
+end

data/lib/fabric/enumerator_queue.rb

@@ -0,0 +1,26 @@
+module Fabric
+  class EnumeratorQueue
+    extend Forwardable
+    def_delegators :@q, :push
+    def_delegators :@q, :size
+
+    def initialize(sentinel)
+      @q = Queue.new
+      @sentinel = sentinel
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      loop do
+        r = @q.pop
+
+        break if r.equal?(@sentinel)
+
+        raise r if r.is_a? Exception
+
+        yield r
+      end
+    end
+  end
+end

data/lib/fabric/error.rb

@@ -0,0 +1,52 @@
+module Fabric
+  class ErrorFactory
+    CHAINCODE_ERROR_MESSAGE_PREFIX = 'transaction returned with failure:'.freeze
+
+    def self.create(message)
+      if message.start_with? CHAINCODE_ERROR_MESSAGE_PREFIX
+        ChaincodeError.new message.gsub(CHAINCODE_ERROR_MESSAGE_PREFIX, '')
+      else
+        UnknownError.new message
+      end
+    end
+  end
+
+  class Error < StandardError
+    attr_reader :code, :errors
+
+    def initialize(message, code = 0, errors = {})
+      super message
+
+      @code = code
+      @errors = errors
+    end
+
+    def response
+      Hashie::Mash.new success: false,
+                       code: code,
+                       result: {},
+                       message: message,
+                       errors: errors
+    end
+  end
+
+  class ChaincodeError < Fabric::Error
+    def initialize(message)
+      response = Hashie::Mash.new JSON.parse(message)
+
+      super response.message, response.code, response.errors
+    end
+  end
+
+  class OrdererError < Fabric::Error; end
+
+  class TransactionError < Fabric::Error
+    def initialize(status)
+      super "Transaction failed (#{status})", "TX_STATUS_#{status}"
+    end
+  end
+
+  class NetworkOfflineError < Fabric::Error; end
+
+  class UnknownError < Fabric::Error; end
+end

data/lib/fabric/event_hub.rb

@@ -0,0 +1,81 @@
+module Fabric
+  class EventHub
+    attr_reader :url, :identity, :logger, :crypto_suite, :channel_id
+    attr_reader :channel, :connection, :queue
+
+    MAX_BLOCK_NUMBER = 1_000_000_000
+
+    def initialize(opts = {})
+      @url = opts[:url]
+      @identity = opts[:identity]
+      @crypto_suite = opts[:crypto_suite]
+      @logger = opts[:logger]
+      @channel_id = opts[:channel_id]
+
+      @channel = ::Protos::Deliver::Stub.new url, :this_channel_is_insecure
+      @queue = Fabric::EnumeratorQueue.new channel
+      @connection = channel.deliver(queue.each).each
+    end
+
+    def observe(start_block = :newest, stop_block = MAX_BLOCK_NUMBER)
+      tx_info = Fabric::TransactionInfo.new crypto_suite, identity
+      seek_header = build_seek_header tx_info
+      seek_info = build_seek_info start_block, stop_block
+      envelope = build_envelope tx_info, seek_header, seek_info
+
+      loop do
+        queue.push envelope
+
+        event = connection.next
+
+        block = Fabric::BlockDecoder.decode_block(event.block)
+
+        yield block if block_given?
+      end
+    end
+
+    private
+
+    def build_envelope(tx_info, seek_header, seek_info)
+      seek_payload = ::Common::Payload.new(
+        header: seek_header,
+        data: seek_info.to_proto
+      )
+
+      ::Common::Envelope.new signature: tx_info.identity.sign(seek_payload.to_proto),
+                             payload: seek_payload.to_proto
+    end
+
+    def build_seek_header(tx_info)
+      seek_info_header = Fabric::Helper.build_channel_header(
+        type: ::Common::HeaderType::DELIVER_SEEK_INFO,
+        channel_id: channel_id,
+        tx_id: tx_info.tx_id
+      )
+
+      ::Common::Header.new(
+        channel_header: seek_info_header.to_proto,
+        signature_header: tx_info.signature_header.to_proto
+      )
+    end
+
+    def build_seek_info(start_block, stop_block)
+      ::Orderer::SeekInfo.new(
+        start: build_seek_position(start_block),
+        stop: build_seek_position(stop_block),
+        behavior: ::Orderer::SeekInfo::SeekBehavior::BLOCK_UNTIL_READY
+      )
+    end
+
+    def build_seek_position(block_number)
+      case block_number
+      when :newest then ::Orderer::SeekPosition.new(newest: ::Orderer::SeekNewest.new)
+      when :oldest then ::Orderer::SeekPosition.new(oldest: ::Orderer::SeekOldest.new)
+      else
+        ::Orderer::SeekPosition.new(
+          specified: ::Orderer::SeekSpecified.new(number: block_number)
+        )
+      end
+    end
+  end
+end

data/lib/fabric/helper.rb

@@ -0,0 +1,31 @@
+module Fabric
+  module Helper
+    def self.build_channel_header(opts)
+      header = Common::ChannelHeader.new type: opts[:type],
+                                         channel_id: opts[:channel_id],
+                                         tx_id: opts[:tx_id],
+                                         timestamp: opts[:timestamp] || build_timestamp,
+                                         version: 1
+
+      header.extension = build_channel_header_extension(opts) if opts[:chaincode_id]
+
+      header
+    end
+
+    def self.build_channel_header_extension(opts)
+      id = Protos::ChaincodeID.new name: opts[:chaincode_id]
+
+      Protos::ChaincodeHeaderExtension.new chaincode_id: id
+    end
+
+    def self.build_timestamp
+      now = Time.current
+
+      Google::Protobuf::Timestamp.new seconds: now.to_i, nanos: now.nsec
+    end
+
+    def self.timestamp_to_time(timestamp)
+      (timestamp.seconds * 1000 + timestamp.nanos / 10**6).to_i
+    end
+  end
+end

data/lib/fabric/identity.rb

@@ -2,35 +2,41 @@ require 'msp/identities_pb'
 
 module Fabric
   class Identity
-    attr_reader :certificate, :public_key, :private_key, :msp_id, :crypto_suite,
-                :key, :iv
-
-    def initialize(args)
-      @certificate = args[:certificate]
-      @public_key = args[:public_key]
-      @private_key = args[:private_key]
-      @msp_id = args[:msp_id]
-      @crypto_suite = args[:crypto_suite]
-      @key = args[:key].to_s
-      @iv = args[:iv].to_s
+    attr_reader :private_key,
+                :public_key,
+                :address
+
+    attr_accessor :certificate, :mspid
+
+    def initialize(crypto_suite, opts = {})
+      @crypto_suite = crypto_suite
+
+      @private_key = opts[:private_key] || @crypto_suite.generate_private_key
+      @public_key = opts[:public_key] || @crypto_suite.restore_public_key(private_key)
+      @certificate = opts[:certificate]
+      @mspid = opts[:mspid]
+
+      @address = @crypto_suite.address_from_public_key public_key
     end
 
-    def serialize
-      Msp::SerializedIdentity.new(mspid: msp_id, id_bytes: certificate).to_proto
+    def generate_csr(attrs = [])
+      @crypto_suite.generate_csr private_key, attrs
     end
 
     def sign(message)
-      digest = crypto_suite.digest message
+      @crypto_suite.sign(private_key, message)
+    end
 
-      crypto_suite.sign private_key, digest
+    def shared_secret_by(public_key)
+      @crypto_suite.build_shared_key private_key, public_key
     end
 
-    def encrypt(message)
-      crypto_suite.encrypt key, iv, message
+    def decoded_certificate
+      Base64.strict_decode64 certificate
     end
 
-    def decrypt(message)
-      crypto_suite.decrypt  key, iv, message
+    def serialize
+      Msp::SerializedIdentity.new(mspid: mspid, id_bytes: decoded_certificate).to_proto
     end
   end
 end

data/lib/fabric/logger.rb

@@ -0,0 +1,37 @@
+module Fabric
+  class Logger
+    LOGGER_TAG = 'HYPERLEDGER FABRIC'.colorize(:green).freeze
+    FILTERED_MASK = '[FILTERED]'.freeze
+
+    attr_reader :logger, :filters
+
+    def initialize(logger, filters = [])
+      @logger = logger
+      @filters = [filters]
+    end
+
+    def error(*args)
+      return unless logger
+
+      logger.tagged(LOGGER_TAG) { |logger| logger.error filter_message(args.join('|')) }
+    end
+
+    def info(*args)
+      return unless logger
+
+      logger.tagged(LOGGER_TAG) { |logger| logger.info filter_message(args.join('|')) }
+    end
+
+    def debug(*args)
+      return unless logger
+
+      logger.tagged(LOGGER_TAG) { |logger| logger.debug filter_message(args.join('|')) }
+    end
+
+    private
+
+    def filter_message(message)
+      filters.inject(message) { |msg, filter| msg.gsub(filter, FILTERED_MASK) }
+    end
+  end
+end

data/lib/fabric/orderer.rb

@@ -2,18 +2,34 @@ require 'orderer/ab_services_pb.rb'
 
 module Fabric
   class Orderer
-    attr_reader :url, :opts, :client
+    attr_reader :url, :opts, :client, :logger
 
     def initialize(args)
       @url = args[:url]
       @opts = args[:opts]
+      @logger = args[:logger]
+
       @client = ::Orderer::AtomicBroadcast::Stub.new url, :this_channel_is_insecure
     end
 
     def send_broadcast(envelope)
-      client.broadcast([envelope]) do |response|
+      logging :send_broadcast_request, envelope.to_h
+
+      client.broadcast([envelope]).each do |response|
+        logging :send_broadcast_response, response.to_h
+
+        raise OrdererError response.message unless response.status == :SUCCESS
+
         yield response if block_given?
       end
     end
+
+    private
+
+    def logging(section, message)
+      logger.debug section.to_s.upcase.colorize(:yellow),
+                   url.colorize(:red),
+                   message.to_s.colorize(:blue)
+    end
   end
 end

data/lib/fabric/peer.rb

@@ -1,58 +1,37 @@
-require 'peer/query_pb'
+require 'peer/peer_services_pb'
 
 module Fabric
   class Peer
-    attr_reader :url, :opts, :identity_context, :client
+    attr_reader :url, :opts, :client, :logger
 
     def initialize(args)
       @url = args[:url]
       @opts = args[:opts]
-      @identity_context = args[:identity_context]
+      @logger = args[:logger]
+
       @client = Protos::Endorser::Stub.new url, :this_channel_is_insecure
     end
 
     def send_process_proposal(proposal)
-      client.process_proposal proposal
-    end
+      logging :send_process_proposal_request, proposal.to_h
 
-    def query_channels
-      request = {
-        targets: [self],
-        chaincode_id: Constants::CSCC,
-        transaction: TransactionID.new(identity_context),
-        function: Constants::FUNC_GET_CHANNELS,
-        args: []
-      }
+      response = client.process_proposal proposal
 
-      responses = PeerEndorser.send_transaction_proposal request, '', identity_context
-      response = responses.first
+      logging :send_process_proposal_response, response.to_h
 
-      Protos::ChannelQueryResponse.decode response.response.payload
+      response
     end
 
-    def query_config_block(channel_id)
-      request = {
-        targets: [self],
-        chaincode_id: Constants::CSCC,
-        transaction: TransactionID.new(identity_context),
-        function: Constants::FUNC_GET_CONFIG_BLOCK,
-        args: [channel_id]
-      }
-
-      responses = PeerEndorser.send_transaction_proposal request, '', identity_context
-      proposal_response = responses.first
-
-      extract_config_enveloper proposal_response
+    def create_event_hub
+      EventHub.new url: url, opts: opts, logger: logger
     end
 
     private
 
-      def extract_config_enveloper(proposal_response)
-        block = Common::Block.decode proposal_response.response.payload
-        envelope = Common::Envelope.decode block.data.data.first
-        payload = Common::Payload.decode envelope.payload
-
-        Common::ConfigEnvelope.decode payload.data
-      end
+    def logging(section, message)
+      logger.debug section.to_s.upcase.colorize(:yellow),
+                   url.colorize(:red),
+                   message.to_s.colorize(:blue)
+    end
   end
 end

data/lib/fabric/proposal.rb

@@ -0,0 +1,100 @@
+module Fabric
+  class Proposal
+    attr_reader :crypto_suite, :identity, :request
+
+    def initialize(crypto_suite, identity, request = {})
+      @crypto_suite = crypto_suite
+      @identity = identity
+      @request = request
+
+      assign_tx request[:transaction_info] if request[:transaction_info]
+    end
+
+    def nonce
+      @nonce ||= crypto_suite.generate_nonce
+    end
+
+    def channel_id
+      request[:channel_id]
+    end
+
+    def chaincode_id
+      request[:chaincode_id]
+    end
+
+    def args
+      request[:args].compact.map &:to_s
+    end
+
+    def transient
+      request[:transient] || {}
+    end
+
+    def transaction_id
+      request[:transaction_id]
+    end
+
+    def tx_id
+      @tx_id ||= crypto_suite.hexdigest(nonce + identity.serialize)
+    end
+
+    def proposal
+      @proposal ||= Protos::Proposal.new header: header.to_proto,
+                                         payload: chaincode_proposal.to_proto
+    end
+
+    def signed_proposal
+      proposal_bytes = proposal.to_proto
+      signature = identity.sign proposal_bytes
+
+      Protos::SignedProposal.new proposal_bytes: proposal_bytes, signature: signature
+    end
+
+    def header
+      Common::Header.new channel_header: channel_header.to_proto,
+                         signature_header: signature_header.to_proto
+    end
+
+    def channel_header
+      Common::ChannelHeader.new type: Common::HeaderType::ENDORSER_TRANSACTION,
+                                channel_id: channel_id, tx_id: tx_id,
+                                extension: channel_header_extension.to_proto,
+                                timestamp: tx_timestamp,
+                                version: Constants::CHANNEL_HEADER_VERSION
+    end
+
+    def channel_header_extension
+      id = Protos::ChaincodeID.new name: chaincode_id
+
+      Protos::ChaincodeHeaderExtension.new chaincode_id: id
+    end
+
+    def tx_timestamp
+      now = Time.current
+
+      @tx_timestamp ||= Google::Protobuf::Timestamp.new seconds: now.to_i, nanos: now.nsec
+    end
+
+    def signature_header
+      Common::SignatureHeader.new creator: identity.serialize, nonce: nonce
+    end
+
+    def chaincode_proposal
+      id = Protos::ChaincodeID.new name: chaincode_id
+      chaincode_input = Protos::ChaincodeInput.new args: args
+      chaincode_spec = Protos::ChaincodeSpec.new type: Protos::ChaincodeSpec::Type::NODE,
+                                                 chaincode_id: id,
+                                                 input: chaincode_input
+      input = Protos::ChaincodeInvocationSpec.new chaincode_spec: chaincode_spec
+
+      Protos::ChaincodeProposalPayload.new input: input.to_proto, TransientMap: transient
+    end
+
+    private
+
+    def assign_tx(transaction_info)
+      @tx_id = transaction_info[:tx_id]
+      @nonce = crypto_suite.decode_hex transaction_info[:nonce_hex]
+    end
+  end
+end