my_sha1.cpp

my_sha1.cpp

#include <iostream>
#include <fstream>
#include <cstdio>

unsigned char Base64EncodeMap[128];

int search(unsigned char const* __restrict target, int target_length){
    unsigned long A, B, C, D, E;
    unsigned long H[5];
    unsigned long W[80];
    unsigned long TEMP;
    int i;
    unsigned long message_length, ll;
    unsigned char message[64] = { 0x00u }, r[21];
    r[20] = 0x00u;

    EntryPoint:;

    // TODO: ここで message を構築.
    // 実行開始時間と ProcessID ごとに Unique な列を生成しなければいけない.
    message[0] = 'a';
    message[1] = 'b';
    message[2] = 'c';
    message[3] = 0x80u;
    message_length = 4, ll = (message_length - 1) * 8;

    message[60] = (ll >> 24) & 0xFFu;
    message[61] = (ll >> 16) & 0xFFu;
    message[62] = (ll >> 8) & 0xFFu;
    message[63] = ll & 0xFFu;

    #define SetMessage_1(t) W[(t)] = message[(t) * 4] << 24u, W[(t)] |= message[(t) * 4 + 1] << 16u, W[(t)] |= message[(t) * 4 + 2] << 8u, W[(t)] |= message[(t) * 4 + 3]
    #define SetMessage_2(t) SetMessage_1((t) + 0), SetMessage_1((t) + 1)
    #define SetMessage_4(t) SetMessage_2((t) + 0), SetMessage_2((t) + 2)
    #define SetMessage_8(t) SetMessage_4((t) + 0), SetMessage_4((t) + 4)
    SetMessage_8(0), SetMessage_8(8);

    #define SHA1CircularShift(bits, word) (((word) << (bits)) | ((word) >> (32 - (bits))))
    #define ApplySHA1CircularShift_1(t) W[(t) + 16] = SHA1CircularShift(1, W[(t) - 3 + 16] ^ W[(t) - 8 + 16] ^ W[(t) - 14 + 16] ^ W[(t) - 16 + 16])
    #define ApplySHA1CircularShift_2(t) ApplySHA1CircularShift_1((t) + 0), ApplySHA1CircularShift_1((t) + 1)
    #define ApplySHA1CircularShift_4(t) ApplySHA1CircularShift_2((t) + 0), ApplySHA1CircularShift_2((t) + 2)
    #define ApplySHA1CircularShift_8(t) ApplySHA1CircularShift_4((t) + 0), ApplySHA1CircularShift_4((t) + 4)
    #define ApplySHA1CircularShift_16(t) ApplySHA1CircularShift_8((t) + 0), ApplySHA1CircularShift_8((t) + 8)
    #define ApplySHA1CircularShift_32(t) ApplySHA1CircularShift_16((t) + 0), ApplySHA1CircularShift_16((t) + 16)
    ApplySHA1CircularShift_32(0), ApplySHA1CircularShift_32(32);
    
    H[0] = 0x67452301u, H[1] = 0xEFCDAB89u, H[2] = 0x98BADCFEu, H[3] = 0x10325476u, H[4] = 0xC3D2E1F0u;
    A = H[0], B = H[1], C = H[2], D = H[3], E = H[4];

    #define K0 0x5A827999u
    #define K1 0x6ED9EBA1u
    #define K2 0x8F1BBCDCu
    #define K3 0xCA62C1D6u
    #define f_00_19(B, C, D) ((B & C) | ((~B) & D))
    #define f_20_39(B, C, D) (B ^ C ^ D)
    #define f_40_59(B, C, D) ((B & C) | (B & D) | (C & D))
    #define f_60_79(B, C, D) (f_20_39(B, C, D))

    #define Apply_2(M, t, offset) M((t) + 0 + offset), M((t) + 1 + offset)
    #define Apply_4(M, t, offset) Apply_2(M, (t) + 0, offset), Apply_2(M, (t) + 2, offset)
    #define Apply_20(M, offset) Apply_4(M, 0, offset), Apply_4(M, 4, offset), Apply_4(M, 8, offset), Apply_4(M, 12, offset), Apply_4(M, 16, offset)

    #define F_00_19(t) TEMP = SHA1CircularShift(5, A) + f_00_19(B, C, D) + E + W[(t)] + K0, E = D, D = C, C = SHA1CircularShift(30, B), B = A, A = TEMP
    Apply_20(F_00_19, 0);

    #define F_20_39(t) TEMP = SHA1CircularShift(5, A) + f_20_39(B, C, D) + E + W[(t)] + K1, E = D, D = C, C = SHA1CircularShift(30, B), B = A, A = TEMP
    Apply_20(F_20_39, 20);

    #define F_40_59(t) TEMP = SHA1CircularShift(5, A) + f_40_59(B, C, D) + E + W[(t)] + K2, E = D, D = C, C = SHA1CircularShift(30, B), B = A, A = TEMP
    Apply_20(F_40_59, 40);

    #define F_60_79(t) TEMP = SHA1CircularShift(5, A) + f_60_79(B, C, D) + E + W[(t)] + K3, E = D, D = C, C = SHA1CircularShift(30, B), B = A, A = TEMP
    Apply_20(F_60_79, 60);

    H[0] += A, H[1] += B, H[2] += C, H[3] += D, H[4] += E;

    #define Result_1(t) r[(t)] = (H[(t) >> 0x02u] >> 0x08u * (0x03u - ((t) & 0x03u))) & 0xFFu
    #define Result_2(t) Result_1((t) + 0), Result_1((t) + 1)
    #define Result_4(t) Result_2((t) + 0), Result_2((t) + 2)
    Result_4(0), Result_4(4), Result_4(8), Result_4(12), Result_4(16);

    {
        std::cout << std::hex;
        for(i = 0; i < 20; ++i){
            std::cout << static_cast<unsigned>(r[i]) << " ";
        }
    }

    return 0;
}

void InitBase64EncodeMap(){
    Base64EncodeMap[43] = 62u;
    Base64EncodeMap[47] = 63u;
    Base64EncodeMap[48] = 52u;
    Base64EncodeMap[49] = 53u;
    Base64EncodeMap[50] = 54u;
    Base64EncodeMap[51] = 55u;
    Base64EncodeMap[52] = 56u;
    Base64EncodeMap[53] = 57u;
    Base64EncodeMap[54] = 58u;
    Base64EncodeMap[55] = 59u;
    Base64EncodeMap[56] = 60u;
    Base64EncodeMap[57] = 61u;
    Base64EncodeMap[66] = 1u;
    Base64EncodeMap[67] = 2u;
    Base64EncodeMap[68] = 3u;
    Base64EncodeMap[69] = 4u;
    Base64EncodeMap[70] = 5u;
    Base64EncodeMap[71] = 6u;
    Base64EncodeMap[72] = 7u;
    Base64EncodeMap[73] = 8u;
    Base64EncodeMap[74] = 9u;
    Base64EncodeMap[75] = 10u;
    Base64EncodeMap[76] = 11u;
    Base64EncodeMap[77] = 12u;
    Base64EncodeMap[78] = 13u;
    Base64EncodeMap[79] = 14u;
    Base64EncodeMap[80] = 15u;
    Base64EncodeMap[81] = 16u;
    Base64EncodeMap[82] = 17u;
    Base64EncodeMap[83] = 18u;
    Base64EncodeMap[84] = 19u;
    Base64EncodeMap[85] = 20u;
    Base64EncodeMap[86] = 21u;
    Base64EncodeMap[87] = 22u;
    Base64EncodeMap[88] = 23u;
    Base64EncodeMap[89] = 24u;
    Base64EncodeMap[90] = 25u;
    Base64EncodeMap[97] = 26u;
    Base64EncodeMap[98] = 27u;
    Base64EncodeMap[99] = 28u;
    Base64EncodeMap[100] = 29u;
    Base64EncodeMap[101] = 30u;
    Base64EncodeMap[102] = 31u;
    Base64EncodeMap[103] = 32u;
    Base64EncodeMap[104] = 33u;
    Base64EncodeMap[105] = 34u;
    Base64EncodeMap[106] = 35u;
    Base64EncodeMap[107] = 36u;
    Base64EncodeMap[108] = 37u;
    Base64EncodeMap[109] = 38u;
    Base64EncodeMap[110] = 39u;
    Base64EncodeMap[111] = 40u;
    Base64EncodeMap[112] = 41u;
    Base64EncodeMap[113] = 42u;
    Base64EncodeMap[114] = 43u;
    Base64EncodeMap[115] = 44u;
    Base64EncodeMap[116] = 45u;
    Base64EncodeMap[117] = 46u;
    Base64EncodeMap[118] = 47u;
    Base64EncodeMap[119] = 48u;
    Base64EncodeMap[120] = 49u;
    Base64EncodeMap[121] = 50u;
    Base64EncodeMap[122] = 51u;
}

int main(){
    InitBase64EncodeMap();

    //search(nullptr, 0);
    return 0;
}