Generating Unpredictable Data for MariaDB: RANDOM_BYTES Explained

• Introduced in MariaDB version 10.10, RANDOM_BYTES is a function that generates a sequence of random bytes of a specified length.
• These bytes are cryptographically secure, meaning they are unpredictable and suitable for security applications like creating encryption keys, password salts, or session tokens.
• The function takes one argument: an integer between 1 and 1024 representing the desired number of random bytes.
• If the argument is outside this range or NULL, an error occurs.

Example of using RANDOM_BYTES:

SELECT RANDOM_BYTES(32);  -- Generates 32 random bytes

Alternatives for older MariaDB versions (or if you can't upgrade):

• UDF (User-Defined Function): You can create a custom function written in C that leverages a cryptographically secure random number generator library (e.g., OpenSSL) to produce random bytes within MariaDB. This approach requires more development effort but offers full control.

Important considerations:

• Security: Never use RAND() for generating random bytes in security contexts. It's not cryptographically secure and can compromise your application's security.
• Statement-based replication: If you're using statement-based replication in MariaDB, be aware that statements containing RANDOM_BYTES might not be replicated consistently across all nodes in the cluster.

In summary:

• For MariaDB 10.10 and later, use RANDOM_BYTES for secure random byte generation.
• For older versions, explore UDFs or consider upgrading if possible.
• Always prioritize cryptographically secure methods for sensitive tasks like encryption and password hashing.

-- Generate 16 random bytes (suitable for many encryption keys)
SELECT RANDOM_BYTES(16) AS random_key;

-- Generate a 32-character hexadecimal string (useful for displaying random values)
SELECT HEX(RANDOM_BYTES(16)) AS hex_random;

Alternative for older MariaDB versions (using SUBSTR and MD5):

-- This approach is NOT cryptographically secure, use with caution!
-- It's for demonstration purposes only in older MariaDB versions.

-- Generate 16 pseudo-random bytes (less secure than RANDOM_BYTES)
SELECT SUBSTR(MD5(RAND()), 1, 32) AS pseudo_random_bytes;

-- Generate a 32-character hexadecimal string (similar to RANDOM_BYTES example)
SELECT HEX(SUBSTR(MD5(RAND()), 1, 16)) AS hex_pseudo_random;

-- Warning: This method (using MD5) is not recommended for security-sensitive applications.

Key points:

• The RANDOM_BYTES function is the preferred and most secure method for MariaDB 10.10 and later.
• The alternative using MD5 is for demonstration purposes only and should not be used for generating random bytes in security contexts (encryption, password hashing).
• Consider upgrading to MariaDB 10.10 or later if possible to benefit from RANDOM_BYTES.

• This method involves creating a custom function written in C.
• The function would leverage a cryptographically secure random number generator library like OpenSSL to generate the bytes within MariaDB.
• This approach offers full control but requires more development effort.

Here's a general outline (not actual code):

CREATE FUNCTION generate_random_bytes(length INT)
RETURNS VARBINARY(length)
SONAME 'path/to/your/udf.so';

• Replace path/to/your/udf.so with the actual path to your compiled UDF library.
• You'll need to write the C code for the function itself to interact with the random number generator library and return the bytes.

Application-Level Generation:

• Instead of relying on MariaDB to generate random bytes, you can generate them in your application code (e.g., PHP, Python, Java) using the language's built-in secure random number generation functions.
• Then, pass those bytes as parameters to your MariaDB queries.
• This approach separates the randomness generation from the database layer, potentially offering more flexibility in your application design.

Here are some examples of secure random byte generation functions in common languages:

• PHP: openssl_random_pseudo_bytes()
• Python: os.urandom()
• Java: SecureRandom.nextBytes()

External Tools (for one-time use):

• For one-time use cases, you can generate random bytes using external tools on your system.
• Tools like openssl rand or /dev/urandom (on Linux) can be used to create random data.
• However, you'll need to manually insert this data into your MariaDB tables, which might not be ideal for frequent use.

Choosing the Right Method:

• If you're using MariaDB 10.10 or later, RANDOM_BYTES is the recommended and most secure method.
• For older versions, consider UDFs if you have the development resources.
• Application-level generation can be a good option if you need more flexibility in your application design.
• External tools are a last resort for one-time use cases.