gmssl 1.0.8 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 436a0544ac1c53637b71170298bc0bf93d94c6fd21372b56587db3cc46599991
-  data.tar.gz: 366622549c376a7a6eab32ab4bc3fe25f3849a18a1e9e581c8dbc2c9429ca162
+  metadata.gz: 91be02f2afeab55a32d5baa453111c80def28f5d1abfbf6be95b137f216103dd
+  data.tar.gz: 8b6c27ee63aac9a32249f6050fe146211f14ba0cb50c021791e4b6886a011a79
 SHA512:
-  metadata.gz: 7d57c9230214a77d0cc7b2b7bee316363c5f810104342fa3c5cf30548bbb3b6a7b6650f150003c2cc37b126390c1d1d20369b08ceae9cd34f99beeed518200a8
-  data.tar.gz: 4c88b05a8647b705117d880f37881d9f6e8588100043b3992de74550125774dd52390ddb5dbc9a0676bcb37809c47bd9a5ba576f8360041b5b6a133bb8060e87
+  metadata.gz: 00c9c994e7a478215afa4705a4ac03d8b08e5e651d4cc8b1ddd1a7a9b6224fe62e2c3804ae4dca950c6b4ddc44a7b68d75fcce8f7098a99782ff9cf73ae22095
+  data.tar.gz: 42770e67af88dcde97433e3a70064bcef5dececf5700ff232752385f41cca461adc3b781ee7548aa0346aaf1d88a6edc84296fa19857b0c1223d3ce381aa8056

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,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'ffi'
+require 'helper'
 
 module GmSSL
   module SM3
@@ -56,5 +57,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

@@ -82,5 +82,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,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'ffi'
+require 'helper'
 
 module GmSSL
   module ZUC
@@ -28,5 +29,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.0
 platform: ruby
 authors:
 - memorycancel
 bindir: bin
 cert_chain: []
-date: 2025-01-20 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