gmssl 1.0.8 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 436a0544ac1c53637b71170298bc0bf93d94c6fd21372b56587db3cc46599991
-  data.tar.gz: 366622549c376a7a6eab32ab4bc3fe25f3849a18a1e9e581c8dbc2c9429ca162
+  metadata.gz: f7e663d96e76c2db23bf58d1a32af5dee12caa50388867dbb72edda107bd0a65
+  data.tar.gz: 83d4a5d271287c85bada897a9fd22a4ee5db8e4d96cf9dac6fe59f9c58492eb8
 SHA512:
-  metadata.gz: 7d57c9230214a77d0cc7b2b7bee316363c5f810104342fa3c5cf30548bbb3b6a7b6650f150003c2cc37b126390c1d1d20369b08ceae9cd34f99beeed518200a8
-  data.tar.gz: 4c88b05a8647b705117d880f37881d9f6e8588100043b3992de74550125774dd52390ddb5dbc9a0676bcb37809c47bd9a5ba576f8360041b5b6a133bb8060e87
+  metadata.gz: a2d9c2376e77251cd14214f75bc11770b4c3711e7cac6fccc88ac65b44d297d95424b9681b860bd9a6332f66e64605f3e4ccaf27472933d1bb4d82f34677a9f6
+  data.tar.gz: ea7f7305374bb138ec02ca4ebb85cb1fa948fb1aaedd12790f85d145e30ced25b981d7512709fa03d11509f5da68199fd7a9c207d966b62d0ff637c317f170c9

data/lib/gmssl/helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Helper
+  # Example usage
+  # hex_string = "54A38E3B599E48C4F581FEC14B62EA29"
+  # packed_bytes = hex_string_to_packed_bytes(hex_string)
+  # puts packed_bytes
+  def hex_string_to_packed_bytes(hex_string)
+    hex_string.scan(/../).map { |byte| byte.hex }.pack("C*")
+  end
+
+  # Example usage
+  # bytes = [0x54, 0xA3, 0x8E, 0x3B, 0x59, 0x9E, 0x48, 0xC4]
+  # hex_string = bytes_to_hex_string(bytes.pack('C*'))
+  # puts hex_string
+  def bytes_to_hex_string(bytes)
+    bytes.unpack1('H*')
+  end
+end

data/lib/gmssl/random.rb

@@ -9,5 +9,11 @@ module GmSSL
     ffi_lib file
 
     attach_function :rand_bytes, [:pointer, :size_t], :int
+
+    def self.bytes(n = 256)
+      buf = FFI::MemoryPointer.new(:uint8, n)
+      Random.rand_bytes(buf, n)
+      buf.read_bytes(n).unpack('H*').first
+    end
   end
 end

data/lib/gmssl/sm3.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 require 'ffi'
+require 'gmssl/helper'
 
 module GmSSL
   module SM3
+    extend Helper
     extend FFI::Library
     file = File.join GmSSL.lib, LIB_FILE
     ffi_lib file
@@ -56,5 +58,34 @@ module GmSSL
     attach_function :sm3_digest_init, [SM3_DIGEST_CTX.by_ref, :pointer, :size_t], :int
     attach_function :sm3_digest_update, [SM3_DIGEST_CTX.by_ref, :pointer, :size_t], :int
     attach_function :sm3_digest_finish, [SM3_DIGEST_CTX.by_ref, :pointer], :int
+
+    def self.digest(data)
+      # Initialize SM3
+      sm3_ctx = SM3_CTX.new
+      sm3_init(sm3_ctx)
+      # Update SM3 context with data
+      sm3_update(sm3_ctx, data, data.bytesize)
+      # Finalize the hash
+      digest = FFI::MemoryPointer.new(:uint8, SM3_DIGEST_SIZE)
+      sm3_finish(sm3_ctx, digest)
+      digest.read_bytes(SM3_DIGEST_SIZE).unpack1('H*')
+    end
+
+    def self.hmac(hex_key, data)
+      key = hex_string_to_packed_bytes(hex_key)
+      ctx = SM3_HMAC_CTX.new
+      sm3_hmac_init(ctx, key, key.bytesize)
+      sm3_hmac_update(ctx, data, data.bytesize)
+      mac = FFI::MemoryPointer.new(:uint8, SM3_HMAC_SIZE)
+      sm3_hmac_finish(ctx, mac)
+      mac.read_string(SM3_HMAC_SIZE).unpack1('H*')
+    end
+
+    def self.pbkdf2(psswd, hex_salt, iterations, outlen)
+      salt = hex_string_to_packed_bytes(hex_salt)
+      out = FFI::MemoryPointer.new(:uint8, outlen)
+      sm3_pbkdf2(psswd, psswd.bytesize, salt, salt.bytesize, iterations, outlen, out)
+      out.read_string(outlen).unpack1('H*')
+    end
   end
 end

data/lib/gmssl/sm4.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require 'ffi'
-
 require 'gmssl/ghash'
+require 'gmssl/helper'
 
 module GmSSL
   module SM4
+    extend Helper
     extend FFI::Library
     file = File.join GmSSL.lib, LIB_FILE
     ffi_lib file
@@ -82,5 +83,91 @@ module GmSSL
     attach_function :sm4_gcm_decrypt_update, [SM4_GCM_CTX.by_ref, :pointer, :size_t, :pointer, :pointer], :int
     attach_function :sm4_gcm_decrypt_finish, [SM4_GCM_CTX.by_ref, :pointer, :pointer], :int
 
+    def self.cbc_encrypt(key, iv, plaintext)
+      ctx = SM4::SM4_CBC_CTX.new
+      SM4.sm4_cbc_encrypt_init(ctx, key, iv)
+      ciphertext = FFI::MemoryPointer.new(:uint8, plaintext.bytesize + SM4::SM4_BLOCK_SIZE)
+      outlen = FFI::MemoryPointer.new(:size_t)
+      SM4.sm4_cbc_encrypt_update(ctx, plaintext, plaintext.bytesize, ciphertext, outlen)
+      ciphertext_len = outlen.read(:size_t)
+      SM4.sm4_cbc_encrypt_finish(ctx, ciphertext + ciphertext_len, outlen)
+      ciphertext_len += outlen.read(:size_t)
+      bytes_to_hex_string ciphertext.read_bytes(ciphertext_len)
+    end
+
+    def self.cbc_decrypt(key, iv, ciphertext)
+      ciphertext = hex_string_to_packed_bytes ciphertext
+      ctx = SM4::SM4_CBC_CTX.new
+      SM4.sm4_cbc_decrypt_init(ctx, key, iv)
+      decrypted = FFI::MemoryPointer.new(:uint8, ciphertext.bytesize + SM4::SM4_BLOCK_SIZE)
+      outlen = FFI::MemoryPointer.new(:size_t)
+      SM4.sm4_cbc_decrypt_update(ctx, ciphertext, ciphertext.bytesize, decrypted, outlen)
+      decrypted_len = outlen.read(:size_t)
+      SM4.sm4_cbc_decrypt_finish(ctx, decrypted + decrypted_len, outlen)
+      decrypted_len += outlen.read(:size_t)
+      decrypted.read_bytes(decrypted_len)
+    end
+
+    def self.ctr_encrypt(input_string, key_hex, ctr_hex)
+      key = hex_string_to_packed_bytes(key_hex)
+      ctr = hex_string_to_packed_bytes(ctr_hex)
+      input_data = input_string.bytes.pack("C*")
+      output_data = FFI::MemoryPointer.new(:uint8, input_data.bytesize)
+      output_length = FFI::MemoryPointer.new(:size_t)
+      key_ptr = FFI::MemoryPointer.new(:uint8, SM4::SM4_KEY_SIZE)
+      ctr_ptr = FFI::MemoryPointer.new(:uint8, SM4::SM4_BLOCK_SIZE)
+      key_ptr.put_array_of_uint8(0, key.bytes)
+      ctr_ptr.put_array_of_uint8(0, ctr.bytes)
+      ctx = SM4::SM4_CTR_CTX.new
+      SM4.sm4_ctr_encrypt_init(ctx, key_ptr, ctr_ptr)
+      SM4.sm4_ctr_encrypt_update(ctx, input_data, input_data.bytesize, output_data, output_length)
+      SM4.sm4_ctr_encrypt_finish(ctx, output_data, output_length)
+      encrypted_data = output_data.read_string(output_length.read(:size_t))
+      encrypted_data.unpack("H*")[0]
+    end
+
+    def self.gcm_encrypt(key, iv, aad, input)
+      key = hex_string_to_packed_bytes key
+      iv = hex_string_to_packed_bytes iv
+      key_struct = SM4::SM4_KEY.new
+      key_ptr = FFI::MemoryPointer.new(:uint8, SM4::SM4_KEY_SIZE)
+      key_ptr.put_array_of_uint8(0, key.bytes)
+      SM4::sm4_set_encrypt_key(key_struct, key_ptr)
+      iv_ptr = FFI::MemoryPointer.new(:uint8, SM4::SM4_BLOCK_SIZE)
+      iv_ptr.put_array_of_uint8(0, iv.bytes)
+      aad_ptr = FFI::MemoryPointer.new(:uint8, aad.bytesize)
+      aad_ptr.put_array_of_uint8(0, aad.bytes)
+      input_ptr = FFI::MemoryPointer.new(:uint8, input.bytesize)
+      input_ptr.put_array_of_uint8(0, input.bytes)
+      output_ptr = FFI::MemoryPointer.new(:uint8, input.bytesize)
+      tag_ptr = FFI::MemoryPointer.new(:uint8, SM4::SM4_GCM_MAX_TAG_SIZE)
+      SM4::sm4_gcm_encrypt(key_struct, iv_ptr, iv.bytesize, aad_ptr, aad.bytesize, input_ptr, input.bytesize, output_ptr, SM4::SM4_GCM_MAX_TAG_SIZE, tag_ptr)
+      encrypted_output = encrypted_output = output_ptr.read_string(input.bytesize).unpack1("H*")
+      tag = tag_ptr.read_string(SM4::SM4_GCM_MAX_TAG_SIZE).unpack1("H*")
+      return encrypted_output, tag
+    end
+
+    def self.gcm_decrypt(key, iv, aad, encrypted_output, tag)
+      encrypted_output = hex_string_to_packed_bytes encrypted_output
+      tag = hex_string_to_packed_bytes tag
+      key = hex_string_to_packed_bytes key
+      iv = hex_string_to_packed_bytes iv
+      key_struct = SM4::SM4_KEY.new
+      key_ptr = FFI::MemoryPointer.new(:uint8, SM4::SM4_KEY_SIZE)
+      key_ptr.put_array_of_uint8(0, key.bytes)
+      SM4::sm4_set_encrypt_key(key_struct, key_ptr)
+      iv_ptr = FFI::MemoryPointer.new(:uint8, SM4::SM4_BLOCK_SIZE)
+      iv_ptr.put_array_of_uint8(0, iv.bytes)
+      aad_ptr = FFI::MemoryPointer.new(:uint8, aad.bytesize)
+      aad_ptr.put_array_of_uint8(0, aad.bytes)
+      encrypted_ptr = FFI::MemoryPointer.new(:uint8, encrypted_output.bytesize)
+      encrypted_ptr.put_array_of_uint8(0, encrypted_output.bytes)
+      tag_ptr = FFI::MemoryPointer.new(:uint8, SM4::SM4_GCM_MAX_TAG_SIZE)
+      tag_ptr.put_array_of_uint8(0, tag.bytes)
+      decrypted_output_ptr = FFI::MemoryPointer.new(:uint8, encrypted_output.bytesize)
+      SM4::sm4_gcm_decrypt(key_struct, iv_ptr, iv.bytesize, aad_ptr, aad.bytesize, encrypted_ptr, encrypted_output.bytesize, tag_ptr, SM4::SM4_GCM_MAX_TAG_SIZE, decrypted_output_ptr)
+      decrypted_output = decrypted_output_ptr.read_string(encrypted_output.bytesize)
+      return decrypted_output
+    end
   end
 end

data/lib/gmssl/version.rb

@@ -10,5 +10,9 @@ module GmSSL
 
     attach_function :gmssl_version_num, [], :int
     attach_function :gmssl_version_str, [], :string
+
+    def self.info
+      "VERSION: #{gmssl_version_num}, #{gmssl_version_str}"
+    end
   end
 end

data/lib/gmssl/zuc.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 require 'ffi'
+require 'gmssl/helper'
 
 module GmSSL
   module ZUC
+    extend Helper
     extend FFI::Library
     file = File.join GmSSL.lib, LIB_FILE
     ffi_lib file
@@ -28,5 +30,44 @@ module GmSSL
     attach_function :zuc_encrypt_init, [ZUC_CTX.by_ref, :pointer, :pointer], :int
     attach_function :zuc_encrypt_update, [ZUC_CTX.by_ref, :pointer, :size_t, :pointer, :pointer], :int
     attach_function :zuc_encrypt_finish, [ZUC_CTX.by_ref, :pointer, :pointer], :int
+
+    def self.encrypt(key, iv, input)
+      key = hex_string_to_packed_bytes key
+      iv = hex_string_to_packed_bytes iv
+      key_ptr = FFI::MemoryPointer.new(:uint8, ZUC::ZUC_KEY_SIZE)
+      key_ptr.put_array_of_uint8(0, key.bytes)
+      iv_ptr = FFI::MemoryPointer.new(:uint8, ZUC::ZUC_IV_SIZE)
+      iv_ptr.put_array_of_uint8(0, iv.bytes)
+      ctx = ZUC::ZUC_CTX.new
+      ZUC::zuc_encrypt_init(ctx, key_ptr, iv_ptr)
+      input_ptr = FFI::MemoryPointer.new(:uint8, input.bytesize)
+      input_ptr.put_array_of_uint8(0, input.bytes)
+      output_ptr = FFI::MemoryPointer.new(:uint8, input.bytesize)
+      outlen_ptr = FFI::MemoryPointer.new(:size_t)
+      ZUC::zuc_encrypt_update(ctx, input_ptr, input.bytesize, output_ptr, outlen_ptr)
+      ZUC::zuc_encrypt_finish(ctx, output_ptr, outlen_ptr)
+      encrypted_output = output_ptr.get_array_of_uint8(0, input.bytesize)
+      bytes_to_hex_string encrypted_output.pack('C*')
+    end
+
+    def self.decrypt(key, iv, encrypted_output)
+      encrypted_output = hex_string_to_packed_bytes encrypted_output
+      key = hex_string_to_packed_bytes key
+      iv = hex_string_to_packed_bytes iv
+      key_ptr = FFI::MemoryPointer.new(:uint8, ZUC::ZUC_KEY_SIZE)
+      key_ptr.put_array_of_uint8(0, key.bytes)
+      iv_ptr = FFI::MemoryPointer.new(:uint8, ZUC::ZUC_IV_SIZE)
+      iv_ptr.put_array_of_uint8(0, iv.bytes)
+      ctx = ZUC::ZUC_CTX.new
+      ZUC::zuc_encrypt_init(ctx, key_ptr, iv_ptr)
+      encrypted_input_ptr = FFI::MemoryPointer.new(:uint8, encrypted_output.bytesize)
+      encrypted_input_ptr.put_array_of_uint8(0, encrypted_output.bytes)
+      decrypted_output_ptr = FFI::MemoryPointer.new(:uint8, encrypted_output.bytesize)
+      outlen_ptr = FFI::MemoryPointer.new(:size_t)
+      ZUC::zuc_encrypt_update(ctx, encrypted_input_ptr, encrypted_output.bytesize, decrypted_output_ptr, outlen_ptr)
+      ZUC::zuc_encrypt_finish(ctx, decrypted_output_ptr, outlen_ptr)
+      decrypted_output = decrypted_output_ptr.get_array_of_uint8(0, encrypted_output.bytesize)
+      decrypted_output.pack('C*')
+    end
   end
 end

data/test/helper.rb

@@ -7,3 +7,11 @@
 def hex_string_to_packed_bytes(hex_string)
   hex_string.scan(/../).map { |byte| byte.hex }.pack("C*")
 end
+
+# Example usage
+# bytes = [0x54, 0xA3, 0x8E, 0x3B, 0x59, 0x9E, 0x48, 0xC4]
+# hex_string = bytes_to_hex_string(bytes.pack('C*'))
+# puts hex_string
+def bytes_to_hex_string(bytes)
+  bytes.unpack1('H*')
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: gmssl
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.1.1
 platform: ruby
 authors:
 - memorycancel
 bindir: bin
 cert_chain: []
-date: 2025-01-20 00:00:00.000000000 Z
+date: 2025-01-23 00:00:00.000000000 Z
 dependencies: []
 description: GmSSL c to ruby FFI
 email: memorycancel@gmail.com
@@ -68,6 +68,7 @@ files:
 - GmSSL/build/bin/zuctest
 - lib/gmssl.rb
 - lib/gmssl/ghash.rb
+- lib/gmssl/helper.rb
 - lib/gmssl/random.rb
 - lib/gmssl/sm3.rb
 - lib/gmssl/sm4.rb