2 # PyGOST -- Pure Python GOST cryptographic functions library
3 # Copyright (C) 2015-2022 Sergey Matveev <stargrave@stargrave.org>
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation, version 3 of the License.
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/>.
17 from os import urandom
18 from unittest import TestCase
20 from pygost.gost28147 import block2ns
21 from pygost.gost28147 import BLOCKSIZE
22 from pygost.gost28147 import cbc_decrypt
23 from pygost.gost28147 import cbc_encrypt
24 from pygost.gost28147 import cfb_decrypt
25 from pygost.gost28147 import cfb_encrypt
26 from pygost.gost28147 import cnt
27 from pygost.gost28147 import DEFAULT_SBOX
28 from pygost.gost28147 import ecb_decrypt
29 from pygost.gost28147 import ecb_encrypt
30 from pygost.gost28147 import encrypt
31 from pygost.gost28147 import KEYSIZE
32 from pygost.gost28147 import MESH_MAX_DATA
33 from pygost.gost28147 import ns2block
34 from pygost.utils import hexdec
35 from pygost.utils import strxor
38 class ECBTest(TestCase):
40 """Test vectors from libgcl3
42 sbox = "id-Gost28147-89-TestParamSet"
43 key = hexdec(b"0475f6e05038fbfad2c7c390edb3ca3d1547124291ae1e8a2f79cd9ed2bcefbd")
44 plaintext = bytes(bytearray((
45 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
46 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
47 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
48 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
49 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
50 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28,
51 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30,
52 0x3f, 0x3e, 0x3d, 0x3c, 0x3b, 0x3a, 0x39, 0x38,
53 0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x41, 0x40,
54 0x4f, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a, 0x49, 0x48,
55 0x57, 0x56, 0x55, 0x54, 0x53, 0x52, 0x51, 0x50,
56 0x5f, 0x5e, 0x5d, 0x5c, 0x5b, 0x5a, 0x59, 0x58,
57 0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0x61, 0x60,
58 0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68,
59 0x77, 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x70,
60 0x7f, 0x7e, 0x7d, 0x7c, 0x7b, 0x7a, 0x79, 0x78,
61 0x87, 0x86, 0x85, 0x84, 0x83, 0x82, 0x81, 0x80,
62 0x8f, 0x8e, 0x8d, 0x8c, 0x8b, 0x8a, 0x89, 0x88,
63 0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,
64 0x9f, 0x9e, 0x9d, 0x9c, 0x9b, 0x9a, 0x99, 0x98,
65 0xa7, 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1, 0xa0,
66 0xaf, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa8,
67 0xb7, 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1, 0xb0,
68 0xbf, 0xbe, 0xbd, 0xbc, 0xbb, 0xba, 0xb9, 0xb8,
69 0xc7, 0xc6, 0xc5, 0xc4, 0xc3, 0xc2, 0xc1, 0xc0,
70 0xcf, 0xce, 0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc8,
71 0xd7, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xd0,
72 0xdf, 0xde, 0xdd, 0xdc, 0xdb, 0xda, 0xd9, 0xd8,
73 0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
74 0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
75 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
76 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
78 ciphertext = bytes(bytearray((
79 0x4b, 0x8c, 0x4c, 0x98, 0x15, 0xf2, 0x4a, 0xea,
80 0x1e, 0xc3, 0x57, 0x09, 0xb3, 0xbc, 0x2e, 0xd1,
81 0xe0, 0xd1, 0xf2, 0x22, 0x65, 0x2d, 0x59, 0x18,
82 0xf7, 0xdf, 0xfc, 0x80, 0x4b, 0xde, 0x5c, 0x68,
83 0x46, 0x53, 0x75, 0x53, 0xa7, 0x46, 0x0d, 0xec,
84 0x05, 0x1f, 0x1b, 0xd3, 0x0a, 0x63, 0x1a, 0xb7,
85 0x78, 0xc4, 0x43, 0xe0, 0x5d, 0x3e, 0xa4, 0x0e,
86 0x2d, 0x7e, 0x23, 0xa9, 0x1b, 0xc9, 0x02, 0xbc,
87 0x21, 0x0c, 0x84, 0xcb, 0x0d, 0x0a, 0x07, 0xc8,
88 0x7b, 0xd0, 0xfb, 0xb5, 0x1a, 0x14, 0x04, 0x5c,
89 0xa2, 0x53, 0x97, 0x71, 0x2e, 0x5c, 0xc2, 0x8f,
90 0x39, 0x3f, 0x6f, 0x52, 0xf2, 0x30, 0x26, 0x4e,
91 0x8c, 0xe0, 0xd1, 0x01, 0x75, 0x6d, 0xdc, 0xd3,
92 0x03, 0x79, 0x1e, 0xca, 0xd5, 0xc1, 0x0e, 0x12,
93 0x53, 0x0a, 0x78, 0xe2, 0x0a, 0xb1, 0x1c, 0xea,
94 0x3a, 0xf8, 0x55, 0xb9, 0x7c, 0xe1, 0x0b, 0xba,
95 0xa0, 0xc8, 0x96, 0xeb, 0x50, 0x5a, 0xd3, 0x60,
96 0x43, 0xa3, 0x0f, 0x98, 0xdb, 0xd9, 0x50, 0x6d,
97 0x63, 0x91, 0xaf, 0x01, 0x40, 0xe9, 0x75, 0x5a,
98 0x46, 0x5c, 0x1f, 0x19, 0x4a, 0x0b, 0x89, 0x9b,
99 0xc4, 0xf6, 0xf8, 0xf5, 0x2f, 0x87, 0x3f, 0xfa,
100 0x26, 0xd4, 0xf8, 0x25, 0xba, 0x1f, 0x98, 0x82,
101 0xfc, 0x26, 0xaf, 0x2d, 0xc0, 0xf9, 0xc4, 0x58,
102 0x49, 0xfa, 0x09, 0x80, 0x02, 0x62, 0xa4, 0x34,
103 0x2d, 0xcb, 0x5a, 0x6b, 0xab, 0x61, 0x5d, 0x08,
104 0xd4, 0x26, 0xe0, 0x08, 0x13, 0xd6, 0x2e, 0x02,
105 0x2a, 0x37, 0xe8, 0xd0, 0xcf, 0x36, 0xf1, 0xc7,
106 0xc0, 0x3f, 0x9b, 0x21, 0x60, 0xbd, 0x29, 0x2d,
107 0x2e, 0x01, 0x48, 0x4e, 0xf8, 0x8f, 0x20, 0x16,
108 0x8a, 0xbf, 0x82, 0xdc, 0x32, 0x7a, 0xa3, 0x18,
109 0x69, 0xd1, 0x50, 0x59, 0x31, 0x91, 0xf2, 0x6c,
110 0x5a, 0x5f, 0xca, 0x58, 0x9a, 0xb2, 0x2d, 0xb2,
112 encrypted = ecb_encrypt(key, plaintext, sbox=sbox)
113 self.assertSequenceEqual(encrypted, ciphertext)
114 decrypted = ecb_decrypt(key, encrypted, sbox=sbox)
115 self.assertSequenceEqual(decrypted, plaintext)
117 def test_cryptopp(self):
118 """Test vectors from Crypto++ 5.6.2
120 sbox = "AppliedCryptography"
122 (b"BE5EC2006CFF9DCF52354959F1FF0CBFE95061B5A648C10387069C25997C0672", b"0DF82802B741A292", b"07F9027DF7F7DF89"),
123 (b"B385272AC8D72A5A8B344BC80363AC4D09BF58F41F540624CBCB8FDCF55307D7", b"1354EE9C0A11CD4C", b"4FB50536F960A7B1"),
124 (b"AEE02F609A35660E4097E546FD3026B032CD107C7D459977ADF489BEF2652262", b"6693D492C4B0CC39", b"670034AC0FA811B5"),
125 (b"320E9D8422165D58911DFC7D8BBB1F81B0ECD924023BF94D9DF7DCF7801240E0", b"99E2D13080928D79", b"8118FF9D3B3CFE7D"),
126 (b"C9F703BBBFC63691BFA3B7B87EA8FD5E8E8EF384EF733F1A61AEF68C8FFA265F", b"D1E787749C72814C", b"A083826A790D3E0C"),
127 (b"728FEE32F04B4C654AD7F607D71C660C2C2670D7C999713233149A1C0C17A1F0", b"D4C05323A4F7A7B5", b"4D1F2E6B0D9DE2CE"),
128 (b"35FC96402209500FCFDEF5352D1ABB038FE33FC0D9D58512E56370B22BAA133B", b"8742D9A05F6A3AF6", b"2F3BB84879D11E52"),
129 (b"D416F630BE65B7FE150656183370E07018234EE5DA3D89C4CE9152A03E5BFB77", b"F86506DA04E41CB8", b"96F0A5C77A04F5CE"),
131 for key, pt, ct in data:
135 self.assertSequenceEqual(ecb_encrypt(key, pt, sbox=sbox), ct)
137 def test_cryptomanager(self):
138 """Test vector from http://cryptomanager.com/tv.html
140 sbox = "id-GostR3411-94-TestParamSet"
141 key = hexdec(b"75713134B60FEC45A607BB83AA3746AF4FF99DA6D1B53B5B1B402A1BAA030D1B")
142 self.assertSequenceEqual(
143 ecb_encrypt(key, hexdec(b"1122334455667788"), sbox=sbox),
144 hexdec(b"03251E14F9D28ACB"),
148 class CFBTest(TestCase):
149 def test_cryptomanager(self):
150 """Test vector from http://cryptomanager.com/tv.html
152 key = hexdec(b"75713134B60FEC45A607BB83AA3746AF4FF99DA6D1B53B5B1B402A1BAA030D1B")
153 sbox = "id-GostR3411-94-TestParamSet"
154 self.assertSequenceEqual(
157 hexdec(b"112233445566778899AABBCCDD800000"),
158 iv=hexdec(b"0102030405060708"),
161 hexdec(b"6EE84586DD2BCA0CAD3616940E164242"),
163 self.assertSequenceEqual(
166 hexdec(b"6EE84586DD2BCA0CAD3616940E164242"),
167 iv=hexdec(b"0102030405060708"),
170 hexdec(b"112233445566778899AABBCCDD800000"),
173 def test_steps(self):
174 """Check step-by-step operation manually
176 key = urandom(KEYSIZE)
177 iv = urandom(BLOCKSIZE)
178 plaintext = urandom(20)
179 ciphertext = cfb_encrypt(key, plaintext, iv)
182 step = encrypt(DEFAULT_SBOX, key, block2ns(iv))
183 step = strxor(plaintext[:8], ns2block(step))
184 self.assertSequenceEqual(step, ciphertext[:8])
187 step = encrypt(DEFAULT_SBOX, key, block2ns(step))
188 step = strxor(plaintext[8:16], ns2block(step))
189 self.assertSequenceEqual(step, ciphertext[8:16])
191 # Third non-full block
192 step = encrypt(DEFAULT_SBOX, key, block2ns(step))
193 step = strxor(plaintext[16:] + 4 * b"\x00", ns2block(step))
194 self.assertSequenceEqual(step[:4], ciphertext[16:])
196 def test_random(self):
197 """Random data with various sizes
199 key = urandom(KEYSIZE)
200 iv = urandom(BLOCKSIZE)
201 for size in (5, 8, 16, 120):
203 self.assertSequenceEqual(
204 cfb_decrypt(key, cfb_encrypt(key, pt, iv), iv),
209 class CTRTest(TestCase):
211 """Test vectors from libgcl3
213 sbox = "id-Gost28147-89-TestParamSet"
214 key = hexdec(b"0475f6e05038fbfad2c7c390edb3ca3d1547124291ae1e8a2f79cd9ed2bcefbd")
215 plaintext = bytes(bytearray((
216 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
217 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
218 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
219 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
220 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
221 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28,
222 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30,
223 0x3f, 0x3e, 0x3d, 0x3c, 0x3b, 0x3a, 0x39, 0x38,
224 0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x41, 0x40,
225 0x4f, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a, 0x49, 0x48,
226 0x57, 0x56, 0x55, 0x54, 0x53, 0x52, 0x51, 0x50,
227 0x5f, 0x5e, 0x5d, 0x5c, 0x5b, 0x5a, 0x59, 0x58,
228 0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0x61, 0x60,
229 0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68,
230 0x77, 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x70,
231 0x7f, 0x7e, 0x7d, 0x7c, 0x7b, 0x7a, 0x79, 0x78,
232 0x87, 0x86, 0x85, 0x84, 0x83, 0x82, 0x81, 0x80,
233 0x8f, 0x8e, 0x8d, 0x8c, 0x8b, 0x8a, 0x89, 0x88,
234 0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,
235 0x9f, 0x9e, 0x9d, 0x9c, 0x9b, 0x9a, 0x99, 0x98,
236 0xa7, 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1, 0xa0,
237 0xaf, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa8,
238 0xb7, 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1, 0xb0,
239 0xbf, 0xbe, 0xbd, 0xbc, 0xbb, 0xba, 0xb9, 0xb8,
240 0xc7, 0xc6, 0xc5, 0xc4, 0xc3, 0xc2, 0xc1, 0xc0,
241 0xcf, 0xce, 0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc8,
242 0xd7, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xd0,
243 0xdf, 0xde, 0xdd, 0xdc, 0xdb, 0xda, 0xd9, 0xd8,
244 0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
245 0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
246 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
247 0xff, 0xfe, 0xfd, 0xfc, 0xfb,
249 ciphertext = bytes(bytearray((
250 0x4a, 0x5e, 0x37, 0x6c, 0xa1, 0x12, 0xd3, 0x55,
251 0x09, 0x13, 0x1a, 0x21, 0xac, 0xfb, 0xb2, 0x1e,
252 0x8c, 0x24, 0x9b, 0x57, 0x20, 0x68, 0x46, 0xd5,
253 0x23, 0x2a, 0x26, 0x35, 0x12, 0x56, 0x5c, 0x69,
254 0x2a, 0x2f, 0xd1, 0xab, 0xbd, 0x45, 0xdc, 0x3a,
255 0x1a, 0xa4, 0x57, 0x64, 0xd5, 0xe4, 0x69, 0x6d,
256 0xb4, 0x8b, 0xf1, 0x54, 0x78, 0x3b, 0x10, 0x8f,
257 0x7a, 0x4b, 0x32, 0xe0, 0xe8, 0x4c, 0xbf, 0x03,
258 0x24, 0x37, 0x95, 0x6a, 0x55, 0xa8, 0xce, 0x6f,
259 0x95, 0x62, 0x12, 0xf6, 0x79, 0xe6, 0xf0, 0x1b,
260 0x86, 0xef, 0x36, 0x36, 0x05, 0xd8, 0x6f, 0x10,
261 0xa1, 0x41, 0x05, 0x07, 0xf8, 0xfa, 0xa4, 0x0b,
262 0x17, 0x2c, 0x71, 0xbc, 0x8b, 0xcb, 0xcf, 0x3d,
263 0x74, 0x18, 0x32, 0x0b, 0x1c, 0xd2, 0x9e, 0x75,
264 0xba, 0x3e, 0x61, 0xe1, 0x61, 0x96, 0xd0, 0xee,
265 0x8f, 0xf2, 0x9a, 0x5e, 0xb7, 0x7a, 0x15, 0xaa,
266 0x4e, 0x1e, 0x77, 0x7c, 0x99, 0xe1, 0x41, 0x13,
267 0xf4, 0x60, 0x39, 0x46, 0x4c, 0x35, 0xde, 0x95,
268 0xcc, 0x4f, 0xd5, 0xaf, 0xd1, 0x4d, 0x84, 0x1a,
269 0x45, 0xc7, 0x2a, 0xf2, 0x2c, 0xc0, 0xb7, 0x94,
270 0xa3, 0x08, 0xb9, 0x12, 0x96, 0xb5, 0x97, 0x99,
271 0x3a, 0xb7, 0x0c, 0x14, 0x56, 0xb9, 0xcb, 0x49,
272 0x44, 0xa9, 0x93, 0xa9, 0xfb, 0x19, 0x10, 0x8c,
273 0x6a, 0x68, 0xe8, 0x7b, 0x06, 0x57, 0xf0, 0xef,
274 0x88, 0x44, 0xa6, 0xd2, 0x98, 0xbe, 0xd4, 0x07,
275 0x41, 0x37, 0x45, 0xa6, 0x71, 0x36, 0x76, 0x69,
276 0x4b, 0x75, 0x15, 0x33, 0x90, 0x29, 0x6e, 0x33,
277 0xcb, 0x96, 0x39, 0x78, 0x19, 0x2e, 0x96, 0xf3,
278 0x49, 0x4c, 0x89, 0x3d, 0xa1, 0x86, 0x82, 0x00,
279 0xce, 0xbd, 0x54, 0x29, 0x65, 0x00, 0x1d, 0x16,
280 0x13, 0xc3, 0xfe, 0x1f, 0x8c, 0x55, 0x63, 0x09,
281 0x1f, 0xcd, 0xd4, 0x28, 0xca,
283 iv = b"\x02\x01\x01\x01\x01\x01\x01\x01"
284 encrypted = cnt(key, plaintext, iv=iv, sbox=sbox)
285 self.assertSequenceEqual(encrypted, ciphertext)
286 decrypted = cnt(key, encrypted, iv=iv, sbox=sbox)
287 self.assertSequenceEqual(decrypted, plaintext)
290 """Test vectors 2 from libgcl3
292 sbox = "id-Gost28147-89-TestParamSet"
293 key = hexdec(b"fc7ad2886f455b50d29008fa622b57d5c65b3c637202025799cadf0768519e8a")
294 plaintext = bytes(bytearray((
295 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
296 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
297 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
298 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
299 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
300 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28,
301 0xff, 0xfe, 0xfd, 0xfc, 0xfb,
303 ciphertext = bytes(bytearray((
304 0xd0, 0xbe, 0x60, 0x1a, 0x2c, 0xf1, 0x90, 0x26,
305 0x9b, 0x7b, 0x23, 0xb4, 0xd2, 0xcc, 0xe1, 0x15,
306 0xf6, 0x05, 0x57, 0x28, 0x88, 0x75, 0xeb, 0x1e,
307 0xd3, 0x62, 0xdc, 0xda, 0x9b, 0x62, 0xee, 0x9a,
308 0x57, 0x87, 0x8a, 0xf1, 0x82, 0x37, 0x9c, 0x7f,
309 0x13, 0xcc, 0x55, 0x38, 0xb5, 0x63, 0x32, 0xc5,
310 0x23, 0xa4, 0xcb, 0x7d, 0x51,
312 iv = BLOCKSIZE * b"\x00"
313 encrypted = cnt(key, plaintext, iv=iv, sbox=sbox)
314 self.assertSequenceEqual(encrypted, ciphertext)
315 decrypted = cnt(key, encrypted, iv=iv, sbox=sbox)
316 self.assertSequenceEqual(decrypted, plaintext)
319 class CBCTest(TestCase):
320 def test_pad_requirement(self):
322 for s in (b"", b"foo", b"foobarbaz"):
323 with self.assertRaises(ValueError):
324 cbc_encrypt(key, s, pad=False)
325 with self.assertRaises(ValueError):
326 cbc_decrypt(key, s, pad=False)
328 def test_passes(self):
329 iv = urandom(BLOCKSIZE)
331 for pt in (b"foo", b"foobarba", b"foobarbaz", 16 * b"x"):
332 ct = cbc_encrypt(key, pt, iv)
333 dt = cbc_decrypt(key, ct)
334 self.assertSequenceEqual(pt, dt)
336 def test_iv_existence_check(self):
338 with self.assertRaises(ValueError):
339 cbc_decrypt(key, BLOCKSIZE * b"x")
340 iv = urandom(BLOCKSIZE)
341 cbc_decrypt(key, cbc_encrypt(key, BLOCKSIZE * b"x", iv))
343 def test_meshing(self):
344 pt = urandom(MESH_MAX_DATA * 3)
345 key = urandom(KEYSIZE)
346 ct = cbc_encrypt(key, pt)
347 dt = cbc_decrypt(key, ct)
348 self.assertSequenceEqual(pt, dt)
351 class CFBMeshingTest(TestCase):
353 self.key = urandom(KEYSIZE)
354 self.iv = urandom(BLOCKSIZE)
356 def test_single(self):
358 ct = cfb_encrypt(self.key, pt, mesh=True)
359 dec = cfb_decrypt(self.key, ct, mesh=True)
360 self.assertSequenceEqual(pt, dec)
362 def test_short(self):
363 pt = urandom(MESH_MAX_DATA - 1)
364 ct = cfb_encrypt(self.key, pt, mesh=True)
365 dec = cfb_decrypt(self.key, ct, mesh=True)
366 dec_plain = cfb_decrypt(self.key, ct)
367 self.assertSequenceEqual(pt, dec)
368 self.assertSequenceEqual(pt, dec_plain)
370 def test_short_iv(self):
371 pt = urandom(MESH_MAX_DATA - 1)
372 ct = cfb_encrypt(self.key, pt, iv=self.iv, mesh=True)
373 dec = cfb_decrypt(self.key, ct, iv=self.iv, mesh=True)
374 dec_plain = cfb_decrypt(self.key, ct, iv=self.iv)
375 self.assertSequenceEqual(pt, dec)
376 self.assertSequenceEqual(pt, dec_plain)
378 def test_longer_iv(self):
379 pt = urandom(MESH_MAX_DATA * 3)
380 ct = cfb_encrypt(self.key, pt, iv=self.iv, mesh=True)
381 dec = cfb_decrypt(self.key, ct, iv=self.iv, mesh=True)
382 dec_plain = cfb_decrypt(self.key, ct, iv=self.iv)
383 self.assertSequenceEqual(pt, dec)
384 self.assertNotEqual(pt, dec_plain)