PyCryptodome

https://www.pycryptodome.org/
Admin
PyCryptodome is a comprehensive Python cryptography library providing symmetric and asymmetric...
Tokens:132,495
Snippets:1,217
Trust Score:8.9
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install PyCryptodome on Linux Ubuntu (PyPy)

Source: https://www.pycryptodome.org/src/installation

Install PyCryptodome on Ubuntu for PyPy. This includes installing build tools, the library, test vectors, and running the self-test.

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

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

### Using functools.partial for KDF

Source: https://www.pycryptodome.org/src/protocol/dh

Example of creating a KDF function using functools.partial for use with key_agreement. This example uses HKDF with specific parameters.

```python
from Crypto.Protocol.KDF import HKDF
from Crypto.Hash import SHA256
import functools

kdf = functools.partial(HKDF,
                         key_len=32,
                         salt=b'nonce',
                         hashmod=SHA256,
                         num_keys=2,
                         context=b'Some context about the operation')

# Pass kdf to key_agreement()
```

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

### Install PyCryptodome on Linux Ubuntu (Python 3.x)

Source: https://www.pycryptodome.org/src/installation

Install PyCryptodome on Ubuntu for Python 3.x. This includes installing build tools, the library, test vectors, and running the self-test.

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

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

### DSA Key Generation, Signing, and Verification Example

Source: https://www.pycryptodome.org/src/public_key/dsa

This example demonstrates the complete workflow of generating a new DSA key pair, saving the public key, signing a message, and then verifying the signature using the pycryptodome library.

```APIDOC
## DSA Key Generation, Signing, and Verification Example

### Description
This example demonstrates the complete workflow of generating a new DSA key pair, saving the public key, signing a message, and then verifying the signature using the pycryptodome library.

### Code Example
```python
from Crypto.PublicKey import DSA
from Crypto.Signature import DSS
from Crypto.Hash import SHA256

# Create a new DSA key
key = DSA.generate(2048)
f = open("public_key.pem", "w")
f.write(key.publickey().export_key())
f.close()

# Sign a message
message = b"Hello"
hash_obj = SHA256.new(message)
signer = DSS.new(key, 'fips-186-3')
signature = signer.sign(hash_obj)

# Load the public key
f = open("public_key.pem", "r")
hash_obj = SHA256.new(message)
pub_key = DSA.import_key(f.read())
verifier = DSS.new(pub_key, 'fips-186-3')

# Verify the authenticity of the message
try:
    verifier.verify(hash_obj, signature)
    print "The message is authentic."
except ValueError:
    print "The message is not authentic."
```
```

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

### Install PyCryptodome on Linux Ubuntu (Python 2.x)

Source: https://www.pycryptodome.org/src/installation

Install PyCryptodome on Ubuntu for Python 2.x. This includes installing build tools, the library, test vectors, and running the self-test.

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

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

### Test PyCryptodome installation (PyCrypto replacement)

Source: https://www.pycryptodome.org/src/installation

After installing PyCryptodome as a PyCrypto replacement, run these commands to install test vectors and execute the self-test suite.

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

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

### SHA3-384 Hashing Example

Source: https://www.pycryptodome.org/_sources/src/hash/sha3_384.rst.txt

Demonstrates how to create a SHA3-384 hash object, update it with data, and get the hexadecimal digest. Ensure the Crypto.Hash module is imported.

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

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

### Install PyCryptodome on Linux Fedora (PyPy)

Source: https://www.pycryptodome.org/src/installation

Install PyCryptodome on Fedora for PyPy. This includes installing GCC, GMP, PyPy development headers, the library, test vectors, and running the self-test.

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

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

### Install PyCryptodome as PyCrypto replacement

Source: https://www.pycryptodome.org/src/installation

Use this command to install PyCryptodome as a drop-in replacement for the old PyCrypto library. All modules will be installed under the `Crypto` package.

```bash
pip install pycryptodome
```

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

### Test PyCryptodome installation (independent library)

Source: https://www.pycryptodome.org/src/installation

After installing PyCryptodome as an independent library, run these commands to install test vectors and execute the self-test suite.

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

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

### CBC Mode Decryption Example

Source: https://www.pycryptodome.org/_sources/src/cipher/classic.rst.txt

Demonstrates the setup for decrypting data encrypted with AES in CBC mode. This snippet shows the necessary imports and the initial steps for decryption.

```python
import json
from base64 import b64decode
from Crypto.Cipher import AES
```

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

### Install PyCryptodome on Linux Fedora (Python 2.x)

Source: https://www.pycryptodome.org/src/installation

Install PyCryptodome on Fedora for Python 2.x. This includes installing GCC, GMP, Python development headers, the library, test vectors, and running the self-test.

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

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

### Install PyCryptodome on Linux Fedora (Python 3.x)

Source: https://www.pycryptodome.org/src/installation

Install PyCryptodome on Fedora for Python 3.x. This includes installing GCC, GMP, Python development headers, the library, test vectors, and running the self-test.

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

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

### Basic Keccak Hashing Example

Source: https://www.pycryptodome.org/src/hash/keccak

Demonstrates how to create a Keccak hash object, update it with data, and retrieve the hexadecimal digest. Ensure the 'Crypto.Hash.keccak' module is imported.

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


```

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

### SHA3-256 Usage Example

Source: https://www.pycryptodome.org/src/hash/sha3_256

Demonstrates how to create a SHA3-256 hash object, update it with data, and retrieve the hexadecimal digest.

```APIDOC
## SHA3-256 Usage Example

### Description
This example shows how to use the SHA3-256 hash function to compute the digest of a message.

### Method
```python
from Crypto.Hash import SHA3_256

h_obj = SHA3_256.new()
h_obj.update(b'Some data')
print(h_obj.hexdigest())
```

### Class
`Crypto.Hash.SHA3_256.SHA3_256_Hash`

### Methods
- `new(_data=None_)`: Creates a new SHA3-256 hash object.
- `update(_data_)`: Continues hashing by consuming the next chunk of data.
- `digest()`: Returns the binary digest.
- `hexdigest()`: Returns the printable hexadecimal digest.
- `copy()`: Returns a copy of the hash object.
```

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

### BLAKE2b Hashing Example

Source: https://www.pycryptodome.org/src/hash/blake2b

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

```APIDOC
## BLAKE2b Hashing Example

### Description
This example shows how to initialize a BLAKE2b hash object with a specified digest size, feed data into it, and obtain the resulting hash in hexadecimal format.

### Method
`Crypto.Hash.BLAKE2b.new()` followed by `update()` and `hexdigest()`

### Parameters for `new()`
- **digest_bits** (integer) - Optional. The size of the digest, in bits (8 to 512, in steps of 8). Default is 512.
- **data** (bytes/bytearray/memoryview) - Optional. The initial data to hash.

### Parameters for `update()`
- **data** (bytes/bytearray/memoryview) - Required. The next chunk of the message to hash.

### Returns
- `hexdigest()` returns a string representing the hexadecimal digest.

### Code Example
```python
from Crypto.Hash import BLAKE2b

h_obj = BLAKE2b.new(digest_bits=512)
h_obj.update(b'Some data')
print(h_obj.hexdigest())
```
```

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

### BLAKE2b MAC Example

Source: https://www.pycryptodome.org/src/hash/blake2b

Illustrates how to use BLAKE2b as a Message Authentication Code (MAC) by initializing it with a secret key.

```APIDOC
## BLAKE2b MAC Example

### Description
This example demonstrates how to use BLAKE2b to generate a Message Authentication Code (MAC). It involves initializing the hash object with a secret key and a desired digest size, updating it with data, and then retrieving the MAC digest.

### Method
`Crypto.Hash.BLAKE2b.new()` followed by `update()` and `hexdigest()`

### Parameters for `new()`
- **digest_bits** (integer) - Optional. The size of the digest, in bits (8 to 512, in steps of 8). Default is 512.
- **key** (bytes/bytearray/memoryview) - Required. The secret key to use for MAC computation (1 to 64 bytes).
- **data** (bytes/bytearray/memoryview) - Optional. The initial data to hash.

### Parameters for `update()`
- **data** (bytes/bytearray/memoryview) - Required. The next chunk of the message to hash.

### Returns
- `hexdigest()` returns a string representing the hexadecimal MAC tag.

### Code Example
```python
from Crypto.Hash import BLAKE2b

mac = BLAKE2b.new(digest_bits=256, key=b'secret')
mac.update(b'Some data')
print(mac.hexdigest())
```
```

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

### Install PyCryptodome as PyCrypto Replacement

Source: https://www.pycryptodome.org/src/introduction

Install PyCryptodome using pip when you need an almost drop-in replacement for the old PyCrypto library. All modules will be installed under the `Crypto` package. Ensure PyCrypto is not installed simultaneously to avoid interference.

```bash
pip install pycryptodome

```

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

### Test PyCryptodome installation on Windows from sources

Source: https://www.pycryptodome.org/src/installation

After compiling PyCryptodome from source on Windows, run these commands to install test vectors and execute the self-test suite.

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

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

### Salsa20 Encryption Example

Source: https://www.pycryptodome.org/src/cipher/salsa20

Demonstrates how to encrypt plaintext using the Salsa20 cipher with a provided key and how to prepend the nonce to the ciphertext.

```APIDOC
## Salsa20 Encryption Example

### Description
This example shows how to encrypt a given plaintext using the Salsa20 cipher. It utilizes a secret key and generates a nonce, which is then prepended to the resulting ciphertext for later decryption.

### Usage
```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)
```
```

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

### Compile PyCryptodome on Windows from sources

Source: https://www.pycryptodome.org/src/installation

Install PyCryptodome on Windows from source, ensuring Visual Studio build tools are installed. This command installs the library without using pre-compiled binaries.

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

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

### Salsa20 Encryption Example

Source: https://www.pycryptodome.org/_sources/src/cipher/cipher.rst.txt

A basic example demonstrating Salsa20 stream cipher encryption. It shows how to instantiate the cipher with a key, encrypt multiple pieces of data, and access the generated nonce which must be sent to the receiver.

```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
```

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

### SHA3-512 Hashing Example

Source: https://www.pycryptodome.org/src/hash/sha3_512

Demonstrates how to create a SHA3-512 hash object, update it with data, and retrieve the hexadecimal digest.

```APIDOC
## SHA3-512 Hashing Example

### Description
This example shows how to use the SHA3-512 hash function to compute the digest of a message.

### Method
```python
from Crypto.Hash import SHA3_512

h_obj = SHA3_512.new()
h_obj.update(b'Some data')
print(h_obj.hexdigest())
```

### Usage
1. Import the `SHA3_512` module from `Crypto.Hash`.
2. Create a new SHA3-512 hash object using `SHA3_512.new()`.
3. Update the hash object with the message data using the `update()` method.
4. Get the hexadecimal representation of the digest using the `hexdigest()` method.
```

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

### SHA3-224 Hashing Example

Source: https://www.pycryptodome.org/src/hash/sha3_224

Demonstrates how to create a SHA3-224 hash object, update it with data, and retrieve the hexadecimal digest.

```APIDOC
## SHA3-224 Hashing

### Description
This section provides an example of how to use the SHA3-224 hash function from the pycryptodome library to hash data.

### Usage
```python
from Crypto.Hash import SHA3_224

h_obj = SHA3_224.new()
h_obj.update(b'Some data')
print(h_obj.hexdigest())
```

### Class: SHA3_224_Hash

#### Description
A SHA3-224 hash object. This class should not be instantiated directly; use the `new()` function instead.

#### Variables
*   **oid** (string) – ASN.1 Object ID
*   **digest_size** (integer) – The size in bytes of the resulting hash

#### Methods
*   **copy()**
    *   Description: Returns a copy (clone) of the hash object with the same internal state.
    *   Returns: A hash object of the same type.
*   **digest()**
    *   Description: Returns the binary (non-printable) digest of the message hashed so far.
    *   Returns: The hash digest in binary form.
    *   Return type: byte string
*   **hexdigest()**
    *   Description: Returns the printable (hexadecimal encoded) digest of the message hashed so far.
    *   Returns: The hash digest in hexadecimal encoded string form.
    *   Return type: string
*   **new(_data =None_)**
    *   Description: Creates a fresh SHA3-224 hash object.
    *   Parameters:
        *   **data** (byte string/byte array/memoryview) – The initial data to hash.
    *   Returns: A `SHA3_224_Hash` hash object.
*   **update(_data_)**
    *   Description: Continues hashing a message by consuming the next chunk of data.
    *   Parameters:
        *   **data** (byte string/byte array/memoryview) – The next chunk of the message being hashed.

### Factory Function: Crypto.Hash.SHA3_224.new

#### Description
Creates a new hash object.

#### Parameters
*   **data** (byte string/byte array/memoryview) – The very first chunk of the message to hash. Equivalent to an early call to `update()`.
*   **update_after_digest** (boolean) – Whether `digest()` can be followed by another `update()` (default: `False`).

#### Returns
A `SHA3_224_Hash` hash object.
```

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

### SHA3-384 Hashing Example

Source: https://www.pycryptodome.org/src/hash/sha3_384

Demonstrates how to create a SHA3-384 hash object, update it with data, and retrieve the hexadecimal digest.

```APIDOC
## SHA3-384 Hashing Example

### Description
This example shows how to use the `SHA3_384` module to compute the hash of a message.

### Usage
```python
from Crypto.Hash import SHA3_384

h_obj = SHA3_384.new()
h_obj.update(b'Some data')
print(h_obj.hexdigest())
```

### Class: SHA3_384.SHA3_384_Hash

This class represents a SHA3-384 hash object. It should not be instantiated directly; use the `new()` function instead.

#### Variables
*   **oid** (string) – ASN.1 Object ID
*   **digest_size** (integer) – The size in bytes of the resulting hash.

#### Methods
*   **copy()**
    Returns a copy of the hash object with the same internal state.
    Returns: A hash object of the same type.
*   **digest()**
    Returns the binary digest of the message hashed so far.
    Returns: The hash digest in binary form.
    Return type: byte string
*   **hexdigest()**
    Returns the printable hexadecimal digest of the message hashed so far.
    Returns: The hash digest in hexadecimal encoded string.
    Return type: string
*   **new(_data=None_)**
    Creates a fresh SHA3-384 hash object. Can optionally be initialized with initial data.
    Parameters:
    *   **data** (byte string/byte array/memoryview) – The initial data to hash.
*   **update(_data_)**
    Continues hashing a message by consuming the next chunk of data.
    Parameters:
    *   **data** (byte string/byte array/memoryview) – The next chunk of the message being hashed.
```

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

### CAST-128 Encryption and Decryption Example

Source: https://www.pycryptodome.org/_sources/src/cipher/cast.rst.txt

Demonstrates how to encrypt and decrypt data using CAST-128 in OpenPGP mode. Ensure the key is of sufficient length (128 bits recommended).

```python
from Crypto.Cipher import CAST

key = b'Sixteen byte key'
cipher = CAST.new(key, CAST.MODE_OPENPGP)
plaintext = b'sona si latine loqueris '
msg = cipher.encrypt(plaintext)

eiv = msg[:CAST.block_size+2]
ciphertext = msg[CAST.block_size+2:]
cipher = CAST.new(key, CAST.MODE_OPENPGP, eiv)
print(cipher.decrypt(ciphertext))
```

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

### SHA3-224 Hashing Example

Source: https://www.pycryptodome.org/_sources/src/hash/sha3_224.rst.txt

Demonstrates how to compute the SHA3-224 hash of a given message. Instantiate the SHA3_224 object, update it with the message bytes, and then get the hexadecimal representation of the digest.

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

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

### Split a secret into shares

Source: https://www.pycryptodome.org/src/protocol/ss

Splits a 16-byte secret into 'n' shares, where 'k' shares are required for reconstruction. Each share is associated with an index starting from 1. This example also demonstrates encrypting a file using the generated key.

```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)
```

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

### Build PyCryptodome documentation

Source: https://www.pycryptodome.org/src/installation

Use this command to build the project documentation into HTML files using Sphinx. The documentation will be generated in the `Doc/_build/html/` directory.

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

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

### Initialize and Hash a Message with SHA-256

Source: https://www.pycryptodome.org/_sources/src/hash/sha256.rst.txt

Demonstrates how to create a SHA-256 hash object, update it with data, and retrieve the hexadecimal digest. Ensure the Crypto.Hash module is imported.

```python
from Crypto.Hash import SHA256

h = SHA256.new()
h.update(b'Hello')
print h.hexdigest()
```

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

### Install PyCryptodome as Independent Library

Source: https://www.pycryptodome.org/src/introduction

Install PyCryptodome using pip as an independent library, allowing it to coexist with PyCrypto. All modules will be installed under the `Cryptodome` package.

```bash
pip install pycryptodomex

```

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

### Diffie-Hellman Key Agreement with Context Binding

Source: https://www.pycryptodome.org/_sources/src/protocol/dh.rst.txt

This example shows how to bind the key agreement to contextual information using a TupleHash128 KDF. This includes session salt, party identifiers, and usage details for enhanced security.

```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)
```

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

### Minimal DH Key Agreement with Static Keys

Source: https://www.pycryptodome.org/src/protocol/dh

A basic example demonstrating Diffie-Hellman key agreement using only static keys. This is suitable when Perfect Forward Secrecy is not a primary concern. Ensure the KDF is agreed upon beforehand.

```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

```

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

### Crypto.Hash Usage Example

Source: https://www.pycryptodome.org/src/hash/hash

Demonstrates the basic API principles for hashing a message using the Crypto.Hash package. It shows how to create a new hash object, update it with data, and retrieve the digest in both byte and hexadecimal formats.

```APIDOC
## Hashing a Message

### Description
This example demonstrates the fundamental API for hashing messages using the `Crypto.Hash` package. It covers creating a hash object, updating it with data in chunks, and retrieving the final digest.

### Method
Instantiate a hash object from a specific algorithm module (e.g., `Crypto.Hash.SHA256.new()`).

### Endpoint
N/A (SDK usage)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```python
from Crypto.Hash import SHA256

# Create a new hash object, optionally with initial data
hash_object = SHA256.new(data=b'First')

# Update the hash object with more data
hash_object.update(b'Second')
hash_object.update(b'Third')

# Retrieve the digest
digest_bytes = hash_object.digest()
digest_hex = hash_object.hexdigest()

print(f"Digest (bytes): {digest_bytes}")
print(f"Digest (hex): {digest_hex}")
```

### Response
#### Success Response
- **digest_bytes** (bytes) - The computed hash digest as a byte string.
- **digest_hex** (string) - The computed hash digest as a hexadecimal string.

#### Response Example
```json
{
  "digest_bytes": "b'}\\x96\\xfd@\\xb2$?O\\xca\\xc1a\\x10\\x15\\x8c\\x94\\xe4\\xb4\\x085"\\xd5"\\xa8\\xa4C\\x9e+\\x00\\x859\\xc7A'",
  "digest_hex": "7d96fd40b2243f4fcac16110158c94e4b4083522d522a8a4439e2b008539c741"
}
```
```

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

### Create RIPEMD-160 Hash with Initial Data

Source: https://www.pycryptodome.org/src/hash/ripemd160

Shows how to create a new RIPEMD-160 hash object and optionally provide the initial data to be hashed. This is a convenient way to start hashing a message.

```python
Crypto.Hash.RIPEMD160.new(_data =None_)
```

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

### PSS Signature Creation and Verification Example

Source: https://www.pycryptodome.org/src/signature/pkcs1_pss

Demonstrates how to sign a message using a private RSA key and verify the signature using a public RSA key with PKCS#1 PSS.

```APIDOC
## Signing a Message

This example shows how to create a PKCS#1 PSS signature for a message using a private RSA key.

### Method
```python
Crypto.Signature.pss.new(key).sign(h)
```

### Parameters

*   **key** (RSA object) - The private RSA key loaded from a file.
*   **h** (hash object) - A hash object from the `Crypto.Hash` package, computed over the message.

### Example
```python
from Crypto.Signature import pss
from Crypto.Hash import SHA256
from Crypto.PublicKey import RSA

message = b'To be signed'
key = RSA.import_key(open('privkey.der', 'rb').read())
h = SHA256.new(message)
signature = pss.new(key).sign(h)
```

## Verifying a Signature

This example shows how to verify a PKCS#1 PSS signature using a public RSA key.

### Method
```python
verifier.verify(h, signature)
```

### Parameters

*   **h** (hash object) - The hash object computed over the original message.
*   **signature** (bytes) - The signature to be validated.

### Example
```python
key = RSA.import_key(open('pubkey.der', 'rb').read())
h = SHA256.new(message)
verifier = pss.new(key)
try:
    verifier.verify(h, signature)
    print("The signature is authentic.")
except (ValueError):
    print("The signature is not authentic.")
```
```

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

### OCB Mode Encryption Example (Once-off)

Source: https://www.pycryptodome.org/_sources/src/cipher/modern.rst.txt

Encrypts data using AES in OCB mode as a single, one-off operation. This example demonstrates generating a random nonce, encrypting ciphertext, and generating a tag, then formatting the output as JSON.

```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_OCB)
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)
```

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

### Minimal Diffie-Hellman Key Agreement with Static Keys

Source: https://www.pycryptodome.org/_sources/src/protocol/dh.rst.txt

A basic example demonstrating Diffie-Hellman key agreement using only static keys. Ensure the KDF is agreed upon in advance. The session key derived is suitable for AES-256 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)
```

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

### CAST-128 Encryption and Decryption Example

Source: https://www.pycryptodome.org/src/cipher/cast

Demonstrates how to encrypt and decrypt data using CAST-128 in OpenPGP mode. Ensure the key is 16 bytes and the plaintext is a multiple of the block size (8 bytes). The example shows how to extract and use the encrypted IV for decryption.

```python
from Crypto.Cipher import CAST

key = b'Sixteen byte key'
cipher = CAST.new(key, CAST.MODE_OPENPGP)
plaintext = b'sona si latine loqueris '
msg = cipher.encrypt(plaintext)

eiv = msg[:CAST.block_size+2]
ciphertext = msg[CAST.block_size+2:]
new_cipher = CAST.new(key, CAST.MODE_OPENPGP, eiv)
print(new_cipher.decrypt(ciphertext))
```

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

### RIPEMD160.new()

Source: https://www.pycryptodome.org/src/hash/ripemd160

Creates a new RIPEMD-160 hash object. This is the primary function to start hashing a message.

```APIDOC
## RIPEMD160.new()

### Description
Creates a new RIPEMD-160 hash object. This is the primary function to start hashing a message.

### Method
`RIPEMD160.new()`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **data** (byte string/byte array/memoryview) - Optional - The very first chunk of the message to hash. It is equivalent to an early call to `RIPEMD160Hash.update()`.

### Request Example
```python
from Crypto.Hash import RIPEMD160
h = RIPEMD160.new(b'initial data')
```

### Response
#### Success Response (200)
* **RIPEMD160Hash object** - A new RIPEMD160 hash object initialized with optional data.
```

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

### Hashing Data with Keccak

Source: https://www.pycryptodome.org/_sources/src/hash/keccak.rst.txt

Example of how to hash data using the Keccak algorithm with a 512-bit digest. Import the keccak module and use the new() constructor to create a hash object, then update it with data and retrieve the hexadecimal digest.

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

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

### Crypto.MD5.new

Source: https://www.pycryptodome.org/_sources/src/hash/md5.rst.txt

Creates a new MD5 hash object. This is the primary function to start hashing a message.

```APIDOC
## Crypto.MD5.new(msg=None)

### Description
Create a new hash object.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Method
None

### Endpoint
None

### Parameters
* **msg** (byte string) - Optional - The very first chunk of the message to hash. It is equivalent to an early call to :func:`update`.

### Response
#### Success Response
* **MD5_Hash object** - An :class:`MD5_Hash` hash object

### Request Example
```python
from Crypto.Hash import MD5
h = MD5.new()
```

### Response Example
```python
# Returns an MD5_Hash object
```
```

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

### Create and Use a CTR Counter

Source: https://www.pycryptodome.org/src/util/util

Example demonstrating how to create a CTR counter with a prefix, suffix, and initial value, and then use it for AES encryption. Ensure the counter block size matches the cipher's block size.

```python
from Crypto.Random import Random
from Crypto.Cipher import AES
from Crypto.Util import Counter

# 4 bytes      8 bytes       4 bytes
nonce = Random.get_random_bytes(4)
ctr = Counter.new(64, prefix=nonce, suffix=b'EFGH', little_endian=True, initial_value=10)
key = b'AES-128 symm key'
plaintext = b'X'*1000000
cipher = AES.new(key, AES.MODE_CTR, counter=ctr)
ciphertext = cipher.encrypt(plaintext)
```

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

### Get Hexadecimal Digest from SHA3-512

Source: https://www.pycryptodome.org/src/hash/sha3_512

Retrieve the computed hash digest as a printable hexadecimal string.

```python
h_obj.hexdigest()
```

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

### Get Binary Digest from SHA3-512

Source: https://www.pycryptodome.org/src/hash/sha3_512

Retrieve the computed hash digest in its raw binary form.

```python
h_obj.digest()
```

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

### Using SHA-384 Hashing

Source: https://www.pycryptodome.org/_sources/src/hash/sha384.rst.txt

Demonstrates how to initialize a SHA-384 hash object, update it with data, and retrieve the hexadecimal digest. This is the standard way to compute a SHA-384 hash.

```python
from Crypto.Hash import SHA384

h = SHA384.new()
h.update(b'Hello')
print(h.hexdigest())
```

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

### Python SHAKE128 Hashing Example

Source: https://www.pycryptodome.org/_sources/src/hash/shake128.rst.txt

Demonstrates how to initialize SHAKE128, update it with data, and read a specified number of bytes for the output. The output length is not fixed and can be adjusted using the read() method.

```python
from Crypto.Hash import SHAKE128

shake = SHAKE128.new()
shake.update(b'Some data')
print(shake.read(26).hex())
```

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

### SHA224.new()

Source: https://www.pycryptodome.org/src/hash/sha224

Creates a new SHA-224 hash object. Optionally, initial data can be provided to start the hashing process.

```APIDOC
## SHA224.new()

### Description
Creates a new SHA-224 hash object. This is the primary function to start hashing a message with SHA-224.

### Method
`SHA224.new(data=None)`

### Parameters
* **data** (byte string/byte array/memoryview) - Optional. The initial data to hash. If provided, it's equivalent to calling `update()` immediately after creation.

### Returns
A `SHA224Hash` object ready for hashing.
```

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

### Using SHA-512

Source: https://www.pycryptodome.org/_sources/src/hash/sha512.rst.txt

Demonstrates how to create a SHA-512 hash object, update it with data, and retrieve the hexadecimal digest. This is suitable for general-purpose hashing where a 512-bit output is required.

```python
from Crypto.Hash import SHA512

h = SHA512.new()
h.update(b'Hello')
print(h.hexdigest())
```

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

### Create and Hash a Message with MD5

Source: https://www.pycryptodome.org/_sources/src/hash/md5.rst.txt

This snippet demonstrates how to initialize an MD5 hash object, update it with a message, and retrieve the resulting hexadecimal digest. Ensure you import the MD5 module from Crypto.Hash.

```python
from Crypto.Hash import MD5:

h = MD5.new()
h.update(b'Hello')
print(h.hexdigest())
```

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

### MD2.new()

Source: https://www.pycryptodome.org/src/hash/md2

Creates a new MD2 hash object. This is the recommended way to start hashing data with the MD2 algorithm.

```APIDOC
## Crypto.Hash.MD2.new(data=None)

Create a new hash object.

*   **Parameters**:
    *   **data** (bytes/bytearray/memoryview) – Optional. The very first chunk of the message to hash. It is equivalent to an early call to `MD2Hash.update()`.
*   **Return**: A `MD2Hash` hash object
```

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

### Basic SHA-224 Hashing

Source: https://www.pycryptodome.org/_sources/src/hash/sha224.rst.txt

Demonstrates how to initialize a SHA-224 hash object, update it with data, and retrieve the hexadecimal digest. Ensure the Crypto.Hash.SHA224 module is imported.

```python
from Crypto.Hash import SHA224

h = SHA224.new()
h.update(b'Hello')
print(h.hexdigest())
```

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

### BLAKE2b Hashing

Source: https://www.pycryptodome.org/_sources/src/hash/blake2b.rst.txt

Initialize a BLAKE2b hash object with a specified digest size, update it with data, and get the hexadecimal digest.

```python
from Crypto.Hash import BLAKE2b

h_obj = BLAKE2b.new(digest_bits=512)
h_obj.update(b'Some data')
print h_obj.hexdigest()
```

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

### Generate SHAKE256 Hash with Custom Output Length

Source: https://www.pycryptodome.org/_sources/src/hash/shake256.rst.txt

Demonstrates how to initialize SHAKE256, update it with data, and read a specific number of bytes for the output. Use this when a variable-length hash is required.

```python
from Crypto.Hash import SHAKE256

shake = SHAKE256.new()
shake.update(b'Some data')
print(shake.read(26).hex())
```

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

### Salsa20 Decryption Example

Source: https://www.pycryptodome.org/src/cipher/salsa20

Illustrates how to decrypt data that was previously encrypted with Salsa20, requiring the same secret key and the nonce that was prepended to the ciphertext.

```APIDOC
## Salsa20 Decryption Example

### Description
This example demonstrates the process of decrypting data that has been encrypted using Salsa20. It requires the original secret key and the nonce, which is extracted from the beginning of the message before decryption.

### Usage
```python
from Crypto.Cipher import Salsa20

secret = b'*Thirty-two byte (256 bits) key*'
msg_nonce = msg[:8] # Assuming msg contains nonce + ciphertext
ciphertext = msg[8:]
cipher = Salsa20.new(key=secret, nonce=msg_nonce)
plaintext = cipher.decrypt(ciphertext)
```
```

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

### Generate KMAC256 Tag

Source: https://www.pycryptodome.org/_sources/src/hash/kmac256.rst.txt

Example of how to generate a KMAC256 tag with a specified MAC length. Ensure the secret key is 32 bytes or more.

```python
from Crypto.Hash import KMAC256

secret = b'Protect this thirty-two byte key'
mac = KMAC256.new(key=secret, mac_len=16)
mac.update(b'Hello')
print(mac.hexdigest())
```

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

### RC2 Encryption Example

Source: https://www.pycryptodome.org/_sources/src/cipher/arc2.rst.txt

Encrypts a message using RC2 in CFB mode. The resulting ciphertext includes the Initialization Vector (IV).

```python
from Crypto.Cipher import ARC2

key = b'Sixteen byte key'
cipher = ARC2.new(key, ARC2.MODE_CFB)
msg = cipher.iv + cipher.encrypt(b'Attack at dawn')
```

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

### Create and Hash Initial Data with SHA256

Source: https://www.pycryptodome.org/_sources/src/hash/hash.rst.txt

Instantiate a new SHA256 hash object and provide the initial data to be hashed. Only byte strings or byte arrays are accepted.

```python
from Crypto.Hash import SHA256

hash_object = SHA256.new(data=b'First')
```
Tokens:
Raw