hyperledger-fabric-sdk 0.1.0

data/lib/fabric/transaction_id.rb

@@ -0,0 +1,11 @@
+module Fabric
+  class TransactionID
+    attr_reader :nonce, :identity_context, :id
+
+    def initialize(identity_context)
+      @identity_context = identity_context
+      @nonce = identity_context.crypto_suite.generate_nonce
+      @id = identity_context.crypto_suite.hexdigest(nonce + identity_context.identity.serialize)
+    end
+  end
+end

data/lib/fabric/user.rb

@@ -0,0 +1,24 @@
+module Fabric
+  class User
+    attr_reader :username, :roles, :affiliation,
+                :identity, :crypto_suite
+
+    def initialize(args)
+      @crypto_suite = args[:crypto_suite]
+      @username = args[:username]
+      @roles = args[:roles] || []
+      @affiliation = args[:affiliation]
+      @identity = nil
+    end
+
+    def enroll(opts)
+      opts[:crypto_suite] = crypto_suite
+
+      @identity = Identity.new opts
+    end
+
+    def enrolled?
+      identity
+    end
+  end
+end

data/lib/fabric/version.rb

@@ -0,0 +1,3 @@
+module Fabric
+  VERSION = '0.0.1'
+end

data/lib/fabric_ca/client.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../connection', __FILE__)
+require File.expand_path('../request', __FILE__)
+
+module FabricCA
+  class Client
+    include Connection
+    include Request
+
+    attr_accessor *Configuration::VALID_OPTIONS_KEYS
+
+    def initialize(options = {})
+      options = FabricCA.options.merge(options)
+
+      Configuration::VALID_OPTIONS_KEYS.each do |key|
+        send("#{key}=", options[key])
+      end
+    end
+
+    def config
+      conf = {}
+      Configuration::VALID_OPTIONS_KEYS.each do |key|
+        conf[key] = send key
+      end
+
+      conf
+    end
+
+    def enroll(identity_context, msp_id)
+      crypto_suite = identity_context.crypto_suite
+      private_key = crypto_suite.generate_private_key
+      certificate_request = crypto_suite.generate_csr private_key,
+                                                      [['CN', identity_context.username]]
+
+      response = post 'enroll', certificate_request: certificate_request.to_s
+
+      identity_context.enroll private_key: private_key,
+                              certificate: Base64.decode64(response.result['Cert']),
+                              msp_id: msp_id
+
+      identity_context
+    end
+
+    def register(params = {})
+      post 'register', params
+    end
+
+    def tcert(params = {})
+      post 'tcert', params
+    end
+  end
+end

data/lib/fabric_ca/configuration.rb

@@ -0,0 +1,25 @@
+module FabricCA
+  module Configuration
+    VALID_OPTIONS_KEYS = [:endpoint, :identity_context, :username, :password, :logger]
+
+    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_ca/connection.rb

@@ -0,0 +1,32 @@
+require 'faraday_middleware'
+
+Dir[File.expand_path('../faraday_middleware/*.rb', __FILE__)].each { |f| require_relative f }
+
+module FabricCA
+  module Connection
+    private
+
+      def connection(opts = {})
+        Faraday::Connection.new(opts.merge(options)) do |connection|
+          connection.use ::FaradayMiddleware::EncodeJson
+          connection.use FabricCA::FaradayMiddleware::BasicAuth, username, password
+          connection.use FabricCA::FaradayMiddleware::TokenAuth, identity_context
+          connection.use ::Faraday::Request::UrlEncoded
+          connection.use ::FaradayMiddleware::Mashify
+          connection.use ::Faraday::Response::ParseJson
+          connection.use FabricCA::FaradayMiddleware::RaiseHttpException, logger
+          connection.adapter(adapter)
+        end
+      end
+
+      def options
+        {
+          url: endpoint
+        }
+      end
+
+      def adapter
+        Faraday.default_adapter
+      end
+  end
+end

data/lib/fabric_ca/error.rb

@@ -0,0 +1,11 @@
+module FabricCA
+  class Error < StandardError
+    attr_reader :response
+
+    def initialize(message, response)
+      super message
+
+      @response = response
+    end
+  end
+end

data/lib/fabric_ca/faraday_middleware/basic_auth.rb

@@ -0,0 +1,33 @@
+require 'faraday'
+require 'base64'
+
+module FabricCA
+  module FaradayMiddleware
+    class BasicAuth < Faraday::Middleware
+      attr_reader :app, :username, :password
+
+      def call(env)
+        if username && password
+          env[:request_headers] =
+            env[:request_headers].merge(
+              'Authorization' => "Basic #{generate_auth_header}"
+            )
+        end
+
+        app.call env
+      end
+
+      def initialize(app, username, password)
+        @app = app
+        @username = username
+        @password = password
+      end
+
+      private
+
+        def generate_auth_header
+          Base64.encode64 "#{username}:#{password}"
+        end
+    end
+  end
+end

data/lib/fabric_ca/faraday_middleware/raise_http_exception.rb

@@ -0,0 +1,47 @@
+require 'faraday'
+
+module FabricCA
+  module FaradayMiddleware
+    class RaiseHttpException < Faraday::Middleware
+      ## Variables
+      LOGGER_TAG = 'FABRIC CA'
+
+      ## Attributes
+      attr_reader :app, :logger
+
+      def call(env)
+        app.call(env).on_complete do |response|
+          case response[:status].to_i
+          when 400..504
+            message = build_error_message response
+            logging message
+
+            raise FabricCA::Error.new message, response
+          end
+        end
+      end
+
+      def initialize(app, logger)
+        @app = app
+        @logger = logger
+      end
+
+      private
+
+        def build_error_message(response)
+          [
+            response[:method].to_s.upcase,
+            response[:url],
+            response[:status],
+            response[:body]
+          ].join(', ')
+        end
+
+        def logging(message)
+          return unless logger
+
+          logger.tagged(LOGGER_TAG) { |logger| logger.error message }
+        end
+    end
+  end
+end

data/lib/fabric_ca/faraday_middleware/token_auth.rb

@@ -0,0 +1,38 @@
+require 'faraday'
+require 'base64'
+
+module FabricCA
+  module FaradayMiddleware
+    class TokenAuth < Faraday::Middleware
+      attr_reader :app, :identity_context
+
+      def call(env)
+        if identity_context&.enrolled?
+          env[:request_headers] =
+            env[:request_headers].merge(
+              'Authorization' => generate_auth_header(env)
+            )
+        end
+
+        app.call env
+      end
+
+      def initialize(app, identity_context)
+        @app = app
+        @identity_context = identity_context
+      end
+
+      private
+
+        def generate_auth_header(env)
+          body = Base64.strict_encode64(env.body.to_s)
+          identity = identity_context.identity
+          cert = Base64.strict_encode64 identity.certificate
+          body_and_cert = body + '.' + cert
+          sign = Base64.strict_encode64 identity.sign(body_and_cert)
+
+          cert + '.' + sign
+        end
+    end
+  end
+end

data/lib/fabric_ca/request.rb

@@ -0,0 +1,50 @@
+module FabricCA
+  module Request
+    def get(path, params = {}, options = {})
+      request :get, path, params, options
+    end
+
+    def post(path, params = {}, options = {})
+      request :post, path, params, options
+    end
+
+    def put(path, params = {}, options = {})
+      request :put, path, params, options
+    end
+
+    def delete(path, params = {}, options = {})
+      request :delete, path, params, options
+    end
+
+    private
+
+      def request(method, path, params, options)
+        response = send_request method, path, params, options
+
+        Response.create response.body
+      end
+
+      def send_request(method, path, params, options)
+        connection(options).send(method) do |request|
+          case method
+          when :get, :delete
+            request.url(URI.encode(path), params)
+          when :post, :put
+            p path
+            p params.to_json
+            p method
+            p options
+            request.path = URI.encode path
+            request.body = params unless params.empty?
+            request.options.params_encoder = Encoder.new
+          end
+        end
+      end
+  end
+end
+
+class Encoder
+  def encode(param)
+    param.to_json
+  end
+end

data/lib/fabric_ca/response.rb

@@ -0,0 +1,10 @@
+module FabricCA
+  module Response
+    def self.create(response_hash)
+      data = response_hash
+      data.extend(self)
+
+      data
+    end
+  end
+end

data/lib/fabric_ca/tools.rb

@@ -0,0 +1,35 @@
+module FabricCA
+  module Tools
+    HEADER_IDENTIFIER = [1, 2, 3, 4, 5, 6, 9].freeze
+
+    def self.extract_attributes(pem)
+      extensions = extract_extensions pem
+
+      attributes = {}
+      extensions[HEADER_IDENTIFIER.join('.')].to_s.split('#').each do |key|
+        id, num = key.split('->')
+
+        attributes[id] = extensions[build_attribute_id(HEADER_IDENTIFIER, num.to_i).join('.')]
+      end
+
+      attributes
+    end
+
+    def self.extract_extensions(pem)
+      certificate = OpenSSL::X509::Certificate.new pem
+      extensions = {}
+      certificate.extensions.each { |ext| extensions[ext.oid] = ext.value }
+
+      extensions
+    end
+
+    private
+
+      def self.build_attribute_id(header_identifier, step)
+        numbers = header_identifier.dup
+        numbers[-1] += step
+
+        numbers
+      end
+  end
+end

data/lib/fabric_ca/version.rb

@@ -0,0 +1,3 @@
+module FabricCA
+  VERSION = '0.0.1'
+end

data/lib/hyperledger-fabric-sdk.rb

@@ -0,0 +1,47 @@
+lib_dir = File.join(File.expand_path(File.dirname(__FILE__)), 'protos')
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require_relative 'fabric/version'
+require_relative 'fabric/configuration'
+require_relative 'fabric/constants'
+require_relative 'fabric/client'
+require_relative 'fabric/peer_endorser'
+require_relative 'fabric/transaction_id'
+require_relative 'fabric/channel'
+require_relative 'fabric/peer'
+require_relative 'fabric/orderer'
+require_relative 'fabric/user'
+require_relative 'fabric/identity'
+
+require_relative 'fabric_ca/error'
+require_relative 'fabric_ca/configuration'
+require_relative 'fabric_ca/client'
+require_relative 'fabric_ca/response'
+require_relative 'fabric_ca/version'
+require_relative 'fabric_ca/tools'
+
+require_relative 'crypto_suite/ecdsa_aes'
+
+require 'common/common_pb'
+require 'common/configtx_pb'
+
+module Fabric
+  extend Configuration
+
+  def self.new(config)
+    client = Fabric::Client.new config[:options]
+
+    config[:orderer_urls].each { |url| client.new_orderer url }
+    config[:peer_urls].each { |url| client.new_peer url }
+
+    client
+  end
+end
+
+module FabricCA
+  extend Configuration
+
+  def self.new(options = {})
+    FabricCA::Client.new(options)
+  end
+end