feat: add crypto_random_bytes

Author: rustyconover

CLAUDE.md

@@ -53,10 +53,10 @@ Builds:
 ### Testing
 
 ```sh
-make test
+make test_debug
 ```
 
-Runs SQL tests located in `test/sql/crypto.test`.  but using the release build.
+Runs SQL tests located in `test/sql/*.test` but uses the debug build.
 
 ### Running the Extension
 
@@ -69,6 +69,7 @@ Launches DuckDB with the extension already loaded.
 ## Supported Hash Algorithms
 
 The extension supports these algorithms (defined in `src/crypto_hash.cpp:getDigestByName()`):
+- blake3
 - blake2b-512
 - keccak224, keccak256, keccak384, keccak512 (mapped to SHA3 variants)
 - md4, md5

README.md

@@ -1,8 +1,8 @@
 # Crypto Hash/HMAC Extension for DuckDB
 
-This extension, `crypto`, adds cryptographic hash functions and HMAC (Hash-based Message Authentication Code) calculation to DuckDB.
+This extension, `crypto`, adds cryptographic hash functions, HMAC (Hash-based Message Authentication Code) calculation, and cryptographically secure random byte generation to DuckDB.
 
-While DuckDB already includes basic hash functions like `hash()` and `sha256()`, this extension provides additional algorithms including Blake3, SHA-3, and supports hashing of various data types beyond just strings.
+While DuckDB already includes basic hash functions like `hash()` and `sha256()`, this extension provides additional algorithms including Blake3, SHA-3, supports hashing of various data types beyond just strings, and includes secure random number generation using OpenSSL.
 
 ## Installation
 
@@ -31,6 +31,10 @@ SELECT lower(to_hex(crypto_hash('sha2-256', 42)));
 -- Calculate HMAC with a secret key
 SELECT lower(to_hex(crypto_hmac('sha2-256', 'my-secret-key', 'important message')));
 -- Result: 97f324adef061b4ad0abeb6be543913d7db6ba8e6e7f33cd3c4395d619b56df4
+
+-- Generate 32 cryptographically secure random bytes
+SELECT lower(to_hex(crypto_random_bytes(32)));
+-- Result: (random hex string, different each time)
 ```
 
 ## Hash Functions
@@ -177,6 +181,63 @@ FROM (VALUES (1), (2), (3), (4), (5)) t(value);
 -- true (aggregate hash matches list hash)
 ```
 
+## Random Byte Generation
+
+### crypto_random_bytes()
+
+**Syntax:**
+```sql
+crypto_random_bytes(length) → BLOB
+```
+
+Generates cryptographically secure random bytes using OpenSSL's `RAND_bytes()` function. This is useful for generating random keys, salts, nonces, and other cryptographic material.
+
+**Parameters:**
+- `length` (BIGINT): The number of random bytes to generate (must be between 1 and 4,294,967,295)
+
+**Returns:** BLOB containing the requested number of cryptographically secure random bytes
+
+**Security:** Uses OpenSSL's `RAND_bytes()`, which provides cryptographically strong random numbers suitable for security-sensitive applications like key generation and cryptographic operations.
+
+**Limits:**
+- Minimum length: 1 byte
+- Maximum length: 4,294,967,295 bytes (4GB - 1, the maximum BLOB size in DuckDB)
+- Requesting 0 or negative bytes raises an `InvalidInputException`
+- Requesting more than 4GB raises an `InvalidInputException`
+
+### Examples
+
+```sql
+-- Generate 32 random bytes (suitable for AES-256 key)
+SELECT crypto_random_bytes(32);
+
+-- Generate random bytes and convert to hex for display
+SELECT lower(to_hex(crypto_random_bytes(16)));
+-- Example output: 3f7a2b8c9d1e4f6a8b2c3d4e5f6a7b8c
+
+-- Generate a random salt for password hashing
+SELECT crypto_random_bytes(16) AS salt;
+
+-- Use random bytes as an HMAC key
+SELECT crypto_hmac('sha2-256', crypto_random_bytes(32), 'message to authenticate');
+
+-- Generate multiple random values in a table
+CREATE TABLE api_keys (id INTEGER, api_key BLOB);
+INSERT INTO api_keys
+SELECT id, crypto_random_bytes(32)
+FROM range(10) t(id);
+
+-- Verify randomness (each call produces different output)
+SELECT crypto_random_bytes(16) != crypto_random_bytes(16);
+-- true
+
+-- Generate a 128-bit random UUID-like value
+SELECT lower(to_hex(crypto_random_bytes(16)));
+
+-- Create a random nonce for cryptographic operations
+SELECT crypto_random_bytes(12) AS nonce;  -- 96-bit nonce for AES-GCM
+```
+
 ## HMAC Functions
 
 ### crypto_hmac()
@@ -229,6 +290,32 @@ FROM api_requests;
 
 ## Common Use Cases
 
+### Generating Cryptographic Keys and Salts
+```sql
+-- Generate a random AES-256 encryption key
+SELECT crypto_random_bytes(32) AS encryption_key;
+
+-- Generate random salts for password hashing
+CREATE TABLE users (
+  id INTEGER,
+  username VARCHAR,
+  password_hash BLOB,
+  salt BLOB
+);
+
+INSERT INTO users (id, username, salt)
+VALUES (1, 'alice', crypto_random_bytes(16));
+
+-- Generate random HMAC keys
+SELECT crypto_random_bytes(32) AS hmac_key;
+
+-- Create a table with random API keys
+CREATE TABLE api_credentials (
+  user_id INTEGER,
+  api_key BLOB DEFAULT crypto_random_bytes(32)
+);
+```
+
 ### Generating Unique IDs
 ```sql
 -- Generate unique IDs from multiple columns

src/crypto_extension.cpp

@@ -300,6 +300,62 @@ namespace duckdb
             });
     }
 
+    inline void CryptoScalarRandomBytesFun(DataChunk &args, ExpressionState &state, Vector &result)
+    {
+        // This is called with one argument: the number of bytes to generate
+        auto &length_vector = args.data[0];
+        auto count = args.size();
+
+        UnifiedVectorFormat length_data;
+        length_vector.ToUnifiedFormat(count, length_data);
+        auto lengths = UnifiedVectorFormat::GetData<int64_t>(length_data);
+
+        auto results = FlatVector::GetData<string_t>(result);
+
+        // Process each row
+        for (idx_t i = 0; i < count; i++)
+        {
+            auto length_idx = length_data.sel->get_index(i);
+
+            if (!length_data.validity.RowIsValid(length_idx))
+            {
+                FlatVector::SetNull(result, i, true);
+                continue;
+            }
+
+            int64_t length = lengths[length_idx];
+
+            // Validate length before allocation (CryptoRandomBytes will validate too, but we need to prevent allocation issues)
+            if (length <= 0)
+            {
+                throw InvalidInputException("Random bytes length must be greater than 0");
+            }
+
+            // DuckDB BLOB maximum size is 4GB (2^32 - 1 bytes)
+            constexpr int64_t MAX_BLOB_SIZE = 4294967295LL; // 4GB - 1
+            if (length > MAX_BLOB_SIZE)
+            {
+                throw InvalidInputException(
+                    "Random bytes length must be less than or equal to " +
+                    std::to_string(MAX_BLOB_SIZE) + " bytes (4GB)");
+            }
+
+            // Allocate buffer for random bytes
+            auto buffer = std::unique_ptr<unsigned char[]>(new unsigned char[length]);
+
+            // Generate random bytes (will also validate length)
+            CryptoRandomBytes(length, buffer.get());
+
+            // Add result as BLOB
+            results[i] = StringVector::AddStringOrBlob(result, string_t(reinterpret_cast<const char *>(buffer.get()), length));
+        }
+
+        if (count == 1)
+        {
+            result.SetVectorType(VectorType::CONSTANT_VECTOR);
+        }
+    }
+
     struct HashAggregateState
     {
         bool is_touched;
@@ -565,6 +621,11 @@ namespace duckdb
         auto crypto_hmac_scalar_function = ScalarFunction("crypto_hmac", {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BLOB, CryptoScalarHmacFun);
         loader.RegisterFunction(crypto_hmac_scalar_function);
 
+        auto crypto_random_bytes_scalar_function = ScalarFunction(
+            "crypto_random_bytes",
+            {LogicalType::BIGINT}, LogicalType::BLOB, CryptoScalarRandomBytesFun, nullptr, nullptr, nullptr, nullptr, LogicalTypeId::INVALID, FunctionStability::VOLATILE);
+        loader.RegisterFunction(crypto_random_bytes_scalar_function);
+
         auto agg_set = AggregateFunctionSet("crypto_hash_agg");
 
         // Variable-size types (include size prefix to prevent length extension attacks)

src/crypto_hash.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/common/string_util.hpp"
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
+#include <openssl/rand.h>
 #include <cstring>
 #include <unordered_map>
 #include <functional>
@@ -152,4 +153,31 @@ namespace duckdb
         }
     }
 
+    void CryptoRandomBytes(int64_t length, unsigned char *result)
+    {
+        // Validate input length
+        if (length <= 0)
+        {
+            throw InvalidInputException("Random bytes length must be greater than 0");
+        }
+
+        // DuckDB BLOB maximum size is 4GB (2^32 - 1 bytes)
+        constexpr int64_t MAX_BLOB_SIZE = 4294967295LL; // 4GB - 1
+        if (length > MAX_BLOB_SIZE)
+        {
+            throw InvalidInputException(
+                "Random bytes length must be less than or equal to " +
+                std::to_string(MAX_BLOB_SIZE) + " bytes (4GB)");
+        }
+
+        // Generate random bytes using OpenSSL's RAND_bytes
+        // RAND_bytes is cryptographically secure and automatically seeds itself
+        int rand_result = RAND_bytes(result, static_cast<int>(length));
+
+        if (rand_result != 1)
+        {
+            throw InternalException("Failed to generate random bytes");
+        }
+    }
+
 } // namespace duckdb

src/include/crypto_hash.hpp

@@ -22,4 +22,7 @@ void CryptoHash(const std::string& algorithm, const char* data, size_t data_len,
 // Compute an HMAC (Hash-based Message Authentication Code)
 void CryptoHmac(const std::string& algorithm, const std::string& key, const std::string& data, unsigned char* result, unsigned int& result_len);
 
+// Generate cryptographically secure random bytes
+void CryptoRandomBytes(int64_t length, unsigned char* result);
+
 } // namespace duckdb

test/sql/crypto.test

@@ -1038,3 +1038,101 @@ SELECT crypto_hash_agg('blake3', data ORDER BY data) =
 FROM (VALUES ('hello'), ('world')) t(data);
 ----
 true
+
+# Test crypto_random_bytes() - Random byte generation
+# =====================================================
+
+# Test basic random byte generation (32 bytes)
+query I
+SELECT octet_length(crypto_random_bytes(32));
+----
+32
+
+# Test small random byte generation (1 byte)
+query I
+SELECT octet_length(crypto_random_bytes(1));
+----
+1
+
+# Test larger random byte generation (1024 bytes)
+query I
+SELECT octet_length(crypto_random_bytes(1024));
+----
+1024
+
+# Test that random bytes are different on each call
+query I
+SELECT crypto_random_bytes(32) != crypto_random_bytes(32);
+----
+true
+
+# Test with different lengths produce different results
+query I
+SELECT octet_length(crypto_random_bytes(16)) != octet_length(crypto_random_bytes(32));
+----
+true
+
+# Test error case: zero bytes
+statement error
+SELECT crypto_random_bytes(0);
+----
+Invalid Input Error: Random bytes length must be greater than 0
+
+# Test error case: negative length
+statement error
+SELECT crypto_random_bytes(-1);
+----
+Invalid Input Error: Random bytes length must be greater than 0
+
+# Test error case: exceeds 4GB limit
+statement error
+SELECT crypto_random_bytes(4294967296);
+----
+Invalid Input Error: Random bytes length must be less than or equal to 4294967295 bytes (4GB)
+
+# Test NULL input returns NULL
+query I
+SELECT crypto_random_bytes(NULL::BIGINT) IS NULL;
+----
+true
+
+# Test that results are truly random (non-zero variance)
+# Generate 10 random bytes and verify they're not all the same
+query I
+SELECT crypto_random_bytes(10) != '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'::BLOB;
+----
+true
+
+# Test at the maximum allowed size (4GB - 1 bytes)
+# Note: We'll test with a smaller size for practicality (1MB)
+query I
+SELECT octet_length(crypto_random_bytes(1048576));
+----
+1048576
+
+# Test using random bytes with crypto_hash
+query I
+SELECT octet_length(crypto_hash('sha2-256', crypto_random_bytes(64)));
+----
+32
+
+# Test in a table context (multiple rows)
+# The function is volatile, so each call produces different random bytes
+query I
+SELECT count(DISTINCT random_data)
+FROM (
+  SELECT crypto_random_bytes(16) AS random_data
+  FROM range(10)
+) subq;
+----
+10
+
+# Test that different calls produce different random values
+query I
+SELECT (
+  SELECT crypto_random_bytes(8)
+) != (
+  SELECT crypto_random_bytes(8)
+);
+----
+true