Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/cryptography/hazmat/primitives/asymmetric/ed25519.py: 73%

1# This file is dual licensed under the terms of the Apache License, Version 

2# 2.0, and the BSD License. See the LICENSE file in the root of this repository 

3# for complete details. 

4 

5from __future__ import annotations 

6 

7import abc 

8 

9from cryptography.exceptions import UnsupportedAlgorithm, _Reasons 

10from cryptography.hazmat.bindings._rust import openssl as rust_openssl 

11from cryptography.hazmat.primitives import _serialization 

12from cryptography.utils import Buffer 

13 

14 

15class Ed25519PublicKey(metaclass=abc.ABCMeta): 

16 @classmethod 

17 def from_public_bytes(cls, data: bytes) -> Ed25519PublicKey: 

18 from cryptography.hazmat.backends.openssl.backend import backend 

19 

20 if not backend.ed25519_supported(): 

21 raise UnsupportedAlgorithm( 

22 "ed25519 is not supported by this version of OpenSSL.", 

23 _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, 

24 ) 

25 

26 return rust_openssl.ed25519.from_public_bytes(data) 

27 

28 @abc.abstractmethod 

29 def public_bytes( 

30 self, 

31 encoding: _serialization.Encoding, 

32 format: _serialization.PublicFormat, 

33 ) -> bytes: 

34 """ 

35 The serialized bytes of the public key. 

36 """ 

37 

38 @abc.abstractmethod 

39 def public_bytes_raw(self) -> bytes: 

40 """ 

41 The raw bytes of the public key. 

42 Equivalent to public_bytes(Raw, Raw). 

43 """ 

44 

45 @abc.abstractmethod 

46 def verify(self, signature: Buffer, data: Buffer) -> None: 

47 """ 

48 Verify the signature. 

49 """ 

50 

51 @abc.abstractmethod 

52 def __eq__(self, other: object) -> bool: 

53 """ 

54 Checks equality. 

55 """ 

56 

57 @abc.abstractmethod 

58 def __copy__(self) -> Ed25519PublicKey: 

59 """ 

60 Returns a copy. 

61 """ 

62 

63 

64Ed25519PublicKey.register(rust_openssl.ed25519.Ed25519PublicKey) 

65 

66 

67class Ed25519PrivateKey(metaclass=abc.ABCMeta): 

68 @classmethod 

69 def generate(cls) -> Ed25519PrivateKey: 

70 from cryptography.hazmat.backends.openssl.backend import backend 

71 

72 if not backend.ed25519_supported(): 

73 raise UnsupportedAlgorithm( 

74 "ed25519 is not supported by this version of OpenSSL.", 

75 _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, 

76 ) 

77 

78 return rust_openssl.ed25519.generate_key() 

79 

80 @classmethod 

81 def from_private_bytes(cls, data: Buffer) -> Ed25519PrivateKey: 

82 from cryptography.hazmat.backends.openssl.backend import backend 

83 

84 if not backend.ed25519_supported(): 

85 raise UnsupportedAlgorithm( 

86 "ed25519 is not supported by this version of OpenSSL.", 

87 _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, 

88 ) 

89 

90 return rust_openssl.ed25519.from_private_bytes(data) 

91 

92 @abc.abstractmethod 

93 def public_key(self) -> Ed25519PublicKey: 

94 """ 

95 The Ed25519PublicKey derived from the private key. 

96 """ 

97 

98 @abc.abstractmethod 

99 def private_bytes( 

100 self, 

101 encoding: _serialization.Encoding, 

102 format: _serialization.PrivateFormat, 

103 encryption_algorithm: _serialization.KeySerializationEncryption, 

104 ) -> bytes: 

105 """ 

106 The serialized bytes of the private key. 

107 """ 

108 

109 @abc.abstractmethod 

110 def private_bytes_raw(self) -> bytes: 

111 """ 

112 The raw bytes of the private key. 

113 Equivalent to private_bytes(Raw, Raw, NoEncryption()). 

114 """ 

115 

116 @abc.abstractmethod 

117 def sign(self, data: Buffer) -> bytes: 

118 """ 

119 Signs the data. 

120 """ 

121 

122 @abc.abstractmethod 

123 def __copy__(self) -> Ed25519PrivateKey: 

124 """ 

125 Returns a copy. 

126 """ 

127 

128 

129Ed25519PrivateKey.register(rust_openssl.ed25519.Ed25519PrivateKey)