code review 217116: Implementation of the symmetric block cipher Blowfish.

src/pkg/crypto/blowfish/blowfish_test.go

 // 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 blowfish
 
 import (
         "testing"
-        "encoding/binary"
 )
 
 type CryptTest struct {
         key []byte
         in  []byte
         out []byte
 }
 
-// Test vector values are from http://www.schneier.com/code/vectors.txt
+// Test vector values are from http://www.schneier.com/code/vectors.txt.
 var encryptTests = []CryptTest{
         CryptTest{
                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
                 []byte{0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78}},
         CryptTest{
                 []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
                 []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
                 []byte{0x51, 0x86, 0x6F, 0xD5, 0xB8, 0x5E, 0xCB, 0x8A}},
         CryptTest{
@@ skipping 155 matching lines @@
                 pt := make([]byte, len(tt.in))
                 c.Decrypt(tt.out, pt)
                 for j, v := range pt {
                         if v != tt.in[j] {
                                 t.Errorf("Cipher.Decrypt, test vector #%d: plain-text[%d] = %#x, expected %#x", i, j, v, tt.in[j])
                                 break
                         }
                 }
         }
 }
-
-func BenchmarkEncoding(b *testing.B) {
-        var buffer = make([]byte, 8)
-        for i := 0; i < b.N; i++ {
-                packWithBinary(b, buffer)
-        }
-}
-
-func packWithBinary(b *testing.B, ba []byte) {
-        l := binary.BigEndian.Uint32(ba[0:])
-        r := binary.BigEndian.Uint32(ba[4:])
-        // ...
-        binary.BigEndian.PutUint32(ba[0:], l)
-        binary.BigEndian.PutUint32(ba[4:], r)
-        b.SetBytes(int64(8))
-}
-
-func BenchmarkShifts(b *testing.B) {
-        var buffer = make([]byte, 8)
-        for i := 0; i < b.N; i++ {
-                packWithShifts(b, buffer)
-        }
-}
-
-func packWithShifts(b *testing.B, ba []byte) {
-        l := uint32(ba[0])<<24 | uint32(ba[1])<<16 | uint32(ba[2])<<8 | uint32(ba[3])
-        r := uint32(ba[4])<<24 | uint32(ba[5])<<16 | uint32(ba[6])<<8 | uint32(ba[7])
-        // ...
-        ba[0], ba[1], ba[2], ba[3] = byte(l>>24), byte(l>>16), byte(l>>8), byte(l)
-        ba[4], ba[5], ba[6], ba[7] = byte(r>>24), byte(r>>16), byte(r>>8), byte(r)
-        b.SetBytes(int64(8))
-}
-
-func BenchmarkCallF(b *testing.B) {
-        var x uint32 = 0x01020304
-        for i := 0; i < b.N; i++ {
-                for j := 0; j < 16; j++ {
-                        f1(b, x)
-                }
-        }
-}
-
-func f1(b *testing.B, x uint32) {
-        i1 := uint(x & 0xFF)
-        i2 := uint(x >> 8 & 0xFF)
-        i3 := uint(x >> 16 & 0xFF)
-        i4 := uint(x >> 24 & 0xFF)
-        r := s0[i1] + s1[i2]
-        r ^= s2[i3]
-        r += s3[i4]
-        b.SetBytes(int64(4))
-}
-
-func BenchmarkInlineF(b *testing.B) {
-        for i := 0; i < b.N; i++ {
-                f2(b)
-        }
-}
-
-func f2(b *testing.B) {
-        l := ((s0[0] + s1[0]) ^ s2[0]) + s3[0]
-        r := ((s0[1] + s1[1]) ^ s2[1]) + s3[1]
-        l ^= ((s0[2] + s1[2]) ^ s2[2]) + s3[2]
-        r ^= ((s0[3] + s1[3]) ^ s2[3]) + s3[3]
-        l ^= ((s0[4] + s1[4]) ^ s2[4]) + s3[4]
-        r ^= ((s0[5] + s1[5]) ^ s2[5]) + s3[5]
-        l ^= ((s0[6] + s1[6]) ^ s2[6]) + s3[6]
-        r ^= ((s0[7] + s1[7]) ^ s2[7]) + s3[7]
-        l ^= ((s0[8] + s1[8]) ^ s2[8]) + s3[8]
-        r ^= ((s0[9] + s1[9]) ^ s2[9]) + s3[9]
-        l ^= ((s0[10] + s1[10]) ^ s2[10]) + s3[10]
-        r ^= ((s0[11] + s1[11]) ^ s2[11]) + s3[11]
-        l ^= ((s0[12] + s1[12]) ^ s2[12]) + s3[12]
-        r ^= ((s0[13] + s1[13]) ^ s2[13]) + s3[13]
-        l ^= ((s0[14] + s1[14]) ^ s2[14]) + s3[14]
-        r ^= ((s0[15] + s1[15]) ^ s2[15]) + s3[15]
-        b.SetBytes(int64(64))
-}
-
-func BenchmarkUint32Index(b *testing.B) {
-        for i := 0; i < b.N; i++ {
-                f3(b)
-        }
-}
-
-func f3(b *testing.B) {
-        xl, xr := uint32(0x01020304), uint32(0x05060708)
-        xl ^= p[0]
-        xr ^= ((s0[xl>>24] + s1[xl>>16&0xFF]) ^ s2[xl>>8&0xFF]) + s3[xl&0xFF] ^ p[1]
-        xl ^= ((s0[xr>>24] + s1[xr>>16&0xFF]) ^ s2[xr>>8&0xFF]) + s3[xr&0xFF] ^ p[2]
-        xr ^= ((s0[xl>>24] + s1[xl>>16&0xFF]) ^ s2[xl>>8&0xFF]) + s3[xl&0xFF] ^ p[3]
-        xl ^= ((s0[xr>>24] + s1[xr>>16&0xFF]) ^ s2[xr>>8&0xFF]) + s3[xr&0xFF] ^ p[4]
-        xr ^= ((s0[xl>>24] + s1[xl>>16&0xFF]) ^ s2[xl>>8&0xFF]) + s3[xl&0xFF] ^ p[5]
-        xl ^= ((s0[xr>>24] + s1[xr>>16&0xFF]) ^ s2[xr>>8&0xFF]) + s3[xr&0xFF] ^ p[6]
-        xr ^= ((s0[xl>>24] + s1[xl>>16&0xFF]) ^ s2[xl>>8&0xFF]) + s3[xl&0xFF] ^ p[7]
-        xl ^= ((s0[xr>>24] + s1[xr>>16&0xFF]) ^ s2[xr>>8&0xFF]) + s3[xr&0xFF] ^ p[8]
-        xr ^= ((s0[xl>>24] + s1[xl>>16&0xFF]) ^ s2[xl>>8&0xFF]) + s3[xl&0xFF] ^ p[9]
-        xl ^= ((s0[xr>>24] + s1[xr>>16&0xFF]) ^ s2[xr>>8&0xFF]) + s3[xr&0xFF] ^ p[10]
-        xr ^= ((s0[xl>>24] + s1[xl>>16&0xFF]) ^ s2[xl>>8&0xFF]) + s3[xl&0xFF] ^ p[11]
-        xl ^= ((s0[xr>>24] + s1[xr>>16&0xFF]) ^ s2[xr>>8&0xFF]) + s3[xr&0xFF] ^ p[12]
-        xr ^= ((s0[xl>>24] + s1[xl>>16&0xFF]) ^ s2[xl>>8&0xFF]) + s3[xl&0xFF] ^ p[13]
-        xl ^= ((s0[xr>>24] + s1[xr>>16&0xFF]) ^ s2[xr>>8&0xFF]) + s3[xr&0xFF] ^ p[14]
-        xr ^= ((s0[xl>>24] + s1[xl>>16&0xFF]) ^ s2[xl>>8&0xFF]) + s3[xl&0xFF] ^ p[15]
-        xl ^= ((s0[xr>>24] + s1[xr>>16&0xFF]) ^ s2[xr>>8&0xFF]) + s3[xr&0xFF] ^ p[16]
-        xr ^= p[17]
-        b.SetBytes(int64(64))
-}
-
-func BenchmarkByteIndex(b *testing.B) {
-        for i := 0; i < b.N; i++ {
-                f4(b)
-        }
-}
-
-func f4(b *testing.B) {
-        xl, xr := uint32(0x01020304), uint32(0x05060708)
-        xl ^= p[0]
-        xr ^= ((s0[byte(xl>>24)] + s1[byte(xl>>16&0xFF)]) ^ s2[byte(xl>>8&0xFF)]) + s3[byte(xl&0xFF)] ^ p[1]
-        xl ^= ((s0[byte(xr>>24)] + s1[byte(xr>>16&0xFF)]) ^ s2[byte(xr>>8&0xFF)]) + s3[byte(xr&0xFF)] ^ p[2]
-        xr ^= ((s0[byte(xl>>24)] + s1[byte(xl>>16&0xFF)]) ^ s2[byte(xl>>8&0xFF)]) + s3[byte(xl&0xFF)] ^ p[3]
-        xl ^= ((s0[byte(xr>>24)] + s1[byte(xr>>16&0xFF)]) ^ s2[byte(xr>>8&0xFF)]) + s3[byte(xr&0xFF)] ^ p[4]
-        xr ^= ((s0[byte(xl>>24)] + s1[byte(xl>>16&0xFF)]) ^ s2[byte(xl>>8&0xFF)]) + s3[byte(xl&0xFF)] ^ p[5]
-        xl ^= ((s0[byte(xr>>24)] + s1[byte(xr>>16&0xFF)]) ^ s2[byte(xr>>8&0xFF)]) + s3[byte(xr&0xFF)] ^ p[6]
-        xr ^= ((s0[byte(xl>>24)] + s1[byte(xl>>16&0xFF)]) ^ s2[byte(xl>>8&0xFF)]) + s3[byte(xl&0xFF)] ^ p[7]
-        xl ^= ((s0[byte(xr>>24)] + s1[byte(xr>>16&0xFF)]) ^ s2[byte(xr>>8&0xFF)]) + s3[byte(xr&0xFF)] ^ p[8]
-        xr ^= ((s0[byte(xl>>24)] + s1[byte(xl>>16&0xFF)]) ^ s2[byte(xl>>8&0xFF)]) + s3[byte(xl&0xFF)] ^ p[9]
-        xl ^= ((s0[byte(xr>>24)] + s1[byte(xr>>16&0xFF)]) ^ s2[byte(xr>>8&0xFF)]) + s3[byte(xr&0xFF)] ^ p[10]
-        xr ^= ((s0[byte(xl>>24)] + s1[byte(xl>>16&0xFF)]) ^ s2[byte(xl>>8&0xFF)]) + s3[byte(xl&0xFF)] ^ p[11]
-        xl ^= ((s0[byte(xr>>24)] + s1[byte(xr>>16&0xFF)]) ^ s2[byte(xr>>8&0xFF)]) + s3[byte(xr&0xFF)] ^ p[12]
-        xr ^= ((s0[byte(xl>>24)] + s1[byte(xl>>16&0xFF)]) ^ s2[byte(xl>>8&0xFF)]) + s3[byte(xl&0xFF)] ^ p[13]
-        xl ^= ((s0[byte(xr>>24)] + s1[byte(xr>>16&0xFF)]) ^ s2[byte(xr>>8&0xFF)]) + s3[byte(xr&0xFF)] ^ p[14]
-        xr ^= ((s0[byte(xl>>24)] + s1[byte(xl>>16&0xFF)]) ^ s2[byte(xl>>8&0xFF)]) + s3[byte(xl&0xFF)] ^ p[15]
-        xl ^= ((s0[byte(xr>>24)] + s1[byte(xr>>16&0xFF)]) ^ s2[byte(xr>>8&0xFF)]) + s3[byte(xr&0xFF)] ^ p[16]
-        xr ^= p[17]
-        b.SetBytes(int64(64))
-}