gost28147/ecb_test.go

   1 // GoGOST -- Pure Go GOST cryptographic functions library
   2 // Copyright (C) 2015-2019 Sergey Matveev <stargrave@stargrave.org>
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, version 3 of the License.
   7 //
   8 // This program is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 // GNU General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15
  16 package gost28147
  17
  18 import (
  19         "bytes"
  20         "crypto/cipher"
  21         "testing"
  22 )
  23
  24 func TestECBGCL3Vectors(t *testing.T) {
  25         key := []byte{
  26                 0x04, 0x75, 0xf6, 0xe0, 0x50, 0x38, 0xfb, 0xfa,
  27                 0xd2, 0xc7, 0xc3, 0x90, 0xed, 0xb3, 0xca, 0x3d,
  28                 0x15, 0x47, 0x12, 0x42, 0x91, 0xae, 0x1e, 0x8a,
  29                 0x2f, 0x79, 0xcd, 0x9e, 0xd2, 0xbc, 0xef, 0xbd,
  30         }
  31         c := NewCipher(key, &SboxIdGost2814789TestParamSet)
  32         plaintext := []byte{
  33                 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
  34                 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
  35                 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
  36                 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
  37                 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
  38                 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28,
  39                 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30,
  40                 0x3f, 0x3e, 0x3d, 0x3c, 0x3b, 0x3a, 0x39, 0x38,
  41                 0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x41, 0x40,
  42                 0x4f, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a, 0x49, 0x48,
  43                 0x57, 0x56, 0x55, 0x54, 0x53, 0x52, 0x51, 0x50,
  44                 0x5f, 0x5e, 0x5d, 0x5c, 0x5b, 0x5a, 0x59, 0x58,
  45                 0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0x61, 0x60,
  46                 0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68,
  47                 0x77, 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x70,
  48                 0x7f, 0x7e, 0x7d, 0x7c, 0x7b, 0x7a, 0x79, 0x78,
  49                 0x87, 0x86, 0x85, 0x84, 0x83, 0x82, 0x81, 0x80,
  50                 0x8f, 0x8e, 0x8d, 0x8c, 0x8b, 0x8a, 0x89, 0x88,
  51                 0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,
  52                 0x9f, 0x9e, 0x9d, 0x9c, 0x9b, 0x9a, 0x99, 0x98,
  53                 0xa7, 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1, 0xa0,
  54                 0xaf, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa8,
  55                 0xb7, 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1, 0xb0,
  56                 0xbf, 0xbe, 0xbd, 0xbc, 0xbb, 0xba, 0xb9, 0xb8,
  57                 0xc7, 0xc6, 0xc5, 0xc4, 0xc3, 0xc2, 0xc1, 0xc0,
  58                 0xcf, 0xce, 0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc8,
  59                 0xd7, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xd0,
  60                 0xdf, 0xde, 0xdd, 0xdc, 0xdb, 0xda, 0xd9, 0xd8,
  61                 0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
  62                 0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
  63                 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
  64                 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
  65         }
  66         ciphertext := []byte{
  67                 0x4b, 0x8c, 0x4c, 0x98, 0x15, 0xf2, 0x4a, 0xea,
  68                 0x1e, 0xc3, 0x57, 0x09, 0xb3, 0xbc, 0x2e, 0xd1,
  69                 0xe0, 0xd1, 0xf2, 0x22, 0x65, 0x2d, 0x59, 0x18,
  70                 0xf7, 0xdf, 0xfc, 0x80, 0x4b, 0xde, 0x5c, 0x68,
  71                 0x46, 0x53, 0x75, 0x53, 0xa7, 0x46, 0x0d, 0xec,
  72                 0x05, 0x1f, 0x1b, 0xd3, 0x0a, 0x63, 0x1a, 0xb7,
  73                 0x78, 0xc4, 0x43, 0xe0, 0x5d, 0x3e, 0xa4, 0x0e,
  74                 0x2d, 0x7e, 0x23, 0xa9, 0x1b, 0xc9, 0x02, 0xbc,
  75                 0x21, 0x0c, 0x84, 0xcb, 0x0d, 0x0a, 0x07, 0xc8,
  76                 0x7b, 0xd0, 0xfb, 0xb5, 0x1a, 0x14, 0x04, 0x5c,
  77                 0xa2, 0x53, 0x97, 0x71, 0x2e, 0x5c, 0xc2, 0x8f,
  78                 0x39, 0x3f, 0x6f, 0x52, 0xf2, 0x30, 0x26, 0x4e,
  79                 0x8c, 0xe0, 0xd1, 0x01, 0x75, 0x6d, 0xdc, 0xd3,
  80                 0x03, 0x79, 0x1e, 0xca, 0xd5, 0xc1, 0x0e, 0x12,
  81                 0x53, 0x0a, 0x78, 0xe2, 0x0a, 0xb1, 0x1c, 0xea,
  82                 0x3a, 0xf8, 0x55, 0xb9, 0x7c, 0xe1, 0x0b, 0xba,
  83                 0xa0, 0xc8, 0x96, 0xeb, 0x50, 0x5a, 0xd3, 0x60,
  84                 0x43, 0xa3, 0x0f, 0x98, 0xdb, 0xd9, 0x50, 0x6d,
  85                 0x63, 0x91, 0xaf, 0x01, 0x40, 0xe9, 0x75, 0x5a,
  86                 0x46, 0x5c, 0x1f, 0x19, 0x4a, 0x0b, 0x89, 0x9b,
  87                 0xc4, 0xf6, 0xf8, 0xf5, 0x2f, 0x87, 0x3f, 0xfa,
  88                 0x26, 0xd4, 0xf8, 0x25, 0xba, 0x1f, 0x98, 0x82,
  89                 0xfc, 0x26, 0xaf, 0x2d, 0xc0, 0xf9, 0xc4, 0x58,
  90                 0x49, 0xfa, 0x09, 0x80, 0x02, 0x62, 0xa4, 0x34,
  91                 0x2d, 0xcb, 0x5a, 0x6b, 0xab, 0x61, 0x5d, 0x08,
  92                 0xd4, 0x26, 0xe0, 0x08, 0x13, 0xd6, 0x2e, 0x02,
  93                 0x2a, 0x37, 0xe8, 0xd0, 0xcf, 0x36, 0xf1, 0xc7,
  94                 0xc0, 0x3f, 0x9b, 0x21, 0x60, 0xbd, 0x29, 0x2d,
  95                 0x2e, 0x01, 0x48, 0x4e, 0xf8, 0x8f, 0x20, 0x16,
  96                 0x8a, 0xbf, 0x82, 0xdc, 0x32, 0x7a, 0xa3, 0x18,
  97                 0x69, 0xd1, 0x50, 0x59, 0x31, 0x91, 0xf2, 0x6c,
  98                 0x5a, 0x5f, 0xca, 0x58, 0x9a, 0xb2, 0x2d, 0xb2,
  99         }
 100         e := c.NewECBEncrypter()
 101         tmp := make([]byte, len(plaintext))
 102         e.CryptBlocks(tmp, plaintext)
 103         if bytes.Compare(tmp, ciphertext) != 0 {
 104                 t.Fatal("encryption failed")
 105         }
 106         d := c.NewECBDecrypter()
 107         d.CryptBlocks(tmp, tmp)
 108         if bytes.Compare(tmp, plaintext) != 0 {
 109                 t.Fatal("decryption failed")
 110         }
 111 }
 112
 113 // Crypto++ 5.6.2 test vectors
 114 func TestECBCryptoPPVectors(t *testing.T) {
 115         sbox := &SboxAppliedCryptographyParamSet
 116         tmp := make([]byte, BlockSize)
 117         var key []byte
 118         var pt []byte
 119         var ct []byte
 120         var c *Cipher
 121
 122         t.Run("1", func(t *testing.T) {
 123                 key = []byte{
 124                         0xBE, 0x5E, 0xC2, 0x00, 0x6C, 0xFF, 0x9D, 0xCF,
 125                         0x52, 0x35, 0x49, 0x59, 0xF1, 0xFF, 0x0C, 0xBF,
 126                         0xE9, 0x50, 0x61, 0xB5, 0xA6, 0x48, 0xC1, 0x03,
 127                         0x87, 0x06, 0x9C, 0x25, 0x99, 0x7C, 0x06, 0x72,
 128                 }
 129                 pt = []byte{0x0D, 0xF8, 0x28, 0x02, 0xB7, 0x41, 0xA2, 0x92}
 130                 ct = []byte{0x07, 0xF9, 0x02, 0x7D, 0xF7, 0xF7, 0xDF, 0x89}
 131                 c = NewCipher(key, sbox)
 132                 c.Encrypt(tmp, pt)
 133                 if bytes.Compare(tmp, ct) != 0 {
 134                         t.FailNow()
 135                 }
 136         })
 137
 138         t.Run("2", func(t *testing.T) {
 139                 key = []byte{
 140                         0xB3, 0x85, 0x27, 0x2A, 0xC8, 0xD7, 0x2A, 0x5A,
 141                         0x8B, 0x34, 0x4B, 0xC8, 0x03, 0x63, 0xAC, 0x4D,
 142                         0x09, 0xBF, 0x58, 0xF4, 0x1F, 0x54, 0x06, 0x24,
 143                         0xCB, 0xCB, 0x8F, 0xDC, 0xF5, 0x53, 0x07, 0xD7,
 144                 }
 145                 pt = []byte{0x13, 0x54, 0xEE, 0x9C, 0x0A, 0x11, 0xCD, 0x4C}
 146                 ct = []byte{0x4F, 0xB5, 0x05, 0x36, 0xF9, 0x60, 0xA7, 0xB1}
 147                 c = NewCipher(key, sbox)
 148                 c.Encrypt(tmp, pt)
 149                 if bytes.Compare(tmp, ct) != 0 {
 150                         t.FailNow()
 151                 }
 152         })
 153
 154         t.Run("3", func(t *testing.T) {
 155                 key = []byte{
 156                         0xAE, 0xE0, 0x2F, 0x60, 0x9A, 0x35, 0x66, 0x0E,
 157                         0x40, 0x97, 0xE5, 0x46, 0xFD, 0x30, 0x26, 0xB0,
 158                         0x32, 0xCD, 0x10, 0x7C, 0x7D, 0x45, 0x99, 0x77,
 159                         0xAD, 0xF4, 0x89, 0xBE, 0xF2, 0x65, 0x22, 0x62,
 160                 }
 161                 pt = []byte{0x66, 0x93, 0xD4, 0x92, 0xC4, 0xB0, 0xCC, 0x39}
 162                 ct = []byte{0x67, 0x00, 0x34, 0xAC, 0x0F, 0xA8, 0x11, 0xB5}
 163                 c = NewCipher(key, sbox)
 164                 c.Encrypt(tmp, pt)
 165                 if bytes.Compare(tmp, ct) != 0 {
 166                         t.FailNow()
 167                 }
 168         })
 169
 170         t.Run("4", func(t *testing.T) {
 171                 key = []byte{
 172                         0x32, 0x0E, 0x9D, 0x84, 0x22, 0x16, 0x5D, 0x58,
 173                         0x91, 0x1D, 0xFC, 0x7D, 0x8B, 0xBB, 0x1F, 0x81,
 174                         0xB0, 0xEC, 0xD9, 0x24, 0x02, 0x3B, 0xF9, 0x4D,
 175                         0x9D, 0xF7, 0xDC, 0xF7, 0x80, 0x12, 0x40, 0xE0,
 176                 }
 177                 pt = []byte{0x99, 0xE2, 0xD1, 0x30, 0x80, 0x92, 0x8D, 0x79}
 178                 ct = []byte{0x81, 0x18, 0xFF, 0x9D, 0x3B, 0x3C, 0xFE, 0x7D}
 179                 c = NewCipher(key, sbox)
 180                 c.Encrypt(tmp, pt)
 181                 if bytes.Compare(tmp, ct) != 0 {
 182                         t.FailNow()
 183                 }
 184         })
 185
 186         t.Run("5", func(t *testing.T) {
 187                 key = []byte{
 188                         0xC9, 0xF7, 0x03, 0xBB, 0xBF, 0xC6, 0x36, 0x91,
 189                         0xBF, 0xA3, 0xB7, 0xB8, 0x7E, 0xA8, 0xFD, 0x5E,
 190                         0x8E, 0x8E, 0xF3, 0x84, 0xEF, 0x73, 0x3F, 0x1A,
 191                         0x61, 0xAE, 0xF6, 0x8C, 0x8F, 0xFA, 0x26, 0x5F,
 192                 }
 193                 pt = []byte{0xD1, 0xE7, 0x87, 0x74, 0x9C, 0x72, 0x81, 0x4C}
 194                 ct = []byte{0xA0, 0x83, 0x82, 0x6A, 0x79, 0x0D, 0x3E, 0x0C}
 195                 c = NewCipher(key, sbox)
 196                 c.Encrypt(tmp, pt)
 197                 if bytes.Compare(tmp, ct) != 0 {
 198                         t.FailNow()
 199                 }
 200         })
 201
 202         t.Run("6", func(t *testing.T) {
 203                 key = []byte{
 204                         0x72, 0x8F, 0xEE, 0x32, 0xF0, 0x4B, 0x4C, 0x65,
 205                         0x4A, 0xD7, 0xF6, 0x07, 0xD7, 0x1C, 0x66, 0x0C,
 206                         0x2C, 0x26, 0x70, 0xD7, 0xC9, 0x99, 0x71, 0x32,
 207                         0x33, 0x14, 0x9A, 0x1C, 0x0C, 0x17, 0xA1, 0xF0,
 208                 }
 209                 pt = []byte{0xD4, 0xC0, 0x53, 0x23, 0xA4, 0xF7, 0xA7, 0xB5}
 210                 ct = []byte{0x4D, 0x1F, 0x2E, 0x6B, 0x0D, 0x9D, 0xE2, 0xCE}
 211                 c = NewCipher(key, sbox)
 212                 c.Encrypt(tmp, pt)
 213                 if bytes.Compare(tmp, ct) != 0 {
 214                         t.FailNow()
 215                 }
 216         })
 217
 218         t.Run("7", func(t *testing.T) {
 219                 key = []byte{
 220                         0x35, 0xFC, 0x96, 0x40, 0x22, 0x09, 0x50, 0x0F,
 221                         0xCF, 0xDE, 0xF5, 0x35, 0x2D, 0x1A, 0xBB, 0x03,
 222                         0x8F, 0xE3, 0x3F, 0xC0, 0xD9, 0xD5, 0x85, 0x12,
 223                         0xE5, 0x63, 0x70, 0xB2, 0x2B, 0xAA, 0x13, 0x3B,
 224                 }
 225                 pt = []byte{0x87, 0x42, 0xD9, 0xA0, 0x5F, 0x6A, 0x3A, 0xF6}
 226                 ct = []byte{0x2F, 0x3B, 0xB8, 0x48, 0x79, 0xD1, 0x1E, 0x52}
 227                 c = NewCipher(key, sbox)
 228                 c.Encrypt(tmp, pt)
 229                 if bytes.Compare(tmp, ct) != 0 {
 230                         t.FailNow()
 231                 }
 232         })
 233
 234         t.Run("8", func(t *testing.T) {
 235                 key = []byte{
 236                         0xD4, 0x16, 0xF6, 0x30, 0xBE, 0x65, 0xB7, 0xFE,
 237                         0x15, 0x06, 0x56, 0x18, 0x33, 0x70, 0xE0, 0x70,
 238                         0x18, 0x23, 0x4E, 0xE5, 0xDA, 0x3D, 0x89, 0xC4,
 239                         0xCE, 0x91, 0x52, 0xA0, 0x3E, 0x5B, 0xFB, 0x77,
 240                 }
 241                 pt = []byte{0xF8, 0x65, 0x06, 0xDA, 0x04, 0xE4, 0x1C, 0xB8}
 242                 ct = []byte{0x96, 0xF0, 0xA5, 0xC7, 0x7A, 0x04, 0xF5, 0xCE}
 243                 c = NewCipher(key, sbox)
 244                 c.Encrypt(tmp, pt)
 245                 if bytes.Compare(tmp, ct) != 0 {
 246                         t.FailNow()
 247                 }
 248         })
 249 }
 250
 251 // http://cryptomanager.com/tv.html test vectors.
 252 func TestECBCryptomanager(t *testing.T) {
 253         key := []byte{
 254                 0x75, 0x71, 0x31, 0x34, 0xB6, 0x0F, 0xEC, 0x45,
 255                 0xA6, 0x07, 0xBB, 0x83, 0xAA, 0x37, 0x46, 0xAF,
 256                 0x4F, 0xF9, 0x9D, 0xA6, 0xD1, 0xB5, 0x3B, 0x5B,
 257                 0x1B, 0x40, 0x2A, 0x1B, 0xAA, 0x03, 0x0D, 0x1B,
 258         }
 259         c := NewCipher(key, &SboxIdGostR341194TestParamSet)
 260         tmp := make([]byte, BlockSize)
 261         c.Encrypt(tmp, []byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})
 262         if bytes.Compare(tmp, []byte{0x03, 0x25, 0x1E, 0x14, 0xF9, 0xD2, 0x8A, 0xCB}) != 0 {
 263                 t.FailNow()
 264         }
 265 }
 266
 267 func TestECBInterface(t *testing.T) {
 268         var key [KeySize]byte
 269         c := NewCipher(key[:], SboxDefault)
 270         var _ cipher.BlockMode = c.NewECBEncrypter()
 271         var _ cipher.BlockMode = c.NewECBDecrypter()
 272 }