In jmcastagnetto/nistrb: Access the NIST Randomness Beacon

This package implements R functions and an S3 class to access the NIST the NIST Randomness Beacon, through its REST web service interface.

The NIST service generates full-entropy bit-strings and posts them in blocks of 512 bits every 60 seconds^[https://beacon.nist.gov/home]

Implementation details

Functions

According to the beacon's documentation, there are five endpoints defined and this package wraps the call to each one in a function:

nrb_get_last()
- Endpoint: https://beacon.nist.gov/rest/record/last
- The last generated record
nrb_get_next(timestamp)
- Endpoint: https://beacon.nist.gov/rest/record/next/<timestamp>
- The record following the given timestamp
nrb_get_previous(timestamp)
- Endpoint: https://beacon.nist.gov/rest/record/previous/<timestamp>
- The record previous to the given timestamp
nrb_get_record(timestamp)
- Endpoint: https://beacon.nist.gov/rest/record/<timestamp>
- The record for the given timestamp (or the one closest)
nrb_get_start_chain(timestamp)
- Endpoint: https://beacon.nist.gov/rest/record/start-chain/<timestamp>
- "The start-of-chain record for the given timestamp

Where timestamp is in POSIX time format: the number of seconds since midnight UTC, January 1, 1970. Alternatively a POSIXct o POSIXlt value can be used.

Class

The service returns an XML document with several pieces of information:

The (seed) value represented as a 64 byte (512-bit) hex string value, and its timestamp
The SHA-512 hash value for the previous record as a 64 byte hex string
A digital signature (RSA) computed over (in order): version, frequency, timeStamp, seedValue, previousHashValue, errorCode. Note: Except for version, the hash is on the byte representations and not the string representations of the data values
The SHA-512 hash of the signature as a 64 byte hex string
The service version and its update frequency (currenty, 60 seconds)
The status of the response
- 0 = Chain intact, values all good
- 1 = Start of a new chain of values, previous hash value will be all zeroes
- 2 = Time between values is greater than the frequency, but the chain is still intact

This package wraps this XML document in the nrb_response class, which contains all the values from the beacon's response.

An nrb_response object contains the properties

version: The current beacon's version
frequency: The beacon's update frequency in seconds
url: The endpoint call
timeStamp: The timestamp (UTC) in Unix Time format
seedValue: The random beacon string for a given timestamp
previousOutputValue: The hash of the previous beacon's record signature
signatureValue: The digital signature of the record
outputValue: The hash of the current signature
statusCode: The service status code for this record
statusDesc: A description of the status code

For example, to get the record generated on Jan 1, 2015 at 10:00h (UTC), we will use the following code:

library(nistrb)
ts <- as.POSIXct("2015-01-01 10:00:00", tz = "UTC")
rec <- nrb_get_record(ts)
rec

We can also make sure that the record chain is unbroken, getting the previous record from the beacon (Jan 1, 2015 09:59h, UTC):

prev_ts <- as.POSIXct("2015-01-01 09:59:00", tz = "UTC")
prev_rec <- nrb_get_record(prev_ts)
prev_rec$output == rec$previousOutputValue

or the next record:

next_ts <- as.POSIXct("2015-01-01 10:01:00", tz = "UTC")
next_rec <- nrb_get_record(next_ts)
rec$output == next_rec$previousOutputValue

Example of use

We can use the NIST Randomness Beacon as a source of reproducible random seeds that depends on a timestamp, for example:

library(nistrb)

# get the number of numeric chars in the seed
# more than a bit contrived as examples go
gen_seed <- function(timestamp) {
  rec <- nrb_get_record(timestamp)
  chrs <- strsplit(rec$seedValue, NULL)
  sum(sapply(chrs, FUN = function(x) {
      grepl(pattern = "[0-9]", x = x)
    }))
}

ts <- as.POSIXct("2015-07-28 00:00:00", tz = "UTC")
gen_seed(ts)

ts <- as.POSIXct("2014-12-25 12:00:00", tz = "UTC")
gen_seed(ts)