record_on_chain 0.1.0

data/lib/record_on_chain/commands/secret.rb

@@ -0,0 +1,57 @@
+require "pathname"
+require_relative "./abstract_command"
+require_relative "./mod_command"
+require_relative "../constants"
+require_relative "../keyfile"
+require_relative "../crypto/default_cryptor"
+
+module RecordOnChain
+  module Commands
+    class Secret < AbstractCommand
+
+      def self.description
+        return "recover secret from keyfile"
+      end
+
+      def self.usage
+        output = <<-EOS
+ -k <value> => keyfile path ( default : $HOME/.ro_chain/default_key.yml )
+
+ (e.g.) keyfile_path:/home/user/doc/.ro_chain/my_key.yml
+ => $ rochain secret -k /home/user/doc/.ro_chain/my_key.yml
+        EOS
+        return output
+      end
+
+      def initialize( argv= ARGV , cli= Cli.new )
+        super( argv.first , cli )
+        val_context  = { "-k" => :keyfile_path }
+        flag_context = {}
+
+        args = squeeze_args_from_argv( val_context , flag_context , argv )
+
+        default_path = Pathname.new( Dir.home ) +
+                       MAINDIR_NAME   +
+                       D_KEYFILE_NAME ;
+        keyfile_path = args[:keyfile_path] ? args[:keyfile_path] : default_path.to_s
+
+        @keyfile = load_datafile( keyfile_path , "keyfile" )
+      rescue => e
+        roc_exit( :halt , "#{e.message}" )
+      end
+
+      def start
+        secret = get_secret( @cli, @keyfile )
+        msg    = "Secret [ #{secret} ]"
+        roc_exit( :nomal_end , msg )
+      rescue => e
+        roc_exit( :halt , "#{e.message}" )
+      end
+
+      private
+
+      include M_LoadDatafile
+      include M_GetSecret
+    end
+  end
+end

data/lib/record_on_chain/config.rb

@@ -0,0 +1,12 @@
+require_relative "./datafile_base"
+
+module RecordOnChain
+  class Config
+    extend DatafileBase
+    define_datafile_class(
+      { :var => :keyfile_path , :type => String },
+      { :var => :recipient    , :type => String },
+      { :var => :add_node     , :type => Array  }
+    )
+  end
+end

data/lib/record_on_chain/constants.rb

@@ -0,0 +1,21 @@
+module RecordOnChain
+  # region generally
+  MAINDIR_NAME = ".ro_chain".freeze
+
+  # region crypto
+  SECRET_LENGTH   = 32.freeze
+  SALT_LENGTH     = 16.freeze
+  CHECKSUM_LENGTH = 4.freeze
+
+  # region datafile
+  D_DATAFILE_NAME     = "default".freeze
+  D_KEYFILE_SUFFIX    = "_key.yml".freeze
+  D_CONFIGFILE_SUFFIX = "_config.yml".freeze
+
+  D_KEYFILE_NAME    = ( D_DATAFILE_NAME + D_KEYFILE_SUFFIX ).freeze
+  D_CONFIGFILE_NAME = ( D_DATAFILE_NAME + D_CONFIGFILE_SUFFIX ).freeze
+
+  # region dirpath
+  COMMANDS_DIRPATH  = File.expand_path( "../commands"     , __FILE__ ).freeze
+  RESOURCES_DIRPATH = File.expand_path( "../../resources" , __FILE__ ).freeze
+end

data/lib/record_on_chain/crypto/aes.rb

@@ -0,0 +1,51 @@
+# reference
+# https://docs.ruby-lang.org/ja/latest/class/OpenSSL=3a=3aCipher.html
+require 'openssl'
+
+module RecordOnChain
+  module Crypto
+    class AES
+      def encrypt( passwd, salt, secret )
+        return crypto_func_base( passwd, salt, secret, :encrypt )
+      end
+
+      def decrypt( passwd, salt, encrypted_data )
+        return crypto_func_base( passwd, salt, encrypted_data, :decrypt )
+      end
+
+      private
+      def generate_base
+        return OpenSSL::Cipher.new("AES-256-CBC")
+      end
+
+      def calc_key_and_initvector( passwd, salt )
+        aes = generate_base
+        # key_inv = key( aes.key_len byte ) | inv ( aes.iv_len byte )
+        key_iv = OpenSSL::PKCS5.pbkdf2_hmac_sha1( passwd, salt, 2000, aes.key_len + aes.iv_len )
+        key = key_iv[ 0,aes.key_len ]
+        iv  = key_iv[ aes.key_len, aes.iv_len ]
+        return { key: key, initvector: iv }
+      end
+
+      def set_key_iv( aes, passwd, salt )
+        key_iv = calc_key_and_initvector( passwd, salt )
+        aes.key = key_iv[ :key ]
+        aes.iv  = key_iv[ :initvector ]
+      end
+
+      #@param [passwd] passwd
+      #@param [salt] salt
+      #@param [data] :encrypt => secret_data , decrypt => encrypted_data
+      #@param [encrypt_or_decrypt] :encrypt or :decrypt (symbol)
+      def crypto_func_base( passwd, salt, data, encrypt_or_decrypt )
+        aes = generate_base
+        aes.send( encrypt_or_decrypt )
+        set_key_iv( aes, passwd, salt )
+        output = ""
+        output << aes.update( data )
+        output<< aes.final
+        return output
+      end
+    end
+  end
+end

data/lib/record_on_chain/crypto/cryptor.rb

@@ -0,0 +1,60 @@
+require "digest/md5"
+require_relative '../utils'
+require_relative '../constants'
+
+module RecordOnChain
+  module Crypto
+    class Cryptor
+      def initialize( crypto_engine )
+        @crypto_engine = crypto_engine
+      end
+
+      def generate_secret
+        return SecureRandom.hex( SECRET_LENGTH )
+      end
+
+      def generate_salt
+        return SecureRandom.hex( SALT_LENGTH )
+      end
+
+      def encrypt( passwd, hex_salt, hex_secret )
+        b_secret = Utils.hex_to_bytes( hex_secret )
+        # add checksum to secret
+        b_secret << calc_checksum( b_secret )
+        b_salt   = Utils.hex_to_bytes( hex_salt )
+        encrypted = @crypto_engine.encrypt( passwd, b_salt, b_secret )
+        return Utils.bytes_to_hex( encrypted )
+      end
+
+      def decrypt( passwd, hex_salt, hex_encrypted_data )
+        b_data = Utils.hex_to_bytes( hex_encrypted_data )
+        b_salt = Utils.hex_to_bytes( hex_salt )
+        decrypted = ""
+        begin
+          # At this point it is not known whether the decrypted data is correct or not.
+          # You should verify decrypted data with checksum.
+          decrypted = @crypto_engine.decrypt( passwd, b_salt, b_data )
+        rescue OpenSSL::Cipher::CipherError
+          # fail to encrypt
+          return ""
+        end
+        # validate checksum
+        secret_length = decrypted.size - CHECKSUM_LENGTH
+        secret_part   = decrypted[0,secret_length]
+        checksum_part = decrypted[secret_length..-1]
+        checksum = calc_checksum( secret_part )
+        # not match checksum
+        return "" unless checksum_part == checksum
+        # match checksum
+        return Utils.bytes_to_hex( secret_part )
+      end
+
+      private
+
+      def calc_checksum( data )
+        # MD5 Hash [0..CCHECKSUM_LENGTH]
+        return Digest::MD5.digest( data )[ 0 , CHECKSUM_LENGTH ]
+      end
+    end
+  end
+end

data/lib/record_on_chain/crypto/default_cryptor.rb

@@ -0,0 +1,12 @@
+require_relative "./aes"
+require_relative "./cryptor"
+
+module RecordOnChain
+  module Crypto
+    class DefaultCryptor
+      def self.generate
+        return Crypto::Cryptor.new( Crypto::AES.new )
+      end
+    end
+  end
+end

data/lib/record_on_chain/datafile_base.rb

@@ -0,0 +1,101 @@
+require "yaml"
+require_relative "./utils"
+
+module RecordOnChain
+  module DatafileBase
+    # status_context = { :var => variable_name , :type => variable_type }
+    def define_datafile_class(*status_context)
+
+      variables = status_context.map{ |c| c[:var] }
+
+      # [ presudo code ]
+      # def initialize( args )
+      #   @status1 = args[1]
+      #   @status2 = args[2]
+      #   ...
+      # end
+      define_method(:initialize) do |*args|
+        variables.each_with_index do |var , index|
+          # add "@" to sym
+          # [e.g.] { var: :name , type: String } => :name => :@name
+          var_name = ( "@#{var}" ).to_sym
+          instance_variable_set( var_name, args[index] )
+        end
+      end
+
+      attr_reader *variables
+
+      # [ presudo code ]
+      # def to_yml
+      #   hash = [ status1: @status1, status2: @status2 ... ]
+      #   return hash.to_yml
+      # end
+      define_method(:to_yml) do
+        hash = {}
+        instance_variables.each do |var_sym|
+          # delete "@" from instance_variables sym
+          # [e.g.] :@status1 => :status1
+          key = var_sym.to_s.delete("@").to_sym
+          # hash[ :status1 ] = @status1
+          hash[key] = instance_variable_get( var_sym )
+        end
+        return hash.to_yaml
+      end
+
+      # [ presudo code ]
+      # self.def generate( filepath , *args )
+      #   obj = Datafile.new( *args )
+      #   yml = obj.to_yml
+      #   File.open( filepath, "w" ){ |f| f.write( yml ) }
+      # end
+      singleton_class.send( :define_method , :generate ) do |filepath , *args|
+        datafile_obj = new( *args )
+        yml = datafile_obj.to_yml
+        File.open( filepath , "w" ){ |f| f.write( yml ) }
+      end
+
+      # [ presudo code ]
+      # def self.load( filepath )
+      #   hash = YAML.load_file( filepath )
+      #   return from_hash( hash )
+      # end
+      singleton_class.send( :define_method , :load ) do |filepath|
+        hash = YAML.load_file( filepath )
+        # RecordOnChain::Utils
+        hash = Utils.symbolize_hashkeys_rf( hash )
+        return from_hash(hash)
+      end
+
+      # [ presudo code ]
+      # def self.from_hash( hash )
+      #
+      #   types = { status1: String , status2: String , status3: Integer ,...}
+      #
+      #   return nil if hash[ :status1 ].nil? || hash[ :status1 ].class != types[ :status1 ]
+      #   @status1 = hash[;status1]
+      #
+      #   return nil if hash[ :status2 ].nil?|| hash[ :status2 ].class != types[ :status2 ]
+      #   @status2 = hash[;status2]
+      #
+      #   return nil if hash[ :status3 ].nil?|| hash[ :status3 ].class != types[ :status3 ]
+      #   @status3 = hash[;status3]
+      #   ...
+      # end
+      singleton_class.send( :define_method , :from_hash ) do |hash|
+        args  = []
+        
+        types = status_context.map{ |c| c[:type] }
+
+        variables.each_with_index do |var,index|
+          value = hash[ var ]
+          # If there is missing status in hash, return nil without generating the object
+          return nil if value.nil?
+          # If type of field does not match type of context, return nil without generating the object
+          return nil unless value.class == types[ index ]
+          args.push( value )
+        end
+        return new(*args)
+      end
+    end
+  end
+end

data/lib/record_on_chain/keyfile.rb

@@ -0,0 +1,14 @@
+require_relative "./datafile_base"
+
+module RecordOnChain
+  class Keyfile
+    extend DatafileBase
+    define_datafile_class(
+      { :var => :network_type     , :type => String },
+      { :var => :salt             , :type => String },
+      { :var => :encrypted_secret , :type => String },
+      { :var => :public_key       , :type => String },
+      { :var => :address          , :type => String }
+    )
+  end
+end

data/lib/record_on_chain/nem_controller.rb

@@ -0,0 +1,113 @@
+require "nem"
+
+module RecordOnChain
+  class NemController
+    @@NET_TYPES = [:testnet , :mainnet].freeze
+
+    def self.public_from_secret( secret )
+      return Nem::Keypair.new( secret ).public
+    end
+
+    def self.address_from_public( public_key , network_type )
+      return Nem::Unit::Address.from_public_key( public_key , network_type.to_sym ).to_s
+    end
+
+    def self.address_from_secret( secret , network_type )
+      public_key = public_from_secret( secret )
+      return address_from_public( public_key , network_type.to_sym )
+    end
+
+    def initialize( node_url_set , network_type = :testnet )
+      raise ArgumentError,"Node set must not be empty." if node_url_set.empty?
+      raise ArgumentError,"Unknown network type.[:testnet,:mainnet]" unless @@NET_TYPES.include?(network_type.to_sym)
+
+      # make node_pool from node_set
+      node_objects = []
+      node_url_set.each do |url|
+        node_object = Nem::Node.new( url: url )
+        node_objects.push( node_object )
+      end
+      @node_pool = Nem::NodePool.new( node_objects )
+      @network_type  = network_type.to_sym
+    end
+
+    def get_address_status( address )
+      endpoint = Nem::Endpoint::Account.new( @node_pool )
+      add = endpoint.find( address )
+      multisig = !add.cosignatories.empty?
+      return { balance: add.balance , multisig: multisig }
+    end
+
+    def prepare_tx( recipient_str, msg )
+      check_address( recipient_str )
+      modified_address = modify_address( recipient_str )
+      # NOTE: Timestamp is set to -10 sec from Time.now.It prevent FAILURE_TIMESTAMP_TOO_FAR_IN_FUTURE
+      @tx = Nem::Transaction::Transfer.new( modified_address, 0, msg, timestamp: Time.now() -10, network: @network_type )
+    end
+
+    def calc_fee
+      prepared?
+      fee = Nem::Fee::Transfer.new( @tx )
+      return fee.to_i
+    end
+
+    def send_transfer_tx( private_key )
+      prepared?
+      result = broadcast_transfer_tx( private_key )
+      return result
+    end
+
+    # default log path : stdout
+    def set_log_path( dir_path )
+      log_name = "nem_controller.log"
+      Nem.logger = Logger.new( dir_path + log_name )
+    end
+
+    private
+
+    def prepared?
+      raise "Error : Please prepare tx before getting fee." if @tx.nil?
+    end
+
+    # delete sigins & upcase
+    def modify_address( address )
+      return address.gsub( /\W/ , "" ).upcase
+    end
+
+    # check whether address matches network_type
+    def check_address( recipient_str )
+      initial = recipient_str.upcase[0]
+      error_msg = "Illegal address. You should make sure address and network type."
+      case initial
+      when "T" then
+        raise ArgumentError,error_msg  unless @network_type == :testnet
+      when "N" then
+        raise ArgumentError,error_msg  unless @network_type == :mainnet
+      else
+        raise ArgumentError,error_msg
+      end
+    end
+
+    def broadcast_transfer_tx( sender_privatekey )
+      sender_keypair   = Nem::Keypair.new( sender_privatekey )
+      announce_request = Nem::Request::Announce.new( @tx, sender_keypair )
+      endpoint = Nem::Endpoint::Transaction.new( @node_pool )
+      response = {}
+      begin
+        # If node pool has next node, it will automatically retry sending transaction.
+        response = endpoint.announce( announce_request )
+      rescue => e
+        # all node failure
+        return { success?: false, message: e.message, error_type: e.class.to_s }
+      end
+      # response.code == 1 ~> success
+      # rasponse.code != 1 -> something failure
+      case response.code
+      when 1 then
+        return { success?: true, message: response.message, tx_hash: response.transaction_hash }
+      else
+        return { success?: false, message: response.message, error_type: e.class.to_s }
+      end
+    end
+  end
+end