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);}