Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/cryptography/hazmat/primitives/asymmetric/dh.py: 62%

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 

8import typing 

9 

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

11from cryptography.hazmat.primitives import _serialization 

12 

13 

14def generate_parameters( 

15 generator: int, key_size: int, backend: typing.Any = None 

16) -> DHParameters: 

17 return rust_openssl.dh.generate_parameters(generator, key_size) 

18 

19 

20class DHParameterNumbers: 

21 def __init__(self, p: int, g: int, q: int | None = None) -> None: 

22 if not isinstance(p, int) or not isinstance(g, int): 

23 raise TypeError("p and g must be integers") 

24 if q is not None and not isinstance(q, int): 

25 raise TypeError("q must be integer or None") 

26 

27 if g < 2: 

28 raise ValueError("DH generator must be 2 or greater") 

29 

30 if p.bit_length() < rust_openssl.dh.MIN_MODULUS_SIZE: 

31 raise ValueError( 

32 f"p (modulus) must be at least " 

33 f"{rust_openssl.dh.MIN_MODULUS_SIZE}-bit" 

34 ) 

35 

36 self._p = p 

37 self._g = g 

38 self._q = q 

39 

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

41 if not isinstance(other, DHParameterNumbers): 

42 return NotImplemented 

43 

44 return ( 

45 self._p == other._p and self._g == other._g and self._q == other._q 

46 ) 

47 

48 def parameters(self, backend: typing.Any = None) -> DHParameters: 

49 return rust_openssl.dh.from_parameter_numbers(self) 

50 

51 @property 

52 def p(self) -> int: 

53 return self._p 

54 

55 @property 

56 def g(self) -> int: 

57 return self._g 

58 

59 @property 

60 def q(self) -> int | None: 

61 return self._q 

62 

63 

64class DHPublicNumbers: 

65 def __init__(self, y: int, parameter_numbers: DHParameterNumbers) -> None: 

66 if not isinstance(y, int): 

67 raise TypeError("y must be an integer.") 

68 

69 if not isinstance(parameter_numbers, DHParameterNumbers): 

70 raise TypeError( 

71 "parameters must be an instance of DHParameterNumbers." 

72 ) 

73 

74 self._y = y 

75 self._parameter_numbers = parameter_numbers 

76 

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

78 if not isinstance(other, DHPublicNumbers): 

79 return NotImplemented 

80 

81 return ( 

82 self._y == other._y 

83 and self._parameter_numbers == other._parameter_numbers 

84 ) 

85 

86 def public_key(self, backend: typing.Any = None) -> DHPublicKey: 

87 return rust_openssl.dh.from_public_numbers(self) 

88 

89 @property 

90 def y(self) -> int: 

91 return self._y 

92 

93 @property 

94 def parameter_numbers(self) -> DHParameterNumbers: 

95 return self._parameter_numbers 

96 

97 

98class DHPrivateNumbers: 

99 def __init__(self, x: int, public_numbers: DHPublicNumbers) -> None: 

100 if not isinstance(x, int): 

101 raise TypeError("x must be an integer.") 

102 

103 if not isinstance(public_numbers, DHPublicNumbers): 

104 raise TypeError( 

105 "public_numbers must be an instance of " "DHPublicNumbers." 

106 ) 

107 

108 self._x = x 

109 self._public_numbers = public_numbers 

110 

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

112 if not isinstance(other, DHPrivateNumbers): 

113 return NotImplemented 

114 

115 return ( 

116 self._x == other._x 

117 and self._public_numbers == other._public_numbers 

118 ) 

119 

120 def private_key(self, backend: typing.Any = None) -> DHPrivateKey: 

121 return rust_openssl.dh.from_private_numbers(self) 

122 

123 @property 

124 def public_numbers(self) -> DHPublicNumbers: 

125 return self._public_numbers 

126 

127 @property 

128 def x(self) -> int: 

129 return self._x 

130 

131 

132class DHParameters(metaclass=abc.ABCMeta): 

133 @abc.abstractmethod 

134 def generate_private_key(self) -> DHPrivateKey: 

135 """ 

136 Generates and returns a DHPrivateKey. 

137 """ 

138 

139 @abc.abstractmethod 

140 def parameter_bytes( 

141 self, 

142 encoding: _serialization.Encoding, 

143 format: _serialization.ParameterFormat, 

144 ) -> bytes: 

145 """ 

146 Returns the parameters serialized as bytes. 

147 """ 

148 

149 @abc.abstractmethod 

150 def parameter_numbers(self) -> DHParameterNumbers: 

151 """ 

152 Returns a DHParameterNumbers. 

153 """ 

154 

155 

156DHParametersWithSerialization = DHParameters 

157DHParameters.register(rust_openssl.dh.DHParameters) 

158 

159 

160class DHPublicKey(metaclass=abc.ABCMeta): 

161 @property 

162 @abc.abstractmethod 

163 def key_size(self) -> int: 

164 """ 

165 The bit length of the prime modulus. 

166 """ 

167 

168 @abc.abstractmethod 

169 def parameters(self) -> DHParameters: 

170 """ 

171 The DHParameters object associated with this public key. 

172 """ 

173 

174 @abc.abstractmethod 

175 def public_numbers(self) -> DHPublicNumbers: 

176 """ 

177 Returns a DHPublicNumbers. 

178 """ 

179 

180 @abc.abstractmethod 

181 def public_bytes( 

182 self, 

183 encoding: _serialization.Encoding, 

184 format: _serialization.PublicFormat, 

185 ) -> bytes: 

186 """ 

187 Returns the key serialized as bytes. 

188 """ 

189 

190 @abc.abstractmethod 

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

192 """ 

193 Checks equality. 

194 """ 

195 

196 

197DHPublicKeyWithSerialization = DHPublicKey 

198DHPublicKey.register(rust_openssl.dh.DHPublicKey) 

199 

200 

201class DHPrivateKey(metaclass=abc.ABCMeta): 

202 @property 

203 @abc.abstractmethod 

204 def key_size(self) -> int: 

205 """ 

206 The bit length of the prime modulus. 

207 """ 

208 

209 @abc.abstractmethod 

210 def public_key(self) -> DHPublicKey: 

211 """ 

212 The DHPublicKey associated with this private key. 

213 """ 

214 

215 @abc.abstractmethod 

216 def parameters(self) -> DHParameters: 

217 """ 

218 The DHParameters object associated with this private key. 

219 """ 

220 

221 @abc.abstractmethod 

222 def exchange(self, peer_public_key: DHPublicKey) -> bytes: 

223 """ 

224 Given peer's DHPublicKey, carry out the key exchange and 

225 return shared key as bytes. 

226 """ 

227 

228 @abc.abstractmethod 

229 def private_numbers(self) -> DHPrivateNumbers: 

230 """ 

231 Returns a DHPrivateNumbers. 

232 """ 

233 

234 @abc.abstractmethod 

235 def private_bytes( 

236 self, 

237 encoding: _serialization.Encoding, 

238 format: _serialization.PrivateFormat, 

239 encryption_algorithm: _serialization.KeySerializationEncryption, 

240 ) -> bytes: 

241 """ 

242 Returns the key serialized as bytes. 

243 """ 

244 

245 

246DHPrivateKeyWithSerialization = DHPrivateKey 

247DHPrivateKey.register(rust_openssl.dh.DHPrivateKey)