libgo/go/crypto/des/des_test.go

   1 // Copyright 2011 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 des
   6
   7 import (
   8         "bytes"
   9         "testing"
  10 )
  11
  12 type CryptTest struct {
  13         key []byte
  14         in  []byte
  15         out []byte
  16 }
  17
  18 // some custom tests for DES
  19 var encryptDESTests = []CryptTest{
  20         {
  21                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  22                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  23                 []byte{0x8c, 0xa6, 0x4d, 0xe9, 0xc1, 0xb1, 0x23, 0xa7}},
  24         {
  25                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  26                 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
  27                 []byte{0x35, 0x55, 0x50, 0xb2, 0x15, 0x0e, 0x24, 0x51}},
  28         {
  29                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  30                 []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  31                 []byte{0x61, 0x7b, 0x3a, 0x0c, 0xe8, 0xf0, 0x71, 0x00}},
  32         {
  33                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  34                 []byte{0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
  35                 []byte{0x92, 0x31, 0xf2, 0x36, 0xff, 0x9a, 0xa9, 0x5c}},
  36         {
  37                 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
  38                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  39                 []byte{0xca, 0xaa, 0xaf, 0x4d, 0xea, 0xf1, 0xdb, 0xae}},
  40         {
  41                 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
  42                 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
  43                 []byte{0x73, 0x59, 0xb2, 0x16, 0x3e, 0x4e, 0xdc, 0x58}},
  44         {
  45                 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
  46                 []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  47                 []byte{0x6d, 0xce, 0x0d, 0xc9, 0x00, 0x65, 0x56, 0xa3}},
  48         {
  49                 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
  50                 []byte{0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
  51                 []byte{0x9e, 0x84, 0xc5, 0xf3, 0x17, 0x0f, 0x8e, 0xff}},
  52         {
  53                 []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  54                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  55                 []byte{0xd5, 0xd4, 0x4f, 0xf7, 0x20, 0x68, 0x3d, 0x0d}},
  56         {
  57                 []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  58                 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
  59                 []byte{0x59, 0x73, 0x23, 0x56, 0xf3, 0x6f, 0xde, 0x06}},
  60         {
  61                 []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  62                 []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  63                 []byte{0x56, 0xcc, 0x09, 0xe7, 0xcf, 0xdc, 0x4c, 0xef}},
  64         {
  65                 []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  66                 []byte{0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
  67                 []byte{0x12, 0xc6, 0x26, 0xaf, 0x05, 0x8b, 0x43, 0x3b}},
  68         {
  69                 []byte{0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
  70                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  71                 []byte{0xa6, 0x8c, 0xdc, 0xa9, 0x0c, 0x90, 0x21, 0xf9}},
  72         {
  73                 []byte{0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
  74                 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
  75                 []byte{0x2a, 0x2b, 0xb0, 0x08, 0xdf, 0x97, 0xc2, 0xf2}},
  76         {
  77                 []byte{0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
  78                 []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  79                 []byte{0xed, 0x39, 0xd9, 0x50, 0xfa, 0x74, 0xbc, 0xc4}},
  80         {
  81                 []byte{0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
  82                 []byte{0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
  83                 []byte{0xa9, 0x33, 0xf6, 0x18, 0x30, 0x23, 0xb3, 0x10}},
  84         {
  85                 []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  86                 []byte{0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
  87                 []byte{0x17, 0x66, 0x8d, 0xfc, 0x72, 0x92, 0x53, 0x2d}},
  88         {
  89                 []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  90                 []byte{0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
  91                 []byte{0xb4, 0xfd, 0x23, 0x16, 0x47, 0xa5, 0xbe, 0xc0}},
  92         {
  93                 []byte{0x0e, 0x32, 0x92, 0x32, 0xea, 0x6d, 0x0d, 0x73},
  94                 []byte{0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87},
  95                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
  96         {
  97                 []byte{0x73, 0x65, 0x63, 0x52, 0x33, 0x74, 0x24, 0x3b}, // "secR3t$;"
  98                 []byte{0x61, 0x20, 0x74, 0x65, 0x73, 0x74, 0x31, 0x32}, // "a test12"
  99                 []byte{0x37, 0x0d, 0xee, 0x2c, 0x1f, 0xb4, 0xf7, 0xa5}},
 100         {
 101                 []byte{0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68}, // "abcdefgh"
 102                 []byte{0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68}, // "abcdefgh"
 103                 []byte{0x2a, 0x8d, 0x69, 0xde, 0x9d, 0x5f, 0xdf, 0xf9}},
 104         {
 105                 []byte{0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68}, // "abcdefgh"
 106                 []byte{0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38}, // "12345678"
 107                 []byte{0x21, 0xc6, 0x0d, 0xa5, 0x34, 0x24, 0x8b, 0xce}},
 108         {
 109                 []byte{0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38}, // "12345678"
 110                 []byte{0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68}, // "abcdefgh"
 111                 []byte{0x94, 0xd4, 0x43, 0x6b, 0xc3, 0xb5, 0xb6, 0x93}},
 112         {
 113                 []byte{0x1f, 0x79, 0x90, 0x5f, 0x88, 0x01, 0xc8, 0x88}, // random
 114                 []byte{0xc7, 0x46, 0x18, 0x73, 0xaf, 0x48, 0x5f, 0xb3}, // random
 115                 []byte{0xb0, 0x93, 0x50, 0x88, 0xf9, 0x92, 0x44, 0x6a}},
 116         {
 117                 []byte{0xe6, 0xf4, 0xf2, 0xdb, 0x31, 0x42, 0x53, 0x01}, // random
 118                 []byte{0xff, 0x3d, 0x25, 0x50, 0x12, 0xe3, 0x4a, 0xc5}, // random
 119                 []byte{0x86, 0x08, 0xd3, 0xd1, 0x6c, 0x2f, 0xd2, 0x55}},
 120         {
 121                 []byte{0x69, 0xc1, 0x9d, 0xc1, 0x15, 0xc5, 0xfb, 0x2b}, // random
 122                 []byte{0x1a, 0x22, 0x5c, 0xaf, 0x1f, 0x1d, 0xa3, 0xf9}, // random
 123                 []byte{0x64, 0xba, 0x31, 0x67, 0x56, 0x91, 0x1e, 0xa7}},
 124         {
 125                 []byte{0x6e, 0x5e, 0xe2, 0x47, 0xc4, 0xbf, 0xf6, 0x51}, // random
 126                 []byte{0x11, 0xc9, 0x57, 0xff, 0x66, 0x89, 0x0e, 0xf0}, // random
 127                 []byte{0x94, 0xc5, 0x35, 0xb2, 0xc5, 0x8b, 0x39, 0x72}},
 128 }
 129
 130 var weakKeyTests = []CryptTest{
 131         {
 132                 []byte{0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 133                 []byte{0x55, 0x74, 0xc0, 0xbd, 0x7c, 0xdf, 0xf7, 0x39}, // random
 134                 nil},
 135         {
 136                 []byte{0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe},
 137                 []byte{0xe8, 0xe1, 0xa7, 0xc1, 0xde, 0x11, 0x89, 0xaa}, // random
 138                 nil},
 139         {
 140                 []byte{0xe0, 0xe0, 0xe0, 0xe0, 0xf1, 0xf1, 0xf1, 0xf1},
 141                 []byte{0x50, 0x6a, 0x4b, 0x94, 0x3b, 0xed, 0x7d, 0xdc}, // random
 142                 nil},
 143         {
 144                 []byte{0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e},
 145                 []byte{0x88, 0x81, 0x56, 0x38, 0xec, 0x3b, 0x1c, 0x97}, // random
 146                 nil},
 147         {
 148                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 149                 []byte{0x17, 0xa0, 0x83, 0x62, 0x32, 0xfe, 0x9a, 0x0b}, // random
 150                 nil},
 151         {
 152                 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
 153                 []byte{0xca, 0x8f, 0xca, 0x1f, 0x50, 0xc5, 0x7b, 0x49}, // random
 154                 nil},
 155         {
 156                 []byte{0xe1, 0xe1, 0xe1, 0xe1, 0xf0, 0xf0, 0xf0, 0xf0},
 157                 []byte{0xb1, 0xea, 0xad, 0x7d, 0xe7, 0xc3, 0x7a, 0x43}, // random
 158                 nil},
 159         {
 160                 []byte{0x1e, 0x1e, 0x1e, 0x1e, 0x0f, 0x0f, 0x0f, 0x0f},
 161                 []byte{0xae, 0x74, 0x7d, 0x6f, 0xef, 0x16, 0xbb, 0x81}, // random
 162                 nil},
 163 }
 164
 165 var semiWeakKeyTests = []CryptTest{
 166         // key and out contain the semi-weak key pair
 167         {
 168                 []byte{0x01, 0x1f, 0x01, 0x1f, 0x01, 0x0e, 0x01, 0x0e},
 169                 []byte{0x12, 0xfa, 0x31, 0x16, 0xf9, 0xc5, 0x0a, 0xe4}, // random
 170                 []byte{0x1f, 0x01, 0x1f, 0x01, 0x0e, 0x01, 0x0e, 0x01}},
 171         {
 172                 []byte{0x01, 0xe0, 0x01, 0xe0, 0x01, 0xf1, 0x01, 0xf1},
 173                 []byte{0xb0, 0x4c, 0x7a, 0xee, 0xd2, 0xe5, 0x4d, 0xb7}, // random
 174                 []byte{0xe0, 0x01, 0xe0, 0x01, 0xf1, 0x01, 0xf1, 0x01}},
 175         {
 176                 []byte{0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe},
 177                 []byte{0xa4, 0x81, 0xcd, 0xb1, 0x64, 0x6f, 0xd3, 0xbc}, // random
 178                 []byte{0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01}},
 179         {
 180                 []byte{0x1f, 0xe0, 0x1f, 0xe0, 0x0e, 0xf1, 0x0e, 0xf1},
 181                 []byte{0xee, 0x27, 0xdd, 0x88, 0x4c, 0x22, 0xcd, 0xce}, // random
 182                 []byte{0xe0, 0x1f, 0xe0, 0x1f, 0xf1, 0x0e, 0xf1, 0x0e}},
 183         {
 184                 []byte{0x1f, 0xfe, 0x1f, 0xfe, 0x0e, 0xfe, 0x0e, 0xfe},
 185                 []byte{0x19, 0x3d, 0xcf, 0x97, 0x70, 0xfb, 0xab, 0xe1}, // random
 186                 []byte{0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x0e, 0xfe, 0x0e}},
 187         {
 188                 []byte{0xe0, 0xfe, 0xe0, 0xfe, 0xf1, 0xfe, 0xf1, 0xfe},
 189                 []byte{0x7c, 0x82, 0x69, 0xe4, 0x1e, 0x86, 0x99, 0xd7}, // random
 190                 []byte{0xfe, 0xe0, 0xfe, 0xe0, 0xfe, 0xf1, 0xfe, 0xf1}},
 191 }
 192
 193 // some custom tests for TripleDES
 194 var encryptTripleDESTests = []CryptTest{
 195         {
 196                 []byte{
 197                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 198                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 199                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 200                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 201                 []byte{0x92, 0x95, 0xb5, 0x9b, 0xb3, 0x84, 0x73, 0x6e}},
 202         {
 203                 []byte{
 204                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 205                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 206                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 207                 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
 208                 []byte{0xc1, 0x97, 0xf5, 0x58, 0x74, 0x8a, 0x20, 0xe7}},
 209         {
 210                 []byte{
 211                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 212                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 213                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
 214                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 215                 []byte{0x3e, 0x68, 0x0a, 0xa7, 0x8b, 0x75, 0xdf, 0x18}},
 216         {
 217                 []byte{
 218                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 219                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 220                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
 221                 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
 222                 []byte{0x6d, 0x6a, 0x4a, 0x64, 0x4c, 0x7b, 0x8c, 0x91}},
 223         {
 224                 []byte{ // "abcdefgh12345678ABCDEFGH"
 225                         0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 226                         0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
 227                         0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48},
 228                 []byte{0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30}, // "00000000"
 229                 []byte{0xe4, 0x61, 0xb7, 0x59, 0x68, 0x8b, 0xff, 0x66}},
 230         {
 231                 []byte{ // "abcdefgh12345678ABCDEFGH"
 232                         0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 233                         0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
 234                         0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48},
 235                 []byte{0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38}, // "12345678"
 236                 []byte{0xdb, 0xd0, 0x92, 0xde, 0xf8, 0x34, 0xff, 0x58}},
 237         {
 238                 []byte{ // "abcdefgh12345678ABCDEFGH"
 239                         0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 240                         0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
 241                         0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48},
 242                 []byte{0xf0, 0xc5, 0x82, 0x22, 0xd3, 0xe6, 0x12, 0xd2}, // random
 243                 []byte{0xba, 0xe4, 0x41, 0xb1, 0x3c, 0x37, 0x4d, 0xf4}},
 244         {
 245                 []byte{ // random
 246                         0xd3, 0x7d, 0x45, 0xee, 0x22, 0xe9, 0xcf, 0x52,
 247                         0xf4, 0x65, 0xa2, 0x4f, 0x70, 0xd1, 0x81, 0x8a,
 248                         0x3d, 0xbe, 0x2f, 0x39, 0xc7, 0x71, 0xd2, 0xe9},
 249                 []byte{0x49, 0x53, 0xc3, 0xe9, 0x78, 0xdf, 0x9f, 0xaf}, // random
 250                 []byte{0x53, 0x40, 0x51, 0x24, 0xd8, 0x3c, 0xf9, 0x88}},
 251         {
 252                 []byte{ // random
 253                         0xcb, 0x10, 0x7d, 0xda, 0x7e, 0x96, 0x57, 0x0a,
 254                         0xe8, 0xeb, 0xe8, 0x07, 0x8e, 0x87, 0xd3, 0x57,
 255                         0xb2, 0x61, 0x12, 0xb8, 0x2a, 0x90, 0xb7, 0x2f},
 256                 []byte{0xa3, 0xc2, 0x60, 0xb1, 0x0b, 0xb7, 0x28, 0x6e}, // random
 257                 []byte{0x56, 0x73, 0x7d, 0xfb, 0xb5, 0xa1, 0xc3, 0xde}},
 258 }
 259
 260 // NIST Special Publication 800-20, Appendix A
 261 // Key for use with Table A.1 tests
 262 var tableA1Key = []byte{
 263         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 264         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 265         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 266 }
 267
 268 // Table A.1 Resulting Ciphertext from the Variable Plaintext Known Answer Test
 269 var tableA1Tests = []CryptTest{
 270         {nil, // 0
 271                 []byte{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 272                 []byte{0x95, 0xf8, 0xa5, 0xe5, 0xdd, 0x31, 0xd9, 0x00}},
 273         {nil, // 1
 274                 []byte{0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 275                 []byte{0xdd, 0x7f, 0x12, 0x1c, 0xa5, 0x01, 0x56, 0x19}},
 276         {nil, // 2
 277                 []byte{0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 278                 []byte{0x2e, 0x86, 0x53, 0x10, 0x4f, 0x38, 0x34, 0xea}},
 279         {nil, // 3
 280                 []byte{0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 281                 []byte{0x4b, 0xd3, 0x88, 0xff, 0x6c, 0xd8, 0x1d, 0x4f}},
 282         {nil, // 4
 283                 []byte{0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 284                 []byte{0x20, 0xb9, 0xe7, 0x67, 0xb2, 0xfb, 0x14, 0x56}},
 285         {nil, // 5
 286                 []byte{0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 287                 []byte{0x55, 0x57, 0x93, 0x80, 0xd7, 0x71, 0x38, 0xef}},
 288         {nil, // 6
 289                 []byte{0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 290                 []byte{0x6c, 0xc5, 0xde, 0xfa, 0xaf, 0x04, 0x51, 0x2f}},
 291         {nil, // 7
 292                 []byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 293                 []byte{0x0d, 0x9f, 0x27, 0x9b, 0xa5, 0xd8, 0x72, 0x60}},
 294         {nil, // 8
 295                 []byte{0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 296                 []byte{0xd9, 0x03, 0x1b, 0x02, 0x71, 0xbd, 0x5a, 0x0a}},
 297         {nil, // 9
 298                 []byte{0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 299                 []byte{0x42, 0x42, 0x50, 0xb3, 0x7c, 0x3d, 0xd9, 0x51}},
 300         {nil, // 10
 301                 []byte{0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 302                 []byte{0xb8, 0x06, 0x1b, 0x7e, 0xcd, 0x9a, 0x21, 0xe5}},
 303         {nil, // 11
 304                 []byte{0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 305                 []byte{0xf1, 0x5d, 0x0f, 0x28, 0x6b, 0x65, 0xbd, 0x28}},
 306         {nil, // 12
 307                 []byte{0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 308                 []byte{0xad, 0xd0, 0xcc, 0x8d, 0x6e, 0x5d, 0xeb, 0xa1}},
 309         {nil, // 13
 310                 []byte{0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 311                 []byte{0xe6, 0xd5, 0xf8, 0x27, 0x52, 0xad, 0x63, 0xd1}},
 312         {nil, // 14
 313                 []byte{0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 314                 []byte{0xec, 0xbf, 0xe3, 0xbd, 0x3f, 0x59, 0x1a, 0x5e}},
 315         {nil, // 15
 316                 []byte{0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 317                 []byte{0xf3, 0x56, 0x83, 0x43, 0x79, 0xd1, 0x65, 0xcd}},
 318         {nil, // 16
 319                 []byte{0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00},
 320                 []byte{0x2b, 0x9f, 0x98, 0x2f, 0x20, 0x03, 0x7f, 0xa9}},
 321         {nil, // 17
 322                 []byte{0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00},
 323                 []byte{0x88, 0x9d, 0xe0, 0x68, 0xa1, 0x6f, 0x0b, 0xe6}},
 324         {nil, // 18
 325                 []byte{0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00},
 326                 []byte{0xe1, 0x9e, 0x27, 0x5d, 0x84, 0x6a, 0x12, 0x98}},
 327         {nil, // 19
 328                 []byte{0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00},
 329                 []byte{0x32, 0x9a, 0x8e, 0xd5, 0x23, 0xd7, 0x1a, 0xec}},
 330         {nil, // 20
 331                 []byte{0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00},
 332                 []byte{0xe7, 0xfc, 0xe2, 0x25, 0x57, 0xd2, 0x3c, 0x97}},
 333         {nil, // 21
 334                 []byte{0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00},
 335                 []byte{0x12, 0xa9, 0xf5, 0x81, 0x7f, 0xf2, 0xd6, 0x5d}},
 336         {nil, // 22
 337                 []byte{0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00},
 338                 []byte{0xa4, 0x84, 0xc3, 0xad, 0x38, 0xdc, 0x9c, 0x19}},
 339         {nil, // 23
 340                 []byte{0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
 341                 []byte{0xfb, 0xe0, 0x0a, 0x8a, 0x1e, 0xf8, 0xad, 0x72}},
 342         {nil, // 24
 343                 []byte{0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00},
 344                 []byte{0x75, 0x0d, 0x07, 0x94, 0x07, 0x52, 0x13, 0x63}},
 345         {nil, // 25
 346                 []byte{0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00},
 347                 []byte{0x64, 0xfe, 0xed, 0x9c, 0x72, 0x4c, 0x2f, 0xaf}},
 348         {nil, // 26
 349                 []byte{0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00},
 350                 []byte{0xf0, 0x2b, 0x26, 0x3b, 0x32, 0x8e, 0x2b, 0x60}},
 351         {nil, // 27
 352                 []byte{0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00},
 353                 []byte{0x9d, 0x64, 0x55, 0x5a, 0x9a, 0x10, 0xb8, 0x52}},
 354         {nil, // 28
 355                 []byte{0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00},
 356                 []byte{0xd1, 0x06, 0xff, 0x0b, 0xed, 0x52, 0x55, 0xd7}},
 357         {nil, // 29
 358                 []byte{0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00},
 359                 []byte{0xe1, 0x65, 0x2c, 0x6b, 0x13, 0x8c, 0x64, 0xa5}},
 360         {nil, // 30
 361                 []byte{0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00},
 362                 []byte{0xe4, 0x28, 0x58, 0x11, 0x86, 0xec, 0x8f, 0x46}},
 363         {nil, // 31
 364                 []byte{0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00},
 365                 []byte{0xae, 0xb5, 0xf5, 0xed, 0xe2, 0x2d, 0x1a, 0x36}},
 366         {nil, // 32
 367                 []byte{0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00},
 368                 []byte{0xe9, 0x43, 0xd7, 0x56, 0x8a, 0xec, 0x0c, 0x5c}},
 369         {nil, // 33
 370                 []byte{0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00},
 371                 []byte{0xdf, 0x98, 0xc8, 0x27, 0x6f, 0x54, 0xb0, 0x4b}},
 372         {nil, // 34
 373                 []byte{0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00},
 374                 []byte{0xb1, 0x60, 0xe4, 0x68, 0x0f, 0x6c, 0x69, 0x6f}},
 375         {nil, // 35
 376                 []byte{0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00},
 377                 []byte{0xfa, 0x07, 0x52, 0xb0, 0x7d, 0x9c, 0x4a, 0xb8}},
 378         {nil, // 36
 379                 []byte{0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00},
 380                 []byte{0xca, 0x3a, 0x2b, 0x03, 0x6d, 0xbc, 0x85, 0x02}},
 381         {nil, // 37
 382                 []byte{0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00},
 383                 []byte{0x5e, 0x09, 0x05, 0x51, 0x7b, 0xb5, 0x9b, 0xcf}},
 384         {nil, // 38
 385                 []byte{0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00},
 386                 []byte{0x81, 0x4e, 0xeb, 0x3b, 0x91, 0xd9, 0x07, 0x26}},
 387         {nil, // 39
 388                 []byte{0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00},
 389                 []byte{0x4d, 0x49, 0xdb, 0x15, 0x32, 0x91, 0x9c, 0x9f}},
 390         {nil, // 40
 391                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00},
 392                 []byte{0x25, 0xeb, 0x5f, 0xc3, 0xf8, 0xcf, 0x06, 0x21}},
 393         {nil, // 41
 394                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00},
 395                 []byte{0xab, 0x6a, 0x20, 0xc0, 0x62, 0x0d, 0x1c, 0x6f}},
 396         {nil, // 42
 397                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00},
 398                 []byte{0x79, 0xe9, 0x0d, 0xbc, 0x98, 0xf9, 0x2c, 0xca}},
 399         {nil, // 43
 400                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00},
 401                 []byte{0x86, 0x6e, 0xce, 0xdd, 0x80, 0x72, 0xbb, 0x0e}},
 402         {nil, // 44
 403                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00},
 404                 []byte{0x8b, 0x54, 0x53, 0x6f, 0x2f, 0x3e, 0x64, 0xa8}},
 405         {nil, // 45
 406                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00},
 407                 []byte{0xea, 0x51, 0xd3, 0x97, 0x55, 0x95, 0xb8, 0x6b}},
 408         {nil, // 46
 409                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00},
 410                 []byte{0xca, 0xff, 0xc6, 0xac, 0x45, 0x42, 0xde, 0x31}},
 411         {nil, // 47
 412                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00},
 413                 []byte{0x8d, 0xd4, 0x5a, 0x2d, 0xdf, 0x90, 0x79, 0x6c}},
 414         {nil, // 48
 415                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00},
 416                 []byte{0x10, 0x29, 0xd5, 0x5e, 0x88, 0x0e, 0xc2, 0xd0}},
 417         {nil, // 49
 418                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00},
 419                 []byte{0x5d, 0x86, 0xcb, 0x23, 0x63, 0x9d, 0xbe, 0xa9}},
 420         {nil, // 50
 421                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00},
 422                 []byte{0x1d, 0x1c, 0xa8, 0x53, 0xae, 0x7c, 0x0c, 0x5f}},
 423         {nil, // 51
 424                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00},
 425                 []byte{0xce, 0x33, 0x23, 0x29, 0x24, 0x8f, 0x32, 0x28}},
 426         {nil, // 52
 427                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00},
 428                 []byte{0x84, 0x05, 0xd1, 0xab, 0xe2, 0x4f, 0xb9, 0x42}},
 429         {nil, // 53
 430                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00},
 431                 []byte{0xe6, 0x43, 0xd7, 0x80, 0x90, 0xca, 0x42, 0x07}},
 432         {nil, // 54
 433                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00},
 434                 []byte{0x48, 0x22, 0x1b, 0x99, 0x37, 0x74, 0x8a, 0x23}},
 435         {nil, // 55
 436                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00},
 437                 []byte{0xdd, 0x7c, 0x0b, 0xbd, 0x61, 0xfa, 0xfd, 0x54}},
 438         {nil, // 56
 439                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80},
 440                 []byte{0x2f, 0xbc, 0x29, 0x1a, 0x57, 0x0d, 0xb5, 0xc4}},
 441         {nil, // 57
 442                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40},
 443                 []byte{0xe0, 0x7c, 0x30, 0xd7, 0xe4, 0xe2, 0x6e, 0x12}},
 444         {nil, // 58
 445                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20},
 446                 []byte{0x09, 0x53, 0xe2, 0x25, 0x8e, 0x8e, 0x90, 0xa1}},
 447         {nil, // 59
 448                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
 449                 []byte{0x5b, 0x71, 0x1b, 0xc4, 0xce, 0xeb, 0xf2, 0xee}},
 450         {nil, // 60
 451                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08},
 452                 []byte{0xcc, 0x08, 0x3f, 0x1e, 0x6d, 0x9e, 0x85, 0xf6}},
 453         {nil, // 61
 454                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04},
 455                 []byte{0xd2, 0xfd, 0x88, 0x67, 0xd5, 0x0d, 0x2d, 0xfe}},
 456         {nil, // 62
 457                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
 458                 []byte{0x06, 0xe7, 0xea, 0x22, 0xce, 0x92, 0x70, 0x8f}},
 459         {nil, // 63
 460                 []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
 461                 []byte{0x16, 0x6b, 0x40, 0xb4, 0x4a, 0xba, 0x4b, 0xd6}},
 462 }
 463
 464 // Plaintext for use with Table A.2 tests
 465 var tableA2Plaintext = []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
 466
 467 // Table A.2 Resulting Ciphertext from the Variable Key Known Answer Test
 468 var tableA2Tests = []CryptTest{
 469         { // 0
 470                 []byte{
 471                         0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 472                         0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 473                         0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 474                 nil,
 475                 []byte{0x95, 0xa8, 0xd7, 0x28, 0x13, 0xda, 0xa9, 0x4d}},
 476         { // 1
 477                 []byte{
 478                         0x40, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 479                         0x40, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 480                         0x40, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 481                 nil,
 482                 []byte{0x0e, 0xec, 0x14, 0x87, 0xdd, 0x8c, 0x26, 0xd5}},
 483         { // 2
 484                 []byte{
 485                         0x20, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 486                         0x20, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 487                         0x20, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 488                 nil,
 489                 []byte{0x7a, 0xd1, 0x6f, 0xfb, 0x79, 0xc4, 0x59, 0x26}},
 490         { // 3
 491                 []byte{
 492                         0x10, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 493                         0x10, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 494                         0x10, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 495                 nil,
 496                 []byte{0xd3, 0x74, 0x62, 0x94, 0xca, 0x6a, 0x6c, 0xf3}},
 497         { // 4
 498                 []byte{
 499                         0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 500                         0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 501                         0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 502                 nil,
 503                 []byte{0x80, 0x9f, 0x5f, 0x87, 0x3c, 0x1f, 0xd7, 0x61}},
 504         { // 5
 505                 []byte{
 506                         0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 507                         0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 508                         0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 509                 nil,
 510                 []byte{0xc0, 0x2f, 0xaf, 0xfe, 0xc9, 0x89, 0xd1, 0xfc}},
 511         { // 6
 512                 []byte{
 513                         0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 514                         0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 515                         0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 516                 nil,
 517                 []byte{0x46, 0x15, 0xaa, 0x1d, 0x33, 0xe7, 0x2f, 0x10}},
 518         { // 7
 519                 []byte{
 520                         0x01, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 521                         0x01, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 522                         0x01, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 523                 nil,
 524                 []byte{0x20, 0x55, 0x12, 0x33, 0x50, 0xc0, 0x08, 0x58}},
 525         { // 8
 526                 []byte{
 527                         0x01, 0x40, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 528                         0x01, 0x40, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 529                         0x01, 0x40, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 530                 nil,
 531                 []byte{0xdf, 0x3b, 0x99, 0xd6, 0x57, 0x73, 0x97, 0xc8}},
 532         { // 9
 533                 []byte{
 534                         0x01, 0x20, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 535                         0x01, 0x20, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 536                         0x01, 0x20, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 537                 nil,
 538                 []byte{0x31, 0xfe, 0x17, 0x36, 0x9b, 0x52, 0x88, 0xc9}},
 539         { // 10
 540                 []byte{
 541                         0x01, 0x10, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 542                         0x01, 0x10, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 543                         0x01, 0x10, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 544                 nil,
 545                 []byte{0xdf, 0xdd, 0x3c, 0xc6, 0x4d, 0xae, 0x16, 0x42}},
 546         { // 11
 547                 []byte{
 548                         0x01, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 549                         0x01, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 550                         0x01, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 551                 nil,
 552                 []byte{0x17, 0x8c, 0x83, 0xce, 0x2b, 0x39, 0x9d, 0x94}},
 553         { // 12
 554                 []byte{
 555                         0x01, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 556                         0x01, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 557                         0x01, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 558                 nil,
 559                 []byte{0x50, 0xf6, 0x36, 0x32, 0x4a, 0x9b, 0x7f, 0x80}},
 560         { // 13
 561                 []byte{
 562                         0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 563                         0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 564                         0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 565                 nil,
 566                 []byte{0xa8, 0x46, 0x8e, 0xe3, 0xbc, 0x18, 0xf0, 0x6d}},
 567         { // 14
 568                 []byte{
 569                         0x01, 0x01, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01,
 570                         0x01, 0x01, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01,
 571                         0x01, 0x01, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01},
 572                 nil,
 573                 []byte{0xa2, 0xdc, 0x9e, 0x92, 0xfd, 0x3c, 0xde, 0x92}},
 574         { // 15
 575                 []byte{
 576                         0x01, 0x01, 0x40, 0x01, 0x01, 0x01, 0x01, 0x01,
 577                         0x01, 0x01, 0x40, 0x01, 0x01, 0x01, 0x01, 0x01,
 578                         0x01, 0x01, 0x40, 0x01, 0x01, 0x01, 0x01, 0x01},
 579                 nil,
 580                 []byte{0xca, 0xc0, 0x9f, 0x79, 0x7d, 0x03, 0x12, 0x87}},
 581         { // 16
 582                 []byte{
 583                         0x01, 0x01, 0x20, 0x01, 0x01, 0x01, 0x01, 0x01,
 584                         0x01, 0x01, 0x20, 0x01, 0x01, 0x01, 0x01, 0x01,
 585                         0x01, 0x01, 0x20, 0x01, 0x01, 0x01, 0x01, 0x01},
 586                 nil,
 587                 []byte{0x90, 0xba, 0x68, 0x0b, 0x22, 0xae, 0xb5, 0x25}},
 588         { // 17
 589                 []byte{
 590                         0x01, 0x01, 0x10, 0x01, 0x01, 0x01, 0x01, 0x01,
 591                         0x01, 0x01, 0x10, 0x01, 0x01, 0x01, 0x01, 0x01,
 592                         0x01, 0x01, 0x10, 0x01, 0x01, 0x01, 0x01, 0x01},
 593                 nil,
 594                 []byte{0xce, 0x7a, 0x24, 0xf3, 0x50, 0xe2, 0x80, 0xb6}},
 595         { // 18
 596                 []byte{
 597                         0x01, 0x01, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01,
 598                         0x01, 0x01, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01,
 599                         0x01, 0x01, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01},
 600                 nil,
 601                 []byte{0x88, 0x2b, 0xff, 0x0a, 0xa0, 0x1a, 0x0b, 0x87}},
 602         { // 19
 603                 []byte{
 604                         0x01, 0x01, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01,
 605                         0x01, 0x01, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01,
 606                         0x01, 0x01, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01},
 607                 nil,
 608                 []byte{0x25, 0x61, 0x02, 0x88, 0x92, 0x45, 0x11, 0xc2}},
 609         { // 20
 610                 []byte{
 611                         0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01,
 612                         0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01,
 613                         0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01},
 614                 nil,
 615                 []byte{0xc7, 0x15, 0x16, 0xc2, 0x9c, 0x75, 0xd1, 0x70}},
 616         { // 21
 617                 []byte{
 618                         0x01, 0x01, 0x01, 0x80, 0x01, 0x01, 0x01, 0x01,
 619                         0x01, 0x01, 0x01, 0x80, 0x01, 0x01, 0x01, 0x01,
 620                         0x01, 0x01, 0x01, 0x80, 0x01, 0x01, 0x01, 0x01},
 621                 nil,
 622                 []byte{0x51, 0x99, 0xc2, 0x9a, 0x52, 0xc9, 0xf0, 0x59}},
 623         { // 22
 624                 []byte{
 625                         0x01, 0x01, 0x01, 0x40, 0x01, 0x01, 0x01, 0x01,
 626                         0x01, 0x01, 0x01, 0x40, 0x01, 0x01, 0x01, 0x01,
 627                         0x01, 0x01, 0x01, 0x40, 0x01, 0x01, 0x01, 0x01},
 628                 nil,
 629                 []byte{0xc2, 0x2f, 0x0a, 0x29, 0x4a, 0x71, 0xf2, 0x9f}},
 630         { // 23
 631                 []byte{
 632                         0x01, 0x01, 0x01, 0x20, 0x01, 0x01, 0x01, 0x01,
 633                         0x01, 0x01, 0x01, 0x20, 0x01, 0x01, 0x01, 0x01,
 634                         0x01, 0x01, 0x01, 0x20, 0x01, 0x01, 0x01, 0x01},
 635                 nil,
 636                 []byte{0xee, 0x37, 0x14, 0x83, 0x71, 0x4c, 0x02, 0xea}},
 637         { // 24
 638                 []byte{
 639                         0x01, 0x01, 0x01, 0x10, 0x01, 0x01, 0x01, 0x01,
 640                         0x01, 0x01, 0x01, 0x10, 0x01, 0x01, 0x01, 0x01,
 641                         0x01, 0x01, 0x01, 0x10, 0x01, 0x01, 0x01, 0x01},
 642                 nil,
 643                 []byte{0xa8, 0x1f, 0xbd, 0x44, 0x8f, 0x9e, 0x52, 0x2f}},
 644         { // 25
 645                 []byte{
 646                         0x01, 0x01, 0x01, 0x08, 0x01, 0x01, 0x01, 0x01,
 647                         0x01, 0x01, 0x01, 0x08, 0x01, 0x01, 0x01, 0x01,
 648                         0x01, 0x01, 0x01, 0x08, 0x01, 0x01, 0x01, 0x01},
 649                 nil,
 650                 []byte{0x4f, 0x64, 0x4c, 0x92, 0xe1, 0x92, 0xdf, 0xed}},
 651         { // 26
 652                 []byte{
 653                         0x01, 0x01, 0x01, 0x04, 0x01, 0x01, 0x01, 0x01,
 654                         0x01, 0x01, 0x01, 0x04, 0x01, 0x01, 0x01, 0x01,
 655                         0x01, 0x01, 0x01, 0x04, 0x01, 0x01, 0x01, 0x01},
 656                 nil,
 657                 []byte{0x1a, 0xfa, 0x9a, 0x66, 0xa6, 0xdf, 0x92, 0xae}},
 658         { // 27
 659                 []byte{
 660                         0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01,
 661                         0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01,
 662                         0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01},
 663                 nil,
 664                 []byte{0xb3, 0xc1, 0xcc, 0x71, 0x5c, 0xb8, 0x79, 0xd8}},
 665         { // 28
 666                 []byte{
 667                         0x01, 0x01, 0x01, 0x01, 0x80, 0x01, 0x01, 0x01,
 668                         0x01, 0x01, 0x01, 0x01, 0x80, 0x01, 0x01, 0x01,
 669                         0x01, 0x01, 0x01, 0x01, 0x80, 0x01, 0x01, 0x01},
 670                 nil,
 671                 []byte{0x19, 0xd0, 0x32, 0xe6, 0x4a, 0xb0, 0xbd, 0x8b}},
 672         { // 29
 673                 []byte{
 674                         0x01, 0x01, 0x01, 0x01, 0x40, 0x01, 0x01, 0x01,
 675                         0x01, 0x01, 0x01, 0x01, 0x40, 0x01, 0x01, 0x01,
 676                         0x01, 0x01, 0x01, 0x01, 0x40, 0x01, 0x01, 0x01},
 677                 nil,
 678                 []byte{0x3c, 0xfa, 0xa7, 0xa7, 0xdc, 0x87, 0x20, 0xdc}},
 679         { // 30
 680                 []byte{
 681                         0x01, 0x01, 0x01, 0x01, 0x20, 0x01, 0x01, 0x01,
 682                         0x01, 0x01, 0x01, 0x01, 0x20, 0x01, 0x01, 0x01,
 683                         0x01, 0x01, 0x01, 0x01, 0x20, 0x01, 0x01, 0x01},
 684                 nil,
 685                 []byte{0xb7, 0x26, 0x5f, 0x7f, 0x44, 0x7a, 0xc6, 0xf3}},
 686         { // 31
 687                 []byte{
 688                         0x01, 0x01, 0x01, 0x01, 0x10, 0x01, 0x01, 0x01,
 689                         0x01, 0x01, 0x01, 0x01, 0x10, 0x01, 0x01, 0x01,
 690                         0x01, 0x01, 0x01, 0x01, 0x10, 0x01, 0x01, 0x01},
 691                 nil,
 692                 []byte{0x9d, 0xb7, 0x3b, 0x3c, 0x0d, 0x16, 0x3f, 0x54}},
 693         { // 32
 694                 []byte{
 695                         0x01, 0x01, 0x01, 0x01, 0x08, 0x01, 0x01, 0x01,
 696                         0x01, 0x01, 0x01, 0x01, 0x08, 0x01, 0x01, 0x01,
 697                         0x01, 0x01, 0x01, 0x01, 0x08, 0x01, 0x01, 0x01},
 698                 nil,
 699                 []byte{0x81, 0x81, 0xb6, 0x5b, 0xab, 0xf4, 0xa9, 0x75}},
 700         { // 33
 701                 []byte{
 702                         0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x01, 0x01,
 703                         0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x01, 0x01,
 704                         0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x01, 0x01},
 705                 nil,
 706                 []byte{0x93, 0xc9, 0xb6, 0x40, 0x42, 0xea, 0xa2, 0x40}},
 707         { // 34
 708                 []byte{
 709                         0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01,
 710                         0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01,
 711                         0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01},
 712                 nil,
 713                 []byte{0x55, 0x70, 0x53, 0x08, 0x29, 0x70, 0x55, 0x92}},
 714         { // 35
 715                 []byte{
 716                         0x01, 0x01, 0x01, 0x01, 0x01, 0x80, 0x01, 0x01,
 717                         0x01, 0x01, 0x01, 0x01, 0x01, 0x80, 0x01, 0x01,
 718                         0x01, 0x01, 0x01, 0x01, 0x01, 0x80, 0x01, 0x01},
 719                 nil,
 720                 []byte{0x86, 0x38, 0x80, 0x9e, 0x87, 0x87, 0x87, 0xa0}},
 721         { // 36
 722                 []byte{
 723                         0x01, 0x01, 0x01, 0x01, 0x01, 0x40, 0x01, 0x01,
 724                         0x01, 0x01, 0x01, 0x01, 0x01, 0x40, 0x01, 0x01,
 725                         0x01, 0x01, 0x01, 0x01, 0x01, 0x40, 0x01, 0x01},
 726                 nil,
 727                 []byte{0x41, 0xb9, 0xa7, 0x9a, 0xf7, 0x9a, 0xc2, 0x08}},
 728         { // 37
 729                 []byte{
 730                         0x01, 0x01, 0x01, 0x01, 0x01, 0x20, 0x01, 0x01,
 731                         0x01, 0x01, 0x01, 0x01, 0x01, 0x20, 0x01, 0x01,
 732                         0x01, 0x01, 0x01, 0x01, 0x01, 0x20, 0x01, 0x01},
 733                 nil,
 734                 []byte{0x7a, 0x9b, 0xe4, 0x2f, 0x20, 0x09, 0xa8, 0x92}},
 735         { // 38
 736                 []byte{
 737                         0x01, 0x01, 0x01, 0x01, 0x01, 0x10, 0x01, 0x01,
 738                         0x01, 0x01, 0x01, 0x01, 0x01, 0x10, 0x01, 0x01,
 739                         0x01, 0x01, 0x01, 0x01, 0x01, 0x10, 0x01, 0x01},
 740                 nil,
 741                 []byte{0x29, 0x03, 0x8d, 0x56, 0xba, 0x6d, 0x27, 0x45}},
 742         { // 39
 743                 []byte{
 744                         0x01, 0x01, 0x01, 0x01, 0x01, 0x08, 0x01, 0x01,
 745                         0x01, 0x01, 0x01, 0x01, 0x01, 0x08, 0x01, 0x01,
 746                         0x01, 0x01, 0x01, 0x01, 0x01, 0x08, 0x01, 0x01},
 747                 nil,
 748                 []byte{0x54, 0x95, 0xc6, 0xab, 0xf1, 0xe5, 0xdf, 0x51}},
 749         { // 40
 750                 []byte{
 751                         0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x01,
 752                         0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x01,
 753                         0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x01},
 754                 nil,
 755                 []byte{0xae, 0x13, 0xdb, 0xd5, 0x61, 0x48, 0x89, 0x33}},
 756         { // 41
 757                 []byte{
 758                         0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01,
 759                         0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01,
 760                         0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01},
 761                 nil,
 762                 []byte{0x02, 0x4d, 0x1f, 0xfa, 0x89, 0x04, 0xe3, 0x89}},
 763         { // 42
 764                 []byte{
 765                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x80, 0x01,
 766                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x80, 0x01,
 767                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x80, 0x01},
 768                 nil,
 769                 []byte{0xd1, 0x39, 0x97, 0x12, 0xf9, 0x9b, 0xf0, 0x2e}},
 770         { // 43
 771                 []byte{
 772                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x40, 0x01,
 773                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x40, 0x01,
 774                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x40, 0x01},
 775                 nil,
 776                 []byte{0x14, 0xc1, 0xd7, 0xc1, 0xcf, 0xfe, 0xc7, 0x9e}},
 777         { // 44
 778                 []byte{
 779                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x20, 0x01,
 780                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x20, 0x01,
 781                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x20, 0x01},
 782                 nil,
 783                 []byte{0x1d, 0xe5, 0x27, 0x9d, 0xae, 0x3b, 0xed, 0x6f}},
 784         { // 45
 785                 []byte{
 786                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x10, 0x01,
 787                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x10, 0x01,
 788                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x10, 0x01},
 789                 nil,
 790                 []byte{0xe9, 0x41, 0xa3, 0x3f, 0x85, 0x50, 0x13, 0x03}},
 791         { // 46
 792                 []byte{
 793                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x08, 0x01,
 794                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x08, 0x01,
 795                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x08, 0x01},
 796                 nil,
 797                 []byte{0xda, 0x99, 0xdb, 0xbc, 0x9a, 0x03, 0xf3, 0x79}},
 798         { // 47
 799                 []byte{
 800                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x01,
 801                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x01,
 802                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x01},
 803                 nil,
 804                 []byte{0xb7, 0xfc, 0x92, 0xf9, 0x1d, 0x8e, 0x92, 0xe9}},
 805         { // 48
 806                 []byte{
 807                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01,
 808                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01,
 809                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01},
 810                 nil,
 811                 []byte{0xae, 0x8e, 0x5c, 0xaa, 0x3c, 0xa0, 0x4e, 0x85}},
 812         { // 49
 813                 []byte{
 814                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x80,
 815                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x80,
 816                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x80},
 817                 nil,
 818                 []byte{0x9c, 0xc6, 0x2d, 0xf4, 0x3b, 0x6e, 0xed, 0x74}},
 819         { // 50
 820                 []byte{
 821                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x40,
 822                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x40,
 823                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x40},
 824                 nil,
 825                 []byte{0xd8, 0x63, 0xdb, 0xb5, 0xc5, 0x9a, 0x91, 0xa0}},
 826         { // 50
 827                 []byte{
 828                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x20,
 829                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x20,
 830                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x20},
 831                 nil,
 832                 []byte{0xa1, 0xab, 0x21, 0x90, 0x54, 0x5b, 0x91, 0xd7}},
 833         { // 52
 834                 []byte{
 835                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x10,
 836                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x10,
 837                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x10},
 838                 nil,
 839                 []byte{0x08, 0x75, 0x04, 0x1e, 0x64, 0xc5, 0x70, 0xf7}},
 840         { // 53
 841                 []byte{
 842                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x08,
 843                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x08,
 844                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x08},
 845                 nil,
 846                 []byte{0x5a, 0x59, 0x45, 0x28, 0xbe, 0xbe, 0xf1, 0xcc}},
 847         { // 54
 848                 []byte{
 849                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04,
 850                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04,
 851                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04},
 852                 nil,
 853                 []byte{0xfc, 0xdb, 0x32, 0x91, 0xde, 0x21, 0xf0, 0xc0}},
 854         { // 55
 855                 []byte{
 856                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02,
 857                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02,
 858                         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02},
 859                 nil,
 860                 []byte{0x86, 0x9e, 0xfd, 0x7f, 0x9f, 0x26, 0x5a, 0x09}},
 861 }
 862
 863 // Plaintext for use with Table A.3 tests
 864 var tableA3Plaintext = []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
 865
 866 // Table A.3 Values To Be Used for the Permutation Operation Known Answer Test
 867 var tableA3Tests = []CryptTest{
 868         { // 0
 869                 []byte{
 870                         0x10, 0x46, 0x91, 0x34, 0x89, 0x98, 0x01, 0x31,
 871                         0x10, 0x46, 0x91, 0x34, 0x89, 0x98, 0x01, 0x31,
 872                         0x10, 0x46, 0x91, 0x34, 0x89, 0x98, 0x01, 0x31,
 873                 },
 874                 nil,
 875                 []byte{0x88, 0xd5, 0x5e, 0x54, 0xf5, 0x4c, 0x97, 0xb4}},
 876         { // 1
 877                 []byte{
 878                         0x10, 0x07, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20,
 879                         0x10, 0x07, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20,
 880                         0x10, 0x07, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20,
 881                 },
 882                 nil,
 883                 []byte{0x0c, 0x0c, 0xc0, 0x0c, 0x83, 0xea, 0x48, 0xfd}},
 884         { // 2
 885                 []byte{
 886                         0x10, 0x07, 0x10, 0x34, 0xc8, 0x98, 0x01, 0x20,
 887                         0x10, 0x07, 0x10, 0x34, 0xc8, 0x98, 0x01, 0x20,
 888                         0x10, 0x07, 0x10, 0x34, 0xc8, 0x98, 0x01, 0x20,
 889                 },
 890                 nil,
 891                 []byte{0x83, 0xbc, 0x8e, 0xf3, 0xa6, 0x57, 0x01, 0x83}},
 892         { // 3
 893                 []byte{
 894                         0x10, 0x46, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20,
 895                         0x10, 0x46, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20,
 896                         0x10, 0x46, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20,
 897                 },
 898                 nil,
 899                 []byte{0xdf, 0x72, 0x5d, 0xca, 0xd9, 0x4e, 0xa2, 0xe9}},
 900         { // 4
 901                 []byte{
 902                         0x10, 0x86, 0x91, 0x15, 0x19, 0x19, 0x01, 0x01,
 903                         0x10, 0x86, 0x91, 0x15, 0x19, 0x19, 0x01, 0x01,
 904                         0x10, 0x86, 0x91, 0x15, 0x19, 0x19, 0x01, 0x01,
 905                 },
 906                 nil,
 907                 []byte{0xe6, 0x52, 0xb5, 0x3b, 0x55, 0x0b, 0xe8, 0xb0}},
 908         { // 5
 909                 []byte{
 910                         0x10, 0x86, 0x91, 0x15, 0x19, 0x58, 0x01, 0x01,
 911                         0x10, 0x86, 0x91, 0x15, 0x19, 0x58, 0x01, 0x01,
 912                         0x10, 0x86, 0x91, 0x15, 0x19, 0x58, 0x01, 0x01,
 913                 },
 914                 nil,
 915                 []byte{0xaf, 0x52, 0x71, 0x20, 0xc4, 0x85, 0xcb, 0xb0}},
 916         { // 6
 917                 []byte{
 918                         0x51, 0x07, 0xb0, 0x15, 0x19, 0x58, 0x01, 0x01,
 919                         0x51, 0x07, 0xb0, 0x15, 0x19, 0x58, 0x01, 0x01,
 920                         0x51, 0x07, 0xb0, 0x15, 0x19, 0x58, 0x01, 0x01,
 921                 },
 922                 nil,
 923                 []byte{0x0f, 0x04, 0xce, 0x39, 0x3d, 0xb9, 0x26, 0xd5}},
 924         { // 7
 925                 []byte{
 926                         0x10, 0x07, 0xb0, 0x15, 0x19, 0x19, 0x01, 0x01,
 927                         0x10, 0x07, 0xb0, 0x15, 0x19, 0x19, 0x01, 0x01,
 928                         0x10, 0x07, 0xb0, 0x15, 0x19, 0x19, 0x01, 0x01,
 929                 },
 930                 nil,
 931                 []byte{0xc9, 0xf0, 0x0f, 0xfc, 0x74, 0x07, 0x90, 0x67}},
 932         { // 8
 933                 []byte{
 934                         0x31, 0x07, 0x91, 0x54, 0x98, 0x08, 0x01, 0x01,
 935                         0x31, 0x07, 0x91, 0x54, 0x98, 0x08, 0x01, 0x01,
 936                         0x31, 0x07, 0x91, 0x54, 0x98, 0x08, 0x01, 0x01,
 937                 },
 938                 nil,
 939                 []byte{0x7c, 0xfd, 0x82, 0xa5, 0x93, 0x25, 0x2b, 0x4e}},
 940         { // 9
 941                 []byte{
 942                         0x31, 0x07, 0x91, 0x94, 0x98, 0x08, 0x01, 0x01,
 943                         0x31, 0x07, 0x91, 0x94, 0x98, 0x08, 0x01, 0x01,
 944                         0x31, 0x07, 0x91, 0x94, 0x98, 0x08, 0x01, 0x01,
 945                 },
 946                 nil,
 947                 []byte{0xcb, 0x49, 0xa2, 0xf9, 0xe9, 0x13, 0x63, 0xe3}},
 948         { // 10
 949                 []byte{
 950                         0x10, 0x07, 0x91, 0x15, 0xb9, 0x08, 0x01, 0x40,
 951                         0x10, 0x07, 0x91, 0x15, 0xb9, 0x08, 0x01, 0x40,
 952                         0x10, 0x07, 0x91, 0x15, 0xb9, 0x08, 0x01, 0x40,
 953                 },
 954                 nil,
 955                 []byte{0x00, 0xb5, 0x88, 0xbe, 0x70, 0xd2, 0x3f, 0x56}},
 956         { // 11
 957                 []byte{
 958                         0x31, 0x07, 0x91, 0x15, 0x98, 0x08, 0x01, 0x40,
 959                         0x31, 0x07, 0x91, 0x15, 0x98, 0x08, 0x01, 0x40,
 960                         0x31, 0x07, 0x91, 0x15, 0x98, 0x08, 0x01, 0x40,
 961                 },
 962                 nil,
 963                 []byte{0x40, 0x6a, 0x9a, 0x6a, 0xb4, 0x33, 0x99, 0xae}},
 964         { // 12
 965                 []byte{
 966                         0x10, 0x07, 0xd0, 0x15, 0x89, 0x98, 0x01, 0x01,
 967                         0x10, 0x07, 0xd0, 0x15, 0x89, 0x98, 0x01, 0x01,
 968                         0x10, 0x07, 0xd0, 0x15, 0x89, 0x98, 0x01, 0x01,
 969                 },
 970                 nil,
 971                 []byte{0x6c, 0xb7, 0x73, 0x61, 0x1d, 0xca, 0x9a, 0xda}},
 972         { // 13
 973                 []byte{
 974                         0x91, 0x07, 0x91, 0x15, 0x89, 0x98, 0x01, 0x01,
 975                         0x91, 0x07, 0x91, 0x15, 0x89, 0x98, 0x01, 0x01,
 976                         0x91, 0x07, 0x91, 0x15, 0x89, 0x98, 0x01, 0x01,
 977                 },
 978                 nil,
 979                 []byte{0x67, 0xfd, 0x21, 0xc1, 0x7d, 0xbb, 0x5d, 0x70}},
 980         { // 14
 981                 []byte{
 982                         0x91, 0x07, 0xd0, 0x15, 0x89, 0x19, 0x01, 0x01,
 983                         0x91, 0x07, 0xd0, 0x15, 0x89, 0x19, 0x01, 0x01,
 984                         0x91, 0x07, 0xd0, 0x15, 0x89, 0x19, 0x01, 0x01,
 985                 },
 986                 nil,
 987                 []byte{0x95, 0x92, 0xcb, 0x41, 0x10, 0x43, 0x07, 0x87}},
 988         { // 15
 989                 []byte{
 990                         0x10, 0x07, 0xd0, 0x15, 0x98, 0x98, 0x01, 0x20,
 991                         0x10, 0x07, 0xd0, 0x15, 0x98, 0x98, 0x01, 0x20,
 992                         0x10, 0x07, 0xd0, 0x15, 0x98, 0x98, 0x01, 0x20,
 993                 },
 994                 nil,
 995                 []byte{0xa6, 0xb7, 0xff, 0x68, 0xa3, 0x18, 0xdd, 0xd3}},
 996         { // 16
 997                 []byte{
 998                         0x10, 0x07, 0x94, 0x04, 0x98, 0x19, 0x01, 0x01,
 999                         0x10, 0x07, 0x94, 0x04, 0x98, 0x19, 0x01, 0x01,
1000                         0x10, 0x07, 0x94, 0x04, 0x98, 0x19, 0x01, 0x01,
1001                 },
1002                 nil,
1003                 []byte{0x4d, 0x10, 0x21, 0x96, 0xc9, 0x14, 0xca, 0x16}},
1004         { // 17
1005                 []byte{
1006                         0x01, 0x07, 0x91, 0x04, 0x91, 0x19, 0x04, 0x01,
1007                         0x01, 0x07, 0x91, 0x04, 0x91, 0x19, 0x04, 0x01,
1008                         0x01, 0x07, 0x91, 0x04, 0x91, 0x19, 0x04, 0x01,
1009                 },
1010                 nil,
1011                 []byte{0x2d, 0xfa, 0x9f, 0x45, 0x73, 0x59, 0x49, 0x65}},
1012         { // 18
1013                 []byte{
1014                         0x01, 0x07, 0x91, 0x04, 0x91, 0x19, 0x01, 0x01,
1015                         0x01, 0x07, 0x91, 0x04, 0x91, 0x19, 0x01, 0x01,
1016                         0x01, 0x07, 0x91, 0x04, 0x91, 0x19, 0x01, 0x01,
1017                 },
1018                 nil,
1019                 []byte{0xb4, 0x66, 0x04, 0x81, 0x6c, 0x0e, 0x07, 0x74}},
1020         { // 19
1021                 []byte{
1022                         0x01, 0x07, 0x94, 0x04, 0x91, 0x19, 0x04, 0x01,
1023                         0x01, 0x07, 0x94, 0x04, 0x91, 0x19, 0x04, 0x01,
1024                         0x01, 0x07, 0x94, 0x04, 0x91, 0x19, 0x04, 0x01,
1025                 },
1026                 nil,
1027                 []byte{0x6e, 0x7e, 0x62, 0x21, 0xa4, 0xf3, 0x4e, 0x87}},
1028         { // 20
1029                 []byte{
1030                         0x19, 0x07, 0x92, 0x10, 0x98, 0x1a, 0x01, 0x01,
1031                         0x19, 0x07, 0x92, 0x10, 0x98, 0x1a, 0x01, 0x01,
1032                         0x19, 0x07, 0x92, 0x10, 0x98, 0x1a, 0x01, 0x01,
1033                 },
1034                 nil,
1035                 []byte{0xaa, 0x85, 0xe7, 0x46, 0x43, 0x23, 0x31, 0x99}},
1036         { // 21
1037                 []byte{
1038                         0x10, 0x07, 0x91, 0x19, 0x98, 0x19, 0x08, 0x01,
1039                         0x10, 0x07, 0x91, 0x19, 0x98, 0x19, 0x08, 0x01,
1040                         0x10, 0x07, 0x91, 0x19, 0x98, 0x19, 0x08, 0x01,
1041                 },
1042                 nil,
1043                 []byte{0x2e, 0x5a, 0x19, 0xdb, 0x4d, 0x19, 0x62, 0xd6}},
1044         { // 22
1045                 []byte{
1046                         0x10, 0x07, 0x91, 0x19, 0x98, 0x1a, 0x08, 0x01,
1047                         0x10, 0x07, 0x91, 0x19, 0x98, 0x1a, 0x08, 0x01,
1048                         0x10, 0x07, 0x91, 0x19, 0x98, 0x1a, 0x08, 0x01,
1049                 },
1050                 nil,
1051                 []byte{0x23, 0xa8, 0x66, 0xa8, 0x09, 0xd3, 0x08, 0x94}},
1052         { // 23
1053                 []byte{
1054                         0x10, 0x07, 0x92, 0x10, 0x98, 0x19, 0x01, 0x01,
1055                         0x10, 0x07, 0x92, 0x10, 0x98, 0x19, 0x01, 0x01,
1056                         0x10, 0x07, 0x92, 0x10, 0x98, 0x19, 0x01, 0x01,
1057                 },
1058                 nil,
1059                 []byte{0xd8, 0x12, 0xd9, 0x61, 0xf0, 0x17, 0xd3, 0x20}},
1060         { // 24
1061                 []byte{
1062                         0x10, 0x07, 0x91, 0x15, 0x98, 0x19, 0x01, 0x0b,
1063                         0x10, 0x07, 0x91, 0x15, 0x98, 0x19, 0x01, 0x0b,
1064                         0x10, 0x07, 0x91, 0x15, 0x98, 0x19, 0x01, 0x0b,
1065                 },
1066                 nil,
1067                 []byte{0x05, 0x56, 0x05, 0x81, 0x6e, 0x58, 0x60, 0x8f}},
1068         { // 25
1069                 []byte{
1070                         0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x01,
1071                         0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x01,
1072                         0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x01,
1073                 },
1074                 nil,
1075                 []byte{0xab, 0xd8, 0x8e, 0x8b, 0x1b, 0x77, 0x16, 0xf1}},
1076         { // 26
1077                 []byte{
1078                         0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x02,
1079                         0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x02,
1080                         0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x02,
1081                 },
1082                 nil,
1083                 []byte{0x53, 0x7a, 0xc9, 0x5b, 0xe6, 0x9d, 0xa1, 0xe1}},
1084         { // 27
1085                 []byte{
1086                         0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x08,
1087                         0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x08,
1088                         0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x08,
1089                 },
1090                 nil,
1091                 []byte{0xae, 0xd0, 0xf6, 0xae, 0x3c, 0x25, 0xcd, 0xd8}},
1092         { // 28
1093                 []byte{
1094                         0x10, 0x02, 0x91, 0x15, 0x98, 0x10, 0x01, 0x04,
1095                         0x10, 0x02, 0x91, 0x15, 0x98, 0x10, 0x01, 0x04,
1096                         0x10, 0x02, 0x91, 0x15, 0x98, 0x10, 0x01, 0x04,
1097                 },
1098                 nil,
1099                 []byte{0xb3, 0xe3, 0x5a, 0x5e, 0xe5, 0x3e, 0x7b, 0x8d}},
1100         { // 29
1101                 []byte{
1102                         0x10, 0x02, 0x91, 0x15, 0x98, 0x19, 0x01, 0x04,
1103                         0x10, 0x02, 0x91, 0x15, 0x98, 0x19, 0x01, 0x04,
1104                         0x10, 0x02, 0x91, 0x15, 0x98, 0x19, 0x01, 0x04,
1105                 },
1106                 nil,
1107                 []byte{0x61, 0xc7, 0x9c, 0x71, 0x92, 0x1a, 0x2e, 0xf8}},
1108         { // 30
1109                 []byte{
1110                         0x10, 0x02, 0x91, 0x15, 0x98, 0x10, 0x02, 0x01,
1111                         0x10, 0x02, 0x91, 0x15, 0x98, 0x10, 0x02, 0x01,
1112                         0x10, 0x02, 0x91, 0x15, 0x98, 0x10, 0x02, 0x01,
1113                 },
1114                 nil,
1115                 []byte{0xe2, 0xf5, 0x72, 0x8f, 0x09, 0x95, 0x01, 0x3c}},
1116         { // 31
1117                 []byte{
1118                         0x10, 0x02, 0x91, 0x16, 0x98, 0x10, 0x01, 0x01,
1119                         0x10, 0x02, 0x91, 0x16, 0x98, 0x10, 0x01, 0x01,
1120                         0x10, 0x02, 0x91, 0x16, 0x98, 0x10, 0x01, 0x01,
1121                 },
1122                 nil,
1123                 []byte{0x1a, 0xea, 0xc3, 0x9a, 0x61, 0xf0, 0xa4, 0x64}},
1124 }
1125
1126 // Table A.4 Values To Be Used for the Substitution Table Known Answer Test
1127 var tableA4Tests = []CryptTest{
1128         { // 0
1129                 []byte{
1130                         0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57,
1131                         0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57,
1132                         0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57},
1133                 []byte{0x01, 0xa1, 0xd6, 0xd0, 0x39, 0x77, 0x67, 0x42},
1134                 []byte{0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b}},
1135         { // 1
1136                 []byte{
1137                         0x01, 0x31, 0xd9, 0x61, 0x9d, 0xc1, 0x37, 0x6e,
1138                         0x01, 0x31, 0xd9, 0x61, 0x9d, 0xc1, 0x37, 0x6e,
1139                         0x01, 0x31, 0xd9, 0x61, 0x9d, 0xc1, 0x37, 0x6e},
1140                 []byte{0x5c, 0xd5, 0x4c, 0xa8, 0x3d, 0xef, 0x57, 0xda},
1141                 []byte{0x7a, 0x38, 0x9d, 0x10, 0x35, 0x4b, 0xd2, 0x71}},
1142         { // 2
1143                 []byte{
1144                         0x07, 0xa1, 0x13, 0x3e, 0x4a, 0x0b, 0x26, 0x86,
1145                         0x07, 0xa1, 0x13, 0x3e, 0x4a, 0x0b, 0x26, 0x86,
1146                         0x07, 0xa1, 0x13, 0x3e, 0x4a, 0x0b, 0x26, 0x86},
1147                 []byte{0x02, 0x48, 0xd4, 0x38, 0x06, 0xf6, 0x71, 0x72},
1148                 []byte{0x86, 0x8e, 0xbb, 0x51, 0xca, 0xb4, 0x59, 0x9a}},
1149         { // 3
1150                 []byte{
1151                         0x38, 0x49, 0x67, 0x4c, 0x26, 0x02, 0x31, 0x9e,
1152                         0x38, 0x49, 0x67, 0x4c, 0x26, 0x02, 0x31, 0x9e,
1153                         0x38, 0x49, 0x67, 0x4c, 0x26, 0x02, 0x31, 0x9e},
1154                 []byte{0x51, 0x45, 0x4b, 0x58, 0x2d, 0xdf, 0x44, 0x0a},
1155                 []byte{0x71, 0x78, 0x87, 0x6e, 0x01, 0xf1, 0x9b, 0x2a}},
1156         { // 4
1157                 []byte{
1158                         0x04, 0xb9, 0x15, 0xba, 0x43, 0xfe, 0xb5, 0xb6,
1159                         0x04, 0xb9, 0x15, 0xba, 0x43, 0xfe, 0xb5, 0xb6,
1160                         0x04, 0xb9, 0x15, 0xba, 0x43, 0xfe, 0xb5, 0xb6},
1161                 []byte{0x42, 0xfd, 0x44, 0x30, 0x59, 0x57, 0x7f, 0xa2},
1162                 []byte{0xaf, 0x37, 0xfb, 0x42, 0x1f, 0x8c, 0x40, 0x95}},
1163         { // 5
1164                 []byte{
1165                         0x01, 0x13, 0xb9, 0x70, 0xfd, 0x34, 0xf2, 0xce,
1166                         0x01, 0x13, 0xb9, 0x70, 0xfd, 0x34, 0xf2, 0xce,
1167                         0x01, 0x13, 0xb9, 0x70, 0xfd, 0x34, 0xf2, 0xce},
1168                 []byte{0x05, 0x9b, 0x5e, 0x08, 0x51, 0xcf, 0x14, 0x3a},
1169                 []byte{0x86, 0xa5, 0x60, 0xf1, 0x0e, 0xc6, 0xd8, 0x5b}},
1170         { // 6
1171                 []byte{
1172                         0x01, 0x70, 0xf1, 0x75, 0x46, 0x8f, 0xb5, 0xe6,
1173                         0x01, 0x70, 0xf1, 0x75, 0x46, 0x8f, 0xb5, 0xe6,
1174                         0x01, 0x70, 0xf1, 0x75, 0x46, 0x8f, 0xb5, 0xe6},
1175                 []byte{0x07, 0x56, 0xd8, 0xe0, 0x77, 0x47, 0x61, 0xd2},
1176                 []byte{0x0c, 0xd3, 0xda, 0x02, 0x00, 0x21, 0xdc, 0x09}},
1177         { // 7
1178                 []byte{
1179                         0x43, 0x29, 0x7f, 0xad, 0x38, 0xe3, 0x73, 0xfe,
1180                         0x43, 0x29, 0x7f, 0xad, 0x38, 0xe3, 0x73, 0xfe,
1181                         0x43, 0x29, 0x7f, 0xad, 0x38, 0xe3, 0x73, 0xfe},
1182                 []byte{0x76, 0x25, 0x14, 0xb8, 0x29, 0xbf, 0x48, 0x6a},
1183                 []byte{0xea, 0x67, 0x6b, 0x2c, 0xb7, 0xdb, 0x2b, 0x7a}},
1184         { // 8
1185                 []byte{
1186                         0x07, 0xa7, 0x13, 0x70, 0x45, 0xda, 0x2a, 0x16,
1187                         0x07, 0xa7, 0x13, 0x70, 0x45, 0xda, 0x2a, 0x16,
1188                         0x07, 0xa7, 0x13, 0x70, 0x45, 0xda, 0x2a, 0x16},
1189                 []byte{0x3b, 0xdd, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
1190                 []byte{0xdf, 0xd6, 0x4a, 0x81, 0x5c, 0xaf, 0x1a, 0x0f}},
1191         { // 9
1192                 []byte{
1193                         0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f,
1194                         0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f,
1195                         0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f},
1196                 []byte{0x26, 0x95, 0x5f, 0x68, 0x35, 0xaf, 0x60, 0x9a},
1197                 []byte{0x5c, 0x51, 0x3c, 0x9c, 0x48, 0x86, 0xc0, 0x88}},
1198         { // 10
1199                 []byte{
1200                         0x37, 0xd0, 0x6b, 0xb5, 0x16, 0xcb, 0x75, 0x46,
1201                         0x37, 0xd0, 0x6b, 0xb5, 0x16, 0xcb, 0x75, 0x46,
1202                         0x37, 0xd0, 0x6b, 0xb5, 0x16, 0xcb, 0x75, 0x46},
1203                 []byte{0x16, 0x4d, 0x5e, 0x40, 0x4f, 0x27, 0x52, 0x32},
1204                 []byte{0x0a, 0x2a, 0xee, 0xae, 0x3f, 0xf4, 0xab, 0x77}},
1205         { // 11
1206                 []byte{
1207                         0x1f, 0x08, 0x26, 0x0d, 0x1a, 0xc2, 0x46, 0x5e,
1208                         0x1f, 0x08, 0x26, 0x0d, 0x1a, 0xc2, 0x46, 0x5e,
1209                         0x1f, 0x08, 0x26, 0x0d, 0x1a, 0xc2, 0x46, 0x5e},
1210                 []byte{0x6b, 0x05, 0x6e, 0x18, 0x75, 0x9f, 0x5c, 0xca},
1211                 []byte{0xef, 0x1b, 0xf0, 0x3e, 0x5d, 0xfa, 0x57, 0x5a}},
1212         { // 12
1213                 []byte{
1214                         0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76,
1215                         0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76,
1216                         0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76},
1217                 []byte{0x00, 0x4b, 0xd6, 0xef, 0x09, 0x17, 0x60, 0x62},
1218                 []byte{0x88, 0xbf, 0x0d, 0xb6, 0xd7, 0x0d, 0xee, 0x56}},
1219         { // 13
1220                 []byte{
1221                         0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xb0, 0x07,
1222                         0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xb0, 0x07,
1223                         0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xb0, 0x07},
1224                 []byte{0x48, 0x0d, 0x39, 0x00, 0x6e, 0xe7, 0x62, 0xf2},
1225                 []byte{0xa1, 0xf9, 0x91, 0x55, 0x41, 0x02, 0x0b, 0x56}},
1226         { // 14
1227                 []byte{
1228                         0x49, 0x79, 0x3e, 0xbc, 0x79, 0xb3, 0x25, 0x8f,
1229                         0x49, 0x79, 0x3e, 0xbc, 0x79, 0xb3, 0x25, 0x8f,
1230                         0x49, 0x79, 0x3e, 0xbc, 0x79, 0xb3, 0x25, 0x8f},
1231                 []byte{0x43, 0x75, 0x40, 0xc8, 0x69, 0x8f, 0x3c, 0xfa},
1232                 []byte{0x6f, 0xbf, 0x1c, 0xaf, 0xcf, 0xfd, 0x05, 0x56}},
1233         { // 15
1234                 []byte{
1235                         0x4f, 0xb0, 0x5e, 0x15, 0x15, 0xab, 0x73, 0xa7,
1236                         0x4f, 0xb0, 0x5e, 0x15, 0x15, 0xab, 0x73, 0xa7,
1237                         0x4f, 0xb0, 0x5e, 0x15, 0x15, 0xab, 0x73, 0xa7},
1238                 []byte{0x07, 0x2d, 0x43, 0xa0, 0x77, 0x07, 0x52, 0x92},
1239                 []byte{0x2f, 0x22, 0xe4, 0x9b, 0xab, 0x7c, 0xa1, 0xac}},
1240         { // 16
1241                 []byte{
1242                         0x49, 0xe9, 0x5d, 0x6d, 0x4c, 0xa2, 0x29, 0xbf,
1243                         0x49, 0xe9, 0x5d, 0x6d, 0x4c, 0xa2, 0x29, 0xbf,
1244                         0x49, 0xe9, 0x5d, 0x6d, 0x4c, 0xa2, 0x29, 0xbf},
1245                 []byte{0x02, 0xfe, 0x55, 0x77, 0x81, 0x17, 0xf1, 0x2a},
1246                 []byte{0x5a, 0x6b, 0x61, 0x2c, 0xc2, 0x6c, 0xce, 0x4a}},
1247         { // 17
1248                 []byte{
1249                         0x01, 0x83, 0x10, 0xdc, 0x40, 0x9b, 0x26, 0xd6,
1250                         0x01, 0x83, 0x10, 0xdc, 0x40, 0x9b, 0x26, 0xd6,
1251                         0x01, 0x83, 0x10, 0xdc, 0x40, 0x9b, 0x26, 0xd6},
1252                 []byte{0x1d, 0x9d, 0x5c, 0x50, 0x18, 0xf7, 0x28, 0xc2},
1253                 []byte{0x5f, 0x4c, 0x03, 0x8e, 0xd1, 0x2b, 0x2e, 0x41}},
1254         { // 18
1255                 []byte{
1256                         0x1c, 0x58, 0x7f, 0x1c, 0x13, 0x92, 0x4f, 0xef,
1257                         0x1c, 0x58, 0x7f, 0x1c, 0x13, 0x92, 0x4f, 0xef,
1258                         0x1c, 0x58, 0x7f, 0x1c, 0x13, 0x92, 0x4f, 0xef},
1259                 []byte{0x30, 0x55, 0x32, 0x28, 0x6d, 0x6f, 0x29, 0x5a},
1260                 []byte{0x63, 0xfa, 0xc0, 0xd0, 0x34, 0xd9, 0xf7, 0x93}},
1261 }
1262
1263 func newCipher(key []byte) *desCipher {
1264         c, err := NewCipher(key)
1265         if err != nil {
1266                 panic("NewCipher failed: " + err.Error())
1267         }
1268         return c.(*desCipher)
1269 }
1270
1271 // Use the known weak keys to test DES implementation
1272 func TestWeakKeys(t *testing.T) {
1273         for i, tt := range weakKeyTests {
1274                 var encrypt = func(in []byte) (out []byte) {
1275                         c := newCipher(tt.key)
1276                         out = make([]byte, len(in))
1277                         encryptBlock(c.subkeys[:], out, in)
1278                         return
1279                 }
1280
1281                 // Encrypting twice with a DES weak
1282                 // key should reproduce the original input
1283                 result := encrypt(tt.in)
1284                 result = encrypt(result)
1285
1286                 if !bytes.Equal(result, tt.in) {
1287                         t.Errorf("#%d: result: %x want: %x", i, result, tt.in)
1288                 }
1289         }
1290 }
1291
1292 // Use the known semi-weak key pairs to test DES implementation
1293 func TestSemiWeakKeyPairs(t *testing.T) {
1294         for i, tt := range semiWeakKeyTests {
1295                 var encrypt = func(key, in []byte) (out []byte) {
1296                         c := newCipher(key)
1297                         out = make([]byte, len(in))
1298                         encryptBlock(c.subkeys[:], out, in)
1299                         return
1300                 }
1301
1302                 // Encrypting with one member of the semi-weak pair
1303                 // and then encrypting the result with the other member
1304                 // should reproduce the original input.
1305                 result := encrypt(tt.key, tt.in)
1306                 result = encrypt(tt.out, result)
1307
1308                 if !bytes.Equal(result, tt.in) {
1309                         t.Errorf("#%d: result: %x want: %x", i, result, tt.in)
1310                 }
1311         }
1312 }
1313
1314 func TestDESEncryptBlock(t *testing.T) {
1315         for i, tt := range encryptDESTests {
1316                 c := newCipher(tt.key)
1317                 out := make([]byte, len(tt.in))
1318                 encryptBlock(c.subkeys[:], out, tt.in)
1319
1320                 if !bytes.Equal(out, tt.out) {
1321                         t.Errorf("#%d: result: %x want: %x", i, out, tt.out)
1322                 }
1323         }
1324 }
1325
1326 func TestDESDecryptBlock(t *testing.T) {
1327         for i, tt := range encryptDESTests {
1328                 c := newCipher(tt.key)
1329                 plain := make([]byte, len(tt.in))
1330                 decryptBlock(c.subkeys[:], plain, tt.out)
1331
1332                 if !bytes.Equal(plain, tt.in) {
1333                         t.Errorf("#%d: result: %x want: %x", i, plain, tt.in)
1334                 }
1335         }
1336 }
1337
1338 func TestEncryptTripleDES(t *testing.T) {
1339         for i, tt := range encryptTripleDESTests {
1340                 c, _ := NewTripleDESCipher(tt.key)
1341                 out := make([]byte, len(tt.in))
1342                 c.Encrypt(out, tt.in)
1343
1344                 if !bytes.Equal(out, tt.out) {
1345                         t.Errorf("#%d: result: %x want: %x", i, out, tt.out)
1346                 }
1347         }
1348 }
1349
1350 func TestDecryptTripleDES(t *testing.T) {
1351         for i, tt := range encryptTripleDESTests {
1352                 c, _ := NewTripleDESCipher(tt.key)
1353
1354                 plain := make([]byte, len(tt.in))
1355                 c.Decrypt(plain, tt.out)
1356
1357                 if !bytes.Equal(plain, tt.in) {
1358                         t.Errorf("#%d: result: %x want: %x", i, plain, tt.in)
1359                 }
1360         }
1361 }
1362
1363 // Defined in Pub 800-20
1364 func TestVariablePlaintextKnownAnswer(t *testing.T) {
1365         for i, tt := range tableA1Tests {
1366                 c, _ := NewTripleDESCipher(tableA1Key)
1367
1368                 out := make([]byte, len(tt.in))
1369                 c.Encrypt(out, tt.in)
1370
1371                 if !bytes.Equal(out, tt.out) {
1372                         t.Errorf("#%d: result: %x want: %x", i, out, tt.out)
1373                 }
1374         }
1375 }
1376
1377 // Defined in Pub 800-20
1378 func TestVariableCiphertextKnownAnswer(t *testing.T) {
1379         for i, tt := range tableA1Tests {
1380                 c, _ := NewTripleDESCipher(tableA1Key)
1381
1382                 plain := make([]byte, len(tt.out))
1383                 c.Decrypt(plain, tt.out)
1384
1385                 if !bytes.Equal(plain, tt.in) {
1386                         t.Errorf("#%d: result: %x want: %x", i, plain, tt.in)
1387                 }
1388         }
1389 }
1390
1391 // Defined in Pub 800-20
1392 // Encrypting the Table A.1 ciphertext with the
1393 // 0x01... key produces the original plaintext
1394 func TestInversePermutationKnownAnswer(t *testing.T) {
1395         for i, tt := range tableA1Tests {
1396                 c, _ := NewTripleDESCipher(tableA1Key)
1397
1398                 plain := make([]byte, len(tt.in))
1399                 c.Encrypt(plain, tt.out)
1400
1401                 if !bytes.Equal(plain, tt.in) {
1402                         t.Errorf("#%d: result: %x want: %x", i, plain, tt.in)
1403                 }
1404         }
1405 }
1406
1407 // Defined in Pub 800-20
1408 // Decrypting the Table A.1 plaintext with the
1409 // 0x01... key produces the corresponding ciphertext
1410 func TestInitialPermutationKnownAnswer(t *testing.T) {
1411         for i, tt := range tableA1Tests {
1412                 c, _ := NewTripleDESCipher(tableA1Key)
1413
1414                 out := make([]byte, len(tt.in))
1415                 c.Decrypt(out, tt.in)
1416
1417                 if !bytes.Equal(out, tt.out) {
1418                         t.Errorf("#%d: result: %x want: %x", i, out, tt.out)
1419                 }
1420         }
1421 }
1422
1423 // Defined in Pub 800-20
1424 func TestVariableKeyKnownAnswerEncrypt(t *testing.T) {
1425         for i, tt := range tableA2Tests {
1426                 c, _ := NewTripleDESCipher(tt.key)
1427
1428                 out := make([]byte, len(tableA2Plaintext))
1429                 c.Encrypt(out, tableA2Plaintext)
1430
1431                 if !bytes.Equal(out, tt.out) {
1432                         t.Errorf("#%d: result: %x want: %x", i, out, tt.out)
1433                 }
1434         }
1435 }
1436
1437 // Defined in Pub 800-20
1438 func TestVariableKeyKnownAnswerDecrypt(t *testing.T) {
1439         for i, tt := range tableA2Tests {
1440                 c, _ := NewTripleDESCipher(tt.key)
1441
1442                 out := make([]byte, len(tt.out))
1443                 c.Decrypt(out, tt.out)
1444
1445                 if !bytes.Equal(out, tableA2Plaintext) {
1446                         t.Errorf("#%d: result: %x want: %x", i, out, tableA2Plaintext)
1447                 }
1448         }
1449 }
1450
1451 // Defined in Pub 800-20
1452 func TestPermutationOperationKnownAnswerEncrypt(t *testing.T) {
1453         for i, tt := range tableA3Tests {
1454                 c, _ := NewTripleDESCipher(tt.key)
1455
1456                 out := make([]byte, len(tableA3Plaintext))
1457                 c.Encrypt(out, tableA3Plaintext)
1458
1459                 if !bytes.Equal(out, tt.out) {
1460                         t.Errorf("#%d: result: %x want: %x", i, out, tt.out)
1461                 }
1462         }
1463 }
1464
1465 // Defined in Pub 800-20
1466 func TestPermutationOperationKnownAnswerDecrypt(t *testing.T) {
1467         for i, tt := range tableA3Tests {
1468                 c, _ := NewTripleDESCipher(tt.key)
1469
1470                 out := make([]byte, len(tt.out))
1471                 c.Decrypt(out, tt.out)
1472
1473                 if !bytes.Equal(out, tableA3Plaintext) {
1474                         t.Errorf("#%d: result: %x want: %x", i, out, tableA3Plaintext)
1475                 }
1476         }
1477 }
1478
1479 // Defined in Pub 800-20
1480 func TestSubstitutionTableKnownAnswerEncrypt(t *testing.T) {
1481         for i, tt := range tableA4Tests {
1482                 c, _ := NewTripleDESCipher(tt.key)
1483
1484                 out := make([]byte, len(tt.in))
1485                 c.Encrypt(out, tt.in)
1486
1487                 if !bytes.Equal(out, tt.out) {
1488                         t.Errorf("#%d: result: %x want: %x", i, out, tt.out)
1489                 }
1490         }
1491 }
1492
1493 // Defined in Pub 800-20
1494 func TestSubstitutionTableKnownAnswerDecrypt(t *testing.T) {
1495         for i, tt := range tableA4Tests {
1496                 c, _ := NewTripleDESCipher(tt.key)
1497
1498                 out := make([]byte, len(tt.out))
1499                 c.Decrypt(out, tt.out)
1500
1501                 if !bytes.Equal(out, tt.in) {
1502                         t.Errorf("#%d: result: %x want: %x", i, out, tt.in)
1503                 }
1504         }
1505 }