Knogle
commented
3 months ago Maybe some interesting insight. We've had an issue with a buffer overflow of bufpos. I think there was too much data, so it wasn't synced properly and fast enough, and caused the other parameters to corrupt, causing access on not-initialized memory. This one was important to me to fix, because i think a crypto-secure PRNG with good speed is an important thing! CPUs starting from Westmere-EP with AES-Ni can benefit from it. Better than the SHA solution.
==40641== Conditional jump or move depends on uninitialised value(s)
==40641== at 0x4B9F565: CRYPTO_ctr128_encrypt_ctr32 (ctr128.c:183)
==40641== by 0x4C655A1: ossl_cipher_hw_generic_ctr (ciphercommon_hw.c:117)
==40641== by 0x4C60FCC: ossl_cipher_generic_stream_update (ciphercommon.c:469)
==40641== by 0x4B61076: EVP_EncryptUpdate (evp_enc.c:643)
==40641== by 0x414314: aes_ctr_prng_genrand_uint128_to_buf (aes_ctr_prng.c:133)
==40641== by 0x417F5F: nwipe_aes_ctr_prng_read (prng.c:293)So i've used a temporary buffer now, and i'm writing 4x 32-Bit values now. It's decreasing the performance slightly, but ensures memory safety now. Speed is still fast enough, considering the excellt quality of the random numbers, passing all tests without fail.
Before:
void aes_ctr_prng_genrand_uint128_to_buf(aes_ctr_state_t* state, unsigned char* bufpos) {
int outlen;
EVP_EncryptUpdate(state->ctx, bufpos, &outlen, bufpos, 16);
// OpenSSL internally calls CRYPTO_ctr128_encrypt_ctr32
}After:
/* Generates pseudorandom numbers and writes them to a buffer.
- state: Pointer to the initialized AES CTR PRNG state.
- bufpos: Target buffer where the pseudorandom numbers will be written. */
void aes_ctr_prng_genrand_uint128_to_buf( aes_ctr_state_t* state, unsigned char* bufpos )
{
unsigned char temp_buffer[16]; /* Intermediate buffer for 128 bits */
int outlen;
/* Generate pseudorandom numbers in the intermediate buffer */
EVP_EncryptUpdate( state->ctx, temp_buffer, &outlen, temp_buffer, sizeof( temp_buffer ) );
/* Write the data from the intermediate buffer to bufpos in four 32-bit steps.
This process is crucial to prevent a buffer overflow of bufpos, as it ensures
that exactly 16 bytes (128 bits) of pseudorandom data are safely transferred
into bufpos. Copying the data in controlled 32-bit segments allows for precise
management of the memory space allocated to bufpos, mitigating the risk of
writing beyond its allocated size. */
int i = 0;
while( i < 4 )
{
/* Copy each 32-bit segment from the intermediate buffer to the target buffer.
This step-by-step approach is essential for maintaining the integrity of
the buffer and ensuring that only the intended amount of data is written.
The ternary operator is used here for illustrative purposes and does not
alter the functionality. */
memcpy( bufpos + ( i * 4 ), temp_buffer + ( i * 4 ), 4 );
i = ( i < 4 ) ? i + 1 : 4; // Ternary operator to increment i or keep it at 4
}
}And it delivers incredible performance.
PartialVolume
In this pull request, I present my implementation of a pseudo-random number generator (PRNG) utilizing the AES-CTR (Advanced Encryption Standard - Counter mode) in 128-bit mode. This implementation is designed to produce high-quality random numbers, which are essential for a wide range of cryptographic applications. By integrating with the OpenSSL library and exploiting AES-NI (Advanced Encryption Standard New Instructions) hardware acceleration when available, I ensure both the security and efficiency of the random number generation process. It provides the highest-quality of PRNGs yet for NWIPE, and is a CSPRNG.
Key Features:
Implementation Details:
This PRNG implementation stands as a robust and efficient tool for generating high-quality pseudo-random numbers, crucial for cryptographic operations, secure communications, and randomized algorithms. The combination of AES-CTR mode, OpenSSL's reliability, and the performance benefits of AES-NI hardware acceleration results in a superior random number generator.
I have ensured that the implementation is well-documented with clear comments, making it accessible for review, understanding, and maintenance, following best practices in both software development and cryptographic standards.
I look forward to receiving feedback on this pull request to further improve and ensure the effectiveness of the PRNG implementation.
Test of randomness:
NIST Test Suite:
SmallCrush Test: