def __init__(self, readerName=None, cardServiceClass=None):
"""Session constructor. Initializes a smart card session and
connect to the card.
@param readerName: reader to connect to; default is first PCSC reader
@param cardServiceClass: card service to bind the session to; default
is None
"""
# if reader name not given, select first reader
if readerName is None:
if len(readers()) > 0:
self.reader = readers()[0]
self.readerName = repr(self.reader)
else:
raise NoReadersException()
# otherwise select reader from name
else:
self.readerName = readerName
for reader in readers():
if readerName == str(reader):
self.reader = reader
self.readerName = repr(self.reader)
try:
self.reader
except AttributeError:
raise InvalidReaderException(self.readerName)
# open card connection and bind PassThruCardService
cc = self.reader.createConnection()
self.cs = PassThruCardService(cc)
self.cs.connection.connect()
def __init__(self, readerName=None, cardServiceClass=None):
"""Session constructor. Initializes a smart card session and
connect to the card.
@param readerName: reader to connect to; default is first PCSC reader
@param cardServiceClass: card service to bind the session to; default
is None
"""
# if reader name not given, select first reader
if readerName is None:
if len(readers()) > 0:
self.reader = readers()[0]
self.readerName = repr(self.reader)
else:
raise NoReadersException()
# otherwise select reader from name
else:
self.readerName = readerName
for reader in readers():
if readerName == str(reader):
self.reader = reader
self.readerName = repr(self.reader)
try:
self.reader
except AttributeError:
raise InvalidReaderException(self.readerName)
# open card connection and bind PassThruCardService
cc = self.reader.createConnection()
self.cs = PassThruCardService(cc)
self.cs.connection.connect()
def checklocalconfig():
try:
f = open('local_config.py', 'r')
except IOError:
print 'local_config.py not found; generating local_config.py...'
# generate local configuration
f = open('local_config.py', 'w+')
f.write('from smartcard.util import toHexString\n')
f.write('expectedReaders = ')
f.write(str(readers()) + '\n')
expectedATRs = []
for reader in readers():
try:
expectedATRs.append(getATR(reader))
except NoCardException:
expectedATRs.append([])
f.write('expectedATRs = ')
#for atr in expectedATRs: print `toHexString(atr)`
f.write( ` expectedATRs ` + '\n')
f.write('expectedATRinReader = {}\n')
f.write('for i in xrange(len(expectedReaders)):\n')
f.write(' expectedATRinReader[expectedReaders[i]] = expectedATRs[i]\n')
f.write('expectedReaderForATR = {}\n')
f.write('for i in xrange(len(expectedReaders)):\n')
f.write(
' expectedReaderForATR[toHexString(expectedATRs[i])] = expectedReaders[i]\n'
)
f.write('expectedReaderGroups = [\'SCard$DefaultReaders\']\n')
f.close()
def main():
""" main """
card_connection = readers()[0].createConnection()
card_connection.connect(mode=SCARD_SHARE_DIRECT,
disposition=SCARD_LEAVE_CARD)
feature_list = getFeatureRequest(card_connection)
get_tlv_properties = hasFeature(feature_list, FEATURE_GET_TLV_PROPERTIES)
if get_tlv_properties:
tlv = getTlvProperties(card_connection)
print "Reader: ", readers()[0]
print "IdVendor: 0x%04X" % tlv['PCSCv2_PART10_PROPERTY_wIdVendor']
print "IdProduct: 0x%04X" % tlv['PCSCv2_PART10_PROPERTY_wIdProduct']
ccid_esc_command = hasFeature(feature_list, FEATURE_CCID_ESC_COMMAND)
if ccid_esc_command is None:
raise Exception("FEATURE_CCID_ESC_COMMAND is not supported or allowed")
# Proprietary command for Gemalto readers
# This is implemented by the Gemalto Pinpad v2 and C200 readers
firmware_features = [0x6A]
try:
res = card_connection.control(ccid_esc_command, firmware_features)
except SmartcardException, ex:
print "Failed:", ex
return
def checklocalconfig():
try:
f = open('local_config.py', 'r')
except IOError:
print 'local_config.py not found; generating local_config.py...'
# generate local configuration
f = open('local_config.py', 'w+')
f.write('from smartcard.util import toHexString\n')
f.write('expectedReaders = ')
f.write(str(readers()) + '\n')
expectedATRs = []
for reader in readers():
try:
expectedATRs.append(getATR(reader))
except NoCardException:
expectedATRs.append([])
f.write('expectedATRs = ')
#for atr in expectedATRs: print `toHexString(atr)`
f.write(`expectedATRs` + '\n')
f.write('expectedATRinReader = {}\n')
f.write('for i in xrange(len(expectedReaders)):\n')
f.write(' expectedATRinReader[expectedReaders[i]] = expectedATRs[i]\n')
f.write('expectedReaderForATR = {}\n')
f.write('for i in xrange(len(expectedReaders)):\n')
f.write(' expectedReaderForATR[toHexString(expectedATRs[i])] = expectedReaders[i]\n')
f.write('expectedReaderGroups = [\'SCard$DefaultReaders\']\n')
f.close()
def testcase_CardRequestNewCardInReaderNotPresentInfiniteTimeOut(self):
"""Test smartcard.CardRequest for any new card in a specific
reader not present without time-out."""
print('please remove a smart card reader')
_readerz = readers()
while True:
readerz = readers()
if len(_readerz) > len(readerz):
break
time.sleep(.1)
for reader in readerz:
_readerz.remove(reader)
cardtype = AnyCardType()
cardrequest = CardRequest(
timeout=None,
readers=[_readerz[0]],
cardType=cardtype,
newcardonly=True)
print('Re-insert reader ', _readerz[0], 'with a card inside')
cardservice = cardrequest.waitforcard()
cardservice.connection.connect()
print(toHexString(
cardservice.connection.getATR()), \
'in', cardservice.connection.getReader())
cardservice.connection.disconnect()
def main():
""" main """
card_connection = readers()[0].createConnection()
card_connection.connect(mode=SCARD_SHARE_DIRECT,
disposition=SCARD_LEAVE_CARD)
feature_list = getFeatureRequest(card_connection)
get_tlv_properties = hasFeature(feature_list, FEATURE_GET_TLV_PROPERTIES)
if get_tlv_properties:
tlv = getTlvProperties(card_connection)
print "Reader: ", readers()[0]
print "IdVendor: 0x%04X" % tlv['PCSCv2_PART10_PROPERTY_wIdVendor']
print "IdProduct: 0x%04X" % tlv['PCSCv2_PART10_PROPERTY_wIdProduct']
ccid_esc_command = hasFeature(feature_list, FEATURE_CCID_ESC_COMMAND)
if ccid_esc_command is None:
raise Exception("FEATURE_CCID_ESC_COMMAND is not supported or allowed")
# Proprietary command for Gemalto readers
# This is implemented by the Gemalto Pinpad v2 and C200 readers
firmware_features = [0x6A]
try:
res = card_connection.control(ccid_esc_command, firmware_features)
except SmartcardException, ex:
print "Failed:", ex
return
def testcase_CardRequestNewCardInReaderNotPresentInfiniteTimeOut(self):
"""Test smartcard.CardRequest for any new card in a specific
reader not present without time-out."""
print 'please remove a smart card reader'
_readerz = readers()
while True:
readerz = readers()
if len(_readerz) > len(readerz):
break
time.sleep(.1)
for reader in readerz:
_readerz.remove(reader)
cardtype = AnyCardType()
cardrequest = CardRequest(
timeout=None,
readers=[_readerz[0]],
cardType=cardtype,
newcardonly=True)
print 'Re-insert reader ', _readerz[0], 'with a card inside'
cardservice = cardrequest.waitforcard()
cardservice.connection.connect()
print toHexString(
cardservice.connection.getATR()), \
'in', cardservice.connection.getReader()
cardservice.connection.disconnect()
def testcase_Card_Eq_NotEq(self):
"""Test == and != for Cards."""
for reader in readers():
card = Card(str(reader), expectedATRinReader[str(reader)])
cardcopy = Card(str(reader), expectedATRinReader[str(reader)])
self.assertEqual(True, card == cardcopy)
self.assertEqual(True, not card != cardcopy)
for reader in readers():
card = Card(str(reader), expectedATRinReader[str(reader)])
cardcopy = Card(str(reader), [0, 0])
self.assertEqual(True, card != cardcopy)
self.assertEqual(True, not card == cardcopy)
def testcase_Card_Eq_NotEq(self):
"""Test == and != for Cards."""
for reader in readers():
card = Card(str(reader), expectedATRinReader[str(reader)])
cardcopy = Card(str(reader), expectedATRinReader[str(reader)])
self.assertEqual(True, card == cardcopy)
self.assertEqual(True, not card != cardcopy)
for reader in readers():
card = Card(str(reader), expectedATRinReader[str(reader)])
cardcopy = Card(str(reader), [0, 0])
self.assertEqual(True, card != cardcopy)
self.assertEqual(True, not card == cardcopy)
def readCard(request):
response_data = {}
response_error = {}
# define the APDUs used in this script
COMMAND = [0xFF, 0xCA, 0x00, 0x00, 0x00]
# get all the available readers
r = readers()
if len(r) > 0:
reader = r[0]
try:
connection = reader.createConnection()
connection.connect()
data, sw1, sw2 = connection.transmit(COMMAND)
response_data['reader'] = str(reader)
response_data['UUIDec'] = str(data)
response_data['UUIDHex'] = "".join(
['{:02X}'.format(h) for h in data])
response_data['command'] = str(sw1) + " " + str(sw2)
response_data['message'] = "Ok"
#raise Exception('hola')
except Exception:
response_error['error'] = 'No se detecto ninguna tarjeta'
return HttpResponse(json.dumps(response_error),
content_type="application/json")
return HttpResponse(json.dumps(response_data),
content_type="application/json")
else:
response_error['error'] = 'No se detecto ningun lector'
return HttpResponse(json.dumps(response_error),
content_type="application/json")
def testcase_readers_in_readergroup_nonexistent(self):
foundreaders = {}
for reader in readers(['dummy$group']):
foundreaders[reader] = 1
for reader in expectedReaders:
self.assert_(not foundreaders.has_key(reader))
self.assertEquals(0, len(foundreaders))
def work():
r = readers()
if len(r) < 1:
print ("error: No readers available!")
sys.exit()
else :
reader = r[0]
print ("Using: ", reader)
connection = reader.createConnection()
while(True):
try:
connection.connect()
cmdMap = {
"getuid":[0xFF, 0xCA, 0x00, 0x00, 0x00]
}
data, sw1, sw2 = connection.transmit( cmdMap['getuid'] )
uid = toHexString(data)
checkUid(uid)
sleep(1)
except:
print("No Card")
window.deiconify()
sleep(1)
continue
def setUp(self): r = readers() self.max = maxim.MaximAPI(r[0]) self.max.Connect() self.CardInterfaces = [1,2] self.UnknownInterfaces = [3, 7] self.timeout = 0b10000111
def main():
global logger
global consumer
setup_logging()
logger = logging.getLogger(__name__)
logger.info(
"Insert MIFARE Desfire card to any reader to get its applications.")
available_reader = readers()
logger.info("Available readers: %s", available_reader)
if not available_reader:
sys.exit("No smartcard readers detected")
consumer = ConsumerThread()
consumer.start()
cardmonitor = CardMonitor()
cardobserver = MyObserver()
cardmonitor.addObserver(cardobserver)
try:
while True:
time.sleep(1)
finally:
consumer.alive = False
# don't forget to remove observer, or the
# monitor will poll forever...
cardmonitor.deleteObserver(cardobserver)
def Baca(blok):
try:
r = readers()
print "Available readers:", r
reader = r[0]
connection = reader.createConnection()
connection.connect()
cmdott = [0xFF, 0x88, 0x00, blok, 0x60, 0x00]
cmd = [0xFF, 0xB0, 0x00, blok, 0x10]
dataott, sw1, sw2 = connection.transmit(cmdott)
# print "Select Applet: %02X %02X" % (sw1, sw2)
if hex(sw1) == hex(144):
print "Ott Sukses"
else:
print "Ott Gagal"
data, sw1, sw2 = connection.transmit(cmd)
if hex(sw1) == hex(144):
print "Baca Sukses"
else:
print "Baca Gagal"
except smartcard.Exceptions.CardConnectionException as inst:
print "Kartu Tidak di Temukan, Mohon Untuk Men Tap Kartu Pada Reader! "
except:
print "Ada Error/NFC Reader Belum Terhubung!"
return toASCIIString(data)
def open_key_multiple_readers(name=None):
"""
Opens a smartcard reader matching the given name and connects to the
ykneo-oath applet through it.
Returns a reference to the YkneoYubiOath object.
"""
for reader in readers():
print "list of readers"
print readers
try:
conn = reader.createConnection()
conn.connect()
data, status = _cmd2(conn, 0, 0xa4, 0x04, 0x00, 'a0000005272101'.decode('hex'))
if (status) != 0x9000:
print "unable to select the applet on reader %s" % reader
else:
print "using reader"
print reader
return YkneoYubiOath(conn)
except Exception, e:
print "WARNING: %s" % e
print "i am in the except of multiple readers"
def closing_connection():
import time
import os, shutil, os.path
"""
This method will ask the user the reject the card!
"""
# Destroy session for next use!
session.clear()
# Destroy all files within data directory!
folder = 'data/'
for the_file in os.listdir(folder):
file_path = os.path.join(folder, the_file)
try:
if os.path.isfile(file_path):
os.unlink(file_path)
#elif os.path.isdir(file_path): shutil.rmtree(file_path)
except Exception as e:
print(e)
# Write file is_exist_card for an ajax to check it
write_data_to_file("is_exist_card", 'data_exist')
r = readers()
reader = r[0]
connection = reader.createConnection()
connection.disconnect()
time.sleep(10) # delays for 10 seconds
os.remove('is_exist_card')
return redirect(url_for('index'))
def __init__(self):
# Get all the available readers
readerList = readers()
print('Available readers:')
for readerIndex, readerItem in enumerate(readerList):
print(readerIndex, readerItem)
# Select reader
readerSelectIndex = 0 # int(input('Select reader[0]: ') or '0')
reader = readerList[readerSelectIndex]
print('Using:', reader)
self.connection = reader.createConnection()
self.connection.connect()
atr = self.connection.getATR()
print('ATR: ' + toHexString(atr))
if (atr[0] == 0x3B & atr[1] == 0x67):
self.req = [0x00, 0xc0, 0x00, 0x01]
else:
self.req = [0x00, 0xc0, 0x00, 0x00]
# Check card
data, sw1, sw2 = self.connection.transmit(SELECT + THAI_CARD)
print('Select Applet: %02X %02X' % (sw1, sw2))
self.PHOTO = [
CMD_PHOTO1, CMD_PHOTO2, CMD_PHOTO3, CMD_PHOTO4, CMD_PHOTO5,
CMD_PHOTO6, CMD_PHOTO7, CMD_PHOTO8, CMD_PHOTO9, CMD_PHOTO10,
CMD_PHOTO11, CMD_PHOTO12, CMD_PHOTO13, CMD_PHOTO14, CMD_PHOTO15,
CMD_PHOTO16, CMD_PHOTO17, CMD_PHOTO18, CMD_PHOTO19, CMD_PHOTO20]
def __init__(self, reader_number: int = 0, **kwargs):
super().__init__(**kwargs)
r = readers()
if reader_number >= len(r):
raise ReaderError
self._reader = r[reader_number]
self._con = self._reader.createConnection()
def connexion():
#Tant que la carte n'a pas été insérée
while (True):
try:
r = readers()
connection = r[0].createConnection()
connection.connect()
#Selection AID
data, sw1, sw2 = connection.transmit([
0x00, 0xA4, 0x04, 0x00, 0x08, 0x01, 0x02, 0x03, 0x04, 0x05,
0x06, 0x07, 0x08
])
if ((int(sw1) != 144) or (int(sw2) != 0)):
print("Problème de communication")
sys.exit()
if ((int(sw1) == 144) and (int(sw2) == 0)):
print("Connexion établie")
if (AUTH == False):
authentification(connection)
break
except NoCardException:
print("Veuillez insérer la carte")
time.sleep(5)
except CardConnectionException:
print("La carte a été retirée")
print("Veuillez insérer la carte")
return connection
def __send_intro_message(self, waiting):
""" sends introduction message and returns active connection to device """
logging.debug('Initialized communication. waiting for device...')
if waiting:
cardrequest = CardRequest(timeout=3000)
cardrequest.waitforcard()
r = readers()
reader = r[0]
connection = reader.createConnection()
connection.connect()
logging.debug('Connected to device. ')
logging.debug('Sending initial message with AID.')
# Send introductory message with AID from configuration file
intro_message = APDUMessage(APDUHeader.SELECT_AID,
config.AID).convertToByteArray()
data, sw1, sw2 = connection.transmit(intro_message)
logging.debug('Got response: %02X %02X' % (sw1, sw2))
# Return active connection that is later used to communicate with device
return connection
def getDongle(debug=False, selectCommand=None):
dev = None
hidDevicePath = None
ledger = True
for hidDevice in hid.enumerate(0, 0):
if hidDevice['vendor_id'] == 0x2c97:
hidDevicePath = hidDevice['path']
if hidDevicePath is not None:
dev = hid.device()
dev.open_path(hidDevicePath)
dev.set_nonblocking(True)
return HIDDongleHIDAPI(dev, ledger, debug)
if SCARD:
connection = None
for reader in readers():
try:
connection = reader.createConnection()
connection.connect()
if selectCommand != None:
response, sw1, sw2 = connection.transmit(
toBytes("00A4040010FF4C4547522E57414C5430312E493031"))
sw = (sw1 << 8) | sw2
if sw == 0x9000:
break
else:
connection.disconnect()
connection = None
else:
break
except:
connection = None
pass
if connection is not None:
return DongleSmartcard(connection, debug)
raise CommException("No dongle found")
def message_received(client, server, message):
if message == "GetInfo":
try:
Select = [0xFF, 0xA4, 0x00, 0x00, 0x01, 0x06]
ReadName = [0xFF, 0xB0, 0x00, 0x20, 0x09]
ReadBirthday = [0xFF, 0xB0, 0x00, 0x30, 0x08]
ReadID = [0xFF, 0xB0, 0x00, 0x40, 0x0A]
r = readers()
reader = r[0]
connection = reader.createConnection()
connection.connect()
connection.transmit(Select)
send_data = ''
data, sw1, sw2 = connection.transmit(ReadName)
send_data += bytes(data).decode('utf8') + ","
data, sw1, sw2 = connection.transmit(ReadBirthday)
send_data += ''.join(chr(i) for i in data) + ","
data, sw1, sw2 = connection.transmit(ReadID)
send_data += ''.join(chr(i) for i in data) + "\n"
server.send_message_to_all(send_data)
except:
server.send_message_to_all('error')
def __init__(self, AppID="A0000010000112"):
"""Search for a Cryptnox and connect to it."""
reader_detected = False
self.appid = AppID
readers_list = readers()
if len(readers_list) > 0:
logger.debug("Available smartcard readers : %s", readers_list)
for r in readers_list:
if not str(r).startswith("Yubico"):
try:
logger.debug("Trying with reader : %s", r)
self.connection = r.createConnection()
self.connection.connect(CardConnection.T1_protocol)
reader_detected = hasattr(self, "connection")
except Exception:
logger.debug("Fail with this reader")
pass
if reader_detected:
logger.debug("A Cryptnox detected, using %s", r)
break
if reader_detected:
self.select()
else:
raise Exception("Can't find any Cryptnox connected.")
self.sec_chan = None
self.SNID = None # will be set by get_manufacturer_cert (cert ID)
self.session_pub_key = self.check_genuine()
def switch_interface(interface):
"""
switch from contact to contactless (or reverse) on a GemProx DU reader
"""
for reader in readers():
cardConnection = reader.createConnection()
cardConnection.connect(mode=SCARD_SHARE_DIRECT, disposition=SCARD_LEAVE_CARD)
switch_interface_cmd = [0x52, 0xF8, 0x04, 0x01, 0x00, interface]
print("Reader:", reader, "=>", end=' ')
try:
res = cardConnection.control(IOCTL_SMARTCARD_VENDOR_IFD_EXCHANGE,
switch_interface_cmd)
except:
print("FAILED")
else:
if res != [0, 0, 0, 0]:
print("Failed: ", end='')
err = res[0] * 256 + res[1]
if err == 0xFF83:
print("Wrong data parameters")
elif err == 0xFF84:
print("Wrong command bytes")
else:
print("Unknown error:", [hex(x) for x in res])
else:
print("Success")
def switch_interface(interface):
"""
switch from contact to contactless (or reverse) on a GemProx DU reader
"""
for reader in readers():
cardConnection = reader.createConnection()
cardConnection.connect(mode=SCARD_SHARE_DIRECT, disposition=SCARD_LEAVE_CARD)
switch_interface_cmd = [0x52, 0xF8, 0x04, 0x01, 0x00, interface]
print("Reader:", reader, "=>", end=' ')
try:
res = cardConnection.control(IOCTL_SMARTCARD_VENDOR_IFD_EXCHANGE,
switch_interface_cmd)
except SmartcardException as e:
print("FAILED")
else:
if res != [0, 0, 0, 0]:
print("Failed: ", end='')
err = res[0] * 256 + res[1]
if err == 0xFF83:
print("Wrong data parameters")
elif err == 0xFF84:
print("Wrong command bytes")
else:
print("Unknown error:", [hex(x) for x in res])
else:
print("Success")
def mp_procedure(reader_name):
print("Input the serial: ")
serial_hex = input()
print("\n------")
print("Current serial: {}".format(serial_hex))
input("Insert a canokey then press enter to continue, Ctrl-C to exit")
try:
r = readers()
if len(r) == 0:
print("No readers available")
return False
for reader in r:
if reader_name in str(reader):
print("Target:", reader)
break
else:
print("No matching reader. Available readers:", r)
return False
dev_key, dev_cert = gen_device_key(serial_hex)
connection = reader.createConnection()
connection.connect()
write_configs(connection)
transmit_apdu(connection, "0030000004{}".format(serial_hex))
transmit_apdu(connection, "0001000020{}".format(dev_key))
transmit_apdu(connection, "0002000000{:04X}{}".format(len(dev_cert)//2, dev_cert))
connection.disconnect()
print("Successfully initialized. Next.")
except:
print("Failed to initialize the canokey")
traceback.print_exc()
return False
return True
def do_cards(self, line):
"""Lists all cards in the system"""
if not self.check_root() or not self.check_pid():
return self.return_code(1)
print('\nLoading connected cards...\n')
# List all cards
try:
rlist = readers()
devices = []
available_readers = []
for reader in rlist:
dev = EBCardReader(reader)
try:
connection = reader.createConnection()
connection.connect()
dev.card_ok = True
available_readers.append(reader)
ebcard = EBCard(reader, connection)
ebcard.select_importcard()
dev.import_applet_ok = True
# Read the card key
key = ebcard.get_pubkey()
dev.card_id = self.format_pubkey(key)
dev.card_id_short = dev.card_id[:23]
except errors.InvalidApplet as e:
dev.import_applet_ok = False
except Exception as e:
dev.card_ok = False
devices.append(dev)
if len(devices) == 0:
print(self.t.red('No card reader connected'))
return self.return_code(1, True)
for idx, dev in enumerate(devices):
if not dev.card_ok:
print('%02d. No card present\n reader: %s\n' %
(idx + 1, dev.reader))
elif not dev.import_applet_ok:
print('%02d. Unknown card\n reader: %s\n' %
(idx + 1, dev.reader))
elif dev.card_id is None:
print('%02d. Uninitialized card\n reader: %s\n' %
(idx + 1, dev.reader))
else:
print('%02d. Import card %s\n reader: %s\n' %
(idx + 1, dev.card_id_short, dev.reader))
return self.return_code(0)
except Exception as e:
logger.error('Exception in setting import card: %s', e)
raise
def main():
""" main """
card_connection = readers()[0].createConnection()
card_connection.connect(mode=SCARD_SHARE_DIRECT,
disposition=SCARD_LEAVE_CARD)
feature_list = getFeatureRequest(card_connection)
#print getPinProperties(card_connection)
mct_reader_direct = hasFeature(feature_list, FEATURE_MCT_READER_DIRECT)
if mct_reader_direct is None:
raise Exception("The reader does not support MCT_READER_DIRECT")
secoder_info = [0x20, 0x70, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00]
res = card_connection.control(mct_reader_direct, secoder_info)
parse_info(res)
secoder_select = [
0x20, 0x71, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x80, 0x05, 0x31, 0x2E,
0x31, 0x2E, 0x30, 0x84, 0x02, 0x64, 0x65, 0x90, 0x01, 0x01, 0x85, 0x03,
ord('g'),
ord('k'),
ord('p'), 0x00, 0x00
]
res = card_connection.control(mct_reader_direct, secoder_select)
parse_select(res)
def testcase_readers_in_readergroup_nonexistent(self):
foundreaders = {}
for reader in readers(['dummy$group']):
foundreaders[reader] = 1
for reader in expectedReaders:
self.assert_(not reader in foundreaders)
self.assertEquals(0, len(foundreaders))
def main():
""" Ask the first reader/driver to return its Vendor Name if any """
card_connection = readers()[0].createConnection()
card_connection.connect(mode=SCARD_SHARE_DIRECT,
disposition=SCARD_LEAVE_CARD)
try:
# Vendor name
name = card_connection.getAttrib(SCARD_ATTR_VENDOR_NAME)
print(''.join([chr(char) for char in name]))
# Vendor-supplied interface device version (DWORD in the form
# 0xMMmmbbbb where MM = major version, mm = minor version, and
# bbbb = build number).
version = card_connection.getAttrib(SCARD_ATTR_VENDOR_IFD_VERSION)
print("Version: %d.%d.%d" % (version[3], version[2],
version[0]))
# Vendor-supplied interface device serial number.
# only for readers with a USB serial number
serial = card_connection.getAttrib(SCARD_ATTR_VENDOR_IFD_SERIAL_NO)
print(serial)
# Reader's display name
# only with pcsc-lite version >= 1.6.0
name = card_connection.getAttrib(SCARD_ATTR_DEVICE_FRIENDLY_NAME)
print(''.join([chr(char) for char in name]))
except smartcard.Exceptions.SmartcardException, message:
print("Exception:", message)
def selection(SELECT_APPLIC, SELECT_APPLET):
global connection
global reponse
try:
r = readers()
print(r)
connection = r[0].createConnection()
connection.connect()
reponse = 1
print(reponse)
try:
data, sw1, sw2 = connection.transmit(SELECT_APPLIC)
sw1 = "%x" % sw1
sw2 = "%x" % sw2
if ((sw1 == "90") and (sw2 == "0")):
data, sw1, sw2 = connection.transmit(SELECT_APPLET)
sw1 = "%x" % sw1
sw2 = "%x" % sw2
# verifier la reponse de selection de l'applet
if ((sw1 == "90") and (sw2 == "0")):
return 1
except:
return 0
except:
return 0
def run(self):
found= False
for reader in readers():
try:
connection = reader.createConnection()
connection.connect()
ATR = toHexString(connection.getATR())
APDU = [0xFF,0xCA,0x00,0x00,0x00]
data, sw1, sw2 = connection.transmit(APDU)
UID= toHexString(data)
except NoCardException:
print(reader, 'no card inserted')
except:
self.signals.error.emit((reader, 'error !!'))
else:
found= True
self.signals.result.emit(UID)
finally:
QThread.sleep(2)
if(found):
self.signals.finished.emit()
else:
self.signals.error.emit((reader,'aucune carte à proximité ou insérée !!!'))
def list_readers():
"""
:rtype : object
"""
r = readers()
return r
def main():
""" Ask the first reader/driver to return its Vendor Name if any """
card_connection = readers()[0].createConnection()
card_connection.connect(mode=SCARD_SHARE_DIRECT,
disposition=SCARD_LEAVE_CARD)
try:
# Vendor name
name = card_connection.getAttrib(SCARD_ATTR_VENDOR_NAME)
print ''.join([chr(char) for char in name])
# Vendor-supplied interface device version (DWORD in the form
# 0xMMmmbbbb where MM = major version, mm = minor version, and
# bbbb = build number).
version = card_connection.getAttrib(SCARD_ATTR_VENDOR_IFD_VERSION)
print "Version: %d.%d.%d" % (version[3], version[2], version[0])
# Vendor-supplied interface device serial number.
# only for readers with a USB serial number
serial = card_connection.getAttrib(SCARD_ATTR_VENDOR_IFD_SERIAL_NO)
print serial
# Reader's display name
# only with pcsc-lite version >= 1.6.0
name = card_connection.getAttrib(SCARD_ATTR_DEVICE_FRIENDLY_NAME)
print ''.join([chr(char) for char in name])
except smartcard.Exceptions.SmartcardException, message:
print "Exception:", message
def testcase_readers_in_readergroup_nonexistent(self):
foundreaders = {}
for reader in readers(['dummy$group']):
foundreaders[reader] = 1
for reader in expectedReaders:
self.assertTrue(not reader in foundreaders)
self.assertEqual(0, len(foundreaders))
def connexion():
r=readers()
connection=r[0].createConnection()
connection.connect()
#Partie LOG
# création de l'objet logger qui va nous servir à écrire dans les logs
# on met le niveau du logger à DEBUG, comme ça il écrit tout
logger.setLevel(logging.DEBUG)
#logger.setLevel(logging.RELEASE)
# création d'un formateur qui va ajouter le temps, le niveau
# de chaque message quand on écrira un message dans le log
formatter = logging.Formatter('%(asctime)s :: %(levelname)s :: %(message)s')
# création d'un handler qui va rediriger une écriture du log vers
# un fichier en mode 'append', avec 1 backup et une taille max de 1Mo
file_handler = RotatingFileHandler('activity.log', 'a', 1000000, 1)
# on lui met le niveau sur DEBUG, on lui dit qu'il doit utiliser le formateur
# créé précédement et on ajoute ce handler au logger
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
# création d'un second handler qui va rediriger chaque écriture de log
# sur la console
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.DEBUG)
logger.addHandler(stream_handler)
def find_reader(reader_name):
""" Looks for a specific card reader
Tries to find a card reader with specified name.
Args:
reader_name (str): string providing name of reader
Returns:
reader:
:obj:`PyScardReader`: PyScard wrapper object.
Chooses first reader with specified name if multiple
readers are found.
Raises:
RuntimeError: No reader found with specified name.
Any exceptions thrown by the reader wrapper are passed through.
"""
logger.debug('FIND READER name %s', reader_name)
r = readers()
for reader in r:
if reader_name in str(reader):
try:
return open_pyscard(r[r.index(reader)])
except:
raise RuntimeError('No card on reader')
raise RuntimeError('No reader found')
def setup(readernumber): """Open up a connection to the specified reader via PCSC """ r = readers() connection = r[readernumber].createConnection() connection.connect() return connection
def setUp(self): r = readers() self.max = maxim.MaximAPI(r[0]) self.max.Connect() self.UnknownInterfaces = [3, 7] self._ENABLE = 0x00 self._DISABLE = 0x01 self._READ = 0b10000000
def print_welcome():
print "Welcome to sandwich-manager beta release."
r = readers()
if len(r) < 1:
print "Warning: no reader available"
else:
print "Reader: " + str(r[0])
print "Type 'help' or 'h' for help."
def __init__(self, dbus_server):
self.dbus_server = dbus_server
r = readers()
self.ttag = r[r.index('ACS ACR 38U-CCID 00 00')].createConnection()
self.ttag.connect()
#set retry time to 1
RTO = get_set_retry_time_to_one()
data, sw1, sw2 = self.ttag.transmit( RTO )
def testcase_CardDictionary(self):
"""Create a dictionnary with Card keys"""
mydict = {}
for reader in readers():
card = Card(reader, expectedATRinReader[str(reader)])
mydict[card] = reader
for card in list(mydict.keys()):
self.assertTrue(str(card.reader) in expectedReaders)
def setUp(self): r = readers() self.max = maxim.MaximAPI(r[0]) self.max.Connect() self.UnknownInterfaces = [3, 7] self.timeout = 0b00000111 # 7 seconds self.EMV_SELECT_COMMAND = [0x00, 0xA4, 0x04, 0x00, 0x0E, 0x31, 0x50, 0x41, 0x59, 0x2E, 0x53, 0x59, 0x53, 0x2E, 0x44, 0x44, 0x46, 0x30, 0x31, 0x00]
def getAttribute(): r=readers() connection = r[0].createConnection() connection.connect() GETATTR = [0x80, 0x2B, 0x00, 0x00] data, sw1, sw2 = connection.transmit( GETATTR ) return (data, sw1, sw2)
def __init__(self):
reader = readers()
print(reader)
if not reader:
print("Reader NOT CONNECTED")
print("Connect reader please, and try again")
Read.exit_app()
else:
print("Приложите карту ")
app_init()
def get_status(self):
cards = 0
for reader in readers():
try:
connection = reader.createConnection()
connection.connect()
cards = cards + 1
except NoCardException: pass
self.cards = cards
return (self.cards > 0)
def testcase_ATRCardTypeWithoutMask(self):
"""Test smartcard.ATRCardType without mask."""
for reader in readers():
if [] != expectedATRinReader[str(reader)]:
ct = ATRCardType(expectedATRinReader[str(reader)])
connection = reader.createConnection()
connection.connect()
self.assertEquals(True, ct.matches(connection.getATR()))
self.assertEquals(True, ct.matches(connection.getATR(), reader))
connection.disconnect()
def testcase_AnyCardType(self):
"""Test smartcard.AnyCardType."""
ct = AnyCardType()
for reader in readers():
if [] != expectedATRinReader[str(reader)]:
connection = reader.createConnection()
connection.connect()
self.assertEquals(True, ct.matches(connection.getATR()))
self.assertEquals(True, ct.matches(connection.getATR(), reader))
connection.disconnect()
def check_reader_availability():
global connection
r = readers()
if len(r) < 1:
print "Warning: no reader available"
else:
#from smartcard.CardConnectionObserver import ConsoleCardConnectionObserver
#observer = ConsoleCardConnectionObserver()
connection = r[0].createConnection()
#connection.addObserver(observer)
connection.connect()
def connectCard(reader_name=""):
r = readers()
rege = re.compile(r".*" + reader_name + r".*")
cons = [rr for rr in r if rege.match(rr.__str__())]
if len(cons) != 1:
print "Non uniq connections:", cons
return
c = GAFConnection(cons[0].createConnection())
observer = ConsoleObserver()
c.addObserver(observer)
dispTime(c, False) # default: time not printed
c.connect()
return c
def list_devices():
devices = []
for reader in readers():
if CARD_PATTERN.match(reader.name):
conn = reader.createConnection()
try:
conn.connect()
data, sw1, sw2 = conn.transmit(hex2cmd('00a4040007%s' % AID))
if (sw1, sw2) == (0x90, 0x00):
devices.append(CCIDDevice(conn))
except:
pass
return devices
def testcase_CardConnectionT1inTransmit(self):
"""Test that T1 in transmit for a T0 card fails."""
SELECT = [0xA0, 0xA4, 0x00, 0x00, 0x02]
DF_TELECOM = [0x7F, 0x10]
for reader in readers():
cc = reader.createConnection()
if [] != expectedATRinReader[str(reader)]:
cc.connect()
self.assertRaises(CardConnectionException, cc.transmit, SELECT + DF_TELECOM, CardConnection.T1_protocol)
else:
self.assertRaises(NoCardException, cc.connect)
cc.disconnect()
def testcase_CardConnectionT1inConnect(self):
"""Test that connecting with T1 on a T0 card fails."""
for reader in readers():
cc = reader.createConnection()
# on Mac OS X Tiger, trying to connect with T=1 protocol does not except
if not 'pcsclite-tiger' == resourceManagerSubType:
if [] != expectedATRinReader[str(reader)]:
# should fail since the test card does not support T1
self.assertRaises(CardConnectionException, cc.connect, CardConnection.T1_protocol)
else:
self.assertRaises(NoCardException, cc.connect)
cc.disconnect()
def connectReaderFun(envi,readerIndex = None):
"establish a link between the shell and a card"
if "connection" in envi and envi["connection"] != None:
print "there is already a connection to reader"
return False
r = readers()
if readerIndex == None:
indice = 0
if len(r) > 1:
Executer.printOnShell("Warning : the connection will open on the first available reader but there are others")
else:
indice = readerIndex
if len(r) == 0:
Executer.printOnShell("there is no reader available")
return False
try:
reader = r[indice]
except IndexError:
Executer.printOnShell("invalid indice")
return False
try:
envi["connection"] = reader.createConnection() #create a connection on the reader
except Exception as e:
Executer.printOnShell(str(e))
return False
try:
envi["connection"].connect()#create a connection on the card
except Exception as e:
del envi["connection"]
Executer.printOnShell(str(e))
return False
card = None
for c in cardobserver.cardList:
if c.atr == envi["connection"].getATR() and c.reader == reader:
card = c
card.connection = envi["connection"]
card.connection.card = card
if card == None:
Executer.printOnShell("WARNING : the connected card is not in the card list")
envi["connectedReader"] = reader
return True
def reader_exists(reader_prefix):
"""Returns boolean based on the existence of our reader
The just happens to be the first place the app falls over if pcsc isn't available,
beware the anecdotal attempt at cross platform exception handling."""
try:
for r in readers():
if reader_prefix in str(r) and str(r).index(reader_prefix) == 0:
return True
return False
except TypeError: # Occurs when SCardSvr is not running on Windows
raise exceptions.PyScardFailure
except PCSCExceptions.ListReadersException: # When pcscd is not running
raise exceptions.PyScardFailure
def testcase_CardConnectionT0T1inTransmitMustFail(self):
"""Test with bad parameter in transmit the response to SELECT
DF_TELECOM."""
SELECT = [0xA0, 0xA4, 0x00, 0x00, 0x02]
DF_TELECOM = [0x7F, 0x10]
for reader in readers():
cc = reader.createConnection()
if [] != expectedATRinReader[str(reader)]:
cc.connect(CardConnection.T0_protocol | CardConnection.T1_protocol)
self.assertRaises(CardConnectionException, cc.transmit, SELECT + DF_TELECOM, CardConnection.T0_protocol | CardConnection.T1_protocol)
else:
self.assertRaises(NoCardException, cc.connect)
cc.disconnect()
def open_key(name=None):
"""
Opens a smartcard reader matching the given name and connects to the
ykneo-bitcoin applet through it.
Returns a reference to the YkneoBitcoin object.
"""
r = re.compile(name) if name else READER_PATTERN
for reader in readers():
if r.match(reader.name):
conn = reader.createConnection()
conn.connect()
return YkneoBitcoin(conn)
raise Exception('No smartcard reader found matching: %s' % r.pattern)
