Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

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) 

11from cryptography.hazmat.primitives.ciphers.modes import ModeWithNonce 

12 

13 

14def _verify_key_size(algorithm: CipherAlgorithm, key: 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(CipherAlgorithm, 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 Camellia(CipherAlgorithm, BlockCipherAlgorithm): 

43 name = "camellia" 

44 block_size = 128 

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

46 

47 def __init__(self, key: bytes): 

48 self.key = _verify_key_size(self, key) 

49 

50 @property 

51 def key_size(self) -> int: 

52 return len(self.key) * 8 

53 

54 

55class TripleDES(CipherAlgorithm, BlockCipherAlgorithm): 

56 name = "3DES" 

57 block_size = 64 

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

59 

60 def __init__(self, key: bytes): 

61 if len(key) == 8: 

62 key += key + key 

63 elif len(key) == 16: 

64 key += key[:8] 

65 self.key = _verify_key_size(self, key) 

66 

67 @property 

68 def key_size(self) -> int: 

69 return len(self.key) * 8 

70 

71 

72class Blowfish(CipherAlgorithm, BlockCipherAlgorithm): 

73 name = "Blowfish" 

74 block_size = 64 

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

76 

77 def __init__(self, key: bytes): 

78 self.key = _verify_key_size(self, key) 

79 

80 @property 

81 def key_size(self) -> int: 

82 return len(self.key) * 8 

83 

84 

85class CAST5(CipherAlgorithm, BlockCipherAlgorithm): 

86 name = "CAST5" 

87 block_size = 64 

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

89 

90 def __init__(self, key: bytes): 

91 self.key = _verify_key_size(self, key) 

92 

93 @property 

94 def key_size(self) -> int: 

95 return len(self.key) * 8 

96 

97 

98class ARC4(CipherAlgorithm): 

99 name = "RC4" 

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

101 

102 def __init__(self, key: bytes): 

103 self.key = _verify_key_size(self, key) 

104 

105 @property 

106 def key_size(self) -> int: 

107 return len(self.key) * 8 

108 

109 

110class IDEA(CipherAlgorithm): 

111 name = "IDEA" 

112 block_size = 64 

113 key_sizes = frozenset([128]) 

114 

115 def __init__(self, key: bytes): 

116 self.key = _verify_key_size(self, key) 

117 

118 @property 

119 def key_size(self) -> int: 

120 return len(self.key) * 8 

121 

122 

123class SEED(CipherAlgorithm, BlockCipherAlgorithm): 

124 name = "SEED" 

125 block_size = 128 

126 key_sizes = frozenset([128]) 

127 

128 def __init__(self, key: bytes): 

129 self.key = _verify_key_size(self, key) 

130 

131 @property 

132 def key_size(self) -> int: 

133 return len(self.key) * 8 

134 

135 

136class ChaCha20(CipherAlgorithm, ModeWithNonce): 

137 name = "ChaCha20" 

138 key_sizes = frozenset([256]) 

139 

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

141 self.key = _verify_key_size(self, key) 

142 utils._check_byteslike("nonce", nonce) 

143 

144 if len(nonce) != 16: 

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

146 

147 self._nonce = nonce 

148 

149 nonce = utils.read_only_property("_nonce") 

150 

151 @property 

152 def key_size(self) -> int: 

153 return len(self.key) * 8