-
Notifications
You must be signed in to change notification settings - Fork 0
/
sha256.go
168 lines (149 loc) · 3.41 KB
/
sha256.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
// 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.
package pbkdf2
import (
"encoding/binary"
)
// The size of a SHA256 checksum in bytes.
const hashLen = 32
// The blocksize of SHA256 in bytes.
const blockSize = 64
const (
chunk = 64
init0 = 0x6A09E667
init1 = 0xBB67AE85
init2 = 0x3C6EF372
init3 = 0xA54FF53A
init4 = 0x510E527F
init5 = 0x9B05688C
init6 = 0x1F83D9AB
init7 = 0x5BE0CD19
)
// digest represents the partial evaluation of a checksum.
type digest struct {
h [8]uint32
x [chunk]byte
nx int
len uint64
}
func (d *digest) Reset() {
d.h[0] = init0
d.h[1] = init1
d.h[2] = init2
d.h[3] = init3
d.h[4] = init4
d.h[5] = init5
d.h[6] = init6
d.h[7] = init7
d.nx = 0
d.len = 0
}
func (d *digest) BlockSize() int {
return blockSize
}
func (d *digest) Size() int {
return hashLen
}
func (d *digest) Write(p []byte) (nn int, err error) {
nn = len(p)
d.len += uint64(nn)
if d.nx > 0 {
n := copy(d.x[d.nx:], p)
d.nx += n
if d.nx == chunk {
block(d, d.x[:])
d.nx = 0
}
p = p[n:]
}
if len(p) >= chunk {
n := len(p) &^ (chunk - 1)
block(d, p[:n])
p = p[n:]
}
if len(p) > 0 {
d.nx = copy(d.x[:], p)
}
return
}
func (d *digest) Sum(in []byte) []byte {
d0 := *d
hash := d0.checkSum()
return append(in, hash[:]...)
}
func (d *digest) checkSum() [hashLen]byte {
len := d.len
// Padding. Add a 1 bit and 0 bits until 56 bytes mod 64.
var tmp [64]byte
tmp[0] = 0x80
if len%64 < 56 {
d.Write(tmp[0 : 56-len%64])
} else {
d.Write(tmp[0 : 64+56-len%64])
}
// Length in bits.
len <<= 3
binary.BigEndian.PutUint64(tmp[:], len)
d.Write(tmp[0:8])
if d.nx != 0 {
panic("d.nx != 0")
}
var digest [hashLen]byte
binary.BigEndian.PutUint32(digest[0:], d.h[0])
binary.BigEndian.PutUint32(digest[4:], d.h[1])
binary.BigEndian.PutUint32(digest[8:], d.h[2])
binary.BigEndian.PutUint32(digest[12:], d.h[3])
binary.BigEndian.PutUint32(digest[16:], d.h[4])
binary.BigEndian.PutUint32(digest[20:], d.h[5])
binary.BigEndian.PutUint32(digest[24:], d.h[6])
binary.BigEndian.PutUint32(digest[28:], d.h[7])
return digest
}
// dirtySum copies the checksum to out, which must be exactly
// hashLen bytes.
//
// dirtySum modifies the digest's internal state.
func (d *digest) dirtySum(out []byte) {
if len(out) != hashLen {
panic("bad len")
}
hash := d.checkSum()
copy(out, hash[:])
}
// writeBlock writes p, which must be exactly one block, to the
// digest.
//
// Can ony be used after writing one or more complete blocks to
// the digest.
func (d *digest) writeBlock(p []byte) {
block(d, p)
}
// sumBlock copies the current checksum to p.
//
// p must be exactly hashLen bytes.
//
// Can only be used after writing one or more complete blocks to
// the digest.
func (d *digest) sumBlock(p []byte) {
// Use p[n:m] prevents sumBlock from being inlined.
binary.BigEndian.PutUint32(p[0:], d.h[0])
binary.BigEndian.PutUint32(p[4:], d.h[1])
binary.BigEndian.PutUint32(p[8:], d.h[2])
binary.BigEndian.PutUint32(p[12:], d.h[3])
binary.BigEndian.PutUint32(p[16:], d.h[4])
binary.BigEndian.PutUint32(p[20:], d.h[5])
binary.BigEndian.PutUint32(p[24:], d.h[6])
binary.BigEndian.PutUint32(p[28:], d.h[7])
}
// xor sets d ^= v.
func (d *digest) xor(v *digest) {
d.h[0] ^= v.h[0]
d.h[1] ^= v.h[1]
d.h[2] ^= v.h[2]
d.h[3] ^= v.h[3]
d.h[4] ^= v.h[4]
d.h[5] ^= v.h[5]
d.h[6] ^= v.h[6]
d.h[7] ^= v.h[7]
}