How can I generate a cryptographically secure number in SQL Server? - sql

Question

I am currently using guid NEWID() but I know it is not cryptographically secure.
Is there any better way of generating a cryptographically secure number in SQL Server?

Answer 1

CRYPT_GEN_RANDOM is documented to return a "cryptographic random number".
It takes a length parameter between 1 and 8000 which is the length of the number to return in bytes.
For lengths <= 8 bytes. This can be cast to one of the SQL Server integer types straightforwardly.
+-----------+------------------+---------+
| Data type | Range | Storage |
+-----------+------------------+---------+
| bigint | -2^63 to 2^63-1 | 8 Bytes |
| int | -2^31 to 2^31-1 | 4 Bytes |
| smallint | -2^15 to 2^15-1 | 2 Bytes |
| tinyint | 0 to 255 | 1 Byte |
+-----------+------------------+---------+
Three of them are signed integers and one unsigned. The following will each use the full range of their respective datatypes.
SELECT
CAST(CRYPT_GEN_RANDOM(1) AS TINYINT),
CAST(CRYPT_GEN_RANDOM(2) AS SMALLINT),
CAST(CRYPT_GEN_RANDOM(4) AS INT),
CAST(CRYPT_GEN_RANDOM(8) AS BIGINT)
It is also possible to supply a shorter value than the datatype storage.
SELECT CAST(CRYPT_GEN_RANDOM(3) AS INT)
In this case only positive numbers can be returned. The sign bit will always be 0 as the last byte is treated as 0x00. The range of possible numbers that can be returned by the above is between 0 and POWER(2, 24) - 1 inclusive.
Suppose the requirement is to generate some random number between 1 and 250.
One possible way of doing it would be
SELECT ( 1 + CAST(CRYPT_GEN_RANDOM(1) AS TINYINT) % 250) AS X
INTO #T
FROM master..spt_values V1, master..spt_values
However this method has a problem.
SELECT COUNT(*),X
FROM #T
GROUP BY X
ORDER BY X
The first ten rows of results are
+-------+----+
| Count | X |
+-------+----+
| 49437 | 1 |
| 49488 | 2 |
| 49659 | 3 |
| 49381 | 4 |
| 49430 | 5 |
| 49356 | 6 |
| 24914 | 7 |
| 24765 | 8 |
| 24513 | 9 |
| 24732 | 10 |
+-------+----+
Lower numbers (in this case 1 -6) are generated twice as regularly as the others because there are two possible inputs to the modulus function that can generate each of those results.
One possible solution would be to discard all numbers >= 250
UPDATE #T
SET X = CASE
WHEN Random >= 250 THEN NULL
ELSE ( 1 + Random % 250 )
END
FROM #T
CROSS APPLY (SELECT CAST(CRYPT_GEN_RANDOM(1) AS TINYINT)) CA (Random)
This appears to work on my machine but it is probably not guaranteed that SQL Server will only evaluate the function once across both references to Random in the CASE expression. Additionally it still leaves the problem of needing second and subsequent passes to fix up the NULL rows where the random value was discarded.
Declaring a scalar UDF can solve both those issues.
/*Work around as can't call CRYPT_GEN_RANDOM from a UDF directly*/
CREATE VIEW dbo.CRYPT_GEN_RANDOM1
AS
SELECT CAST(CRYPT_GEN_RANDOM(1) AS TINYINT) AS Random
go
CREATE FUNCTION GET_CRYPT_GEN_RANDOM1()
RETURNS TINYINT
AS
BEGIN
DECLARE #Result TINYINT
WHILE (#Result IS NULL OR #Result >= 250)
/*Not initialised or result to be discarded*/
SELECT #Result = Random FROM dbo.CRYPT_GEN_RANDOM1
RETURN #Result
END
And then
UPDATE #T
SET X = dbo.GET_CRYPT_GEN_RANDOM1()
Alternatively and more straight forwardly one could simply use
CAST(CRYPT_GEN_RANDOM(8) AS BIGINT) % 250
On the grounds that the range of bigint is so huge that any bias will likely be insignificant. There are 73,786,976,294,838,208 ways that 1 can be generated and 73,786,976,294,838,206 that 249 can be from the query above.
If even that small possible bias is not permitted you could discard any values NOT BETWEEN -9223372036854775750 AND 9223372036854775749 as shown earlier.

Answer 2

Interesting question :)
I think this will work: CRYPT_GEN_RANDOM