pyscard mutes/hides user created exceptions in `on_insert()` hook. about pyscard HOT 5 CLOSED

import time
import threading
import cryptography.x509
import cryptography.hazmat.primitives
import smartcard
import smartcard.CardMonitoring
from PyKCS11 import *
from PyKCS11.LowLevel import CKA_ID

yubikey_pin = "123456"
pkcs11_lib = '/usr/lib/opensc-pkcs11.so'
test = {
	"alive": True
}

class CardInsertedHook(smartcard.CardMonitoring.CardObserver):
	def __init__(self, on_insert=None, on_eject=None):
		self.on_insert = on_insert
		self.on_eject = on_eject

	def update(self, observable, actions):
		(addedcards, removedcards) = actions
		if addedcards and self.on_insert:
			self.on_insert(addedcards)
		if removedcards and self.on_eject:
			self.on_eject(removedcards)

class CardMonitor(threading.Thread):
	def __init__(self, on_insert=None, on_eject=None):
		# Create an instance of the CardMonitor
		cardmonitor = smartcard.CardMonitoring.CardMonitor()

		# Add your observer to the CardMonitor
		cardobserver = CardInsertedHook(on_insert, on_eject)
		cardmonitor.addObserver(cardobserver)

		threading.Thread.__init__(self)
		self.start()

	def run(self):
		# We stay alive as long as our overlord says to stay alive
		while test['alive']:
			time.sleep(0.25)

class YubikeySession:
	def __init__(self):
		self.session = None
		self.share_holders = {}

		# Initialize the library
		self.pkcs11 = PyKCS11Lib()
		self.pkcs11.load(pkcs11_lib)

	def sign(self, data :bytes):
		print(f"Signing {data} with {self.session}")

	def decrypt(self, data :bytes):
		print(f"Decrypt {data} with {self.session}")

	def on_insert(self, cards):
		for device in self.pkcs11.getSlotList():
			try:
				_tmp_session = self.pkcs11.openSession(device, CKF_SERIAL_SESSION | CKF_RW_SESSION)
			except PyKCS11.PyKCS11Error as error:
				if error.value == 224:
					continue
				raise error

			try:
				_tmp_session.login(yubikey_pin)
			except PyKCS11.PyKCS11Error as error:
				if error.value == 256:
					# Already logged in
					pass
				else:
					raise error

			certificates = _tmp_session.findObjects([
				(CKA_CLASS, CKO_CERTIFICATE),
			])

			for certificate in certificates:
				_tmp_cert_der = bytes(_tmp_session.getAttributeValue(certificate, [CKA_VALUE])[0])

			_tmp_private_keys = _tmp_session.findObjects([
				(CKA_CLASS, CKO_PRIVATE_KEY),
			])

			for _tmp_private_key in _tmp_private_keys:
				attributes = _tmp_session.getAttributeValue(_tmp_private_key, [CKA_ID])

				_tmp_cert = cryptography.x509.load_der_x509_certificate(_tmp_cert_der)
				_tmp_fingerprint = _tmp_cert.fingerprint(cryptography.hazmat.primitives.hashes.SHA512())
				break # .. todo:: make sure this belongs to the cert we found

			print(f"Has detected Yubikey for {_tmp_cert.subject.get_attributes_for_oid(cryptography.x509.NameOID.COMMON_NAME)[0].value}")

			self.session = _tmp_session
			break

		if self.session:
			self.sign(b"data", "This should break things")

	def on_eject(self, cards):
		if self.session:
			self.session.logout()
			self.session.closeSession()
			self.session = None
			
yubikey = YubikeySession()
sc_monitor = CardMonitor(on_insert=yubikey.on_insert, on_eject=yubikey.on_eject)

time.sleep(2)

yubikey.on_eject([])
test['alive'] = False