sequence.c

/*
 * sequence.c
 */
#include <stdio.h>
#include <memory.h>

/*
 * SM3算法产生的哈希值大小（单位：字节）
 */
#define SM3_HASH_SIZE 32 

/*
 * SM3上下文
 */
typedef struct SM3Context
{
    unsigned int intermediateHash[SM3_HASH_SIZE / ];
    unsigned char messageBlock[];
} SM3Context;

/*
 * 判断运行环境是否为小端
 */
static const int endianTest = ;
#define IsLittleEndian() (*(char *)&endianTest == 1)

/*
 * 向左循环移位
 */
#define LeftRotate(word, bits) ( (word) << (bits) | (word) >> (32 - (bits)) )

/*
 * 反转四字节整型字节序
 */
unsigned int *ReverseWord(unsigned int *word)
{
    unsigned char *byte, temp;

    byte = (unsigned char *)word;
    temp = byte[];
    byte[] = byte[];
    byte[] = temp;

    temp = byte[];
    byte[] = byte[];
    byte[] = temp;
    return word;
}

/*
 * T
 */
unsigned int T(int i)
{
    if (i >=  && i <= )
        return 0x79CC4519;
    else if (i >=  && i <= )
        return 0x7A879D8A;
    else
        return ;
}

/*
 * FF
 */
unsigned int FF(unsigned int X, unsigned int Y, unsigned int Z, int i)
{
    if (i >=  && i <= )
        return X ^ Y ^ Z;
    else if (i >=  && i <= )
        return (X & Y) | (X & Z) | (Y & Z);
    else
        return ;
}

/*
 * GG
 */
unsigned int GG(unsigned int X, unsigned int Y, unsigned int Z, int i)
{
    if (i >=  && i <= )
        return X ^ Y ^ Z;
    else if (i >=  && i <= )
        return (X & Y) | (~X & Z);
    else
        return ;
}

/*
 * P0
 */
unsigned int P0(unsigned int X)
{
    return X ^ LeftRotate(X, ) ^ LeftRotate(X, );
}

/*
 * P1
 */
unsigned int P1(unsigned int X)
{
    return X ^ LeftRotate(X, ) ^ LeftRotate(X, );
}

/*
 * 初始化函数
 */
void SM3Init(SM3Context *context)
{
    context->intermediateHash[] = 0x7380166F;
    context->intermediateHash[] = 0x4914B2B9;
    context->intermediateHash[] = 0x172442D7;
    context->intermediateHash[] = 0xDA8A0600;
    context->intermediateHash[] = 0xA96F30BC;
    context->intermediateHash[] = 0x163138AA;
    context->intermediateHash[] = 0xE38DEE4D;
    context->intermediateHash[] = 0xB0FB0E4E;
}

/*
 * 处理消息块
 */
void SM3ProcessMessageBlock(SM3Context *context)
{
    int i;
    unsigned int W[];
    unsigned int W_[];
    unsigned int A, B, C, D, E, F, G, H, SS1, SS2, TT1, TT2;

    /* 消息扩展 */
    for (i = ; i < ; i++)
    {
        W[i] = *(unsigned int *)(context->messageBlock + i * );
        if (IsLittleEndian())
            ReverseWord(W + i);
        //printf("%d: %x\n", i, W[i]);
    }
    for (i = ; i < ; i++)
    {
        W[i] = P1(W[i - ] ^ W[i - ] ^ LeftRotate(W[i - ], ))
                ^ LeftRotate(W[i - ], )
                ^ W[i - ];
        //printf("%d: %x\n", i, W[i]);
    }
    for (i = ; i < ; i++)
    {
        W_[i] = W[i] ^ W[i + ];
        //printf("%d: %x\n", i, W_[i]);
    }

    /* 消息压缩 */
    A = context->intermediateHash[];
    B = context->intermediateHash[];
    C = context->intermediateHash[];
    D = context->intermediateHash[];
    E = context->intermediateHash[];
    F = context->intermediateHash[];
    G = context->intermediateHash[];
    H = context->intermediateHash[];
    for (i = ; i < ; i++)
    {
        SS1 = LeftRotate((LeftRotate(A, ) + E + LeftRotate(T(i), i)), );
        SS2 = SS1 ^ LeftRotate(A, );
        TT1 = FF(A, B, C, i) + D + SS2 + W_[i];
        TT2 = GG(E, F, G, i) + H + SS1 + W[i];
        D = C;
        C = LeftRotate(B, );
        B = A;
        A = TT1;
        H = G;
        G = LeftRotate(F, );
        F = E;
        E = P0(TT2);
    }
    context->intermediateHash[] ^= A;
    context->intermediateHash[] ^= B;
    context->intermediateHash[] ^= C;
    context->intermediateHash[] ^= D;
    context->intermediateHash[] ^= E;
    context->intermediateHash[] ^= F;
    context->intermediateHash[] ^= G;
    context->intermediateHash[] ^= H;
}

/*
 * SM3算法主函数
 */
unsigned char *SM3Calc(const unsigned char *message,
        unsigned int messageLen, unsigned char digest[SM3_HASH_SIZE])
{
    SM3Context context;
    unsigned int i, remainder, bitLen;

    SM3Init(&context);

    for (i = ; i < messageLen / ; i++)
    {
        memcpy(context.messageBlock, message + i * , );
        SM3ProcessMessageBlock(&context);
    }

    bitLen = messageLen * ;
    if (IsLittleEndian())
        ReverseWord(&bitLen);
    remainder = messageLen % ;
    memcpy(context.messageBlock, message + i * , remainder);
    context.messageBlock[remainder] = 0x80;
    if (remainder <= )
    {
        memset(context.messageBlock + remainder + , ,  - remainder -  -  + );
        memcpy(context.messageBlock +  - , &bitLen, );
        SM3ProcessMessageBlock(&context);
    }
    else
    {
        memset(context.messageBlock + remainder + , ,  - remainder - );
        SM3ProcessMessageBlock(&context);
        memset(context.messageBlock, ,  - );
        memcpy(context.messageBlock +  - , &bitLen, );
        SM3ProcessMessageBlock(&context);
    }

    if (IsLittleEndian())
        for (i = ; i < ; i++)
            ReverseWord(context.intermediateHash + i);
    memcpy(digest, context.intermediateHash, SM3_HASH_SIZE);

    return digest;
}

/*
 * 计算SM3，并将结果以无符号整数形式返回
 */
unsigned int SM3CalcAndReturnUInt(const unsigned char *message, unsigned int messageLen)
{
    int i;
    unsigned int s;
    unsigned char digest[SM3_HASH_SIZE];

    SM3Calc(message, messageLen, digest);
    for (i = , s = ; i < SM3_HASH_SIZE; i += )
    {
        s += digest[i + ] <<  |
             digest[i + ] <<  |
             digest[i + ] <<   |
             digest[i + ] << ;
    }

    return s;
}

int main(void)
{
    printf("%x\n", SM3CalcAndReturnUInt("\x1\x2\x3\x4\x5\x6", strlen("\x1\x2\x3\x4\x5\x6")));
    return ;
}