hyperledger-fabric-sdk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8868d76ed70adc4cedf983ad30718b1964bdd4a4a06291bc336d7381bc152a74
+  data.tar.gz: 97809db15dee6a3f8ac534a63eb3933895e8f0fa0ebd255b10569124e5ff06c4
+SHA512:
+  metadata.gz: e4c1c49bdc093de69d552136954eacf30f0e92128222f5e878d760e71dd94ac08720ad832e8172014fb2363ce507963fe1099f1c7589878875c412704063de8f
+  data.tar.gz: e91abaeeee3053694b18362ab2fff01132267782ae6fdc0e01ed8bcc04540ff565fa70ae6bd5e4931068664f8ae51230008792e3a9cf1592c23ba5284bead9e0

data/lib/crypto_suite/ecdsa_aes.rb

@@ -0,0 +1,86 @@
+require 'openssl'
+
+module CryptoSuite
+  class ECDSA_AES
+    DEFAULT_KEY_SIZE = 256.freeze
+    DEFAULT_NONCE_LENGTH = 24.freeze
+    DEFAULT_DIGEST_ALGORITHM = 'SHA256'.freeze
+    DEFAULT_AES_KEY_SIZE = 128.freeze
+
+    EC_CURVES = { 256 => 'prime256v1', 384 => 'secp384r1' }.freeze
+
+    attr_reader :key_size, :nonce_length, :digest_algorithm, :digest, :cipher
+
+    def initialize(opts = {})
+      @key_size = opts[:key_size] || DEFAULT_KEY_SIZE
+      @nonce_length = opts[:nonce_length] || DEFAULT_NONCE_LENGTH
+      @digest_algorithm = opts[:digest_algorithm] || DEFAULT_DIGEST_ALGORITHM
+      @digest = OpenSSL::Digest.new(digest_algorithm)
+      @cipher = OpenSSL::Cipher::AES.new(opts[:aes_key_size] || DEFAULT_AES_KEY_SIZE, :CBC)
+    end
+
+    def generate_nonce
+      OpenSSL::Random.random_bytes nonce_length
+    end
+
+    def hexdigest(message)
+      @digest.hexdigest message
+    end
+
+    def digest(message)
+      @digest.digest message
+    end
+
+    def sign(private_key, msg)
+      key = OpenSSL::PKey::EC.new private_key
+      signature = key.dsa_sign_asn1 msg
+      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 EC_CURVES[key_size]
+      key.generate_key!
+
+      key.to_pem
+    end
+
+    def generate_csr(private_key, options = [])
+      key = OpenSSL::PKey::EC.new private_key
+      req = OpenSSL::X509::Request.new
+      req.public_key = key
+      req.subject = OpenSSL::X509::Name.new(options)
+      req.sign key, @digest
+
+      req
+    end
+
+    def encrypt(key, iv, message)
+      cipher.encrypt key, iv
+
+      Base64.strict_encode64(cipher.update(message) + cipher.final)
+    end
+
+    def decrypt(key, iv, message)
+      cipher.decrypt key, iv
+
+      cipher.update(Base64.strict_decode64(message)) + cipher.final
+    rescue OpenSSL::Cipher::CipherError
+      nil
+    end
+
+    private
+
+      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/channel.rb

@@ -0,0 +1,54 @@
+require 'peer/transaction_pb'
+
+module Fabric
+  class Channel
+    attr_reader :identity_context, :name, :peers, :orderers
+
+    def initialize(args)
+      @identity_context = args[:identity_context]
+      @name = args[:name]
+      @peers = args[:peers] || []
+      @orderers = args[:orderers] || []
+    end
+
+    def query_by_chaincode(request)
+      request[:targets] ||= peers
+      request[:transaction] = TransactionID.new identity_context
+
+      PeerEndorser.send_transaction_proposal request, name, identity_context
+    end
+
+    def send_transaction(request, &block)
+      header = Common::Header.decode request[:proposal].header
+      chaincode_action_payload = build_chaincode_action request
+
+      transaction_action = Protos::TransactionAction.new header: header.signature_header,
+                                                         payload: chaincode_action_payload.to_proto
+      transaction = Protos::Transaction.new actions: [transaction_action]
+
+      payload = Common::Payload.new header: header,
+                                    data: transaction.to_proto
+
+      envelope = Common::Envelope.new signature: identity_context.identity.sign(payload.to_proto),
+                                      payload: payload.to_proto
+
+      orderers.first.send_broadcast envelope, &block
+    end
+
+    private
+
+      def build_chaincode_action(request)
+        responses = request[:responses].select { |response| response.response.status == 200 }
+        endorsements = responses.map { |response| response.endorsement }
+        chaincode_endorser_action =
+          Protos::ChaincodeEndorsedAction.new proposal_response_payload: responses.first.payload,
+                                              endorsements: endorsements
+
+        payload = Protos::ChaincodeProposalPayload.decode request[:proposal].payload
+        payload_no_trans = Protos::ChaincodeProposalPayload.new input: payload.input
+
+        Protos::ChaincodeActionPayload.new action: chaincode_endorser_action,
+                                           chaincode_proposal_payload: payload_no_trans.to_proto
+      end
+  end
+end

data/lib/fabric/client.rb

@@ -0,0 +1,45 @@
+module Fabric
+  class Client
+    attr_reader :identity_context, :orderers, :peers, :channels
+
+    def initialize(options = {})
+      options = Fabric.options.merge(options)
+
+      @identity_context = options[:identity_context]
+      @orderers = {}
+      @channels = {}
+      @peers = {}
+    end
+
+    def config
+      conf = {}
+      Configuration::VALID_OPTIONS_KEYS.each do |key|
+        conf[key] = public_send key
+      end
+
+      conf
+    end
+
+    def new_channel(name)
+      channels[name] ||= Channel.new name: name,
+                                     orderers: orderers.values , peers: peers.values,
+                                     identity_context: identity_context
+
+      channels[name]
+    end
+
+    def new_peer(url, opts = {})
+      peers[url] ||= Peer.new url: url, opts: opts,
+                              identity_context: identity_context
+
+      peers[url]
+    end
+
+    def new_orderer(url, opts = {})
+      orderers[url] ||= Orderer.new url: url, opts: opts,
+                                    identity_context: identity_context
+
+      orderers[url]
+    end
+  end
+end

data/lib/fabric/configuration.rb

@@ -0,0 +1,25 @@
+module Fabric
+  module Configuration
+    VALID_OPTIONS_KEYS = [:identity_context, :orderers, :peers]
+
+    attr_accessor *VALID_OPTIONS_KEYS
+
+    def self.extended(base)
+      base.reset
+    end
+
+    def configure
+      yield self
+    end
+
+    def options
+      VALID_OPTIONS_KEYS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+
+    def reset
+      VALID_OPTIONS_KEYS.each {|key| send("#{key}=", nil)}
+    end
+  end
+end

data/lib/fabric/constants.rb

@@ -0,0 +1,18 @@
+module Fabric
+  module Constants
+    ## System Chaincodes
+    LSCC = 'lscc'.freeze
+    QSCC = 'qscc'.freeze
+    CSCC = 'cscc'.freeze
+
+    ## System Channels
+    SYSTEM_CHANNEL_NAME = 'testchainid'.freeze
+
+    ## System Functions
+    FUNC_GET_CHANNELS = 'GetChannels'.freeze
+    FUNC_GET_CONFIG_BLOCK = 'GetConfigBlock'.freeze
+
+    ## Variables
+    CHANNEL_HEADER_VERSION = 1.freeze
+  end
+end

data/lib/fabric/identity.rb

@@ -0,0 +1,36 @@
+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
+    end
+
+    def serialize
+      Msp::SerializedIdentity.new(mspid: msp_id, id_bytes: certificate).to_proto
+    end
+
+    def sign(message)
+      digest = crypto_suite.digest message
+
+      crypto_suite.sign private_key, digest
+    end
+
+    def encrypt(message)
+      crypto_suite.encrypt key, iv, message
+    end
+
+    def decrypt(message)
+      crypto_suite.decrypt  key, iv, message
+    end
+  end
+end

data/lib/fabric/orderer.rb

@@ -0,0 +1,19 @@
+require 'orderer/ab_services_pb.rb'
+
+module Fabric
+  class Orderer
+    attr_reader :url, :opts, :client
+
+    def initialize(args)
+      @url = args[:url]
+      @opts = args[:opts]
+      @client = ::Orderer::AtomicBroadcast::Stub.new url, :this_channel_is_insecure
+    end
+
+    def send_broadcast(envelope)
+      client.broadcast([envelope]) do |response|
+        yield response if block_given?
+      end
+    end
+  end
+end

data/lib/fabric/peer.rb

@@ -0,0 +1,58 @@
+require 'peer/query_pb'
+
+module Fabric
+  class Peer
+    attr_reader :url, :opts, :identity_context, :client
+
+    def initialize(args)
+      @url = args[:url]
+      @opts = args[:opts]
+      @identity_context = args[:identity_context]
+      @client = Protos::Endorser::Stub.new url, :this_channel_is_insecure
+    end
+
+    def send_process_proposal(proposal)
+      client.process_proposal proposal
+    end
+
+    def query_channels
+      request = {
+        targets: [self],
+        chaincode_id: Constants::CSCC,
+        transaction: TransactionID.new(identity_context),
+        function: Constants::FUNC_GET_CHANNELS,
+        args: []
+      }
+
+      responses = PeerEndorser.send_transaction_proposal request, '', identity_context
+      response = responses.first
+
+      Protos::ChannelQueryResponse.decode response.response.payload
+    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
+    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
+  end
+end

data/lib/fabric/peer_endorser.rb

@@ -0,0 +1,85 @@
+require 'peer/peer_services_pb'
+
+module Fabric
+  class PeerEndorser
+    def self.send_transaction_proposal(request, channel_id, identity_context)
+      args = request[:args].unshift request[:function]
+
+      transaction = request[:transaction]
+
+      channel_header = build_channel_header Common::HeaderType::ENDORSER_TRANSACTION,
+                                            channel_id, transaction.id, request[:chaincode_id]
+      header = build_header channel_header, identity_context.identity, transaction.nonce
+      proposal = build_proposal header, request[:chaincode_id], args
+      signed_proposal = sign_proposal identity_context.identity, proposal
+
+      responses = send_peers_process_proposal request[:targets], signed_proposal
+
+      { responses: responses, proposal: proposal, header: header }
+    end
+
+    private
+
+      def self.build_header(channel_header, identity, nonce)
+        signature_header = Common::SignatureHeader.new creator: identity.serialize,
+                                                       nonce: nonce
+
+        Common::Header.new channel_header: channel_header.to_proto,
+                           signature_header: signature_header.to_proto
+      end
+
+      def self.build_channel_header(type, channel_id, tx_id, chaincode_id)
+        attrs = { type: type, channel_id: channel_id, tx_id: tx_id }
+        attrs[:extension] = build_channel_header_extension(chaincode_id).to_proto if chaincode_id
+        attrs[:timestamp] = build_current_timestamp
+        attrs[:version] = Constants::CHANNEL_HEADER_VERSION
+
+        Common::ChannelHeader.new attrs
+      end
+
+      def self.build_channel_header_extension(chaincode_id)
+        id = Protos::ChaincodeID.new name: chaincode_id
+
+        Protos::ChaincodeHeaderExtension.new chaincode_id: id
+      end
+
+      def self.build_current_timestamp
+        now = Time.current
+
+        Google::Protobuf::Timestamp.new seconds: now.to_i, nanos: now.sec
+      end
+
+      def self.build_proposal(header, chaincode_id, args)
+        chaincode_proposal = build_chaincode_proposal chaincode_id, args
+
+        Protos::Proposal.new header: header.to_proto,
+                             payload: chaincode_proposal.to_proto
+      end
+
+      def self.build_chaincode_proposal(chaincode_id, args)
+        id = Protos::ChaincodeID.new name: chaincode_id
+        chaincode_input = Protos::ChaincodeInput.new args: args
+        chaincode_spec = Protos::ChaincodeSpec.new type: Protos::ChaincodeSpec::Type::GOLANG,
+                                                   chaincode_id: id,
+                                                   input: chaincode_input
+        chaincode_invocation_spec =
+          Protos::ChaincodeInvocationSpec.new chaincode_spec: chaincode_spec
+
+        Protos::ChaincodeProposalPayload.new input: chaincode_invocation_spec.to_proto
+      end
+
+      def self.sign_proposal(identity, proposal)
+        proposal_bytes = proposal.to_proto
+        signature = identity.sign(proposal_bytes)
+
+        Protos::SignedProposal.new proposal_bytes: proposal_bytes,
+                                   signature: signature
+      end
+
+      def self.send_peers_process_proposal(peers, proposal)
+        peers.map do |peer|
+          peer.send_process_proposal(proposal)
+        end
+      end
+  end
+end