PyCryptodome

https://pycryptodome.readthedocs.io/en/latest/
Admin
PyCryptodome is a self-contained Python package of low-level cryptographic primitives providing...
Tokens:214,659
Snippets:1,546
Trust Score:9.6
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Windows - Run test suite

Source: https://pycryptodome.readthedocs.io/en/latest/src/installation.html

Install test vectors and run the self-test on Windows to verify the installation.

```bash
> pip install pycryptodome-test-vectors
> python -m Cryptodome.SelfTest
```

--------------------------------

### Linux Fedora - PyPy installation

Source: https://pycryptodome.readthedocs.io/en/latest/src/installation.html

Install gcc, gmp, and PyPy development headers, then install pycryptodomex and test vectors, and run the self-test with pypy -m Cryptodome.SelfTest.

```bash
$ sudo yum install gcc gmp pypy-devel
$ pip install pycryptodomex
$ pip install pycryptodome-test-vectors
$ pypy -m Cryptodome.SelfTest
```

--------------------------------

### BLAKE2b MAC example

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/hash/blake2b.rst.txt

Initializes BLAKE2b with a secret key to create a keyed MAC. The example uses a 256-bit digest and prints the resulting hex digest.

```python
>>> from Crypto.Hash import BLAKE2b
>>>
>>> mac = BLAKE2b.new(digest_bits=256, key=b'secret')
>>> mac.update(b'Some data')
>>> print mac.hexdigest()
```

--------------------------------

### Windows - Install PyCryptodome from source

Source: https://pycryptodome.readthedocs.io/en/latest/src/installation.html

Compile and install PyCryptodome on Windows using pip with --no-binary :all: to build from source. Requires Visual Studio build tools.

```bash
> pip install pycryptodomex --no-binary :all:
```

--------------------------------

### Linux Fedora - Python 2.x installation

Source: https://pycryptodome.readthedocs.io/en/latest/src/installation.html

Install gcc, gmp, and Python 2 development headers, then install pycryptodomex and test vectors, and run the self-test with python -m Cryptodome.SelfTest.

```bash
$ sudo yum install gcc gmp python-devel
$ pip install pycryptodomex
$ pip install pycryptodome-test-vectors
$ python -m Cryptodome.SelfTest
```

--------------------------------

### Linux Fedora - Python 3.x installation

Source: https://pycryptodome.readthedocs.io/en/latest/src/installation.html

Install gcc, gmp, and Python 3 development headers, then install pycryptodomex and test vectors, and run the self-test with python3 -m Cryptodome.SelfTest.

```bash
$ sudo yum install gcc gmp python3-devel
$ pip install pycryptodomex
$ pip install pycryptodome-test-vectors
$ python3 -m Cryptodome.SelfTest
```

--------------------------------

### MD5 hash usage example

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/hash/md5.rst.txt

Shows how to create an MD5 hash object, update it with data, and print the hexadecimal digest. Note the example uses Python 2 syntax (print statement) and includes a colon after the import, which is a typo in the original.

```python
>>> from Crypto.Hash import MD5:
>>>
>>> h = MD5.new()
>>> h.update(b'Hello')
>>> print h.hexdigest()
```

--------------------------------

### Basic Salsa20 encryption example

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/cipher/cipher.rst.txt

Shows how to instantiate a Salsa20 cipher with a 16-byte key, encrypt plaintext in multiple calls, and print the nonce to send to the receiver. The example uses Python 2 syntax (print statement) and demonstrates that encrypt can be called multiple times.

```python
>>> from Crypto.Cipher import Salsa20
>>>
>>> key = b'0123456789012345'
>>> cipher = Salsa20.new(key)
>>> ciphertext =  cipher.encrypt(b'The secret I want to send.')
>>> ciphertext += cipher.encrypt(b'The second part of the secret.')
>>> print cipher.nonce  # A byte string you must send to the receiver too
```

--------------------------------

### Compile PyCryptodome on Ubuntu for PyPy

Source: https://pycryptodome.readthedocs.io/en/latest/src/installation.html

Compiles and installs PyCryptodome on Linux Ubuntu for PyPy. Installs build dependencies, the library, test vectors, and runs the self-test.

```bash
$ sudo apt-get install build-essential pypy-dev
$ pip install pycryptodomex
$ pip install pycryptodome-test-vectors
$ pypy -m Cryptodome.SelfTest

```

--------------------------------

### BLAKE2b hashing example

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/hash/blake2b.rst.txt

Computes a BLAKE2b hash with a 512-bit digest. The example creates a hash object, updates it with data, and prints the hex digest.

```python
>>> from Crypto.Hash import BLAKE2b
>>>
>>> h_obj = BLAKE2b.new(digest_bits=512)
>>> h_obj.update(b'Some data')
>>> print h_obj.hexdigest()
```

--------------------------------

### Static Key Agreement Example

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/protocol/dh.rst.txt

Minimal example using only static keys for Diffie-Hellman key agreement. It generates a static private key for U and a static public key for V, then derives a session key using a pre-agreed KDF. The resulting session key is an AES-256 key for subsequent encryption.

```python
from Crypto.PublicKey import ECC
from Crypto.Hash import SHAKE128
from Crypto.Protocol.DH import key_agreement

# This KDF has been agreed in advance
def kdf(x):
        return SHAKE128.new(x).read(32)

# In a real scenario, this key already exists
U = ECC.generate(curve='p256')

# In a real scenario, this key is received from the peer
# and it is verified as authentic
V = ECC.generate(curve='p256').public_key()

session_key = key_agreement(static_priv=U, static_pub=V, kdf=kdf)

# session_key is an AES-256 key, which will be used to encrypt
# subsequent communications
```

--------------------------------

### SIV Encryption Example

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/cipher/modern.rst.txt

Shows how to encrypt data using SIV mode with AES. The nonce is optional; if omitted, encryption is deterministic. The example outputs a JSON object with base64-encoded nonce, header, ciphertext, and tag.

```python
>>> import json
>>> from base64 import b64encode
>>> from Crypto.Cipher import AES
>>> from Crypto.Random import get_random_bytes
>>>
>>> header = b"header"
>>> data = b"secret"
>>> key = get_random_bytes(16 * 2)
>>> nonce = get_random_bytes(16)
>>> cipher = AES.new(key, AES.MODE_SIV, nonce=nonce)    # Without nonce, the encryption
>>>                                                     # becomes deterministic
>>> cipher.update(header)
>>> ciphertext, tag = cipher.encrypt_and_digest(data)
>>>
>>> json_k = [ 'nonce', 'header', 'ciphertext', 'tag' ]
>>> json_v = [ b64encode(x).decode('utf-8') for x in (nonce, header, ciphertext, tag) ]
>>> result = json.dumps(dict(zip(json_k, json_v)))
>>> print(result)
{"nonce": "zMiifAVvDpMS8hnGK/z+iw==", "header": "aGVhZGVy", "ciphertext": "Q7lReEAF", "tag": "KgdnBVbCee6B/wGmMf/wQA=="}
```

--------------------------------

### Compile PyCryptodome on Ubuntu for Python 3.x

Source: https://pycryptodome.readthedocs.io/en/latest/src/installation.html

Compiles and installs PyCryptodome on Linux Ubuntu for Python 3.x. Installs build dependencies, the library, test vectors, and runs the self-test.

```bash
$ sudo apt-get install build-essential python3-dev
$ pip install pycryptodomex
$ pip install pycryptodome-test-vectors
$ python3 -m Cryptodome.SelfTest

```

--------------------------------

### PKCS8.wrap

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/io/pkcs8.rst.txt

Documentation for the PKCS8.wrap function from the Crypto.IO.PKCS8 module, including parameters and usage example.

```APIDOC
## PKCS8.wrap

### Description
Wraps a DER-encoded private key into a PKCS#8 container, optionally encrypting it with a passphrase.

### Method
wrap

### Parameters
- **key_der** (bytes) - Required - The DER-encoded private key to wrap.
- **oid** (str) - Required - The object identifier (OID) of the key algorithm (e.g., "1.2.840.10045.2.1" for unrestricted ECC).
- **passphrase** (bytes) - Optional - The passphrase used to encrypt the key. If not provided, the key is left unencrypted.
- **protection** (str) - Optional - The encryption algorithm string, e.g., "PBKDF2WithHMAC-SHA512AndAES256-CBC".
- **prot_params** (dict) - Optional - A dictionary of parameters for the key derivation function (e.g., iteration_count, salt_size, block_size, parallelization).

### Request Example
```python
from Crypto.PublicKey import ECC
from Crypto.IO import PKCS8

key = ECC.generate(curve='p256')
pkey = key.export_key(format='DER')
passphrase = b'secret santa'
encrypted_key = PKCS8.wrap(
    pkey,
    "1.2.840.10045.2.1",  # unrestricted ECC
    passphrase=passphrase,
    protection='PBKDF2WithHMAC-SHA512AndAES256-CBC',
    prot_params={'iteration_count': 210000}
)
```

### Response
Returns the PKCS#8 container as bytes.

### Notes
- The `protection` parameter must follow one of two patterns: `'PBKDF2WithHMAC-' + hash + 'And' + cipher` or `'scryptAnd' + cipher`.
- Recommended hash: `'SHA512'`; recommended cipher: `'AES256-CBC'`.
- Other hashes: `'SHA1'`, `'SHA224'`, `'SHA256'`, `'SHA384'`, `'SHA512-224'`, `'SHA512-256'`, `'SHA3-224'`, `'SHA3-256'`, `'SHA3-384'`, `'SHA3-512'`.
- Other ciphers: `'AES128-GCM'`, `'AES192-GCM'`, `'AES256-GCM'`, `'AES128-CBC'`, `'AES192-CBC'`, `'DES-EDE3-CBC'`.
- `prot_params` keys: `iteration_count` (default 1000 for PBKDF2, 16384 for scrypt; recommended 210000 for PBKDF2-SHA512, 131072 for scrypt), `salt_size` (default 8), `block_size` (scrypt only, default 8), `parallelization` (scrypt only, default 1).
- Legacy protection mechanisms (only for importing): `pbeWithMD5AndRC2-CBC`, `pbeWithMD5AndDES-CBC`, `pbeWithSHA1AndRC2-CBC`, `pbeWithSHA1AndDES-CBC`.
```

--------------------------------

### Static key agreement with context binding using TupleHash128

Source: https://pycryptodome.readthedocs.io/en/latest/src/protocol/dh.html

Use when the key agreement must be bound to context information as recommended by NIST SP 800-56A. The KDF incorporates a session salt, party identifiers, and purpose strings to derive a 32-byte key. The example uses TupleHash128 for the KDF and includes the same static key setup as the minimal example.

```python
from Crypto.Hash import TupleHash128
from Crypto.Protocol.DH import key_agreement

# Random value (e.g., a nonce)
session_salt = b'XYZ'

# The unique identifier of each party
id_u = 'Client 12'
id_v = 'Server 25'

def kdf(x):
    h = TupleHash128.new(digest_bytes=32)
    h.update(x,
             session_salt,
             id_u.encode(),     # To UTF-8
             id_v.encode(),     # To UTF-8
             b'Email encryption',
             b'TupleHash128',
             b'AES256')
    return h.digest()

# In a real scenario, this key already exists
U = ECC.generate(curve='p256')

# In a real scenario, this key is received from the peer
# and it is verified as authentic
V = ECC.generate(curve='p256').public_key()

key = key_agreement(static_priv=U, static_pub=V, kdf=kdf)
```

--------------------------------

### Crypto.Random.random.randrange([start,] stop[, step])

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/random/random.rst.txt

Returns a random integer in the range (start, stop, step). By default, start is 0 and step is 1.

```APIDOC
## Crypto.Random.random.randrange([start,] stop[, step])

### Description
Returns a random integer in the range (start, stop, step). By default, start is 0 and step is 1.

### Method
N/A

### Endpoint
N/A

### Parameters
- **start** (int) - Optional - The lower bound of the range. Default is 0.
- **stop** (int) - Required - The upper bound of the range (exclusive).
- **step** (int) - Optional - The step size. Default is 1.

### Request Example
N/A

### Response
#### Success Response
- **int** - A random integer in the specified range.

#### Response Example
N/A
```

--------------------------------

### Sign and verify with PKCS#1 v1.5 (RSASSA-PKCS1-v1_5)

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/signature/pkcs1_v1_5.rst.txt

Shows how to sign a message with a private RSA key using PKCS#1 v1.5 (RSASSA-PKCS1-v1_5) and verify it with the matching public key. The signing example loads the private key from 'private_key.der', hashes the message with SHA256, and produces the signature. The verification example loads the public key from 'public_key.der', verifies the signature, and prints whether it is valid, catching ValueError and TypeError for invalid signatures.

```python
>>> from Crypto.Signature import pkcs1_15
>>> from Crypto.Hash import SHA256
>>> from Crypto.PublicKey import RSA
>>>
>>> message = b'To be signed'
>>> key = RSA.import_key(open('private_key.der').read())
>>> h = SHA256.new(message)
>>> signature = pkcs1_15.new(key).sign(h)
```

```python
>>> key = RSA.import_key(open('public_key.der').read())
>>> h = SHA256.new(message)
>>> try:
>>>     pkcs1_15.new(key).verify(h, signature)
>>>     print "The signature is valid."
>>> except (ValueError, TypeError):
>>>    print "The signature is not valid."
```

--------------------------------

### Build HTML documentation with Sphinx

Source: https://pycryptodome.readthedocs.io/en/latest/src/installation.html

Run this command from the project root to build the reStructuredText documentation into HTML. Requires Sphinx to be installed. The output is written to Doc/_build/html/.

```shell
> make -C Doc/ html
```

--------------------------------

### Install PyCryptodome as PyCrypto replacement

Source: https://pycryptodome.readthedocs.io/en/latest/src/introduction.html

Installs PyCryptodome as a drop-in replacement for PyCrypto, placing modules under the Crypto package. Avoid installing both PyCrypto and PyCryptodome simultaneously as they interfere; recommended only in a virtualenv.

```bash
pip install pycryptodome
```

--------------------------------

### Test PyCryptodome (Cryptodome package)

Source: https://pycryptodome.readthedocs.io/en/latest/src/installation.html

Verifies the PyCryptodome installation when installed under the Cryptodome package. Runs the self-test suite to confirm everything is working.

```bash
pip install pycryptodome-test-vectors
python -m Cryptodome.SelfTest

```

--------------------------------

### Split a secret and encrypt a file with Shamir and AES

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/protocol/ss.rst.txt

Shows how to split a 16-byte key into 2-of-5 shares and use it to encrypt a file with AES in EAX mode. Requires the binascii, Crypto.Cipher, Crypto.Random, and Crypto.Protocol.SecretSharing modules. The example prints each share index and hexlified share, then writes nonce, tag, and ciphertext to enc.txt.

```python
>>> from binascii import hexlify
>>> from Crypto.Cipher import AES
>>> from Crypto.Random import get_random_bytes
>>> from Crypto.Protocol.SecretSharing import Shamir
>>>
>>> key = get_random_bytes(16)
>>> shares = Shamir.split(2, 5, key)
>>> for idx, share in shares:
>>>     print "Index #%d: %s" % (idx, hexlify(share))
>>>
>>> with open("clear.txt", "rb") as fi, open("enc.txt", "wb") as fo:
>>>     cipher = AES.new(key, AES.MODE_EAX)
>>>     ct, tag = cipher.encrypt(fi.read()), cipher.digest()
>>>     fo.write(cipher.nonce + tag + ct)
```

--------------------------------

### Test PyCryptodome (Crypto package)

Source: https://pycryptodome.readthedocs.io/en/latest/src/installation.html

Verifies the PyCryptodome installation when installed under the Crypto package. Runs the self-test suite to confirm everything is working.

```bash
pip install pycryptodome-test-vectors
python -m Crypto.SelfTest

```

--------------------------------

### Install PyCryptodome as independent library

Source: https://pycryptodome.readthedocs.io/en/latest/src/introduction.html

Installs PyCryptodome as an independent library, placing modules under the Cryptodome package. This allows PyCrypto and PyCryptodome to coexist.

```bash
pip install pycryptodomex
```

--------------------------------

### new

Source: https://pycryptodome.readthedocs.io/en/latest/src/signature/pkcs1_v1_5.html

Create a signature object for PKCS#1 v1.5 signing or verification.

```APIDOC
## [NEW] Crypto.Signature.pkcs1_15.new

### Description
Create a signature object for creating or verifying PKCS#1 v1.5 signatures.

### Method
NEW

### Endpoint
Crypto.Signature.pkcs1_15.new

### Parameters
#### Parameters
- **rsa_key** (RSA object) - Required - The RSA key to use for signing or verifying the message. This is a Crypto.PublicKey.RSA object. Signing is only possible when rsa_key is a private RSA key.

### Returns
- a PKCS115_SigScheme signature object
```

--------------------------------

### Keccak hash example in Python

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/hash/keccak.rst.txt

Shows how to create a Keccak hash object with a 512-bit digest, update it with data, and print the hexadecimal digest. Use this when you need to compute a Keccak hash with the Crypto.Hash.keccak module.

```python
>>> from Crypto.Hash import keccak
>>>
>>> keccak_hash = keccak.new(digest_bits=512)
>>> keccak_hash.update(b'Some data')
>>> print keccak_hash.hexdigest()
```

--------------------------------

### Triple DES Encryption Example

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/cipher/des3.rst.txt

Example showing how to encrypt data using Triple DES in CFB mode with a randomly generated 24-byte key.

```APIDOC
## [EXAMPLE] Triple DES Encryption

### Description
Demonstrates how to encrypt a plaintext message using the Triple DES cipher in CFB mode with a randomly generated 24-byte key (Keying Option 1).

### Method
EXAMPLE

### Endpoint
N/A

### Parameters
#### Key Generation
- **key** (bytes) - Required - 24-byte key generated with `get_random_bytes(24)` and adjusted for parity using `DES3.adjust_key_parity()`.

#### Cipher Initialization
- **cipher** (object) - Required - Created with `DES3.new(key, DES3.MODE_CFB)`.

#### Plaintext
- **plaintext** (bytes) - Required - The message to encrypt.

### Request Example
```python
from Crypto.Cipher import DES3
from Crypto.Random import get_random_bytes

# Avoid Option 3
while True:
    try:
        key = DES3.adjust_key_parity(get_random_bytes(24))
        break
    except ValueError:
        pass

cipher = DES3.new(key, DES3.MODE_CFB)
plaintext = b'We are no longer the knights who say ni!'
msg = cipher.iv + cipher.encrypt(plaintext)
```

### Response
#### Success Response
- **msg** (bytes) - The concatenation of the initialization vector (IV) and the ciphertext.

#### Response Example
```python
# msg contains the IV followed by the encrypted plaintext
```
```

--------------------------------

### Combine shares and decrypt a file with Shamir and AES

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/protocol/ss.rst.txt

Shows how to collect two shares from user input, combine them with Shamir.combine, and decrypt a file previously encrypted with AES in EAX mode. The example reads nonce and tag from the file, decrypts, verifies the tag, and writes the plaintext to clear2.txt. If verification fails, it prints 'The shares were incorrect'.

```python
>>> from binascii import unhexlify
>>> from Crypto.Cipher import AES
>>> from Crypto.Protocol.SecretSharing import Shamir
>>>
>>> shares = []
>>> for x in range(2):
>>>     in_str = raw_input("Enter index and share separated by comma: ")
>>>     idx, share = [ strip(s) for s in in_str.split(",") ]
>>>     shares.append((idx, unhexlify(share)))
>>> key = Shamir.combine(shares)
>>>
>>> with open("enc.txt", "rb") as fi:
>>>     nonce, tag = [ fi.read(16) for x in range(2) ]
>>>     cipher = AES.new(key, AES.MODE_EAX, nonce)
>>>     try:
>>>         result = cipher.decrypt(fi.read())
>>>         cipher.verify(tag)
>>>         with open("clear2.txt", "wb") as fo:
>>>             fo.write(result)
>>>     except ValueError:
>>>         print "The shares were incorrect"
```

--------------------------------

### Compute SHA3-256 hash in Python

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/hash/sha3_256.rst.txt

Shows how to create a SHA3-256 hash object, update it with data, and print the hex digest. The example uses the Crypto.Hash.SHA3_256 module.

```python
>>> from Crypto.Hash import SHA3_256
>>>
>>> h_obj = SHA3_256.new()
>>> h_obj.update(b'Some data')
>>> print h_obj.hexdigest()
```

--------------------------------

### EAX encryption example with AES

Source: https://pycryptodome.readthedocs.io/en/latest/src/cipher/modern.html

Shows how to encrypt data using AES in EAX mode, including generating a random key, updating header, and producing a JSON output with nonce, header, ciphertext, and tag.

```Python
>>> import json
>>> from base64 import b64encode
>>> from Crypto.Cipher import AES
>>> from Crypto.Random import get_random_bytes
>>>
>>> header = b"header"
>>> data = b"secret"
>>> key = get_random_bytes(16)
>>> cipher = AES.new(key, AES.MODE_EAX)
>>> cipher.update(header)
>>> ciphertext, tag = cipher.encrypt_and_digest(data)
>>>
>>> json_k = [ 'nonce', 'header', 'ciphertext', 'tag' ]
>>> json_v = [ b64encode(x).decode('utf-8') for x in (cipher.nonce, header, ciphertext, tag) ]
>>> result = json.dumps(dict(zip(json_k, json_v)))
>>> print(result)
{"nonce": "CSIJ+e8KP7HJo+hC4RXIyQ==", "header": "aGVhZGVy", "ciphertext": "9YYjuAn", "tag": "kXHrs9ZwYmjDkmfEJx7Clg=="}
```

--------------------------------

### Salsa20 encryption example

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/cipher/salsa20.rst.txt

Shows how to encrypt data with Salsa20 using a 256-bit key. The nonce is prepended to the ciphertext for later decryption.

```python
>>> from Crypto.Cipher import Salsa20
>>>
>>> plaintext = b'Attack at dawn'
>>> secret = b'*Thirty-two byte (256 bits) key*'
>>> cipher = Salsa20.new(key=secret)
>>> msg = cipher.nonce + cipher.encrypt(plaintext)
```

--------------------------------

### CBC decryption example

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/cipher/classic.rst.txt

Decrypts data encrypted with AES in CBC mode. The example is incomplete in the source, but it is intended to reverse the encryption process using the IV and ciphertext.

```python
>>>
```

--------------------------------

### Keccak Hash Creation and Usage

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/hash/keccak.rst.txt

Demonstrates how to create a Keccak hash object, update it with data, and compute the hexadecimal digest.

```APIDOC
## Keccak Hash Creation and Usage

### Description
Creates a Keccak hash object with a specified digest size, updates it with data, and computes the hexadecimal digest.

### Method
new

### Endpoint
Crypto.Hash.keccak.new

### Parameters
#### Keyword Arguments
- **digest_bits** (int) - Required - The digest size in bits. Supported values: 224, 256, 384, 512.

### Request Example
```python
>>> from Crypto.Hash import keccak
>>> keccak_hash = keccak.new(digest_bits=512)
>>> keccak_hash.update(b'Some data')
>>> print keccak_hash.hexdigest()
```

### Response
#### Success Response
- **hexdigest** (str) - The hexadecimal representation of the hash digest.

#### Response Example
```
(hexadecimal digest string)
```

```

--------------------------------

### Compile PyCryptodome on Ubuntu for Python 2.x

Source: https://pycryptodome.readthedocs.io/en/latest/src/installation.html

Compiles and installs PyCryptodome on Linux Ubuntu for Python 2.x. Installs build dependencies, the library, test vectors, and runs the self-test.

```bash
$ sudo apt-get install build-essential python-dev
$ pip install pycryptodomex
$ pip install pycryptodome-test-vectors
$ python -m Cryptodome.SelfTest

```

--------------------------------

### Compute SHA3-512 digest

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/hash/sha3_512.rst.txt

Example of computing the 512-bit digest of a message using the SHA3_512 module. The example creates a hash object, updates it with the message bytes, and prints the hexadecimal digest.

```python
>>> from Crypto.Hash import SHA3_512
>>>
>>> h_obj = SHA3_512.new()
>>> h_obj.update(b'Some data')
>>> print h_obj.hexdigest()
```

--------------------------------

### SIV Decryption Example

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/cipher/modern.rst.txt

Shows how to decrypt and verify data encrypted with SIV mode. It assumes the key was securely shared beforehand and handles incorrect decryption by catching ValueError and KeyError.

```python
>>> import json
>>> from base64 import b64decode
>>> from Crypto.Cipher import AES
>>>
>>> # We assume that the key was securely shared beforehand
>>> try:
>>>     b64 = json.loads(json_input)
>>>     json_k = [ 'nonce', 'header', 'ciphertext', 'tag' ]
>>>     jv = {k:b64decode(b64[k]) for k in json_k}    
>>>     
>>>     cipher = AES.new(key, AES.MODE_SIV, nonce=jv['nonce'])
>>>     cipher.update(jv['header'])
>>>     plaintext = cipher.decrypt_and_verify(jv['ciphertext'], jv['tag'])
>>>     print("The message was: " + plaintext.decode('utf-8'))
>>> except (ValueError, KeyError):
>>>     print("Incorrect decryption")
```

--------------------------------

### Check Python site-packages directory

Source: https://pycryptodome.readthedocs.io/en/latest/src/faq.html

Shows the path to the Python site-packages directory to check for the crypto package.

```text
/path/to/python/Lib/site-packages/
```

--------------------------------

### TurboSHAKE128 XOF example

Source: https://pycryptodome.readthedocs.io/en/latest/_sources/src/hash/turboshake.rst.txt

Creates a TurboSHAKE128 XOF, updates it with data, and reads 26 bytes (208 bits) of output. The output is printed as hexadecimal. The example shows the read() method instead of digest().

```python
>>> from Crypto.Hash import TurboSHAKE128
>>>
>>> xof = TurboSHAKE128.new()
>>> xof.update(b'Some data')
>>> print(xof.read(26).hex())
d9dfbe4ff8bf344749908073916d3f185ef88f5401024f029
```

--------------------------------

### Example 2: HMAC as PRF, two AES128 keys

Source: https://pycryptodome.readthedocs.io/en/latest/src/protocol/kdf.html

Derives two AES128 keys using HMAC-SHA256 as the PRF. The PRF function is the same as in Example 1. The function is called with num_keys=2 to obtain two derived keys.

```python
>> from Crypto.Hash import SHA256, HMAC
>>
>> def prf(s, x):
>>     return HMAC.new(s, x, SHA256).digest()
>>
>> key_A, key_B = SP800_108_Counter(secret, 16, prf, num_keys=2, label=b'Key AB')

```
Tokens:
Raw