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

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

16 @classmethod 

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

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

19 

20 if not backend.x25519_supported(): 

21 raise UnsupportedAlgorithm( 

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

23 _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, 

24 ) 

25 

26 return rust_openssl.x25519.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 __eq__(self, other: object) -> bool: 

47 """ 

48 Checks equality. 

49 """ 

50 

51 @abc.abstractmethod 

52 def __copy__(self) -> X25519PublicKey: 

53 """ 

54 Returns a copy. 

55 """ 

56 

57 

58X25519PublicKey.register(rust_openssl.x25519.X25519PublicKey) 

59 

60 

61class X25519PrivateKey(metaclass=abc.ABCMeta): 

62 @classmethod 

63 def generate(cls) -> X25519PrivateKey: 

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

65 

66 if not backend.x25519_supported(): 

67 raise UnsupportedAlgorithm( 

68 "X25519 is not supported by this version of OpenSSL.", 

69 _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, 

70 ) 

71 return rust_openssl.x25519.generate_key() 

72 

73 @classmethod 

74 def from_private_bytes(cls, data: Buffer) -> X25519PrivateKey: 

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

76 

77 if not backend.x25519_supported(): 

78 raise UnsupportedAlgorithm( 

79 "X25519 is not supported by this version of OpenSSL.", 

80 _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, 

81 ) 

82 

83 return rust_openssl.x25519.from_private_bytes(data) 

84 

85 @abc.abstractmethod 

86 def public_key(self) -> X25519PublicKey: 

87 """ 

88 Returns the public key associated with this private key 

89 """ 

90 

91 @abc.abstractmethod 

92 def private_bytes( 

93 self, 

94 encoding: _serialization.Encoding, 

95 format: _serialization.PrivateFormat, 

96 encryption_algorithm: _serialization.KeySerializationEncryption, 

97 ) -> bytes: 

98 """ 

99 The serialized bytes of the private key. 

100 """ 

101 

102 @abc.abstractmethod 

103 def private_bytes_raw(self) -> bytes: 

104 """ 

105 The raw bytes of the private key. 

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

107 """ 

108 

109 @abc.abstractmethod 

110 def exchange(self, peer_public_key: X25519PublicKey) -> bytes: 

111 """ 

112 Performs a key exchange operation using the provided peer's public key. 

113 """ 

114 

115 @abc.abstractmethod 

116 def __copy__(self) -> X25519PrivateKey: 

117 """ 

118 Returns a copy. 

119 """ 

120 

121 

122X25519PrivateKey.register(rust_openssl.x25519.X25519PrivateKey)