iOS-嵌入SM3算法

OC方法

-(void)sm3Method:(NSString *)password

{

    NSData *testData = [password dataUsingEncoding: NSUTF8StringEncoding];

    Byte *input = (Byte *)[testData bytes];

    

    const char *byteLength = [password UTF8String];

    size_t length = strlen(byteLength);

    Word* hash = SM3::hash(input, length);

    NSMutableString *result = [NSMutableString string];

    for (int i = 0; i < 8; i++) {

        printf("%x ", hash[i]);

        [result appendFormat:@"%x",hash[i]];

    }

    NSLog(@"result = %@",result);

}

C++文件 .h

#ifndef SM3_SM3_H

#define SM3_SM3_H

#include <vector>

typedef uint32_t Word;

typedef uint8_t Byte;

class SM3 {

private:

    static void CF(Word* V, Byte* B);

    static Word P0(Word X);

    static Word P1(Word X);

    static Word FF(int j, Word X, Word Y, Word Z);

    static Word GG(int j, Word X, Word Y, Word Z);

    static Word T(int j);

public:

    static Word* hash(Byte* input, uint64_t inputLen);

};

#endif //SM3_SM3_H

C++文件 .cpp

#include "SM3.h"

#define ROTATELEFT(X, n)  (((X)<<(n)) | ((X)>>(32-(n))))

Word *SM3::hash(Byte *input, uint64_t inputLen) {

    Word VI[] = {0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e};

    Word* state = new Word[8];

    memcpy(state, VI, 8*sizeof(VI));

    Byte buf[64];

    int inputPtr = 0;

    int bufPtr = 0;

    while (inputPtr < inputLen) {

        buf[bufPtr] = input[inputPtr];

        inputPtr++;

        bufPtr++;

        if (bufPtr == 64) {

            CF(state, buf);

            bufPtr = 0;

        }

    }

    buf[bufPtr++] = 0x80;

    if (64 - bufPtr < 8) {

        while (bufPtr < 64) buf[bufPtr++] = 0;

        bufPtr = 0;

        CF(state, buf);

    }

    while (bufPtr < 56) buf[bufPtr++] = 0;

    inputLen *= 8;

    buf[63] = static_cast<Byte>(inputLen & 0x00000000000000ff);

    buf[62] = static_cast<Byte>((inputLen & 0x000000000000ff00) >> 8);

    buf[61] = static_cast<Byte>((inputLen & 0x0000000000ff0000) >> 16);

    buf[60] = static_cast<Byte>((inputLen & 0x00000000ff000000) >> 24);

    buf[59] = static_cast<Byte>((inputLen & 0x000000ff00000000) >> 32);

    buf[58] = static_cast<Byte>((inputLen & 0x0000ff0000000000) >> 40);

    buf[57] = static_cast<Byte>((inputLen & 0x00ff000000000000) >> 48);

    buf[56] = static_cast<Byte>((inputLen & 0xff00000000000000) >> 56);

    CF(state, buf);

    return state;

}

void SM3::CF(Word *V, Byte *Bi) {

    auto W = std::vector<Word>(68, 0); // W

    auto WW = std::vector<Word>(64, 0); // W'

    for (int i = 0; i < 16; ++i) {

        W[i] = 0;

        W[i] |= ((Word) Bi[i * 4] << 24);

        W[i] |= ((Word) Bi[i * 4 + 1] << 16);

        W[i] |= ((Word) Bi[i * 4 + 2] << 8);

        W[i] |= ((Word) Bi[i * 4 + 3]);

    }

    for (int i = 16; i <= 67; ++i) {

        W[i] = P1(W[i - 16] ^ W[i - 9] ^ ROTATELEFT(W[i - 3], 15)) ^ ROTATELEFT(W[i - 13], 7) ^ (W[i - 6]);

    }

    for (int i = 0; i <= 63; ++i) {

        WW[i] = W[i] ^ W[i + 4];

    }

    constexpr int A = 0, B = 1, C = 2, D = 3, E = 4, F = 5, G = 6, H = 7;

    Word reg[8];

    for (int j = 0; j < 8; ++j) {

        reg[j] = V[j];

    }

    for (int j = 0; j <= 63; ++j) {

        Word SS1, SS2, TT1, TT2;

        SS1 = ROTATELEFT(ROTATELEFT(reg[A], 12) + reg[E] + ROTATELEFT(T(j), j), 7);

        SS2 = SS1 ^ ROTATELEFT(reg[A], 12);

        TT1 = FF(j, reg[A], reg[B], reg[C]) + reg[D] + SS2 + WW[j];

        TT2 = GG(j, reg[E], reg[F], reg[G]) + reg[H] + SS1 + W[j];

        reg[D] = reg[C];

        reg[C] = ROTATELEFT(reg[B], 9);

        reg[B] = reg[A];

        reg[A] = TT1;

        reg[H] = reg[G];

        reg[G] = ROTATELEFT(reg[F], 19);

        reg[F] = reg[E];

        reg[E] = P0(TT2);

    }

    for (int i = 0; i < 8; ++i) {

        V[i] ^= reg[i];

    }

}

Word SM3::P0(Word X) {

    return X ^ ROTATELEFT(X, 9) ^ ROTATELEFT(X, 17);

}

Word SM3::P1(Word X) {

    return X ^ ROTATELEFT(X, 15) ^ ROTATELEFT(X, 23);

}

Word SM3::T(int j) {

    if (j <= 15) {

        return 0x79cc4519;

    } else {

        return 0x7a879d8a;

    }

}

Word SM3::FF(int j, Word X, Word Y, Word Z) {

    if (j <= 15) {

        return X ^ Y ^ Z;

    } else {

        return (X & Y) | (X & Z) | (Y & Z);

    }

}

Word SM3::GG(int j, Word X, Word Y, Word Z) {

    if (j <= 15) {

        return X ^ Y ^ Z;

    } else {

        return (X & Y) | ((~X) & Z);

    }

}