ccrypto 0.1.2 → 0.2.0

data/lib/ccrypto/in_memory_record.rb

@@ -0,0 +1,255 @@
+
+require 'yaml'
+require 'fileutils'
+
+module Ccrypto
+  class InMemoryRecordError < StandardError; end
+
+  module InMemoryRecord
+    include TR::CondUtils
+
+    module ClassMethods
+      
+      def record_storage_root=(val)
+        @store_root
+        FileUtils.mkdir_p(@store_root) if not File.exist?(@store_root)
+      end
+
+      def record_storage_root
+        if @store_root.nil?
+          @store_root = File.join(Dir.home,".ccrypto")
+          FileUtils.mkdir_p(@store_root) if not File.exist?(@store_root)
+        end
+        @store_root
+      end
+
+      def load_from_storage(record, &block)
+        recFile = File.join(record_storage_root, "#{record.gsub(" ","_")}.imr")
+        if File.exist?(recFile)
+          YAML.unsafe_load_file(recFile)
+        else
+          if block
+            block.call(:init_new_instance)
+          else
+            # try to do generic
+            eval("#{self.name}.new")
+          end
+        end
+      end
+      alias_method :load, :load_from_storage
+
+    end # ClassMethods
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      @klass = klass
+    end
+
+    # 
+    # Instance methods
+    #
+    def save_to_storage(record)
+      target = File.join(self.class.record_storage_root,"#{record}.imr")  
+      File.open(target,"w") do |f|
+        f.write YAML.dump(self)
+      end
+      self
+    end
+    alias_method :save, :save_to_storage
+
+    def register(obj, opts = {})
+      logger.debug "Giving #{obj} to register"
+      if not obj.nil?
+        extrapolate(obj, opts)
+        logger.debug "Extrapolated object #{obj}"
+        records << obj
+        logger.debug "Object #{obj} added to records"
+      end
+    end
+
+    # finder only accept hash
+    def find(field)
+      res = []
+      case field
+      when Hash
+        loopRes = []
+        field.each do |k,v|
+          case v
+          when Array
+            # extra configration at value is array
+            # 1st parameter always the keyword to find
+            ss = v.first
+            fuzzy = v[1] || false
+          else
+            ss = v
+            fuzzy = false
+          end
+
+          if not searchRes[k.to_sym].nil?
+            if fuzzy
+              found = searchRes[k.to_sym].select { |sk,sv|
+                sk.to_s.downcase =~ /#{ss.downcase}/
+              }
+              loopRes = found.values
+            else
+              ss = ss.to_s.downcase
+              if searchRes[k.to_sym].keys.include?(ss)
+                loopRes = searchRes[k.to_sym][ss]
+              end
+            end
+          end
+
+          if is_empty?(res)
+            res = loopRes
+          else
+            res = res & loopRes
+          end
+        end
+      else
+        raise InMemoryRecordError, "Hash is expected for finder function"
+      end
+
+      # apparantly dup and clone has some different side effects
+      # dup will not copy the frozen flag but shall also ignore the dynamic method
+      # created using instance_eval
+      # clone shall retain the frozen flag but shall also carry over the instance_eval
+      # result.
+      # Hence let the application to decide to use dup or clone
+      res
+      #if field[:do_not_dup] == true
+      #  res
+      #else
+      #  # always return a copy instead of actual one
+      #  # dup call here might not help if there are embedded
+      #  # object in the class as the dup only does swallow
+      #  # copy, not deep copy
+      #  # Library user need to handle deep copy
+      #  res.map { |r| 
+      #    if r.respond_to?(:ddup)
+      #      r.ddup
+      #    else
+      #      r.clone
+      #    end
+      #  }
+      #end
+
+    end # find() operation
+
+    def each(&block)
+      raise InMemoryRecordError, "each function requires a block" if not block
+      records.each(&block)
+      #records.map {|r| 
+      #  if r.respond_to?(:ddup)
+      #    r.ddup
+      #  else
+      #    r.clone
+      #  end
+      #}.each(&block)
+    end
+
+    def collect(&block)
+      records.collect(&block)
+    end
+
+    def select(&block)
+      records.select(&block)
+      #records.map { |r| 
+      #  if r.respond_to?(:ddup)
+      #    r.ddup
+      #  else
+      #    r.clone
+      #  end
+      #}.select(&block)
+    end
+
+    def empty?
+      records.empty?
+    end
+
+    def to_a
+      records #.freeze
+      #records.map { |c| 
+      #  if c.respond_to?(:ddup)
+      #    c.ddup
+      #  else
+      #    c.clone
+      #  end
+      #}.freeze
+    end
+
+    private
+    def records
+      if @records.nil?
+        @records = []
+      end
+      @records
+    end
+
+    def define_search_key(*args)
+      args.map { |s|
+        raise InMemoryRecordError, "Only support Symbol/String as search key" if not [String, Symbol].include?(s.class)
+      }
+      searchKeys.concat(args)
+    end
+
+    def extrapolate(a, opts = {})
+      if not_empty?(opts) and not_empty?(opts[:tag_under])
+        tag = opts[:tag_under]
+        searchRes[tag] = {} if searchRes[tag].nil?
+
+        val = opts[:tag_value]
+        val = val.to_s.downcase
+
+        if not_empty?(val)
+          searchRes[tag][val] = [] if searchRes[tag][val].nil?
+          searchRes[tag][val] << a
+          logger.debug "Registering #{tag}/#{val}"
+
+        else
+          raise InMemoryRecordError, ":tag_under requires :tag_value to operate"
+        end
+      end # additional tagging
+
+      searchKeys.each do |ss|
+        case ss
+        when Symbol, String
+          val = a.send(ss)
+          #logger.debug "Extrapolating #{ss} got : #{val}" 
+          if not_empty?(val)
+            val = val.to_s.downcase
+            # search field has value
+            searchRes[ss.to_sym] = {} if searchRes[ss.to_sym].nil?
+            searchRes[ss.to_sym][val] = [] if searchRes[ss.to_sym][val].nil?
+            searchRes[ss.to_sym][val] << a
+            logger.debug "Registering #{ss.to_sym}/#{val}"
+          end
+        end
+      end
+    end
+
+    def searchKeys
+      if @searchKeys.nil?
+        @searchKeys = []
+      end
+      @searchKeys 
+    end
+
+    def searchRes
+      if @searchRes.nil?
+        @searchRes = {}
+      end
+      @searchRes
+    end
+
+    def hash_tree
+      Hash.new do |hash, key|
+        hash[key] = hash_tree
+      end
+    end
+
+    def logger
+      Ccrypto.logger(:inMemRec)
+    end
+
+
+  end
+end

data/lib/ccrypto/key_bundle.rb

@@ -2,12 +2,31 @@
 
 module Ccrypto
   module KeyBundle
-    attr_accessor :nativeKeypair
+    attr_reader :nativeKeypair
 
     def KeyBundle.from_storage(*args, &block)
       Provider.instance.provider.keybundle_from_storage(*args, &block)
     end
 
+    def native
+      @nativeKeypair
+    end
+    alias_method :keypair, :native
+
+    private
+    def method_missing(mtd, *args, &block)
+      if not @nativeKeypair.nil?
+        logger.debug "Sending to method #{mtd} of object '#{@nativeKeypair}' at KeyBundle level"
+        @nativeKeypair.send(mtd, *args, &block)
+      else
+        super
+      end
+    end
+
+    def logger
+      Ccrypto.logger(:keybundle)
+    end
+
   end
 
   module ECCKeyBundle

data/lib/ccrypto/keystore.rb

@@ -0,0 +1,25 @@
+
+
+module Ccrypto
+  module Keystore
+
+    class KeystoreException < StandardError; end
+   
+    def Keystore.load_keystore(*args, &block)
+      Provider.instance.provider.load_keystore(*args, &block)
+    end
+
+    def Keystore.load_keystore_file(*args, &block)
+      Provider.instance.provider.load_keystore_file(*args, &block)
+    end
+
+    def Keystore.convert_keystore(*args, &block)
+      Provider.instance.provider.convert_keystore(*args, &block)
+    end
+
+    def Keystore.convert_keystore_file(*args, &block)
+      Provider.instance.provider.convert_keystore_file(*args, &block)
+    end
+
+  end
+end

data/lib/ccrypto/private_key.rb

@@ -23,10 +23,18 @@ module Ccrypto
       end
     end
 
+    def native
+      @native_privKey
+    end
+
   end # PrivateKey
 
   class ECCPrivateKey < PrivateKey; end
   class RSAPrivateKey < PrivateKey; end
   class ED25519PrivateKey < PrivateKey; end
   class X25519PrivateKey < PrivateKey; end
+
+  class CrystalDilithiumPrivateKey < PrivateKey; end
+  class CrystalKyberPrivateKey < PrivateKey; end
+  
 end

data/lib/ccrypto/public_key.rb

@@ -7,10 +7,20 @@ module Ccrypto
       @native_pubKey = pubkey
     end
 
+    def native
+      @native_pubKey
+    end
+
+    private
+    def logger
+      Ccrypto.logger(:pubkey)
+    end
+
     def method_missing(mtd, *args, &block)
       if @native_pubKey.nil?
         super
       else
+        logger.debug "Sending to native pubKey '#{@native_pubKey}' of method '#{mtd}'"
         @native_pubKey.send(mtd, *args, &block)
       end
     end
@@ -29,4 +39,7 @@ module Ccrypto
   class RSAPublicKey < PublicKey; end
   class ED25519PublicKey < PublicKey; end
   class X25519PublicKey < PublicKey; end
+
+  class CrystalDilithiumPublicKey < PublicKey; end
+  class CrystalKyberPublicKey < PublicKey; end
 end

data/lib/ccrypto/secret_key.rb

@@ -2,12 +2,17 @@
 
 module Ccrypto
   class SecretKey
-    attr_accessor :algo
-    attr_accessor :key
+    attr_reader :algo, :keysize
 
-    def initialize(algo, key)
+    attr_reader :native_key
+
+    attr_accessor :provider_config
+
+    def initialize(algo, keysize, key)
       @algo = algo
-      @key = key
+      @keysize = keysize
+      @native_key = key
     end
+
   end
 end

data/lib/ccrypto/supported_cipher_list.rb

@@ -1,5 +1,8 @@
 
-require 'singleton'
+require 'yaml'
+require 'fileutils'
+
+require_relative 'in_memory_record'
 
 module Ccrypto
 
@@ -7,120 +10,10 @@ module Ccrypto
 
   class SupportedCipherList
     include TR::CondUtils
-    include Singleton
-
-    include TeLogger::TeLogHelper
-    teLogger_tag :supCipherList
+    include InMemoryRecord
 
     def initialize
-      @algos = {}
-      @keysizes = {}
-      @modes = {}
-
-      @algoKeysize = {}
-      @algoKeysizeMode = {}
-      @keysizeMode = {}
-      @algoMode = {}
-      @items = []
-    end
-
-    def register(cc)
-      raise SupportedCipherListError, "Ccrypto::CipherConfig required. Got '#{cc.class}'" if not cc.is_a?(Ccrypto::CipherConfig)
-
-      @items << cc
-      algo = cc.algo.to_sym
-      @algos[algo] = [] if @algos[algo].nil?
-      @algos[algo] << cc
-
-      keysize = cc.keysize.to_s
-      @keysizes[keysize] = [] if @keysizes[keysize].nil?
-      @keysizes[keysize] << cc
-
-      mode = cc.mode.nil? ? "" : cc.mode.to_s
-      if not_empty?(mode)
-        @modes[mode.to_s] = [] if @modes[mode.to_s].nil?
-        @modes[mode.to_s] << cc
-      end
-
-      @algoKeysize[algo] = {  } if @algoKeysize[algo].nil?
-      @algoKeysize[algo][keysize] = [] if @algoKeysize[algo][keysize].nil?
-      @algoKeysize[algo][keysize] << cc
-
-      if not_empty?(mode)
-        @algoMode[algo] = {} if @algoMode[algo].nil?
-        @algoMode[algo][mode] = [] if @algoMode[algo][mode].nil?
-        @algoMode[algo][mode] << cc
-
-        @keysizeMode[keysize] = {} if @keysizeMode[keysize].nil?
-        @keysizeMode[keysize][mode] = [] if @keysizeMode[keysize][mode].nil?
-        @keysizeMode[keysize][mode] << cc
-
-        @algoKeysizeMode[algo] = {} if @algoKeysizeMode[algo].nil?
-        @algoKeysizeMode[algo][keysize] = {} if @algoKeysizeMode[algo][keysize].nil?
-        @algoKeysizeMode[algo][keysize][mode] = [] if @algoKeysizeMode[algo][keysize][mode].nil?
-        @algoKeysizeMode[algo][keysize][mode] << cc
-      end 
-
-    end
-
-    def items
-      @items
-    end
-
-    def each(&block)
-      @items.each(&block)
-    end
-
-    def algo_count
-      @algos.length
-    end
-    def find_algo(algo)
-      @algos[algo.to_sym] || []
-    end
-    def algos
-      @algos.keys
-    end
-
-    def keysizes_count
-      @keysizes.length 
-    end
-    def keysizes
-      @keysizes.keys
-    end
-    def find_keysize(keysize)
-      @keysizes[keysize.to_s]
-    end
-
-    def mode_count
-      @modes.length
-    end
-    def find_mode(mode)
-      @modes[mode.to_s]
-    end
-    def modes
-      @modes.keys
-    end
-
-    def find_algo_keysize(algo, keysize)
-      res = @algoKeysize[algo.to_sym] || {  }
-      res[keysize.to_s] || []
-    end
-
-    def find_algo_mode(algo, mode)
-      res = @algoMode[algo.to_sym] || {}
-      res[mode.to_s] || []
-    end
-
-    def find_algo_keysize_mode(algo, keysize, mode)
-      res = @algoKeysizeMode[algo.to_sym] || {}
-      res = res[keysize.to_s] || {}
-      res[mode.to_s] || []
-    end
-
-    def find_keysize_modes(keysize, mode)
-
-      res = @keysizeMode[keysize.to_s] || {}
-      res[mode.to_s] || []
+      define_search_key(:algo, :keysize, :mode, :padding, :ivLength)
     end
 
   end

data/lib/ccrypto/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ccrypto
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/ccrypto/x509_cert.rb

@@ -8,5 +8,10 @@ module Ccrypto
       @nativeX509 = x509
     end
 
+    def X509Cert.load_x509(*args, &block)
+      Provider.instance.provider.load_x509(*args, &block)
+    end
+
+
   end
 end

data/lib/ccrypto/x509_csr.rb

@@ -4,6 +4,8 @@ module Ccrypto
   class X509CSR
     attr_accessor :nativeCSR
 
+    class X509CSRSignatureInvalid < StandardError; end
+
     def initialize(csr)
       @nativeCSR = csr
     end

data/lib/ccrypto.rb

@@ -26,7 +26,16 @@ require_relative 'ccrypto/secret_key'
 require_relative 'ccrypto/x509_cert'
 require_relative 'ccrypto/x509_csr'
 
+require_relative 'ccrypto/digest_matcher'
+require_relative 'ccrypto/in_memory_record'
+
+require_relative 'ccrypto/keystore'
+
+require_relative 'ccrypto/capability'
+
 module Ccrypto
+  include TR::CondUtils
+
   class Error < StandardError; end
   class CcryptoProviderException < StandardError; end
 
@@ -56,4 +65,39 @@ module Ccrypto
 
   class KeyBundleStorageException < StandardError; end
   # Your code goes here...
+
+  Root_OID = ["2","0","18"]
+
+  def self.logger(tag = nil, &block)
+      if @_logger.nil?
+        @_logger = TeLogger::Tlogger.new
+      end
+
+     if block
+      if not_empty?(tag)
+        @_logger.with_tag(tag, &block)
+      else
+        @_logger.with_tag(@_logger.tag, &block)
+      end
+    else
+      if is_empty?(tag)
+        @_logger.tag = :CryptoJava
+        @_logger
+      else
+        # no block but tag is given? hmm
+        @_logger.tag = tag
+        @_logger
+      end
+    end
+
+  end
+
+  def self.if_detail_debug(msg)
+    logger.tdebug(:ccrypto_detail_debug, msg) if is_detail_debug_on?
+  end
+
+  def self.is_detail_debug_on?
+    ENV['CCRYPTO_DEBUG'] == "true"
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ccrypto
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Ian
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-30 00:00:00.000000000 Z
+date: 2023-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: teLogger
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: devops_assist
+  name: release-gem
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -76,6 +76,7 @@ extra_rdoc_files: []
 files:
 - ".release_history.yml"
 - ".rspec"
+- ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
 - README.md
@@ -87,6 +88,7 @@ files:
 - lib/ccrypto/algo_factory.rb
 - lib/ccrypto/asn1.rb
 - lib/ccrypto/asn1_object.rb
+- lib/ccrypto/capability.rb
 - lib/ccrypto/configs/algo_config.rb
 - lib/ccrypto/configs/cipher_config.rb
 - lib/ccrypto/configs/compress_config.rb
@@ -100,7 +102,10 @@ files:
 - lib/ccrypto/configs/secure_random_config.rb
 - lib/ccrypto/configs/x509_cert_profile.rb
 - lib/ccrypto/configs/x509_csr_profile.rb
+- lib/ccrypto/digest_matcher.rb
+- lib/ccrypto/in_memory_record.rb
 - lib/ccrypto/key_bundle.rb
+- lib/ccrypto/keystore.rb
 - lib/ccrypto/private_key.rb
 - lib/ccrypto/provider.rb
 - lib/ccrypto/public_key.rb
@@ -113,7 +118,7 @@ files:
 homepage: https://github.com/cameronian/ccrypto
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -128,8 +133,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
-signing_key: 
+rubygems_version: 3.5.1
+signing_key:
 specification_version: 4
 summary: Crypto API normalization for Ruby and Java
 test_files: []