gost28147/ctr_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         "crypto/rand"
  22         "testing"
  23         "testing/quick"
  24 )
  25
  26 func TestCTRGCL3Vector(t *testing.T) {
  27         sbox := &SboxIdGost2814789TestParamSet
  28         key := []byte{
  29                 0x04, 0x75, 0xf6, 0xe0, 0x50, 0x38, 0xfb, 0xfa,
  30                 0xd2, 0xc7, 0xc3, 0x90, 0xed, 0xb3, 0xca, 0x3d,
  31                 0x15, 0x47, 0x12, 0x42, 0x91, 0xae, 0x1e, 0x8a,
  32                 0x2f, 0x79, 0xcd, 0x9e, 0xd2, 0xbc, 0xef, 0xbd,
  33         }
  34         plaintext := []byte{
  35                 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
  36                 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
  37                 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
  38                 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
  39                 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
  40                 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28,
  41                 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30,
  42                 0x3f, 0x3e, 0x3d, 0x3c, 0x3b, 0x3a, 0x39, 0x38,
  43                 0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x41, 0x40,
  44                 0x4f, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a, 0x49, 0x48,
  45                 0x57, 0x56, 0x55, 0x54, 0x53, 0x52, 0x51, 0x50,
  46                 0x5f, 0x5e, 0x5d, 0x5c, 0x5b, 0x5a, 0x59, 0x58,
  47                 0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0x61, 0x60,
  48                 0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68,
  49                 0x77, 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x70,
  50                 0x7f, 0x7e, 0x7d, 0x7c, 0x7b, 0x7a, 0x79, 0x78,
  51                 0x87, 0x86, 0x85, 0x84, 0x83, 0x82, 0x81, 0x80,
  52                 0x8f, 0x8e, 0x8d, 0x8c, 0x8b, 0x8a, 0x89, 0x88,
  53                 0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,
  54                 0x9f, 0x9e, 0x9d, 0x9c, 0x9b, 0x9a, 0x99, 0x98,
  55                 0xa7, 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1, 0xa0,
  56                 0xaf, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa8,
  57                 0xb7, 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1, 0xb0,
  58                 0xbf, 0xbe, 0xbd, 0xbc, 0xbb, 0xba, 0xb9, 0xb8,
  59                 0xc7, 0xc6, 0xc5, 0xc4, 0xc3, 0xc2, 0xc1, 0xc0,
  60                 0xcf, 0xce, 0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc8,
  61                 0xd7, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xd0,
  62                 0xdf, 0xde, 0xdd, 0xdc, 0xdb, 0xda, 0xd9, 0xd8,
  63                 0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
  64                 0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
  65                 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
  66                 0xff, 0xfe, 0xfd, 0xfc, 0xfb,
  67         }
  68         ciphertext := []byte{
  69                 0x4a, 0x5e, 0x37, 0x6c, 0xa1, 0x12, 0xd3, 0x55,
  70                 0x09, 0x13, 0x1a, 0x21, 0xac, 0xfb, 0xb2, 0x1e,
  71                 0x8c, 0x24, 0x9b, 0x57, 0x20, 0x68, 0x46, 0xd5,
  72                 0x23, 0x2a, 0x26, 0x35, 0x12, 0x56, 0x5c, 0x69,
  73                 0x2a, 0x2f, 0xd1, 0xab, 0xbd, 0x45, 0xdc, 0x3a,
  74                 0x1a, 0xa4, 0x57, 0x64, 0xd5, 0xe4, 0x69, 0x6d,
  75                 0xb4, 0x8b, 0xf1, 0x54, 0x78, 0x3b, 0x10, 0x8f,
  76                 0x7a, 0x4b, 0x32, 0xe0, 0xe8, 0x4c, 0xbf, 0x03,
  77                 0x24, 0x37, 0x95, 0x6a, 0x55, 0xa8, 0xce, 0x6f,
  78                 0x95, 0x62, 0x12, 0xf6, 0x79, 0xe6, 0xf0, 0x1b,
  79                 0x86, 0xef, 0x36, 0x36, 0x05, 0xd8, 0x6f, 0x10,
  80                 0xa1, 0x41, 0x05, 0x07, 0xf8, 0xfa, 0xa4, 0x0b,
  81                 0x17, 0x2c, 0x71, 0xbc, 0x8b, 0xcb, 0xcf, 0x3d,
  82                 0x74, 0x18, 0x32, 0x0b, 0x1c, 0xd2, 0x9e, 0x75,
  83                 0xba, 0x3e, 0x61, 0xe1, 0x61, 0x96, 0xd0, 0xee,
  84                 0x8f, 0xf2, 0x9a, 0x5e, 0xb7, 0x7a, 0x15, 0xaa,
  85                 0x4e, 0x1e, 0x77, 0x7c, 0x99, 0xe1, 0x41, 0x13,
  86                 0xf4, 0x60, 0x39, 0x46, 0x4c, 0x35, 0xde, 0x95,
  87                 0xcc, 0x4f, 0xd5, 0xaf, 0xd1, 0x4d, 0x84, 0x1a,
  88                 0x45, 0xc7, 0x2a, 0xf2, 0x2c, 0xc0, 0xb7, 0x94,
  89                 0xa3, 0x08, 0xb9, 0x12, 0x96, 0xb5, 0x97, 0x99,
  90                 0x3a, 0xb7, 0x0c, 0x14, 0x56, 0xb9, 0xcb, 0x49,
  91                 0x44, 0xa9, 0x93, 0xa9, 0xfb, 0x19, 0x10, 0x8c,
  92                 0x6a, 0x68, 0xe8, 0x7b, 0x06, 0x57, 0xf0, 0xef,
  93                 0x88, 0x44, 0xa6, 0xd2, 0x98, 0xbe, 0xd4, 0x07,
  94                 0x41, 0x37, 0x45, 0xa6, 0x71, 0x36, 0x76, 0x69,
  95                 0x4b, 0x75, 0x15, 0x33, 0x90, 0x29, 0x6e, 0x33,
  96                 0xcb, 0x96, 0x39, 0x78, 0x19, 0x2e, 0x96, 0xf3,
  97                 0x49, 0x4c, 0x89, 0x3d, 0xa1, 0x86, 0x82, 0x00,
  98                 0xce, 0xbd, 0x54, 0x29, 0x65, 0x00, 0x1d, 0x16,
  99                 0x13, 0xc3, 0xfe, 0x1f, 0x8c, 0x55, 0x63, 0x09,
 100                 0x1f, 0xcd, 0xd4, 0x28, 0xca,
 101         }
 102         iv := []byte{0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}
 103         c := NewCipher(key, sbox)
 104         ctr := c.NewCTR(iv)
 105         tmp := make([]byte, len(plaintext))
 106         ctr.XORKeyStream(tmp, plaintext)
 107         if bytes.Compare(tmp, ciphertext) != 0 {
 108                 t.Fatal("encryption failed")
 109         }
 110         ctr = c.NewCTR(iv)
 111         ctr.XORKeyStream(tmp, tmp)
 112         if bytes.Compare(tmp, plaintext) != 0 {
 113                 t.Fatal("decryption failed")
 114         }
 115 }
 116
 117 func TestCTRGCL2Vector(t *testing.T) {
 118         sbox := &SboxIdGost2814789TestParamSet
 119         key := []byte{
 120                 0xfc, 0x7a, 0xd2, 0x88, 0x6f, 0x45, 0x5b, 0x50,
 121                 0xd2, 0x90, 0x08, 0xfa, 0x62, 0x2b, 0x57, 0xd5,
 122                 0xc6, 0x5b, 0x3c, 0x63, 0x72, 0x02, 0x02, 0x57,
 123                 0x99, 0xca, 0xdf, 0x07, 0x68, 0x51, 0x9e, 0x8a,
 124         }
 125         plaintext := []byte{
 126                 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
 127                 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
 128                 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
 129                 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
 130                 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
 131                 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28,
 132                 0xff, 0xfe, 0xfd, 0xfc, 0xfb,
 133         }
 134         ciphertext := []byte{
 135                 0xd0, 0xbe, 0x60, 0x1a, 0x2c, 0xf1, 0x90, 0x26,
 136                 0x9b, 0x7b, 0x23, 0xb4, 0xd2, 0xcc, 0xe1, 0x15,
 137                 0xf6, 0x05, 0x57, 0x28, 0x88, 0x75, 0xeb, 0x1e,
 138                 0xd3, 0x62, 0xdc, 0xda, 0x9b, 0x62, 0xee, 0x9a,
 139                 0x57, 0x87, 0x8a, 0xf1, 0x82, 0x37, 0x9c, 0x7f,
 140                 0x13, 0xcc, 0x55, 0x38, 0xb5, 0x63, 0x32, 0xc5,
 141                 0x23, 0xa4, 0xcb, 0x7d, 0x51,
 142         }
 143         var iv [8]byte
 144         c := NewCipher(key, sbox)
 145         ctr := c.NewCTR(iv[:])
 146         tmp := make([]byte, len(plaintext))
 147         ctr.XORKeyStream(tmp, plaintext)
 148         if bytes.Compare(tmp, ciphertext) != 0 {
 149                 t.Fatal("encryption failed")
 150         }
 151         ctr = c.NewCTR(iv[:])
 152         ctr.XORKeyStream(tmp, tmp)
 153         if bytes.Compare(tmp, plaintext) != 0 {
 154                 t.Fatal("decryption failed")
 155         }
 156 }
 157
 158 func TestCTRRandom(t *testing.T) {
 159         f := func(key [KeySize]byte, iv [BlockSize]byte, pt []byte) bool {
 160                 if len(pt) == 0 {
 161                         return true
 162                 }
 163                 c := NewCipher(key[:], SboxDefault)
 164                 tmp := make([]byte, len(pt))
 165                 ctr := c.NewCTR(iv[:])
 166                 ctr.XORKeyStream(tmp, pt[:])
 167                 ctr = c.NewCTR(iv[:])
 168                 ctr.XORKeyStream(tmp, tmp)
 169                 return bytes.Compare(tmp, pt) == 0
 170         }
 171         if err := quick.Check(f, nil); err != nil {
 172                 t.Error(err)
 173         }
 174 }
 175 func TestCTRInterface(t *testing.T) {
 176         var key [KeySize]byte
 177         var iv [8]byte
 178         c := NewCipher(key[:], SboxDefault)
 179         var _ cipher.Stream = c.NewCTR(iv[:])
 180 }
 181
 182 func BenchmarkCTR(b *testing.B) {
 183         key := make([]byte, KeySize)
 184         iv := make([]byte, BlockSize)
 185         rand.Read(key)
 186         rand.Read(iv)
 187         dst := make([]byte, BlockSize)
 188         src := make([]byte, BlockSize)
 189         rand.Read(src)
 190         c := NewCipher(key, SboxDefault)
 191         ctr := c.NewCTR(iv)
 192         b.ResetTimer()
 193         for i := 0; i < b.N; i++ {
 194                 ctr.XORKeyStream(dst, src)
 195         }
 196 }