Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/cryptography/hazmat/primitives/ciphers/algorithms.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 

7from cryptography import utils 

8from cryptography.hazmat.primitives.ciphers import ( 

9 BlockCipherAlgorithm, 

10 CipherAlgorithm, 

11) 

12 

13 

14def _verify_key_size(algorithm: CipherAlgorithm, key: bytes) -> bytes: 

15 # Verify that the key is instance of bytes 

16 utils._check_byteslike("key", key) 

17 

18 # Verify that the key size matches the expected key size 

19 if len(key) * 8 not in algorithm.key_sizes: 

20 raise ValueError( 

21 "Invalid key size ({}) for {}.".format( 

22 len(key) * 8, algorithm.name 

23 ) 

24 ) 

25 return key 

26 

27 

28class AES(BlockCipherAlgorithm): 

29 name = "AES" 

30 block_size = 128 

31 # 512 added to support AES-256-XTS, which uses 512-bit keys 

32 key_sizes = frozenset([128, 192, 256, 512]) 

33 

34 def __init__(self, key: bytes): 

35 self.key = _verify_key_size(self, key) 

36 

37 @property 

38 def key_size(self) -> int: 

39 return len(self.key) * 8 

40 

41 

42class AES128(BlockCipherAlgorithm): 

43 name = "AES" 

44 block_size = 128 

45 key_sizes = frozenset([128]) 

46 key_size = 128 

47 

48 def __init__(self, key: bytes): 

49 self.key = _verify_key_size(self, key) 

50 

51 

52class AES256(BlockCipherAlgorithm): 

53 name = "AES" 

54 block_size = 128 

55 key_sizes = frozenset([256]) 

56 key_size = 256 

57 

58 def __init__(self, key: bytes): 

59 self.key = _verify_key_size(self, key) 

60 

61 

62class Camellia(BlockCipherAlgorithm): 

63 name = "camellia" 

64 block_size = 128 

65 key_sizes = frozenset([128, 192, 256]) 

66 

67 def __init__(self, key: bytes): 

68 self.key = _verify_key_size(self, key) 

69 

70 @property 

71 def key_size(self) -> int: 

72 return len(self.key) * 8 

73 

74 

75class TripleDES(BlockCipherAlgorithm): 

76 name = "3DES" 

77 block_size = 64 

78 key_sizes = frozenset([64, 128, 192]) 

79 

80 def __init__(self, key: bytes): 

81 if len(key) == 8: 

82 key += key + key 

83 elif len(key) == 16: 

84 key += key[:8] 

85 self.key = _verify_key_size(self, key) 

86 

87 @property 

88 def key_size(self) -> int: 

89 return len(self.key) * 8 

90 

91 

92class Blowfish(BlockCipherAlgorithm): 

93 name = "Blowfish" 

94 block_size = 64 

95 key_sizes = frozenset(range(32, 449, 8)) 

96 

97 def __init__(self, key: bytes): 

98 self.key = _verify_key_size(self, key) 

99 

100 @property 

101 def key_size(self) -> int: 

102 return len(self.key) * 8 

103 

104 

105_BlowfishInternal = Blowfish 

106utils.deprecated( 

107 Blowfish, 

108 __name__, 

109 "Blowfish has been deprecated", 

110 utils.DeprecatedIn37, 

111 name="Blowfish", 

112) 

113 

114 

115class CAST5(BlockCipherAlgorithm): 

116 name = "CAST5" 

117 block_size = 64 

118 key_sizes = frozenset(range(40, 129, 8)) 

119 

120 def __init__(self, key: bytes): 

121 self.key = _verify_key_size(self, key) 

122 

123 @property 

124 def key_size(self) -> int: 

125 return len(self.key) * 8 

126 

127 

128_CAST5Internal = CAST5 

129utils.deprecated( 

130 CAST5, 

131 __name__, 

132 "CAST5 has been deprecated", 

133 utils.DeprecatedIn37, 

134 name="CAST5", 

135) 

136 

137 

138class ARC4(CipherAlgorithm): 

139 name = "RC4" 

140 key_sizes = frozenset([40, 56, 64, 80, 128, 160, 192, 256]) 

141 

142 def __init__(self, key: bytes): 

143 self.key = _verify_key_size(self, key) 

144 

145 @property 

146 def key_size(self) -> int: 

147 return len(self.key) * 8 

148 

149 

150class IDEA(BlockCipherAlgorithm): 

151 name = "IDEA" 

152 block_size = 64 

153 key_sizes = frozenset([128]) 

154 

155 def __init__(self, key: bytes): 

156 self.key = _verify_key_size(self, key) 

157 

158 @property 

159 def key_size(self) -> int: 

160 return len(self.key) * 8 

161 

162 

163_IDEAInternal = IDEA 

164utils.deprecated( 

165 IDEA, 

166 __name__, 

167 "IDEA has been deprecated", 

168 utils.DeprecatedIn37, 

169 name="IDEA", 

170) 

171 

172 

173class SEED(BlockCipherAlgorithm): 

174 name = "SEED" 

175 block_size = 128 

176 key_sizes = frozenset([128]) 

177 

178 def __init__(self, key: bytes): 

179 self.key = _verify_key_size(self, key) 

180 

181 @property 

182 def key_size(self) -> int: 

183 return len(self.key) * 8 

184 

185 

186_SEEDInternal = SEED 

187utils.deprecated( 

188 SEED, 

189 __name__, 

190 "SEED has been deprecated", 

191 utils.DeprecatedIn37, 

192 name="SEED", 

193) 

194 

195 

196class ChaCha20(CipherAlgorithm): 

197 name = "ChaCha20" 

198 key_sizes = frozenset([256]) 

199 

200 def __init__(self, key: bytes, nonce: bytes): 

201 self.key = _verify_key_size(self, key) 

202 utils._check_byteslike("nonce", nonce) 

203 

204 if len(nonce) != 16: 

205 raise ValueError("nonce must be 128-bits (16 bytes)") 

206 

207 self._nonce = nonce 

208 

209 @property 

210 def nonce(self) -> bytes: 

211 return self._nonce 

212 

213 @property 

214 def key_size(self) -> int: 

215 return len(self.key) * 8 

216 

217 

218class SM4(BlockCipherAlgorithm): 

219 name = "SM4" 

220 block_size = 128 

221 key_sizes = frozenset([128]) 

222 

223 def __init__(self, key: bytes): 

224 self.key = _verify_key_size(self, key) 

225 

226 @property 

227 def key_size(self) -> int: 

228 return len(self.key) * 8