libgo/go/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 SHA1 hash algorithm as defined in RFC 3174.
   6 package sha1
   7
   8 import (
   9         "crypto"
  10         "hash"
  11 )
  12
  13 func init() {
  14         crypto.RegisterHash(crypto.SHA1, New)
  15 }
  16
  17 // The size of a SHA1 checksum in bytes.
  18 const Size = 20
  19
  20 // The blocksize of SHA1 in bytes.
  21 const BlockSize = 64
  22
  23 const (
  24         chunk = 64
  25         init0 = 0x67452301
  26         init1 = 0xEFCDAB89
  27         init2 = 0x98BADCFE
  28         init3 = 0x10325476
  29         init4 = 0xC3D2E1F0
  30 )
  31
  32 // digest represents the partial evaluation of a checksum.
  33 type digest struct {
  34         h   [5]uint32
  35         x   [chunk]byte
  36         nx  int
  37         len uint64
  38 }
  39
  40 func (d *digest) Reset() {
  41         d.h[0] = init0
  42         d.h[1] = init1
  43         d.h[2] = init2
  44         d.h[3] = init3
  45         d.h[4] = init4
  46         d.nx = 0
  47         d.len = 0
  48 }
  49
  50 // New returns a new hash.Hash computing the SHA1 checksum.
  51 func New() hash.Hash {
  52         d := new(digest)
  53         d.Reset()
  54         return d
  55 }
  56
  57 func (d *digest) Size() int { return Size }
  58
  59 func (d *digest) BlockSize() int { return BlockSize }
  60
  61 func (d *digest) Write(p []byte) (nn int, err error) {
  62         nn = len(p)
  63         d.len += uint64(nn)
  64         if d.nx > 0 {
  65                 n := copy(d.x[d.nx:], p)
  66                 d.nx += n
  67                 if d.nx == chunk {
  68                         block(d, d.x[:])
  69                         d.nx = 0
  70                 }
  71                 p = p[n:]
  72         }
  73         if len(p) >= chunk {
  74                 n := len(p) &^ (chunk - 1)
  75                 block(d, p[:n])
  76                 p = p[n:]
  77         }
  78         if len(p) > 0 {
  79                 d.nx = copy(d.x[:], p)
  80         }
  81         return
  82 }
  83
  84 func (d0 *digest) Sum(in []byte) []byte {
  85         // Make a copy of d0 so that caller can keep writing and summing.
  86         d := *d0
  87         hash := d.checkSum()
  88         return append(in, hash[:]...)
  89 }
  90
  91 func (d *digest) checkSum() [Size]byte {
  92         len := d.len
  93         // Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
  94         var tmp [64]byte
  95         tmp[0] = 0x80
  96         if len%64 < 56 {
  97                 d.Write(tmp[0 : 56-len%64])
  98         } else {
  99                 d.Write(tmp[0 : 64+56-len%64])
 100         }
 101
 102         // Length in bits.
 103         len <<= 3
 104         for i := uint(0); i < 8; i++ {
 105                 tmp[i] = byte(len >> (56 - 8*i))
 106         }
 107         d.Write(tmp[0:8])
 108
 109         if d.nx != 0 {
 110                 panic("d.nx != 0")
 111         }
 112
 113         var digest [Size]byte
 114         for i, s := range d.h {
 115                 digest[i*4] = byte(s >> 24)
 116                 digest[i*4+1] = byte(s >> 16)
 117                 digest[i*4+2] = byte(s >> 8)
 118                 digest[i*4+3] = byte(s)
 119         }
 120
 121         return digest
 122 }
 123
 124 // Sum returns the SHA1 checksum of the data.
 125 func Sum(data []byte) [Size]byte {
 126         var d digest
 127         d.Reset()
 128         d.Write(data)
 129         return d.checkSum()
 130 }