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 

5 

6from cryptography import utils 

7from cryptography.hazmat.primitives.ciphers import ( 

8 BlockCipherAlgorithm, 

9 CipherAlgorithm, 

10) 

11 

12 

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

14 # Verify that the key is instance of bytes 

15 utils._check_byteslike("key", key) 

16 

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

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

19 raise ValueError( 

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

21 len(key) * 8, algorithm.name 

22 ) 

23 ) 

24 return key 

25 

26 

27class AES(CipherAlgorithm, BlockCipherAlgorithm): 

28 name = "AES" 

29 block_size = 128 

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

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

32 

33 def __init__(self, key: bytes): 

34 self.key = _verify_key_size(self, key) 

35 

36 @property 

37 def key_size(self) -> int: 

38 return len(self.key) * 8 

39 

40 

41class AES128(CipherAlgorithm, BlockCipherAlgorithm): 

42 name = "AES" 

43 block_size = 128 

44 key_sizes = frozenset([128]) 

45 key_size = 128 

46 

47 def __init__(self, key: bytes): 

48 self.key = _verify_key_size(self, key) 

49 

50 

51class AES256(CipherAlgorithm, BlockCipherAlgorithm): 

52 name = "AES" 

53 block_size = 128 

54 key_sizes = frozenset([256]) 

55 key_size = 256 

56 

57 def __init__(self, key: bytes): 

58 self.key = _verify_key_size(self, key) 

59 

60 

61class Camellia(CipherAlgorithm, BlockCipherAlgorithm): 

62 name = "camellia" 

63 block_size = 128 

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

65 

66 def __init__(self, key: bytes): 

67 self.key = _verify_key_size(self, key) 

68 

69 @property 

70 def key_size(self) -> int: 

71 return len(self.key) * 8 

72 

73 

74class TripleDES(CipherAlgorithm, BlockCipherAlgorithm): 

75 name = "3DES" 

76 block_size = 64 

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

78 

79 def __init__(self, key: bytes): 

80 if len(key) == 8: 

81 key += key + key 

82 elif len(key) == 16: 

83 key += key[:8] 

84 self.key = _verify_key_size(self, key) 

85 

86 @property 

87 def key_size(self) -> int: 

88 return len(self.key) * 8 

89 

90 

91class Blowfish(CipherAlgorithm, BlockCipherAlgorithm): 

92 name = "Blowfish" 

93 block_size = 64 

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

95 

96 def __init__(self, key: bytes): 

97 self.key = _verify_key_size(self, key) 

98 

99 @property 

100 def key_size(self) -> int: 

101 return len(self.key) * 8 

102 

103 

104_BlowfishInternal = Blowfish 

105utils.deprecated( 

106 Blowfish, 

107 __name__, 

108 "Blowfish has been deprecated", 

109 utils.DeprecatedIn37, 

110 name="Blowfish", 

111) 

112 

113 

114class CAST5(CipherAlgorithm, BlockCipherAlgorithm): 

115 name = "CAST5" 

116 block_size = 64 

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

118 

119 def __init__(self, key: bytes): 

120 self.key = _verify_key_size(self, key) 

121 

122 @property 

123 def key_size(self) -> int: 

124 return len(self.key) * 8 

125 

126 

127_CAST5Internal = CAST5 

128utils.deprecated( 

129 CAST5, 

130 __name__, 

131 "CAST5 has been deprecated", 

132 utils.DeprecatedIn37, 

133 name="CAST5", 

134) 

135 

136 

137class ARC4(CipherAlgorithm): 

138 name = "RC4" 

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

140 

141 def __init__(self, key: bytes): 

142 self.key = _verify_key_size(self, key) 

143 

144 @property 

145 def key_size(self) -> int: 

146 return len(self.key) * 8 

147 

148 

149class IDEA(CipherAlgorithm, BlockCipherAlgorithm): 

150 name = "IDEA" 

151 block_size = 64 

152 key_sizes = frozenset([128]) 

153 

154 def __init__(self, key: bytes): 

155 self.key = _verify_key_size(self, key) 

156 

157 @property 

158 def key_size(self) -> int: 

159 return len(self.key) * 8 

160 

161 

162_IDEAInternal = IDEA 

163utils.deprecated( 

164 IDEA, 

165 __name__, 

166 "IDEA has been deprecated", 

167 utils.DeprecatedIn37, 

168 name="IDEA", 

169) 

170 

171 

172class SEED(CipherAlgorithm, BlockCipherAlgorithm): 

173 name = "SEED" 

174 block_size = 128 

175 key_sizes = frozenset([128]) 

176 

177 def __init__(self, key: bytes): 

178 self.key = _verify_key_size(self, key) 

179 

180 @property 

181 def key_size(self) -> int: 

182 return len(self.key) * 8 

183 

184 

185_SEEDInternal = SEED 

186utils.deprecated( 

187 SEED, 

188 __name__, 

189 "SEED has been deprecated", 

190 utils.DeprecatedIn37, 

191 name="SEED", 

192) 

193 

194 

195class ChaCha20(CipherAlgorithm): 

196 name = "ChaCha20" 

197 key_sizes = frozenset([256]) 

198 

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

200 self.key = _verify_key_size(self, key) 

201 utils._check_byteslike("nonce", nonce) 

202 

203 if len(nonce) != 16: 

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

205 

206 self._nonce = nonce 

207 

208 @property 

209 def nonce(self) -> bytes: 

210 return self._nonce 

211 

212 @property 

213 def key_size(self) -> int: 

214 return len(self.key) * 8 

215 

216 

217class SM4(CipherAlgorithm, BlockCipherAlgorithm): 

218 name = "SM4" 

219 block_size = 128 

220 key_sizes = frozenset([128]) 

221 

222 def __init__(self, key: bytes): 

223 self.key = _verify_key_size(self, key) 

224 

225 @property 

226 def key_size(self) -> int: 

227 return len(self.key) * 8