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