forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
173 lines
5.5 KiB
173 lines
5.5 KiB
from freshen import * |
|
from freshen.checks import * |
|
from nose.tools import assert_regexp_matches |
|
from binascii import hexlify |
|
|
|
import ast |
|
|
|
import gnuk_token as gnuk |
|
import rsa_keys |
|
from array import array |
|
|
|
@Before |
|
def ini(sc): |
|
if not glc.token: |
|
glc.token = gnuk.get_gnuk_device() |
|
glc.token.cmd_select_openpgp() |
|
|
|
@Given("cmd_verify with (.*) and \"(.*)\"") |
|
def cmd_verify(who_str,pass_str): |
|
who = int(who_str) |
|
scc.result = glc.token.cmd_verify(who, pass_str) |
|
|
|
@Given("cmd_change_reference_data with (.*) and \"(.*)\"") |
|
def cmd_change_reference_data(who_str,pass_str): |
|
who = int(who_str) |
|
scc.result = glc.token.cmd_change_reference_data(who, pass_str) |
|
|
|
@Given("cmd_put_data with (.*) and (\".*\")") |
|
def cmd_put_data(tag_str,content_str_repr): |
|
content_str = ast.literal_eval("b" + content_str_repr + "") |
|
tag = int(tag_str, 16) |
|
tagh = tag >> 8 |
|
tagl = tag & 0xff |
|
scc.result = glc.token.cmd_put_data(tagh, tagl, content_str) |
|
|
|
@Given("cmd_reset_retry_counter with (.*) and \"(.*)\"") |
|
def cmd_reset_retry_counter(how_str, data): |
|
how = int(how_str) |
|
scc.result = glc.token.cmd_reset_retry_counter(how, 0x81, data) |
|
|
|
@Given("a RSA key pair (.*)") |
|
def set_rsa_key(keyno_str): |
|
scc.keyno = int(keyno_str) |
|
|
|
@Given("importing it to the token as OPENPGP.(.*)") |
|
def import_key(openpgp_keyno_str): |
|
openpgp_keyno = int(openpgp_keyno_str) |
|
t = rsa_keys.build_privkey_template(openpgp_keyno, scc.keyno) |
|
scc.result = glc.token.cmd_put_data_odd(0x3f, 0xff, t) |
|
|
|
@Given("a fingerprint of OPENPGP.(.*) key") |
|
def get_key_fpr(openpgp_keyno_str): |
|
openpgp_keyno = int(openpgp_keyno_str) |
|
scc.result = rsa_keys.fpr[openpgp_keyno - 1] |
|
|
|
@Given("a timestamp of OPENPGP.(.*) key") |
|
def get_key_timestamp(openpgp_keyno_str): |
|
openpgp_keyno = int(openpgp_keyno_str) |
|
scc.result = rsa_keys.timestamp[openpgp_keyno - 1] |
|
|
|
@Given("put the data to (.*)") |
|
def cmd_put_data_with_result(tag_str): |
|
tag = int(tag_str, 16) |
|
tagh = tag >> 8 |
|
tagl = tag & 0xff |
|
scc.result = glc.token.cmd_put_data(tagh, tagl, scc.result) |
|
|
|
@Given("a message (\".*\")") |
|
def set_msg(content_str_repr): |
|
msg = ast.literal_eval(content_str_repr).encode('UTF-8') |
|
scc.digestinfo = rsa_keys.compute_digestinfo(msg) |
|
|
|
@Given("a public key from token for OPENPGP.(.*)") |
|
def get_public_key(openpgp_keyno_str): |
|
openpgp_keyno = int(openpgp_keyno_str) |
|
scc.pubkey_info = glc.token.cmd_get_public_key(openpgp_keyno) |
|
|
|
@Given("verify signature") |
|
def verify_signature(): |
|
scc.result = rsa_keys.verify_signature(scc.pubkey_info, scc.digestinfo, scc.sig) |
|
|
|
@Given("let a token compute digital signature") |
|
def compute_signature(): |
|
scc.sig = int(hexlify(glc.token.cmd_pso(0x9e, 0x9a, scc.digestinfo)),16) |
|
|
|
@Given("let a token authenticate") |
|
def internal_authenticate(): |
|
scc.sig = int(hexlify(glc.token.cmd_internal_authenticate(scc.digestinfo)),16) |
|
|
|
@Given("compute digital signature on host with RSA key pair (.*)") |
|
def compute_signature_on_host(keyno_str): |
|
keyno = int(keyno_str) |
|
scc.result = rsa_keys.compute_signature(keyno, scc.digestinfo) |
|
|
|
@Given("a plain text (\".*\")") |
|
def set_plaintext(content_str_repr): |
|
scc.plaintext = ast.literal_eval("b" + content_str_repr + "") |
|
|
|
@Given("encrypt it on host with RSA key pair (.*)$") |
|
def encrypt_on_host(keyno_str): |
|
keyno = int(keyno_str) |
|
scc.ciphertext = rsa_keys.encrypt(keyno, scc.plaintext) |
|
|
|
@Given("encrypt it on host$") |
|
def encrypt_on_host_public_key(): |
|
scc.ciphertext = rsa_keys.encrypt_with_pubkey(scc.pubkey_info, scc.plaintext) |
|
|
|
@Given("let a token decrypt encrypted data") |
|
def decrypt(): |
|
scc.result = glc.token.cmd_pso_longdata(0x80, 0x86, scc.ciphertext).tostring() |
|
|
|
@Given("USB version string of the token") |
|
def usb_version_string(): |
|
scc.result = glc.token.get_string(3) |
|
|
|
@When("requesting (.+): ([0-9a-fA-F]+)") |
|
def get_data(name, tag_str): |
|
tag = int(tag_str, 16) |
|
tagh = tag >> 8 |
|
tagl = tag & 0xff |
|
scc.result = glc.token.cmd_get_data(tagh, tagl) |
|
|
|
@When("removing a key OPENPGP.(.*)") |
|
def remove_key(openpgp_keyno_str): |
|
openpgp_keyno = int(openpgp_keyno_str) |
|
t = rsa_keys.build_privkey_template_for_remove(openpgp_keyno) |
|
scc.result = glc.token.cmd_put_data_odd(0x3f, 0xff, t) |
|
|
|
@When("generating a key of OPENPGP.(.*)") |
|
def generate_key(openpgp_keyno_str): |
|
openpgp_keyno = int(openpgp_keyno_str) |
|
pubkey_info = glc.token.cmd_genkey(openpgp_keyno) |
|
scc.data = rsa_keys.calc_fpr(pubkey_info[0].tostring(), pubkey_info[1].tostring()) |
|
|
|
@When("put the first data to (.*)") |
|
def cmd_put_data_first_with_result(tag_str): |
|
tag = int(tag_str, 16) |
|
tagh = tag >> 8 |
|
tagl = tag & 0xff |
|
scc.result = glc.token.cmd_put_data(tagh, tagl, scc.data[0]) |
|
|
|
@When("put the second data to (.*)") |
|
def cmd_put_data_second_with_result(tag_str): |
|
tag = int(tag_str, 16) |
|
tagh = tag >> 8 |
|
tagl = tag & 0xff |
|
result = glc.token.cmd_put_data(tagh, tagl, scc.data[1]) |
|
scc.result = (scc.result and result) |
|
|
|
@Then("you should get: (.*)") |
|
def check_result(v): |
|
value = ast.literal_eval("b'" + v + "'") |
|
assert_equal(scc.result, array('B', value)) |
|
|
|
@Then("it should get success") |
|
def check_success(): |
|
assert_equal(scc.result, True) |
|
|
|
@Then("you should get NULL") |
|
def check_null(): |
|
assert_equal(scc.result, array('B')) |
|
|
|
@Then("data should match: (.*)") |
|
def check_regexp(re): |
|
assert_regexp_matches(scc.result, re) |
|
|
|
@Then("results should be same") |
|
def check_signature(): |
|
assert_equal(scc.sig, scc.result) |
|
|
|
@Then("decrypted data should be same as a plain text") |
|
def check_decrypt(): |
|
assert_equal(scc.plaintext, scc.result)
|
|
|