--- /dev/null
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// MD5 block step.
+// In its own file so that a faster assembly or C version
+// can be substituted easily.
+
+package md5
+
+import "md5"
+
+// T[i] = int((1<<32) * abs(sin(i+1 radians))).
+var T = []uint32 {
+ // round 1
+ 0xd76aa478,
+ 0xe8c7b756,
+ 0x242070db,
+ 0xc1bdceee,
+ 0xf57c0faf,
+ 0x4787c62a,
+ 0xa8304613,
+ 0xfd469501,
+ 0x698098d8,
+ 0x8b44f7af,
+ 0xffff5bb1,
+ 0x895cd7be,
+ 0x6b901122,
+ 0xfd987193,
+ 0xa679438e,
+ 0x49b40821,
+
+ // round 2
+ 0xf61e2562,
+ 0xc040b340,
+ 0x265e5a51,
+ 0xe9b6c7aa,
+ 0xd62f105d,
+ 0x2441453,
+ 0xd8a1e681,
+ 0xe7d3fbc8,
+ 0x21e1cde6,
+ 0xc33707d6,
+ 0xf4d50d87,
+ 0x455a14ed,
+ 0xa9e3e905,
+ 0xfcefa3f8,
+ 0x676f02d9,
+ 0x8d2a4c8a,
+
+ // round3
+ 0xfffa3942,
+ 0x8771f681,
+ 0x6d9d6122,
+ 0xfde5380c,
+ 0xa4beea44,
+ 0x4bdecfa9,
+ 0xf6bb4b60,
+ 0xbebfbc70,
+ 0x289b7ec6,
+ 0xeaa127fa,
+ 0xd4ef3085,
+ 0x4881d05,
+ 0xd9d4d039,
+ 0xe6db99e5,
+ 0x1fa27cf8,
+ 0xc4ac5665,
+
+ // round 4
+ 0xf4292244,
+ 0x432aff97,
+ 0xab9423a7,
+ 0xfc93a039,
+ 0x655b59c3,
+ 0x8f0ccc92,
+ 0xffeff47d,
+ 0x85845dd1,
+ 0x6fa87e4f,
+ 0xfe2ce6e0,
+ 0xa3014314,
+ 0x4e0811a1,
+ 0xf7537e82,
+ 0xbd3af235,
+ 0x2ad7d2bb,
+ 0xeb86d391,
+}
+
+var shift1 = []uint { 7, 12, 17, 22 };
+var shift2 = []uint { 5, 9, 14, 20 };
+var shift3 = []uint { 4, 11, 16, 23 };
+var shift4 = []uint { 6, 10, 15, 21 };
+
+package func Block(dig *Digest, p *[]byte) int {
+ a := dig.s[0];
+ b := dig.s[1];
+ c := dig.s[2];
+ d := dig.s[3];
+ n := 0;
+ var X [16]uint32;
+ for len(p) >= Chunk {
+ aa, bb, cc, dd := a, b, c, d;
+
+ for i := 0; i < 16; i++ {
+ j := i*4;
+ X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24;
+ }
+
+ // If this needs to be made faster in the future,
+ // the usual trick is to unroll each of these
+ // loops by a factor of 4; that lets you replace
+ // the shift[] lookups with constants and,
+ // with suitable variable renaming in each
+ // unrolled body, delete the a, b, c, d = d, a, b, c
+ // (or you can let the optimizer do the renaming).
+
+ // Round 1.
+ for i := 0; i < 16; i++ {
+ x := i;
+ t := i;
+ s := shift1[i%4];
+ f := ((c ^ d) & b) ^ d;
+ a += f + X[x] + T[t];
+ a = a<<s | a>>(32-s);
+ a += b;
+ a, b, c, d = d, a, b, c;
+ }
+
+ // Round 2.
+ for i := 0; i < 16; i++ {
+ x := (1+5*i)%16;
+ t := 16+i;
+ s := shift2[i%4];
+ g := ((b ^ c) & d) ^ c;
+ a += g + X[x] + T[t];
+ a = a<<s | a>>(32-s);
+ a += b;
+ a, b, c, d = d, a, b, c;
+ }
+
+ // Round 3.
+ for i := 0; i < 16; i++ {
+ x := (5+3*i)%16;
+ t := 32+i;
+ s := shift3[i%4];
+ h := b ^ c ^ d;
+ a += h + X[x] + T[t];
+ a = a<<s | a>>(32-s);
+ a += b;
+ a, b, c, d = d, a, b, c;
+ }
+
+ // Round 4.
+ for i := 0; i < 16; i++ {
+ x := (7*i)%16;
+ s := shift4[i%4];
+ t := 48+i;
+ ii := c ^ (b | ^d);
+ a += ii + X[x] + T[t];
+ a = a<<s | a>>(32-s);
+ a += b;
+ a, b, c, d = d, a, b, c;
+ }
+
+ a += aa;
+ b += bb;
+ c += cc;
+ d += dd;
+
+ p = p[Chunk:len(p)];
+ n += Chunk;
+ }
+
+ dig.s[0] = a;
+ dig.s[1] = b;
+ dig.s[2] = c;
+ dig.s[3] = d;
+ return n;
+}