# rencrypt
[](https://badge.fury.io/py/rencrypt)
[](https://github.com/radumarias/rencrypt-python/actions/workflows/CI.yml)
> [!WARNING]
> **This crate hasn't been audited, but it's mostly a wrapper over several libs like `ring` (well known and audited
library),`RustCrypto` (`AES-GCM` and `ChaCha20Poly1305` ciphers are audited) but also others which are NOT audited, so
in principle at least the primitives should offer a similar level of security.**
A Python encryption library implemented in Rust. It supports `AEAD` with varius ciphers. It
uses [ring](https://crates.io/crates/ring), [RustCrypto](https://crates.io/crates/aead) (and
derivates), [sodiumoxide](https://crates.io/crates/sodiumoxide) and [orion](https://crates.io/crates/orion) to handle
encryption.
If offers slightly higher speed compared to other Python libs, especially for small chunks of data (especially
the `Ring` provider with `AES-GCM` ciphers). The API also tries to be easy to use but it's more optimized for speed than
usability.
So if you want to use a vast variaety of ciphers and/or achieve the highest possible encryption speed, consider giving
it a try.
# Benchmark
Some benchmarks comparing it to [PyFLocker](https://github.com/arunanshub/pyflocker) which from my benchmarks is the
fastest among other Python libs like `cryptography`, `NaCl` (`libsodium`), `PyCryptodome`.
## Buffer in memory
This is useful when you keep a buffer, set your plaintext/ciphertext in there, and then encrypt/decrypt in-place in that
buffer. This is the most performant way to use it, because it does't copy any bytes nor allocate new memory.
`rencrypt` is faster on small buffers, less than few MB, `PyFLocker` is comming closer for larger buffers.
**Encrypt seconds**
**Decrypt seconds**
**Block size and duration in seconds**
<table>
<thead>
<tr>
<th>MB</th>
<th>rencrypt<br>encrypt</th>
<th>PyFLocker<br>encrypt</th>
<th>rencrypt<br>decrypt</th>
<th>PyFLocker<br>decrypt</th>
</tr>
</thead>
<tbody>
<tr>
<td>0.03125</td>
<td>0.00001</td>
<td>0.00091</td>
<td>0.00001</td>
<td>0.00004</td>
</tr>
<tr>
<td>0.0625</td>
<td>0.00001</td>
<td>0.00005</td>
<td>0.00001</td>
<td>0.00004</td>
</tr>
<tr>
<td>0.125</td>
<td>0.00002</td>
<td>0.00005</td>
<td>0.00003</td>
<td>0.00005</td>
</tr>
<tr>
<td>0.25</td>
<td>0.00004</td>
<td>0.00008</td>
<td>0.00005</td>
<td>0.00009</td>
</tr>
<tr>
<td>0.5</td>
<td>0.00010</td>
<td>0.00014</td>
<td>0.00011</td>
<td>0.00015</td>
</tr>
<tr>
<td>1</td>
<td>0.00021</td>
<td>0.00024</td>
<td>0.00021</td>
<td>0.00029</td>
</tr>
<tr>
<td>2</td>
<td>0.00043</td>
<td>0.00052</td>
<td>0.00044</td>
<td>0.00058</td>
</tr>
<tr>
<td>4</td>
<td>0.00089</td>
<td>0.00098</td>
<td>0.00089</td>
<td>0.00117</td>
</tr>
<tr>
<td>8</td>
<td>0.00184</td>
<td>0.00190</td>
<td>0.00192</td>
<td>0.00323</td>
</tr>
<tr>
<td>16</td>
<td>0.00353</td>
<td>0.00393</td>
<td>0.00367</td>
<td>0.00617</td>
</tr>
<tr>
<td>32</td>
<td>0.00678</td>
<td>0.00748</td>
<td>0.00749</td>
<td>0.01348</td>
</tr>
<tr>
<td>64</td>
<td>0.01361</td>
<td>0.01461</td>
<td>0.01460</td>
<td>0.02697</td>
</tr>
<tr>
<td>128</td>
<td>0.02923</td>
<td>0.03027</td>
<td>0.03134</td>
<td>0.05410</td>
</tr>
<tr>
<td>256</td>
<td>0.06348</td>
<td>0.06188</td>
<td>0.06136</td>
<td>0.10417</td>
</tr>
<tr>
<td>512</td>
<td>0.11782</td>
<td>0.13463</td>
<td>0.12090</td>
<td>0.21114</td>
</tr>
<tr>
<td>1024</td>
<td>0.25001</td>
<td>0.24953</td>
<td>0.25377</td>
<td>0.42581</td>
</tr>
</tbody>
</table>
## File
**Encrypt seconds**
**Decrypt seconds**
**File size and duration in seconds**
<table>
<thead>
<tr>
<th>MB</th>
<th>rencrypt<br>encrypt</th>
<th>PyFLocker<br>encrypt</th>
<th>rencrypt<br>decrypt</th>
<th>PyFLocker<br>decrypt</th>
</tr>
</tr>
</thead>
<tbody>
<tr>
<td>0.031251</td>
<td>0.00010</td>
<td>0.00280</td>
<td>0.00004</td>
<td>0.00479</td>
</tr>
<tr>
<td>0.062501</td>
<td>0.00009</td>
<td>0.00218</td>
<td>0.00005</td>
<td>0.00143</td>
</tr>
<tr>
<td>0.125</td>
<td>0.00020</td>
<td>0.00212</td>
<td>0.00014</td>
<td>0.00129</td>
</tr>
<tr>
<td>0.25</td>
<td>0.00034</td>
<td>0.00232</td>
<td>0.00020</td>
<td>0.00165</td>
</tr>
<tr>
<td>0.5</td>
<td>0.00050</td>
<td>0.00232</td>
<td>0.00035</td>
<td>0.00181</td>
</tr>
<tr>
<td>1</td>
<td>0.00087</td>
<td>0.00356</td>
<td>0.00065</td>
<td>0.00248</td>
</tr>
<tr>
<td>2</td>
<td>0.00215</td>
<td>0.00484</td>
<td>0.00154</td>
<td>0.00363</td>
</tr>
<tr>
<td>4</td>
<td>0.00361</td>
<td>0.00765</td>
<td>0.00301</td>
<td>0.00736</td>
</tr>
<tr>
<td>8</td>
<td>0.00688</td>
<td>0.01190</td>
<td>0.00621</td>
<td>0.00876</td>
</tr>
<tr>
<td>16</td>
<td>0.01503</td>
<td>0.02097</td>
<td>0.01202</td>
<td>0.01583</td>
</tr>
<tr>
<td>32</td>
<td>0.02924</td>
<td>0.03642</td>
<td>0.02563</td>
<td>0.02959</td>
</tr>
<tr>
<td>64</td>
<td>0.05737</td>
<td>0.06473</td>
<td>0.04431</td>
<td>0.05287</td>
</tr>
<tr>
<td>128</td>
<td>0.11098</td>
<td>0.12646</td>
<td>0.08944</td>
<td>0.09926</td>
</tr>
<tr>
<td>256</td>
<td>0.22964</td>
<td>0.24716</td>
<td>0.17402</td>
<td>0.19420</td>
</tr>
<tr>
<td>512</td>
<td>0.43506</td>
<td>0.46444</td>
<td>0.38143</td>
<td>0.38242</td>
</tr>
<tr>
<td>1024</td>
<td>0.97147</td>
<td>0.95803</td>
<td>0.78137</td>
<td>0.87363</td>
</tr>
<tr>
<td>2048</td>
<td>2.07143</td>
<td>2.10766</td>
<td>1.69471</td>
<td>2.99210</td>
</tr>
<tr>
<td>4096</td>
<td>4.85395</td>
<td>4.69722</td>
<td>5.40580</td>
<td>8.73779</td>
</tr>
<tr>
<td>8192</td>
<td>10.76984</td>
<td>11.76741</td>
<td>10.29253</td>
<td>21.00636</td>
</tr>
<tr>
<td>16384</td>
<td>21.84490</td>
<td>26.27385</td>
<td>39.56230</td>
<td>43.55530</td>
</tr>
</tbody>
</table>
# Hardware used in benchmarks
```
Laptop LG Gram 17Z90Q
SSD: 1 TB M.2 NVMe SSD (Samsung PM9A1) – 2x M.2 2280 slots
CPU: 12th Gen Intel(R) Core(TM) i7-1260P
CPU ID: GenuineIntel,6,154,3
CPU Architecture: x86_64
CPUs Online: 16
CPUs Available: 16
CPU Sibling Cores: [0-15]
CPU Sibling Threads: [0-1], [2-3], [4-5], [6-7], [8], [9], [10], [11], [12], [13], [14], [15]
Total Memory: 33.4 GB LPDDR5 5200 MHz
Linux Kernel Version: 6.9.5-1-MANJARO
```
# Usage
There are two ways in which you can use the lib, the first one is a bit faster, the second offers a bit more flexible
way to use it sacrificing a bit of performance.
1. **With a buffer in memory**: using `seal_in_place()`/`open_in_place()`, is useful when you keep a buffer (or have it
from somewhere), set your plaintext/ciphertext in there, and then encrypt/decrypt in-place in that buffer. This is
the most performant way to use it, because it does't copy any bytes nor allocate new memory.
**The buffer has to be a `numpy array`**, so that it's easier for you to collect data with slices that reference to
underlying data. This is because the whole buffer needs to be the size of ciphertext (which is plaintext_len +
tag_len + nonce_len) but you may pass a slice of the buffer to a BufferedReader to `read_into()` the plaintext.
If you can directly collect the data to that buffer, like `BufferedReader.read_into()`, **this is the preffered way
to go**.
2. **From some bytes into the buffer**: using `seal_in_place_from()`/`open_in_place_from()`, when you have some
arbitrary data that you want to work with. It will first copy those bytes to the buffer then do the operation
in-place in the buffer. This is a bit slower, especially for large data, because it first needs to copy the bytes to
the buffer.
`block_index`, `aad` and `nonce` are optional.
If `nonce` is not provided, on each encrypt operation (`seal_in_place*()`) it will generate a cryptographically secure
random nonce using `ChaCha20`. You can also provide your own nonce, there is an example below.
# Security
- **The total number of invocations of the encryption functions (`seal_in_place*()`) shall not exceed `2^32`, including
all nonce lengths and all instances of `Cipher` with the given key. Following this guideline, only `4,294,967,296`
messages with random nonces can be encrypted under a given key. While this bound is high, it's possible to encounter
in practice, and systems which might reach it should consider alternatives to purely random nonces, like a counter or
a combination of a random nonce + counter.**
- **When encrypting more than one block you should provide `block_index` as it's more secure because it ensures the
order of the blocks was not changed in ciphertext.**
- **When you encrypt files it's more secure to generate a random number per file and include that in AAD, this will
prevent ciphertext blocks from being swapped between files.**
- **For security reasons it's a good practice to lock the memory with `mlock()` in which you keep sensitive data like
passwords or encrryption keys, or any other plaintext sensitive content. Also it's important to zeroize the data when
not used anymore.**
- **In the case of [Copy-on-write fork](https://en.wikipedia.org/wiki/Copy-on-write) you need to zeroize the memory
before forking the child process.**
In the examples below you will see how to do it.
# Encryption providers and algorithms (ciphers)
You will notice in the examples we create the `Cipher` from something like
this `cipher_meta = CipherMeta.Ring(RingAlgorithm.Aes256Gcm)`. The first part `CipherMeta.Ring` is the encryption
provider. The last part is the algorithm for that provider, in this case `Aes256Gcm`. Each provier might expose specific
algorithms.
## Providers
```rust
enum CipherMeta {
Ring { alg: RingAlgorithm },
RustCrypto { alg: RustCryptoAlgorithm },
Sodiumoxide { alg: SodiumoxideAlgorithm },
Orion { alg: OrionAlgorithm },
}
```
- `Ring`: Based on [ring](https://crates.io/crates/ring) crate. ring is focused on the implementation, testing, and
optimization of a core set of cryptographic operations exposed via an easy-to-use (and hard-to-misuse) API. ring
exposes a Rust API and is written in a hybrid of Rust, C, and assembly language.
Particular attention is being paid to making it easy to build and integrate ring into applications and higher-level
frameworks, and to ensuring that ring works optimally on small devices, and eventually microcontrollers, to support
Internet of Things (IoT) applications.
Most of the C and assembly language code in ring comes from BoringSSL, and BoringSSL is derived from OpenSSL. ring
merges changes from BoringSSL regularly. Also, several changes that were developed for ring have been contributed to
and integrated into BoringSSL.
- `RustCrypto`: Based on [RustCrypto](https://github.com/RustCrypto/AEADs) collection of Authenticated Encryption with
Associated Data (AEAD) algorithms written in pure Rust. AEADs are high-level symmetric encryption primitives which
defend against a wide range of potential attacks (i.e. IND-CCA3).
- `Sodiumoxide`: Based on [sodiumoxide](https://crates.io/crates/sodiumoxide) crate which aims to provide a type-safe
and efficient Rust binding that's just as easy to use.
[`NaCl`](https://nacl.cr.yp.to) (pronounced "salt") is a new easy-to-use high-speed software library for network
communication, encryption, decryption, signatures, etc. NaCl's goal is to provide all of the core operations needed to
build higher-level cryptographic tools. Of course, other libraries already exist for these core operations. NaCl
advances the state of the art by improving security, by improving usability, and by improving speed.
[Sodium](https://github.com/jedisct1/libsodium) is a portable, cross-compilable, installable, packageable fork of
NaCl (based on the latest released upstream version nacl-20110221), with a compatible API.
- `Orion`: Based on [orion](https://crates.io/crates/orion) crate. Written in pure Rust, it aims to provide easy and
usable crypto while trying to minimize the use of unsafe code. You can read more about Orion in
the [wiki](https://github.com/orion-rs/orion/wiki).
## Algorithms
```rust
enum RingAlgorithm {
ChaCha20Poly1305,
Aes128Gcm,
Aes256Gcm,
}
```
```rust
enum RustCryptoAlgorithm {
ChaCha20Poly1305,
XChaCha20Poly1305,
Aes128Gcm,
Aes256Gcm,
Aes128GcmSiv,
Aes256GcmSiv,
Aes128Siv,
Aes256Siv,
Ascon128,
Ascon128a,
Ascon80pq,
DeoxysI128,
DeoxysI256,
DeoxysII128,
DeoxysII256,
Aes128Eax,
Aes256Eax,
}
```
```rust
enum SodiumoxideAlgorithm {
ChaCha20Poly1305,
ChaCha20Poly1305Ietf,
XChaCha20Poly1305Ietf,
}
```
```rust
enum OrionAlgorithm {
ChaCha20Poly1305,
XChaCha20Poly1305,
}
```
## Audited
**Only for `Aes128Gcm`, `Aes256Gcm` and `ChaCha20Poly1305` with `Ring` and `RustCrypto` providers underlying crates have
been audited.**
- [`Aes128Gcm`/`Aes256Gcm`](https://datatracker.ietf.org/doc/html/rfc5288): If you have hardware acceleration (
e.g. `AES-NI`), then `AES-GCM` provides better performance. If you do not have a hardware acceleration, `AES-GCM` is
either slower than `ChaCha20Poly1305`, or it leaks your encryption keys in cache timing. With `RustCrypto` provider
the underlying `aes-gcm` has received one security audit by NCC Group, with no significant findings. With `Ring`
provider the underlying `ring` crate was also audited.
- [`ChaCha20Poly1305`](https://en.wikipedia.org/wiki/ChaCha20-Poly1305): Is notable for being simple and fast when
implemented in pure software. The underlying `ChaCha20` stream cipher uses a simple combination of `add`, `rotate`,
and `XOR` instructions (a.k.a. `"ARX"`), and the `Poly1305` hash function is likewise extremely simple.
With `RustCrypto` provider the underlying `chacha20poly1305` has received one security audit by NCC Group, with no
significant findings. With `Ring` provider the underlying `ring` crtate was also audited.
If you do not have a hardware acceleration, `ChaCha20Poly1305` is faster than `AES-GCM`.
While it hasn't received approval from certain standards bodies (i.e. NIST) the algorithm is widely used and deployed.
Notably it's mandatory to implement in the Transport Layer Security (TLS) protocol. The underlying `ChaCha20` cipher
is also widely used as a cryptographically secure random number generator, including internal use by the Rust standard
library.
- [`XChaCha20Poly1305`](https://en.wikipedia.org/wiki/ChaCha20-Poly1305#XChaCha20-Poly1305_%E2%80%93_extended_nonce_variant):
A variant of `ChaCha20Poly1305` with an extended 192-bit (24-byte) nonce.
## Not audited
**USE AT YOUR OWN RISK!**
- [`Aes128GcmSiv` / `Aes256GcmSiv`](https://en.wikipedia.org/wiki/AES-GCM-SIV): Provides nonce reuse misuse resistance.
Suitable as a general purpose symmetric encryption cipher, `AES-GCM-SIV` also removes many of the "sharp edges"
of `AES-GCM`, providing significantly better security bounds while simultaneously eliminating the most catastrophic
risks of nonce reuse that exist in `AES-GCM`. Decryption performance is equivalent to `AES-GCM`. Encryption is
marginally slower.
- [`Aes128Siv` / `Aes256Siv`](https://github.com/miscreant/meta/wiki/AES-SIV): Cipher which also provides nonce reuse
misuse resistance.
- [`Ascon128` / `Ascon128a` / `Ascon80pq`](https://ascon.iaik.tugraz.at): Designed to be lightweight and easy to
implement, even with added countermeasures against side-channel attacks. Ascon has been selected as new standard for
lightweight cryptography in the NIST Lightweight Cryptography competition (2019–2023). Ascon has also been selected as
the primary choice for lightweight authenticated encryption in the final portfolio of the CAESAR competition (
2014–2019).
- [`Deoxys`](https://sites.google.com/view/deoxyscipher): Based on a 128-bit lightweight ad-hoc tweakable block cipher.
It may be used in two modes to handle nonce-respecting users (`Deoxys-I`) or nonce-reusing
user (`Deoxys-II`). `Deoxys-II` has been selected as first choice for the "in-depth security" portfolio of
the `CAESAR` competition.
- [`Aes128Eax` / `Aes256Eax`](https://en.wikipedia.org/wiki/EAX_mode): Designed with a two-pass scheme, one pass for
achieving privacy and one for authenticity for each block. `EAX` mode was submitted on October 3, 2003, to the
attention of NIST in order to replace `CCM` as standard `AEAD` mode of operation, since `CCM` mode lacks some
desirable attributes of `EAX` and is more complex.
- For `Sodiumoxide`
provider [`ChaCha20Poly1305`](https://libsodium.gitbook.io/doc/secret-key_cryptography/aead/chacha20-poly1305/original_chacha20-poly1305_construction):
The original `ChaCha20-Poly1305` construction can safely encrypt a pratically unlimited number of messages with the
same key, without any practical limit to the size of a message (up to ~ 2^64 bytes).
- For `Sodiumoxide`
provider [`ChaChaCha20Poly1305Ietf`](https://libsodium.gitbook.io/doc/secret-key_cryptography/aead/chacha20-poly1305/ietf_chacha20-poly1305_construction):
The IETF variant of the `ChaCha20-Poly1305` construction can safely encrypt a practically unlimited number of
messages, but individual messages cannot exceed 64*(2^32)-64 bytes (approximatively 256 GB).
# Examples
You can see more in [examples](https://github.com/radumarias/rencrypt-python/tree/main/examples) directory and
in [bench.py](https://github.com/radumarias/rencrypt-python/tree/main/bench.py) which has some benchmarks. Here are few
simple examples:
## Encrypt and decrypt with a buffer in memory
`seal_in_place()`/`open_in_place()`
This is the most performant way to use it as it will not copy bytes to the buffer nor allocate new memory for plaintext
and ciphertext.
```python
from rencrypt import Cipher, CipherMeta, RingAlgorithm
import os
from zeroize import zeroize1, mlock, munlock
import numpy as np
import platform
def setup_memory_limit():
if not platform.system() == "Windows":
return
import ctypes
from ctypes import wintypes
# Define the Windows API functions
kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
GetCurrentProcess = kernel32.GetCurrentProcess
GetCurrentProcess.restype = wintypes.HANDLE
SetProcessWorkingSetSize = kernel32.SetProcessWorkingSetSize
SetProcessWorkingSetSize.restype = wintypes.BOOL
SetProcessWorkingSetSize.argtypes = [wintypes.HANDLE, ctypes.c_size_t, ctypes.c_size_t]
# Get the handle of the current process
current_process = GetCurrentProcess()
# Set the working set size
min_size = 6 * 1024 * 1024 # Minimum working set size
max_size = 10 * 1024 * 1024 # Maximum working set size
result = SetProcessWorkingSetSize(current_process, min_size, max_size)
if not result:
error_code = ctypes.get_last_error()
error_message = ctypes.FormatError(error_code)
raise RuntimeError(f"SetProcessWorkingSetSize failed with error code {error_code}: {error_message}")
if __name__ == "__main__":
try:
setup_memory_limit()
# You can use also other algorithms like cipher_meta = CipherMeta.Ring(RingAlgorithm.ChaCha20Poly1305)`.
cipher_meta = CipherMeta.Ring(RingAlgorithm.Aes256Gcm)
key_len = cipher_meta.key_len()
key = bytearray(key_len)
# for security reasons we lock the memory of the key so it won't be swapped to disk
mlock(key)
cipher_meta.generate_key(key)
# The key is copied and the input key is zeroized for security reasons.
# The copied key will also be zeroized when the object is dropped.
cipher = Cipher(cipher_meta, key)
# it was zeroized we can unlock it
munlock(key)
# we create a buffer based on plaintext block len of 4096
# the actual buffer needs to be a bit larger as the ciphertext also includes the tag and nonce
plaintext_len = 4096
ciphertext_len = cipher_meta.ciphertext_len(plaintext_len)
buf = np.array([0] * ciphertext_len, dtype=np.uint8)
# for security reasons we lock the memory of the buffer so it won't be swapped to disk, because it contains plaintext after decryption
mlock(buf)
aad = b"AAD"
# put some plaintext in the buffer, it would be ideal if you can directly collect the data into the buffer without allocating new memory
# but for the sake of example we will allocate and copy the data
plaintext = bytearray(os.urandom(plaintext_len))
# for security reasons we lock the memory of the plaintext so it won't be swapped to disk
mlock(plaintext)
# cipher.copy_slice is slighlty faster than buf[:plaintext_len] = plaintext, especially for large plaintext, because it copies the data in parallel
# cipher.copy_slice takes bytes as input, cipher.copy_slice1 takes bytearray
cipher.copy_slice(plaintext, buf)
# encrypt it, this will encrypt in-place the data in the buffer
print("encrypting...")
ciphertext_len = cipher.seal_in_place(buf, plaintext_len, 42, aad)
cipertext = buf[:ciphertext_len]
# you can do something with the ciphertext
# decrypt it
# if you need to copy ciphertext to buffer, we don't need to do it now as it's already in the buffer
# cipher.copy_slice(ciphertext, buf[:len(ciphertext)])
print("decrypting...")
plaintext_len = cipher.open_in_place(buf, ciphertext_len, 42, aad)
plaintext2 = buf[:plaintext_len]
# for security reasons we lock the memory of the plaintext so it won't be swapped to disk
mlock(plaintext2)
assert plaintext == plaintext2
finally:
# best practice, you should always zeroize the plaintext and keys after you are done with it (key will be zeroized when the enc object is dropped)
zeroize1(plaintext)
zeroize1(buf)
munlock(buf)
munlock(plaintext)
print("bye!")
```
You can use other ciphers like `cipher_meta = CipherMeta.Ring(RingAlgorithm.ChaCha20Poly1305)`.
You can also provide your own nonce that you can generate based on your contraints.
```python
from rencrypt import Cipher, CipherMeta, RingAlgorithm
import os
from zeroize import zeroize1, mlock, munlock
import numpy as np
import platform
def setup_memory_limit():
if not platform.system() == "Windows":
return
import ctypes
from ctypes import wintypes
# Define the Windows API functions
kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
GetCurrentProcess = kernel32.GetCurrentProcess
GetCurrentProcess.restype = wintypes.HANDLE
SetProcessWorkingSetSize = kernel32.SetProcessWorkingSetSize
SetProcessWorkingSetSize.restype = wintypes.BOOL
SetProcessWorkingSetSize.argtypes = [wintypes.HANDLE, ctypes.c_size_t, ctypes.c_size_t]
# Get the handle of the current process
current_process = GetCurrentProcess()
# Set the working set size
min_size = 6 * 1024 * 1024 # Minimum working set size
max_size = 10 * 1024 * 1024 # Maximum working set size
result = SetProcessWorkingSetSize(current_process, min_size, max_size)
if not result:
error_code = ctypes.get_last_error()
error_message = ctypes.FormatError(error_code)
raise RuntimeError(f"SetProcessWorkingSetSize failed with error code {error_code}: {error_message}")
if __name__ == "__main__":
try:
setup_memory_limit()
# You can use also other algorithms like cipher_meta = CipherMeta.Ring(RingAlgorithm.ChaCha20Poly1305)`.
cipher_meta = CipherMeta.Ring(RingAlgorithm.Aes256Gcm)
key_len = cipher_meta.key_len()
key = bytearray(key_len)
# for security reasons we lock the memory of the key so it won't be swapped to disk
mlock(key)
cipher_meta.generate_key(key)
# The key is copied and the input key is zeroized for security reasons.
# The copied key will also be zeroized when the object is dropped.
cipher = Cipher(cipher_meta, key)
# it was zeroized we can unlock it
munlock(key)
# we create a buffer based on plaintext block len of 4096
# the actual buffer needs to be a bit larger as the ciphertext also includes the tag and nonce
plaintext_len = 4096
ciphertext_len = cipher_meta.ciphertext_len(plaintext_len)
buf = np.array([0] * ciphertext_len, dtype=np.uint8)
# for security reasons we lock the memory of the buffer so it won't be swapped to disk, because it contains plaintext after decryption
mlock(buf)
aad = b"AAD"
# create our own nonce
nonce = os.urandom(cipher_meta.nonce_len())
# put some plaintext in the buffer, it would be ideal if you can directly collect the data into the buffer without allocating new memory
# but for the sake of example we will allocate and copy the data
plaintext = bytearray(os.urandom(plaintext_len))
# for security reasons we lock the memory of the plaintext so it won't be swapped to disk
mlock(plaintext)
# cipher.copy_slice is slighlty faster than buf[:plaintext_len] = plaintext, especially for large plaintext, because it copies the data in parallel
# cipher.copy_slice takes bytes as input, cipher.copy_slice1 takes bytearray
cipher.copy_slice(plaintext, buf)
# encrypt it, this will encrypt in-place the data in the buffer
print("encrypting...")
ciphertext_len = cipher.seal_in_place(buf, plaintext_len, 42, aad, nonce)
cipertext = buf[:ciphertext_len]
# you can do something with the ciphertext
# decrypt it
# if you need to copy ciphertext to buffer, we don't need to do it now as it's already in the buffer
# cipher.copy_slice(ciphertext, buf[:len(ciphertext)])
print("decrypting...")
plaintext_len = cipher.open_in_place(buf, ciphertext_len, 42, aad, nonce)
plaintext2 = buf[:plaintext_len]
# for security reasons we lock the memory of the plaintext so it won't be swapped to disk
mlock(plaintext2)
assert plaintext == plaintext2
finally:
# best practice, you should always zeroize the plaintext and keys after you are done with it (key will be zeroized when the enc object is dropped)
zeroize1(plaintext)
zeroize1(buf)
munlock(buf)
munlock(plaintext)
print("bye!")
```
## Encrypt and decrypt a file
```python
import errno
import io
import os
from pathlib import Path
import shutil
from rencrypt import Cipher, CipherMeta, RingAlgorithm
import hashlib
from zeroize import zeroize1, mlock, munlock
import numpy as np
import platform
def setup_memory_limit():
if not platform.system() == "Windows":
return
import ctypes
from ctypes import wintypes
# Define the Windows API functions
kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
GetCurrentProcess = kernel32.GetCurrentProcess
GetCurrentProcess.restype = wintypes.HANDLE
SetProcessWorkingSetSize = kernel32.SetProcessWorkingSetSize
SetProcessWorkingSetSize.restype = wintypes.BOOL
SetProcessWorkingSetSize.argtypes = [wintypes.HANDLE, ctypes.c_size_t, ctypes.c_size_t]
# Get the handle of the current process
current_process = GetCurrentProcess()
# Set the working set size
min_size = 6 * 1024 * 1024 # Minimum working set size
max_size = 10 * 1024 * 1024 # Maximum working set size
result = SetProcessWorkingSetSize(current_process, min_size, max_size)
if not result:
error_code = ctypes.get_last_error()
error_message = ctypes.FormatError(error_code)
raise RuntimeError(f"SetProcessWorkingSetSize failed with error code {error_code}: {error_message}")
def read_file_in_chunks(file_path, buf):
with open(file_path, "rb") as file:
buffered_reader = io.BufferedReader(file, buffer_size=len(buf))
while True:
read = buffered_reader.readinto(buf)
if read == 0:
break
yield read
def hash_file(file_path):
hash_algo = hashlib.sha256()
with open(file_path, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
hash_algo.update(chunk)
return hash_algo.hexdigest()
def compare_files_by_hash(file1, file2):
return hash_file(file1) == hash_file(file2)
def silentremove(filename):
try:
os.remove(filename)
except OSError as e: # this would be "except OSError, e:" before Python 2.6
if e.errno != errno.ENOENT: # errno.ENOENT = no such file or directory
raise # re-raise exception if a different error occurred
def create_directory_in_home(dir_name):
# Get the user's home directory
home_dir = Path.home()
# Create the full path for the new directory
new_dir_path = home_dir / dir_name
# Create the directory
try:
new_dir_path.mkdir(parents=True, exist_ok=True)
except Exception as e:
print(f"Error creating directory: {e}")
return new_dir_path.absolute().__str__()
def create_file_with_size(file_path_str, size_in_bytes):
with open(file_path_str, "wb") as f:
for _ in range((size_in_bytes // 4096) + 1):
f.write(os.urandom(min(4096, size_in_bytes)))
f.flush()
def delete_dir(path):
if os.path.exists(path):
shutil.rmtree(path)
else:
print(f"Directory {path} does not exist.")
if __name__ == "__main__":
try:
setup_memory_limit()
tmp_dir = create_directory_in_home("rencrypt_tmp")
fin = tmp_dir + "/" + "fin"
fout = tmp_dir + "/" + "fout.enc"
create_file_with_size(fin, 1 * 1024 * 1024)
chunk_len = 256 * 1024
# You can use also other algorithms like cipher_meta = CipherMeta.Ring(RingAlgorithm.ChaCha20Poly1305)`.
cipher_meta = CipherMeta.Ring(RingAlgorithm.Aes256Gcm)
key_len = cipher_meta.key_len()
key = bytearray(key_len)
# for security reasons we lock the memory of the key so it won't be swapped to disk
mlock(key)
cipher_meta.generate_key(key)
# The key is copied and the input key is zeroized for security reasons.
# The copied key will also be zeroized when the object is dropped.
cipher = Cipher(cipher_meta, key)
# it was zeroized we can unlock it
munlock(key)
plaintext_len = chunk_len
ciphertext_len = cipher_meta.ciphertext_len(plaintext_len)
buf = np.array([0] * ciphertext_len, dtype=np.uint8)
mlock(buf)
# use some random per file in additional authenticated data to prevent blocks from being swapped between files
aad = os.urandom(16)
# encrypt
print("encrypting...")
with open(fout, "wb", buffering=plaintext_len) as file_out:
i = 0
for read in read_file_in_chunks(fin, buf[:plaintext_len]):
ciphertext_len = cipher.seal_in_place(buf, read, i, aad)
file_out.write(buf[:ciphertext_len])
i += 1
file_out.flush()
# decrypt
print("decrypting...")
tmp = fout + ".dec"
with open(tmp, "wb", buffering=plaintext_len) as file_out:
i = 0
for read in read_file_in_chunks(fout, buf):
plaintext_len2 = cipher.open_in_place(buf, read, i, aad)
file_out.write(buf[:plaintext_len2])
i += 1
file_out.flush()
assert compare_files_by_hash(fin, tmp)
delete_dir(tmp_dir)
finally:
# best practice, you should always zeroize the plaintext and keys after you are done with it (key will be zeroized when the enc object is dropped)
# buf will containt the last block plaintext so we need to zeroize it
zeroize1(buf)
munlock(buf)
print("bye!")
```
## Encrypt and decrypt from some bytes into the buffer
`encrypt_from()`/`decrypt_from()`
This is a bit slower than handling data only via the buffer, especially for large plaintext, but there are situations
when you can't directly collect the data to the buffer but have some data from somewhere else.
```python
from rencrypt import Cipher, CipherMeta, RingAlgorithm
import os
from zeroize import zeroize1, mlock, munlock
import numpy as np
import platform
def setup_memory_limit():
if not platform.system() == "Windows":
return
import ctypes
from ctypes import wintypes
# Define the Windows API functions
kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
GetCurrentProcess = kernel32.GetCurrentProcess
GetCurrentProcess.restype = wintypes.HANDLE
SetProcessWorkingSetSize = kernel32.SetProcessWorkingSetSize
SetProcessWorkingSetSize.restype = wintypes.BOOL
SetProcessWorkingSetSize.argtypes = [wintypes.HANDLE, ctypes.c_size_t, ctypes.c_size_t]
# Get the handle of the current process
current_process = GetCurrentProcess()
# Set the working set size
min_size = 6 * 1024 * 1024 # Minimum working set size
max_size = 10 * 1024 * 1024 # Maximum working set size
result = SetProcessWorkingSetSize(current_process, min_size, max_size)
if not result:
error_code = ctypes.get_last_error()
error_message = ctypes.FormatError(error_code)
raise RuntimeError(f"SetProcessWorkingSetSize failed with error code {error_code}: {error_message}")
if __name__ == "__main__":
try:
setup_memory_limit()
# You can use also other algorithms like cipher_meta = CipherMeta.Ring(RingAlgorithm.ChaCha20Poly1305)`.
cipher_meta = CipherMeta.Ring(RingAlgorithm.Aes256Gcm)
key_len = cipher_meta.key_len()
key = bytearray(key_len)
# for security reasons we lock the memory of the key so it won't be swapped to disk
mlock(key)
cipher_meta.generate_key(key)
# The key is copied and the input key is zeroized for security reasons.
# The copied key will also be zeroized when the object is dropped.
cipher = Cipher(cipher_meta, key)
# it was zeroized we can unlock it
munlock(key)
# we create a buffer based on plaintext block len of 4096
# the actual buffer needs to be a bit larger as the ciphertext also includes the tag and nonce
plaintext_len = 4096
ciphertext_len = cipher_meta.ciphertext_len(plaintext_len)
buf = np.array([0] * ciphertext_len, dtype=np.uint8)
# for security reasons we lock the memory of the buffer so it won't be swapped to disk, because it contains plaintext after decryption
mlock(buf)
aad = b"AAD"
plaintext = bytearray(os.urandom(plaintext_len))
# for security reasons we lock the memory of the plaintext so it won't be swapped to disk
mlock(plaintext)
# encrypt it, after this will have the ciphertext in the buffer
print("encrypting...")
ciphertext_len = cipher.seal_in_place_from(plaintext, buf, 42, aad)
cipertext = bytes(buf[:ciphertext_len])
# decrypt it
print("decrypting...")
plaintext_len = cipher.open_in_place_from(cipertext, buf, 42, aad)
plaintext2 = buf[:plaintext_len]
# for security reasons we lock the memory of the plaintext so it won't be swapped to disk
mlock(plaintext2)
assert plaintext == plaintext2
finally:
# best practice, you should always zeroize the plaintext and keys after you are done with it (key will be zeroized when the enc object is dropped)
zeroize1(plaintext)
zeroize1(buf)
munlock(buf)
munlock(plaintext)
print("bye!")
```
## Zeroing memory before forking child process
This mitigates the problems that appears on [Copy-on-write fork](https://en.wikipedia.org/wiki/Copy-on-write). You need
to zeroize the data before forking the child process.
```python
import os
from zeroize import zeroize1, mlock, munlock
if __name__ == "__main__":
try:
# Maximum you can mlock is 4MB
sensitive_data = bytearray(b"Sensitive Information")
mlock(sensitive_data)
print("Before zeroization:", sensitive_data)
zeroize1(sensitive_data)
print("After zeroization:", sensitive_data)
# Forking after zeroization to ensure no sensitive data is copied
pid = os.fork()
if pid == 0:
# This is the child process
print("Child process memory after fork:", sensitive_data)
else:
# This is the parent process
os.wait() # Wait for the child process to exit
print("all good, bye!")
finally:
# Unlock the memory
print("unlocking memory")
munlock(sensitive_data)
```
# Build from source
## Browser
[](https://gitpod.io/#https://github.com/radumarias/rencrypt-python)
[](https://github.com/codespaces/new/?repo=radumarias%2Frencrypt-python&ref=main)
## Geting sources from GitHub
Skip this if you're starting it in browser.
```bash
git clone https://github.com/radumarias/rencrypt-python && cd Cipher-python
```
## Compile and run
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
To configure your current shell, you need to source
the corresponding env file under $HOME/.cargo.
This is usually done by running one of the following (note the leading DOT):
```bash
. "$HOME/.cargo/env"
```
```bash
python -m venv .env
source .env/bin/activate
pip install -r requirements.txt
maturin develop --release
pytest
python examples/encrypt.py
python examples/encrypt_into.py
python examples/encrypt_from.py
python examples/encrypt_file.py
python benches/bench.py
```
# More benchmarks
## Different ways to use the lib
**Encrypt**
**Decrypt**
**Block size and duration in seconds**
<table>
<thead>
<tr>
<td>MB</td>
<td>rencrypt<br>encrypt</td>
<td>PyFLocker<br>encrypt update_into</td>
<td>rencrypt<br>encrypt_from</td>
<td>PyFLocker<br>encrypt update</td>
<td>rencrypt<br>decrypt</td>
<td>PyFLocker<br>decrypt update_into</td>
<td>rencrypt<br>decrypt_from</td>
<td>
<div>
<div>PyFLocker<br>decrypt update</div>
</div>
</td>
</tr>
</thead>
<tbody>
<tr>
<td>0.03125</td>
<td>0.00001</td>
<td>0.00091</td>
<td>0.00001</td>
<td>0.00009</td>
<td>0.00001</td>
<td>0.00004</td>
<td>0.00001</td>
<td>0.00005</td>
</tr>
<tr>
<td>0.0625</td>
<td>0.00001</td>
<td>0.00005</td>
<td>0.00002</td>
<td>0.00005</td>
<td>0.00001</td>
<td>0.00004</td>
<td>0.00002</td>
<td>0.00008</td>
</tr>
<tr>
<td>0.125</td>
<td>0.00002</td>
<td>0.00005</td>
<td>0.00003</td>
<td>0.00011</td>
<td>0.00003</td>
<td>0.00005</td>
<td>0.00003</td>
<td>0.00013</td>
</tr>
<tr>
<td>0.25</td>
<td>0.00004</td>
<td>0.00008</td>
<td>0.00007</td>
<td>0.00019</td>
<td>0.00005</td>
<td>0.00009</td>
<td>0.00007</td>
<td>0.00023</td>
</tr>
<tr>
<td>0.5</td>
<td>0.0001</td>
<td>0.00014</td>
<td>0.00015</td>
<td>0.00035</td>
<td>0.00011</td>
<td>0.00015</td>
<td>0.00014</td>
<td>0.00043</td>
</tr>
<tr>
<td>1</td>
<td>0.00021</td>
<td>0.00024</td>
<td>0.0008</td>
<td>0.00082</td>
<td>0.00021</td>
<td>0.00029</td>
<td>0.00044</td>
<td>0.00103</td>
</tr>
<tr>
<td>2</td>
<td>0.00043</td>
<td>0.00052</td>
<td>0.00082</td>
<td>0.00147</td>
<td>0.00044</td>
<td>0.00058</td>
<td>0.00089</td>
<td>0.00176</td>
</tr>
<tr>
<td>4</td>
<td>0.00089</td>
<td>0.00098</td>
<td>0.00174</td>
<td>0.00284</td>
<td>0.00089</td>
<td>0.00117</td>
<td>0.0013</td>
<td>0.0034</td>
</tr>
<tr>
<td>8</td>
<td>0.00184</td>
<td>0.0019</td>
<td>0.00263</td>
<td>0.00523</td>
<td>0.00192</td>
<td>0.00323</td>
<td>0.00283</td>
<td>0.00571</td>
</tr>
<tr>
<td>16</td>
<td>0.00353</td>
<td>0.00393</td>
<td>0.00476</td>
<td>0.0141</td>
<td>0.00367</td>
<td>0.00617</td>
<td>0.00509</td>
<td>0.01031</td>
</tr>
<tr>
<td>32</td>
<td>0.00678</td>
<td>0.00748</td>
<td>0.00904</td>
<td>0.0244</td>
<td>0.00749</td>
<td>0.01348</td>
<td>0.01014</td>
<td>0.02543</td>
</tr>
<tr>
<td>64</td>
<td>0.01361</td>
<td>0.01461</td>
<td>0.01595</td>
<td>0.05064</td>
<td>0.0146</td>
<td>0.02697</td>
<td>0.0192</td>
<td>0.05296</td>
</tr>
<tr>
<td>128</td>
<td>0.02923</td>
<td>0.03027</td>
<td>0.03343</td>
<td>0.10362</td>
<td>0.03134</td>
<td>0.0541</td>
<td>0.03558</td>
<td>0.1138</td>
</tr>
<tr>
<td>256</td>
<td>0.06348</td>
<td>0.06188</td>
<td>0.07303</td>
<td>0.20911</td>
<td>0.06136</td>
<td>0.10417</td>
<td>0.07572</td>
<td>0.20828</td>
</tr>
<tr>
<td>512</td>
<td>0.11782</td>
<td>0.13463</td>
<td>0.14283</td>
<td>0.41929</td>
<td>0.1209</td>
<td>0.21114</td>
<td>0.14434</td>
<td>0.41463</td>
</tr>
<tr>
<td>1024</td>
<td>0.25001</td>
<td>0.24953</td>
<td>0.28912</td>
<td>0.8237</td>
<td>0.25377</td>
<td>0.42581</td>
<td>0.29795</td>
<td>0.82588</td>
</tr>
</tbody>
</table>
## Speed throughput
`256KB` seems to be the sweet spot for buffer size that offers the max `MB/s` speed for encryption, on benchmarks that
seem to be the case.
We performed `10.000` encryption operations for each size varying from `1KB` to `16MB`.
| MB | MB/s |
|----------------------------------------------------------|----------------------------------------------------------|
| 0.0009765625 | 1083 |
| 0.001953125 | 1580 |
| 0.00390625 | 2158 |
| 0.0078125 | 2873 |
| 0.015625 | 3348 |
| 0.03125 | 3731 |
| 0.0625 | 4053 |
| 0.125 | 4156 |
| <span style="color: red; font-weight: bold;">0.25</span> | <span style="color: red; font-weight: bold;">4247</span> |
| 0.5 | 4182 |
| 1.0 | 3490 |
| 2.0 | 3539 |
| 4.0 | 3684 |
| 8.0 | 3787 |
| 16.0 | 3924 |
# For the future
- Generating key from password (`KDF`)
- Maybe add support for `RSA` and `Elliptic-curve cryptography`
- Saving and loading keys from file
# Considerations
This lib hasn't been audited, but it wraps `ring` crate (well known and audited library) and `RustCrypto` (`AES-GCM`
and `ChaCha20Poly1305` ciphers are audited), so in principle at least the primitives should offer a similar level of
security.
# Contribute
Feel free to fork it, change and use it in any way that you want.
If you build something interesting and feel like sharing pull requests are always appreciated.
## How to contribute
Please see [CONTRIBUTING.md](CONTRIBUTING.md).
Raw data
{
"_id": null,
"home_page": "https://radumarias.github.io/rencrypt-python",
"name": "rencrypt",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.7",
"maintainer_email": null,
"keywords": "cryptography, encryption, security, rust, speed, aead, cipher",
"author": "Radu Marias <radumarias@gmail.com>",
"author_email": "Radu Marias <radumarias@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/4f/24/91f4932479cdb8141a2eda56423b2f054a9d62567355e7a63271c373a676/rencrypt-1.2.2.tar.gz",
"platform": null,
"description": "# rencrypt\n\n[](https://badge.fury.io/py/rencrypt)\n[](https://github.com/radumarias/rencrypt-python/actions/workflows/CI.yml)\n\n> [!WARNING]\n> **This crate hasn't been audited, but it's mostly a wrapper over several libs like `ring` (well known and audited\nlibrary),`RustCrypto` (`AES-GCM` and `ChaCha20Poly1305` ciphers are audited) but also others which are NOT audited, so\nin principle at least the primitives should offer a similar level of security.**\n\nA Python encryption library implemented in Rust. It supports `AEAD` with varius ciphers. It\nuses [ring](https://crates.io/crates/ring), [RustCrypto](https://crates.io/crates/aead) (and\nderivates), [sodiumoxide](https://crates.io/crates/sodiumoxide) and [orion](https://crates.io/crates/orion) to handle\nencryption.\nIf offers slightly higher speed compared to other Python libs, especially for small chunks of data (especially\nthe `Ring` provider with `AES-GCM` ciphers). The API also tries to be easy to use but it's more optimized for speed than\nusability.\n\nSo if you want to use a vast variaety of ciphers and/or achieve the highest possible encryption speed, consider giving\nit a try.\n\n# Benchmark\n\nSome benchmarks comparing it to [PyFLocker](https://github.com/arunanshub/pyflocker) which from my benchmarks is the\nfastest among other Python libs like `cryptography`, `NaCl` (`libsodium`), `PyCryptodome`.\n\n## Buffer in memory\n\nThis is useful when you keep a buffer, set your plaintext/ciphertext in there, and then encrypt/decrypt in-place in that\nbuffer. This is the most performant way to use it, because it does't copy any bytes nor allocate new memory.\n`rencrypt` is faster on small buffers, less than few MB, `PyFLocker` is comming closer for larger buffers.\n\n**Encrypt seconds**\n\n\n**Decrypt seconds**\n\n\n**Block size and duration in seconds**\n\n<table>\n <thead>\n <tr>\n <th>MB</th>\n <th>rencrypt<br>encrypt</th>\n <th>PyFLocker<br>encrypt</th>\n <th>rencrypt<br>decrypt</th>\n <th>PyFLocker<br>decrypt</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <td>0.03125</td>\n <td>0.00001</td>\n <td>0.00091</td>\n <td>0.00001</td>\n <td>0.00004</td>\n </tr>\n <tr>\n <td>0.0625</td>\n <td>0.00001</td>\n <td>0.00005</td>\n <td>0.00001</td>\n <td>0.00004</td>\n </tr>\n <tr>\n <td>0.125</td>\n <td>0.00002</td>\n <td>0.00005</td>\n <td>0.00003</td>\n <td>0.00005</td>\n </tr>\n <tr>\n <td>0.25</td>\n <td>0.00004</td>\n <td>0.00008</td>\n <td>0.00005</td>\n <td>0.00009</td>\n </tr>\n <tr>\n <td>0.5</td>\n <td>0.00010</td>\n <td>0.00014</td>\n <td>0.00011</td>\n <td>0.00015</td>\n </tr>\n <tr>\n <td>1</td>\n <td>0.00021</td>\n <td>0.00024</td>\n <td>0.00021</td>\n <td>0.00029</td>\n </tr>\n <tr>\n <td>2</td>\n <td>0.00043</td>\n <td>0.00052</td>\n <td>0.00044</td>\n <td>0.00058</td>\n </tr>\n <tr>\n <td>4</td>\n <td>0.00089</td>\n <td>0.00098</td>\n <td>0.00089</td>\n <td>0.00117</td>\n </tr>\n <tr>\n <td>8</td>\n <td>0.00184</td>\n <td>0.00190</td>\n <td>0.00192</td>\n <td>0.00323</td>\n </tr>\n <tr>\n <td>16</td>\n <td>0.00353</td>\n <td>0.00393</td>\n <td>0.00367</td>\n <td>0.00617</td>\n </tr>\n <tr>\n <td>32</td>\n <td>0.00678</td>\n <td>0.00748</td>\n <td>0.00749</td>\n <td>0.01348</td>\n </tr>\n <tr>\n <td>64</td>\n <td>0.01361</td>\n <td>0.01461</td>\n <td>0.01460</td>\n <td>0.02697</td>\n </tr>\n <tr>\n <td>128</td>\n <td>0.02923</td>\n <td>0.03027</td>\n <td>0.03134</td>\n <td>0.05410</td>\n </tr>\n <tr>\n <td>256</td>\n <td>0.06348</td>\n <td>0.06188</td>\n <td>0.06136</td>\n <td>0.10417</td>\n </tr>\n <tr>\n <td>512</td>\n <td>0.11782</td>\n <td>0.13463</td>\n <td>0.12090</td>\n <td>0.21114</td>\n </tr>\n <tr>\n <td>1024</td>\n <td>0.25001</td>\n <td>0.24953</td>\n <td>0.25377</td>\n <td>0.42581</td>\n </tr>\n </tbody>\n</table>\n\n## File\n\n**Encrypt seconds**\n\n\n**Decrypt seconds**\n\n\n**File size and duration in seconds**\n\n<table>\n <thead>\n <tr>\n <th>MB</th>\n <th>rencrypt<br>encrypt</th>\n <th>PyFLocker<br>encrypt</th>\n <th>rencrypt<br>decrypt</th>\n <th>PyFLocker<br>decrypt</th>\n </tr>\n </tr>\n </thead>\n <tbody>\n <tr>\n <td>0.031251</td>\n <td>0.00010</td>\n <td>0.00280</td>\n <td>0.00004</td>\n <td>0.00479</td>\n </tr>\n <tr>\n <td>0.062501</td>\n <td>0.00009</td>\n <td>0.00218</td>\n <td>0.00005</td>\n <td>0.00143</td>\n </tr>\n <tr>\n <td>0.125</td>\n <td>0.00020</td>\n <td>0.00212</td>\n <td>0.00014</td>\n <td>0.00129</td>\n </tr>\n <tr>\n <td>0.25</td>\n <td>0.00034</td>\n <td>0.00232</td>\n <td>0.00020</td>\n <td>0.00165</td>\n </tr>\n <tr>\n <td>0.5</td>\n <td>0.00050</td>\n <td>0.00232</td>\n <td>0.00035</td>\n <td>0.00181</td>\n </tr>\n <tr>\n <td>1</td>\n <td>0.00087</td>\n <td>0.00356</td>\n <td>0.00065</td>\n <td>0.00248</td>\n </tr>\n <tr>\n <td>2</td>\n <td>0.00215</td>\n <td>0.00484</td>\n <td>0.00154</td>\n <td>0.00363</td>\n </tr>\n <tr>\n <td>4</td>\n <td>0.00361</td>\n <td>0.00765</td>\n <td>0.00301</td>\n <td>0.00736</td>\n </tr>\n <tr>\n <td>8</td>\n <td>0.00688</td>\n <td>0.01190</td>\n <td>0.00621</td>\n <td>0.00876</td>\n </tr>\n <tr>\n <td>16</td>\n <td>0.01503</td>\n <td>0.02097</td>\n <td>0.01202</td>\n <td>0.01583</td>\n </tr>\n <tr>\n <td>32</td>\n <td>0.02924</td>\n <td>0.03642</td>\n <td>0.02563</td>\n <td>0.02959</td>\n </tr>\n <tr>\n <td>64</td>\n <td>0.05737</td>\n <td>0.06473</td>\n <td>0.04431</td>\n <td>0.05287</td>\n </tr>\n <tr>\n <td>128</td>\n <td>0.11098</td>\n <td>0.12646</td>\n <td>0.08944</td>\n <td>0.09926</td>\n </tr>\n <tr>\n <td>256</td>\n <td>0.22964</td>\n <td>0.24716</td>\n <td>0.17402</td>\n <td>0.19420</td>\n </tr>\n <tr>\n <td>512</td>\n <td>0.43506</td>\n <td>0.46444</td>\n <td>0.38143</td>\n <td>0.38242</td>\n </tr>\n <tr>\n <td>1024</td>\n <td>0.97147</td>\n <td>0.95803</td>\n <td>0.78137</td>\n <td>0.87363</td>\n </tr>\n <tr>\n <td>2048</td>\n <td>2.07143</td>\n <td>2.10766</td>\n <td>1.69471</td>\n <td>2.99210</td>\n </tr>\n <tr>\n <td>4096</td>\n <td>4.85395</td>\n <td>4.69722</td>\n <td>5.40580</td>\n <td>8.73779</td>\n </tr>\n <tr>\n <td>8192</td>\n <td>10.76984</td>\n <td>11.76741</td>\n <td>10.29253</td>\n <td>21.00636</td>\n </tr>\n <tr>\n <td>16384</td>\n <td>21.84490</td>\n <td>26.27385</td>\n <td>39.56230</td>\n <td>43.55530</td>\n </tr>\n </tbody>\n</table>\n\n# Hardware used in benchmarks\n\n```\nLaptop LG Gram 17Z90Q\nSSD: 1 TB M.2 NVMe SSD (Samsung PM9A1) \u2013 2x M.2 2280 slots\nCPU: 12th Gen Intel(R) Core(TM) i7-1260P\nCPU ID: GenuineIntel,6,154,3\nCPU Architecture: x86_64\nCPUs Online: 16\nCPUs Available: 16\nCPU Sibling Cores: [0-15]\nCPU Sibling Threads: [0-1], [2-3], [4-5], [6-7], [8], [9], [10], [11], [12], [13], [14], [15]\nTotal Memory: 33.4 GB LPDDR5 5200 MHz\nLinux Kernel Version: 6.9.5-1-MANJARO\n```\n\n# Usage\n\nThere are two ways in which you can use the lib, the first one is a bit faster, the second offers a bit more flexible\nway to use it sacrificing a bit of performance.\n\n1. **With a buffer in memory**: using `seal_in_place()`/`open_in_place()`, is useful when you keep a buffer (or have it\n from somewhere), set your plaintext/ciphertext in there, and then encrypt/decrypt in-place in that buffer. This is\n the most performant way to use it, because it does't copy any bytes nor allocate new memory.\n **The buffer has to be a `numpy array`**, so that it's easier for you to collect data with slices that reference to\n underlying data. This is because the whole buffer needs to be the size of ciphertext (which is plaintext_len +\n tag_len + nonce_len) but you may pass a slice of the buffer to a BufferedReader to `read_into()` the plaintext.\n If you can directly collect the data to that buffer, like `BufferedReader.read_into()`, **this is the preffered way\n to go**.\n2. **From some bytes into the buffer**: using `seal_in_place_from()`/`open_in_place_from()`, when you have some\n arbitrary data that you want to work with. It will first copy those bytes to the buffer then do the operation\n in-place in the buffer. This is a bit slower, especially for large data, because it first needs to copy the bytes to\n the buffer.\n\n`block_index`, `aad` and `nonce` are optional.\n\nIf `nonce` is not provided, on each encrypt operation (`seal_in_place*()`) it will generate a cryptographically secure\nrandom nonce using `ChaCha20`. You can also provide your own nonce, there is an example below.\n\n# Security\n\n- **The total number of invocations of the encryption functions (`seal_in_place*()`) shall not exceed `2^32`, including\n all nonce lengths and all instances of `Cipher` with the given key. Following this guideline, only `4,294,967,296`\n messages with random nonces can be encrypted under a given key. While this bound is high, it's possible to encounter\n in practice, and systems which might reach it should consider alternatives to purely random nonces, like a counter or\n a combination of a random nonce + counter.**\n- **When encrypting more than one block you should provide `block_index` as it's more secure because it ensures the\n order of the blocks was not changed in ciphertext.**\n- **When you encrypt files it's more secure to generate a random number per file and include that in AAD, this will\n prevent ciphertext blocks from being swapped between files.**\n- **For security reasons it's a good practice to lock the memory with `mlock()` in which you keep sensitive data like\n passwords or encrryption keys, or any other plaintext sensitive content. Also it's important to zeroize the data when\n not used anymore.**\n- **In the case of [Copy-on-write fork](https://en.wikipedia.org/wiki/Copy-on-write) you need to zeroize the memory\n before forking the child process.**\n\nIn the examples below you will see how to do it.\n\n# Encryption providers and algorithms (ciphers)\n\nYou will notice in the examples we create the `Cipher` from something like\nthis `cipher_meta = CipherMeta.Ring(RingAlgorithm.Aes256Gcm)`. The first part `CipherMeta.Ring` is the encryption\nprovider. The last part is the algorithm for that provider, in this case `Aes256Gcm`. Each provier might expose specific\nalgorithms.\n\n## Providers\n\n```rust\nenum CipherMeta {\n Ring { alg: RingAlgorithm },\n RustCrypto { alg: RustCryptoAlgorithm },\n Sodiumoxide { alg: SodiumoxideAlgorithm },\n Orion { alg: OrionAlgorithm },\n}\n```\n\n- `Ring`: Based on [ring](https://crates.io/crates/ring) crate. ring is focused on the implementation, testing, and\n optimization of a core set of cryptographic operations exposed via an easy-to-use (and hard-to-misuse) API. ring\n exposes a Rust API and is written in a hybrid of Rust, C, and assembly language.\n Particular attention is being paid to making it easy to build and integrate ring into applications and higher-level\n frameworks, and to ensuring that ring works optimally on small devices, and eventually microcontrollers, to support\n Internet of Things (IoT) applications.\n Most of the C and assembly language code in ring comes from BoringSSL, and BoringSSL is derived from OpenSSL. ring\n merges changes from BoringSSL regularly. Also, several changes that were developed for ring have been contributed to\n and integrated into BoringSSL.\n- `RustCrypto`: Based on [RustCrypto](https://github.com/RustCrypto/AEADs) collection of Authenticated Encryption with\n Associated Data (AEAD) algorithms written in pure Rust. AEADs are high-level symmetric encryption primitives which\n defend against a wide range of potential attacks (i.e. IND-CCA3).\n- `Sodiumoxide`: Based on [sodiumoxide](https://crates.io/crates/sodiumoxide) crate which aims to provide a type-safe\n and efficient Rust binding that's just as easy to use.\n [`NaCl`](https://nacl.cr.yp.to) (pronounced \"salt\") is a new easy-to-use high-speed software library for network\n communication, encryption, decryption, signatures, etc. NaCl's goal is to provide all of the core operations needed to\n build higher-level cryptographic tools. Of course, other libraries already exist for these core operations. NaCl\n advances the state of the art by improving security, by improving usability, and by improving speed.\n [Sodium](https://github.com/jedisct1/libsodium) is a portable, cross-compilable, installable, packageable fork of\n NaCl (based on the latest released upstream version nacl-20110221), with a compatible API.\n- `Orion`: Based on [orion](https://crates.io/crates/orion) crate. Written in pure Rust, it aims to provide easy and\n usable crypto while trying to minimize the use of unsafe code. You can read more about Orion in\n the [wiki](https://github.com/orion-rs/orion/wiki).\n\n## Algorithms\n\n```rust\nenum RingAlgorithm {\n ChaCha20Poly1305,\n Aes128Gcm,\n Aes256Gcm,\n}\n```\n\n```rust\nenum RustCryptoAlgorithm {\n ChaCha20Poly1305,\n XChaCha20Poly1305,\n Aes128Gcm,\n Aes256Gcm,\n Aes128GcmSiv,\n Aes256GcmSiv,\n Aes128Siv,\n Aes256Siv,\n Ascon128,\n Ascon128a,\n Ascon80pq,\n DeoxysI128,\n DeoxysI256,\n DeoxysII128,\n DeoxysII256,\n Aes128Eax,\n Aes256Eax,\n}\n```\n\n```rust\nenum SodiumoxideAlgorithm {\n ChaCha20Poly1305,\n ChaCha20Poly1305Ietf,\n XChaCha20Poly1305Ietf,\n}\n```\n\n```rust\nenum OrionAlgorithm {\n ChaCha20Poly1305,\n XChaCha20Poly1305,\n}\n```\n\n## Audited\n\n**Only for `Aes128Gcm`, `Aes256Gcm` and `ChaCha20Poly1305` with `Ring` and `RustCrypto` providers underlying crates have\nbeen audited.**\n\n- [`Aes128Gcm`/`Aes256Gcm`](https://datatracker.ietf.org/doc/html/rfc5288): If you have hardware acceleration (\n e.g. `AES-NI`), then `AES-GCM` provides better performance. If you do not have a hardware acceleration, `AES-GCM` is\n either slower than `ChaCha20Poly1305`, or it leaks your encryption keys in cache timing. With `RustCrypto` provider\n the underlying `aes-gcm` has received one security audit by NCC Group, with no significant findings. With `Ring`\n provider the underlying `ring` crate was also audited.\n- [`ChaCha20Poly1305`](https://en.wikipedia.org/wiki/ChaCha20-Poly1305): Is notable for being simple and fast when\n implemented in pure software. The underlying `ChaCha20` stream cipher uses a simple combination of `add`, `rotate`,\n and `XOR` instructions (a.k.a. `\"ARX\"`), and the `Poly1305` hash function is likewise extremely simple.\n With `RustCrypto` provider the underlying `chacha20poly1305` has received one security audit by NCC Group, with no\n significant findings. With `Ring` provider the underlying `ring` crtate was also audited.\n If you do not have a hardware acceleration, `ChaCha20Poly1305` is faster than `AES-GCM`.\n While it hasn't received approval from certain standards bodies (i.e. NIST) the algorithm is widely used and deployed.\n Notably it's mandatory to implement in the Transport Layer Security (TLS) protocol. The underlying `ChaCha20` cipher\n is also widely used as a cryptographically secure random number generator, including internal use by the Rust standard\n library.\n- [`XChaCha20Poly1305`](https://en.wikipedia.org/wiki/ChaCha20-Poly1305#XChaCha20-Poly1305_%E2%80%93_extended_nonce_variant):\n A variant of `ChaCha20Poly1305` with an extended 192-bit (24-byte) nonce.\n\n## Not audited\n\n**USE AT YOUR OWN RISK!**\n\n- [`Aes128GcmSiv` / `Aes256GcmSiv`](https://en.wikipedia.org/wiki/AES-GCM-SIV): Provides nonce reuse misuse resistance.\n Suitable as a general purpose symmetric encryption cipher, `AES-GCM-SIV` also removes many of the \"sharp edges\"\n of `AES-GCM`, providing significantly better security bounds while simultaneously eliminating the most catastrophic\n risks of nonce reuse that exist in `AES-GCM`. Decryption performance is equivalent to `AES-GCM`. Encryption is\n marginally slower.\n- [`Aes128Siv` / `Aes256Siv`](https://github.com/miscreant/meta/wiki/AES-SIV): Cipher which also provides nonce reuse\n misuse resistance.\n- [`Ascon128` / `Ascon128a` / `Ascon80pq`](https://ascon.iaik.tugraz.at): Designed to be lightweight and easy to\n implement, even with added countermeasures against side-channel attacks. Ascon has been selected as new standard for\n lightweight cryptography in the NIST Lightweight Cryptography competition (2019\u20132023). Ascon has also been selected as\n the primary choice for lightweight authenticated encryption in the final portfolio of the CAESAR competition (\n 2014\u20132019).\n- [`Deoxys`](https://sites.google.com/view/deoxyscipher): Based on a 128-bit lightweight ad-hoc tweakable block cipher.\n It may be used in two modes to handle nonce-respecting users (`Deoxys-I`) or nonce-reusing\n user (`Deoxys-II`). `Deoxys-II` has been selected as first choice for the \"in-depth security\" portfolio of\n the `CAESAR` competition.\n- [`Aes128Eax` / `Aes256Eax`](https://en.wikipedia.org/wiki/EAX_mode): Designed with a two-pass scheme, one pass for\n achieving privacy and one for authenticity for each block. `EAX` mode was submitted on October 3, 2003, to the\n attention of NIST in order to replace `CCM` as standard `AEAD` mode of operation, since `CCM` mode lacks some\n desirable attributes of `EAX` and is more complex.\n- For `Sodiumoxide`\n provider [`ChaCha20Poly1305`](https://libsodium.gitbook.io/doc/secret-key_cryptography/aead/chacha20-poly1305/original_chacha20-poly1305_construction):\n The original `ChaCha20-Poly1305` construction can safely encrypt a pratically unlimited number of messages with the\n same key, without any practical limit to the size of a message (up to ~ 2^64 bytes).\n- For `Sodiumoxide`\n provider [`ChaChaCha20Poly1305Ietf`](https://libsodium.gitbook.io/doc/secret-key_cryptography/aead/chacha20-poly1305/ietf_chacha20-poly1305_construction):\n The IETF variant of the `ChaCha20-Poly1305` construction can safely encrypt a practically unlimited number of\n messages, but individual messages cannot exceed 64*(2^32)-64 bytes (approximatively 256 GB).\n\n# Examples\n\nYou can see more in [examples](https://github.com/radumarias/rencrypt-python/tree/main/examples) directory and\nin [bench.py](https://github.com/radumarias/rencrypt-python/tree/main/bench.py) which has some benchmarks. Here are few\nsimple examples:\n\n## Encrypt and decrypt with a buffer in memory\n\n`seal_in_place()`/`open_in_place()`\n\nThis is the most performant way to use it as it will not copy bytes to the buffer nor allocate new memory for plaintext\nand ciphertext.\n\n```python\nfrom rencrypt import Cipher, CipherMeta, RingAlgorithm\nimport os\nfrom zeroize import zeroize1, mlock, munlock\nimport numpy as np\nimport platform\n\n\ndef setup_memory_limit():\n if not platform.system() == \"Windows\":\n return\n\n import ctypes\n from ctypes import wintypes\n\n # Define the Windows API functions\n kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)\n\n GetCurrentProcess = kernel32.GetCurrentProcess\n GetCurrentProcess.restype = wintypes.HANDLE\n\n SetProcessWorkingSetSize = kernel32.SetProcessWorkingSetSize\n SetProcessWorkingSetSize.restype = wintypes.BOOL\n SetProcessWorkingSetSize.argtypes = [wintypes.HANDLE, ctypes.c_size_t, ctypes.c_size_t]\n\n # Get the handle of the current process\n current_process = GetCurrentProcess()\n\n # Set the working set size\n min_size = 6 * 1024 * 1024 # Minimum working set size\n max_size = 10 * 1024 * 1024 # Maximum working set size\n\n result = SetProcessWorkingSetSize(current_process, min_size, max_size)\n\n if not result:\n error_code = ctypes.get_last_error()\n error_message = ctypes.FormatError(error_code)\n raise RuntimeError(f\"SetProcessWorkingSetSize failed with error code {error_code}: {error_message}\")\n\n\nif __name__ == \"__main__\":\n try:\n setup_memory_limit()\n\n # You can use also other algorithms like cipher_meta = CipherMeta.Ring(RingAlgorithm.ChaCha20Poly1305)`.\n cipher_meta = CipherMeta.Ring(RingAlgorithm.Aes256Gcm)\n key_len = cipher_meta.key_len()\n key = bytearray(key_len)\n # for security reasons we lock the memory of the key so it won't be swapped to disk\n mlock(key)\n cipher_meta.generate_key(key)\n # The key is copied and the input key is zeroized for security reasons.\n # The copied key will also be zeroized when the object is dropped.\n cipher = Cipher(cipher_meta, key)\n # it was zeroized we can unlock it\n munlock(key)\n\n # we create a buffer based on plaintext block len of 4096\n # the actual buffer needs to be a bit larger as the ciphertext also includes the tag and nonce\n plaintext_len = 4096\n ciphertext_len = cipher_meta.ciphertext_len(plaintext_len)\n buf = np.array([0] * ciphertext_len, dtype=np.uint8)\n # for security reasons we lock the memory of the buffer so it won't be swapped to disk, because it contains plaintext after decryption\n mlock(buf)\n\n aad = b\"AAD\"\n\n # put some plaintext in the buffer, it would be ideal if you can directly collect the data into the buffer without allocating new memory\n # but for the sake of example we will allocate and copy the data\n plaintext = bytearray(os.urandom(plaintext_len))\n # for security reasons we lock the memory of the plaintext so it won't be swapped to disk\n mlock(plaintext)\n # cipher.copy_slice is slighlty faster than buf[:plaintext_len] = plaintext, especially for large plaintext, because it copies the data in parallel\n # cipher.copy_slice takes bytes as input, cipher.copy_slice1 takes bytearray\n cipher.copy_slice(plaintext, buf)\n # encrypt it, this will encrypt in-place the data in the buffer\n print(\"encrypting...\")\n ciphertext_len = cipher.seal_in_place(buf, plaintext_len, 42, aad)\n cipertext = buf[:ciphertext_len]\n # you can do something with the ciphertext\n\n # decrypt it\n # if you need to copy ciphertext to buffer, we don't need to do it now as it's already in the buffer\n # cipher.copy_slice(ciphertext, buf[:len(ciphertext)])\n print(\"decrypting...\")\n plaintext_len = cipher.open_in_place(buf, ciphertext_len, 42, aad)\n plaintext2 = buf[:plaintext_len]\n # for security reasons we lock the memory of the plaintext so it won't be swapped to disk\n mlock(plaintext2)\n assert plaintext == plaintext2\n\n finally:\n # best practice, you should always zeroize the plaintext and keys after you are done with it (key will be zeroized when the enc object is dropped)\n zeroize1(plaintext)\n zeroize1(buf)\n\n munlock(buf)\n munlock(plaintext)\n\n print(\"bye!\")\n```\n\nYou can use other ciphers like `cipher_meta = CipherMeta.Ring(RingAlgorithm.ChaCha20Poly1305)`.\n\nYou can also provide your own nonce that you can generate based on your contraints.\n\n```python\nfrom rencrypt import Cipher, CipherMeta, RingAlgorithm\nimport os\nfrom zeroize import zeroize1, mlock, munlock\nimport numpy as np\nimport platform\n\n\ndef setup_memory_limit():\n if not platform.system() == \"Windows\":\n return\n\n import ctypes\n from ctypes import wintypes\n\n # Define the Windows API functions\n kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)\n\n GetCurrentProcess = kernel32.GetCurrentProcess\n GetCurrentProcess.restype = wintypes.HANDLE\n\n SetProcessWorkingSetSize = kernel32.SetProcessWorkingSetSize\n SetProcessWorkingSetSize.restype = wintypes.BOOL\n SetProcessWorkingSetSize.argtypes = [wintypes.HANDLE, ctypes.c_size_t, ctypes.c_size_t]\n\n # Get the handle of the current process\n current_process = GetCurrentProcess()\n\n # Set the working set size\n min_size = 6 * 1024 * 1024 # Minimum working set size\n max_size = 10 * 1024 * 1024 # Maximum working set size\n\n result = SetProcessWorkingSetSize(current_process, min_size, max_size)\n\n if not result:\n error_code = ctypes.get_last_error()\n error_message = ctypes.FormatError(error_code)\n raise RuntimeError(f\"SetProcessWorkingSetSize failed with error code {error_code}: {error_message}\")\n\n\nif __name__ == \"__main__\":\n try:\n setup_memory_limit()\n\n # You can use also other algorithms like cipher_meta = CipherMeta.Ring(RingAlgorithm.ChaCha20Poly1305)`.\n cipher_meta = CipherMeta.Ring(RingAlgorithm.Aes256Gcm)\n key_len = cipher_meta.key_len()\n key = bytearray(key_len)\n # for security reasons we lock the memory of the key so it won't be swapped to disk\n mlock(key)\n cipher_meta.generate_key(key)\n # The key is copied and the input key is zeroized for security reasons.\n # The copied key will also be zeroized when the object is dropped.\n cipher = Cipher(cipher_meta, key)\n # it was zeroized we can unlock it\n munlock(key)\n\n # we create a buffer based on plaintext block len of 4096\n # the actual buffer needs to be a bit larger as the ciphertext also includes the tag and nonce\n plaintext_len = 4096\n ciphertext_len = cipher_meta.ciphertext_len(plaintext_len)\n buf = np.array([0] * ciphertext_len, dtype=np.uint8)\n # for security reasons we lock the memory of the buffer so it won't be swapped to disk, because it contains plaintext after decryption\n mlock(buf)\n\n aad = b\"AAD\"\n # create our own nonce\n nonce = os.urandom(cipher_meta.nonce_len())\n\n # put some plaintext in the buffer, it would be ideal if you can directly collect the data into the buffer without allocating new memory\n # but for the sake of example we will allocate and copy the data\n plaintext = bytearray(os.urandom(plaintext_len))\n # for security reasons we lock the memory of the plaintext so it won't be swapped to disk\n mlock(plaintext)\n # cipher.copy_slice is slighlty faster than buf[:plaintext_len] = plaintext, especially for large plaintext, because it copies the data in parallel\n # cipher.copy_slice takes bytes as input, cipher.copy_slice1 takes bytearray\n cipher.copy_slice(plaintext, buf)\n # encrypt it, this will encrypt in-place the data in the buffer\n print(\"encrypting...\")\n ciphertext_len = cipher.seal_in_place(buf, plaintext_len, 42, aad, nonce)\n cipertext = buf[:ciphertext_len]\n # you can do something with the ciphertext\n\n # decrypt it\n # if you need to copy ciphertext to buffer, we don't need to do it now as it's already in the buffer\n # cipher.copy_slice(ciphertext, buf[:len(ciphertext)])\n print(\"decrypting...\")\n plaintext_len = cipher.open_in_place(buf, ciphertext_len, 42, aad, nonce)\n plaintext2 = buf[:plaintext_len]\n # for security reasons we lock the memory of the plaintext so it won't be swapped to disk\n mlock(plaintext2)\n assert plaintext == plaintext2\n\n finally:\n # best practice, you should always zeroize the plaintext and keys after you are done with it (key will be zeroized when the enc object is dropped)\n zeroize1(plaintext)\n zeroize1(buf)\n\n munlock(buf)\n munlock(plaintext)\n\n print(\"bye!\")\n```\n\n## Encrypt and decrypt a file\n\n```python\nimport errno\nimport io\nimport os\nfrom pathlib import Path\nimport shutil\nfrom rencrypt import Cipher, CipherMeta, RingAlgorithm\nimport hashlib\nfrom zeroize import zeroize1, mlock, munlock\nimport numpy as np\nimport platform\n\n\ndef setup_memory_limit():\n if not platform.system() == \"Windows\":\n return\n\n import ctypes\n from ctypes import wintypes\n\n # Define the Windows API functions\n kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)\n\n GetCurrentProcess = kernel32.GetCurrentProcess\n GetCurrentProcess.restype = wintypes.HANDLE\n\n SetProcessWorkingSetSize = kernel32.SetProcessWorkingSetSize\n SetProcessWorkingSetSize.restype = wintypes.BOOL\n SetProcessWorkingSetSize.argtypes = [wintypes.HANDLE, ctypes.c_size_t, ctypes.c_size_t]\n\n # Get the handle of the current process\n current_process = GetCurrentProcess()\n\n # Set the working set size\n min_size = 6 * 1024 * 1024 # Minimum working set size\n max_size = 10 * 1024 * 1024 # Maximum working set size\n\n result = SetProcessWorkingSetSize(current_process, min_size, max_size)\n\n if not result:\n error_code = ctypes.get_last_error()\n error_message = ctypes.FormatError(error_code)\n raise RuntimeError(f\"SetProcessWorkingSetSize failed with error code {error_code}: {error_message}\")\n\n\ndef read_file_in_chunks(file_path, buf):\n with open(file_path, \"rb\") as file:\n buffered_reader = io.BufferedReader(file, buffer_size=len(buf))\n while True:\n read = buffered_reader.readinto(buf)\n if read == 0:\n break\n yield read\n\n\ndef hash_file(file_path):\n hash_algo = hashlib.sha256()\n with open(file_path, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_algo.update(chunk)\n return hash_algo.hexdigest()\n\n\ndef compare_files_by_hash(file1, file2):\n return hash_file(file1) == hash_file(file2)\n\n\ndef silentremove(filename):\n try:\n os.remove(filename)\n except OSError as e: # this would be \"except OSError, e:\" before Python 2.6\n if e.errno != errno.ENOENT: # errno.ENOENT = no such file or directory\n raise # re-raise exception if a different error occurred\n\n\ndef create_directory_in_home(dir_name):\n # Get the user's home directory\n home_dir = Path.home()\n\n # Create the full path for the new directory\n new_dir_path = home_dir / dir_name\n\n # Create the directory\n try:\n new_dir_path.mkdir(parents=True, exist_ok=True)\n except Exception as e:\n print(f\"Error creating directory: {e}\")\n\n return new_dir_path.absolute().__str__()\n\n\ndef create_file_with_size(file_path_str, size_in_bytes):\n with open(file_path_str, \"wb\") as f:\n for _ in range((size_in_bytes // 4096) + 1):\n f.write(os.urandom(min(4096, size_in_bytes)))\n f.flush()\n\n\ndef delete_dir(path):\n if os.path.exists(path):\n shutil.rmtree(path)\n else:\n print(f\"Directory {path} does not exist.\")\n\n\nif __name__ == \"__main__\":\n try:\n setup_memory_limit()\n\n tmp_dir = create_directory_in_home(\"rencrypt_tmp\")\n fin = tmp_dir + \"/\" + \"fin\"\n fout = tmp_dir + \"/\" + \"fout.enc\"\n create_file_with_size(fin, 1 * 1024 * 1024)\n\n chunk_len = 256 * 1024\n\n # You can use also other algorithms like cipher_meta = CipherMeta.Ring(RingAlgorithm.ChaCha20Poly1305)`.\n cipher_meta = CipherMeta.Ring(RingAlgorithm.Aes256Gcm)\n key_len = cipher_meta.key_len()\n key = bytearray(key_len)\n # for security reasons we lock the memory of the key so it won't be swapped to disk\n mlock(key)\n cipher_meta.generate_key(key)\n # The key is copied and the input key is zeroized for security reasons.\n # The copied key will also be zeroized when the object is dropped.\n cipher = Cipher(cipher_meta, key)\n # it was zeroized we can unlock it\n munlock(key)\n\n plaintext_len = chunk_len\n ciphertext_len = cipher_meta.ciphertext_len(plaintext_len)\n buf = np.array([0] * ciphertext_len, dtype=np.uint8)\n mlock(buf)\n\n # use some random per file in additional authenticated data to prevent blocks from being swapped between files\n aad = os.urandom(16)\n\n # encrypt\n print(\"encrypting...\")\n with open(fout, \"wb\", buffering=plaintext_len) as file_out:\n i = 0\n for read in read_file_in_chunks(fin, buf[:plaintext_len]):\n ciphertext_len = cipher.seal_in_place(buf, read, i, aad)\n file_out.write(buf[:ciphertext_len])\n i += 1\n file_out.flush()\n\n # decrypt\n print(\"decrypting...\")\n tmp = fout + \".dec\"\n with open(tmp, \"wb\", buffering=plaintext_len) as file_out:\n i = 0\n for read in read_file_in_chunks(fout, buf):\n plaintext_len2 = cipher.open_in_place(buf, read, i, aad)\n file_out.write(buf[:plaintext_len2])\n i += 1\n file_out.flush()\n\n assert compare_files_by_hash(fin, tmp)\n\n delete_dir(tmp_dir)\n\n finally:\n # best practice, you should always zeroize the plaintext and keys after you are done with it (key will be zeroized when the enc object is dropped)\n # buf will containt the last block plaintext so we need to zeroize it\n zeroize1(buf)\n\n munlock(buf)\n\n print(\"bye!\")\n```\n\n## Encrypt and decrypt from some bytes into the buffer\n\n`encrypt_from()`/`decrypt_from()`\n\nThis is a bit slower than handling data only via the buffer, especially for large plaintext, but there are situations\nwhen you can't directly collect the data to the buffer but have some data from somewhere else.\n\n```python\nfrom rencrypt import Cipher, CipherMeta, RingAlgorithm\nimport os\nfrom zeroize import zeroize1, mlock, munlock\nimport numpy as np\nimport platform\n\n\ndef setup_memory_limit():\n if not platform.system() == \"Windows\":\n return\n\n import ctypes\n from ctypes import wintypes\n\n # Define the Windows API functions\n kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)\n\n GetCurrentProcess = kernel32.GetCurrentProcess\n GetCurrentProcess.restype = wintypes.HANDLE\n\n SetProcessWorkingSetSize = kernel32.SetProcessWorkingSetSize\n SetProcessWorkingSetSize.restype = wintypes.BOOL\n SetProcessWorkingSetSize.argtypes = [wintypes.HANDLE, ctypes.c_size_t, ctypes.c_size_t]\n\n # Get the handle of the current process\n current_process = GetCurrentProcess()\n\n # Set the working set size\n min_size = 6 * 1024 * 1024 # Minimum working set size\n max_size = 10 * 1024 * 1024 # Maximum working set size\n\n result = SetProcessWorkingSetSize(current_process, min_size, max_size)\n\n if not result:\n error_code = ctypes.get_last_error()\n error_message = ctypes.FormatError(error_code)\n raise RuntimeError(f\"SetProcessWorkingSetSize failed with error code {error_code}: {error_message}\")\n\n\nif __name__ == \"__main__\":\n try:\n setup_memory_limit()\n\n # You can use also other algorithms like cipher_meta = CipherMeta.Ring(RingAlgorithm.ChaCha20Poly1305)`.\n cipher_meta = CipherMeta.Ring(RingAlgorithm.Aes256Gcm)\n key_len = cipher_meta.key_len()\n key = bytearray(key_len)\n # for security reasons we lock the memory of the key so it won't be swapped to disk\n mlock(key)\n cipher_meta.generate_key(key)\n # The key is copied and the input key is zeroized for security reasons.\n # The copied key will also be zeroized when the object is dropped.\n cipher = Cipher(cipher_meta, key)\n # it was zeroized we can unlock it\n munlock(key)\n\n # we create a buffer based on plaintext block len of 4096\n # the actual buffer needs to be a bit larger as the ciphertext also includes the tag and nonce\n plaintext_len = 4096\n ciphertext_len = cipher_meta.ciphertext_len(plaintext_len)\n buf = np.array([0] * ciphertext_len, dtype=np.uint8)\n # for security reasons we lock the memory of the buffer so it won't be swapped to disk, because it contains plaintext after decryption\n mlock(buf)\n\n aad = b\"AAD\"\n\n plaintext = bytearray(os.urandom(plaintext_len))\n # for security reasons we lock the memory of the plaintext so it won't be swapped to disk\n mlock(plaintext)\n\n # encrypt it, after this will have the ciphertext in the buffer\n print(\"encrypting...\")\n ciphertext_len = cipher.seal_in_place_from(plaintext, buf, 42, aad)\n cipertext = bytes(buf[:ciphertext_len])\n\n # decrypt it\n print(\"decrypting...\")\n plaintext_len = cipher.open_in_place_from(cipertext, buf, 42, aad)\n plaintext2 = buf[:plaintext_len]\n # for security reasons we lock the memory of the plaintext so it won't be swapped to disk\n mlock(plaintext2)\n assert plaintext == plaintext2\n\n finally:\n # best practice, you should always zeroize the plaintext and keys after you are done with it (key will be zeroized when the enc object is dropped)\n zeroize1(plaintext)\n zeroize1(buf)\n\n munlock(buf)\n munlock(plaintext)\n\n print(\"bye!\")\n```\n\n## Zeroing memory before forking child process\n\nThis mitigates the problems that appears on [Copy-on-write fork](https://en.wikipedia.org/wiki/Copy-on-write). You need\nto zeroize the data before forking the child process.\n\n```python\nimport os\nfrom zeroize import zeroize1, mlock, munlock\n\nif __name__ == \"__main__\":\n try:\n # Maximum you can mlock is 4MB\n sensitive_data = bytearray(b\"Sensitive Information\")\n mlock(sensitive_data)\n\n print(\"Before zeroization:\", sensitive_data)\n\n zeroize1(sensitive_data)\n print(\"After zeroization:\", sensitive_data)\n\n # Forking after zeroization to ensure no sensitive data is copied\n pid = os.fork()\n if pid == 0:\n # This is the child process\n print(\"Child process memory after fork:\", sensitive_data)\n else:\n # This is the parent process\n os.wait() # Wait for the child process to exit\n\n print(\"all good, bye!\")\n\n finally:\n # Unlock the memory\n print(\"unlocking memory\")\n munlock(sensitive_data)\n```\n\n# Build from source\n\n## Browser\n\n[](https://gitpod.io/#https://github.com/radumarias/rencrypt-python)\n\n[](https://github.com/codespaces/new/?repo=radumarias%2Frencrypt-python&ref=main)\n\n## Geting sources from GitHub\n\nSkip this if you're starting it in browser.\n\n```bash\ngit clone https://github.com/radumarias/rencrypt-python && cd Cipher-python\n```\n\n## Compile and run\n\n```bash\ncurl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh\n```\n\nTo configure your current shell, you need to source\nthe corresponding env file under $HOME/.cargo.\nThis is usually done by running one of the following (note the leading DOT):\n\n```bash\n. \"$HOME/.cargo/env\"\n```\n\n```bash\npython -m venv .env\nsource .env/bin/activate\npip install -r requirements.txt\nmaturin develop --release\npytest\npython examples/encrypt.py\npython examples/encrypt_into.py\npython examples/encrypt_from.py\npython examples/encrypt_file.py\npython benches/bench.py\n```\n\n# More benchmarks\n\n## Different ways to use the lib\n\n**Encrypt**\n\n\n**Decrypt**\n\n\n**Block size and duration in seconds**\n\n<table>\n <thead>\n <tr>\n <td>MB</td>\n <td>rencrypt<br>encrypt</td>\n <td>PyFLocker<br>encrypt update_into</td>\n <td>rencrypt<br>encrypt_from</td>\n <td>PyFLocker<br>encrypt update</td>\n <td>rencrypt<br>decrypt</td>\n <td>PyFLocker<br>decrypt update_into</td>\n <td>rencrypt<br>decrypt_from</td>\n <td>\n <div>\n <div>PyFLocker<br>decrypt update</div>\n </div>\n </td>\n </tr>\n </thead>\n <tbody>\n <tr>\n <td>0.03125</td>\n <td>0.00001</td>\n <td>0.00091</td>\n <td>0.00001</td>\n <td>0.00009</td>\n <td>0.00001</td>\n <td>0.00004</td>\n <td>0.00001</td>\n <td>0.00005</td>\n </tr>\n <tr>\n <td>0.0625</td>\n <td>0.00001</td>\n <td>0.00005</td>\n <td>0.00002</td>\n <td>0.00005</td>\n <td>0.00001</td>\n <td>0.00004</td>\n <td>0.00002</td>\n <td>0.00008</td>\n </tr>\n <tr>\n <td>0.125</td>\n <td>0.00002</td>\n <td>0.00005</td>\n <td>0.00003</td>\n <td>0.00011</td>\n <td>0.00003</td>\n <td>0.00005</td>\n <td>0.00003</td>\n <td>0.00013</td>\n </tr>\n <tr>\n <td>0.25</td>\n <td>0.00004</td>\n <td>0.00008</td>\n <td>0.00007</td>\n <td>0.00019</td>\n <td>0.00005</td>\n <td>0.00009</td>\n <td>0.00007</td>\n <td>0.00023</td>\n </tr>\n <tr>\n <td>0.5</td>\n <td>0.0001</td>\n <td>0.00014</td>\n <td>0.00015</td>\n <td>0.00035</td>\n <td>0.00011</td>\n <td>0.00015</td>\n <td>0.00014</td>\n <td>0.00043</td>\n </tr>\n <tr>\n <td>1</td>\n <td>0.00021</td>\n <td>0.00024</td>\n <td>0.0008</td>\n <td>0.00082</td>\n <td>0.00021</td>\n <td>0.00029</td>\n <td>0.00044</td>\n <td>0.00103</td>\n </tr>\n <tr>\n <td>2</td>\n <td>0.00043</td>\n <td>0.00052</td>\n <td>0.00082</td>\n <td>0.00147</td>\n <td>0.00044</td>\n <td>0.00058</td>\n <td>0.00089</td>\n <td>0.00176</td>\n </tr>\n <tr>\n <td>4</td>\n <td>0.00089</td>\n <td>0.00098</td>\n <td>0.00174</td>\n <td>0.00284</td>\n <td>0.00089</td>\n <td>0.00117</td>\n <td>0.0013</td>\n <td>0.0034</td>\n </tr>\n <tr>\n <td>8</td>\n <td>0.00184</td>\n <td>0.0019</td>\n <td>0.00263</td>\n <td>0.00523</td>\n <td>0.00192</td>\n <td>0.00323</td>\n <td>0.00283</td>\n <td>0.00571</td>\n </tr>\n <tr>\n <td>16</td>\n <td>0.00353</td>\n <td>0.00393</td>\n <td>0.00476</td>\n <td>0.0141</td>\n <td>0.00367</td>\n <td>0.00617</td>\n <td>0.00509</td>\n <td>0.01031</td>\n </tr>\n <tr>\n <td>32</td>\n <td>0.00678</td>\n <td>0.00748</td>\n <td>0.00904</td>\n <td>0.0244</td>\n <td>0.00749</td>\n <td>0.01348</td>\n <td>0.01014</td>\n <td>0.02543</td>\n </tr>\n <tr>\n <td>64</td>\n <td>0.01361</td>\n <td>0.01461</td>\n <td>0.01595</td>\n <td>0.05064</td>\n <td>0.0146</td>\n <td>0.02697</td>\n <td>0.0192</td>\n <td>0.05296</td>\n </tr>\n <tr>\n <td>128</td>\n <td>0.02923</td>\n <td>0.03027</td>\n <td>0.03343</td>\n <td>0.10362</td>\n <td>0.03134</td>\n <td>0.0541</td>\n <td>0.03558</td>\n <td>0.1138</td>\n </tr>\n <tr>\n <td>256</td>\n <td>0.06348</td>\n <td>0.06188</td>\n <td>0.07303</td>\n <td>0.20911</td>\n <td>0.06136</td>\n <td>0.10417</td>\n <td>0.07572</td>\n <td>0.20828</td>\n </tr>\n <tr>\n <td>512</td>\n <td>0.11782</td>\n <td>0.13463</td>\n <td>0.14283</td>\n <td>0.41929</td>\n <td>0.1209</td>\n <td>0.21114</td>\n <td>0.14434</td>\n <td>0.41463</td>\n </tr>\n <tr>\n <td>1024</td>\n <td>0.25001</td>\n <td>0.24953</td>\n <td>0.28912</td>\n <td>0.8237</td>\n <td>0.25377</td>\n <td>0.42581</td>\n <td>0.29795</td>\n <td>0.82588</td>\n </tr>\n </tbody>\n</table>\n\n## Speed throughput\n\n`256KB` seems to be the sweet spot for buffer size that offers the max `MB/s` speed for encryption, on benchmarks that\nseem to be the case.\nWe performed `10.000` encryption operations for each size varying from `1KB` to `16MB`.\n\n\n\n| MB | MB/s |\n|----------------------------------------------------------|----------------------------------------------------------|\n| 0.0009765625 | 1083 |\n| 0.001953125 | 1580 |\n| 0.00390625 | 2158 |\n| 0.0078125 | 2873 |\n| 0.015625 | 3348 |\n| 0.03125 | 3731 |\n| 0.0625 | 4053 |\n| 0.125 | 4156 |\n| <span style=\"color: red; font-weight: bold;\">0.25</span> | <span style=\"color: red; font-weight: bold;\">4247</span> |\n| 0.5 | 4182 |\n| 1.0 | 3490 |\n| 2.0 | 3539 |\n| 4.0 | 3684 |\n| 8.0 | 3787 |\n| 16.0 | 3924 |\n\n# For the future\n\n- Generating key from password (`KDF`)\n- Maybe add support for `RSA` and `Elliptic-curve cryptography`\n- Saving and loading keys from file\n\n# Considerations\n\nThis lib hasn't been audited, but it wraps `ring` crate (well known and audited library) and `RustCrypto` (`AES-GCM`\nand `ChaCha20Poly1305` ciphers are audited), so in principle at least the primitives should offer a similar level of\nsecurity.\n\n# Contribute\n\nFeel free to fork it, change and use it in any way that you want.\nIf you build something interesting and feel like sharing pull requests are always appreciated.\n\n## How to contribute\n\nPlease see [CONTRIBUTING.md](CONTRIBUTING.md).\n\n",
"bugtrack_url": null,
"license": "Apache-2.0 OR MIT",
"summary": "A Python encryption library implemented in Rust. It supports AEAD with various ciphers. It uses multiple providers to handle encryption.",
"version": "1.2.2",
"project_urls": {
"Homepage": "https://github.com/radumarias/rencrypt-python",
"Issues": "https://github.com/radumarias/rencrypt-python/issues"
},
"split_keywords": [
"cryptography",
" encryption",
" security",
" rust",
" speed",
" aead",
" cipher"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "a2ca165a877615bc620dbd852ed1e11c11e5705280ac8b6bdc9cca07570898ea",
"md5": "783cc9cc8934eb4c11e7eeadd326249e",
"sha256": "38697587e693e34c361b06fdc81ffbd19168b2f951b603ff95c5b3accf811ed3"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp310-cp310-macosx_10_12_x86_64.whl",
"has_sig": false,
"md5_digest": "783cc9cc8934eb4c11e7eeadd326249e",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.7",
"size": 484794,
"upload_time": "2024-08-14T17:01:45",
"upload_time_iso_8601": "2024-08-14T17:01:45.450097Z",
"url": "https://files.pythonhosted.org/packages/a2/ca/165a877615bc620dbd852ed1e11c11e5705280ac8b6bdc9cca07570898ea/rencrypt-1.2.2-cp310-cp310-macosx_10_12_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "8098fa56ee341bd4772713c03a9411b145c40f201b352c74eb1e3953360433e5",
"md5": "37ea2fe96fc14b712612c72219b27867",
"sha256": "9dbd5146a319d8c80c39a71b3db59417429221a5fca0799c84f5c2513a3307e5"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp310-cp310-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "37ea2fe96fc14b712612c72219b27867",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.7",
"size": 346127,
"upload_time": "2024-08-14T17:01:40",
"upload_time_iso_8601": "2024-08-14T17:01:40.099344Z",
"url": "https://files.pythonhosted.org/packages/80/98/fa56ee341bd4772713c03a9411b145c40f201b352c74eb1e3953360433e5/rencrypt-1.2.2-cp310-cp310-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "a680b1ffa867b690d3c63ba521d8e90c98b6024155f705748d7da4dc9ac0b5d9",
"md5": "9b8805edade1e75f1df99e3c0a459581",
"sha256": "7777608ffddd38363c84ae32557488b913e1ccf1a5a9f5e13d870991684fa53b"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl",
"has_sig": false,
"md5_digest": "9b8805edade1e75f1df99e3c0a459581",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.7",
"size": 540607,
"upload_time": "2024-08-14T17:01:15",
"upload_time_iso_8601": "2024-08-14T17:01:15.745982Z",
"url": "https://files.pythonhosted.org/packages/a6/80/b1ffa867b690d3c63ba521d8e90c98b6024155f705748d7da4dc9ac0b5d9/rencrypt-1.2.2-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "de4ddee94305094506670d3121e8bfbca7e9fd36b9f207c5feacdc88c44f1dde",
"md5": "390a02e1f50f2056d0b8303187c1b5b8",
"sha256": "31b573b047fa7a8bb45b064a09225172385ce783e15122d110592a82687cad6e"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"has_sig": false,
"md5_digest": "390a02e1f50f2056d0b8303187c1b5b8",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.7",
"size": 513867,
"upload_time": "2024-08-14T17:00:26",
"upload_time_iso_8601": "2024-08-14T17:00:26.082319Z",
"url": "https://files.pythonhosted.org/packages/de/4d/dee94305094506670d3121e8bfbca7e9fd36b9f207c5feacdc88c44f1dde/rencrypt-1.2.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "870d6ac7cc4355962faa1a5658631f5e950ec761d617b0d1d6b132fe49f2f6de",
"md5": "575546766a205be34f6aca3b50cfa364",
"sha256": "9207c1553e52c35e6ae8e633c1cb4e2e4b85055c40e8a71f95bc0f9689ee5508"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"has_sig": false,
"md5_digest": "575546766a205be34f6aca3b50cfa364",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.7",
"size": 492946,
"upload_time": "2024-08-14T17:00:43",
"upload_time_iso_8601": "2024-08-14T17:00:43.231909Z",
"url": "https://files.pythonhosted.org/packages/87/0d/6ac7cc4355962faa1a5658631f5e950ec761d617b0d1d6b132fe49f2f6de/rencrypt-1.2.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "1b5719d574200d363f8ac44b6a6e8f79c55a0b1960cee438eace6e922b8b0ed1",
"md5": "00da67ea6e5535d5690f86616f0077c9",
"sha256": "cfad6d12c90f0d833e19029008445b3ec83639659f009ea2cb076a9ff379eab1"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"has_sig": false,
"md5_digest": "00da67ea6e5535d5690f86616f0077c9",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.7",
"size": 598699,
"upload_time": "2024-08-14T17:00:58",
"upload_time_iso_8601": "2024-08-14T17:00:58.907866Z",
"url": "https://files.pythonhosted.org/packages/1b/57/19d574200d363f8ac44b6a6e8f79c55a0b1960cee438eace6e922b8b0ed1/rencrypt-1.2.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "87ebdf527e4918f5d0a5f1df6265dad8fa82e2745986e8e14093680a6d244023",
"md5": "73fbc9910975bd1d98d50f370ea5f59c",
"sha256": "1a0b080ba351c4a392a90f1d64239282d23a1c2adc443b23953ba3304cac4170"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "73fbc9910975bd1d98d50f370ea5f59c",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.7",
"size": 532205,
"upload_time": "2024-08-14T17:01:28",
"upload_time_iso_8601": "2024-08-14T17:01:28.100038Z",
"url": "https://files.pythonhosted.org/packages/87/eb/df527e4918f5d0a5f1df6265dad8fa82e2745986e8e14093680a6d244023/rencrypt-1.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "f8b5c3d11212a8548dc8bb5ac968ece4ec71821942301fa8f992b6ae4ec166ed",
"md5": "6c395c3a45c06c6bae370e43bb54711c",
"sha256": "c1cd92858f028b8a89dc9479c121bfee664238869d46580c40ccadb2fd18f258"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp310-none-win_amd64.whl",
"has_sig": false,
"md5_digest": "6c395c3a45c06c6bae370e43bb54711c",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.7",
"size": 363400,
"upload_time": "2024-08-14T17:01:54",
"upload_time_iso_8601": "2024-08-14T17:01:54.157634Z",
"url": "https://files.pythonhosted.org/packages/f8/b5/c3d11212a8548dc8bb5ac968ece4ec71821942301fa8f992b6ae4ec166ed/rencrypt-1.2.2-cp310-none-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "8ed48b992d8bedd4659a4586e51323f6aa568764bfe8ade10f57e116525e8c36",
"md5": "e314bf6881e5ce722b7da7e7212079b4",
"sha256": "161be96e4a295483ad3f938041439e25a8c9ede427f71fd99e4d2ec75cc3f20b"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp311-cp311-macosx_10_12_x86_64.whl",
"has_sig": false,
"md5_digest": "e314bf6881e5ce722b7da7e7212079b4",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.7",
"size": 485550,
"upload_time": "2024-08-14T17:01:47",
"upload_time_iso_8601": "2024-08-14T17:01:47.189294Z",
"url": "https://files.pythonhosted.org/packages/8e/d4/8b992d8bedd4659a4586e51323f6aa568764bfe8ade10f57e116525e8c36/rencrypt-1.2.2-cp311-cp311-macosx_10_12_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "5d5664555d3d6c8abca52cc084a026960584ab9e79433df113d3d8890a32d4db",
"md5": "a521baf72942be1f5a5a5e637934dc35",
"sha256": "45b3621e9a86934269fcf1be1b57a998c0389df2b2ed328cb77d2bcffa266e04"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp311-cp311-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "a521baf72942be1f5a5a5e637934dc35",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.7",
"size": 346109,
"upload_time": "2024-08-14T17:01:41",
"upload_time_iso_8601": "2024-08-14T17:01:41.317095Z",
"url": "https://files.pythonhosted.org/packages/5d/56/64555d3d6c8abca52cc084a026960584ab9e79433df113d3d8890a32d4db/rencrypt-1.2.2-cp311-cp311-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "02badb6046a244f9ed04594e3c7992af180670943020c69c9b79a2cb37cc9ebe",
"md5": "e8568baf95e6c5d37ff3de5f07123dc5",
"sha256": "27a366e05705a8c3bb4f53d724d895368d1594225ef4c8b1bbc6b092f6a3aeb1"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl",
"has_sig": false,
"md5_digest": "e8568baf95e6c5d37ff3de5f07123dc5",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.7",
"size": 540299,
"upload_time": "2024-08-14T17:01:17",
"upload_time_iso_8601": "2024-08-14T17:01:17.451339Z",
"url": "https://files.pythonhosted.org/packages/02/ba/db6046a244f9ed04594e3c7992af180670943020c69c9b79a2cb37cc9ebe/rencrypt-1.2.2-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "d1ec80cf3e2c28058aed3c055afeec03461bfa4fcccbf756c21cfc63ebd5a171",
"md5": "23b59f644745c728f69627b603b9ed90",
"sha256": "2dced1a85f126b741c01b2b6ece8219e13240c41e6d33bf934efa4891492052b"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"has_sig": false,
"md5_digest": "23b59f644745c728f69627b603b9ed90",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.7",
"size": 513787,
"upload_time": "2024-08-14T17:00:28",
"upload_time_iso_8601": "2024-08-14T17:00:28.679473Z",
"url": "https://files.pythonhosted.org/packages/d1/ec/80cf3e2c28058aed3c055afeec03461bfa4fcccbf756c21cfc63ebd5a171/rencrypt-1.2.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "0218da0342178028bd3527c48557e5fefebcad31c42a43e98e3825a0126c9669",
"md5": "aa7c422ef9deeba18c2828ce11eafb14",
"sha256": "21f1b5c109b99ffd1c03c6cd705d64a3f4eb6419e81d1d51387f69917573dbbe"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"has_sig": false,
"md5_digest": "aa7c422ef9deeba18c2828ce11eafb14",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.7",
"size": 492878,
"upload_time": "2024-08-14T17:00:44",
"upload_time_iso_8601": "2024-08-14T17:00:44.597542Z",
"url": "https://files.pythonhosted.org/packages/02/18/da0342178028bd3527c48557e5fefebcad31c42a43e98e3825a0126c9669/rencrypt-1.2.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "860a7e9c64d60ae6d6eac88ea2fbfc0fb9304caea77776ad64fe224aa22c7506",
"md5": "134ac945744085a89b31156e54e0ca46",
"sha256": "fc90eeffad3ad24bdedfbc47ca4e6365869138598fe5e3599cb28b23c0b9542f"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"has_sig": false,
"md5_digest": "134ac945744085a89b31156e54e0ca46",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.7",
"size": 598627,
"upload_time": "2024-08-14T17:01:00",
"upload_time_iso_8601": "2024-08-14T17:01:00.656358Z",
"url": "https://files.pythonhosted.org/packages/86/0a/7e9c64d60ae6d6eac88ea2fbfc0fb9304caea77776ad64fe224aa22c7506/rencrypt-1.2.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "5f10d873d1167b91d0c6b292ce22a2ed9db1e42e21f782b1b9fcdcfe8b28a2cc",
"md5": "2e36e6c870ab8d7cd6fd14108efee668",
"sha256": "36ce62d26d38466e82ffe7c82201c76d902bd2229d7f458d086292a6a2fb672c"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "2e36e6c870ab8d7cd6fd14108efee668",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.7",
"size": 532018,
"upload_time": "2024-08-14T17:01:29",
"upload_time_iso_8601": "2024-08-14T17:01:29.576109Z",
"url": "https://files.pythonhosted.org/packages/5f/10/d873d1167b91d0c6b292ce22a2ed9db1e42e21f782b1b9fcdcfe8b28a2cc/rencrypt-1.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "7da1cf9e4d5da7daa89293e9623e88518409931bc345bd2ffd0225c674b1c489",
"md5": "d61394eaaf7925a4c77ba031229fd6d2",
"sha256": "04e733e980830fe70361321de2e996d0ce9227abe7b1097c8edf38723b4a1ca4"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp311-none-win_amd64.whl",
"has_sig": false,
"md5_digest": "d61394eaaf7925a4c77ba031229fd6d2",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.7",
"size": 363245,
"upload_time": "2024-08-14T17:01:55",
"upload_time_iso_8601": "2024-08-14T17:01:55.381844Z",
"url": "https://files.pythonhosted.org/packages/7d/a1/cf9e4d5da7daa89293e9623e88518409931bc345bd2ffd0225c674b1c489/rencrypt-1.2.2-cp311-none-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "2343fc7347acddda857d9a0534d9843b366136e37a9495a42d02b74cad542a9a",
"md5": "3d93f5af9cb793dc2dd6bf8f7ff9b7de",
"sha256": "f503945880b8863f4722611b8f3a2846b69f985548ce3a1002d46da2dba5c7e1"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp312-cp312-macosx_10_12_x86_64.whl",
"has_sig": false,
"md5_digest": "3d93f5af9cb793dc2dd6bf8f7ff9b7de",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.7",
"size": 483385,
"upload_time": "2024-08-14T17:01:48",
"upload_time_iso_8601": "2024-08-14T17:01:48.895798Z",
"url": "https://files.pythonhosted.org/packages/23/43/fc7347acddda857d9a0534d9843b366136e37a9495a42d02b74cad542a9a/rencrypt-1.2.2-cp312-cp312-macosx_10_12_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "cd8c9b427397293d4dbab2f37a494f54c83fa30165210de63e8df1c140f0e9e7",
"md5": "5c12302cedcf08925beb794cb336dbf4",
"sha256": "1cef1862a070cd4d4c1054ed19142c9c96faae851710c349020105c26d836c56"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp312-cp312-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "5c12302cedcf08925beb794cb336dbf4",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.7",
"size": 345071,
"upload_time": "2024-08-14T17:01:42",
"upload_time_iso_8601": "2024-08-14T17:01:42.609535Z",
"url": "https://files.pythonhosted.org/packages/cd/8c/9b427397293d4dbab2f37a494f54c83fa30165210de63e8df1c140f0e9e7/rencrypt-1.2.2-cp312-cp312-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "1eb25d2b3cef4d6793af2b387326eb2c59a91c81031d516c8eb26fc1e154607b",
"md5": "07a0d6571c235e11f8fa9b703b0205cc",
"sha256": "069b02a8b5b123c2984c9d92a240acce2051b200c579996fbf4bc502af5ee08a"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl",
"has_sig": false,
"md5_digest": "07a0d6571c235e11f8fa9b703b0205cc",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.7",
"size": 538752,
"upload_time": "2024-08-14T17:01:19",
"upload_time_iso_8601": "2024-08-14T17:01:19.198282Z",
"url": "https://files.pythonhosted.org/packages/1e/b2/5d2b3cef4d6793af2b387326eb2c59a91c81031d516c8eb26fc1e154607b/rencrypt-1.2.2-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "a65022e2a5904104da208460540680573c26074bd8050d79cad73e5e7fa626f1",
"md5": "47aed6260803f085e93802dbae0a07cd",
"sha256": "38289d81ce75fb62ecce2b64ac19ff53f71413edc932287993e453f1a216aa27"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"has_sig": false,
"md5_digest": "47aed6260803f085e93802dbae0a07cd",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.7",
"size": 512999,
"upload_time": "2024-08-14T17:00:31",
"upload_time_iso_8601": "2024-08-14T17:00:31.065645Z",
"url": "https://files.pythonhosted.org/packages/a6/50/22e2a5904104da208460540680573c26074bd8050d79cad73e5e7fa626f1/rencrypt-1.2.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "5e640c48f47905f097151feef26ce31a1824fc17bb6c4b245754d7227f2f5e08",
"md5": "913f762ee4bf6450d8b37470748008fc",
"sha256": "88ab1a4e6125b0fac252f04e6c11e1e626945cf05c0259570d49a35a9adbb4ed"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"has_sig": false,
"md5_digest": "913f762ee4bf6450d8b37470748008fc",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.7",
"size": 490586,
"upload_time": "2024-08-14T17:00:45",
"upload_time_iso_8601": "2024-08-14T17:00:45.765059Z",
"url": "https://files.pythonhosted.org/packages/5e/64/0c48f47905f097151feef26ce31a1824fc17bb6c4b245754d7227f2f5e08/rencrypt-1.2.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "32d2527bbb6df7e9918afc913b1ce2f5e7061adca5deafc4df0db4e13448bbc9",
"md5": "55e60154797ab15bd197c53a24455b99",
"sha256": "950dd42c680fed1bd8f00ee2d0cf158f3f9042ca8f55b714e1ac92183d5a2500"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"has_sig": false,
"md5_digest": "55e60154797ab15bd197c53a24455b99",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.7",
"size": 601373,
"upload_time": "2024-08-14T17:01:02",
"upload_time_iso_8601": "2024-08-14T17:01:02.287632Z",
"url": "https://files.pythonhosted.org/packages/32/d2/527bbb6df7e9918afc913b1ce2f5e7061adca5deafc4df0db4e13448bbc9/rencrypt-1.2.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "cc1f6324de2a16fd8ebb2f7a02cb3e4a9cb1a6f16b89f5f4c9bc49019479985c",
"md5": "d7acb0375948dd9dfda76ef18218e7f5",
"sha256": "4b6f3de39ead1a7fe66f3eba7e09fa02b3e962575fafc91345cc4c1de6a7dcb9"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "d7acb0375948dd9dfda76ef18218e7f5",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.7",
"size": 528211,
"upload_time": "2024-08-14T17:01:31",
"upload_time_iso_8601": "2024-08-14T17:01:31.370594Z",
"url": "https://files.pythonhosted.org/packages/cc/1f/6324de2a16fd8ebb2f7a02cb3e4a9cb1a6f16b89f5f4c9bc49019479985c/rencrypt-1.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "b5ae2dbf13744fa38ca190323ffe8d302c6fb2972d286f4cd19887beb44047f0",
"md5": "fc2652af375c5b8056e5ea2b21d2d92e",
"sha256": "54c6c918a40be2e17208f01fee9f6f945c424d4b7762a96c6d1bd0a7c7bdc6fd"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp312-none-win_amd64.whl",
"has_sig": false,
"md5_digest": "fc2652af375c5b8056e5ea2b21d2d92e",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.7",
"size": 361793,
"upload_time": "2024-08-14T17:01:56",
"upload_time_iso_8601": "2024-08-14T17:01:56.607228Z",
"url": "https://files.pythonhosted.org/packages/b5/ae/2dbf13744fa38ca190323ffe8d302c6fb2972d286f4cd19887beb44047f0/rencrypt-1.2.2-cp312-none-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "4c5c7459801d00f94f1be2c1a86758a4b4dd1e7a12618265c4256608407ecade",
"md5": "a53df7ec5af1338454ab2df28eb4fc8a",
"sha256": "20735c29b8b64fccb313c3422ba8ddcbd754cdd16e7f7fc4dd9e797c770e4427"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl",
"has_sig": false,
"md5_digest": "a53df7ec5af1338454ab2df28eb4fc8a",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": ">=3.7",
"size": 540748,
"upload_time": "2024-08-14T17:01:20",
"upload_time_iso_8601": "2024-08-14T17:01:20.991733Z",
"url": "https://files.pythonhosted.org/packages/4c/5c/7459801d00f94f1be2c1a86758a4b4dd1e7a12618265c4256608407ecade/rencrypt-1.2.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "e677ddd89ddc44662ab049846bf85f17f9dc08c2df898ae9d99a4fa6f6818308",
"md5": "639d3e1f1f2721c4736c29520765ac1d",
"sha256": "ff2420fd96073adfb915ec0ef1fab48a20d9c6db85f9ae1765c20cb9babb514d"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp37-cp37m-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"has_sig": false,
"md5_digest": "639d3e1f1f2721c4736c29520765ac1d",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": ">=3.7",
"size": 514117,
"upload_time": "2024-08-14T17:00:32",
"upload_time_iso_8601": "2024-08-14T17:00:32.866408Z",
"url": "https://files.pythonhosted.org/packages/e6/77/ddd89ddc44662ab049846bf85f17f9dc08c2df898ae9d99a4fa6f6818308/rencrypt-1.2.2-cp37-cp37m-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "9a52d1c709d2c7275e10990447d82e97cb2d955c70fbfa8b637f6a5b1013a7a6",
"md5": "19c229264054bd3335786ae5cb0eac67",
"sha256": "260349b85794c991fdfd47a037aa9abf877105c9463a172d9ebb2ba232b011b0"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"has_sig": false,
"md5_digest": "19c229264054bd3335786ae5cb0eac67",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": ">=3.7",
"size": 492847,
"upload_time": "2024-08-14T17:00:47",
"upload_time_iso_8601": "2024-08-14T17:00:47.420524Z",
"url": "https://files.pythonhosted.org/packages/9a/52/d1c709d2c7275e10990447d82e97cb2d955c70fbfa8b637f6a5b1013a7a6/rencrypt-1.2.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "00ddf14f11c91edff32fdbb8c32aab4eb41d2b015001f4a21c6a58e05ffaa686",
"md5": "13fd705130463ac757687e1e27251240",
"sha256": "b046dd5ed41ca52a32f1804da763b789dbce587a890b63526c9bc54f0a752221"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"has_sig": false,
"md5_digest": "13fd705130463ac757687e1e27251240",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": ">=3.7",
"size": 600632,
"upload_time": "2024-08-14T17:01:03",
"upload_time_iso_8601": "2024-08-14T17:01:03.775422Z",
"url": "https://files.pythonhosted.org/packages/00/dd/f14f11c91edff32fdbb8c32aab4eb41d2b015001f4a21c6a58e05ffaa686/rencrypt-1.2.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "64bf5480948778cbf18a39109e67e3ff025091f8da529b331cbeee8bfe4c8de3",
"md5": "371a94159ba3ee29e3e400d0ccd9530a",
"sha256": "61444a0bd2b4b9c29e152bd30e92b4abec4426289fc7d552880fe8a8c6031737"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "371a94159ba3ee29e3e400d0ccd9530a",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": ">=3.7",
"size": 532664,
"upload_time": "2024-08-14T17:01:33",
"upload_time_iso_8601": "2024-08-14T17:01:33.054254Z",
"url": "https://files.pythonhosted.org/packages/64/bf/5480948778cbf18a39109e67e3ff025091f8da529b331cbeee8bfe4c8de3/rencrypt-1.2.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "15f48239c0de7e7ff4e525ca1d3bf8501d15f6736b0f41bcfab4fcf7af62ad89",
"md5": "1c9e5cc2817f8faa0980301c20c8dd67",
"sha256": "a1bce70efdceef224d5c01e3796256f6f67507f1abe70f9d71ce903ce0d29ca6"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp37-none-win_amd64.whl",
"has_sig": false,
"md5_digest": "1c9e5cc2817f8faa0980301c20c8dd67",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": ">=3.7",
"size": 363255,
"upload_time": "2024-08-14T17:01:57",
"upload_time_iso_8601": "2024-08-14T17:01:57.804997Z",
"url": "https://files.pythonhosted.org/packages/15/f4/8239c0de7e7ff4e525ca1d3bf8501d15f6736b0f41bcfab4fcf7af62ad89/rencrypt-1.2.2-cp37-none-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "b30d426fe1db7a7176be3a504c04c4a1430a2d2de2081d554067901435690488",
"md5": "5adb70d2d24a8745d6a4f3b26156aba7",
"sha256": "9090b91a29527fdb409d6301bab5be0b7b0fac8f787546d0dccf5de6270b3ff7"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl",
"has_sig": false,
"md5_digest": "5adb70d2d24a8745d6a4f3b26156aba7",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.7",
"size": 541034,
"upload_time": "2024-08-14T17:01:22",
"upload_time_iso_8601": "2024-08-14T17:01:22.238145Z",
"url": "https://files.pythonhosted.org/packages/b3/0d/426fe1db7a7176be3a504c04c4a1430a2d2de2081d554067901435690488/rencrypt-1.2.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "db7fd03d1eec2b4c66685927e9d704de0274f5d9c79a9560ce296deba56ebe3e",
"md5": "27fad43dd75ce628d1b46fa337c32011",
"sha256": "0d78f4263cc12d5d1e8d2afbee27750db8486822f2e631b499501020d5da9674"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"has_sig": false,
"md5_digest": "27fad43dd75ce628d1b46fa337c32011",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.7",
"size": 514598,
"upload_time": "2024-08-14T17:00:34",
"upload_time_iso_8601": "2024-08-14T17:00:34.139437Z",
"url": "https://files.pythonhosted.org/packages/db/7f/d03d1eec2b4c66685927e9d704de0274f5d9c79a9560ce296deba56ebe3e/rencrypt-1.2.2-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "d5b1c28c5ec73a16a1972e04a1dd8b30437dfd4306c2ff8ab723715ac7d80013",
"md5": "67e36858ec556a92edd10953e201345a",
"sha256": "a235d8c0a57d11a7ae96fbc67bf153e2c9adf175e44d5e839f956eb1fa247cbe"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"has_sig": false,
"md5_digest": "67e36858ec556a92edd10953e201345a",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.7",
"size": 492986,
"upload_time": "2024-08-14T17:00:49",
"upload_time_iso_8601": "2024-08-14T17:00:49.063418Z",
"url": "https://files.pythonhosted.org/packages/d5/b1/c28c5ec73a16a1972e04a1dd8b30437dfd4306c2ff8ab723715ac7d80013/rencrypt-1.2.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "eef9ad4fc62bd68da955e8207733a3a702bd5794f79688db489ed922ef96b634",
"md5": "7dcfa9e68edeb828c6e30893313c51e8",
"sha256": "220b3dded13e341de4e87f76851571b85dc492a51321f28c2737f2a6d7cc8b63"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"has_sig": false,
"md5_digest": "7dcfa9e68edeb828c6e30893313c51e8",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.7",
"size": 599693,
"upload_time": "2024-08-14T17:01:05",
"upload_time_iso_8601": "2024-08-14T17:01:05.581820Z",
"url": "https://files.pythonhosted.org/packages/ee/f9/ad4fc62bd68da955e8207733a3a702bd5794f79688db489ed922ef96b634/rencrypt-1.2.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "06f8931a8deda7232b796610452ddb1c7d2e0450860738c1a3028514c66b02a4",
"md5": "0dbebcbcd28f71046edb4b750ccede04",
"sha256": "5511918200bc40e7bd75ad02c3db4540fa651902019e518a7e4932158d4c781c"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "0dbebcbcd28f71046edb4b750ccede04",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.7",
"size": 532595,
"upload_time": "2024-08-14T17:01:34",
"upload_time_iso_8601": "2024-08-14T17:01:34.626751Z",
"url": "https://files.pythonhosted.org/packages/06/f8/931a8deda7232b796610452ddb1c7d2e0450860738c1a3028514c66b02a4/rencrypt-1.2.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "f4dae5735c37bc75ea4d64676b0c68f6357d0fbdf5892eeebb136313cdcb0296",
"md5": "df03a8f17bb2a967794819f428d5fb79",
"sha256": "cdded4e4e6267417c7e5647075eb0a96e8a272ba6eb74a2eef628d00ce7cf899"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp38-none-win_amd64.whl",
"has_sig": false,
"md5_digest": "df03a8f17bb2a967794819f428d5fb79",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.7",
"size": 363208,
"upload_time": "2024-08-14T17:01:59",
"upload_time_iso_8601": "2024-08-14T17:01:59.198575Z",
"url": "https://files.pythonhosted.org/packages/f4/da/e5735c37bc75ea4d64676b0c68f6357d0fbdf5892eeebb136313cdcb0296/rencrypt-1.2.2-cp38-none-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "3c50b344e1c3e9efb8b378360e720e802313d078fabf7adcea454f0efdc7451a",
"md5": "2c912200f49b291c27c215b399dd0ba2",
"sha256": "bccabe9e7feb34743367aa106c4a20700342df253a41afb4aba9a0cd169929bb"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp39-cp39-macosx_10_12_x86_64.whl",
"has_sig": false,
"md5_digest": "2c912200f49b291c27c215b399dd0ba2",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.7",
"size": 485059,
"upload_time": "2024-08-14T17:01:51",
"upload_time_iso_8601": "2024-08-14T17:01:51.848401Z",
"url": "https://files.pythonhosted.org/packages/3c/50/b344e1c3e9efb8b378360e720e802313d078fabf7adcea454f0efdc7451a/rencrypt-1.2.2-cp39-cp39-macosx_10_12_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "be19bdf844ad8a3dbe1ae7cad53d53814a4262a1cec746763e12a975233028fa",
"md5": "94aafad84a6b6364431d57a3e59c3a01",
"sha256": "e9d467642ca89b8724056e313de9285ab66d925d1a0fdcd4bec24953a99d5416"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp39-cp39-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "94aafad84a6b6364431d57a3e59c3a01",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.7",
"size": 346381,
"upload_time": "2024-08-14T17:01:44",
"upload_time_iso_8601": "2024-08-14T17:01:44.009085Z",
"url": "https://files.pythonhosted.org/packages/be/19/bdf844ad8a3dbe1ae7cad53d53814a4262a1cec746763e12a975233028fa/rencrypt-1.2.2-cp39-cp39-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "5a1ca2cb0a67d883b1870d8b484a16ab61ff9d6ef7734c405317cae1c166c47f",
"md5": "a7fad8fa79748718dd6e7bf63ada4f0b",
"sha256": "8fe0274cbb87cbbe82ea4ea71aee3ed6ba097f95080aa568ab28c9206d9f4778"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl",
"has_sig": false,
"md5_digest": "a7fad8fa79748718dd6e7bf63ada4f0b",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.7",
"size": 540878,
"upload_time": "2024-08-14T17:01:24",
"upload_time_iso_8601": "2024-08-14T17:01:24.073837Z",
"url": "https://files.pythonhosted.org/packages/5a/1c/a2cb0a67d883b1870d8b484a16ab61ff9d6ef7734c405317cae1c166c47f/rencrypt-1.2.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "1526219478e60ca73ac94b0e117d875f4a3a30936a2d1d0b04381a778c181656",
"md5": "0d4b14df38dc007c284f0856322afd04",
"sha256": "be15816b5b1952a165ad67111fc24b91cd2cc07b1e91713747d188057b681752"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"has_sig": false,
"md5_digest": "0d4b14df38dc007c284f0856322afd04",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.7",
"size": 514592,
"upload_time": "2024-08-14T17:00:35",
"upload_time_iso_8601": "2024-08-14T17:00:35.503687Z",
"url": "https://files.pythonhosted.org/packages/15/26/219478e60ca73ac94b0e117d875f4a3a30936a2d1d0b04381a778c181656/rencrypt-1.2.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "8ff486f37866d32e471f2ecc4ddc1161a132ac46d197e92d372ac7f90072abda",
"md5": "8174eb296dd64cb51b48ed0cbf2423fa",
"sha256": "6f5d50aa345eb54874dbd194a57a8e5bf10b372a24e4959fdfd627f44707d48f"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"has_sig": false,
"md5_digest": "8174eb296dd64cb51b48ed0cbf2423fa",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.7",
"size": 492916,
"upload_time": "2024-08-14T17:00:50",
"upload_time_iso_8601": "2024-08-14T17:00:50.750132Z",
"url": "https://files.pythonhosted.org/packages/8f/f4/86f37866d32e471f2ecc4ddc1161a132ac46d197e92d372ac7f90072abda/rencrypt-1.2.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "5aa28cdee4cda757510d2c321229713b3ad3d8f632984e26fba237016d01a16b",
"md5": "b1f44853d30854048196f39e46c4cb84",
"sha256": "a964f04841a2fc7b78b23cda75ae70a8ef3ce854cc99551eb3d02904d07bb448"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"has_sig": false,
"md5_digest": "b1f44853d30854048196f39e46c4cb84",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.7",
"size": 599691,
"upload_time": "2024-08-14T17:01:07",
"upload_time_iso_8601": "2024-08-14T17:01:07.009692Z",
"url": "https://files.pythonhosted.org/packages/5a/a2/8cdee4cda757510d2c321229713b3ad3d8f632984e26fba237016d01a16b/rencrypt-1.2.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "89b52d343bd167d3c3c51db1d651ef70bc60674d0066b4b3800308a2c0ce034e",
"md5": "c5663efc597ea3573b4b7f3092ec76b7",
"sha256": "67fde306d30131d37b0bfcca78840a5b60b5ae43fa65117afe8afb8846f531c6"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "c5663efc597ea3573b4b7f3092ec76b7",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.7",
"size": 532399,
"upload_time": "2024-08-14T17:01:35",
"upload_time_iso_8601": "2024-08-14T17:01:35.910123Z",
"url": "https://files.pythonhosted.org/packages/89/b5/2d343bd167d3c3c51db1d651ef70bc60674d0066b4b3800308a2c0ce034e/rencrypt-1.2.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "73de6fe4b93a1dc2bea608bc84f28997f88ac0614fb23c09a38eb2845c4b6fc9",
"md5": "6f535333d74e29fcf8c71d461036c4b7",
"sha256": "8c28a76e83f1264b1602888eea719b51dcfcc8785d51ae061fd87d5a8cb78170"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-cp39-none-win_amd64.whl",
"has_sig": false,
"md5_digest": "6f535333d74e29fcf8c71d461036c4b7",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.7",
"size": 362985,
"upload_time": "2024-08-14T17:02:00",
"upload_time_iso_8601": "2024-08-14T17:02:00.898435Z",
"url": "https://files.pythonhosted.org/packages/73/de/6fe4b93a1dc2bea608bc84f28997f88ac0614fb23c09a38eb2845c4b6fc9/rencrypt-1.2.2-cp39-none-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "7d4d54b9f790fb30c58ed33767bc622624a6447c3ad2fdfbc523502daf60ebae",
"md5": "c54c4ef56b3cf3c5be7e79455d0d45d3",
"sha256": "74f36e3a54dcd5ae5171ec21a6547abba7fd46209b97f6f1df2141c0bf1878d6"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.whl",
"has_sig": false,
"md5_digest": "c54c4ef56b3cf3c5be7e79455d0d45d3",
"packagetype": "bdist_wheel",
"python_version": "pp310",
"requires_python": ">=3.7",
"size": 539407,
"upload_time": "2024-08-14T17:01:25",
"upload_time_iso_8601": "2024-08-14T17:01:25.542608Z",
"url": "https://files.pythonhosted.org/packages/7d/4d/54b9f790fb30c58ed33767bc622624a6447c3ad2fdfbc523502daf60ebae/rencrypt-1.2.2-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "ee24af7a525a3f16df3ad07c6ed005d2ae2aeebda2b398a0612617fa7a939b36",
"md5": "f49a9124a9d88324b84fe9319553538a",
"sha256": "da377ed1c22ea9d3fa4ce2a5c1ccfde801600583c1840c573f7f7b56b9688875"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"has_sig": false,
"md5_digest": "f49a9124a9d88324b84fe9319553538a",
"packagetype": "bdist_wheel",
"python_version": "pp310",
"requires_python": ">=3.7",
"size": 512549,
"upload_time": "2024-08-14T17:00:36",
"upload_time_iso_8601": "2024-08-14T17:00:36.949882Z",
"url": "https://files.pythonhosted.org/packages/ee/24/af7a525a3f16df3ad07c6ed005d2ae2aeebda2b398a0612617fa7a939b36/rencrypt-1.2.2-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "7b4b53f2c69871d07f390020b08f6a5b10160000ecf228b16bd46e8d677cddc3",
"md5": "851b4578ecca80f81e3b79b43aa5b34c",
"sha256": "4694189f2cd10fa7878ea84efc04d4311e84ffabfa6db5c2a23b0abcd882fb3e"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"has_sig": false,
"md5_digest": "851b4578ecca80f81e3b79b43aa5b34c",
"packagetype": "bdist_wheel",
"python_version": "pp310",
"requires_python": ">=3.7",
"size": 491806,
"upload_time": "2024-08-14T17:00:52",
"upload_time_iso_8601": "2024-08-14T17:00:52.489443Z",
"url": "https://files.pythonhosted.org/packages/7b/4b/53f2c69871d07f390020b08f6a5b10160000ecf228b16bd46e8d677cddc3/rencrypt-1.2.2-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "adc0ceca89dc058c27553e2389d6c132cd1194799131ded2cbe11d8cb3267421",
"md5": "4a45ebf0726d801142823282ac3cb47c",
"sha256": "0ad3f19e4a29246c2eed3f0e005568f5d34a439bdb81e2e2d72cd0e2cee497fc"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"has_sig": false,
"md5_digest": "4a45ebf0726d801142823282ac3cb47c",
"packagetype": "bdist_wheel",
"python_version": "pp310",
"requires_python": ">=3.7",
"size": 598394,
"upload_time": "2024-08-14T17:01:08",
"upload_time_iso_8601": "2024-08-14T17:01:08.959635Z",
"url": "https://files.pythonhosted.org/packages/ad/c0/ceca89dc058c27553e2389d6c132cd1194799131ded2cbe11d8cb3267421/rencrypt-1.2.2-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "3b68d965495c734314def5073e6894ac790c518bd3939904b91a2f12ca766bb1",
"md5": "67a681117c95a30d037a147485663396",
"sha256": "7e2b0eca8b14d2d8ec9d1e6dbee5e7e111a3ae101d4d14da5f25fb97fc0eb3bc"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "67a681117c95a30d037a147485663396",
"packagetype": "bdist_wheel",
"python_version": "pp310",
"requires_python": ">=3.7",
"size": 530276,
"upload_time": "2024-08-14T17:01:37",
"upload_time_iso_8601": "2024-08-14T17:01:37.238053Z",
"url": "https://files.pythonhosted.org/packages/3b/68/d965495c734314def5073e6894ac790c518bd3939904b91a2f12ca766bb1/rencrypt-1.2.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "b44e371fc88db2acea04e855eb90449c827620b714051f1ad4b81bc58bc9c84c",
"md5": "791be9c30fffe8ff9468a12884312ddf",
"sha256": "4969c660ba7974f51e112e094d37a226870f250ac788f3d108b68e381c695df5"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp37-pypy37_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"has_sig": false,
"md5_digest": "791be9c30fffe8ff9468a12884312ddf",
"packagetype": "bdist_wheel",
"python_version": "pp37",
"requires_python": ">=3.7",
"size": 515971,
"upload_time": "2024-08-14T17:00:38",
"upload_time_iso_8601": "2024-08-14T17:00:38.535807Z",
"url": "https://files.pythonhosted.org/packages/b4/4e/371fc88db2acea04e855eb90449c827620b714051f1ad4b81bc58bc9c84c/rencrypt-1.2.2-pp37-pypy37_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "87cd04ec88753f8d2b33c4846ee5af0ec0eafac94150e513b98ebde92d223942",
"md5": "8d345f0b022f459e732779c49d155856",
"sha256": "b8dcf619147b2a6035e88bbb64ee8198bf11ab9f250257066076c23b60cb2e86"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp37-pypy37_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"has_sig": false,
"md5_digest": "8d345f0b022f459e732779c49d155856",
"packagetype": "bdist_wheel",
"python_version": "pp37",
"requires_python": ">=3.7",
"size": 494524,
"upload_time": "2024-08-14T17:00:54",
"upload_time_iso_8601": "2024-08-14T17:00:54.238269Z",
"url": "https://files.pythonhosted.org/packages/87/cd/04ec88753f8d2b33c4846ee5af0ec0eafac94150e513b98ebde92d223942/rencrypt-1.2.2-pp37-pypy37_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "6af00ed43c5f690f4bbe7f4e7ed0c4f964b24511a33d41124b971922d33dc65d",
"md5": "c5c88efcca6074de6f00a0bb2637ee43",
"sha256": "15736a843e77d1f1566bf2bdbc83cf679544323f4761d81752611262845de323"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp37-pypy37_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"has_sig": false,
"md5_digest": "c5c88efcca6074de6f00a0bb2637ee43",
"packagetype": "bdist_wheel",
"python_version": "pp37",
"requires_python": ">=3.7",
"size": 600767,
"upload_time": "2024-08-14T17:01:10",
"upload_time_iso_8601": "2024-08-14T17:01:10.995433Z",
"url": "https://files.pythonhosted.org/packages/6a/f0/0ed43c5f690f4bbe7f4e7ed0c4f964b24511a33d41124b971922d33dc65d/rencrypt-1.2.2-pp37-pypy37_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "dd7c5c76fe31d63daebe9759a63447670092a8fdee84ee603add26bd8f48c2f9",
"md5": "eb215d51be1d7ae3fd2806fd7ce38008",
"sha256": "9f0637bdfa234db30e565b00803de82333c36ddcb6c1b6a727c1b2a38af46998"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"has_sig": false,
"md5_digest": "eb215d51be1d7ae3fd2806fd7ce38008",
"packagetype": "bdist_wheel",
"python_version": "pp38",
"requires_python": ">=3.7",
"size": 513929,
"upload_time": "2024-08-14T17:00:39",
"upload_time_iso_8601": "2024-08-14T17:00:39.957628Z",
"url": "https://files.pythonhosted.org/packages/dd/7c/5c76fe31d63daebe9759a63447670092a8fdee84ee603add26bd8f48c2f9/rencrypt-1.2.2-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "b574959edf8a669aef3e466b0051a8528912d0c6232f291edcdbf084aa9f3b5e",
"md5": "eb63b0036f953448397ca88c9519b130",
"sha256": "a9a524ab8ffa915e33e8070f586d3f1be68b9cedc00ba7d068dad33ac4c509fe"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"has_sig": false,
"md5_digest": "eb63b0036f953448397ca88c9519b130",
"packagetype": "bdist_wheel",
"python_version": "pp38",
"requires_python": ">=3.7",
"size": 492926,
"upload_time": "2024-08-14T17:00:55",
"upload_time_iso_8601": "2024-08-14T17:00:55.925038Z",
"url": "https://files.pythonhosted.org/packages/b5/74/959edf8a669aef3e466b0051a8528912d0c6232f291edcdbf084aa9f3b5e/rencrypt-1.2.2-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "7e0a6f76df320ac26cc93aa0eb22219e4d0ee9673c7fdc4bf05b458793550f52",
"md5": "a9fed0801d7b1644212d6a6f1f66c958",
"sha256": "1accedcb2b559136167e9918fa073897308511ff82eaef7960ad5c3dd75e144c"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"has_sig": false,
"md5_digest": "a9fed0801d7b1644212d6a6f1f66c958",
"packagetype": "bdist_wheel",
"python_version": "pp38",
"requires_python": ">=3.7",
"size": 599659,
"upload_time": "2024-08-14T17:01:12",
"upload_time_iso_8601": "2024-08-14T17:01:12.674911Z",
"url": "https://files.pythonhosted.org/packages/7e/0a/6f76df320ac26cc93aa0eb22219e4d0ee9673c7fdc4bf05b458793550f52/rencrypt-1.2.2-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "ffdce9f0adee424e2280be8afd5602e8d258fa3051f75f06327ce134d38cf3d3",
"md5": "45ad91a16c78c2499225fe3be2dd3cb0",
"sha256": "36fc48a5f9fd4e4bd845243b46b36ed7d607a2e102520e3222ff9b2d8872355b"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.whl",
"has_sig": false,
"md5_digest": "45ad91a16c78c2499225fe3be2dd3cb0",
"packagetype": "bdist_wheel",
"python_version": "pp39",
"requires_python": ">=3.7",
"size": 540081,
"upload_time": "2024-08-14T17:01:26",
"upload_time_iso_8601": "2024-08-14T17:01:26.776542Z",
"url": "https://files.pythonhosted.org/packages/ff/dc/e9f0adee424e2280be8afd5602e8d258fa3051f75f06327ce134d38cf3d3/rencrypt-1.2.2-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "9ad15cde7366d962f1c433ba3365806f58f99dc3b037936106121211be38bb01",
"md5": "561ee179dd46b64073e19b21ed118a5a",
"sha256": "5ce97ae0a9b5833e815e11d844ff4a56df93aa2e1e97288a0154c6a8a8084994"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"has_sig": false,
"md5_digest": "561ee179dd46b64073e19b21ed118a5a",
"packagetype": "bdist_wheel",
"python_version": "pp39",
"requires_python": ">=3.7",
"size": 513657,
"upload_time": "2024-08-14T17:00:41",
"upload_time_iso_8601": "2024-08-14T17:00:41.591367Z",
"url": "https://files.pythonhosted.org/packages/9a/d1/5cde7366d962f1c433ba3365806f58f99dc3b037936106121211be38bb01/rencrypt-1.2.2-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "236707e0c9b795158f030d672fe55b811a5f6ccc3dece5a0d40622b379ebe0db",
"md5": "3a8dab058fabc6c23fe4e90df51dc3f9",
"sha256": "0747fe69e514541acd9cdb0145caba2374e55e5af2257cb56c5a196d979b822a"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"has_sig": false,
"md5_digest": "3a8dab058fabc6c23fe4e90df51dc3f9",
"packagetype": "bdist_wheel",
"python_version": "pp39",
"requires_python": ">=3.7",
"size": 492810,
"upload_time": "2024-08-14T17:00:57",
"upload_time_iso_8601": "2024-08-14T17:00:57.246244Z",
"url": "https://files.pythonhosted.org/packages/23/67/07e0c9b795158f030d672fe55b811a5f6ccc3dece5a0d40622b379ebe0db/rencrypt-1.2.2-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "b7f0dd83a0d00cf123c7e87251640282fa93424ce5f30a2c91de6c36929a4f6b",
"md5": "779e57748a3a444efaab650a1506a7a6",
"sha256": "a25f1b0c35af1614142bf552e9d9b55dc8b532251065e4b00b86db28a7036636"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"has_sig": false,
"md5_digest": "779e57748a3a444efaab650a1506a7a6",
"packagetype": "bdist_wheel",
"python_version": "pp39",
"requires_python": ">=3.7",
"size": 600012,
"upload_time": "2024-08-14T17:01:14",
"upload_time_iso_8601": "2024-08-14T17:01:14.288433Z",
"url": "https://files.pythonhosted.org/packages/b7/f0/dd83a0d00cf123c7e87251640282fa93424ce5f30a2c91de6c36929a4f6b/rencrypt-1.2.2-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "aaeefad009f66ef45caeda7297c107a7598a70702c5dc448a4191d12f3bba772",
"md5": "4d200173b042642874c947c31555e0cc",
"sha256": "9a888d8af81394aa136032a3109fd3cae766833cf4bc8192cc95353df3cabd99"
},
"downloads": -1,
"filename": "rencrypt-1.2.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "4d200173b042642874c947c31555e0cc",
"packagetype": "bdist_wheel",
"python_version": "pp39",
"requires_python": ">=3.7",
"size": 531718,
"upload_time": "2024-08-14T17:01:38",
"upload_time_iso_8601": "2024-08-14T17:01:38.698339Z",
"url": "https://files.pythonhosted.org/packages/aa/ee/fad009f66ef45caeda7297c107a7598a70702c5dc448a4191d12f3bba772/rencrypt-1.2.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "4f2491f4932479cdb8141a2eda56423b2f054a9d62567355e7a63271c373a676",
"md5": "e3ab018b589ad2820c4482b0de5569f4",
"sha256": "11e747a46012fcea9582e1060564a57ca01d0fee4fb5836e66febe4856878c3e"
},
"downloads": -1,
"filename": "rencrypt-1.2.2.tar.gz",
"has_sig": false,
"md5_digest": "e3ab018b589ad2820c4482b0de5569f4",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.7",
"size": 290478,
"upload_time": "2024-08-14T17:01:53",
"upload_time_iso_8601": "2024-08-14T17:01:53.099959Z",
"url": "https://files.pythonhosted.org/packages/4f/24/91f4932479cdb8141a2eda56423b2f054a9d62567355e7a63271c373a676/rencrypt-1.2.2.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-08-14 17:01:53",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "radumarias",
"github_project": "rencrypt-python",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "maturin",
"specs": []
},
{
"name": "numpy",
"specs": []
},
{
"name": "zeroize",
"specs": [
[
">=",
"0.2.0"
]
]
},
{
"name": "pytest",
"specs": []
}
],
"lcname": "rencrypt"
}
JSON
