SM2 签名预处理操作

痛定思痛。 2023-02-17 11:13 121阅读 0赞

**如果觉得写得不错，烦请微信搜索公众号 "郑州行疆户外" 了解程序员的户外业余喜好。**

![2020102921582474.jpg][]

转载：[https://www.xuebuyuan.com/1473900.html][https_www.xuebuyuan.com_1473900.html]

**一般情况下，计算数字签名时应执行以下操作：**

1. 计算原始数据的 Hash 值；  
2. 将 Hash 值作为输入，计算签名函数的输出。并不是对原始数据直接签名，而是对 Hash 值签名。  
验证签名时应执行以下操作：  
1. 计算原始数据的 Hash 值；  
2. 将 Hash 值和签名值作为输入，计算验签函数的输出，根据输出判断签名为“有效”或“无效”。  
这只是一个简单描述，实际上 PKCS\#1 中规定的签名和验签过程要复杂得多。

计算 SM2 签名和验签的过程有点特殊，因为根据国内的行业标准，SM2 签名[算法][Link 1]要和 SM3 Hash 算法搭配使用，并且计算 SM2 签名的输入并不是待签名数据的 SM3 杂凑值，而是一个预处理阶段的输出。  
预处理分为两步：  
1. 定义一个级联生成的字节流 T1 = ENTL || ID || a || b || x\_G || y\_G || x\_A || y\_A，  
其中 || 表示字节流的拼接，  
ENTL 是用两个字节表示的签名者 ID 的比特长度（注意不是字节长度），  
ID 为签名者的标识，  
a, b, x\_G, y\_G 都是标准中给定的值， x\_A 和 y\_A 是签名者的公钥,  
对字节流 T1 计算 SM3 杂凑值，得到的输出为 Z = SM3(T1)。  
这一步并没有用到待签名数据。  
2. 将待签名数据用 M 表示，将 Z 与待签名数据级联，得到 T2 = Z || M，计算 T2 的杂凑值，即 SM3(T2)，SM3(T2)才是 SM2 签名函数的真正输入。  
注意预处理中用到的数都采用 big-endian 表示法！

从上面的预处理过程可以看出，当验证签名时，也要经过同样的预处理过程，将预处理阶段的输出、签名值作为验签函数的输入。

网上有很多 SM3 杂凑算法的开源实现，比如这个网址上提供的：[https://github.com/siddontang/pygmcrypto/tree/master/src][https_github.com_siddontang_pygmcrypto_tree_master_src] 。但是一般能找到的 SM3 实现都没有提供预处理功能，所以是不能直接用作计算 SM2 签名和验签的输入。在上面网址提供的  
SM3 实现基础上，本文将给出一个预处理的实现。首先从标准中可以查到预处理第 1 步中 a、b、x\_G 、 y\_G 的值。签名者的公钥通常是以结构体的形式给出的，对于加密机，公钥定义为  
typedef struct ECCrefPublicKey\_st  
\{  
unsigned int bits;  
unsigned char x\[64\];  
unsigned char y\[64\];  
\} ECCrefPublicKey;  
对于 Ukey，公钥定义为  
typedef struct Struct\_ECCPUBLICKEYBLOB  
\{  
ULONG BitLen;  
BYTE XCoordinate\[64\];  
BYTE YCoordinate\[64\];  
\} ECCPUBLICKEYBLOB;  
注意这两个结构体在本质上是一样的。ECCPUBLICKEYBLOB 中出现的 ULONG 并不是 unsigned long，在 Ukey 国内标准中将 ULONG 定义为无符号 32 位整数类型，因此可以把这个 ULONG 看作是 unsigned int。

由于是结构体，可能会遇到对齐的问题，常见的情况是：硬件厂商在实现接口时是按 1 字节对齐（ 即用 \#pragma pack (1) 设定），最好看看硬件厂商提供的用户手册核实一下，确保没有问题。本文中假定上面两个结构体都已被设为按 1 字节对齐。  
对于 SM2 算法，公钥的 X 分量和 Y 分量都是 32 字节长，因为以 big-endian 方式存放在对应数组中，对应数组大小为 64 字节，所以数组中前 32 字节的值为 0， 后 32 字节的值对应于分量。这一点在从数组中提取出分量值时要用到。

下面给出 SM2 签名前的预处理的计算 C 程序：

/************************************************** 
    * Author: HAN Wei 
    * Author's blog: http://blog.csdn.net/henter/ 
    * Date: Oct 30th, 2013 
    * Description: the following codes demonstrates how to 
                   perform SM3 Hash pre-process for SM2 signature 
    **************************************************/ 
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include "sm3.h"
    
    /**************************************************
    *函数名称：SM3HashWithPreprocess
    *功能: 计算 SM3 杂凑值（可能包含为满足 SM2 签名要求所做的预处理操作）
    *参数:
     input[in]                         输入数据
     input_byte_len[in]                输入数据的字节长度
     public_key[in]                    签名者的公钥
     public_key_byte_len[in]           签名者公钥的字节长度
     signer_ID[in]                     签名者的 ID 值
     signer_ID_byte_len[in]            签名者 ID 的字节长度
     hash_value[out]                   SM3 杂凑值
     hash_value_byte_len_pointer[out]  指向表示 SM3 杂凑值字节长度变量的指针
    *返回值:
        0    成功
        -1   失败
    *备注：
       如果以下四个条件：
       a) 输入参数 public_key 是空指针；
       b) 输入参数 public_key_byte_len 的值等于 0；
       c) 输入参数 signer_ID 是空指针；
       d) 输入参数 signer_ID_byte_len 的值等于 0。
       中有一个成立，就直接计算输入数据 input 的 SM3 杂凑值，
       忽略输入参数 public_key, public_key_byte_len, signer_ID
       和 signer_ID_byte_len，这时不会进行 SM2 算法签名预处理
       操作。
       如果四个条件全部不成立，才执行 SM2 算法签名预处理操作，
       预处理计算过程遵循 GM/T 0009《 SM2 密码使用规范》。
    **************************************************/
    int SM3HashWithPreprocess(unsigned char *input,
                              unsigned int input_byte_len,
                              unsigned char *public_key,
                              unsigned int public_key_byte_len,
                              unsigned char *signer_ID,
                              unsigned int signer_ID_byte_len,
                              unsigned char *hash_value,
                              unsigned int *hash_value_byte_len_pointer);
    
    /*********************************************************/
    int SM3HashWithPreprocess(unsigned char *input,
                              unsigned int input_byte_len,
                              unsigned char *public_key,
                              unsigned int public_key_byte_len,
                              unsigned char *signer_ID,
                              unsigned int signer_ID_byte_len,
                              unsigned char *hash_value,
                              unsigned int *hash_value_byte_len_pointer)
    {
      unsigned short ID_bit_len;
      unsigned char *step1_input;
      unsigned int step1_input_byte_len;
      unsigned char step1_output[32];
      unsigned char *step2_input;
      unsigned int step2_input_byte_len;
    
      unsigned char a[32]={0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF,
                           0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                           0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
                           0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC};
            
      unsigned char b[32]={0x28, 0xE9, 0xFA, 0x9E, 0x9D, 0x9F, 0x5E, 0x34,
                           0x4D, 0x5A, 0x9E, 0x4B, 0xCF, 0x65, 0x09, 0xA7,
                           0xF3, 0x97, 0x89, 0xF5, 0x15, 0xAB, 0x8F, 0x92,
                           0xDD, 0xBC, 0xBD, 0x41, 0x4D, 0x94, 0xE,  0x93};
    
      unsigned char x_G[32]={0x32, 0xC4, 0xAE, 0x2C, 0x1F, 0x19, 0x81, 0x19,
                             0x5F, 0x99, 0x4,  0x46, 0x6A, 0x39, 0xC9, 0x94,
                             0x8F, 0xE3, 0xB,  0xBF, 0xF2, 0x66, 0xB,  0xE1,
                             0x71, 0x5A, 0x45, 0x89, 0x33, 0x4C, 0x74, 0xC7};
    
      unsigned char y_G[32]={0xBC, 0x37, 0x36, 0xA2, 0xF4, 0xF6, 0x77, 0x9C,
                             0x59, 0xBD, 0xCE, 0xE3, 0x6B, 0x69, 0x21, 0x53,
                             0xD0, 0xA9, 0x87, 0x7C, 0xC6, 0x2A, 0x47, 0x40,
                             0x2,  0xDF, 0x32, 0xE5, 0x21, 0x39, 0xF0, 0xA0};
    
    // 下面定义的结构体 x 用于判断当前环境是 big-endian 还是 little-endian
      union { int i;
              char c[sizeof(int)];
            } x;
    
      if ( (!public_key) || (!public_key_byte_len) || (!signer_ID) || (!signer_ID_byte_len) )
      {
        sm3(input, input_byte_len, hash_value);
        *hash_value_byte_len_pointer = 32U;
        return 0;
      }
    
    // 下面为满足 SM2 签名的要求，做预处理操作
      step1_input_byte_len = (2 + signer_ID_byte_len + 32 * 6);
      if ( !(step1_input = (unsigned char *)malloc(step1_input_byte_len)) )
      {
    #ifdef _DEBUG
        printf("malloc function failed at %s, line %d!\n", __FILE__, __LINE__);
    #endif
        return (-1);
      }
     
    /* 预处理1 */
      ID_bit_len = (unsigned short)(signer_ID_byte_len*8);
    
    /* 判断当前环境是 big-endian 还是 little-endian。
       国密规范中要求把 ENTL(用 2 个字节表示的 ID 的比特长度)
       以 big-endian 方式作为预处理 1 输入的前两个字节  */
      x.i = 1;
      if(x.c[0] == 1)  /* little-endian */
      {
        memcpy(step1_input, (unsigned char *)(&ID_bit_len) + 1, 1);
        memcpy((step1_input + 1), (unsigned char *)(&ID_bit_len), 1); 
      }
      else  /* big-endian */
      {
        memcpy(step1_input, (unsigned char *)(&ID_bit_len), 1);
        memcpy((step1_input + 1), (unsigned char *)(&ID_bit_len) + 1, 1);
      }
    
      memcpy((step1_input + 2), signer_ID, signer_ID_byte_len);
      memcpy((step1_input + 2) + signer_ID_byte_len, a, 32);
      memcpy((step1_input + 2) + signer_ID_byte_len + 32, b, 32);
      memcpy((step1_input + 2 + signer_ID_byte_len + 64), x_G, 32);
      memcpy((step1_input + 2 + signer_ID_byte_len + 96), y_G, 32);
      memcpy((step1_input + 2 + signer_ID_byte_len + 128), (public_key + 4 + 32), 32);
      memcpy((step1_input + 2 + signer_ID_byte_len + 160), (public_key + 4 + 64 + 32), 32);
      sm3(step1_input, step1_input_byte_len, step1_output);
    
    /* 预处理2 */
      step2_input_byte_len = (32 + input_byte_len);
      if ( !(step2_input = (unsigned char *)malloc(step2_input_byte_len)) )
      {
    #ifdef _DEBUG
        printf("malloc function failed at %s, line %d!\n", __FILE__, __LINE__);
    #endif
        free(step1_input);
        return (-1);
      }
      memcpy(step2_input, step1_output, 32);
      memcpy((step2_input + 32), input, input_byte_len);
      sm3(step2_input, step2_input_byte_len, hash_value);
      *hash_value_byte_len_pointer = 32U;
      
      free(step1_input);
      free(step2_input);
      return 0;
    }

编译时要用到文件 sm3.h 和 sm3.c，这两个文件的下载网址前面已经给出。

**如果觉得写得不错，烦请微信搜索公众号 "郑州行疆户外" 了解程序员的户外业余喜好。**

![2020102921582474.jpg][]

[2020102921582474.jpg]: https://img-blog.csdnimg.cn/2020102921582474.jpg
[https_www.xuebuyuan.com_1473900.html]: https://www.xuebuyuan.com/1473900.html
[Link 1]: http://www.xuebuyuan.com/category/%E7%AE%97%E6%B3%95
[https_github.com_siddontang_pygmcrypto_tree_master_src]: https://github.com/siddontang/pygmcrypto/tree/master/src