X-Git-Url: http://www.git.cypherpunks.ru/?a=blobdiff_plain;f=pygost%2Fgost3410.py;h=50f3d00b0e05e02f25eabe9d6047cc5b1349a87c;hb=cf0e4b011863b11ccaba5fbcd9566cafbd130398;hp=8ef068f650a46bdf31739adc30e297571711799b;hpb=282cb5e23df11f9d5e3c29185f0e6c72f038f731;p=pygost.git

diff --git a/pygost/gost3410.py b/pygost/gost3410.py
index 8ef068f..50f3d00 100644
--- a/pygost/gost3410.py
+++ b/pygost/gost3410.py
@@ -1,6 +1,6 @@
 # coding: utf-8
 # PyGOST -- Pure Python GOST cryptographic functions library
-# Copyright (C) 2015-2016 Sergey Matveev <stargrave@stargrave.org>
+# Copyright (C) 2015-2018 Sergey Matveev <stargrave@stargrave.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -29,11 +29,9 @@ from pygost.utils import long2bytes
 from pygost.utils import modinvert
 
 
-SIZE_3410_2001 = 32
-SIZE_3410_2012 = 64
 MODE2SIZE = {
-    2001: SIZE_3410_2001,
-    2012: SIZE_3410_2012,
+    2001: 32,
+    2012: 64,
 }
 
 
@@ -122,10 +120,10 @@ class GOST3410Curve(object):
 
     >>> p, q, a, b, x, y = CURVE_PARAMS["GostR3410_2001_TestParamSet"]
     >>> curve = GOST3410Curve(p, q, a, b, x, y)
-    >>> priv = bytes2long(urandom(32))
-    >>> signature = sign(curve, priv, GOST341194(data).digest())
-    >>> pubX, pubY = public_key(curve, priv)
-    >>> verify(curve, pubX, pubY, GOST341194(data).digest(), signature)
+    >>> prv = prv_unmarshal(urandom(32))
+    >>> signature = sign(curve, prv, GOST341194(data).digest())
+    >>> pub = public_key(curve, prv)
+    >>> verify(curve, pub, GOST341194(data).digest(), signature)
     True
     """
     def __init__(self, p, q, a, b, x, y):
@@ -164,9 +162,9 @@ class GOST3410Curve(object):
         y = y or self.y
         tx = x
         ty = y
-        degree -= 1
         if degree == 0:
             raise ValueError("Bad degree value")
+        degree -= 1
         while degree != 0:
             if degree & 1 == 1:
                 tx, ty = self._add(tx, ty, x, y)
@@ -175,31 +173,28 @@ class GOST3410Curve(object):
         return tx, ty
 
 
-def public_key(curve, private_key):
+def public_key(curve, prv):
     """ Generate public key from the private one
 
     :param GOST3410Curve curve: curve to use
-    :param long private_key: private key
-    :return: public key's parts, X and Y
+    :param long prv: private key
+    :returns: public key's parts, X and Y
     :rtype: (long, long)
     """
-    return curve.exp(private_key)
+    return curve.exp(prv)
 
 
-def sign(curve, private_key, digest, size=SIZE_3410_2001):
+def sign(curve, prv, digest, mode=2001):
     """ Calculate signature for provided digest
 
     :param GOST3410Curve curve: curve to use
-    :param long private_key: private key
+    :param long prv: private key
     :param digest: digest for signing
     :type digest: bytes, 32 or 64 bytes
-    :param size: signature size
-    :type size: 32 (for 34.10-2001) or 64 (for 34.10-2012)
-    :return: signature
+    :returns: signature
     :rtype: bytes, 64 or 128 bytes
     """
-    if len(digest) != size:
-        raise ValueError("Invalid digest length")
+    size = MODE2SIZE[mode]
     q = curve.q
     e = bytes2long(digest) % q
     if e == 0:
@@ -212,7 +207,7 @@ def sign(curve, private_key, digest, size=SIZE_3410_2001):
         r %= q
         if r == 0:
             continue
-        d = private_key * r
+        d = prv * r
         k *= e
         s = (d + k) % q
         if s == 0:
@@ -221,22 +216,18 @@ def sign(curve, private_key, digest, size=SIZE_3410_2001):
     return long2bytes(s, size) + long2bytes(r, size)
 
 
-def verify(curve, pubkeyX, pubkeyY, digest, signature, size=SIZE_3410_2001):
+def verify(curve, pub, digest, signature, mode=2001):
     """ Verify provided digest with the signature
 
     :param GOST3410Curve curve: curve to use
-    :param long pubkeyX: public key's X
-    :param long pubkeyY: public key's Y
+    :type pub: (long, long)
     :param digest: digest needed to check
     :type digest: bytes, 32 or 64 bytes
     :param signature: signature to verify with
     :type signature: bytes, 64 or 128 bytes
-    :param size: signature size
-    :type size: 32 (for 34.10-2001) or 64 (for 34.10-2012)
     :rtype: bool
     """
-    if len(digest) != size:
-        raise ValueError("Invalid digest length")
+    size = MODE2SIZE[mode]
     if len(signature) != size * 2:
         raise ValueError("Invalid signature length")
     q = curve.q
@@ -252,7 +243,7 @@ def verify(curve, pubkeyX, pubkeyY, digest, signature, size=SIZE_3410_2001):
     z1 = s * v % q
     z2 = q - r * v % q
     p1x, p1y = curve.exp(z1)
-    q1x, q1y = curve.exp(z2, pubkeyX, pubkeyY)
+    q1x, q1y = curve.exp(z2, pub[0], pub[1])
     lm = q1x - p1x
     if lm < 0:
         lm += p
@@ -269,13 +260,13 @@ def verify(curve, pubkeyX, pubkeyY, digest, signature, size=SIZE_3410_2001):
     return lm == r
 
 
-def prv_unmarshal(private_key):
+def prv_unmarshal(prv):
     """Unmarshal private key
 
-    :param bytes private_key: serialized private key
+    :param bytes prv: serialized private key
     :rtype: long
     """
-    return bytes2long(private_key[::-1])
+    return bytes2long(prv[::-1])
 
 
 def pub_marshal(pub, mode=2001):
@@ -294,6 +285,6 @@ def pub_unmarshal(pub, mode=2001):
     :type pub: bytes
     :rtype: (long, long)
     """
-    pub = pub[::-1]
     size = MODE2SIZE[mode]
+    pub = pub[::-1]
     return (bytes2long(pub[size:]), bytes2long(pub[:size]))