Windows下VC编译器和Linux下做的SM3摘要值不一样

最近向Linux移植自己的Windows服务，HTTPS中的服务端秘钥是我经过SM4加密的，此加密是在VC2012做的，但是同样的代码移植到Linux 64位下死活解密不了了，解出来就是一堆乱码。开始排查错误，第一种情况先看解密时的数据是不是完整的，用16进制字符串打出来发现没有问题。那就是解密的秘钥不对，我的解密秘钥是一段数据经过运算形成的加解密秘钥。

void makeSecretKey(unsigned char *str,int strLen,unsigned char *secretKey,int *secretKeyLen)
{
	//1.str做摘要
	unsigned char strDegist[32]={0};
	int strDegistLen=32;
	unsigned char strDegistBefore[16]={0}; //SM3摘要前16字节
	unsigned char strDegistAfter[16]={0};  //SM3摘要后16字节
	unsigned char dzstrDegist[32]={0};		//SM3对折后
	unsigned char dzstrDegist_f[32]={0};	//SM3对折取反
	unsigned char dzstrDegist_md5[16]={0};	//对折取反再MD5
	unsigned char dzstrDegist_md5_f[16]={0};	//MD5取反
	unsigned char dzstrDegist_md5_f_after[8]={0};	//MD5摘要取反 后8字节
	unsigned char dzstrDegist_md5_f_before[8]={0};	//MD5摘要取反 前8字节
	unsigned char dzstrDegist_md5_f_dz[16]={0};		//MD5摘要取反 对折摘要
	unsigned char mk[32]={0};
	SoftWare_SM3_Compress(str,strLen,strDegist);
	//2.SM3摘要值对折摘要值
	memcpy(strDegistBefore,strDegist,16);
	strsub((char*)strDegist,32,16,16,(char*)strDegistAfter);
	memcpy(dzstrDegist,strDegistAfter,16);
	memcpy(dzstrDegist+16,strDegistBefore,16);
	//3.SM3摘要值对之后取反
	for (int i=0;i<32;i++)
	{
		dzstrDegist_f[i]=~dzstrDegist[i]; //取反
	}
	//4.MD5摘要
	SoftWare_MD5_Compress(dzstrDegist,32,dzstrDegist_md5);
	//5.MD5摘要值取反
	for (int i=0;i<16;i++)
	{
		dzstrDegist_md5_f[i]=~dzstrDegist_md5[i];
	}
	//6.MD5摘要值取反后对折
	memcpy(dzstrDegist_md5_f_before,dzstrDegist_md5_f,8);
	strsub((char*)dzstrDegist_md5_f,16,8,8,(char*)dzstrDegist_md5_f_after);
	memcpy(dzstrDegist_md5_f_dz,dzstrDegist_md5_f_after,8);
	memcpy(dzstrDegist_md5_f_dz+8,dzstrDegist_md5_f_before,8);
	//7.MD5摘要值取反后对折做SM3摘要
	SoftWare_SM3_Compress(dzstrDegist_md5_f_dz,16,mk);
	//生成密钥
	memcpy(secretKey,mk,32);
	*secretKeyLen=32;
}

发现第一步的摘要值（SM3）就和Linux下的不一致了，怀疑字节序大小端问题或者是基本数据类型大小不一样，后来看了看SM3摘要的源码，没有发小大小端问题，那么就是基本数据类型大小不一致，一开始以为是系统位数问题，因为VC2012默认是Win32的，我又做了一个X64的也不能解开，后来查了一下Linux下基本数据类型大小。

类型	win32	win64	linux32	linux64
char	1	1	1	1
short	2	2	2	2
int	4	4	4	4
long	4	4	4	8
long long	8	8	8	8
float	4	4	4	4
double	8	8	8	8
void*	4	8	4	8

一声卧槽，，，，，，long类型不一样啊，怪不得。后来就把SM3中的 long 都换为了int，基本都是unsigned long替换为unsigned int 就这样大工告成啦~！！！！最后移植完毕，高兴。！！！！！

后来发现了一个前辈写的文章，说的就是国密SM3在Linux和Windows下不一致的问题，并且有修改好的SM3 C代码，其实就是我上述说的把 unsigned long替换为unsigned int 就可以了，附上链接及内容。
以下转自：链接：https://www.cnblogs.com/cocoajin/p/10457282.html
————————————————————————————————————————————————————————
什么是sm3，是一种类似于sha256的哈希算法，是咱们国家的哈希标准算法；
最近在使用sm3算法时，同样的一份数据，调用同样的sm3接口，发现得到的结果是不一样的；
那么在应用过的过程中，如果同样的算法出的结果不一样，那验证签名业务就会不过，出问题；

最后发现是sm3算法在内部使用了unsigned long,
这里要注意 long, 在 windows64平台下占用4个字节 ；
而long, 在linux64平台下占用8个字节；
这种差异直接导致了windows和linux结果的差异；

原sm3.cpp 中使用了 unsigned long ，如下

#ifndef GET_ULONG_BE
#define GET_ULONG_BE(n,b,i)                             \
{                                                       \
    (n) = ( (unsigned long) (b)[(i)    ] << 24 )        \
        | ( (unsigned long) (b)[(i) + 1] << 16 )        \
        | ( (unsigned long) (b)[(i) + 2] <<  8 )        \
        | ( (unsigned long) (b)[(i) + 3]       );       \
}
#endif
　　

//解决方式就是，修改sm3.cpp，将所有unsigned long 改成 unsigned int;
这样即支持linux和windows平台就保持一致了；

修改后的源码

sm3.h

/**
 * \file sm3.h
 * thanks to Xyssl
 * SM3 standards:http://www.oscca.gov.cn/News/201012/News_1199.htm
 * author:goldboar
 * email:goldboar@163.com
 * 2011-10-26
 */
#ifndef XYSSL_SM3_H
#define XYSSL_SM3_H
 
 
/**
 * \brief          SM3 context structure
 */
typedef struct
{
    unsigned long total[2];     /*!< number of bytes processed  */
    unsigned long state[8];     /*!< intermediate digest state  */
    unsigned char buffer[64];   /*!< data block being processed */
 
    unsigned char ipad[64];     /*!< HMAC: inner padding        */
    unsigned char opad[64];     /*!< HMAC: outer padding        */
 
}
sm3_context;
 
#ifdef __cplusplus
extern "C" {
#endif
 
/**
 * \brief          SM3 context setup
 *
 * \param ctx      context to be initialized
 */
void sm3_starts( sm3_context *ctx );
 
/**
 * \brief          SM3 process buffer
 *
 * \param ctx      SM3 context
 * \param input    buffer holding the  data
 * \param ilen     length of the input data
 */
void sm3_update( sm3_context *ctx, unsigned char *input, int ilen );
 
/**
 * \brief          SM3 final digest
 *
 * \param ctx      SM3 context
 */
void sm3_finish( sm3_context *ctx, unsigned char output[32] );
 
/**
 * \brief          Output = SM3( input buffer )
 *
 * \param input    buffer holding the  data
 * \param ilen     length of the input data
 * \param output   SM3 checksum result
 */
void sm3( unsigned char *input, int ilen,
           unsigned char output[32]);
 
/**
 * \brief          Output = SM3( file contents )
 *
 * \param path     input file name
 * \param output   SM3 checksum result
 *
 * \return         0 if successful, 1 if fopen failed,
 *                 or 2 if fread failed
 */
int sm3_file( char *path, unsigned char output[32] );
 
/**
 * \brief          SM3 HMAC context setup
 *
 * \param ctx      HMAC context to be initialized
 * \param key      HMAC secret key
 * \param keylen   length of the HMAC key
 */
void sm3_hmac_starts( sm3_context *ctx, unsigned char *key, int keylen);
 
/**
 * \brief          SM3 HMAC process buffer
 *
 * \param ctx      HMAC context
 * \param input    buffer holding the  data
 * \param ilen     length of the input data
 */
void sm3_hmac_update( sm3_context *ctx, unsigned char *input, int ilen );
 
/**
 * \brief          SM3 HMAC final digest
 *
 * \param ctx      HMAC context
 * \param output   SM3 HMAC checksum result
 */
void sm3_hmac_finish( sm3_context *ctx, unsigned char output[32] );
 
/**
 * \brief          Output = HMAC-SM3( hmac key, input buffer )
 *
 * \param key      HMAC secret key
 * \param keylen   length of the HMAC key
 * \param input    buffer holding the  data
 * \param ilen     length of the input data
 * \param output   HMAC-SM3 result
 */
void sm3_hmac( unsigned char *key, int keylen,
                unsigned char *input, int ilen,
                unsigned char output[32] );
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* sm3.h */

sm3.cpp

/*
 * SM3 Hash alogrith
 * thanks to Xyssl
 * author:goldboar
 * email:goldboar@163.com
 * 2011-10-26
 */
 
//Testing data from SM3 Standards
//http://www.oscca.gov.cn/News/201012/News_1199.htm
// Sample 1
// Input:"abc" 
// Output:66c7f0f4 62eeedd9 d1f2d46b dc10e4e2 4167c487 5cf2f7a2 297da02b 8f4ba8e0
 
// Sample 2
// Input:"abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"
// Outpuf:debe9ff9 2275b8a1 38604889 c18e5a4d 6fdb70e5 387e5765 293dcba3 9c0c5732
 
#include "sm3.h"
#include <string.h>
#include <stdio.h>
 
/*
 * 32-bit integer manipulation macros (big endian)
 */
#ifndef GET_ULONG_BE
#define GET_ULONG_BE(n,b,i)                             \
{                                                       \
    (n) = ( (unsigned int) (b)[(i)    ] << 24 )        \
        | ( (unsigned int) (b)[(i) + 1] << 16 )        \
        | ( (unsigned int) (b)[(i) + 2] <<  8 )        \
        | ( (unsigned int) (b)[(i) + 3]       );       \
}
#endif
 
#ifndef PUT_ULONG_BE
#define PUT_ULONG_BE(n,b,i)                             \
{                                                       \
    (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
    (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
    (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
    (b)[(i) + 3] = (unsigned char) ( (n)       );       \
}
#endif
 
/*
 * SM3 context setup
 */
void sm3_starts( sm3_context *ctx )
{
    ctx->total[0] = 0;
    ctx->total[1] = 0;
 
    ctx->state[0] = 0x7380166F;
    ctx->state[1] = 0x4914B2B9;
    ctx->state[2] = 0x172442D7;
    ctx->state[3] = 0xDA8A0600;
    ctx->state[4] = 0xA96F30BC;
    ctx->state[5] = 0x163138AA;
    ctx->state[6] = 0xE38DEE4D;
    ctx->state[7] = 0xB0FB0E4E;
 
}
 
static void sm3_process( sm3_context *ctx, unsigned char data[64] )
{
    unsigned int SS1, SS2, TT1, TT2, W[68],W1[64];
    unsigned int A, B, C, D, E, F, G, H;
    unsigned int T[64];
    unsigned int Temp1,Temp2,Temp3,Temp4,Temp5;
    int j;
#ifdef _DEBUG
    int i;
#endif
 
//  for(j=0; j < 68; j++)
//      W[j] = 0;
//  for(j=0; j < 64; j++)
//      W1[j] = 0;
     
    for(j = 0; j < 16; j++)
        T[j] = 0x79CC4519;
    for(j =16; j < 64; j++)
        T[j] = 0x7A879D8A;
 
    GET_ULONG_BE( W[ 0], data,  0 );
    GET_ULONG_BE( W[ 1], data,  4 );
    GET_ULONG_BE( W[ 2], data,  8 );
    GET_ULONG_BE( W[ 3], data, 12 );
    GET_ULONG_BE( W[ 4], data, 16 );
    GET_ULONG_BE( W[ 5], data, 20 );
    GET_ULONG_BE( W[ 6], data, 24 );
    GET_ULONG_BE( W[ 7], data, 28 );
    GET_ULONG_BE( W[ 8], data, 32 );
    GET_ULONG_BE( W[ 9], data, 36 );
    GET_ULONG_BE( W[10], data, 40 );
    GET_ULONG_BE( W[11], data, 44 );
    GET_ULONG_BE( W[12], data, 48 );
    GET_ULONG_BE( W[13], data, 52 );
    GET_ULONG_BE( W[14], data, 56 );
    GET_ULONG_BE( W[15], data, 60 );
 
#ifdef _DEBUG
    printf("Message with padding:\n");
    for(i=0; i< 8; i++)
        printf("%08x ",W[i]);
    printf("\n");
    for(i=8; i< 16; i++)
        printf("%08x ",W[i]);
    printf("\n");
#endif
 
#define FF0(x,y,z) ( (x) ^ (y) ^ (z))
#define FF1(x,y,z) (((x) & (y)) | ( (x) & (z)) | ( (y) & (z)))
 
#define GG0(x,y,z) ( (x) ^ (y) ^ (z))
#define GG1(x,y,z) (((x) & (y)) | ( (~(x)) & (z)) )
 
 
#define  SHL(x,n) (((x) & 0xFFFFFFFF) << n)
#define ROTL(x,n) (SHL((x),n) | ((x) >> (32 - n)))
 
 
#define P0(x) ((x) ^  ROTL((x),9) ^ ROTL((x),17))
#define P1(x) ((x) ^  ROTL((x),15) ^ ROTL((x),23))
 
    for(j = 16; j < 68; j++ )
    {
        //W[j] = P1( W[j-16] ^ W[j-9] ^ ROTL(W[j-3],15)) ^ ROTL(W[j - 13],7 ) ^ W[j-6];
        //Why thd release's result is different with the debug's ?
        //Below is okay. Interesting, Perhaps VC6 has a bug of Optimizaiton.
         
        Temp1 = W[j-16] ^ W[j-9];
        Temp2 = ROTL(W[j-3],15);
        Temp3 = Temp1 ^ Temp2;
        Temp4 = P1(Temp3);
        Temp5 =  ROTL(W[j - 13],7 ) ^ W[j-6];
        W[j] = Temp4 ^ Temp5;
    }
 
#ifdef _DEBUG
    printf("Expanding message W0-67:\n");
    for(i=0; i<68; i++)
    {
        printf("%08x ",W[i]);
        if(((i+1) % 8) == 0) printf("\n");
    }
    printf("\n");
#endif
 
    for(j =  0; j < 64; j++)
    {
        W1[j] = W[j] ^ W[j+4];
    }
 
#ifdef _DEBUG
    printf("Expanding message W'0-63:\n");
    for(i=0; i<64; i++)
    {
        printf("%08x ",W1[i]);
        if(((i+1) % 8) == 0) printf("\n");
    }
    printf("\n");
#endif
 
    A = ctx->state[0];
    B = ctx->state[1];
    C = ctx->state[2];
    D = ctx->state[3];
    E = ctx->state[4];
    F = ctx->state[5];
    G = ctx->state[6];
    H = ctx->state[7];
#ifdef _DEBUG      
    printf("j     A       B        C         D         E        F        G       H\n");
    printf("   %08x %08x %08x %08x %08x %08x %08x %08x\n",A,B,C,D,E,F,G,H);
#endif
 
    for(j =0; j < 16; j++)
    {
        SS1 = ROTL((ROTL(A,12) + E + ROTL(T[j],j)), 7);
        SS2 = SS1 ^ ROTL(A,12);
        TT1 = FF0(A,B,C) + D + SS2 + W1[j];
        TT2 = GG0(E,F,G) + H + SS1 + W[j];
        D = C;
        C = ROTL(B,9);
        B = A;
        A = TT1;
        H = G;
        G = ROTL(F,19);
        F = E;
        E = P0(TT2);
#ifdef _DEBUG
        printf("%02d %08x %08x %08x %08x %08x %08x %08x %08x\n",j,A,B,C,D,E,F,G,H);
#endif
    }
     
    for(j =16; j < 64; j++)
    {
        SS1 = ROTL((ROTL(A,12) + E + ROTL(T[j],j)), 7);
        SS2 = SS1 ^ ROTL(A,12);
        TT1 = FF1(A,B,C) + D + SS2 + W1[j];
        TT2 = GG1(E,F,G) + H + SS1 + W[j];
        D = C;
        C = ROTL(B,9);
        B = A;
        A = TT1;
        H = G;
        G = ROTL(F,19);
        F = E;
        E = P0(TT2);
#ifdef _DEBUG
        printf("%02d %08x %08x %08x %08x %08x %08x %08x %08x\n",j,A,B,C,D,E,F,G,H);
#endif 
    }
 
    ctx->state[0] ^= A;
    ctx->state[1] ^= B;
    ctx->state[2] ^= C;
    ctx->state[3] ^= D;
    ctx->state[4] ^= E;
    ctx->state[5] ^= F;
    ctx->state[6] ^= G;
    ctx->state[7] ^= H;
#ifdef _DEBUG
       printf("   %08x %08x %08x %08x %08x %08x %08x %08x\n",ctx->state[0],ctx->state[1],ctx->state[2],
                                  ctx->state[3],ctx->state[4],ctx->state[5],ctx->state[6],ctx->state[7]);
#endif
}
 
/*
 * SM3 process buffer
 */
void sm3_update( sm3_context *ctx, unsigned char *input, int ilen )
{
    int fill;
    unsigned int left;
 
    if( ilen <= 0 )
        return;
 
    left = ctx->total[0] & 0x3F;
    fill = 64 - left;
 
    ctx->total[0] += ilen;
    ctx->total[0] &= 0xFFFFFFFF;
 
    if( ctx->total[0] < (unsigned int) ilen )
        ctx->total[1]++;
 
    if( left && ilen >= fill )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, fill );
        sm3_process( ctx, ctx->buffer );
        input += fill;
        ilen  -= fill;
        left = 0;
    }
 
    while( ilen >= 64 )
    {
        sm3_process( ctx, input );
        input += 64;
        ilen  -= 64;
    }
 
    if( ilen > 0 )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, ilen );
    }
}
 
static const unsigned char sm3_padding[64] =
{
 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
 
/*
 * SM3 final digest
 */
void sm3_finish( sm3_context *ctx, unsigned char output[32] )
{
    unsigned int last, padn;
    unsigned int high, low;
    unsigned char msglen[8];
 
    high = ( ctx->total[0] >> 29 )
         | ( ctx->total[1] <<  3 );
    low  = ( ctx->total[0] <<  3 );
 
    PUT_ULONG_BE( high, msglen, 0 );
    PUT_ULONG_BE( low,  msglen, 4 );
 
    last = ctx->total[0] & 0x3F;
    padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
 
    sm3_update( ctx, (unsigned char *) sm3_padding, padn );
    sm3_update( ctx, msglen, 8 );
 
    PUT_ULONG_BE( ctx->state[0], output,  0 );
    PUT_ULONG_BE( ctx->state[1], output,  4 );
    PUT_ULONG_BE( ctx->state[2], output,  8 );
    PUT_ULONG_BE( ctx->state[3], output, 12 );
    PUT_ULONG_BE( ctx->state[4], output, 16 );
    PUT_ULONG_BE( ctx->state[5], output, 20 );
    PUT_ULONG_BE( ctx->state[6], output, 24 );
    PUT_ULONG_BE( ctx->state[7], output, 28 );
}
 
/*
 * output = SM3( input buffer )
 */
void sm3( unsigned char *input, int ilen,
           unsigned char output[32] )
{
    sm3_context ctx;
 
    sm3_starts( &ctx );
    sm3_update( &ctx, input, ilen );
    sm3_finish( &ctx, output );
 
    memset( &ctx, 0, sizeof( sm3_context ) );
}
 
/*
 * output = SM3( file contents )
 */
int sm3_file( char *path, unsigned char output[32] )
{
    FILE *f;
    size_t n;
    sm3_context ctx;
    unsigned char buf[1024];
 
    if( ( f = fopen( path, "rb" ) ) == NULL )
        return( 1 );
 
    sm3_starts( &ctx );
 
    while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
        sm3_update( &ctx, buf, (int) n );
 
    sm3_finish( &ctx, output );
 
    memset( &ctx, 0, sizeof( sm3_context ) );
 
    if( ferror( f ) != 0 )
    {
        fclose( f );
        return( 2 );
    }
 
    fclose( f );
    return( 0 );
}
 
/*
 * SM3 HMAC context setup
 */
void sm3_hmac_starts( sm3_context *ctx, unsigned char *key, int keylen )
{
    int i;
    unsigned char sum[32];
 
    if( keylen > 64 )
    {
        sm3( key, keylen, sum );
        keylen = 32;
        //keylen = ( is224 ) ? 28 : 32;
        key = sum;
    }
 
    memset( ctx->ipad, 0x36, 64 );
    memset( ctx->opad, 0x5C, 64 );
 
    for( i = 0; i < keylen; i++ )
    {
        ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
        ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
    }
 
    sm3_starts( ctx);
    sm3_update( ctx, ctx->ipad, 64 );
 
    memset( sum, 0, sizeof( sum ) );
}
 
/*
 * SM3 HMAC process buffer
 */
void sm3_hmac_update( sm3_context *ctx, unsigned char *input, int ilen )
{
    sm3_update( ctx, input, ilen );
}
 
/*
 * SM3 HMAC final digest
 */
void sm3_hmac_finish( sm3_context *ctx, unsigned char output[32] )
{
    int hlen;
    unsigned char tmpbuf[32];
 
    //is224 = ctx->is224;
    hlen =  32;
 
    sm3_finish( ctx, tmpbuf );
    sm3_starts( ctx );
    sm3_update( ctx, ctx->opad, 64 );
    sm3_update( ctx, tmpbuf, hlen );
    sm3_finish( ctx, output );
 
    memset( tmpbuf, 0, sizeof( tmpbuf ) );
}
 
/*
 * output = HMAC-SM#( hmac key, input buffer )
 */
void sm3_hmac( unsigned char *key, int keylen,
                unsigned char *input, int ilen,
                unsigned char output[32] )
{
    sm3_context ctx;
 
    sm3_hmac_starts( &ctx, key, keylen);
    sm3_hmac_update( &ctx, input, ilen );
    sm3_hmac_finish( &ctx, output );
 
    memset( &ctx, 0, sizeof( sm3_context ) );
}

测试代码test.c

#include <stdio.h>
#include "sm3.h"
 
int main () {
 
                    //test sm3_hash
                    unsigned char tp[2] = {0x1,0x2};
                    unsigned char hspV[2014] = {0};
                    int hspL = 0;
                    sm3(tp, 2, hspV);
                    FILE *fp = NULL;
                    fp = fopen("./sm3hsv.dat","wb");
                    fwrite(hspV,1,32,fp);
                    fclose(fp);
            printf("sm3=%d\n",hspL);
    return 0;
}

最后通过md5比较生成的hash文件即可验证；