roqs 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f19a8901d58a30e6f96bc3a69edd4674c5a2c64bc9acc017b806c6617961c0dd
+  data.tar.gz: 86a3ad02995a7d908818d11d185510faee8ead854611266737af43fe5f2410b1
+SHA512:
+  metadata.gz: fe26fcb62c00f7622d35d2560b3183fab2d2917b4b90755fd58ffeaedbd4ceda0ca1faf405ed4e84a2baea5ab890ce085760bad4826fda434c7cc29964ab53c6
+  data.tar.gz: 16a08e37b93c050424969e5a64dce0a780379304cabf1d864bfb91d838a73f74bb4b89aebffa45e7edb44344f3061508bef2e2ec656122dd4718556b3d485544

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,2 @@
+AllCops:
+  DisabledByDefault: true

data/README.md

@@ -0,0 +1,128 @@
+# Roqs
+
+Roqs is the Ruby wrapper to the [Open Quantum Safe library](https://openquantumsafe.org). The native library was tested against the liboqs at [liboqs](https://github.com/open-quantum-safe/liboqs)
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'roqs'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install roqs
+
+## Usage
+
+OQS mainly only has two group of functions: Key Encapsulation Mechanism (KEM) and Signature (SIG). 
+
+Therefore the Ruby wrapper abstraction is following the liboqs C version as baseline. 
+
+### Key Encapsulation Mechanism (KEM)
+
+For KEM, the API is simple:
+
+1. List all supported KEM PQ algorithms - PQ algorithms can be enable or disabled at compile time so it all depends on the liboqs native library. This API listed down the algorithms which are *supported* as reported by the native library. If you're using your own version of the library, you might have different output. 
+```ruby
+require 'roqs'
+
+supported_algo = Roqs::KEM.supported_kem_algo
+supported_algo.each do |al|
+  # al is the algorithm name (string) which is required by subsequent API
+  ...
+end
+```
+
+2. Generate keypair
+```ruby
+require 'roqs'
+
+kyber = Roqs::KEM.new('Kyber768')
+pubKey, secretKey = kyber.genkeypair
+# note pubKey and secretKey (or private key) is Fiddle::Pointer type and 
+# is required to be used by the C API in the subsequent phase.
+# Note that pubKey and secretKey are required to be free manually
+# Refer spec file for usage
+```
+
+3. Key encapsulation - KEM is meant for key encapsulation which similar with Diffie-Hellman kind of key exchange
+```ruby
+require 'roqs'
+
+sessionKey, cipher = kyber.derive_encapsulation_key(pubKey)
+# cipher is required to be sent to recipient end to re-generate the sessionKey at recipient end.
+# Returned sessionKey is meant to convert into the final AES (or any other symmetric key) 
+# for the actual data encryption
+```
+
+4. Key decapsulation - Re-generate the session key from the private key
+```ruby
+require 'roqs'
+
+sessionKey = kyber.derive_decapsulation_key(cipher, secretKey)
+# cipher is given by sender and privKey is the recipient own private key
+```
+
+_sessionKey_ returned from derive\_encapsulation\_key() shall be same as the _sessionKey_ from derive\_decapsulation\_key(). That session key shall be the AES key (any other symmetric key) for the data encryption.
+
+
+### Signature mechanism
+
+Signature mechanism is similar with KEM.
+
+1. List all supported Signature PQ algorithms - It is same as KEM as algorithm can be turned on or off during compile time 
+```ruby
+require 'roqs'
+
+supported_algo = Roqs::SIG.supported_signature_algo
+supported_algo.each do |al|
+  # al is the algorithm name (string) which is required by subsequent API
+  ...
+end
+```
+
+2. Generate keypair
+```ruby
+require 'roqs'
+
+dili = Roqs::SIG.new('Dilithium5')
+pubKey, secretKey = dili.genkeypair
+# note pubKey and secretKey (or private key) is Fiddle::Pointer type and 
+# is required to be used by the C API in the subsequent phase.
+# Note that pubKey and secretKey are required to be free manually
+# Refer spec file for usage
+```
+
+3. Generate data signature 
+```rubyion 
+require 'roqs'
+
+# sign data using sender secretKey/private key
+signature = dili.sign("this is message", secretKey)
+```
+
+4. Verify data signature
+```ruby
+require 'roqs'
+
+# verify signature with given data using sender public key
+res = dili.verify("this is message", signature, pubKey)
+# res is boolean to indicate the signature verification is passed or failed
+```
+
+spec folder has the necessary API example usage.
+
+
+## Test Results
+
+Refer to [test result](https://github.com/chrisliaw/liboqs-ruby/blob/master/TEST-RESULT.md) for details.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+require 'release/gem'

data/TEST-RESULT.md

@@ -0,0 +1,68 @@
+
+# The following are test results for release roqs-0.1.0
+
+liboqs-0.9.0 has less PQ algorithms and includes all 4 + 3 of the [finalist in the NIST PQC Standardization Candidates](https://csrc.nist.gov/news/2022/pqc-candidates-to-be-standardized-and-round-4)
+## Development Environment
+
+The source code was tested on 
+* Linux:   Ruby MRI 3.2.1 (2023-02-08 revision 31819e82c8) [x86\_64-linux], Linux Mint 21.2 x86\_64, Kernel 5.15.0-88-generic, CMake version 3.22.1, Ninja 1.10.1
+
+## Testing result
+
+The following test result is by running the rspec.
+
+The compiled liboqs version 0.9.0 library on Linux works flawlessly.
+
+Unfornately I've lost access to MacOS. Any help would be gladely appreciated.
+
+All KEM and SIG algos supported completed all major operations such as keygen, sign/verify, encap/decap without error.
+
+
+### Windows (Coming Soon)
+
+# The following are the test results for liboqs version 0.7.0 (before NIST finalist was published. It may not relevent for now just for history purposes)
+## Development Environment
+
+The source code was tested on 
+* Linux: Ruby MRI 3.0.2p107 (2021-07-07 revision 0db68f0233) [x86_64-linux], Linux Mint 20.2 x86_64, Kernel 5.4.0-81-generic, Intel i7-9750H, CMake version 3.16.3, Ninja 1.10.0
+* MacOS:   Ruby MRI 3.0.1p64 (2021-04-05 revision 0fb782ee38) [x86\_64-darwin20], Mac OS BigSur 11.5, 2.5GHz Quad-Core Intel Core i7, Apple clang version 12.0.5 (clang-1205.0.22.11), CMake version 3.21.1, Ninja 1.10.2
+* Windows: Ruby MRI 3.0.2p107 (2021-07-07 revision 0db68f02333) [x64-mingw32], Windows 10 64 bits, Microsoft C/C++ compiler v 19.25.28610.4, Intel i7-9750H, CMake version 3.16.19112601-MSVC\_2, Ninja 1.8.2
+
+## Testing result
+
+The following test result is by running the rspec.
+
+The compiled liboqs version 0.7.0 library on Linux works flawlessly on respective OS. 
+
+All KEM and SIG algos supported completed all major operations such as keygen, sign/verify, encap/decap without error.
+
+
+### Windows (Cross Compiling)
+
+Cross compiling DLL for Windows on Linux with MingW toolchain failed with:
+For KEM:
+* BIKE-L1 & BIKE-L3 failed where library return null. Both running ok on Linux and MacOS
+* Stack level too deep with all Classic-McEliece family of algo. All algo of Classic-McEliece-xxxx not able to execute.
+* Stagmentation fault for SIDH-p503, SIDH-p503-compressed, SIDH-p751, SIDH-p751-compressed, SIKE-p503, SIKE-p751, SIKE-p503-compressed and SIKE-p751-compressed
+
+For SIG:
+* Stack level too deep for Rainbow-V-Classic, Rainbow-V-Circumzenithal and Rainbow-V-Compressed
+
+Test cases not able to proceed after "Stack level too deep" exception. Not sure due to Ruby or native library
+
+### Windows (Native build)
+
+Native compile oqs library on Windows however have different result:
+For KEM:
+* BIKE-L1 & BIKE-L3 failed where library return null. Both running ok on Linux and MacOS
+* Stack level too deep with all Classic-McEliece family of algo. All algo of Classic-McEliece-xxxx not able to execute.
+
+For SIG
+* Rainbow-V still crash
+
+Rainbow feels taking longer time on Windows compare to Linux/Mac?
+Sphincs slow too
+
+But SIDH-xxx and SIKE-xxx family passed on native build
+
+

data/lib/roqs/common_wrapper.rb

@@ -0,0 +1,20 @@
+
+require 'fiddle'
+require 'fiddle/import'
+
+module Roqs
+  module CommonWrapper
+   extend Fiddle::Importer
+   include Roqs::Wrapper
+
+   #dlload File.join(File.dirname(__FILE__),"..","..","native","linux","x86_64","liboqs.so.0.7.0")
+   load_oqs_lib
+
+   extern 'int OQS_MEM_secure_bcmp(const void *a, const void *b, size_t len)'
+   extern 'int OQS_MEM_cleanse(const void *ptr, size_t len)'
+   extern 'int OQS_MEM_secure_free(void *ptr, size_t len)'
+   extern 'int OQS_MEM_insecure_free(void *ptr)'
+
+
+  end
+end

data/lib/roqs/kem.rb

@@ -0,0 +1,148 @@
+
+require_relative 'struct'
+require_relative 'kem_wrapper'
+require_relative 'common_wrapper'
+
+require_relative 'kem_public_key'
+
+module Roqs
+  class KEM
+   
+   def self.supported_kem_algo
+     ttl = KEMWrapper.OQS_KEM_alg_count
+     supported = []
+     (0...ttl).each do |i|
+        pName = KEMWrapper.OQS_KEM_alg_identifier(i)
+        name = pName.to_s
+        st = KEMWrapper.OQS_KEM_alg_is_enabled(name)
+        if st
+          supported << name
+        end
+     end
+
+     supported
+   end
+
+   def initialize(name)
+     @algo = name
+     oqsKem = KEMWrapper.OQS_KEM_new(@algo) 
+     raise Error, "Unable to create object '#{@algo}'. It is either the algorithm not supported or it is disabled at compile time." if oqsKem.null?
+     @struct = OQS_KEM.new(oqsKem)
+   end
+
+   def cleanup
+     KEMWrapper.OQS_KEM_free(@struct) if not @struct.nil?
+   end
+
+   def free(obj)
+     obj.free if not (obj.nil? and obj.null?)
+   end
+
+   def intrinsic_name
+     @struct.intrinsic_name.to_s
+   end
+
+   def algo_version
+     @struct.algo_version.to_s
+   end
+
+   def method_missing(mtd, *args, &block)
+     @struct.send(mtd) if not @struct.nil? and @struct.respond_to?(mtd)
+   end
+
+   def genkeypair
+     pubKey = Fiddle::Pointer.malloc(@struct.length_public_key, Fiddle::RUBY_FREE)
+     raise Error, "Unable to allocate memory for public key size #{@struct.length_public_key}" if pubKey.null?
+     privKey = Fiddle::Pointer.malloc(@struct.length_secret_key, Fiddle::RUBY_FREE)
+     raise Error, "Unable to allocate memory for secret key size #{@struct.length_secret_key}" if privKey.null?
+
+     rv = KEMWrapper.OQS_KEM_keypair(@struct, pubKey, privKey)
+     raise Error, "Error in generation of keypair" if rv != Roqs::OQS_SUCCESS
+
+     #pubKeyBin = pubKey[0, pubKey.size]
+     #privKeyBin = privKey[0, privKey.size]
+
+     [KEMPublicKey.new(pubKey), privKey]
+   end
+
+   def derive_encapsulation_key(pubKey)
+
+     cipher = Fiddle::Pointer.malloc(@struct.length_ciphertext, Fiddle::RUBY_FREE)
+     raise Error, "Unable to allocate memory for ciphertext size #{@struct.length_ciphertext}" if cipher.null?
+
+     encpKey = Fiddle::Pointer.malloc(@struct.length_shared_secret, Fiddle::RUBY_FREE)
+     raise Error, "Unable to allocate memory for shared secret size #{@struct.length_shared_secret}" if encpKey.null?
+     
+     rv = KEMWrapper.OQS_KEM_encaps(@struct, cipher, encpKey, pubKey)
+     raise Error, "Error in encapsulation" if rv != Roqs::OQS_SUCCESS
+
+     encpKeyBin = encpKey[0,encpKey.size]
+     cipherBin = cipher[0,cipher.size]
+
+     cipher.free
+     encpKey.free
+
+     [encpKeyBin, cipherBin]
+
+   end
+
+   def derive_decapsulation_key(cipherBin, privKey)
+
+     raise Error, "Cipher cannot be empty" if cipherBin.nil?
+     raise Error, "Private key cannot be nil" if privKey.nil?
+
+     encpKey = Fiddle::Pointer.malloc(@struct.length_shared_secret, Fiddle::RUBY_FREE)
+     raise Error, "Unable to allocate memory for shared secret size #{@struct.length_shared_secret}" if encpKey.null?
+     
+     rv = KEMWrapper.OQS_KEM_decaps(@struct, encpKey , cipherBin, privKey)
+     raise Error, "Error in decapsulation" if rv != Roqs::OQS_SUCCESS
+
+     encpKeyBin = encpKey[0,encpKey.size]
+
+     encpKey.free
+
+     encpKeyBin
+     
+   end
+
+   #def test
+
+   #  @cipher = Fiddle::Pointer.malloc(@struct.length_ciphertext, Fiddle::RUBY_FREE)
+   #  raise Error, "Unable to allocate memory for ciphertext size #{@struct.length_ciphertext}" if @cipher.null?
+
+   #  shared_e = Fiddle::Pointer.malloc(@struct.length_shared_secret, Fiddle::RUBY_FREE)
+   #  raise Error, "Unable to allocate memory for shared secret size #{@struct.length_shared_secret}" if shared_e.null?
+   #  
+   #  shared_d = Fiddle::Pointer.malloc(@struct.length_shared_secret, Fiddle::RUBY_FREE)
+   #  raise Error, "Unable to allocate memory for shared secret size #{@struct.length_shared_secret}" if shared_d.null?
+
+   #  shared_x = Fiddle::Pointer.malloc(@struct.length_shared_secret, Fiddle::RUBY_FREE)
+   # 
+   #  p shared_e.ptr == shared_d.ptr
+
+   #  rb = shared_e[0, shared_e.size]
+   #  p rb
+
+   #  rv = KEMWrapper.OQS_KEM_encaps(@struct, @cipher, shared_e, @pubKey)
+   #  raise Error, "Error in encapsulation" if rv != KEMWrapper::OQS_SUCCESS
+
+   #  rb = shared_e[0, shared_e.size]
+   #  p rb
+
+   #  p shared_e.ptr == shared_d.ptr
+
+   #  rv = KEMWrapper.OQS_KEM_decaps(@struct, shared_d, @cipher, @privKey)
+   #  raise Error, "Error in decapsulation" if rv != KEMWrapper::OQS_SUCCESS
+
+   #  p shared_e.ptr == shared_d.ptr
+
+   #  p shared_d.size
+   #  rb = shared_d[0, shared_d.size]
+   #  p rb
+
+
+   #end
+
+  end
+  
+end

data/lib/roqs/kem_public_key.rb

@@ -0,0 +1,28 @@
+
+require_relative 'struct'
+require_relative 'kem_wrapper'
+require_relative 'common_wrapper'
+
+module Roqs
+  class KEMPublicKey
+    
+    def initialize(nativePubKey)
+      @native_pubkey = nativePubKey
+    end
+
+    def length
+      @native_pubkey.size
+    end
+
+    def bytes
+      #puts "raw 1 : #{@native_pubkey.size}"
+      #puts "raw 2 : #{@native_pubkey.to_str}"
+      @native_pubkey.to_str
+    end
+
+    def native_pubkey
+      @native_pubkey
+    end
+
+  end
+end

data/lib/roqs/kem_wrapper.rb

@@ -0,0 +1,28 @@
+
+require 'fiddle'
+require 'fiddle/import'
+
+require_relative 'wrapper'
+
+module Roqs
+  module KEMWrapper
+   extend Fiddle::Importer
+   include Roqs::Wrapper
+
+   #dlload File.join(File.dirname(__FILE__),"..","..","native","linux","x86_64","liboqs.so.0.7.0")
+   load_oqs_lib
+
+   extern 'const char * OQS_KEM_alg_identifier(size_t i)'
+   extern 'int OQS_KEM_alg_count(void)'
+   extern 'int OQS_KEM_alg_is_enabled(const char * name)'
+
+   extern 'OQS_KEM * OQS_KEM_new(const char * algo)'
+   extern 'void OQS_KEM_free(OQS_KEM * kem)'
+
+   extern 'int OQS_KEM_keypair(const OQS_KEM *kem, uint8_t *public_key, uint8_t *secret_key)'
+   
+   extern 'int OQS_KEM_encaps(const OQS_KEM *kem, uint8_t * ciphertext, uint8_t *shared_secret, uint8_t *public_key)'
+   extern 'int OQS_KEM_decaps(const OQS_KEM *kem, uint8_t * shared_secret, uint8_t *ciphertext, uint8_t *secret_key)'
+
+  end
+end

data/lib/roqs/sig.rb

@@ -0,0 +1,99 @@
+
+require_relative 'struct'
+require_relative 'sig_wrapper'
+require_relative 'common_wrapper'
+
+module Roqs
+  class SIG
+
+   def self.supported_signature_algo
+     ttl = SIGWrapper.OQS_SIG_alg_count
+     supported = []
+     (0...ttl).each do |i|
+        pName = SIGWrapper.OQS_SIG_alg_identifier(i)
+        name = pName.to_s
+        st = SIGWrapper.OQS_SIG_alg_is_enabled(name)
+        if st
+          supported << name
+        end
+     end
+
+     supported
+   end
+
+   def initialize(name)
+     @algo = name
+     oqsSig = SIGWrapper.OQS_SIG_new(@algo) 
+     raise Error, "Unable to create object '#{@algo}'. It is either the algorithm not supported or it is disabled at compile time." if oqsSig.null?
+     @struct = OQS_SIG.new(oqsSig)
+   end
+
+   def cleanup
+     SIGWrapper.OQS_SIG_free(@struct) if not @struct.nil?
+   end
+
+   def free(obj)
+     obj.free if not (obj.nil? and obj.null?)
+   end
+
+   def intrinsic_name
+     @struct.intrinsic_name.to_s
+   end
+
+   def algo_version
+     @struct.algo_version.to_s
+   end
+
+   def method_missing(mtd, *args, &block)
+     @struct.send(mtd) if not @struct.nil? and @struct.respond_to?(mtd)
+   end
+
+   def genkeypair
+     pubKey = Fiddle::Pointer.malloc(@struct.length_public_key, Fiddle::RUBY_FREE)
+     raise Error, "Unable to allocate memory for public key size #{@struct.length_public_key}" if pubKey.null?
+     privKey = Fiddle::Pointer.malloc(@struct.length_secret_key, Fiddle::RUBY_FREE)
+     raise Error, "Unable to allocate memory for secret key size #{@struct.length_secret_key}" if privKey.null?
+
+     rv = SIGWrapper.OQS_SIG_keypair(@struct, pubKey, privKey)
+     raise Error, "Error in generation of keypair" if rv != Roqs::OQS_SUCCESS
+
+     [pubKey, privKey]
+   end
+
+   def verify(message,signature,pubKey)
+
+     pMessage = Fiddle::Pointer.to_ptr(message)
+     pSignature = Fiddle::Pointer.to_ptr(signature)
+     
+     rv = SIGWrapper.OQS_SIG_verify(@struct, pMessage, message.length, pSignature, signature.length, pubKey)
+
+     rv == Roqs::OQS_SUCCESS
+
+   end
+
+   def sign(message, privKey)
+
+     raise Error, "Private key cannot be nil" if privKey.nil?
+
+     signature = Fiddle::Pointer.malloc(@struct.length_signature, Fiddle::RUBY_FREE)
+     raise Error, "Unable to allocate memory for signature size #{@struct.length_signature}" if signature.null?
+     signLen = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SIZE_T, Fiddle::RUBY_FREE)
+     raise Error, "Unable to allocate memory for signature length size #{Fiddle::SIZEOF_SIZE_T}" if signLen.null?
+   
+     pMessage = Fiddle::Pointer.to_ptr(message)
+
+     rv = SIGWrapper.OQS_SIG_sign(@struct, signature, signLen, pMessage, message.length, privKey)
+     raise Error, "Error in signing" if rv != Roqs::OQS_SUCCESS
+
+     signBin = signature[0, signLen.ptr.to_i]
+
+     signLen.free
+     signature.free
+
+     signBin
+     
+   end
+
+  end
+  
+end

data/lib/roqs/sig_wrapper.rb

@@ -0,0 +1,31 @@
+
+require 'fiddle'
+require 'fiddle/import'
+
+module Roqs
+  module SIGWrapper
+   extend Fiddle::Importer
+   include Roqs::Wrapper
+
+   ## OQS_STATUS
+   #OQS_ERROR = -1
+   #OQS_SUCCESS = 0
+   #OQS_EXTERNAL_LIB_ERROR_OPENSSL = 50
+    
+   #dlload File.join(File.dirname(__FILE__),"..","..","native","linux","x86_64","liboqs.so.0.7.0")
+   load_oqs_lib
+
+   extern 'const char * OQS_SIG_alg_identifier(size_t i)'
+   extern 'int OQS_SIG_alg_count(void)'
+   extern 'int OQS_SIG_alg_is_enabled(const char * name)'
+
+   extern 'OQS_SIG * OQS_SIG_new(const char * algo)'
+   extern 'void OQS_SIG_free(OQS_SIG * sig)'
+
+   extern 'int OQS_SIG_keypair(const OQS_SIG *sig, uint8_t *public_key, uint8_t *secret_key)'
+   
+   extern 'int OQS_SIG_sign(const OQS_SIG *sig, uint8_t * signature, size_t *signature_len, uint8_t *message, size_t message_len, uint8_t *secret_key)'
+   extern 'int OQS_SIG_verify(const OQS_SIG *sig, uint8_t * message, size_t message_len, uint8_t *signature, size_t signature_len, uint8_t *public_key)'
+
+  end
+end

data/lib/roqs/struct.rb

@@ -0,0 +1,35 @@
+
+require 'fiddle'
+require 'fiddle/import'
+
+module Roqs
+  extend Fiddle::Importer
+
+  OQS_KEM = struct [
+    "const char * intrinsic_name",
+    "const char * algo_version",
+    "uint8_t claimed_nist_level",
+    "int ind_cca",
+    "size_t length_public_key",
+    "size_t length_secret_key",
+    "size_t length_ciphertext",
+    "size_t length_shared_secret",
+    "int (*keypair)(uint8_t *pubKey, uint8_t* secretKey)",
+    "int (*encaps)(uint8_t *cipher_text, uint8_t* shared_secret, const unit8_t * pubKey)",
+    "int (*decaps)(uint8_t *shared_secret, uint8_t* cipher_text, const unit8_t * secretKey)"
+  ]
+
+  OQS_SIG = struct [
+    "const char * intrinsic_name",
+    "const char * algo_version",
+    "uint8_t claimed_nist_level",
+    "int euf_cma",
+    "size_t length_public_key",
+    "size_t length_secret_key",
+    "size_t length_signature",
+    "int (*keypair)(uint8_t *pubKey, uint8_t* secretKey)",
+    "int (*sign)(uint8_t *signature, size_t signature_len, const uint8_t* message, size_t message_len, const unit8_t * secretKey)",
+    "int (*verify)(uint8_t *message, size_t message_len, const uint8_t* signature, size_t signature_len, const unit8_t * pubKey)"
+  ]
+ 
+end

data/lib/roqs/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Roqs
+  VERSION = "0.1.0"
+end

data/lib/roqs/wrapper.rb

@@ -0,0 +1,79 @@
+
+require 'fiddle'
+
+module Roqs
+  module Wrapper
+    class WrapperError < StandardError; end
+
+    module ClassMethods
+      def load_oqs_lib
+        os = detect_os
+        logger.debug "Found OS #{os}"
+        load_arch_lib(os)          
+      end
+
+      def detect_os
+        plat = RUBY_PLATFORM
+        if plat =~ /linux/
+          :linux
+        elsif plat =~ /darwin/
+          :macos
+        elsif plat =~ /mingw/
+          :windows
+        else
+          raise WrapperError, "Unknown platform detected. [#{plat}]"
+        end
+      end
+
+      def load_arch_lib(os) 
+        plat = RUBY_PLATFORM
+        pplat = plat.split('-')[0]
+        logger.debug "OS architecture is #{pplat}"
+        usrDrvDir = ENV['ROQS_LIBOQS_DIR']
+        if not_empty?(usrDrvDir)
+          logger.debug "Load liboqs shared library from user provided root : #{File.join(usrDrvDir, pplat)}" 
+          drvDir = File.join(usrDrvDir,pplat)
+        else
+          logger.debug "Load liboqs shared library from Roqs internal root : #{File.join(File.dirname(__FILE__),"..","..","native","#{os}",pplat)}" 
+          drvDir = File.join(File.dirname(__FILE__),"..","..","native","#{os}",pplat)
+        end
+
+        if File.exist?(drvDir)
+          Dir.glob(File.join(drvDir,"liboqs*")) do |f|
+            logger.debug "Loading liboqs at : #{f}"
+            dlload f
+          end
+        else
+          errMsg = []
+          errMsg << "Shared library of liboqs (https://github.com/open-quantum-safe/liboqs) could not be found at '#{drvDir}'"
+          errMsg << "You might need to compile for your platform."
+          errMsg << "Simply follow the steps beflow:"
+          errMsg << "1. Clone the repository at https://github.com/open-quantum-safe/liboqs"
+          errMsg << "   > clone https://github.com/open-quantum-safe/liboqs liboqs"
+          errMsg << "2. Make sure all pre-requisites are installed as documented here : https://github.com/open-quantum-safe/liboqs#quickstart"
+          errMsg << "3. Run the following commands: "
+          errMsg << "   > cd liboqs && mkdir build && cd build"
+          errMsg << "   > cmake -GNinja .. -DBUILD_SHARED_LIBS=ON"
+          errMsg << "   > ninja"
+          errMsg << "4. Shared library shall be built under lib dir."
+          errMsg << "5. Copy the shared library into '#{drvDir}' and you should be good to go"
+          errMsg << "   Note: System shall read env variable 'ROQS_LIBOQS_DIR' to decide where to load the liboqs dynamic library from."
+          errMsg << "         If no value is given, system shall load from default path : #{File.join(File.dirname(__FILE__),"..","..","native","#{os}",pplat)}"
+          raise WrapperError, errMsg.join("\n")
+        end
+      end
+
+      def logger
+        Roqs.logger(:roqs_wrapper)
+      end
+    end
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    def logger
+      self.class.logger
+    end
+
+  end
+end

data/lib/roqs.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'teLogger'
+require 'toolrack'
+
+require_relative "roqs/version"
+
+module Roqs
+  include TR::CondUtils
+
+  # OQS_STATUS
+  OQS_ERROR = -1
+  OQS_SUCCESS = 0
+  OQS_EXTERNAL_LIB_ERROR_OPENSSL = 50
+
+  class Error < StandardError; end
+  # Your code goes here...
+
+  def self.logger(tag = nil, &block)
+    @_logger = TeLogger::Tlogger.new if @_logger.nil?
+
+    if block
+      if not_empty?(tag)
+        @_logger.with_tag(tag, &block)
+      else
+        @_logger.with_tag(@_logger.tag, &block)
+      end
+    elsif is_empty?(tag)
+      @_logger.tag = :roqs
+      @_logger
+    else
+      # no block but tag is given? hmm
+      @_logger.tag = tag
+      @_logger
+    end
+  end
+
+end
+
+require_relative "roqs/struct"
+require_relative "roqs/kem"
+require_relative "roqs/sig"

data/sig/roqs.rbs

@@ -0,0 +1,4 @@
+module Roqs
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: roqs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: teLogger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: toolrack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: release-gem
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+description: ''
+email:
+- chris@antrapol.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- README.md
+- Rakefile
+- TEST-RESULT.md
+- lib/roqs.rb
+- lib/roqs/common_wrapper.rb
+- lib/roqs/kem.rb
+- lib/roqs/kem_public_key.rb
+- lib/roqs/kem_wrapper.rb
+- lib/roqs/sig.rb
+- lib/roqs/sig_wrapper.rb
+- lib/roqs/struct.rb
+- lib/roqs/version.rb
+- lib/roqs/wrapper.rb
+- native/linux/x86_64/liboqs.so.0.9.0
+- native/macos/x86_64/liboqs.0.7.0.dylib
+- native/windows/x64/liboqs.dll
+- sig/roqs.rbs
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []