0x5a, 0x5f, 0xca, 0x58, 0x9a, 0xb2, 0x2d, 0xb2,
)))
encrypted = ecb_encrypt(key, plaintext, sbox=sbox)
- self.assertEqual(encrypted, ciphertext)
+ self.assertSequenceEqual(encrypted, ciphertext)
decrypted = ecb_decrypt(key, encrypted, sbox=sbox)
- self.assertEqual(decrypted, plaintext)
+ self.assertSequenceEqual(decrypted, plaintext)
def test_cryptopp(self):
""" Test vectors from Crypto++ 5.6.2
key = hexdec(key)
pt = hexdec(pt)
ct = hexdec(ct)
- self.assertEqual(ecb_encrypt(key, pt, sbox=sbox), ct)
+ self.assertSequenceEqual(ecb_encrypt(key, pt, sbox=sbox), ct)
def test_cryptomanager(self):
""" Test vector from http://cryptomanager.com/tv.html
"""
sbox = "GostR3411_94_TestParamSet"
key = hexdec(b"75713134B60FEC45A607BB83AA3746AF4FF99DA6D1B53B5B1B402A1BAA030D1B")
- self.assertEqual(
+ self.assertSequenceEqual(
ecb_encrypt(key, hexdec(b"1122334455667788"), sbox=sbox),
hexdec(b"03251E14F9D28ACB"),
)
"""
key = hexdec(b"75713134B60FEC45A607BB83AA3746AF4FF99DA6D1B53B5B1B402A1BAA030D1B")
sbox = "GostR3411_94_TestParamSet"
- self.assertEqual(
+ self.assertSequenceEqual(
cfb_encrypt(
key,
hexdec(b"112233445566778899AABBCCDD800000"),
),
hexdec(b"6EE84586DD2BCA0CAD3616940E164242"),
)
- self.assertEqual(
+ self.assertSequenceEqual(
cfb_decrypt(
key,
hexdec(b"6EE84586DD2BCA0CAD3616940E164242"),
# First full block
step = encrypt(DEFAULT_SBOX, key, block2ns(iv))
step = strxor(plaintext[:8], ns2block(step))
- self.assertEqual(step, ciphertext[:8])
+ self.assertSequenceEqual(step, ciphertext[:8])
# Second full block
step = encrypt(DEFAULT_SBOX, key, block2ns(step))
step = strxor(plaintext[8:16], ns2block(step))
- self.assertEqual(step, ciphertext[8:16])
+ self.assertSequenceEqual(step, ciphertext[8:16])
# Third non-full block
step = encrypt(DEFAULT_SBOX, key, block2ns(step))
step = strxor(plaintext[16:] + 4 * b"\x00", ns2block(step))
- self.assertEqual(step[:4], ciphertext[16:])
+ self.assertSequenceEqual(step[:4], ciphertext[16:])
def test_random(self):
""" Random data with various sizes
iv = urandom(8)
for size in (5, 8, 16, 120):
pt = urandom(size)
- self.assertEqual(
- cfb_decrypt(key, cfb_encrypt(key, pt, iv), iv), pt,
+ self.assertSequenceEqual(
+ cfb_decrypt(key, cfb_encrypt(key, pt, iv), iv),
+ pt,
)
)))
iv = b"\x02\x01\x01\x01\x01\x01\x01\x01"
encrypted = cnt(key, plaintext, iv=iv, sbox=sbox)
- self.assertEqual(encrypted, ciphertext)
+ self.assertSequenceEqual(encrypted, ciphertext)
decrypted = cnt(key, encrypted, iv=iv, sbox=sbox)
- self.assertEqual(decrypted, plaintext)
+ self.assertSequenceEqual(decrypted, plaintext)
def test_gcl2(self):
""" Test vectors 2 from libgcl3
)))
iv = 8 * b"\x00"
encrypted = cnt(key, plaintext, iv=iv, sbox=sbox)
- self.assertEqual(encrypted, ciphertext)
+ self.assertSequenceEqual(encrypted, ciphertext)
decrypted = cnt(key, encrypted, iv=iv, sbox=sbox)
- self.assertEqual(decrypted, plaintext)
+ self.assertSequenceEqual(decrypted, plaintext)
class CBCTest(TestCase):
for pt in (b"foo", b"foobarba", b"foobarbaz", 16 * b"x"):
ct = cbc_encrypt(key, pt, iv)
dt = cbc_decrypt(key, ct)
- self.assertEqual(pt, dt)
+ self.assertSequenceEqual(pt, dt)
def test_iv_existence_check(self):
key = 32 * b"x"
key = urandom(32)
ct = cbc_encrypt(key, pt)
dt = cbc_decrypt(key, ct)
- self.assertEqual(pt, dt)
+ self.assertSequenceEqual(pt, dt)
class CFBMeshingTest(TestCase):
pt = b"\x00"
ct = cfb_encrypt(self.key, pt, mesh=True)
dec = cfb_decrypt(self.key, ct, mesh=True)
- self.assertEqual(pt, dec)
+ self.assertSequenceEqual(pt, dec)
def test_short(self):
pt = urandom(MESH_MAX_DATA - 1)
ct = cfb_encrypt(self.key, pt, mesh=True)
dec = cfb_decrypt(self.key, ct, mesh=True)
dec_plain = cfb_decrypt(self.key, ct)
- self.assertEqual(pt, dec)
- self.assertEqual(pt, dec_plain)
+ self.assertSequenceEqual(pt, dec)
+ self.assertSequenceEqual(pt, dec_plain)
def test_short_iv(self):
pt = urandom(MESH_MAX_DATA - 1)
ct = cfb_encrypt(self.key, pt, iv=self.iv, mesh=True)
dec = cfb_decrypt(self.key, ct, iv=self.iv, mesh=True)
dec_plain = cfb_decrypt(self.key, ct, iv=self.iv)
- self.assertEqual(pt, dec)
- self.assertEqual(pt, dec_plain)
+ self.assertSequenceEqual(pt, dec)
+ self.assertSequenceEqual(pt, dec_plain)
def test_longer_iv(self):
pt = urandom(MESH_MAX_DATA * 3)
ct = cfb_encrypt(self.key, pt, iv=self.iv, mesh=True)
dec = cfb_decrypt(self.key, ct, iv=self.iv, mesh=True)
dec_plain = cfb_decrypt(self.key, ct, iv=self.iv)
- self.assertEqual(pt, dec)
+ self.assertSequenceEqual(pt, dec)
self.assertNotEqual(pt, dec_plain)
k = b"This is message\xFF length\x0032 bytes"
def test_a(self):
- self.assertEqual(
+ self.assertSequenceEqual(
MAC(self.k, b"a").hexdigest(),
"bd5d3b5b2b7b57af",
)
def test_abc(self):
- self.assertEqual(
+ self.assertSequenceEqual(
MAC(self.k, b"abc").hexdigest(),
"28661e40805b1ff9",
)
def test_128U(self):
- self.assertEqual(
+ self.assertSequenceEqual(
MAC(self.k, 128 * b"U").hexdigest(),
"1a06d1bad74580ef",
)
def test_13x(self):
- self.assertEqual(
+ self.assertSequenceEqual(
MAC(self.k, 13 * b"x").hexdigest(),
"917ee1f1a668fbd3",
)
m = MAC(self.k)
m.update(b"foo")
m.update(b"bar")
- self.assertEqual(m.digest(), MAC(self.k, b"foobar").digest())
+ self.assertSequenceEqual(m.digest(), MAC(self.k, b"foobar").digest())
def test_copy(self):
m = MAC(self.k, b"foo")
m.update(b"barbaz")
c.update(b"bar")
c.update(b"baz")
- self.assertEqual(m.digest(), c.digest())
+ self.assertSequenceEqual(m.digest(), c.digest())
c = GOST3410Curve(*CURVE_PARAMS["GostR3410_2001_TestParamSet"])
pubX, pubY = public_key(c, prv)
- self.assertEqual(long2bytes(pubX), pub_x)
- self.assertEqual(long2bytes(pubY), pub_y)
+ self.assertSequenceEqual(long2bytes(pubX), pub_x)
+ self.assertSequenceEqual(long2bytes(pubY), pub_y)
s = sign(c, prv, digest)
self.assertTrue(verify(c, (pubX, pubY), digest, s))
self.assertTrue(verify(c, (pubX, pubY), digest, signature))
c = GOST3410Curve(p, q, a, b, x, y)
pubX, pubY = public_key(c, prv)
- self.assertEqual(long2bytes(pubX), pub_x)
- self.assertEqual(long2bytes(pubY), pub_y)
+ self.assertSequenceEqual(long2bytes(pubX), pub_x)
+ self.assertSequenceEqual(long2bytes(pubY), pub_y)
s = sign(c, prv, digest, mode=2012)
self.assertTrue(verify(c, (pubX, pubY), digest, s, mode=2012))
self.assertTrue(verify(c, (pubX, pubY), digest, signature, mode=2012))
kek = hexdec("ee4618a0dbb10cb31777b4b86a53d9e7ef6cb3e400101410f0c0f2af46c494a6")
pub1 = public_key(curve, prv1)
pub2 = public_key(curve, prv2)
- self.assertEqual(kek_34102001(curve, prv1, pub2, ukm), kek)
- self.assertEqual(kek_34102001(curve, prv2, pub1, ukm), kek)
+ self.assertSequenceEqual(kek_34102001(curve, prv1, pub2, ukm), kek)
+ self.assertSequenceEqual(kek_34102001(curve, prv2, pub1, ukm), kek)
def test_sequence(self):
curve = GOST3410Curve(*CURVE_PARAMS["GostR3410_2001_TestParamSet"])
pub2 = public_key(curve, prv2)
kek1 = kek_34102001(curve, prv1, pub2, ukm)
kek2 = kek_34102001(curve, prv2, pub1, ukm)
- self.assertEqual(kek1, kek2)
+ self.assertSequenceEqual(kek1, kek2)
kek1 = kek_34102001(curve, prv1, pub1, ukm)
kek2 = kek_34102001(curve, prv2, pub2, ukm)
self.assertNotEqual(kek1, kek2)
prvB = prv_unmarshal(hexdec("48c859f7b6f11585887cc05ec6ef1390cfea739b1a18c0d4662293ef63b79e3b8014070b44918590b4b996acfea4edfbbbcccc8c06edd8bf5bda92a51392d0db"))
pubB = pub_unmarshal(hexdec("192fe183b9713a077253c72c8735de2ea42a3dbc66ea317838b65fa32523cd5efca974eda7c863f4954d1147f1f2b25c395fce1c129175e876d132e94ed5a65104883b414c9b592ec4dc84826f07d0b6d9006dda176ce48c391e3f97d102e03bb598bf132a228a45f7201aba08fc524a2d77e43a362ab022ad4028f75bde3b79"), mode=2012)
vko = hexdec("c9a9a77320e2cc559ed72dce6f47e2192ccea95fa648670582c054c0ef36c221")
- self.assertEqual(kek_34102012256(curve, prvA, pubB, ukm), vko)
- self.assertEqual(kek_34102012256(curve, prvB, pubA, ukm), vko)
+ self.assertSequenceEqual(kek_34102012256(curve, prvA, pubB, ukm), vko)
+ self.assertSequenceEqual(kek_34102012256(curve, prvB, pubA, ukm), vko)
def test_sequence(self):
curve = GOST3410Curve(*CURVE_PARAMS["GostR3410_2012_TC26_ParamSetA"])
pub2 = public_key(curve, prv2)
kek1 = kek_34102012256(curve, prv1, pub2, ukm)
kek2 = kek_34102012256(curve, prv2, pub1, ukm)
- self.assertEqual(kek1, kek2)
+ self.assertSequenceEqual(kek1, kek2)
kek1 = kek_34102012256(curve, prv1, pub1, ukm)
kek2 = kek_34102012256(curve, prv2, pub2, ukm)
self.assertNotEqual(kek1, kek2)
prvB = prv_unmarshal(hexdec("48c859f7b6f11585887cc05ec6ef1390cfea739b1a18c0d4662293ef63b79e3b8014070b44918590b4b996acfea4edfbbbcccc8c06edd8bf5bda92a51392d0db"))
pubB = pub_unmarshal(hexdec("192fe183b9713a077253c72c8735de2ea42a3dbc66ea317838b65fa32523cd5efca974eda7c863f4954d1147f1f2b25c395fce1c129175e876d132e94ed5a65104883b414c9b592ec4dc84826f07d0b6d9006dda176ce48c391e3f97d102e03bb598bf132a228a45f7201aba08fc524a2d77e43a362ab022ad4028f75bde3b79"), mode=2012)
vko = hexdec("79f002a96940ce7bde3259a52e015297adaad84597a0d205b50e3e1719f97bfa7ee1d2661fa9979a5aa235b558a7e6d9f88f982dd63fc35a8ec0dd5e242d3bdf")
- self.assertEqual(kek_34102012512(curve, prvA, pubB, ukm), vko)
- self.assertEqual(kek_34102012512(curve, prvB, pubA, ukm), vko)
+ self.assertSequenceEqual(kek_34102012512(curve, prvA, pubB, ukm), vko)
+ self.assertSequenceEqual(kek_34102012512(curve, prvB, pubA, ukm), vko)
def test_sequence(self):
curve = GOST3410Curve(*CURVE_PARAMS["GostR3410_2012_TC26_ParamSetA"])
pub2 = public_key(curve, prv2)
kek1 = kek_34102012512(curve, prv1, pub2, ukm)
kek2 = kek_34102012512(curve, prv2, pub1, ukm)
- self.assertEqual(kek1, kek2)
+ self.assertSequenceEqual(kek1, kek2)
kek1 = kek_34102012512(curve, prv1, pub1, ukm)
kek2 = kek_34102012512(curve, prv2, pub2, ukm)
self.assertNotEqual(kek1, kek2)
m.update(b"foobar")
c.update(b"foo")
c.update(b"bar")
- self.assertEqual(m.digest(), c.digest())
+ self.assertSequenceEqual(m.digest(), c.digest())
class TestHMAC(TestCase):
"""
def test_256(self):
for digestmod in (GOST34112012256, gost34112012256):
- self.assertEqual(
+ self.assertSequenceEqual(
hmac.new(
key=hexdec("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"),
msg=hexdec("0126bdb87800af214341456563780100"),
def test_512(self):
for digestmod in (GOST34112012512, gost34112012512):
- self.assertEqual(
+ self.assertSequenceEqual(
hmac.new(
key=hexdec("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"),
msg=hexdec("0126bdb87800af214341456563780100"),
class TestVectors(TestCase):
def test_m1(self):
m = hexdec("323130393837363534333231303938373635343332313039383736353433323130393837363534333231303938373635343332313039383736353433323130")[::-1]
- self.assertEqual(
+ self.assertSequenceEqual(
GOST34112012512(m).digest(),
hexdec("486f64c1917879417fef082b3381a4e211c324f074654c38823a7b76f830ad00fa1fbae42b1285c0352f227524bc9ab16254288dd6863dccd5b9f54a1ad0541b")[::-1]
)
- self.assertEqual(
+ self.assertSequenceEqual(
GOST34112012256(m).digest(),
hexdec("00557be5e584fd52a449b16b0251d05d27f94ab76cbaa6da890b59d8ef1e159d")[::-1]
)
def test_m2(self):
m = u"Се ветри, Стрибожи внуци, веютъ с моря стрелами на храбрыя плъкы Игоревы".encode("cp1251")
self.assertSequenceEqual(m, hexdec("fbe2e5f0eee3c820fbeafaebef20fffbf0e1e0f0f520e0ed20e8ece0ebe5f0f2f120fff0eeec20f120faf2fee5e2202ce8f6f3ede220e8e6eee1e8f0f2d1202ce8f0f2e5e220e5d1")[::-1])
- self.assertEqual(
+ self.assertSequenceEqual(
GOST34112012512(m).digest(),
hexdec("28fbc9bada033b1460642bdcddb90c3fb3e56c497ccd0f62b8a2ad4935e85f037613966de4ee00531ae60f3b5a47f8dae06915d5f2f194996fcabf2622e6881e")[::-1]
)
- self.assertEqual(
+ self.assertSequenceEqual(
GOST34112012256(m).digest(),
hexdec("508f7e553c06501d749a66fc28c6cac0b005746d97537fa85d9e40904efed29d")[::-1]
)
"""http://tc26.ru/.../R_50.1.111-2016.pdf
"""
def test_1(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(b"password", b"salt", 1, 64)),
"64770af7f748c3b1c9ac831dbcfd85c26111b30a8a657ddc3056b80ca73e040d2854fd36811f6d825cc4ab66ec0a68a490a9e5cf5156b3a2b7eecddbf9a16b47",
)
def test_2(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(b"password", b"salt", 2, 64)),
"5a585bafdfbb6e8830d6d68aa3b43ac00d2e4aebce01c9b31c2caed56f0236d4d34b2b8fbd2c4e89d54d46f50e47d45bbac301571743119e8d3c42ba66d348de",
)
def test_3(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(b"password", b"salt", 4096, 64)),
"e52deb9a2d2aaff4e2ac9d47a41f34c20376591c67807f0477e32549dc341bc7867c09841b6d58e29d0347c996301d55df0d34e47cf68f4e3c2cdaf1d9ab86c3",
)
@skip("it takes too long")
def test_4(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(b"password", b"salt", 1677216, 64)),
"49e4843bba76e300afe24c4d23dc7392def12f2c0e244172367cd70a8982ac361adb601c7e2a314e8cb7b1e9df840e36ab5615be5d742b6cf203fb55fdc48071",
)
def test_5(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(
b"passwordPASSWORDpassword",
b"saltSALTsaltSALTsaltSALTsaltSALTsalt",
)
def test_6(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(b"pass\x00word", b"sa\x00lt", 4096, 64)),
"50df062885b69801a3c10248eb0a27ab6e522ffeb20c991c660f001475d73a4e167f782c18e97e92976d9c1d970831ea78ccb879f67068cdac1910740844e830",
)
m.update(b"foobar")
c.update(b"foo")
c.update(b"bar")
- self.assertEqual(m.digest(), c.digest())
+ self.assertSequenceEqual(m.digest(), c.digest())
class TestHMACPEP247(TestCase):
class TestVectors(TestCase):
def test_empty(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"", "GostR3411_94_TestParamSet").hexdigest(),
"ce85b99cc46752fffee35cab9a7b0278abb4c2d2055cff685af4912c49490f8d",
)
def test_a(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"a", "GostR3411_94_TestParamSet").hexdigest(),
"d42c539e367c66e9c88a801f6649349c21871b4344c6a573f849fdce62f314dd",
)
def test_abc(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"abc", "GostR3411_94_TestParamSet").hexdigest(),
"f3134348c44fb1b2a277729e2285ebb5cb5e0f29c975bc753b70497c06a4d51d",
)
def test_message_digest(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"message digest", "GostR3411_94_TestParamSet").hexdigest(),
"ad4434ecb18f2c99b60cbe59ec3d2469582b65273f48de72db2fde16a4889a4d",
)
def test_Us(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(128 * b"U", "GostR3411_94_TestParamSet").hexdigest(),
"53a3a3ed25180cef0c1d85a074273e551c25660a87062a52d926a9e8fe5733a4",
)
def test_dog(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"The quick brown fox jumps over the lazy dog", "GostR3411_94_TestParamSet",).hexdigest(),
"77b7fa410c9ac58a25f49bca7d0468c9296529315eaca76bd1a10f376d1f4294",
)
def test_cog(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"The quick brown fox jumps over the lazy cog", "GostR3411_94_TestParamSet",).hexdigest(),
"a3ebc4daaab78b0be131dab5737a7f67e602670d543521319150d2e14eeec445",
)
def test_rfc32(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"This is message, length=32 bytes", "GostR3411_94_TestParamSet",).hexdigest(),
"b1c466d37519b82e8319819ff32595e047a28cb6f83eff1c6916a815a637fffa",
)
def test_rfc50(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"Suppose the original message has length = 50 bytes", "GostR3411_94_TestParamSet",).hexdigest(),
"471aba57a60a770d3a76130635c1fbea4ef14de51f78b4ae57dd893b62f55208",
)
""" CryptoPro S-box test vectors
"""
def test_empty(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"", "GostR3411_94_CryptoProParamSet").hexdigest(),
"981e5f3ca30c841487830f84fb433e13ac1101569b9c13584ac483234cd656c0",
)
def test_a(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"a", "GostR3411_94_CryptoProParamSet").hexdigest(),
"e74c52dd282183bf37af0079c9f78055715a103f17e3133ceff1aacf2f403011",
)
def test_abc(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"abc", "GostR3411_94_CryptoProParamSet").hexdigest(),
"b285056dbf18d7392d7677369524dd14747459ed8143997e163b2986f92fd42c",
)
def test_message_digest(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"message digest", "GostR3411_94_CryptoProParamSet",).hexdigest(),
"bc6041dd2aa401ebfa6e9886734174febdb4729aa972d60f549ac39b29721ba0",
)
def test_dog(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"The quick brown fox jumps over the lazy dog", "GostR3411_94_CryptoProParamSet",).hexdigest(),
"9004294a361a508c586fe53d1f1b02746765e71b765472786e4770d565830a76",
)
def test_32(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"This is message, length=32 bytes", "GostR3411_94_CryptoProParamSet",).hexdigest(),
"2cefc2f7b7bdc514e18ea57fa74ff357e7fa17d652c75f69cb1be7893ede48eb",
)
def test_50(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(b"Suppose the original message has length = 50 bytes", "GostR3411_94_CryptoProParamSet",).hexdigest(),
"c3730c5cbccacf915ac292676f21e8bd4ef75331d9405e5f1a61dc3130a65011",
)
def test_Us(self):
- self.assertEqual(
+ self.assertSequenceEqual(
GOST341194(128 * b"U", "GostR3411_94_CryptoProParamSet").hexdigest(),
"1c4ac7614691bbf427fa2316216be8f10d92edfd37cd1027514c1008f649c4e8",
)
"""http://tc26.ru/methods/containers_v1/Addition_to_PKCS5_v1_0.pdf test vectors
"""
def test_1(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(b"password", b"salt", 1, 32)),
"7314e7c04fb2e662c543674253f68bd0b73445d07f241bed872882da21662d58",
)
def test_2(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(b"password", b"salt", 2, 32)),
"990dfa2bd965639ba48b07b792775df79f2db34fef25f274378872fed7ed1bb3",
)
def test_3(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(b"password", b"salt", 4096, 32)),
"1f1829a94bdff5be10d0aeb36af498e7a97467f3b31116a5a7c1afff9deadafe",
)
@skip("it takes too long")
def test_4(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(b"password", b"salt", 16777216, 32)),
"a57ae5a6088396d120850c5c09de0a525100938a59b1b5c3f7810910d05fcd97",
)
def test_5(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(
b"passwordPASSWORDpassword",
b"saltSALTsaltSALTsaltSALTsaltSALTsalt",
)
def test_6(self):
- self.assertEqual(
+ self.assertSequenceEqual(
hexenc(pbkdf2(
b"pass\x00word",
b"sa\x00lt",
class STest(TestCase):
def test_vec1(self):
blk = bytearray(hexdec("ffeeddccbbaa99881122334455667700"))
- self.assertEqual(S(blk), hexdec("b66cd8887d38e8d77765aeea0c9a7efc"))
+ self.assertSequenceEqual(S(blk), hexdec("b66cd8887d38e8d77765aeea0c9a7efc"))
def test_vec2(self):
blk = bytearray(hexdec("b66cd8887d38e8d77765aeea0c9a7efc"))
- self.assertEqual(S(blk), hexdec("559d8dd7bd06cbfe7e7b262523280d39"))
+ self.assertSequenceEqual(S(blk), hexdec("559d8dd7bd06cbfe7e7b262523280d39"))
def test_vec3(self):
blk = bytearray(hexdec("559d8dd7bd06cbfe7e7b262523280d39"))
- self.assertEqual(S(blk), hexdec("0c3322fed531e4630d80ef5c5a81c50b"))
+ self.assertSequenceEqual(S(blk), hexdec("0c3322fed531e4630d80ef5c5a81c50b"))
def test_vec4(self):
blk = bytearray(hexdec("0c3322fed531e4630d80ef5c5a81c50b"))
- self.assertEqual(S(blk), hexdec("23ae65633f842d29c5df529c13f5acda"))
+ self.assertSequenceEqual(S(blk), hexdec("23ae65633f842d29c5df529c13f5acda"))
class RTest(TestCase):
def test_vec1(self):
blk = bytearray(hexdec("00000000000000000000000000000100"))
- self.assertEqual(R(blk), hexdec("94000000000000000000000000000001"))
+ self.assertSequenceEqual(R(blk), hexdec("94000000000000000000000000000001"))
def test_vec2(self):
blk = bytearray(hexdec("94000000000000000000000000000001"))
- self.assertEqual(R(blk), hexdec("a5940000000000000000000000000000"))
+ self.assertSequenceEqual(R(blk), hexdec("a5940000000000000000000000000000"))
def test_vec3(self):
blk = bytearray(hexdec("a5940000000000000000000000000000"))
- self.assertEqual(R(blk), hexdec("64a59400000000000000000000000000"))
+ self.assertSequenceEqual(R(blk), hexdec("64a59400000000000000000000000000"))
def test_vec4(self):
blk = bytearray(hexdec("64a59400000000000000000000000000"))
- self.assertEqual(R(blk), hexdec("0d64a594000000000000000000000000"))
+ self.assertSequenceEqual(R(blk), hexdec("0d64a594000000000000000000000000"))
class LTest(TestCase):
def test_vec1(self):
blk = bytearray(hexdec("64a59400000000000000000000000000"))
- self.assertEqual(L(blk), hexdec("d456584dd0e3e84cc3166e4b7fa2890d"))
+ self.assertSequenceEqual(L(blk), hexdec("d456584dd0e3e84cc3166e4b7fa2890d"))
def test_vec2(self):
blk = bytearray(hexdec("d456584dd0e3e84cc3166e4b7fa2890d"))
- self.assertEqual(L(blk), hexdec("79d26221b87b584cd42fbc4ffea5de9a"))
+ self.assertSequenceEqual(L(blk), hexdec("79d26221b87b584cd42fbc4ffea5de9a"))
def test_vec3(self):
blk = bytearray(hexdec("79d26221b87b584cd42fbc4ffea5de9a"))
- self.assertEqual(L(blk), hexdec("0e93691a0cfc60408b7b68f66b513c13"))
+ self.assertSequenceEqual(L(blk), hexdec("0e93691a0cfc60408b7b68f66b513c13"))
def test_vec4(self):
blk = bytearray(hexdec("0e93691a0cfc60408b7b68f66b513c13"))
- self.assertEqual(L(blk), hexdec("e6a8094fee0aa204fd97bcb0b44b8580"))
+ self.assertSequenceEqual(L(blk), hexdec("e6a8094fee0aa204fd97bcb0b44b8580"))
class KuznechikTest(TestCase):
ciphertext = hexdec("7f679d90bebc24305a468d42b9d4edcd")
def test_c(self):
- self.assertEqual(C[0], hexdec("6ea276726c487ab85d27bd10dd849401"))
- self.assertEqual(C[1], hexdec("dc87ece4d890f4b3ba4eb92079cbeb02"))
- self.assertEqual(C[2], hexdec("b2259a96b4d88e0be7690430a44f7f03"))
- self.assertEqual(C[3], hexdec("7bcd1b0b73e32ba5b79cb140f2551504"))
- self.assertEqual(C[4], hexdec("156f6d791fab511deabb0c502fd18105"))
- self.assertEqual(C[5], hexdec("a74af7efab73df160dd208608b9efe06"))
- self.assertEqual(C[6], hexdec("c9e8819dc73ba5ae50f5b570561a6a07"))
- self.assertEqual(C[7], hexdec("f6593616e6055689adfba18027aa2a08"))
+ self.assertSequenceEqual(C[0], hexdec("6ea276726c487ab85d27bd10dd849401"))
+ self.assertSequenceEqual(C[1], hexdec("dc87ece4d890f4b3ba4eb92079cbeb02"))
+ self.assertSequenceEqual(C[2], hexdec("b2259a96b4d88e0be7690430a44f7f03"))
+ self.assertSequenceEqual(C[3], hexdec("7bcd1b0b73e32ba5b79cb140f2551504"))
+ self.assertSequenceEqual(C[4], hexdec("156f6d791fab511deabb0c502fd18105"))
+ self.assertSequenceEqual(C[5], hexdec("a74af7efab73df160dd208608b9efe06"))
+ self.assertSequenceEqual(C[6], hexdec("c9e8819dc73ba5ae50f5b570561a6a07"))
+ self.assertSequenceEqual(C[7], hexdec("f6593616e6055689adfba18027aa2a08"))
def test_roundkeys(self):
ciph = GOST3412Kuznechik(self.key)
- self.assertEqual(ciph.ks[0], hexdec("8899aabbccddeeff0011223344556677"))
- self.assertEqual(ciph.ks[1], hexdec("fedcba98765432100123456789abcdef"))
- self.assertEqual(ciph.ks[2], hexdec("db31485315694343228d6aef8cc78c44"))
- self.assertEqual(ciph.ks[3], hexdec("3d4553d8e9cfec6815ebadc40a9ffd04"))
- self.assertEqual(ciph.ks[4], hexdec("57646468c44a5e28d3e59246f429f1ac"))
- self.assertEqual(ciph.ks[5], hexdec("bd079435165c6432b532e82834da581b"))
- self.assertEqual(ciph.ks[6], hexdec("51e640757e8745de705727265a0098b1"))
- self.assertEqual(ciph.ks[7], hexdec("5a7925017b9fdd3ed72a91a22286f984"))
- self.assertEqual(ciph.ks[8], hexdec("bb44e25378c73123a5f32f73cdb6e517"))
- self.assertEqual(ciph.ks[9], hexdec("72e9dd7416bcf45b755dbaa88e4a4043"))
+ self.assertSequenceEqual(ciph.ks[0], hexdec("8899aabbccddeeff0011223344556677"))
+ self.assertSequenceEqual(ciph.ks[1], hexdec("fedcba98765432100123456789abcdef"))
+ self.assertSequenceEqual(ciph.ks[2], hexdec("db31485315694343228d6aef8cc78c44"))
+ self.assertSequenceEqual(ciph.ks[3], hexdec("3d4553d8e9cfec6815ebadc40a9ffd04"))
+ self.assertSequenceEqual(ciph.ks[4], hexdec("57646468c44a5e28d3e59246f429f1ac"))
+ self.assertSequenceEqual(ciph.ks[5], hexdec("bd079435165c6432b532e82834da581b"))
+ self.assertSequenceEqual(ciph.ks[6], hexdec("51e640757e8745de705727265a0098b1"))
+ self.assertSequenceEqual(ciph.ks[7], hexdec("5a7925017b9fdd3ed72a91a22286f984"))
+ self.assertSequenceEqual(ciph.ks[8], hexdec("bb44e25378c73123a5f32f73cdb6e517"))
+ self.assertSequenceEqual(ciph.ks[9], hexdec("72e9dd7416bcf45b755dbaa88e4a4043"))
def test_encrypt(self):
ciph = GOST3412Kuznechik(self.key)
- self.assertEqual(ciph.encrypt(self.plaintext), self.ciphertext)
+ self.assertSequenceEqual(ciph.encrypt(self.plaintext), self.ciphertext)
def test_decrypt(self):
ciph = GOST3412Kuznechik(self.key)
- self.assertEqual(ciph.decrypt(self.ciphertext), self.plaintext)
+ self.assertSequenceEqual(ciph.decrypt(self.ciphertext), self.plaintext)
class MagmaTest(TestCase):
def test_encrypt(self):
ciph = GOST3412Magma(self.key)
- self.assertEqual(ciph.encrypt(self.plaintext), self.ciphertext)
+ self.assertSequenceEqual(ciph.encrypt(self.plaintext), self.ciphertext)
def test_decrypt(self):
ciph = GOST3412Magma(self.key)
- self.assertEqual(ciph.decrypt(self.ciphertext), self.plaintext)
+ self.assertSequenceEqual(ciph.decrypt(self.ciphertext), self.plaintext)
ukm = urandom(8)
wrapped = wrap_gost(ukm, kek, cek)
unwrapped = unwrap_gost(kek, wrapped)
- self.assertEqual(unwrapped, cek)
+ self.assertSequenceEqual(unwrapped, cek)
def test_invalid_length(self):
with self.assertRaises(ValueError):
ukm = urandom(8)
wrapped = wrap_cryptopro(ukm, kek, cek)
unwrapped = unwrap_cryptopro(kek, wrapped)
- self.assertEqual(unwrapped, cek)
+ self.assertSequenceEqual(unwrapped, cek)