gmssl 1.0.5 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9514334537ed45916f2bbf32ae560f6512b5818b5573cf311279a8bade02d6b
-  data.tar.gz: ca339c65e15b7e10e406e29850a3df105fa241cad9cd149833bce1814d8c052a
+  metadata.gz: 91be02f2afeab55a32d5baa453111c80def28f5d1abfbf6be95b137f216103dd
+  data.tar.gz: 8b6c27ee63aac9a32249f6050fe146211f14ba0cb50c021791e4b6886a011a79
 SHA512:
-  metadata.gz: 68cae5e537a484ed824cb06a885b83768a3be8add848bdfd61d2c1c6c6b0770cfb9119c5f8a9e0b38e46799415bab6518ba5a3efecef811426500a1b4b46c6a8
-  data.tar.gz: 402efb2453cdbeb3ef2aababf311fddb819e165a6ecac2e6ab4851531f5d3a5d6d9be54824706d0dd87ff749ef9f447aeb9138733aa12824334aab7ea86747f9
+  metadata.gz: 00c9c994e7a478215afa4705a4ac03d8b08e5e651d4cc8b1ddd1a7a9b6224fe62e2c3804ae4dca950c6b4ddc44a7b68d75fcce8f7098a99782ff9cf73ae22095
+  data.tar.gz: 42770e67af88dcde97433e3a70064bcef5dececf5700ff232752385f41cca461adc3b781ee7548aa0346aaf1d88a6edc84296fa19857b0c1223d3ce381aa8056

data/lib/gmssl/ghash.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module GmSSL
+  module Ghash
+    extend FFI::Library
+    file = File.join GmSSL.lib, LIB_FILE
+    ffi_lib file
+
+    class GF128 < FFI::Struct
+      layout :data, [:uint64, 2]
+    end
+
+    class GHASH_CTX < FFI::Struct
+      layout :H, GF128,
+             :X, GF128,
+             :aadlen, :size_t,
+             :clen, :size_t,
+             :block, [:uint8, 16],
+             :num, :size_t
+    end
+
+    attach_function :ghash, [:pointer, :pointer, :size_t, :pointer, :size_t, :pointer], :void
+    attach_function :ghash_init, [GHASH_CTX.by_ref, :pointer, :pointer, :size_t], :void
+    attach_function :ghash_update, [GHASH_CTX.by_ref, :pointer, :size_t], :void
+    attach_function :ghash_finish, [GHASH_CTX.by_ref, :pointer], :void
+  end
+end

data/lib/gmssl/random.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module GmSSL
+  module Random
+    extend FFI::Library
+    file = File.join GmSSL.lib, LIB_FILE
+    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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'helper'
+
+module GmSSL
+  module SM3
+    extend FFI::Library
+    file = File.join GmSSL.lib, LIB_FILE
+    ffi_lib file
+
+    SM3_DIGEST_SIZE = 32
+    SM3_BLOCK_SIZE = 64
+    SM3_STATE_WORDS = 8
+    SM3_HMAC_SIZE = SM3_DIGEST_SIZE
+    SM3_PBKDF2_MIN_ITER = 10000
+    SM3_PBKDF2_MAX_ITER = 16777215
+    SM3_PBKDF2_MAX_SALT_SIZE = 64
+    SM3_PBKDF2_DEFAULT_SALT_SIZE = 8
+
+    class SM3_CTX < FFI::Struct
+    layout :digest, [:uint32, SM3_STATE_WORDS],
+           :nblocks, :uint64,
+           :block, [:uint8, SM3_BLOCK_SIZE],
+           :num, :size_t
+    end
+
+    class SM3_HMAC_CTX < FFI::Struct
+      layout :sm3_ctx, SM3_CTX,
+             :key, [:uint8, SM3_BLOCK_SIZE]
+    end
+
+    class SM3_KDF_CTX < FFI::Struct
+      layout :sm3_ctx, SM3_CTX,
+             :outlen, :size_t
+    end
+
+    class SM3_DIGEST_CTX < FFI::Union
+      layout :sm3_ctx, SM3_CTX,
+             :hmac_ctx, SM3_HMAC_CTX
+    end
+
+    attach_function :sm3_compress_blocks, [:pointer, :pointer, :size_t], :void
+    attach_function :sm3_init, [SM3_CTX.by_ref], :void
+    attach_function :sm3_update, [SM3_CTX.by_ref, :pointer, :size_t], :void
+    attach_function :sm3_finish, [SM3_CTX.by_ref, :pointer], :void
+
+    attach_function :sm3_hmac_init, [SM3_HMAC_CTX.by_ref, :pointer, :size_t], :void
+    attach_function :sm3_hmac_update, [SM3_HMAC_CTX.by_ref, :pointer, :size_t], :void
+    attach_function :sm3_hmac_finish, [SM3_HMAC_CTX.by_ref, :pointer], :void
+
+    attach_function :sm3_kdf_init, [SM3_KDF_CTX.by_ref, :size_t], :void
+    attach_function :sm3_kdf_update, [SM3_KDF_CTX.by_ref, :pointer, :size_t], :void
+    attach_function :sm3_kdf_finish, [SM3_KDF_CTX.by_ref, :pointer], :void
+    attach_function :sm3_pbkdf2, [:string, :size_t, :pointer, :size_t, :size_t, :size_t, :pointer], :int
+
+    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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+require 'gmssl/ghash'
+
+module GmSSL
+  module SM4
+    extend FFI::Library
+    file = File.join GmSSL.lib, LIB_FILE
+    ffi_lib file
+
+    SM4_KEY_SIZE = 16
+    SM4_BLOCK_SIZE = 16
+    SM4_NUM_ROUNDS = 32
+    SM4_GCM_MAX_TAG_SIZE = 16
+
+    class SM4_KEY < FFI::Struct
+      layout :rk, [:uint32, SM4_NUM_ROUNDS]
+    end
+
+    class SM4_CBC_CTX < FFI::Struct
+      layout :sm4_key, SM4_KEY,
+             :iv, [:uint8, SM4_BLOCK_SIZE],
+             :block, [:uint8, SM4_BLOCK_SIZE],
+             :block_nbytes, :size_t
+    end
+
+    class SM4_CTR_CTX < FFI::Struct
+      layout :sm4_key, SM4_KEY,
+             :ctr, [:uint8, SM4_BLOCK_SIZE],
+             :block, [:uint8, SM4_BLOCK_SIZE],
+             :block_nbytes, :size_t
+    end
+
+    class SM4_GCM_CTX < FFI::Struct
+      layout :enc_ctx, SM4_CTR_CTX,
+             :mac_ctx, GmSSL::Ghash::GHASH_CTX, # GHASH_CTX defined in ghash.rb
+             :Y, [:uint8, 16],
+             :taglen, :size_t,
+             :mac, [:uint8, 16],
+             :maclen, :size_t,
+             :encedlen, :uint64
+    end
+
+    attach_function :sm4_set_encrypt_key, [SM4_KEY.by_ref, :pointer], :void
+    attach_function :sm4_set_decrypt_key, [SM4_KEY.by_ref, :pointer], :void
+    attach_function :sm4_encrypt, [SM4_KEY.by_ref, :pointer, :pointer], :void
+
+    attach_function :sm4_encrypt_blocks, [SM4_KEY.by_ref, :pointer, :size_t, :pointer], :void
+    attach_function :sm4_cbc_encrypt_blocks, [SM4_KEY.by_ref, :pointer, :pointer, :size_t, :pointer], :void
+    attach_function :sm4_cbc_decrypt_blocks, [SM4_KEY.by_ref, :pointer, :pointer, :size_t, :pointer], :void
+    attach_function :sm4_ctr_encrypt_blocks, [SM4_KEY.by_ref, :pointer, :pointer, :size_t, :pointer], :void
+    attach_function :sm4_ctr32_encrypt_blocks, [SM4_KEY.by_ref, :pointer, :pointer, :size_t, :pointer], :void
+
+    attach_function :sm4_cbc_padding_encrypt, [SM4_KEY.by_ref, :pointer, :pointer, :size_t, :pointer, :pointer], :int
+    attach_function :sm4_cbc_padding_decrypt, [SM4_KEY.by_ref, :pointer, :pointer, :size_t, :pointer, :pointer], :int
+    attach_function :sm4_ctr_encrypt, [SM4_KEY.by_ref, :pointer, :pointer, :size_t, :pointer], :void
+    attach_function :sm4_ctr32_encrypt, [SM4_KEY.by_ref, :pointer, :pointer, :size_t, :pointer], :void
+
+    attach_function :sm4_cbc_encrypt_init, [SM4_CBC_CTX.by_ref, :pointer, :pointer], :int
+    attach_function :sm4_cbc_encrypt_update, [SM4_CBC_CTX.by_ref, :pointer, :size_t, :pointer, :pointer], :int
+    attach_function :sm4_cbc_encrypt_finish, [SM4_CBC_CTX.by_ref, :pointer, :pointer], :int
+    attach_function :sm4_cbc_decrypt_init, [SM4_CBC_CTX.by_ref, :pointer, :pointer], :int
+    attach_function :sm4_cbc_decrypt_update, [SM4_CBC_CTX.by_ref, :pointer, :size_t, :pointer, :pointer], :int
+    attach_function :sm4_cbc_decrypt_finish, [SM4_CBC_CTX.by_ref, :pointer, :pointer], :int
+
+    attach_function :sm4_ctr_encrypt_init, [SM4_CTR_CTX.by_ref, :pointer, :pointer], :int
+    attach_function :sm4_ctr_encrypt_update, [SM4_CTR_CTX.by_ref, :pointer, :size_t, :pointer, :pointer], :int
+    attach_function :sm4_ctr_encrypt_finish, [SM4_CTR_CTX.by_ref, :pointer, :pointer], :int
+    attach_function :sm4_ctr32_encrypt_init, [SM4_CTR_CTX.by_ref, :pointer, :pointer], :int
+    attach_function :sm4_ctr32_encrypt_update, [SM4_CTR_CTX.by_ref, :pointer, :size_t, :pointer, :pointer], :int
+    attach_function :sm4_ctr32_encrypt_finish, [SM4_CTR_CTX.by_ref, :pointer, :pointer], :int
+
+    attach_function :sm4_gcm_encrypt, [SM4_KEY.by_ref, :pointer, :size_t, :pointer, :size_t, :pointer, :size_t, :pointer, :size_t, :pointer], :int
+    attach_function :sm4_gcm_decrypt, [SM4_KEY.by_ref, :pointer, :size_t, :pointer, :size_t, :pointer, :size_t, :pointer, :size_t, :pointer], :int
+
+    attach_function :sm4_gcm_encrypt_init, [SM4_GCM_CTX.by_ref, :pointer, :size_t, :pointer, :size_t, :pointer, :size_t, :size_t], :int
+    attach_function :sm4_gcm_encrypt_update, [SM4_GCM_CTX.by_ref, :pointer, :size_t, :pointer, :pointer], :int
+    attach_function :sm4_gcm_encrypt_finish, [SM4_GCM_CTX.by_ref, :pointer, :pointer], :int
+    attach_function :sm4_gcm_decrypt_init, [SM4_GCM_CTX.by_ref, :pointer, :size_t, :pointer, :size_t, :pointer, :size_t, :size_t], :int
+    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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'helper'
+
+module GmSSL
+  module ZUC
+    extend FFI::Library
+    file = File.join GmSSL.lib, LIB_FILE
+    ffi_lib file
+
+    ZUC_KEY_SIZE = 16
+    ZUC_IV_SIZE = 16
+
+    class ZUC_STATE < FFI::Struct
+      layout :LFSR, [:uint32, 16],
+             :R1, :uint32,
+             :R2, :uint32
+    end
+
+    class ZUC_CTX < FFI::Struct
+      layout :zuc_state, ZUC_STATE,
+             :block, [:uint8, 4],
+             :block_nbytes, :size_t
+    end
+
+    attach_function :zuc_init, [ZUC_STATE.by_ref, :pointer, :pointer], :void
+    attach_function :zuc_encrypt, [ZUC_STATE.by_ref, :pointer, :size_t, :pointer], :void
+    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/lib/gmssl.rb

@@ -19,3 +19,5 @@ end
 require 'gmssl/version'
 require 'gmssl/random'
 require 'gmssl/sm3'
+require 'gmssl/sm4'
+require 'gmssl/zuc'

data/test/helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# 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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: gmssl
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.0
 platform: ruby
 authors:
 - memorycancel
 bindir: bin
 cert_chain: []
-date: 2025-01-07 00:00:00.000000000 Z
+date: 2025-01-22 00:00:00.000000000 Z
 dependencies: []
 description: GmSSL c to ruby FFI
 email: memorycancel@gmail.com
@@ -67,7 +67,13 @@ files:
 - GmSSL/build/bin/x509test
 - GmSSL/build/bin/zuctest
 - lib/gmssl.rb
+- lib/gmssl/ghash.rb
+- lib/gmssl/random.rb
+- lib/gmssl/sm3.rb
+- lib/gmssl/sm4.rb
 - lib/gmssl/version.rb
+- lib/gmssl/zuc.rb
+- test/helper.rb
 homepage: https://rubygems.org/gems/gmssl
 licenses:
 - MIT