Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/cryptography/hazmat/primitives/hashes.py: 84%

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 abc 

8import typing 

9 

10from cryptography.hazmat.bindings._rust import openssl as rust_openssl 

11 

12__all__ = [ 

13 "HashAlgorithm", 

14 "HashContext", 

15 "Hash", 

16 "ExtendableOutputFunction", 

17 "SHA1", 

18 "SHA512_224", 

19 "SHA512_256", 

20 "SHA224", 

21 "SHA256", 

22 "SHA384", 

23 "SHA512", 

24 "SHA3_224", 

25 "SHA3_256", 

26 "SHA3_384", 

27 "SHA3_512", 

28 "SHAKE128", 

29 "SHAKE256", 

30 "MD5", 

31 "BLAKE2b", 

32 "BLAKE2s", 

33 "SM3", 

34] 

35 

36 

37class HashAlgorithm(metaclass=abc.ABCMeta): 

38 @property 

39 @abc.abstractmethod 

40 def name(self) -> str: 

41 """ 

42 A string naming this algorithm (e.g. "sha256", "md5"). 

43 """ 

44 

45 @property 

46 @abc.abstractmethod 

47 def digest_size(self) -> int: 

48 """ 

49 The size of the resulting digest in bytes. 

50 """ 

51 

52 @property 

53 @abc.abstractmethod 

54 def block_size(self) -> typing.Optional[int]: 

55 """ 

56 The internal block size of the hash function, or None if the hash 

57 function does not use blocks internally (e.g. SHA3). 

58 """ 

59 

60 

61class HashContext(metaclass=abc.ABCMeta): 

62 @property 

63 @abc.abstractmethod 

64 def algorithm(self) -> HashAlgorithm: 

65 """ 

66 A HashAlgorithm that will be used by this context. 

67 """ 

68 

69 @abc.abstractmethod 

70 def update(self, data: bytes) -> None: 

71 """ 

72 Processes the provided bytes through the hash. 

73 """ 

74 

75 @abc.abstractmethod 

76 def finalize(self) -> bytes: 

77 """ 

78 Finalizes the hash context and returns the hash digest as bytes. 

79 """ 

80 

81 @abc.abstractmethod 

82 def copy(self) -> HashContext: 

83 """ 

84 Return a HashContext that is a copy of the current context. 

85 """ 

86 

87 

88Hash = rust_openssl.hashes.Hash 

89HashContext.register(Hash) 

90 

91 

92class ExtendableOutputFunction(metaclass=abc.ABCMeta): 

93 """ 

94 An interface for extendable output functions. 

95 """ 

96 

97 

98class SHA1(HashAlgorithm): 

99 name = "sha1" 

100 digest_size = 20 

101 block_size = 64 

102 

103 

104class SHA512_224(HashAlgorithm): # noqa: N801 

105 name = "sha512-224" 

106 digest_size = 28 

107 block_size = 128 

108 

109 

110class SHA512_256(HashAlgorithm): # noqa: N801 

111 name = "sha512-256" 

112 digest_size = 32 

113 block_size = 128 

114 

115 

116class SHA224(HashAlgorithm): 

117 name = "sha224" 

118 digest_size = 28 

119 block_size = 64 

120 

121 

122class SHA256(HashAlgorithm): 

123 name = "sha256" 

124 digest_size = 32 

125 block_size = 64 

126 

127 

128class SHA384(HashAlgorithm): 

129 name = "sha384" 

130 digest_size = 48 

131 block_size = 128 

132 

133 

134class SHA512(HashAlgorithm): 

135 name = "sha512" 

136 digest_size = 64 

137 block_size = 128 

138 

139 

140class SHA3_224(HashAlgorithm): # noqa: N801 

141 name = "sha3-224" 

142 digest_size = 28 

143 block_size = None 

144 

145 

146class SHA3_256(HashAlgorithm): # noqa: N801 

147 name = "sha3-256" 

148 digest_size = 32 

149 block_size = None 

150 

151 

152class SHA3_384(HashAlgorithm): # noqa: N801 

153 name = "sha3-384" 

154 digest_size = 48 

155 block_size = None 

156 

157 

158class SHA3_512(HashAlgorithm): # noqa: N801 

159 name = "sha3-512" 

160 digest_size = 64 

161 block_size = None 

162 

163 

164class SHAKE128(HashAlgorithm, ExtendableOutputFunction): 

165 name = "shake128" 

166 block_size = None 

167 

168 def __init__(self, digest_size: int): 

169 if not isinstance(digest_size, int): 

170 raise TypeError("digest_size must be an integer") 

171 

172 if digest_size < 1: 

173 raise ValueError("digest_size must be a positive integer") 

174 

175 self._digest_size = digest_size 

176 

177 @property 

178 def digest_size(self) -> int: 

179 return self._digest_size 

180 

181 

182class SHAKE256(HashAlgorithm, ExtendableOutputFunction): 

183 name = "shake256" 

184 block_size = None 

185 

186 def __init__(self, digest_size: int): 

187 if not isinstance(digest_size, int): 

188 raise TypeError("digest_size must be an integer") 

189 

190 if digest_size < 1: 

191 raise ValueError("digest_size must be a positive integer") 

192 

193 self._digest_size = digest_size 

194 

195 @property 

196 def digest_size(self) -> int: 

197 return self._digest_size 

198 

199 

200class MD5(HashAlgorithm): 

201 name = "md5" 

202 digest_size = 16 

203 block_size = 64 

204 

205 

206class BLAKE2b(HashAlgorithm): 

207 name = "blake2b" 

208 _max_digest_size = 64 

209 _min_digest_size = 1 

210 block_size = 128 

211 

212 def __init__(self, digest_size: int): 

213 if digest_size != 64: 

214 raise ValueError("Digest size must be 64") 

215 

216 self._digest_size = digest_size 

217 

218 @property 

219 def digest_size(self) -> int: 

220 return self._digest_size 

221 

222 

223class BLAKE2s(HashAlgorithm): 

224 name = "blake2s" 

225 block_size = 64 

226 _max_digest_size = 32 

227 _min_digest_size = 1 

228 

229 def __init__(self, digest_size: int): 

230 if digest_size != 32: 

231 raise ValueError("Digest size must be 32") 

232 

233 self._digest_size = digest_size 

234 

235 @property 

236 def digest_size(self) -> int: 

237 return self._digest_size 

238 

239 

240class SM3(HashAlgorithm): 

241 name = "sm3" 

242 digest_size = 32 

243 block_size = 64