Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/starkbank_ecdsa-2.3.1-py3.11.egg/ellipticcurve/privateKey.py: 91%

1from .math import Math 

2from .utils.integer import RandomInteger 

3from .utils.pem import getPemContent, createPem 

4from .utils.binary import hexFromByteString, byteStringFromHex, intFromHex, base64FromByteString, byteStringFromBase64 

5from .utils.der import hexFromInt, parse, encodeConstructed, DerFieldType, encodePrimitive 

6from .curve import secp256k1, getByOid 

7from .publicKey import PublicKey 

8 

9 

10class PrivateKey: 

11 

12 def __init__(self, curve=secp256k1, secret=None): 

13 self.curve = curve 

14 self.secret = secret or RandomInteger.between(1, curve.N - 1) 

15 if not 1 <= self.secret <= curve.N - 1: 

16 raise Exception("Secret must be in range [1, N-1] for curve {name}".format(name=curve.name)) 

17 

18 def publicKey(self): 

19 curve = self.curve 

20 publicPoint = Math.multiply( 

21 p=curve.G, 

22 n=self.secret, 

23 N=curve.N, 

24 A=curve.A, 

25 P=curve.P, 

26 ) 

27 return PublicKey(point=publicPoint, curve=curve) 

28 

29 def toString(self): 

30 return hexFromInt(self.secret) 

31 

32 def toDer(self): 

33 publicKeyString = self.publicKey().toString(encoded=True) 

34 hexadecimal = encodeConstructed( 

35 encodePrimitive(DerFieldType.integer, 1), 

36 encodePrimitive(DerFieldType.octetString, hexFromInt(self.secret)), 

37 encodePrimitive(DerFieldType.oidContainer, encodePrimitive(DerFieldType.object, self.curve.oid)), 

38 encodePrimitive(DerFieldType.publicKeyPointContainer, encodePrimitive(DerFieldType.bitString, publicKeyString)) 

39 ) 

40 return byteStringFromHex(hexadecimal) 

41 

42 def toPem(self): 

43 der = self.toDer() 

44 return createPem(content=base64FromByteString(der), template=_pemTemplate) 

45 

46 @classmethod 

47 def fromPem(cls, string): 

48 privateKeyPem = getPemContent(pem=string, template=_pemTemplate) 

49 return cls.fromDer(byteStringFromBase64(privateKeyPem)) 

50 

51 @classmethod 

52 def fromDer(cls, string): 

53 hexadecimal = hexFromByteString(string) 

54 privateKeyFlag, secretHex, curveData, publicKeyString = parse(hexadecimal)[0] 

55 if privateKeyFlag != 1: 

56 raise Exception("Private keys should start with a '1' flag, but a '{flag}' was found instead".format( 

57 flag=privateKeyFlag 

58 )) 

59 curve = getByOid(curveData[0]) 

60 privateKey = cls.fromString(string=secretHex, curve=curve) 

61 if privateKey.publicKey().toString(encoded=True) != publicKeyString[0]: 

62 raise Exception("The public key described inside the private key file doesn't match the actual public key of the pair") 

63 return privateKey 

64 

65 @classmethod 

66 def fromString(cls, string, curve=secp256k1): 

67 return PrivateKey(secret=intFromHex(string), curve=curve) 

68 

69 

70_pemTemplate = """ 

71-----BEGIN EC PRIVATE KEY----- 

72{content} 

73-----END EC PRIVATE KEY----- 

74"""