src/crypto/sha1/sha1.go

   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.
   4
   5 // Package sha1 implements the SHA-1 hash algorithm as defined in RFC 3174.
   6 //
   7 // SHA-1 is cryptographically broken and should not be used for secure
   8 // applications.
   9 package sha1
  10
  11 import (
  12         "crypto"
  13         "errors"
  14         "hash"
  15 )
  16
  17 func init() {
  18         crypto.RegisterHash(crypto.SHA1, New)
  19 }
  20
  21 // The size of a SHA-1 checksum in bytes.
  22 const Size = 20
  23
  24 // The blocksize of SHA-1 in bytes.
  25 const BlockSize = 64
  26
  27 const (
  28         chunk = 64
  29         init0 = 0x67452301
  30         init1 = 0xEFCDAB89
  31         init2 = 0x98BADCFE
  32         init3 = 0x10325476
  33         init4 = 0xC3D2E1F0
  34 )
  35
  36 // digest represents the partial evaluation of a checksum.
  37 type digest struct {
  38         h   [5]uint32
  39         x   [chunk]byte
  40         nx  int
  41         len uint64
  42 }
  43
  44 const (
  45         magic         = "sha\x01"
  46         marshaledSize = len(magic) + 5*4 + chunk + 8
  47 )
  48
  49 func (d *digest) MarshalBinary() ([]byte, error) {
  50         b := make([]byte, 0, marshaledSize)
  51         b = append(b, magic...)
  52         b = appendUint32(b, d.h[0])
  53         b = appendUint32(b, d.h[1])
  54         b = appendUint32(b, d.h[2])
  55         b = appendUint32(b, d.h[3])
  56         b = appendUint32(b, d.h[4])
  57         b = append(b, d.x[:d.nx]...)
  58         b = b[:len(b)+len(d.x)-int(d.nx)] // already zero
  59         b = appendUint64(b, d.len)
  60         return b, nil
  61 }
  62
  63 func (d *digest) UnmarshalBinary(b []byte) error {
  64         if len(b) < len(magic) || string(b[:len(magic)]) != magic {
  65                 return errors.New("crypto/sha1: invalid hash state identifier")
  66         }
  67         if len(b) != marshaledSize {
  68                 return errors.New("crypto/sha1: invalid hash state size")
  69         }
  70         b = b[len(magic):]
  71         b, d.h[0] = consumeUint32(b)
  72         b, d.h[1] = consumeUint32(b)
  73         b, d.h[2] = consumeUint32(b)
  74         b, d.h[3] = consumeUint32(b)
  75         b, d.h[4] = consumeUint32(b)
  76         b = b[copy(d.x[:], b):]
  77         b, d.len = consumeUint64(b)
  78         d.nx = int(d.len) % chunk
  79         return nil
  80 }
  81
  82 func appendUint64(b []byte, x uint64) []byte {
  83         var a [8]byte
  84         putUint64(a[:], x)
  85         return append(b, a[:]...)
  86 }
  87
  88 func appendUint32(b []byte, x uint32) []byte {
  89         var a [4]byte
  90         putUint32(a[:], x)
  91         return append(b, a[:]...)
  92 }
  93
  94 func consumeUint64(b []byte) ([]byte, uint64) {
  95         _ = b[7]
  96         x := uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
  97                 uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
  98         return b[8:], x
  99 }
 100
 101 func consumeUint32(b []byte) ([]byte, uint32) {
 102         _ = b[3]
 103         x := uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
 104         return b[4:], x
 105 }
 106
 107 func (d *digest) Reset() {
 108         d.h[0] = init0
 109         d.h[1] = init1
 110         d.h[2] = init2
 111         d.h[3] = init3
 112         d.h[4] = init4
 113         d.nx = 0
 114         d.len = 0
 115 }
 116
 117 // New returns a new hash.Hash computing the SHA1 checksum. The Hash also
 118 // implements encoding.BinaryMarshaler and encoding.BinaryUnmarshaler to
 119 // marshal and unmarshal the internal state of the hash.
 120 func New() hash.Hash {
 121         if boringEnabled {
 122                 return boringNewSHA1()
 123         }
 124         d := new(digest)
 125         d.Reset()
 126         return d
 127 }
 128
 129 func (d *digest) Size() int { return Size }
 130
 131 func (d *digest) BlockSize() int { return BlockSize }
 132
 133 func (d *digest) Write(p []byte) (nn int, err error) {
 134         boringUnreachable()
 135         nn = len(p)
 136         d.len += uint64(nn)
 137         if d.nx > 0 {
 138                 n := copy(d.x[d.nx:], p)
 139                 d.nx += n
 140                 if d.nx == chunk {
 141                         block(d, d.x[:])
 142                         d.nx = 0
 143                 }
 144                 p = p[n:]
 145         }
 146         if len(p) >= chunk {
 147                 n := len(p) &^ (chunk - 1)
 148                 block(d, p[:n])
 149                 p = p[n:]
 150         }
 151         if len(p) > 0 {
 152                 d.nx = copy(d.x[:], p)
 153         }
 154         return
 155 }
 156
 157 func (d *digest) Sum(in []byte) []byte {
 158         boringUnreachable()
 159         // Make a copy of d so that caller can keep writing and summing.
 160         d0 := *d
 161         hash := d0.checkSum()
 162         return append(in, hash[:]...)
 163 }
 164
 165 func (d *digest) checkSum() [Size]byte {
 166         len := d.len
 167         // Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
 168         var tmp [64]byte
 169         tmp[0] = 0x80
 170         if len%64 < 56 {
 171                 d.Write(tmp[0 : 56-len%64])
 172         } else {
 173                 d.Write(tmp[0 : 64+56-len%64])
 174         }
 175
 176         // Length in bits.
 177         len <<= 3
 178         putUint64(tmp[:], len)
 179         d.Write(tmp[0:8])
 180
 181         if d.nx != 0 {
 182                 panic("d.nx != 0")
 183         }
 184
 185         var digest [Size]byte
 186
 187         putUint32(digest[0:], d.h[0])
 188         putUint32(digest[4:], d.h[1])
 189         putUint32(digest[8:], d.h[2])
 190         putUint32(digest[12:], d.h[3])
 191         putUint32(digest[16:], d.h[4])
 192
 193         return digest
 194 }
 195
 196 // ConstantTimeSum computes the same result of Sum() but in constant time
 197 func (d *digest) ConstantTimeSum(in []byte) []byte {
 198         d0 := *d
 199         hash := d0.constSum()
 200         return append(in, hash[:]...)
 201 }
 202
 203 func (d *digest) constSum() [Size]byte {
 204         var length [8]byte
 205         l := d.len << 3
 206         for i := uint(0); i < 8; i++ {
 207                 length[i] = byte(l >> (56 - 8*i))
 208         }
 209
 210         nx := byte(d.nx)
 211         t := nx - 56                 // if nx < 56 then the MSB of t is one
 212         mask1b := byte(int8(t) >> 7) // mask1b is 0xFF iff one block is enough
 213
 214         separator := byte(0x80) // gets reset to 0x00 once used
 215         for i := byte(0); i < chunk; i++ {
 216                 mask := byte(int8(i-nx) >> 7) // 0x00 after the end of data
 217
 218                 // if we reached the end of the data, replace with 0x80 or 0x00
 219                 d.x[i] = (^mask & separator) | (mask & d.x[i])
 220
 221                 // zero the separator once used
 222                 separator &= mask
 223
 224                 if i >= 56 {
 225                         // we might have to write the length here if all fit in one block
 226                         d.x[i] |= mask1b & length[i-56]
 227                 }
 228         }
 229
 230         // compress, and only keep the digest if all fit in one block
 231         block(d, d.x[:])
 232
 233         var digest [Size]byte
 234         for i, s := range d.h {
 235                 digest[i*4] = mask1b & byte(s>>24)
 236                 digest[i*4+1] = mask1b & byte(s>>16)
 237                 digest[i*4+2] = mask1b & byte(s>>8)
 238                 digest[i*4+3] = mask1b & byte(s)
 239         }
 240
 241         for i := byte(0); i < chunk; i++ {
 242                 // second block, it's always past the end of data, might start with 0x80
 243                 if i < 56 {
 244                         d.x[i] = separator
 245                         separator = 0
 246                 } else {
 247                         d.x[i] = length[i-56]
 248                 }
 249         }
 250
 251         // compress, and only keep the digest if we actually needed the second block
 252         block(d, d.x[:])
 253
 254         for i, s := range d.h {
 255                 digest[i*4] |= ^mask1b & byte(s>>24)
 256                 digest[i*4+1] |= ^mask1b & byte(s>>16)
 257                 digest[i*4+2] |= ^mask1b & byte(s>>8)
 258                 digest[i*4+3] |= ^mask1b & byte(s)
 259         }
 260
 261         return digest
 262 }
 263
 264 // Sum returns the SHA-1 checksum of the data.
 265 func Sum(data []byte) [Size]byte {
 266         if boringEnabled {
 267                 h := New()
 268                 h.Write(data)
 269                 var ret [Size]byte
 270                 h.Sum(ret[:0])
 271                 return ret
 272         }
 273         var d digest
 274         d.Reset()
 275         d.Write(data)
 276         return d.checkSum()
 277 }
 278
 279 func putUint64(x []byte, s uint64) {
 280         _ = x[7]
 281         x[0] = byte(s >> 56)
 282         x[1] = byte(s >> 48)
 283         x[2] = byte(s >> 40)
 284         x[3] = byte(s >> 32)
 285         x[4] = byte(s >> 24)
 286         x[5] = byte(s >> 16)
 287         x[6] = byte(s >> 8)
 288         x[7] = byte(s)
 289 }
 290
 291 func putUint32(x []byte, s uint32) {
 292         _ = x[3]
 293         x[0] = byte(s >> 24)
 294         x[1] = byte(s >> 16)
 295         x[2] = byte(s >> 8)
 296         x[3] = byte(s)
 297 }