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)