doc/INSTALL | 2 +- doc/NEWS | 8 +++++--- pygost/__init__.py | 2 +- pygost/asn1schemas/cert-selfsigned-example.py | 3 +-- pygost/gost3410.py | 145 ++++++++++++++++++++++++++--------------------------- pygost/gost3410_vko.py | 3 +-- pygost/gost3413.py | 12 +++++------- pygost/iface.py | 20 +------------------- pygost/kdf.py | 11 ++++++----- pygost/mgm.py | 14 ++++++-------- pygost/pbkdf2.py | 10 ++++------ pygost/run-tests | 8 ++++++++ pygost/sespake.py | 70 ++++++++++++++++++++++++++--------------------------- pygost/test.do | 14 -------------- pygost/test_cms.py | 18 ++++++++---------- pygost/test_gost3410.py | 76 ++++++++++++++++++++++++++--------------------------- pygost/test_gost3410_vko.py | 15 +++++++-------- pygost/test_sespake.py | 68 ++++++++++++++++++++++++++--------------------------- pygost/utils.py | 26 -------------------------- setup.py | 8 ++------ diff --git a/doc/INSTALL b/doc/INSTALL index 0d67bbe79f97a276c04bc4e6a963f76b9a1e309d86ba7d9bed7abd8276e90b8a..b29453a09a7071e8b3932aa540995a8452d6c4f236b09b25b2e7d470536533c5 100644 --- a/doc/INSTALL +++ b/doc/INSTALL @@ -2,7 +2,7 @@ No additional dependencies except Python 2.7/3.x interpreter are required. Preferable way is to [Download] tarball with the signature: - $ v=5.14 + $ v=6.0 $ fetch http://www.pygost.cypherpunks.su/pygost-$v.tar.zst $ fetch http://www.pygost.cypherpunks.su/pygost-$v.tar.zst.{asc,sig} [Integrity] verify diff --git a/doc/NEWS b/doc/NEWS index 9978c555de73157d9b4b9625d7edf8a1c1bd24e0862dbe78664731d0e6d61a52..87df310701b63d4cfa349974917227d1ab48d71a095b700fff2544142f64dc38 100644 --- a/doc/NEWS +++ b/doc/NEWS @@ -1,6 +1,8 @@ -A 5.14 -5.14 - Added SESPAKE (RFC 8133) algorithm support. +A 6.0 +6.0 + * Removed Python2 compatibility. + * Added SESPAKE (RFC 8133) algorithm support. + * Removed utils.bytes2long and utils.long2bytes. A 5.13 5.13 diff --git a/pygost/__init__.py b/pygost/__init__.py index 6e67f923df598d7af11fd19b3a7dfca148a8de0d8ee0ea0a526c383785b53c8b..871bf6b5c10e859d8408e3c9581e30c28d78d3f68c4fda409dd3276f8d83be5f 100644 --- a/pygost/__init__.py +++ b/pygost/__init__.py @@ -3,4 +3,4 @@ PyGOST is free software: see the file COPYING for copying conditions. """ -__version__ = "5.14" +__version__ = "6.0" diff --git a/pygost/asn1schemas/cert-selfsigned-example.py b/pygost/asn1schemas/cert-selfsigned-example.py index 046f042656e5e55fc58a80e9b559502d83b729dcba276384d289d58df60dc9e5..8d3e295af1e39861f8508f6b8f97fc2b9684a7756962b6d79099d40cfd6ed90a 100755 --- a/pygost/asn1schemas/cert-selfsigned-example.py +++ b/pygost/asn1schemas/cert-selfsigned-example.py @@ -73,7 +73,6 @@ from pygost.gost3410 import public_key from pygost.gost3410 import sign from pygost.gost34112012256 import GOST34112012256 from pygost.gost34112012512 import GOST34112012512 -from pygost.utils import bytes2long parser = ArgumentParser(description="Self-signed X.509 certificate creator") parser.add_argument( @@ -311,7 +310,7 @@ )).encode())), ))) serial = ( - bytes2long(GOST34112012256(urandom(16)).digest()[:20]) + int.from_bytes(urandom(20), "big") if args.serial is None else int(args.serial) ) tbs = TBSCertificate(( diff --git a/pygost/gost3410.py b/pygost/gost3410.py index 3d899e0b8a16625848f1d9b064f5d93c9292fece890ca82740ee7ce8679662cb..fbb794bb5db1ff667b56e5c9ca843be18ded9c7af8db78c125dffbed0d1984bb 100644 --- a/pygost/gost3410.py +++ b/pygost/gost3410.py @@ -22,9 +22,7 @@ """ from os import urandom -from pygost.utils import bytes2long from pygost.utils import hexdec -from pygost.utils import long2bytes from pygost.utils import modinvert @@ -138,90 +136,90 @@ CURVES = { "GostR3410_2001_ParamSet_cc": GOST3410Curve( - p=bytes2long(hexdec("C0000000000000000000000000000000000000000000000000000000000003C7")), - q=bytes2long(hexdec("5fffffffffffffffffffffffffffffff606117a2f4bde428b7458a54b6e87b85")), - a=bytes2long(hexdec("C0000000000000000000000000000000000000000000000000000000000003c4")), - b=bytes2long(hexdec("2d06B4265ebc749ff7d0f1f1f88232e81632e9088fd44b7787d5e407e955080c")), - x=bytes2long(hexdec("0000000000000000000000000000000000000000000000000000000000000002")), - y=bytes2long(hexdec("a20e034bf8813ef5c18d01105e726a17eb248b264ae9706f440bedc8ccb6b22c")), + 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"), ), "id-GostR3410-2001-TestParamSet": GOST3410Curve( - p=bytes2long(hexdec("8000000000000000000000000000000000000000000000000000000000000431")), - q=bytes2long(hexdec("8000000000000000000000000000000150FE8A1892976154C59CFC193ACCF5B3")), - a=bytes2long(hexdec("0000000000000000000000000000000000000000000000000000000000000007")), - b=bytes2long(hexdec("5FBFF498AA938CE739B8E022FBAFEF40563F6E6A3472FC2A514C0CE9DAE23B7E")), - x=bytes2long(hexdec("0000000000000000000000000000000000000000000000000000000000000002")), - y=bytes2long(hexdec("08E2A8A0E65147D4BD6316030E16D19C85C97F0A9CA267122B96ABBCEA7E8FC8")), + 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"), ), "id-tc26-gost-3410-12-256-paramSetA": GOST3410Curve( - p=bytes2long(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD97")), - q=bytes2long(hexdec("400000000000000000000000000000000FD8CDDFC87B6635C115AF556C360C67")), - a=bytes2long(hexdec("C2173F1513981673AF4892C23035A27CE25E2013BF95AA33B22C656F277E7335")), - b=bytes2long(hexdec("295F9BAE7428ED9CCC20E7C359A9D41A22FCCD9108E17BF7BA9337A6F8AE9513")), - x=bytes2long(hexdec("91E38443A5E82C0D880923425712B2BB658B9196932E02C78B2582FE742DAA28")), - y=bytes2long(hexdec("32879423AB1A0375895786C4BB46E9565FDE0B5344766740AF268ADB32322E5C")), + 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"), cofactor=4, e=0x01, - d=bytes2long(hexdec("0605F6B7C183FA81578BC39CFAD518132B9DF62897009AF7E522C32D6DC7BFFB")), + d=int.from_bytes(hexdec("0605F6B7C183FA81578BC39CFAD518132B9DF62897009AF7E522C32D6DC7BFFB"), "big"), ), "id-tc26-gost-3410-12-256-paramSetB": GOST3410Curve( - p=bytes2long(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD97")), - q=bytes2long(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6C611070995AD10045841B09B761B893")), - a=bytes2long(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD94")), - b=bytes2long(hexdec("00000000000000000000000000000000000000000000000000000000000000a6")), - x=bytes2long(hexdec("0000000000000000000000000000000000000000000000000000000000000001")), - y=bytes2long(hexdec("8D91E471E0989CDA27DF505A453F2B7635294F2DDF23E3B122ACC99C9E9F1E14")), + 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"), ), "id-tc26-gost-3410-12-256-paramSetC": GOST3410Curve( - p=bytes2long(hexdec("8000000000000000000000000000000000000000000000000000000000000C99")), - q=bytes2long(hexdec("800000000000000000000000000000015F700CFFF1A624E5E497161BCC8A198F")), - a=bytes2long(hexdec("8000000000000000000000000000000000000000000000000000000000000C96")), - b=bytes2long(hexdec("3E1AF419A269A5F866A7D3C25C3DF80AE979259373FF2B182F49D4CE7E1BBC8B")), - x=bytes2long(hexdec("0000000000000000000000000000000000000000000000000000000000000001")), - y=bytes2long(hexdec("3FA8124359F96680B83D1C3EB2C070E5C545C9858D03ECFB744BF8D717717EFC")), + 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"), ), "id-tc26-gost-3410-12-256-paramSetD": GOST3410Curve( - p=bytes2long(hexdec("9B9F605F5A858107AB1EC85E6B41C8AACF846E86789051D37998F7B9022D759B")), - q=bytes2long(hexdec("9B9F605F5A858107AB1EC85E6B41C8AA582CA3511EDDFB74F02F3A6598980BB9")), - a=bytes2long(hexdec("9B9F605F5A858107AB1EC85E6B41C8AACF846E86789051D37998F7B9022D7598")), - b=bytes2long(hexdec("000000000000000000000000000000000000000000000000000000000000805a")), - x=bytes2long(hexdec("0000000000000000000000000000000000000000000000000000000000000000")), - y=bytes2long(hexdec("41ECE55743711A8C3CBF3783CD08C0EE4D4DC440D4641A8F366E550DFDB3BB67")), + 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"), ), "id-tc26-gost-3410-12-512-paramSetTest": GOST3410Curve( - p=bytes2long(hexdec("4531ACD1FE0023C7550D267B6B2FEE80922B14B2FFB90F04D4EB7C09B5D2D15DF1D852741AF4704A0458047E80E4546D35B8336FAC224DD81664BBF528BE6373")), - q=bytes2long(hexdec("4531ACD1FE0023C7550D267B6B2FEE80922B14B2FFB90F04D4EB7C09B5D2D15DA82F2D7ECB1DBAC719905C5EECC423F1D86E25EDBE23C595D644AAF187E6E6DF")), + p=int.from_bytes(hexdec("4531ACD1FE0023C7550D267B6B2FEE80922B14B2FFB90F04D4EB7C09B5D2D15DF1D852741AF4704A0458047E80E4546D35B8336FAC224DD81664BBF528BE6373"), "big"), + q=int.from_bytes(hexdec("4531ACD1FE0023C7550D267B6B2FEE80922B14B2FFB90F04D4EB7C09B5D2D15DA82F2D7ECB1DBAC719905C5EECC423F1D86E25EDBE23C595D644AAF187E6E6DF"), "big"), a=7, - b=bytes2long(hexdec("1CFF0806A31116DA29D8CFA54E57EB748BC5F377E49400FDD788B649ECA1AC4361834013B2AD7322480A89CA58E0CF74BC9E540C2ADD6897FAD0A3084F302ADC")), - x=bytes2long(hexdec("24D19CC64572EE30F396BF6EBBFD7A6C5213B3B3D7057CC825F91093A68CD762FD60611262CD838DC6B60AA7EEE804E28BC849977FAC33B4B530F1B120248A9A")), - y=bytes2long(hexdec("2BB312A43BD2CE6E0D020613C857ACDDCFBF061E91E5F2C3F32447C259F39B2C83AB156D77F1496BF7EB3351E1EE4E43DC1A18B91B24640B6DBB92CB1ADD371E")), + b=int.from_bytes(hexdec("1CFF0806A31116DA29D8CFA54E57EB748BC5F377E49400FDD788B649ECA1AC4361834013B2AD7322480A89CA58E0CF74BC9E540C2ADD6897FAD0A3084F302ADC"), "big"), + x=int.from_bytes(hexdec("24D19CC64572EE30F396BF6EBBFD7A6C5213B3B3D7057CC825F91093A68CD762FD60611262CD838DC6B60AA7EEE804E28BC849977FAC33B4B530F1B120248A9A"), "big"), + y=int.from_bytes(hexdec("2BB312A43BD2CE6E0D020613C857ACDDCFBF061E91E5F2C3F32447C259F39B2C83AB156D77F1496BF7EB3351E1EE4E43DC1A18B91B24640B6DBB92CB1ADD371E"), "big"), ), "id-tc26-gost-3410-12-512-paramSetA": GOST3410Curve( - p=bytes2long(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC7")), - q=bytes2long(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF27E69532F48D89116FF22B8D4E0560609B4B38ABFAD2B85DCACDB1411F10B275")), - a=bytes2long(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC4")), - b=bytes2long(hexdec("E8C2505DEDFC86DDC1BD0B2B6667F1DA34B82574761CB0E879BD081CFD0B6265EE3CB090F30D27614CB4574010DA90DD862EF9D4EBEE4761503190785A71C760")), - x=bytes2long(hexdec("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003")), - y=bytes2long(hexdec("7503CFE87A836AE3A61B8816E25450E6CE5E1C93ACF1ABC1778064FDCBEFA921DF1626BE4FD036E93D75E6A50E3A41E98028FE5FC235F5B889A589CB5215F2A4")), + 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"), ), "id-tc26-gost-3410-12-512-paramSetB": GOST3410Curve( - p=bytes2long(hexdec("8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006F")), - q=bytes2long(hexdec("800000000000000000000000000000000000000000000000000000000000000149A1EC142565A545ACFDB77BD9D40CFA8B996712101BEA0EC6346C54374F25BD")), - a=bytes2long(hexdec("8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006C")), - b=bytes2long(hexdec("687D1B459DC841457E3E06CF6F5E2517B97C7D614AF138BCBF85DC806C4B289F3E965D2DB1416D217F8B276FAD1AB69C50F78BEE1FA3106EFB8CCBC7C5140116")), - x=bytes2long(hexdec("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002")), - y=bytes2long(hexdec("1A8F7EDA389B094C2C071E3647A8940F3C123B697578C213BE6DD9E6C8EC7335DCB228FD1EDF4A39152CBCAAF8C0398828041055F94CEEEC7E21340780FE41BD")), + 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"), ), "id-tc26-gost-3410-12-512-paramSetC": GOST3410Curve( - p=bytes2long(hexdec("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC7")), - q=bytes2long(hexdec("3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC98CDBA46506AB004C33A9FF5147502CC8EDA9E7A769A12694623CEF47F023ED")), - a=bytes2long(hexdec("DC9203E514A721875485A529D2C722FB187BC8980EB866644DE41C68E143064546E861C0E2C9EDD92ADE71F46FCF50FF2AD97F951FDA9F2A2EB6546F39689BD3")), - b=bytes2long(hexdec("B4C4EE28CEBC6C2C8AC12952CF37F16AC7EFB6A9F69F4B57FFDA2E4F0DE5ADE038CBC2FFF719D2C18DE0284B8BFEF3B52B8CC7A5F5BF0A3C8D2319A5312557E1")), - x=bytes2long(hexdec("E2E31EDFC23DE7BDEBE241CE593EF5DE2295B7A9CBAEF021D385F7074CEA043AA27272A7AE602BF2A7B9033DB9ED3610C6FB85487EAE97AAC5BC7928C1950148")), - y=bytes2long(hexdec("F5CE40D95B5EB899ABBCCFF5911CB8577939804D6527378B8C108C3D2090FF9BE18E2D33E3021ED2EF32D85822423B6304F726AA854BAE07D0396E9A9ADDC40F")), + 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"), cofactor=4, e=0x01, - d=bytes2long(hexdec("9E4F5D8C017D8D9F13A5CF3CDF5BFE4DAB402D54198E31EBDE28A0621050439CA6B39E0A515C06B304E2CE43E79E369E91A0CFC2BC2A22B4CA302DBB33EE7550")), + d=int.from_bytes(hexdec("9E4F5D8C017D8D9F13A5CF3CDF5BFE4DAB402D54198E31EBDE28A0621050439CA6B39E0A515C06B304E2CE43E79E369E91A0CFC2BC2A22B4CA302DBB33EE7550"), "big"), ), } CURVES["id-GostR3410-2001-CryptoPro-A-ParamSet"] = CURVES["id-tc26-gost-3410-12-256-paramSetB"] @@ -270,7 +268,7 @@ :rtype: bytes, 64 or 128 bytes """ size = curve.point_size q = curve.q - e = bytes2long(digest) % q + e = int.from_bytes(digest, "big") % q if e == 0: e = 1 while True: @@ -278,7 +276,7 @@ if rand is None: rand = urandom(size) elif len(rand) != size: raise ValueError("rand length != %d" % size) - k = bytes2long(rand) % q + k = int.from_bytes(rand, "big") % q if k == 0: continue r, y = curve.exp(k) @@ -296,7 +294,7 @@ s %= q if s == 0: continue break - return long2bytes(s, size) + long2bytes(r, size) + return s.to_bytes(size, "big") + r.to_bytes(size, "big") def verify(curve, pub, digest, signature): @@ -315,11 +313,11 @@ if len(signature) != size * 2: raise ValueError("Invalid signature length") q = curve.q p = curve.p - s = bytes2long(signature[:size]) - r = bytes2long(signature[size:]) + s = int.from_bytes(signature[:size], "big") + r = int.from_bytes(signature[size:], "big") if r <= 0 or r >= q or s <= 0 or s >= q: return False - e = bytes2long(digest) % curve.q + e = int.from_bytes(digest, "big") % curve.q if e == 0: e = 1 v = modinvert(e, q) @@ -353,7 +351,7 @@ It is advisable to use :py:func:`pygost.gost3410.prv_marshal` to assure that key i in curve's Q field for better compatibility with some implementations. """ - return bytes2long(prv[::-1]) + return int.from_bytes(prv, "little") def prv_marshal(curve, prv): @@ -365,7 +363,7 @@ :rtype: bytes Key is in curve's Q field. """ - return long2bytes(prv % curve.q, point_size(prv))[::-1] + return (prv % curve.q).to_bytes(point_size(prv), "little") def pub_marshal(pub): @@ -376,7 +374,7 @@ :rtype: bytes :returns: LE(X) || LE(Y) """ size = point_size(pub[0]) - return (long2bytes(pub[1], size) + long2bytes(pub[0], size))[::-1] + return pub[0].to_bytes(size, "little") + pub[1].to_bytes(size, "little") def pub_unmarshal(pub): @@ -387,8 +385,7 @@ :type pub: bytes :rtype: (long, long) """ size = len(pub) // 2 - pub = pub[::-1] - return (bytes2long(pub[size:]), bytes2long(pub[:size])) + return (int.from_bytes(pub[:size], "little"), int.from_bytes(pub[size:], "little")) def uv2xy(curve, u, v): diff --git a/pygost/gost3410_vko.py b/pygost/gost3410_vko.py index 0d805e57acb8754a4e5f35d5463d98b67643c8942ad15f8f271969a9c0fb9a9e..b6eb14a678dc03a524e428db88a0f325d4bd57f2933c88cdbf6f7c12257dadef 100644 --- a/pygost/gost3410_vko.py +++ b/pygost/gost3410_vko.py @@ -20,7 +20,6 @@ from pygost.gost3410 import pub_marshal from pygost.gost34112012256 import GOST34112012256 from pygost.gost34112012512 import GOST34112012512 from pygost.gost341194 import GOST341194 -from pygost.utils import bytes2long def ukm_unmarshal(ukm): @@ -29,7 +28,7 @@ :type ukm: little-endian bytes :rtype: long """ - return bytes2long(ukm[::-1]) + return int.from_bytes(ukm, "little") def kek(curve, prv, pub, ukm, mask=None): diff --git a/pygost/gost3413.py b/pygost/gost3413.py index bd77b1a3d09f57dfe5a719054490ae8b68b8d3bf907d68e7aba5ae3c3e5ad995..a651ab900470bafafb40f71d62ba7193b0d178bfac4e5c6523b2741fbbc9bbaa 100644 --- a/pygost/gost3413.py +++ b/pygost/gost3413.py @@ -20,8 +20,6 @@ """ from os import urandom -from pygost.utils import bytes2long -from pygost.utils import long2bytes from pygost.utils import strxor from pygost.utils import xrange @@ -145,7 +143,7 @@ ctr_value != 0 and ctr_value % acpkm_section_size_in_bs == 0 ): encrypter = acpkm_algo_class(acpkm(encrypter, bs)).encrypt - stream.append(encrypter(iv + long2bytes(ctr_value, bs // 2))) + stream.append(encrypter(iv + ctr_value.to_bytes(bs // 2, "big"))) ctr_value = (ctr_value + 1) % ctr_max_value return strxor(b"".join(stream), data) @@ -266,8 +264,8 @@ return b"".join(pt) def _mac_shift(bs, data, xor_lsb=0): - num = (bytes2long(data) << 1) ^ xor_lsb - return long2bytes(num, bs)[-bs:] + num = (int.from_bytes(data, "big") << 1) ^ xor_lsb + return num.to_bytes(bs+1, "big")[-bs:] Rb64 = 0b11011 @@ -360,9 +358,9 @@ tail = data[tail_offset:] if len(tail) == bs: key, k1 = keymats[:KEYSIZE], keymats[KEYSIZE:] encrypter = algo_class(key).encrypt - k2 = long2bytes(bytes2long(k1) << 1, size=bs) + k2 = (int.from_bytes(k1, "big") << 1).to_bytes(bs, "big") if bytearray(k1)[0] & 0x80 != 0: - k2 = strxor(k2, long2bytes(Rb128 if bs == 16 else Rb64, size=bs)) + k2 = strxor(k2, (Rb128 if bs == 16 else Rb64).to_bytes(bs, "big")) return encrypter(strxor( strxor(pad3(tail, bs), prev), k1 if len(tail) == bs else k2, diff --git a/pygost/iface.py b/pygost/iface.py index 3b512a22508a49bb0bbe6a27b323851a533795d9e3fb39c3791b4190222628f0..1d3d0991468a645f196c315c537a75269374065e4751f19aee33b03bc6090be7 100644 --- a/pygost/iface.py +++ b/pygost/iface.py @@ -4,25 +4,7 @@ from pygost.utils import hexenc -# This function is taken from six package as is -def add_metaclass(metaclass): - """Class decorator for creating a class with a metaclass.""" - def wrapper(cls): - orig_vars = cls.__dict__.copy() - slots = orig_vars.get("__slots__") - if slots is not None: - if isinstance(slots, str): - slots = [slots] - for slots_var in slots: - orig_vars.pop(slots_var) - orig_vars.pop("__dict__", None) - orig_vars.pop("__weakref__", None) - return metaclass(cls.__name__, cls.__bases__, orig_vars) - return wrapper - - -@add_metaclass(ABCMeta) -class PEP247(object): +class PEP247(metaclass=ABCMeta): @property @abstractmethod def digest_size(self): diff --git a/pygost/kdf.py b/pygost/kdf.py index 0185109e290976f86db3655e3a9d21d62f36f9d423be27d3d10b9312902f6779..da4867950ab296fd88dce42e1f3eb16dfd7b0f4d93de9540bee41e7e28eb5d1a 100644 --- a/pygost/kdf.py +++ b/pygost/kdf.py @@ -21,8 +21,6 @@ from pygost.gost3410_vko import kek_34102012256 from pygost.gost3410_vko import kek_34102012512 from pygost.gost34112012256 import GOST34112012256 -from pygost.utils import bytes2long -from pygost.utils import long2bytes def kdf_gostr3411_2012_256(key, label, seed): @@ -51,11 +49,14 @@ :param int i_len: length of iterations value (called "R") :returns: list of 256-bit keys """ keymat = [] - _len = long2bytes(keys * 32 * 8, size=1) + _len = (keys * 32 * 8).to_bytes(2, "big") for i in range(keys): keymat.append(hmac.new( key=key, - msg=b"".join((long2bytes(i + 1, size=i_len), label, b"\x00", seed, _len)), + msg=b"".join(( + (i + 1).to_bytes(i_len, "big"), + label, b"\x00", seed, _len, + )), digestmod=GOST34112012256, ).digest()) return keymat @@ -72,7 +73,7 @@ :param bytes h: "h"-value, 32 bytes """ if len(h) != 32: raise ValueError("h must be 32 bytes long") - ukm = bytes2long(h[:16]) + ukm = int.from_bytes(h[:16], "big") if ukm == 0: ukm = 1 if curve.point_size == 64: diff --git a/pygost/mgm.py b/pygost/mgm.py index 5732e3c242043fcf643d8e3c44e5687e405fe99ca773595a6cefff587b07e5a9..c37305571a1b74c1d59a4cc1b5e67ab113ae108b55d43953050c4b96e953d064 100644 --- a/pygost/mgm.py +++ b/pygost/mgm.py @@ -19,13 +19,11 @@ from hmac import compare_digest from pygost.gost3413 import pad1 -from pygost.utils import bytes2long -from pygost.utils import long2bytes from pygost.utils import strxor def _incr(data, bs): - return long2bytes(bytes2long(data) + 1, size=bs // 2) + return (int.from_bytes(data, "big") + 1).to_bytes(bs // 2, "big") def incr_r(data, bs): @@ -79,8 +77,8 @@ if len(plaintext) + len(additional_data) > self.max_size: raise ValueError("plaintext+additional_data are too big") def _mul(self, x, y): - x = bytes2long(x) - y = bytes2long(y) + x = int.from_bytes(x, "big") + y = int.from_bytes(y, "big") z = 0 max_bit = 1 << (self.bs * 8 - 1) while y > 0: @@ -91,7 +89,7 @@ x = ((x ^ max_bit) << 1) ^ self.r else: x <<= 1 y >>= 1 - return long2bytes(z, size=self.bs) + return z.to_bytes(self.bs, "big") def _crypt(self, icn, data): icn[0] &= 0x7F @@ -124,8 +122,8 @@ )) enc = incr_l(enc, self.bs) text = text[self.bs:] _sum = strxor(_sum, self._mul(self.encrypter(enc), ( - long2bytes(ad_len * 8, size=self.bs // 2) + - long2bytes(text_len * 8, size=self.bs // 2) + (ad_len * 8).to_bytes(self.bs // 2, "big") + + (text_len * 8).to_bytes(self.bs // 2, "big") ))) return self.encrypter(_sum)[:self.tag_size] diff --git a/pygost/pbkdf2.py b/pygost/pbkdf2.py index 0a78e7b82d320850515cf6b39cdfa15dc1de8411c2de42d8958db9bb777b1231..80ac943d89b8bce0cedd32971a995ebceb92b9e25e63989118a378981cb0bae1 100644 --- a/pygost/pbkdf2.py +++ b/pygost/pbkdf2.py @@ -6,8 +6,6 @@ PyGOST does not register itself in hashlib anyway, so use it instead. """ -from pygost.utils import bytes2long -from pygost.utils import long2bytes from pygost.utils import strxor from pygost.utils import xrange @@ -31,11 +29,11 @@ dkey = b"" loop = 1 while len(dkey) < dklen: - prev = prf(salt + long2bytes(loop, 4)) - rkey = bytes2long(prev) + prev = prf(salt + loop.to_bytes(4, "big")) + rkey = int.from_bytes(prev, "big") for _ in xrange(iterations - 1): prev = prf(prev) - rkey ^= bytes2long(prev) + rkey ^= int.from_bytes(prev, "big") loop += 1 - dkey += long2bytes(rkey, inner.digest_size) + dkey += rkey.to_bytes(inner.digest_size, "big") return dkey[:dklen] diff --git a/pygost/run-tests b/pygost/run-tests new file mode 100755 index 0000000000000000000000000000000000000000..66ba2d3a675d33d6dc3e3a393c13fcabc7d2c603412b8c620f1862df21c093e0 --- /dev/null +++ b/pygost/run-tests @@ -0,0 +1,8 @@ +#!/bin/sh + +export PYTHONPATH=$PYTHONPATH:.. +set -x +for t in gost28147 gost28147_mac gost341194 gost34112012 gost3410 gost3410_vko wrap gost3412 gost3413 mgm kdf sespake x509 cms pfx ; do + ${PYTHON:-python} -m unittest test_$t +done + diff --git a/pygost/sespake.py b/pygost/sespake.py index 3d014624bed9a98ae7e909af96e650cd29d778556840c9a7a96cb2555d1a4193..704e1d3b755bcae3b5c3a3be65037cb8de51a33b1ece4c023a68801d08036ea0 100644 --- a/pygost/sespake.py +++ b/pygost/sespake.py @@ -26,40 +26,38 @@ from pygost import gost34112012256 from pygost import gost34112012512 from pygost.pbkdf2 import pbkdf2 -from pygost.utils import bytes2long from pygost.utils import hexdec -from pygost.utils import long2bytes Qs = { "id-GostR3410-2001-CryptoPro-A-ParamSet": ( - bytes2long(hexdec("a69d51caf1a309fa9e9b66187759b0174c274e080356f23cfcbfe84d396ad7bb")), - bytes2long(hexdec("5d26f29ecc2e9ac0404dcf7986fa55fe94986362170f54b9616426a659786dac")), + int.from_bytes(hexdec("a69d51caf1a309fa9e9b66187759b0174c274e080356f23cfcbfe84d396ad7bb"), "big"), + int.from_bytes(hexdec("5d26f29ecc2e9ac0404dcf7986fa55fe94986362170f54b9616426a659786dac"), "big"), ), "id-GostR3410-2001-CryptoPro-B-ParamSet": ( - bytes2long(hexdec("3d715a874a4b17cb3b517893a9794a2b36c89d2ffc693f01ee4cc27e7f49e399")), - bytes2long(hexdec("1c5a641fcf7ce7e87cdf8cea38f3db3096eace2fad158384b53953365f4fe7fe")), + int.from_bytes(hexdec("3d715a874a4b17cb3b517893a9794a2b36c89d2ffc693f01ee4cc27e7f49e399"), "big"), + int.from_bytes(hexdec("1c5a641fcf7ce7e87cdf8cea38f3db3096eace2fad158384b53953365f4fe7fe"), "big"), ), "id-GostR3410-2001-CryptoPro-C-ParamSet": ( - bytes2long(hexdec("1e36383e43bb6cfa2917167d71b7b5dd3d6d462b43d7c64282ae67dfbec2559d")), - bytes2long(hexdec("137478a9f721c73932ea06b45cf72e37eb78a63f29a542e563c614650c8b6399")), + int.from_bytes(hexdec("1e36383e43bb6cfa2917167d71b7b5dd3d6d462b43d7c64282ae67dfbec2559d"), "big"), + int.from_bytes(hexdec("137478a9f721c73932ea06b45cf72e37eb78a63f29a542e563c614650c8b6399"), "big"), ), "id-tc26-gost-3410-2012-512-paramSetA": ( - bytes2long(hexdec("2a17f8833a32795327478871b5c5e88aefb91126c64b4b8327289bea62559425d18198f133f400874328b220c74497cd240586cb249e158532cb8090776cd61c")), - bytes2long(hexdec("728f0c4a73b48da41ce928358fad26b47a6e094e9362bae82559f83cddc4ec3a4676bd3707edeaf4cd85e99695c64c241edc622be87dc0cf87f51f4367f723c5")), + int.from_bytes(hexdec("2a17f8833a32795327478871b5c5e88aefb91126c64b4b8327289bea62559425d18198f133f400874328b220c74497cd240586cb249e158532cb8090776cd61c"), "big"), + int.from_bytes(hexdec("728f0c4a73b48da41ce928358fad26b47a6e094e9362bae82559f83cddc4ec3a4676bd3707edeaf4cd85e99695c64c241edc622be87dc0cf87f51f4367f723c5"), "big"), ), "id-tc26-gost-3410-2012-512-paramSetB": ( - bytes2long(hexdec("7e1fae8285e035bec244bef2d0e5ebf436633cf50e55231dea9c9cf21d4c8c33df85d4305de92971f0a4b4c07e00d87bdbc720eb66e49079285aaf12e0171149")), - bytes2long(hexdec("2cc89998b875d4463805ba0d858a196592db20ab161558ff2f4ef7a85725d20953967ae621afdeae89bb77c83a2528ef6fce02f68bda4679d7f2704947dbc408")), + int.from_bytes(hexdec("7e1fae8285e035bec244bef2d0e5ebf436633cf50e55231dea9c9cf21d4c8c33df85d4305de92971f0a4b4c07e00d87bdbc720eb66e49079285aaf12e0171149"), "big"), + int.from_bytes(hexdec("2cc89998b875d4463805ba0d858a196592db20ab161558ff2f4ef7a85725d20953967ae621afdeae89bb77c83a2528ef6fce02f68bda4679d7f2704947dbc408"), "big"), ), "id-tc26-gost-3410-2012-256-paramSetA": ( - bytes2long(hexdec("b51adf93a40ab15792164fad3352f95b66369eb2a4ef5efae32829320363350e")), - bytes2long(hexdec("74a358cc08593612f5955d249c96afb7e8b0bb6d8bd2bbe491046650d822be18")), + int.from_bytes(hexdec("b51adf93a40ab15792164fad3352f95b66369eb2a4ef5efae32829320363350e"), "big"), + int.from_bytes(hexdec("74a358cc08593612f5955d249c96afb7e8b0bb6d8bd2bbe491046650d822be18"), "big"), # U: ebe97afffe0d0f88b8b0114b8de430ac2b34564e4420af24728e7305bc48aeaa # V: 828f2dcf8f06612b4fea4da72ca509c0f76dd37df424ea22bfa6f4f65748c1e4 ), "id-tc26-gost-3410-2012-512-paramSetC": ( - bytes2long(hexdec("489c91784e02e98f19a803abca319917f37689e5a18965251ce2ff4e8d8b298f5ba7470f9e0e713487f96f4a8397b3d09a270c9d367eb5e0e6561adeeb51581d")), - bytes2long(hexdec("684ea885aca64eaf1b3fee36c0852a3be3bd8011b0ef18e203ff87028d6eb5db2c144a0dcc71276542bfd72ca2a43fa4f4939da66d9a60793c704a8c94e16f18")), + int.from_bytes(hexdec("489c91784e02e98f19a803abca319917f37689e5a18965251ce2ff4e8d8b298f5ba7470f9e0e713487f96f4a8397b3d09a270c9d367eb5e0e6561adeeb51581d"), "big"), + int.from_bytes(hexdec("684ea885aca64eaf1b3fee36c0852a3be3bd8011b0ef18e203ff87028d6eb5db2c144a0dcc71276542bfd72ca2a43fa4f4939da66d9a60793c704a8c94e16f18"), "big"), # U: 3a3496f97e96b3849a4fa7db60fd93858bde89958e4beebd05a6b3214216b37c9d9a560076e7ea59714828b18fbfef996ffc98bf3dc9f2d3cb0ed36a0d6ace88 # V: 52d884c8bf0ad6c5f7b3973e32a668daa1f1ed092eff138dae6203b2ccdec56147464d35fec4b727b2480eb143074712c76550c7a54ff3ea26f70059480dcb50 ), @@ -90,9 +88,9 @@ self.idB = idB if fpw is None: fpw = pbkdf2(gost34112012512.new, pw, salt, fIters, 64) self.qpw = self.curve.exp( - bytes2long(fpw[:self.curve.point_size][::-1]), q[0], q[1]) + int.from_bytes(fpw[:self.curve.point_size], "little"), q[0], q[1]) self.alpha = ( - bytes2long(urandom(self.curve.point_size)) % self.curve.q + int.from_bytes(urandom(self.curve.point_size), "big") % self.curve.q ) if alpha is None else alpha alphaP = self.curve.exp(self.alpha) tmp = self.curve.exp(self.curve.q-1, self.qpw[0], self.qpw[1]) @@ -109,16 +107,16 @@ # TODO: check zero point tmp = self.curve.exp( (self.curve.cofactor * self.alpha) % self.curve.q, qA[0], qA[1]) self.k = gost34112012256.new( - long2bytes(tmp[0], self.curve.point_size)[::-1] + - long2bytes(tmp[1], self.curve.point_size)[::-1] + tmp[0].to_bytes(self.curve.point_size, "little") + + tmp[1].to_bytes(self.curve.point_size, "little") ).digest() u1 = ( - long2bytes(self.u1[0], self.curve.point_size)[::-1] + - long2bytes(self.u1[1], self.curve.point_size)[::-1] + self.u1[0].to_bytes(self.curve.point_size, "little") + + self.u1[1].to_bytes(self.curve.point_size, "little") ) u2 = ( - long2bytes(self.u2[0], self.curve.point_size)[::-1] + - long2bytes(self.u2[1], self.curve.point_size)[::-1] + self.u2[0].to_bytes(self.curve.point_size, "little") + + self.u2[1].to_bytes(self.curve.point_size, "little") ) macA = hmac.new(key=self.k, msg=b"".join(( b"\x01", self.idA, self.ind, self.salt, u1, u2, self.idAlg, @@ -128,12 +126,12 @@ return macA def kc(self, macB, dataB=b""): u1 = ( - long2bytes(self.u1[0], self.curve.point_size)[::-1] + - long2bytes(self.u1[1], self.curve.point_size)[::-1] + self.u1[0].to_bytes(self.curve.point_size, "little") + + self.u1[1].to_bytes(self.curve.point_size, "little") ) u2 = ( - long2bytes(self.u2[0], self.curve.point_size)[::-1] + - long2bytes(self.u2[1], self.curve.point_size)[::-1] + self.u2[0].to_bytes(self.curve.point_size, "little") + + self.u2[1].to_bytes(self.curve.point_size, "little") ) _macB = hmac.new(key=self.k, msg=b"".join(( b"\x02", self.idB, self.ind, self.salt, u1, u2, self.idAlg, @@ -171,7 +169,7 @@ if fpw is None: fpw = pbkdf2(gost34112012512.new, pw, self.salt, fIters, 64) self.fpw = fpw self.qpw = self.curve.exp( - bytes2long(fpw[:self.curve.point_size][::-1]), q[0], q[1]) + int.from_bytes(fpw[:self.curve.point_size], "little"), q[0], q[1]) def ka(self, u1, beta=None): if not self.curve.contains(u1): @@ -180,11 +178,11 @@ self.u1 = u1 qB = self.curve._add(self.u1[0], self.u1[1], self.qpw[0], self.qpw[1]) # TODO: check zero point if beta is None: - beta = bytes2long(urandom(self.curve.point_size)) % self.curve.q + beta = int.from_bytes(urandom(self.curve.point_size), "big") % self.curve.q tmp = self.curve.exp((self.curve.cofactor * beta) % self.curve.q, qB[0], qB[1]) self.k = gost34112012256.new( - long2bytes(tmp[0], self.curve.point_size)[::-1] + - long2bytes(tmp[1], self.curve.point_size)[::-1] + tmp[0].to_bytes(self.curve.point_size, "little") + + tmp[1].to_bytes(self.curve.point_size, "little") ).digest() betaP = self.curve.exp(beta) self.u2 = self.curve._add(betaP[0], betaP[1], self.qpw[0], self.qpw[1]) @@ -192,12 +190,12 @@ return self.u2 def kc(self, macA, dataA=b"", dataB=b""): u1 = ( - long2bytes(self.u1[0], self.curve.point_size)[::-1] + - long2bytes(self.u1[1], self.curve.point_size)[::-1] + self.u1[0].to_bytes(self.curve.point_size, "little") + + self.u1[1].to_bytes(self.curve.point_size, "little") ) u2 = ( - long2bytes(self.u2[0], self.curve.point_size)[::-1] + - long2bytes(self.u2[1], self.curve.point_size)[::-1] + self.u2[0].to_bytes(self.curve.point_size, "little") + + self.u2[1].to_bytes(self.curve.point_size, "little") ) _macA = hmac.new(key=self.k, msg=b"".join(( b"\x01", self.idA, self.ind, self.salt, u1, u2, self.idAlg, diff --git a/pygost/test.do b/pygost/test.do deleted file mode 100644 index d78c04081e2612ee1c9923b2164bb36dd3219123b52b73f17a68456c16cb8fef..0000000000000000000000000000000000000000 --- a/pygost/test.do +++ /dev/null @@ -1,14 +0,0 @@ -redo gost28147.t -redo gost28147_mac.t -redo gost341194.t -redo gost34112012.t -redo gost3410.t -redo gost3410_vko.t -redo wrap.t -redo gost3412.t -redo gost3413.t -redo mgm.t -redo kdf.t -redo x509.t -redo cms.t -redo pfx.t diff --git a/pygost/test_cms.py b/pygost/test_cms.py index fb91deabfd2d679fc7a1a5556c021145df469b42397dd3971ea5be4e0d3f5dcc..6d3de7aa8cd1015cad50d8592028c9d5d0044cb609e71e97392be0870a8c4be6 100644 --- a/pygost/test_cms.py +++ b/pygost/test_cms.py @@ -18,8 +18,6 @@ from base64 import b64decode from unittest import skipIf from unittest import TestCase -from six import text_type - from pygost.gost28147 import cfb_decrypt from pygost.gost3410 import CURVES from pygost.gost3410 import prv_unmarshal @@ -637,7 +635,7 @@ _, sd = ci["content"].defined content = bytes(sd["encapContentInfo"]["eContent"]) self.assertEqual( content.decode("cp1251"), - text_type(u"Контрольный пример для структуры SignedData."), + u"Контрольный пример для структуры SignedData.", ) si = sd["signerInfos"][0] self.assertEqual( @@ -682,7 +680,7 @@ _, sd = ci["content"].defined content = bytes(sd["encapContentInfo"]["eContent"]) self.assertEqual( content.decode("cp1251"), - text_type(u"Контрольный пример для структуры SignedData."), + u"Контрольный пример для структуры SignedData.", ) si = sd["signerInfos"][0] self.assertEqual( @@ -776,7 +774,7 @@ tag_expected, ) self.assertEqual( content.decode("cp1251"), - text_type(u"Контрольный пример для структуры EnvelopedData."), + u"Контрольный пример для структуры EnvelopedData.", ) def test_kari_static(self): @@ -834,7 +832,7 @@ eci_ukm[:GOST3412Magma.blocksize // 2], ) self.assertEqual( content.decode("cp1251"), - text_type(u"Контрольный пример для структуры EnvelopedData."), + u"Контрольный пример для структуры EnvelopedData.", ) def test_ktri_256(self): @@ -896,7 +894,7 @@ eci_ukm[:GOST3412Kuznechik.blocksize // 2], ) self.assertEqual( content.decode("cp1251"), - text_type(u"Контрольный пример для структуры EnvelopedData."), + u"Контрольный пример для структуры EnvelopedData.", ) def test_ktri_512(self): @@ -977,7 +975,7 @@ tag_expected, ) self.assertEqual( content.decode("cp1251"), - text_type(u"Контрольный пример для структуры EnvelopedData."), + u"Контрольный пример для структуры EnvelopedData.", ) def test_digested256(self): @@ -1031,7 +1029,7 @@ ukm[:GOST3412Kuznechik.blocksize // 2], ) self.assertEqual( content.decode("cp1251"), - text_type(u"Контрольный пример для структуры EncryptedData."), + u"Контрольный пример для структуры EncryptedData.", ) def test_encrypted_magma(self): @@ -1074,5 +1072,5 @@ tag_expected, ) self.assertEqual( content.decode("cp1251"), - text_type(u"Контрольный пример для структуры EncryptedData."), + u"Контрольный пример для структуры EncryptedData.", ) diff --git a/pygost/test_gost3410.py b/pygost/test_gost3410.py index 09ad786bf14ef1914be79429a7ddd28af350724e0eed27cac649dd7783164ac5..cdb95b37f93ac469bf4787891eebb3596cb17fd2d0cf893beca20f99fc3156ef 100644 --- a/pygost/test_gost3410.py +++ b/pygost/test_gost3410.py @@ -26,10 +26,8 @@ from pygost.gost3410 import sign from pygost.gost3410 import uv2xy from pygost.gost3410 import verify from pygost.gost3410 import xy2uv -from pygost.utils import bytes2long from pygost.utils import hexdec from pygost.utils import hexenc -from pygost.utils import long2bytes class Test341001(TestCase): @@ -70,13 +68,13 @@ 0x65, 0x3C, 0x23, 0x5A, 0x98, 0xA6, 0x02, 0x49, 0xBC, 0xD6, 0xD3, 0xF7, 0x46, 0xB6, 0x31, 0xDF, 0x92, 0x80, 0x14, 0xF6, 0xC5, 0xBF, 0x9C, 0x40 ))) - prv = bytes2long(prv) + prv = int.from_bytes(prv, "big") signature = signature[32:] + signature[:32] c = CURVES["id-GostR3410-2001-TestParamSet"] pubX, pubY = public_key(c, prv) - self.assertSequenceEqual(long2bytes(pubX), pub_x) - self.assertSequenceEqual(long2bytes(pubY), pub_y) + self.assertSequenceEqual(pubX.to_bytes(32, "big"), pub_x) + self.assertSequenceEqual(pubY.to_bytes(32, "big"), pub_y) s = sign(c, prv, digest) self.assertTrue(verify(c, (pubX, pubY), digest, s)) self.assertTrue(verify(c, (pubX, pubY), digest, signature)) @@ -96,7 +94,7 @@ def test_1(self): """Test vector from 34.10-2012 standard itself """ curve = CURVES["id-GostR3410-2001-TestParamSet"] - prv = bytes2long(hexdec("7A929ADE789BB9BE10ED359DD39A72C11B60961F49397EEE1D19CE9891EC3B28")) + prv = int.from_bytes(hexdec("7A929ADE789BB9BE10ED359DD39A72C11B60961F49397EEE1D19CE9891EC3B28"), "big") digest = hexdec("2DFBC1B372D89A1188C09C52E0EEC61FCE52032AB1022E8E67ECE6672B043EE5") rand = hexdec("77105C9B20BCD3122823C8CF6FCC7B956DE33814E95B7FE64FED924594DCEAB3") signature = sign(curve, prv, digest, rand) @@ -115,7 +113,7 @@ b=1518655069210828534508950034714043154928747527740206436194018823352809982443793732829756914785974674866041605397883677596626326413990136959047435811826396, x=1928356944067022849399309401243137598997786635459507974357075491307766592685835441065557681003184874819658004903212332884252335830250729527632383493573274, y=2288728693371972859970012155529478416353562327329506180314497425931102860301572814141997072271708807066593850650334152381857347798885864807605098724013854, ) - prv = bytes2long(hexdec("0BA6048AADAE241BA40936D47756D7C93091A0E8514669700EE7508E508B102072E8123B2200A0563322DAD2827E2714A2636B7BFD18AADFC62967821FA18DD4")) + prv = int.from_bytes(hexdec("0BA6048AADAE241BA40936D47756D7C93091A0E8514669700EE7508E508B102072E8123B2200A0563322DAD2827E2714A2636B7BFD18AADFC62967821FA18DD4"), "big") digest = hexdec("3754F3CFACC9E0615C4F4A7C4D8DAB531B09B6F9C170C533A71D147035B0C5917184EE536593F4414339976C647C5D5A407ADEDB1D560C4FC6777D2972075B8C") rand = hexdec("0359E7F4B1410FEACC570456C6801496946312120B39D019D455986E364F365886748ED7A44B3E794434006011842286212273A6D14CF70EA3AF71BB1AE679F1") signature = sign(curve, prv, digest, rand) @@ -126,7 +124,7 @@ def test_gcl3(self): """Test vector from libgcl3 """ - p = bytes2long(bytes(bytearray(( + p = int.from_bytes(bytes(bytearray(( 0x45, 0x31, 0xAC, 0xD1, 0xFE, 0x00, 0x23, 0xC7, 0x55, 0x0D, 0x26, 0x7B, 0x6B, 0x2F, 0xEE, 0x80, 0x92, 0x2B, 0x14, 0xB2, 0xFF, 0xB9, 0x0F, 0x04, @@ -135,8 +133,8 @@ 0xF1, 0xD8, 0x52, 0x74, 0x1A, 0xF4, 0x70, 0x4A, 0x04, 0x58, 0x04, 0x7E, 0x80, 0xE4, 0x54, 0x6D, 0x35, 0xB8, 0x33, 0x6F, 0xAC, 0x22, 0x4D, 0xD8, 0x16, 0x64, 0xBB, 0xF5, 0x28, 0xBE, 0x63, 0x73, - )))) - q = bytes2long(bytes(bytearray(( + ))), "big") + q = int.from_bytes(bytes(bytearray(( 0x45, 0x31, 0xAC, 0xD1, 0xFE, 0x00, 0x23, 0xC7, 0x55, 0x0D, 0x26, 0x7B, 0x6B, 0x2F, 0xEE, 0x80, 0x92, 0x2B, 0x14, 0xB2, 0xFF, 0xB9, 0x0F, 0x04, @@ -145,8 +143,8 @@ 0xA8, 0x2F, 0x2D, 0x7E, 0xCB, 0x1D, 0xBA, 0xC7, 0x19, 0x90, 0x5C, 0x5E, 0xEC, 0xC4, 0x23, 0xF1, 0xD8, 0x6E, 0x25, 0xED, 0xBE, 0x23, 0xC5, 0x95, 0xD6, 0x44, 0xAA, 0xF1, 0x87, 0xE6, 0xE6, 0xDF, - )))) - a = bytes2long(bytes(bytearray(( + ))), "big") + a = int.from_bytes(bytes(bytearray(( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -155,8 +153,8 @@ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, - )))) - b = bytes2long(bytes(bytearray(( + ))), "big") + b = int.from_bytes(bytes(bytearray(( 0x1C, 0xFF, 0x08, 0x06, 0xA3, 0x11, 0x16, 0xDA, 0x29, 0xD8, 0xCF, 0xA5, 0x4E, 0x57, 0xEB, 0x74, 0x8B, 0xC5, 0xF3, 0x77, 0xE4, 0x94, 0x00, 0xFD, @@ -165,8 +163,8 @@ 0x61, 0x83, 0x40, 0x13, 0xB2, 0xAD, 0x73, 0x22, 0x48, 0x0A, 0x89, 0xCA, 0x58, 0xE0, 0xCF, 0x74, 0xBC, 0x9E, 0x54, 0x0C, 0x2A, 0xDD, 0x68, 0x97, 0xFA, 0xD0, 0xA3, 0x08, 0x4F, 0x30, 0x2A, 0xDC, - )))) - x = bytes2long(bytes(bytearray(( + ))), "big") + x = int.from_bytes(bytes(bytearray(( 0x24, 0xD1, 0x9C, 0xC6, 0x45, 0x72, 0xEE, 0x30, 0xF3, 0x96, 0xBF, 0x6E, 0xBB, 0xFD, 0x7A, 0x6C, 0x52, 0x13, 0xB3, 0xB3, 0xD7, 0x05, 0x7C, 0xC8, @@ -175,8 +173,8 @@ 0xFD, 0x60, 0x61, 0x12, 0x62, 0xCD, 0x83, 0x8D, 0xC6, 0xB6, 0x0A, 0xA7, 0xEE, 0xE8, 0x04, 0xE2, 0x8B, 0xC8, 0x49, 0x97, 0x7F, 0xAC, 0x33, 0xB4, 0xB5, 0x30, 0xF1, 0xB1, 0x20, 0x24, 0x8A, 0x9A, - )))) - y = bytes2long(bytes(bytearray(( + ))), "big") + y = int.from_bytes(bytes(bytearray(( 0x2B, 0xB3, 0x12, 0xA4, 0x3B, 0xD2, 0xCE, 0x6E, 0x0D, 0x02, 0x06, 0x13, 0xC8, 0x57, 0xAC, 0xDD, 0xCF, 0xBF, 0x06, 0x1E, 0x91, 0xE5, 0xF2, 0xC3, @@ -185,7 +183,7 @@ 0x83, 0xAB, 0x15, 0x6D, 0x77, 0xF1, 0x49, 0x6B, 0xF7, 0xEB, 0x33, 0x51, 0xE1, 0xEE, 0x4E, 0x43, 0xDC, 0x1A, 0x18, 0xB9, 0x1B, 0x24, 0x64, 0x0B, 0x6D, 0xBB, 0x92, 0xCB, 0x1A, 0xDD, 0x37, 0x1E, - )))) + ))), "big") prv = bytes(bytearray(( 0x0B, 0xA6, 0x04, 0x8A, 0xAD, 0xAE, 0x24, 0x1B, 0xA4, 0x09, 0x36, 0xD4, 0x77, 0x56, 0xD7, 0xC9, @@ -244,19 +242,19 @@ 0x52, 0x60, 0x80, 0xDF, 0x7F, 0x70, 0xCE, 0x40, 0x6A, 0x6E, 0xEB, 0x1F, 0x56, 0x91, 0x9C, 0xB9, 0x2A, 0x98, 0x53, 0xBD, 0xE7, 0x3E, 0x5B, 0x4A, ))) - prv = bytes2long(prv) + prv = int.from_bytes(prv, "big") signature = signature[64:] + signature[:64] c = GOST3410Curve(p, q, a, b, x, y) pubX, pubY = public_key(c, prv) - self.assertSequenceEqual(long2bytes(pubX), pub_x) - self.assertSequenceEqual(long2bytes(pubY), pub_y) + self.assertSequenceEqual(pubX.to_bytes(64, "big"), pub_x) + self.assertSequenceEqual(pubY.to_bytes(64, "big"), pub_y) s = sign(c, prv, digest) self.assertTrue(verify(c, (pubX, pubY), digest, s)) self.assertTrue(verify(c, (pubX, pubY), digest, signature)) def test_sequence(self): c = CURVES["id-tc26-gost-3410-12-512-paramSetA"] - prv = bytes2long(urandom(64)) + prv = int.from_bytes(urandom(64), "big") pubX, pubY = public_key(c, prv_unmarshal(prv_marshal(c, prv))) for _ in range(20): digest = urandom(64) @@ -270,13 +268,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, bytes2long(hexdec("60CA1E32AA475B348488C38FAB07649CE7EF8DBE87F22E81F92B2592DBA300E7"))) + u, v = (0x0D, int.from_bytes(hexdec("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, bytes2long(hexdec("469AF79D1FB1F5E16B99592B77A01E2A0FDFB0D01794368D9A56117F7B38669522DD4B650CF789EEBF068C5D139732F0905622C04B2BAAE7600303EE73001A3D"))) + u, v = (0x12, int.from_bytes(hexdec("469AF79D1FB1F5E16B99592B77A01E2A0FDFB0D01794368D9A56117F7B38669522DD4B650CF789EEBF068C5D139732F0905622C04B2BAAE7600303EE73001A3D"), "big")) self.assertEqual(uv2xy(c, u, v), (c.x, c.y)) self.assertEqual(xy2uv(c, c.x, c.y), (u, v)) @@ -291,9 +289,9 @@ 0xA69D51CAF1A309FA9E9B66187759B0174C274E080356F23CFCBFE84D396AD7BB, 0x5D26F29ECC2E9AC0404DCF7986FA55FE94986362170F54B9616426A659786DAC, ) self.assertEqual( - c.exp(bytes2long(hexdec( + c.exp(int.from_bytes(hexdec( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F18127067" - )[::-1]), x=q_ind[0], y=q_ind[1]), + ), "little"), x=q_ind[0], y=q_ind[1]), ( 0x59495655D1E7C7424C622485F575CCF121F3122D274101E8AB734CC9C9A9B45E, 0x48D1C311D33C9B701F3B03618562A4A07A044E3AF31E3999E67B487778B53C62, @@ -321,9 +319,9 @@ 0x3D715A874A4B17CB3B517893A9794A2B36C89D2FFC693F01EE4CC27E7F49E399, 0x1C5A641FCF7CE7E87CDF8CEA38F3DB3096EACE2FAD158384B53953365F4FE7FE, ) self.assertEqual( - c.exp(bytes2long(hexdec( + c.exp(int.from_bytes(hexdec( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F18127067" - )[::-1]), x=q_ind[0], y=q_ind[1]), + ), "little"), x=q_ind[0], y=q_ind[1]), ( 0x6DC2AE26BC691FCA5A73D9C452790D15E34BA5404D92955B914C8D2662ABB985, 0x3B02AAA9DD65AE30C335CED12F3154BBAC059F66B088306747453EDF6E5DB077, @@ -351,9 +349,9 @@ 0x1E36383E43BB6CFA2917167D71B7B5DD3D6D462B43D7C64282AE67DFBEC2559D, 0x137478A9F721C73932EA06B45CF72E37EB78A63F29A542E563C614650C8B6399, ) self.assertEqual( - c.exp(bytes2long(hexdec( + c.exp(int.from_bytes(hexdec( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F18127067" - )[::-1]), x=q_ind[0], y=q_ind[1]), + ), "little"), x=q_ind[0], y=q_ind[1]), ( 0x945821DAF91E158B839939630655A3B21FF3E146D27041E86C05650EB3B46B59, 0x3A0C2816AC97421FA0E879605F17F0C9C3EB734CFF196937F6284438D70BDC48, @@ -381,9 +379,9 @@ 0x2A17F8833A32795327478871B5C5E88AEFB91126C64B4B8327289BEA62559425D18198F133F400874328B220C74497CD240586CB249E158532CB8090776CD61C, 0x728F0C4A73B48DA41CE928358FAD26B47A6E094E9362BAE82559F83CDDC4EC3A4676BD3707EDEAF4CD85E99695C64C241EDC622BE87DC0CF87F51F4367F723C5, ) self.assertEqual( - c.exp(bytes2long(hexdec( + c.exp(int.from_bytes(hexdec( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F181270671C6213E3930EFDDA26451792C6208122EE60D200520D695DFD9F5F0FD5ABA702" - )[::-1]), x=q_ind[0], y=q_ind[1]), + ), "little"), x=q_ind[0], y=q_ind[1]), ( 0x0C0AB53D0E0A9C607CAD758F558915A0A7DC5DC87B45E9A58FDDF30EC3385960283E030CD322D9E46B070637785FD49D2CD711F46807A24C40AF9A42C8E2D740, 0xDF93A8012B86D3A3D4F8A4D487DA15FC739EB31B20B3B0E8C8C032AAF8072C6337CF7D5B404719E5B4407C41D9A3216A08CA69C271484E9ED72B8AAA52E28B8B, @@ -411,9 +409,9 @@ 0x7E1FAE8285E035BEC244BEF2D0E5EBF436633CF50E55231DEA9C9CF21D4C8C33DF85D4305DE92971F0A4B4C07E00D87BDBC720EB66E49079285AAF12E0171149, 0x2CC89998B875D4463805BA0D858A196592DB20AB161558FF2F4EF7A85725D20953967AE621AFDEAE89BB77C83A2528EF6FCE02F68BDA4679D7F2704947DBC408, ) self.assertEqual( - c.exp(bytes2long(hexdec( + c.exp(int.from_bytes(hexdec( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F181270671C6213E3930EFDDA26451792C6208122EE60D200520D695DFD9F5F0FD5ABA702" - )[::-1]), x=q_ind[0], y=q_ind[1]), + ), "little"), x=q_ind[0], y=q_ind[1]), ( 0x7D03E65B8050D1E12CBB601A17B9273B0E728F5021CD47C8A4DD822E4627BA5F9C696286A2CDDA9A065509866B4DEDEDC4A118409604AD549F87A60AFA621161, 0x16037DAD45421EC50B00D50BDC6AC3B85348BC1D3A2F85DB27C3373580FEF87C2C743B7ED30F22BE22958044E716F93A61CA3213A361A2797A16A3AE62957377, @@ -441,9 +439,9 @@ 0xB51ADF93A40AB15792164FAD3352F95B66369EB2A4EF5EFAE32829320363350E, 0x74A358CC08593612F5955D249C96AFB7E8B0BB6D8BD2BBE491046650D822BE18, ) self.assertEqual( - c.exp(bytes2long(hexdec( + c.exp(int.from_bytes(hexdec( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F18127067" - )[::-1]), x=q_ind[0], y=q_ind[1]), + ), "little"), x=q_ind[0], y=q_ind[1]), ( 0xDBF99827078956812FA48C6E695DF589DEF1D18A2D4D35A96D75BF6854237629, 0x9FDDD48BFBC57BEE1DA0CFF282884F284D471B388893C48F5ECB02FC18D67589, @@ -471,9 +469,9 @@ 0x489C91784E02E98F19A803ABCA319917F37689E5A18965251CE2FF4E8D8B298F5BA7470F9E0E713487F96F4A8397B3D09A270C9D367EB5E0E6561ADEEB51581D, 0x684EA885ACA64EAF1B3FEE36C0852A3BE3BD8011B0EF18E203FF87028D6EB5DB2C144A0DCC71276542BFD72CA2A43FA4F4939DA66D9A60793C704A8C94E16F18, ) self.assertEqual( - c.exp(bytes2long(hexdec( + c.exp(int.from_bytes(hexdec( "BD04673F7149B18E98155BD1E2724E71D0099AA25174F792D3326C6F181270671C6213E3930EFDDA26451792C6208122EE60D200520D695DFD9F5F0FD5ABA702" - )[::-1]), x=q_ind[0], y=q_ind[1]), + ), "little"), x=q_ind[0], y=q_ind[1]), ( 0x0185AE6271A81BB7F236A955F7CAA26FB63849813C0287D96C83A15AE6B6A86467AB13B6D88CE8CD7DC2E5B97FF5F28FAC2C108F2A3CF3DB5515C9E6D7D210E8, 0xED0220F92EF771A71C64ECC77986DB7C03D37B3E2AB3E83F32CE5E074A762EC08253C9E2102B87532661275C4B1D16D2789CDABC58ACFDF7318DE70AB64F09B8, diff --git a/pygost/test_gost3410_vko.py b/pygost/test_gost3410_vko.py index 38920df50ea8587ffa67d12ece847407b402467f2c1dff9ab96cff076a78060b..504771beda80c671c14f317f98366820b641604aecd444c317d8290634ca0771 100644 --- a/pygost/test_gost3410_vko.py +++ b/pygost/test_gost3410_vko.py @@ -25,7 +25,6 @@ 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 bytes2long from pygost.utils import hexdec @@ -45,8 +44,8 @@ def test_sequence(self): curve = CURVES["id-GostR3410-2001-TestParamSet"] for _ in range(10): ukm = ukm_unmarshal(urandom(8)) - prv1 = bytes2long(urandom(32)) - prv2 = bytes2long(urandom(32)) + prv1 = int.from_bytes(urandom(32), "big") + prv2 = int.from_bytes(urandom(32), "big") pub1 = public_key(curve, prv1) pub2 = public_key(curve, prv2) kek1 = kek_34102001(curve, prv1, pub2, ukm) @@ -75,8 +74,8 @@ def test_sequence(self): curve = CURVES["id-tc26-gost-3410-2012-256-paramSetA"] for _ in range(10): ukm = ukm_unmarshal(urandom(8)) - prv1 = bytes2long(urandom(32)) - prv2 = bytes2long(urandom(32)) + prv1 = int.from_bytes(urandom(32), "big") + prv2 = int.from_bytes(urandom(32), "big") pub1 = public_key(curve, prv1) pub2 = public_key(curve, prv2) kek1 = kek_34102012256(curve, prv1, pub2, ukm) @@ -90,7 +89,7 @@ def test_pub_is_not_on_curve(self): with self.assertRaises(ValueError): kek_34102012256( CURVES["id-tc26-gost-3410-2012-256-paramSetA"], - bytes2long(urandom(32)), + int.from_bytes(urandom(32), "big"), pub_unmarshal(urandom(64)), ) @@ -113,8 +112,8 @@ def test_sequence(self): curve = CURVES["id-tc26-gost-3410-12-512-paramSetA"] for _ in range(10): ukm = ukm_unmarshal(urandom(8)) - prv1 = bytes2long(urandom(32)) - prv2 = bytes2long(urandom(32)) + prv1 = int.from_bytes(urandom(32), "big") + prv2 = int.from_bytes(urandom(32), "big") pub1 = public_key(curve, prv1) pub2 = public_key(curve, prv2) kek1 = kek_34102012512(curve, prv1, pub2, ukm) diff --git a/pygost/test_sespake.py b/pygost/test_sespake.py index 7154c0a4520ae3e804c971110fc48377c046086e7afab96904e1ff85f541cd30..1e18aae3824799c3e20aea4d1f874a1e8ec3c0fd1adbbeda42595cf4b9887e27 100644 --- a/pygost/test_sespake.py +++ b/pygost/test_sespake.py @@ -24,10 +24,8 @@ from pygost import gost34112012512 from pygost import sespake from pygost.gost3410 import CURVES from pygost.pbkdf2 import pbkdf2 -from pygost.utils import bytes2long from pygost.utils import hexdec from pygost.utils import hexenc -from pygost.utils import long2bytes class TestQs(TestCase): @@ -221,15 +219,15 @@ def generateQs(p, point_size, a, b, q, cofactor, Px, Py): seed = 0 while True: hashSrc = ( - long2bytes(Px, point_size)[::-1] + - long2bytes(Py, point_size)[::-1] + - long2bytes(seed, 4)[::-1] + Px.to_bytes(point_size, "little") + + Py.to_bytes(point_size, "little") + + seed.to_bytes(4, "little") ) if point_size == 32: QxRaw = gost34112012256.new(hashSrc).digest() else: QxRaw = gost34112012512.new(hashSrc).digest() - Qx = bytes2long(QxRaw[::-1]) % p + Qx = int.from_bytes(QxRaw, "little") % p R = addF(addF(powF(Qx, 3, p), mulF(Qx, a, p), p), b, p) if (R == 0) or not isQuadraticResidue( R, p ): seed += 1 @@ -320,43 +318,43 @@ macBExpected, ): curve = CURVES[curveName] q = sespake.Qs[curveName] - qpw = curve.exp(bytes2long(self.fpw[:curve.point_size][::-1]), q[0], q[1]) - self.assertSequenceEqual(hexenc(long2bytes(qpw[0])), qpwExpected[0]) - self.assertSequenceEqual(hexenc(long2bytes(qpw[1])), qpwExpected[1]) + 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]) alphaP = curve.exp(alpha) - self.assertSequenceEqual(hexenc(long2bytes(alphaP[0])), alphaPExpected[0]) - self.assertSequenceEqual(hexenc(long2bytes(alphaP[1])), alphaPExpected[1]) + 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]) tmp = curve.exp(curve.q-1, qpw[0], qpw[1]) u1 = curve._add(alphaP[0], alphaP[1], tmp[0], tmp[1]) - self.assertSequenceEqual(hexenc(long2bytes(u1[0])), u1Expected[0]) - self.assertSequenceEqual(hexenc(long2bytes(u1[1])), u1Expected[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.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(long2bytes(tmp[0])[::-1]), kBSrcExpected[0]) - self.assertSequenceEqual(hexenc(long2bytes(tmp[1])[::-1]), kBSrcExpected[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]) kB = gost34112012256.new( - long2bytes(tmp[0], curve.point_size)[::-1] + - long2bytes(tmp[1], curve.point_size)[::-1] + tmp[0].to_bytes(curve.point_size, "little") + + tmp[1].to_bytes(curve.point_size, "little") ).digest() self.assertSequenceEqual(hexenc(kB), kBExpected) betaP = curve.exp(beta) - self.assertSequenceEqual(hexenc(long2bytes(betaP[0])), betaPExpected[0]) - self.assertSequenceEqual(hexenc(long2bytes(betaP[1])), betaPExpected[1]) + 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]) u2 = curve._add(betaP[0], betaP[1], qpw[0], qpw[1]) - self.assertSequenceEqual(hexenc(long2bytes(u2[0])), u2Expected[0]) - self.assertSequenceEqual(hexenc(long2bytes(u2[1])), u2Expected[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.assertTrue(curve.contains(u2)) tmp = curve.exp(curve.q-1, qpw[0], qpw[1]) qA = curve._add(u2[0], u2[1], tmp[0], tmp[1]) tmp = curve.exp((curve.cofactor * alpha) % curve.q, qA[0], qA[1]) kA = gost34112012256.new( - long2bytes(tmp[0], curve.point_size)[::-1] + - long2bytes(tmp[1], curve.point_size)[::-1] + tmp[0].to_bytes(curve.point_size, "little") + + tmp[1].to_bytes(curve.point_size, "little") ).digest() self.assertEqual(kA, kB) @@ -364,10 +362,10 @@ macA = hmac.new( key=kA, msg=b"".join(( b"\x01", self.idA, b"\x01", self.salt, - long2bytes(u1[0], curve.point_size)[::-1], - long2bytes(u1[1], curve.point_size)[::-1], - long2bytes(u2[0], curve.point_size)[::-1], - long2bytes(u2[1], curve.point_size)[::-1], + u1[0].to_bytes(curve.point_size, "little"), + u1[1].to_bytes(curve.point_size, "little"), + u2[0].to_bytes(curve.point_size, "little"), + u2[1].to_bytes(curve.point_size, "little"), )), digestmod=gost34112012256, ).digest() @@ -377,10 +375,10 @@ macB = hmac.new( key=kB, msg=b"".join(( b"\x02", self.idB, b"\x01", self.salt, - long2bytes(u1[0], curve.point_size)[::-1], - long2bytes(u1[1], curve.point_size)[::-1], - long2bytes(u2[0], curve.point_size)[::-1], - long2bytes(u2[1], curve.point_size)[::-1], + u1[0].to_bytes(curve.point_size, "little"), + u1[1].to_bytes(curve.point_size, "little"), + u2[0].to_bytes(curve.point_size, "little"), + u2[1].to_bytes(curve.point_size, "little"), )), digestmod=gost34112012256, ).digest() @@ -419,8 +417,8 @@ self.idB, fpw=self.fpw, alpha=alpha, ) - self.assertSequenceEqual(hexenc(long2bytes(a.u1[0])), u1Expected[0]) - self.assertSequenceEqual(hexenc(long2bytes(a.u1[1])), u1Expected[1]) + 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]) b = sespake.B( curve, q, @@ -431,8 +429,8 @@ salt=self.salt, fpw=self.fpw, ) u2 = b.ka(a.u1, beta=beta) - self.assertSequenceEqual(hexenc(long2bytes(u2[0])), u2Expected[0]) - self.assertSequenceEqual(hexenc(long2bytes(u2[1])), u2Expected[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]) macA = a.ka(u2) self.assertSequenceEqual(hexenc(macA), macAExpected) macB = b.kc(macA) diff --git a/pygost/utils.py b/pygost/utils.py index 49743f6e82d74b329143506b61a9d56ba858d81a6139daf6017edc60a229dcee..61e68cd07ceb5e73df454693f275ffbb35f9370f47c0059e3cc2205cc307762f 100644 --- a/pygost/utils.py +++ b/pygost/utils.py @@ -51,32 +51,6 @@ """ return _hexencoder(data)[0].decode("ascii") -def bytes2long(raw): - """Deserialize big-endian bytes into long number - - :param bytes raw: binary string - :returns: deserialized long number - :rtype: int - """ - return int(hexenc(raw), 16) - - -def long2bytes(n, size=32): - """Serialize long number into big-endian bytestring - - :param long n: long number - :returns: serialized bytestring - :rtype: bytes - """ - res = hex(int(n))[2:].rstrip("L") - if len(res) % 2 != 0: - res = "0" + res - s = hexdec(res) - if len(s) != size: - s = (size - len(s)) * b"\x00" + s - return s - - def modinvert(a, n): """Modular multiplicative inverse diff --git a/setup.py b/setup.py index f66744c6c3b62d279886a8cb5e8a8738e1a7dff2f5dd0e688656cecd556fb7dc..0be8d247b0b393d2ca703e7c7b62554fc8c51397964e902e1cae35b50708fe0e 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ from setuptools import setup setup( name="pygost", - version="5.14", + version="6.0", description="Pure Python GOST cryptographic functions library", long_description=open("README", "rb").read().decode("utf-8"), author="Sergey Matveev", @@ -15,17 +15,13 @@ "Intended Audience :: Developers", "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", "Natural Language :: English", "Operating System :: OS Independent", - "Programming Language :: Python :: 2", "Programming Language :: Python :: 3", "Topic :: Security :: Cryptography", "Topic :: Software Development :: Libraries :: Python Modules", ], packages=["pygost", "pygost.asn1schemas"], - package_data={ - "pygost": ["stubs/**/*.pyi"], - }, data_files=( ("", ("AUTHORS", "COPYING", "FAQ", "INSTALL", "NEWS", "README", "THANKS")), ), - tests_require=["pyderasn~=8.1"], + tests_require=["pyderasn~=9.3"], )