def post(self, **kw):
if not request.is_xhr:
raise HTTPNotFound()
app = self.app
valid, invalid = manage_form().native(kw)
for k in ('name', 'description', 'groups', 'site', 'contact'):
setattr(app, k, valid[k])
if valid['key']['public'].startswith('-'):
# Assume PEM format.
valid['key']['public'] = hexlify(
VerifyingKey.from_pem(valid['key']['public']).to_string())
app.key.public = valid['key']['public']
app.mask.required = valid['required'] or 0
app.mask.optional = valid['optional'] or 0
if valid['development'] == "true" or valid['development'] == "True":
app.development = True
else:
app.development = False
app.save()
return 'json:', dict(success=True, )
def post(self, **kw):
if not request.is_xhr:
raise HTTPNotFound()
app = self.app
valid, invalid = manage_form().native(kw)
for k in ('name', 'description', 'groups', 'site', 'contact'):
setattr(app, k, valid[k])
if valid['key']['public'].startswith('-'):
# Assume PEM format.
valid['key']['public'] = hexlify(VerifyingKey.from_pem(valid['key']['public']).to_string())
app.key.public = valid['key']['public']
app.mask.required = valid['required'] or 0
app.mask.optional = valid['optional'] or 0
if valid['development'] == "true" or valid['development'] == "True":
app.development = True
else:
app.development = False
app.save()
return 'json:', dict(
success = True,
)
def ecdsa_key_to_bin(ecdsa_key_file):
with open(ecdsa_key_file, 'r') as f:
ecdsa_key_str = f.read()
vk = VerifyingKey.from_pem(ecdsa_key_str)
_x = vk.pubkey.point.x()
_y = vk.pubkey.point.y()
x = bitarray(bin(_x)[2:])
y = bitarray(bin(_y)[2:])
x_remain = (8-(len(x) % 8)) % 8
y_remain = (8-(len(y) % 8)) % 8
for _ in range(0, x_remain):
x.insert(0, 0)
for _ in range(0, y_remain):
y.insert(0, 0)
x = x.tobytes()
y = y.tobytes()
x_b = bytearray(x)
y_b = bytearray(y)
key_bin = bytearray(48 * 2)
insert_bytearray(x_b, key_bin, 0)
insert_bytearray(y_b, key_bin, 48)
return key_bin
def from_string(s: str) -> 'DuckietownToken':
"""
Decodes a Duckietown Token string into an instance of
:py:class:`dt_authentication.DuckietownToken`.
Args:
s: The Duckietown Token string.
Raises:
InvalidToken: The given token is not valid.
"""
# break token into 3 pieces, dt1-PAYLOAD-SIGNATURE
p = s.split('-')
# check number of components
if len(p) != 3:
raise InvalidToken(
"The token should be comprised of three (dash-separated) parts"
)
# unpack components
version, payload_base58, signature_base58 = p
# check token version
if version != DuckietownToken.VERSION:
raise InvalidToken("Duckietown Token version '%s' not supported" %
version)
# decode payload and signature
payload_json = b58decode(payload_base58)
signature = b58decode(signature_base58)
# verify token
vk = VerifyingKey.from_pem(PUBLIC_KEY)
is_valid = False
try:
is_valid = vk.verify(signature, payload_json)
except BadSignatureError:
pass
# raise exception if the token is not valid
if not is_valid:
raise InvalidToken("Duckietown Token not valid")
# unpack payload
payload = json.loads(payload_json.decode("utf-8"))
if not isinstance(payload, dict) or \
len(set(payload.keys()).intersection(PAYLOAD_FIELDS)) != len(PAYLOAD_FIELDS):
raise InvalidToken("Duckietown Token has an invalid payload")
# ---
return DuckietownToken(payload, str(signature))
sendMessage(notified_socket,message_to_send)
elif message_received[0] == '1112':
secret_number = message_received[1]
value = getRegistrationDetailsFromDatabase(secret_number)
print(value)
message_to_send = ['2222',value[0]]
sendMessage(notified_socket,message_to_send)
elif message_received[0] == '0001':
secret_number = message_received[1]
data = getRegistrationDetailsFromDatabase(secret_number)
if(data is False):
message_to_send = ['0002',data]
sendMessage(notified_socket,message_to_send)
else:
public_key = data[0][1]
public_key = VerifyingKey.from_pem(public_key)
puzzle_number = randint(1111,99999)
message_to_send = ['0002',puzzle_number]
sendMessage(notified_socket,message_to_send)
message_received = receiveMessages(notified_socket)
if(message_received[0] == '0010'):
signature = message_received[1]
if(signature is False):
socket_list.remove(notified_socket)
continue
value = public_key.verify(signature,str(puzzle_number).encode())
message_to_send = ['0020',value]
authenticated[secret_number] = True
else:
message_to_send = ['0020',False]
