Subversion Repositories openrisc

// 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

// table[i] = int((1<<32) * abs(sin(i+1 radians))).

var table = []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}

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

                j := 0

                for i := 0; i < 16; i++ {

                        X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24

                        j += 4

                }

                // 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).

                //

                // The index variables are uint so that % by a power

                // of two can be optimized easily by a compiler.

                // Round 1.

                for i := uint(0); i < 16; i++ {

                        x := i

                        s := shift1[i%4]

                        f := ((c ^ d) & b) ^ d

                        a += f + X[x] + table[i]

                        a = a<>(32-s) + b

                        a, b, c, d = d, a, b, c

                }

                // Round 2.

                for i := uint(0); i < 16; i++ {

                        x := (1 + 5*i) % 16

                        s := shift2[i%4]

                        g := ((b ^ c) & d) ^ c

                        a += g + X[x] + table[i+16]

                        a = a<>(32-s) + b

                        a, b, c, d = d, a, b, c

                }

                // Round 3.

                for i := uint(0); i < 16; i++ {

                        x := (5 + 3*i) % 16

                        s := shift3[i%4]

                        h := b ^ c ^ d

                        a += h + X[x] + table[i+32]

                        a = a<>(32-s) + b

                        a, b, c, d = d, a, b, c

                }

                // Round 4.

                for i := uint(0); i < 16; i++ {

                        x := (7 * i) % 16

                        s := shift4[i%4]

                        j := c ^ (b | ^d)

                        a += j + X[x] + table[i+48]

                        a = a<>(32-s) + b

                        a, b, c, d = d, a, b, c

                }

                a += aa

                b += bb

                c += cc

                d += dd

                p = p[_Chunk:]

                n += _Chunk

        }

        dig.s[0] = a

        dig.s[1] = b

        dig.s[2] = c

        dig.s[3] = d

        return n

}