README | 3 +-- doc/NEWS | 3 ++- doc/index | 3 +-- pygost/gost28147.py | 3 +-- pygost/gost3410.py | 123 ++++++++++++++++++++++++++--------------------------- pygost/gost34112012.py | 5 ++--- pygost/gost341194.py | 8 +++----- pygost/iface.py | 4 +--- pygost/sespake.py | 58 +++++++++++++++++++++++++++--------------------------- pygost/test_cms.py | 25 ++++++++++++------------- pygost/test_gost28147.py | 49 ++++++++++++++++++++++++------------------------- pygost/test_gost3410.py | 36 +++++++++++++++++------------------- pygost/test_gost3410_vko.py | 33 ++++++++++++++++----------------- pygost/test_gost34112012.py | 38 ++++++++++++++++++-------------------- pygost/test_gost341194.py | 17 ++++++++--------- pygost/test_gost3412.py | 97 ++++++++++++++++++++++++++--------------------------- pygost/test_gost3413.py | 200 ++++++++++++++++++++++++++--------------------------- pygost/test_kdf.py | 27 +++++++++++++-------------- pygost/test_mgm.py | 11 +++++------ pygost/test_pfx.py | 23 +++++++++++------------ pygost/test_sespake.py | 50 ++++++++++++++++++++++++-------------------------- pygost/test_wrap.py | 15 +++++++-------- pygost/test_x509.py | 13 ++++++------- pygost/utils.py | 16 ---------------- diff --git a/README b/README index 7314a4535592c04dc4f2c128aa89a74b52f712128a498dfd9947162d5f2a762c..be3af2a161806e57c3bbe23ebb312c0b86b0a60ecae281456c50a6cb6e872d60 100644 --- a/README +++ b/README @@ -47,8 +47,7 @@ >>> prv_raw = prv_marshal(curve, prv) >>> from pygost.gost3410 import public_key >>> pub = public_key(curve, prv) >>> from pygost.gost3410 import pub_marshal - >>> from pygost.utils import hexenc - >>> print "Public key is:", hexenc(pub_marshal(pub)) + >>> print "Public key is:", pub_marshal(pub).hex() >>> from pygost import gost34112012512 >>> data_for_signing = b"some data" >>> dgst = gost34112012512.new(data_for_signing).digest() diff --git a/doc/NEWS b/doc/NEWS index b7d8c96da7ab5e0219e968c3e787dc6306fce460b6ccae514f232ebeb7d73e41..bd5de1b0e8c402b5f757028d6de3172f01e70d178755541e0cc159713cf5f27d 100644 --- a/doc/NEWS +++ b/doc/NEWS @@ -2,7 +2,8 @@ A 6.0 6.0 * Removed Python2 compatibility. * Added SESPAKE (RFC 8133) algorithm support. - * Removed utils.bytes2long, utils.long2bytes, utils.xrange. + * Removed utils.bytes2long, utils.long2bytes, + utils.xrange, utils.hexenc, utils.hexdec. A 5.13 5.13 diff --git a/doc/index b/doc/index index 683ca62bfb642322ec92609b3d714f35701c58209d74b86da3757cf608641c5a..b728783d8e19ce1ebb6f42f72011ffff521f01d269bbf7a6ca1b791987f5654b 100644 --- a/doc/index +++ b/doc/index @@ -63,8 +63,7 @@ >>> prv = prv_unmarshal(prv_raw) >>> from pygost.gost3410 import public_key >>> pub = public_key(curve, prv) >>> from pygost.gost3410 import pub_marshal - >>> from pygost.utils import hexenc - >>> print "Public key is:", hexenc(pub_marshal(pub)) + >>> print "Public key is:", pub_marshal(pub).hex() >>> from pygost import gost34112012512 >>> data_for_signing = b"some data" >>> dgst = gost34112012512.new(data_for_signing).digest()[::-1] diff --git a/pygost/gost28147.py b/pygost/gost28147.py index deb7feb07a51b9867426069e06dafc9e86e148a6042e42e59a1d0aab44fb0a9d..e4eccb294aea078bed0e4b642c02aabfd044bcb037ddb02e94f8d3aeaa2e6cd6 100644 --- a/pygost/gost28147.py +++ b/pygost/gost28147.py @@ -27,7 +27,6 @@ from pygost.gost3413 import pad2 from pygost.gost3413 import pad_size from pygost.gost3413 import unpad2 -from pygost.utils import hexdec from pygost.utils import strxor @@ -368,7 +367,7 @@ gamma.append(ns2block(encrypt(sbox, key, (n1, n2)))) return strxor(b"".join(gamma), data) -MESH_CONST = hexdec("6900722264C904238D3ADB9646E92AC418FEAC9400ED0712C086DCC2EF4CA92B") +MESH_CONST = bytes.fromhex("6900722264C904238D3ADB9646E92AC418FEAC9400ED0712C086DCC2EF4CA92B") MESH_MAX_DATA = 1024 diff --git a/pygost/gost3410.py b/pygost/gost3410.py index e03c933b8c6d7053fb8a96dafa1b553ddf8ef503f3c938525e8fd0af0f992bcf..601c91d1d41463f6b0ab0c975d553896fd6c6b9cc282bb06b7dfd17fce0cd561 100644 --- a/pygost/gost3410.py +++ b/pygost/gost3410.py @@ -23,7 +23,6 @@ from os import urandom from typing import Tuple -from pygost.utils import hexdec from pygost.utils import modinvert @@ -150,90 +149,90 @@ CURVES = { "GostR3410_2001_ParamSet_cc": GOST3410Curve( - p=int.from_bytes(hexdec("C0000000000000000000000000000000000000000000000000000000000003C7"), "big"), - q=int.from_bytes(hexdec("5fffffffffffffffffffffffffffffff606117a2f4bde428b7458a54b6e87b85"), "big"), - a=int.from_bytes(hexdec("C0000000000000000000000000000000000000000000000000000000000003c4"), "big"), - b=int.from_bytes(hexdec("2d06B4265ebc749ff7d0f1f1f88232e81632e9088fd44b7787d5e407e955080c"), "big"), - x=int.from_bytes(hexdec("0000000000000000000000000000000000000000000000000000000000000002"), "big"), - y=int.from_bytes(hexdec("a20e034bf8813ef5c18d01105e726a17eb248b264ae9706f440bedc8ccb6b22c"), "big"), + p=int.from_bytes(bytes.fromhex("C0000000000000000000000000000000000000000000000000000000000003C7"), "big"), + q=int.from_bytes(bytes.fromhex("5fffffffffffffffffffffffffffffff606117a2f4bde428b7458a54b6e87b85"), "big"), + a=int.from_bytes(bytes.fromhex("C0000000000000000000000000000000000000000000000000000000000003c4"), "big"), + b=int.from_bytes(bytes.fromhex("2d06B4265ebc749ff7d0f1f1f88232e81632e9088fd44b7787d5e407e955080c"), "big"), + x=int.from_bytes(bytes.fromhex("0000000000000000000000000000000000000000000000000000000000000002"), "big"), + y=int.from_bytes(bytes.fromhex("a20e034bf8813ef5c18d01105e726a17eb248b264ae9706f440bedc8ccb6b22c"), "big"), ), "id-GostR3410-2001-TestParamSet": GOST3410Curve( - p=int.from_bytes(hexdec("8000000000000000000000000000000000000000000000000000000000000431"), "big"), - q=int.from_bytes(hexdec("8000000000000000000000000000000150FE8A1892976154C59CFC193ACCF5B3"), "big"), - a=int.from_bytes(hexdec("0000000000000000000000000000000000000000000000000000000000000007"), "big"), - b=int.from_bytes(hexdec("5FBFF498AA938CE739B8E022FBAFEF40563F6E6A3472FC2A514C0CE9DAE23B7E"), "big"), - x=int.from_bytes(hexdec("0000000000000000000000000000000000000000000000000000000000000002"), "big"), - y=int.from_bytes(hexdec("08E2A8A0E65147D4BD6316030E16D19C85C97F0A9CA267122B96ABBCEA7E8FC8"), "big"), + p=int.from_bytes(bytes.fromhex("8000000000000000000000000000000000000000000000000000000000000431"), "big"), + q=int.from_bytes(bytes.fromhex("8000000000000000000000000000000150FE8A1892976154C59CFC193ACCF5B3"), "big"), + a=int.from_bytes(bytes.fromhex("0000000000000000000000000000000000000000000000000000000000000007"), "big"), + b=int.from_bytes(bytes.fromhex("5FBFF498AA938CE739B8E022FBAFEF40563F6E6A3472FC2A514C0CE9DAE23B7E"), "big"), + x=int.from_bytes(bytes.fromhex("0000000000000000000000000000000000000000000000000000000000000002"), "big"), + y=int.from_bytes(bytes.fromhex("08E2A8A0E65147D4BD6316030E16D19C85C97F0A9CA267122B96ABBCEA7E8FC8"), "big"), ), "id-tc26-gost-3410-12-256-paramSetA": GOST3410Curve( - p=int.from_bytes(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD97"), "big"), - q=int.from_bytes(hexdec("400000000000000000000000000000000FD8CDDFC87B6635C115AF556C360C67"), "big"), - a=int.from_bytes(hexdec("C2173F1513981673AF4892C23035A27CE25E2013BF95AA33B22C656F277E7335"), "big"), - b=int.from_bytes(hexdec("295F9BAE7428ED9CCC20E7C359A9D41A22FCCD9108E17BF7BA9337A6F8AE9513"), "big"), - x=int.from_bytes(hexdec("91E38443A5E82C0D880923425712B2BB658B9196932E02C78B2582FE742DAA28"), "big"), - y=int.from_bytes(hexdec("32879423AB1A0375895786C4BB46E9565FDE0B5344766740AF268ADB32322E5C"), "big"), + p=int.from_bytes(bytes.fromhex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD97"), "big"), + q=int.from_bytes(bytes.fromhex("400000000000000000000000000000000FD8CDDFC87B6635C115AF556C360C67"), "big"), + a=int.from_bytes(bytes.fromhex("C2173F1513981673AF4892C23035A27CE25E2013BF95AA33B22C656F277E7335"), "big"), + b=int.from_bytes(bytes.fromhex("295F9BAE7428ED9CCC20E7C359A9D41A22FCCD9108E17BF7BA9337A6F8AE9513"), "big"), + x=int.from_bytes(bytes.fromhex("91E38443A5E82C0D880923425712B2BB658B9196932E02C78B2582FE742DAA28"), "big"), + y=int.from_bytes(bytes.fromhex("32879423AB1A0375895786C4BB46E9565FDE0B5344766740AF268ADB32322E5C"), "big"), cofactor=4, e=0x01, - d=int.from_bytes(hexdec("0605F6B7C183FA81578BC39CFAD518132B9DF62897009AF7E522C32D6DC7BFFB"), "big"), + d=int.from_bytes(bytes.fromhex("0605F6B7C183FA81578BC39CFAD518132B9DF62897009AF7E522C32D6DC7BFFB"), "big"), ), "id-tc26-gost-3410-12-256-paramSetB": GOST3410Curve( - p=int.from_bytes(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD97"), "big"), - q=int.from_bytes(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6C611070995AD10045841B09B761B893"), "big"), - a=int.from_bytes(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD94"), "big"), - b=int.from_bytes(hexdec("00000000000000000000000000000000000000000000000000000000000000a6"), "big"), - x=int.from_bytes(hexdec("0000000000000000000000000000000000000000000000000000000000000001"), "big"), - y=int.from_bytes(hexdec("8D91E471E0989CDA27DF505A453F2B7635294F2DDF23E3B122ACC99C9E9F1E14"), "big"), + p=int.from_bytes(bytes.fromhex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD97"), "big"), + q=int.from_bytes(bytes.fromhex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6C611070995AD10045841B09B761B893"), "big"), + a=int.from_bytes(bytes.fromhex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD94"), "big"), + b=int.from_bytes(bytes.fromhex("00000000000000000000000000000000000000000000000000000000000000a6"), "big"), + x=int.from_bytes(bytes.fromhex("0000000000000000000000000000000000000000000000000000000000000001"), "big"), + y=int.from_bytes(bytes.fromhex("8D91E471E0989CDA27DF505A453F2B7635294F2DDF23E3B122ACC99C9E9F1E14"), "big"), ), "id-tc26-gost-3410-12-256-paramSetC": GOST3410Curve( - p=int.from_bytes(hexdec("8000000000000000000000000000000000000000000000000000000000000C99"), "big"), - q=int.from_bytes(hexdec("800000000000000000000000000000015F700CFFF1A624E5E497161BCC8A198F"), "big"), - a=int.from_bytes(hexdec("8000000000000000000000000000000000000000000000000000000000000C96"), "big"), - b=int.from_bytes(hexdec("3E1AF419A269A5F866A7D3C25C3DF80AE979259373FF2B182F49D4CE7E1BBC8B"), "big"), - x=int.from_bytes(hexdec("0000000000000000000000000000000000000000000000000000000000000001"), "big"), - y=int.from_bytes(hexdec("3FA8124359F96680B83D1C3EB2C070E5C545C9858D03ECFB744BF8D717717EFC"), "big"), + p=int.from_bytes(bytes.fromhex("8000000000000000000000000000000000000000000000000000000000000C99"), "big"), + q=int.from_bytes(bytes.fromhex("800000000000000000000000000000015F700CFFF1A624E5E497161BCC8A198F"), "big"), + a=int.from_bytes(bytes.fromhex("8000000000000000000000000000000000000000000000000000000000000C96"), "big"), + b=int.from_bytes(bytes.fromhex("3E1AF419A269A5F866A7D3C25C3DF80AE979259373FF2B182F49D4CE7E1BBC8B"), "big"), + x=int.from_bytes(bytes.fromhex("0000000000000000000000000000000000000000000000000000000000000001"), "big"), + y=int.from_bytes(bytes.fromhex("3FA8124359F96680B83D1C3EB2C070E5C545C9858D03ECFB744BF8D717717EFC"), "big"), ), "id-tc26-gost-3410-12-256-paramSetD": GOST3410Curve( - p=int.from_bytes(hexdec("9B9F605F5A858107AB1EC85E6B41C8AACF846E86789051D37998F7B9022D759B"), "big"), - q=int.from_bytes(hexdec("9B9F605F5A858107AB1EC85E6B41C8AA582CA3511EDDFB74F02F3A6598980BB9"), "big"), - a=int.from_bytes(hexdec("9B9F605F5A858107AB1EC85E6B41C8AACF846E86789051D37998F7B9022D7598"), "big"), - b=int.from_bytes(hexdec("000000000000000000000000000000000000000000000000000000000000805a"), "big"), - x=int.from_bytes(hexdec("0000000000000000000000000000000000000000000000000000000000000000"), "big"), - y=int.from_bytes(hexdec("41ECE55743711A8C3CBF3783CD08C0EE4D4DC440D4641A8F366E550DFDB3BB67"), "big"), + p=int.from_bytes(bytes.fromhex("9B9F605F5A858107AB1EC85E6B41C8AACF846E86789051D37998F7B9022D759B"), "big"), + q=int.from_bytes(bytes.fromhex("9B9F605F5A858107AB1EC85E6B41C8AA582CA3511EDDFB74F02F3A6598980BB9"), "big"), + a=int.from_bytes(bytes.fromhex("9B9F605F5A858107AB1EC85E6B41C8AACF846E86789051D37998F7B9022D7598"), "big"), + b=int.from_bytes(bytes.fromhex("000000000000000000000000000000000000000000000000000000000000805a"), "big"), + x=int.from_bytes(bytes.fromhex("0000000000000000000000000000000000000000000000000000000000000000"), "big"), + y=int.from_bytes(bytes.fromhex("41ECE55743711A8C3CBF3783CD08C0EE4D4DC440D4641A8F366E550DFDB3BB67"), "big"), ), "id-tc26-gost-3410-12-512-paramSetTest": GOST3410Curve( - p=int.from_bytes(hexdec("4531ACD1FE0023C7550D267B6B2FEE80922B14B2FFB90F04D4EB7C09B5D2D15DF1D852741AF4704A0458047E80E4546D35B8336FAC224DD81664BBF528BE6373"), "big"), - q=int.from_bytes(hexdec("4531ACD1FE0023C7550D267B6B2FEE80922B14B2FFB90F04D4EB7C09B5D2D15DA82F2D7ECB1DBAC719905C5EECC423F1D86E25EDBE23C595D644AAF187E6E6DF"), "big"), + p=int.from_bytes(bytes.fromhex("4531ACD1FE0023C7550D267B6B2FEE80922B14B2FFB90F04D4EB7C09B5D2D15DF1D852741AF4704A0458047E80E4546D35B8336FAC224DD81664BBF528BE6373"), "big"), + q=int.from_bytes(bytes.fromhex("4531ACD1FE0023C7550D267B6B2FEE80922B14B2FFB90F04D4EB7C09B5D2D15DA82F2D7ECB1DBAC719905C5EECC423F1D86E25EDBE23C595D644AAF187E6E6DF"), "big"), a=7, - b=int.from_bytes(hexdec("1CFF0806A31116DA29D8CFA54E57EB748BC5F377E49400FDD788B649ECA1AC4361834013B2AD7322480A89CA58E0CF74BC9E540C2ADD6897FAD0A3084F302ADC"), "big"), - x=int.from_bytes(hexdec("24D19CC64572EE30F396BF6EBBFD7A6C5213B3B3D7057CC825F91093A68CD762FD60611262CD838DC6B60AA7EEE804E28BC849977FAC33B4B530F1B120248A9A"), "big"), - y=int.from_bytes(hexdec("2BB312A43BD2CE6E0D020613C857ACDDCFBF061E91E5F2C3F32447C259F39B2C83AB156D77F1496BF7EB3351E1EE4E43DC1A18B91B24640B6DBB92CB1ADD371E"), "big"), + b=int.from_bytes(bytes.fromhex("1CFF0806A31116DA29D8CFA54E57EB748BC5F377E49400FDD788B649ECA1AC4361834013B2AD7322480A89CA58E0CF74BC9E540C2ADD6897FAD0A3084F302ADC"), "big"), + x=int.from_bytes(bytes.fromhex("24D19CC64572EE30F396BF6EBBFD7A6C5213B3B3D7057CC825F91093A68CD762FD60611262CD838DC6B60AA7EEE804E28BC849977FAC33B4B530F1B120248A9A"), "big"), + y=int.from_bytes(bytes.fromhex("2BB312A43BD2CE6E0D020613C857ACDDCFBF061E91E5F2C3F32447C259F39B2C83AB156D77F1496BF7EB3351E1EE4E43DC1A18B91B24640B6DBB92CB1ADD371E"), "big"), ), "id-tc26-gost-3410-12-512-paramSetA": GOST3410Curve( - p=int.from_bytes(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC7"), "big"), - q=int.from_bytes(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF27E69532F48D89116FF22B8D4E0560609B4B38ABFAD2B85DCACDB1411F10B275"), "big"), - a=int.from_bytes(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC4"), "big"), - b=int.from_bytes(hexdec("E8C2505DEDFC86DDC1BD0B2B6667F1DA34B82574761CB0E879BD081CFD0B6265EE3CB090F30D27614CB4574010DA90DD862EF9D4EBEE4761503190785A71C760"), "big"), - x=int.from_bytes(hexdec("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003"), "big"), - y=int.from_bytes(hexdec("7503CFE87A836AE3A61B8816E25450E6CE5E1C93ACF1ABC1778064FDCBEFA921DF1626BE4FD036E93D75E6A50E3A41E98028FE5FC235F5B889A589CB5215F2A4"), "big"), + p=int.from_bytes(bytes.fromhex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC7"), "big"), + q=int.from_bytes(bytes.fromhex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF27E69532F48D89116FF22B8D4E0560609B4B38ABFAD2B85DCACDB1411F10B275"), "big"), + a=int.from_bytes(bytes.fromhex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC4"), "big"), + b=int.from_bytes(bytes.fromhex("E8C2505DEDFC86DDC1BD0B2B6667F1DA34B82574761CB0E879BD081CFD0B6265EE3CB090F30D27614CB4574010DA90DD862EF9D4EBEE4761503190785A71C760"), "big"), + x=int.from_bytes(bytes.fromhex("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003"), "big"), + y=int.from_bytes(bytes.fromhex("7503CFE87A836AE3A61B8816E25450E6CE5E1C93ACF1ABC1778064FDCBEFA921DF1626BE4FD036E93D75E6A50E3A41E98028FE5FC235F5B889A589CB5215F2A4"), "big"), ), "id-tc26-gost-3410-12-512-paramSetB": GOST3410Curve( - p=int.from_bytes(hexdec("8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006F"), "big"), - q=int.from_bytes(hexdec("800000000000000000000000000000000000000000000000000000000000000149A1EC142565A545ACFDB77BD9D40CFA8B996712101BEA0EC6346C54374F25BD"), "big"), - a=int.from_bytes(hexdec("8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006C"), "big"), - b=int.from_bytes(hexdec("687D1B459DC841457E3E06CF6F5E2517B97C7D614AF138BCBF85DC806C4B289F3E965D2DB1416D217F8B276FAD1AB69C50F78BEE1FA3106EFB8CCBC7C5140116"), "big"), - x=int.from_bytes(hexdec("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002"), "big"), - y=int.from_bytes(hexdec("1A8F7EDA389B094C2C071E3647A8940F3C123B697578C213BE6DD9E6C8EC7335DCB228FD1EDF4A39152CBCAAF8C0398828041055F94CEEEC7E21340780FE41BD"), "big"), + p=int.from_bytes(bytes.fromhex("8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006F"), "big"), + q=int.from_bytes(bytes.fromhex("800000000000000000000000000000000000000000000000000000000000000149A1EC142565A545ACFDB77BD9D40CFA8B996712101BEA0EC6346C54374F25BD"), "big"), + a=int.from_bytes(bytes.fromhex("8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006C"), "big"), + b=int.from_bytes(bytes.fromhex("687D1B459DC841457E3E06CF6F5E2517B97C7D614AF138BCBF85DC806C4B289F3E965D2DB1416D217F8B276FAD1AB69C50F78BEE1FA3106EFB8CCBC7C5140116"), "big"), + x=int.from_bytes(bytes.fromhex("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002"), "big"), + y=int.from_bytes(bytes.fromhex("1A8F7EDA389B094C2C071E3647A8940F3C123B697578C213BE6DD9E6C8EC7335DCB228FD1EDF4A39152CBCAAF8C0398828041055F94CEEEC7E21340780FE41BD"), "big"), ), "id-tc26-gost-3410-12-512-paramSetC": GOST3410Curve( - p=int.from_bytes(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC7"), "big"), - q=int.from_bytes(hexdec("3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC98CDBA46506AB004C33A9FF5147502CC8EDA9E7A769A12694623CEF47F023ED"), "big"), - a=int.from_bytes(hexdec("DC9203E514A721875485A529D2C722FB187BC8980EB866644DE41C68E143064546E861C0E2C9EDD92ADE71F46FCF50FF2AD97F951FDA9F2A2EB6546F39689BD3"), "big"), - b=int.from_bytes(hexdec("B4C4EE28CEBC6C2C8AC12952CF37F16AC7EFB6A9F69F4B57FFDA2E4F0DE5ADE038CBC2FFF719D2C18DE0284B8BFEF3B52B8CC7A5F5BF0A3C8D2319A5312557E1"), "big"), - x=int.from_bytes(hexdec("E2E31EDFC23DE7BDEBE241CE593EF5DE2295B7A9CBAEF021D385F7074CEA043AA27272A7AE602BF2A7B9033DB9ED3610C6FB85487EAE97AAC5BC7928C1950148"), "big"), - y=int.from_bytes(hexdec("F5CE40D95B5EB899ABBCCFF5911CB8577939804D6527378B8C108C3D2090FF9BE18E2D33E3021ED2EF32D85822423B6304F726AA854BAE07D0396E9A9ADDC40F"), "big"), + p=int.from_bytes(bytes.fromhex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC7"), "big"), + q=int.from_bytes(bytes.fromhex("3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC98CDBA46506AB004C33A9FF5147502CC8EDA9E7A769A12694623CEF47F023ED"), "big"), + a=int.from_bytes(bytes.fromhex("DC9203E514A721875485A529D2C722FB187BC8980EB866644DE41C68E143064546E861C0E2C9EDD92ADE71F46FCF50FF2AD97F951FDA9F2A2EB6546F39689BD3"), "big"), + b=int.from_bytes(bytes.fromhex("B4C4EE28CEBC6C2C8AC12952CF37F16AC7EFB6A9F69F4B57FFDA2E4F0DE5ADE038CBC2FFF719D2C18DE0284B8BFEF3B52B8CC7A5F5BF0A3C8D2319A5312557E1"), "big"), + x=int.from_bytes(bytes.fromhex("E2E31EDFC23DE7BDEBE241CE593EF5DE2295B7A9CBAEF021D385F7074CEA043AA27272A7AE602BF2A7B9033DB9ED3610C6FB85487EAE97AAC5BC7928C1950148"), "big"), + y=int.from_bytes(bytes.fromhex("F5CE40D95B5EB899ABBCCFF5911CB8577939804D6527378B8C108C3D2090FF9BE18E2D33E3021ED2EF32D85822423B6304F726AA854BAE07D0396E9A9ADDC40F"), "big"), cofactor=4, e=0x01, - d=int.from_bytes(hexdec("9E4F5D8C017D8D9F13A5CF3CDF5BFE4DAB402D54198E31EBDE28A0621050439CA6B39E0A515C06B304E2CE43E79E369E91A0CFC2BC2A22B4CA302DBB33EE7550"), "big"), + d=int.from_bytes(bytes.fromhex("9E4F5D8C017D8D9F13A5CF3CDF5BFE4DAB402D54198E31EBDE28A0621050439CA6B39E0A515C06B304E2CE43E79E369E91A0CFC2BC2A22B4CA302DBB33EE7550"), "big"), ), } CURVES["id-GostR3410-2001-CryptoPro-A-ParamSet"] = CURVES["id-tc26-gost-3410-12-256-paramSetB"] diff --git a/pygost/gost34112012.py b/pygost/gost34112012.py index cd992986a85dafeda39424c47dd9111d2e19a06e7c6c290d291c709fa122e873..0f95021730e1c828deb3b242a8ad8981bb85349707b9ffc43e2f79794b97f7c6 100644 --- a/pygost/gost34112012.py +++ b/pygost/gost34112012.py @@ -24,7 +24,6 @@ from struct import pack from struct import unpack from pygost.iface import PEP247 -from pygost.utils import hexdec from pygost.utils import strxor @@ -56,7 +55,7 @@ 116, 210, 230, 244, 180, 192, 209, 102, 175, 194, 57, 75, 99, 182, )) -A = [unpack(">Q", hexdec(s))[0] for s in ( +A = [unpack(">Q", bytes.fromhex(s))[0] for s in ( "8e20faa72ba0b470", "47107ddd9b505a38", "ad08b0e0c3282d1c", "d8045870ef14980e", "6c022c38f90a4c07", "3601161cf205268d", "1b8e0b0e798c13c8", "83478b07b2468764", "a011d380818e8f40", "5086e740ce47c920", "2843fd2067adea10", "14aff010bdd87508", @@ -86,7 +85,7 @@ 6, 14, 22, 30, 38, 46, 54, 62, 7, 15, 23, 31, 39, 47, 55, 63, ) -C = [hexdec("".join(s))[::-1] for s in ( +C = [bytes.fromhex("".join(s))[::-1] for s in ( ( "b1085bda1ecadae9ebcb2f81c0657c1f", "2f6a76432e45d016714eb88d7585c4fc", diff --git a/pygost/gost341194.py b/pygost/gost341194.py index fb54b1791d3e0bdbc90edec2213709dcb7d5a3a3741248e9bed8bc3dce3511d0..465c9cda5abefd2b02d5d4733c4b0288f515048acd86f9cf4e24435dda09c5f1 100644 --- a/pygost/gost341194.py +++ b/pygost/gost341194.py @@ -29,15 +29,13 @@ from pygost.gost28147 import ns2block from pygost.gost28147 import validate_sbox from pygost.iface import PEP247 from pygost.pbkdf2 import pbkdf2 as pbkdf2_base -from pygost.utils import hexdec -from pygost.utils import hexenc from pygost.utils import strxor DEFAULT_SBOX = "id-GostR3411-94-CryptoProParamSet" BLOCKSIZE = 32 C2 = 32 * b"\x00" -C3 = hexdec(b"ff00ffff000000ffff0000ff00ffff0000ff00ff00ff00ffff00ff00ff00ff00") +C3 = bytes.fromhex("ff00ffff000000ffff0000ff00ffff0000ff00ff00ff00ffff00ff00ff00ff00") C4 = 32 * b"\x00" digest_size = 32 @@ -165,7 +163,7 @@ m = self.data for i in range(0, len(m), BLOCKSIZE): part = m[i:i + BLOCKSIZE][::-1] _len += len(part) * 8 - checksum = (checksum + int(hexenc(part), 16)) % (2 ** 256) + checksum = (checksum + int(part.hex(), 16)) % (2 ** 256) if len(part) < BLOCKSIZE: part = b"\x00" * (BLOCKSIZE - len(part)) + part h = _step(h, part, self.sbox) @@ -174,7 +172,7 @@ checksum = hex(checksum)[2:].rstrip("L") if len(checksum) % 2 != 0: checksum = "0" + checksum - checksum = hexdec(checksum) + checksum = bytes.fromhex(checksum) checksum = b"\x00" * (BLOCKSIZE - len(checksum)) + checksum h = _step(h, checksum, self.sbox) return h[::-1] diff --git a/pygost/iface.py b/pygost/iface.py index 86e14e4fe086ea044796a92bba43f74ff79b40d920fac1597748a69ece136b15..cfb3799088085be50cd99950bf24e2a65805f6ab0b1c247987ff664f17a198dc 100644 --- a/pygost/iface.py +++ b/pygost/iface.py @@ -1,8 +1,6 @@ from abc import ABCMeta from abc import abstractmethod -from pygost.utils import hexenc - class PEP247(metaclass=ABCMeta): @property @@ -29,4 +27,4 @@ def hexdigest(self) -> str: """Return the hash value as a string containing hexadecimal digits. """ - return hexenc(self.digest()) + return self.digest().hex() diff --git a/pygost/sespake.py b/pygost/sespake.py index 18543a9254c2015aa15e347dbc4a441d78c4d9feb0ae30269c035ebf7c7ce440..29ca49c2e780e20d41ed9b849baafe351553b7ed7f3cb361e018a941fba91fe6 100644 --- a/pygost/sespake.py +++ b/pygost/sespake.py @@ -26,39 +26,39 @@ from pygost import gost34112012256 from pygost import gost34112012512 from pygost.gost3410 import GOST3410Curve +from pygost.gost3410 import Point from pygost.pbkdf2 import pbkdf2 -from pygost.utils import hexdec Qs = { "id-GostR3410-2001-CryptoPro-A-ParamSet": ( - int.from_bytes(hexdec("a69d51caf1a309fa9e9b66187759b0174c274e080356f23cfcbfe84d396ad7bb"), "big"), - int.from_bytes(hexdec("5d26f29ecc2e9ac0404dcf7986fa55fe94986362170f54b9616426a659786dac"), "big"), + int.from_bytes(bytes.fromhex("a69d51caf1a309fa9e9b66187759b0174c274e080356f23cfcbfe84d396ad7bb"), "big"), + int.from_bytes(bytes.fromhex("5d26f29ecc2e9ac0404dcf7986fa55fe94986362170f54b9616426a659786dac"), "big"), ), "id-GostR3410-2001-CryptoPro-B-ParamSet": ( - int.from_bytes(hexdec("3d715a874a4b17cb3b517893a9794a2b36c89d2ffc693f01ee4cc27e7f49e399"), "big"), - int.from_bytes(hexdec("1c5a641fcf7ce7e87cdf8cea38f3db3096eace2fad158384b53953365f4fe7fe"), "big"), + int.from_bytes(bytes.fromhex("3d715a874a4b17cb3b517893a9794a2b36c89d2ffc693f01ee4cc27e7f49e399"), "big"), + int.from_bytes(bytes.fromhex("1c5a641fcf7ce7e87cdf8cea38f3db3096eace2fad158384b53953365f4fe7fe"), "big"), ), "id-GostR3410-2001-CryptoPro-C-ParamSet": ( - int.from_bytes(hexdec("1e36383e43bb6cfa2917167d71b7b5dd3d6d462b43d7c64282ae67dfbec2559d"), "big"), - int.from_bytes(hexdec("137478a9f721c73932ea06b45cf72e37eb78a63f29a542e563c614650c8b6399"), "big"), + int.from_bytes(bytes.fromhex("1e36383e43bb6cfa2917167d71b7b5dd3d6d462b43d7c64282ae67dfbec2559d"), "big"), + int.from_bytes(bytes.fromhex("137478a9f721c73932ea06b45cf72e37eb78a63f29a542e563c614650c8b6399"), "big"), ), "id-tc26-gost-3410-2012-512-paramSetA": ( - int.from_bytes(hexdec("2a17f8833a32795327478871b5c5e88aefb91126c64b4b8327289bea62559425d18198f133f400874328b220c74497cd240586cb249e158532cb8090776cd61c"), "big"), - int.from_bytes(hexdec("728f0c4a73b48da41ce928358fad26b47a6e094e9362bae82559f83cddc4ec3a4676bd3707edeaf4cd85e99695c64c241edc622be87dc0cf87f51f4367f723c5"), "big"), + int.from_bytes(bytes.fromhex("2a17f8833a32795327478871b5c5e88aefb91126c64b4b8327289bea62559425d18198f133f400874328b220c74497cd240586cb249e158532cb8090776cd61c"), "big"), + int.from_bytes(bytes.fromhex("728f0c4a73b48da41ce928358fad26b47a6e094e9362bae82559f83cddc4ec3a4676bd3707edeaf4cd85e99695c64c241edc622be87dc0cf87f51f4367f723c5"), "big"), ), "id-tc26-gost-3410-2012-512-paramSetB": ( - int.from_bytes(hexdec("7e1fae8285e035bec244bef2d0e5ebf436633cf50e55231dea9c9cf21d4c8c33df85d4305de92971f0a4b4c07e00d87bdbc720eb66e49079285aaf12e0171149"), "big"), - int.from_bytes(hexdec("2cc89998b875d4463805ba0d858a196592db20ab161558ff2f4ef7a85725d20953967ae621afdeae89bb77c83a2528ef6fce02f68bda4679d7f2704947dbc408"), "big"), + int.from_bytes(bytes.fromhex("7e1fae8285e035bec244bef2d0e5ebf436633cf50e55231dea9c9cf21d4c8c33df85d4305de92971f0a4b4c07e00d87bdbc720eb66e49079285aaf12e0171149"), "big"), + int.from_bytes(bytes.fromhex("2cc89998b875d4463805ba0d858a196592db20ab161558ff2f4ef7a85725d20953967ae621afdeae89bb77c83a2528ef6fce02f68bda4679d7f2704947dbc408"), "big"), ), "id-tc26-gost-3410-2012-256-paramSetA": ( - int.from_bytes(hexdec("b51adf93a40ab15792164fad3352f95b66369eb2a4ef5efae32829320363350e"), "big"), - int.from_bytes(hexdec("74a358cc08593612f5955d249c96afb7e8b0bb6d8bd2bbe491046650d822be18"), "big"), + int.from_bytes(bytes.fromhex("b51adf93a40ab15792164fad3352f95b66369eb2a4ef5efae32829320363350e"), "big"), + int.from_bytes(bytes.fromhex("74a358cc08593612f5955d249c96afb7e8b0bb6d8bd2bbe491046650d822be18"), "big"), # U: ebe97afffe0d0f88b8b0114b8de430ac2b34564e4420af24728e7305bc48aeaa # V: 828f2dcf8f06612b4fea4da72ca509c0f76dd37df424ea22bfa6f4f65748c1e4 ), "id-tc26-gost-3410-2012-512-paramSetC": ( - int.from_bytes(hexdec("489c91784e02e98f19a803abca319917f37689e5a18965251ce2ff4e8d8b298f5ba7470f9e0e713487f96f4a8397b3d09a270c9d367eb5e0e6561adeeb51581d"), "big"), - int.from_bytes(hexdec("684ea885aca64eaf1b3fee36c0852a3be3bd8011b0ef18e203ff87028d6eb5db2c144a0dcc71276542bfd72ca2a43fa4f4939da66d9a60793c704a8c94e16f18"), "big"), + int.from_bytes(bytes.fromhex("489c91784e02e98f19a803abca319917f37689e5a18965251ce2ff4e8d8b298f5ba7470f9e0e713487f96f4a8397b3d09a270c9d367eb5e0e6561adeeb51581d"), "big"), + int.from_bytes(bytes.fromhex("684ea885aca64eaf1b3fee36c0852a3be3bd8011b0ef18e203ff87028d6eb5db2c144a0dcc71276542bfd72ca2a43fa4f4939da66d9a60793c704a8c94e16f18"), "big"), # U: 3a3496f97e96b3849a4fa7db60fd93858bde89958e4beebd05a6b3214216b37c9d9a560076e7ea59714828b18fbfef996ffc98bf3dc9f2d3cb0ed36a0d6ace88 # V: 52d884c8bf0ad6c5f7b3973e32a668daa1f1ed092eff138dae6203b2ccdec56147464d35fec4b727b2480eb143074712c76550c7a54ff3ea26f70059480dcb50 ), @@ -69,11 +69,11 @@ class A: def __init__( self, curve: GOST3410Curve, - q: , - pw, - salt, - idA, - idB, + q: Point, + pw: bytes, + salt: bytes, + idA: bytes, + idB: bytes, idAlg=b"", ind=b"\x01", fIters=2000, @@ -97,7 +97,7 @@ alphaP = self.curve.exp(self.alpha) tmp = self.curve.exp(self.curve.q-1, self.qpw[0], self.qpw[1]) self.u1 = self.curve._add(alphaP[0], alphaP[1], tmp[0], tmp[1]) - def ka(self, u2, dataA=b""): + def ka(self, u2: Point, dataA=b""): if not self.curve.contains(u2): raise ValueError("u2 is not on curve") self.u2 = u2 @@ -125,7 +125,7 @@ self.dataA, )), digestmod=gost34112012256).digest() return macA - def kc(self, macB, dataB=b""): + def kc(self, macB: bytes, dataB=b""): u1 = ( self.u1[0].to_bytes(self.curve.point_size, "little") + self.u1[1].to_bytes(self.curve.point_size, "little") @@ -145,11 +145,11 @@ class B: def __init__( self, - curve, - q, - pw, - idA, - idB, + curve: GOST3410Curve, + q: Point, + pw: bytes, + idA: bytes, + idB: bytes, idAlg=b"", ind=b"\x01", salt=None, @@ -172,7 +172,7 @@ self.fpw = fpw self.qpw = self.curve.exp( int.from_bytes(fpw[:self.curve.point_size], "little"), q[0], q[1]) - def ka(self, u1, beta=None): + def ka(self, u1: Point, beta=None): if not self.curve.contains(u1): raise ValueError("u1 is not on curve") self.u1 = u1 @@ -189,7 +189,7 @@ betaP = self.curve.exp(beta) self.u2 = self.curve._add(betaP[0], betaP[1], self.qpw[0], self.qpw[1]) return self.u2 - def kc(self, macA, dataA=b"", dataB=b""): + def kc(self, macA: bytes, dataA=b"", dataB=b""): u1 = ( self.u1[0].to_bytes(self.curve.point_size, "little") + self.u1[1].to_bytes(self.curve.point_size, "little") diff --git a/pygost/test_cms.py b/pygost/test_cms.py index 6d3de7aa8cd1015cad50d8592028c9d5d0044cb609e71e97392be0870a8c4be6..a986e6e5f1a008c02f91f4a52bfd6f6386318b3a8e3bde7331862e8ad5c0977c 100644 --- a/pygost/test_cms.py +++ b/pygost/test_cms.py @@ -36,7 +36,6 @@ from pygost.gost3413 import KEYSIZE from pygost.gost3413 import mac as omac from pygost.kdf import kdf_tree_gostr3411_2012_256 from pygost.kdf import keg -from pygost.utils import hexdec from pygost.wrap import kimp15 from pygost.wrap import unwrap_cryptopro from pygost.wrap import unwrap_gost @@ -107,7 +106,7 @@ MC0yMDEyICgyNTYgYml0KSBleGFtcGxlAgEBMAwGCCqFAwcBAQICBQAwDAYIKoUD BwEBAQEFAARAkptb2ekZbC94FaGDQeP70ExvTkXtOY9zgz3cCco/hxPhXUVo3eCx VNwDQ8enFItJZ8DEX4blZ8QtziNCMl5HbA== """) - prv_key_raw = hexdec("BFCF1D623E5CDD3032A7C6EABB4A923C46E43D640FFEAAF2C3ED39A8FA399924")[::-1] + prv_key_raw = bytes.fromhex("BFCF1D623E5CDD3032A7C6EABB4A923C46E43D640FFEAAF2C3ED39A8FA399924")[::-1] self.process_cms( content_info_raw, prv_key_raw, @@ -125,7 +124,7 @@ KoUDBwEBAQIFAASBgFyVohNhMHUi/+RAF3Gh/cC7why6v+4jPWVlx1TYlXtV8Hje hI2Y+rP52/LO6EUHG/XcwCBbUxmRWsbUSRRBAexmaafkSdvv2FFwC8kHOcti+UPX PS+KRYxT8vhcsBLWWxDkc1McI7aF09hqtED36mQOfACzeJjEoUjALpmJob1V """) - prv_key_raw = hexdec("3FC01CDCD4EC5F972EB482774C41E66DB7F380528DFE9E67992BA05AEE462435757530E641077CE587B976C8EEB48C48FD33FD175F0C7DE6A44E014E6BCB074B")[::-1] + prv_key_raw = bytes.fromhex("3FC01CDCD4EC5F972EB482774C41E66DB7F380528DFE9E67992BA05AEE462435757530E641077CE587B976C8EEB48C48FD33FD175F0C7DE6A44E014E6BCB074B")[::-1] self.process_cms( content_info_raw, prv_key_raw, @@ -299,7 +298,7 @@ 3+ZHSLW3IgOiy+1jvK/20CZxNWc+pey8v4zji1hI17iohsipX/uZKRxhxF6+Xn2R UQp6qoxHAspNXgWQ57xg7C3+gmi4ciVr0fT9pg54ogcowrRH+I6wd0EpeWPbzfnQ pRmMVN+YtRsrEHwH3ToQ/i4vrtgA+eONuKT2uKZFikxA+VNmeeGdhkgqETMihQ== """) - prv_key_our = hexdec("BFCF1D623E5CDD3032A7C6EABB4A923C46E43D640FFEAAF2C3ED39A8FA399924")[::-1] + prv_key_our = bytes.fromhex("BFCF1D623E5CDD3032A7C6EABB4A923C46E43D640FFEAAF2C3ED39A8FA399924")[::-1] def keker(curve, prv, pub, ukm): return kek_34102012256( @@ -330,7 +329,7 @@ M40kOXv8kcDdTzEVKA/ZLxA8xanL+gTD6ZjaPsUu06nsA2MoMBWcHLUzueaP3bGT /yHTV+Za5xdcQehag/lNBgQIvCw4uUl0XC4wOgYJKoZIhvcNAQcBMB8GBiqFAwIC FTAVBAj+1QzaXaN9FwYJKoUDBwECBQEBgAyK54euw0sHhEVEkA0= """) - prv_key_our = hexdec("3FC01CDCD4EC5F972EB482774C41E66DB7F380528DFE9E67992BA05AEE462435757530E641077CE587B976C8EEB48C48FD33FD175F0C7DE6A44E014E6BCB074B")[::-1] + prv_key_our = bytes.fromhex("3FC01CDCD4EC5F972EB482774C41E66DB7F380528DFE9E67992BA05AEE462435757530E641077CE587B976C8EEB48C48FD33FD175F0C7DE6A44E014E6BCB074B")[::-1] def keker(curve, prv, pub, ukm): return kek_34102012256( @@ -431,7 +430,7 @@ AQEEKjAoBCCNhrZOr7x2fsjjQAeDMv/tSoNRQSSQzzxgqdnYxJ3fIAQEgYLqVDA6 BgkqhkiG9w0BBwEwHwYGKoUDAgIVMBUECHVmR/S+hlYiBgkqhQMHAQIFAQGADEI9 UNjyuY+54uVcHw== """) - prv_key_our = hexdec("BFCF1D623E5CDD3032A7C6EABB4A923C46E43D640FFEAAF2C3ED39A8FA399924")[::-1] + prv_key_our = bytes.fromhex("BFCF1D623E5CDD3032A7C6EABB4A923C46E43D640FFEAAF2C3ED39A8FA399924")[::-1] def keker(curve, prv, pub, ukm): return kek_34102012256( @@ -462,7 +461,7 @@ MDEyIDUxMiBiaXRzIGV4Y2hhbmdlAgEBBCowKAQg8C/OcxRR0Uq8nDjHrQlayFb3 WFUZEnEuAKcuG6dTOawEBLhi9hIwOgYJKoZIhvcNAQcBMB8GBiqFAwICFTAVBAiD 1wH+CX6CwgYJKoUDBwECBQEBgAzUvQI4H2zRfgNgdlY= """) - prv_key_our = hexdec("3FC01CDCD4EC5F972EB482774C41E66DB7F380528DFE9E67992BA05AEE462435757530E641077CE587B976C8EEB48C48FD33FD175F0C7DE6A44E014E6BCB074B")[::-1] + prv_key_our = bytes.fromhex("3FC01CDCD4EC5F972EB482774C41E66DB7F380528DFE9E67992BA05AEE462435757530E641077CE587B976C8EEB48C48FD33FD175F0C7DE6A44E014E6BCB074B")[::-1] def keker(curve, prv, pub, ukm): return kek_34102012256( @@ -488,9 +487,9 @@ """ def setUp(self): self.curve256 = CURVES["id-tc26-gost-3410-2012-256-paramSetA"] self.curve512 = CURVES["id-tc26-gost-3410-12-512-paramSetA"] - self.psk = hexdec("8F5EEF8814D228FB2BBC5612323730CFA33DB7263CC2C0A01A6C6953F33D61D5")[::-1] + self.psk = bytes.fromhex("8F5EEF8814D228FB2BBC5612323730CFA33DB7263CC2C0A01A6C6953F33D61D5")[::-1] - self.ca_prv = prv_unmarshal(hexdec("092F8D059E97E22B90B1AE99F0087FC4D26620B91550CBB437C191005A290810")[::-1]) + self.ca_prv = prv_unmarshal(bytes.fromhex("092F8D059E97E22B90B1AE99F0087FC4D26620B91550CBB437C191005A290810")[::-1]) self.ca_pub = public_key(self.curve256, self.ca_prv) self.ca_cert = Certificate().decod(b64decode(""" MIIB8DCCAZ2gAwIBAgIEAYy6gTAKBggqhQMHAQEDAjA4MQ0wCwYDVQQKEwRUSzI2 @@ -506,7 +505,7 @@ AgNBAAgv248F4OeNCkhlzJWec0evHYnMBlSzk1lDm0F875B7CqMrKh2MtJHXenbj Gc2uRn2IwgmSf/LZDrYsKKqZSxk= """)) - self.sender256_prv = prv_unmarshal(hexdec("0B20810E449978C7C3B76C6FF77A16C532421139344A058EF56310B6B6F377E8")[::-1]) + self.sender256_prv = prv_unmarshal(bytes.fromhex("0B20810E449978C7C3B76C6FF77A16C532421139344A058EF56310B6B6F377E8")[::-1]) self.sender256_pub = public_key(self.curve256, self.sender256_prv) self.sender256_cert = Certificate().decod(b64decode(""" MIIB8zCCAaCgAwIBAgIEAYy6gjAKBggqhQMHAQEDAjA4MQ0wCwYDVQQKEwRUSzI2 @@ -522,7 +521,7 @@ AQEDAgNBAB41oijaXSEn58l78y2rhxY35/lKEq4XWZ70FtsNlVxWATyzgO5Wliwn t1O4GoZsxx8r6T/i7VG65UNmQlwdOKQ= """)) - self.recipient256_prv = prv_unmarshal(hexdec("0DC8DC1FF2BC114BABC3F1CA8C51E4F58610427E197B1C2FBDBA4AE58CBFB7CE")[::-1]) + self.recipient256_prv = prv_unmarshal(bytes.fromhex("0DC8DC1FF2BC114BABC3F1CA8C51E4F58610427E197B1C2FBDBA4AE58CBFB7CE")[::-1]) self.recipient256_pub = public_key(self.curve256, self.recipient256_prv) self.recipient256_cert = Certificate().decod(b64decode(""" MIIB8jCCAZ+gAwIBAgIEAYy6gzAKBggqhQMHAQEDAjA4MQ0wCwYDVQQKEwRUSzI2 @@ -538,7 +537,7 @@ AQMCA0EAPP9Oad1/5jwokSjPpccsQ0xCdVYM+mGQ0IbpiZxQj8gnkt8sq4jR6Ya+ I/BDkbZNDNE27TU1p3t5rE9NMEeViA== """)) - self.sender512_prv = prv_unmarshal(hexdec("F95A5D44C5245F63F2E7DF8E782C1924EADCB8D06C52D91023179786154CBDB1561B4DF759D69F67EE1FBD5B68800E134BAA12818DA4F3AC75B0E5E6F9256911")[::-1]) + self.sender512_prv = prv_unmarshal(bytes.fromhex("F95A5D44C5245F63F2E7DF8E782C1924EADCB8D06C52D91023179786154CBDB1561B4DF759D69F67EE1FBD5B68800E134BAA12818DA4F3AC75B0E5E6F9256911")[::-1]) self.sender512_pub = public_key(self.curve512, self.sender512_prv) self.sender512_cert = Certificate().decod(b64decode(""" MIICNjCCAeOgAwIBAgIEAYy6hDAKBggqhQMHAQEDAjA4MQ0wCwYDVQQKEwRUSzI2 @@ -555,7 +554,7 @@ zCcRpxRAmFHvlXowCgYIKoUDBwEBAwIDQQAbjA0Q41/rIKOOvjHKsAsoEJM+WJf6 /PKXg2JaStthmw99bdtwwkU/qDbcje2tF6mt+XWyQBXwvfeES1GFY9fJ """)) - self.recipient512_prv = prv_unmarshal(hexdec("A50315981F0A7C7FC05B4EB9591A62B1F84BD6FD518ACFCEDF0A7C9CF388D1F18757C056ADA5B38CBF24CDDB0F1519EF72DB1712CEF1920952E94AF1F9C575DC")[::-1]) + self.recipient512_prv = prv_unmarshal(bytes.fromhex("A50315981F0A7C7FC05B4EB9591A62B1F84BD6FD518ACFCEDF0A7C9CF388D1F18757C056ADA5B38CBF24CDDB0F1519EF72DB1712CEF1920952E94AF1F9C575DC")[::-1]) self.recipient512_pub = public_key(self.curve512, self.recipient512_prv) self.recipient512_cert = Certificate().decod(b64decode(""" MIICNTCCAeKgAwIBAgIEAYy6hTAKBggqhQMHAQEDAjA4MQ0wCwYDVQQKEwRUSzI2 diff --git a/pygost/test_gost28147.py b/pygost/test_gost28147.py index ba979d5aaaaad4029199d78490b97cc8bcc431b0eea923a28390cef531b6bc0d..bd04dc88c15ebf6bc7134a0dce5564d790bb14a4abb58f6112cb365675cfa47f 100644 --- a/pygost/test_gost28147.py +++ b/pygost/test_gost28147.py @@ -31,7 +31,6 @@ from pygost.gost28147 import encrypt from pygost.gost28147 import KEYSIZE from pygost.gost28147 import MESH_MAX_DATA from pygost.gost28147 import ns2block -from pygost.utils import hexdec from pygost.utils import strxor @@ -40,7 +39,7 @@ def test_gcl(self): """Test vectors from libgcl3 """ sbox = "id-Gost28147-89-TestParamSet" - key = hexdec(b"0475f6e05038fbfad2c7c390edb3ca3d1547124291ae1e8a2f79cd9ed2bcefbd") + key = bytes.fromhex("0475f6e05038fbfad2c7c390edb3ca3d1547124291ae1e8a2f79cd9ed2bcefbd") plaintext = bytes(bytearray(( 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, @@ -119,29 +118,29 @@ """Test vectors from Crypto++ 5.6.2 """ sbox = "AppliedCryptography" data = ( - (b"BE5EC2006CFF9DCF52354959F1FF0CBFE95061B5A648C10387069C25997C0672", b"0DF82802B741A292", b"07F9027DF7F7DF89"), - (b"B385272AC8D72A5A8B344BC80363AC4D09BF58F41F540624CBCB8FDCF55307D7", b"1354EE9C0A11CD4C", b"4FB50536F960A7B1"), - (b"AEE02F609A35660E4097E546FD3026B032CD107C7D459977ADF489BEF2652262", b"6693D492C4B0CC39", b"670034AC0FA811B5"), - (b"320E9D8422165D58911DFC7D8BBB1F81B0ECD924023BF94D9DF7DCF7801240E0", b"99E2D13080928D79", b"8118FF9D3B3CFE7D"), - (b"C9F703BBBFC63691BFA3B7B87EA8FD5E8E8EF384EF733F1A61AEF68C8FFA265F", b"D1E787749C72814C", b"A083826A790D3E0C"), - (b"728FEE32F04B4C654AD7F607D71C660C2C2670D7C999713233149A1C0C17A1F0", b"D4C05323A4F7A7B5", b"4D1F2E6B0D9DE2CE"), - (b"35FC96402209500FCFDEF5352D1ABB038FE33FC0D9D58512E56370B22BAA133B", b"8742D9A05F6A3AF6", b"2F3BB84879D11E52"), - (b"D416F630BE65B7FE150656183370E07018234EE5DA3D89C4CE9152A03E5BFB77", b"F86506DA04E41CB8", b"96F0A5C77A04F5CE"), + ("BE5EC2006CFF9DCF52354959F1FF0CBFE95061B5A648C10387069C25997C0672", "0DF82802B741A292", "07F9027DF7F7DF89"), + ("B385272AC8D72A5A8B344BC80363AC4D09BF58F41F540624CBCB8FDCF55307D7", "1354EE9C0A11CD4C", "4FB50536F960A7B1"), + ("AEE02F609A35660E4097E546FD3026B032CD107C7D459977ADF489BEF2652262", "6693D492C4B0CC39", "670034AC0FA811B5"), + ("320E9D8422165D58911DFC7D8BBB1F81B0ECD924023BF94D9DF7DCF7801240E0", "99E2D13080928D79", "8118FF9D3B3CFE7D"), + ("C9F703BBBFC63691BFA3B7B87EA8FD5E8E8EF384EF733F1A61AEF68C8FFA265F", "D1E787749C72814C", "A083826A790D3E0C"), + ("728FEE32F04B4C654AD7F607D71C660C2C2670D7C999713233149A1C0C17A1F0", "D4C05323A4F7A7B5", "4D1F2E6B0D9DE2CE"), + ("35FC96402209500FCFDEF5352D1ABB038FE33FC0D9D58512E56370B22BAA133B", "8742D9A05F6A3AF6", "2F3BB84879D11E52"), + ("D416F630BE65B7FE150656183370E07018234EE5DA3D89C4CE9152A03E5BFB77", "F86506DA04E41CB8", "96F0A5C77A04F5CE"), ) for key, pt, ct in data: - key = hexdec(key) - pt = hexdec(pt) - ct = hexdec(ct) + key = bytes.fromhex(key) + pt = bytes.fromhex(pt) + ct = bytes.fromhex(ct) self.assertSequenceEqual(ecb_encrypt(key, pt, sbox=sbox), ct) def test_cryptomanager(self): """Test vector from http://cryptomanager.com/tv.html """ sbox = "id-GostR3411-94-TestParamSet" - key = hexdec(b"75713134B60FEC45A607BB83AA3746AF4FF99DA6D1B53B5B1B402A1BAA030D1B") + key = bytes.fromhex("75713134B60FEC45A607BB83AA3746AF4FF99DA6D1B53B5B1B402A1BAA030D1B") self.assertSequenceEqual( - ecb_encrypt(key, hexdec(b"1122334455667788"), sbox=sbox), - hexdec(b"03251E14F9D28ACB"), + ecb_encrypt(key, bytes.fromhex("1122334455667788"), sbox=sbox), + bytes.fromhex("03251E14F9D28ACB"), ) @@ -149,25 +148,25 @@ class CFBTest(TestCase): def test_cryptomanager(self): """Test vector from http://cryptomanager.com/tv.html """ - key = hexdec(b"75713134B60FEC45A607BB83AA3746AF4FF99DA6D1B53B5B1B402A1BAA030D1B") + key = bytes.fromhex("75713134B60FEC45A607BB83AA3746AF4FF99DA6D1B53B5B1B402A1BAA030D1B") sbox = "id-GostR3411-94-TestParamSet" self.assertSequenceEqual( cfb_encrypt( key, - hexdec(b"112233445566778899AABBCCDD800000"), - iv=hexdec(b"0102030405060708"), + bytes.fromhex("112233445566778899AABBCCDD800000"), + iv=bytes.fromhex("0102030405060708"), sbox=sbox, ), - hexdec(b"6EE84586DD2BCA0CAD3616940E164242"), + bytes.fromhex("6EE84586DD2BCA0CAD3616940E164242"), ) self.assertSequenceEqual( cfb_decrypt( key, - hexdec(b"6EE84586DD2BCA0CAD3616940E164242"), - iv=hexdec(b"0102030405060708"), + bytes.fromhex("6EE84586DD2BCA0CAD3616940E164242"), + iv=bytes.fromhex("0102030405060708"), sbox=sbox, ), - hexdec(b"112233445566778899AABBCCDD800000"), + bytes.fromhex("112233445566778899AABBCCDD800000"), ) def test_steps(self): @@ -211,7 +210,7 @@ def test_gcl(self): """Test vectors from libgcl3 """ sbox = "id-Gost28147-89-TestParamSet" - key = hexdec(b"0475f6e05038fbfad2c7c390edb3ca3d1547124291ae1e8a2f79cd9ed2bcefbd") + key = bytes.fromhex("0475f6e05038fbfad2c7c390edb3ca3d1547124291ae1e8a2f79cd9ed2bcefbd") plaintext = bytes(bytearray(( 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, @@ -290,7 +289,7 @@ def test_gcl2(self): """Test vectors 2 from libgcl3 """ sbox = "id-Gost28147-89-TestParamSet" - key = hexdec(b"fc7ad2886f455b50d29008fa622b57d5c65b3c637202025799cadf0768519e8a") + key = bytes.fromhex("fc7ad2886f455b50d29008fa622b57d5c65b3c637202025799cadf0768519e8a") plaintext = bytes(bytearray(( 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, diff --git a/pygost/test_gost3410.py b/pygost/test_gost3410.py index cdb95b37f93ac469bf4787891eebb3596cb17fd2d0cf893beca20f99fc3156ef..af78418c3d510eba4db5271db37c04136f0f0b6075fef43aeec20102e8a68037 100644 --- a/pygost/test_gost3410.py +++ b/pygost/test_gost3410.py @@ -26,8 +26,6 @@ from pygost.gost3410 import sign from pygost.gost3410 import uv2xy from pygost.gost3410 import verify from pygost.gost3410 import xy2uv -from pygost.utils import hexdec -from pygost.utils import hexenc class Test341001(TestCase): @@ -94,13 +92,13 @@ def test_1(self): """Test vector from 34.10-2012 standard itself """ curve = CURVES["id-GostR3410-2001-TestParamSet"] - prv = int.from_bytes(hexdec("7A929ADE789BB9BE10ED359DD39A72C11B60961F49397EEE1D19CE9891EC3B28"), "big") - digest = hexdec("2DFBC1B372D89A1188C09C52E0EEC61FCE52032AB1022E8E67ECE6672B043EE5") - rand = hexdec("77105C9B20BCD3122823C8CF6FCC7B956DE33814E95B7FE64FED924594DCEAB3") + prv = int.from_bytes(bytes.fromhex("7A929ADE789BB9BE10ED359DD39A72C11B60961F49397EEE1D19CE9891EC3B28"), "big") + digest = bytes.fromhex("2DFBC1B372D89A1188C09C52E0EEC61FCE52032AB1022E8E67ECE6672B043EE5") + rand = bytes.fromhex("77105C9B20BCD3122823C8CF6FCC7B956DE33814E95B7FE64FED924594DCEAB3") signature = sign(curve, prv, digest, rand) r = "41aa28d2f1ab148280cd9ed56feda41974053554a42767b83ad043fd39dc0493" s = "01456c64ba4642a1653c235a98a60249bcd6d3f746b631df928014f6c5bf9c40" - self.assertSequenceEqual(hexenc(signature), s + r) + self.assertSequenceEqual(signature.hex(), s + r) def test_2(self): """Test vector from 34.10-2012 standard itself @@ -113,13 +111,13 @@ b=1518655069210828534508950034714043154928747527740206436194018823352809982443793732829756914785974674866041605397883677596626326413990136959047435811826396, x=1928356944067022849399309401243137598997786635459507974357075491307766592685835441065557681003184874819658004903212332884252335830250729527632383493573274, y=2288728693371972859970012155529478416353562327329506180314497425931102860301572814141997072271708807066593850650334152381857347798885864807605098724013854, ) - prv = int.from_bytes(hexdec("0BA6048AADAE241BA40936D47756D7C93091A0E8514669700EE7508E508B102072E8123B2200A0563322DAD2827E2714A2636B7BFD18AADFC62967821FA18DD4"), "big") - digest = hexdec("3754F3CFACC9E0615C4F4A7C4D8DAB531B09B6F9C170C533A71D147035B0C5917184EE536593F4414339976C647C5D5A407ADEDB1D560C4FC6777D2972075B8C") - rand = hexdec("0359E7F4B1410FEACC570456C6801496946312120B39D019D455986E364F365886748ED7A44B3E794434006011842286212273A6D14CF70EA3AF71BB1AE679F1") + prv = int.from_bytes(bytes.fromhex("0BA6048AADAE241BA40936D47756D7C93091A0E8514669700EE7508E508B102072E8123B2200A0563322DAD2827E2714A2636B7BFD18AADFC62967821FA18DD4"), "big") + digest = bytes.fromhex("3754F3CFACC9E0615C4F4A7C4D8DAB531B09B6F9C170C533A71D147035B0C5917184EE536593F4414339976C647C5D5A407ADEDB1D560C4FC6777D2972075B8C") + rand = bytes.fromhex("0359E7F4B1410FEACC570456C6801496946312120B39D019D455986E364F365886748ED7A44B3E794434006011842286212273A6D14CF70EA3AF71BB1AE679F1") signature = sign(curve, prv, digest, rand) r = "2f86fa60a081091a23dd795e1e3c689ee512a3c82ee0dcc2643c78eea8fcacd35492558486b20f1c9ec197c90699850260c93bcbcd9c5c3317e19344e173ae36" s = "1081b394696ffe8e6585e7a9362d26b6325f56778aadbc081c0bfbe933d52ff5823ce288e8c4f362526080df7f70ce406a6eeb1f56919cb92a9853bde73e5b4a" - self.assertSequenceEqual(hexenc(signature), s + r) + self.assertSequenceEqual(signature.hex(), s + r) def test_gcl3(self): """Test vector from libgcl3 @@ -268,13 +266,13 @@ """Twisted Edwards to Weierstrass coordinates conversion and vice versa """ def test_curve1(self): c = CURVES["id-tc26-gost-3410-2012-256-paramSetA"] - u, v = (0x0D, int.from_bytes(hexdec("60CA1E32AA475B348488C38FAB07649CE7EF8DBE87F22E81F92B2592DBA300E7"), "big")) + u, v = (0x0D, int.from_bytes(bytes.fromhex("60CA1E32AA475B348488C38FAB07649CE7EF8DBE87F22E81F92B2592DBA300E7"), "big")) self.assertEqual(uv2xy(c, u, v), (c.x, c.y)) self.assertEqual(xy2uv(c, c.x, c.y), (u, v)) def test_curve2(self): c = CURVES["id-tc26-gost-3410-2012-512-paramSetC"] - u, v = (0x12, int.from_bytes(hexdec("469AF79D1FB1F5E16B99592B77A01E2A0FDFB0D01794368D9A56117F7B38669522DD4B650CF789EEBF068C5D139732F0905622C04B2BAAE7600303EE73001A3D"), "big")) + u, v = (0x12, int.from_bytes(bytes.fromhex("469AF79D1FB1F5E16B99592B77A01E2A0FDFB0D01794368D9A56117F7B38669522DD4B650CF789EEBF068C5D139732F0905622C04B2BAAE7600303EE73001A3D"), "big")) self.assertEqual(uv2xy(c, u, v), (c.x, c.y)) self.assertEqual(xy2uv(c, c.x, c.y), (u, v)) @@ -289,7 +287,7 @@ 0xA69D51CAF1A309FA9E9B66187759B0174C274E080356F23CFCBFE84D396AD7BB, 0x5D26F29ECC2E9AC0404DCF7986FA55FE94986362170F54B9616426A659786DAC, ) self.assertEqual( - c.exp(int.from_bytes(hexdec( + c.exp(int.from_bytes(bytes.fromhex( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F18127067" ), "little"), x=q_ind[0], y=q_ind[1]), ( @@ -319,7 +317,7 @@ 0x3D715A874A4B17CB3B517893A9794A2B36C89D2FFC693F01EE4CC27E7F49E399, 0x1C5A641FCF7CE7E87CDF8CEA38F3DB3096EACE2FAD158384B53953365F4FE7FE, ) self.assertEqual( - c.exp(int.from_bytes(hexdec( + c.exp(int.from_bytes(bytes.fromhex( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F18127067" ), "little"), x=q_ind[0], y=q_ind[1]), ( @@ -349,7 +347,7 @@ 0x1E36383E43BB6CFA2917167D71B7B5DD3D6D462B43D7C64282AE67DFBEC2559D, 0x137478A9F721C73932EA06B45CF72E37EB78A63F29A542E563C614650C8B6399, ) self.assertEqual( - c.exp(int.from_bytes(hexdec( + c.exp(int.from_bytes(bytes.fromhex( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F18127067" ), "little"), x=q_ind[0], y=q_ind[1]), ( @@ -379,7 +377,7 @@ 0x2A17F8833A32795327478871B5C5E88AEFB91126C64B4B8327289BEA62559425D18198F133F400874328B220C74497CD240586CB249E158532CB8090776CD61C, 0x728F0C4A73B48DA41CE928358FAD26B47A6E094E9362BAE82559F83CDDC4EC3A4676BD3707EDEAF4CD85E99695C64C241EDC622BE87DC0CF87F51F4367F723C5, ) self.assertEqual( - c.exp(int.from_bytes(hexdec( + c.exp(int.from_bytes(bytes.fromhex( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F181270671C6213E3930EFDDA26451792C6208122EE60D200520D695DFD9F5F0FD5ABA702" ), "little"), x=q_ind[0], y=q_ind[1]), ( @@ -409,7 +407,7 @@ 0x7E1FAE8285E035BEC244BEF2D0E5EBF436633CF50E55231DEA9C9CF21D4C8C33DF85D4305DE92971F0A4B4C07E00D87BDBC720EB66E49079285AAF12E0171149, 0x2CC89998B875D4463805BA0D858A196592DB20AB161558FF2F4EF7A85725D20953967AE621AFDEAE89BB77C83A2528EF6FCE02F68BDA4679D7F2704947DBC408, ) self.assertEqual( - c.exp(int.from_bytes(hexdec( + c.exp(int.from_bytes(bytes.fromhex( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F181270671C6213E3930EFDDA26451792C6208122EE60D200520D695DFD9F5F0FD5ABA702" ), "little"), x=q_ind[0], y=q_ind[1]), ( @@ -439,7 +437,7 @@ 0xB51ADF93A40AB15792164FAD3352F95B66369EB2A4EF5EFAE32829320363350E, 0x74A358CC08593612F5955D249C96AFB7E8B0BB6D8BD2BBE491046650D822BE18, ) self.assertEqual( - c.exp(int.from_bytes(hexdec( + c.exp(int.from_bytes(bytes.fromhex( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F18127067" ), "little"), x=q_ind[0], y=q_ind[1]), ( @@ -469,7 +467,7 @@ 0x489C91784E02E98F19A803ABCA319917F37689E5A18965251CE2FF4E8D8B298F5BA7470F9E0E713487F96F4A8397B3D09A270C9D367EB5E0E6561ADEEB51581D, 0x684EA885ACA64EAF1B3FEE36C0852A3BE3BD8011B0EF18E203FF87028D6EB5DB2C144A0DCC71276542BFD72CA2A43FA4F4939DA66D9A60793C704A8C94E16F18, ) self.assertEqual( - c.exp(int.from_bytes(hexdec( + c.exp(int.from_bytes(bytes.fromhex( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F181270671C6213E3930EFDDA26451792C6208122EE60D200520D695DFD9F5F0FD5ABA702" ), "little"), x=q_ind[0], y=q_ind[1]), ( diff --git a/pygost/test_gost3410_vko.py b/pygost/test_gost3410_vko.py index 504771beda80c671c14f317f98366820b641604aecd444c317d8290634ca0771..a2ae7ad34b00076b101adc2bd5f47f6925d4a2c5f24eb6d9a1b6e639610f1b14 100644 --- a/pygost/test_gost3410_vko.py +++ b/pygost/test_gost3410_vko.py @@ -25,16 +25,15 @@ from pygost.gost3410_vko import kek_34102001 from pygost.gost3410_vko import kek_34102012256 from pygost.gost3410_vko import kek_34102012512 from pygost.gost3410_vko import ukm_unmarshal -from pygost.utils import hexdec class TestVKO34102001(TestCase): def test_vector(self): curve = CURVES["id-GostR3410-2001-TestParamSet"] - ukm = ukm_unmarshal(hexdec("5172be25f852a233")) - prv1 = prv_unmarshal(hexdec("1df129e43dab345b68f6a852f4162dc69f36b2f84717d08755cc5c44150bf928")) - prv2 = prv_unmarshal(hexdec("5b9356c6474f913f1e83885ea0edd5df1a43fd9d799d219093241157ac9ed473")) - kek = hexdec("ee4618a0dbb10cb31777b4b86a53d9e7ef6cb3e400101410f0c0f2af46c494a6") + ukm = ukm_unmarshal(bytes.fromhex("5172be25f852a233")) + prv1 = prv_unmarshal(bytes.fromhex("1df129e43dab345b68f6a852f4162dc69f36b2f84717d08755cc5c44150bf928")) + prv2 = prv_unmarshal(bytes.fromhex("5b9356c6474f913f1e83885ea0edd5df1a43fd9d799d219093241157ac9ed473")) + kek = bytes.fromhex("ee4618a0dbb10cb31777b4b86a53d9e7ef6cb3e400101410f0c0f2af46c494a6") pub1 = public_key(curve, prv1) pub2 = public_key(curve, prv2) self.assertSequenceEqual(kek_34102001(curve, prv1, pub2, ukm), kek) @@ -61,12 +60,12 @@ """RFC 7836 """ def test_vector(self): curve = CURVES["id-tc26-gost-3410-12-512-paramSetA"] - ukm = ukm_unmarshal(hexdec("1d80603c8544c727")) - prvA = prv_unmarshal(hexdec("c990ecd972fce84ec4db022778f50fcac726f46708384b8d458304962d7147f8c2db41cef22c90b102f2968404f9b9be6d47c79692d81826b32b8daca43cb667")) - pubA = pub_unmarshal(hexdec("aab0eda4abff21208d18799fb9a8556654ba783070eba10cb9abb253ec56dcf5d3ccba6192e464e6e5bcb6dea137792f2431f6c897eb1b3c0cc14327b1adc0a7914613a3074e363aedb204d38d3563971bd8758e878c9db11403721b48002d38461f92472d40ea92f9958c0ffa4c93756401b97f89fdbe0b5e46e4a4631cdb5a")) - prvB = prv_unmarshal(hexdec("48c859f7b6f11585887cc05ec6ef1390cfea739b1a18c0d4662293ef63b79e3b8014070b44918590b4b996acfea4edfbbbcccc8c06edd8bf5bda92a51392d0db")) - pubB = pub_unmarshal(hexdec("192fe183b9713a077253c72c8735de2ea42a3dbc66ea317838b65fa32523cd5efca974eda7c863f4954d1147f1f2b25c395fce1c129175e876d132e94ed5a65104883b414c9b592ec4dc84826f07d0b6d9006dda176ce48c391e3f97d102e03bb598bf132a228a45f7201aba08fc524a2d77e43a362ab022ad4028f75bde3b79")) - vko = hexdec("c9a9a77320e2cc559ed72dce6f47e2192ccea95fa648670582c054c0ef36c221") + ukm = ukm_unmarshal(bytes.fromhex("1d80603c8544c727")) + prvA = prv_unmarshal(bytes.fromhex("c990ecd972fce84ec4db022778f50fcac726f46708384b8d458304962d7147f8c2db41cef22c90b102f2968404f9b9be6d47c79692d81826b32b8daca43cb667")) + pubA = pub_unmarshal(bytes.fromhex("aab0eda4abff21208d18799fb9a8556654ba783070eba10cb9abb253ec56dcf5d3ccba6192e464e6e5bcb6dea137792f2431f6c897eb1b3c0cc14327b1adc0a7914613a3074e363aedb204d38d3563971bd8758e878c9db11403721b48002d38461f92472d40ea92f9958c0ffa4c93756401b97f89fdbe0b5e46e4a4631cdb5a")) + prvB = prv_unmarshal(bytes.fromhex("48c859f7b6f11585887cc05ec6ef1390cfea739b1a18c0d4662293ef63b79e3b8014070b44918590b4b996acfea4edfbbbcccc8c06edd8bf5bda92a51392d0db")) + pubB = pub_unmarshal(bytes.fromhex("192fe183b9713a077253c72c8735de2ea42a3dbc66ea317838b65fa32523cd5efca974eda7c863f4954d1147f1f2b25c395fce1c129175e876d132e94ed5a65104883b414c9b592ec4dc84826f07d0b6d9006dda176ce48c391e3f97d102e03bb598bf132a228a45f7201aba08fc524a2d77e43a362ab022ad4028f75bde3b79")) + vko = bytes.fromhex("c9a9a77320e2cc559ed72dce6f47e2192ccea95fa648670582c054c0ef36c221") self.assertSequenceEqual(kek_34102012256(curve, prvA, pubB, ukm), vko) self.assertSequenceEqual(kek_34102012256(curve, prvB, pubA, ukm), vko) @@ -99,12 +98,12 @@ """RFC 7836 """ def test_vector(self): curve = CURVES["id-tc26-gost-3410-12-512-paramSetA"] - ukm = ukm_unmarshal(hexdec("1d80603c8544c727")) - prvA = prv_unmarshal(hexdec("c990ecd972fce84ec4db022778f50fcac726f46708384b8d458304962d7147f8c2db41cef22c90b102f2968404f9b9be6d47c79692d81826b32b8daca43cb667")) - pubA = pub_unmarshal(hexdec("aab0eda4abff21208d18799fb9a8556654ba783070eba10cb9abb253ec56dcf5d3ccba6192e464e6e5bcb6dea137792f2431f6c897eb1b3c0cc14327b1adc0a7914613a3074e363aedb204d38d3563971bd8758e878c9db11403721b48002d38461f92472d40ea92f9958c0ffa4c93756401b97f89fdbe0b5e46e4a4631cdb5a")) - prvB = prv_unmarshal(hexdec("48c859f7b6f11585887cc05ec6ef1390cfea739b1a18c0d4662293ef63b79e3b8014070b44918590b4b996acfea4edfbbbcccc8c06edd8bf5bda92a51392d0db")) - pubB = pub_unmarshal(hexdec("192fe183b9713a077253c72c8735de2ea42a3dbc66ea317838b65fa32523cd5efca974eda7c863f4954d1147f1f2b25c395fce1c129175e876d132e94ed5a65104883b414c9b592ec4dc84826f07d0b6d9006dda176ce48c391e3f97d102e03bb598bf132a228a45f7201aba08fc524a2d77e43a362ab022ad4028f75bde3b79")) - vko = hexdec("79f002a96940ce7bde3259a52e015297adaad84597a0d205b50e3e1719f97bfa7ee1d2661fa9979a5aa235b558a7e6d9f88f982dd63fc35a8ec0dd5e242d3bdf") + ukm = ukm_unmarshal(bytes.fromhex("1d80603c8544c727")) + prvA = prv_unmarshal(bytes.fromhex("c990ecd972fce84ec4db022778f50fcac726f46708384b8d458304962d7147f8c2db41cef22c90b102f2968404f9b9be6d47c79692d81826b32b8daca43cb667")) + pubA = pub_unmarshal(bytes.fromhex("aab0eda4abff21208d18799fb9a8556654ba783070eba10cb9abb253ec56dcf5d3ccba6192e464e6e5bcb6dea137792f2431f6c897eb1b3c0cc14327b1adc0a7914613a3074e363aedb204d38d3563971bd8758e878c9db11403721b48002d38461f92472d40ea92f9958c0ffa4c93756401b97f89fdbe0b5e46e4a4631cdb5a")) + prvB = prv_unmarshal(bytes.fromhex("48c859f7b6f11585887cc05ec6ef1390cfea739b1a18c0d4662293ef63b79e3b8014070b44918590b4b996acfea4edfbbbcccc8c06edd8bf5bda92a51392d0db")) + pubB = pub_unmarshal(bytes.fromhex("192fe183b9713a077253c72c8735de2ea42a3dbc66ea317838b65fa32523cd5efca974eda7c863f4954d1147f1f2b25c395fce1c129175e876d132e94ed5a65104883b414c9b592ec4dc84826f07d0b6d9006dda176ce48c391e3f97d102e03bb598bf132a228a45f7201aba08fc524a2d77e43a362ab022ad4028f75bde3b79")) + vko = bytes.fromhex("79f002a96940ce7bde3259a52e015297adaad84597a0d205b50e3e1719f97bfa7ee1d2661fa9979a5aa235b558a7e6d9f88f982dd63fc35a8ec0dd5e242d3bdf") self.assertSequenceEqual(kek_34102012512(curve, prvA, pubB, ukm), vko) self.assertSequenceEqual(kek_34102012512(curve, prvB, pubA, ukm), vko) diff --git a/pygost/test_gost34112012.py b/pygost/test_gost34112012.py index f5726550a65114822b54d96ed53ccfcabbff0414d59b9cf8460bba73674ed01b..3c47d3100140cd9bf00d2f6597e73cd6c7a881850b622fc2ffcbb51e21ca255e 100644 --- a/pygost/test_gost34112012.py +++ b/pygost/test_gost34112012.py @@ -25,8 +25,6 @@ from pygost import gost34112012512 from pygost.gost34112012256 import GOST34112012256 from pygost.gost34112012512 import GOST34112012512 from pygost.gost34112012512 import pbkdf2 -from pygost.utils import hexdec -from pygost.utils import hexenc class TestCopy(TestCase): @@ -60,8 +58,8 @@ def test_256(self): for digestmod in (GOST34112012256, gost34112012256): self.assertSequenceEqual( hmac.new( - key=hexdec("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), - msg=hexdec("0126bdb87800af214341456563780100"), + key=bytes.fromhex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), + msg=bytes.fromhex("0126bdb87800af214341456563780100"), digestmod=digestmod, ).hexdigest(), "a1aa5f7de402d7b3d323f2991c8d4534013137010a83754fd0af6d7cd4922ed9", @@ -71,8 +69,8 @@ def test_512(self): for digestmod in (GOST34112012512, gost34112012512): self.assertSequenceEqual( hmac.new( - key=hexdec("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), - msg=hexdec("0126bdb87800af214341456563780100"), + key=bytes.fromhex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), + msg=bytes.fromhex("0126bdb87800af214341456563780100"), digestmod=digestmod, ).hexdigest(), "a59bab22ecae19c65fbde6e5f4e9f5d8549d31f037f9df9b905500e171923a773d5f1530f2ed7e964cb2eedc29e9ad2f3afe93b2814f79f5000ffc0366c251e6", @@ -81,32 +79,32 @@ class TestVectors(TestCase): def test_m1(self): - m = hexdec("323130393837363534333231303938373635343332313039383736353433323130393837363534333231303938373635343332313039383736353433323130")[::-1] + m = bytes.fromhex("323130393837363534333231303938373635343332313039383736353433323130393837363534333231303938373635343332313039383736353433323130")[::-1] self.assertSequenceEqual( GOST34112012512(m).digest(), - hexdec("486f64c1917879417fef082b3381a4e211c324f074654c38823a7b76f830ad00fa1fbae42b1285c0352f227524bc9ab16254288dd6863dccd5b9f54a1ad0541b")[::-1] + bytes.fromhex("486f64c1917879417fef082b3381a4e211c324f074654c38823a7b76f830ad00fa1fbae42b1285c0352f227524bc9ab16254288dd6863dccd5b9f54a1ad0541b")[::-1] ) self.assertSequenceEqual( GOST34112012256(m).digest(), - hexdec("00557be5e584fd52a449b16b0251d05d27f94ab76cbaa6da890b59d8ef1e159d")[::-1] + bytes.fromhex("00557be5e584fd52a449b16b0251d05d27f94ab76cbaa6da890b59d8ef1e159d")[::-1] ) def test_m2(self): m = u"Се ветри, Стрибожи внуци, веютъ с моря стрелами на храбрыя плъкы Игоревы".encode("cp1251") - self.assertSequenceEqual(m, hexdec("fbe2e5f0eee3c820fbeafaebef20fffbf0e1e0f0f520e0ed20e8ece0ebe5f0f2f120fff0eeec20f120faf2fee5e2202ce8f6f3ede220e8e6eee1e8f0f2d1202ce8f0f2e5e220e5d1")[::-1]) + self.assertSequenceEqual(m, bytes.fromhex("fbe2e5f0eee3c820fbeafaebef20fffbf0e1e0f0f520e0ed20e8ece0ebe5f0f2f120fff0eeec20f120faf2fee5e2202ce8f6f3ede220e8e6eee1e8f0f2d1202ce8f0f2e5e220e5d1")[::-1]) self.assertSequenceEqual( GOST34112012512(m).digest(), - hexdec("28fbc9bada033b1460642bdcddb90c3fb3e56c497ccd0f62b8a2ad4935e85f037613966de4ee00531ae60f3b5a47f8dae06915d5f2f194996fcabf2622e6881e")[::-1] + bytes.fromhex("28fbc9bada033b1460642bdcddb90c3fb3e56c497ccd0f62b8a2ad4935e85f037613966de4ee00531ae60f3b5a47f8dae06915d5f2f194996fcabf2622e6881e")[::-1] ) self.assertSequenceEqual( GOST34112012256(m).digest(), - hexdec("508f7e553c06501d749a66fc28c6cac0b005746d97537fa85d9e40904efed29d")[::-1] + bytes.fromhex("508f7e553c06501d749a66fc28c6cac0b005746d97537fa85d9e40904efed29d")[::-1] ) def test_habr144(self): """Test vector from https://habr.com/ru/post/452200/ """ - m = hexdec("d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff0900060000000000000000000000010000000100000000000000001000002400000001000000feffffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff") + m = bytes.fromhex("d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff0900060000000000000000000000010000000100000000000000001000002400000001000000feffffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff") self.assertSequenceEqual( GOST34112012256(m).hexdigest(), "c766085540caaa8953bfcf7a1ba220619cee50d65dc242f82f23ba4b180b18e0", @@ -118,42 +116,42 @@ """http://tc26.ru/.../R_50.1.111-2016.pdf """ def test_1(self): self.assertSequenceEqual( - hexenc(pbkdf2(b"password", b"salt", 1, 64)), + pbkdf2(b"password", b"salt", 1, 64).hex(), "64770af7f748c3b1c9ac831dbcfd85c26111b30a8a657ddc3056b80ca73e040d2854fd36811f6d825cc4ab66ec0a68a490a9e5cf5156b3a2b7eecddbf9a16b47", ) def test_2(self): self.assertSequenceEqual( - hexenc(pbkdf2(b"password", b"salt", 2, 64)), + pbkdf2(b"password", b"salt", 2, 64).hex(), "5a585bafdfbb6e8830d6d68aa3b43ac00d2e4aebce01c9b31c2caed56f0236d4d34b2b8fbd2c4e89d54d46f50e47d45bbac301571743119e8d3c42ba66d348de", ) def test_3(self): self.assertSequenceEqual( - hexenc(pbkdf2(b"password", b"salt", 4096, 64)), + pbkdf2(b"password", b"salt", 4096, 64).hex(), "e52deb9a2d2aaff4e2ac9d47a41f34c20376591c67807f0477e32549dc341bc7867c09841b6d58e29d0347c996301d55df0d34e47cf68f4e3c2cdaf1d9ab86c3", ) @skip("it takes too long") def test_4(self): self.assertSequenceEqual( - hexenc(pbkdf2(b"password", b"salt", 16777216, 64)), + pbkdf2(b"password", b"salt", 16777216, 64).hex(), "49e4843bba76e300afe24c4d23dc7392def12f2c0e244172367cd70a8982ac361adb601c7e2a314e8cb7b1e9df840e36ab5615be5d742b6cf203fb55fdc48071", ) def test_5(self): self.assertSequenceEqual( - hexenc(pbkdf2( + pbkdf2( b"passwordPASSWORDpassword", b"saltSALTsaltSALTsaltSALTsaltSALTsalt", 4096, 100, - )), + ).hex(), "b2d8f1245fc4d29274802057e4b54e0a0753aa22fc53760b301cf008679e58fe4bee9addcae99ba2b0b20f431a9c5e50f395c89387d0945aedeca6eb4015dfc2bd2421ee9bb71183ba882ceebfef259f33f9e27dc6178cb89dc37428cf9cc52a2baa2d3a", ) def test_6(self): self.assertSequenceEqual( - hexenc(pbkdf2(b"pass\x00word", b"sa\x00lt", 4096, 64)), + pbkdf2(b"pass\x00word", b"sa\x00lt", 4096, 64).hex(), "50df062885b69801a3c10248eb0a27ab6e522ffeb20c991c660f001475d73a4e167f782c18e97e92976d9c1d970831ea78ccb879f67068cdac1910740844e830", ) diff --git a/pygost/test_gost341194.py b/pygost/test_gost341194.py index 7530ccaf8fb0d642fff51124b8aace5d9c7f1c05916571f1e32b35314ee4f4e2..64a0ab259494f3a2402a79d841c03614f45a2c2ec95afc84c073f2b043388960 100644 --- a/pygost/test_gost341194.py +++ b/pygost/test_gost341194.py @@ -21,7 +21,6 @@ from pygost import gost341194 from pygost.gost341194 import GOST341194 from pygost.gost341194 import pbkdf2 -from pygost.utils import hexenc class TestCopy(TestCase): @@ -154,47 +153,47 @@ """http://tc26.ru/methods/containers_v1/Addition_to_PKCS5_v1_0.pdf test vectors """ def test_1(self): self.assertSequenceEqual( - hexenc(pbkdf2(b"password", b"salt", 1, 32)), + pbkdf2(b"password", b"salt", 1, 32).hex(), "7314e7c04fb2e662c543674253f68bd0b73445d07f241bed872882da21662d58", ) def test_2(self): self.assertSequenceEqual( - hexenc(pbkdf2(b"password", b"salt", 2, 32)), + pbkdf2(b"password", b"salt", 2, 32).hex(), "990dfa2bd965639ba48b07b792775df79f2db34fef25f274378872fed7ed1bb3", ) def test_3(self): self.assertSequenceEqual( - hexenc(pbkdf2(b"password", b"salt", 4096, 32)), + pbkdf2(b"password", b"salt", 4096, 32).hex(), "1f1829a94bdff5be10d0aeb36af498e7a97467f3b31116a5a7c1afff9deadafe", ) @skip("it takes too long") def test_4(self): self.assertSequenceEqual( - hexenc(pbkdf2(b"password", b"salt", 16777216, 32)), + pbkdf2(b"password", b"salt", 16777216, 32).hex(), "a57ae5a6088396d120850c5c09de0a525100938a59b1b5c3f7810910d05fcd97", ) def test_5(self): self.assertSequenceEqual( - hexenc(pbkdf2( + pbkdf2( b"passwordPASSWORDpassword", b"saltSALTsaltSALTsaltSALTsaltSALTsalt", 4096, 40, - )), + ).hex(), "788358c69cb2dbe251a7bb17d5f4241f265a792a35becde8d56f326b49c85047b7638acb4764b1fd", ) def test_6(self): self.assertSequenceEqual( - hexenc(pbkdf2( + pbkdf2( b"pass\x00word", b"sa\x00lt", 4096, 20, - )), + ).hex(), "43e06c5590b08c0225242373127edf9c8e9c3291", ) diff --git a/pygost/test_gost3412.py b/pygost/test_gost3412.py index ae497b62f630dcbbe4cc70b86a6fa06baaa6e8b034a453760441fb1560125007..46c91934339d494410a81bc731444564be08926875be7492df600fcc324dfed0 100644 --- a/pygost/test_gost3412.py +++ b/pygost/test_gost3412.py @@ -21,7 +21,6 @@ from pygost.gost3412 import GOST3412Kuznechik from pygost.gost3412 import GOST3412Magma from pygost.gost3412 import L from pygost.gost3412 import PI -from pygost.utils import hexdec def S(blk): @@ -34,85 +33,85 @@ class STest(TestCase): def test_vec1(self): - blk = bytearray(hexdec("ffeeddccbbaa99881122334455667700")) - self.assertSequenceEqual(S(blk), hexdec("b66cd8887d38e8d77765aeea0c9a7efc")) + blk = bytearray(bytes.fromhex("ffeeddccbbaa99881122334455667700")) + self.assertSequenceEqual(S(blk), bytes.fromhex("b66cd8887d38e8d77765aeea0c9a7efc")) def test_vec2(self): - blk = bytearray(hexdec("b66cd8887d38e8d77765aeea0c9a7efc")) - self.assertSequenceEqual(S(blk), hexdec("559d8dd7bd06cbfe7e7b262523280d39")) + blk = bytearray(bytes.fromhex("b66cd8887d38e8d77765aeea0c9a7efc")) + self.assertSequenceEqual(S(blk), bytes.fromhex("559d8dd7bd06cbfe7e7b262523280d39")) def test_vec3(self): - blk = bytearray(hexdec("559d8dd7bd06cbfe7e7b262523280d39")) - self.assertSequenceEqual(S(blk), hexdec("0c3322fed531e4630d80ef5c5a81c50b")) + blk = bytearray(bytes.fromhex("559d8dd7bd06cbfe7e7b262523280d39")) + self.assertSequenceEqual(S(blk), bytes.fromhex("0c3322fed531e4630d80ef5c5a81c50b")) def test_vec4(self): - blk = bytearray(hexdec("0c3322fed531e4630d80ef5c5a81c50b")) - self.assertSequenceEqual(S(blk), hexdec("23ae65633f842d29c5df529c13f5acda")) + blk = bytearray(bytes.fromhex("0c3322fed531e4630d80ef5c5a81c50b")) + self.assertSequenceEqual(S(blk), bytes.fromhex("23ae65633f842d29c5df529c13f5acda")) class RTest(TestCase): def test_vec1(self): - blk = bytearray(hexdec("00000000000000000000000000000100")) - self.assertSequenceEqual(R(blk), hexdec("94000000000000000000000000000001")) + blk = bytearray(bytes.fromhex("00000000000000000000000000000100")) + self.assertSequenceEqual(R(blk), bytes.fromhex("94000000000000000000000000000001")) def test_vec2(self): - blk = bytearray(hexdec("94000000000000000000000000000001")) - self.assertSequenceEqual(R(blk), hexdec("a5940000000000000000000000000000")) + blk = bytearray(bytes.fromhex("94000000000000000000000000000001")) + self.assertSequenceEqual(R(blk), bytes.fromhex("a5940000000000000000000000000000")) def test_vec3(self): - blk = bytearray(hexdec("a5940000000000000000000000000000")) - self.assertSequenceEqual(R(blk), hexdec("64a59400000000000000000000000000")) + blk = bytearray(bytes.fromhex("a5940000000000000000000000000000")) + self.assertSequenceEqual(R(blk), bytes.fromhex("64a59400000000000000000000000000")) def test_vec4(self): - blk = bytearray(hexdec("64a59400000000000000000000000000")) - self.assertSequenceEqual(R(blk), hexdec("0d64a594000000000000000000000000")) + blk = bytearray(bytes.fromhex("64a59400000000000000000000000000")) + self.assertSequenceEqual(R(blk), bytes.fromhex("0d64a594000000000000000000000000")) class LTest(TestCase): def test_vec1(self): - blk = bytearray(hexdec("64a59400000000000000000000000000")) - self.assertSequenceEqual(L(blk), hexdec("d456584dd0e3e84cc3166e4b7fa2890d")) + blk = bytearray(bytes.fromhex("64a59400000000000000000000000000")) + self.assertSequenceEqual(L(blk), bytes.fromhex("d456584dd0e3e84cc3166e4b7fa2890d")) def test_vec2(self): - blk = bytearray(hexdec("d456584dd0e3e84cc3166e4b7fa2890d")) - self.assertSequenceEqual(L(blk), hexdec("79d26221b87b584cd42fbc4ffea5de9a")) + blk = bytearray(bytes.fromhex("d456584dd0e3e84cc3166e4b7fa2890d")) + self.assertSequenceEqual(L(blk), bytes.fromhex("79d26221b87b584cd42fbc4ffea5de9a")) def test_vec3(self): - blk = bytearray(hexdec("79d26221b87b584cd42fbc4ffea5de9a")) - self.assertSequenceEqual(L(blk), hexdec("0e93691a0cfc60408b7b68f66b513c13")) + blk = bytearray(bytes.fromhex("79d26221b87b584cd42fbc4ffea5de9a")) + self.assertSequenceEqual(L(blk), bytes.fromhex("0e93691a0cfc60408b7b68f66b513c13")) def test_vec4(self): - blk = bytearray(hexdec("0e93691a0cfc60408b7b68f66b513c13")) - self.assertSequenceEqual(L(blk), hexdec("e6a8094fee0aa204fd97bcb0b44b8580")) + blk = bytearray(bytes.fromhex("0e93691a0cfc60408b7b68f66b513c13")) + self.assertSequenceEqual(L(blk), bytes.fromhex("e6a8094fee0aa204fd97bcb0b44b8580")) class KuznechikTest(TestCase): - key = hexdec("8899aabbccddeeff0011223344556677fedcba98765432100123456789abcdef") - plaintext = hexdec("1122334455667700ffeeddccbbaa9988") - ciphertext = hexdec("7f679d90bebc24305a468d42b9d4edcd") + key = bytes.fromhex("8899aabbccddeeff0011223344556677fedcba98765432100123456789abcdef") + plaintext = bytes.fromhex("1122334455667700ffeeddccbbaa9988") + ciphertext = bytes.fromhex("7f679d90bebc24305a468d42b9d4edcd") def test_c(self): - 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")) + self.assertSequenceEqual(C[0], bytes.fromhex("6ea276726c487ab85d27bd10dd849401")) + self.assertSequenceEqual(C[1], bytes.fromhex("dc87ece4d890f4b3ba4eb92079cbeb02")) + self.assertSequenceEqual(C[2], bytes.fromhex("b2259a96b4d88e0be7690430a44f7f03")) + self.assertSequenceEqual(C[3], bytes.fromhex("7bcd1b0b73e32ba5b79cb140f2551504")) + self.assertSequenceEqual(C[4], bytes.fromhex("156f6d791fab511deabb0c502fd18105")) + self.assertSequenceEqual(C[5], bytes.fromhex("a74af7efab73df160dd208608b9efe06")) + self.assertSequenceEqual(C[6], bytes.fromhex("c9e8819dc73ba5ae50f5b570561a6a07")) + self.assertSequenceEqual(C[7], bytes.fromhex("f6593616e6055689adfba18027aa2a08")) def test_roundkeys(self): ciph = GOST3412Kuznechik(self.key) - 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")) + self.assertSequenceEqual(ciph.ks[0], bytes.fromhex("8899aabbccddeeff0011223344556677")) + self.assertSequenceEqual(ciph.ks[1], bytes.fromhex("fedcba98765432100123456789abcdef")) + self.assertSequenceEqual(ciph.ks[2], bytes.fromhex("db31485315694343228d6aef8cc78c44")) + self.assertSequenceEqual(ciph.ks[3], bytes.fromhex("3d4553d8e9cfec6815ebadc40a9ffd04")) + self.assertSequenceEqual(ciph.ks[4], bytes.fromhex("57646468c44a5e28d3e59246f429f1ac")) + self.assertSequenceEqual(ciph.ks[5], bytes.fromhex("bd079435165c6432b532e82834da581b")) + self.assertSequenceEqual(ciph.ks[6], bytes.fromhex("51e640757e8745de705727265a0098b1")) + self.assertSequenceEqual(ciph.ks[7], bytes.fromhex("5a7925017b9fdd3ed72a91a22286f984")) + self.assertSequenceEqual(ciph.ks[8], bytes.fromhex("bb44e25378c73123a5f32f73cdb6e517")) + self.assertSequenceEqual(ciph.ks[9], bytes.fromhex("72e9dd7416bcf45b755dbaa88e4a4043")) def test_encrypt(self): ciph = GOST3412Kuznechik(self.key) @@ -124,9 +123,9 @@ self.assertSequenceEqual(ciph.decrypt(self.ciphertext), self.plaintext) class MagmaTest(TestCase): - key = hexdec("ffeeddccbbaa99887766554433221100f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff") - plaintext = hexdec("fedcba9876543210") - ciphertext = hexdec("4ee901e5c2d8ca3d") + key = bytes.fromhex("ffeeddccbbaa99887766554433221100f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff") + plaintext = bytes.fromhex("fedcba9876543210") + ciphertext = bytes.fromhex("4ee901e5c2d8ca3d") def test_encrypt(self): ciph = GOST3412Magma(self.key) diff --git a/pygost/test_gost3413.py b/pygost/test_gost3413.py index 2abcd564980684b6f47f65905b27ca65a020750c63c5a8595f0807f465f26187..850035f716f829af84f2ed4d566d003877ae7eb6b4d80d513b44a8d5ba4545b6 100644 --- a/pygost/test_gost3413.py +++ b/pygost/test_gost3413.py @@ -39,8 +39,6 @@ from pygost.gost3413 import pad2 from pygost.gost3413 import pad_iso10126 from pygost.gost3413 import unpad2 from pygost.gost3413 import unpad_iso10126 -from pygost.utils import hexdec -from pygost.utils import hexenc from pygost.utils import strxor @@ -56,14 +54,14 @@ ) class GOST3412KuznechikModesTest(TestCase): - key = hexdec("8899aabbccddeeff0011223344556677fedcba98765432100123456789abcdef") + key = bytes.fromhex("8899aabbccddeeff0011223344556677fedcba98765432100123456789abcdef") ciph = GOST3412Kuznechik(key) plaintext = "" plaintext += "1122334455667700ffeeddccbbaa9988" plaintext += "00112233445566778899aabbcceeff0a" plaintext += "112233445566778899aabbcceeff0a00" plaintext += "2233445566778899aabbcceeff0a0011" - iv = hexdec("1234567890abcef0a1b2c3d4e5f0011223344556677889901213141516171819") + iv = bytes.fromhex("1234567890abcef0a1b2c3d4e5f0011223344556677889901213141516171819") def test_ecb_vectors(self): ciphtext = "" @@ -72,19 +70,19 @@ ciphtext += "b429912c6e0032f9285452d76718d08b" ciphtext += "f0ca33549d247ceef3f5a5313bd4b157" ciphtext += "d0b09ccde830b9eb3a02c4c5aa8ada98" self.assertSequenceEqual( - hexenc(ecb_encrypt( + ecb_encrypt( self.ciph.encrypt, GOST3412Kuznechik.blocksize, - hexdec(self.plaintext), - )), + bytes.fromhex(self.plaintext), + ).hex(), ciphtext, ) self.assertSequenceEqual( - hexenc(ecb_decrypt( + ecb_decrypt( self.ciph.decrypt, GOST3412Kuznechik.blocksize, - hexdec(ciphtext), - )), + bytes.fromhex(ciphtext), + ).hex(), self.plaintext, ) @@ -107,21 +105,21 @@ ciphtext += "a5eae88be6356ed3d5e877f13564a3a5" ciphtext += "cb91fab1f20cbab6d1c6d15820bdba73" iv = self.iv[:GOST3412Kuznechik.blocksize // 2] self.assertSequenceEqual( - hexenc(ctr( + ctr( self.ciph.encrypt, GOST3412Kuznechik.blocksize, - hexdec(self.plaintext), + bytes.fromhex(self.plaintext), iv, - )), + ).hex(), ciphtext, ) self.assertSequenceEqual( - hexenc(ctr( + ctr( self.ciph.encrypt, GOST3412Kuznechik.blocksize, - hexdec(ciphtext), + bytes.fromhex(ciphtext), iv, - )), + ).hex(), self.plaintext, ) @@ -145,21 +143,21 @@ ciphtext += "ed5b47a7048cfab48fb521369d9326bf" ciphtext += "66a257ac3ca0b8b1c80fe7fc10288a13" ciphtext += "203ebbc066138660a0292243f6903150" self.assertSequenceEqual( - hexenc(ofb( + ofb( self.ciph.encrypt, GOST3412Kuznechik.blocksize, - hexdec(self.plaintext), + bytes.fromhex(self.plaintext), self.iv, - )), + ).hex(), ciphtext, ) self.assertSequenceEqual( - hexenc(ofb( + ofb( self.ciph.encrypt, GOST3412Kuznechik.blocksize, - hexdec(ciphtext), + bytes.fromhex(ciphtext), self.iv, - )), + ).hex(), self.plaintext, ) @@ -199,21 +197,21 @@ ciphtext += "2826e661b478eca6af1e8e448d5ea5ac" ciphtext += "fe7babf1e91999e85640e8b0f49d90d0" ciphtext += "167688065a895c631a2d9a1560b63970" self.assertSequenceEqual( - hexenc(cbc_encrypt( + cbc_encrypt( self.ciph.encrypt, GOST3412Kuznechik.blocksize, - hexdec(self.plaintext), + bytes.fromhex(self.plaintext), self.iv, - )), + ).hex(), ciphtext, ) self.assertSequenceEqual( - hexenc(cbc_decrypt( + cbc_decrypt( self.ciph.decrypt, GOST3412Kuznechik.blocksize, - hexdec(ciphtext), + bytes.fromhex(ciphtext), self.iv, - )), + ).hex(), self.plaintext, ) @@ -237,21 +235,21 @@ ciphtext += "ed5b47a7048cfab48fb521369d9326bf" ciphtext += "79f2a8eb5cc68d38842d264e97a238b5" ciphtext += "4ffebecd4e922de6c75bd9dd44fbf4d1" self.assertSequenceEqual( - hexenc(cfb_encrypt( + cfb_encrypt( self.ciph.encrypt, GOST3412Kuznechik.blocksize, - hexdec(self.plaintext), + bytes.fromhex(self.plaintext), self.iv, - )), + ).hex(), ciphtext, ) self.assertSequenceEqual( - hexenc(cfb_decrypt( + cfb_decrypt( self.ciph.encrypt, GOST3412Kuznechik.blocksize, - hexdec(ciphtext), + bytes.fromhex(ciphtext), self.iv, - )), + ).hex(), self.plaintext, ) @@ -270,14 +268,14 @@ ), pt) def test_mac_vectors(self): k1, k2 = _mac_ks(self.ciph.encrypt, GOST3412Kuznechik.blocksize) - self.assertSequenceEqual(hexenc(k1), "297d82bc4d39e3ca0de0573298151dc7") - self.assertSequenceEqual(hexenc(k2), "52fb05789a73c7941bc0ae65302a3b8e") + self.assertSequenceEqual(k1.hex(), "297d82bc4d39e3ca0de0573298151dc7") + self.assertSequenceEqual(k2.hex(), "52fb05789a73c7941bc0ae65302a3b8e") self.assertSequenceEqual( - hexenc(mac( + mac( self.ciph.encrypt, GOST3412Kuznechik.blocksize, - hexdec(self.plaintext), - )[:8]), + bytes.fromhex(self.plaintext), + )[:8].hex(), "336f4d296059fbe3", ) @@ -289,14 +287,14 @@ mac(ciph.encrypt, GOST3412Kuznechik.blocksize, data) class GOST3412MagmaModesTest(TestCase): - key = hexdec("ffeeddccbbaa99887766554433221100f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff") + key = bytes.fromhex("ffeeddccbbaa99887766554433221100f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff") ciph = GOST3412Magma(key) plaintext = "" plaintext += "92def06b3c130a59" plaintext += "db54c704f8189d20" plaintext += "4a98fb2e67a8024c" plaintext += "8912409b17b57e41" - iv = hexdec("1234567890abcdef234567890abcdef134567890abcdef12") + iv = bytes.fromhex("1234567890abcdef234567890abcdef134567890abcdef12") def test_ecb_vectors(self): ciphtext = "" @@ -305,19 +303,19 @@ ciphtext += "de70e715d3556e48" ciphtext += "11d8d9e9eacfbc1e" ciphtext += "7c68260996c67efb" self.assertSequenceEqual( - hexenc(ecb_encrypt( + ecb_encrypt( self.ciph.encrypt, GOST3412Magma.blocksize, - hexdec(self.plaintext), - )), + bytes.fromhex(self.plaintext), + ).hex(), ciphtext, ) self.assertSequenceEqual( - hexenc(ecb_decrypt( + ecb_decrypt( self.ciph.decrypt, GOST3412Magma.blocksize, - hexdec(ciphtext), - )), + bytes.fromhex(ciphtext), + ).hex(), self.plaintext, ) @@ -340,21 +338,21 @@ ciphtext += "136d868807b2dbef" ciphtext += "568eb680ab52a12d" iv = self.iv[:4] self.assertSequenceEqual( - hexenc(ctr( + ctr( self.ciph.encrypt, GOST3412Magma.blocksize, - hexdec(self.plaintext), + bytes.fromhex(self.plaintext), iv, - )), + ).hex(), ciphtext, ) self.assertSequenceEqual( - hexenc(ctr( + ctr( self.ciph.encrypt, GOST3412Magma.blocksize, - hexdec(ciphtext), + bytes.fromhex(ciphtext), iv, - )), + ).hex(), self.plaintext, ) @@ -379,21 +377,21 @@ ciphtext += "0d46644c1f9a089c" ciphtext += "a0f83062430e327e" ciphtext += "c824efb8bd4fdb05" self.assertSequenceEqual( - hexenc(ofb( + ofb( self.ciph.encrypt, GOST3412Magma.blocksize, - hexdec(self.plaintext), + bytes.fromhex(self.plaintext), iv, - )), + ).hex(), ciphtext, ) self.assertSequenceEqual( - hexenc(ofb( + ofb( self.ciph.encrypt, GOST3412Magma.blocksize, - hexdec(ciphtext), + bytes.fromhex(ciphtext), iv, - )), + ).hex(), self.plaintext, ) @@ -417,21 +415,21 @@ ciphtext += "aff76129abb937b9" ciphtext += "5058b4a1c4bc0019" ciphtext += "20b78b1a7cd7e667" self.assertSequenceEqual( - hexenc(cbc_encrypt( + cbc_encrypt( self.ciph.encrypt, GOST3412Magma.blocksize, - hexdec(self.plaintext), + bytes.fromhex(self.plaintext), self.iv, - )), + ).hex(), ciphtext, ) self.assertSequenceEqual( - hexenc(cbc_decrypt( + cbc_decrypt( self.ciph.decrypt, GOST3412Magma.blocksize, - hexdec(ciphtext), + bytes.fromhex(ciphtext), self.iv, - )), + ).hex(), self.plaintext, ) @@ -456,21 +454,21 @@ ciphtext += "0d46644c1f9a089c" ciphtext += "24bdd2035315d38b" ciphtext += "bcc0321421075505" self.assertSequenceEqual( - hexenc(cfb_encrypt( + cfb_encrypt( self.ciph.encrypt, GOST3412Magma.blocksize, - hexdec(self.plaintext), + bytes.fromhex(self.plaintext), iv, - )), + ).hex(), ciphtext, ) self.assertSequenceEqual( - hexenc(cfb_decrypt( + cfb_decrypt( self.ciph.encrypt, GOST3412Magma.blocksize, - hexdec(ciphtext), + bytes.fromhex(ciphtext), iv, - )), + ).hex(), self.plaintext, ) @@ -489,14 +487,14 @@ ), pt) def test_mac_vectors(self): k1, k2 = _mac_ks(self.ciph.encrypt, GOST3412Magma.blocksize) - self.assertSequenceEqual(hexenc(k1), "5f459b3342521424") - self.assertSequenceEqual(hexenc(k2), "be8b366684a42848") + self.assertSequenceEqual(k1.hex(), "5f459b3342521424") + self.assertSequenceEqual(k2.hex(), "be8b366684a42848") self.assertSequenceEqual( - hexenc(mac( + mac( self.ciph.encrypt, GOST3412Magma.blocksize, - hexdec(self.plaintext), - )[:4]), + bytes.fromhex(self.plaintext), + )[:4].hex(), "154e7210", ) @@ -510,26 +508,26 @@ class TestVectorACPKM(TestCase): """Test vectors from ТК26 Р 1323565.1.017-2018 """ - key = hexdec("8899AABBCCDDEEFF0011223344556677FEDCBA98765432100123456789ABCDEF") + key = bytes.fromhex("8899AABBCCDDEEFF0011223344556677FEDCBA98765432100123456789ABCDEF") def test_magma_ctr_acpkm(self): key = acpkm(GOST3412Magma(self.key).encrypt, GOST3412Magma.blocksize) - self.assertSequenceEqual(key, hexdec("863EA017842C3D372B18A85A28E2317D74BEFC107720DE0C9E8AB974ABD00CA0")) + self.assertSequenceEqual(key, bytes.fromhex("863EA017842C3D372B18A85A28E2317D74BEFC107720DE0C9E8AB974ABD00CA0")) key = acpkm(GOST3412Magma(key).encrypt, GOST3412Magma.blocksize) - self.assertSequenceEqual(key, hexdec("49A5E2677DE555982B8AD5E826652D17EEC847BF5B3997A81CF7FE7F1187BD27")) + self.assertSequenceEqual(key, bytes.fromhex("49A5E2677DE555982B8AD5E826652D17EEC847BF5B3997A81CF7FE7F1187BD27")) key = acpkm(GOST3412Magma(key).encrypt, GOST3412Magma.blocksize) - self.assertSequenceEqual(key, hexdec("3256BF3F97B5667426A9FB1C5EAABE41893CCDD5A868F9B63B0AA90720FA43C4")) + self.assertSequenceEqual(key, bytes.fromhex("3256BF3F97B5667426A9FB1C5EAABE41893CCDD5A868F9B63B0AA90720FA43C4")) def test_magma_ctr(self): encrypter = GOST3412Magma(self.key).encrypt - plaintext = hexdec(""" + plaintext = bytes.fromhex(""" 11 22 33 44 55 66 77 00 FF EE DD CC BB AA 99 88 00 11 22 33 44 55 66 77 88 99 AA BB CC EE FF 0A 11 22 33 44 55 66 77 88 99 AA BB CC EE FF 0A 00 22 33 44 55 66 77 88 99 """.replace("\n", "").replace(" ", "")) - iv = hexdec("12345678") - ciphertext = hexdec(""" + iv = bytes.fromhex("12345678") + ciphertext = bytes.fromhex(""" 2A B8 1D EE EB 1E 4C AB 68 E1 04 C4 BD 6B 94 EA C7 2C 67 AF 6C 2E 5B 6B 0E AF B6 17 70 F1 B3 2E A1 AE 71 14 9E ED 13 82 AB D4 67 18 06 72 EC 6F @@ -560,16 +558,16 @@ ) def test_kuznechik_ctr_acpkm(self): key = acpkm(GOST3412Kuznechik(self.key).encrypt, GOST3412Kuznechik.blocksize) - self.assertSequenceEqual(key, hexdec("2666ED40AE687811745CA0B448F57A7B390ADB5780307E8E9659AC403AE60C60")) + self.assertSequenceEqual(key, bytes.fromhex("2666ED40AE687811745CA0B448F57A7B390ADB5780307E8E9659AC403AE60C60")) key = acpkm(GOST3412Kuznechik(key).encrypt, GOST3412Kuznechik.blocksize) - self.assertSequenceEqual(key, hexdec("BB3DD5402E999B7A3DEBB0DB45448EC530F07365DFEE3ABA8415F77AC8F34CE8")) + self.assertSequenceEqual(key, bytes.fromhex("BB3DD5402E999B7A3DEBB0DB45448EC530F07365DFEE3ABA8415F77AC8F34CE8")) key = acpkm(GOST3412Kuznechik(key).encrypt, GOST3412Kuznechik.blocksize) - self.assertSequenceEqual(key, hexdec("23362FD553CAD2178299A5B5A2D4722E3BB83C730A8BF57CE2DD004017F8C565")) + self.assertSequenceEqual(key, bytes.fromhex("23362FD553CAD2178299A5B5A2D4722E3BB83C730A8BF57CE2DD004017F8C565")) def test_kuznechik_ctr(self): encrypter = GOST3412Kuznechik(self.key).encrypt - iv = hexdec("1234567890ABCEF0") - plaintext = hexdec(""" + iv = bytes.fromhex("1234567890ABCEF0") + plaintext = bytes.fromhex(""" 11 22 33 44 55 66 77 00 FF EE DD CC BB AA 99 88 00 11 22 33 44 55 66 77 88 99 AA BB CC EE FF 0A 11 22 33 44 55 66 77 88 99 AA BB CC EE FF 0A 00 @@ -578,7 +576,7 @@ 33 44 55 66 77 88 99 AA BB CC EE FF 0A 00 11 22 44 55 66 77 88 99 AA BB CC EE FF 0A 00 11 22 33 55 66 77 88 99 AA BB CC EE FF 0A 00 11 22 33 44 """.replace("\n", "").replace(" ", "")) - ciphertext = hexdec(""" + ciphertext = bytes.fromhex(""" F1 95 D8 BE C1 0E D1 DB D5 7B 5F A2 40 BD A1 B8 85 EE E7 33 F6 A1 3E 5D F3 3C E4 B3 3C 45 DE E4 4B CE EB 8F 64 6F 4C 55 00 17 06 27 5E 85 E8 00 @@ -621,9 +619,9 @@ key_section_size=key_section_size, bs=GOST3412Magma.blocksize, keymat_len=KEYSIZE + GOST3412Magma.blocksize, ), - hexdec("0DF2F5273DA328932AC49D81D36B2558A50DBF9BBCAC74A614B2CCB2F1CBCD8A70638E3DE8B3571E"), + bytes.fromhex("0DF2F5273DA328932AC49D81D36B2558A50DBF9BBCAC74A614B2CCB2F1CBCD8A70638E3DE8B3571E"), ) - text = hexdec("1122334455667700FFEEDDCC") + text = bytes.fromhex("1122334455667700FFEEDDCC") self.assertSequenceEqual( mac_acpkm_master( GOST3412Magma, @@ -633,7 +631,7 @@ section_size=GOST3412Magma.blocksize * 2, bs=GOST3412Magma.blocksize, data=text, ), - hexdec("A0540E3730ACBCF3"), + bytes.fromhex("A0540E3730ACBCF3"), ) def test_magma_omac_5_blocks(self): @@ -647,7 +645,7 @@ key_section_size=key_section_size, bs=GOST3412Magma.blocksize, keymat_len=3 * (KEYSIZE + GOST3412Magma.blocksize), ), - hexdec(""" + bytes.fromhex(""" 0D F2 F5 27 3D A3 28 93 2A C4 9D 81 D3 6B 25 58 A5 0D BF 9B BC AC 74 A6 14 B2 CC B2 F1 CB CD 8A 70 63 8E 3D E8 B3 57 1E 8D 38 26 D5 5E 63 A1 67 @@ -658,7 +656,7 @@ 6E F1 71 0F 92 4A E0 31 30 52 CB 5F CA 0B 79 1E 1B AB E8 57 6D 0F E3 A8 """.replace("\n", "").replace(" ", "")), ) - text = hexdec(""" + text = bytes.fromhex(""" 11 22 33 44 55 66 77 00 FF EE DD CC BB AA 99 88 00 11 22 33 44 55 66 77 88 99 AA BB CC EE FF 0A 11 22 33 44 55 66 77 88 @@ -672,7 +670,7 @@ section_size=GOST3412Magma.blocksize * 2, bs=GOST3412Magma.blocksize, data=text, ), - hexdec("34008DAD5496BB8E"), + bytes.fromhex("34008DAD5496BB8E"), ) def test_kuznechik_omac_1_5_blocks(self): @@ -686,13 +684,13 @@ key_section_size=key_section_size, bs=GOST3412Kuznechik.blocksize, keymat_len=KEYSIZE + GOST3412Kuznechik.blocksize, ), - hexdec(""" + bytes.fromhex(""" 0C AB F1 F2 EF BC 4A C1 60 48 DF 1A 24 C6 05 B2 C0 D1 67 3D 75 86 A8 EC 0D D4 2C 45 A4 F9 5B AE 0F 2E 26 17 E4 71 48 68 0F C3 E6 17 8D F2 C1 37 """.replace("\n", "").replace(" ", "")) ) - text = hexdec(""" + text = bytes.fromhex(""" 11 22 33 44 55 66 77 00 FF EE DD CC BB AA 99 88 00 11 22 33 44 55 66 77 """.replace("\n", "").replace(" ", "")) @@ -705,7 +703,7 @@ section_size=GOST3412Kuznechik.blocksize * 2, bs=GOST3412Kuznechik.blocksize, data=text, ), - hexdec("B5367F47B62B995EEB2A648C5843145E"), + bytes.fromhex("B5367F47B62B995EEB2A648C5843145E"), ) def test_kuznechik_omac_5_blocks(self): @@ -719,7 +717,7 @@ key_section_size=key_section_size, bs=GOST3412Kuznechik.blocksize, keymat_len=3 * (KEYSIZE + GOST3412Kuznechik.blocksize), ), - hexdec(""" + bytes.fromhex(""" 0C AB F1 F2 EF BC 4A C1 60 48 DF 1A 24 C6 05 B2 C0 D1 67 3D 75 86 A8 EC 0D D4 2C 45 A4 F9 5B AE 0F 2E 26 17 E4 71 48 68 0F C3 E6 17 8D F2 C1 37 @@ -731,7 +729,7 @@ A8 1C 79 A0 4F 29 66 0E A3 FD A8 74 C6 30 79 9E 14 2C 57 79 14 FE A9 0D 3B C2 50 2E 83 36 85 D9 """.replace("\n", "").replace(" ", "")), ) - text = hexdec(""" + text = bytes.fromhex(""" 11 22 33 44 55 66 77 00 FF EE DD CC BB AA 99 88 00 11 22 33 44 55 66 77 88 99 AA BB CC EE FF 0A 11 22 33 44 55 66 77 88 99 AA BB CC EE FF 0A 00 @@ -747,7 +745,7 @@ section_size=GOST3412Kuznechik.blocksize * 2, bs=GOST3412Kuznechik.blocksize, data=text, ), - hexdec("FBB8DCEE45BEA67C35F58C5700898E5D"), + bytes.fromhex("FBB8DCEE45BEA67C35F58C5700898E5D"), ) diff --git a/pygost/test_kdf.py b/pygost/test_kdf.py index cf491d8fd6a31e4c60cbd46ca699aa3bb4dd5d128256d56319da7209262d6e8a..9032fd568cf8d772c4a3a9b77eee58aee163b5ed2d2615e474d0986d16c9254b 100644 --- a/pygost/test_kdf.py +++ b/pygost/test_kdf.py @@ -18,18 +18,17 @@ from unittest import TestCase from pygost.kdf import kdf_gostr3411_2012_256 from pygost.kdf import kdf_tree_gostr3411_2012_256 -from pygost.utils import hexdec class TestKDFGOSTR34112012256(TestCase): def runTest(self): self.assertEqual( kdf_gostr3411_2012_256( - hexdec("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), - hexdec("26bdb878"), - hexdec("af21434145656378"), + bytes.fromhex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), + bytes.fromhex("26bdb878"), + bytes.fromhex("af21434145656378"), ), - hexdec("a1aa5f7de402d7b3d323f2991c8d4534013137010a83754fd0af6d7cd4922ed9"), + bytes.fromhex("a1aa5f7de402d7b3d323f2991c8d4534013137010a83754fd0af6d7cd4922ed9"), ) @@ -37,22 +36,22 @@ class TestKDFTREEGOSTR34112012256(TestCase): def runTest(self): self.assertSequenceEqual( kdf_tree_gostr3411_2012_256( - hexdec("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), - hexdec("26bdb878"), - hexdec("af21434145656378"), + bytes.fromhex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), + bytes.fromhex("26bdb878"), + bytes.fromhex("af21434145656378"), 1, ), - (hexdec("a1aa5f7de402d7b3d323f2991c8d4534013137010a83754fd0af6d7cd4922ed9"),), + (bytes.fromhex("a1aa5f7de402d7b3d323f2991c8d4534013137010a83754fd0af6d7cd4922ed9"),), ) self.assertSequenceEqual( kdf_tree_gostr3411_2012_256( - hexdec("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), - hexdec("26bdb878"), - hexdec("af21434145656378"), + bytes.fromhex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), + bytes.fromhex("26bdb878"), + bytes.fromhex("af21434145656378"), 2, ), ( - hexdec("22b6837845c6bef65ea71672b265831086d3c76aebe6dae91cad51d83f79d16b"), - hexdec("074c9330599d7f8d712fca54392f4ddde93751206b3584c8f43f9e6dc51531f9"), + bytes.fromhex("22b6837845c6bef65ea71672b265831086d3c76aebe6dae91cad51d83f79d16b"), + bytes.fromhex("074c9330599d7f8d712fca54392f4ddde93751206b3584c8f43f9e6dc51531f9"), ), ) diff --git a/pygost/test_mgm.py b/pygost/test_mgm.py index 45c344332961ea5ec7d46ecc0dfbca6d66308a42d6f5cf50802b90f4006bfca4..e346efe02112eb847acbb7db6b370cf01f530134d0df7d8d295f54775897e5d0 100644 --- a/pygost/test_mgm.py +++ b/pygost/test_mgm.py @@ -23,18 +23,17 @@ from pygost.gost3412 import GOST3412Magma from pygost.gost3412 import KEYSIZE from pygost.mgm import MGM from pygost.mgm import nonce_prepare -from pygost.utils import hexdec class TestVector(TestCase): def runTest(self): - key = hexdec("8899AABBCCDDEEFF0011223344556677FEDCBA98765432100123456789ABCDEF") - ad = hexdec("0202020202020202010101010101010104040404040404040303030303030303EA0505050505050505") - plaintext = hexdec("1122334455667700FFEEDDCCBBAA998800112233445566778899AABBCCEEFF0A112233445566778899AABBCCEEFF0A002233445566778899AABBCCEEFF0A0011AABBCC") + key = bytes.fromhex("8899AABBCCDDEEFF0011223344556677FEDCBA98765432100123456789ABCDEF") + ad = bytes.fromhex("0202020202020202010101010101010104040404040404040303030303030303EA0505050505050505") + plaintext = bytes.fromhex("1122334455667700FFEEDDCCBBAA998800112233445566778899AABBCCEEFF0A112233445566778899AABBCCEEFF0A002233445566778899AABBCCEEFF0A0011AABBCC") mgm = MGM(GOST3412Kuznechik(key).encrypt, GOST3412Kuznechik.blocksize) ciphertext = mgm.seal(plaintext[:16], plaintext, ad) - self.assertSequenceEqual(ciphertext[:len(plaintext)], hexdec("A9757B8147956E9055B8A33DE89F42FC8075D2212BF9FD5BD3F7069AADC16B39497AB15915A6BA85936B5D0EA9F6851CC60C14D4D3F883D0AB94420695C76DEB2C7552")) - self.assertSequenceEqual(ciphertext[len(plaintext):], hexdec("CF5D656F40C34F5C46E8BB0E29FCDB4C")) + self.assertSequenceEqual(ciphertext[:len(plaintext)], bytes.fromhex("A9757B8147956E9055B8A33DE89F42FC8075D2212BF9FD5BD3F7069AADC16B39497AB15915A6BA85936B5D0EA9F6851CC60C14D4D3F883D0AB94420695C76DEB2C7552")) + self.assertSequenceEqual(ciphertext[len(plaintext):], bytes.fromhex("CF5D656F40C34F5C46E8BB0E29FCDB4C")) self.assertSequenceEqual(mgm.open(plaintext[:16], ciphertext, ad), plaintext) diff --git a/pygost/test_pfx.py b/pygost/test_pfx.py index 52a881870a7d9731c3c1084f0ad8cf1fa823042d266ff131562f2ca807a531f6..c9dd4aac923258aed8dc7d5a71935b6df7b96dbd3dd756f82b9930b0fb2ecd59 100644 --- a/pygost/test_pfx.py +++ b/pygost/test_pfx.py @@ -31,7 +31,6 @@ from pygost.gost3413 import ctr_acpkm from pygost.gost3413 import mac as omac from pygost.kdf import kdf_tree_gostr3411_2012_256 from pygost.kdf import keg -from pygost.utils import hexdec from pygost.wrap import kimp15 @@ -136,7 +135,7 @@ salt=bytes(pbkdf2_params["salt"]["specified"]), iterations=int(pbkdf2_params["iterationCount"]), dklen=32, ) - # key = hexdec("309dd0354c5603739403f2335e9e2055138f8b5c98b63009de0635eea1fd7ba8") + # key = bytes.fromhex("309dd0354c5603739403f2335e9e2055138f8b5c98b63009de0635eea1fd7ba8") self.assertSequenceEqual( cfb_decrypt( key, @@ -179,7 +178,7 @@ salt=bytes(pbkdf2_params["salt"]["specified"]), iterations=int(pbkdf2_params["iterationCount"]), dklen=32, ) - # key = hexdec("0e93d71339e7f53b79a0bc41f9109dd4fb60b30ae10736c1bb77b84c07681cfc") + # key = bytes.fromhex("0e93d71339e7f53b79a0bc41f9109dd4fb60b30ae10736c1bb77b84c07681cfc") self.assertSequenceEqual( cfb_decrypt( key, @@ -201,7 +200,7 @@ salt=bytes(mac_data["macSalt"]), iterations=int(mac_data["iterations"]), dklen=96, )[-32:] - # mac_key = hexdec("cadbfbf3bceaa9b79f651508fac5abbeb4a13d0bd0e1876bd3c3efb2112128a5") + # mac_key = bytes.fromhex("cadbfbf3bceaa9b79f651508fac5abbeb4a13d0bd0e1876bd3c3efb2112128a5") self.assertSequenceEqual( hmac_new( key=mac_key, @@ -216,7 +215,7 @@ @skipIf(not pyderasn_exists, "PyDERASN dependency is required") class TestPFX2020(TestCase): """PFX test vectors from newer PKCS#12 update """ - ca_prv_raw = hexdec("092F8D059E97E22B90B1AE99F0087FC4D26620B91550CBB437C191005A290810") + ca_prv_raw = bytes.fromhex("092F8D059E97E22B90B1AE99F0087FC4D26620B91550CBB437C191005A290810") ca_curve = gost3410.CURVES["id-tc26-gost-3410-12-256-paramSetA"] ca_cert = Certificate().decod(b64decode(b""" MIIB+TCCAaagAwIBAgIEAYy6gTAKBggqhQMHAQEDAjA4MQ0wCwYDVQQKEwRUSzI2MS @@ -317,7 +316,7 @@ salt=bytes(pbkdf2_params["salt"]["specified"]), iterations=int(pbkdf2_params["iterationCount"]), dklen=32, ) - # key = hexdec("4b7ae649ca31dd5fe3243a91a5188c03f1d7049bec8e0d241c0e1e8c39ea4c1f") + # key = bytes.fromhex("4b7ae649ca31dd5fe3243a91a5188c03f1d7049bec8e0d241c0e1e8c39ea4c1f") key_enc, key_mac = kdf_tree_gostr3411_2012_256( key, b"kdf tree", ukm[GOST3412Kuznechik.blocksize // 2:], 2, ) @@ -347,7 +346,7 @@ salt=bytes(mac_data["macSalt"]), iterations=int(mac_data["iterations"]), dklen=96, )[-32:] - # mac_key = hexdec("a81d1bc91a4a5cf1fd7320f92dda7e5b285816c3b20826a382d7ed0cbf3a9bf4") + # mac_key = bytes.fromhex("a81d1bc91a4a5cf1fd7320f92dda7e5b285816c3b20826a382d7ed0cbf3a9bf4") self.assertSequenceEqual( hmac_new( key=mac_key, @@ -416,7 +415,7 @@ salt=bytes(pbkdf2_params["salt"]["specified"]), iterations=int(pbkdf2_params["iterationCount"]), dklen=32, ) - # key = hexdec("d066a96fb326ba896a2352d3f40240a4ded6e7e7bd5b4db6b5241d631c8c381c") + # key = bytes.fromhex("d066a96fb326ba896a2352d3f40240a4ded6e7e7bd5b4db6b5241d631c8c381c") key_enc, key_mac = kdf_tree_gostr3411_2012_256( key, b"kdf tree", ukm[GOST3412Magma.blocksize // 2:], 2, ) @@ -462,7 +461,7 @@ salt=bytes(pbkdf2_params["salt"]["specified"]), iterations=int(pbkdf2_params["iterationCount"]), dklen=32, ) - # key = hexdec("f840d001fd11441e0fb7ccf48f471915e5bf35275309dbe7ade9da4fe460ba7e") + # key = bytes.fromhex("f840d001fd11441e0fb7ccf48f471915e5bf35275309dbe7ade9da4fe460ba7e") ciphertext = bytes(shrouded_key_bag["encryptedData"]) plaintext = ctr_acpkm( GOST3412Magma, @@ -481,7 +480,7 @@ salt=bytes(mac_data["macSalt"]), iterations=int(mac_data["iterations"]), dklen=96, )[-32:] - # mac_key = hexdec("084f81782af1534ffd67e3c579c14cb45d7a6f659f46fdbb51a552e874e66fb2") + # mac_key = bytes.fromhex("084f81782af1534ffd67e3c579c14cb45d7a6f659f46fdbb51a552e874e66fb2") self.assertSequenceEqual( hmac_new( key=mac_key, @@ -493,7 +492,7 @@ ) def test_dh(self): curve = gost3410.CURVES["id-tc26-gost-3410-12-256-paramSetA"] - # sender_prv_raw = hexdec("0B20810E449978C7C3B76C6FF77A16C532421139344A058EF56310B6B6F377E8") + # sender_prv_raw = bytes.fromhex("0B20810E449978C7C3B76C6FF77A16C532421139344A058EF56310B6B6F377E8") sender_cert = Certificate().decod(b64decode(""" MIIB6zCCAZigAwIBAgIEAYy6gjAKBggqhQMHAQEDAjA4MQ0wCwYDVQQKEwRUSzI2 MScwJQYDVQQDEx5DQSBUSzI2OiBHT1NUIDM0LjEwLTEyIDI1Ni1iaXQwHhcNMDEw @@ -507,7 +506,7 @@ gTAdBgNVHQ4EFgQUPx5RgcjkifhlJm4/jQdkbm30rVQwCgYIKoUDBwEBAwIDQQA6 8x7Vk6PvP/8xOGHhf8PuqaXAYskSyJPuBu+3Bo/PEj10devwc1J9uYWIDCGdKKPy bSlnQHqUPBBPM30YX1YN """)) - recipient_prv_raw = hexdec("0DC8DC1FF2BC114BABC3F1CA8C51E4F58610427E197B1C2FBDBA4AE58CBFB7CE")[::-1] + recipient_prv_raw = bytes.fromhex("0DC8DC1FF2BC114BABC3F1CA8C51E4F58610427E197B1C2FBDBA4AE58CBFB7CE")[::-1] recipient_prv = gost3410.prv_unmarshal(recipient_prv_raw) recipient_cert = Certificate().decod(b64decode(""" MIIB6jCCAZegAwIBAgIEAYy6gzAKBggqhQMHAQEDAjA4MQ0wCwYDVQQKEwRUSzI2 diff --git a/pygost/test_sespake.py b/pygost/test_sespake.py index 1e18aae3824799c3e20aea4d1f874a1e8ec3c0fd1adbbeda42595cf4b9887e27..3d4af2ab860715f4a86d44fa07feb6b1d1b1846d47870d1f10d1ba1bdaf81d71 100644 --- a/pygost/test_sespake.py +++ b/pygost/test_sespake.py @@ -24,8 +24,6 @@ from pygost import gost34112012512 from pygost import sespake from pygost.gost3410 import CURVES from pygost.pbkdf2 import pbkdf2 -from pygost.utils import hexdec -from pygost.utils import hexenc class TestQs(TestCase): @@ -292,8 +290,8 @@ self._test(CURVES[curveName], sespake.Qs[curveName]) class TestExamples(TestCase): - fpw = hexdec("bd04673f7149b18e98155bd1e2724e71d0099aa25174f792d3326c6f181270671c6213e3930efdda26451792c6208122ee60d200520d695dfd9f5f0fd5aba702") - salt = hexdec("2923be84e16cd6ae529049f1f1bbe9eb") + fpw = bytes.fromhex("bd04673f7149b18e98155bd1e2724e71d0099aa25174f792d3326c6f181270671c6213e3930efdda26451792c6208122ee60d200520d695dfd9f5f0fd5aba702") + salt = bytes.fromhex("2923be84e16cd6ae529049f1f1bbe9eb") idA = 4 * b"\x00" idB = 4 * b"\x00" @@ -319,34 +317,34 @@ ): curve = CURVES[curveName] q = sespake.Qs[curveName] qpw = curve.exp(int.from_bytes(self.fpw[:curve.point_size], "little"), q[0], q[1]) - self.assertSequenceEqual(hexenc(qpw[0].to_bytes(curve.point_size, "big")), qpwExpected[0]) - self.assertSequenceEqual(hexenc(qpw[1].to_bytes(curve.point_size, "big")), qpwExpected[1]) + self.assertSequenceEqual(qpw[0].to_bytes(curve.point_size, "big").hex(), qpwExpected[0]) + self.assertSequenceEqual(qpw[1].to_bytes(curve.point_size, "big").hex(), qpwExpected[1]) alphaP = curve.exp(alpha) - self.assertSequenceEqual(hexenc(alphaP[0].to_bytes(curve.point_size, "big")), alphaPExpected[0]) - self.assertSequenceEqual(hexenc(alphaP[1].to_bytes(curve.point_size, "big")), alphaPExpected[1]) + self.assertSequenceEqual(alphaP[0].to_bytes(curve.point_size, "big").hex(), alphaPExpected[0]) + self.assertSequenceEqual(alphaP[1].to_bytes(curve.point_size, "big").hex(), alphaPExpected[1]) tmp = curve.exp(curve.q-1, qpw[0], qpw[1]) u1 = curve._add(alphaP[0], alphaP[1], tmp[0], tmp[1]) - self.assertSequenceEqual(hexenc(u1[0].to_bytes(curve.point_size, "big")), u1Expected[0]) - self.assertSequenceEqual(hexenc(u1[1].to_bytes(curve.point_size, "big")), u1Expected[1]) + self.assertSequenceEqual(u1[0].to_bytes(curve.point_size, "big").hex(), u1Expected[0]) + self.assertSequenceEqual(u1[1].to_bytes(curve.point_size, "big").hex(), u1Expected[1]) self.assertTrue(curve.contains(u1)) qB = curve._add(u1[0], u1[1], qpw[0], qpw[1]) self.assertEqual(qB, alphaP) tmp = curve.exp((curve.cofactor * beta) % curve.q, qB[0], qB[1]) - self.assertSequenceEqual(hexenc(tmp[0].to_bytes(curve.point_size, "little")), kBSrcExpected[0]) - self.assertSequenceEqual(hexenc(tmp[1].to_bytes(curve.point_size, "little")), kBSrcExpected[1]) + self.assertSequenceEqual(tmp[0].to_bytes(curve.point_size, "little").hex(), kBSrcExpected[0]) + self.assertSequenceEqual(tmp[1].to_bytes(curve.point_size, "little").hex(), kBSrcExpected[1]) kB = gost34112012256.new( tmp[0].to_bytes(curve.point_size, "little") + tmp[1].to_bytes(curve.point_size, "little") ).digest() - self.assertSequenceEqual(hexenc(kB), kBExpected) + self.assertSequenceEqual(kB.hex(), kBExpected) betaP = curve.exp(beta) - self.assertSequenceEqual(hexenc(betaP[0].to_bytes(curve.point_size, "big")), betaPExpected[0]) - self.assertSequenceEqual(hexenc(betaP[1].to_bytes(curve.point_size, "big")), betaPExpected[1]) + self.assertSequenceEqual(betaP[0].to_bytes(curve.point_size, "big").hex(), betaPExpected[0]) + self.assertSequenceEqual(betaP[1].to_bytes(curve.point_size, "big").hex(), betaPExpected[1]) u2 = curve._add(betaP[0], betaP[1], qpw[0], qpw[1]) - self.assertSequenceEqual(hexenc(u2[0].to_bytes(curve.point_size, "big")), u2Expected[0]) - self.assertSequenceEqual(hexenc(u2[1].to_bytes(curve.point_size, "big")), u2Expected[1]) + self.assertSequenceEqual(u2[0].to_bytes(curve.point_size, "big").hex(), u2Expected[0]) + self.assertSequenceEqual(u2[1].to_bytes(curve.point_size, "big").hex(), u2Expected[1]) self.assertTrue(curve.contains(u2)) tmp = curve.exp(curve.q-1, qpw[0], qpw[1]) @@ -369,7 +367,7 @@ u2[1].to_bytes(curve.point_size, "little"), )), digestmod=gost34112012256, ).digest() - self.assertSequenceEqual(hexenc(macA), macAExpected) + self.assertSequenceEqual(macA.hex(), macAExpected) macB = hmac.new( key=kB, @@ -382,7 +380,7 @@ u2[1].to_bytes(curve.point_size, "little"), )), digestmod=gost34112012256, ).digest() - self.assertSequenceEqual(hexenc(macB), macBExpected) + self.assertSequenceEqual(macB.hex(), macBExpected) self._test_lib( curveName, alpha, @@ -417,8 +415,8 @@ self.idB, fpw=self.fpw, alpha=alpha, ) - self.assertSequenceEqual(hexenc(a.u1[0].to_bytes(curve.point_size, "big")), u1Expected[0]) - self.assertSequenceEqual(hexenc(a.u1[1].to_bytes(curve.point_size, "big")), u1Expected[1]) + self.assertSequenceEqual(a.u1[0].to_bytes(curve.point_size, "big").hex(), u1Expected[0]) + self.assertSequenceEqual(a.u1[1].to_bytes(curve.point_size, "big").hex(), u1Expected[1]) b = sespake.B( curve, q, @@ -429,15 +427,15 @@ salt=self.salt, fpw=self.fpw, ) u2 = b.ka(a.u1, beta=beta) - self.assertSequenceEqual(hexenc(u2[0].to_bytes(curve.point_size, "big")), u2Expected[0]) - self.assertSequenceEqual(hexenc(u2[1].to_bytes(curve.point_size, "big")), u2Expected[1]) + self.assertSequenceEqual(u2[0].to_bytes(curve.point_size, "big").hex(), u2Expected[0]) + self.assertSequenceEqual(u2[1].to_bytes(curve.point_size, "big").hex(), u2Expected[1]) macA = a.ka(u2) - self.assertSequenceEqual(hexenc(macA), macAExpected) + self.assertSequenceEqual(macA.hex(), macAExpected) macB = b.kc(macA) - self.assertSequenceEqual(hexenc(macB), macBExpected) + self.assertSequenceEqual(macB.hex(), macBExpected) a.kc(macB) self.assertEqual(a.k, b.k) - self.assertSequenceEqual(hexenc(a.k), kExpected) + self.assertSequenceEqual(a.k.hex(), kExpected) def test_256B(self): self._test( diff --git a/pygost/test_wrap.py b/pygost/test_wrap.py index c9a53827afba395daaa16b4d71f1cac6607304ccc7ebaeaf9628137e5ebc7ffe..2769dcef035a0f72e74bbd89bf41793eae1f38faf784f950b9050da96b97de1c 100644 --- a/pygost/test_wrap.py +++ b/pygost/test_wrap.py @@ -20,7 +20,6 @@ from pygost.gost28147 import DEFAULT_SBOX from pygost.gost3412 import GOST3412Kuznechik from pygost.gost3412 import GOST3412Magma -from pygost.utils import hexdec from pygost.wrap import kexp15 from pygost.wrap import kimp15 from pygost.wrap import unwrap_cryptopro @@ -62,12 +61,12 @@ class TestVectorKExp15(TestCase): """Test vectors from ТК26 Р 1323565.1.017-2018 """ - key = hexdec("8899AABBCCDDEEFF0011223344556677FEDCBA98765432100123456789ABCDEF") - key_enc = hexdec("202122232425262728292A2B2C2D2E2F38393A3B3C3D3E3F3031323334353637") - key_mac = hexdec("08090A0B0C0D0E0F0001020304050607101112131415161718191A1B1C1D1E1F") + key = bytes.fromhex("8899AABBCCDDEEFF0011223344556677FEDCBA98765432100123456789ABCDEF") + key_enc = bytes.fromhex("202122232425262728292A2B2C2D2E2F38393A3B3C3D3E3F3031323334353637") + key_mac = bytes.fromhex("08090A0B0C0D0E0F0001020304050607101112131415161718191A1B1C1D1E1F") def test_magma(self): - iv = hexdec("67BED654") + iv = bytes.fromhex("67BED654") kexp = kexp15( GOST3412Magma(self.key_enc).encrypt, GOST3412Magma(self.key_mac).encrypt, @@ -75,7 +74,7 @@ GOST3412Magma.blocksize, self.key, iv, ) - self.assertSequenceEqual(kexp, hexdec(""" + self.assertSequenceEqual(kexp, bytes.fromhex(""" CF D5 A1 2D 5B 81 B6 E1 E9 9C 91 6D 07 90 0C 6A C1 27 03 FB 3A BD ED 55 56 7B F3 74 2C 89 9C 75 5D AF E7 B4 2E 3A 8B D9 @@ -89,7 +88,7 @@ iv, ), self.key) def test_kuznechik(self): - iv = hexdec("0909472DD9F26BE8") + iv = bytes.fromhex("0909472DD9F26BE8") kexp = kexp15( GOST3412Kuznechik(self.key_enc).encrypt, GOST3412Kuznechik(self.key_mac).encrypt, @@ -97,7 +96,7 @@ GOST3412Kuznechik.blocksize, self.key, iv, ) - self.assertSequenceEqual(kexp, hexdec(""" + self.assertSequenceEqual(kexp, bytes.fromhex(""" E3 61 84 E8 4E 8D 73 6F F3 6C C2 E5 AE 06 5D C6 56 B2 3C 20 F5 49 B0 2F DF F8 8E 1F 3F 30 D8 C2 9A 53 F3 CA 55 4D BA D8 0D E1 52 B9 A4 62 5B 32 diff --git a/pygost/test_x509.py b/pygost/test_x509.py index 1ecfcd641abb2b7e582fd6dc0a833fa38dea7802acb724707380e2511c02e31e..86a291bee2ea028e3b3c7565c259917fb177016633ae32844cc341bec340ad41 100644 --- a/pygost/test_x509.py +++ b/pygost/test_x509.py @@ -26,7 +26,6 @@ from pygost.gost3410 import public_key from pygost.gost3410 import verify from pygost.gost34112012256 import GOST34112012256 from pygost.gost34112012512 import GOST34112012512 -from pygost.utils import hexdec try: @@ -140,7 +139,7 @@ YW1wbGUuY29tMSkwJwYDVQQDEyBHb3N0UjM0MTAtMjAxMiAoMjU2IGJpdCkgZXhh bXBsZYIBATAKBggqhQMHAQEDAgNBAF5bm4BbARR6hJLEoWJkOsYV3Hd7kXQQjz3C dqQfmHrz6TI6Xojdh/t8ckODv/587NS5/6KsM77vc6Wh90NAT2s= """) - prv_key_raw = hexdec("BFCF1D623E5CDD3032A7C6EABB4A923C46E43D640FFEAAF2C3ED39A8FA399924")[::-1] + prv_key_raw = bytes.fromhex("BFCF1D623E5CDD3032A7C6EABB4A923C46E43D640FFEAAF2C3ED39A8FA399924")[::-1] self.process_cert( "id-GostR3410-2001-CryptoPro-XchA-ParamSet", GOST34112012256, @@ -167,7 +166,7 @@ ppPTXzHyVR1DtPa8b57nudJzI4czhsfeX5HDntOq45t9B/qSs8dC6eGxbhHZ9zCO SFtxWYdmg0au8XI9Xb8vTC1qdwWID7FFjMWDNQZb6lYh/J+8F2xKylvB5nIlRZqO o3eUNFkNyHJwQCk2WoOlO16zwGk2tdKH4KmD5w== """) - prv_key_raw = hexdec("3FC01CDCD4EC5F972EB482774C41E66DB7F380528DFE9E67992BA05AEE462435757530E641077CE587B976C8EEB48C48FD33FD175F0C7DE6A44E014E6BCB074B")[::-1] + prv_key_raw = bytes.fromhex("3FC01CDCD4EC5F972EB482774C41E66DB7F380528DFE9E67992BA05AEE462435757530E641077CE587B976C8EEB48C48FD33FD175F0C7DE6A44E014E6BCB074B")[::-1] self.process_cert( "id-tc26-gost-3410-12-512-paramSetB", GOST34112012512, @@ -196,7 +195,7 @@ c_b64, crl_sign_hex, crl_b64, ): - prv_raw = hexdec(prv_hex)[::-1] + prv_raw = bytes.fromhex(prv_hex)[::-1] prv = prv_unmarshal(prv_raw) curve = CURVES[curve_name] pub = public_key(curve, prv) @@ -221,7 +220,7 @@ ("subject", subj), ("subjectPKInfo", spki), ("attributes", Attributes()), )) - sign = hexdec(cr_sign_hex) + sign = bytes.fromhex(cr_sign_hex) self.assertTrue(verify( curve, pub, @@ -257,7 +256,7 @@ )), )), ))), )) - sign = hexdec(c_sign_hex) + sign = bytes.fromhex(c_sign_hex) self.assertTrue(verify( curve, pub, @@ -279,7 +278,7 @@ ("issuer", subj), ("thisUpdate", Time(("utcTime", UTCTime(b"140101000000Z")))), ("nextUpdate", Time(("utcTime", UTCTime(b"140102000000Z")))), )) - sign = hexdec(crl_sign_hex) + sign = bytes.fromhex(crl_sign_hex) self.assertTrue(verify( curve, pub, diff --git a/pygost/utils.py b/pygost/utils.py index 4bacc04eb878afaf4e22d0cbeafe1d046b944cac7ff397ef736e228120e7e812..7d930da4b8c2eadf120e25e01cd704e4267cce8faef025d8cda29754a924e533 100644 --- a/pygost/utils.py +++ b/pygost/utils.py @@ -31,22 +31,6 @@ xor[i] = a[i] ^ b[i] return bytes(xor) -_hexdecoder = getdecoder("hex") -_hexencoder = getencoder("hex") - - -def hexdec(data): - """Decode hexadecimal - """ - return _hexdecoder(data)[0] - - -def hexenc(data): - """Encode hexadecimal - """ - return _hexencoder(data)[0].decode("ascii") - - def modinvert(a: int, n: int) -> int: """Modular multiplicative inverse