def test_get_all_public_key_data(self):
# Hm. The behaviour of something that matches
# more than one key may change.
data = get_public_key_data("", homedir=self.homedir)
newkey = openpgpkey_from_data(data)
# Hrm. We may be better off checking for a few things
# we actually care about rather than delegating to the Key() itself.
assert_equals(self.originalkey, newkey)
def setup(self):
self.fname = get_fixture_file("seckey-1.asc")
original = open(self.fname, 'r').read()
# This should be a new, empty directory
self.homedir = tempfile.mkdtemp()
gpgcmd = ["gpg", "--homedir={}".format(self.homedir)]
# The directory should not have any keys
# I don't know how to easily check for that, though
# Now we import a single key
check_call(gpgcmd + ["--import", self.fname])
self.originalkey = openpgpkey_from_data(original)
def test_wrmhl_wrong_code():
data = read_fixture_file("seckey-no-pw-1.asc")
key = openpgpkey_from_data(data)
log.info("Running with key %r", key)
# Start offering the key
offer = WormholeOffer(key)
info = yield offer.allocate_code()
code, _ = info
offer.start()
receive = WormholeReceive(code + "-wrong")
msg_tuple = yield receive.start()
downloaded_key_data, success, message = msg_tuple
assert_false(success)
assert_is_not_none(message)
assert_equal(message, WrongPasswordError)
def test_wrmhl():
data = read_fixture_file("seckey-no-pw-1.asc")
key = openpgpkey_from_data(data)
file_key_data = get_public_key_data(key.fingerprint)
log.info("Running with key %r", key)
# Start offering the key
offer = WormholeOffer(key)
info = yield offer.allocate_code()
code, _ = info
offer.start()
receive = WormholeReceive(code)
msg_tuple = yield receive.start()
downloaded_key_data, success, _ = msg_tuple
assert_true(success)
log.info("Checking with key: %r", downloaded_key_data)
assert_equal(downloaded_key_data, file_key_data)
def test_bt_corrupted_key():
"""This test requires two working Bluetooth devices"""
@inlineCallbacks
def start(bo):
success = False
try:
while not success:
# server_socket.accept() is not stoppable. So with select we can call accept()
# only when we are sure that there is already a waiting connection
ready_to_read, ready_to_write, in_error = yield threads.deferToThread(
select.select, [bo.server_socket], [], [], 0.5)
if ready_to_read:
# We are sure that a connection is available, so we can call
# accept() without deferring it to a thread
client_socket, address = bo.server_socket.accept()
key_data = get_public_key_data(bo.key.fingerprint)
kd_decoded = key_data.decode('utf-8')
# We send only a part of the key. In this way we can simulate the case
# where the connection has been lost
half = len(kd_decoded)/2
kd_corrupted = kd_decoded[:half]
yield threads.deferToThread(client_socket.sendall, kd_corrupted)
client_socket.shutdown(socket.SHUT_RDWR)
client_socket.close()
success = True
except Exception as e:
log.error("An error occurred: %s" % e)
data = read_fixture_file("seckey-no-pw-1.asc")
key = openpgpkey_from_data(data)
log.info("Running with key %r", key)
file_key_data = get_public_key_data(key.fingerprint)
hmac = mac_generate(key.fingerprint.encode('ascii'), file_key_data)
# Start offering the key
offer = BluetoothOffer(key)
data = yield offer.allocate_code()
# getting the code from "BT=code;...."
code = data.split("=", 1)[1]
code = code.split(";", 1)[0]
port = int(data.rsplit("=", 1)[1])
start(offer)
receive = BluetoothReceive(port)
msg_tuple = yield receive.find_key(code, hmac)
downloaded_key_data, result, error = msg_tuple
assert_false(result)
assert_equal(type(error), ValueError)
def test_wrmhl_offline_code():
data = read_fixture_file("seckey-no-pw-1.asc")
key = openpgpkey_from_data(data)
file_key_data = get_public_key_data(key.fingerprint)
# We assume that this channel, at execution time, is free
code = "5556-penguin-paw-print"
# Start offering the key
offer = WormholeOffer(key)
offer.allocate_code(code)
offer.start()
# Start receiving the key
receive = WormholeReceive(code)
msg_tuple = yield receive.start()
downloaded_key_data, success, _ = msg_tuple
assert_true(success)
log.info("Checking with key: %r", downloaded_key_data)
assert_equal(downloaded_key_data, file_key_data)
def test_bt_wrong_hmac():
"""This test requires two working Bluetooth devices"""
data = read_fixture_file("seckey-no-pw-1.asc")
key = openpgpkey_from_data(data)
log.info("Running with key %r", key)
hmac = "wrong_hmac_eg_tampered_key"
# Start offering the key
offer = BluetoothOffer(key)
data = yield offer.allocate_code()
# getting the code from "BT=code;...."
code = data.split("=", 1)[1]
code = code.split(";", 1)[0]
port = int(data.rsplit("=", 1)[1])
offer.start()
receive = BluetoothReceive(port)
msg_tuple = yield receive.find_key(code, hmac)
downloaded_key_data, success, _ = msg_tuple
assert_false(success)
def test_bt():
"""This test requires two working Bluetooth devices"""
data = read_fixture_file("seckey-no-pw-1.asc")
key = openpgpkey_from_data(data)
file_key_data = get_public_key_data(key.fingerprint)
log.info("Running with key %r", key)
hmac = mac_generate(key.fingerprint.encode('ascii'), file_key_data)
# Start offering the key
offer = BluetoothOffer(key)
data = yield offer.allocate_code()
# getting the code from "BT=code;...."
code = data.split("=", 1)[1]
code = code.split(";", 1)[0]
port = int(data.rsplit("=", 1)[1])
offer.start()
receive = BluetoothReceive(port)
msg_tuple = yield receive.find_key(code, hmac)
downloaded_key_data, success, _ = msg_tuple
assert_true(success)
log.info("Checking with key: %r", downloaded_key_data)
assert_equal(downloaded_key_data.encode("utf-8"), file_key_data)
def load_key(key):
f = read_fixture_file(key)
k = gpgmh.openpgpkey_from_data(f)
return k
def setup(self):
data = read_fixture_file("pubkey-1.asc")
self.key = openpgpkey_from_data(data)
def test_openpgpkey_from_wrong_data():
r = openpgpkey_from_data("this is no key!!1")
assert False
def test_openpgpkey_from_empty_data():
r = openpgpkey_from_data("")
assert False
def test_openpgpkey_from_no_data():
r = openpgpkey_from_data(None)
assert False
def test_no_match(self):
data = get_public_key_data("nothing should match this",
homedir=self.homedir)
newkey = openpgpkey_from_data(data)
assert False
def test_get_public_key_data(self):
fpr = self.originalkey.fingerprint
data = get_public_key_data(fpr, homedir=self.homedir)
newkey = openpgpkey_from_data(data)
assert_equals(fpr, newkey.fingerprint)
