...
Run Format

Source file src/crypto/des/des_test.go

Documentation: crypto/des

     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  }
  1506  
  1507  func TestInitialPermute(t *testing.T) {
  1508  	for i := uint(0); i < 64; i++ {
  1509  		bit := uint64(1) << i
  1510  		got := permuteInitialBlock(bit)
  1511  		want := uint64(1) << finalPermutation[63-i]
  1512  		if got != want {
  1513  			t.Errorf("permute(%x) = %x, want %x", bit, got, want)
  1514  		}
  1515  	}
  1516  }
  1517  
  1518  func TestFinalPermute(t *testing.T) {
  1519  	for i := uint(0); i < 64; i++ {
  1520  		bit := uint64(1) << i
  1521  		got := permuteFinalBlock(bit)
  1522  		want := uint64(1) << initialPermutation[63-i]
  1523  		if got != want {
  1524  			t.Errorf("permute(%x) = %x, want %x", bit, got, want)
  1525  		}
  1526  	}
  1527  }
  1528  
  1529  func BenchmarkEncrypt(b *testing.B) {
  1530  	tt := encryptDESTests[0]
  1531  	c, err := NewCipher(tt.key)
  1532  	if err != nil {
  1533  		b.Fatal("NewCipher:", err)
  1534  	}
  1535  	out := make([]byte, len(tt.in))
  1536  	b.SetBytes(int64(len(out)))
  1537  	b.ResetTimer()
  1538  	for i := 0; i < b.N; i++ {
  1539  		c.Encrypt(out, tt.in)
  1540  	}
  1541  }
  1542  
  1543  func BenchmarkDecrypt(b *testing.B) {
  1544  	tt := encryptDESTests[0]
  1545  	c, err := NewCipher(tt.key)
  1546  	if err != nil {
  1547  		b.Fatal("NewCipher:", err)
  1548  	}
  1549  	out := make([]byte, len(tt.out))
  1550  	b.SetBytes(int64(len(out)))
  1551  	b.ResetTimer()
  1552  	for i := 0; i < b.N; i++ {
  1553  		c.Decrypt(out, tt.out)
  1554  	}
  1555  }
  1556  
  1557  func BenchmarkTDESEncrypt(b *testing.B) {
  1558  	tt := encryptTripleDESTests[0]
  1559  	c, err := NewTripleDESCipher(tt.key)
  1560  	if err != nil {
  1561  		b.Fatal("NewCipher:", err)
  1562  	}
  1563  	out := make([]byte, len(tt.in))
  1564  	b.SetBytes(int64(len(out)))
  1565  	b.ResetTimer()
  1566  	for i := 0; i < b.N; i++ {
  1567  		c.Encrypt(out, tt.in)
  1568  	}
  1569  }
  1570  
  1571  func BenchmarkTDESDecrypt(b *testing.B) {
  1572  	tt := encryptTripleDESTests[0]
  1573  	c, err := NewTripleDESCipher(tt.key)
  1574  	if err != nil {
  1575  		b.Fatal("NewCipher:", err)
  1576  	}
  1577  	out := make([]byte, len(tt.out))
  1578  	b.SetBytes(int64(len(out)))
  1579  	b.ResetTimer()
  1580  	for i := 0; i < b.N; i++ {
  1581  		c.Decrypt(out, tt.out)
  1582  	}
  1583  }
  1584  

View as plain text