class testthread(Thread):
def __init__(self, obsindex):
Thread.__init__(self)
self.readermonitor = ReaderMonitor()
self.obsindex = obsindex
self.observer = None
def run(self):
# create and register observer
self.observer = printobserver(self.obsindex)
self.readermonitor.addObserver(self.observer)
sleep(20)
self.readermonitor.deleteObserver(self.observer)
class testthread(Thread):
def __init__(self, obsindex):
Thread.__init__(self)
self.readermonitor = ReaderMonitor()
self.obsindex = obsindex
self.observer = None
def run(self):
# create and register observer
self.observer = printobserver(self.obsindex)
self.readermonitor.addObserver(self.observer)
sleep(20)
self.readermonitor.deleteObserver(self.observer)
class testthread(threading.Thread):
def __init__(self, obsindex, testcase):
threading.Thread.__init__(self)
self.obsindex = obsindex
self.testcase = testcase
self.readermonitor = ReaderMonitor()
self.observer = None
def run(self):
# create and register observer
self.observer = printobserver(self.obsindex, self.testcase)
self.readermonitor.addObserver(self.observer)
time.sleep(1)
self.readermonitor.deleteObserver(self.observer)
class testthread(threading.Thread):
def __init__(self, obsindex, testcase):
threading.Thread.__init__(self)
self.obsindex = obsindex
self.testcase = testcase
self.readermonitor = ReaderMonitor()
self.observer = None
def run(self):
# create and register observer
self.observer = printobserver(self.obsindex, self.testcase)
self.readermonitor.addObserver(self.observer)
time.sleep(1)
self.readermonitor.deleteObserver(self.observer)
def entry_point():
print u"Smartcard monitor applet by Lauri Võsandi <*****@*****.**>"
if not os.path.exists(PCSCD):
print "Unable to find", PCSCD, "are you sure it is installed"
applet = SmartcardApplet()
reader_monitor = ReaderMonitor()
reader_monitor.addObserver(applet.reader_observer)
card_monitor = CardMonitor()
card_monitor.addObserver(applet.card_observer)
try:
gtk.main()
except KeyboardInterrupt:
pass
card_monitor.deleteObserver(applet.card_observer)
reader_monitor.deleteObserver(applet.reader_observer)
class ThaiIDCard:
status = None
smart_card_reader_monitor = None
smart_card_reader_observer = None
smart_card_monitor = None
smart_card_observer = None
#
# Thailand National ID Card Address
#
# Select & Thai MOI
SELECT = [0x00, 0xA4, 0x04, 0x00, 0x08]
AID_MOI = [0xA0, 0x00, 0x00, 0x00, 0x54, 0x48, 0x00, 0x01]
# APDU Type
APDU_THAILAND_IDCARD_TYPE_01 = [0x00, 0xc0, 0x00, 0x01]
APDU_THAILAND_IDCARD_TYPE_02 = [0x00, 0xc0, 0x00, 0x00]
# TH Citizen ID
CMD_CITIZEN = [0x80, 0xb0, 0x00, 0x04, 0x02, 0x00, 0x0d]
# TH Full Name
CMD_THFULLNAME = [0x80, 0xb0, 0x00, 0x11, 0x02, 0x00, 0x64]
# EN Full Name
CMD_ENFULLNAME = [0x80, 0xb0, 0x00, 0x75, 0x02, 0x00, 0x64]
# Date of birth
CMD_BIRTH = [0x80, 0xb0, 0x00, 0xD9, 0x02, 0x00, 0x08]
# Gender
CMD_GENDER = [0x80, 0xb0, 0x00, 0xE1, 0x02, 0x00, 0x01]
# Card Issuer
CMD_ISSUER = [0x80, 0xb0, 0x00, 0xF6, 0x02, 0x00, 0x64]
# Issue Date
CMD_ISSUE = [0x80, 0xb0, 0x01, 0x67, 0x02, 0x00, 0x08]
# Expire Date
CMD_EXPIRE = [0x80, 0xb0, 0x01, 0x6F, 0x02, 0x00, 0x08]
# Address
CMD_ADDRESS = [0x80, 0xb0, 0x15, 0x79, 0x02, 0x00, 0x64]
# Photo_Part1/20
CMD_PHOTO01 = [0x80, 0xb0, 0x01, 0x7B, 0x02, 0x00, 0xFF]
# Photo_Part2/20
CMD_PHOTO02 = [0x80, 0xb0, 0x02, 0x7A, 0x02, 0x00, 0xFF]
# Photo_Part3/20
CMD_PHOTO03 = [0x80, 0xb0, 0x03, 0x79, 0x02, 0x00, 0xFF]
# Photo_Part4/20
CMD_PHOTO04 = [0x80, 0xb0, 0x04, 0x78, 0x02, 0x00, 0xFF]
# Photo_Part5/20
CMD_PHOTO05 = [0x80, 0xb0, 0x05, 0x77, 0x02, 0x00, 0xFF]
# Photo_Part6/20
CMD_PHOTO06 = [0x80, 0xb0, 0x06, 0x76, 0x02, 0x00, 0xFF]
# Photo_Part7/20
CMD_PHOTO07 = [0x80, 0xb0, 0x07, 0x75, 0x02, 0x00, 0xFF]
# Photo_Part8/20
CMD_PHOTO08 = [0x80, 0xb0, 0x08, 0x74, 0x02, 0x00, 0xFF]
# Photo_Part9/20
CMD_PHOTO09 = [0x80, 0xb0, 0x09, 0x73, 0x02, 0x00, 0xFF]
# Photo_Part10/20
CMD_PHOTO10 = [0x80, 0xb0, 0x0A, 0x72, 0x02, 0x00, 0xFF]
# Photo_Part11/20
CMD_PHOTO11 = [0x80, 0xb0, 0x0B, 0x71, 0x02, 0x00, 0xFF]
# Photo_Part12/20
CMD_PHOTO12 = [0x80, 0xb0, 0x0C, 0x70, 0x02, 0x00, 0xFF]
# Photo_Part13/20
CMD_PHOTO13 = [0x80, 0xb0, 0x0D, 0x6F, 0x02, 0x00, 0xFF]
# Photo_Part14/20
CMD_PHOTO14 = [0x80, 0xb0, 0x0E, 0x6E, 0x02, 0x00, 0xFF]
# Photo_Part15/20
CMD_PHOTO15 = [0x80, 0xb0, 0x0F, 0x6D, 0x02, 0x00, 0xFF]
# Photo_Part16/20
CMD_PHOTO16 = [0x80, 0xb0, 0x10, 0x6C, 0x02, 0x00, 0xFF]
# Photo_Part17/20
CMD_PHOTO17 = [0x80, 0xb0, 0x11, 0x6B, 0x02, 0x00, 0xFF]
# Photo_Part18/20
CMD_PHOTO18 = [0x80, 0xb0, 0x12, 0x6A, 0x02, 0x00, 0xFF]
# Photo_Part19/20
CMD_PHOTO19 = [0x80, 0xb0, 0x13, 0x69, 0x02, 0x00, 0xFF]
# Photo_Part20/20
CMD_PHOTO20 = [0x80, 0xb0, 0x14, 0x68, 0x02, 0x00, 0xFF]
# Expire time of data -- seconds
_read_expire_time = 5 #
# Thai Citizen ID
_citizen = None
_citizen_t = 0
# Thai Full Name
_full_name_th = None
_full_name_th_t = 0
# English Full Name
_full_name_en = None
_full_name_en_th = 0
# Date of birth
_birth = None
_birth_t = 0
# Gender
_gender = None
_gender_t = 0
# Card Issuer
_issuer = None
_issuer_t = 0
# Issue Date
_issue = None
_issue_t = 0
# Expire Date
_expire = None
_expire_t = 0
# Address
_address = None
_address_t = 0
# Photo
_photo = None
_photo_t = 0
def __init__(self):
self.readerList = []
if (len(self.getReaders()) > 0):
self.connect(0)
def readerMonitor(self, reader_added_cb, reader_removed_cb):
self.reader_added_cb = reader_added_cb
self.reader_removed_cb = reader_removed_cb
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: Add SmartCard reader observer")
self.smart_card_reader_monitor = ReaderMonitor()
self.smart_card_reader_observer = SmartCardReaderObserver(
reader_added_callback=self.reader_removed_cb,
reader_removed_callback=self.reader_removed_cb)
self.smart_card_reader_monitor.addObserver(
self.smart_card_reader_observer)
def readerUnmonitor(self):
try:
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: Remove SmartCard reader observer")
self.smart_card_reader_monitor.deleteObserver(
self.smart_card_reader_observer)
except:
pass
def cardMonitor(self, smart_card_insert_cb, smart_card_remove_cb):
self.smart_card_insert_cb = smart_card_insert_cb
self.smart_card_remove_cb = smart_card_remove_cb
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: Add SmartCard observer")
self.smart_card_monitor = CardMonitor()
self.smart_card_observer = SmartCardObserver(
card_insert_callback=self.smart_card_insert_cb,
card_remove_callback=self.smart_card_remove_cb)
self.smart_card_monitor.addObserver(self.smart_card_observer)
def cardUnmonitor(self):
try:
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: Remove SmartCard observer")
self.smart_card_monitor.deleteObserver(self.smart_card_observer)
except:
pass
# Get SmartCard reader list
def getReaders(self):
# Get all the available readers
self.readerList = smartcard.System.readers()
#if len(self.readerList) > 0:
# print ("Found SmartCard readers:")
# for readerIndex,readerItem in enumerate(self.readerList):
# print(" - %d, '%s'"%(readerIndex, readerItem))
#else:
# print ("No SmartCard reader")
self.readerIndex = 0
return self.readerList
# Connect to SmartCard reader
def connect(self, index=0):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: Connecting to SmartCard")
if len(self.readerList) == 0:
if len(self.getReaders()) == 0:
return None
if index < 0 or index >= len(self.readerList):
return None
# Select reader
self.readerIndex = index
self.reader = self.readerList[self.readerIndex]
if THAI_ID_CARD_DEBUG:
print("Using SmartCard reader:", self.reader)
try:
self.connection = self.reader.createConnection()
self.connection.connect()
atr = self.connection.getATR()
if THAI_ID_CARD_DEBUG:
print(" - Card type: " + toHexString(atr))
if (atr[0] == 0x3B & atr[1] == 0x67):
# Corruption Card
self._apdu = self.APDU_THAILAND_IDCARD_TYPE_01
else:
self._apdu = self.APDU_THAILAND_IDCARD_TYPE_02
if THAI_ID_CARD_DEBUG:
print(" - Connect to SmartCard success")
self.status = True
response, sw1, sw2 = self.selectApplet()
# [], 61, 0A
time.sleep(0.1)
if sw1 == 0x61 and sw2 == 0x0A:
return True
self.status = None
return None
except:
if THAI_ID_CARD_DEBUG:
print(" - Failed to connect to SmartCard")
self.status = None
return None
def disconnect(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: Closing connection from SmartCard")
try:
self.connection.disconnect()
except:
pass
# Select MOI Applet
def selectApplet(self):
if self.status == None:
if self.connect(self.readerIndex) == None:
return [None, None, None]
response, sw1, sw2 = self.connection.transmit(self.SELECT +
self.AID_MOI)
#print ("Select Applet: %02X %02X" % (sw1, sw2))
return [response, sw1, sw2]
# Read data from SmartCard
def read(self, cmd, apdu=None):
if self.status == None:
if self.connect(self.readerIndex) == None:
return [None, None, None]
if apdu == None:
apdu = self._apdu
try:
response, sw1, sw2 = self.connection.transmit(cmd)
response, sw1, sw2 = self.connection.transmit(apdu + [cmd[-1]])
return [response, sw1, sw2]
except Exception as w:
return [None, None, None]
# Read photo from SmartCard
def readPhoto(self):
if self.status == None:
if self.connect(self.readerIndex) == None:
return None
photo = self.read(self.CMD_PHOTO01)[0]
photo += self.read(self.CMD_PHOTO02)[0]
photo += self.read(self.CMD_PHOTO03)[0]
photo += self.read(self.CMD_PHOTO04)[0]
photo += self.read(self.CMD_PHOTO05)[0]
photo += self.read(self.CMD_PHOTO06)[0]
photo += self.read(self.CMD_PHOTO07)[0]
photo += self.read(self.CMD_PHOTO08)[0]
photo += self.read(self.CMD_PHOTO09)[0]
photo += self.read(self.CMD_PHOTO10)[0]
photo += self.read(self.CMD_PHOTO11)[0]
photo += self.read(self.CMD_PHOTO12)[0]
photo += self.read(self.CMD_PHOTO13)[0]
photo += self.read(self.CMD_PHOTO14)[0]
photo += self.read(self.CMD_PHOTO15)[0]
photo += self.read(self.CMD_PHOTO16)[0]
photo += self.read(self.CMD_PHOTO17)[0]
photo += self.read(self.CMD_PHOTO18)[0]
photo += self.read(self.CMD_PHOTO19)[0]
photo += self.read(self.CMD_PHOTO20)[0]
response = HexListToBinString(photo)
return response
def thai2unicode(self, data):
result = ''
result = bytes(data).decode('tis-620')
return result.strip()
# Citizen ID
@property
def citizen(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: citizen=", end=' ')
if (self._citizen != None):
if ((time.time() - self._citizen_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._citizen)
return self._citizen
response, sw1, sw2 = self.read(self.CMD_CITIZEN)
if (response != None):
self._citizen = self.thai2unicode(response)
self._citizen_t = time.time()
else:
self._citizen = None
if THAI_ID_CARD_DEBUG:
print(self._citizen)
return self._citizen
# Thai Name
@property
def full_name_th(self):
#if THAI_ID_CARD_DEBUG:
# print("ThaiIDCard: full_name_th")
if (self._full_name_th != None):
if ((time.time() - self._full_name_th_t) < self._read_expire_time):
return self._full_name_th
response, sw1, sw2 = self.read(self.CMD_THFULLNAME)
if (response != None):
self._full_name_th = self.thai2unicode(response)
self._full_name_th_t = time.time()
self._first_name_th, self._last_name_th = self._full_name_th.split(
'##')
self._prefix_th, self._first_name_th = self._first_name_th.split(
'#')
else:
self._full_name_th = None
return self._full_name_th
@property
def prefix_th(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: prefix_th=", end=' ')
if (self._full_name_th != None):
if ((time.time() - self._full_name_th_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._prefix_th)
return self._prefix_th
if (self.full_name_th != None):
if THAI_ID_CARD_DEBUG:
print(self._prefix_th)
return self._prefix_th
return None
@property
def first_name_th(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: first_name_th=", end=' ')
if (self._full_name_th != None):
if ((time.time() - self._full_name_th_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._first_name_th)
return self._first_name_th
if (self.full_name_th != None):
if THAI_ID_CARD_DEBUG:
print(self._first_name_th)
return self._first_name_th
return None
@property
def last_name_th(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: last_name_th=", end=' ')
if (self._full_name_th != None):
if ((time.time() - self._full_name_th_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._last_name_th)
return self._last_name_th
if (self.full_name_th != None):
if THAI_ID_CARD_DEBUG:
print(self._last_name_th)
return self._last_name_th
return None
# English Name
@property
def full_name_en(self):
#if THAI_ID_CARD_DEBUG:
# print("ThaiIDCard: full_name_en")
if (self._full_name_en != None):
if ((time.time() - self._full_name_en_t) < self._read_expire_time):
return self._full_name_en
response, sw1, sw2 = self.read(self.CMD_ENFULLNAME)
if (response != None):
self._full_name_en = self.thai2unicode(response)
self._full_name_en_t = time.time()
self._first_name_en, self._last_name_en = self._full_name_en.split(
'##')
self._prefix_en, self._first_name_en = self._first_name_en.split(
'#')
else:
self._full_name_en = None
return self._full_name_en
@property
def prefix_en(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: prefix_en=", end=' ')
if (self._full_name_en != None):
if ((time.time() - self._full_name_en_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._prefix_en)
return self._prefix_en
if (self.full_name_en != None):
if THAI_ID_CARD_DEBUG:
print(self._prefix_en)
return self._prefix_en
return None
@property
def first_name_en(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: first_name_en=", end=' ')
if (self._full_name_en != None):
if ((time.time() - self._full_name_en_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._first_name_en)
return self._first_name_en
if (self.full_name_en != None):
if THAI_ID_CARD_DEBUG:
print(self._first_name_en)
return self._first_name_en
return None
@property
def last_name_en(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: last_name_en=", end=' ')
if (self._full_name_en != None):
if ((time.time() - self._full_name_en_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._last_name_en)
return self._last_name_en
if (self.full_name_en != None):
if THAI_ID_CARD_DEBUG:
print(self._last_name_en)
return self._last_name_en
return None
# Date of birth
@property
def birth(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: birth=", end=' ')
if (self._birth != None):
if ((time.time() - self._birth_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._birth)
return self._birth
response, sw1, sw2 = self.read(self.CMD_BIRTH)
if (response != None):
self._birth = self.thai2unicode(response)
self._birth_t = time.time()
self._birth = self._birth[0:4] + '-' + self._birth[
4:6] + '-' + self._birth[6:8]
else:
self._birth = None
if THAI_ID_CARD_DEBUG:
print(self._birth)
return self._birth
# Gender
@property
def gender(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: gender=", end=' ')
if (self._gender != None):
if ((time.time() - self._gender_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._gender)
return self._gender
response, sw1, sw2 = self.read(self.CMD_GENDER)
if (response != None):
self._gender = self.thai2unicode(response)
self._gender_t = time.time()
else:
self._gender = None
if THAI_ID_CARD_DEBUG:
print(self._gender)
return self._gender
# Issue date
@property
def issue(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: issue=", end=' ')
if (self._issue != None):
if ((time.time() - self._issue_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._issue)
return self._issue
response, sw1, sw2 = self.read(self.CMD_ISSUE)
if (response != None):
self._issue = self.thai2unicode(response)
self._issue_t = time.time()
self._issue = self._issue[0:4] + '-' + self._issue[
4:6] + '-' + self._issue[6:8]
else:
self._issue = None
if THAI_ID_CARD_DEBUG:
print(self._issue)
return self._issue
# Expire date
@property
def expire(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: expire=", end=' ')
if (self._expire != None):
if ((time.time() - self._expire_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._expire)
return self._expire
response, sw1, sw2 = self.read(self.CMD_EXPIRE)
if (response != None):
self._expire = self.thai2unicode(response)
self._expire_t = time.time()
self._expire = self._expire[0:4] + '-' + self._expire[
4:6] + '-' + self._expire[6:8]
else:
self._expire = None
if THAI_ID_CARD_DEBUG:
print(self._expire)
return self._expire
# Address
@property
def address(self):
#if THAI_ID_CARD_DEBUG:
# print("ThaiIDCard: address")
if (self._address != None):
if ((time.time() - self._address_t) < self._read_expire_time):
return self._address
response, sw1, sw2 = self.read(self.CMD_ADDRESS)
if (response != None):
self._address = self.thai2unicode(response)
self._address_t = time.time()
#self._address = self._address[0:4]+'-'+self._address[4:6]+'-'+self._address[6:8]
self._address = re.sub(r'#', ' ', self._address)
self._address = re.sub(r' ', ' ', self._address)
self._address = re.sub(r' ', ' ', self._address)
x = self._address.rsplit()
self._city = x[len(x) - 2]
self._province = x[len(x) - 1]
else:
self._address = None
return self._address
@property
def city(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: city=", end=' ')
if (self._address != None):
if ((time.time() - self._address_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._city)
return self._city
if (self.address != None):
if THAI_ID_CARD_DEBUG:
print(self._city)
return self._city
return None
@property
def province(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: province=", end=' ')
if (self._address != None):
if ((time.time() - self._address_t) < self._read_expire_time):
if THAI_ID_CARD_DEBUG:
print(self._province)
return self._province
if (self.address != None):
if THAI_ID_CARD_DEBUG:
print(self._province)
return self._province
return None
# Photo
@property
def photo(self):
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: photo")
if (self._photo != None):
if ((time.time() - self._photo_t) < self._read_expire_time):
return self._photo
self._photo = self.readPhoto()
return self._photo
# Example code, read all attributes
def example(self):
if (len(self.readerList) < 0):
return None
# Reader list
print(self.getReaders())
print(f'Citizen ID:', self.citizen)
print(f'Thai Full Name: ' + self.full_name_th)
print(f'Thai Prefix: ' + self.prefix_th)
print(f'Thai First Name: ' + self.first_name_th)
print(f'Thai Last Name: ' + self.last_name_th)
print(f'English Full Name: ' + self.full_name_en)
print(f'English Prefix: ' + self.prefix_en)
print(f'English First Name: ' + self.first_name_en)
print(f'English Last Name: ' + self.last_name_en)
print(f'Date of birth: ' + self.birth)
print(f'Gender: ' + self.gender)
print(f'Issue date: ' + self.issue)
print(f'Expire date: ' + self.expire)
print(f'Address: ' + self.address)
print(f'City: ' + self.city)
print(f'Province: ' + self.province)
#print(f'Photo file size: ' + self.photo)
return
class CardAndReaderTreePanel(wx.Panel):
"""Panel containing the smart card and reader tree controls."""
class _CardObserver(CardObserver):
"""Inner CardObserver. Gets notified of card insertion
removal by the CardMonitor."""
def __init__(self, cardtreectrl):
self.cardtreectrl = cardtreectrl
def update(self, observable, handlers):
"""CardObserver callback that is notified
when cards are added or removed."""
addedcards, removedcards = handlers
self.cardtreectrl.OnRemoveCards(removedcards)
self.cardtreectrl.OnAddCards(addedcards)
class _ReaderObserver(ReaderObserver):
"""Inner ReaderObserver. Gets notified of reader insertion/removal
by the ReaderMonitor."""
def __init__(self, readertreectrl):
self.readertreectrl = readertreectrl
def update(self, observable, handlers):
"""ReaderObserver callback that is notified when
readers are added or removed."""
addedcards, removedcards = handlers
self.readertreectrl.OnRemoveReaders(removedreaders)
self.readertreectrl.OnAddReaders(addedreaders)
def __init__(self, parent, appstyle, clientpanel):
"""Constructor. Create a smartcard and reader tree control on the
left-hand side of the application main frame.
@param parent: the tree panel parent
@param appstyle: a combination of the following styles (bitwise or |)
- TR_SMARTCARD: display a smartcard tree panel
- TR_READER: display a reader tree panel
- default is TR_DEFAULT = TR_SMARTCARD
@param clientpanel: the client panel to notify of smartcard and reader events
"""
wx.Panel.__init__(self, parent, -1, style=wx.WANTS_CHARS)
sizer = wx.BoxSizer(wx.VERTICAL)
# create the smartcard tree
if appstyle & smartcard.wx.SimpleSCardApp.TR_SMARTCARD:
self.cardtreectrl = CardTreeCtrl(self, clientpanel=clientpanel)
# create the smartcard insertion observer
self.cardtreecardobserver = self._CardObserver(self.cardtreectrl)
# register as a CardObserver; we will ge
# notified of added/removed cards
self.cardmonitor = CardMonitor()
self.cardmonitor.addObserver(self.cardtreecardobserver)
sizer.Add(
self.cardtreectrl, flag=wx.EXPAND | wx.ALL, proportion=1)
# create the reader tree
if appstyle & smartcard.wx.SimpleSCardApp.TR_READER:
self.readertreectrl = ReaderTreeCtrl(
self, clientpanel=clientpanel)
# create the reader insertion observer
self.readertreereaderobserver = self._ReaderObserver(
self.readertreectrl)
# register as a ReaderObserver; we will ge
# notified of added/removed readers
self.readermonitor = ReaderMonitor()
self.readermonitor.addObserver(self.readertreereaderobserver)
# create the smartcard insertion observer
self.readertreecardobserver = self._CardObserver(
self.readertreectrl)
# register as a CardObserver; we will get
# notified of added/removed cards
self.cardmonitor = CardMonitor()
self.cardmonitor.addObserver(self.readertreecardobserver)
sizer.Add(
self.readertreectrl, flag=wx.EXPAND | wx.ALL, proportion=1)
self.SetSizer(sizer)
self.SetAutoLayout(True)
def OnDestroy(self, event):
"""Called on panel destruction."""
# deregister observers
if hasattr(self, 'cardmonitor'):
self.cardmonitor.deleteObserver(self.cardtreecardobserver)
if hasattr(self, 'readermonitor'):
self.readermonitor.deleteObserver(self.readertreereaderobserver)
self.cardmonitor.deleteObserver(self.readertreecardobserver)
event.Skip()
"""A simple reader observer that is notified
when readers are added/removed from the system and
prints the list of readers
"""
def update(self, observable, (addedreaders, removedreaders)):
print "Added readers", addedreaders
print "Removed readers", removedreaders
try:
print "Add or remove a smartcard reader to the system."
print "This program will exit in 10 seconds"
print ""
readermonitor = ReaderMonitor()
readerobserver = printobserver()
readermonitor.addObserver(readerobserver)
sleep(10)
# don't forget to remove observer, or the
# monitor will poll forever...
readermonitor.deleteObserver(readerobserver)
import sys
if 'win32' == sys.platform:
print 'press Enter to continue'
sys.stdin.read(1)
except:
print exc_info()[0], ':', exc_info()[1]
class Monitor(QRunnable):
"""
Monitoriza los dispositivos pkcs11 conectados a la computadora.
Lanza 2 eventos:
* Dispositivo conectado (signals.USB_CONNECTED)
* Dispositivo desconectado (signals.USB_DISCONNECTED)
Un ejemplo de uso puede ser:
.. code:: python
from client_fva.monitor import Monitor
from client_fva import signals
class OSDummyClient:
def __init__(self):
self.client = Monitor()
self.client.start()
self.client.signal.connect(self.token_information_event)
def token_information_event(self, sender, **kw):
obj = kw['obj']
if obj._type == signals.USB_CONNECTED:
print("Conectando ", obj._type)
elif obj._type == signals.USB_DISCONNECTED:
print("Desconectando ", obj._type)
print(obj.data)
return obj
No se requiere devolver nada, pero es bueno para seguir con el formato, de otras señales
"""
connected_device = {}
lib = None
def __init__(self, *args, **kwargs):
self.settings = kwargs.get('settings', UserSettings.getInstance())
kwargs['settings'] = self.settings
kwargs['cached'] = False
self.session_storage = SessionStorage.getInstance()
self.pkcs11client = PKCS11Client(*args, **kwargs)
self.session_storage.pkcs11_client = self.pkcs11client
QRunnable.__init__(self)
self.setAutoDelete(True)
self.cardmonitor = None
self.cardobserver = None
self.mutex = QMutex()
self.run_mutex = QMutex()
@pyqtSlot()
def run(self):
logger.info("Iniciando monitor")
self.readermonitor = ReaderMonitor()
self.cardmonitor = CardMonitor()
self.cardobserver = DfvaCardObserver(eventmanager=self)
self.readerobserver = DFVAReaderObserver(eventmanager=self)
self.cardmonitor.addObserver(self.cardobserver)
self.readermonitor.addObserver(self.readerobserver)
self.run_mutex.lock()
self.run_mutex.lock()
def detect_device(self, notify_exception=False):
"""
Identifica cambios en las tarjetas conectadas, es utilizado
normalmente de forma automática con el monitor, pero se puede llamar
usando detect_device( notify_exception=True) para que envíe notificaciones
de los errores presentados al detectar las tarjetas.
"""
logger.debug("Monitor: detect device")
self.mutex.lock()
tmp_device = []
added_device = {}
try:
for tokeninfo in self.pkcs11client.get_tokens_information():
slot = tokeninfo['slot']
serial = tokeninfo['serial']
if serial in self.connected_device:
tmp_device.append(serial)
else:
tmp_device.append(serial)
person = self.pkcs11client.get_identification(slot=slot)
data = {'slot': slot, 'person': person, 'serial': serial}
added_device[serial] = data
self.send_add_signal(data)
except SlotNotFound as notoken:
pass
except Exception as noToken:
if notify_exception:
signals.send(
'notify', {
'message':
"Un dispositivo ha sido encontrado, pero ninguna tarjeta pudo ser "
"leída, por favor verifique que la tarjeta esté correctamente "
"insertada"
})
logger.error("%r" % (noToken, ))
# except Exception as e:
# if notify_exception:
# signals.result.emit('notify', {
# 'message': "Ha ocurrido un error inesperado leyendo alguno de los dispositivos"
# })
self.connected_device.update(added_device)
for connected_serial in tuple(self.connected_device.keys()):
if connected_serial not in tmp_device:
self.send_removed_signal(
self.connected_device[connected_serial])
self.connected_device.pop(connected_serial)
self.mutex.unlock()
def send_add_signal(self, data):
sobj = signals.SignalObject(signals.USB_CONNECTED, data)
logger.info("Tarjeta conectada %s" % (data['person'], ))
signals.send('monitor_usb', sobj)
def send_removed_signal(self, data):
sobj = signals.SignalObject(signals.USB_DISCONNECTED, data)
logger.info("Tarjeta desconectada %s" % (data['person'], ))
signals.send('monitor_usb', sobj)
def close(self):
logger.info("Terminando monitor")
if self.cardmonitor and self.cardobserver:
self.cardmonitor.deleteObserver(self.cardobserver)
if self.cardmonitor and self.readermonitor:
self.readermonitor.deleteObserver(self.readerobserver)
if self.cardmonitor:
self.cardmonitor.rmthread.stop()
self.run_mutex.unlock()
del self.cardobserver
del self.readerobserver
del self.cardmonitor
