crypto/ripemd160: new package

R=rsc
CC=golang-dev
https://golang.org/cl/224081

diff --git a/src/pkg/Makefile b/src/pkg/Makefile
index 3fa6b00ed07571ac35c7fc464cf93825168c99e5..d6552d06581f845bfaba4d3be9c18d9a43e5790a 100644 (file)
--- a/src/pkg/Makefile
+++ b/src/pkg/Makefile
@@ -40,6 +40,7 @@ DIRS=\
        crypto/md4\
        crypto/md5\
        crypto/rc4\
+       crypto/ripemd160\
        crypto/rsa\
        crypto/sha1\
        crypto/sha256\

diff --git a/src/pkg/crypto/ripemd160/Makefile b/src/pkg/crypto/ripemd160/Makefile
new file mode 100644 (file)
index 0000000..109e68e
--- /dev/null
+++ b/src/pkg/crypto/ripemd160/Makefile
@@ -0,0 +1,12 @@
+# Copyright 2010 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.
+
+include ../../../Make.$(GOARCH)
+
+TARG=crypto/ripemd160
+GOFILES=\
+       ripemd160.go\
+       ripemd160block.go\
+
+include ../../../Make.pkg

diff --git a/src/pkg/crypto/ripemd160/ripemd160.go b/src/pkg/crypto/ripemd160/ripemd160.go
new file mode 100644 (file)
index 0000000..9eb8340
--- /dev/null
+++ b/src/pkg/crypto/ripemd160/ripemd160.go
@@ -0,0 +1,116 @@
+// Copyright 2010 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.
+
+// This package implements the RIPEMD-160 hash algorithm.
+package ripemd160
+
+// RIPEMD-160 is designed by by Hans Dobbertin, Antoon Bosselaers, and Bart
+// Preneel with specifications available at:
+// http://homes.esat.kuleuven.be/~cosicart/pdf/AB-9601/AB-9601.pdf.
+
+import (
+       "hash"
+       "os"
+)
+
+// The size of the checksum in bytes.
+const Size = 20
+
+// The block size of the hash algorithm in bytes.
+const BlockSize = 64
+
+const (
+       _s0 = 0x67452301
+       _s1 = 0xefcdab89
+       _s2 = 0x98badcfe
+       _s3 = 0x10325476
+       _s4 = 0xc3d2e1f0
+)
+
+// digest represents the partial evaluation of a checksum.
+type digest struct {
+       s  [5]uint32       // running context
+       x  [BlockSize]byte // temporary buffer
+       nx int             // index into x
+       tc uint64          // total count of bytes processed
+}
+
+func (d *digest) Reset() {
+       d.s[0], d.s[1], d.s[2], d.s[3], d.s[4] = _s0, _s1, _s2, _s3, _s4
+       d.nx = 0
+       d.tc = 0
+}
+
+// New returns a new hash.Hash computing the checksum.
+func New() hash.Hash {
+       result := new(digest)
+       result.Reset()
+       return result
+}
+
+func (d *digest) Size() int { return Size }
+
+func (d *digest) Write(p []byte) (nn int, err os.Error) {
+       nn = len(p)
+       d.tc += uint64(nn)
+       if d.nx > 0 {
+               n := len(p)
+               if n > BlockSize-d.nx {
+                       n = BlockSize - d.nx
+               }
+               for i := 0; i < n; i++ {
+                       d.x[d.nx+i] = p[i]
+               }
+               d.nx += n
+               if d.nx == BlockSize {
+                       _Block(d, &d.x)
+                       d.nx = 0
+               }
+               p = p[n:]
+       }
+       n := _Block(d, p)
+       p = p[n:]
+       if len(p) > 0 {
+               for i, x := range p {
+                       d.x[i] = x
+               }
+               d.nx = len(p)
+       }
+       return
+}
+
+func (d0 *digest) Sum() []byte {
+       // Make a copy of d0 so that caller can keep writing and summing.
+       d := new(digest)
+       *d = *d0
+
+       // Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
+       tc := d.tc
+       var tmp [64]byte
+       tmp[0] = 0x80
+       if tc%64 < 56 {
+               d.Write(tmp[0 : 56-tc%64])
+       } else {
+               d.Write(tmp[0 : 64+56-tc%64])
+       }
+
+       // Length in bits.
+       tc <<= 3
+       for i := uint(0); i < 8; i++ {
+               tmp[i] = byte(tc >> (8 * i))
+       }
+       d.Write(tmp[0:8])
+
+       if d.nx != 0 {
+               panicln("oops")
+       }
+
+       p := make([]byte, 20)
+       j := 0
+       for _, s := range d.s {
+               p[j], p[j+1], p[j+2], p[j+3] = byte(s), byte(s>>8), byte(s>>16), byte(s>>24)
+               j += 4
+       }
+       return p
+}

diff --git a/src/pkg/crypto/ripemd160/ripemd160_test.go b/src/pkg/crypto/ripemd160/ripemd160_test.go
new file mode 100644 (file)
index 0000000..eaa3d78
--- /dev/null
+++ b/src/pkg/crypto/ripemd160/ripemd160_test.go
@@ -0,0 +1,64 @@
+// Copyright 2010 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 ripemd160
+
+// Test vectors are from:
+// http://homes.esat.kuleuven.be/~bosselae/ripemd160.html
+
+import (
+       "fmt"
+       "io"
+       "testing"
+)
+
+type mdTest struct {
+       out string
+       in  string
+}
+
+var vectors = [...]mdTest{
+       mdTest{"9c1185a5c5e9fc54612808977ee8f548b2258d31", ""},
+       mdTest{"0bdc9d2d256b3ee9daae347be6f4dc835a467ffe", "a"},
+       mdTest{"8eb208f7e05d987a9b044a8e98c6b087f15a0bfc", "abc"},
+       mdTest{"5d0689ef49d2fae572b881b123a85ffa21595f36", "message digest"},
+       mdTest{"f71c27109c692c1b56bbdceb5b9d2865b3708dbc", "abcdefghijklmnopqrstuvwxyz"},
+       mdTest{"12a053384a9c0c88e405a06c27dcf49ada62eb2b", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
+       mdTest{"b0e20b6e3116640286ed3a87a5713079b21f5189", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"},
+       mdTest{"9b752e45573d4b39f4dbd3323cab82bf63326bfb", "12345678901234567890123456789012345678901234567890123456789012345678901234567890"},
+}
+
+func TestVectors(t *testing.T) {
+       for i := 0; i < len(vectors); i++ {
+               tv := vectors[i]
+               md := New()
+               for j := 0; j < 3; j++ {
+                       if j < 2 {
+                               io.WriteString(md, tv.in)
+                       } else {
+                               io.WriteString(md, tv.in[0:len(tv.in)/2])
+                               md.Sum()
+                               io.WriteString(md, tv.in[len(tv.in)/2:])
+                       }
+                       s := fmt.Sprintf("%x", md.Sum())
+                       if s != tv.out {
+                               t.Fatalf("RIPEMD-160[%d](%s) = %s, expected %s", j, tv.in, s, tv.out)
+                       }
+                       md.Reset()
+               }
+       }
+}
+
+func TestMillionA(t *testing.T) {
+       md := New()
+       for i := 0; i < 100000; i++ {
+               io.WriteString(md, "aaaaaaaaaa")
+       }
+       out := "52783243c1697bdbe16d37f97f68f08325dc1528"
+       s := fmt.Sprintf("%x", md.Sum())
+       if s != out {
+               t.Fatalf("RIPEMD-160 (1 million 'a') = %s, expected %s", s, out)
+       }
+       md.Reset()
+}

diff --git a/src/pkg/crypto/ripemd160/ripemd160block.go b/src/pkg/crypto/ripemd160/ripemd160block.go
new file mode 100644 (file)
index 0000000..7bc8e6c
--- /dev/null
+++ b/src/pkg/crypto/ripemd160/ripemd160block.go
@@ -0,0 +1,161 @@
+// Copyright 2010 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.
+
+// RIPEMD-160 block step.
+// In its own file so that a faster assembly or C version
+// can be substituted easily.
+
+package ripemd160
+
+// work buffer indices and roll amounts for one line
+var _n = [80]uint{
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+       7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
+       3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
+       1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
+       4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13,
+}
+
+var _r = [80]uint{
+       11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
+       7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
+       11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
+       11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
+       9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6,
+}
+
+// same for the other parallel one
+var n_ = [80]uint{
+       5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
+       6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
+       15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
+       8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
+       12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11,
+}
+
+var r_ = [80]uint{
+       8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
+       9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
+       9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
+       15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
+       8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11,
+}
+
+func _Block(md *digest, p []byte) int {
+       n := 0
+       var x [16]uint32
+       var alpha, beta uint32
+       for len(p) >= BlockSize {
+               a, b, c, d, e := md.s[0], md.s[1], md.s[2], md.s[3], md.s[4]
+               aa, bb, cc, dd, ee := a, b, c, d, e
+               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
+               }
+
+               // round 1
+               i := 0
+               for i < 16 {
+                       alpha = a + (b ^ c ^ d) + x[_n[i]]
+                       s := _r[i]
+                       alpha = (alpha<<s | alpha>>(32-s)) + e
+                       beta = c<<10 | c>>22
+                       a, b, c, d, e = e, alpha, b, beta, d
+
+                       // parallel line
+                       alpha = aa + (bb ^ (cc | ^dd)) + x[n_[i]] + 0x50a28be6
+                       s = r_[i]
+                       alpha = (alpha<<s | alpha>>(32-s)) + ee
+                       beta = cc<<10 | cc>>22
+                       aa, bb, cc, dd, ee = ee, alpha, bb, beta, dd
+
+                       i++
+               }
+
+               // round 2
+               for i < 32 {
+                       alpha = a + (b&c | ^b&d) + x[_n[i]] + 0x5a827999
+                       s := _r[i]
+                       alpha = (alpha<<s | alpha>>(32-s)) + e
+                       beta = c<<10 | c>>22
+                       a, b, c, d, e = e, alpha, b, beta, d
+
+                       // parallel line
+                       alpha = aa + (bb&dd | cc&^dd) + x[n_[i]] + 0x5c4dd124
+                       s = r_[i]
+                       alpha = (alpha<<s | alpha>>(32-s)) + ee
+                       beta = cc<<10 | cc>>22
+                       aa, bb, cc, dd, ee = ee, alpha, bb, beta, dd
+
+                       i++
+               }
+
+               // round 3
+               for i < 48 {
+                       alpha = a + (b | ^c ^ d) + x[_n[i]] + 0x6ed9eba1
+                       s := _r[i]
+                       alpha = (alpha<<s | alpha>>(32-s)) + e
+                       beta = c<<10 | c>>22
+                       a, b, c, d, e = e, alpha, b, beta, d
+
+                       // parallel line
+                       alpha = aa + (bb | ^cc ^ dd) + x[n_[i]] + 0x6d703ef3
+                       s = r_[i]
+                       alpha = (alpha<<s | alpha>>(32-s)) + ee
+                       beta = cc<<10 | cc>>22
+                       aa, bb, cc, dd, ee = ee, alpha, bb, beta, dd
+
+                       i++
+               }
+
+               // round 4
+               for i < 64 {
+                       alpha = a + (b&d | c&^d) + x[_n[i]] + 0x8f1bbcdc
+                       s := _r[i]
+                       alpha = (alpha<<s | alpha>>(32-s)) + e
+                       beta = c<<10 | c>>22
+                       a, b, c, d, e = e, alpha, b, beta, d
+
+                       // parallel line
+                       alpha = aa + (bb&cc | ^bb&dd) + x[n_[i]] + 0x7a6d76e9
+                       s = r_[i]
+                       alpha = (alpha<<s | alpha>>(32-s)) + ee
+                       beta = cc<<10 | cc>>22
+                       aa, bb, cc, dd, ee = ee, alpha, bb, beta, dd
+
+                       i++
+               }
+
+               // round 5
+               for i < 80 {
+                       alpha = a + (b ^ (c | ^d)) + x[_n[i]] + 0xa953fd4e
+                       s := _r[i]
+                       alpha = (alpha<<s | alpha>>(32-s)) + e
+                       beta = c<<10 | c>>22
+                       a, b, c, d, e = e, alpha, b, beta, d
+
+                       // parallel line
+                       alpha = aa + (bb ^ cc ^ dd) + x[n_[i]]
+                       s = r_[i]
+                       alpha = (alpha<<s | alpha>>(32-s)) + ee
+                       beta = cc<<10 | cc>>22
+                       aa, bb, cc, dd, ee = ee, alpha, bb, beta, dd
+
+                       i++
+               }
+
+               // combine results
+               dd += c + md.s[1]
+               md.s[1] = md.s[2] + d + ee
+               md.s[2] = md.s[3] + e + aa
+               md.s[3] = md.s[4] + a + bb
+               md.s[4] = md.s[0] + b + cc
+               md.s[0] = dd
+
+               p = p[BlockSize:]
+               n += BlockSize
+       }
+       return n
+}