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

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 Ed448PublicKey(metaclass=abc.ABCMeta): 

16 @classmethod 

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

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

19 

20 if not backend.ed448_supported(): 

21 raise UnsupportedAlgorithm( 

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

23 _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, 

24 ) 

25 

26 return rust_openssl.ed448.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) -> Ed448PublicKey: 

59 """ 

60 Returns a copy. 

61 """ 

62 

63 

64if hasattr(rust_openssl, "ed448"): 

65 Ed448PublicKey.register(rust_openssl.ed448.Ed448PublicKey) 

66 

67 

68class Ed448PrivateKey(metaclass=abc.ABCMeta): 

69 @classmethod 

70 def generate(cls) -> Ed448PrivateKey: 

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

72 

73 if not backend.ed448_supported(): 

74 raise UnsupportedAlgorithm( 

75 "ed448 is not supported by this version of OpenSSL.", 

76 _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, 

77 ) 

78 

79 return rust_openssl.ed448.generate_key() 

80 

81 @classmethod 

82 def from_private_bytes(cls, data: Buffer) -> Ed448PrivateKey: 

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

84 

85 if not backend.ed448_supported(): 

86 raise UnsupportedAlgorithm( 

87 "ed448 is not supported by this version of OpenSSL.", 

88 _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, 

89 ) 

90 

91 return rust_openssl.ed448.from_private_bytes(data) 

92 

93 @abc.abstractmethod 

94 def public_key(self) -> Ed448PublicKey: 

95 """ 

96 The Ed448PublicKey derived from the private key. 

97 """ 

98 

99 @abc.abstractmethod 

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

101 """ 

102 Signs the data. 

103 """ 

104 

105 @abc.abstractmethod 

106 def private_bytes( 

107 self, 

108 encoding: _serialization.Encoding, 

109 format: _serialization.PrivateFormat, 

110 encryption_algorithm: _serialization.KeySerializationEncryption, 

111 ) -> bytes: 

112 """ 

113 The serialized bytes of the private key. 

114 """ 

115 

116 @abc.abstractmethod 

117 def private_bytes_raw(self) -> bytes: 

118 """ 

119 The raw bytes of the private key. 

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

121 """ 

122 

123 @abc.abstractmethod 

124 def __copy__(self) -> Ed448PrivateKey: 

125 """ 

126 Returns a copy. 

127 """ 

128 

129 

130if hasattr(rust_openssl, "x448"): 

131 Ed448PrivateKey.register(rust_openssl.ed448.Ed448PrivateKey)