static INT rmd128_compress(hash_state *md, UCHAR *buf)
#endif
{
ULONG aa,bb,cc,dd,aaa,bbb,ccc,ddd,X[16];
INT i;
/* load words X */
for (i = 0; i < 16; i++) {
LOAD32L(X[i], buf + (4 * i));
}
/* load state */
aa = aaa = md->rmd128.state[0];
bb = bbb = md->rmd128.state[1];
cc = ccc = md->rmd128.state[2];
dd = ddd = md->rmd128.state[3];
/* round 1 */
FF(aa, bb, cc, dd, X[ 0], 11);
FF(dd, aa, bb, cc, X[ 1], 14);
FF(cc, dd, aa, bb, X[ 2], 15);
FF(bb, cc, dd, aa, X[ 3], 12);
FF(aa, bb, cc, dd, X[ 4], 5);
FF(dd, aa, bb, cc, X[ 5], 8);
FF(cc, dd, aa, bb, X[ 6], 7);
FF(bb, cc, dd, aa, X[ 7], 9);
FF(aa, bb, cc, dd, X[ 8], 11);
FF(dd, aa, bb, cc, X[ 9], 13);
FF(cc, dd, aa, bb, X[10], 14);
FF(bb, cc, dd, aa, X[11], 15);
FF(aa, bb, cc, dd, X[12], 6);
FF(dd, aa, bb, cc, X[13], 7);
FF(cc, dd, aa, bb, X[14], 9);
FF(bb, cc, dd, aa, X[15], 8);
/* round 2 */
GG(aa, bb, cc, dd, X[ 7], 7);
GG(dd, aa, bb, cc, X[ 4], 6);
GG(cc, dd, aa, bb, X[13], 8);
GG(bb, cc, dd, aa, X[ 1], 13);
GG(aa, bb, cc, dd, X[10], 11);
GG(dd, aa, bb, cc, X[ 6], 9);
GG(cc, dd, aa, bb, X[15], 7);
GG(bb, cc, dd, aa, X[ 3], 15);
GG(aa, bb, cc, dd, X[12], 7);
GG(dd, aa, bb, cc, X[ 0], 12);
GG(cc, dd, aa, bb, X[ 9], 15);
GG(bb, cc, dd, aa, X[ 5], 9);
GG(aa, bb, cc, dd, X[ 2], 11);
GG(dd, aa, bb, cc, X[14], 7);
GG(cc, dd, aa, bb, X[11], 13);
GG(bb, cc, dd, aa, X[ 8], 12);
/* round 3 */
HH(aa, bb, cc, dd, X[ 3], 11);
HH(dd, aa, bb, cc, X[10], 13);
HH(cc, dd, aa, bb, X[14], 6);
HH(bb, cc, dd, aa, X[ 4], 7);
HH(aa, bb, cc, dd, X[ 9], 14);
HH(dd, aa, bb, cc, X[15], 9);
HH(cc, dd, aa, bb, X[ 8], 13);
HH(bb, cc, dd, aa, X[ 1], 15);
HH(aa, bb, cc, dd, X[ 2], 14);
HH(dd, aa, bb, cc, X[ 7], 8);
HH(cc, dd, aa, bb, X[ 0], 13);
HH(bb, cc, dd, aa, X[ 6], 6);
HH(aa, bb, cc, dd, X[13], 5);
HH(dd, aa, bb, cc, X[11], 12);
HH(cc, dd, aa, bb, X[ 5], 7);
HH(bb, cc, dd, aa, X[12], 5);
/* round 4 */
II(aa, bb, cc, dd, X[ 1], 11);
II(dd, aa, bb, cc, X[ 9], 12);
II(cc, dd, aa, bb, X[11], 14);
II(bb, cc, dd, aa, X[10], 15);
II(aa, bb, cc, dd, X[ 0], 14);
II(dd, aa, bb, cc, X[ 8], 15);
II(cc, dd, aa, bb, X[12], 9);
II(bb, cc, dd, aa, X[ 4], 8);
II(aa, bb, cc, dd, X[13], 9);
II(dd, aa, bb, cc, X[ 3], 14);
II(cc, dd, aa, bb, X[ 7], 5);
II(bb, cc, dd, aa, X[15], 6);
II(aa, bb, cc, dd, X[14], 8);
II(dd, aa, bb, cc, X[ 5], 6);
II(cc, dd, aa, bb, X[ 6], 5);
II(bb, cc, dd, aa, X[ 2], 12);
/* parallel round 1 */
III(aaa, bbb, ccc, ddd, X[ 5], 8);
III(ddd, aaa, bbb, ccc, X[14], 9);
III(ccc, ddd, aaa, bbb, X[ 7], 9);
III(bbb, ccc, ddd, aaa, X[ 0], 11);
III(aaa, bbb, ccc, ddd, X[ 9], 13);
III(ddd, aaa, bbb, ccc, X[ 2], 15);
III(ccc, ddd, aaa, bbb, X[11], 15);
III(bbb, ccc, ddd, aaa, X[ 4], 5);
III(aaa, bbb, ccc, ddd, X[13], 7);
III(ddd, aaa, bbb, ccc, X[ 6], 7);
III(ccc, ddd, aaa, bbb, X[15], 8);
III(bbb, ccc, ddd, aaa, X[ 8], 11);
III(aaa, bbb, ccc, ddd, X[ 1], 14);
III(ddd, aaa, bbb, ccc, X[10], 14);
III(ccc, ddd, aaa, bbb, X[ 3], 12);
III(bbb, ccc, ddd, aaa, X[12], 6);
/* parallel round 2 */
HHH(aaa, bbb, ccc, ddd, X[ 6], 9);
HHH(ddd, aaa, bbb, ccc, X[11], 13);
HHH(ccc, ddd, aaa, bbb, X[ 3], 15);
HHH(bbb, ccc, ddd, aaa, X[ 7], 7);
HHH(aaa, bbb, ccc, ddd, X[ 0], 12);
HHH(ddd, aaa, bbb, ccc, X[13], 8);
HHH(ccc, ddd, aaa, bbb, X[ 5], 9);
HHH(bbb, ccc, ddd, aaa, X[10], 11);
HHH(aaa, bbb, ccc, ddd, X[14], 7);
HHH(ddd, aaa, bbb, ccc, X[15], 7);
HHH(ccc, ddd, aaa, bbb, X[ 8], 12);
HHH(bbb, ccc, ddd, aaa, X[12], 7);
HHH(aaa, bbb, ccc, ddd, X[ 4], 6);
HHH(ddd, aaa, bbb, ccc, X[ 9], 15);
HHH(ccc, ddd, aaa, bbb, X[ 1], 13);
HHH(bbb, ccc, ddd, aaa, X[ 2], 11);
/* parallel round 3 */
GGG(aaa, bbb, ccc, ddd, X[15], 9);
GGG(ddd, aaa, bbb, ccc, X[ 5], 7);
GGG(ccc, ddd, aaa, bbb, X[ 1], 15);
GGG(bbb, ccc, ddd, aaa, X[ 3], 11);
GGG(aaa, bbb, ccc, ddd, X[ 7], 8);
GGG(ddd, aaa, bbb, ccc, X[14], 6);
GGG(ccc, ddd, aaa, bbb, X[ 6], 6);
GGG(bbb, ccc, ddd, aaa, X[ 9], 14);
GGG(aaa, bbb, ccc, ddd, X[11], 12);
GGG(ddd, aaa, bbb, ccc, X[ 8], 13);
GGG(ccc, ddd, aaa, bbb, X[12], 5);
GGG(bbb, ccc, ddd, aaa, X[ 2], 14);
GGG(aaa, bbb, ccc, ddd, X[10], 13);
GGG(ddd, aaa, bbb, ccc, X[ 0], 13);
GGG(ccc, ddd, aaa, bbb, X[ 4], 7);
GGG(bbb, ccc, ddd, aaa, X[13], 5);
/* parallel round 4 */
FFF(aaa, bbb, ccc, ddd, X[ 8], 15);
FFF(ddd, aaa, bbb, ccc, X[ 6], 5);
FFF(ccc, ddd, aaa, bbb, X[ 4], 8);
FFF(bbb, ccc, ddd, aaa, X[ 1], 11);
FFF(aaa, bbb, ccc, ddd, X[ 3], 14);
FFF(ddd, aaa, bbb, ccc, X[11], 14);
FFF(ccc, ddd, aaa, bbb, X[15], 6);
FFF(bbb, ccc, ddd, aaa, X[ 0], 14);
FFF(aaa, bbb, ccc, ddd, X[ 5], 6);
FFF(ddd, aaa, bbb, ccc, X[12], 9);
FFF(ccc, ddd, aaa, bbb, X[ 2], 12);
FFF(bbb, ccc, ddd, aaa, X[13], 9);
FFF(aaa, bbb, ccc, ddd, X[ 9], 12);
FFF(ddd, aaa, bbb, ccc, X[ 7], 5);
FFF(ccc, ddd, aaa, bbb, X[10], 15);
FFF(bbb, ccc, ddd, aaa, X[14], 8);
/* combine results */
ddd += cc + md->rmd128.state[1]; /* final result for MDbuf[0] */
md->rmd128.state[1] = md->rmd128.state[2] + dd + aaa;
md->rmd128.state[2] = md->rmd128.state[3] + aa + bbb;
md->rmd128.state[3] = md->rmd128.state[0] + bb + ccc;
md->rmd128.state[0] = ddd;
return CRYPT_OK;
}
void md4Process(md4Param *mp)
/*@modifies mp @*/
{
uint32_t a, b, c, d;
register uint32_t* w;
#ifdef WORDS_BIGENDIAN
register byte t;
#endif
w = mp->data;
#ifdef WORDS_BIGENDIAN
t = 16;
while (t--)
{
register uint32_t temp = swapu32(*w);
*(w++) = temp;
}
w = mp->data;
#endif
a = mp->h[0];
b = mp->h[1];
c = mp->h[2];
d = mp->h[3];
FF (a, b, c, d, w[ 0], 3);
FF (d, a, b, c, w[ 1], 7);
FF (c, d, a, b, w[ 2], 11);
FF (b, c, d, a, w[ 3], 19);
FF (a, b, c, d, w[ 4], 3);
FF (d, a, b, c, w[ 5], 7);
FF (c, d, a, b, w[ 6], 11);
FF (b, c, d, a, w[ 7], 19);
FF (a, b, c, d, w[ 8], 3);
FF (d, a, b, c, w[ 9], 7);
FF (c, d, a, b, w[10], 11);
FF (b, c, d, a, w[11], 19);
FF (a, b, c, d, w[12], 3);
FF (d, a, b, c, w[13], 7);
FF (c, d, a, b, w[14], 11);
FF (b, c, d, a, w[15], 19);
GG (a, b, c, d, w[ 0], 3);
GG (d, a, b, c, w[ 4], 5);
GG (c, d, a, b, w[ 8], 9);
GG (b, c, d, a, w[12], 13);
GG (a, b, c, d, w[ 1], 3);
GG (d, a, b, c, w[ 5], 5);
GG (c, d, a, b, w[ 9], 9);
GG (b, c, d, a, w[13], 13);
GG (a, b, c, d, w[ 2], 3);
GG (d, a, b, c, w[ 6], 5);
GG (c, d, a, b, w[10], 9);
GG (b, c, d, a, w[14], 13);
GG (a, b, c, d, w[ 3], 3);
GG (d, a, b, c, w[ 7], 5);
GG (c, d, a, b, w[11], 9);
GG (b, c, d, a, w[15], 13);
HH (a, b, c, d, w[ 0], 3);
HH (d, a, b, c, w[ 8], 9);
HH (c, d, a, b, w[ 4], 11);
HH (b, c, d, a, w[12], 15);
HH (a, b, c, d, w[ 2], 3);
HH (d, a, b, c, w[10], 9);
HH (c, d, a, b, w[ 6], 11);
HH (b, c, d, a, w[14], 15);
HH (a, b, c, d, w[ 1], 3);
HH (d, a, b, c, w[ 9], 9);
HH (c, d, a, b, w[ 5], 11);
HH (b, c, d, a, w[13], 15);
HH (a, b, c, d, w[ 3], 3);
HH (d, a, b, c, w[11], 9);
HH (c, d, a, b, w[ 7], 11);
HH (b, c, d, a, w[15], 15);
mp->h[0] += a;
mp->h[1] += b;
mp->h[2] += c;
mp->h[3] += d;
}
void md4_update(md4_ctx_t *ctx, void *data, size_t dlen) {
uint16_t avail; /* space available in the context message block */
uint8_t i;
uint16_t pos; /* position to write data into the message block */
uint32_t x[16];
while (dlen) {
pos = CTX_POS(ctx);
avail = CTX_AVAIL(ctx);
if (avail > dlen)
avail = dlen;
/* Copy input data into the context's message block. */
memcpy(ctx->block + pos, data, avail);
data += avail;
dlen -= avail;
ctx->len += avail;
/* If the block is full then transform it. */
if ((ctx->len % 64) == 0) {
uint32_t a = ctx->hash[0];
uint32_t b = ctx->hash[1];
uint32_t c = ctx->hash[2];
uint32_t d = ctx->hash[3];
FF(a, b, c, d, x, 0, 3);
FF(d, a, b, c, x, 1, 7);
FF(c, d, a, b, x, 2, 11);
FF(b, c, d, a, x, 3, 19);
FF(a, b, c, d, x, 4, 3);
FF(d, a, b, c, x, 5, 7);
FF(c, d, a, b, x, 6, 11);
FF(b, c, d, a, x, 7, 19);
FF(a, b, c, d, x, 8, 3);
FF(d, a, b, c, x, 9, 7);
FF(c, d, a, b, x, 10, 11);
FF(b, c, d, a, x, 11, 19);
FF(a, b, c, d, x, 12, 3);
FF(d, a, b, c, x, 13, 7);
FF(c, d, a, b, x, 14, 11);
FF(b, c, d, a, x, 15, 19);
GG(a, b, c, d, x, 0, 3);
GG(d, a, b, c, x, 4, 5);
GG(c, d, a, b, x, 8, 9);
GG(b, c, d, a, x, 12, 13);
GG(a, b, c, d, x, 1, 3);
GG(d, a, b, c, x, 5, 5);
GG(c, d, a, b, x, 9, 9);
GG(b, c, d, a, x, 13, 13);
GG(a, b, c, d, x, 2, 3);
GG(d, a, b, c, x, 6, 5);
GG(c, d, a, b, x, 10, 9);
GG(b, c, d, a, x, 14, 13);
GG(a, b, c, d, x, 3, 3);
GG(d, a, b, c, x, 7, 5);
GG(c, d, a, b, x, 11, 9);
GG(b, c, d, a, x, 15, 13);
HH(a, b, c, d, x, 0, 3);
HH(d, a, b, c, x, 8, 9);
HH(c, d, a, b, x, 4, 11);
HH(b, c, d, a, x, 12, 15);
HH(a, b, c, d, x, 2, 3);
HH(d, a, b, c, x, 10, 9);
HH(c, d, a, b, x, 6, 11);
HH(b, c, d, a, x, 14, 15);
HH(a, b, c, d, x, 1, 3);
HH(d, a, b, c, x, 9, 9);
HH(c, d, a, b, x, 5, 11);
HH(b, c, d, a, x, 13, 15);
HH(a, b, c, d, x, 3, 3);
HH(d, a, b, c, x, 11, 9);
HH(c, d, a, b, x, 7, 11);
HH(b, c, d, a, x, 15, 15);
ctx->hash[0] += a;
ctx->hash[1] += b;
ctx->hash[2] += c;
ctx->hash[3] += d;
}
}
}
void calcMD5SSE(const char message[4][64],unsigned char * hash[4])
{
svSSE2Vector_4_uint32_t a,b,c,d;
svSSE2Vector_4_uint32_t x[16];
a.sse=CST_A;
b.sse=CST_B;
c.sse=CST_C;
d.sse=CST_D;
for (int j=0;j<16;j++)
{
x[j].normal[0]=((const uint32_t *)message[0])[j];
x[j].normal[1]=((const uint32_t *)message[1])[j];
x[j].normal[2]=((const uint32_t *)message[2])[j];
x[j].normal[3]=((const uint32_t *)message[3])[j];
}
/* Round 1 */
FF (a, b, c, d, x[ 0], S11, SIN1); /* 1 */
FF (d, a, b, c, x[ 1], S12, SIN2); /* 2 */
FF (c, d, a, b, x[ 2], S13, SIN3); /* 3 */
FF (b, c, d, a, x[ 3], S14, SIN4); /* 4 */
FF (a, b, c, d, x[ 4], S11, SIN5); /* 5 */
FF (d, a, b, c, x[ 5], S12, SIN6); /* 6 */
FF (c, d, a, b, x[ 6], S13, SIN7); /* 7 */
FF (b, c, d, a, x[ 7], S14, SIN8); /* 8 */
FF (a, b, c, d, x[ 8], S11, SIN9); /* 9 */
FF (d, a, b, c, x[ 9], S12, SIN10); /* 10 */
FF (c, d, a, b, x[10], S13, SIN11); /* 11 */
FF (b, c, d, a, x[11], S14, SIN12); /* 12 */
FF (a, b, c, d, x[12], S11, SIN13); /* 13 */
FF (d, a, b, c, x[13], S12, SIN14); /* 14 */
FF (c, d, a, b, x[14], S13, SIN15); /* 15 */
FF (b, c, d, a, x[15], S14, SIN16); /* 16 */
/* Round 2 */
GG (a, b, c, d, x[ 1], S21, SIN17); /* 17 */
GG (d, a, b, c, x[ 6], S22, SIN18); /* 18 */
GG (c, d, a, b, x[11], S23, SIN19); /* 19 */
GG (b, c, d, a, x[ 0], S24, SIN20); /* 20 */
GG (a, b, c, d, x[ 5], S21, SIN21); /* 21 */
GG (d, a, b, c, x[10], S22, SIN22); /* 22 */
GG (c, d, a, b, x[15], S23, SIN23); /* 23 */
GG (b, c, d, a, x[ 4], S24, SIN24); /* 24 */
GG (a, b, c, d, x[ 9], S21, SIN25); /* 25 */
GG (d, a, b, c, x[14], S22, SIN26); /* 26 */
GG (c, d, a, b, x[ 3], S23, SIN27); /* 27 */
GG (b, c, d, a, x[ 8], S24, SIN28); /* 28 */
GG (a, b, c, d, x[13], S21, SIN29); /* 29 */
GG (d, a, b, c, x[ 2], S22, SIN30); /* 30 */
GG (c, d, a, b, x[ 7], S23, SIN31); /* 31 */
GG (b, c, d, a, x[12], S24, SIN32); /* 32 */
/* Round 3 */
HH (a, b, c, d, x[ 5], S31, SIN33); /* 33 */
HH (d, a, b, c, x[ 8], S32, SIN34); /* 34 */
HH (c, d, a, b, x[11], S33, SIN35); /* 35 */
HH (b, c, d, a, x[14], S34, SIN36); /* 36 */
HH (a, b, c, d, x[ 1], S31, SIN37); /* 37 */
HH (d, a, b, c, x[ 4], S32, SIN38); /* 38 */
HH (c, d, a, b, x[ 7], S33, SIN39); /* 39 */
HH (b, c, d, a, x[10], S34, SIN40); /* 40 */
HH (a, b, c, d, x[13], S31, SIN41); /* 41 */
HH (d, a, b, c, x[ 0], S32, SIN42); /* 42 */
HH (c, d, a, b, x[ 3], S33, SIN43); /* 43 */
HH (b, c, d, a, x[ 6], S34, SIN44); /* 44 */
HH (a, b, c, d, x[ 9], S31, SIN45); /* 45 */
HH (d, a, b, c, x[12], S32, SIN46); /* 46 */
HH (c, d, a, b, x[15], S33, SIN47); /* 47 */
HH (b, c, d, a, x[ 2], S34, SIN48); /* 48 */
/* Round 4 */
II (a, b, c, d, x[ 0], S41, SIN49); /* 49 */
II (d, a, b, c, x[ 7], S42, SIN50); /* 50 */
II (c, d, a, b, x[14], S43, SIN51); /* 51 */
II (b, c, d, a, x[ 5], S44, SIN52); /* 52 */
II (a, b, c, d, x[12], S41, SIN53); /* 53 */
II (d, a, b, c, x[ 3], S42, SIN54); /* 54 */
II (c, d, a, b, x[10], S43, SIN55); /* 55 */
II (b, c, d, a, x[ 1], S44, SIN56); /* 56 */
II (a, b, c, d, x[ 8], S41, SIN57); /* 57 */
II (d, a, b, c, x[15], S42, SIN58); /* 58 */
II (c, d, a, b, x[ 6], S43, SIN59); /* 59 */
II (b, c, d, a, x[13], S44, SIN60); /* 60 */
II (a, b, c, d, x[ 4], S41, SIN61); /* 61 */
II (d, a, b, c, x[11], S42, SIN62); /* 62 */
II (c, d, a, b, x[ 2], S43, SIN63); /* 63 */
II (b, c, d, a, x[ 9], S44, SIN64); /* 64 */
a.sse = a.sse + CST_A;
b.sse = b.sse + CST_B;
c.sse = c.sse + CST_C;
d.sse = d.sse + CST_D;
for (int i=0;i<4; i++)
{
((uint32_t *)hash[i])[0]=a.normal[i];
((uint32_t *)hash[i])[1]=b.normal[i];
((uint32_t *)hash[i])[2]=c.normal[i];
((uint32_t *)hash[i])[3]=d.normal[i];
}
}
static INT rmd256_compress(hash_state *md, UCHAR *buf)
#endif
{
ULONG aa,bb,cc,dd,aaa,bbb,ccc,ddd,tmp,X[16];
INT i;
/* load words X */
for (i = 0; i < 16; i++){
LOAD32L(X[i], buf + (4 * i));
}
/* load state */
aa = md->rmd256.state[0];
bb = md->rmd256.state[1];
cc = md->rmd256.state[2];
dd = md->rmd256.state[3];
aaa = md->rmd256.state[4];
bbb = md->rmd256.state[5];
ccc = md->rmd256.state[6];
ddd = md->rmd256.state[7];
/* round 1 */
FF(aa, bb, cc, dd, X[ 0], 11);
FF(dd, aa, bb, cc, X[ 1], 14);
FF(cc, dd, aa, bb, X[ 2], 15);
FF(bb, cc, dd, aa, X[ 3], 12);
FF(aa, bb, cc, dd, X[ 4], 5);
FF(dd, aa, bb, cc, X[ 5], 8);
FF(cc, dd, aa, bb, X[ 6], 7);
FF(bb, cc, dd, aa, X[ 7], 9);
FF(aa, bb, cc, dd, X[ 8], 11);
FF(dd, aa, bb, cc, X[ 9], 13);
FF(cc, dd, aa, bb, X[10], 14);
FF(bb, cc, dd, aa, X[11], 15);
FF(aa, bb, cc, dd, X[12], 6);
FF(dd, aa, bb, cc, X[13], 7);
FF(cc, dd, aa, bb, X[14], 9);
FF(bb, cc, dd, aa, X[15], 8);
/* parallel round 1 */
III(aaa, bbb, ccc, ddd, X[ 5], 8);
III(ddd, aaa, bbb, ccc, X[14], 9);
III(ccc, ddd, aaa, bbb, X[ 7], 9);
III(bbb, ccc, ddd, aaa, X[ 0], 11);
III(aaa, bbb, ccc, ddd, X[ 9], 13);
III(ddd, aaa, bbb, ccc, X[ 2], 15);
III(ccc, ddd, aaa, bbb, X[11], 15);
III(bbb, ccc, ddd, aaa, X[ 4], 5);
III(aaa, bbb, ccc, ddd, X[13], 7);
III(ddd, aaa, bbb, ccc, X[ 6], 7);
III(ccc, ddd, aaa, bbb, X[15], 8);
III(bbb, ccc, ddd, aaa, X[ 8], 11);
III(aaa, bbb, ccc, ddd, X[ 1], 14);
III(ddd, aaa, bbb, ccc, X[10], 14);
III(ccc, ddd, aaa, bbb, X[ 3], 12);
III(bbb, ccc, ddd, aaa, X[12], 6);
tmp = aa; aa = aaa; aaa = tmp;
/* round 2 */
GG(aa, bb, cc, dd, X[ 7], 7);
GG(dd, aa, bb, cc, X[ 4], 6);
GG(cc, dd, aa, bb, X[13], 8);
GG(bb, cc, dd, aa, X[ 1], 13);
GG(aa, bb, cc, dd, X[10], 11);
GG(dd, aa, bb, cc, X[ 6], 9);
GG(cc, dd, aa, bb, X[15], 7);
GG(bb, cc, dd, aa, X[ 3], 15);
GG(aa, bb, cc, dd, X[12], 7);
GG(dd, aa, bb, cc, X[ 0], 12);
GG(cc, dd, aa, bb, X[ 9], 15);
GG(bb, cc, dd, aa, X[ 5], 9);
GG(aa, bb, cc, dd, X[ 2], 11);
GG(dd, aa, bb, cc, X[14], 7);
GG(cc, dd, aa, bb, X[11], 13);
GG(bb, cc, dd, aa, X[ 8], 12);
/* parallel round 2 */
HHH(aaa, bbb, ccc, ddd, X[ 6], 9);
HHH(ddd, aaa, bbb, ccc, X[11], 13);
HHH(ccc, ddd, aaa, bbb, X[ 3], 15);
HHH(bbb, ccc, ddd, aaa, X[ 7], 7);
HHH(aaa, bbb, ccc, ddd, X[ 0], 12);
HHH(ddd, aaa, bbb, ccc, X[13], 8);
HHH(ccc, ddd, aaa, bbb, X[ 5], 9);
HHH(bbb, ccc, ddd, aaa, X[10], 11);
HHH(aaa, bbb, ccc, ddd, X[14], 7);
HHH(ddd, aaa, bbb, ccc, X[15], 7);
HHH(ccc, ddd, aaa, bbb, X[ 8], 12);
HHH(bbb, ccc, ddd, aaa, X[12], 7);
HHH(aaa, bbb, ccc, ddd, X[ 4], 6);
HHH(ddd, aaa, bbb, ccc, X[ 9], 15);
HHH(ccc, ddd, aaa, bbb, X[ 1], 13);
HHH(bbb, ccc, ddd, aaa, X[ 2], 11);
tmp = bb; bb = bbb; bbb = tmp;
/* round 3 */
HH(aa, bb, cc, dd, X[ 3], 11);
HH(dd, aa, bb, cc, X[10], 13);
HH(cc, dd, aa, bb, X[14], 6);
HH(bb, cc, dd, aa, X[ 4], 7);
HH(aa, bb, cc, dd, X[ 9], 14);
HH(dd, aa, bb, cc, X[15], 9);
HH(cc, dd, aa, bb, X[ 8], 13);
HH(bb, cc, dd, aa, X[ 1], 15);
HH(aa, bb, cc, dd, X[ 2], 14);
HH(dd, aa, bb, cc, X[ 7], 8);
HH(cc, dd, aa, bb, X[ 0], 13);
HH(bb, cc, dd, aa, X[ 6], 6);
HH(aa, bb, cc, dd, X[13], 5);
HH(dd, aa, bb, cc, X[11], 12);
HH(cc, dd, aa, bb, X[ 5], 7);
HH(bb, cc, dd, aa, X[12], 5);
/* parallel round 3 */
GGG(aaa, bbb, ccc, ddd, X[15], 9);
GGG(ddd, aaa, bbb, ccc, X[ 5], 7);
GGG(ccc, ddd, aaa, bbb, X[ 1], 15);
GGG(bbb, ccc, ddd, aaa, X[ 3], 11);
GGG(aaa, bbb, ccc, ddd, X[ 7], 8);
GGG(ddd, aaa, bbb, ccc, X[14], 6);
GGG(ccc, ddd, aaa, bbb, X[ 6], 6);
GGG(bbb, ccc, ddd, aaa, X[ 9], 14);
GGG(aaa, bbb, ccc, ddd, X[11], 12);
GGG(ddd, aaa, bbb, ccc, X[ 8], 13);
GGG(ccc, ddd, aaa, bbb, X[12], 5);
GGG(bbb, ccc, ddd, aaa, X[ 2], 14);
GGG(aaa, bbb, ccc, ddd, X[10], 13);
GGG(ddd, aaa, bbb, ccc, X[ 0], 13);
GGG(ccc, ddd, aaa, bbb, X[ 4], 7);
GGG(bbb, ccc, ddd, aaa, X[13], 5);
tmp = cc; cc = ccc; ccc = tmp;
/* round 4 */
II(aa, bb, cc, dd, X[ 1], 11);
II(dd, aa, bb, cc, X[ 9], 12);
II(cc, dd, aa, bb, X[11], 14);
II(bb, cc, dd, aa, X[10], 15);
II(aa, bb, cc, dd, X[ 0], 14);
II(dd, aa, bb, cc, X[ 8], 15);
II(cc, dd, aa, bb, X[12], 9);
II(bb, cc, dd, aa, X[ 4], 8);
II(aa, bb, cc, dd, X[13], 9);
II(dd, aa, bb, cc, X[ 3], 14);
II(cc, dd, aa, bb, X[ 7], 5);
II(bb, cc, dd, aa, X[15], 6);
II(aa, bb, cc, dd, X[14], 8);
II(dd, aa, bb, cc, X[ 5], 6);
II(cc, dd, aa, bb, X[ 6], 5);
II(bb, cc, dd, aa, X[ 2], 12);
/* parallel round 4 */
FFF(aaa, bbb, ccc, ddd, X[ 8], 15);
FFF(ddd, aaa, bbb, ccc, X[ 6], 5);
FFF(ccc, ddd, aaa, bbb, X[ 4], 8);
FFF(bbb, ccc, ddd, aaa, X[ 1], 11);
FFF(aaa, bbb, ccc, ddd, X[ 3], 14);
FFF(ddd, aaa, bbb, ccc, X[11], 14);
FFF(ccc, ddd, aaa, bbb, X[15], 6);
FFF(bbb, ccc, ddd, aaa, X[ 0], 14);
FFF(aaa, bbb, ccc, ddd, X[ 5], 6);
FFF(ddd, aaa, bbb, ccc, X[12], 9);
FFF(ccc, ddd, aaa, bbb, X[ 2], 12);
FFF(bbb, ccc, ddd, aaa, X[13], 9);
FFF(aaa, bbb, ccc, ddd, X[ 9], 12);
FFF(ddd, aaa, bbb, ccc, X[ 7], 5);
FFF(ccc, ddd, aaa, bbb, X[10], 15);
FFF(bbb, ccc, ddd, aaa, X[14], 8);
tmp = dd; dd = ddd; ddd = tmp;
/* combine results */
md->rmd256.state[0] += aa;
md->rmd256.state[1] += bb;
md->rmd256.state[2] += cc;
md->rmd256.state[3] += dd;
md->rmd256.state[4] += aaa;
md->rmd256.state[5] += bbb;
md->rmd256.state[6] += ccc;
md->rmd256.state[7] += ddd;
return CRYPT_OK;
}
TPassword EncryptingWithMd5(TPassword userPassword)
{
int lengthPassword = userPassword.length();
int lengthOfBits = lengthPassword * 8;
int M[16] = {0};
int i = 0 , j = 0 , p = 1;
for ( ; j < 16; ++j)
{
int num;
if (4 * p - 1 < lengthPassword) num = 4 * p - 1;
else num = lengthPassword - 1;
for (int k = num; k >= i; --k)
{
M[j] = (M[j] << 8) + userPassword[k];
}
i = num + 1;
if (i == lengthPassword ) {
if (i % 4) M[j] += 0x80 << ((i % 4) * 8);
else M[++j] = 0x80;
break;
}
++p;
}
M[14] = lengthOfBits & 0x00000000ffffffff;
M[15] = lengthOfBits & 0xffffffff00000000;
int A , B , C , D;
A = 0x67452301;
B = 0xefcdab89;
C = 0x98badcfe;
D = 0x10325476;
int a = A , b = B , c = C , d = D;
FF(a,b,c,d,M[0],7,0xd76aa478);
FF(d,a,b,c,M[1],12,0xe8c7b756);
FF(c,d,a,b,M[2],17,0x242070db);
FF(b,c,d,a,M[3],22,0xc1bdceee);
FF(a,b,c,d,M[4],7,0xf57c0faf);
FF(d,a,b,c,M[5],12,0x4787c62a);
FF(c,d,a,b,M[6],17,0xa8304613);
FF(b,c,d,a,M[7],22,0xfd469501) ;
FF(a,b,c,d,M[8],7,0x698098d8) ;
FF(d,a,b,c,M[9],12,0x8b44f7af) ;
FF(c,d,a,b,M[10],17,0xffff5bb1) ;
FF(b,c,d,a,M[11],22,0x895cd7be) ;
FF(a,b,c,d,M[12],7,0x6b901122) ;
FF(d,a,b,c,M[13],12,0xfd987193) ;
FF(c,d,a,b,M[14],17,0xa679438e) ;
FF(b,c,d,a,M[15],22,0x49b40821);
GG(a,b,c,d,M[1],5,0xf61e2562);
GG(d,a,b,c,M[6],9,0xc040b340);
GG(c,d,a,b,M[11],14,0x265e5a51);
GG(b,c,d,a,M[0],20,0xe9b6c7aa) ;
GG(a,b,c,d,M[5],5,0xd62f105d) ;
GG(d,a,b,c,M[10],9,0x02441453) ;
GG(c,d,a,b,M[15],14,0xd8a1e681);
GG(b,c,d,a,M[4],20,0xe7d3fbc8) ;
GG(a,b,c,d,M[9],5,0x21e1cde6) ;
GG(d,a,b,c,M[14],9,0xc33707d6) ;
GG(c,d,a,b,M[3],14,0xf4d50d87) ;
GG(b,c,d,a,M[8],20,0x455a14ed);
GG(a,b,c,d,M[13],5,0xa9e3e905);
GG(d,a,b,c,M[2],9,0xfcefa3f8) ;
GG(c,d,a,b,M[7],14,0x676f02d9) ;
GG(b,c,d,a,M[12],20,0x8d2a4c8a);
HH(a,b,c,d,M[5],4,0xfffa3942);
HH(d,a,b,c,M[8],11,0x8771f681);
HH(c,d,a,b,M[11],16,0x6d9d6122);
HH(b,c,d,a,M[14],23,0xfde5380c) ;
HH(a,b,c,d,M[1],4,0xa4beea44) ;
HH(d,a,b,c,M[4],11,0x4bdecfa9) ;
HH(c,d,a,b,M[7],16,0xf6bb4b60) ;
HH(b,c,d,a,M[10],23,0xbebfbc70);
HH(a,b,c,d,M[13],4,0x289b7ec6);
HH(d,a,b,c,M[0],11,0xeaa127fa);
HH(c,d,a,b,M[3],16,0xd4ef3085);
HH(b,c,d,a,M[6],23,0x04881d05);
HH(a,b,c,d,M[9],4,0xd9d4d039);
HH(d,a,b,c,M[12],11,0xe6db99e5);
HH(c,d,a,b,M[15],16,0x1fa27cf8) ;
HH(b,c,d,a,M[2],23,0xc4ac5665);
II(a,b,c,d,M[0],6,0xf4292244) ;
II(d,a,b,c,M[7],10,0x432aff97) ;
II(c,d,a,b,M[14],15,0xab9423a7);
II(b,c,d,a,M[5],21,0xfc93a039) ;
II(a,b,c,d,M[12],6,0x655b59c3) ;
II(d,a,b,c,M[3],10,0x8f0ccc92) ;
II(c,d,a,b,M[10],15,0xffeff47d);
II(b,c,d,a,M[1],21,0x85845dd1) ;
II(a,b,c,d,M[8],6,0x6fa87e4f) ;
II(d,a,b,c,M[15],10,0xfe2ce6e0);
II(c,d,a,b,M[6],15,0xa3014314) ;
II(b,c,d,a,M[13],21,0x4e0811a1);
II(a,b,c,d,M[4],6,0xf7537e82) ;
II(d,a,b,c,M[11],10,0xbd3af235);
II(c,d,a,b,M[2],15,0x2ad7d2bb);
II(b,c,d,a,M[9],21,0xeb86d391);
A += a;
B += b;
C += c;
D += d;
TPassword encryptedPassword = "";
encryptedPassword = PrintWithLE(A) + PrintWithLE(B) + PrintWithLE(C) + PrintWithLE(D);
return encryptedPassword;
}
unsigned int TransformBlock(unsigned int x0, unsigned int x1, unsigned int x2, unsigned int x14)
{
unsigned int a=0x67452301, b=0xefcdab89, c=0x98badcfe, d=0x10325476;
// Round 1
a=FF(a, b, c, d, x0, 7, 0xd76aa478);
d=FF(d, a, b, c, x1, 12, 0xe8c7b756);
c=FF(c, d, a, b, x2, 17, 0x242070db);
b=FF(b, c, d, a, 0, 22, 0xc1bdceee);
a=FF(a, b, c, d, 0, 7, 0xf57c0faf);
d=FF(d, a, b, c, 0, 12, 0x4787c62a);
c=FF(c, d, a, b, 0, 17, 0xa8304613);
b=FF(b, c, d, a, 0, 22, 0xfd469501);
a=FF(a, b, c, d, 0, 7, 0x698098d8);
d=FF(d, a, b, c, 0, 12, 0x8b44f7af);
c=FF(c, d, a, b, 0, 17, 0xffff5bb1);
b=FF(b, c, d, a, 0, 22, 0x895cd7be);
a=FF(a, b, c, d, 0, 7, 0x6b901122);
d=FF(d, a, b, c, 0, 12, 0xfd987193);
c=FF(c, d, a, b, x14, 17, 0xa679438e);
b=FF(b, c, d, a, 0, 22, 0x49b40821);
// Round 2
a=GG(a, b, c, d, x1, 5, 0xf61e2562);
d=GG(d, a, b, c, 0, 9, 0xc040b340);
c=GG(c, d, a, b, 0, 14, 0x265e5a51);
b=GG(b, c, d, a, x0, 20, 0xe9b6c7aa);
a=GG(a, b, c, d, 0, 5, 0xd62f105d);
d=GG(d, a, b, c, 0, 9, 0x02441453);
c=GG(c, d, a, b, 0, 14, 0xd8a1e681);
b=GG(b, c, d, a, 0, 20, 0xe7d3fbc8);
a=GG(a, b, c, d, 0, 5, 0x21e1cde6);
d=GG(d, a, b, c, x14, 9, 0xc33707d6);
c=GG(c, d, a, b, 0, 14, 0xf4d50d87);
b=GG(b, c, d, a, 0, 20, 0x455a14ed);
a=GG(a, b, c, d, 0, 5, 0xa9e3e905);
d=GG(d, a, b, c, x2, 9, 0xfcefa3f8);
c=GG(c, d, a, b, 0, 14, 0x676f02d9);
b=GG(b, c, d, a, 0, 20, 0x8d2a4c8a);
// Round 3
a=HH(a, b, c, d, 0, 4, 0xfffa3942);
d=HH(d, a, b, c, 0, 11, 0x8771f681);
c=HH(c, d, a, b, 0, 16, 0x6d9d6122);
b=HH(b, c, d, a, x14, 23, 0xfde5380c);
a=HH(a, b, c, d, x1, 4, 0xa4beea44);
d=HH(d, a, b, c, 0, 11, 0x4bdecfa9);
c=HH(c, d, a, b, 0, 16, 0xf6bb4b60);
b=HH(b, c, d, a, 0, 23, 0xbebfbc70);
a=HH(a, b, c, d, 0, 4, 0x289b7ec6);
d=HH(d, a, b, c, x0, 11, 0xeaa127fa);
c=HH(c, d, a, b, 0, 16, 0xd4ef3085);
b=HH(b, c, d, a, 0, 23, 0x04881d05);
a=HH(a, b, c, d, 0, 4, 0xd9d4d039);
d=HH(d, a, b, c, 0, 11, 0xe6db99e5);
c=HH(c, d, a, b, 0, 16, 0x1fa27cf8);
b=HH(b, c, d, a, x2, 23, 0xc4ac5665);
// Round 4
a=II(a, b, c, d, x0, 6, 0xf4292244);
d=II(d, a, b, c, 0, 10, 0x432aff97);
c=II(c, d, a, b, x14, 15, 0xab9423a7);
b=II(b, c, d, a, 0, 21, 0xfc93a039);
a=II(a, b, c, d, 0, 6, 0x655b59c3);
d=II(d, a, b, c, 0, 10, 0x8f0ccc92);
c=II(c, d, a, b, 0, 15, 0xffeff47d);
b=II(b, c, d, a, x1, 21, 0x85845dd1);
a=II(a, b, c, d, 0, 6, 0x6fa87e4f);
d=II(d, a, b, c, 0, 10, 0xfe2ce6e0);
c=II(c, d, a, b, 0, 15, 0xa3014314);
b=II(b, c, d, a, 0, 21, 0x4e0811a1);
a=II(a, b, c, d, 0, 6, 0xf7537e82);
d=II(d, a, b, c, 0, 10, 0xbd3af235);
c=II(c, d, a, b, x2, 15, 0x2ad7d2bb);
b=II(b, c, d, a, 0, 21, 0xeb86d391);
a+=0x67452301;
b+=0xefcdab89;
c+=0x98badcfe;
d+=0x10325476;
return a^b^c^d;
}
/***************************************************************************
* MD5Transform - Basic MD5 transformation.
*
* Transforms the state registers based on the given block.
*
* RETURNS: A new state.
*
* NOMANUAL
*/
LOCAL void MD5Transform
(
ULONG state[4],
UCHAR block[64]
)
{
ULONG a, b, c, d;
ULONG x[16];
UINT i, j;
/* Copy block[j] into x[i] */
for (i = 0, j = 0; j < 64; i++, j += 4)
{
x[i] = (((ULONG)block[j]) |
(((ULONG)block[j+1]) << 8) |
(((ULONG)block[j+2]) << 16) |
(((ULONG)block[j+3]) << 24));
}
/* Copy context->state[] to working vars */
a = state[0];
b = state[1];
c = state[2];
d = state[3];
/*
* The last argument of the following function is based of the
* sine funciton. A 64 element table T[1...64] has been constructed
* where T[i] denotes the i-th element of the table which is equal
* to the integer part of 4294967296 times abs(sin(i)), i is in radians.
* See the appendix of RFC 1321 for actual values.
*/
/* Round 1 */
FF(a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
FF(d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
FF(c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
FF(b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
FF(a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
FF(d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
FF(c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
FF(b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
FF(a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
FF(d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
/* Round 2 */
GG(a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG(d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG(b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG(a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG(b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG(a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG(c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG(b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG(d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG(c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
/* Round 3 */
HH(a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH(d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH(a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH(d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH(c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH(d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH(c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH(b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH(a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH(b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
/* Round 4 */
II(a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II(d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II(b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II(d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II(b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II(a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II(c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II(a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II(c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II(b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
/* increment each state register by the new value */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
/* Zeroize sensitive information */
memset((UCHAR *)x, 0, sizeof(x));
}
//MD5文件摘要
MD5VAL md5File(FILE * fpin)
{
if(!Buffer)
Buffer=new char[BUFFER_SIZE+64];
char * buf=Buffer;
MD5VAL val={0x67452301,0xefcdab89,0x98badcfe,0x10325476};
unsigned int &a=val.a, &b=val.b, &c=val.c, &d=val.d;
unsigned int aa,bb,cc,dd;
unsigned int i,j,count,co;
unsigned int * x;
i=0;
do
{
count=fread(buf,1,BUFFER_SIZE,fpin);
i+=count;
if(count==BUFFER_SIZE)
co=BUFFER_SIZE;
else
{
j=count;
buf[j++]=char(0x80);
for(j;j%64!=56;j++)
buf[j]=0x00;
*(unsigned int *)(buf+j)=i<<3; j+=4;
*(unsigned int *)(buf+j)=i>>29; j+=4;
co=j;
}
for(j=0;j<co;j+=64)
{
x=(unsigned int *)(buf+j);
// Save the values
aa=a; bb=b; cc=c; dd=d;
// Round 1
FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
// Round 2
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
// Round 3
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
// Round 4 */
II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
// Add the original values
a+=aa;
b+=bb;
c+=cc;
d+=dd;
}
} while(count==BUFFER_SIZE);
return val;
}
//MD5摘要
MD5VAL md5(char * str, unsigned int size)
{
if(size==0)
size=strlen(str);
unsigned int m=size%64;
unsigned int lm=size-m; //数据整块长度
unsigned int ln; //数据补位后长度
if(m<56)
ln=lm+64;
else
ln=lm+128;
char * strw=new char[ln];
unsigned int i;
//复制原字串到缓冲区strw
for(i=0;i<size;i++)
strw[i]=str[i];
//补位
strw[i++]=char(0x80);
for(i;i<ln-8;i++)
strw[i]=0x00;
//补长度
unsigned int * x=(unsigned int *)(strw+i);
*(x++)=size<<3;
*(x++)=size>>29;
//初始化MD5参数
MD5VAL val={0x67452301,0xefcdab89,0x98badcfe,0x10325476};
unsigned int &a=val.a, &b=val.b, &c=val.c, &d=val.d;
unsigned int aa,bb,cc,dd;
for(i=0;i<ln;i+=64)
{
x=(unsigned int *)(strw+i);
// Save the values
aa=a; bb=b; cc=c; dd=d;
// Round 1
FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
// Round 2
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
// Round 3
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
// Round 4 */
II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
// Add the original values
a+=aa;
b+=bb;
c+=cc;
d+=dd;
}
delete[] strw;
return val;
}
void
ncp_sign(const u_int32_t *state, const char *block, u_int32_t *ostate) {
UINT4 a, b, c, d, x[16];
Decode (x, block, 64);
a = state[0];
b = state[1];
c = state[2];
d = state[3];
/* Round 1 */
FF (a, b, c, d, x[ 0], S11); /* 1 */
FF (d, a, b, c, x[ 1], S12); /* 2 */
FF (c, d, a, b, x[ 2], S13); /* 3 */
FF (b, c, d, a, x[ 3], S14); /* 4 */
FF (a, b, c, d, x[ 4], S11); /* 5 */
FF (d, a, b, c, x[ 5], S12); /* 6 */
FF (c, d, a, b, x[ 6], S13); /* 7 */
FF (b, c, d, a, x[ 7], S14); /* 8 */
FF (a, b, c, d, x[ 8], S11); /* 9 */
FF (d, a, b, c, x[ 9], S12); /* 10 */
FF (c, d, a, b, x[10], S13); /* 11 */
FF (b, c, d, a, x[11], S14); /* 12 */
FF (a, b, c, d, x[12], S11); /* 13 */
FF (d, a, b, c, x[13], S12); /* 14 */
FF (c, d, a, b, x[14], S13); /* 15 */
FF (b, c, d, a, x[15], S14); /* 16 */
/* Round 2 */
GG (a, b, c, d, x[ 0], S21); /* 17 */
GG (d, a, b, c, x[ 4], S22); /* 18 */
GG (c, d, a, b, x[ 8], S23); /* 19 */
GG (b, c, d, a, x[12], S24); /* 20 */
GG (a, b, c, d, x[ 1], S21); /* 21 */
GG (d, a, b, c, x[ 5], S22); /* 22 */
GG (c, d, a, b, x[ 9], S23); /* 23 */
GG (b, c, d, a, x[13], S24); /* 24 */
GG (a, b, c, d, x[ 2], S21); /* 25 */
GG (d, a, b, c, x[ 6], S22); /* 26 */
GG (c, d, a, b, x[10], S23); /* 27 */
GG (b, c, d, a, x[14], S24); /* 28 */
GG (a, b, c, d, x[ 3], S21); /* 29 */
GG (d, a, b, c, x[ 7], S22); /* 30 */
GG (c, d, a, b, x[11], S23); /* 31 */
GG (b, c, d, a, x[15], S24); /* 32 */
/* Round 3 */
HH (a, b, c, d, x[ 0], S31); /* 33 */
HH (d, a, b, c, x[ 8], S32); /* 34 */
HH (c, d, a, b, x[ 4], S33); /* 35 */
HH (b, c, d, a, x[12], S34); /* 36 */
HH (a, b, c, d, x[ 2], S31); /* 37 */
HH (d, a, b, c, x[10], S32); /* 38 */
HH (c, d, a, b, x[ 6], S33); /* 39 */
HH (b, c, d, a, x[14], S34); /* 40 */
HH (a, b, c, d, x[ 1], S31); /* 41 */
HH (d, a, b, c, x[ 9], S32); /* 42 */
HH (c, d, a, b, x[ 5], S33); /* 43 */
HH (b, c, d, a, x[13], S34); /* 44 */
HH (a, b, c, d, x[ 3], S31); /* 45 */
HH (d, a, b, c, x[11], S32); /* 46 */
HH (c, d, a, b, x[ 7], S33); /* 47 */
HH (b, c, d, a, x[15], S34); /* 48 */
ostate[0] = state[0] + a;
ostate[1] = state[1] + b;
ostate[2] = state[2] + c;
ostate[3] = state[3] + d;
}
static void
doTheRounds(uint32 X[16], uint32 state[4])
{
uint32 a,
b,
c,
d;
a = state[0];
b = state[1];
c = state[2];
d = state[3];
/* round 1 */
FF(a, b, c, d, X[ 0], S11, T[ 0]);
FF(d, a, b, c, X[ 1], S12, T[ 1]);
FF(c, d, a, b, X[ 2], S13, T[ 2]);
FF(b, c, d, a, X[ 3], S14, T[ 3]);
FF(a, b, c, d, X[ 4], S11, T[ 4]);
FF(d, a, b, c, X[ 5], S12, T[ 5]);
FF(c, d, a, b, X[ 6], S13, T[ 6]);
FF(b, c, d, a, X[ 7], S14, T[ 7]);
FF(a, b, c, d, X[ 8], S11, T[ 8]);
FF(d, a, b, c, X[ 9], S12, T[ 9]);
FF(c, d, a, b, X[10], S13, T[10]);
FF(b, c, d, a, X[11], S14, T[11]);
FF(a, b, c, d, X[12], S11, T[12]);
FF(d, a, b, c, X[13], S12, T[13]);
FF(c, d, a, b, X[14], S13, T[14]);
FF(b, c, d, a, X[15], S14, T[15]);
GG(a, b, c, d, X[ 1], S21, T[16]);
GG(d, a, b, c, X[ 6], S22, T[17]);
GG(c, d, a, b, X[11], S23, T[18]);
GG(b, c, d, a, X[ 0], S24, T[19]);
GG(a, b, c, d, X[ 5], S21, T[20]);
GG(d, a, b, c, X[10], S22, T[21]);
GG(c, d, a, b, X[15], S23, T[22]);
GG(b, c, d, a, X[ 4], S24, T[23]);
GG(a, b, c, d, X[ 9], S21, T[24]);
GG(d, a, b, c, X[14], S22, T[25]);
GG(c, d, a, b, X[ 3], S23, T[26]);
GG(b, c, d, a, X[ 8], S24, T[27]);
GG(a, b, c, d, X[13], S21, T[28]);
GG(d, a, b, c, X[ 2], S22, T[29]);
GG(c, d, a, b, X[ 7], S23, T[30]);
GG(b, c, d, a, X[12], S24, T[31]);
HH(a, b, c, d, X[ 5], S31, T[32]);
HH(d, a, b, c, X[ 8], S32, T[33]);
HH(c, d, a, b, X[11], S33, T[34]);
HH(b, c, d, a, X[14], S34, T[35]);
HH(a, b, c, d, X[ 1], S31, T[36]);
HH(d, a, b, c, X[ 4], S32, T[37]);
HH(c, d, a, b, X[ 7], S33, T[38]);
HH(b, c, d, a, X[10], S34, T[39]);
HH(a, b, c, d, X[13], S31, T[40]);
HH(d, a, b, c, X[ 0], S32, T[41]);
HH(c, d, a, b, X[ 3], S33, T[42]);
HH(b, c, d, a, X[ 6], S34, T[43]);
HH(a, b, c, d, X[ 9], S31, T[44]);
HH(d, a, b, c, X[12], S32, T[45]);
HH(c, d, a, b, X[15], S33, T[46]);
HH(b, c, d, a, X[ 2], S34, T[47]);
II(a, b, c, d, X[ 0], S41, T[48]);
II(d, a, b, c, X[ 7], S42, T[49]);
II(c, d, a, b, X[14], S43, T[50]);
II(b, c, d, a, X[ 5], S44, T[51]);
II(a, b, c, d, X[12], S41, T[52]);
II(d, a, b, c, X[ 3], S42, T[53]);
II(c, d, a, b, X[10], S43, T[54]);
II(b, c, d, a, X[ 1], S44, T[55]);
II(a, b, c, d, X[ 8], S41, T[56]);
II(d, a, b, c, X[15], S42, T[57]);
II(c, d, a, b, X[ 6], S43, T[58]);
II(b, c, d, a, X[13], S44, T[59]);
II(a, b, c, d, X[ 4], S41, T[60]);
II(d, a, b, c, X[11], S42, T[61]);
II(c, d, a, b, X[ 2], S43, T[62]);
II(b, c, d, a, X[ 9], S44, T[63]);
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
}
//MD5摘要
MD5VAL md5( const INT8 * pc_abstract_str, UINT32 n_size )
{
if( n_size == 0 ) {
n_size = strlen( pc_abstract_str );
}
UINT32 n_m = n_size % 64;
UINT32 n_lm = n_size - n_m; //数据整块长度
UINT32 n_ln; //数据补位后长度
if( n_m < 56 ) {
n_ln = n_lm + 64;
}
else {
n_ln = n_lm + 128;
}
INT8 * pc_strw = new INT8[n_ln];
UINT32 i;
//复制原字串到缓冲区strw
for( i = 0; i < n_size; i++ ) {
pc_strw[i] = pc_abstract_str[i];
}
//补位
pc_strw[i++] = 0x80;
for( ; i < n_ln-8; i++ ) {
pc_strw[i] = 0x00;
}
//补长度
UINT32 * pn_len = ( UINT32 * )( pc_strw+i );
*(pn_len++) = n_size<<3;
*(pn_len++) = n_size>>29;
//初始化MD5参数
MD5VAL val = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476 };
UINT32 &n_a = val.n_a, &n_b = val.n_b, &n_c = val.n_c, &n_d = val.n_d;
UINT32 n_aa, n_bb, n_cc, n_dd;
for( i = 0; i < n_ln; i += 64)
{
pn_len = ( UINT32 * )( pc_strw + i );
// Save the values
n_aa = n_a; n_bb = n_b; n_cc = n_c; n_dd = n_d;
// Round 1
FF ( n_a, n_b, n_c, n_d, pn_len[ 0], S11, 0xd76aa478); /* 1 */
FF ( n_d, n_a, n_b, n_c, pn_len[ 1], S12, 0xe8c7b756); /* 2 */
FF ( n_c, n_d, n_a, n_b, pn_len[ 2], S13, 0x242070db); /* 3 */
FF ( n_b, n_c, n_d, n_a, pn_len[ 3], S14, 0xc1bdceee); /* 4 */
FF ( n_a, n_b, n_c, n_d, pn_len[ 4], S11, 0xf57c0faf); /* 5 */
FF ( n_d, n_a, n_b, n_c, pn_len[ 5], S12, 0x4787c62a); /* 6 */
FF ( n_c, n_d, n_a, n_b, pn_len[ 6], S13, 0xa8304613); /* 7 */
FF ( n_b, n_c, n_d, n_a, pn_len[ 7], S14, 0xfd469501); /* 8 */
FF ( n_a, n_b, n_c, n_d, pn_len[ 8], S11, 0x698098d8); /* 9 */
FF ( n_d, n_a, n_b, n_c, pn_len[ 9], S12, 0x8b44f7af); /* 10 */
FF ( n_c, n_d, n_a, n_b, pn_len[10], S13, 0xffff5bb1); /* 11 */
FF ( n_b, n_c, n_d, n_a, pn_len[11], S14, 0x895cd7be); /* 12 */
FF ( n_a, n_b, n_c, n_d, pn_len[12], S11, 0x6b901122); /* 13 */
FF ( n_d, n_a, n_b, n_c, pn_len[13], S12, 0xfd987193); /* 14 */
FF ( n_c, n_d, n_a, n_b, pn_len[14], S13, 0xa679438e); /* 15 */
FF ( n_b, n_c, n_d, n_a, pn_len[15], S14, 0x49b40821); /* 16 */
// Round 2
GG ( n_a, n_b, n_c, n_d, pn_len[ 1], S21, 0xf61e2562); /* 17 */
GG ( n_d, n_a, n_b, n_c, pn_len[ 6], S22, 0xc040b340); /* 18 */
GG ( n_c, n_d, n_a, n_b, pn_len[11], S23, 0x265e5a51); /* 19 */
GG ( n_b, n_c, n_d, n_a, pn_len[ 0], S24, 0xe9b6c7aa); /* 20 */
GG ( n_a, n_b, n_c, n_d, pn_len[ 5], S21, 0xd62f105d); /* 21 */
GG ( n_d, n_a, n_b, n_c, pn_len[10], S22, 0x2441453); /* 22 */
GG ( n_c, n_d, n_a, n_b, pn_len[15], S23, 0xd8a1e681); /* 23 */
GG ( n_b, n_c, n_d, n_a, pn_len[ 4], S24, 0xe7d3fbc8); /* 24 */
GG ( n_a, n_b, n_c, n_d, pn_len[ 9], S21, 0x21e1cde6); /* 25 */
GG ( n_d, n_a, n_b, n_c, pn_len[14], S22, 0xc33707d6); /* 26 */
GG ( n_c, n_d, n_a, n_b, pn_len[ 3], S23, 0xf4d50d87); /* 27 */
GG ( n_b, n_c, n_d, n_a, pn_len[ 8], S24, 0x455a14ed); /* 28 */
GG ( n_a, n_b, n_c, n_d, pn_len[13], S21, 0xa9e3e905); /* 29 */
GG ( n_d, n_a, n_b, n_c, pn_len[ 2], S22, 0xfcefa3f8); /* 30 */
GG ( n_c, n_d, n_a, n_b, pn_len[ 7], S23, 0x676f02d9); /* 31 */
GG ( n_b, n_c, n_d, n_a, pn_len[12], S24, 0x8d2a4c8a); /* 32 */
// Round 3
HH ( n_a, n_b, n_c, n_d, pn_len[ 5], S31, 0xfffa3942); /* 33 */
HH ( n_d, n_a, n_b, n_c, pn_len[ 8], S32, 0x8771f681); /* 34 */
HH ( n_c, n_d, n_a, n_b, pn_len[11], S33, 0x6d9d6122); /* 35 */
HH ( n_b, n_c, n_d, n_a, pn_len[14], S34, 0xfde5380c); /* 36 */
HH ( n_a, n_b, n_c, n_d, pn_len[ 1], S31, 0xa4beea44); /* 37 */
HH ( n_d, n_a, n_b, n_c, pn_len[ 4], S32, 0x4bdecfa9); /* 38 */
HH ( n_c, n_d, n_a, n_b, pn_len[ 7], S33, 0xf6bb4b60); /* 39 */
HH ( n_b, n_c, n_d, n_a, pn_len[10], S34, 0xbebfbc70); /* 40 */
HH ( n_a, n_b, n_c, n_d, pn_len[13], S31, 0x289b7ec6); /* 41 */
HH ( n_d, n_a, n_b, n_c, pn_len[ 0], S32, 0xeaa127fa); /* 42 */
HH ( n_c, n_d, n_a, n_b, pn_len[ 3], S33, 0xd4ef3085); /* 43 */
HH ( n_b, n_c, n_d, n_a, pn_len[ 6], S34, 0x4881d05); /* 44 */
HH ( n_a, n_b, n_c, n_d, pn_len[ 9], S31, 0xd9d4d039); /* 45 */
HH ( n_d, n_a, n_b, n_c, pn_len[12], S32, 0xe6db99e5); /* 46 */
HH ( n_c, n_d, n_a, n_b, pn_len[15], S33, 0x1fa27cf8); /* 47 */
HH ( n_b, n_c, n_d, n_a, pn_len[ 2], S34, 0xc4ac5665); /* 48 */
// Round 4 */
II ( n_a, n_b, n_c, n_d, pn_len[ 0], S41, 0xf4292244); /* 49 */
II ( n_d, n_a, n_b, n_c, pn_len[ 7], S42, 0x432aff97); /* 50 */
II ( n_c, n_d, n_a, n_b, pn_len[14], S43, 0xab9423a7); /* 51 */
II ( n_b, n_c, n_d, n_a, pn_len[ 5], S44, 0xfc93a039); /* 52 */
II ( n_a, n_b, n_c, n_d, pn_len[12], S41, 0x655b59c3); /* 53 */
II ( n_d, n_a, n_b, n_c, pn_len[ 3], S42, 0x8f0ccc92); /* 54 */
II ( n_c, n_d, n_a, n_b, pn_len[10], S43, 0xffeff47d); /* 55 */
II ( n_b, n_c, n_d, n_a, pn_len[ 1], S44, 0x85845dd1); /* 56 */
II ( n_a, n_b, n_c, n_d, pn_len[ 8], S41, 0x6fa87e4f); /* 57 */
II ( n_d, n_a, n_b, n_c, pn_len[15], S42, 0xfe2ce6e0); /* 58 */
II ( n_c, n_d, n_a, n_b, pn_len[ 6], S43, 0xa3014314); /* 59 */
II ( n_b, n_c, n_d, n_a, pn_len[13], S44, 0x4e0811a1); /* 60 */
II ( n_a, n_b, n_c, n_d, pn_len[ 4], S41, 0xf7537e82); /* 61 */
II ( n_d, n_a, n_b, n_c, pn_len[11], S42, 0xbd3af235); /* 62 */
II ( n_c, n_d, n_a, n_b, pn_len[ 2], S43, 0x2ad7d2bb); /* 63 */
II ( n_b, n_c, n_d, n_a, pn_len[ 9], S44, 0xeb86d391); /* 64 */
// Add the original values
n_a += n_aa;
n_b += n_bb;
n_c += n_cc;
n_d += n_dd;
}
delete[] pc_strw;
return val;
}
static void rmd128_compress(ccdigest_state_t state, unsigned long nblocks, const void *in)
{
uint32_t aa,bb,cc,dd,aaa,bbb,ccc,ddd,X[16];
int i;
uint32_t *s = ccdigest_u32(state);
const unsigned char *buf = in;
while(nblocks--) {
/* load words X */
for (i = 0; i < 16; i++){
CC_LOAD32_LE(X[i], buf + (4 * i));
}
/* load state */
aa = aaa = s[0];
bb = bbb = s[1];
cc = ccc = s[2];
dd = ddd = s[3];
/* round 1 */
FF(aa, bb, cc, dd, X[ 0], 11);
FF(dd, aa, bb, cc, X[ 1], 14);
FF(cc, dd, aa, bb, X[ 2], 15);
FF(bb, cc, dd, aa, X[ 3], 12);
FF(aa, bb, cc, dd, X[ 4], 5);
FF(dd, aa, bb, cc, X[ 5], 8);
FF(cc, dd, aa, bb, X[ 6], 7);
FF(bb, cc, dd, aa, X[ 7], 9);
FF(aa, bb, cc, dd, X[ 8], 11);
FF(dd, aa, bb, cc, X[ 9], 13);
FF(cc, dd, aa, bb, X[10], 14);
FF(bb, cc, dd, aa, X[11], 15);
FF(aa, bb, cc, dd, X[12], 6);
FF(dd, aa, bb, cc, X[13], 7);
FF(cc, dd, aa, bb, X[14], 9);
FF(bb, cc, dd, aa, X[15], 8);
/* round 2 */
GG(aa, bb, cc, dd, X[ 7], 7);
GG(dd, aa, bb, cc, X[ 4], 6);
GG(cc, dd, aa, bb, X[13], 8);
GG(bb, cc, dd, aa, X[ 1], 13);
GG(aa, bb, cc, dd, X[10], 11);
GG(dd, aa, bb, cc, X[ 6], 9);
GG(cc, dd, aa, bb, X[15], 7);
GG(bb, cc, dd, aa, X[ 3], 15);
GG(aa, bb, cc, dd, X[12], 7);
GG(dd, aa, bb, cc, X[ 0], 12);
GG(cc, dd, aa, bb, X[ 9], 15);
GG(bb, cc, dd, aa, X[ 5], 9);
GG(aa, bb, cc, dd, X[ 2], 11);
GG(dd, aa, bb, cc, X[14], 7);
GG(cc, dd, aa, bb, X[11], 13);
GG(bb, cc, dd, aa, X[ 8], 12);
/* round 3 */
HH(aa, bb, cc, dd, X[ 3], 11);
HH(dd, aa, bb, cc, X[10], 13);
HH(cc, dd, aa, bb, X[14], 6);
HH(bb, cc, dd, aa, X[ 4], 7);
HH(aa, bb, cc, dd, X[ 9], 14);
HH(dd, aa, bb, cc, X[15], 9);
HH(cc, dd, aa, bb, X[ 8], 13);
HH(bb, cc, dd, aa, X[ 1], 15);
HH(aa, bb, cc, dd, X[ 2], 14);
HH(dd, aa, bb, cc, X[ 7], 8);
HH(cc, dd, aa, bb, X[ 0], 13);
HH(bb, cc, dd, aa, X[ 6], 6);
HH(aa, bb, cc, dd, X[13], 5);
HH(dd, aa, bb, cc, X[11], 12);
HH(cc, dd, aa, bb, X[ 5], 7);
HH(bb, cc, dd, aa, X[12], 5);
/* round 4 */
II(aa, bb, cc, dd, X[ 1], 11);
II(dd, aa, bb, cc, X[ 9], 12);
II(cc, dd, aa, bb, X[11], 14);
II(bb, cc, dd, aa, X[10], 15);
II(aa, bb, cc, dd, X[ 0], 14);
II(dd, aa, bb, cc, X[ 8], 15);
II(cc, dd, aa, bb, X[12], 9);
II(bb, cc, dd, aa, X[ 4], 8);
II(aa, bb, cc, dd, X[13], 9);
II(dd, aa, bb, cc, X[ 3], 14);
II(cc, dd, aa, bb, X[ 7], 5);
II(bb, cc, dd, aa, X[15], 6);
II(aa, bb, cc, dd, X[14], 8);
II(dd, aa, bb, cc, X[ 5], 6);
II(cc, dd, aa, bb, X[ 6], 5);
II(bb, cc, dd, aa, X[ 2], 12);
/* parallel round 1 */
III(aaa, bbb, ccc, ddd, X[ 5], 8);
III(ddd, aaa, bbb, ccc, X[14], 9);
III(ccc, ddd, aaa, bbb, X[ 7], 9);
III(bbb, ccc, ddd, aaa, X[ 0], 11);
III(aaa, bbb, ccc, ddd, X[ 9], 13);
III(ddd, aaa, bbb, ccc, X[ 2], 15);
III(ccc, ddd, aaa, bbb, X[11], 15);
III(bbb, ccc, ddd, aaa, X[ 4], 5);
III(aaa, bbb, ccc, ddd, X[13], 7);
III(ddd, aaa, bbb, ccc, X[ 6], 7);
III(ccc, ddd, aaa, bbb, X[15], 8);
III(bbb, ccc, ddd, aaa, X[ 8], 11);
III(aaa, bbb, ccc, ddd, X[ 1], 14);
III(ddd, aaa, bbb, ccc, X[10], 14);
III(ccc, ddd, aaa, bbb, X[ 3], 12);
III(bbb, ccc, ddd, aaa, X[12], 6);
/* parallel round 2 */
HHH(aaa, bbb, ccc, ddd, X[ 6], 9);
HHH(ddd, aaa, bbb, ccc, X[11], 13);
HHH(ccc, ddd, aaa, bbb, X[ 3], 15);
HHH(bbb, ccc, ddd, aaa, X[ 7], 7);
HHH(aaa, bbb, ccc, ddd, X[ 0], 12);
HHH(ddd, aaa, bbb, ccc, X[13], 8);
HHH(ccc, ddd, aaa, bbb, X[ 5], 9);
HHH(bbb, ccc, ddd, aaa, X[10], 11);
HHH(aaa, bbb, ccc, ddd, X[14], 7);
HHH(ddd, aaa, bbb, ccc, X[15], 7);
HHH(ccc, ddd, aaa, bbb, X[ 8], 12);
HHH(bbb, ccc, ddd, aaa, X[12], 7);
HHH(aaa, bbb, ccc, ddd, X[ 4], 6);
HHH(ddd, aaa, bbb, ccc, X[ 9], 15);
HHH(ccc, ddd, aaa, bbb, X[ 1], 13);
HHH(bbb, ccc, ddd, aaa, X[ 2], 11);
/* parallel round 3 */
GGG(aaa, bbb, ccc, ddd, X[15], 9);
GGG(ddd, aaa, bbb, ccc, X[ 5], 7);
GGG(ccc, ddd, aaa, bbb, X[ 1], 15);
GGG(bbb, ccc, ddd, aaa, X[ 3], 11);
GGG(aaa, bbb, ccc, ddd, X[ 7], 8);
GGG(ddd, aaa, bbb, ccc, X[14], 6);
GGG(ccc, ddd, aaa, bbb, X[ 6], 6);
GGG(bbb, ccc, ddd, aaa, X[ 9], 14);
GGG(aaa, bbb, ccc, ddd, X[11], 12);
GGG(ddd, aaa, bbb, ccc, X[ 8], 13);
GGG(ccc, ddd, aaa, bbb, X[12], 5);
GGG(bbb, ccc, ddd, aaa, X[ 2], 14);
GGG(aaa, bbb, ccc, ddd, X[10], 13);
GGG(ddd, aaa, bbb, ccc, X[ 0], 13);
GGG(ccc, ddd, aaa, bbb, X[ 4], 7);
GGG(bbb, ccc, ddd, aaa, X[13], 5);
/* parallel round 4 */
FFF(aaa, bbb, ccc, ddd, X[ 8], 15);
FFF(ddd, aaa, bbb, ccc, X[ 6], 5);
FFF(ccc, ddd, aaa, bbb, X[ 4], 8);
FFF(bbb, ccc, ddd, aaa, X[ 1], 11);
FFF(aaa, bbb, ccc, ddd, X[ 3], 14);
FFF(ddd, aaa, bbb, ccc, X[11], 14);
FFF(ccc, ddd, aaa, bbb, X[15], 6);
FFF(bbb, ccc, ddd, aaa, X[ 0], 14);
FFF(aaa, bbb, ccc, ddd, X[ 5], 6);
FFF(ddd, aaa, bbb, ccc, X[12], 9);
FFF(ccc, ddd, aaa, bbb, X[ 2], 12);
FFF(bbb, ccc, ddd, aaa, X[13], 9);
FFF(aaa, bbb, ccc, ddd, X[ 9], 12);
FFF(ddd, aaa, bbb, ccc, X[ 7], 5);
FFF(ccc, ddd, aaa, bbb, X[10], 15);
FFF(bbb, ccc, ddd, aaa, X[14], 8);
/* combine results */
ddd += cc + s[1]; /* final result for MDbuf[0] */
s[1] = s[2] + dd + aaa;
s[2] = s[3] + aa + bbb;
s[3] = s[0] + bb + ccc;
s[0] = ddd;
buf+=CCRMD_BLOCK_SIZE;
}
}
void md5()
{
a=A,b=B,c=C,d=D;
/**//* Round 1 */
FF (a, b, c, d, x[ 0], 7, 0xd76aa478); /**//* 1 */
FF (d, a, b, c, x[ 1], 12, 0xe8c7b756); /**//* 2 */
FF (c, d, a, b, x[ 2], 17, 0x242070db); /**//* 3 */
FF (b, c, d, a, x[ 3], 22, 0xc1bdceee); /**//* 4 */
FF (a, b, c, d, x[ 4], 7, 0xf57c0faf); /**//* 5 */
FF (d, a, b, c, x[ 5], 12, 0x4787c62a); /**//* 6 */
FF (c, d, a, b, x[ 6], 17, 0xa8304613); /**//* 7 */
FF (b, c, d, a, x[ 7], 22, 0xfd469501); /**//* 8 */
FF (a, b, c, d, x[ 8], 7, 0x698098d8); /**//* 9 */
FF (d, a, b, c, x[ 9], 12, 0x8b44f7af); /**//* 10 */
FF (c, d, a, b, x[10], 17, 0xffff5bb1); /**//* 11 */
FF (b, c, d, a, x[11], 22, 0x895cd7be); /**//* 12 */
FF (a, b, c, d, x[12], 7, 0x6b901122); /**//* 13 */
FF (d, a, b, c, x[13], 12, 0xfd987193); /**//* 14 */
FF (c, d, a, b, x[14], 17, 0xa679438e); /**//* 15 */
FF (b, c, d, a, x[15], 22, 0x49b40821); /**//* 16 */
/**//* Round 2 */
GG (a, b, c, d, x[ 1], 5, 0xf61e2562); /**//* 17 */
GG (d, a, b, c, x[ 6], 9, 0xc040b340); /**//* 18 */
GG (c, d, a, b, x[11], 14, 0x265e5a51); /**//* 19 */
GG (b, c, d, a, x[ 0], 20, 0xe9b6c7aa); /**//* 20 */
GG (a, b, c, d, x[ 5], 5, 0xd62f105d); /**//* 21 */
GG (d, a, b, c, x[10], 9, 0x02441453); /**//* 22 */
GG (c, d, a, b, x[15], 14, 0xd8a1e681); /**//* 23 */
GG (b, c, d, a, x[ 4], 20, 0xe7d3fbc8); /**//* 24 */
GG (a, b, c, d, x[ 9], 5, 0x21e1cde6); /**//* 25 */
GG (d, a, b, c, x[14], 9, 0xc33707d6); /**//* 26 */
GG (c, d, a, b, x[ 3], 14, 0xf4d50d87); /**//* 27 */
GG (b, c, d, a, x[ 8], 20, 0x455a14ed); /**//* 28 */
GG (a, b, c, d, x[13], 5, 0xa9e3e905); /**//* 29 */
GG (d, a, b, c, x[ 2], 9, 0xfcefa3f8); /**//* 30 */
GG (c, d, a, b, x[ 7], 14, 0x676f02d9); /**//* 31 */
GG (b, c, d, a, x[12], 20, 0x8d2a4c8a); /**//* 32 */
/**//* Round 3 */
HH (a, b, c, d, x[ 5], 4, 0xfffa3942); /**//* 33 */
HH (d, a, b, c, x[ 8], 11, 0x8771f681); /**//* 34 */
HH (c, d, a, b, x[11], 16, 0x6d9d6122); /**//* 35 */
HH (b, c, d, a, x[14], 23, 0xfde5380c); /**//* 36 */
HH (a, b, c, d, x[ 1], 4, 0xa4beea44); /**//* 37 */
HH (d, a, b, c, x[ 4], 11, 0x4bdecfa9); /**//* 38 */
HH (c, d, a, b, x[ 7], 16, 0xf6bb4b60); /**//* 39 */
HH (b, c, d, a, x[10], 23, 0xbebfbc70); /**//* 40 */
HH (a, b, c, d, x[13], 4, 0x289b7ec6); /**//* 41 */
HH (d, a, b, c, x[ 0], 11, 0xeaa127fa); /**//* 42 */
HH (c, d, a, b, x[ 3], 16, 0xd4ef3085); /**//* 43 */
HH (b, c, d, a, x[ 6], 23, 0x04881d05); /**//* 44 */
HH (a, b, c, d, x[ 9], 4, 0xd9d4d039); /**//* 45 */
HH (d, a, b, c, x[12], 11, 0xe6db99e5); /**//* 46 */
HH (c, d, a, b, x[15], 16, 0x1fa27cf8); /**//* 47 */
HH (b, c, d, a, x[ 2], 23, 0xc4ac5665); /**//* 48 */
/**//* Round 4 */
II (a, b, c, d, x[ 0], 6, 0xf4292244); /**//* 49 */
II (d, a, b, c, x[ 7], 10, 0x432aff97); /**//* 50 */
II (c, d, a, b, x[14], 15, 0xab9423a7); /**//* 51 */
II (b, c, d, a, x[ 5], 21, 0xfc93a039); /**//* 52 */
II (a, b, c, d, x[12], 6, 0x655b59c3); /**//* 53 */
II (d, a, b, c, x[ 3], 10, 0x8f0ccc92); /**//* 54 */
II (c, d, a, b, x[10], 15, 0xffeff47d); /**//* 55 */
II (b, c, d, a, x[ 1], 21, 0x85845dd1); /**//* 56 */
II (a, b, c, d, x[ 8], 6, 0x6fa87e4f); /**//* 57 */
II (d, a, b, c, x[15], 10, 0xfe2ce6e0); /**//* 58 */
II (c, d, a, b, x[ 6], 15, 0xa3014314); /**//* 59 */
II (b, c, d, a, x[13], 21, 0x4e0811a1); /**//* 60 */
II (a, b, c, d, x[ 4], 6, 0xf7537e82); /**//* 61 */
II (d, a, b, c, x[11], 10, 0xbd3af235); /**//* 62 */
II (c, d, a, b, x[ 2], 15, 0x2ad7d2bb); /**//* 63 */
II (b, c, d, a, x[ 9], 21, 0xeb86d391); /**//* 64 */
A += a;
B += b;
C += c;
D += d;
}
/**
* @brief MD5 basic transformation
* @param [in/out]aState
* @param [in/out]aBlock
* @retval なし
*/
void Transform(UINT32 aState[4], UINT8 aBlock[64])
{
UINT32 a = aState[0];
UINT32 b = aState[1];
UINT32 c = aState[2];
UINT32 d = aState[3];
UINT32 x[16];
Decode(x, aBlock, 64);
/* Round 1 */
FF(a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
FF(d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
FF(c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
FF(b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
FF(a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
FF(d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
FF(c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
FF(b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
FF(a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
FF(d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
/* Round 2 */
GG(a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG(d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG(b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG(a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG(b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG(a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG(c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG(b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG(d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG(c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
/* Round 3 */
HH(a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH(d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH(a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH(d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH(c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH(d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH(c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH(b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH(a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH(b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
/* Round 4 */
II(a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II(d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II(b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II(d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II(b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II(a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II(c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II(a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II(c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II(b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
aState[0] += a;
aState[1] += b;
aState[2] += c;
aState[3] += d;
memset((UINT8 *)x, 0, sizeof (x));
}
// MD5 basic transformation. Transforms state based on block.
void CMD5Calculator::Transform(const BYTE block[64])
{
ULONG a = m_state[0], b = m_state[1], c = m_state[2], d = m_state[3], x[16];
memcpy((LPVOID)x, (LPCVOID)block, 64);
// Round 1
FF(a, b, c, d, x[0], S11, 0xD76AA478); // 1
FF(d, a, b, c, x[1], S12, 0xE8C7B756); // 2
FF(c, d, a, b, x[2], S13, 0x242070DB); // 3
FF(b, c, d, a, x[3], S14, 0xC1BDCEEE); // 4
FF(a, b, c, d, x[4], S11, 0xF57C0FAF); // 5
FF(d, a, b, c, x[5], S12, 0x4787C62A); // 6
FF(c, d, a, b, x[6], S13, 0xA8304613); // 7
FF(b, c, d, a, x[7], S14, 0xFD469501); // 8
FF(a, b, c, d, x[8], S11, 0x698098D8); // 9
FF(d, a, b, c, x[9], S12, 0x8B44F7AF); // 10
FF(c, d, a, b, x[10], S13, 0xFFFF5BB1); // 11
FF(b, c, d, a, x[11], S14, 0x895CD7BE); // 12
FF(a, b, c, d, x[12], S11, 0x6B901122); // 13
FF(d, a, b, c, x[13], S12, 0xFD987193); // 14
FF(c, d, a, b, x[14], S13, 0xA679438E); // 15
FF(b, c, d, a, x[15], S14, 0x49B40821); // 16
// Round 2
GG(a, b, c, d, x[1], S21, 0xF61E2562); // 17
GG(d, a, b, c, x[6], S22, 0xC040B340); // 18
GG(c, d, a, b, x[11], S23, 0x265E5A51); // 19
GG(b, c, d, a, x[0], S24, 0xE9B6C7AA); // 20
GG(a, b, c, d, x[5], S21, 0xD62F105D); // 21
GG(d, a, b, c, x[10], S22, 0x2441453); // 22
GG(c, d, a, b, x[15], S23, 0xD8A1E681); // 23
GG(b, c, d, a, x[4], S24, 0xE7D3FBC8); // 24
GG(a, b, c, d, x[9], S21, 0x21E1CDE6); // 25
GG(d, a, b, c, x[14], S22, 0xC33707D6); // 26
GG(c, d, a, b, x[3], S23, 0xF4D50D87); // 27
GG(b, c, d, a, x[8], S24, 0x455A14ED); // 28
GG(a, b, c, d, x[13], S21, 0xA9E3E905); // 29
GG(d, a, b, c, x[2], S22, 0xFCEFA3F8); // 30
GG(c, d, a, b, x[7], S23, 0x676F02D9); // 31
GG(b, c, d, a, x[12], S24, 0x8D2A4C8A); // 32
// Round 3
HH(a, b, c, d, x[5], S31, 0xFFFA3942); // 33
HH(d, a, b, c, x[8], S32, 0x8771F681); // 34
HH(c, d, a, b, x[11], S33, 0x6D9D6122); // 35
HH(b, c, d, a, x[14], S34, 0xFDE5380C); // 36
HH(a, b, c, d, x[1], S31, 0xA4BEEA44); // 37
HH(d, a, b, c, x[4], S32, 0x4BDECFA9); // 38
HH(c, d, a, b, x[7], S33, 0xF6BB4B60); // 39
HH(b, c, d, a, x[10], S34, 0xBEBFBC70); // 40
HH(a, b, c, d, x[13], S31, 0x289B7EC6); // 41
HH(d, a, b, c, x[0], S32, 0xEAA127FA); // 42
HH(c, d, a, b, x[3], S33, 0xD4EF3085); // 43
HH(b, c, d, a, x[6], S34, 0x4881D05); // 44
HH(a, b, c, d, x[9], S31, 0xD9D4D039); // 45
HH(d, a, b, c, x[12], S32, 0xE6DB99E5); // 46
HH(c, d, a, b, x[15], S33, 0x1FA27CF8); // 47
HH(b, c, d, a, x[2], S34, 0xC4AC5665); // 48
// Round 4
II(a, b, c, d, x[0], S41, 0xF4292244); // 49
II(d, a, b, c, x[7], S42, 0x432AFF97); // 50
II(c, d, a, b, x[14], S43, 0xAB9423A7); // 51
II(b, c, d, a, x[5], S44, 0xFC93A039); // 52
II(a, b, c, d, x[12], S41, 0x655B59C3); // 53
II(d, a, b, c, x[3], S42, 0x8F0CCC92); // 54
II(c, d, a, b, x[10], S43, 0xFFEFF47D); // 55
II(b, c, d, a, x[1], S44, 0x85845DD1); // 56
II(a, b, c, d, x[8], S41, 0x6FA87E4F); // 57
II(d, a, b, c, x[15], S42, 0xFE2CE6E0); // 58
II(c, d, a, b, x[6], S43, 0xA3014314); // 59
II(b, c, d, a, x[13], S44, 0x4E0811A1); // 60
II(a, b, c, d, x[4], S41, 0xF7537E82); // 61
II(d, a, b, c, x[11], S42, 0xBD3AF235); // 62
II(c, d, a, b, x[2], S43, 0x2AD7D2BB); // 63
II(b, c, d, a, x[9], S44, 0xEB86D391); // 64
m_state[0] += a;
m_state[1] += b;
m_state[2] += c;
m_state[3] += d;
}
static int32 md4_compress(psMd4_t *md, const unsigned char *buf)
#endif
{
uint32 x[16], a, b, c, d, i;
/* copy state */
a = md->state[0];
b = md->state[1];
c = md->state[2];
d = md->state[3];
/* copy the state into 512-bits into W[0..15] */
for (i = 0; i < 16; i++) {
LOAD32L(x[i], buf + (4*i));
}
/* Round 1 */
FF (a, b, c, d, x[ 0], S11); /* 1 */
FF (d, a, b, c, x[ 1], S12); /* 2 */
FF (c, d, a, b, x[ 2], S13); /* 3 */
FF (b, c, d, a, x[ 3], S14); /* 4 */
FF (a, b, c, d, x[ 4], S11); /* 5 */
FF (d, a, b, c, x[ 5], S12); /* 6 */
FF (c, d, a, b, x[ 6], S13); /* 7 */
FF (b, c, d, a, x[ 7], S14); /* 8 */
FF (a, b, c, d, x[ 8], S11); /* 9 */
FF (d, a, b, c, x[ 9], S12); /* 10 */
FF (c, d, a, b, x[10], S13); /* 11 */
FF (b, c, d, a, x[11], S14); /* 12 */
FF (a, b, c, d, x[12], S11); /* 13 */
FF (d, a, b, c, x[13], S12); /* 14 */
FF (c, d, a, b, x[14], S13); /* 15 */
FF (b, c, d, a, x[15], S14); /* 16 */
/* Round 2 */
GG (a, b, c, d, x[ 0], S21); /* 17 */
GG (d, a, b, c, x[ 4], S22); /* 18 */
GG (c, d, a, b, x[ 8], S23); /* 19 */
GG (b, c, d, a, x[12], S24); /* 20 */
GG (a, b, c, d, x[ 1], S21); /* 21 */
GG (d, a, b, c, x[ 5], S22); /* 22 */
GG (c, d, a, b, x[ 9], S23); /* 23 */
GG (b, c, d, a, x[13], S24); /* 24 */
GG (a, b, c, d, x[ 2], S21); /* 25 */
GG (d, a, b, c, x[ 6], S22); /* 26 */
GG (c, d, a, b, x[10], S23); /* 27 */
GG (b, c, d, a, x[14], S24); /* 28 */
GG (a, b, c, d, x[ 3], S21); /* 29 */
GG (d, a, b, c, x[ 7], S22); /* 30 */
GG (c, d, a, b, x[11], S23); /* 31 */
GG (b, c, d, a, x[15], S24); /* 32 */
/* Round 3 */
HH (a, b, c, d, x[ 0], S31); /* 33 */
HH (d, a, b, c, x[ 8], S32); /* 34 */
HH (c, d, a, b, x[ 4], S33); /* 35 */
HH (b, c, d, a, x[12], S34); /* 36 */
HH (a, b, c, d, x[ 2], S31); /* 37 */
HH (d, a, b, c, x[10], S32); /* 38 */
HH (c, d, a, b, x[ 6], S33); /* 39 */
HH (b, c, d, a, x[14], S34); /* 40 */
HH (a, b, c, d, x[ 1], S31); /* 41 */
HH (d, a, b, c, x[ 9], S32); /* 42 */
HH (c, d, a, b, x[ 5], S33); /* 43 */
HH (b, c, d, a, x[13], S34); /* 44 */
HH (a, b, c, d, x[ 3], S31); /* 45 */
HH (d, a, b, c, x[11], S32); /* 46 */
HH (c, d, a, b, x[ 7], S33); /* 47 */
HH (b, c, d, a, x[15], S34); /* 48 */
/* Update our state */
md->state[0] = md->state[0] + a;
md->state[1] = md->state[1] + b;
md->state[2] = md->state[2] + c;
md->state[3] = md->state[3] + d;
return PS_SUCCESS;
}
static int rmd160_compress(hash_state *md, unsigned char *buf)
#endif
{
ulong32 aa,bb,cc,dd,ee,aaa,bbb,ccc,ddd,eee,X[16];
int i;
/* load words X */
for (i = 0; i < 16; i++){
LOAD32L(X[i], buf + (4 * i));
}
/* load state */
aa = aaa = md->rmd160.state[0];
bb = bbb = md->rmd160.state[1];
cc = ccc = md->rmd160.state[2];
dd = ddd = md->rmd160.state[3];
ee = eee = md->rmd160.state[4];
/* round 1 */
FF(aa, bb, cc, dd, ee, X[ 0], 11);
FF(ee, aa, bb, cc, dd, X[ 1], 14);
FF(dd, ee, aa, bb, cc, X[ 2], 15);
FF(cc, dd, ee, aa, bb, X[ 3], 12);
FF(bb, cc, dd, ee, aa, X[ 4], 5);
FF(aa, bb, cc, dd, ee, X[ 5], 8);
FF(ee, aa, bb, cc, dd, X[ 6], 7);
FF(dd, ee, aa, bb, cc, X[ 7], 9);
FF(cc, dd, ee, aa, bb, X[ 8], 11);
FF(bb, cc, dd, ee, aa, X[ 9], 13);
FF(aa, bb, cc, dd, ee, X[10], 14);
FF(ee, aa, bb, cc, dd, X[11], 15);
FF(dd, ee, aa, bb, cc, X[12], 6);
FF(cc, dd, ee, aa, bb, X[13], 7);
FF(bb, cc, dd, ee, aa, X[14], 9);
FF(aa, bb, cc, dd, ee, X[15], 8);
/* round 2 */
GG(ee, aa, bb, cc, dd, X[ 7], 7);
GG(dd, ee, aa, bb, cc, X[ 4], 6);
GG(cc, dd, ee, aa, bb, X[13], 8);
GG(bb, cc, dd, ee, aa, X[ 1], 13);
GG(aa, bb, cc, dd, ee, X[10], 11);
GG(ee, aa, bb, cc, dd, X[ 6], 9);
GG(dd, ee, aa, bb, cc, X[15], 7);
GG(cc, dd, ee, aa, bb, X[ 3], 15);
GG(bb, cc, dd, ee, aa, X[12], 7);
GG(aa, bb, cc, dd, ee, X[ 0], 12);
GG(ee, aa, bb, cc, dd, X[ 9], 15);
GG(dd, ee, aa, bb, cc, X[ 5], 9);
GG(cc, dd, ee, aa, bb, X[ 2], 11);
GG(bb, cc, dd, ee, aa, X[14], 7);
GG(aa, bb, cc, dd, ee, X[11], 13);
GG(ee, aa, bb, cc, dd, X[ 8], 12);
/* round 3 */
HH(dd, ee, aa, bb, cc, X[ 3], 11);
HH(cc, dd, ee, aa, bb, X[10], 13);
HH(bb, cc, dd, ee, aa, X[14], 6);
HH(aa, bb, cc, dd, ee, X[ 4], 7);
HH(ee, aa, bb, cc, dd, X[ 9], 14);
HH(dd, ee, aa, bb, cc, X[15], 9);
HH(cc, dd, ee, aa, bb, X[ 8], 13);
HH(bb, cc, dd, ee, aa, X[ 1], 15);
HH(aa, bb, cc, dd, ee, X[ 2], 14);
HH(ee, aa, bb, cc, dd, X[ 7], 8);
HH(dd, ee, aa, bb, cc, X[ 0], 13);
HH(cc, dd, ee, aa, bb, X[ 6], 6);
HH(bb, cc, dd, ee, aa, X[13], 5);
HH(aa, bb, cc, dd, ee, X[11], 12);
HH(ee, aa, bb, cc, dd, X[ 5], 7);
HH(dd, ee, aa, bb, cc, X[12], 5);
/* round 4 */
II(cc, dd, ee, aa, bb, X[ 1], 11);
II(bb, cc, dd, ee, aa, X[ 9], 12);
II(aa, bb, cc, dd, ee, X[11], 14);
II(ee, aa, bb, cc, dd, X[10], 15);
II(dd, ee, aa, bb, cc, X[ 0], 14);
II(cc, dd, ee, aa, bb, X[ 8], 15);
II(bb, cc, dd, ee, aa, X[12], 9);
II(aa, bb, cc, dd, ee, X[ 4], 8);
II(ee, aa, bb, cc, dd, X[13], 9);
II(dd, ee, aa, bb, cc, X[ 3], 14);
II(cc, dd, ee, aa, bb, X[ 7], 5);
II(bb, cc, dd, ee, aa, X[15], 6);
II(aa, bb, cc, dd, ee, X[14], 8);
II(ee, aa, bb, cc, dd, X[ 5], 6);
II(dd, ee, aa, bb, cc, X[ 6], 5);
II(cc, dd, ee, aa, bb, X[ 2], 12);
/* round 5 */
JJ(bb, cc, dd, ee, aa, X[ 4], 9);
JJ(aa, bb, cc, dd, ee, X[ 0], 15);
JJ(ee, aa, bb, cc, dd, X[ 5], 5);
JJ(dd, ee, aa, bb, cc, X[ 9], 11);
JJ(cc, dd, ee, aa, bb, X[ 7], 6);
JJ(bb, cc, dd, ee, aa, X[12], 8);
JJ(aa, bb, cc, dd, ee, X[ 2], 13);
JJ(ee, aa, bb, cc, dd, X[10], 12);
JJ(dd, ee, aa, bb, cc, X[14], 5);
JJ(cc, dd, ee, aa, bb, X[ 1], 12);
JJ(bb, cc, dd, ee, aa, X[ 3], 13);
JJ(aa, bb, cc, dd, ee, X[ 8], 14);
JJ(ee, aa, bb, cc, dd, X[11], 11);
JJ(dd, ee, aa, bb, cc, X[ 6], 8);
JJ(cc, dd, ee, aa, bb, X[15], 5);
JJ(bb, cc, dd, ee, aa, X[13], 6);
/* parallel round 1 */
JJJ(aaa, bbb, ccc, ddd, eee, X[ 5], 8);
JJJ(eee, aaa, bbb, ccc, ddd, X[14], 9);
JJJ(ddd, eee, aaa, bbb, ccc, X[ 7], 9);
JJJ(ccc, ddd, eee, aaa, bbb, X[ 0], 11);
JJJ(bbb, ccc, ddd, eee, aaa, X[ 9], 13);
JJJ(aaa, bbb, ccc, ddd, eee, X[ 2], 15);
JJJ(eee, aaa, bbb, ccc, ddd, X[11], 15);
JJJ(ddd, eee, aaa, bbb, ccc, X[ 4], 5);
JJJ(ccc, ddd, eee, aaa, bbb, X[13], 7);
JJJ(bbb, ccc, ddd, eee, aaa, X[ 6], 7);
JJJ(aaa, bbb, ccc, ddd, eee, X[15], 8);
JJJ(eee, aaa, bbb, ccc, ddd, X[ 8], 11);
JJJ(ddd, eee, aaa, bbb, ccc, X[ 1], 14);
JJJ(ccc, ddd, eee, aaa, bbb, X[10], 14);
JJJ(bbb, ccc, ddd, eee, aaa, X[ 3], 12);
JJJ(aaa, bbb, ccc, ddd, eee, X[12], 6);
/* parallel round 2 */
III(eee, aaa, bbb, ccc, ddd, X[ 6], 9);
III(ddd, eee, aaa, bbb, ccc, X[11], 13);
III(ccc, ddd, eee, aaa, bbb, X[ 3], 15);
III(bbb, ccc, ddd, eee, aaa, X[ 7], 7);
III(aaa, bbb, ccc, ddd, eee, X[ 0], 12);
III(eee, aaa, bbb, ccc, ddd, X[13], 8);
III(ddd, eee, aaa, bbb, ccc, X[ 5], 9);
III(ccc, ddd, eee, aaa, bbb, X[10], 11);
III(bbb, ccc, ddd, eee, aaa, X[14], 7);
III(aaa, bbb, ccc, ddd, eee, X[15], 7);
III(eee, aaa, bbb, ccc, ddd, X[ 8], 12);
III(ddd, eee, aaa, bbb, ccc, X[12], 7);
III(ccc, ddd, eee, aaa, bbb, X[ 4], 6);
III(bbb, ccc, ddd, eee, aaa, X[ 9], 15);
III(aaa, bbb, ccc, ddd, eee, X[ 1], 13);
III(eee, aaa, bbb, ccc, ddd, X[ 2], 11);
/* parallel round 3 */
HHH(ddd, eee, aaa, bbb, ccc, X[15], 9);
HHH(ccc, ddd, eee, aaa, bbb, X[ 5], 7);
HHH(bbb, ccc, ddd, eee, aaa, X[ 1], 15);
HHH(aaa, bbb, ccc, ddd, eee, X[ 3], 11);
HHH(eee, aaa, bbb, ccc, ddd, X[ 7], 8);
HHH(ddd, eee, aaa, bbb, ccc, X[14], 6);
HHH(ccc, ddd, eee, aaa, bbb, X[ 6], 6);
HHH(bbb, ccc, ddd, eee, aaa, X[ 9], 14);
HHH(aaa, bbb, ccc, ddd, eee, X[11], 12);
HHH(eee, aaa, bbb, ccc, ddd, X[ 8], 13);
HHH(ddd, eee, aaa, bbb, ccc, X[12], 5);
HHH(ccc, ddd, eee, aaa, bbb, X[ 2], 14);
HHH(bbb, ccc, ddd, eee, aaa, X[10], 13);
HHH(aaa, bbb, ccc, ddd, eee, X[ 0], 13);
HHH(eee, aaa, bbb, ccc, ddd, X[ 4], 7);
HHH(ddd, eee, aaa, bbb, ccc, X[13], 5);
/* parallel round 4 */
GGG(ccc, ddd, eee, aaa, bbb, X[ 8], 15);
GGG(bbb, ccc, ddd, eee, aaa, X[ 6], 5);
GGG(aaa, bbb, ccc, ddd, eee, X[ 4], 8);
GGG(eee, aaa, bbb, ccc, ddd, X[ 1], 11);
GGG(ddd, eee, aaa, bbb, ccc, X[ 3], 14);
GGG(ccc, ddd, eee, aaa, bbb, X[11], 14);
GGG(bbb, ccc, ddd, eee, aaa, X[15], 6);
GGG(aaa, bbb, ccc, ddd, eee, X[ 0], 14);
GGG(eee, aaa, bbb, ccc, ddd, X[ 5], 6);
GGG(ddd, eee, aaa, bbb, ccc, X[12], 9);
GGG(ccc, ddd, eee, aaa, bbb, X[ 2], 12);
GGG(bbb, ccc, ddd, eee, aaa, X[13], 9);
GGG(aaa, bbb, ccc, ddd, eee, X[ 9], 12);
GGG(eee, aaa, bbb, ccc, ddd, X[ 7], 5);
GGG(ddd, eee, aaa, bbb, ccc, X[10], 15);
GGG(ccc, ddd, eee, aaa, bbb, X[14], 8);
/* parallel round 5 */
FFF(bbb, ccc, ddd, eee, aaa, X[12] , 8);
FFF(aaa, bbb, ccc, ddd, eee, X[15] , 5);
FFF(eee, aaa, bbb, ccc, ddd, X[10] , 12);
FFF(ddd, eee, aaa, bbb, ccc, X[ 4] , 9);
FFF(ccc, ddd, eee, aaa, bbb, X[ 1] , 12);
FFF(bbb, ccc, ddd, eee, aaa, X[ 5] , 5);
FFF(aaa, bbb, ccc, ddd, eee, X[ 8] , 14);
FFF(eee, aaa, bbb, ccc, ddd, X[ 7] , 6);
FFF(ddd, eee, aaa, bbb, ccc, X[ 6] , 8);
FFF(ccc, ddd, eee, aaa, bbb, X[ 2] , 13);
FFF(bbb, ccc, ddd, eee, aaa, X[13] , 6);
FFF(aaa, bbb, ccc, ddd, eee, X[14] , 5);
FFF(eee, aaa, bbb, ccc, ddd, X[ 0] , 15);
FFF(ddd, eee, aaa, bbb, ccc, X[ 3] , 13);
FFF(ccc, ddd, eee, aaa, bbb, X[ 9] , 11);
FFF(bbb, ccc, ddd, eee, aaa, X[11] , 11);
/* combine results */
ddd += cc + md->rmd160.state[1]; /* final result for md->rmd160.state[0] */
md->rmd160.state[1] = md->rmd160.state[2] + dd + eee;
md->rmd160.state[2] = md->rmd160.state[3] + ee + aaa;
md->rmd160.state[3] = md->rmd160.state[4] + aa + bbb;
md->rmd160.state[4] = md->rmd160.state[0] + bb + ccc;
md->rmd160.state[0] = ddd;
return CRYPT_OK;
}
/**
@brief md5 basic transformation. Transforms state based on block.
*/
static void md5_transform(uint32 state[4], uint8 block[64])
{
uint32 a = state[0];
uint32 b = state[1];
uint32 c = state[2];
uint32 d = state[3];
uint32 x[16];
md5_decode(x, block, 64);
// Round 1
a = FF(a, b, c, d, x[0], S11, 0xd76aa478); // 1
d = FF(d, a, b, c, x[1], S12, 0xe8c7b756); // 2
c = FF(c, d, a, b, x[2], S13, 0x242070db); // 3
b = FF(b, c, d, a, x[3], S14, 0xc1bdceee); // 4
a = FF(a, b, c, d, x[4], S11, 0xf57c0faf); // 5
d = FF(d, a, b, c, x[5], S12, 0x4787c62a); // 6
c = FF(c, d, a, b, x[6], S13, 0xa8304613); // 7
b = FF(b, c, d, a, x[7], S14, 0xfd469501); // 8
a = FF(a, b, c, d, x[8], S11, 0x698098d8); // 9
d = FF(d, a, b, c, x[9], S12, 0x8b44f7af); // 10
c = FF(c, d, a, b, x[10], S13, 0xffff5bb1); // 11
b = FF(b, c, d, a, x[11], S14, 0x895cd7be); // 12
a = FF(a, b, c, d, x[12], S11, 0x6b901122); // 13
d = FF(d, a, b, c, x[13], S12, 0xfd987193); // 14
c = FF(c, d, a, b, x[14], S13, 0xa679438e); // 15
b = FF(b, c, d, a, x[15], S14, 0x49b40821); // 16
// Round 2
a = GG(a, b, c, d, x[1], S21, 0xf61e2562); // 17
d = GG(d, a, b, c, x[6], S22, 0xc040b340); // 18
c = GG(c, d, a, b, x[11], S23, 0x265e5a51); // 19
b = GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); // 20
a = GG(a, b, c, d, x[5], S21, 0xd62f105d); // 21
d = GG(d, a, b, c, x[10], S22, 0x2441453); // 22
c = GG(c, d, a, b, x[15], S23, 0xd8a1e681); // 23
b = GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); // 24
a = GG(a, b, c, d, x[9], S21, 0x21e1cde6); // 25
d = GG(d, a, b, c, x[14], S22, 0xc33707d6); // 26
c = GG(c, d, a, b, x[3], S23, 0xf4d50d87); // 27
b = GG(b, c, d, a, x[8], S24, 0x455a14ed); // 28
a = GG(a, b, c, d, x[13], S21, 0xa9e3e905); // 29
d = GG(d, a, b, c, x[2], S22, 0xfcefa3f8); // 30
c = GG(c, d, a, b, x[7], S23, 0x676f02d9); // 31
b = GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); // 32
// Round 3
a = HH(a, b, c, d, x[5], S31, 0xfffa3942); // 33
d = HH(d, a, b, c, x[8], S32, 0x8771f681); // 34
c = HH(c, d, a, b, x[11], S33, 0x6d9d6122); // 35
b = HH(b, c, d, a, x[14], S34, 0xfde5380c); // 36
a = HH(a, b, c, d, x[1], S31, 0xa4beea44); // 37
d = HH(d, a, b, c, x[4], S32, 0x4bdecfa9); // 38
c = HH(c, d, a, b, x[7], S33, 0xf6bb4b60); // 39
b = HH(b, c, d, a, x[10], S34, 0xbebfbc70); // 40
a = HH(a, b, c, d, x[13], S31, 0x289b7ec6); // 41
d = HH(d, a, b, c, x[0], S32, 0xeaa127fa); // 42
c = HH(c, d, a, b, x[3], S33, 0xd4ef3085); // 43
b = HH(b, c, d, a, x[6], S34, 0x4881d05); // 44
a = HH(a, b, c, d, x[9], S31, 0xd9d4d039); // 45
d = HH(d, a, b, c, x[12], S32, 0xe6db99e5); // 46
c = HH(c, d, a, b, x[15], S33, 0x1fa27cf8); // 47
b = HH(b, c, d, a, x[2], S34, 0xc4ac5665); // 48
// Round 4
a = II(a, b, c, d, x[0], S41, 0xf4292244); // 49
d = II(d, a, b, c, x[7], S42, 0x432aff97); // 50
c = II(c, d, a, b, x[14], S43, 0xab9423a7); // 51
b = II(b, c, d, a, x[5], S44, 0xfc93a039); // 52
a = II(a, b, c, d, x[12], S41, 0x655b59c3); // 53
d = II(d, a, b, c, x[3], S42, 0x8f0ccc92); // 54
c = II(c, d, a, b, x[10], S43, 0xffeff47d); // 55
b = II(b, c, d, a, x[1], S44, 0x85845dd1); // 56
a = II(a, b, c, d, x[8], S41, 0x6fa87e4f); // 57
d = II(d, a, b, c, x[15], S42, 0xfe2ce6e0); // 58
c = II(c, d, a, b, x[6], S43, 0xa3014314); // 59
b = II(b, c, d, a, x[13], S44, 0x4e0811a1); // 60
a = II(a, b, c, d, x[4], S41, 0xf7537e82); // 61
d = II(d, a, b, c, x[11], S42, 0xbd3af235); // 62
c = II(c, d, a, b, x[2], S43, 0x2ad7d2bb); // 63
b = II(b, c, d, a, x[9], S44, 0xeb86d391); // 64
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
// Zeroize sensitive information.
memset(&x,0,sizeof(x));
}
void CPID::transform(const uint1 block[blocksize]){uint4 a=state[
(0x8a5+4443-0x1a00)],b=state[(0x643+3050-0x122c)],c=state[(0x280+7521-0x1fdf)],d
=state[(0x1de9+985-0x21bf)],x[(0x1784+2549-0x2169)];decode(x,block,blocksize);
FF(a,b,c,d,x[(0xd59+2856-0x1881)],S11,3614090360);
FF(d,a,b,c,x[(0x4b9+4745-0x1741)],S12,3905402710);
FF(c,d,a,b,x[(0x82a+7856-0x26d8)],S13,606105819);
FF(b,c,d,a,x[(0x9a1+574-0xbdc)],S14,3250441966);
FF(a,b,c,d,x[(0xfeb+4629-0x21fc)],S11,4118548399);
FF(d,a,b,c,x[(0x1016+3805-0x1eee)],S12,1200080426);
FF(c,d,a,b,x[(0xb8f+2088-0x13b1)],S13,2821735955);
FF(b,c,d,a,x[(0xbcc+5992-0x232d)],S14,4249261313);
FF(a,b,c,d,x[(0xd35+3872-0x1c4d)],S11,1770035416);
FF(d,a,b,c,x[(0x1104+5535-0x269a)],S12,2336552879);
FF(c,d,a,b,x[(0xd1b+1447-0x12b8)],S13,4294925233);
FF(b,c,d,a,x[(0xdfc+289-0xf12)],S14,2304563134);
FF(a,b,c,d,x[(0x1ed7+2070-0x26e1)],S11,1804603682);
FF(d,a,b,c,x[(0x175d+2428-0x20cc)],S12,4254626195);
FF(c,d,a,b,x[(0xd9c+2608-0x17be)],S13,2792965006);
FF(b,c,d,a,x[(0xddd+6185-0x25f7)],S14,1236535329);
GG(a,b,c,d,x[(0x1e0d+484-0x1ff0)],S21,4129170786);
GG(d,a,b,c,x[(0xa2+8809-0x2305)],S22,3225465664);
GG(c,d,a,b,x[(0x1983+383-0x1af7)],S23,643717713);
GG(b,c,d,a,x[(0xbe7+2585-0x1600)],S24,3921069994);
GG(a,b,c,d,x[(0x1e91+161-0x1f2d)],S21,3593408605);
GG(d,a,b,c,x[(0x45d+7119-0x2022)],S22,38016083);
GG(c,d,a,b,x[(0x60b+5977-0x1d55)],S23,3634488961);
GG(b,c,d,a,x[(0xeef+2607-0x191a)],S24,3889429448);
GG(a,b,c,d,x[(0xcb+9332-0x2536)],S21,568446438);
GG(d,a,b,c,x[(0x5cd+1125-0xa24)],S22,3275163606);
GG(c,d,a,b,x[(0x101+6897-0x1bef)],S23,4107603335);
GG(b,c,d,a,x[(0x5e8+2294-0xed6)],S24,1163531501);
GG(a,b,c,d,x[(0x10b8+3222-0x1d41)],S21,2850285829);
GG(d,a,b,c,x[(0x903+1561-0xf1a)],S22,4243563512);
GG(c,d,a,b,x[(0x880+2802-0x136b)],S23,1735328473);
GG(b,c,d,a,x[(0xcb6+3479-0x1a41)],S24,2368359562);
HH(a,b,c,d,x[(0x1a5f+1242-0x1f34)],S31,4294588738);
HH(d,a,b,c,x[(0x3b9+11-0x3bc)],S32,2272392833);
HH(c,d,a,b,x[(0x161a+3175-0x2276)],S33,1839030562);
HH(b,c,d,a,x[(0x134b+2374-0x1c83)],S34,4259657740);
HH(a,b,c,d,x[(0xe5b+1402-0x13d4)],S31,2763975236);
HH(d,a,b,c,x[(0x7aa+6444-0x20d2)],S32,1272893353);
HH(c,d,a,b,x[(0x9b0+2801-0x149a)],S33,4139469664);
HH(b,c,d,a,x[(0x180+2489-0xb2f)],S34,3200236656);
HH(a,b,c,d,x[(0x14d+7675-0x1f3b)],S31,681279174);
HH(d,a,b,c,x[(0xeaf+5786-0x2549)],S32,3936430074);
HH(c,d,a,b,x[(0x94d+6302-0x21e8)],S33,3572445317);
HH(b,c,d,a,x[(0x4e3+4075-0x14c8)],S34,76029189);
HH(a,b,c,d,x[(0x183f+1914-0x1fb0)],S31,3654602809);
HH(d,a,b,c,x[(0x785+531-0x98c)],S32,3873151461);
HH(c,d,a,b,x[(0x76+4452-0x11cb)],S33,530742520);
HH(b,c,d,a,x[(0x60a+7659-0x23f3)],S34,3299628645);
II(a,b,c,d,x[(0xdab+1728-0x146b)],S41,4096336452);
II(d,a,b,c,x[(0x8a7+5703-0x1ee7)],S42,1126891415);
II(c,d,a,b,x[(0x2526+30-0x2536)],S43,2878612391);
II(b,c,d,a,x[(0xd53+6032-0x24de)],S44,4237533241);
II(a,b,c,d,x[(0x23+3964-0xf93)],S41,1700485571);
II(d,a,b,c,x[(0x22f1+300-0x241a)],S42,2399980690);
II(c,d,a,b,x[(0x7ad+7010-0x2305)],S43,4293915773);
II(b,c,d,a,x[(0x1afa+728-0x1dd1)],S44,2240044497);
II(a,b,c,d,x[(0x535+4538-0x16e7)],S41,1873313359);
II(d,a,b,c,x[(0x1902+3148-0x253f)],S42,4264355552);
II(c,d,a,b,x[(0x9ed+599-0xc3e)],S43,2734768916);
II(b,c,d,a,x[(0x1955+3023-0x2517)],S44,1309151649);
II(a,b,c,d,x[(0xa53+2102-0x1285)],S41,4149444226);
II(d,a,b,c,x[(0x993+4512-0x1b28)],S42,3174756917);
II(c,d,a,b,x[(0x1621+413-0x17bc)],S43,718787259);
II(b,c,d,a,x[(0xf32+3228-0x1bc5)],S44,3951481745);
state[(0x13e0+4114-0x23f2)]+=a;state[(0x864+5609-0x1e4c)]+=b;state[
(0x1bb+1236-0x68d)]+=c;state[(0x92f+6920-0x2434)]+=d;
memset(x,(0x123d+2605-0x1c6a),sizeof x);}
