fabric-gateway 0.1.0 → 0.2.0

data/lib/fabric/gateway/client.rb

@@ -1,13 +0,0 @@
-module Fabric
-  module Gateway
-    class Client
-      attr_accessor :identity
-      attr_accessor :connection
-
-      def initialize(connection, identity) 
-        self.identity = identity
-        self.connection = connection
-      end
-    end
-  end
-end

data/lib/fabric/gateway/constants.rb

@@ -1,20 +0,0 @@
-module Fabric
-  module Gateway
-    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
-    end
-  end
-end

data/lib/fabric/gateway/ec_crypto_suite.rb

@@ -1,172 +0,0 @@
-require 'openssl'
-
-module Fabric
-  module Gateway
-    # Elliptic-curve Crypto Suite using OpenSSL
-    class ECCryptoSuite
-      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_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)
-        OpenSSL::Digest.new('SHA3-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
-
-      def pkey_pem_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)
-
-        pkey = OpenSSL::PKey::EC.new(key.public_key.group)
-        pkey.public_key = key.public_key
-
-        pkey.to_pem
-      end
-
-      def key_from_pem(pem)
-        key = OpenSSL::PKey::EC.new(pem)
-        key.private_key.to_s(16)
-      end
-
-      def pkey_from_x509_certificate(certificate)
-        cert = OpenSSL::X509::Certificate.new(certificate)
-        cert.public_key.public_key.to_bn.to_s(16)
-      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
-  end

data/lib/fabric/gateway/identity.rb

@@ -1,47 +0,0 @@
-require 'msp/identities_pb'
-require 'base64'
-
-module Fabric
-  module Gateway
-    class Identity
-      attr_reader :private_key,
-                  :public_key,
-                  :address,
-                  :crypto_suite
-
-      attr_accessor :pem_certificate, :certificate, :mspid
-
-      def initialize(opts = {})
-        @crypto_suite = opts[:crypto_suite] || Fabric::Gateway.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]
-        @pem_certificate = opts[:pem_certificate]
-        @mspid = opts[:mspid]
-
-        @address = @crypto_suite.address_from_public_key public_key
-      end
-
-      def generate_csr(attrs = [])
-        @crypto_suite.generate_csr private_key, attrs
-      end
-
-      def sign(message)
-        @crypto_suite.sign(private_key, message)
-      end
-
-      def shared_secret_by(public_key)
-        @crypto_suite.build_shared_key private_key, public_key
-      end
-
-      def decoded_certificate
-        Base64.strict_decode64 certificate
-      end
-
-      def serialize
-        Msp::SerializedIdentity.new(mspid: mspid, id_bytes: pem_certificate).to_proto
-      end
-    end
-  end
-end

data/lib/fabric/gateway/proposal.rb

@@ -1,105 +0,0 @@
-module Fabric
-  module Gateway
-    class Proposal
-      attr_reader :identity, :request
-
-      def initialize(identity, request = {})
-        @identity = identity
-        @request = request
-
-        assign_tx request[:transaction_info] if request[:transaction_info]
-      end
-
-      def crypto_suite
-        identity.crypto_suite
-      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.now
-
-        @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
-end

data/lib/fabric/gateway/version.rb

@@ -1,5 +0,0 @@
-module Fabric
-  module Gateway
-    VERSION = "0.1.0"
-  end
-end