~ubuntu-branches/ubuntu/utopic/golang/utopic

« back to all changes in this revision

Viewing changes to src/pkg/crypto/md5/md5block.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
// Copyright 2009 The Go Authors. All rights reserved.
2
 
// Use of this source code is governed by a BSD-style
3
 
// license that can be found in the LICENSE file.
 
1
// DO NOT EDIT.
 
2
// Generate with: go run gen.go -full | gofmt >md5block.go
4
3
 
5
 
// MD5 block step.
6
 
// In its own file so that a faster assembly or C version
7
 
// can be substituted easily.
 
4
// +build !amd64,!386
8
5
 
9
6
package md5
10
7
 
11
 
// table[i] = int((1<<32) * abs(sin(i+1 radians))).
12
 
var table = []uint32{
13
 
        // round 1
14
 
        0xd76aa478,
15
 
        0xe8c7b756,
16
 
        0x242070db,
17
 
        0xc1bdceee,
18
 
        0xf57c0faf,
19
 
        0x4787c62a,
20
 
        0xa8304613,
21
 
        0xfd469501,
22
 
        0x698098d8,
23
 
        0x8b44f7af,
24
 
        0xffff5bb1,
25
 
        0x895cd7be,
26
 
        0x6b901122,
27
 
        0xfd987193,
28
 
        0xa679438e,
29
 
        0x49b40821,
30
 
 
31
 
        // round 2
32
 
        0xf61e2562,
33
 
        0xc040b340,
34
 
        0x265e5a51,
35
 
        0xe9b6c7aa,
36
 
        0xd62f105d,
37
 
        0x2441453,
38
 
        0xd8a1e681,
39
 
        0xe7d3fbc8,
40
 
        0x21e1cde6,
41
 
        0xc33707d6,
42
 
        0xf4d50d87,
43
 
        0x455a14ed,
44
 
        0xa9e3e905,
45
 
        0xfcefa3f8,
46
 
        0x676f02d9,
47
 
        0x8d2a4c8a,
48
 
 
49
 
        // round3
50
 
        0xfffa3942,
51
 
        0x8771f681,
52
 
        0x6d9d6122,
53
 
        0xfde5380c,
54
 
        0xa4beea44,
55
 
        0x4bdecfa9,
56
 
        0xf6bb4b60,
57
 
        0xbebfbc70,
58
 
        0x289b7ec6,
59
 
        0xeaa127fa,
60
 
        0xd4ef3085,
61
 
        0x4881d05,
62
 
        0xd9d4d039,
63
 
        0xe6db99e5,
64
 
        0x1fa27cf8,
65
 
        0xc4ac5665,
66
 
 
67
 
        // round 4
68
 
        0xf4292244,
69
 
        0x432aff97,
70
 
        0xab9423a7,
71
 
        0xfc93a039,
72
 
        0x655b59c3,
73
 
        0x8f0ccc92,
74
 
        0xffeff47d,
75
 
        0x85845dd1,
76
 
        0x6fa87e4f,
77
 
        0xfe2ce6e0,
78
 
        0xa3014314,
79
 
        0x4e0811a1,
80
 
        0xf7537e82,
81
 
        0xbd3af235,
82
 
        0x2ad7d2bb,
83
 
        0xeb86d391,
 
8
import (
 
9
        "runtime"
 
10
        "unsafe"
 
11
)
 
12
 
 
13
const x86 = runtime.GOARCH == "amd64" || runtime.GOARCH == "386"
 
14
 
 
15
var littleEndian bool
 
16
 
 
17
func init() {
 
18
        x := uint32(0x04030201)
 
19
        y := [4]byte{0x1, 0x2, 0x3, 0x4}
 
20
        littleEndian = *(*[4]byte)(unsafe.Pointer(&x)) == y
84
21
}
85
22
 
86
 
var shift1 = []uint{7, 12, 17, 22}
87
 
var shift2 = []uint{5, 9, 14, 20}
88
 
var shift3 = []uint{4, 11, 16, 23}
89
 
var shift4 = []uint{6, 10, 15, 21}
90
 
 
91
 
func _Block(dig *digest, p []byte) int {
 
23
func block(dig *digest, p []byte) {
92
24
        a := dig.s[0]
93
25
        b := dig.s[1]
94
26
        c := dig.s[2]
95
27
        d := dig.s[3]
96
 
        n := 0
97
 
        var X [16]uint32
98
 
        for len(p) >= _Chunk {
 
28
        var X *[16]uint32
 
29
        var xbuf [16]uint32
 
30
        for len(p) >= chunk {
99
31
                aa, bb, cc, dd := a, b, c, d
100
32
 
101
 
                j := 0
102
 
                for i := 0; i < 16; i++ {
103
 
                        X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24
104
 
                        j += 4
 
33
                // This is a constant condition - it is not evaluated on each iteration.
 
34
                if x86 {
 
35
                        // MD5 was designed so that x86 processors can just iterate
 
36
                        // over the block data directly as uint32s, and we generate
 
37
                        // less code and run 1.3x faster if we take advantage of that.
 
38
                        // My apologies.
 
39
                        X = (*[16]uint32)(unsafe.Pointer(&p[0]))
 
40
                } else if littleEndian && uintptr(unsafe.Pointer(&p[0]))&(unsafe.Alignof(uint32(0))-1) == 0 {
 
41
                        X = (*[16]uint32)(unsafe.Pointer(&p[0]))
 
42
                } else {
 
43
                        X = &xbuf
 
44
                        j := 0
 
45
                        for i := 0; i < 16; i++ {
 
46
                                X[i&15] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24
 
47
                                j += 4
 
48
                        }
105
49
                }
106
50
 
107
 
                // If this needs to be made faster in the future,
108
 
                // the usual trick is to unroll each of these
109
 
                // loops by a factor of 4; that lets you replace
110
 
                // the shift[] lookups with constants and,
111
 
                // with suitable variable renaming in each
112
 
                // unrolled body, delete the a, b, c, d = d, a, b, c
113
 
                // (or you can let the optimizer do the renaming).
114
 
                //
115
 
                // The index variables are uint so that % by a power
116
 
                // of two can be optimized easily by a compiler.
117
 
 
118
51
                // Round 1.
119
 
                for i := uint(0); i < 16; i++ {
120
 
                        x := i
121
 
                        s := shift1[i%4]
122
 
                        f := ((c ^ d) & b) ^ d
123
 
                        a += f + X[x] + table[i]
124
 
                        a = a<<s | a>>(32-s) + b
125
 
                        a, b, c, d = d, a, b, c
126
 
                }
 
52
 
 
53
                a += (((c ^ d) & b) ^ d) + X[0] + 3614090360
 
54
                a = a<<7 | a>>(32-7) + b
 
55
 
 
56
                d += (((b ^ c) & a) ^ c) + X[1] + 3905402710
 
57
                d = d<<12 | d>>(32-12) + a
 
58
 
 
59
                c += (((a ^ b) & d) ^ b) + X[2] + 606105819
 
60
                c = c<<17 | c>>(32-17) + d
 
61
 
 
62
                b += (((d ^ a) & c) ^ a) + X[3] + 3250441966
 
63
                b = b<<22 | b>>(32-22) + c
 
64
 
 
65
                a += (((c ^ d) & b) ^ d) + X[4] + 4118548399
 
66
                a = a<<7 | a>>(32-7) + b
 
67
 
 
68
                d += (((b ^ c) & a) ^ c) + X[5] + 1200080426
 
69
                d = d<<12 | d>>(32-12) + a
 
70
 
 
71
                c += (((a ^ b) & d) ^ b) + X[6] + 2821735955
 
72
                c = c<<17 | c>>(32-17) + d
 
73
 
 
74
                b += (((d ^ a) & c) ^ a) + X[7] + 4249261313
 
75
                b = b<<22 | b>>(32-22) + c
 
76
 
 
77
                a += (((c ^ d) & b) ^ d) + X[8] + 1770035416
 
78
                a = a<<7 | a>>(32-7) + b
 
79
 
 
80
                d += (((b ^ c) & a) ^ c) + X[9] + 2336552879
 
81
                d = d<<12 | d>>(32-12) + a
 
82
 
 
83
                c += (((a ^ b) & d) ^ b) + X[10] + 4294925233
 
84
                c = c<<17 | c>>(32-17) + d
 
85
 
 
86
                b += (((d ^ a) & c) ^ a) + X[11] + 2304563134
 
87
                b = b<<22 | b>>(32-22) + c
 
88
 
 
89
                a += (((c ^ d) & b) ^ d) + X[12] + 1804603682
 
90
                a = a<<7 | a>>(32-7) + b
 
91
 
 
92
                d += (((b ^ c) & a) ^ c) + X[13] + 4254626195
 
93
                d = d<<12 | d>>(32-12) + a
 
94
 
 
95
                c += (((a ^ b) & d) ^ b) + X[14] + 2792965006
 
96
                c = c<<17 | c>>(32-17) + d
 
97
 
 
98
                b += (((d ^ a) & c) ^ a) + X[15] + 1236535329
 
99
                b = b<<22 | b>>(32-22) + c
127
100
 
128
101
                // Round 2.
129
 
                for i := uint(0); i < 16; i++ {
130
 
                        x := (1 + 5*i) % 16
131
 
                        s := shift2[i%4]
132
 
                        g := ((b ^ c) & d) ^ c
133
 
                        a += g + X[x] + table[i+16]
134
 
                        a = a<<s | a>>(32-s) + b
135
 
                        a, b, c, d = d, a, b, c
136
 
                }
 
102
 
 
103
                a += (((b ^ c) & d) ^ c) + X[(1+5*0)&15] + 4129170786
 
104
                a = a<<5 | a>>(32-5) + b
 
105
 
 
106
                d += (((a ^ b) & c) ^ b) + X[(1+5*1)&15] + 3225465664
 
107
                d = d<<9 | d>>(32-9) + a
 
108
 
 
109
                c += (((d ^ a) & b) ^ a) + X[(1+5*2)&15] + 643717713
 
110
                c = c<<14 | c>>(32-14) + d
 
111
 
 
112
                b += (((c ^ d) & a) ^ d) + X[(1+5*3)&15] + 3921069994
 
113
                b = b<<20 | b>>(32-20) + c
 
114
 
 
115
                a += (((b ^ c) & d) ^ c) + X[(1+5*4)&15] + 3593408605
 
116
                a = a<<5 | a>>(32-5) + b
 
117
 
 
118
                d += (((a ^ b) & c) ^ b) + X[(1+5*5)&15] + 38016083
 
119
                d = d<<9 | d>>(32-9) + a
 
120
 
 
121
                c += (((d ^ a) & b) ^ a) + X[(1+5*6)&15] + 3634488961
 
122
                c = c<<14 | c>>(32-14) + d
 
123
 
 
124
                b += (((c ^ d) & a) ^ d) + X[(1+5*7)&15] + 3889429448
 
125
                b = b<<20 | b>>(32-20) + c
 
126
 
 
127
                a += (((b ^ c) & d) ^ c) + X[(1+5*8)&15] + 568446438
 
128
                a = a<<5 | a>>(32-5) + b
 
129
 
 
130
                d += (((a ^ b) & c) ^ b) + X[(1+5*9)&15] + 3275163606
 
131
                d = d<<9 | d>>(32-9) + a
 
132
 
 
133
                c += (((d ^ a) & b) ^ a) + X[(1+5*10)&15] + 4107603335
 
134
                c = c<<14 | c>>(32-14) + d
 
135
 
 
136
                b += (((c ^ d) & a) ^ d) + X[(1+5*11)&15] + 1163531501
 
137
                b = b<<20 | b>>(32-20) + c
 
138
 
 
139
                a += (((b ^ c) & d) ^ c) + X[(1+5*12)&15] + 2850285829
 
140
                a = a<<5 | a>>(32-5) + b
 
141
 
 
142
                d += (((a ^ b) & c) ^ b) + X[(1+5*13)&15] + 4243563512
 
143
                d = d<<9 | d>>(32-9) + a
 
144
 
 
145
                c += (((d ^ a) & b) ^ a) + X[(1+5*14)&15] + 1735328473
 
146
                c = c<<14 | c>>(32-14) + d
 
147
 
 
148
                b += (((c ^ d) & a) ^ d) + X[(1+5*15)&15] + 2368359562
 
149
                b = b<<20 | b>>(32-20) + c
137
150
 
138
151
                // Round 3.
139
 
                for i := uint(0); i < 16; i++ {
140
 
                        x := (5 + 3*i) % 16
141
 
                        s := shift3[i%4]
142
 
                        h := b ^ c ^ d
143
 
                        a += h + X[x] + table[i+32]
144
 
                        a = a<<s | a>>(32-s) + b
145
 
                        a, b, c, d = d, a, b, c
146
 
                }
 
152
 
 
153
                a += (b ^ c ^ d) + X[(5+3*0)&15] + 4294588738
 
154
                a = a<<4 | a>>(32-4) + b
 
155
 
 
156
                d += (a ^ b ^ c) + X[(5+3*1)&15] + 2272392833
 
157
                d = d<<11 | d>>(32-11) + a
 
158
 
 
159
                c += (d ^ a ^ b) + X[(5+3*2)&15] + 1839030562
 
160
                c = c<<16 | c>>(32-16) + d
 
161
 
 
162
                b += (c ^ d ^ a) + X[(5+3*3)&15] + 4259657740
 
163
                b = b<<23 | b>>(32-23) + c
 
164
 
 
165
                a += (b ^ c ^ d) + X[(5+3*4)&15] + 2763975236
 
166
                a = a<<4 | a>>(32-4) + b
 
167
 
 
168
                d += (a ^ b ^ c) + X[(5+3*5)&15] + 1272893353
 
169
                d = d<<11 | d>>(32-11) + a
 
170
 
 
171
                c += (d ^ a ^ b) + X[(5+3*6)&15] + 4139469664
 
172
                c = c<<16 | c>>(32-16) + d
 
173
 
 
174
                b += (c ^ d ^ a) + X[(5+3*7)&15] + 3200236656
 
175
                b = b<<23 | b>>(32-23) + c
 
176
 
 
177
                a += (b ^ c ^ d) + X[(5+3*8)&15] + 681279174
 
178
                a = a<<4 | a>>(32-4) + b
 
179
 
 
180
                d += (a ^ b ^ c) + X[(5+3*9)&15] + 3936430074
 
181
                d = d<<11 | d>>(32-11) + a
 
182
 
 
183
                c += (d ^ a ^ b) + X[(5+3*10)&15] + 3572445317
 
184
                c = c<<16 | c>>(32-16) + d
 
185
 
 
186
                b += (c ^ d ^ a) + X[(5+3*11)&15] + 76029189
 
187
                b = b<<23 | b>>(32-23) + c
 
188
 
 
189
                a += (b ^ c ^ d) + X[(5+3*12)&15] + 3654602809
 
190
                a = a<<4 | a>>(32-4) + b
 
191
 
 
192
                d += (a ^ b ^ c) + X[(5+3*13)&15] + 3873151461
 
193
                d = d<<11 | d>>(32-11) + a
 
194
 
 
195
                c += (d ^ a ^ b) + X[(5+3*14)&15] + 530742520
 
196
                c = c<<16 | c>>(32-16) + d
 
197
 
 
198
                b += (c ^ d ^ a) + X[(5+3*15)&15] + 3299628645
 
199
                b = b<<23 | b>>(32-23) + c
147
200
 
148
201
                // Round 4.
149
 
                for i := uint(0); i < 16; i++ {
150
 
                        x := (7 * i) % 16
151
 
                        s := shift4[i%4]
152
 
                        j := c ^ (b | ^d)
153
 
                        a += j + X[x] + table[i+48]
154
 
                        a = a<<s | a>>(32-s) + b
155
 
                        a, b, c, d = d, a, b, c
156
 
                }
 
202
 
 
203
                a += (c ^ (b | ^d)) + X[(7*0)&15] + 4096336452
 
204
                a = a<<6 | a>>(32-6) + b
 
205
 
 
206
                d += (b ^ (a | ^c)) + X[(7*1)&15] + 1126891415
 
207
                d = d<<10 | d>>(32-10) + a
 
208
 
 
209
                c += (a ^ (d | ^b)) + X[(7*2)&15] + 2878612391
 
210
                c = c<<15 | c>>(32-15) + d
 
211
 
 
212
                b += (d ^ (c | ^a)) + X[(7*3)&15] + 4237533241
 
213
                b = b<<21 | b>>(32-21) + c
 
214
 
 
215
                a += (c ^ (b | ^d)) + X[(7*4)&15] + 1700485571
 
216
                a = a<<6 | a>>(32-6) + b
 
217
 
 
218
                d += (b ^ (a | ^c)) + X[(7*5)&15] + 2399980690
 
219
                d = d<<10 | d>>(32-10) + a
 
220
 
 
221
                c += (a ^ (d | ^b)) + X[(7*6)&15] + 4293915773
 
222
                c = c<<15 | c>>(32-15) + d
 
223
 
 
224
                b += (d ^ (c | ^a)) + X[(7*7)&15] + 2240044497
 
225
                b = b<<21 | b>>(32-21) + c
 
226
 
 
227
                a += (c ^ (b | ^d)) + X[(7*8)&15] + 1873313359
 
228
                a = a<<6 | a>>(32-6) + b
 
229
 
 
230
                d += (b ^ (a | ^c)) + X[(7*9)&15] + 4264355552
 
231
                d = d<<10 | d>>(32-10) + a
 
232
 
 
233
                c += (a ^ (d | ^b)) + X[(7*10)&15] + 2734768916
 
234
                c = c<<15 | c>>(32-15) + d
 
235
 
 
236
                b += (d ^ (c | ^a)) + X[(7*11)&15] + 1309151649
 
237
                b = b<<21 | b>>(32-21) + c
 
238
 
 
239
                a += (c ^ (b | ^d)) + X[(7*12)&15] + 4149444226
 
240
                a = a<<6 | a>>(32-6) + b
 
241
 
 
242
                d += (b ^ (a | ^c)) + X[(7*13)&15] + 3174756917
 
243
                d = d<<10 | d>>(32-10) + a
 
244
 
 
245
                c += (a ^ (d | ^b)) + X[(7*14)&15] + 718787259
 
246
                c = c<<15 | c>>(32-15) + d
 
247
 
 
248
                b += (d ^ (c | ^a)) + X[(7*15)&15] + 3951481745
 
249
                b = b<<21 | b>>(32-21) + c
157
250
 
158
251
                a += aa
159
252
                b += bb
160
253
                c += cc
161
254
                d += dd
162
255
 
163
 
                p = p[_Chunk:]
164
 
                n += _Chunk
 
256
                p = p[chunk:]
165
257
        }
166
258
 
167
259
        dig.s[0] = a
168
260
        dig.s[1] = b
169
261
        dig.s[2] = c
170
262
        dig.s[3] = d
171
 
        return n
172
263
}