jam134 commited on
Commit
17ff01e
·
verified ·
1 Parent(s): 8c7e1ee

Upload 388 files

Browse files
This view is limited to 50 files because it contains too many changes.   See raw diff
Files changed (50) hide show
  1. runtime/Lib/site-packages/Crypto/Cipher/AES.py +250 -0
  2. runtime/Lib/site-packages/Crypto/Cipher/AES.pyi +47 -0
  3. runtime/Lib/site-packages/Crypto/Cipher/ARC2.py +175 -0
  4. runtime/Lib/site-packages/Crypto/Cipher/ARC2.pyi +35 -0
  5. runtime/Lib/site-packages/Crypto/Cipher/ARC4.py +136 -0
  6. runtime/Lib/site-packages/Crypto/Cipher/ARC4.pyi +16 -0
  7. runtime/Lib/site-packages/Crypto/Cipher/Blowfish.py +159 -0
  8. runtime/Lib/site-packages/Crypto/Cipher/Blowfish.pyi +35 -0
  9. runtime/Lib/site-packages/Crypto/Cipher/CAST.py +159 -0
  10. runtime/Lib/site-packages/Crypto/Cipher/CAST.pyi +35 -0
  11. runtime/Lib/site-packages/Crypto/Cipher/ChaCha20.py +287 -0
  12. runtime/Lib/site-packages/Crypto/Cipher/ChaCha20.pyi +25 -0
  13. runtime/Lib/site-packages/Crypto/Cipher/ChaCha20_Poly1305.py +336 -0
  14. runtime/Lib/site-packages/Crypto/Cipher/ChaCha20_Poly1305.pyi +28 -0
  15. runtime/Lib/site-packages/Crypto/Cipher/DES.py +158 -0
  16. runtime/Lib/site-packages/Crypto/Cipher/DES.pyi +35 -0
  17. runtime/Lib/site-packages/Crypto/Cipher/DES3.py +187 -0
  18. runtime/Lib/site-packages/Crypto/Cipher/DES3.pyi +37 -0
  19. runtime/Lib/site-packages/Crypto/Cipher/PKCS1_OAEP.py +239 -0
  20. runtime/Lib/site-packages/Crypto/Cipher/PKCS1_OAEP.pyi +35 -0
  21. runtime/Lib/site-packages/Crypto/Cipher/PKCS1_v1_5.py +217 -0
  22. runtime/Lib/site-packages/Crypto/Cipher/PKCS1_v1_5.pyi +20 -0
  23. runtime/Lib/site-packages/Crypto/Cipher/Salsa20.py +167 -0
  24. runtime/Lib/site-packages/Crypto/Cipher/Salsa20.pyi +27 -0
  25. runtime/Lib/site-packages/Crypto/Cipher/_ARC4.pyd +0 -0
  26. runtime/Lib/site-packages/Crypto/Cipher/_EKSBlowfish.py +131 -0
  27. runtime/Lib/site-packages/Crypto/Cipher/_EKSBlowfish.pyi +15 -0
  28. runtime/Lib/site-packages/Crypto/Cipher/_Salsa20.pyd +0 -0
  29. runtime/Lib/site-packages/Crypto/Cipher/__init__.py +79 -0
  30. runtime/Lib/site-packages/Crypto/Cipher/__init__.pyi +0 -0
  31. runtime/Lib/site-packages/Crypto/Cipher/_chacha20.pyd +0 -0
  32. runtime/Lib/site-packages/Crypto/Cipher/_mode_cbc.py +293 -0
  33. runtime/Lib/site-packages/Crypto/Cipher/_mode_cbc.pyi +25 -0
  34. runtime/Lib/site-packages/Crypto/Cipher/_mode_ccm.py +650 -0
  35. runtime/Lib/site-packages/Crypto/Cipher/_mode_ccm.pyi +47 -0
  36. runtime/Lib/site-packages/Crypto/Cipher/_mode_cfb.py +293 -0
  37. runtime/Lib/site-packages/Crypto/Cipher/_mode_cfb.pyi +26 -0
  38. runtime/Lib/site-packages/Crypto/Cipher/_mode_ctr.py +393 -0
  39. runtime/Lib/site-packages/Crypto/Cipher/_mode_ctr.pyi +27 -0
  40. runtime/Lib/site-packages/Crypto/Cipher/_mode_eax.py +408 -0
  41. runtime/Lib/site-packages/Crypto/Cipher/_mode_eax.pyi +45 -0
  42. runtime/Lib/site-packages/Crypto/Cipher/_mode_ecb.py +220 -0
  43. runtime/Lib/site-packages/Crypto/Cipher/_mode_ecb.pyi +19 -0
  44. runtime/Lib/site-packages/Crypto/Cipher/_mode_gcm.py +620 -0
  45. runtime/Lib/site-packages/Crypto/Cipher/_mode_gcm.pyi +45 -0
  46. runtime/Lib/site-packages/Crypto/Cipher/_mode_ocb.py +525 -0
  47. runtime/Lib/site-packages/Crypto/Cipher/_mode_ocb.pyi +36 -0
  48. runtime/Lib/site-packages/Crypto/Cipher/_mode_ofb.py +282 -0
  49. runtime/Lib/site-packages/Crypto/Cipher/_mode_ofb.pyi +25 -0
  50. runtime/Lib/site-packages/Crypto/Cipher/_mode_openpgp.py +206 -0
runtime/Lib/site-packages/Crypto/Cipher/AES.py ADDED
@@ -0,0 +1,250 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/AES.py : AES
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+ """
23
+ Module's constants for the modes of operation supported with AES:
24
+
25
+ :var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
26
+ :var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
27
+ :var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
28
+ :var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
29
+ :var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
30
+ :var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
31
+ :var MODE_CCM: :ref:`Counter with CBC-MAC (CCM) Mode <ccm_mode>`
32
+ :var MODE_EAX: :ref:`EAX Mode <eax_mode>`
33
+ :var MODE_GCM: :ref:`Galois Counter Mode (GCM) <gcm_mode>`
34
+ :var MODE_SIV: :ref:`Syntethic Initialization Vector (SIV) <siv_mode>`
35
+ :var MODE_OCB: :ref:`Offset Code Book (OCB) <ocb_mode>`
36
+ """
37
+
38
+ import sys
39
+
40
+ from Crypto.Cipher import _create_cipher
41
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
42
+ VoidPointer, SmartPointer,
43
+ c_size_t, c_uint8_ptr)
44
+
45
+ from Crypto.Util import _cpu_features
46
+ from Crypto.Random import get_random_bytes
47
+
48
+
49
+ _cproto = """
50
+ int AES_start_operation(const uint8_t key[],
51
+ size_t key_len,
52
+ void **pResult);
53
+ int AES_encrypt(const void *state,
54
+ const uint8_t *in,
55
+ uint8_t *out,
56
+ size_t data_len);
57
+ int AES_decrypt(const void *state,
58
+ const uint8_t *in,
59
+ uint8_t *out,
60
+ size_t data_len);
61
+ int AES_stop_operation(void *state);
62
+ """
63
+
64
+
65
+ # Load portable AES
66
+ _raw_aes_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_aes",
67
+ _cproto)
68
+
69
+ # Try to load AES with AES NI instructions
70
+ try:
71
+ _raw_aesni_lib = None
72
+ if _cpu_features.have_aes_ni():
73
+ _raw_aesni_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_aesni",
74
+ _cproto.replace("AES",
75
+ "AESNI"))
76
+ # _raw_aesni may not have been compiled in
77
+ except OSError:
78
+ pass
79
+
80
+
81
+ def _create_base_cipher(dict_parameters):
82
+ """This method instantiates and returns a handle to a low-level
83
+ base cipher. It will absorb named parameters in the process."""
84
+
85
+ use_aesni = dict_parameters.pop("use_aesni", True)
86
+
87
+ try:
88
+ key = dict_parameters.pop("key")
89
+ except KeyError:
90
+ raise TypeError("Missing 'key' parameter")
91
+
92
+ if len(key) not in key_size:
93
+ raise ValueError("Incorrect AES key length (%d bytes)" % len(key))
94
+
95
+ if use_aesni and _raw_aesni_lib:
96
+ start_operation = _raw_aesni_lib.AESNI_start_operation
97
+ stop_operation = _raw_aesni_lib.AESNI_stop_operation
98
+ else:
99
+ start_operation = _raw_aes_lib.AES_start_operation
100
+ stop_operation = _raw_aes_lib.AES_stop_operation
101
+
102
+ cipher = VoidPointer()
103
+ result = start_operation(c_uint8_ptr(key),
104
+ c_size_t(len(key)),
105
+ cipher.address_of())
106
+ if result:
107
+ raise ValueError("Error %X while instantiating the AES cipher"
108
+ % result)
109
+ return SmartPointer(cipher.get(), stop_operation)
110
+
111
+
112
+ def _derive_Poly1305_key_pair(key, nonce):
113
+ """Derive a tuple (r, s, nonce) for a Poly1305 MAC.
114
+
115
+ If nonce is ``None``, a new 16-byte nonce is generated.
116
+ """
117
+
118
+ if len(key) != 32:
119
+ raise ValueError("Poly1305 with AES requires a 32-byte key")
120
+
121
+ if nonce is None:
122
+ nonce = get_random_bytes(16)
123
+ elif len(nonce) != 16:
124
+ raise ValueError("Poly1305 with AES requires a 16-byte nonce")
125
+
126
+ s = new(key[:16], MODE_ECB).encrypt(nonce)
127
+ return key[16:], s, nonce
128
+
129
+
130
+ def new(key, mode, *args, **kwargs):
131
+ """Create a new AES cipher.
132
+
133
+ :param key:
134
+ The secret key to use in the symmetric cipher.
135
+
136
+ It must be 16, 24 or 32 bytes long (respectively for *AES-128*,
137
+ *AES-192* or *AES-256*).
138
+
139
+ For ``MODE_SIV`` only, it doubles to 32, 48, or 64 bytes.
140
+ :type key: bytes/bytearray/memoryview
141
+
142
+ :param mode:
143
+ The chaining mode to use for encryption or decryption.
144
+ If in doubt, use ``MODE_EAX``.
145
+ :type mode: One of the supported ``MODE_*`` constants
146
+
147
+ :Keyword Arguments:
148
+ * **iv** (*bytes*, *bytearray*, *memoryview*) --
149
+ (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
150
+ and ``MODE_OPENPGP`` modes).
151
+
152
+ The initialization vector to use for encryption or decryption.
153
+
154
+ For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 16 bytes long.
155
+
156
+ For ``MODE_OPENPGP`` mode only,
157
+ it must be 16 bytes long for encryption
158
+ and 18 bytes for decryption (in the latter case, it is
159
+ actually the *encrypted* IV which was prefixed to the ciphertext).
160
+
161
+ If not provided, a random byte string is generated (you must then
162
+ read its value with the :attr:`iv` attribute).
163
+
164
+ * **nonce** (*bytes*, *bytearray*, *memoryview*) --
165
+ (Only applicable for ``MODE_CCM``, ``MODE_EAX``, ``MODE_GCM``,
166
+ ``MODE_SIV``, ``MODE_OCB``, and ``MODE_CTR``).
167
+
168
+ A value that must never be reused for any other encryption done
169
+ with this key (except possibly for ``MODE_SIV``, see below).
170
+
171
+ For ``MODE_EAX``, ``MODE_GCM`` and ``MODE_SIV`` there are no
172
+ restrictions on its length (recommended: **16** bytes).
173
+
174
+ For ``MODE_CCM``, its length must be in the range **[7..13]**.
175
+ Bear in mind that with CCM there is a trade-off between nonce
176
+ length and maximum message size. Recommendation: **11** bytes.
177
+
178
+ For ``MODE_OCB``, its length must be in the range **[1..15]**
179
+ (recommended: **15**).
180
+
181
+ For ``MODE_CTR``, its length must be in the range **[0..15]**
182
+ (recommended: **8**).
183
+
184
+ For ``MODE_SIV``, the nonce is optional, if it is not specified,
185
+ then no nonce is being used, which renders the encryption
186
+ deterministic.
187
+
188
+ If not provided, for modes other than ``MODE_SIV```, a random
189
+ byte string of the recommended length is used (you must then
190
+ read its value with the :attr:`nonce` attribute).
191
+
192
+ * **segment_size** (*integer*) --
193
+ (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
194
+ are segmented in. It must be a multiple of 8.
195
+ If not specified, it will be assumed to be 8.
196
+
197
+ * **mac_len** : (*integer*) --
198
+ (Only ``MODE_EAX``, ``MODE_GCM``, ``MODE_OCB``, ``MODE_CCM``)
199
+ Length of the authentication tag, in bytes.
200
+
201
+ It must be even and in the range **[4..16]**.
202
+ The recommended value (and the default, if not specified) is **16**.
203
+
204
+ * **msg_len** : (*integer*) --
205
+ (Only ``MODE_CCM``). Length of the message to (de)cipher.
206
+ If not specified, ``encrypt`` must be called with the entire message.
207
+ Similarly, ``decrypt`` can only be called once.
208
+
209
+ * **assoc_len** : (*integer*) --
210
+ (Only ``MODE_CCM``). Length of the associated data.
211
+ If not specified, all associated data is buffered internally,
212
+ which may represent a problem for very large messages.
213
+
214
+ * **initial_value** : (*integer* or *bytes/bytearray/memoryview*) --
215
+ (Only ``MODE_CTR``).
216
+ The initial value for the counter. If not present, the cipher will
217
+ start counting from 0. The value is incremented by one for each block.
218
+ The counter number is encoded in big endian mode.
219
+
220
+ * **counter** : (*object*) --
221
+ Instance of ``Crypto.Util.Counter``, which allows full customization
222
+ of the counter block. This parameter is incompatible to both ``nonce``
223
+ and ``initial_value``.
224
+
225
+ * **use_aesni** : (*boolean*) --
226
+ Use Intel AES-NI hardware extensions (default: use if available).
227
+
228
+ :Return: an AES object, of the applicable mode.
229
+ """
230
+
231
+ kwargs["add_aes_modes"] = True
232
+ return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
233
+
234
+
235
+ MODE_ECB = 1
236
+ MODE_CBC = 2
237
+ MODE_CFB = 3
238
+ MODE_OFB = 5
239
+ MODE_CTR = 6
240
+ MODE_OPENPGP = 7
241
+ MODE_CCM = 8
242
+ MODE_EAX = 9
243
+ MODE_SIV = 10
244
+ MODE_GCM = 11
245
+ MODE_OCB = 12
246
+
247
+ # Size of a data block (in bytes)
248
+ block_size = 16
249
+ # Size of a key (in bytes)
250
+ key_size = (16, 24, 32)
runtime/Lib/site-packages/Crypto/Cipher/AES.pyi ADDED
@@ -0,0 +1,47 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, Tuple, Optional, Dict
2
+
3
+ from Crypto.Cipher._mode_ecb import EcbMode
4
+ from Crypto.Cipher._mode_cbc import CbcMode
5
+ from Crypto.Cipher._mode_cfb import CfbMode
6
+ from Crypto.Cipher._mode_ofb import OfbMode
7
+ from Crypto.Cipher._mode_ctr import CtrMode
8
+ from Crypto.Cipher._mode_openpgp import OpenPgpMode
9
+ from Crypto.Cipher._mode_ccm import CcmMode
10
+ from Crypto.Cipher._mode_eax import EaxMode
11
+ from Crypto.Cipher._mode_gcm import GcmMode
12
+ from Crypto.Cipher._mode_siv import SivMode
13
+ from Crypto.Cipher._mode_ocb import OcbMode
14
+
15
+ AESMode = int
16
+
17
+ MODE_ECB: AESMode
18
+ MODE_CBC: AESMode
19
+ MODE_CFB: AESMode
20
+ MODE_OFB: AESMode
21
+ MODE_CTR: AESMode
22
+ MODE_OPENPGP: AESMode
23
+ MODE_CCM: AESMode
24
+ MODE_EAX: AESMode
25
+ MODE_GCM: AESMode
26
+ MODE_SIV: AESMode
27
+ MODE_OCB: AESMode
28
+
29
+ Buffer = Union[bytes, bytearray, memoryview]
30
+
31
+ def new(key: Buffer,
32
+ mode: AESMode,
33
+ iv : Buffer = ...,
34
+ IV : Buffer = ...,
35
+ nonce : Buffer = ...,
36
+ segment_size : int = ...,
37
+ mac_len : int = ...,
38
+ assoc_len : int = ...,
39
+ initial_value : Union[int, Buffer] = ...,
40
+ counter : Dict = ...,
41
+ use_aesni : bool = ...) -> \
42
+ Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode,
43
+ OpenPgpMode, CcmMode, EaxMode, GcmMode,
44
+ SivMode, OcbMode]: ...
45
+
46
+ block_size: int
47
+ key_size: Tuple[int, int, int]
runtime/Lib/site-packages/Crypto/Cipher/ARC2.py ADDED
@@ -0,0 +1,175 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/ARC2.py : ARC2.py
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+ """
23
+ Module's constants for the modes of operation supported with ARC2:
24
+
25
+ :var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
26
+ :var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
27
+ :var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
28
+ :var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
29
+ :var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
30
+ :var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
31
+ :var MODE_EAX: :ref:`EAX Mode <eax_mode>`
32
+ """
33
+
34
+ import sys
35
+
36
+ from Crypto.Cipher import _create_cipher
37
+ from Crypto.Util.py3compat import byte_string
38
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
39
+ VoidPointer, SmartPointer,
40
+ c_size_t, c_uint8_ptr)
41
+
42
+ _raw_arc2_lib = load_pycryptodome_raw_lib(
43
+ "Crypto.Cipher._raw_arc2",
44
+ """
45
+ int ARC2_start_operation(const uint8_t key[],
46
+ size_t key_len,
47
+ size_t effective_key_len,
48
+ void **pResult);
49
+ int ARC2_encrypt(const void *state,
50
+ const uint8_t *in,
51
+ uint8_t *out,
52
+ size_t data_len);
53
+ int ARC2_decrypt(const void *state,
54
+ const uint8_t *in,
55
+ uint8_t *out,
56
+ size_t data_len);
57
+ int ARC2_stop_operation(void *state);
58
+ """
59
+ )
60
+
61
+
62
+ def _create_base_cipher(dict_parameters):
63
+ """This method instantiates and returns a handle to a low-level
64
+ base cipher. It will absorb named parameters in the process."""
65
+
66
+ try:
67
+ key = dict_parameters.pop("key")
68
+ except KeyError:
69
+ raise TypeError("Missing 'key' parameter")
70
+
71
+ effective_keylen = dict_parameters.pop("effective_keylen", 1024)
72
+
73
+ if len(key) not in key_size:
74
+ raise ValueError("Incorrect ARC2 key length (%d bytes)" % len(key))
75
+
76
+ if not (40 <= effective_keylen <= 1024):
77
+ raise ValueError("'effective_key_len' must be at least 40 and no larger than 1024 "
78
+ "(not %d)" % effective_keylen)
79
+
80
+ start_operation = _raw_arc2_lib.ARC2_start_operation
81
+ stop_operation = _raw_arc2_lib.ARC2_stop_operation
82
+
83
+ cipher = VoidPointer()
84
+ result = start_operation(c_uint8_ptr(key),
85
+ c_size_t(len(key)),
86
+ c_size_t(effective_keylen),
87
+ cipher.address_of())
88
+ if result:
89
+ raise ValueError("Error %X while instantiating the ARC2 cipher"
90
+ % result)
91
+
92
+ return SmartPointer(cipher.get(), stop_operation)
93
+
94
+
95
+ def new(key, mode, *args, **kwargs):
96
+ """Create a new RC2 cipher.
97
+
98
+ :param key:
99
+ The secret key to use in the symmetric cipher.
100
+ Its length can vary from 5 to 128 bytes; the actual search space
101
+ (and the cipher strength) can be reduced with the ``effective_keylen`` parameter.
102
+ :type key: bytes, bytearray, memoryview
103
+
104
+ :param mode:
105
+ The chaining mode to use for encryption or decryption.
106
+ :type mode: One of the supported ``MODE_*`` constants
107
+
108
+ :Keyword Arguments:
109
+ * **iv** (*bytes*, *bytearray*, *memoryview*) --
110
+ (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
111
+ and ``MODE_OPENPGP`` modes).
112
+
113
+ The initialization vector to use for encryption or decryption.
114
+
115
+ For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
116
+
117
+ For ``MODE_OPENPGP`` mode only,
118
+ it must be 8 bytes long for encryption
119
+ and 10 bytes for decryption (in the latter case, it is
120
+ actually the *encrypted* IV which was prefixed to the ciphertext).
121
+
122
+ If not provided, a random byte string is generated (you must then
123
+ read its value with the :attr:`iv` attribute).
124
+
125
+ * **nonce** (*bytes*, *bytearray*, *memoryview*) --
126
+ (Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
127
+
128
+ A value that must never be reused for any other encryption done
129
+ with this key.
130
+
131
+ For ``MODE_EAX`` there are no
132
+ restrictions on its length (recommended: **16** bytes).
133
+
134
+ For ``MODE_CTR``, its length must be in the range **[0..7]**.
135
+
136
+ If not provided for ``MODE_EAX``, a random byte string is generated (you
137
+ can read it back via the ``nonce`` attribute).
138
+
139
+ * **effective_keylen** (*integer*) --
140
+ Optional. Maximum strength in bits of the actual key used by the ARC2 algorithm.
141
+ If the supplied ``key`` parameter is longer (in bits) of the value specified
142
+ here, it will be weakened to match it.
143
+ If not specified, no limitation is applied.
144
+
145
+ * **segment_size** (*integer*) --
146
+ (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
147
+ are segmented in. It must be a multiple of 8.
148
+ If not specified, it will be assumed to be 8.
149
+
150
+ * **mac_len** : (*integer*) --
151
+ (Only ``MODE_EAX``)
152
+ Length of the authentication tag, in bytes.
153
+ It must be no longer than 8 (default).
154
+
155
+ * **initial_value** : (*integer*) --
156
+ (Only ``MODE_CTR``). The initial value for the counter within
157
+ the counter block. By default it is **0**.
158
+
159
+ :Return: an ARC2 object, of the applicable mode.
160
+ """
161
+
162
+ return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
163
+
164
+ MODE_ECB = 1
165
+ MODE_CBC = 2
166
+ MODE_CFB = 3
167
+ MODE_OFB = 5
168
+ MODE_CTR = 6
169
+ MODE_OPENPGP = 7
170
+ MODE_EAX = 9
171
+
172
+ # Size of a data block (in bytes)
173
+ block_size = 8
174
+ # Size of a key (in bytes)
175
+ key_size = range(5, 128 + 1)
runtime/Lib/site-packages/Crypto/Cipher/ARC2.pyi ADDED
@@ -0,0 +1,35 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, Dict, Iterable
2
+
3
+ from Crypto.Cipher._mode_ecb import EcbMode
4
+ from Crypto.Cipher._mode_cbc import CbcMode
5
+ from Crypto.Cipher._mode_cfb import CfbMode
6
+ from Crypto.Cipher._mode_ofb import OfbMode
7
+ from Crypto.Cipher._mode_ctr import CtrMode
8
+ from Crypto.Cipher._mode_openpgp import OpenPgpMode
9
+ from Crypto.Cipher._mode_eax import EaxMode
10
+
11
+ ARC2Mode = int
12
+
13
+ MODE_ECB: ARC2Mode
14
+ MODE_CBC: ARC2Mode
15
+ MODE_CFB: ARC2Mode
16
+ MODE_OFB: ARC2Mode
17
+ MODE_CTR: ARC2Mode
18
+ MODE_OPENPGP: ARC2Mode
19
+ MODE_EAX: ARC2Mode
20
+
21
+ Buffer = Union[bytes, bytearray, memoryview]
22
+
23
+ def new(key: Buffer,
24
+ mode: ARC2Mode,
25
+ iv : Buffer = ...,
26
+ IV : Buffer = ...,
27
+ nonce : Buffer = ...,
28
+ segment_size : int = ...,
29
+ mac_len : int = ...,
30
+ initial_value : Union[int, Buffer] = ...,
31
+ counter : Dict = ...) -> \
32
+ Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
33
+
34
+ block_size: int
35
+ key_size: Iterable[int]
runtime/Lib/site-packages/Crypto/Cipher/ARC4.py ADDED
@@ -0,0 +1,136 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/ARC4.py : ARC4
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+
23
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
24
+ create_string_buffer, get_raw_buffer,
25
+ SmartPointer, c_size_t, c_uint8_ptr)
26
+
27
+
28
+ _raw_arc4_lib = load_pycryptodome_raw_lib("Crypto.Cipher._ARC4", """
29
+ int ARC4_stream_encrypt(void *rc4State, const uint8_t in[],
30
+ uint8_t out[], size_t len);
31
+ int ARC4_stream_init(uint8_t *key, size_t keylen,
32
+ void **pRc4State);
33
+ int ARC4_stream_destroy(void *rc4State);
34
+ """)
35
+
36
+
37
+ class ARC4Cipher:
38
+ """ARC4 cipher object. Do not create it directly. Use
39
+ :func:`Crypto.Cipher.ARC4.new` instead.
40
+ """
41
+
42
+ def __init__(self, key, *args, **kwargs):
43
+ """Initialize an ARC4 cipher object
44
+
45
+ See also `new()` at the module level."""
46
+
47
+ if len(args) > 0:
48
+ ndrop = args[0]
49
+ args = args[1:]
50
+ else:
51
+ ndrop = kwargs.pop('drop', 0)
52
+
53
+ if len(key) not in key_size:
54
+ raise ValueError("Incorrect ARC4 key length (%d bytes)" %
55
+ len(key))
56
+
57
+ self._state = VoidPointer()
58
+ result = _raw_arc4_lib.ARC4_stream_init(c_uint8_ptr(key),
59
+ c_size_t(len(key)),
60
+ self._state.address_of())
61
+ if result != 0:
62
+ raise ValueError("Error %d while creating the ARC4 cipher"
63
+ % result)
64
+ self._state = SmartPointer(self._state.get(),
65
+ _raw_arc4_lib.ARC4_stream_destroy)
66
+
67
+ if ndrop > 0:
68
+ # This is OK even if the cipher is used for decryption,
69
+ # since encrypt and decrypt are actually the same thing
70
+ # with ARC4.
71
+ self.encrypt(b'\x00' * ndrop)
72
+
73
+ self.block_size = 1
74
+ self.key_size = len(key)
75
+
76
+ def encrypt(self, plaintext):
77
+ """Encrypt a piece of data.
78
+
79
+ :param plaintext: The data to encrypt, of any size.
80
+ :type plaintext: bytes, bytearray, memoryview
81
+ :returns: the encrypted byte string, of equal length as the
82
+ plaintext.
83
+ """
84
+
85
+ ciphertext = create_string_buffer(len(plaintext))
86
+ result = _raw_arc4_lib.ARC4_stream_encrypt(self._state.get(),
87
+ c_uint8_ptr(plaintext),
88
+ ciphertext,
89
+ c_size_t(len(plaintext)))
90
+ if result:
91
+ raise ValueError("Error %d while encrypting with RC4" % result)
92
+ return get_raw_buffer(ciphertext)
93
+
94
+ def decrypt(self, ciphertext):
95
+ """Decrypt a piece of data.
96
+
97
+ :param ciphertext: The data to decrypt, of any size.
98
+ :type ciphertext: bytes, bytearray, memoryview
99
+ :returns: the decrypted byte string, of equal length as the
100
+ ciphertext.
101
+ """
102
+
103
+ try:
104
+ return self.encrypt(ciphertext)
105
+ except ValueError as e:
106
+ raise ValueError(str(e).replace("enc", "dec"))
107
+
108
+
109
+ def new(key, *args, **kwargs):
110
+ """Create a new ARC4 cipher.
111
+
112
+ :param key:
113
+ The secret key to use in the symmetric cipher.
114
+ Its length must be in the range ``[1..256]``.
115
+ The recommended length is 16 bytes.
116
+ :type key: bytes, bytearray, memoryview
117
+
118
+ :Keyword Arguments:
119
+ * *drop* (``integer``) --
120
+ The amount of bytes to discard from the initial part of the keystream.
121
+ In fact, such part has been found to be distinguishable from random
122
+ data (while it shouldn't) and also correlated to key.
123
+
124
+ The recommended value is 3072_ bytes. The default value is 0.
125
+
126
+ :Return: an `ARC4Cipher` object
127
+
128
+ .. _3072: http://eprint.iacr.org/2002/067.pdf
129
+ """
130
+ return ARC4Cipher(key, *args, **kwargs)
131
+
132
+
133
+ # Size of a data block (in bytes)
134
+ block_size = 1
135
+ # Size of a key (in bytes)
136
+ key_size = range(1, 256+1)
runtime/Lib/site-packages/Crypto/Cipher/ARC4.pyi ADDED
@@ -0,0 +1,16 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Any, Union, Iterable
2
+
3
+ Buffer = Union[bytes, bytearray, memoryview]
4
+
5
+ class ARC4Cipher:
6
+ block_size: int
7
+ key_size: int
8
+
9
+ def __init__(self, key: Buffer, *args: Any, **kwargs: Any) -> None: ...
10
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
11
+ def decrypt(self, ciphertext: Buffer) -> bytes: ...
12
+
13
+ def new(key: Buffer, drop : int = ...) -> ARC4Cipher: ...
14
+
15
+ block_size: int
16
+ key_size: Iterable[int]
runtime/Lib/site-packages/Crypto/Cipher/Blowfish.py ADDED
@@ -0,0 +1,159 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/Blowfish.py : Blowfish
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+ """
23
+ Module's constants for the modes of operation supported with Blowfish:
24
+
25
+ :var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
26
+ :var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
27
+ :var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
28
+ :var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
29
+ :var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
30
+ :var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
31
+ :var MODE_EAX: :ref:`EAX Mode <eax_mode>`
32
+ """
33
+
34
+ import sys
35
+
36
+ from Crypto.Cipher import _create_cipher
37
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
38
+ VoidPointer, SmartPointer, c_size_t,
39
+ c_uint8_ptr)
40
+
41
+ _raw_blowfish_lib = load_pycryptodome_raw_lib(
42
+ "Crypto.Cipher._raw_blowfish",
43
+ """
44
+ int Blowfish_start_operation(const uint8_t key[],
45
+ size_t key_len,
46
+ void **pResult);
47
+ int Blowfish_encrypt(const void *state,
48
+ const uint8_t *in,
49
+ uint8_t *out,
50
+ size_t data_len);
51
+ int Blowfish_decrypt(const void *state,
52
+ const uint8_t *in,
53
+ uint8_t *out,
54
+ size_t data_len);
55
+ int Blowfish_stop_operation(void *state);
56
+ """
57
+ )
58
+
59
+
60
+ def _create_base_cipher(dict_parameters):
61
+ """This method instantiates and returns a smart pointer to
62
+ a low-level base cipher. It will absorb named parameters in
63
+ the process."""
64
+
65
+ try:
66
+ key = dict_parameters.pop("key")
67
+ except KeyError:
68
+ raise TypeError("Missing 'key' parameter")
69
+
70
+ if len(key) not in key_size:
71
+ raise ValueError("Incorrect Blowfish key length (%d bytes)" % len(key))
72
+
73
+ start_operation = _raw_blowfish_lib.Blowfish_start_operation
74
+ stop_operation = _raw_blowfish_lib.Blowfish_stop_operation
75
+
76
+ void_p = VoidPointer()
77
+ result = start_operation(c_uint8_ptr(key),
78
+ c_size_t(len(key)),
79
+ void_p.address_of())
80
+ if result:
81
+ raise ValueError("Error %X while instantiating the Blowfish cipher"
82
+ % result)
83
+ return SmartPointer(void_p.get(), stop_operation)
84
+
85
+
86
+ def new(key, mode, *args, **kwargs):
87
+ """Create a new Blowfish cipher
88
+
89
+ :param key:
90
+ The secret key to use in the symmetric cipher.
91
+ Its length can vary from 5 to 56 bytes.
92
+ :type key: bytes, bytearray, memoryview
93
+
94
+ :param mode:
95
+ The chaining mode to use for encryption or decryption.
96
+ :type mode: One of the supported ``MODE_*`` constants
97
+
98
+ :Keyword Arguments:
99
+ * **iv** (*bytes*, *bytearray*, *memoryview*) --
100
+ (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
101
+ and ``MODE_OPENPGP`` modes).
102
+
103
+ The initialization vector to use for encryption or decryption.
104
+
105
+ For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
106
+
107
+ For ``MODE_OPENPGP`` mode only,
108
+ it must be 8 bytes long for encryption
109
+ and 10 bytes for decryption (in the latter case, it is
110
+ actually the *encrypted* IV which was prefixed to the ciphertext).
111
+
112
+ If not provided, a random byte string is generated (you must then
113
+ read its value with the :attr:`iv` attribute).
114
+
115
+ * **nonce** (*bytes*, *bytearray*, *memoryview*) --
116
+ (Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
117
+
118
+ A value that must never be reused for any other encryption done
119
+ with this key.
120
+
121
+ For ``MODE_EAX`` there are no
122
+ restrictions on its length (recommended: **16** bytes).
123
+
124
+ For ``MODE_CTR``, its length must be in the range **[0..7]**.
125
+
126
+ If not provided for ``MODE_EAX``, a random byte string is generated (you
127
+ can read it back via the ``nonce`` attribute).
128
+
129
+ * **segment_size** (*integer*) --
130
+ (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
131
+ are segmented in. It must be a multiple of 8.
132
+ If not specified, it will be assumed to be 8.
133
+
134
+ * **mac_len** : (*integer*) --
135
+ (Only ``MODE_EAX``)
136
+ Length of the authentication tag, in bytes.
137
+ It must be no longer than 8 (default).
138
+
139
+ * **initial_value** : (*integer*) --
140
+ (Only ``MODE_CTR``). The initial value for the counter within
141
+ the counter block. By default it is **0**.
142
+
143
+ :Return: a Blowfish object, of the applicable mode.
144
+ """
145
+
146
+ return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
147
+
148
+ MODE_ECB = 1
149
+ MODE_CBC = 2
150
+ MODE_CFB = 3
151
+ MODE_OFB = 5
152
+ MODE_CTR = 6
153
+ MODE_OPENPGP = 7
154
+ MODE_EAX = 9
155
+
156
+ # Size of a data block (in bytes)
157
+ block_size = 8
158
+ # Size of a key (in bytes)
159
+ key_size = range(4, 56 + 1)
runtime/Lib/site-packages/Crypto/Cipher/Blowfish.pyi ADDED
@@ -0,0 +1,35 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, Dict, Iterable
2
+
3
+ from Crypto.Cipher._mode_ecb import EcbMode
4
+ from Crypto.Cipher._mode_cbc import CbcMode
5
+ from Crypto.Cipher._mode_cfb import CfbMode
6
+ from Crypto.Cipher._mode_ofb import OfbMode
7
+ from Crypto.Cipher._mode_ctr import CtrMode
8
+ from Crypto.Cipher._mode_openpgp import OpenPgpMode
9
+ from Crypto.Cipher._mode_eax import EaxMode
10
+
11
+ BlowfishMode = int
12
+
13
+ MODE_ECB: BlowfishMode
14
+ MODE_CBC: BlowfishMode
15
+ MODE_CFB: BlowfishMode
16
+ MODE_OFB: BlowfishMode
17
+ MODE_CTR: BlowfishMode
18
+ MODE_OPENPGP: BlowfishMode
19
+ MODE_EAX: BlowfishMode
20
+
21
+ Buffer = Union[bytes, bytearray, memoryview]
22
+
23
+ def new(key: Buffer,
24
+ mode: BlowfishMode,
25
+ iv : Buffer = ...,
26
+ IV : Buffer = ...,
27
+ nonce : Buffer = ...,
28
+ segment_size : int = ...,
29
+ mac_len : int = ...,
30
+ initial_value : Union[int, Buffer] = ...,
31
+ counter : Dict = ...) -> \
32
+ Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
33
+
34
+ block_size: int
35
+ key_size: Iterable[int]
runtime/Lib/site-packages/Crypto/Cipher/CAST.py ADDED
@@ -0,0 +1,159 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/CAST.py : CAST
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+ """
23
+ Module's constants for the modes of operation supported with CAST:
24
+
25
+ :var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
26
+ :var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
27
+ :var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
28
+ :var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
29
+ :var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
30
+ :var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
31
+ :var MODE_EAX: :ref:`EAX Mode <eax_mode>`
32
+ """
33
+
34
+ import sys
35
+
36
+ from Crypto.Cipher import _create_cipher
37
+ from Crypto.Util.py3compat import byte_string
38
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
39
+ VoidPointer, SmartPointer,
40
+ c_size_t, c_uint8_ptr)
41
+
42
+ _raw_cast_lib = load_pycryptodome_raw_lib(
43
+ "Crypto.Cipher._raw_cast",
44
+ """
45
+ int CAST_start_operation(const uint8_t key[],
46
+ size_t key_len,
47
+ void **pResult);
48
+ int CAST_encrypt(const void *state,
49
+ const uint8_t *in,
50
+ uint8_t *out,
51
+ size_t data_len);
52
+ int CAST_decrypt(const void *state,
53
+ const uint8_t *in,
54
+ uint8_t *out,
55
+ size_t data_len);
56
+ int CAST_stop_operation(void *state);
57
+ """)
58
+
59
+
60
+ def _create_base_cipher(dict_parameters):
61
+ """This method instantiates and returns a handle to a low-level
62
+ base cipher. It will absorb named parameters in the process."""
63
+
64
+ try:
65
+ key = dict_parameters.pop("key")
66
+ except KeyError:
67
+ raise TypeError("Missing 'key' parameter")
68
+
69
+ if len(key) not in key_size:
70
+ raise ValueError("Incorrect CAST key length (%d bytes)" % len(key))
71
+
72
+ start_operation = _raw_cast_lib.CAST_start_operation
73
+ stop_operation = _raw_cast_lib.CAST_stop_operation
74
+
75
+ cipher = VoidPointer()
76
+ result = start_operation(c_uint8_ptr(key),
77
+ c_size_t(len(key)),
78
+ cipher.address_of())
79
+ if result:
80
+ raise ValueError("Error %X while instantiating the CAST cipher"
81
+ % result)
82
+
83
+ return SmartPointer(cipher.get(), stop_operation)
84
+
85
+
86
+ def new(key, mode, *args, **kwargs):
87
+ """Create a new CAST cipher
88
+
89
+ :param key:
90
+ The secret key to use in the symmetric cipher.
91
+ Its length can vary from 5 to 16 bytes.
92
+ :type key: bytes, bytearray, memoryview
93
+
94
+ :param mode:
95
+ The chaining mode to use for encryption or decryption.
96
+ :type mode: One of the supported ``MODE_*`` constants
97
+
98
+ :Keyword Arguments:
99
+ * **iv** (*bytes*, *bytearray*, *memoryview*) --
100
+ (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
101
+ and ``MODE_OPENPGP`` modes).
102
+
103
+ The initialization vector to use for encryption or decryption.
104
+
105
+ For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
106
+
107
+ For ``MODE_OPENPGP`` mode only,
108
+ it must be 8 bytes long for encryption
109
+ and 10 bytes for decryption (in the latter case, it is
110
+ actually the *encrypted* IV which was prefixed to the ciphertext).
111
+
112
+ If not provided, a random byte string is generated (you must then
113
+ read its value with the :attr:`iv` attribute).
114
+
115
+ * **nonce** (*bytes*, *bytearray*, *memoryview*) --
116
+ (Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
117
+
118
+ A value that must never be reused for any other encryption done
119
+ with this key.
120
+
121
+ For ``MODE_EAX`` there are no
122
+ restrictions on its length (recommended: **16** bytes).
123
+
124
+ For ``MODE_CTR``, its length must be in the range **[0..7]**.
125
+
126
+ If not provided for ``MODE_EAX``, a random byte string is generated (you
127
+ can read it back via the ``nonce`` attribute).
128
+
129
+ * **segment_size** (*integer*) --
130
+ (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
131
+ are segmented in. It must be a multiple of 8.
132
+ If not specified, it will be assumed to be 8.
133
+
134
+ * **mac_len** : (*integer*) --
135
+ (Only ``MODE_EAX``)
136
+ Length of the authentication tag, in bytes.
137
+ It must be no longer than 8 (default).
138
+
139
+ * **initial_value** : (*integer*) --
140
+ (Only ``MODE_CTR``). The initial value for the counter within
141
+ the counter block. By default it is **0**.
142
+
143
+ :Return: a CAST object, of the applicable mode.
144
+ """
145
+
146
+ return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
147
+
148
+ MODE_ECB = 1
149
+ MODE_CBC = 2
150
+ MODE_CFB = 3
151
+ MODE_OFB = 5
152
+ MODE_CTR = 6
153
+ MODE_OPENPGP = 7
154
+ MODE_EAX = 9
155
+
156
+ # Size of a data block (in bytes)
157
+ block_size = 8
158
+ # Size of a key (in bytes)
159
+ key_size = range(5, 16 + 1)
runtime/Lib/site-packages/Crypto/Cipher/CAST.pyi ADDED
@@ -0,0 +1,35 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, Dict, Iterable
2
+
3
+ from Crypto.Cipher._mode_ecb import EcbMode
4
+ from Crypto.Cipher._mode_cbc import CbcMode
5
+ from Crypto.Cipher._mode_cfb import CfbMode
6
+ from Crypto.Cipher._mode_ofb import OfbMode
7
+ from Crypto.Cipher._mode_ctr import CtrMode
8
+ from Crypto.Cipher._mode_openpgp import OpenPgpMode
9
+ from Crypto.Cipher._mode_eax import EaxMode
10
+
11
+ CASTMode = int
12
+
13
+ MODE_ECB: CASTMode
14
+ MODE_CBC: CASTMode
15
+ MODE_CFB: CASTMode
16
+ MODE_OFB: CASTMode
17
+ MODE_CTR: CASTMode
18
+ MODE_OPENPGP: CASTMode
19
+ MODE_EAX: CASTMode
20
+
21
+ Buffer = Union[bytes, bytearray, memoryview]
22
+
23
+ def new(key: Buffer,
24
+ mode: CASTMode,
25
+ iv : Buffer = ...,
26
+ IV : Buffer = ...,
27
+ nonce : Buffer = ...,
28
+ segment_size : int = ...,
29
+ mac_len : int = ...,
30
+ initial_value : Union[int, Buffer] = ...,
31
+ counter : Dict = ...) -> \
32
+ Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
33
+
34
+ block_size: int
35
+ key_size : Iterable[int]
runtime/Lib/site-packages/Crypto/Cipher/ChaCha20.py ADDED
@@ -0,0 +1,287 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # ===================================================================
2
+ #
3
+ # Copyright (c) 2014, Legrandin <helderijs@gmail.com>
4
+ # All rights reserved.
5
+ #
6
+ # Redistribution and use in source and binary forms, with or without
7
+ # modification, are permitted provided that the following conditions
8
+ # are met:
9
+ #
10
+ # 1. Redistributions of source code must retain the above copyright
11
+ # notice, this list of conditions and the following disclaimer.
12
+ # 2. Redistributions in binary form must reproduce the above copyright
13
+ # notice, this list of conditions and the following disclaimer in
14
+ # the documentation and/or other materials provided with the
15
+ # distribution.
16
+ #
17
+ # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18
+ # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19
+ # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20
+ # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21
+ # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22
+ # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23
+ # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24
+ # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25
+ # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
+ # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
27
+ # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28
+ # POSSIBILITY OF SUCH DAMAGE.
29
+ # ===================================================================
30
+
31
+ from Crypto.Random import get_random_bytes
32
+
33
+ from Crypto.Util.py3compat import _copy_bytes
34
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
35
+ create_string_buffer,
36
+ get_raw_buffer, VoidPointer,
37
+ SmartPointer, c_size_t,
38
+ c_uint8_ptr, c_ulong,
39
+ is_writeable_buffer)
40
+
41
+ _raw_chacha20_lib = load_pycryptodome_raw_lib("Crypto.Cipher._chacha20",
42
+ """
43
+ int chacha20_init(void **pState,
44
+ const uint8_t *key,
45
+ size_t keySize,
46
+ const uint8_t *nonce,
47
+ size_t nonceSize);
48
+
49
+ int chacha20_destroy(void *state);
50
+
51
+ int chacha20_encrypt(void *state,
52
+ const uint8_t in[],
53
+ uint8_t out[],
54
+ size_t len);
55
+
56
+ int chacha20_seek(void *state,
57
+ unsigned long block_high,
58
+ unsigned long block_low,
59
+ unsigned offset);
60
+ int hchacha20( const uint8_t key[32],
61
+ const uint8_t nonce16[16],
62
+ uint8_t subkey[32]);
63
+ """)
64
+
65
+
66
+ def _HChaCha20(key, nonce):
67
+
68
+ assert(len(key) == 32)
69
+ assert(len(nonce) == 16)
70
+
71
+ subkey = bytearray(32)
72
+ result = _raw_chacha20_lib.hchacha20(
73
+ c_uint8_ptr(key),
74
+ c_uint8_ptr(nonce),
75
+ c_uint8_ptr(subkey))
76
+ if result:
77
+ raise ValueError("Error %d when deriving subkey with HChaCha20" % result)
78
+
79
+ return subkey
80
+
81
+
82
+ class ChaCha20Cipher(object):
83
+ """ChaCha20 (or XChaCha20) cipher object.
84
+ Do not create it directly. Use :py:func:`new` instead.
85
+
86
+ :var nonce: The nonce with length 8, 12 or 24 bytes
87
+ :vartype nonce: bytes
88
+ """
89
+
90
+ block_size = 1
91
+
92
+ def __init__(self, key, nonce):
93
+ """Initialize a ChaCha20/XChaCha20 cipher object
94
+
95
+ See also `new()` at the module level."""
96
+
97
+ self.nonce = _copy_bytes(None, None, nonce)
98
+
99
+ # XChaCha20 requires a key derivation with HChaCha20
100
+ # See 2.3 in https://tools.ietf.org/html/draft-arciszewski-xchacha-03
101
+ if len(nonce) == 24:
102
+ key = _HChaCha20(key, nonce[:16])
103
+ nonce = b'\x00' * 4 + nonce[16:]
104
+ self._name = "XChaCha20"
105
+ else:
106
+ self._name = "ChaCha20"
107
+ nonce = self.nonce
108
+
109
+ self._next = ( self.encrypt, self.decrypt )
110
+
111
+ self._state = VoidPointer()
112
+ result = _raw_chacha20_lib.chacha20_init(
113
+ self._state.address_of(),
114
+ c_uint8_ptr(key),
115
+ c_size_t(len(key)),
116
+ nonce,
117
+ c_size_t(len(nonce)))
118
+ if result:
119
+ raise ValueError("Error %d instantiating a %s cipher" % (result,
120
+ self._name))
121
+ self._state = SmartPointer(self._state.get(),
122
+ _raw_chacha20_lib.chacha20_destroy)
123
+
124
+ def encrypt(self, plaintext, output=None):
125
+ """Encrypt a piece of data.
126
+
127
+ Args:
128
+ plaintext(bytes/bytearray/memoryview): The data to encrypt, of any size.
129
+ Keyword Args:
130
+ output(bytes/bytearray/memoryview): The location where the ciphertext
131
+ is written to. If ``None``, the ciphertext is returned.
132
+ Returns:
133
+ If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
134
+ Otherwise, ``None``.
135
+ """
136
+
137
+ if self.encrypt not in self._next:
138
+ raise TypeError("Cipher object can only be used for decryption")
139
+ self._next = ( self.encrypt, )
140
+ return self._encrypt(plaintext, output)
141
+
142
+ def _encrypt(self, plaintext, output):
143
+ """Encrypt without FSM checks"""
144
+
145
+ if output is None:
146
+ ciphertext = create_string_buffer(len(plaintext))
147
+ else:
148
+ ciphertext = output
149
+
150
+ if not is_writeable_buffer(output):
151
+ raise TypeError("output must be a bytearray or a writeable memoryview")
152
+
153
+ if len(plaintext) != len(output):
154
+ raise ValueError("output must have the same length as the input"
155
+ " (%d bytes)" % len(plaintext))
156
+
157
+ result = _raw_chacha20_lib.chacha20_encrypt(
158
+ self._state.get(),
159
+ c_uint8_ptr(plaintext),
160
+ c_uint8_ptr(ciphertext),
161
+ c_size_t(len(plaintext)))
162
+ if result:
163
+ raise ValueError("Error %d while encrypting with %s" % (result, self._name))
164
+
165
+ if output is None:
166
+ return get_raw_buffer(ciphertext)
167
+ else:
168
+ return None
169
+
170
+ def decrypt(self, ciphertext, output=None):
171
+ """Decrypt a piece of data.
172
+
173
+ Args:
174
+ ciphertext(bytes/bytearray/memoryview): The data to decrypt, of any size.
175
+ Keyword Args:
176
+ output(bytes/bytearray/memoryview): The location where the plaintext
177
+ is written to. If ``None``, the plaintext is returned.
178
+ Returns:
179
+ If ``output`` is ``None``, the plaintext is returned as ``bytes``.
180
+ Otherwise, ``None``.
181
+ """
182
+
183
+ if self.decrypt not in self._next:
184
+ raise TypeError("Cipher object can only be used for encryption")
185
+ self._next = ( self.decrypt, )
186
+
187
+ try:
188
+ return self._encrypt(ciphertext, output)
189
+ except ValueError as e:
190
+ raise ValueError(str(e).replace("enc", "dec"))
191
+
192
+ def seek(self, position):
193
+ """Seek to a certain position in the key stream.
194
+
195
+ Args:
196
+ position (integer):
197
+ The absolute position within the key stream, in bytes.
198
+ """
199
+
200
+ position, offset = divmod(position, 64)
201
+ block_low = position & 0xFFFFFFFF
202
+ block_high = position >> 32
203
+
204
+ result = _raw_chacha20_lib.chacha20_seek(
205
+ self._state.get(),
206
+ c_ulong(block_high),
207
+ c_ulong(block_low),
208
+ offset
209
+ )
210
+ if result:
211
+ raise ValueError("Error %d while seeking with %s" % (result, self._name))
212
+
213
+
214
+ def _derive_Poly1305_key_pair(key, nonce):
215
+ """Derive a tuple (r, s, nonce) for a Poly1305 MAC.
216
+
217
+ If nonce is ``None``, a new 12-byte nonce is generated.
218
+ """
219
+
220
+ if len(key) != 32:
221
+ raise ValueError("Poly1305 with ChaCha20 requires a 32-byte key")
222
+
223
+ if nonce is None:
224
+ padded_nonce = nonce = get_random_bytes(12)
225
+ elif len(nonce) == 8:
226
+ # See RFC7538, 2.6: [...] ChaCha20 as specified here requires a 96-bit
227
+ # nonce. So if the provided nonce is only 64-bit, then the first 32
228
+ # bits of the nonce will be set to a constant number.
229
+ # This will usually be zero, but for protocols with multiple senders it may be
230
+ # different for each sender, but should be the same for all
231
+ # invocations of the function with the same key by a particular
232
+ # sender.
233
+ padded_nonce = b'\x00\x00\x00\x00' + nonce
234
+ elif len(nonce) == 12:
235
+ padded_nonce = nonce
236
+ else:
237
+ raise ValueError("Poly1305 with ChaCha20 requires an 8- or 12-byte nonce")
238
+
239
+ rs = new(key=key, nonce=padded_nonce).encrypt(b'\x00' * 32)
240
+ return rs[:16], rs[16:], nonce
241
+
242
+
243
+ def new(**kwargs):
244
+ """Create a new ChaCha20 or XChaCha20 cipher
245
+
246
+ Keyword Args:
247
+ key (bytes/bytearray/memoryview): The secret key to use.
248
+ It must be 32 bytes long.
249
+ nonce (bytes/bytearray/memoryview): A mandatory value that
250
+ must never be reused for any other encryption
251
+ done with this key.
252
+
253
+ For ChaCha20, it must be 8 or 12 bytes long.
254
+
255
+ For XChaCha20, it must be 24 bytes long.
256
+
257
+ If not provided, 8 bytes will be randomly generated
258
+ (you can find them back in the ``nonce`` attribute).
259
+
260
+ :Return: a :class:`Crypto.Cipher.ChaCha20.ChaCha20Cipher` object
261
+ """
262
+
263
+ try:
264
+ key = kwargs.pop("key")
265
+ except KeyError as e:
266
+ raise TypeError("Missing parameter %s" % e)
267
+
268
+ nonce = kwargs.pop("nonce", None)
269
+ if nonce is None:
270
+ nonce = get_random_bytes(8)
271
+
272
+ if len(key) != 32:
273
+ raise ValueError("ChaCha20/XChaCha20 key must be 32 bytes long")
274
+
275
+ if len(nonce) not in (8, 12, 24):
276
+ raise ValueError("Nonce must be 8/12 bytes(ChaCha20) or 24 bytes (XChaCha20)")
277
+
278
+ if kwargs:
279
+ raise TypeError("Unknown parameters: " + str(kwargs))
280
+
281
+ return ChaCha20Cipher(key, nonce)
282
+
283
+ # Size of a data block (in bytes)
284
+ block_size = 1
285
+
286
+ # Size of a key (in bytes)
287
+ key_size = 32
runtime/Lib/site-packages/Crypto/Cipher/ChaCha20.pyi ADDED
@@ -0,0 +1,25 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, overload
2
+
3
+ Buffer = Union[bytes, bytearray, memoryview]
4
+
5
+ def _HChaCha20(key: Buffer, nonce: Buffer) -> bytearray: ...
6
+
7
+ class ChaCha20Cipher:
8
+ block_size: int
9
+ nonce: bytes
10
+
11
+ def __init__(self, key: Buffer, nonce: Buffer) -> None: ...
12
+ @overload
13
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
14
+ @overload
15
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
16
+ @overload
17
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
18
+ @overload
19
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
20
+ def seek(self, position: int) -> None: ...
21
+
22
+ def new(key: Buffer, nonce: Buffer = ...) -> ChaCha20Cipher: ...
23
+
24
+ block_size: int
25
+ key_size: int
runtime/Lib/site-packages/Crypto/Cipher/ChaCha20_Poly1305.py ADDED
@@ -0,0 +1,336 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # ===================================================================
2
+ #
3
+ # Copyright (c) 2018, Helder Eijs <helderijs@gmail.com>
4
+ # All rights reserved.
5
+ #
6
+ # Redistribution and use in source and binary forms, with or without
7
+ # modification, are permitted provided that the following conditions
8
+ # are met:
9
+ #
10
+ # 1. Redistributions of source code must retain the above copyright
11
+ # notice, this list of conditions and the following disclaimer.
12
+ # 2. Redistributions in binary form must reproduce the above copyright
13
+ # notice, this list of conditions and the following disclaimer in
14
+ # the documentation and/or other materials provided with the
15
+ # distribution.
16
+ #
17
+ # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18
+ # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19
+ # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20
+ # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21
+ # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22
+ # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23
+ # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24
+ # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25
+ # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
+ # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
27
+ # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28
+ # POSSIBILITY OF SUCH DAMAGE.
29
+ # ===================================================================
30
+
31
+ from binascii import unhexlify
32
+
33
+ from Crypto.Cipher import ChaCha20
34
+ from Crypto.Cipher.ChaCha20 import _HChaCha20
35
+ from Crypto.Hash import Poly1305, BLAKE2s
36
+
37
+ from Crypto.Random import get_random_bytes
38
+
39
+ from Crypto.Util.number import long_to_bytes
40
+ from Crypto.Util.py3compat import _copy_bytes, bord
41
+ from Crypto.Util._raw_api import is_buffer
42
+
43
+
44
+ def _enum(**enums):
45
+ return type('Enum', (), enums)
46
+
47
+
48
+ _CipherStatus = _enum(PROCESSING_AUTH_DATA=1,
49
+ PROCESSING_CIPHERTEXT=2,
50
+ PROCESSING_DONE=3)
51
+
52
+
53
+ class ChaCha20Poly1305Cipher(object):
54
+ """ChaCha20-Poly1305 and XChaCha20-Poly1305 cipher object.
55
+ Do not create it directly. Use :py:func:`new` instead.
56
+
57
+ :var nonce: The nonce with length 8, 12 or 24 bytes
58
+ :vartype nonce: byte string
59
+ """
60
+
61
+ def __init__(self, key, nonce):
62
+ """Initialize a ChaCha20-Poly1305 AEAD cipher object
63
+
64
+ See also `new()` at the module level."""
65
+
66
+ self.nonce = _copy_bytes(None, None, nonce)
67
+
68
+ self._next = (self.update, self.encrypt, self.decrypt, self.digest,
69
+ self.verify)
70
+
71
+ self._authenticator = Poly1305.new(key=key, nonce=nonce, cipher=ChaCha20)
72
+
73
+ self._cipher = ChaCha20.new(key=key, nonce=nonce)
74
+ self._cipher.seek(64) # Block counter starts at 1
75
+
76
+ self._len_aad = 0
77
+ self._len_ct = 0
78
+ self._mac_tag = None
79
+ self._status = _CipherStatus.PROCESSING_AUTH_DATA
80
+
81
+ def update(self, data):
82
+ """Protect the associated data.
83
+
84
+ Associated data (also known as *additional authenticated data* - AAD)
85
+ is the piece of the message that must stay in the clear, while
86
+ still allowing the receiver to verify its integrity.
87
+ An example is packet headers.
88
+
89
+ The associated data (possibly split into multiple segments) is
90
+ fed into :meth:`update` before any call to :meth:`decrypt` or :meth:`encrypt`.
91
+ If there is no associated data, :meth:`update` is not called.
92
+
93
+ :param bytes/bytearray/memoryview assoc_data:
94
+ A piece of associated data. There are no restrictions on its size.
95
+ """
96
+
97
+ if self.update not in self._next:
98
+ raise TypeError("update() method cannot be called")
99
+
100
+ self._len_aad += len(data)
101
+ self._authenticator.update(data)
102
+
103
+ def _pad_aad(self):
104
+
105
+ assert(self._status == _CipherStatus.PROCESSING_AUTH_DATA)
106
+ if self._len_aad & 0x0F:
107
+ self._authenticator.update(b'\x00' * (16 - (self._len_aad & 0x0F)))
108
+ self._status = _CipherStatus.PROCESSING_CIPHERTEXT
109
+
110
+ def encrypt(self, plaintext, output=None):
111
+ """Encrypt a piece of data.
112
+
113
+ Args:
114
+ plaintext(bytes/bytearray/memoryview): The data to encrypt, of any size.
115
+ Keyword Args:
116
+ output(bytes/bytearray/memoryview): The location where the ciphertext
117
+ is written to. If ``None``, the ciphertext is returned.
118
+ Returns:
119
+ If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
120
+ Otherwise, ``None``.
121
+ """
122
+
123
+ if self.encrypt not in self._next:
124
+ raise TypeError("encrypt() method cannot be called")
125
+
126
+ if self._status == _CipherStatus.PROCESSING_AUTH_DATA:
127
+ self._pad_aad()
128
+
129
+ self._next = (self.encrypt, self.digest)
130
+
131
+ result = self._cipher.encrypt(plaintext, output=output)
132
+ self._len_ct += len(plaintext)
133
+ if output is None:
134
+ self._authenticator.update(result)
135
+ else:
136
+ self._authenticator.update(output)
137
+ return result
138
+
139
+ def decrypt(self, ciphertext, output=None):
140
+ """Decrypt a piece of data.
141
+
142
+ Args:
143
+ ciphertext(bytes/bytearray/memoryview): The data to decrypt, of any size.
144
+ Keyword Args:
145
+ output(bytes/bytearray/memoryview): The location where the plaintext
146
+ is written to. If ``None``, the plaintext is returned.
147
+ Returns:
148
+ If ``output`` is ``None``, the plaintext is returned as ``bytes``.
149
+ Otherwise, ``None``.
150
+ """
151
+
152
+ if self.decrypt not in self._next:
153
+ raise TypeError("decrypt() method cannot be called")
154
+
155
+ if self._status == _CipherStatus.PROCESSING_AUTH_DATA:
156
+ self._pad_aad()
157
+
158
+ self._next = (self.decrypt, self.verify)
159
+
160
+ self._len_ct += len(ciphertext)
161
+ self._authenticator.update(ciphertext)
162
+ return self._cipher.decrypt(ciphertext, output=output)
163
+
164
+ def _compute_mac(self):
165
+ """Finalize the cipher (if not done already) and return the MAC."""
166
+
167
+ if self._mac_tag:
168
+ assert(self._status == _CipherStatus.PROCESSING_DONE)
169
+ return self._mac_tag
170
+
171
+ assert(self._status != _CipherStatus.PROCESSING_DONE)
172
+
173
+ if self._status == _CipherStatus.PROCESSING_AUTH_DATA:
174
+ self._pad_aad()
175
+
176
+ if self._len_ct & 0x0F:
177
+ self._authenticator.update(b'\x00' * (16 - (self._len_ct & 0x0F)))
178
+
179
+ self._status = _CipherStatus.PROCESSING_DONE
180
+
181
+ self._authenticator.update(long_to_bytes(self._len_aad, 8)[::-1])
182
+ self._authenticator.update(long_to_bytes(self._len_ct, 8)[::-1])
183
+ self._mac_tag = self._authenticator.digest()
184
+ return self._mac_tag
185
+
186
+ def digest(self):
187
+ """Compute the *binary* authentication tag (MAC).
188
+
189
+ :Return: the MAC tag, as 16 ``bytes``.
190
+ """
191
+
192
+ if self.digest not in self._next:
193
+ raise TypeError("digest() method cannot be called")
194
+ self._next = (self.digest,)
195
+
196
+ return self._compute_mac()
197
+
198
+ def hexdigest(self):
199
+ """Compute the *printable* authentication tag (MAC).
200
+
201
+ This method is like :meth:`digest`.
202
+
203
+ :Return: the MAC tag, as a hexadecimal string.
204
+ """
205
+ return "".join(["%02x" % bord(x) for x in self.digest()])
206
+
207
+ def verify(self, received_mac_tag):
208
+ """Validate the *binary* authentication tag (MAC).
209
+
210
+ The receiver invokes this method at the very end, to
211
+ check if the associated data (if any) and the decrypted
212
+ messages are valid.
213
+
214
+ :param bytes/bytearray/memoryview received_mac_tag:
215
+ This is the 16-byte *binary* MAC, as received from the sender.
216
+ :Raises ValueError:
217
+ if the MAC does not match. The message has been tampered with
218
+ or the key is incorrect.
219
+ """
220
+
221
+ if self.verify not in self._next:
222
+ raise TypeError("verify() cannot be called"
223
+ " when encrypting a message")
224
+ self._next = (self.verify,)
225
+
226
+ secret = get_random_bytes(16)
227
+
228
+ self._compute_mac()
229
+
230
+ mac1 = BLAKE2s.new(digest_bits=160, key=secret,
231
+ data=self._mac_tag)
232
+ mac2 = BLAKE2s.new(digest_bits=160, key=secret,
233
+ data=received_mac_tag)
234
+
235
+ if mac1.digest() != mac2.digest():
236
+ raise ValueError("MAC check failed")
237
+
238
+ def hexverify(self, hex_mac_tag):
239
+ """Validate the *printable* authentication tag (MAC).
240
+
241
+ This method is like :meth:`verify`.
242
+
243
+ :param string hex_mac_tag:
244
+ This is the *printable* MAC.
245
+ :Raises ValueError:
246
+ if the MAC does not match. The message has been tampered with
247
+ or the key is incorrect.
248
+ """
249
+
250
+ self.verify(unhexlify(hex_mac_tag))
251
+
252
+ def encrypt_and_digest(self, plaintext):
253
+ """Perform :meth:`encrypt` and :meth:`digest` in one step.
254
+
255
+ :param plaintext: The data to encrypt, of any size.
256
+ :type plaintext: bytes/bytearray/memoryview
257
+ :return: a tuple with two ``bytes`` objects:
258
+
259
+ - the ciphertext, of equal length as the plaintext
260
+ - the 16-byte MAC tag
261
+ """
262
+
263
+ return self.encrypt(plaintext), self.digest()
264
+
265
+ def decrypt_and_verify(self, ciphertext, received_mac_tag):
266
+ """Perform :meth:`decrypt` and :meth:`verify` in one step.
267
+
268
+ :param ciphertext: The piece of data to decrypt.
269
+ :type ciphertext: bytes/bytearray/memoryview
270
+ :param bytes received_mac_tag:
271
+ This is the 16-byte *binary* MAC, as received from the sender.
272
+ :return: the decrypted data (as ``bytes``)
273
+ :raises ValueError:
274
+ if the MAC does not match. The message has been tampered with
275
+ or the key is incorrect.
276
+ """
277
+
278
+ plaintext = self.decrypt(ciphertext)
279
+ self.verify(received_mac_tag)
280
+ return plaintext
281
+
282
+
283
+ def new(**kwargs):
284
+ """Create a new ChaCha20-Poly1305 or XChaCha20-Poly1305 AEAD cipher.
285
+
286
+ :keyword key: The secret key to use. It must be 32 bytes long.
287
+ :type key: byte string
288
+
289
+ :keyword nonce:
290
+ A value that must never be reused for any other encryption
291
+ done with this key.
292
+
293
+ For ChaCha20-Poly1305, it must be 8 or 12 bytes long.
294
+
295
+ For XChaCha20-Poly1305, it must be 24 bytes long.
296
+
297
+ If not provided, 12 ``bytes`` will be generated randomly
298
+ (you can find them back in the ``nonce`` attribute).
299
+ :type nonce: bytes, bytearray, memoryview
300
+
301
+ :Return: a :class:`Crypto.Cipher.ChaCha20.ChaCha20Poly1305Cipher` object
302
+ """
303
+
304
+ try:
305
+ key = kwargs.pop("key")
306
+ except KeyError as e:
307
+ raise TypeError("Missing parameter %s" % e)
308
+
309
+ self._len_ct += len(plaintext)
310
+
311
+ if len(key) != 32:
312
+ raise ValueError("Key must be 32 bytes long")
313
+
314
+ nonce = kwargs.pop("nonce", None)
315
+ if nonce is None:
316
+ nonce = get_random_bytes(12)
317
+
318
+ if len(nonce) in (8, 12):
319
+ pass
320
+ elif len(nonce) == 24:
321
+ key = _HChaCha20(key, nonce[:16])
322
+ nonce = b'\x00\x00\x00\x00' + nonce[16:]
323
+ else:
324
+ raise ValueError("Nonce must be 8, 12 or 24 bytes long")
325
+
326
+ if not is_buffer(nonce):
327
+ raise TypeError("nonce must be bytes, bytearray or memoryview")
328
+
329
+ if kwargs:
330
+ raise TypeError("Unknown parameters: " + str(kwargs))
331
+
332
+ return ChaCha20Poly1305Cipher(key, nonce)
333
+
334
+
335
+ # Size of a key (in bytes)
336
+ key_size = 32
runtime/Lib/site-packages/Crypto/Cipher/ChaCha20_Poly1305.pyi ADDED
@@ -0,0 +1,28 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, Tuple, overload
2
+
3
+ Buffer = Union[bytes, bytearray, memoryview]
4
+
5
+ class ChaCha20Poly1305Cipher:
6
+ nonce: bytes
7
+
8
+ def __init__(self, key: Buffer, nonce: Buffer) -> None: ...
9
+ def update(self, data: Buffer) -> None: ...
10
+ @overload
11
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
12
+ @overload
13
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
14
+ @overload
15
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
16
+ @overload
17
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
18
+ def digest(self) -> bytes: ...
19
+ def hexdigest(self) -> str: ...
20
+ def verify(self, received_mac_tag: Buffer) -> None: ...
21
+ def hexverify(self, received_mac_tag: str) -> None: ...
22
+ def encrypt_and_digest(self, plaintext: Buffer) -> Tuple[bytes, bytes]: ...
23
+ def decrypt_and_verify(self, ciphertext: Buffer, received_mac_tag: Buffer) -> bytes: ...
24
+
25
+ def new(key: Buffer, nonce: Buffer = ...) -> ChaCha20Poly1305Cipher: ...
26
+
27
+ block_size: int
28
+ key_size: int
runtime/Lib/site-packages/Crypto/Cipher/DES.py ADDED
@@ -0,0 +1,158 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/DES.py : DES
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+ """
23
+ Module's constants for the modes of operation supported with Single DES:
24
+
25
+ :var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
26
+ :var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
27
+ :var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
28
+ :var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
29
+ :var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
30
+ :var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
31
+ :var MODE_EAX: :ref:`EAX Mode <eax_mode>`
32
+ """
33
+
34
+ import sys
35
+
36
+ from Crypto.Cipher import _create_cipher
37
+ from Crypto.Util.py3compat import byte_string
38
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
39
+ VoidPointer, SmartPointer,
40
+ c_size_t, c_uint8_ptr)
41
+
42
+ _raw_des_lib = load_pycryptodome_raw_lib(
43
+ "Crypto.Cipher._raw_des",
44
+ """
45
+ int DES_start_operation(const uint8_t key[],
46
+ size_t key_len,
47
+ void **pResult);
48
+ int DES_encrypt(const void *state,
49
+ const uint8_t *in,
50
+ uint8_t *out,
51
+ size_t data_len);
52
+ int DES_decrypt(const void *state,
53
+ const uint8_t *in,
54
+ uint8_t *out,
55
+ size_t data_len);
56
+ int DES_stop_operation(void *state);
57
+ """)
58
+
59
+
60
+ def _create_base_cipher(dict_parameters):
61
+ """This method instantiates and returns a handle to a low-level
62
+ base cipher. It will absorb named parameters in the process."""
63
+
64
+ try:
65
+ key = dict_parameters.pop("key")
66
+ except KeyError:
67
+ raise TypeError("Missing 'key' parameter")
68
+
69
+ if len(key) != key_size:
70
+ raise ValueError("Incorrect DES key length (%d bytes)" % len(key))
71
+
72
+ start_operation = _raw_des_lib.DES_start_operation
73
+ stop_operation = _raw_des_lib.DES_stop_operation
74
+
75
+ cipher = VoidPointer()
76
+ result = start_operation(c_uint8_ptr(key),
77
+ c_size_t(len(key)),
78
+ cipher.address_of())
79
+ if result:
80
+ raise ValueError("Error %X while instantiating the DES cipher"
81
+ % result)
82
+ return SmartPointer(cipher.get(), stop_operation)
83
+
84
+
85
+ def new(key, mode, *args, **kwargs):
86
+ """Create a new DES cipher.
87
+
88
+ :param key:
89
+ The secret key to use in the symmetric cipher.
90
+ It must be 8 byte long. The parity bits will be ignored.
91
+ :type key: bytes/bytearray/memoryview
92
+
93
+ :param mode:
94
+ The chaining mode to use for encryption or decryption.
95
+ :type mode: One of the supported ``MODE_*`` constants
96
+
97
+ :Keyword Arguments:
98
+ * **iv** (*byte string*) --
99
+ (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
100
+ and ``MODE_OPENPGP`` modes).
101
+
102
+ The initialization vector to use for encryption or decryption.
103
+
104
+ For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
105
+
106
+ For ``MODE_OPENPGP`` mode only,
107
+ it must be 8 bytes long for encryption
108
+ and 10 bytes for decryption (in the latter case, it is
109
+ actually the *encrypted* IV which was prefixed to the ciphertext).
110
+
111
+ If not provided, a random byte string is generated (you must then
112
+ read its value with the :attr:`iv` attribute).
113
+
114
+ * **nonce** (*byte string*) --
115
+ (Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
116
+
117
+ A value that must never be reused for any other encryption done
118
+ with this key.
119
+
120
+ For ``MODE_EAX`` there are no
121
+ restrictions on its length (recommended: **16** bytes).
122
+
123
+ For ``MODE_CTR``, its length must be in the range **[0..7]**.
124
+
125
+ If not provided for ``MODE_EAX``, a random byte string is generated (you
126
+ can read it back via the ``nonce`` attribute).
127
+
128
+ * **segment_size** (*integer*) --
129
+ (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
130
+ are segmented in. It must be a multiple of 8.
131
+ If not specified, it will be assumed to be 8.
132
+
133
+ * **mac_len** : (*integer*) --
134
+ (Only ``MODE_EAX``)
135
+ Length of the authentication tag, in bytes.
136
+ It must be no longer than 8 (default).
137
+
138
+ * **initial_value** : (*integer*) --
139
+ (Only ``MODE_CTR``). The initial value for the counter within
140
+ the counter block. By default it is **0**.
141
+
142
+ :Return: a DES object, of the applicable mode.
143
+ """
144
+
145
+ return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
146
+
147
+ MODE_ECB = 1
148
+ MODE_CBC = 2
149
+ MODE_CFB = 3
150
+ MODE_OFB = 5
151
+ MODE_CTR = 6
152
+ MODE_OPENPGP = 7
153
+ MODE_EAX = 9
154
+
155
+ # Size of a data block (in bytes)
156
+ block_size = 8
157
+ # Size of a key (in bytes)
158
+ key_size = 8
runtime/Lib/site-packages/Crypto/Cipher/DES.pyi ADDED
@@ -0,0 +1,35 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, Dict, Iterable
2
+
3
+ from Crypto.Cipher._mode_ecb import EcbMode
4
+ from Crypto.Cipher._mode_cbc import CbcMode
5
+ from Crypto.Cipher._mode_cfb import CfbMode
6
+ from Crypto.Cipher._mode_ofb import OfbMode
7
+ from Crypto.Cipher._mode_ctr import CtrMode
8
+ from Crypto.Cipher._mode_openpgp import OpenPgpMode
9
+ from Crypto.Cipher._mode_eax import EaxMode
10
+
11
+ DESMode = int
12
+
13
+ MODE_ECB: DESMode
14
+ MODE_CBC: DESMode
15
+ MODE_CFB: DESMode
16
+ MODE_OFB: DESMode
17
+ MODE_CTR: DESMode
18
+ MODE_OPENPGP: DESMode
19
+ MODE_EAX: DESMode
20
+
21
+ Buffer = Union[bytes, bytearray, memoryview]
22
+
23
+ def new(key: Buffer,
24
+ mode: DESMode,
25
+ iv : Buffer = ...,
26
+ IV : Buffer = ...,
27
+ nonce : Buffer = ...,
28
+ segment_size : int = ...,
29
+ mac_len : int = ...,
30
+ initial_value : Union[int, Buffer] = ...,
31
+ counter : Dict = ...) -> \
32
+ Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
33
+
34
+ block_size: int
35
+ key_size: int
runtime/Lib/site-packages/Crypto/Cipher/DES3.py ADDED
@@ -0,0 +1,187 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/DES3.py : DES3
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+ """
23
+ Module's constants for the modes of operation supported with Triple DES:
24
+
25
+ :var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
26
+ :var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
27
+ :var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
28
+ :var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
29
+ :var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
30
+ :var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
31
+ :var MODE_EAX: :ref:`EAX Mode <eax_mode>`
32
+ """
33
+
34
+ import sys
35
+
36
+ from Crypto.Cipher import _create_cipher
37
+ from Crypto.Util.py3compat import byte_string, bchr, bord, bstr
38
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
39
+ VoidPointer, SmartPointer,
40
+ c_size_t)
41
+
42
+ _raw_des3_lib = load_pycryptodome_raw_lib(
43
+ "Crypto.Cipher._raw_des3",
44
+ """
45
+ int DES3_start_operation(const uint8_t key[],
46
+ size_t key_len,
47
+ void **pResult);
48
+ int DES3_encrypt(const void *state,
49
+ const uint8_t *in,
50
+ uint8_t *out,
51
+ size_t data_len);
52
+ int DES3_decrypt(const void *state,
53
+ const uint8_t *in,
54
+ uint8_t *out,
55
+ size_t data_len);
56
+ int DES3_stop_operation(void *state);
57
+ """)
58
+
59
+
60
+ def adjust_key_parity(key_in):
61
+ """Set the parity bits in a TDES key.
62
+
63
+ :param key_in: the TDES key whose bits need to be adjusted
64
+ :type key_in: byte string
65
+
66
+ :returns: a copy of ``key_in``, with the parity bits correctly set
67
+ :rtype: byte string
68
+
69
+ :raises ValueError: if the TDES key is not 16 or 24 bytes long
70
+ :raises ValueError: if the TDES key degenerates into Single DES
71
+ """
72
+
73
+ def parity_byte(key_byte):
74
+ parity = 1
75
+ for i in range(1, 8):
76
+ parity ^= (key_byte >> i) & 1
77
+ return (key_byte & 0xFE) | parity
78
+
79
+ if len(key_in) not in key_size:
80
+ raise ValueError("Not a valid TDES key")
81
+
82
+ key_out = b"".join([ bchr(parity_byte(bord(x))) for x in key_in ])
83
+
84
+ if key_out[:8] == key_out[8:16] or key_out[-16:-8] == key_out[-8:]:
85
+ raise ValueError("Triple DES key degenerates to single DES")
86
+
87
+ return key_out
88
+
89
+
90
+ def _create_base_cipher(dict_parameters):
91
+ """This method instantiates and returns a handle to a low-level base cipher.
92
+ It will absorb named parameters in the process."""
93
+
94
+ try:
95
+ key_in = dict_parameters.pop("key")
96
+ except KeyError:
97
+ raise TypeError("Missing 'key' parameter")
98
+
99
+ key = adjust_key_parity(bstr(key_in))
100
+
101
+ start_operation = _raw_des3_lib.DES3_start_operation
102
+ stop_operation = _raw_des3_lib.DES3_stop_operation
103
+
104
+ cipher = VoidPointer()
105
+ result = start_operation(key,
106
+ c_size_t(len(key)),
107
+ cipher.address_of())
108
+ if result:
109
+ raise ValueError("Error %X while instantiating the TDES cipher"
110
+ % result)
111
+ return SmartPointer(cipher.get(), stop_operation)
112
+
113
+
114
+ def new(key, mode, *args, **kwargs):
115
+ """Create a new Triple DES cipher.
116
+
117
+ :param key:
118
+ The secret key to use in the symmetric cipher.
119
+ It must be 16 or 24 byte long. The parity bits will be ignored.
120
+ :type key: bytes/bytearray/memoryview
121
+
122
+ :param mode:
123
+ The chaining mode to use for encryption or decryption.
124
+ :type mode: One of the supported ``MODE_*`` constants
125
+
126
+ :Keyword Arguments:
127
+ * **iv** (*bytes*, *bytearray*, *memoryview*) --
128
+ (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
129
+ and ``MODE_OPENPGP`` modes).
130
+
131
+ The initialization vector to use for encryption or decryption.
132
+
133
+ For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
134
+
135
+ For ``MODE_OPENPGP`` mode only,
136
+ it must be 8 bytes long for encryption
137
+ and 10 bytes for decryption (in the latter case, it is
138
+ actually the *encrypted* IV which was prefixed to the ciphertext).
139
+
140
+ If not provided, a random byte string is generated (you must then
141
+ read its value with the :attr:`iv` attribute).
142
+
143
+ * **nonce** (*bytes*, *bytearray*, *memoryview*) --
144
+ (Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
145
+
146
+ A value that must never be reused for any other encryption done
147
+ with this key.
148
+
149
+ For ``MODE_EAX`` there are no
150
+ restrictions on its length (recommended: **16** bytes).
151
+
152
+ For ``MODE_CTR``, its length must be in the range **[0..7]**.
153
+
154
+ If not provided for ``MODE_EAX``, a random byte string is generated (you
155
+ can read it back via the ``nonce`` attribute).
156
+
157
+ * **segment_size** (*integer*) --
158
+ (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
159
+ are segmented in. It must be a multiple of 8.
160
+ If not specified, it will be assumed to be 8.
161
+
162
+ * **mac_len** : (*integer*) --
163
+ (Only ``MODE_EAX``)
164
+ Length of the authentication tag, in bytes.
165
+ It must be no longer than 8 (default).
166
+
167
+ * **initial_value** : (*integer*) --
168
+ (Only ``MODE_CTR``). The initial value for the counter within
169
+ the counter block. By default it is **0**.
170
+
171
+ :Return: a Triple DES object, of the applicable mode.
172
+ """
173
+
174
+ return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
175
+
176
+ MODE_ECB = 1
177
+ MODE_CBC = 2
178
+ MODE_CFB = 3
179
+ MODE_OFB = 5
180
+ MODE_CTR = 6
181
+ MODE_OPENPGP = 7
182
+ MODE_EAX = 9
183
+
184
+ # Size of a data block (in bytes)
185
+ block_size = 8
186
+ # Size of a key (in bytes)
187
+ key_size = (16, 24)
runtime/Lib/site-packages/Crypto/Cipher/DES3.pyi ADDED
@@ -0,0 +1,37 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, Dict, Tuple
2
+
3
+ from Crypto.Cipher._mode_ecb import EcbMode
4
+ from Crypto.Cipher._mode_cbc import CbcMode
5
+ from Crypto.Cipher._mode_cfb import CfbMode
6
+ from Crypto.Cipher._mode_ofb import OfbMode
7
+ from Crypto.Cipher._mode_ctr import CtrMode
8
+ from Crypto.Cipher._mode_openpgp import OpenPgpMode
9
+ from Crypto.Cipher._mode_eax import EaxMode
10
+
11
+ def adjust_key_parity(key_in: bytes) -> bytes: ...
12
+
13
+ DES3Mode = int
14
+
15
+ MODE_ECB: DES3Mode
16
+ MODE_CBC: DES3Mode
17
+ MODE_CFB: DES3Mode
18
+ MODE_OFB: DES3Mode
19
+ MODE_CTR: DES3Mode
20
+ MODE_OPENPGP: DES3Mode
21
+ MODE_EAX: DES3Mode
22
+
23
+ Buffer = Union[bytes, bytearray, memoryview]
24
+
25
+ def new(key: Buffer,
26
+ mode: DES3Mode,
27
+ iv : Buffer = ...,
28
+ IV : Buffer = ...,
29
+ nonce : Buffer = ...,
30
+ segment_size : int = ...,
31
+ mac_len : int = ...,
32
+ initial_value : Union[int, Buffer] = ...,
33
+ counter : Dict = ...) -> \
34
+ Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
35
+
36
+ block_size: int
37
+ key_size: Tuple[int, int]
runtime/Lib/site-packages/Crypto/Cipher/PKCS1_OAEP.py ADDED
@@ -0,0 +1,239 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/PKCS1_OAEP.py : PKCS#1 OAEP
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+
23
+ from Crypto.Signature.pss import MGF1
24
+ import Crypto.Hash.SHA1
25
+
26
+ from Crypto.Util.py3compat import bord, _copy_bytes
27
+ import Crypto.Util.number
28
+ from Crypto.Util.number import ceil_div, bytes_to_long, long_to_bytes
29
+ from Crypto.Util.strxor import strxor
30
+ from Crypto import Random
31
+
32
+ class PKCS1OAEP_Cipher:
33
+ """Cipher object for PKCS#1 v1.5 OAEP.
34
+ Do not create directly: use :func:`new` instead."""
35
+
36
+ def __init__(self, key, hashAlgo, mgfunc, label, randfunc):
37
+ """Initialize this PKCS#1 OAEP cipher object.
38
+
39
+ :Parameters:
40
+ key : an RSA key object
41
+ If a private half is given, both encryption and decryption are possible.
42
+ If a public half is given, only encryption is possible.
43
+ hashAlgo : hash object
44
+ The hash function to use. This can be a module under `Crypto.Hash`
45
+ or an existing hash object created from any of such modules. If not specified,
46
+ `Crypto.Hash.SHA1` is used.
47
+ mgfunc : callable
48
+ A mask generation function that accepts two parameters: a string to
49
+ use as seed, and the lenth of the mask to generate, in bytes.
50
+ If not specified, the standard MGF1 consistent with ``hashAlgo`` is used (a safe choice).
51
+ label : bytes/bytearray/memoryview
52
+ A label to apply to this particular encryption. If not specified,
53
+ an empty string is used. Specifying a label does not improve
54
+ security.
55
+ randfunc : callable
56
+ A function that returns random bytes.
57
+
58
+ :attention: Modify the mask generation function only if you know what you are doing.
59
+ Sender and receiver must use the same one.
60
+ """
61
+ self._key = key
62
+
63
+ if hashAlgo:
64
+ self._hashObj = hashAlgo
65
+ else:
66
+ self._hashObj = Crypto.Hash.SHA1
67
+
68
+ if mgfunc:
69
+ self._mgf = mgfunc
70
+ else:
71
+ self._mgf = lambda x,y: MGF1(x,y,self._hashObj)
72
+
73
+ self._label = _copy_bytes(None, None, label)
74
+ self._randfunc = randfunc
75
+
76
+ def can_encrypt(self):
77
+ """Legacy function to check if you can call :meth:`encrypt`.
78
+
79
+ .. deprecated:: 3.0"""
80
+ return self._key.can_encrypt()
81
+
82
+ def can_decrypt(self):
83
+ """Legacy function to check if you can call :meth:`decrypt`.
84
+
85
+ .. deprecated:: 3.0"""
86
+ return self._key.can_decrypt()
87
+
88
+ def encrypt(self, message):
89
+ """Encrypt a message with PKCS#1 OAEP.
90
+
91
+ :param message:
92
+ The message to encrypt, also known as plaintext. It can be of
93
+ variable length, but not longer than the RSA modulus (in bytes)
94
+ minus 2, minus twice the hash output size.
95
+ For instance, if you use RSA 2048 and SHA-256, the longest message
96
+ you can encrypt is 190 byte long.
97
+ :type message: bytes/bytearray/memoryview
98
+
99
+ :returns: The ciphertext, as large as the RSA modulus.
100
+ :rtype: bytes
101
+
102
+ :raises ValueError:
103
+ if the message is too long.
104
+ """
105
+
106
+ # See 7.1.1 in RFC3447
107
+ modBits = Crypto.Util.number.size(self._key.n)
108
+ k = ceil_div(modBits, 8) # Convert from bits to bytes
109
+ hLen = self._hashObj.digest_size
110
+ mLen = len(message)
111
+
112
+ # Step 1b
113
+ ps_len = k - mLen - 2 * hLen - 2
114
+ if ps_len < 0:
115
+ raise ValueError("Plaintext is too long.")
116
+ # Step 2a
117
+ lHash = self._hashObj.new(self._label).digest()
118
+ # Step 2b
119
+ ps = b'\x00' * ps_len
120
+ # Step 2c
121
+ db = lHash + ps + b'\x01' + _copy_bytes(None, None, message)
122
+ # Step 2d
123
+ ros = self._randfunc(hLen)
124
+ # Step 2e
125
+ dbMask = self._mgf(ros, k-hLen-1)
126
+ # Step 2f
127
+ maskedDB = strxor(db, dbMask)
128
+ # Step 2g
129
+ seedMask = self._mgf(maskedDB, hLen)
130
+ # Step 2h
131
+ maskedSeed = strxor(ros, seedMask)
132
+ # Step 2i
133
+ em = b'\x00' + maskedSeed + maskedDB
134
+ # Step 3a (OS2IP)
135
+ em_int = bytes_to_long(em)
136
+ # Step 3b (RSAEP)
137
+ m_int = self._key._encrypt(em_int)
138
+ # Step 3c (I2OSP)
139
+ c = long_to_bytes(m_int, k)
140
+ return c
141
+
142
+ def decrypt(self, ciphertext):
143
+ """Decrypt a message with PKCS#1 OAEP.
144
+
145
+ :param ciphertext: The encrypted message.
146
+ :type ciphertext: bytes/bytearray/memoryview
147
+
148
+ :returns: The original message (plaintext).
149
+ :rtype: bytes
150
+
151
+ :raises ValueError:
152
+ if the ciphertext has the wrong length, or if decryption
153
+ fails the integrity check (in which case, the decryption
154
+ key is probably wrong).
155
+ :raises TypeError:
156
+ if the RSA key has no private half (i.e. you are trying
157
+ to decrypt using a public key).
158
+ """
159
+
160
+ # See 7.1.2 in RFC3447
161
+ modBits = Crypto.Util.number.size(self._key.n)
162
+ k = ceil_div(modBits,8) # Convert from bits to bytes
163
+ hLen = self._hashObj.digest_size
164
+
165
+ # Step 1b and 1c
166
+ if len(ciphertext) != k or k<hLen+2:
167
+ raise ValueError("Ciphertext with incorrect length.")
168
+ # Step 2a (O2SIP)
169
+ ct_int = bytes_to_long(ciphertext)
170
+ # Step 2b (RSADP)
171
+ m_int = self._key._decrypt(ct_int)
172
+ # Complete step 2c (I2OSP)
173
+ em = long_to_bytes(m_int, k)
174
+ # Step 3a
175
+ lHash = self._hashObj.new(self._label).digest()
176
+ # Step 3b
177
+ y = em[0]
178
+ # y must be 0, but we MUST NOT check it here in order not to
179
+ # allow attacks like Manger's (http://dl.acm.org/citation.cfm?id=704143)
180
+ maskedSeed = em[1:hLen+1]
181
+ maskedDB = em[hLen+1:]
182
+ # Step 3c
183
+ seedMask = self._mgf(maskedDB, hLen)
184
+ # Step 3d
185
+ seed = strxor(maskedSeed, seedMask)
186
+ # Step 3e
187
+ dbMask = self._mgf(seed, k-hLen-1)
188
+ # Step 3f
189
+ db = strxor(maskedDB, dbMask)
190
+ # Step 3g
191
+ one_pos = hLen + db[hLen:].find(b'\x01')
192
+ lHash1 = db[:hLen]
193
+ invalid = bord(y) | int(one_pos < hLen)
194
+ hash_compare = strxor(lHash1, lHash)
195
+ for x in hash_compare:
196
+ invalid |= bord(x)
197
+ for x in db[hLen:one_pos]:
198
+ invalid |= bord(x)
199
+ if invalid != 0:
200
+ raise ValueError("Incorrect decryption.")
201
+ # Step 4
202
+ return db[one_pos + 1:]
203
+
204
+ def new(key, hashAlgo=None, mgfunc=None, label=b'', randfunc=None):
205
+ """Return a cipher object :class:`PKCS1OAEP_Cipher` that can be used to perform PKCS#1 OAEP encryption or decryption.
206
+
207
+ :param key:
208
+ The key object to use to encrypt or decrypt the message.
209
+ Decryption is only possible with a private RSA key.
210
+ :type key: RSA key object
211
+
212
+ :param hashAlgo:
213
+ The hash function to use. This can be a module under `Crypto.Hash`
214
+ or an existing hash object created from any of such modules.
215
+ If not specified, `Crypto.Hash.SHA1` is used.
216
+ :type hashAlgo: hash object
217
+
218
+ :param mgfunc:
219
+ A mask generation function that accepts two parameters: a string to
220
+ use as seed, and the lenth of the mask to generate, in bytes.
221
+ If not specified, the standard MGF1 consistent with ``hashAlgo`` is used (a safe choice).
222
+ :type mgfunc: callable
223
+
224
+ :param label:
225
+ A label to apply to this particular encryption. If not specified,
226
+ an empty string is used. Specifying a label does not improve
227
+ security.
228
+ :type label: bytes/bytearray/memoryview
229
+
230
+ :param randfunc:
231
+ A function that returns random bytes.
232
+ The default is `Random.get_random_bytes`.
233
+ :type randfunc: callable
234
+ """
235
+
236
+ if randfunc is None:
237
+ randfunc = Random.get_random_bytes
238
+ return PKCS1OAEP_Cipher(key, hashAlgo, mgfunc, label, randfunc)
239
+
runtime/Lib/site-packages/Crypto/Cipher/PKCS1_OAEP.pyi ADDED
@@ -0,0 +1,35 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Optional, Union, Callable, Any, overload
2
+ from typing_extensions import Protocol
3
+
4
+ from Crypto.PublicKey.RSA import RsaKey
5
+
6
+ class HashLikeClass(Protocol):
7
+ digest_size : int
8
+ def new(self, data: Optional[bytes] = ...) -> Any: ...
9
+
10
+ class HashLikeModule(Protocol):
11
+ digest_size : int
12
+ @staticmethod
13
+ def new(data: Optional[bytes] = ...) -> Any: ...
14
+
15
+ HashLike = Union[HashLikeClass, HashLikeModule]
16
+
17
+ Buffer = Union[bytes, bytearray, memoryview]
18
+
19
+ class PKCS1OAEP_Cipher:
20
+ def __init__(self,
21
+ key: RsaKey,
22
+ hashAlgo: HashLike,
23
+ mgfunc: Callable[[bytes, int], bytes],
24
+ label: Buffer,
25
+ randfunc: Callable[[int], bytes]) -> None: ...
26
+ def can_encrypt(self) -> bool: ...
27
+ def can_decrypt(self) -> bool: ...
28
+ def encrypt(self, message: Buffer) -> bytes: ...
29
+ def decrypt(self, ciphertext: Buffer) -> bytes: ...
30
+
31
+ def new(key: RsaKey,
32
+ hashAlgo: Optional[HashLike] = ...,
33
+ mgfunc: Optional[Callable[[bytes, int], bytes]] = ...,
34
+ label: Optional[Buffer] = ...,
35
+ randfunc: Optional[Callable[[int], bytes]] = ...) -> PKCS1OAEP_Cipher: ...
runtime/Lib/site-packages/Crypto/Cipher/PKCS1_v1_5.py ADDED
@@ -0,0 +1,217 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/PKCS1-v1_5.py : PKCS#1 v1.5
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+
23
+ __all__ = ['new', 'PKCS115_Cipher']
24
+
25
+ from Crypto import Random
26
+ from Crypto.Util.number import bytes_to_long, long_to_bytes
27
+ from Crypto.Util.py3compat import bord, is_bytes, _copy_bytes
28
+
29
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib, c_size_t,
30
+ c_uint8_ptr)
31
+
32
+
33
+ _raw_pkcs1_decode = load_pycryptodome_raw_lib("Crypto.Cipher._pkcs1_decode",
34
+ """
35
+ int pkcs1_decode(const uint8_t *em, size_t len_em,
36
+ const uint8_t *sentinel, size_t len_sentinel,
37
+ size_t expected_pt_len,
38
+ uint8_t *output);
39
+ """)
40
+
41
+
42
+ def _pkcs1_decode(em, sentinel, expected_pt_len, output):
43
+ if len(em) != len(output):
44
+ raise ValueError("Incorrect output length")
45
+
46
+ ret = _raw_pkcs1_decode.pkcs1_decode(c_uint8_ptr(em),
47
+ c_size_t(len(em)),
48
+ c_uint8_ptr(sentinel),
49
+ c_size_t(len(sentinel)),
50
+ c_size_t(expected_pt_len),
51
+ c_uint8_ptr(output))
52
+ return ret
53
+
54
+
55
+ class PKCS115_Cipher:
56
+ """This cipher can perform PKCS#1 v1.5 RSA encryption or decryption.
57
+ Do not instantiate directly. Use :func:`Crypto.Cipher.PKCS1_v1_5.new` instead."""
58
+
59
+ def __init__(self, key, randfunc):
60
+ """Initialize this PKCS#1 v1.5 cipher object.
61
+
62
+ :Parameters:
63
+ key : an RSA key object
64
+ If a private half is given, both encryption and decryption are possible.
65
+ If a public half is given, only encryption is possible.
66
+ randfunc : callable
67
+ Function that returns random bytes.
68
+ """
69
+
70
+ self._key = key
71
+ self._randfunc = randfunc
72
+
73
+ def can_encrypt(self):
74
+ """Return True if this cipher object can be used for encryption."""
75
+ return self._key.can_encrypt()
76
+
77
+ def can_decrypt(self):
78
+ """Return True if this cipher object can be used for decryption."""
79
+ return self._key.can_decrypt()
80
+
81
+ def encrypt(self, message):
82
+ """Produce the PKCS#1 v1.5 encryption of a message.
83
+
84
+ This function is named ``RSAES-PKCS1-V1_5-ENCRYPT``, and it is specified in
85
+ `section 7.2.1 of RFC8017
86
+ <https://tools.ietf.org/html/rfc8017#page-28>`_.
87
+
88
+ :param message:
89
+ The message to encrypt, also known as plaintext. It can be of
90
+ variable length, but not longer than the RSA modulus (in bytes) minus 11.
91
+ :type message: bytes/bytearray/memoryview
92
+
93
+ :Returns: A byte string, the ciphertext in which the message is encrypted.
94
+ It is as long as the RSA modulus (in bytes).
95
+
96
+ :Raises ValueError:
97
+ If the RSA key length is not sufficiently long to deal with the given
98
+ message.
99
+ """
100
+
101
+ # See 7.2.1 in RFC8017
102
+ k = self._key.size_in_bytes()
103
+ mLen = len(message)
104
+
105
+ # Step 1
106
+ if mLen > k - 11:
107
+ raise ValueError("Plaintext is too long.")
108
+ # Step 2a
109
+ ps = []
110
+ while len(ps) != k - mLen - 3:
111
+ new_byte = self._randfunc(1)
112
+ if bord(new_byte[0]) == 0x00:
113
+ continue
114
+ ps.append(new_byte)
115
+ ps = b"".join(ps)
116
+ assert(len(ps) == k - mLen - 3)
117
+ # Step 2b
118
+ em = b'\x00\x02' + ps + b'\x00' + _copy_bytes(None, None, message)
119
+ # Step 3a (OS2IP)
120
+ em_int = bytes_to_long(em)
121
+ # Step 3b (RSAEP)
122
+ m_int = self._key._encrypt(em_int)
123
+ # Step 3c (I2OSP)
124
+ c = long_to_bytes(m_int, k)
125
+ return c
126
+
127
+ def decrypt(self, ciphertext, sentinel, expected_pt_len=0):
128
+ r"""Decrypt a PKCS#1 v1.5 ciphertext.
129
+
130
+ This is the function ``RSAES-PKCS1-V1_5-DECRYPT`` specified in
131
+ `section 7.2.2 of RFC8017
132
+ <https://tools.ietf.org/html/rfc8017#page-29>`_.
133
+
134
+ Args:
135
+ ciphertext (bytes/bytearray/memoryview):
136
+ The ciphertext that contains the message to recover.
137
+ sentinel (any type):
138
+ The object to return whenever an error is detected.
139
+ expected_pt_len (integer):
140
+ The length the plaintext is known to have, or 0 if unknown.
141
+
142
+ Returns (byte string):
143
+ It is either the original message or the ``sentinel`` (in case of an error).
144
+
145
+ .. warning::
146
+ PKCS#1 v1.5 decryption is intrinsically vulnerable to timing
147
+ attacks (see `Bleichenbacher's`__ attack).
148
+ **Use PKCS#1 OAEP instead**.
149
+
150
+ This implementation attempts to mitigate the risk
151
+ with some constant-time constructs.
152
+ However, they are not sufficient by themselves: the type of protocol you
153
+ implement and the way you handle errors make a big difference.
154
+
155
+ Specifically, you should make it very hard for the (malicious)
156
+ party that submitted the ciphertext to quickly understand if decryption
157
+ succeeded or not.
158
+
159
+ To this end, it is recommended that your protocol only encrypts
160
+ plaintexts of fixed length (``expected_pt_len``),
161
+ that ``sentinel`` is a random byte string of the same length,
162
+ and that processing continues for as long
163
+ as possible even if ``sentinel`` is returned (i.e. in case of
164
+ incorrect decryption).
165
+
166
+ .. __: https://dx.doi.org/10.1007/BFb0055716
167
+ """
168
+
169
+ # See 7.2.2 in RFC8017
170
+ k = self._key.size_in_bytes()
171
+
172
+ # Step 1
173
+ if len(ciphertext) != k:
174
+ raise ValueError("Ciphertext with incorrect length (not %d bytes)" % k)
175
+
176
+ # Step 2a (O2SIP)
177
+ ct_int = bytes_to_long(ciphertext)
178
+
179
+ # Step 2b (RSADP)
180
+ m_int = self._key._decrypt(ct_int)
181
+
182
+ # Complete step 2c (I2OSP)
183
+ em = long_to_bytes(m_int, k)
184
+
185
+ # Step 3 (not constant time when the sentinel is not a byte string)
186
+ output = bytes(bytearray(k))
187
+ if not is_bytes(sentinel) or len(sentinel) > k:
188
+ size = _pkcs1_decode(em, b'', expected_pt_len, output)
189
+ if size < 0:
190
+ return sentinel
191
+ else:
192
+ return output[size:]
193
+
194
+ # Step 3 (somewhat constant time)
195
+ size = _pkcs1_decode(em, sentinel, expected_pt_len, output)
196
+ return output[size:]
197
+
198
+
199
+ def new(key, randfunc=None):
200
+ """Create a cipher for performing PKCS#1 v1.5 encryption or decryption.
201
+
202
+ :param key:
203
+ The key to use to encrypt or decrypt the message. This is a `Crypto.PublicKey.RSA` object.
204
+ Decryption is only possible if *key* is a private RSA key.
205
+ :type key: RSA key object
206
+
207
+ :param randfunc:
208
+ Function that return random bytes.
209
+ The default is :func:`Crypto.Random.get_random_bytes`.
210
+ :type randfunc: callable
211
+
212
+ :returns: A cipher object `PKCS115_Cipher`.
213
+ """
214
+
215
+ if randfunc is None:
216
+ randfunc = Random.get_random_bytes
217
+ return PKCS115_Cipher(key, randfunc)
runtime/Lib/site-packages/Crypto/Cipher/PKCS1_v1_5.pyi ADDED
@@ -0,0 +1,20 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Callable, Union, Any, Optional, TypeVar
2
+
3
+ from Crypto.PublicKey.RSA import RsaKey
4
+
5
+ Buffer = Union[bytes, bytearray, memoryview]
6
+ T = TypeVar('T')
7
+
8
+ class PKCS115_Cipher:
9
+ def __init__(self,
10
+ key: RsaKey,
11
+ randfunc: Callable[[int], bytes]) -> None: ...
12
+ def can_encrypt(self) -> bool: ...
13
+ def can_decrypt(self) -> bool: ...
14
+ def encrypt(self, message: Buffer) -> bytes: ...
15
+ def decrypt(self, ciphertext: Buffer,
16
+ sentinel: T,
17
+ expected_pt_len: Optional[int] = ...) -> Union[bytes, T]: ...
18
+
19
+ def new(key: RsaKey,
20
+ randfunc: Optional[Callable[[int], bytes]] = ...) -> PKCS115_Cipher: ...
runtime/Lib/site-packages/Crypto/Cipher/Salsa20.py ADDED
@@ -0,0 +1,167 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/Salsa20.py : Salsa20 stream cipher (http://cr.yp.to/snuffle.html)
4
+ #
5
+ # Contributed by Fabrizio Tarizzo <fabrizio@fabriziotarizzo.org>.
6
+ #
7
+ # ===================================================================
8
+ # The contents of this file are dedicated to the public domain. To
9
+ # the extent that dedication to the public domain is not available,
10
+ # everyone is granted a worldwide, perpetual, royalty-free,
11
+ # non-exclusive license to exercise all rights associated with the
12
+ # contents of this file for any purpose whatsoever.
13
+ # No rights are reserved.
14
+ #
15
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
19
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
20
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22
+ # SOFTWARE.
23
+ # ===================================================================
24
+
25
+ from Crypto.Util.py3compat import _copy_bytes
26
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
27
+ create_string_buffer,
28
+ get_raw_buffer, VoidPointer,
29
+ SmartPointer, c_size_t,
30
+ c_uint8_ptr, is_writeable_buffer)
31
+
32
+ from Crypto.Random import get_random_bytes
33
+
34
+ _raw_salsa20_lib = load_pycryptodome_raw_lib("Crypto.Cipher._Salsa20",
35
+ """
36
+ int Salsa20_stream_init(uint8_t *key, size_t keylen,
37
+ uint8_t *nonce, size_t nonce_len,
38
+ void **pSalsaState);
39
+ int Salsa20_stream_destroy(void *salsaState);
40
+ int Salsa20_stream_encrypt(void *salsaState,
41
+ const uint8_t in[],
42
+ uint8_t out[], size_t len);
43
+ """)
44
+
45
+
46
+ class Salsa20Cipher:
47
+ """Salsa20 cipher object. Do not create it directly. Use :py:func:`new`
48
+ instead.
49
+
50
+ :var nonce: The nonce with length 8
51
+ :vartype nonce: byte string
52
+ """
53
+
54
+ def __init__(self, key, nonce):
55
+ """Initialize a Salsa20 cipher object
56
+
57
+ See also `new()` at the module level."""
58
+
59
+ if len(key) not in key_size:
60
+ raise ValueError("Incorrect key length for Salsa20 (%d bytes)" % len(key))
61
+
62
+ if len(nonce) != 8:
63
+ raise ValueError("Incorrect nonce length for Salsa20 (%d bytes)" %
64
+ len(nonce))
65
+
66
+ self.nonce = _copy_bytes(None, None, nonce)
67
+
68
+ self._state = VoidPointer()
69
+ result = _raw_salsa20_lib.Salsa20_stream_init(
70
+ c_uint8_ptr(key),
71
+ c_size_t(len(key)),
72
+ c_uint8_ptr(nonce),
73
+ c_size_t(len(nonce)),
74
+ self._state.address_of())
75
+ if result:
76
+ raise ValueError("Error %d instantiating a Salsa20 cipher")
77
+ self._state = SmartPointer(self._state.get(),
78
+ _raw_salsa20_lib.Salsa20_stream_destroy)
79
+
80
+ self.block_size = 1
81
+ self.key_size = len(key)
82
+
83
+ def encrypt(self, plaintext, output=None):
84
+ """Encrypt a piece of data.
85
+
86
+ Args:
87
+ plaintext(bytes/bytearray/memoryview): The data to encrypt, of any size.
88
+ Keyword Args:
89
+ output(bytes/bytearray/memoryview): The location where the ciphertext
90
+ is written to. If ``None``, the ciphertext is returned.
91
+ Returns:
92
+ If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
93
+ Otherwise, ``None``.
94
+ """
95
+
96
+ if output is None:
97
+ ciphertext = create_string_buffer(len(plaintext))
98
+ else:
99
+ ciphertext = output
100
+
101
+ if not is_writeable_buffer(output):
102
+ raise TypeError("output must be a bytearray or a writeable memoryview")
103
+
104
+ if len(plaintext) != len(output):
105
+ raise ValueError("output must have the same length as the input"
106
+ " (%d bytes)" % len(plaintext))
107
+
108
+ result = _raw_salsa20_lib.Salsa20_stream_encrypt(
109
+ self._state.get(),
110
+ c_uint8_ptr(plaintext),
111
+ c_uint8_ptr(ciphertext),
112
+ c_size_t(len(plaintext)))
113
+ if result:
114
+ raise ValueError("Error %d while encrypting with Salsa20" % result)
115
+
116
+ if output is None:
117
+ return get_raw_buffer(ciphertext)
118
+ else:
119
+ return None
120
+
121
+ def decrypt(self, ciphertext, output=None):
122
+ """Decrypt a piece of data.
123
+
124
+ Args:
125
+ ciphertext(bytes/bytearray/memoryview): The data to decrypt, of any size.
126
+ Keyword Args:
127
+ output(bytes/bytearray/memoryview): The location where the plaintext
128
+ is written to. If ``None``, the plaintext is returned.
129
+ Returns:
130
+ If ``output`` is ``None``, the plaintext is returned as ``bytes``.
131
+ Otherwise, ``None``.
132
+ """
133
+
134
+ try:
135
+ return self.encrypt(ciphertext, output=output)
136
+ except ValueError as e:
137
+ raise ValueError(str(e).replace("enc", "dec"))
138
+
139
+
140
+ def new(key, nonce=None):
141
+ """Create a new Salsa20 cipher
142
+
143
+ :keyword key: The secret key to use. It must be 16 or 32 bytes long.
144
+ :type key: bytes/bytearray/memoryview
145
+
146
+ :keyword nonce:
147
+ A value that must never be reused for any other encryption
148
+ done with this key. It must be 8 bytes long.
149
+
150
+ If not provided, a random byte string will be generated (you can read
151
+ it back via the ``nonce`` attribute of the returned object).
152
+ :type nonce: bytes/bytearray/memoryview
153
+
154
+ :Return: a :class:`Crypto.Cipher.Salsa20.Salsa20Cipher` object
155
+ """
156
+
157
+ if nonce is None:
158
+ nonce = get_random_bytes(8)
159
+
160
+ return Salsa20Cipher(key, nonce)
161
+
162
+ # Size of a data block (in bytes)
163
+ block_size = 1
164
+
165
+ # Size of a key (in bytes)
166
+ key_size = (16, 32)
167
+
runtime/Lib/site-packages/Crypto/Cipher/Salsa20.pyi ADDED
@@ -0,0 +1,27 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, Tuple, Optional, overload
2
+
3
+
4
+ Buffer = Union[bytes, bytearray, memoryview]
5
+
6
+ class Salsa20Cipher:
7
+ nonce: bytes
8
+ block_size: int
9
+ key_size: int
10
+
11
+ def __init__(self,
12
+ key: Buffer,
13
+ nonce: Buffer) -> None: ...
14
+ @overload
15
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
16
+ @overload
17
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
18
+ @overload
19
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
20
+ @overload
21
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
22
+
23
+ def new(key: Buffer, nonce: Optional[Buffer] = ...) -> Salsa20Cipher: ...
24
+
25
+ block_size: int
26
+ key_size: Tuple[int, int]
27
+
runtime/Lib/site-packages/Crypto/Cipher/_ARC4.pyd ADDED
Binary file (11.3 kB). View file
 
runtime/Lib/site-packages/Crypto/Cipher/_EKSBlowfish.py ADDED
@@ -0,0 +1,131 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # ===================================================================
2
+ #
3
+ # Copyright (c) 2019, Legrandin <helderijs@gmail.com>
4
+ # All rights reserved.
5
+ #
6
+ # Redistribution and use in source and binary forms, with or without
7
+ # modification, are permitted provided that the following conditions
8
+ # are met:
9
+ #
10
+ # 1. Redistributions of source code must retain the above copyright
11
+ # notice, this list of conditions and the following disclaimer.
12
+ # 2. Redistributions in binary form must reproduce the above copyright
13
+ # notice, this list of conditions and the following disclaimer in
14
+ # the documentation and/or other materials provided with the
15
+ # distribution.
16
+ #
17
+ # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18
+ # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19
+ # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20
+ # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21
+ # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22
+ # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23
+ # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24
+ # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25
+ # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
+ # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
27
+ # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28
+ # POSSIBILITY OF SUCH DAMAGE.
29
+ # ===================================================================
30
+
31
+ import sys
32
+
33
+ from Crypto.Cipher import _create_cipher
34
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
35
+ VoidPointer, SmartPointer, c_size_t,
36
+ c_uint8_ptr, c_uint)
37
+
38
+ _raw_blowfish_lib = load_pycryptodome_raw_lib(
39
+ "Crypto.Cipher._raw_eksblowfish",
40
+ """
41
+ int EKSBlowfish_start_operation(const uint8_t key[],
42
+ size_t key_len,
43
+ const uint8_t salt[16],
44
+ size_t salt_len,
45
+ unsigned cost,
46
+ unsigned invert,
47
+ void **pResult);
48
+ int EKSBlowfish_encrypt(const void *state,
49
+ const uint8_t *in,
50
+ uint8_t *out,
51
+ size_t data_len);
52
+ int EKSBlowfish_decrypt(const void *state,
53
+ const uint8_t *in,
54
+ uint8_t *out,
55
+ size_t data_len);
56
+ int EKSBlowfish_stop_operation(void *state);
57
+ """
58
+ )
59
+
60
+
61
+ def _create_base_cipher(dict_parameters):
62
+ """This method instantiates and returns a smart pointer to
63
+ a low-level base cipher. It will absorb named parameters in
64
+ the process."""
65
+
66
+ try:
67
+ key = dict_parameters.pop("key")
68
+ salt = dict_parameters.pop("salt")
69
+ cost = dict_parameters.pop("cost")
70
+ except KeyError as e:
71
+ raise TypeError("Missing EKSBlowfish parameter: " + str(e))
72
+ invert = dict_parameters.pop("invert", True)
73
+
74
+ if len(key) not in key_size:
75
+ raise ValueError("Incorrect EKSBlowfish key length (%d bytes)" % len(key))
76
+
77
+ start_operation = _raw_blowfish_lib.EKSBlowfish_start_operation
78
+ stop_operation = _raw_blowfish_lib.EKSBlowfish_stop_operation
79
+
80
+ void_p = VoidPointer()
81
+ result = start_operation(c_uint8_ptr(key),
82
+ c_size_t(len(key)),
83
+ c_uint8_ptr(salt),
84
+ c_size_t(len(salt)),
85
+ c_uint(cost),
86
+ c_uint(int(invert)),
87
+ void_p.address_of())
88
+ if result:
89
+ raise ValueError("Error %X while instantiating the EKSBlowfish cipher"
90
+ % result)
91
+ return SmartPointer(void_p.get(), stop_operation)
92
+
93
+
94
+ def new(key, mode, salt, cost, invert):
95
+ """Create a new EKSBlowfish cipher
96
+
97
+ Args:
98
+
99
+ key (bytes, bytearray, memoryview):
100
+ The secret key to use in the symmetric cipher.
101
+ Its length can vary from 0 to 72 bytes.
102
+
103
+ mode (one of the supported ``MODE_*`` constants):
104
+ The chaining mode to use for encryption or decryption.
105
+
106
+ salt (bytes, bytearray, memoryview):
107
+ The salt that bcrypt uses to thwart rainbow table attacks
108
+
109
+ cost (integer):
110
+ The complexity factor in bcrypt
111
+
112
+ invert (bool):
113
+ If ``False``, in the inner loop use ``ExpandKey`` first over the salt
114
+ and then over the key, as defined in
115
+ the `original bcrypt specification <https://www.usenix.org/legacy/events/usenix99/provos/provos_html/node4.html>`_.
116
+ If ``True``, reverse the order, as in the first implementation of
117
+ `bcrypt` in OpenBSD.
118
+
119
+ :Return: an EKSBlowfish object
120
+ """
121
+
122
+ kwargs = { 'salt':salt, 'cost':cost, 'invert':invert }
123
+ return _create_cipher(sys.modules[__name__], key, mode, **kwargs)
124
+
125
+
126
+ MODE_ECB = 1
127
+
128
+ # Size of a data block (in bytes)
129
+ block_size = 8
130
+ # Size of a key (in bytes)
131
+ key_size = range(0, 72 + 1)
runtime/Lib/site-packages/Crypto/Cipher/_EKSBlowfish.pyi ADDED
@@ -0,0 +1,15 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, Iterable
2
+
3
+ from Crypto.Cipher._mode_ecb import EcbMode
4
+
5
+ MODE_ECB: int
6
+
7
+ Buffer = Union[bytes, bytearray, memoryview]
8
+
9
+ def new(key: Buffer,
10
+ mode: int,
11
+ salt: Buffer,
12
+ cost: int) -> EcbMode: ...
13
+
14
+ block_size: int
15
+ key_size: Iterable[int]
runtime/Lib/site-packages/Crypto/Cipher/_Salsa20.pyd ADDED
Binary file (13.8 kB). View file
 
runtime/Lib/site-packages/Crypto/Cipher/__init__.py ADDED
@@ -0,0 +1,79 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # A block cipher is instantiated as a combination of:
3
+ # 1. A base cipher (such as AES)
4
+ # 2. A mode of operation (such as CBC)
5
+ #
6
+ # Both items are implemented as C modules.
7
+ #
8
+ # The API of #1 is (replace "AES" with the name of the actual cipher):
9
+ # - AES_start_operaion(key) --> base_cipher_state
10
+ # - AES_encrypt(base_cipher_state, in, out, length)
11
+ # - AES_decrypt(base_cipher_state, in, out, length)
12
+ # - AES_stop_operation(base_cipher_state)
13
+ #
14
+ # Where base_cipher_state is AES_State, a struct with BlockBase (set of
15
+ # pointers to encrypt/decrypt/stop) followed by cipher-specific data.
16
+ #
17
+ # The API of #2 is (replace "CBC" with the name of the actual mode):
18
+ # - CBC_start_operation(base_cipher_state) --> mode_state
19
+ # - CBC_encrypt(mode_state, in, out, length)
20
+ # - CBC_decrypt(mode_state, in, out, length)
21
+ # - CBC_stop_operation(mode_state)
22
+ #
23
+ # where mode_state is a a pointer to base_cipher_state plus mode-specific data.
24
+
25
+ import os
26
+
27
+ from Crypto.Cipher._mode_ecb import _create_ecb_cipher
28
+ from Crypto.Cipher._mode_cbc import _create_cbc_cipher
29
+ from Crypto.Cipher._mode_cfb import _create_cfb_cipher
30
+ from Crypto.Cipher._mode_ofb import _create_ofb_cipher
31
+ from Crypto.Cipher._mode_ctr import _create_ctr_cipher
32
+ from Crypto.Cipher._mode_openpgp import _create_openpgp_cipher
33
+ from Crypto.Cipher._mode_ccm import _create_ccm_cipher
34
+ from Crypto.Cipher._mode_eax import _create_eax_cipher
35
+ from Crypto.Cipher._mode_siv import _create_siv_cipher
36
+ from Crypto.Cipher._mode_gcm import _create_gcm_cipher
37
+ from Crypto.Cipher._mode_ocb import _create_ocb_cipher
38
+
39
+ _modes = { 1:_create_ecb_cipher,
40
+ 2:_create_cbc_cipher,
41
+ 3:_create_cfb_cipher,
42
+ 5:_create_ofb_cipher,
43
+ 6:_create_ctr_cipher,
44
+ 7:_create_openpgp_cipher,
45
+ 9:_create_eax_cipher
46
+ }
47
+
48
+ _extra_modes = { 8:_create_ccm_cipher,
49
+ 10:_create_siv_cipher,
50
+ 11:_create_gcm_cipher,
51
+ 12:_create_ocb_cipher
52
+ }
53
+
54
+ def _create_cipher(factory, key, mode, *args, **kwargs):
55
+
56
+ kwargs["key"] = key
57
+
58
+ modes = dict(_modes)
59
+ if kwargs.pop("add_aes_modes", False):
60
+ modes.update(_extra_modes)
61
+ if not mode in modes:
62
+ raise ValueError("Mode not supported")
63
+
64
+ if args:
65
+ if mode in (8, 9, 10, 11, 12):
66
+ if len(args) > 1:
67
+ raise TypeError("Too many arguments for this mode")
68
+ kwargs["nonce"] = args[0]
69
+ elif mode in (2, 3, 5, 7):
70
+ if len(args) > 1:
71
+ raise TypeError("Too many arguments for this mode")
72
+ kwargs["IV"] = args[0]
73
+ elif mode == 6:
74
+ if len(args) > 0:
75
+ raise TypeError("Too many arguments for this mode")
76
+ elif mode == 1:
77
+ raise TypeError("IV is not meaningful for the ECB mode")
78
+
79
+ return modes[mode](factory, **kwargs)
runtime/Lib/site-packages/Crypto/Cipher/__init__.pyi ADDED
File without changes
runtime/Lib/site-packages/Crypto/Cipher/_chacha20.pyd ADDED
Binary file (13.3 kB). View file
 
runtime/Lib/site-packages/Crypto/Cipher/_mode_cbc.py ADDED
@@ -0,0 +1,293 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # ===================================================================
2
+ #
3
+ # Copyright (c) 2014, Legrandin <helderijs@gmail.com>
4
+ # All rights reserved.
5
+ #
6
+ # Redistribution and use in source and binary forms, with or without
7
+ # modification, are permitted provided that the following conditions
8
+ # are met:
9
+ #
10
+ # 1. Redistributions of source code must retain the above copyright
11
+ # notice, this list of conditions and the following disclaimer.
12
+ # 2. Redistributions in binary form must reproduce the above copyright
13
+ # notice, this list of conditions and the following disclaimer in
14
+ # the documentation and/or other materials provided with the
15
+ # distribution.
16
+ #
17
+ # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18
+ # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19
+ # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20
+ # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21
+ # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22
+ # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23
+ # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24
+ # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25
+ # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
+ # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
27
+ # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28
+ # POSSIBILITY OF SUCH DAMAGE.
29
+ # ===================================================================
30
+
31
+ """
32
+ Ciphertext Block Chaining (CBC) mode.
33
+ """
34
+
35
+ __all__ = ['CbcMode']
36
+
37
+ from Crypto.Util.py3compat import _copy_bytes
38
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
39
+ create_string_buffer, get_raw_buffer,
40
+ SmartPointer, c_size_t, c_uint8_ptr,
41
+ is_writeable_buffer)
42
+
43
+ from Crypto.Random import get_random_bytes
44
+
45
+ raw_cbc_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_cbc", """
46
+ int CBC_start_operation(void *cipher,
47
+ const uint8_t iv[],
48
+ size_t iv_len,
49
+ void **pResult);
50
+ int CBC_encrypt(void *cbcState,
51
+ const uint8_t *in,
52
+ uint8_t *out,
53
+ size_t data_len);
54
+ int CBC_decrypt(void *cbcState,
55
+ const uint8_t *in,
56
+ uint8_t *out,
57
+ size_t data_len);
58
+ int CBC_stop_operation(void *state);
59
+ """
60
+ )
61
+
62
+
63
+ class CbcMode(object):
64
+ """*Cipher-Block Chaining (CBC)*.
65
+
66
+ Each of the ciphertext blocks depends on the current
67
+ and all previous plaintext blocks.
68
+
69
+ An Initialization Vector (*IV*) is required.
70
+
71
+ See `NIST SP800-38A`_ , Section 6.2 .
72
+
73
+ .. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
74
+
75
+ :undocumented: __init__
76
+ """
77
+
78
+ def __init__(self, block_cipher, iv):
79
+ """Create a new block cipher, configured in CBC mode.
80
+
81
+ :Parameters:
82
+ block_cipher : C pointer
83
+ A smart pointer to the low-level block cipher instance.
84
+
85
+ iv : bytes/bytearray/memoryview
86
+ The initialization vector to use for encryption or decryption.
87
+ It is as long as the cipher block.
88
+
89
+ **The IV must be unpredictable**. Ideally it is picked randomly.
90
+
91
+ Reusing the *IV* for encryptions performed with the same key
92
+ compromises confidentiality.
93
+ """
94
+
95
+ self._state = VoidPointer()
96
+ result = raw_cbc_lib.CBC_start_operation(block_cipher.get(),
97
+ c_uint8_ptr(iv),
98
+ c_size_t(len(iv)),
99
+ self._state.address_of())
100
+ if result:
101
+ raise ValueError("Error %d while instantiating the CBC mode"
102
+ % result)
103
+
104
+ # Ensure that object disposal of this Python object will (eventually)
105
+ # free the memory allocated by the raw library for the cipher mode
106
+ self._state = SmartPointer(self._state.get(),
107
+ raw_cbc_lib.CBC_stop_operation)
108
+
109
+ # Memory allocated for the underlying block cipher is now owed
110
+ # by the cipher mode
111
+ block_cipher.release()
112
+
113
+ self.block_size = len(iv)
114
+ """The block size of the underlying cipher, in bytes."""
115
+
116
+ self.iv = _copy_bytes(None, None, iv)
117
+ """The Initialization Vector originally used to create the object.
118
+ The value does not change."""
119
+
120
+ self.IV = self.iv
121
+ """Alias for `iv`"""
122
+
123
+ self._next = [ self.encrypt, self.decrypt ]
124
+
125
+ def encrypt(self, plaintext, output=None):
126
+ """Encrypt data with the key and the parameters set at initialization.
127
+
128
+ A cipher object is stateful: once you have encrypted a message
129
+ you cannot encrypt (or decrypt) another message using the same
130
+ object.
131
+
132
+ The data to encrypt can be broken up in two or
133
+ more pieces and `encrypt` can be called multiple times.
134
+
135
+ That is, the statement:
136
+
137
+ >>> c.encrypt(a) + c.encrypt(b)
138
+
139
+ is equivalent to:
140
+
141
+ >>> c.encrypt(a+b)
142
+
143
+ That also means that you cannot reuse an object for encrypting
144
+ or decrypting other data with the same key.
145
+
146
+ This function does not add any padding to the plaintext.
147
+
148
+ :Parameters:
149
+ plaintext : bytes/bytearray/memoryview
150
+ The piece of data to encrypt.
151
+ Its lenght must be multiple of the cipher block size.
152
+ :Keywords:
153
+ output : bytearray/memoryview
154
+ The location where the ciphertext must be written to.
155
+ If ``None``, the ciphertext is returned.
156
+ :Return:
157
+ If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
158
+ Otherwise, ``None``.
159
+ """
160
+
161
+ if self.encrypt not in self._next:
162
+ raise TypeError("encrypt() cannot be called after decrypt()")
163
+ self._next = [ self.encrypt ]
164
+
165
+ if output is None:
166
+ ciphertext = create_string_buffer(len(plaintext))
167
+ else:
168
+ ciphertext = output
169
+
170
+ if not is_writeable_buffer(output):
171
+ raise TypeError("output must be a bytearray or a writeable memoryview")
172
+
173
+ if len(plaintext) != len(output):
174
+ raise ValueError("output must have the same length as the input"
175
+ " (%d bytes)" % len(plaintext))
176
+
177
+ result = raw_cbc_lib.CBC_encrypt(self._state.get(),
178
+ c_uint8_ptr(plaintext),
179
+ c_uint8_ptr(ciphertext),
180
+ c_size_t(len(plaintext)))
181
+ if result:
182
+ if result == 3:
183
+ raise ValueError("Data must be padded to %d byte boundary in CBC mode" % self.block_size)
184
+ raise ValueError("Error %d while encrypting in CBC mode" % result)
185
+
186
+ if output is None:
187
+ return get_raw_buffer(ciphertext)
188
+ else:
189
+ return None
190
+
191
+ def decrypt(self, ciphertext, output=None):
192
+ """Decrypt data with the key and the parameters set at initialization.
193
+
194
+ A cipher object is stateful: once you have decrypted a message
195
+ you cannot decrypt (or encrypt) another message with the same
196
+ object.
197
+
198
+ The data to decrypt can be broken up in two or
199
+ more pieces and `decrypt` can be called multiple times.
200
+
201
+ That is, the statement:
202
+
203
+ >>> c.decrypt(a) + c.decrypt(b)
204
+
205
+ is equivalent to:
206
+
207
+ >>> c.decrypt(a+b)
208
+
209
+ This function does not remove any padding from the plaintext.
210
+
211
+ :Parameters:
212
+ ciphertext : bytes/bytearray/memoryview
213
+ The piece of data to decrypt.
214
+ Its length must be multiple of the cipher block size.
215
+ :Keywords:
216
+ output : bytearray/memoryview
217
+ The location where the plaintext must be written to.
218
+ If ``None``, the plaintext is returned.
219
+ :Return:
220
+ If ``output`` is ``None``, the plaintext is returned as ``bytes``.
221
+ Otherwise, ``None``.
222
+ """
223
+
224
+ if self.decrypt not in self._next:
225
+ raise TypeError("decrypt() cannot be called after encrypt()")
226
+ self._next = [ self.decrypt ]
227
+
228
+ if output is None:
229
+ plaintext = create_string_buffer(len(ciphertext))
230
+ else:
231
+ plaintext = output
232
+
233
+ if not is_writeable_buffer(output):
234
+ raise TypeError("output must be a bytearray or a writeable memoryview")
235
+
236
+ if len(ciphertext) != len(output):
237
+ raise ValueError("output must have the same length as the input"
238
+ " (%d bytes)" % len(plaintext))
239
+
240
+ result = raw_cbc_lib.CBC_decrypt(self._state.get(),
241
+ c_uint8_ptr(ciphertext),
242
+ c_uint8_ptr(plaintext),
243
+ c_size_t(len(ciphertext)))
244
+ if result:
245
+ if result == 3:
246
+ raise ValueError("Data must be padded to %d byte boundary in CBC mode" % self.block_size)
247
+ raise ValueError("Error %d while decrypting in CBC mode" % result)
248
+
249
+ if output is None:
250
+ return get_raw_buffer(plaintext)
251
+ else:
252
+ return None
253
+
254
+
255
+ def _create_cbc_cipher(factory, **kwargs):
256
+ """Instantiate a cipher object that performs CBC encryption/decryption.
257
+
258
+ :Parameters:
259
+ factory : module
260
+ The underlying block cipher, a module from ``Crypto.Cipher``.
261
+
262
+ :Keywords:
263
+ iv : bytes/bytearray/memoryview
264
+ The IV to use for CBC.
265
+
266
+ IV : bytes/bytearray/memoryview
267
+ Alias for ``iv``.
268
+
269
+ Any other keyword will be passed to the underlying block cipher.
270
+ See the relevant documentation for details (at least ``key`` will need
271
+ to be present).
272
+ """
273
+
274
+ cipher_state = factory._create_base_cipher(kwargs)
275
+ iv = kwargs.pop("IV", None)
276
+ IV = kwargs.pop("iv", None)
277
+
278
+ if (None, None) == (iv, IV):
279
+ iv = get_random_bytes(factory.block_size)
280
+ if iv is not None:
281
+ if IV is not None:
282
+ raise TypeError("You must either use 'iv' or 'IV', not both")
283
+ else:
284
+ iv = IV
285
+
286
+ if len(iv) != factory.block_size:
287
+ raise ValueError("Incorrect IV length (it must be %d bytes long)" %
288
+ factory.block_size)
289
+
290
+ if kwargs:
291
+ raise TypeError("Unknown parameters for CBC: %s" % str(kwargs))
292
+
293
+ return CbcMode(cipher_state, iv)
runtime/Lib/site-packages/Crypto/Cipher/_mode_cbc.pyi ADDED
@@ -0,0 +1,25 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, overload
2
+
3
+ from Crypto.Util._raw_api import SmartPointer
4
+
5
+ Buffer = Union[bytes, bytearray, memoryview]
6
+
7
+ __all__ = ['CbcMode']
8
+
9
+ class CbcMode(object):
10
+ block_size: int
11
+ iv: Buffer
12
+ IV: Buffer
13
+
14
+ def __init__(self,
15
+ block_cipher: SmartPointer,
16
+ iv: Buffer) -> None: ...
17
+ @overload
18
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
19
+ @overload
20
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
21
+ @overload
22
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
23
+ @overload
24
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
25
+
runtime/Lib/site-packages/Crypto/Cipher/_mode_ccm.py ADDED
@@ -0,0 +1,650 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # ===================================================================
2
+ #
3
+ # Copyright (c) 2014, Legrandin <helderijs@gmail.com>
4
+ # All rights reserved.
5
+ #
6
+ # Redistribution and use in source and binary forms, with or without
7
+ # modification, are permitted provided that the following conditions
8
+ # are met:
9
+ #
10
+ # 1. Redistributions of source code must retain the above copyright
11
+ # notice, this list of conditions and the following disclaimer.
12
+ # 2. Redistributions in binary form must reproduce the above copyright
13
+ # notice, this list of conditions and the following disclaimer in
14
+ # the documentation and/or other materials provided with the
15
+ # distribution.
16
+ #
17
+ # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18
+ # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19
+ # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20
+ # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21
+ # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22
+ # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23
+ # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24
+ # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25
+ # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
+ # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
27
+ # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28
+ # POSSIBILITY OF SUCH DAMAGE.
29
+ # ===================================================================
30
+
31
+ """
32
+ Counter with CBC-MAC (CCM) mode.
33
+ """
34
+
35
+ __all__ = ['CcmMode']
36
+
37
+ import struct
38
+ from binascii import unhexlify
39
+
40
+ from Crypto.Util.py3compat import (byte_string, bord,
41
+ _copy_bytes)
42
+ from Crypto.Util._raw_api import is_writeable_buffer
43
+
44
+ from Crypto.Util.strxor import strxor
45
+ from Crypto.Util.number import long_to_bytes
46
+
47
+ from Crypto.Hash import BLAKE2s
48
+ from Crypto.Random import get_random_bytes
49
+
50
+
51
+ def enum(**enums):
52
+ return type('Enum', (), enums)
53
+
54
+ MacStatus = enum(NOT_STARTED=0, PROCESSING_AUTH_DATA=1, PROCESSING_PLAINTEXT=2)
55
+
56
+
57
+ class CcmMode(object):
58
+ """Counter with CBC-MAC (CCM).
59
+
60
+ This is an Authenticated Encryption with Associated Data (`AEAD`_) mode.
61
+ It provides both confidentiality and authenticity.
62
+
63
+ The header of the message may be left in the clear, if needed, and it will
64
+ still be subject to authentication. The decryption step tells the receiver
65
+ if the message comes from a source that really knowns the secret key.
66
+ Additionally, decryption detects if any part of the message - including the
67
+ header - has been modified or corrupted.
68
+
69
+ This mode requires a nonce. The nonce shall never repeat for two
70
+ different messages encrypted with the same key, but it does not need
71
+ to be random.
72
+ Note that there is a trade-off between the size of the nonce and the
73
+ maximum size of a single message you can encrypt.
74
+
75
+ It is important to use a large nonce if the key is reused across several
76
+ messages and the nonce is chosen randomly.
77
+
78
+ It is acceptable to us a short nonce if the key is only used a few times or
79
+ if the nonce is taken from a counter.
80
+
81
+ The following table shows the trade-off when the nonce is chosen at
82
+ random. The column on the left shows how many messages it takes
83
+ for the keystream to repeat **on average**. In practice, you will want to
84
+ stop using the key way before that.
85
+
86
+ +--------------------+---------------+-------------------+
87
+ | Avg. # of messages | nonce | Max. message |
88
+ | before keystream | size | size |
89
+ | repeats | (bytes) | (bytes) |
90
+ +====================+===============+===================+
91
+ | 2^52 | 13 | 64K |
92
+ +--------------------+---------------+-------------------+
93
+ | 2^48 | 12 | 16M |
94
+ +--------------------+---------------+-------------------+
95
+ | 2^44 | 11 | 4G |
96
+ +--------------------+---------------+-------------------+
97
+ | 2^40 | 10 | 1T |
98
+ +--------------------+---------------+-------------------+
99
+ | 2^36 | 9 | 64P |
100
+ +--------------------+---------------+-------------------+
101
+ | 2^32 | 8 | 16E |
102
+ +--------------------+---------------+-------------------+
103
+
104
+ This mode is only available for ciphers that operate on 128 bits blocks
105
+ (e.g. AES but not TDES).
106
+
107
+ See `NIST SP800-38C`_ or RFC3610_.
108
+
109
+ .. _`NIST SP800-38C`: http://csrc.nist.gov/publications/nistpubs/800-38C/SP800-38C.pdf
110
+ .. _RFC3610: https://tools.ietf.org/html/rfc3610
111
+ .. _AEAD: http://blog.cryptographyengineering.com/2012/05/how-to-choose-authenticated-encryption.html
112
+
113
+ :undocumented: __init__
114
+ """
115
+
116
+ def __init__(self, factory, key, nonce, mac_len, msg_len, assoc_len,
117
+ cipher_params):
118
+
119
+ self.block_size = factory.block_size
120
+ """The block size of the underlying cipher, in bytes."""
121
+
122
+ self.nonce = _copy_bytes(None, None, nonce)
123
+ """The nonce used for this cipher instance"""
124
+
125
+ self._factory = factory
126
+ self._key = _copy_bytes(None, None, key)
127
+ self._mac_len = mac_len
128
+ self._msg_len = msg_len
129
+ self._assoc_len = assoc_len
130
+ self._cipher_params = cipher_params
131
+
132
+ self._mac_tag = None # Cache for MAC tag
133
+
134
+ if self.block_size != 16:
135
+ raise ValueError("CCM mode is only available for ciphers"
136
+ " that operate on 128 bits blocks")
137
+
138
+ # MAC tag length (Tlen)
139
+ if mac_len not in (4, 6, 8, 10, 12, 14, 16):
140
+ raise ValueError("Parameter 'mac_len' must be even"
141
+ " and in the range 4..16 (not %d)" % mac_len)
142
+
143
+ # Nonce value
144
+ if not (nonce and 7 <= len(nonce) <= 13):
145
+ raise ValueError("Length of parameter 'nonce' must be"
146
+ " in the range 7..13 bytes")
147
+
148
+ # Create MAC object (the tag will be the last block
149
+ # bytes worth of ciphertext)
150
+ self._mac = self._factory.new(key,
151
+ factory.MODE_CBC,
152
+ iv=b'\x00' * 16,
153
+ **cipher_params)
154
+ self._mac_status = MacStatus.NOT_STARTED
155
+ self._t = None
156
+
157
+ # Allowed transitions after initialization
158
+ self._next = [self.update, self.encrypt, self.decrypt,
159
+ self.digest, self.verify]
160
+
161
+ # Cumulative lengths
162
+ self._cumul_assoc_len = 0
163
+ self._cumul_msg_len = 0
164
+
165
+ # Cache for unaligned associated data/plaintext.
166
+ # This is a list with byte strings, but when the MAC starts,
167
+ # it will become a binary string no longer than the block size.
168
+ self._cache = []
169
+
170
+ # Start CTR cipher, by formatting the counter (A.3)
171
+ q = 15 - len(nonce) # length of Q, the encoded message length
172
+ self._cipher = self._factory.new(key,
173
+ self._factory.MODE_CTR,
174
+ nonce=struct.pack("B", q - 1) + self.nonce,
175
+ **cipher_params)
176
+
177
+ # S_0, step 6 in 6.1 for j=0
178
+ self._s_0 = self._cipher.encrypt(b'\x00' * 16)
179
+
180
+ # Try to start the MAC
181
+ if None not in (assoc_len, msg_len):
182
+ self._start_mac()
183
+
184
+ def _start_mac(self):
185
+
186
+ assert(self._mac_status == MacStatus.NOT_STARTED)
187
+ assert(None not in (self._assoc_len, self._msg_len))
188
+ assert(isinstance(self._cache, list))
189
+
190
+ # Formatting control information and nonce (A.2.1)
191
+ q = 15 - len(self.nonce) # length of Q, the encoded message length
192
+ flags = (64 * (self._assoc_len > 0) + 8 * ((self._mac_len - 2) // 2) +
193
+ (q - 1))
194
+ b_0 = struct.pack("B", flags) + self.nonce + long_to_bytes(self._msg_len, q)
195
+
196
+ # Formatting associated data (A.2.2)
197
+ # Encoded 'a' is concatenated with the associated data 'A'
198
+ assoc_len_encoded = b''
199
+ if self._assoc_len > 0:
200
+ if self._assoc_len < (2 ** 16 - 2 ** 8):
201
+ enc_size = 2
202
+ elif self._assoc_len < (2 ** 32):
203
+ assoc_len_encoded = b'\xFF\xFE'
204
+ enc_size = 4
205
+ else:
206
+ assoc_len_encoded = b'\xFF\xFF'
207
+ enc_size = 8
208
+ assoc_len_encoded += long_to_bytes(self._assoc_len, enc_size)
209
+
210
+ # b_0 and assoc_len_encoded must be processed first
211
+ self._cache.insert(0, b_0)
212
+ self._cache.insert(1, assoc_len_encoded)
213
+
214
+ # Process all the data cached so far
215
+ first_data_to_mac = b"".join(self._cache)
216
+ self._cache = b""
217
+ self._mac_status = MacStatus.PROCESSING_AUTH_DATA
218
+ self._update(first_data_to_mac)
219
+
220
+ def _pad_cache_and_update(self):
221
+
222
+ assert(self._mac_status != MacStatus.NOT_STARTED)
223
+ assert(len(self._cache) < self.block_size)
224
+
225
+ # Associated data is concatenated with the least number
226
+ # of zero bytes (possibly none) to reach alignment to
227
+ # the 16 byte boundary (A.2.3)
228
+ len_cache = len(self._cache)
229
+ if len_cache > 0:
230
+ self._update(b'\x00' * (self.block_size - len_cache))
231
+
232
+ def update(self, assoc_data):
233
+ """Protect associated data
234
+
235
+ If there is any associated data, the caller has to invoke
236
+ this function one or more times, before using
237
+ ``decrypt`` or ``encrypt``.
238
+
239
+ By *associated data* it is meant any data (e.g. packet headers) that
240
+ will not be encrypted and will be transmitted in the clear.
241
+ However, the receiver is still able to detect any modification to it.
242
+ In CCM, the *associated data* is also called
243
+ *additional authenticated data* (AAD).
244
+
245
+ If there is no associated data, this method must not be called.
246
+
247
+ The caller may split associated data in segments of any size, and
248
+ invoke this method multiple times, each time with the next segment.
249
+
250
+ :Parameters:
251
+ assoc_data : bytes/bytearray/memoryview
252
+ A piece of associated data. There are no restrictions on its size.
253
+ """
254
+
255
+ if self.update not in self._next:
256
+ raise TypeError("update() can only be called"
257
+ " immediately after initialization")
258
+
259
+ self._next = [self.update, self.encrypt, self.decrypt,
260
+ self.digest, self.verify]
261
+
262
+ self._cumul_assoc_len += len(assoc_data)
263
+ if self._assoc_len is not None and \
264
+ self._cumul_assoc_len > self._assoc_len:
265
+ raise ValueError("Associated data is too long")
266
+
267
+ self._update(assoc_data)
268
+ return self
269
+
270
+ def _update(self, assoc_data_pt=b""):
271
+ """Update the MAC with associated data or plaintext
272
+ (without FSM checks)"""
273
+
274
+ # If MAC has not started yet, we just park the data into a list.
275
+ # If the data is mutable, we create a copy and store that instead.
276
+ if self._mac_status == MacStatus.NOT_STARTED:
277
+ if is_writeable_buffer(assoc_data_pt):
278
+ assoc_data_pt = _copy_bytes(None, None, assoc_data_pt)
279
+ self._cache.append(assoc_data_pt)
280
+ return
281
+
282
+ assert(len(self._cache) < self.block_size)
283
+
284
+ if len(self._cache) > 0:
285
+ filler = min(self.block_size - len(self._cache),
286
+ len(assoc_data_pt))
287
+ self._cache += _copy_bytes(None, filler, assoc_data_pt)
288
+ assoc_data_pt = _copy_bytes(filler, None, assoc_data_pt)
289
+
290
+ if len(self._cache) < self.block_size:
291
+ return
292
+
293
+ # The cache is exactly one block
294
+ self._t = self._mac.encrypt(self._cache)
295
+ self._cache = b""
296
+
297
+ update_len = len(assoc_data_pt) // self.block_size * self.block_size
298
+ self._cache = _copy_bytes(update_len, None, assoc_data_pt)
299
+ if update_len > 0:
300
+ self._t = self._mac.encrypt(assoc_data_pt[:update_len])[-16:]
301
+
302
+ def encrypt(self, plaintext, output=None):
303
+ """Encrypt data with the key set at initialization.
304
+
305
+ A cipher object is stateful: once you have encrypted a message
306
+ you cannot encrypt (or decrypt) another message using the same
307
+ object.
308
+
309
+ This method can be called only **once** if ``msg_len`` was
310
+ not passed at initialization.
311
+
312
+ If ``msg_len`` was given, the data to encrypt can be broken
313
+ up in two or more pieces and `encrypt` can be called
314
+ multiple times.
315
+
316
+ That is, the statement:
317
+
318
+ >>> c.encrypt(a) + c.encrypt(b)
319
+
320
+ is equivalent to:
321
+
322
+ >>> c.encrypt(a+b)
323
+
324
+ This function does not add any padding to the plaintext.
325
+
326
+ :Parameters:
327
+ plaintext : bytes/bytearray/memoryview
328
+ The piece of data to encrypt.
329
+ It can be of any length.
330
+ :Keywords:
331
+ output : bytearray/memoryview
332
+ The location where the ciphertext must be written to.
333
+ If ``None``, the ciphertext is returned.
334
+ :Return:
335
+ If ``output`` is ``None``, the ciphertext as ``bytes``.
336
+ Otherwise, ``None``.
337
+ """
338
+
339
+ if self.encrypt not in self._next:
340
+ raise TypeError("encrypt() can only be called after"
341
+ " initialization or an update()")
342
+ self._next = [self.encrypt, self.digest]
343
+
344
+ # No more associated data allowed from now
345
+ if self._assoc_len is None:
346
+ assert(isinstance(self._cache, list))
347
+ self._assoc_len = sum([len(x) for x in self._cache])
348
+ if self._msg_len is not None:
349
+ self._start_mac()
350
+ else:
351
+ if self._cumul_assoc_len < self._assoc_len:
352
+ raise ValueError("Associated data is too short")
353
+
354
+ # Only once piece of plaintext accepted if message length was
355
+ # not declared in advance
356
+ if self._msg_len is None:
357
+ self._msg_len = len(plaintext)
358
+ self._start_mac()
359
+ self._next = [self.digest]
360
+
361
+ self._cumul_msg_len += len(plaintext)
362
+ if self._cumul_msg_len > self._msg_len:
363
+ raise ValueError("Message is too long")
364
+
365
+ if self._mac_status == MacStatus.PROCESSING_AUTH_DATA:
366
+ # Associated data is concatenated with the least number
367
+ # of zero bytes (possibly none) to reach alignment to
368
+ # the 16 byte boundary (A.2.3)
369
+ self._pad_cache_and_update()
370
+ self._mac_status = MacStatus.PROCESSING_PLAINTEXT
371
+
372
+ self._update(plaintext)
373
+ return self._cipher.encrypt(plaintext, output=output)
374
+
375
+ def decrypt(self, ciphertext, output=None):
376
+ """Decrypt data with the key set at initialization.
377
+
378
+ A cipher object is stateful: once you have decrypted a message
379
+ you cannot decrypt (or encrypt) another message with the same
380
+ object.
381
+
382
+ This method can be called only **once** if ``msg_len`` was
383
+ not passed at initialization.
384
+
385
+ If ``msg_len`` was given, the data to decrypt can be
386
+ broken up in two or more pieces and `decrypt` can be
387
+ called multiple times.
388
+
389
+ That is, the statement:
390
+
391
+ >>> c.decrypt(a) + c.decrypt(b)
392
+
393
+ is equivalent to:
394
+
395
+ >>> c.decrypt(a+b)
396
+
397
+ This function does not remove any padding from the plaintext.
398
+
399
+ :Parameters:
400
+ ciphertext : bytes/bytearray/memoryview
401
+ The piece of data to decrypt.
402
+ It can be of any length.
403
+ :Keywords:
404
+ output : bytearray/memoryview
405
+ The location where the plaintext must be written to.
406
+ If ``None``, the plaintext is returned.
407
+ :Return:
408
+ If ``output`` is ``None``, the plaintext as ``bytes``.
409
+ Otherwise, ``None``.
410
+ """
411
+
412
+ if self.decrypt not in self._next:
413
+ raise TypeError("decrypt() can only be called"
414
+ " after initialization or an update()")
415
+ self._next = [self.decrypt, self.verify]
416
+
417
+ # No more associated data allowed from now
418
+ if self._assoc_len is None:
419
+ assert(isinstance(self._cache, list))
420
+ self._assoc_len = sum([len(x) for x in self._cache])
421
+ if self._msg_len is not None:
422
+ self._start_mac()
423
+ else:
424
+ if self._cumul_assoc_len < self._assoc_len:
425
+ raise ValueError("Associated data is too short")
426
+
427
+ # Only once piece of ciphertext accepted if message length was
428
+ # not declared in advance
429
+ if self._msg_len is None:
430
+ self._msg_len = len(ciphertext)
431
+ self._start_mac()
432
+ self._next = [self.verify]
433
+
434
+ self._cumul_msg_len += len(ciphertext)
435
+ if self._cumul_msg_len > self._msg_len:
436
+ raise ValueError("Message is too long")
437
+
438
+ if self._mac_status == MacStatus.PROCESSING_AUTH_DATA:
439
+ # Associated data is concatenated with the least number
440
+ # of zero bytes (possibly none) to reach alignment to
441
+ # the 16 byte boundary (A.2.3)
442
+ self._pad_cache_and_update()
443
+ self._mac_status = MacStatus.PROCESSING_PLAINTEXT
444
+
445
+ # Encrypt is equivalent to decrypt with the CTR mode
446
+ plaintext = self._cipher.encrypt(ciphertext, output=output)
447
+ if output is None:
448
+ self._update(plaintext)
449
+ else:
450
+ self._update(output)
451
+ return plaintext
452
+
453
+ def digest(self):
454
+ """Compute the *binary* MAC tag.
455
+
456
+ The caller invokes this function at the very end.
457
+
458
+ This method returns the MAC that shall be sent to the receiver,
459
+ together with the ciphertext.
460
+
461
+ :Return: the MAC, as a byte string.
462
+ """
463
+
464
+ if self.digest not in self._next:
465
+ raise TypeError("digest() cannot be called when decrypting"
466
+ " or validating a message")
467
+ self._next = [self.digest]
468
+ return self._digest()
469
+
470
+ def _digest(self):
471
+ if self._mac_tag:
472
+ return self._mac_tag
473
+
474
+ if self._assoc_len is None:
475
+ assert(isinstance(self._cache, list))
476
+ self._assoc_len = sum([len(x) for x in self._cache])
477
+ if self._msg_len is not None:
478
+ self._start_mac()
479
+ else:
480
+ if self._cumul_assoc_len < self._assoc_len:
481
+ raise ValueError("Associated data is too short")
482
+
483
+ if self._msg_len is None:
484
+ self._msg_len = 0
485
+ self._start_mac()
486
+
487
+ if self._cumul_msg_len != self._msg_len:
488
+ raise ValueError("Message is too short")
489
+
490
+ # Both associated data and payload are concatenated with the least
491
+ # number of zero bytes (possibly none) that align it to the
492
+ # 16 byte boundary (A.2.2 and A.2.3)
493
+ self._pad_cache_and_update()
494
+
495
+ # Step 8 in 6.1 (T xor MSB_Tlen(S_0))
496
+ self._mac_tag = strxor(self._t, self._s_0)[:self._mac_len]
497
+
498
+ return self._mac_tag
499
+
500
+ def hexdigest(self):
501
+ """Compute the *printable* MAC tag.
502
+
503
+ This method is like `digest`.
504
+
505
+ :Return: the MAC, as a hexadecimal string.
506
+ """
507
+ return "".join(["%02x" % bord(x) for x in self.digest()])
508
+
509
+ def verify(self, received_mac_tag):
510
+ """Validate the *binary* MAC tag.
511
+
512
+ The caller invokes this function at the very end.
513
+
514
+ This method checks if the decrypted message is indeed valid
515
+ (that is, if the key is correct) and it has not been
516
+ tampered with while in transit.
517
+
518
+ :Parameters:
519
+ received_mac_tag : bytes/bytearray/memoryview
520
+ This is the *binary* MAC, as received from the sender.
521
+ :Raises ValueError:
522
+ if the MAC does not match. The message has been tampered with
523
+ or the key is incorrect.
524
+ """
525
+
526
+ if self.verify not in self._next:
527
+ raise TypeError("verify() cannot be called"
528
+ " when encrypting a message")
529
+ self._next = [self.verify]
530
+
531
+ self._digest()
532
+ secret = get_random_bytes(16)
533
+
534
+ mac1 = BLAKE2s.new(digest_bits=160, key=secret, data=self._mac_tag)
535
+ mac2 = BLAKE2s.new(digest_bits=160, key=secret, data=received_mac_tag)
536
+
537
+ if mac1.digest() != mac2.digest():
538
+ raise ValueError("MAC check failed")
539
+
540
+ def hexverify(self, hex_mac_tag):
541
+ """Validate the *printable* MAC tag.
542
+
543
+ This method is like `verify`.
544
+
545
+ :Parameters:
546
+ hex_mac_tag : string
547
+ This is the *printable* MAC, as received from the sender.
548
+ :Raises ValueError:
549
+ if the MAC does not match. The message has been tampered with
550
+ or the key is incorrect.
551
+ """
552
+
553
+ self.verify(unhexlify(hex_mac_tag))
554
+
555
+ def encrypt_and_digest(self, plaintext, output=None):
556
+ """Perform encrypt() and digest() in one step.
557
+
558
+ :Parameters:
559
+ plaintext : bytes/bytearray/memoryview
560
+ The piece of data to encrypt.
561
+ :Keywords:
562
+ output : bytearray/memoryview
563
+ The location where the ciphertext must be written to.
564
+ If ``None``, the ciphertext is returned.
565
+ :Return:
566
+ a tuple with two items:
567
+
568
+ - the ciphertext, as ``bytes``
569
+ - the MAC tag, as ``bytes``
570
+
571
+ The first item becomes ``None`` when the ``output`` parameter
572
+ specified a location for the result.
573
+ """
574
+
575
+ return self.encrypt(plaintext, output=output), self.digest()
576
+
577
+ def decrypt_and_verify(self, ciphertext, received_mac_tag, output=None):
578
+ """Perform decrypt() and verify() in one step.
579
+
580
+ :Parameters:
581
+ ciphertext : bytes/bytearray/memoryview
582
+ The piece of data to decrypt.
583
+ received_mac_tag : bytes/bytearray/memoryview
584
+ This is the *binary* MAC, as received from the sender.
585
+ :Keywords:
586
+ output : bytearray/memoryview
587
+ The location where the plaintext must be written to.
588
+ If ``None``, the plaintext is returned.
589
+ :Return: the plaintext as ``bytes`` or ``None`` when the ``output``
590
+ parameter specified a location for the result.
591
+ :Raises ValueError:
592
+ if the MAC does not match. The message has been tampered with
593
+ or the key is incorrect.
594
+ """
595
+
596
+ plaintext = self.decrypt(ciphertext, output=output)
597
+ self.verify(received_mac_tag)
598
+ return plaintext
599
+
600
+
601
+ def _create_ccm_cipher(factory, **kwargs):
602
+ """Create a new block cipher, configured in CCM mode.
603
+
604
+ :Parameters:
605
+ factory : module
606
+ A symmetric cipher module from `Crypto.Cipher` (like
607
+ `Crypto.Cipher.AES`).
608
+
609
+ :Keywords:
610
+ key : bytes/bytearray/memoryview
611
+ The secret key to use in the symmetric cipher.
612
+
613
+ nonce : bytes/bytearray/memoryview
614
+ A value that must never be reused for any other encryption.
615
+
616
+ Its length must be in the range ``[7..13]``.
617
+ 11 or 12 bytes are reasonable values in general. Bear in
618
+ mind that with CCM there is a trade-off between nonce length and
619
+ maximum message size.
620
+
621
+ If not specified, a 11 byte long random string is used.
622
+
623
+ mac_len : integer
624
+ Length of the MAC, in bytes. It must be even and in
625
+ the range ``[4..16]``. The default is 16.
626
+
627
+ msg_len : integer
628
+ Length of the message to (de)cipher.
629
+ If not specified, ``encrypt`` or ``decrypt`` may only be called once.
630
+
631
+ assoc_len : integer
632
+ Length of the associated data.
633
+ If not specified, all data is internally buffered.
634
+ """
635
+
636
+ try:
637
+ key = key = kwargs.pop("key")
638
+ except KeyError as e:
639
+ raise TypeError("Missing parameter: " + str(e))
640
+
641
+ nonce = kwargs.pop("nonce", None) # N
642
+ if nonce is None:
643
+ nonce = get_random_bytes(11)
644
+ mac_len = kwargs.pop("mac_len", factory.block_size)
645
+ msg_len = kwargs.pop("msg_len", None) # p
646
+ assoc_len = kwargs.pop("assoc_len", None) # a
647
+ cipher_params = dict(kwargs)
648
+
649
+ return CcmMode(factory, key, nonce, mac_len, msg_len,
650
+ assoc_len, cipher_params)
runtime/Lib/site-packages/Crypto/Cipher/_mode_ccm.pyi ADDED
@@ -0,0 +1,47 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from types import ModuleType
2
+ from typing import Union, overload, Dict, Tuple, Optional
3
+
4
+ Buffer = Union[bytes, bytearray, memoryview]
5
+
6
+ __all__ = ['CcmMode']
7
+
8
+ class CcmMode(object):
9
+ block_size: int
10
+ nonce: bytes
11
+
12
+ def __init__(self,
13
+ factory: ModuleType,
14
+ key: Buffer,
15
+ nonce: Buffer,
16
+ mac_len: int,
17
+ msg_len: int,
18
+ assoc_len: int,
19
+ cipher_params: Dict) -> None: ...
20
+
21
+ def update(self, assoc_data: Buffer) -> CcmMode: ...
22
+
23
+ @overload
24
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
25
+ @overload
26
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
27
+ @overload
28
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
29
+ @overload
30
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
31
+
32
+ def digest(self) -> bytes: ...
33
+ def hexdigest(self) -> str: ...
34
+ def verify(self, received_mac_tag: Buffer) -> None: ...
35
+ def hexverify(self, hex_mac_tag: str) -> None: ...
36
+
37
+ @overload
38
+ def encrypt_and_digest(self,
39
+ plaintext: Buffer) -> Tuple[bytes, bytes]: ...
40
+ @overload
41
+ def encrypt_and_digest(self,
42
+ plaintext: Buffer,
43
+ output: Buffer) -> Tuple[None, bytes]: ...
44
+ def decrypt_and_verify(self,
45
+ ciphertext: Buffer,
46
+ received_mac_tag: Buffer,
47
+ output: Optional[Union[bytearray, memoryview]] = ...) -> bytes: ...
runtime/Lib/site-packages/Crypto/Cipher/_mode_cfb.py ADDED
@@ -0,0 +1,293 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/mode_cfb.py : CFB mode
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+
23
+ """
24
+ Counter Feedback (CFB) mode.
25
+ """
26
+
27
+ __all__ = ['CfbMode']
28
+
29
+ from Crypto.Util.py3compat import _copy_bytes
30
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
31
+ create_string_buffer, get_raw_buffer,
32
+ SmartPointer, c_size_t, c_uint8_ptr,
33
+ is_writeable_buffer)
34
+
35
+ from Crypto.Random import get_random_bytes
36
+
37
+ raw_cfb_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_cfb","""
38
+ int CFB_start_operation(void *cipher,
39
+ const uint8_t iv[],
40
+ size_t iv_len,
41
+ size_t segment_len, /* In bytes */
42
+ void **pResult);
43
+ int CFB_encrypt(void *cfbState,
44
+ const uint8_t *in,
45
+ uint8_t *out,
46
+ size_t data_len);
47
+ int CFB_decrypt(void *cfbState,
48
+ const uint8_t *in,
49
+ uint8_t *out,
50
+ size_t data_len);
51
+ int CFB_stop_operation(void *state);"""
52
+ )
53
+
54
+
55
+ class CfbMode(object):
56
+ """*Cipher FeedBack (CFB)*.
57
+
58
+ This mode is similar to CFB, but it transforms
59
+ the underlying block cipher into a stream cipher.
60
+
61
+ Plaintext and ciphertext are processed in *segments*
62
+ of **s** bits. The mode is therefore sometimes
63
+ labelled **s**-bit CFB.
64
+
65
+ An Initialization Vector (*IV*) is required.
66
+
67
+ See `NIST SP800-38A`_ , Section 6.3.
68
+
69
+ .. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
70
+
71
+ :undocumented: __init__
72
+ """
73
+
74
+ def __init__(self, block_cipher, iv, segment_size):
75
+ """Create a new block cipher, configured in CFB mode.
76
+
77
+ :Parameters:
78
+ block_cipher : C pointer
79
+ A smart pointer to the low-level block cipher instance.
80
+
81
+ iv : bytes/bytearray/memoryview
82
+ The initialization vector to use for encryption or decryption.
83
+ It is as long as the cipher block.
84
+
85
+ **The IV must be unpredictable**. Ideally it is picked randomly.
86
+
87
+ Reusing the *IV* for encryptions performed with the same key
88
+ compromises confidentiality.
89
+
90
+ segment_size : integer
91
+ The number of bytes the plaintext and ciphertext are segmented in.
92
+ """
93
+
94
+ self._state = VoidPointer()
95
+ result = raw_cfb_lib.CFB_start_operation(block_cipher.get(),
96
+ c_uint8_ptr(iv),
97
+ c_size_t(len(iv)),
98
+ c_size_t(segment_size),
99
+ self._state.address_of())
100
+ if result:
101
+ raise ValueError("Error %d while instantiating the CFB mode" % result)
102
+
103
+ # Ensure that object disposal of this Python object will (eventually)
104
+ # free the memory allocated by the raw library for the cipher mode
105
+ self._state = SmartPointer(self._state.get(),
106
+ raw_cfb_lib.CFB_stop_operation)
107
+
108
+ # Memory allocated for the underlying block cipher is now owed
109
+ # by the cipher mode
110
+ block_cipher.release()
111
+
112
+ self.block_size = len(iv)
113
+ """The block size of the underlying cipher, in bytes."""
114
+
115
+ self.iv = _copy_bytes(None, None, iv)
116
+ """The Initialization Vector originally used to create the object.
117
+ The value does not change."""
118
+
119
+ self.IV = self.iv
120
+ """Alias for `iv`"""
121
+
122
+ self._next = [ self.encrypt, self.decrypt ]
123
+
124
+ def encrypt(self, plaintext, output=None):
125
+ """Encrypt data with the key and the parameters set at initialization.
126
+
127
+ A cipher object is stateful: once you have encrypted a message
128
+ you cannot encrypt (or decrypt) another message using the same
129
+ object.
130
+
131
+ The data to encrypt can be broken up in two or
132
+ more pieces and `encrypt` can be called multiple times.
133
+
134
+ That is, the statement:
135
+
136
+ >>> c.encrypt(a) + c.encrypt(b)
137
+
138
+ is equivalent to:
139
+
140
+ >>> c.encrypt(a+b)
141
+
142
+ This function does not add any padding to the plaintext.
143
+
144
+ :Parameters:
145
+ plaintext : bytes/bytearray/memoryview
146
+ The piece of data to encrypt.
147
+ It can be of any length.
148
+ :Keywords:
149
+ output : bytearray/memoryview
150
+ The location where the ciphertext must be written to.
151
+ If ``None``, the ciphertext is returned.
152
+ :Return:
153
+ If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
154
+ Otherwise, ``None``.
155
+ """
156
+
157
+ if self.encrypt not in self._next:
158
+ raise TypeError("encrypt() cannot be called after decrypt()")
159
+ self._next = [ self.encrypt ]
160
+
161
+ if output is None:
162
+ ciphertext = create_string_buffer(len(plaintext))
163
+ else:
164
+ ciphertext = output
165
+
166
+ if not is_writeable_buffer(output):
167
+ raise TypeError("output must be a bytearray or a writeable memoryview")
168
+
169
+ if len(plaintext) != len(output):
170
+ raise ValueError("output must have the same length as the input"
171
+ " (%d bytes)" % len(plaintext))
172
+
173
+ result = raw_cfb_lib.CFB_encrypt(self._state.get(),
174
+ c_uint8_ptr(plaintext),
175
+ c_uint8_ptr(ciphertext),
176
+ c_size_t(len(plaintext)))
177
+ if result:
178
+ raise ValueError("Error %d while encrypting in CFB mode" % result)
179
+
180
+ if output is None:
181
+ return get_raw_buffer(ciphertext)
182
+ else:
183
+ return None
184
+
185
+ def decrypt(self, ciphertext, output=None):
186
+ """Decrypt data with the key and the parameters set at initialization.
187
+
188
+ A cipher object is stateful: once you have decrypted a message
189
+ you cannot decrypt (or encrypt) another message with the same
190
+ object.
191
+
192
+ The data to decrypt can be broken up in two or
193
+ more pieces and `decrypt` can be called multiple times.
194
+
195
+ That is, the statement:
196
+
197
+ >>> c.decrypt(a) + c.decrypt(b)
198
+
199
+ is equivalent to:
200
+
201
+ >>> c.decrypt(a+b)
202
+
203
+ This function does not remove any padding from the plaintext.
204
+
205
+ :Parameters:
206
+ ciphertext : bytes/bytearray/memoryview
207
+ The piece of data to decrypt.
208
+ It can be of any length.
209
+ :Keywords:
210
+ output : bytearray/memoryview
211
+ The location where the plaintext must be written to.
212
+ If ``None``, the plaintext is returned.
213
+ :Return:
214
+ If ``output`` is ``None``, the plaintext is returned as ``bytes``.
215
+ Otherwise, ``None``.
216
+ """
217
+
218
+ if self.decrypt not in self._next:
219
+ raise TypeError("decrypt() cannot be called after encrypt()")
220
+ self._next = [ self.decrypt ]
221
+
222
+ if output is None:
223
+ plaintext = create_string_buffer(len(ciphertext))
224
+ else:
225
+ plaintext = output
226
+
227
+ if not is_writeable_buffer(output):
228
+ raise TypeError("output must be a bytearray or a writeable memoryview")
229
+
230
+ if len(ciphertext) != len(output):
231
+ raise ValueError("output must have the same length as the input"
232
+ " (%d bytes)" % len(plaintext))
233
+
234
+ result = raw_cfb_lib.CFB_decrypt(self._state.get(),
235
+ c_uint8_ptr(ciphertext),
236
+ c_uint8_ptr(plaintext),
237
+ c_size_t(len(ciphertext)))
238
+ if result:
239
+ raise ValueError("Error %d while decrypting in CFB mode" % result)
240
+
241
+ if output is None:
242
+ return get_raw_buffer(plaintext)
243
+ else:
244
+ return None
245
+
246
+
247
+ def _create_cfb_cipher(factory, **kwargs):
248
+ """Instantiate a cipher object that performs CFB encryption/decryption.
249
+
250
+ :Parameters:
251
+ factory : module
252
+ The underlying block cipher, a module from ``Crypto.Cipher``.
253
+
254
+ :Keywords:
255
+ iv : bytes/bytearray/memoryview
256
+ The IV to use for CFB.
257
+
258
+ IV : bytes/bytearray/memoryview
259
+ Alias for ``iv``.
260
+
261
+ segment_size : integer
262
+ The number of bit the plaintext and ciphertext are segmented in.
263
+ If not present, the default is 8.
264
+
265
+ Any other keyword will be passed to the underlying block cipher.
266
+ See the relevant documentation for details (at least ``key`` will need
267
+ to be present).
268
+ """
269
+
270
+ cipher_state = factory._create_base_cipher(kwargs)
271
+
272
+ iv = kwargs.pop("IV", None)
273
+ IV = kwargs.pop("iv", None)
274
+
275
+ if (None, None) == (iv, IV):
276
+ iv = get_random_bytes(factory.block_size)
277
+ if iv is not None:
278
+ if IV is not None:
279
+ raise TypeError("You must either use 'iv' or 'IV', not both")
280
+ else:
281
+ iv = IV
282
+
283
+ if len(iv) != factory.block_size:
284
+ raise ValueError("Incorrect IV length (it must be %d bytes long)" %
285
+ factory.block_size)
286
+
287
+ segment_size_bytes, rem = divmod(kwargs.pop("segment_size", 8), 8)
288
+ if segment_size_bytes == 0 or rem != 0:
289
+ raise ValueError("'segment_size' must be positive and multiple of 8 bits")
290
+
291
+ if kwargs:
292
+ raise TypeError("Unknown parameters for CFB: %s" % str(kwargs))
293
+ return CfbMode(cipher_state, iv, segment_size_bytes)
runtime/Lib/site-packages/Crypto/Cipher/_mode_cfb.pyi ADDED
@@ -0,0 +1,26 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, overload
2
+
3
+ from Crypto.Util._raw_api import SmartPointer
4
+
5
+ Buffer = Union[bytes, bytearray, memoryview]
6
+
7
+ __all__ = ['CfbMode']
8
+
9
+
10
+ class CfbMode(object):
11
+ block_size: int
12
+ iv: Buffer
13
+ IV: Buffer
14
+
15
+ def __init__(self,
16
+ block_cipher: SmartPointer,
17
+ iv: Buffer,
18
+ segment_size: int) -> None: ...
19
+ @overload
20
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
21
+ @overload
22
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
23
+ @overload
24
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
25
+ @overload
26
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
runtime/Lib/site-packages/Crypto/Cipher/_mode_ctr.py ADDED
@@ -0,0 +1,393 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/mode_ctr.py : CTR mode
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+
23
+ """
24
+ Counter (CTR) mode.
25
+ """
26
+
27
+ __all__ = ['CtrMode']
28
+
29
+ import struct
30
+
31
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
32
+ create_string_buffer, get_raw_buffer,
33
+ SmartPointer, c_size_t, c_uint8_ptr,
34
+ is_writeable_buffer)
35
+
36
+ from Crypto.Random import get_random_bytes
37
+ from Crypto.Util.py3compat import _copy_bytes, is_native_int
38
+ from Crypto.Util.number import long_to_bytes
39
+
40
+ raw_ctr_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_ctr", """
41
+ int CTR_start_operation(void *cipher,
42
+ uint8_t initialCounterBlock[],
43
+ size_t initialCounterBlock_len,
44
+ size_t prefix_len,
45
+ unsigned counter_len,
46
+ unsigned littleEndian,
47
+ void **pResult);
48
+ int CTR_encrypt(void *ctrState,
49
+ const uint8_t *in,
50
+ uint8_t *out,
51
+ size_t data_len);
52
+ int CTR_decrypt(void *ctrState,
53
+ const uint8_t *in,
54
+ uint8_t *out,
55
+ size_t data_len);
56
+ int CTR_stop_operation(void *ctrState);"""
57
+ )
58
+
59
+
60
+ class CtrMode(object):
61
+ """*CounTeR (CTR)* mode.
62
+
63
+ This mode is very similar to ECB, in that
64
+ encryption of one block is done independently of all other blocks.
65
+
66
+ Unlike ECB, the block *position* contributes to the encryption
67
+ and no information leaks about symbol frequency.
68
+
69
+ Each message block is associated to a *counter* which
70
+ must be unique across all messages that get encrypted
71
+ with the same key (not just within the same message).
72
+ The counter is as big as the block size.
73
+
74
+ Counters can be generated in several ways. The most
75
+ straightword one is to choose an *initial counter block*
76
+ (which can be made public, similarly to the *IV* for the
77
+ other modes) and increment its lowest **m** bits by one
78
+ (modulo *2^m*) for each block. In most cases, **m** is
79
+ chosen to be half the block size.
80
+
81
+ See `NIST SP800-38A`_, Section 6.5 (for the mode) and
82
+ Appendix B (for how to manage the *initial counter block*).
83
+
84
+ .. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
85
+
86
+ :undocumented: __init__
87
+ """
88
+
89
+ def __init__(self, block_cipher, initial_counter_block,
90
+ prefix_len, counter_len, little_endian):
91
+ """Create a new block cipher, configured in CTR mode.
92
+
93
+ :Parameters:
94
+ block_cipher : C pointer
95
+ A smart pointer to the low-level block cipher instance.
96
+
97
+ initial_counter_block : bytes/bytearray/memoryview
98
+ The initial plaintext to use to generate the key stream.
99
+
100
+ It is as large as the cipher block, and it embeds
101
+ the initial value of the counter.
102
+
103
+ This value must not be reused.
104
+ It shall contain a nonce or a random component.
105
+ Reusing the *initial counter block* for encryptions
106
+ performed with the same key compromises confidentiality.
107
+
108
+ prefix_len : integer
109
+ The amount of bytes at the beginning of the counter block
110
+ that never change.
111
+
112
+ counter_len : integer
113
+ The length in bytes of the counter embedded in the counter
114
+ block.
115
+
116
+ little_endian : boolean
117
+ True if the counter in the counter block is an integer encoded
118
+ in little endian mode. If False, it is big endian.
119
+ """
120
+
121
+ if len(initial_counter_block) == prefix_len + counter_len:
122
+ self.nonce = _copy_bytes(None, prefix_len, initial_counter_block)
123
+ """Nonce; not available if there is a fixed suffix"""
124
+
125
+ self._state = VoidPointer()
126
+ result = raw_ctr_lib.CTR_start_operation(block_cipher.get(),
127
+ c_uint8_ptr(initial_counter_block),
128
+ c_size_t(len(initial_counter_block)),
129
+ c_size_t(prefix_len),
130
+ counter_len,
131
+ little_endian,
132
+ self._state.address_of())
133
+ if result:
134
+ raise ValueError("Error %X while instantiating the CTR mode"
135
+ % result)
136
+
137
+ # Ensure that object disposal of this Python object will (eventually)
138
+ # free the memory allocated by the raw library for the cipher mode
139
+ self._state = SmartPointer(self._state.get(),
140
+ raw_ctr_lib.CTR_stop_operation)
141
+
142
+ # Memory allocated for the underlying block cipher is now owed
143
+ # by the cipher mode
144
+ block_cipher.release()
145
+
146
+ self.block_size = len(initial_counter_block)
147
+ """The block size of the underlying cipher, in bytes."""
148
+
149
+ self._next = [self.encrypt, self.decrypt]
150
+
151
+ def encrypt(self, plaintext, output=None):
152
+ """Encrypt data with the key and the parameters set at initialization.
153
+
154
+ A cipher object is stateful: once you have encrypted a message
155
+ you cannot encrypt (or decrypt) another message using the same
156
+ object.
157
+
158
+ The data to encrypt can be broken up in two or
159
+ more pieces and `encrypt` can be called multiple times.
160
+
161
+ That is, the statement:
162
+
163
+ >>> c.encrypt(a) + c.encrypt(b)
164
+
165
+ is equivalent to:
166
+
167
+ >>> c.encrypt(a+b)
168
+
169
+ This function does not add any padding to the plaintext.
170
+
171
+ :Parameters:
172
+ plaintext : bytes/bytearray/memoryview
173
+ The piece of data to encrypt.
174
+ It can be of any length.
175
+ :Keywords:
176
+ output : bytearray/memoryview
177
+ The location where the ciphertext must be written to.
178
+ If ``None``, the ciphertext is returned.
179
+ :Return:
180
+ If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
181
+ Otherwise, ``None``.
182
+ """
183
+
184
+ if self.encrypt not in self._next:
185
+ raise TypeError("encrypt() cannot be called after decrypt()")
186
+ self._next = [self.encrypt]
187
+
188
+ if output is None:
189
+ ciphertext = create_string_buffer(len(plaintext))
190
+ else:
191
+ ciphertext = output
192
+
193
+ if not is_writeable_buffer(output):
194
+ raise TypeError("output must be a bytearray or a writeable memoryview")
195
+
196
+ if len(plaintext) != len(output):
197
+ raise ValueError("output must have the same length as the input"
198
+ " (%d bytes)" % len(plaintext))
199
+
200
+ result = raw_ctr_lib.CTR_encrypt(self._state.get(),
201
+ c_uint8_ptr(plaintext),
202
+ c_uint8_ptr(ciphertext),
203
+ c_size_t(len(plaintext)))
204
+ if result:
205
+ if result == 0x60002:
206
+ raise OverflowError("The counter has wrapped around in"
207
+ " CTR mode")
208
+ raise ValueError("Error %X while encrypting in CTR mode" % result)
209
+
210
+ if output is None:
211
+ return get_raw_buffer(ciphertext)
212
+ else:
213
+ return None
214
+
215
+ def decrypt(self, ciphertext, output=None):
216
+ """Decrypt data with the key and the parameters set at initialization.
217
+
218
+ A cipher object is stateful: once you have decrypted a message
219
+ you cannot decrypt (or encrypt) another message with the same
220
+ object.
221
+
222
+ The data to decrypt can be broken up in two or
223
+ more pieces and `decrypt` can be called multiple times.
224
+
225
+ That is, the statement:
226
+
227
+ >>> c.decrypt(a) + c.decrypt(b)
228
+
229
+ is equivalent to:
230
+
231
+ >>> c.decrypt(a+b)
232
+
233
+ This function does not remove any padding from the plaintext.
234
+
235
+ :Parameters:
236
+ ciphertext : bytes/bytearray/memoryview
237
+ The piece of data to decrypt.
238
+ It can be of any length.
239
+ :Keywords:
240
+ output : bytearray/memoryview
241
+ The location where the plaintext must be written to.
242
+ If ``None``, the plaintext is returned.
243
+ :Return:
244
+ If ``output`` is ``None``, the plaintext is returned as ``bytes``.
245
+ Otherwise, ``None``.
246
+ """
247
+
248
+ if self.decrypt not in self._next:
249
+ raise TypeError("decrypt() cannot be called after encrypt()")
250
+ self._next = [self.decrypt]
251
+
252
+ if output is None:
253
+ plaintext = create_string_buffer(len(ciphertext))
254
+ else:
255
+ plaintext = output
256
+
257
+ if not is_writeable_buffer(output):
258
+ raise TypeError("output must be a bytearray or a writeable memoryview")
259
+
260
+ if len(ciphertext) != len(output):
261
+ raise ValueError("output must have the same length as the input"
262
+ " (%d bytes)" % len(plaintext))
263
+
264
+ result = raw_ctr_lib.CTR_decrypt(self._state.get(),
265
+ c_uint8_ptr(ciphertext),
266
+ c_uint8_ptr(plaintext),
267
+ c_size_t(len(ciphertext)))
268
+ if result:
269
+ if result == 0x60002:
270
+ raise OverflowError("The counter has wrapped around in"
271
+ " CTR mode")
272
+ raise ValueError("Error %X while decrypting in CTR mode" % result)
273
+
274
+ if output is None:
275
+ return get_raw_buffer(plaintext)
276
+ else:
277
+ return None
278
+
279
+
280
+ def _create_ctr_cipher(factory, **kwargs):
281
+ """Instantiate a cipher object that performs CTR encryption/decryption.
282
+
283
+ :Parameters:
284
+ factory : module
285
+ The underlying block cipher, a module from ``Crypto.Cipher``.
286
+
287
+ :Keywords:
288
+ nonce : bytes/bytearray/memoryview
289
+ The fixed part at the beginning of the counter block - the rest is
290
+ the counter number that gets increased when processing the next block.
291
+ The nonce must be such that no two messages are encrypted under the
292
+ same key and the same nonce.
293
+
294
+ The nonce must be shorter than the block size (it can have
295
+ zero length; the counter is then as long as the block).
296
+
297
+ If this parameter is not present, a random nonce will be created with
298
+ length equal to half the block size. No random nonce shorter than
299
+ 64 bits will be created though - you must really think through all
300
+ security consequences of using such a short block size.
301
+
302
+ initial_value : posive integer or bytes/bytearray/memoryview
303
+ The initial value for the counter. If not present, the cipher will
304
+ start counting from 0. The value is incremented by one for each block.
305
+ The counter number is encoded in big endian mode.
306
+
307
+ counter : object
308
+ Instance of ``Crypto.Util.Counter``, which allows full customization
309
+ of the counter block. This parameter is incompatible to both ``nonce``
310
+ and ``initial_value``.
311
+
312
+ Any other keyword will be passed to the underlying block cipher.
313
+ See the relevant documentation for details (at least ``key`` will need
314
+ to be present).
315
+ """
316
+
317
+ cipher_state = factory._create_base_cipher(kwargs)
318
+
319
+ counter = kwargs.pop("counter", None)
320
+ nonce = kwargs.pop("nonce", None)
321
+ initial_value = kwargs.pop("initial_value", None)
322
+ if kwargs:
323
+ raise TypeError("Invalid parameters for CTR mode: %s" % str(kwargs))
324
+
325
+ if counter is not None and (nonce, initial_value) != (None, None):
326
+ raise TypeError("'counter' and 'nonce'/'initial_value'"
327
+ " are mutually exclusive")
328
+
329
+ if counter is None:
330
+ # Crypto.Util.Counter is not used
331
+ if nonce is None:
332
+ if factory.block_size < 16:
333
+ raise TypeError("Impossible to create a safe nonce for short"
334
+ " block sizes")
335
+ nonce = get_random_bytes(factory.block_size // 2)
336
+ else:
337
+ if len(nonce) >= factory.block_size:
338
+ raise ValueError("Nonce is too long")
339
+
340
+ # What is not nonce is counter
341
+ counter_len = factory.block_size - len(nonce)
342
+
343
+ if initial_value is None:
344
+ initial_value = 0
345
+
346
+ if is_native_int(initial_value):
347
+ if (1 << (counter_len * 8)) - 1 < initial_value:
348
+ raise ValueError("Initial counter value is too large")
349
+ initial_counter_block = nonce + long_to_bytes(initial_value, counter_len)
350
+ else:
351
+ if len(initial_value) != counter_len:
352
+ raise ValueError("Incorrect length for counter byte string (%d bytes, expected %d)" %
353
+ (len(initial_value), counter_len))
354
+ initial_counter_block = nonce + initial_value
355
+
356
+ return CtrMode(cipher_state,
357
+ initial_counter_block,
358
+ len(nonce), # prefix
359
+ counter_len,
360
+ False) # little_endian
361
+
362
+ # Crypto.Util.Counter is used
363
+
364
+ # 'counter' used to be a callable object, but now it is
365
+ # just a dictionary for backward compatibility.
366
+ _counter = dict(counter)
367
+ try:
368
+ counter_len = _counter.pop("counter_len")
369
+ prefix = _counter.pop("prefix")
370
+ suffix = _counter.pop("suffix")
371
+ initial_value = _counter.pop("initial_value")
372
+ little_endian = _counter.pop("little_endian")
373
+ except KeyError:
374
+ raise TypeError("Incorrect counter object"
375
+ " (use Crypto.Util.Counter.new)")
376
+
377
+ # Compute initial counter block
378
+ words = []
379
+ while initial_value > 0:
380
+ words.append(struct.pack('B', initial_value & 255))
381
+ initial_value >>= 8
382
+ words += [b'\x00'] * max(0, counter_len - len(words))
383
+ if not little_endian:
384
+ words.reverse()
385
+ initial_counter_block = prefix + b"".join(words) + suffix
386
+
387
+ if len(initial_counter_block) != factory.block_size:
388
+ raise ValueError("Size of the counter block (%d bytes) must match"
389
+ " block size (%d)" % (len(initial_counter_block),
390
+ factory.block_size))
391
+
392
+ return CtrMode(cipher_state, initial_counter_block,
393
+ len(prefix), counter_len, little_endian)
runtime/Lib/site-packages/Crypto/Cipher/_mode_ctr.pyi ADDED
@@ -0,0 +1,27 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, overload
2
+
3
+ from Crypto.Util._raw_api import SmartPointer
4
+
5
+ Buffer = Union[bytes, bytearray, memoryview]
6
+
7
+ __all__ = ['CtrMode']
8
+
9
+ class CtrMode(object):
10
+ block_size: int
11
+ nonce: bytes
12
+
13
+ def __init__(self,
14
+ block_cipher: SmartPointer,
15
+ initial_counter_block: Buffer,
16
+ prefix_len: int,
17
+ counter_len: int,
18
+ little_endian: bool) -> None: ...
19
+ @overload
20
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
21
+ @overload
22
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
23
+ @overload
24
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
25
+ @overload
26
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
27
+
runtime/Lib/site-packages/Crypto/Cipher/_mode_eax.py ADDED
@@ -0,0 +1,408 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # ===================================================================
2
+ #
3
+ # Copyright (c) 2014, Legrandin <helderijs@gmail.com>
4
+ # All rights reserved.
5
+ #
6
+ # Redistribution and use in source and binary forms, with or without
7
+ # modification, are permitted provided that the following conditions
8
+ # are met:
9
+ #
10
+ # 1. Redistributions of source code must retain the above copyright
11
+ # notice, this list of conditions and the following disclaimer.
12
+ # 2. Redistributions in binary form must reproduce the above copyright
13
+ # notice, this list of conditions and the following disclaimer in
14
+ # the documentation and/or other materials provided with the
15
+ # distribution.
16
+ #
17
+ # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18
+ # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19
+ # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20
+ # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21
+ # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22
+ # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23
+ # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24
+ # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25
+ # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
+ # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
27
+ # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28
+ # POSSIBILITY OF SUCH DAMAGE.
29
+ # ===================================================================
30
+
31
+ """
32
+ EAX mode.
33
+ """
34
+
35
+ __all__ = ['EaxMode']
36
+
37
+ import struct
38
+ from binascii import unhexlify
39
+
40
+ from Crypto.Util.py3compat import byte_string, bord, _copy_bytes
41
+
42
+ from Crypto.Util._raw_api import is_buffer
43
+
44
+ from Crypto.Util.strxor import strxor
45
+ from Crypto.Util.number import long_to_bytes, bytes_to_long
46
+
47
+ from Crypto.Hash import CMAC, BLAKE2s
48
+ from Crypto.Random import get_random_bytes
49
+
50
+
51
+ class EaxMode(object):
52
+ """*EAX* mode.
53
+
54
+ This is an Authenticated Encryption with Associated Data
55
+ (`AEAD`_) mode. It provides both confidentiality and authenticity.
56
+
57
+ The header of the message may be left in the clear, if needed,
58
+ and it will still be subject to authentication.
59
+
60
+ The decryption step tells the receiver if the message comes
61
+ from a source that really knowns the secret key.
62
+ Additionally, decryption detects if any part of the message -
63
+ including the header - has been modified or corrupted.
64
+
65
+ This mode requires a *nonce*.
66
+
67
+ This mode is only available for ciphers that operate on 64 or
68
+ 128 bits blocks.
69
+
70
+ There are no official standards defining EAX.
71
+ The implementation is based on `a proposal`__ that
72
+ was presented to NIST.
73
+
74
+ .. _AEAD: http://blog.cryptographyengineering.com/2012/05/how-to-choose-authenticated-encryption.html
75
+ .. __: http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/eax/eax-spec.pdf
76
+
77
+ :undocumented: __init__
78
+ """
79
+
80
+ def __init__(self, factory, key, nonce, mac_len, cipher_params):
81
+ """EAX cipher mode"""
82
+
83
+ self.block_size = factory.block_size
84
+ """The block size of the underlying cipher, in bytes."""
85
+
86
+ self.nonce = _copy_bytes(None, None, nonce)
87
+ """The nonce originally used to create the object."""
88
+
89
+ self._mac_len = mac_len
90
+ self._mac_tag = None # Cache for MAC tag
91
+
92
+ # Allowed transitions after initialization
93
+ self._next = [self.update, self.encrypt, self.decrypt,
94
+ self.digest, self.verify]
95
+
96
+ # MAC tag length
97
+ if not (4 <= self._mac_len <= self.block_size):
98
+ raise ValueError("Parameter 'mac_len' must not be larger than %d"
99
+ % self.block_size)
100
+
101
+ # Nonce cannot be empty and must be a byte string
102
+ if len(self.nonce) == 0:
103
+ raise ValueError("Nonce cannot be empty in EAX mode")
104
+ if not is_buffer(nonce):
105
+ raise TypeError("nonce must be bytes, bytearray or memoryview")
106
+
107
+ self._omac = [
108
+ CMAC.new(key,
109
+ b'\x00' * (self.block_size - 1) + struct.pack('B', i),
110
+ ciphermod=factory,
111
+ cipher_params=cipher_params)
112
+ for i in range(0, 3)
113
+ ]
114
+
115
+ # Compute MAC of nonce
116
+ self._omac[0].update(self.nonce)
117
+ self._signer = self._omac[1]
118
+
119
+ # MAC of the nonce is also the initial counter for CTR encryption
120
+ counter_int = bytes_to_long(self._omac[0].digest())
121
+ self._cipher = factory.new(key,
122
+ factory.MODE_CTR,
123
+ initial_value=counter_int,
124
+ nonce=b"",
125
+ **cipher_params)
126
+
127
+ def update(self, assoc_data):
128
+ """Protect associated data
129
+
130
+ If there is any associated data, the caller has to invoke
131
+ this function one or more times, before using
132
+ ``decrypt`` or ``encrypt``.
133
+
134
+ By *associated data* it is meant any data (e.g. packet headers) that
135
+ will not be encrypted and will be transmitted in the clear.
136
+ However, the receiver is still able to detect any modification to it.
137
+
138
+ If there is no associated data, this method must not be called.
139
+
140
+ The caller may split associated data in segments of any size, and
141
+ invoke this method multiple times, each time with the next segment.
142
+
143
+ :Parameters:
144
+ assoc_data : bytes/bytearray/memoryview
145
+ A piece of associated data. There are no restrictions on its size.
146
+ """
147
+
148
+ if self.update not in self._next:
149
+ raise TypeError("update() can only be called"
150
+ " immediately after initialization")
151
+
152
+ self._next = [self.update, self.encrypt, self.decrypt,
153
+ self.digest, self.verify]
154
+
155
+ self._signer.update(assoc_data)
156
+ return self
157
+
158
+ def encrypt(self, plaintext, output=None):
159
+ """Encrypt data with the key and the parameters set at initialization.
160
+
161
+ A cipher object is stateful: once you have encrypted a message
162
+ you cannot encrypt (or decrypt) another message using the same
163
+ object.
164
+
165
+ The data to encrypt can be broken up in two or
166
+ more pieces and `encrypt` can be called multiple times.
167
+
168
+ That is, the statement:
169
+
170
+ >>> c.encrypt(a) + c.encrypt(b)
171
+
172
+ is equivalent to:
173
+
174
+ >>> c.encrypt(a+b)
175
+
176
+ This function does not add any padding to the plaintext.
177
+
178
+ :Parameters:
179
+ plaintext : bytes/bytearray/memoryview
180
+ The piece of data to encrypt.
181
+ It can be of any length.
182
+ :Keywords:
183
+ output : bytearray/memoryview
184
+ The location where the ciphertext must be written to.
185
+ If ``None``, the ciphertext is returned.
186
+ :Return:
187
+ If ``output`` is ``None``, the ciphertext as ``bytes``.
188
+ Otherwise, ``None``.
189
+ """
190
+
191
+ if self.encrypt not in self._next:
192
+ raise TypeError("encrypt() can only be called after"
193
+ " initialization or an update()")
194
+ self._next = [self.encrypt, self.digest]
195
+ ct = self._cipher.encrypt(plaintext, output=output)
196
+ if output is None:
197
+ self._omac[2].update(ct)
198
+ else:
199
+ self._omac[2].update(output)
200
+ return ct
201
+
202
+ def decrypt(self, ciphertext, output=None):
203
+ """Decrypt data with the key and the parameters set at initialization.
204
+
205
+ A cipher object is stateful: once you have decrypted a message
206
+ you cannot decrypt (or encrypt) another message with the same
207
+ object.
208
+
209
+ The data to decrypt can be broken up in two or
210
+ more pieces and `decrypt` can be called multiple times.
211
+
212
+ That is, the statement:
213
+
214
+ >>> c.decrypt(a) + c.decrypt(b)
215
+
216
+ is equivalent to:
217
+
218
+ >>> c.decrypt(a+b)
219
+
220
+ This function does not remove any padding from the plaintext.
221
+
222
+ :Parameters:
223
+ ciphertext : bytes/bytearray/memoryview
224
+ The piece of data to decrypt.
225
+ It can be of any length.
226
+ :Keywords:
227
+ output : bytearray/memoryview
228
+ The location where the plaintext must be written to.
229
+ If ``None``, the plaintext is returned.
230
+ :Return:
231
+ If ``output`` is ``None``, the plaintext as ``bytes``.
232
+ Otherwise, ``None``.
233
+ """
234
+
235
+ if self.decrypt not in self._next:
236
+ raise TypeError("decrypt() can only be called"
237
+ " after initialization or an update()")
238
+ self._next = [self.decrypt, self.verify]
239
+ self._omac[2].update(ciphertext)
240
+ return self._cipher.decrypt(ciphertext, output=output)
241
+
242
+ def digest(self):
243
+ """Compute the *binary* MAC tag.
244
+
245
+ The caller invokes this function at the very end.
246
+
247
+ This method returns the MAC that shall be sent to the receiver,
248
+ together with the ciphertext.
249
+
250
+ :Return: the MAC, as a byte string.
251
+ """
252
+
253
+ if self.digest not in self._next:
254
+ raise TypeError("digest() cannot be called when decrypting"
255
+ " or validating a message")
256
+ self._next = [self.digest]
257
+
258
+ if not self._mac_tag:
259
+ tag = b'\x00' * self.block_size
260
+ for i in range(3):
261
+ tag = strxor(tag, self._omac[i].digest())
262
+ self._mac_tag = tag[:self._mac_len]
263
+
264
+ return self._mac_tag
265
+
266
+ def hexdigest(self):
267
+ """Compute the *printable* MAC tag.
268
+
269
+ This method is like `digest`.
270
+
271
+ :Return: the MAC, as a hexadecimal string.
272
+ """
273
+ return "".join(["%02x" % bord(x) for x in self.digest()])
274
+
275
+ def verify(self, received_mac_tag):
276
+ """Validate the *binary* MAC tag.
277
+
278
+ The caller invokes this function at the very end.
279
+
280
+ This method checks if the decrypted message is indeed valid
281
+ (that is, if the key is correct) and it has not been
282
+ tampered with while in transit.
283
+
284
+ :Parameters:
285
+ received_mac_tag : bytes/bytearray/memoryview
286
+ This is the *binary* MAC, as received from the sender.
287
+ :Raises MacMismatchError:
288
+ if the MAC does not match. The message has been tampered with
289
+ or the key is incorrect.
290
+ """
291
+
292
+ if self.verify not in self._next:
293
+ raise TypeError("verify() cannot be called"
294
+ " when encrypting a message")
295
+ self._next = [self.verify]
296
+
297
+ if not self._mac_tag:
298
+ tag = b'\x00' * self.block_size
299
+ for i in range(3):
300
+ tag = strxor(tag, self._omac[i].digest())
301
+ self._mac_tag = tag[:self._mac_len]
302
+
303
+ secret = get_random_bytes(16)
304
+
305
+ mac1 = BLAKE2s.new(digest_bits=160, key=secret, data=self._mac_tag)
306
+ mac2 = BLAKE2s.new(digest_bits=160, key=secret, data=received_mac_tag)
307
+
308
+ if mac1.digest() != mac2.digest():
309
+ raise ValueError("MAC check failed")
310
+
311
+ def hexverify(self, hex_mac_tag):
312
+ """Validate the *printable* MAC tag.
313
+
314
+ This method is like `verify`.
315
+
316
+ :Parameters:
317
+ hex_mac_tag : string
318
+ This is the *printable* MAC, as received from the sender.
319
+ :Raises MacMismatchError:
320
+ if the MAC does not match. The message has been tampered with
321
+ or the key is incorrect.
322
+ """
323
+
324
+ self.verify(unhexlify(hex_mac_tag))
325
+
326
+ def encrypt_and_digest(self, plaintext, output=None):
327
+ """Perform encrypt() and digest() in one step.
328
+
329
+ :Parameters:
330
+ plaintext : bytes/bytearray/memoryview
331
+ The piece of data to encrypt.
332
+ :Keywords:
333
+ output : bytearray/memoryview
334
+ The location where the ciphertext must be written to.
335
+ If ``None``, the ciphertext is returned.
336
+ :Return:
337
+ a tuple with two items:
338
+
339
+ - the ciphertext, as ``bytes``
340
+ - the MAC tag, as ``bytes``
341
+
342
+ The first item becomes ``None`` when the ``output`` parameter
343
+ specified a location for the result.
344
+ """
345
+
346
+ return self.encrypt(plaintext, output=output), self.digest()
347
+
348
+ def decrypt_and_verify(self, ciphertext, received_mac_tag, output=None):
349
+ """Perform decrypt() and verify() in one step.
350
+
351
+ :Parameters:
352
+ ciphertext : bytes/bytearray/memoryview
353
+ The piece of data to decrypt.
354
+ received_mac_tag : bytes/bytearray/memoryview
355
+ This is the *binary* MAC, as received from the sender.
356
+ :Keywords:
357
+ output : bytearray/memoryview
358
+ The location where the plaintext must be written to.
359
+ If ``None``, the plaintext is returned.
360
+ :Return: the plaintext as ``bytes`` or ``None`` when the ``output``
361
+ parameter specified a location for the result.
362
+ :Raises MacMismatchError:
363
+ if the MAC does not match. The message has been tampered with
364
+ or the key is incorrect.
365
+ """
366
+
367
+ pt = self.decrypt(ciphertext, output=output)
368
+ self.verify(received_mac_tag)
369
+ return pt
370
+
371
+
372
+ def _create_eax_cipher(factory, **kwargs):
373
+ """Create a new block cipher, configured in EAX mode.
374
+
375
+ :Parameters:
376
+ factory : module
377
+ A symmetric cipher module from `Crypto.Cipher` (like
378
+ `Crypto.Cipher.AES`).
379
+
380
+ :Keywords:
381
+ key : bytes/bytearray/memoryview
382
+ The secret key to use in the symmetric cipher.
383
+
384
+ nonce : bytes/bytearray/memoryview
385
+ A value that must never be reused for any other encryption.
386
+ There are no restrictions on its length, but it is recommended to use
387
+ at least 16 bytes.
388
+
389
+ The nonce shall never repeat for two different messages encrypted with
390
+ the same key, but it does not need to be random.
391
+
392
+ If not specified, a 16 byte long random string is used.
393
+
394
+ mac_len : integer
395
+ Length of the MAC, in bytes. It must be no larger than the cipher
396
+ block bytes (which is the default).
397
+ """
398
+
399
+ try:
400
+ key = kwargs.pop("key")
401
+ nonce = kwargs.pop("nonce", None)
402
+ if nonce is None:
403
+ nonce = get_random_bytes(16)
404
+ mac_len = kwargs.pop("mac_len", factory.block_size)
405
+ except KeyError as e:
406
+ raise TypeError("Missing parameter: " + str(e))
407
+
408
+ return EaxMode(factory, key, nonce, mac_len, kwargs)
runtime/Lib/site-packages/Crypto/Cipher/_mode_eax.pyi ADDED
@@ -0,0 +1,45 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from types import ModuleType
2
+ from typing import Any, Union, Tuple, Dict, overload, Optional
3
+
4
+ Buffer = Union[bytes, bytearray, memoryview]
5
+
6
+ __all__ = ['EaxMode']
7
+
8
+ class EaxMode(object):
9
+ block_size: int
10
+ nonce: bytes
11
+
12
+ def __init__(self,
13
+ factory: ModuleType,
14
+ key: Buffer,
15
+ nonce: Buffer,
16
+ mac_len: int,
17
+ cipher_params: Dict) -> None: ...
18
+
19
+ def update(self, assoc_data: Buffer) -> EaxMode: ...
20
+
21
+ @overload
22
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
23
+ @overload
24
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
25
+ @overload
26
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
27
+ @overload
28
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
29
+
30
+ def digest(self) -> bytes: ...
31
+ def hexdigest(self) -> str: ...
32
+ def verify(self, received_mac_tag: Buffer) -> None: ...
33
+ def hexverify(self, hex_mac_tag: str) -> None: ...
34
+
35
+ @overload
36
+ def encrypt_and_digest(self,
37
+ plaintext: Buffer) -> Tuple[bytes, bytes]: ...
38
+ @overload
39
+ def encrypt_and_digest(self,
40
+ plaintext: Buffer,
41
+ output: Buffer) -> Tuple[None, bytes]: ...
42
+ def decrypt_and_verify(self,
43
+ ciphertext: Buffer,
44
+ received_mac_tag: Buffer,
45
+ output: Optional[Union[bytearray, memoryview]] = ...) -> bytes: ...
runtime/Lib/site-packages/Crypto/Cipher/_mode_ecb.py ADDED
@@ -0,0 +1,220 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/mode_ecb.py : ECB mode
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+
23
+ """
24
+ Electronic Code Book (ECB) mode.
25
+ """
26
+
27
+ __all__ = [ 'EcbMode' ]
28
+
29
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
30
+ VoidPointer, create_string_buffer,
31
+ get_raw_buffer, SmartPointer,
32
+ c_size_t, c_uint8_ptr,
33
+ is_writeable_buffer)
34
+
35
+ raw_ecb_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_ecb", """
36
+ int ECB_start_operation(void *cipher,
37
+ void **pResult);
38
+ int ECB_encrypt(void *ecbState,
39
+ const uint8_t *in,
40
+ uint8_t *out,
41
+ size_t data_len);
42
+ int ECB_decrypt(void *ecbState,
43
+ const uint8_t *in,
44
+ uint8_t *out,
45
+ size_t data_len);
46
+ int ECB_stop_operation(void *state);
47
+ """
48
+ )
49
+
50
+
51
+ class EcbMode(object):
52
+ """*Electronic Code Book (ECB)*.
53
+
54
+ This is the simplest encryption mode. Each of the plaintext blocks
55
+ is directly encrypted into a ciphertext block, independently of
56
+ any other block.
57
+
58
+ This mode is dangerous because it exposes frequency of symbols
59
+ in your plaintext. Other modes (e.g. *CBC*) should be used instead.
60
+
61
+ See `NIST SP800-38A`_ , Section 6.1.
62
+
63
+ .. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
64
+
65
+ :undocumented: __init__
66
+ """
67
+
68
+ def __init__(self, block_cipher):
69
+ """Create a new block cipher, configured in ECB mode.
70
+
71
+ :Parameters:
72
+ block_cipher : C pointer
73
+ A smart pointer to the low-level block cipher instance.
74
+ """
75
+ self.block_size = block_cipher.block_size
76
+
77
+ self._state = VoidPointer()
78
+ result = raw_ecb_lib.ECB_start_operation(block_cipher.get(),
79
+ self._state.address_of())
80
+ if result:
81
+ raise ValueError("Error %d while instantiating the ECB mode"
82
+ % result)
83
+
84
+ # Ensure that object disposal of this Python object will (eventually)
85
+ # free the memory allocated by the raw library for the cipher
86
+ # mode
87
+ self._state = SmartPointer(self._state.get(),
88
+ raw_ecb_lib.ECB_stop_operation)
89
+
90
+ # Memory allocated for the underlying block cipher is now owned
91
+ # by the cipher mode
92
+ block_cipher.release()
93
+
94
+ def encrypt(self, plaintext, output=None):
95
+ """Encrypt data with the key set at initialization.
96
+
97
+ The data to encrypt can be broken up in two or
98
+ more pieces and `encrypt` can be called multiple times.
99
+
100
+ That is, the statement:
101
+
102
+ >>> c.encrypt(a) + c.encrypt(b)
103
+
104
+ is equivalent to:
105
+
106
+ >>> c.encrypt(a+b)
107
+
108
+ This function does not add any padding to the plaintext.
109
+
110
+ :Parameters:
111
+ plaintext : bytes/bytearray/memoryview
112
+ The piece of data to encrypt.
113
+ The length must be multiple of the cipher block length.
114
+ :Keywords:
115
+ output : bytearray/memoryview
116
+ The location where the ciphertext must be written to.
117
+ If ``None``, the ciphertext is returned.
118
+ :Return:
119
+ If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
120
+ Otherwise, ``None``.
121
+ """
122
+
123
+ if output is None:
124
+ ciphertext = create_string_buffer(len(plaintext))
125
+ else:
126
+ ciphertext = output
127
+
128
+ if not is_writeable_buffer(output):
129
+ raise TypeError("output must be a bytearray or a writeable memoryview")
130
+
131
+ if len(plaintext) != len(output):
132
+ raise ValueError("output must have the same length as the input"
133
+ " (%d bytes)" % len(plaintext))
134
+
135
+ result = raw_ecb_lib.ECB_encrypt(self._state.get(),
136
+ c_uint8_ptr(plaintext),
137
+ c_uint8_ptr(ciphertext),
138
+ c_size_t(len(plaintext)))
139
+ if result:
140
+ if result == 3:
141
+ raise ValueError("Data must be aligned to block boundary in ECB mode")
142
+ raise ValueError("Error %d while encrypting in ECB mode" % result)
143
+
144
+ if output is None:
145
+ return get_raw_buffer(ciphertext)
146
+ else:
147
+ return None
148
+
149
+ def decrypt(self, ciphertext, output=None):
150
+ """Decrypt data with the key set at initialization.
151
+
152
+ The data to decrypt can be broken up in two or
153
+ more pieces and `decrypt` can be called multiple times.
154
+
155
+ That is, the statement:
156
+
157
+ >>> c.decrypt(a) + c.decrypt(b)
158
+
159
+ is equivalent to:
160
+
161
+ >>> c.decrypt(a+b)
162
+
163
+ This function does not remove any padding from the plaintext.
164
+
165
+ :Parameters:
166
+ ciphertext : bytes/bytearray/memoryview
167
+ The piece of data to decrypt.
168
+ The length must be multiple of the cipher block length.
169
+ :Keywords:
170
+ output : bytearray/memoryview
171
+ The location where the plaintext must be written to.
172
+ If ``None``, the plaintext is returned.
173
+ :Return:
174
+ If ``output`` is ``None``, the plaintext is returned as ``bytes``.
175
+ Otherwise, ``None``.
176
+ """
177
+
178
+ if output is None:
179
+ plaintext = create_string_buffer(len(ciphertext))
180
+ else:
181
+ plaintext = output
182
+
183
+ if not is_writeable_buffer(output):
184
+ raise TypeError("output must be a bytearray or a writeable memoryview")
185
+
186
+ if len(ciphertext) != len(output):
187
+ raise ValueError("output must have the same length as the input"
188
+ " (%d bytes)" % len(plaintext))
189
+
190
+ result = raw_ecb_lib.ECB_decrypt(self._state.get(),
191
+ c_uint8_ptr(ciphertext),
192
+ c_uint8_ptr(plaintext),
193
+ c_size_t(len(ciphertext)))
194
+ if result:
195
+ if result == 3:
196
+ raise ValueError("Data must be aligned to block boundary in ECB mode")
197
+ raise ValueError("Error %d while decrypting in ECB mode" % result)
198
+
199
+ if output is None:
200
+ return get_raw_buffer(plaintext)
201
+ else:
202
+ return None
203
+
204
+
205
+ def _create_ecb_cipher(factory, **kwargs):
206
+ """Instantiate a cipher object that performs ECB encryption/decryption.
207
+
208
+ :Parameters:
209
+ factory : module
210
+ The underlying block cipher, a module from ``Crypto.Cipher``.
211
+
212
+ All keywords are passed to the underlying block cipher.
213
+ See the relevant documentation for details (at least ``key`` will need
214
+ to be present"""
215
+
216
+ cipher_state = factory._create_base_cipher(kwargs)
217
+ cipher_state.block_size = factory.block_size
218
+ if kwargs:
219
+ raise TypeError("Unknown parameters for ECB: %s" % str(kwargs))
220
+ return EcbMode(cipher_state)
runtime/Lib/site-packages/Crypto/Cipher/_mode_ecb.pyi ADDED
@@ -0,0 +1,19 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, overload
2
+
3
+ from Crypto.Util._raw_api import SmartPointer
4
+
5
+ Buffer = Union[bytes, bytearray, memoryview]
6
+
7
+ __all__ = [ 'EcbMode' ]
8
+
9
+ class EcbMode(object):
10
+ def __init__(self, block_cipher: SmartPointer) -> None: ...
11
+ @overload
12
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
13
+ @overload
14
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
15
+ @overload
16
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
17
+ @overload
18
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
19
+
runtime/Lib/site-packages/Crypto/Cipher/_mode_gcm.py ADDED
@@ -0,0 +1,620 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # ===================================================================
2
+ #
3
+ # Copyright (c) 2014, Legrandin <helderijs@gmail.com>
4
+ # All rights reserved.
5
+ #
6
+ # Redistribution and use in source and binary forms, with or without
7
+ # modification, are permitted provided that the following conditions
8
+ # are met:
9
+ #
10
+ # 1. Redistributions of source code must retain the above copyright
11
+ # notice, this list of conditions and the following disclaimer.
12
+ # 2. Redistributions in binary form must reproduce the above copyright
13
+ # notice, this list of conditions and the following disclaimer in
14
+ # the documentation and/or other materials provided with the
15
+ # distribution.
16
+ #
17
+ # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18
+ # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19
+ # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20
+ # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21
+ # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22
+ # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23
+ # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24
+ # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25
+ # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
+ # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
27
+ # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28
+ # POSSIBILITY OF SUCH DAMAGE.
29
+ # ===================================================================
30
+
31
+ """
32
+ Galois/Counter Mode (GCM).
33
+ """
34
+
35
+ __all__ = ['GcmMode']
36
+
37
+ from binascii import unhexlify
38
+
39
+ from Crypto.Util.py3compat import bord, _copy_bytes
40
+
41
+ from Crypto.Util._raw_api import is_buffer
42
+
43
+ from Crypto.Util.number import long_to_bytes, bytes_to_long
44
+ from Crypto.Hash import BLAKE2s
45
+ from Crypto.Random import get_random_bytes
46
+
47
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
48
+ create_string_buffer, get_raw_buffer,
49
+ SmartPointer, c_size_t, c_uint8_ptr)
50
+
51
+ from Crypto.Util import _cpu_features
52
+
53
+
54
+ # C API by module implementing GHASH
55
+ _ghash_api_template = """
56
+ int ghash_%imp%(uint8_t y_out[16],
57
+ const uint8_t block_data[],
58
+ size_t len,
59
+ const uint8_t y_in[16],
60
+ const void *exp_key);
61
+ int ghash_expand_%imp%(const uint8_t h[16],
62
+ void **ghash_tables);
63
+ int ghash_destroy_%imp%(void *ghash_tables);
64
+ """
65
+
66
+ def _build_impl(lib, postfix):
67
+ from collections import namedtuple
68
+
69
+ funcs = ( "ghash", "ghash_expand", "ghash_destroy" )
70
+ GHASH_Imp = namedtuple('_GHash_Imp', funcs)
71
+ try:
72
+ imp_funcs = [ getattr(lib, x + "_" + postfix) for x in funcs ]
73
+ except AttributeError: # Make sphinx stop complaining with its mocklib
74
+ imp_funcs = [ None ] * 3
75
+ params = dict(zip(funcs, imp_funcs))
76
+ return GHASH_Imp(**params)
77
+
78
+
79
+ def _get_ghash_portable():
80
+ api = _ghash_api_template.replace("%imp%", "portable")
81
+ lib = load_pycryptodome_raw_lib("Crypto.Hash._ghash_portable", api)
82
+ result = _build_impl(lib, "portable")
83
+ return result
84
+ _ghash_portable = _get_ghash_portable()
85
+
86
+
87
+ def _get_ghash_clmul():
88
+ """Return None if CLMUL implementation is not available"""
89
+
90
+ if not _cpu_features.have_clmul():
91
+ return None
92
+ try:
93
+ api = _ghash_api_template.replace("%imp%", "clmul")
94
+ lib = load_pycryptodome_raw_lib("Crypto.Hash._ghash_clmul", api)
95
+ result = _build_impl(lib, "clmul")
96
+ except OSError:
97
+ result = None
98
+ return result
99
+ _ghash_clmul = _get_ghash_clmul()
100
+
101
+
102
+ class _GHASH(object):
103
+ """GHASH function defined in NIST SP 800-38D, Algorithm 2.
104
+
105
+ If X_1, X_2, .. X_m are the blocks of input data, the function
106
+ computes:
107
+
108
+ X_1*H^{m} + X_2*H^{m-1} + ... + X_m*H
109
+
110
+ in the Galois field GF(2^256) using the reducing polynomial
111
+ (x^128 + x^7 + x^2 + x + 1).
112
+ """
113
+
114
+ def __init__(self, subkey, ghash_c):
115
+ assert len(subkey) == 16
116
+
117
+ self.ghash_c = ghash_c
118
+
119
+ self._exp_key = VoidPointer()
120
+ result = ghash_c.ghash_expand(c_uint8_ptr(subkey),
121
+ self._exp_key.address_of())
122
+ if result:
123
+ raise ValueError("Error %d while expanding the GHASH key" % result)
124
+
125
+ self._exp_key = SmartPointer(self._exp_key.get(),
126
+ ghash_c.ghash_destroy)
127
+
128
+ # create_string_buffer always returns a string of zeroes
129
+ self._last_y = create_string_buffer(16)
130
+
131
+ def update(self, block_data):
132
+ assert len(block_data) % 16 == 0
133
+
134
+ result = self.ghash_c.ghash(self._last_y,
135
+ c_uint8_ptr(block_data),
136
+ c_size_t(len(block_data)),
137
+ self._last_y,
138
+ self._exp_key.get())
139
+ if result:
140
+ raise ValueError("Error %d while updating GHASH" % result)
141
+
142
+ return self
143
+
144
+ def digest(self):
145
+ return get_raw_buffer(self._last_y)
146
+
147
+
148
+ def enum(**enums):
149
+ return type('Enum', (), enums)
150
+
151
+
152
+ MacStatus = enum(PROCESSING_AUTH_DATA=1, PROCESSING_CIPHERTEXT=2)
153
+
154
+
155
+ class GcmMode(object):
156
+ """Galois Counter Mode (GCM).
157
+
158
+ This is an Authenticated Encryption with Associated Data (`AEAD`_) mode.
159
+ It provides both confidentiality and authenticity.
160
+
161
+ The header of the message may be left in the clear, if needed, and it will
162
+ still be subject to authentication. The decryption step tells the receiver
163
+ if the message comes from a source that really knowns the secret key.
164
+ Additionally, decryption detects if any part of the message - including the
165
+ header - has been modified or corrupted.
166
+
167
+ This mode requires a *nonce*.
168
+
169
+ This mode is only available for ciphers that operate on 128 bits blocks
170
+ (e.g. AES but not TDES).
171
+
172
+ See `NIST SP800-38D`_.
173
+
174
+ .. _`NIST SP800-38D`: http://csrc.nist.gov/publications/nistpubs/800-38D/SP-800-38D.pdf
175
+ .. _AEAD: http://blog.cryptographyengineering.com/2012/05/how-to-choose-authenticated-encryption.html
176
+
177
+ :undocumented: __init__
178
+ """
179
+
180
+ def __init__(self, factory, key, nonce, mac_len, cipher_params, ghash_c):
181
+
182
+ self.block_size = factory.block_size
183
+ if self.block_size != 16:
184
+ raise ValueError("GCM mode is only available for ciphers"
185
+ " that operate on 128 bits blocks")
186
+
187
+ if len(nonce) == 0:
188
+ raise ValueError("Nonce cannot be empty")
189
+
190
+ if not is_buffer(nonce):
191
+ raise TypeError("Nonce must be bytes, bytearray or memoryview")
192
+
193
+ # See NIST SP 800 38D, 5.2.1.1
194
+ if len(nonce) > 2**64 - 1:
195
+ raise ValueError("Nonce exceeds maximum length")
196
+
197
+
198
+ self.nonce = _copy_bytes(None, None, nonce)
199
+ """Nonce"""
200
+
201
+ self._factory = factory
202
+ self._key = _copy_bytes(None, None, key)
203
+ self._tag = None # Cache for MAC tag
204
+
205
+ self._mac_len = mac_len
206
+ if not (4 <= mac_len <= 16):
207
+ raise ValueError("Parameter 'mac_len' must be in the range 4..16")
208
+
209
+ # Allowed transitions after initialization
210
+ self._next = [self.update, self.encrypt, self.decrypt,
211
+ self.digest, self.verify]
212
+
213
+ self._no_more_assoc_data = False
214
+
215
+ # Length of associated data
216
+ self._auth_len = 0
217
+
218
+ # Length of the ciphertext or plaintext
219
+ self._msg_len = 0
220
+
221
+ # Step 1 in SP800-38D, Algorithm 4 (encryption) - Compute H
222
+ # See also Algorithm 5 (decryption)
223
+ hash_subkey = factory.new(key,
224
+ self._factory.MODE_ECB,
225
+ **cipher_params
226
+ ).encrypt(b'\x00' * 16)
227
+
228
+ # Step 2 - Compute J0
229
+ if len(self.nonce) == 12:
230
+ j0 = self.nonce + b"\x00\x00\x00\x01"
231
+ else:
232
+ fill = (16 - (len(nonce) % 16)) % 16 + 8
233
+ ghash_in = (self.nonce +
234
+ b'\x00' * fill +
235
+ long_to_bytes(8 * len(nonce), 8))
236
+ j0 = _GHASH(hash_subkey, ghash_c).update(ghash_in).digest()
237
+
238
+ # Step 3 - Prepare GCTR cipher for encryption/decryption
239
+ nonce_ctr = j0[:12]
240
+ iv_ctr = (bytes_to_long(j0) + 1) & 0xFFFFFFFF
241
+ self._cipher = factory.new(key,
242
+ self._factory.MODE_CTR,
243
+ initial_value=iv_ctr,
244
+ nonce=nonce_ctr,
245
+ **cipher_params)
246
+
247
+ # Step 5 - Bootstrat GHASH
248
+ self._signer = _GHASH(hash_subkey, ghash_c)
249
+
250
+ # Step 6 - Prepare GCTR cipher for GMAC
251
+ self._tag_cipher = factory.new(key,
252
+ self._factory.MODE_CTR,
253
+ initial_value=j0,
254
+ nonce=b"",
255
+ **cipher_params)
256
+
257
+ # Cache for data to authenticate
258
+ self._cache = b""
259
+
260
+ self._status = MacStatus.PROCESSING_AUTH_DATA
261
+
262
+ def update(self, assoc_data):
263
+ """Protect associated data
264
+
265
+ If there is any associated data, the caller has to invoke
266
+ this function one or more times, before using
267
+ ``decrypt`` or ``encrypt``.
268
+
269
+ By *associated data* it is meant any data (e.g. packet headers) that
270
+ will not be encrypted and will be transmitted in the clear.
271
+ However, the receiver is still able to detect any modification to it.
272
+ In GCM, the *associated data* is also called
273
+ *additional authenticated data* (AAD).
274
+
275
+ If there is no associated data, this method must not be called.
276
+
277
+ The caller may split associated data in segments of any size, and
278
+ invoke this method multiple times, each time with the next segment.
279
+
280
+ :Parameters:
281
+ assoc_data : bytes/bytearray/memoryview
282
+ A piece of associated data. There are no restrictions on its size.
283
+ """
284
+
285
+ if self.update not in self._next:
286
+ raise TypeError("update() can only be called"
287
+ " immediately after initialization")
288
+
289
+ self._next = [self.update, self.encrypt, self.decrypt,
290
+ self.digest, self.verify]
291
+
292
+ self._update(assoc_data)
293
+ self._auth_len += len(assoc_data)
294
+
295
+ # See NIST SP 800 38D, 5.2.1.1
296
+ if self._auth_len > 2**64 - 1:
297
+ raise ValueError("Additional Authenticated Data exceeds maximum length")
298
+
299
+ return self
300
+
301
+ def _update(self, data):
302
+ assert(len(self._cache) < 16)
303
+
304
+ if len(self._cache) > 0:
305
+ filler = min(16 - len(self._cache), len(data))
306
+ self._cache += _copy_bytes(None, filler, data)
307
+ data = data[filler:]
308
+
309
+ if len(self._cache) < 16:
310
+ return
311
+
312
+ # The cache is exactly one block
313
+ self._signer.update(self._cache)
314
+ self._cache = b""
315
+
316
+ update_len = len(data) // 16 * 16
317
+ self._cache = _copy_bytes(update_len, None, data)
318
+ if update_len > 0:
319
+ self._signer.update(data[:update_len])
320
+
321
+ def _pad_cache_and_update(self):
322
+ assert(len(self._cache) < 16)
323
+
324
+ # The authenticated data A is concatenated to the minimum
325
+ # number of zero bytes (possibly none) such that the
326
+ # - ciphertext C is aligned to the 16 byte boundary.
327
+ # See step 5 in section 7.1
328
+ # - ciphertext C is aligned to the 16 byte boundary.
329
+ # See step 6 in section 7.2
330
+ len_cache = len(self._cache)
331
+ if len_cache > 0:
332
+ self._update(b'\x00' * (16 - len_cache))
333
+
334
+ def encrypt(self, plaintext, output=None):
335
+ """Encrypt data with the key and the parameters set at initialization.
336
+
337
+ A cipher object is stateful: once you have encrypted a message
338
+ you cannot encrypt (or decrypt) another message using the same
339
+ object.
340
+
341
+ The data to encrypt can be broken up in two or
342
+ more pieces and `encrypt` can be called multiple times.
343
+
344
+ That is, the statement:
345
+
346
+ >>> c.encrypt(a) + c.encrypt(b)
347
+
348
+ is equivalent to:
349
+
350
+ >>> c.encrypt(a+b)
351
+
352
+ This function does not add any padding to the plaintext.
353
+
354
+ :Parameters:
355
+ plaintext : bytes/bytearray/memoryview
356
+ The piece of data to encrypt.
357
+ It can be of any length.
358
+ :Keywords:
359
+ output : bytearray/memoryview
360
+ The location where the ciphertext must be written to.
361
+ If ``None``, the ciphertext is returned.
362
+ :Return:
363
+ If ``output`` is ``None``, the ciphertext as ``bytes``.
364
+ Otherwise, ``None``.
365
+ """
366
+
367
+ if self.encrypt not in self._next:
368
+ raise TypeError("encrypt() can only be called after"
369
+ " initialization or an update()")
370
+ self._next = [self.encrypt, self.digest]
371
+
372
+ ciphertext = self._cipher.encrypt(plaintext, output=output)
373
+
374
+ if self._status == MacStatus.PROCESSING_AUTH_DATA:
375
+ self._pad_cache_and_update()
376
+ self._status = MacStatus.PROCESSING_CIPHERTEXT
377
+
378
+ self._update(ciphertext if output is None else output)
379
+ self._msg_len += len(plaintext)
380
+
381
+ # See NIST SP 800 38D, 5.2.1.1
382
+ if self._msg_len > 2**39 - 256:
383
+ raise ValueError("Plaintext exceeds maximum length")
384
+
385
+ return ciphertext
386
+
387
+ def decrypt(self, ciphertext, output=None):
388
+ """Decrypt data with the key and the parameters set at initialization.
389
+
390
+ A cipher object is stateful: once you have decrypted a message
391
+ you cannot decrypt (or encrypt) another message with the same
392
+ object.
393
+
394
+ The data to decrypt can be broken up in two or
395
+ more pieces and `decrypt` can be called multiple times.
396
+
397
+ That is, the statement:
398
+
399
+ >>> c.decrypt(a) + c.decrypt(b)
400
+
401
+ is equivalent to:
402
+
403
+ >>> c.decrypt(a+b)
404
+
405
+ This function does not remove any padding from the plaintext.
406
+
407
+ :Parameters:
408
+ ciphertext : bytes/bytearray/memoryview
409
+ The piece of data to decrypt.
410
+ It can be of any length.
411
+ :Keywords:
412
+ output : bytearray/memoryview
413
+ The location where the plaintext must be written to.
414
+ If ``None``, the plaintext is returned.
415
+ :Return:
416
+ If ``output`` is ``None``, the plaintext as ``bytes``.
417
+ Otherwise, ``None``.
418
+ """
419
+
420
+ if self.decrypt not in self._next:
421
+ raise TypeError("decrypt() can only be called"
422
+ " after initialization or an update()")
423
+ self._next = [self.decrypt, self.verify]
424
+
425
+ if self._status == MacStatus.PROCESSING_AUTH_DATA:
426
+ self._pad_cache_and_update()
427
+ self._status = MacStatus.PROCESSING_CIPHERTEXT
428
+
429
+ self._update(ciphertext)
430
+ self._msg_len += len(ciphertext)
431
+
432
+ return self._cipher.decrypt(ciphertext, output=output)
433
+
434
+ def digest(self):
435
+ """Compute the *binary* MAC tag in an AEAD mode.
436
+
437
+ The caller invokes this function at the very end.
438
+
439
+ This method returns the MAC that shall be sent to the receiver,
440
+ together with the ciphertext.
441
+
442
+ :Return: the MAC, as a byte string.
443
+ """
444
+
445
+ if self.digest not in self._next:
446
+ raise TypeError("digest() cannot be called when decrypting"
447
+ " or validating a message")
448
+ self._next = [self.digest]
449
+
450
+ return self._compute_mac()
451
+
452
+ def _compute_mac(self):
453
+ """Compute MAC without any FSM checks."""
454
+
455
+ if self._tag:
456
+ return self._tag
457
+
458
+ # Step 5 in NIST SP 800-38D, Algorithm 4 - Compute S
459
+ self._pad_cache_and_update()
460
+ self._update(long_to_bytes(8 * self._auth_len, 8))
461
+ self._update(long_to_bytes(8 * self._msg_len, 8))
462
+ s_tag = self._signer.digest()
463
+
464
+ # Step 6 - Compute T
465
+ self._tag = self._tag_cipher.encrypt(s_tag)[:self._mac_len]
466
+
467
+ return self._tag
468
+
469
+ def hexdigest(self):
470
+ """Compute the *printable* MAC tag.
471
+
472
+ This method is like `digest`.
473
+
474
+ :Return: the MAC, as a hexadecimal string.
475
+ """
476
+ return "".join(["%02x" % bord(x) for x in self.digest()])
477
+
478
+ def verify(self, received_mac_tag):
479
+ """Validate the *binary* MAC tag.
480
+
481
+ The caller invokes this function at the very end.
482
+
483
+ This method checks if the decrypted message is indeed valid
484
+ (that is, if the key is correct) and it has not been
485
+ tampered with while in transit.
486
+
487
+ :Parameters:
488
+ received_mac_tag : bytes/bytearray/memoryview
489
+ This is the *binary* MAC, as received from the sender.
490
+ :Raises ValueError:
491
+ if the MAC does not match. The message has been tampered with
492
+ or the key is incorrect.
493
+ """
494
+
495
+ if self.verify not in self._next:
496
+ raise TypeError("verify() cannot be called"
497
+ " when encrypting a message")
498
+ self._next = [self.verify]
499
+
500
+ secret = get_random_bytes(16)
501
+
502
+ mac1 = BLAKE2s.new(digest_bits=160, key=secret,
503
+ data=self._compute_mac())
504
+ mac2 = BLAKE2s.new(digest_bits=160, key=secret,
505
+ data=received_mac_tag)
506
+
507
+ if mac1.digest() != mac2.digest():
508
+ raise ValueError("MAC check failed")
509
+
510
+ def hexverify(self, hex_mac_tag):
511
+ """Validate the *printable* MAC tag.
512
+
513
+ This method is like `verify`.
514
+
515
+ :Parameters:
516
+ hex_mac_tag : string
517
+ This is the *printable* MAC, as received from the sender.
518
+ :Raises ValueError:
519
+ if the MAC does not match. The message has been tampered with
520
+ or the key is incorrect.
521
+ """
522
+
523
+ self.verify(unhexlify(hex_mac_tag))
524
+
525
+ def encrypt_and_digest(self, plaintext, output=None):
526
+ """Perform encrypt() and digest() in one step.
527
+
528
+ :Parameters:
529
+ plaintext : bytes/bytearray/memoryview
530
+ The piece of data to encrypt.
531
+ :Keywords:
532
+ output : bytearray/memoryview
533
+ The location where the ciphertext must be written to.
534
+ If ``None``, the ciphertext is returned.
535
+ :Return:
536
+ a tuple with two items:
537
+
538
+ - the ciphertext, as ``bytes``
539
+ - the MAC tag, as ``bytes``
540
+
541
+ The first item becomes ``None`` when the ``output`` parameter
542
+ specified a location for the result.
543
+ """
544
+
545
+ return self.encrypt(plaintext, output=output), self.digest()
546
+
547
+ def decrypt_and_verify(self, ciphertext, received_mac_tag, output=None):
548
+ """Perform decrypt() and verify() in one step.
549
+
550
+ :Parameters:
551
+ ciphertext : bytes/bytearray/memoryview
552
+ The piece of data to decrypt.
553
+ received_mac_tag : byte string
554
+ This is the *binary* MAC, as received from the sender.
555
+ :Keywords:
556
+ output : bytearray/memoryview
557
+ The location where the plaintext must be written to.
558
+ If ``None``, the plaintext is returned.
559
+ :Return: the plaintext as ``bytes`` or ``None`` when the ``output``
560
+ parameter specified a location for the result.
561
+ :Raises ValueError:
562
+ if the MAC does not match. The message has been tampered with
563
+ or the key is incorrect.
564
+ """
565
+
566
+ plaintext = self.decrypt(ciphertext, output=output)
567
+ self.verify(received_mac_tag)
568
+ return plaintext
569
+
570
+
571
+ def _create_gcm_cipher(factory, **kwargs):
572
+ """Create a new block cipher, configured in Galois Counter Mode (GCM).
573
+
574
+ :Parameters:
575
+ factory : module
576
+ A block cipher module, taken from `Crypto.Cipher`.
577
+ The cipher must have block length of 16 bytes.
578
+ GCM has been only defined for `Crypto.Cipher.AES`.
579
+
580
+ :Keywords:
581
+ key : bytes/bytearray/memoryview
582
+ The secret key to use in the symmetric cipher.
583
+ It must be 16 (e.g. *AES-128*), 24 (e.g. *AES-192*)
584
+ or 32 (e.g. *AES-256*) bytes long.
585
+
586
+ nonce : bytes/bytearray/memoryview
587
+ A value that must never be reused for any other encryption.
588
+
589
+ There are no restrictions on its length,
590
+ but it is recommended to use at least 16 bytes.
591
+
592
+ The nonce shall never repeat for two
593
+ different messages encrypted with the same key,
594
+ but it does not need to be random.
595
+
596
+ If not provided, a 16 byte nonce will be randomly created.
597
+
598
+ mac_len : integer
599
+ Length of the MAC, in bytes.
600
+ It must be no larger than 16 bytes (which is the default).
601
+ """
602
+
603
+ try:
604
+ key = kwargs.pop("key")
605
+ except KeyError as e:
606
+ raise TypeError("Missing parameter:" + str(e))
607
+
608
+ nonce = kwargs.pop("nonce", None)
609
+ if nonce is None:
610
+ nonce = get_random_bytes(16)
611
+ mac_len = kwargs.pop("mac_len", 16)
612
+
613
+ # Not documented - only used for testing
614
+ use_clmul = kwargs.pop("use_clmul", True)
615
+ if use_clmul and _ghash_clmul:
616
+ ghash_c = _ghash_clmul
617
+ else:
618
+ ghash_c = _ghash_portable
619
+
620
+ return GcmMode(factory, key, nonce, mac_len, kwargs, ghash_c)
runtime/Lib/site-packages/Crypto/Cipher/_mode_gcm.pyi ADDED
@@ -0,0 +1,45 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from types import ModuleType
2
+ from typing import Union, Tuple, Dict, overload, Optional
3
+
4
+ __all__ = ['GcmMode']
5
+
6
+ Buffer = Union[bytes, bytearray, memoryview]
7
+
8
+ class GcmMode(object):
9
+ block_size: int
10
+ nonce: Buffer
11
+
12
+ def __init__(self,
13
+ factory: ModuleType,
14
+ key: Buffer,
15
+ nonce: Buffer,
16
+ mac_len: int,
17
+ cipher_params: Dict) -> None: ...
18
+
19
+ def update(self, assoc_data: Buffer) -> GcmMode: ...
20
+
21
+ @overload
22
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
23
+ @overload
24
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
25
+ @overload
26
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
27
+ @overload
28
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
29
+
30
+ def digest(self) -> bytes: ...
31
+ def hexdigest(self) -> str: ...
32
+ def verify(self, received_mac_tag: Buffer) -> None: ...
33
+ def hexverify(self, hex_mac_tag: str) -> None: ...
34
+
35
+ @overload
36
+ def encrypt_and_digest(self,
37
+ plaintext: Buffer) -> Tuple[bytes, bytes]: ...
38
+ @overload
39
+ def encrypt_and_digest(self,
40
+ plaintext: Buffer,
41
+ output: Buffer) -> Tuple[None, bytes]: ...
42
+ def decrypt_and_verify(self,
43
+ ciphertext: Buffer,
44
+ received_mac_tag: Buffer,
45
+ output: Optional[Union[bytearray, memoryview]] = ...) -> bytes: ...
runtime/Lib/site-packages/Crypto/Cipher/_mode_ocb.py ADDED
@@ -0,0 +1,525 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # ===================================================================
2
+ #
3
+ # Copyright (c) 2014, Legrandin <helderijs@gmail.com>
4
+ # All rights reserved.
5
+ #
6
+ # Redistribution and use in source and binary forms, with or without
7
+ # modification, are permitted provided that the following conditions
8
+ # are met:
9
+ #
10
+ # 1. Redistributions of source code must retain the above copyright
11
+ # notice, this list of conditions and the following disclaimer.
12
+ # 2. Redistributions in binary form must reproduce the above copyright
13
+ # notice, this list of conditions and the following disclaimer in
14
+ # the documentation and/or other materials provided with the
15
+ # distribution.
16
+ #
17
+ # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18
+ # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19
+ # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20
+ # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21
+ # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22
+ # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23
+ # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24
+ # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25
+ # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
+ # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
27
+ # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28
+ # POSSIBILITY OF SUCH DAMAGE.
29
+ # ===================================================================
30
+
31
+ """
32
+ Offset Codebook (OCB) mode.
33
+
34
+ OCB is Authenticated Encryption with Associated Data (AEAD) cipher mode
35
+ designed by Prof. Phillip Rogaway and specified in `RFC7253`_.
36
+
37
+ The algorithm provides both authenticity and privacy, it is very efficient,
38
+ it uses only one key and it can be used in online mode (so that encryption
39
+ or decryption can start before the end of the message is available).
40
+
41
+ This module implements the third and last variant of OCB (OCB3) and it only
42
+ works in combination with a 128-bit block symmetric cipher, like AES.
43
+
44
+ OCB is patented in US but `free licenses`_ exist for software implementations
45
+ meant for non-military purposes.
46
+
47
+ Example:
48
+ >>> from Crypto.Cipher import AES
49
+ >>> from Crypto.Random import get_random_bytes
50
+ >>>
51
+ >>> key = get_random_bytes(32)
52
+ >>> cipher = AES.new(key, AES.MODE_OCB)
53
+ >>> plaintext = b"Attack at dawn"
54
+ >>> ciphertext, mac = cipher.encrypt_and_digest(plaintext)
55
+ >>> # Deliver cipher.nonce, ciphertext and mac
56
+ ...
57
+ >>> cipher = AES.new(key, AES.MODE_OCB, nonce=nonce)
58
+ >>> try:
59
+ >>> plaintext = cipher.decrypt_and_verify(ciphertext, mac)
60
+ >>> except ValueError:
61
+ >>> print "Invalid message"
62
+ >>> else:
63
+ >>> print plaintext
64
+
65
+ :undocumented: __package__
66
+
67
+ .. _RFC7253: http://www.rfc-editor.org/info/rfc7253
68
+ .. _free licenses: http://web.cs.ucdavis.edu/~rogaway/ocb/license.htm
69
+ """
70
+
71
+ import struct
72
+ from binascii import unhexlify
73
+
74
+ from Crypto.Util.py3compat import bord, _copy_bytes
75
+ from Crypto.Util.number import long_to_bytes, bytes_to_long
76
+ from Crypto.Util.strxor import strxor
77
+
78
+ from Crypto.Hash import BLAKE2s
79
+ from Crypto.Random import get_random_bytes
80
+
81
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
82
+ create_string_buffer, get_raw_buffer,
83
+ SmartPointer, c_size_t, c_uint8_ptr,
84
+ is_buffer)
85
+
86
+ _raw_ocb_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_ocb", """
87
+ int OCB_start_operation(void *cipher,
88
+ const uint8_t *offset_0,
89
+ size_t offset_0_len,
90
+ void **pState);
91
+ int OCB_encrypt(void *state,
92
+ const uint8_t *in,
93
+ uint8_t *out,
94
+ size_t data_len);
95
+ int OCB_decrypt(void *state,
96
+ const uint8_t *in,
97
+ uint8_t *out,
98
+ size_t data_len);
99
+ int OCB_update(void *state,
100
+ const uint8_t *in,
101
+ size_t data_len);
102
+ int OCB_digest(void *state,
103
+ uint8_t *tag,
104
+ size_t tag_len);
105
+ int OCB_stop_operation(void *state);
106
+ """)
107
+
108
+
109
+ class OcbMode(object):
110
+ """Offset Codebook (OCB) mode.
111
+
112
+ :undocumented: __init__
113
+ """
114
+
115
+ def __init__(self, factory, nonce, mac_len, cipher_params):
116
+
117
+ if factory.block_size != 16:
118
+ raise ValueError("OCB mode is only available for ciphers"
119
+ " that operate on 128 bits blocks")
120
+
121
+ self.block_size = 16
122
+ """The block size of the underlying cipher, in bytes."""
123
+
124
+ self.nonce = _copy_bytes(None, None, nonce)
125
+ """Nonce used for this session."""
126
+ if len(nonce) not in range(1, 16):
127
+ raise ValueError("Nonce must be at most 15 bytes long")
128
+ if not is_buffer(nonce):
129
+ raise TypeError("Nonce must be bytes, bytearray or memoryview")
130
+
131
+ self._mac_len = mac_len
132
+ if not 8 <= mac_len <= 16:
133
+ raise ValueError("MAC tag must be between 8 and 16 bytes long")
134
+
135
+ # Cache for MAC tag
136
+ self._mac_tag = None
137
+
138
+ # Cache for unaligned associated data
139
+ self._cache_A = b""
140
+
141
+ # Cache for unaligned ciphertext/plaintext
142
+ self._cache_P = b""
143
+
144
+ # Allowed transitions after initialization
145
+ self._next = [self.update, self.encrypt, self.decrypt,
146
+ self.digest, self.verify]
147
+
148
+ # Compute Offset_0
149
+ params_without_key = dict(cipher_params)
150
+ key = params_without_key.pop("key")
151
+ nonce = (struct.pack('B', self._mac_len << 4 & 0xFF) +
152
+ b'\x00' * (14 - len(nonce)) +
153
+ b'\x01' + self.nonce)
154
+
155
+ bottom_bits = bord(nonce[15]) & 0x3F # 6 bits, 0..63
156
+ top_bits = bord(nonce[15]) & 0xC0 # 2 bits
157
+
158
+ ktop_cipher = factory.new(key,
159
+ factory.MODE_ECB,
160
+ **params_without_key)
161
+ ktop = ktop_cipher.encrypt(struct.pack('15sB',
162
+ nonce[:15],
163
+ top_bits))
164
+
165
+ stretch = ktop + strxor(ktop[:8], ktop[1:9]) # 192 bits
166
+ offset_0 = long_to_bytes(bytes_to_long(stretch) >>
167
+ (64 - bottom_bits), 24)[8:]
168
+
169
+ # Create low-level cipher instance
170
+ raw_cipher = factory._create_base_cipher(cipher_params)
171
+ if cipher_params:
172
+ raise TypeError("Unknown keywords: " + str(cipher_params))
173
+
174
+ self._state = VoidPointer()
175
+ result = _raw_ocb_lib.OCB_start_operation(raw_cipher.get(),
176
+ offset_0,
177
+ c_size_t(len(offset_0)),
178
+ self._state.address_of())
179
+ if result:
180
+ raise ValueError("Error %d while instantiating the OCB mode"
181
+ % result)
182
+
183
+ # Ensure that object disposal of this Python object will (eventually)
184
+ # free the memory allocated by the raw library for the cipher mode
185
+ self._state = SmartPointer(self._state.get(),
186
+ _raw_ocb_lib.OCB_stop_operation)
187
+
188
+ # Memory allocated for the underlying block cipher is now owed
189
+ # by the cipher mode
190
+ raw_cipher.release()
191
+
192
+ def _update(self, assoc_data, assoc_data_len):
193
+ result = _raw_ocb_lib.OCB_update(self._state.get(),
194
+ c_uint8_ptr(assoc_data),
195
+ c_size_t(assoc_data_len))
196
+ if result:
197
+ raise ValueError("Error %d while computing MAC in OCB mode" % result)
198
+
199
+ def update(self, assoc_data):
200
+ """Process the associated data.
201
+
202
+ If there is any associated data, the caller has to invoke
203
+ this method one or more times, before using
204
+ ``decrypt`` or ``encrypt``.
205
+
206
+ By *associated data* it is meant any data (e.g. packet headers) that
207
+ will not be encrypted and will be transmitted in the clear.
208
+ However, the receiver shall still able to detect modifications.
209
+
210
+ If there is no associated data, this method must not be called.
211
+
212
+ The caller may split associated data in segments of any size, and
213
+ invoke this method multiple times, each time with the next segment.
214
+
215
+ :Parameters:
216
+ assoc_data : bytes/bytearray/memoryview
217
+ A piece of associated data.
218
+ """
219
+
220
+ if self.update not in self._next:
221
+ raise TypeError("update() can only be called"
222
+ " immediately after initialization")
223
+
224
+ self._next = [self.encrypt, self.decrypt, self.digest,
225
+ self.verify, self.update]
226
+
227
+ if len(self._cache_A) > 0:
228
+ filler = min(16 - len(self._cache_A), len(assoc_data))
229
+ self._cache_A += _copy_bytes(None, filler, assoc_data)
230
+ assoc_data = assoc_data[filler:]
231
+
232
+ if len(self._cache_A) < 16:
233
+ return self
234
+
235
+ # Clear the cache, and proceeding with any other aligned data
236
+ self._cache_A, seg = b"", self._cache_A
237
+ self.update(seg)
238
+
239
+ update_len = len(assoc_data) // 16 * 16
240
+ self._cache_A = _copy_bytes(update_len, None, assoc_data)
241
+ self._update(assoc_data, update_len)
242
+ return self
243
+
244
+ def _transcrypt_aligned(self, in_data, in_data_len,
245
+ trans_func, trans_desc):
246
+
247
+ out_data = create_string_buffer(in_data_len)
248
+ result = trans_func(self._state.get(),
249
+ in_data,
250
+ out_data,
251
+ c_size_t(in_data_len))
252
+ if result:
253
+ raise ValueError("Error %d while %sing in OCB mode"
254
+ % (result, trans_desc))
255
+ return get_raw_buffer(out_data)
256
+
257
+ def _transcrypt(self, in_data, trans_func, trans_desc):
258
+ # Last piece to encrypt/decrypt
259
+ if in_data is None:
260
+ out_data = self._transcrypt_aligned(self._cache_P,
261
+ len(self._cache_P),
262
+ trans_func,
263
+ trans_desc)
264
+ self._cache_P = b""
265
+ return out_data
266
+
267
+ # Try to fill up the cache, if it already contains something
268
+ prefix = b""
269
+ if len(self._cache_P) > 0:
270
+ filler = min(16 - len(self._cache_P), len(in_data))
271
+ self._cache_P += _copy_bytes(None, filler, in_data)
272
+ in_data = in_data[filler:]
273
+
274
+ if len(self._cache_P) < 16:
275
+ # We could not manage to fill the cache, so there is certainly
276
+ # no output yet.
277
+ return b""
278
+
279
+ # Clear the cache, and proceeding with any other aligned data
280
+ prefix = self._transcrypt_aligned(self._cache_P,
281
+ len(self._cache_P),
282
+ trans_func,
283
+ trans_desc)
284
+ self._cache_P = b""
285
+
286
+ # Process data in multiples of the block size
287
+ trans_len = len(in_data) // 16 * 16
288
+ result = self._transcrypt_aligned(c_uint8_ptr(in_data),
289
+ trans_len,
290
+ trans_func,
291
+ trans_desc)
292
+ if prefix:
293
+ result = prefix + result
294
+
295
+ # Left-over
296
+ self._cache_P = _copy_bytes(trans_len, None, in_data)
297
+
298
+ return result
299
+
300
+ def encrypt(self, plaintext=None):
301
+ """Encrypt the next piece of plaintext.
302
+
303
+ After the entire plaintext has been passed (but before `digest`),
304
+ you **must** call this method one last time with no arguments to collect
305
+ the final piece of ciphertext.
306
+
307
+ If possible, use the method `encrypt_and_digest` instead.
308
+
309
+ :Parameters:
310
+ plaintext : bytes/bytearray/memoryview
311
+ The next piece of data to encrypt or ``None`` to signify
312
+ that encryption has finished and that any remaining ciphertext
313
+ has to be produced.
314
+ :Return:
315
+ the ciphertext, as a byte string.
316
+ Its length may not match the length of the *plaintext*.
317
+ """
318
+
319
+ if self.encrypt not in self._next:
320
+ raise TypeError("encrypt() can only be called after"
321
+ " initialization or an update()")
322
+
323
+ if plaintext is None:
324
+ self._next = [self.digest]
325
+ else:
326
+ self._next = [self.encrypt]
327
+ return self._transcrypt(plaintext, _raw_ocb_lib.OCB_encrypt, "encrypt")
328
+
329
+ def decrypt(self, ciphertext=None):
330
+ """Decrypt the next piece of ciphertext.
331
+
332
+ After the entire ciphertext has been passed (but before `verify`),
333
+ you **must** call this method one last time with no arguments to collect
334
+ the remaining piece of plaintext.
335
+
336
+ If possible, use the method `decrypt_and_verify` instead.
337
+
338
+ :Parameters:
339
+ ciphertext : bytes/bytearray/memoryview
340
+ The next piece of data to decrypt or ``None`` to signify
341
+ that decryption has finished and that any remaining plaintext
342
+ has to be produced.
343
+ :Return:
344
+ the plaintext, as a byte string.
345
+ Its length may not match the length of the *ciphertext*.
346
+ """
347
+
348
+ if self.decrypt not in self._next:
349
+ raise TypeError("decrypt() can only be called after"
350
+ " initialization or an update()")
351
+
352
+ if ciphertext is None:
353
+ self._next = [self.verify]
354
+ else:
355
+ self._next = [self.decrypt]
356
+ return self._transcrypt(ciphertext,
357
+ _raw_ocb_lib.OCB_decrypt,
358
+ "decrypt")
359
+
360
+ def _compute_mac_tag(self):
361
+
362
+ if self._mac_tag is not None:
363
+ return
364
+
365
+ if self._cache_A:
366
+ self._update(self._cache_A, len(self._cache_A))
367
+ self._cache_A = b""
368
+
369
+ mac_tag = create_string_buffer(16)
370
+ result = _raw_ocb_lib.OCB_digest(self._state.get(),
371
+ mac_tag,
372
+ c_size_t(len(mac_tag))
373
+ )
374
+ if result:
375
+ raise ValueError("Error %d while computing digest in OCB mode"
376
+ % result)
377
+ self._mac_tag = get_raw_buffer(mac_tag)[:self._mac_len]
378
+
379
+ def digest(self):
380
+ """Compute the *binary* MAC tag.
381
+
382
+ Call this method after the final `encrypt` (the one with no arguments)
383
+ to obtain the MAC tag.
384
+
385
+ The MAC tag is needed by the receiver to determine authenticity
386
+ of the message.
387
+
388
+ :Return: the MAC, as a byte string.
389
+ """
390
+
391
+ if self.digest not in self._next:
392
+ raise TypeError("digest() cannot be called now for this cipher")
393
+
394
+ assert(len(self._cache_P) == 0)
395
+
396
+ self._next = [self.digest]
397
+
398
+ if self._mac_tag is None:
399
+ self._compute_mac_tag()
400
+
401
+ return self._mac_tag
402
+
403
+ def hexdigest(self):
404
+ """Compute the *printable* MAC tag.
405
+
406
+ This method is like `digest`.
407
+
408
+ :Return: the MAC, as a hexadecimal string.
409
+ """
410
+ return "".join(["%02x" % bord(x) for x in self.digest()])
411
+
412
+ def verify(self, received_mac_tag):
413
+ """Validate the *binary* MAC tag.
414
+
415
+ Call this method after the final `decrypt` (the one with no arguments)
416
+ to check if the message is authentic and valid.
417
+
418
+ :Parameters:
419
+ received_mac_tag : bytes/bytearray/memoryview
420
+ This is the *binary* MAC, as received from the sender.
421
+ :Raises ValueError:
422
+ if the MAC does not match. The message has been tampered with
423
+ or the key is incorrect.
424
+ """
425
+
426
+ if self.verify not in self._next:
427
+ raise TypeError("verify() cannot be called now for this cipher")
428
+
429
+ assert(len(self._cache_P) == 0)
430
+
431
+ self._next = [self.verify]
432
+
433
+ if self._mac_tag is None:
434
+ self._compute_mac_tag()
435
+
436
+ secret = get_random_bytes(16)
437
+ mac1 = BLAKE2s.new(digest_bits=160, key=secret, data=self._mac_tag)
438
+ mac2 = BLAKE2s.new(digest_bits=160, key=secret, data=received_mac_tag)
439
+
440
+ if mac1.digest() != mac2.digest():
441
+ raise ValueError("MAC check failed")
442
+
443
+ def hexverify(self, hex_mac_tag):
444
+ """Validate the *printable* MAC tag.
445
+
446
+ This method is like `verify`.
447
+
448
+ :Parameters:
449
+ hex_mac_tag : string
450
+ This is the *printable* MAC, as received from the sender.
451
+ :Raises ValueError:
452
+ if the MAC does not match. The message has been tampered with
453
+ or the key is incorrect.
454
+ """
455
+
456
+ self.verify(unhexlify(hex_mac_tag))
457
+
458
+ def encrypt_and_digest(self, plaintext):
459
+ """Encrypt the message and create the MAC tag in one step.
460
+
461
+ :Parameters:
462
+ plaintext : bytes/bytearray/memoryview
463
+ The entire message to encrypt.
464
+ :Return:
465
+ a tuple with two byte strings:
466
+
467
+ - the encrypted data
468
+ - the MAC
469
+ """
470
+
471
+ return self.encrypt(plaintext) + self.encrypt(), self.digest()
472
+
473
+ def decrypt_and_verify(self, ciphertext, received_mac_tag):
474
+ """Decrypted the message and verify its authenticity in one step.
475
+
476
+ :Parameters:
477
+ ciphertext : bytes/bytearray/memoryview
478
+ The entire message to decrypt.
479
+ received_mac_tag : byte string
480
+ This is the *binary* MAC, as received from the sender.
481
+
482
+ :Return: the decrypted data (byte string).
483
+ :Raises ValueError:
484
+ if the MAC does not match. The message has been tampered with
485
+ or the key is incorrect.
486
+ """
487
+
488
+ plaintext = self.decrypt(ciphertext) + self.decrypt()
489
+ self.verify(received_mac_tag)
490
+ return plaintext
491
+
492
+
493
+ def _create_ocb_cipher(factory, **kwargs):
494
+ """Create a new block cipher, configured in OCB mode.
495
+
496
+ :Parameters:
497
+ factory : module
498
+ A symmetric cipher module from `Crypto.Cipher`
499
+ (like `Crypto.Cipher.AES`).
500
+
501
+ :Keywords:
502
+ nonce : bytes/bytearray/memoryview
503
+ A value that must never be reused for any other encryption.
504
+ Its length can vary from 1 to 15 bytes.
505
+ If not specified, a random 15 bytes long nonce is generated.
506
+
507
+ mac_len : integer
508
+ Length of the MAC, in bytes.
509
+ It must be in the range ``[8..16]``.
510
+ The default is 16 (128 bits).
511
+
512
+ Any other keyword will be passed to the underlying block cipher.
513
+ See the relevant documentation for details (at least ``key`` will need
514
+ to be present).
515
+ """
516
+
517
+ try:
518
+ nonce = kwargs.pop("nonce", None)
519
+ if nonce is None:
520
+ nonce = get_random_bytes(15)
521
+ mac_len = kwargs.pop("mac_len", 16)
522
+ except KeyError as e:
523
+ raise TypeError("Keyword missing: " + str(e))
524
+
525
+ return OcbMode(factory, nonce, mac_len, kwargs)
runtime/Lib/site-packages/Crypto/Cipher/_mode_ocb.pyi ADDED
@@ -0,0 +1,36 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from types import ModuleType
2
+ from typing import Union, Any, Optional, Tuple, Dict, overload
3
+
4
+ Buffer = Union[bytes, bytearray, memoryview]
5
+
6
+ class OcbMode(object):
7
+ block_size: int
8
+ nonce: Buffer
9
+
10
+ def __init__(self,
11
+ factory: ModuleType,
12
+ nonce: Buffer,
13
+ mac_len: int,
14
+ cipher_params: Dict) -> None: ...
15
+
16
+ def update(self, assoc_data: Buffer) -> OcbMode: ...
17
+
18
+ @overload
19
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
20
+ @overload
21
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
22
+ @overload
23
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
24
+ @overload
25
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
26
+
27
+ def digest(self) -> bytes: ...
28
+ def hexdigest(self) -> str: ...
29
+ def verify(self, received_mac_tag: Buffer) -> None: ...
30
+ def hexverify(self, hex_mac_tag: str) -> None: ...
31
+
32
+ def encrypt_and_digest(self,
33
+ plaintext: Buffer) -> Tuple[bytes, bytes]: ...
34
+ def decrypt_and_verify(self,
35
+ ciphertext: Buffer,
36
+ received_mac_tag: Buffer) -> bytes: ...
runtime/Lib/site-packages/Crypto/Cipher/_mode_ofb.py ADDED
@@ -0,0 +1,282 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ #
3
+ # Cipher/mode_ofb.py : OFB mode
4
+ #
5
+ # ===================================================================
6
+ # The contents of this file are dedicated to the public domain. To
7
+ # the extent that dedication to the public domain is not available,
8
+ # everyone is granted a worldwide, perpetual, royalty-free,
9
+ # non-exclusive license to exercise all rights associated with the
10
+ # contents of this file for any purpose whatsoever.
11
+ # No rights are reserved.
12
+ #
13
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15
+ # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17
+ # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18
+ # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19
+ # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ # SOFTWARE.
21
+ # ===================================================================
22
+
23
+ """
24
+ Output Feedback (CFB) mode.
25
+ """
26
+
27
+ __all__ = ['OfbMode']
28
+
29
+ from Crypto.Util.py3compat import _copy_bytes
30
+ from Crypto.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
31
+ create_string_buffer, get_raw_buffer,
32
+ SmartPointer, c_size_t, c_uint8_ptr,
33
+ is_writeable_buffer)
34
+
35
+ from Crypto.Random import get_random_bytes
36
+
37
+ raw_ofb_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_ofb", """
38
+ int OFB_start_operation(void *cipher,
39
+ const uint8_t iv[],
40
+ size_t iv_len,
41
+ void **pResult);
42
+ int OFB_encrypt(void *ofbState,
43
+ const uint8_t *in,
44
+ uint8_t *out,
45
+ size_t data_len);
46
+ int OFB_decrypt(void *ofbState,
47
+ const uint8_t *in,
48
+ uint8_t *out,
49
+ size_t data_len);
50
+ int OFB_stop_operation(void *state);
51
+ """
52
+ )
53
+
54
+
55
+ class OfbMode(object):
56
+ """*Output FeedBack (OFB)*.
57
+
58
+ This mode is very similar to CBC, but it
59
+ transforms the underlying block cipher into a stream cipher.
60
+
61
+ The keystream is the iterated block encryption of the
62
+ previous ciphertext block.
63
+
64
+ An Initialization Vector (*IV*) is required.
65
+
66
+ See `NIST SP800-38A`_ , Section 6.4.
67
+
68
+ .. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
69
+
70
+ :undocumented: __init__
71
+ """
72
+
73
+ def __init__(self, block_cipher, iv):
74
+ """Create a new block cipher, configured in OFB mode.
75
+
76
+ :Parameters:
77
+ block_cipher : C pointer
78
+ A smart pointer to the low-level block cipher instance.
79
+
80
+ iv : bytes/bytearray/memoryview
81
+ The initialization vector to use for encryption or decryption.
82
+ It is as long as the cipher block.
83
+
84
+ **The IV must be a nonce, to to be reused for any other
85
+ message**. It shall be a nonce or a random value.
86
+
87
+ Reusing the *IV* for encryptions performed with the same key
88
+ compromises confidentiality.
89
+ """
90
+
91
+ self._state = VoidPointer()
92
+ result = raw_ofb_lib.OFB_start_operation(block_cipher.get(),
93
+ c_uint8_ptr(iv),
94
+ c_size_t(len(iv)),
95
+ self._state.address_of())
96
+ if result:
97
+ raise ValueError("Error %d while instantiating the OFB mode"
98
+ % result)
99
+
100
+ # Ensure that object disposal of this Python object will (eventually)
101
+ # free the memory allocated by the raw library for the cipher mode
102
+ self._state = SmartPointer(self._state.get(),
103
+ raw_ofb_lib.OFB_stop_operation)
104
+
105
+ # Memory allocated for the underlying block cipher is now owed
106
+ # by the cipher mode
107
+ block_cipher.release()
108
+
109
+ self.block_size = len(iv)
110
+ """The block size of the underlying cipher, in bytes."""
111
+
112
+ self.iv = _copy_bytes(None, None, iv)
113
+ """The Initialization Vector originally used to create the object.
114
+ The value does not change."""
115
+
116
+ self.IV = self.iv
117
+ """Alias for `iv`"""
118
+
119
+ self._next = [ self.encrypt, self.decrypt ]
120
+
121
+ def encrypt(self, plaintext, output=None):
122
+ """Encrypt data with the key and the parameters set at initialization.
123
+
124
+ A cipher object is stateful: once you have encrypted a message
125
+ you cannot encrypt (or decrypt) another message using the same
126
+ object.
127
+
128
+ The data to encrypt can be broken up in two or
129
+ more pieces and `encrypt` can be called multiple times.
130
+
131
+ That is, the statement:
132
+
133
+ >>> c.encrypt(a) + c.encrypt(b)
134
+
135
+ is equivalent to:
136
+
137
+ >>> c.encrypt(a+b)
138
+
139
+ This function does not add any padding to the plaintext.
140
+
141
+ :Parameters:
142
+ plaintext : bytes/bytearray/memoryview
143
+ The piece of data to encrypt.
144
+ It can be of any length.
145
+ :Keywords:
146
+ output : bytearray/memoryview
147
+ The location where the ciphertext must be written to.
148
+ If ``None``, the ciphertext is returned.
149
+ :Return:
150
+ If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
151
+ Otherwise, ``None``.
152
+ """
153
+
154
+ if self.encrypt not in self._next:
155
+ raise TypeError("encrypt() cannot be called after decrypt()")
156
+ self._next = [ self.encrypt ]
157
+
158
+ if output is None:
159
+ ciphertext = create_string_buffer(len(plaintext))
160
+ else:
161
+ ciphertext = output
162
+
163
+ if not is_writeable_buffer(output):
164
+ raise TypeError("output must be a bytearray or a writeable memoryview")
165
+
166
+ if len(plaintext) != len(output):
167
+ raise ValueError("output must have the same length as the input"
168
+ " (%d bytes)" % len(plaintext))
169
+
170
+ result = raw_ofb_lib.OFB_encrypt(self._state.get(),
171
+ c_uint8_ptr(plaintext),
172
+ c_uint8_ptr(ciphertext),
173
+ c_size_t(len(plaintext)))
174
+ if result:
175
+ raise ValueError("Error %d while encrypting in OFB mode" % result)
176
+
177
+ if output is None:
178
+ return get_raw_buffer(ciphertext)
179
+ else:
180
+ return None
181
+
182
+ def decrypt(self, ciphertext, output=None):
183
+ """Decrypt data with the key and the parameters set at initialization.
184
+
185
+ A cipher object is stateful: once you have decrypted a message
186
+ you cannot decrypt (or encrypt) another message with the same
187
+ object.
188
+
189
+ The data to decrypt can be broken up in two or
190
+ more pieces and `decrypt` can be called multiple times.
191
+
192
+ That is, the statement:
193
+
194
+ >>> c.decrypt(a) + c.decrypt(b)
195
+
196
+ is equivalent to:
197
+
198
+ >>> c.decrypt(a+b)
199
+
200
+ This function does not remove any padding from the plaintext.
201
+
202
+ :Parameters:
203
+ ciphertext : bytes/bytearray/memoryview
204
+ The piece of data to decrypt.
205
+ It can be of any length.
206
+ :Keywords:
207
+ output : bytearray/memoryview
208
+ The location where the plaintext is written to.
209
+ If ``None``, the plaintext is returned.
210
+ :Return:
211
+ If ``output`` is ``None``, the plaintext is returned as ``bytes``.
212
+ Otherwise, ``None``.
213
+ """
214
+
215
+ if self.decrypt not in self._next:
216
+ raise TypeError("decrypt() cannot be called after encrypt()")
217
+ self._next = [ self.decrypt ]
218
+
219
+ if output is None:
220
+ plaintext = create_string_buffer(len(ciphertext))
221
+ else:
222
+ plaintext = output
223
+
224
+ if not is_writeable_buffer(output):
225
+ raise TypeError("output must be a bytearray or a writeable memoryview")
226
+
227
+ if len(ciphertext) != len(output):
228
+ raise ValueError("output must have the same length as the input"
229
+ " (%d bytes)" % len(plaintext))
230
+
231
+ result = raw_ofb_lib.OFB_decrypt(self._state.get(),
232
+ c_uint8_ptr(ciphertext),
233
+ c_uint8_ptr(plaintext),
234
+ c_size_t(len(ciphertext)))
235
+ if result:
236
+ raise ValueError("Error %d while decrypting in OFB mode" % result)
237
+
238
+ if output is None:
239
+ return get_raw_buffer(plaintext)
240
+ else:
241
+ return None
242
+
243
+
244
+ def _create_ofb_cipher(factory, **kwargs):
245
+ """Instantiate a cipher object that performs OFB encryption/decryption.
246
+
247
+ :Parameters:
248
+ factory : module
249
+ The underlying block cipher, a module from ``Crypto.Cipher``.
250
+
251
+ :Keywords:
252
+ iv : bytes/bytearray/memoryview
253
+ The IV to use for OFB.
254
+
255
+ IV : bytes/bytearray/memoryview
256
+ Alias for ``iv``.
257
+
258
+ Any other keyword will be passed to the underlying block cipher.
259
+ See the relevant documentation for details (at least ``key`` will need
260
+ to be present).
261
+ """
262
+
263
+ cipher_state = factory._create_base_cipher(kwargs)
264
+ iv = kwargs.pop("IV", None)
265
+ IV = kwargs.pop("iv", None)
266
+
267
+ if (None, None) == (iv, IV):
268
+ iv = get_random_bytes(factory.block_size)
269
+ if iv is not None:
270
+ if IV is not None:
271
+ raise TypeError("You must either use 'iv' or 'IV', not both")
272
+ else:
273
+ iv = IV
274
+
275
+ if len(iv) != factory.block_size:
276
+ raise ValueError("Incorrect IV length (it must be %d bytes long)" %
277
+ factory.block_size)
278
+
279
+ if kwargs:
280
+ raise TypeError("Unknown parameters for OFB: %s" % str(kwargs))
281
+
282
+ return OfbMode(cipher_state, iv)
runtime/Lib/site-packages/Crypto/Cipher/_mode_ofb.pyi ADDED
@@ -0,0 +1,25 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from typing import Union, overload
2
+
3
+ from Crypto.Util._raw_api import SmartPointer
4
+
5
+ Buffer = Union[bytes, bytearray, memoryview]
6
+
7
+ __all__ = ['OfbMode']
8
+
9
+ class OfbMode(object):
10
+ block_size: int
11
+ iv: Buffer
12
+ IV: Buffer
13
+
14
+ def __init__(self,
15
+ block_cipher: SmartPointer,
16
+ iv: Buffer) -> None: ...
17
+ @overload
18
+ def encrypt(self, plaintext: Buffer) -> bytes: ...
19
+ @overload
20
+ def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
21
+ @overload
22
+ def decrypt(self, plaintext: Buffer) -> bytes: ...
23
+ @overload
24
+ def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
25
+
runtime/Lib/site-packages/Crypto/Cipher/_mode_openpgp.py ADDED
@@ -0,0 +1,206 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # ===================================================================
2
+ #
3
+ # Copyright (c) 2014, Legrandin <helderijs@gmail.com>
4
+ # All rights reserved.
5
+ #
6
+ # Redistribution and use in source and binary forms, with or without
7
+ # modification, are permitted provided that the following conditions
8
+ # are met:
9
+ #
10
+ # 1. Redistributions of source code must retain the above copyright
11
+ # notice, this list of conditions and the following disclaimer.
12
+ # 2. Redistributions in binary form must reproduce the above copyright
13
+ # notice, this list of conditions and the following disclaimer in
14
+ # the documentation and/or other materials provided with the
15
+ # distribution.
16
+ #
17
+ # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18
+ # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19
+ # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20
+ # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21
+ # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22
+ # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23
+ # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24
+ # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25
+ # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
+ # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
27
+ # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28
+ # POSSIBILITY OF SUCH DAMAGE.
29
+ # ===================================================================
30
+
31
+ """
32
+ OpenPGP mode.
33
+ """
34
+
35
+ __all__ = ['OpenPgpMode']
36
+
37
+ from Crypto.Util.py3compat import _copy_bytes
38
+ from Crypto.Random import get_random_bytes
39
+
40
+ class OpenPgpMode(object):
41
+ """OpenPGP mode.
42
+
43
+ This mode is a variant of CFB, and it is only used in PGP and
44
+ OpenPGP_ applications. If in doubt, use another mode.
45
+
46
+ An Initialization Vector (*IV*) is required.
47
+
48
+ Unlike CFB, the *encrypted* IV (not the IV itself) is
49
+ transmitted to the receiver.
50
+
51
+ The IV is a random data block. For legacy reasons, two of its bytes are
52
+ duplicated to act as a checksum for the correctness of the key, which is now
53
+ known to be insecure and is ignored. The encrypted IV is therefore 2 bytes
54
+ longer than the clean IV.
55
+
56
+ .. _OpenPGP: http://tools.ietf.org/html/rfc4880
57
+
58
+ :undocumented: __init__
59
+ """
60
+
61
+ def __init__(self, factory, key, iv, cipher_params):
62
+
63
+ #: The block size of the underlying cipher, in bytes.
64
+ self.block_size = factory.block_size
65
+
66
+ self._done_first_block = False # True after the first encryption
67
+
68
+ # Instantiate a temporary cipher to process the IV
69
+ IV_cipher = factory.new(
70
+ key,
71
+ factory.MODE_CFB,
72
+ IV=b'\x00' * self.block_size,
73
+ segment_size=self.block_size * 8,
74
+ **cipher_params)
75
+
76
+ iv = _copy_bytes(None, None, iv)
77
+
78
+ # The cipher will be used for...
79
+ if len(iv) == self.block_size:
80
+ # ... encryption
81
+ self._encrypted_IV = IV_cipher.encrypt(iv + iv[-2:])
82
+ elif len(iv) == self.block_size + 2:
83
+ # ... decryption
84
+ self._encrypted_IV = iv
85
+ # Last two bytes are for a deprecated "quick check" feature that
86
+ # should not be used. (https://eprint.iacr.org/2005/033)
87
+ iv = IV_cipher.decrypt(iv)[:-2]
88
+ else:
89
+ raise ValueError("Length of IV must be %d or %d bytes"
90
+ " for MODE_OPENPGP"
91
+ % (self.block_size, self.block_size + 2))
92
+
93
+ self.iv = self.IV = iv
94
+
95
+ # Instantiate the cipher for the real PGP data
96
+ self._cipher = factory.new(
97
+ key,
98
+ factory.MODE_CFB,
99
+ IV=self._encrypted_IV[-self.block_size:],
100
+ segment_size=self.block_size * 8,
101
+ **cipher_params)
102
+
103
+ def encrypt(self, plaintext):
104
+ """Encrypt data with the key and the parameters set at initialization.
105
+
106
+ A cipher object is stateful: once you have encrypted a message
107
+ you cannot encrypt (or decrypt) another message using the same
108
+ object.
109
+
110
+ The data to encrypt can be broken up in two or
111
+ more pieces and `encrypt` can be called multiple times.
112
+
113
+ That is, the statement:
114
+
115
+ >>> c.encrypt(a) + c.encrypt(b)
116
+
117
+ is equivalent to:
118
+
119
+ >>> c.encrypt(a+b)
120
+
121
+ This function does not add any padding to the plaintext.
122
+
123
+ :Parameters:
124
+ plaintext : bytes/bytearray/memoryview
125
+ The piece of data to encrypt.
126
+
127
+ :Return:
128
+ the encrypted data, as a byte string.
129
+ It is as long as *plaintext* with one exception:
130
+ when encrypting the first message chunk,
131
+ the encypted IV is prepended to the returned ciphertext.
132
+ """
133
+
134
+ res = self._cipher.encrypt(plaintext)
135
+ if not self._done_first_block:
136
+ res = self._encrypted_IV + res
137
+ self._done_first_block = True
138
+ return res
139
+
140
+ def decrypt(self, ciphertext):
141
+ """Decrypt data with the key and the parameters set at initialization.
142
+
143
+ A cipher object is stateful: once you have decrypted a message
144
+ you cannot decrypt (or encrypt) another message with the same
145
+ object.
146
+
147
+ The data to decrypt can be broken up in two or
148
+ more pieces and `decrypt` can be called multiple times.
149
+
150
+ That is, the statement:
151
+
152
+ >>> c.decrypt(a) + c.decrypt(b)
153
+
154
+ is equivalent to:
155
+
156
+ >>> c.decrypt(a+b)
157
+
158
+ This function does not remove any padding from the plaintext.
159
+
160
+ :Parameters:
161
+ ciphertext : bytes/bytearray/memoryview
162
+ The piece of data to decrypt.
163
+
164
+ :Return: the decrypted data (byte string).
165
+ """
166
+
167
+ return self._cipher.decrypt(ciphertext)
168
+
169
+
170
+ def _create_openpgp_cipher(factory, **kwargs):
171
+ """Create a new block cipher, configured in OpenPGP mode.
172
+
173
+ :Parameters:
174
+ factory : module
175
+ The module.
176
+
177
+ :Keywords:
178
+ key : bytes/bytearray/memoryview
179
+ The secret key to use in the symmetric cipher.
180
+
181
+ IV : bytes/bytearray/memoryview
182
+ The initialization vector to use for encryption or decryption.
183
+
184
+ For encryption, the IV must be as long as the cipher block size.
185
+
186
+ For decryption, it must be 2 bytes longer (it is actually the
187
+ *encrypted* IV which was prefixed to the ciphertext).
188
+ """
189
+
190
+ iv = kwargs.pop("IV", None)
191
+ IV = kwargs.pop("iv", None)
192
+
193
+ if (None, None) == (iv, IV):
194
+ iv = get_random_bytes(factory.block_size)
195
+ if iv is not None:
196
+ if IV is not None:
197
+ raise TypeError("You must either use 'iv' or 'IV', not both")
198
+ else:
199
+ iv = IV
200
+
201
+ try:
202
+ key = kwargs.pop("key")
203
+ except KeyError as e:
204
+ raise TypeError("Missing component: " + str(e))
205
+
206
+ return OpenPgpMode(factory, key, iv, kwargs)