ig-crypto-utils 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ec754385ef30a08d89b3c0b866245b404a50868a
+  data.tar.gz: 369c33e30159d8e254ae73dbe447d359c6eb7f2a
+SHA512:
+  metadata.gz: 727072d7053adf71cce4fbd9bab32a2ac3b99145fe5f31b203a45aa3d817adbd700b3618f5896a09e9fb8cd201e622043667ff377fa5975de62c53cac5772578
+  data.tar.gz: dac2ad1dd4a0159bc10410d945a570220db8e145b528b1e2bb3793f260b6b32043a59c8bc4e72ec587b8b41cdd25580915e12a0eba8e3eb319e63539380ce51d

data/ig-crypto-utils.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name        = 'ig-crypto-utils'
+  s.version     = '0.0.2'
+  s.date        = '2015-04-17'
+  s.summary     = 'AES and EDCSA utils based on OpenSSL'
+  s.description = 'Asymmetric/symmetric encryption utility'
+  s.authors     = ['Infinity-G']
+  s.email       = 'developer@infinity-g.com'
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+  s.homepage    = ''
+  s.license     = 'MIT'
+end
+
+# run 'gem build ig-crypto-utils' to create gem
+# run

data/lib/ig-crypto-utils.rb

@@ -0,0 +1,142 @@
+require 'securerandom'
+require 'digest'
+require 'base64'
+require 'openssl'
+
+# NOTE: All inputs of methods in this module require Base64 encoding!
+# Outputs are all Base64 encoded
+
+module CryptoUtils
+
+  # General use static functions
+
+  def self.encode_base64(value)
+    unless value =~ /^([A-Za-z0-9+]{4})*([A-Za-z0-9+]{4}|[A-Za-z0-9+]{3}=|[A-Za-z0-9+]{2}==)$/i
+      puts "#{value} is NOT base64 encoded, ENCODING..."
+      return Base64.encode64 value
+    end
+
+    value
+  end
+
+  def self.decode_base64(value)
+    if value =~ /^([A-Za-z0-9+]{4})*([A-Za-z0-9+]{4}|[A-Za-z0-9+]{3}=|[A-Za-z0-9+]{2}==)$/i
+      puts "#{value} is base64 encoded, ...DECODING"
+      return Base64.decode64 value
+    end
+
+    value
+  end
+
+  def self.create_digest(value)
+    Digest::SHA2.base64digest value
+  end
+
+  #############################
+  # SYMMETRIC ENCRYPTION UTIL
+  #############################
+
+  class AesUtil
+    # https://gist.github.com/byu/99651
+    # http://ruby-doc.org/stdlib-1.9.3/libdoc/openssl/rdoc/OpenSSL/Cipher.html
+
+    def encrypt(encoded_plain_text, encoded_key)
+
+      cipher = OpenSSL::Cipher::AES.new(256, :CBC) # CBC = cipher block chaining
+      cipher.encrypt
+
+      # generate a random iv
+      iv = cipher.random_iv
+
+      cipher.key = encoded_key
+      cipher.iv = iv
+
+      result = cipher.update(encoded_plain_text) + cipher.final
+
+      encoded_result = Base64.encode64 result
+      encoded_iv = Base64.encode64 iv
+
+      {:cipher_text => encoded_result, :iv => encoded_iv}
+    end
+
+    def decrypt(encoded_cipher_text, encoded_key, encoded_iv)
+
+      decoded_cipher_text = Base64.decode64 encoded_cipher_text
+      decoded_iv = Base64.decode64 encoded_iv
+
+      cipher = OpenSSL::Cipher::AES.new(256, :CBC)
+      cipher.decrypt
+
+      cipher.key = encoded_key
+      cipher.iv = decoded_iv
+
+      cipher.update(decoded_cipher_text) + cipher.final
+    end
+
+  end
+
+  ##########################
+  # ASYMMETRIC SIGNING UTIL
+  ##########################
+
+  class EcdsaUtil
+
+    # for a 256-bit ECDSA curve, the uncompressed pubkey is 512 bits (256 bits of x, 256 bits of y, no sign bit).
+    # The compressed pubkey is 257 bits (256 bits of x, one bit of the sign of y).
+    def create_key_pair
+      group_name = 'secp256k1'
+
+      # set compression to true for key generation on the group
+      group = OpenSSL::PKey::EC::Group.new(group_name)
+      group.point_conversion_form = :compressed
+
+      # instantiate the curve and generate the keys
+      curve = OpenSSL::PKey::EC.new(group)
+      curve.generate_key
+
+      public_key = curve.public_key
+      private_key = curve.private_key
+
+      # get binary representation of keys
+      pk_bn_bin = public_key.to_bn.to_s(2)
+      sk_bn_bin = private_key.to_s(2)
+
+      #base64 encode keys
+      encoded_pk = Base64.encode64(pk_bn_bin)
+      encoded_sk = Base64.encode64(sk_bn_bin)
+
+      {:pk => encoded_pk, :sk => encoded_sk}
+
+    end
+
+    def sign(encoded_data, encoded_private_key)
+      group_name = 'secp256k1'
+
+      decoded_data = Base64.decode64 encoded_data
+      decoded_private_key = Base64.decode64 encoded_private_key
+
+      curve = OpenSSL::PKey::EC.new(group_name)
+      curve.private_key = OpenSSL::BN.new(decoded_private_key, 2)
+
+      result = curve.dsa_sign_asn1 decoded_data
+
+      Base64.encode64 result
+    end
+
+    def validate_signature(encoded_digest, encoded_signature, encoded_public_key)
+      group_name = 'secp256k1'
+
+      decoded_signature = Base64.decode64 encoded_signature
+      decoded_digest = Base64.decode64 encoded_digest
+      decoded_public_key = Base64.decode64 encoded_public_key
+
+      curve = OpenSSL::PKey::EC.new(group_name)
+      key_bn = OpenSSL::BN.new(decoded_public_key, 2)
+      group = OpenSSL::PKey::EC::Group.new(group_name)
+      curve.public_key = OpenSSL::PKey::EC::Point.new(group, key_bn)
+
+      curve.dsa_verify_asn1(decoded_digest, decoded_signature)
+    end
+  end
+
+end

data/tests/aes_tests.rb

@@ -0,0 +1,27 @@
+require 'minitest'
+require 'minitest/autorun'
+require 'base64'
+
+require_relative '../../ig-crypto-utils/lib/ig-crypto-utils'
+
+class AesTests < MiniTest::Test
+
+  def test_encrypt
+    # NOTE: AesUtil methods expect all inputs to be Base64 encoded
+
+    util = CryptoUtils::AesUtil.new
+
+    plain_text = '{"blah":"Super secret text"}'
+    encoded_plain_text = Base64.encode64 plain_text
+
+    aes_256_key = 'ky4xgi0+KvLYmVp1J5akqkJkv8z5rJsHTo9FcBc0hgo='  # already base64 encoded
+
+    # encrypt
+    encrypted_result = util.encrypt encoded_plain_text, aes_256_key
+
+    # decrypt
+    decrypted_result = util.decrypt encrypted_result[:cipher_text], aes_256_key, encrypted_result[:iv]
+
+    assert decrypted_result == encoded_plain_text
+  end
+end

data/tests/ecdsa_tests.rb

@@ -0,0 +1,36 @@
+require 'minitest'
+require 'minitest/autorun'
+require 'base64'
+
+require_relative '../../ig-crypto-utils/lib/ig-crypto-utils'
+
+class EcdsaTests < MiniTest::Test
+
+  def test_create_key_pair
+    result = CryptoUtils::EcdsaUtil.new.create_key_pair
+
+    assert result[:pk]!= nil
+    assert result[:sk]!= nil
+  end
+
+  def test_sign
+    text = 'Text to sign'
+    text_digest = CryptoUtils.create_digest text
+    encoded_text_digest = Base64.encode64 text_digest
+
+    encoded_secret_key = 'gCrHtl8VVWs6EuJLy7vPqVdBZWzRAR9ZCjIRRpoWvME=' # already base64 encoded
+    encoded_public_key = 'Ag7PunGy2BmnAi+PGE4/Dm9nCg1URv8wLZwSOggyfmAn' # already base64 encoded
+
+    util = CryptoUtils::EcdsaUtil.new
+
+    # sign
+    encoded_result = util.sign encoded_text_digest, encoded_secret_key
+
+    # validate
+    validation_result = util.validate_signature encoded_text_digest, encoded_result, encoded_public_key
+
+    puts validation_result
+    assert validation_result
+
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: ig-crypto-utils
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Infinity-G
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-17 00:00:00.000000000 Z
+dependencies: []
+description: Asymmetric/symmetric encryption utility
+email: developer@infinity-g.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ig-crypto-utils.gemspec
+- lib/ig-crypto-utils.rb
+- tests/aes_tests.rb
+- tests/ecdsa_tests.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: AES and EDCSA utils based on OpenSSL
+test_files: []