def test_get_first_record(self, requests_get_patched):
mock_response = Mock(spec=Response)
mock_response.status_code = 200
mock_response.text = self.expected_first.xml
requests_get_patched.return_value = mock_response
expected = self.expected_first
actual_download_false = NistBeacon.get_first_record(download=False)
actual_download_true = NistBeacon.get_first_record(download=True)
self.assertEqual(expected, actual_download_false)
self.assertEqual(expected, actual_download_true)
self.assertIsNot(expected, actual_download_false)
self.assertIsNot(expected, actual_download_true)
self.assertIsNot(actual_download_false, actual_download_true)
def test_chain_check_empty_input(self, requests_get_patched):
mock_response = Mock(spec=Response)
mock_response.status_code = 404
requests_get_patched.return_value = mock_response
# noinspection PyTypeChecker
self.assertFalse(NistBeacon.chain_check(None))
def test_get_record(self):
expected = self.focus_record
actual = NistBeacon.get_record(self.target_timestamp)
self.assertTrue(actual.valid_signature)
self.assertEqual(expected, actual)
self.assertIsNot(expected, actual)
def test_get_last_record(self, requests_get_patched):
mock_response = Mock(spec=Response)
mock_response.status_code = 200
mock_response.text = self.expected_current.xml
requests_get_patched.return_value = mock_response
last_record = NistBeacon.get_last_record()
self.assertIsInstance(last_record, NistBeaconValue)
def test_get_record(self, requests_get_patched):
mock_response = Mock(spec=Response)
mock_response.status_code = 200
mock_response.text = self.expected_current.xml
requests_get_patched.return_value = mock_response
record = NistBeacon.get_record(self.reference_timestamp)
self.assertEqual(self.expected_current, record)
def __init__(self, seed=None):
"""Initialize an instance.
"""
if seed == None:
self.timestamp = 1378395540 # this is the first possible timestamp
else:
self.timestamp = seed
self.beacon = NistBeacon()
def test_get_last_record_exceptions(self, requests_get_patched):
exceptions_to_test = [
requests.exceptions.RequestException(),
requests.exceptions.ConnectionError(),
requests.exceptions.HTTPError(),
requests.exceptions.URLRequired(),
requests.exceptions.TooManyRedirects(),
requests.exceptions.Timeout(),
]
for exception_to_test in exceptions_to_test:
requests_get_patched.side_effect = exception_to_test
self.assertIsNone(NistBeacon.get_last_record())
def test_chain_check_no_records_around(self, requests_get_patched):
first_response = Mock(spec=Response)
first_response.status_code = 200
first_response.text = self.expected_current.xml
none_response = Mock(spec=Response)
none_response.status_code = 404
requests_get_patched.side_effect = [
first_response,
none_response,
none_response,
]
self.assertFalse(
NistBeacon.chain_check(
self.expected_current.timestamp
)
)
def test_chain_check_last(self, requests_get_patched):
first_response = Mock(spec=Response)
first_response.status_code = 200
first_response.text = self.expected_current.xml
previous_response = Mock(spec=Response)
previous_response.status_code = 200
previous_response.text = self.expected_previous.xml
next_response = Mock(spec=Response)
next_response.status_code = 404
requests_get_patched.side_effect = [
first_response,
previous_response,
next_response,
]
self.assertTrue(
NistBeacon.chain_check(
self.expected_current.timestamp,
)
)
def test_chain_check_init(self, requests_get_patched):
first_response = Mock(spec=Response)
first_response.status_code = 200
first_response.text = self.expected_first.xml
previous_response = Mock(spec=Response)
previous_response.status_code = 404
next_response = Mock(spec=Response)
next_response.status_code = 200
next_response.text = self.expected_first_next.xml
requests_get_patched.side_effect = [
first_response,
previous_response,
next_response,
]
self.assertTrue(
NistBeacon.chain_check(
self.init_timestamp,
)
)
from nistbeacon import NistBeacon
import time
print()
print('Coin flip 0 or 1 tails or heads')
print()
print('Run five times')
for count in range(5):
time.sleep(66) # wait for new beacon every 66 seconds
h = NistBeacon.get_last_record()
v = h.output_value # 512 hex
d = int(v, 16) # convert to decimal
coin = d % 2 # modulus of record (0 or 1)
if coin == 0:
print('tails')
else:
print('heads')
def iterate_over_records():
db_file_name = 'nist.db'
# Setup the database
db = sqlite3.connect(db_file_name)
cursor = db.cursor()
cursor.execute(
'CREATE TABLE IF NOT EXISTS "beacon_values" ('
'timestamp INTEGER,'
'output_value TEXT,'
'seed_value TEXT,'
'previous_output_value TEXT,'
'status_code TEXT,'
'version TEXT,'
'signature_value TEXT,'
'frequency INTEGER,'
'PRIMARY KEY(timestamp)'
')'
)
db.commit()
db.close()
# IF rows
db = sqlite3.connect(db_file_name)
cursor = db.cursor()
cursor.execute(
'SELECT timestamp FROM beacon_values ORDER BY timestamp DESC LIMIT 1;'
)
result = cursor.fetchone()
db.close()
if result:
# Go to the next record from the last timestamp in the database
record = NistBeacon.get_next(result[0])
else:
# We begin at record zero
record = NistBeacon.get_first_record()
# Open the database
db = sqlite3.connect(db_file_name)
cursor = db.cursor()
while True:
if record is None:
print("Got 'None' back for a record. Stopping.")
break
print(
"{0} - {1} - {2}".format(
record.timestamp,
record.valid_signature,
record.output_value,
)
)
# Insert this record
cursor.execute(
'INSERT INTO beacon_values('
'timestamp, output_value, seed_value, previous_output_value, '
'status_code, version, signature_value, frequency'
')'
'VALUES('
':timestamp, :output_value, :seed_value, :previous_output_value,'
':status_code, :version, :signature_value, :frequency'
')',
{
'timestamp': record.timestamp,
'output_value': record.output_value,
'seed_value': record.seed_value,
'previous_output_value': record.previous_output_value,
'status_code': record.status_code,
'version': record.version,
'signature_value': record.signature_value,
'frequency': record.frequency,
}
)
db.commit()
# Advance to the next record
record = NistBeacon.get_next(record.timestamp)
# Close out
db.close()
def test_get_last_record_404(self, requests_get_patched):
mock_response = Mock(spec=Response)
mock_response.status_code = 404
requests_get_patched.return_value = mock_response
self.assertIsNone(NistBeacon.get_last_record())
def test_get_record_404(self):
expected = self.future_record
actual = NistBeacon.get_record(self.future_timestamp)
self.assertIsNone(actual)
self.assertEqual(expected, actual)
def test_get_last_record(self):
actual = NistBeacon.get_last_record()
self.assertTrue(actual.valid_signature)
class NistBeaconRandom(random.Random):
'''Random number generator base class'''
def __init__(self, seed=None):
"""Initialize an instance.
"""
if seed == None:
self.timestamp = 1378395540 # this is the first possible timestamp
else:
self.timestamp = seed
self.beacon = NistBeacon()
def get_value(self):
"""
Get a random number from the server
"""
val = self.beacon.get_record(self.timestamp).output_value
return int(val,16)
def next(self):
"""
Update the counter
"""
self.timestamp += 60 # 60 seconds = 1 step
def getstate(self):
return (self.timestamp)
def jumpahead(self, n):
"""
Jump ahead n steps in time
"""
self.timestamp += n*60
self.get_value()
def __repr__(self):
"""
>>> r = true_random()
>>> repr(r)
'True RNG with Timestamp 0'
>>> str(r)
'True RNG with Timestamp 0'
"""
stringrepr = "True RNG with Timestamp " + str(self.timestamp)
return stringrepr
def random(self, size=None):
"""
Generate random numbers between 0 and 1.
size controls the number of ints generated. If size=None, just one is produced.
"""
if size==None:
return self.nextRandom()*RECIP_BITLEN
else:
return np.reshape(np.array([self.nextRandom()*RECIP_BITLEN for i in np.arange(np.prod(size))]), size)
def nextRandom(self):
"""
Generate the next random number
"""
val = self.get_value()
self.next()
return(val)
def randint(self, a, b, size=None):
"""
Generate random integers between a (inclusive) and b (exclusive).
size controls the number of ints generated. If size=None, just one is produced.
"""
assert a <= b, "lower and upper limits are switched"
if size==None:
return a + (self.nextRandom() % (b-a))
else:
return np.reshape(np.array([a + (self.nextRandom() % (b-a)) for i in np.arange(np.prod(size))]), size)
