def obtain_alternatives(trip_id, user_id):
db = get_trip_db()
trip = E_Mission_Trip.trip_from_json(db.find_one({"trip_id": trip_id, "user_id": user_id}))
logging.debug(trip.sections)
start_coord = trip.trip_start_location.maps_coordinate()
end_coord = trip.trip_end_location.maps_coordinate()
logging.debug("Start: %s " % start_coord)
logging.debug("End: %s " % end_coord)
curr_time = datetime.datetime.now()
curr_month = curr_time.month
curr_day = curr_time.day
curr_hour = curr_time.hour
curr_minute = curr_time.minute
otp_modes = ['CAR', 'WALK', 'BICYCLE', 'TRANSIT']
for mode in otp_modes:
try:
otp_trip = OTP(start_coord, end_coord, mode, write_day(curr_month, curr_day, "2015"), write_time(curr_hour, curr_minute), False)
otp_trip = otp_trip.turn_into_trip(None, user_id, trip_id)
otp_trip.save_to_db()
except Exception as e:
#modes = ['driving', 'walking', 'bicycling', 'transit']
logging.debug("Got error %s from OTP, defaulting to Google Maps" % e)
otp_to_google_mode = {"CAR":"driving", "WALK":"walking", "BICYCLE":"bicycling", "TRANSIT":"transit"}
mode = otp_to_google_mode[mode]
gmaps = googlemaps.GoogleMaps('AIzaSyBEkw4PXVv_bsAdUmrFwatEyS6xLw3Bd9c')
result = gmaps.directions(origin=start_coord, destination=end_coord, mode=mode)
gmaps_trip = google_maps_to_our_trip(result, None, user_id, trip_id, mode, curr_time)
gmaps_trip.save_to_db()
'''
def otpgen():
if "user" in session:
otp=OTP(productname)
tmp=otp.genOTP()
enckey=EncryptPass()
return render_template("nano/2fa_gen.html",productname=productname,toqr=tmp[1],year=year)
else:
return redirect(url_for("login"))
def test_generate_hotp(self):
# Test vectors taken from RFC 4226, Appendix E
self.assertEqual('755224', OTP.generate_hotp(self.secret, 0))
self.assertEqual('287082', OTP.generate_hotp(self.secret, 1))
self.assertEqual('359152', OTP.generate_hotp(self.secret, 2))
self.assertEqual('969429', OTP.generate_hotp(self.secret, 3))
self.assertEqual('338314', OTP.generate_hotp(self.secret, 4))
self.assertEqual('254676', OTP.generate_hotp(self.secret, 5))
self.assertEqual('287922', OTP.generate_hotp(self.secret, 6))
self.assertEqual('162583', OTP.generate_hotp(self.secret, 7))
self.assertEqual('399871', OTP.generate_hotp(self.secret, 8))
self.assertEqual('520489', OTP.generate_hotp(self.secret, 9))
def do_getHOTP(self, line):
"getHOTP [digits]"
digits = 6
if line:
digits = int(line.split()[0])
print("Your HOTP code : ",
OTP.generate_hotp(self.secret, self.counter, digits))
self.counter += 1
def do_geturl(self, line):
"""geturl authtype(hotp/totp) """
if not line or len(line.split()) < 1:
print("Wrong")
else:
auth = line.split()[0]
if auth != "hotp" and auth != "totp":
print("Wrong auth param")
else:
print("Type this in browser : ",
OTP.get_url(self.account, auth, self.secret))
def test_generate_totp(self):
# Test vectors taken from RFC 6238, Appendix B
self.assertEqual('94287082', OTP.generate_totp(self.secret, 59, 8))
self.assertEqual('07081804', OTP.generate_totp(self.secret, 1111111109, 8))
self.assertEqual('14050471', OTP.generate_totp(self.secret, 1111111111, 8))
self.assertEqual('89005924', OTP.generate_totp(self.secret, 1234567890, 8))
self.assertEqual('69279037', OTP.generate_totp(self.secret, 2000000000, 8))
self.assertEqual('65353130', OTP.generate_totp(self.secret, 20000000000, 8))
def verify(self,
otp,
timestamp=False,
sl=None,
timeout=None,
return_response=False):
"""
Returns True is the provided OTP is valid,
False if the REPLAYED_OTP status value is returned or the response
message signature verification failed and None for the rest of the
status values.
"""
ca_bundle_path = self._get_ca_bundle_path()
otp = OTP(otp, self.translate_otp)
nonce = base64.b64encode(os.urandom(30), 'xz')[:25]
query_string = self.generate_query_string(otp.otp, nonce, timestamp,
sl, timeout)
request_urls = self.generate_request_urls()
threads = []
timeout = timeout or DEFAULT_TIMEOUT
for url in request_urls:
thread = URLThread('%s?%s' % (url, query_string), timeout,
self.verify_cert, ca_bundle_path)
thread.start()
threads.append(thread)
# Wait for a first positive or negative response
start_time = time.time()
while threads and (start_time + timeout) > time.time():
for thread in threads:
if not thread.is_alive():
if thread.exception:
raise thread.exception
elif thread.response:
status = self.verify_response(thread.response, otp.otp,
nonce, return_response)
if status:
if return_response:
return status
else:
return True
threads.remove(thread)
time.sleep(0.1)
# Timeout or no valid response received
raise Exception('NO_VALID_ANSWERS')
def verify_multi(self,
otp_list=None,
max_time_window=None,
sl=None,
timeout=None):
# Create the OTP objects
otps = []
for otp in otp_list:
otps.append(OTP(otp, self.translate_otp))
device_ids = set()
for otp in otps:
device_ids.add(otp.device_id)
# Check that all the OTPs contain same device id
if len(device_ids) != 1:
raise Exception('OTPs contain different device ids')
# Now we verify the OTPs and save the server response for each OTP.
# We need the server response, to retrieve the timestamp.
# It's possible to retrieve this value locally, without querying the
# server but in this case, user would need to provide his AES key.
for otp in otps:
response = self.verify(otp.otp,
True,
sl,
timeout,
return_response=True)
if not response:
return False
otp.timestamp = int(response['timestamp'])
count = len(otps)
delta = otps[count - 1].timestamp - otps[0].timestamp
if max_time_window:
max_time_window = (max_time_window / 0.125)
else:
max_time_window = DEFAULT_MAX_TIME_WINDOW
if delta > max_time_window:
raise Exception('More then %s seconds has passed between ' +
'generating the first and the last OTP.' %
(max_time_window * 0.125))
return True
def verify_multi(self,
otp_list=None,
max_time_window=None,
sl=None,
timeout=None):
# Create the OTP objects
otps = []
for otp in otp_list:
otps.append(OTP(otp, self.translate_otp))
device_ids = set()
for otp in otps:
device_ids.add(otp.device_id)
# Check that all the OTPs contain same device id
if len(device_ids) != 1:
return False
# Now we verify the OTPs and save the server response for each OTP.
# We need the server response, to retrieve the timestamp.
# It's possible to retrieve this value locally, without querying the server
# but in this case, user would need to provide his AES key.
for otp in otps:
response = self.verify(otp.otp,
True,
sl,
timeout,
return_response=True)
if not response:
return False
otp.timestamp = int(response['timestamp'])
count = len(otps)
delta = otps[count - 1].timestamp - otps[0].timestamp
max_time_window = (max_time_window /
0.125) if max_time_window else None
max_time_window = max_time_window or MAX_TIME_WINDOW
if delta > max_time_window:
return False
return True
def verify(self,
otp,
timestamp=False,
sl=None,
timeout=None,
return_response=False):
"""
Returns True is the provided OTP is valid,
False if the REPLAYED_OTP status value is returned or the response
message signature verification failed and None for the rest of the status values.
"""
otp = OTP(otp, self.translate_otp)
nonce = base64.b64encode(os.urandom(30), 'xz')[:25]
query_string = self.generate_query_string(otp.otp, nonce, timestamp,
sl, timeout)
request_urls = self.generate_request_urls()
threads = []
timeout = timeout or TIMEOUT
for url in request_urls:
thread = URLThread('%s?%s' % (url, query_string), timeout,
self.verify_cert)
thread.start()
threads.append(thread)
# Wait for a first positive or negative response
start_time = time.time()
while threads and (start_time + timeout) > time.time():
for thread in threads:
if not thread.is_alive() and thread.response:
status = self.verify_response(thread.response,
return_response)
if status:
if return_response:
return status
else:
return True
threads.remove(thread)
return None
def setUp(self):
self.otp = OTP()
self.secret = "12345678901234567890"
class TestOTP(TestCase):
def setUp(self):
self.otp = OTP()
self.secret = "12345678901234567890"
def test_generate_hotp(self):
# Test vectors taken from RFC 4226, Appendix E
self.assertEqual("755224", self.otp.generate_hotp(self.secret, 0))
self.assertEqual("287082", self.otp.generate_hotp(self.secret, 1))
self.assertEqual("359152", self.otp.generate_hotp(self.secret, 2))
self.assertEqual("969429", self.otp.generate_hotp(self.secret, 3))
self.assertEqual("338314", self.otp.generate_hotp(self.secret, 4))
self.assertEqual("254676", self.otp.generate_hotp(self.secret, 5))
self.assertEqual("287922", self.otp.generate_hotp(self.secret, 6))
self.assertEqual("162583", self.otp.generate_hotp(self.secret, 7))
self.assertEqual("399871", self.otp.generate_hotp(self.secret, 8))
self.assertEqual("520489", self.otp.generate_hotp(self.secret, 9))
def test_generate_totp(self):
# Test vectors taken from RFC 6238, Appendix B
self.assertEqual("94287082", self.otp.generate_totp(self.secret, 59, 8))
self.assertEqual("07081804", self.otp.generate_totp(self.secret, 1111111109, 8))
self.assertEqual("14050471", self.otp.generate_totp(self.secret, 1111111111, 8))
self.assertEqual("89005924", self.otp.generate_totp(self.secret, 1234567890, 8))
self.assertEqual("69279037", self.otp.generate_totp(self.secret, 2000000000, 8))
self.assertEqual("65353130", self.otp.generate_totp(self.secret, 20000000000, 8))
def test_validate_hotp(self):
self.assertTrue(self.otp.validate_hotp("755224", self.secret, 0))
self.assertTrue(self.otp.validate_hotp("287082", self.secret, 0))
self.assertFalse(self.otp.validate_hotp("969429", self.secret, 0))
def test_validate_totp(self):
self.assertTrue(self.otp.validate_totp("07081804", self.secret, 1111111109, 8))
self.assertTrue(self.otp.validate_totp("07081804", self.secret, 1111111084, 8))
self.assertFalse(self.otp.validate_totp("07081804", self.secret, 1111111078, 8))
self.assertTrue(self.otp.validate_totp("07081804", self.secret, 1111111134, 8))
self.assertFalse(self.otp.validate_totp("07081804", self.secret, 1111111140, 8))
def test_encode(self):
self.assertRaises(IncorrectOTPType, self.otp.encode, "asdf", "asdf", "asdf", "asdf")
os.remove("../website/data/" + file)
if algo == 'caesar':
f = open("../website/data/" + file)
encrypted_message = f.read()
f.close()
caesar = CaesarCipherDecrypt(encrypted_message)
decrypted_message = caesar.decrypt(5)
print("Decrypted Message: {}".format(decrypted_message))
os.remove("../website/data/" + file)
if algo == 'otp':
f = open("../website/data/" + file)
encrypted_message = f.read()
f.close()
otp = OTP(" ")
key = key[1:-1].split(', ')
for x in range(len(key)):
key[x] = int(key[x])
decrypted_message = otp.decrypt(encrypted_message, key)
print("Decrypted Message: {}".format(decrypted_message))
os.remove("../website/data/" + file)
if algo == 'substitution':
f = open("../website/data/" + file)
encrypted_message = f.read()
f.close()
key = key[1:-1].split(', ')
for x in range(len(key)):
key[x] = int(key[x])
substitution = SubstitutionCipher('', key)
def do_getTOTP(self, line):
"getTOTP [digits]"
digits = 6
if line:
digits = int(line.split()[0])
print("Your TOTP code : ", OTP.generate_totp(self.secret, digits))
def test_validate_totp(self):
self.assertTrue(OTP.validate_totp('07081804', self.secret, 1111111109, 8))
self.assertTrue(OTP.validate_totp('07081804', self.secret, 1111111084, 8))
self.assertFalse(OTP.validate_totp('07081804', self.secret, 1111111078, 8))
self.assertFalse(OTP.validate_totp('07081804', self.secret, 1111111140, 8))
def test_validate_hotp(self):
self.assertTrue(OTP.validate_hotp('755224', self.secret, 0))
self.assertTrue(OTP.validate_hotp('287082', self.secret, 0))
self.assertFalse(OTP.validate_hotp('969429', self.secret, 0))
