Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/cryptography/hazmat/decrepit/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 

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 if len(key) == 8: 

36 warnings.warn( 

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

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

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

40 utils.DeprecatedIn47, 

41 stacklevel=2, 

42 ) 

43 key = key + key + key 

44 elif len(key) == 16: 

45 warnings.warn( 

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

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

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

49 utils.DeprecatedIn47, 

50 stacklevel=2, 

51 ) 

52 key = key + key[:8] 

53 self.key = _verify_key_size(self, key) 

54 

55 @property 

56 def key_size(self) -> int: 

57 return len(self.key) * 8 

58 

59 

60# Not actually supported, marker for tests 

61class _DES: 

62 key_size = 64 

63 

64 

65class Blowfish(BlockCipherAlgorithm): 

66 name = "Blowfish" 

67 block_size = 64 

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

69 

70 def __init__(self, key: bytes): 

71 self.key = _verify_key_size(self, key) 

72 

73 @property 

74 def key_size(self) -> int: 

75 return len(self.key) * 8 

76 

77 

78class CAST5(BlockCipherAlgorithm): 

79 name = "CAST5" 

80 block_size = 64 

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

82 

83 def __init__(self, key: bytes): 

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 SEED(BlockCipherAlgorithm): 

92 name = "SEED" 

93 block_size = 128 

94 key_sizes = frozenset([128]) 

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 

104class IDEA(BlockCipherAlgorithm): 

105 name = "IDEA" 

106 block_size = 64 

107 key_sizes = frozenset([128]) 

108 

109 def __init__(self, key: bytes): 

110 self.key = _verify_key_size(self, key) 

111 

112 @property 

113 def key_size(self) -> int: 

114 return len(self.key) * 8 

115 

116 

117class Camellia(BlockCipherAlgorithm): 

118 name = "camellia" 

119 block_size = 128 

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

121 

122 def __init__(self, key: bytes): 

123 self.key = _verify_key_size(self, key) 

124 

125 @property 

126 def key_size(self) -> int: 

127 return len(self.key) * 8 

128 

129 

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

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

132class RC2(BlockCipherAlgorithm): 

133 name = "RC2" 

134 block_size = 64 

135 key_sizes = frozenset([128]) 

136 

137 def __init__(self, key: bytes): 

138 self.key = _verify_key_size(self, key) 

139 

140 @property 

141 def key_size(self) -> int: 

142 return len(self.key) * 8