SM2 签名前要进行的预处理操作

    转载：https://www.xuebuyuan.com/1473900.html

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

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

    计算 SM2 签名和验签的过程有点特殊，因为根据国内的行业标准，SM2 签名算法要和 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 。但是一般能找到的 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 
#include 
#include 
#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，这两个文件的下载网址前面已经给出。