ccipher_factory 0.1.0

data/lib/ccipher_factory/asymkey_cipher/ecc/ecc_att_encrypt.rb

@@ -0,0 +1,70 @@
+
+
+module CcipherFactory
+  module AsymKeyCipher
+    module ECCAttEncrypt
+      include Common
+      include TR::CondUtils
+      include Compression::CompressionHelper
+
+      attr_accessor :recipient_key, :sender_keypair
+
+      def att_encrypt_init(opts = { }, &block)
+
+        @enc = AsymKeyCipher.encryptor(:ecc)
+        @enc.output(intOutputFile)
+
+        if is_compression_on?
+          logger.tdebug :ecc_att_enc, "Compression on"
+          @enc.compression_on
+        else
+          logger.tdebug :ecc_att_enc, "Compression off"
+          @enc.compression_off
+        end
+
+        @enc.recipient_key = @recipient_key
+        @enc.sender_keypair = @sender_keypair
+
+        @enc.encrypt_init(opts)
+
+        if block
+          instance_eval(&block)
+          att_encrypt_final
+        else
+          self
+        end
+
+      end
+
+      def att_encrypt_update(val)
+        raise ECCCipherError, "Output is required for encryption" if not is_output_given?
+        @enc.encrypt_update(val) 
+      end
+
+      def att_encrypt_final
+
+        ts = @enc.encrypt_final
+
+        write_to_output(ts)
+
+        intOutputFile.rewind
+        while not intOutputFile.eof?
+          write_to_output(intOutputFile.read)
+        end
+
+        intOutputFile.close!
+
+        @output
+
+      end
+
+      def logger
+        if @logger.nil?
+          @logger = Tlogger.new
+        end
+        @logger
+      end
+
+    end
+  end
+end

data/lib/ccipher_factory/asymkey_cipher/ecc/ecc_att_signer.rb

@@ -0,0 +1,88 @@
+
+
+
+
+module CcipherFactory
+  module AsymKeySigner
+
+    module ECCAttSigner
+      include Common
+      include Compression::CompressionHelper
+
+      attr_accessor :signing_key
+      def att_sign_init(*args, &block)
+
+        @signer = AsymKeySigner.signer
+        @signer.signing_key = @signing_key
+
+        @signer.sign_init(*args)
+
+        @totalPlain = 0
+        @totalCompressed = 0
+
+        if block
+          instance_eval(&block)
+          att_sign_final
+        else
+          self
+        end
+
+      end
+
+      def att_sign_update(val)
+
+        raise ECCSignerError, "Output is required for attached sign with ECC" if not is_output_given?
+
+        @totalPlain += val.length
+        @signer.sign_update(val) 
+        res = compress_data_if_active(val)
+        intOutputFile.write(res)
+        @totalCompressed += res.length
+
+        res
+
+      end
+
+      def att_sign_final
+        meta = @signer.sign_final 
+
+        #ts = Encoding::ASN1Encoder.instance(:ecc_att_sign)
+        ts = BinStruct.instance.struct(:ecc_att_sign)
+        ts.ecc_signature = meta
+
+        #ts.set(:ecc_signature, meta)
+        if is_compression_on?
+          #ts.set(:compression, compressor.compress_final)
+          ts.compression = compressor.compress_final
+        else
+          #ts.set(:compression, encode_null_compressor)
+          ts.compression = encode_null_compressor
+        end
+
+        smeta = ts.encoded
+        write_to_output(smeta)
+
+        intOutputFile.rewind
+        while not intOutputFile.eof?
+          write_to_output(intOutputFile.read)
+        end
+
+        disposeOutput(intOutputFile)
+
+        logger.tdebug :ecc_att_sign, "Total Plain : #{@totalPlain} / Total Compressed : #{@totalCompressed} = #{(@totalCompressed*1.0)/@totalPlain*100} %" if is_compression_on?
+
+        smeta
+
+      end
+
+      def logger
+        if @logger.nil?
+          @logger = Tlogger.new
+        end
+        @logger
+      end
+
+    end
+
+  end
+end

data/lib/ccipher_factory/asymkey_cipher/ecc/ecc_att_verifier.rb

@@ -0,0 +1,100 @@
+
+
+
+module CcipherFactory
+  module AsymKeySigner
+
+    module ECCAttVerifier
+      include Common
+      include Compression::CompressionHelper
+
+      def embedded_signer
+        if not_empty?(@ver)
+          @ver.embedded_signer
+        else
+          nil
+        end
+      end
+
+      def att_verify_init(*args, &block)
+
+        @params = args
+
+        if block
+          instance_eval(&block)
+          att_verify_final
+        else
+          self
+        end
+
+      end
+
+      def att_verify_update(val)
+
+        if @ver.nil?
+
+          intOutputBuf.write(val)
+          begin
+            Encoding.extract_meta(intOutputBuf) do |meta, bal|
+
+              ts = BinStruct.instance.struct_from_bin(meta)
+              smeta = ts.ecc_signature
+              compression = ts.compression
+
+              decompressor_from_encoded(compression)
+              if is_compression_on?
+                logger.tdebug :ecc_att_ver, "Compression on"
+              else
+                logger.tdebug :ecc_att_ver, "No compression"
+              end
+
+              @ver = AsymKeySigner.verifier
+              @ver.output(@output) if is_output_given?
+
+              @ver.verify_init(*@params)
+              @ver.verify_update_meta(smeta)
+
+              att_verify_update(bal) if bal.length > 0
+
+              disposeOutput(intOutputBuf)
+
+            end
+          rescue Encoding::InsufficientData
+          end
+
+        else
+          logger.tdebug :ecc_att_ver, "Compressed size : #{val.length}" if is_compression_on?
+          res = decompress_data_if_active(val) 
+          @ver.verify_update_data(res)
+          intOutputFile.write(res)
+        end
+
+      end
+
+      def att_verify_final
+
+        res = @ver.verify_final
+
+        if is_output_given?
+          intOutputFile.rewind
+          while not intOutputFile.eof?
+            write_to_output(intOutputFile.read)
+          end
+        end
+
+        disposeOutput(intOutputFile)
+        res
+
+      end
+
+      def logger
+        if @logger.nil?
+          @logger = Tlogger.new
+        end
+        @logger
+      end
+
+    end
+
+  end
+end

data/lib/ccipher_factory/asymkey_cipher/ecc/ecc_decrypt.rb

@@ -0,0 +1,80 @@
+
+
+require_relative '../../symkey_cipher/symkey_cipher'
+require_relative '../../kdf/kdf'
+require_relative '../../asymkey/ecc_keypair'
+
+module CcipherFactory
+  module AsymKeyCipher
+    module ECCDecrypt
+      include TR::CondUtils
+      include Common
+
+      class ECCCipherError < AsymKeyCipherError; end
+
+      attr_accessor :decryption_key
+      def decrypt_init(opts = {  }, &block)
+
+        #raise ECCCipherError, "Decryption keypair is mandatory" if is_empty?(eccKeypair)
+
+        #@eccKeypair = eccKeypair
+
+        if block
+          instance_eval(&block)
+          decrypt_final
+        else
+          self
+        end
+
+      end
+
+      def decrypt_update_meta(meta)
+
+        raise ECCCipherError, "Output is required" if not is_output_given?
+
+        ts = BinStruct.instance.struct_from_bin(meta)
+        senderPub = ts.sender_public
+        cipherConf = ts.cipher_config
+        keyConf = ts.key_config
+        
+        sender = Ccrypto::AlgoFactory.engine(Ccrypto::ECCPublicKey).to_key(senderPub)
+        derived = @decryption_key.derive_dh_shared_secret(sender)
+
+        sessKey = DerivedSymKey.from_encoded(keyConf) do |ops|
+          case ops
+          when :password
+            derived
+          end
+        end
+
+        @cipher = SymKeyCipher.decryptor
+        @cipher.output(@output)
+        @cipher.key = sessKey
+        @cipher.decrypt_init
+        @cipher.decrypt_update_meta(cipherConf)
+
+      end
+
+      def decrypt_update_cipher(cipher)
+        raise ECCCipherError, "Please update meta first before update cipher" if is_empty?(@cipher) 
+
+        @cipher.decrypt_update_cipher(cipher)
+      end
+
+      def decrypt_final
+
+        @cipher.decrypt_final
+
+      end
+
+      def logger
+        if @logger.nil?
+          @logger = Tlogger.new
+          @logger.tag = :ecc_dec
+        end
+        @logger
+      end
+
+    end
+  end
+end

data/lib/ccipher_factory/asymkey_cipher/ecc/ecc_encrypt.rb

@@ -0,0 +1,101 @@
+
+require_relative '../../symkey_cipher/symkey_cipher'
+require_relative '../../kdf/kdf'
+
+require_relative '../../asymkey/asymkey_generator'
+require_relative '../../compression/compression_helper'
+
+module CcipherFactory
+  module AsymKeyCipher
+    module ECCEncrypt
+      include TR::CondUtils
+      include Common
+      include Compression::CompressionHelper
+
+      class ECCCipherError < AsymKeyCipher::AsymKeyCipherError; end
+
+      attr_accessor :recipient_key, :sender_keypair
+
+      def encrypt_init(opts = { }, &block)
+
+        #@sender = opts[:sender_keypair]
+        #recpPub = opts[:recipient_public]
+        recpPub = @recipient_key
+
+        raise ECCCipherError, "Receipient public key is required" if is_empty?(recpPub)
+        raise ECCCipherError, "Cipher requires output to be set" if not is_output_given?  
+        raise ECCCipherError, "Sender Keypair is required" if is_empty?(@sender_keypair)
+
+        #if is_empty?(@sender_keypair)
+        #  @sender_keypair = AsymKeyGenerator.generate(:ecc) 
+        #end
+
+        #derived = @sender_keypair.dh_compute_key(recpPub)
+        #logger.debug "sender : #{@sender_keypair.inspect} / #{@sender_keypair.private?}"
+        #logger.debug "recp : #{recpPub.inspect}"
+        derived = @sender_keypair.derive_dh_shared_secret(recpPub)
+
+        @sessKey = SymKeyGenerator.derive(:aes, 256) do |ops|
+          case ops
+          when :password
+            derived
+          end
+        end
+
+        @cipher = SymKeyCipher.encryptor
+        @cipher.output(intOutputFile)
+        @cipher.key = @sessKey
+
+        if is_compression_on?
+          logger.debug "Turning on compression"
+          @cipher.compression_on
+        else
+          logger.debug "Compression not active"
+          @cipher.compression_off
+        end
+
+        @cipher.encrypt_init 
+
+        if block
+          instance_eval(&block)
+          encrypt_final
+        else
+          self
+        end
+
+      end
+
+      def encrypt_update(val)
+        @cipher.encrypt_update(val) 
+      end
+
+      def encrypt_final
+
+        cipherConfig = @cipher.encrypt_final 
+
+        intOutputFile.rewind
+        while not intOutputFile.eof?
+          write_to_output(intOutputFile.read)
+        end
+        cleanup_intOutputFile
+
+        pkBin = @sender_keypair.public_key.to_bin
+        ts = BinStruct.instance.struct(:ecc_cipher)
+        ts.sender_public = @sender_keypair.public_key.to_bin
+        ts.cipher_config = cipherConfig
+        ts.key_config = @sessKey.encoded
+        ts.encoded
+
+      end
+
+      def logger
+        if @logger.nil?
+          @logger = Tlogger.new
+          @logger.tag = :ecc_enc
+        end
+        @logger
+      end
+
+    end
+  end
+end

data/lib/ccipher_factory/asymkey_cipher/ecc/ecc_signer.rb

@@ -0,0 +1,80 @@
+
+require_relative '../../digest/digest'
+require_relative '../../compression/compressor'
+
+module CcipherFactory
+  module AsymKeySigner
+    module ECCSigner
+      include TR::CondUtils
+      include Common
+
+      class ECCSignerError < AsymKeySignerError; end
+
+      attr_accessor :signing_key
+
+      def compression_on
+        @compress = true
+      end
+
+      def compression_off
+        @compress = false
+      end
+
+      def sign_init(opts = {  }, &block)
+
+        raise ECCSignerError, "Signer must be given" if is_empty?(@signing_key)
+
+        @digest = Digest.instance
+        @digest.output(intOutputBuf)
+        @digest.digest_init
+
+        if @compress
+          logger.tdebug :asymkey_enc, "Compression on"
+          @compressor = CcipherFactory::Compression::Compressor.new 
+          @compressor.compress
+          @compressor.compress_init
+        else
+          logger.tdebug :asymkey_enc, "Compression off"
+        end
+
+
+        if block
+          instance_eval(&block)
+          sign_final
+        else
+          self
+        end
+
+      end
+
+      def sign_update(val)
+        @digest.digest_update(val)
+      end
+
+      def sign_final
+        dig = @digest.digest_final
+
+        eccConf = Ccrypto::ECCConfig.new
+        eccConf.keypair = @signing_key.keypair
+        eccEng = Ccrypto::AlgoFactory.engine(eccConf)
+        sign = eccEng.sign(intOutputBuf.bytes)
+
+        ts = BinStruct.instance.struct(:ecc_signature)
+        ts.digest_info = dig
+        ts.signer_info = @signing_key.to_signer_info
+        ts.signature = sign
+        ts.encoded
+
+      end
+
+      def logger
+        if @logger.nil?
+          @logger = Tlogger.new
+        end
+        @logger
+      end
+
+
+    end
+  end
+end

data/lib/ccipher_factory/asymkey_cipher/ecc/ecc_verifier.rb

@@ -0,0 +1,56 @@
+
+require_relative '../../asymkey/ecc_keypair'
+
+module CcipherFactory
+  module AsymKeySigner
+    module ECCVerifier
+      include Common
+
+      attr_accessor :verification_key
+      attr_reader :embedded_signer 
+      def verify_init(*args, &block)
+
+        if block
+          instance_eval(&block)
+          verify_final
+        else
+          self
+        end
+
+      end
+
+      def verify_update_meta(meta)
+
+        ts = BinStruct.instance.struct_from_bin(meta)
+        digInfo = ts.digest_info
+        sigInfo = ts.signer_info
+        @sign = ts.signature
+
+        @digest = Digest.from_encoded(digInfo)
+        @digest.output(intOutputBuf)
+
+        @signer = KeyPair::ECCKeyPair.from_signer_info(sigInfo)
+        @embedded_signer = @signer
+
+      end
+
+      def verify_update_data(data)
+        @digest.digest_update(data) 
+      end
+
+      def verify_final
+
+        @digest.digest_final
+        
+        res = Ccrypto::AlgoFactory.engine(Ccrypto::ECCConfig).verify(@signer, intOutputBuf.bytes, @sign)
+        
+        #res = @signer.dsa_verify_asn1(intOutputBuf.string, @sign)
+
+        res
+
+      end
+
+    end
+  end
+
+end

data/lib/ccipher_factory/composite_cipher/composite_cipher.rb

@@ -0,0 +1,28 @@
+
+
+module CcipherFactory
+  module CompositeCipher
+
+    class CompositeCipherError < StandardError; end
+
+    class CompCipher; end
+
+    def self.sign_encryptor(opts = {  })
+      cc = CompCipher.new
+      cc.extend(SignEncryptor)
+      cc
+    end
+
+    def self.decrypt_verifier(opts = {  })
+      cc = CompCipher.new
+      cc.extend(DecryptVerifier)
+      cc
+    end
+
+  end
+end
+
+require_relative 'sign_encryptor'
+require_relative 'decrypt_verifier'
+
+