Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/cryptography/hazmat/decrepit/ciphers/algorithms.py: 72%

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 warnings 

8 

9from cryptography import utils 

10from cryptography.hazmat.primitives._cipheralgorithm import ( 

11 BlockCipherAlgorithm, 

12 CipherAlgorithm, 

13 _verify_key_size, 

14) 

15 

16 

17class ARC4(CipherAlgorithm): 

18 name = "RC4" 

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

20 

21 def __init__(self, key: bytes): 

22 self.key = _verify_key_size(self, key) 

23 

24 @property 

25 def key_size(self) -> int: 

26 return len(self.key) * 8 

27 

28 

29class TripleDES(BlockCipherAlgorithm): 

30 name = "3DES" 

31 block_size = 64 

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

33 

34 def __init__(self, key: bytes): 

35 # Check the key type before the length-based deprecation warnings so 

36 # an invalid key type doesn't trigger a spurious warning. 

37 utils._check_byteslike("key", key) 

38 if len(key) == 8: 

39 warnings.warn( 

40 "Single-key TripleDES (8-byte keys) is deprecated and " 

41 "support will be removed in a future release. Use 24-byte " 

42 "keys instead (e.g., key + key + key).", 

43 utils.DeprecatedIn47, 

44 stacklevel=2, 

45 ) 

46 key = key + key + key 

47 elif len(key) == 16: 

48 warnings.warn( 

49 "Two-key TripleDES (16-byte keys) is deprecated and " 

50 "support will be removed in a future release. Use 24-byte " 

51 "keys instead (e.g., key + key[:8]).", 

52 utils.DeprecatedIn47, 

53 stacklevel=2, 

54 ) 

55 key = key + key[:8] 

56 self.key = _verify_key_size(self, key) 

57 

58 @property 

59 def key_size(self) -> int: 

60 return len(self.key) * 8 

61 

62 

63# Not actually supported, marker for tests 

64class _DES: 

65 key_size = 64 

66 

67 

68class Blowfish(BlockCipherAlgorithm): 

69 name = "Blowfish" 

70 block_size = 64 

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

72 

73 def __init__(self, key: bytes): 

74 self.key = _verify_key_size(self, key) 

75 

76 @property 

77 def key_size(self) -> int: 

78 return len(self.key) * 8 

79 

80 

81class CAST5(BlockCipherAlgorithm): 

82 name = "CAST5" 

83 block_size = 64 

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

85 

86 def __init__(self, key: bytes): 

87 self.key = _verify_key_size(self, key) 

88 

89 @property 

90 def key_size(self) -> int: 

91 return len(self.key) * 8 

92 

93 

94class SEED(BlockCipherAlgorithm): 

95 name = "SEED" 

96 block_size = 128 

97 key_sizes = frozenset([128]) 

98 

99 def __init__(self, key: bytes): 

100 self.key = _verify_key_size(self, key) 

101 

102 @property 

103 def key_size(self) -> int: 

104 return len(self.key) * 8 

105 

106 

107class IDEA(BlockCipherAlgorithm): 

108 name = "IDEA" 

109 block_size = 64 

110 key_sizes = frozenset([128]) 

111 

112 def __init__(self, key: bytes): 

113 self.key = _verify_key_size(self, key) 

114 

115 @property 

116 def key_size(self) -> int: 

117 return len(self.key) * 8 

118 

119 

120class Camellia(BlockCipherAlgorithm): 

121 name = "camellia" 

122 block_size = 128 

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

124 

125 def __init__(self, key: bytes): 

126 self.key = _verify_key_size(self, key) 

127 

128 @property 

129 def key_size(self) -> int: 

130 return len(self.key) * 8 

131 

132 

133# This class only allows RC2 with a 128-bit key. No support for 

134# effective key bits or other key sizes is provided. 

135class RC2(BlockCipherAlgorithm): 

136 name = "RC2" 

137 block_size = 64 

138 key_sizes = frozenset([128]) 

139 

140 def __init__(self, key: bytes): 

141 self.key = _verify_key_size(self, key) 

142 

143 @property 

144 def key_size(self) -> int: 

145 return len(self.key) * 8