ccrypto-java 0.1.0

data/lib/ccrypto/java/engines/cipher_engine.rb

@@ -0,0 +1,255 @@
+
+require_relative '../data_conversion'
+
+module Ccrypto
+  module Java
+    class CipherEngine
+      include TR::CondUtils
+      include DataConversion
+
+      include TeLogger::TeLogHelper
+
+      teLogger_tag :j_cipher
+
+      def self.supported_ciphers
+        res = java.security.Security.getAlgorithms("Cipher").to_a.delete_if { |e| e.include?(".") }.sort
+      end
+
+      def self.is_supported_cipher?(c)
+        case c
+        when String, java.lang.String
+          javax.crypto.Cipher.getInstance(c)
+        when Hash
+          spec = to_spec(c)
+          javax.crypto.Cipher.getInstance(spec)
+        else
+          raise CipherEngineException, "Unsupported input #{c} to check supported cipher"
+        end
+      end
+
+      def self.to_spec(hash)
+        res = []
+        res << hash[:algo].to_s
+        res << hash[:mode].to_s
+        res << hash[:padding].to_s
+        res.join("/")
+      end
+
+      def supported_ciphers
+        self.class.supported_ciphers
+      end
+
+      def initialize(*args, &block)
+
+        @spec = args.first
+
+        case @spec
+        when String, java.lang.String, Hash
+          @spec = Ccrypto::DirectCipherConfig.new(@spec)
+        when Ccrypto::CipherConfig
+        else
+          raise Ccrypto::CipherEngineException, "Unsupported config type #{@spec.class}"
+        end
+
+
+        if block
+          @cipherJceProvider = block.call(:cipher_jceProvider)
+          @keygenJceProvider = block.call(:keygen_jceProvider)
+        end
+
+        cSpec = to_cipher_spec(@spec)
+        if @cipherJceProvider.nil?
+          begin
+            teLogger.debug "Cipher instance #{cSpec} with null provider"
+            @cipher = javax.crypto.Cipher.getInstance(cSpec)
+          rescue Exception => ex
+            teLogger.debug "Error #{ex.message} for spec '#{cSpec}' using null provider. Retest with BC provider"
+            @cipher = javax.crypto.Cipher.getInstance(cSpec, Ccrypto::Java::JCEProvider::BCProv.name)
+          end
+        else
+          teLogger.debug "Cipher instance #{cSpec} with provider '#{@cipherJceProvider.is_a?(String) ? @cipherJceProvider : @cipherJceProvider.name}'"
+          @cipher = javax.crypto.Cipher.getInstance(cSpec, @cipherJceProvider)
+        end
+
+
+        if @spec.has_key?
+          teLogger.debug "Using given cipher key"
+
+        else
+          
+          teLogger.debug "Generating cipher key"
+          if @keygenJceProvider.nil?
+            kg = javax.crypto.KeyGenerator.getInstance(to_algo(@spec.algo))
+          else
+            kg = javax.crypto.KeyGenerator.getInstance(to_algo(@spec.algo), @keygenJceProvider)
+          end
+
+          kg.init(@spec.keysize.to_i)
+          @spec.key = kg.generateKey
+
+        end
+
+        if @spec.iv.is_a?(String)
+          @spec.iv = to_java_bytes(@spec.iv)
+        end
+
+        if @spec.is_mode?(:gcm) or @spec.is_algo?(:chacha20)
+          if is_empty?(@spec.iv)
+            teLogger.debug "Generating 12 bytes of IV"
+            @spec.iv = Ccrypto::Java::SecureRandomEngine.random_bytes(12)
+          else
+            teLogger.debug "Using given IV"
+          end
+
+          if @spec.is_mode?(:gcm)
+            ivParam = javax.crypto.spec.GCMParameterSpec.new(@spec.iv.length*8, @spec.iv) # 16 bytes
+          else
+            ivParam = javax.crypto.spec.IvParameterSpec.new(@spec.iv) # 16 bytes
+          end
+
+        elsif @spec.is_algo?(:blowfish)
+          if is_empty?(@spec.iv)
+            teLogger.debug "Generating 8 bytes of IV"
+            @spec.iv = Ccrypto::Java::SecureRandomEngine.random_bytes(8)
+          else
+            teLogger.debug "Using given IV"
+          end
+          ivParam = javax.crypto.spec.IvParameterSpec.new(@spec.iv)
+
+        elsif @spec.is_mode?(:cbc) or @spec.is_mode?(:ctr) or @spec.is_mode?(:cfb) or @spec.is_mode?(:ofb)
+          if is_empty?(@spec.iv)
+            teLogger.debug "Generating 16 bytes of IV" 
+            @spec.iv = Ccrypto::Java::SecureRandomEngine.random_bytes(16)
+          else
+            teLogger.debug "Using given IV"
+          end
+          ivParam = javax.crypto.spec.IvParameterSpec.new(@spec.iv)
+
+        end
+
+        #teLogger.debug "IV : #{@spec.iv}"
+
+        case @spec.key
+        when Ccrypto::SecretKey
+          skey = @spec.key.key
+        when ::Java::byte[]
+          skey = javax.crypto.spec.SecretKeySpec.new(@spec.key, @spec.algo.to_s)
+        when String
+          skey = javax.crypto.spec.SecretKeySpec.new(to_java_bytes(@spec.key), @spec.algo.to_s)
+        when javax.crypto.spec.SecretKeySpec
+          skey = @spec.key
+        else
+          raise CipherEngineException, "Unknown key type '#{@spec.key}'"
+        end
+
+        #teLogger.debug "SKey : #{skey.encoded}"
+
+        case @spec.cipherOps
+        when :encrypt, :enc
+          if ivParam.nil?
+            teLogger.debug "Encryption mode"
+            @cipher.init(javax.crypto.Cipher::ENCRYPT_MODE, skey)
+          else
+            teLogger.debug "Encryption mode with IV"
+            @cipher.init(javax.crypto.Cipher::ENCRYPT_MODE, skey, ivParam)
+          end
+
+        when :decrypt, :dec
+          if ivParam.nil?
+            teLogger.debug "Decryption mode"
+            @cipher.init(javax.crypto.Cipher::DECRYPT_MODE, skey)
+          else
+            teLogger.debug "Decryption mode with IV"
+            @cipher.init(javax.crypto.Cipher::DECRYPT_MODE, skey, ivParam)
+          end
+
+        else
+          raise Ccrypto::CipherEngineException, "Cipher operation must be given"
+        end
+
+        if @spec.is_mode?(:gcm) and not_empty?(@spec.auth_data)
+          teLogger.debug "Adding additional authenticated data for GCM mode"
+          @cipher.updateAAD(to_java_bytes(@spec.auth_data))
+        end
+
+      end
+
+      def update(val)
+        teLogger.debug "Passing #{val.length} bytes to cipher"
+        res = @cipher.update(to_java_bytes(val))  
+        if res.nil?
+          teLogger.debug "Cipher update returns nothing"
+        else
+          teLogger.debug "Cipher update output length #{res.length}"
+        end
+        res
+      end
+
+      def final(val = nil, &block)
+        baos = java.io.ByteArrayOutputStream.new
+        if not_empty?(val)
+          res = update(val)
+          baos.write(res) if not_empty?(res)
+        end
+
+        begin
+          res = @cipher.doFinal
+
+          teLogger.debug "Final output length : #{res.length}"
+
+          if @spec.is_mode?(:gcm) and @spec.is_encrypt_cipher_mode?
+            # extract auth_tag
+            @spec.auth_tag = res[-16..-1]
+            @spec.auth_tag = String.from_java_bytes(@spec.auth_tag) if not_empty?(@spec.auth_tag)
+          end 
+
+          baos.write(res) if not_empty?(res)
+          baos.toByteArray
+
+        rescue Exception => ex
+          raise Ccrypto::CipherEngineException, ex
+        end
+      end
+
+      def reset
+        #@cipher.reset
+      end
+
+      private
+      def to_algo(algo)
+        algo.to_s.gsub("_","-")
+      end
+
+      def to_cipher_spec(spec)
+        res = []
+
+        res << spec.algo.to_s.gsub("_","-")
+
+        res << spec.mode if not_empty?(spec.mode)
+
+        if spec.algo.to_s.downcase == "aria" and spec.mode.to_s.downcase == "gcm"
+          # for some reasons only aria gcm trigger this error
+          res << "NoPadding"
+        elsif spec.mode.to_s.downcase != "poly1305"
+          case spec.padding 
+          when :pkcs5
+            res << "PKCS5Padding"
+          when :pkcs7
+            res << "PKCS7Padding"
+          when :nopadding
+            res << "NOPadding"
+          end
+        end
+
+        if spec.is_algo?(:chacha20)
+          res.join("-")
+        elsif spec.is_algo?(:blowfish)
+          res[0]
+        else
+          res.join("/")
+        end
+      end
+
+    end
+  end
+end

data/lib/ccrypto/java/engines/compression_engine.rb

@@ -0,0 +1,92 @@
+
+require_relative '../data_conversion'
+
+module Ccrypto
+  module Java
+    class Compression
+      include DataConversion
+      include TR::CondUtils
+
+      include TeLogger::TeLogHelper
+
+      teLogger_tag :j_compression
+
+      def initialize(*args, &block)
+
+        @config = args.first
+        raise CompressionError, "Compress Config is expected. Given #{@config}" if not @config.is_a?(Ccrypto::CompressionConfig)
+        
+        #if block
+
+        #  outPath = block.call(:out_path)
+        #  if is_empty?(outPath)
+        #    outFile = block.call(:out_file) 
+        #    raise CompressionError, "OutputStream required" if not outFile.is_a?(java.io.OutputStream)
+        #    @out = outFile
+        #  else
+        #    @out = java.io.RandomAccessFile.new(java.io.File.new(outPath), "w")
+        #  end
+
+        #  @intBufSize = block.call(:int_buf_size) || 102400
+
+        #else
+        #  @intBufSize = 102400
+
+        #end
+
+        #@in = java.io.RandomAccessFile.new(java.nio.file.Files.createTempFile(nil,".zl").toFile, "rw")
+        #@inPtr = 0
+
+        case @config.level
+        when :best_compression
+          teLogger.debug "Compression with best compression"
+          @eng = java.util.zip.Deflater.new(java.util.zip.Deflater::BEST_COMPRESSION)
+        when :best_speed
+          teLogger.debug "Compression with best speed"
+          @eng = java.util.zip.Deflater.new(java.util.zip.Deflater::BEST_SPEED)
+        when :no_compression
+          teLogger.debug "No compression"
+          @eng = java.util.zip.Deflater.new(java.util.zip.Deflater::NO_COMPRESSION)
+        else
+          teLogger.debug "Default compression"
+          @eng = java.util.zip.Deflater.new(java.util.zip.Deflater::DEFAULT_COMPRESSION)
+        end
+
+        teLogger.debug "Default strategy"
+        @eng.setStrategy(java.util.zip.Deflater::DEFAULT_STRATEGY)
+
+        @os = java.io.ByteArrayOutputStream.new
+        
+      end
+
+      # returns compressed output length
+      def update(val)
+        if val.length > 0
+          teLogger.debug "Given #{val.length} bytes for compression"
+          #teLogger.debug "Write ready-to-compress data : #{val.length}"
+          #@in.write(to_java_bytes(val))
+
+          @eng.setInput(to_java_bytes(val))
+
+          @eng.finish
+
+          baos = java.io.ByteArrayOutputStream.new
+          buf = ::Java::byte[102400].new
+          while not @eng.finished
+            done = @eng.deflate(buf)
+            @os.write(buf,0,done)
+          end
+
+          @os.toByteArray
+        else
+          ::Java::byte[0].new
+        end
+      end
+
+      def final
+     
+      end
+
+    end
+  end
+end

data/lib/ccrypto/java/engines/data_conversion_engine.rb

@@ -0,0 +1,9 @@
+
+
+module Ccrypto
+  module Java
+    class DataConversionEngine
+      extend DataConversion
+    end
+  end
+end

data/lib/ccrypto/java/engines/decompression_engine.rb

@@ -0,0 +1,48 @@
+
+require_relative '../data_conversion'
+
+module Ccrypto
+  module Java
+    class Decompression
+      include DataConversion
+      include TR::CondUtils
+
+      include TeLogger::TeLogHelper
+      teLogger_tag :j_decompression
+
+      def initialize(*args,&block)
+       
+        @eng = java.util.zip.Inflater.new
+
+        @os = java.io.ByteArrayOutputStream.new
+
+      end
+
+      def update(val)
+        teLogger.debug "Given #{val.length} bytes for decompression"
+        if val.length > 0
+
+          @eng.setInput(to_java_bytes(val))
+
+          baos = java.io.ByteArrayOutputStream.new
+          buf = ::Java::byte[102400].new
+          while not @eng.finished
+            done = @eng.inflate(buf)
+            teLogger.debug "Done #{done} bytes"
+            @os.write(buf,0,done)
+          end
+
+          @os.toByteArray
+
+        else
+          ::Java::byte[0].new
+
+        end
+      end
+
+      def final
+      end
+
+    end
+  end
+end

data/lib/ccrypto/java/engines/digest_engine.rb

@@ -0,0 +1,208 @@
+
+require_relative '../data_conversion'
+
+module Ccrypto
+  module Java
+    class DigestEngine
+      include TR::CondUtils
+      include DataConversion
+
+      include TeLogger::TeLogHelper
+
+      teLogger_tag :j_digest
+
+      Potential = [
+
+        Ccrypto::SHA1.provider_info("SHA-1"),
+        Ccrypto::SHA224.provider_info("SHA-224"),
+        Ccrypto::SHA256.provider_info("SHA-256"),
+        Ccrypto::SHA384.provider_info("SHA-384"),
+        Ccrypto::SHA512.provider_info("SHA-512"),
+        Ccrypto::SHA512_224.provider_info("SHA-512/224"),
+        Ccrypto::SHA512_256.provider_info("SHA-512/256"),
+
+        Ccrypto::SHA3_224.provider_info("SHA3-224"),
+        Ccrypto::SHA3_256.provider_info("SHA3-256"),
+        Ccrypto::SHA3_384.provider_info("SHA3-384"),
+        Ccrypto::SHA3_512.provider_info("SHA3-512"),
+
+        Ccrypto::BLAKE2b160.provider_info("BLAKE2B-160"),
+        Ccrypto::BLAKE2b256.provider_info("BLAKE2B-256"),
+        Ccrypto::BLAKE2b384.provider_info("BLAKE2B-384"),
+        Ccrypto::BLAKE2b512.provider_info("BLAKE2B-512"),
+
+        Ccrypto::BLAKE2s128.provider_info("BLAKE2S-128"),
+        Ccrypto::BLAKE2s160.provider_info("BLAKE2s-160"),
+        Ccrypto::BLAKE2s224.provider_info("BLAKE2s-224"),
+        Ccrypto::BLAKE2s256.provider_info("BLAKE2s-256"),
+
+        Ccrypto::HARAKA256.provider_info("HARAKA-256"),
+        Ccrypto::HARAKA512.provider_info("HARAKA-512"),
+
+        Ccrypto::KECCAK224.provider_info("KECCAK-224"),
+        Ccrypto::KECCAK256.provider_info("KECCAK-256"),
+        Ccrypto::KECCAK288.provider_info("KECCAK-288"),
+        Ccrypto::KECCAK384.provider_info("KECCAK-384"),
+        Ccrypto::KECCAK512.provider_info("KECCAK-512"),
+
+        Ccrypto::RIPEMD128.provider_info("RIPEMD128"),
+        Ccrypto::RIPEMD160.provider_info("RIPEMD160"),
+        Ccrypto::RIPEMD256.provider_info("RIPEMD256"),
+        Ccrypto::RIPEMD320.provider_info("RIPEMD320"),
+
+        Ccrypto::SHAKE128_256.provider_info("SHAKE128-256"),
+        Ccrypto::SHAKE256_512.provider_info("SHAKE256-512"),
+
+        Ccrypto::SKEIN1024_1024.provider_info("SKEIN-1024-1024"),
+        Ccrypto::SKEIN1024_384.provider_info("SKEIN-1024-384"),
+        Ccrypto::SKEIN1024_512.provider_info("SKEIN-1024-512"),
+
+        Ccrypto::SKEIN256_128.provider_info("SKEIN-256-128"),
+        Ccrypto::SKEIN256_160.provider_info("SKEIN-256-160"),
+        Ccrypto::SKEIN256_224.provider_info("SKEIN-256-224"),
+        Ccrypto::SKEIN256_256.provider_info("SKEIN-256-256"),
+
+        Ccrypto::SKEIN512_128.provider_info("SKEIN-512-128"),
+        Ccrypto::SKEIN512_160.provider_info("SKEIN-512-160"),
+        Ccrypto::SKEIN512_224.provider_info("SKEIN-512-224"),
+        Ccrypto::SKEIN512_256.provider_info("SKEIN-512-256"),
+        Ccrypto::SKEIN512_384.provider_info("SKEIN-512-384"),
+        Ccrypto::SKEIN512_512.provider_info("SKEIN-512-512"),
+
+        SM3 = Ccrypto::SM3.provider_info("SM3"),
+        WHIRLPOOL = Ccrypto::WHIRLPOOL.provider_info("WHIRLPOOL")
+      ]
+
+      def self.supported
+        if @supported.nil?
+          @supported = []
+          probe = java.security.Security.getAlgorithms("MessageDigest").to_a.delete_if { |e| e.include?(".") }
+          Potential.each do |po|
+            @supported << po if probe.include?(po.provider_config)
+          end
+        end
+        @supported
+      end
+
+      def self.is_supported?(eng, prov = nil)
+        if is_empty?(eng)
+          false
+        else
+
+          jceName = algo_jce_map[eng]
+          begin
+            if not_empty?(prov)
+              #java.security.MessageDigest.getInstance(eng.to_s.gsub("_","-"), prov)
+              java.security.MessageDigest.getInstance(jceName, prov)
+            else
+              #java.security.MessageDigest.getInstance(eng.to_s.gsub("_","-"))
+              java.security.MessageDigest.getInstance(jceName)
+            end
+            true
+          rescue java.security.NoSuchAlgorithmException => ex
+            p ex.message
+            false
+          end
+        end
+      end
+
+      def self.default_algo
+        "SHA256"
+      end
+
+      def self.instance(conf, &block)
+        if block
+          prov = block.call(:jce_provider)
+          if not_empty?(prov)
+            DigestEngine.new(conf.provider_config, prov, &block)
+          else
+            DigestEngine.new(conf.provider_config, &block)
+          end
+        else
+          DigestEngine.new(conf.provider_config, &block)
+        end
+      end
+
+      def self.digest(key, &block)
+        res = engineKeys[key]
+        if is_empty?(res)
+          raise DigestEngine, "Not supported digest engine #{key}"
+        else
+          if block
+            digProv = block.call(:digest_jceProvider)
+          end
+
+          if digProv.nil?
+            DigestEngine.new(res.provider_config)
+          else
+            DigestEngine.new(res.provider_config, digProv)
+          end
+        end
+      end
+
+      def self.engineKeys
+        if @engineKeys.nil?
+          @engineKeys = {}
+          supported.each do |a|
+            @engineKeys[a.algo.to_sym] = a
+          end
+        end
+        @engineKeys
+      end
+
+      def self.algo_jce_map
+        if @algoMap.nil?
+          @algoMap = {}
+          supported.each do |a|
+            @algoMap[a.algo.to_sym] = a.provider_config
+          end
+        end
+        @algoMap
+      end
+
+      def initialize(algo, prov = nil, &block)
+        teLogger.debug "Algo : #{algo}"
+        @algo =  algo #algo.to_s.gsub("_","-")
+        begin
+          if not_empty?(prov)
+            @inst = java.security.MessageDigest.getInstance(@algo, prov)
+          else
+            @inst = java.security.MessageDigest.getInstance(@algo)
+          end
+        #rescue java.security.NoSuchAlgorithmException => ex
+        rescue Exception => ex
+          raise DigestEngineException, ex
+        end
+      end
+
+      def digest(val, output = :binary)
+        digest_final(val, output)
+      end
+
+      def digest_update(val)
+        @inst.update(to_java_bytes(val))
+      end
+
+      def digest_final(val = nil, output = :binary)
+        if not_empty?(val)
+          @inst.update(to_java_bytes(val))
+        end
+        res = @inst.digest
+        @inst.reset
+        case output
+        when :hex
+          to_hex(res)
+        when :b64
+          to_b64(res)
+        else
+          res
+        end
+      end
+
+      def reset
+        @inst.reset
+      end
+
+    end
+  end
+end