def get_icc_certificate(ipk_certificate: str, card_tags: Mapping[str, EmvTag]):
ipk_certificate_modulus = convert_hex_str_2_int(ipk_certificate)
ipk_certificate_exponent = convert_hex_str_2_int(card_tags['9F32'].value)
icc_public_key = card_tags['9F46'].value
icc_public_key_int = convert_hex_str_2_int(icc_public_key)
ca_ipk = RSAPublicKey(ipk_certificate_modulus, ipk_certificate_exponent)
decrypted = ca_ipk.decrypt(icc_public_key_int)
icc_public_key_decrypted = convert_int_2_hex_str(decrypted)
print(icc_public_key_decrypted)
def get_issuer_public_key(application: str, card_tags: Mapping[str, EmvTag]):
ca_key = ca_public_keys[application[0:10]][card_tags['8F'].value]
ca_key_modulus = convert_hex_str_2_int(ca_key['modulus'])
ca_key_exponent = ca_key['exponent']
issuer_public_key = card_tags['90'].value
issuer_public_key_int = convert_hex_str_2_int(issuer_public_key)
ca_ipk = RSAPublicKey(ca_key_modulus, ca_key_exponent)
decrypted = ca_ipk.decrypt(issuer_public_key_int)
issuer_public_key_decrypted = convert_int_2_hex_str(decrypted)
print(issuer_public_key_decrypted)
return issuer_public_key_decrypted[30:-42]
def parse_sfi(sfi_block: str) -> Tuple[int, int, int, int]:
"""
Get an afl block with 4 bytes and separate its values in a tuple
:param sfi_block: str of 4 bytes
:return: Tuple[sfi_number, first_record, last_record, signed_records]
"""
sfi = get_n_bytes(sfi_block, 1)[0]
sfi = convert_hex_str_2_int(sfi) >> 3
first_record = convert_hex_str_2_int(get_n_bytes(sfi_block, 1, 1)[0])
last_record = convert_hex_str_2_int(get_n_bytes(sfi_block, 1, 2)[0])
signed_record = convert_hex_str_2_int(get_n_bytes(sfi_block, 1, 3)[0])
return sfi, first_record, last_record, signed_record
def get_n_bytes(hex_str: str,
byte_qtd: Union[str, int],
offset: Union[str, int] = 0) -> Tuple[str, str]:
"""
Get N bytes of the provided hex_str
"""
if isinstance(byte_qtd, str):
byte_qtd = convert_hex_str_2_int(byte_qtd)
if isinstance(offset, str):
offset = convert_hex_str_2_int(offset)
offset *= 2
final = offset + byte_qtd * 2
return hex_str[offset:final], hex_str[final:]
# coding=utf-8
from Utils.Classes.RSA.RSAPublicKey import RSAPublicKey
from Utils.Convert import convert_hex_str_2_int, convert_int_2_hex_str
from Utils.EMVValues.CaPublicKeys import ca_public_keys
ca_key = ca_public_keys['A000000004']['05']
ca_key_modulus = convert_hex_str_2_int(ca_key['modulus'])
ca_key_exponent = ca_key['exponent']
issuer_public_key = (
'0160D9786A87CBCCE94E4FFB07333BB3ED704C4EF31D933A770172632717B367DD75C22D962BF600C2279D0BE2FE30DFE'
'06BA1637E39E2AC9C5096466D17D5D3507659FE5474174E60EFA6936B34BF789BAB07F4DE27C84E12D62EE7CFCCC6B14E'
'B57A8CA4B3814645712D4B067A7C8BE1A223C594619D7569B9D2DF03E1AB742C07E0050027EA72202D5B6F301217F81A0'
'B53AE612DDBD81CC887FE72066FAD8C1CEEE8FD6846A3A511C3DE10CA8930')
issuer_public_key_int = convert_hex_str_2_int(issuer_public_key)
ca_ipk = RSAPublicKey(ca_key_modulus, ca_key_exponent)
decrypted = ca_ipk.decrypt(issuer_public_key_int)
print(convert_int_2_hex_str(decrypted))
parsed = tlvParser.parse(card_connection.response)
print(parsed)
card_connection.disconnect()
print(signed_records)
print(card_tags)
print('*' * 100)
print(f'OFFLINE DATA AUTHENTICATION BEGIN')
print('*' * 100)
print('*' * 100)
print(f'USE CA PUBLIC KEY TO GET ISSUER PUBLIC KEY')
print('*' * 100)
ca_public_key_values = ca_public_keys[application[0:10]][card_tags['8F'].value]
ca_public_key_modulus = convert_hex_str_2_int(ca_public_key_values['modulus'])
ca_public_key_exponent = ca_public_key_values['exponent']
issuer_public_key = convert_hex_str_2_int(card_tags['90'].value)
ca_public_key = RSAPublicKey(ca_public_key_modulus, ca_public_key_exponent)
decrypted = ca_public_key.decrypt(issuer_public_key)
issuer_public_key_decrypted = convert_int_2_hex_str(decrypted)
assert get_n_bytes(issuer_public_key_decrypted, 1)[0] == '6A'
assert get_n_bytes(issuer_public_key_decrypted, 1, 1)[0] == '02'
pan_leftmost_digits = get_n_bytes(issuer_public_key_decrypted, 4,
2)[0].replace('FF', '')
assert card_tags['5A'].value.startswith(pan_leftmost_digits)
print(issuer_public_key_decrypted)