Python util.toHexString函数代码示例

    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 _process_card(self, connection):
        """This is where the magic happens"""
        self.reader.busy_signal(connection)
        self.logger.info(self.reader.card_description + ' card detected')
        self.logger.debug('ATR: ' + toHexString(self.reader.card_ATR))
        card_serial_number = self.reader.get_serial_number(connection)
        if card_serial_number:
            self.logger.debug('UID: ' + toHexString(card_serial_number))
        else:
            card_serial_number = []
            self.logger.warn('No UID read!')

        # parse data definition and read data accordingly
        data_list = self._read_defined_data(connection)

        output_string = self.head + self.start1 + self.track1 + self.end
        if self.track2 != "": output_string += self.start2 + self.track2 + self.end
        if self.track3 != "": output_string += self.start3 + self.track3 + self.end
        output_string += self.tail

        self.key_stroker.send_string(
            self._process_output_string(output_string, card_serial_number, data_list))

        self.reader.ready_signal(connection)
        connection.disconnect()

    def case_3e(self, full):
        # send data to the card
        # >  80 12 01 80 00 00 07 00 01 02 03 04 05 06
        # <  []  90 0
        CASE_3 = toBytes("80 12 01 80 00 00 00")

        print "Case 3 extended"
        print

        if toHexString(self.ATR) != "3B D6 18 00 81 B1 80 7D 1F 03 80 51 00 61 10 30 8F":
            print_error("Wrong card inserted!")
            print "Got ATR:", toHexString(self.ATR)
            return

        end = 65535
        step = 100
        if full:
            start = 1
        else:
            start = end

        expected = ([], 0x90, 0x00)
        for length in range(start, end + 1, step):
            print self.BOL, "length:", length
            APDU = list(CASE_3)
            APDU[5] = (length & 0xFF00) >> 8
            APDU[6] = length & 0x00FF
            APDU += [i for i in range(0, length)]

            self.transmitAndCompare(APDU, expected)

    def read(self):
	# keyword to ask card id
	SELECT = [0xFF, 0xCA, 0x00, 0x00, 0x00]

        if debug: print "reading data"
        try:
	    self.connection.connect()
	    data, sw1, sw2 = self.connection.transmit( SELECT )
	    if debug: print "%x %x" % (sw1, sw2)
	    #90 0
	    if debug: print data
	    if format == 'hex' and reverse == 0:
		cardid = toHexString(data).replace(' ','')
	    elif format == 'hex' and reverse == 1:
		cardid = toHexString(data[::-1]).replace(' ','')
	    elif format == 'dec' and reverse == 0:
		cardid = toHexString(data).replace(' ','')
		cardid = int(cardid, 16)
	    elif format == 'dec' and reverse == 1:
		cardid = toHexString(data[::-1]).replace(' ','')
		cardid = int(cardid, 16)
	    if debug: print "cardid: %s" % cardid
	    return cardid
	except:
	    if debug: print "no card data"
	    return False

    def case_2e(self, full):
        # gets (1 to 256) data from the card
        # >  80 00 04 2A 00 00 07
        # <  2A 2A 2A 2A 2A 2A 2A 90 0
        magic_value = 42
        CASE_2 = toBytes("80 00 04 00 00 00 00")
        CASE_2[3] = magic_value

        print "Case 2 extended"
        print

        # ATRs of the Athena test cards
        Athena_ATRs = ["3B D6 18 00 80 B1 80 6D 1F 03 80 51 00 61 10 30 9E",
                       "3F 96 18 80 01 80 51 00 61 10 30 9F"]

        if toHexString(self.ATR) not in Athena_ATRs:
            print_error("Wrong card inserted!")
            print "Got ATR:", toHexString(self.ATR)
            return

        step = 100
        end = 65535
        if full:
            start = 1
        else:
            start = end

        for length in range(start, end + 1, step):
            print self.BOL, "length:", length
            APDU = list(CASE_2)
            APDU[5] = (length & 0xFF00) >> 8
            APDU[6] = length & 0x00FF

            expected = ([magic_value] * length, 0x90, 0x00)
            self.transmitAndCompare(APDU, expected)

    def send_to_tag(self, tag, apdu):
        if tag is not None:
            raise ValueError('Multiple tags not supported')

        HResult(smartcard.scard.SCardBeginTransaction(self.hcard))

        if DEBUG:
            print '> %s' % toHexString(list(apdu))

        response = HResult(smartcard.scard.SCardTransmit(self.hcard, smartcard.scard.SCARD_PCI_T0, list(apdu)))
        if DEBUG:
            print '< %s' % toHexString(response)

        sw1, sw2 = response[0:2]
        if sw1 == 0x61:  # More data
            apdu2 = APDU(0, 0xc0, lc=sw2)
            if DEBUG:
                print '> %s' % toHexString(list(apdu2))

            response = HResult(smartcard.scard.SCardTransmit(self.hcard, smartcard.scard.SCARD_PCI_T0, list(apdu2)))
            if DEBUG:
                print '< %s' % toHexString(response)

        HResult(smartcard.scard.SCardEndTransaction(self.hcard, smartcard.scard.SCARD_LEAVE_CARD))

        return response

def printExchange(query, response, sw1, sw2):
    """Affiche un échange query-response."""
    print ">> ",
    if type(query) == type([]):
         print toHexString(query)
    else:
        print query
    print "<< ", toHexString(response), " / ", "%x %x" % (sw1, sw2)

def print_details(debug, apdu, result, t, n):
  (data, sw1, sw2) = result

  if debug == 1:
    print "C =", toHexString(apdu)
    print "D =",toHexString(data)
    print "R = %x %x" % (sw1, sw2)
    print '%s took %0.3f ms.' % (n, t*1000.)

def printExchange(query, response, sw1, sw2):
    """Prints an APDU exchange (query-response)."""
    print ">> ",
    if type(query) is types.ListType:
         print toHexString(query)
    else:
        print query
    print "<< ", toHexString(response), " / ", "%x %x" % (sw1, sw2)

 def update(self, observable, actions):
     (addedcards, removedcards) = actions
     foundcards = {}
     self.testcase.assertEqual(removedcards, [])
     for card in addedcards:
         foundcards[toHexString(card.atr)] = 1
     for atr in expectedATRs:
         if [] != atr and {} != foundcards:
             self.testcase.assertTrue(toHexString(atr) in foundcards)

	def _send_apdu(self, apdu):
		if self.debug == True:
			print("--> {0}".format(toHexString(apdu)))
		data, sw1, sw2 = self.connection.transmit(apdu)
		self.last_sent = apdu
		self.last_received = data + [sw1, sw2]
		if self.debug == True:
			print("<-- {0}".format(toHexString(data)))
			print("<-- {0}".format(toHexString([sw1, sw2])))
			print("")
		return data, sw1, sw2

 def evtLogKeyDown(self, event):
     code = event.GetKeyCode()
     if wx.WXK_RETURN == code or wx.WXK_NUMPAD_ENTER == code:
         linenum = len(self.txtLog.GetRange(0, self.txtLog.GetInsertionPoint()).split("\n"))
         linetext = self.txtLog.GetLineText(linenum - 1)
         self.history.append(linetext)
         self.history_index = len(self.history)
         cmd = map(ord, linetext.decode("hex"))
         self.txtLog.AppendText("\n")
         if self.card:
             try:
                 data, sw1, sw2 = self.card.transmit(cmd)
             except Exceptions.CardConnectionException as ex:
                 self.txtLog.SetDefaultStyle(wx.TextAttr("RED"))
                 self.txtLog.AppendText("{0}\n\n".format(ex.message))
                 self.txtLog.SetDefaultStyle(wx.TextAttr("BLACK"))
             if sw1 == 0x61:
                 data, sw1, sw2 = self.card.transmit([0x00, 0xC0, 0x00, 0x00, sw2])
             self.txtLog.SetDefaultStyle(wx.TextAttr("BROWN"))
             if data:
                 self.txtLog.AppendText("> Data:\n")
                 for octet in [data[i : i + 8] for i in xrange(0, len(data), 8)]:
                     txtform = "".join(map(logchr, octet))
                     txtform = "{0}{1}{2}\n".format(toHexString(octet), " " * ((8 - len(octet)) * 3 + 5), txtform)
                     self.txtLog.AppendText(txtform)
             self.txtLog.SetDefaultStyle(wx.TextAttr("BLUE"))
             self.txtLog.AppendText("> SW: " + toHexString([sw1, sw2]) + "\n\n")
             self.txtLog.SetDefaultStyle(wx.TextAttr("BLACK"))
         self.lastpos = self.txtLog.GetLastPosition()
     elif wx.WXK_UP == code:
         if not len(self.history):
             return
         if self.history_index:
             self.history_index -= 1
         self.txtLog.Remove(self.lastpos, self.txtLog.GetLastPosition())
         self.txtLog.SetInsertionPoint(self.lastpos)
         self.txtLog.WriteText(self.history[self.history_index])
     elif wx.WXK_DOWN == code:
         if not len(self.history):
             return
         if self.history_index + 1 < len(self.history):
             self.history_index += 1
         self.txtLog.Remove(self.lastpos, self.txtLog.GetLastPosition())
         self.txtLog.SetInsertionPoint(self.lastpos)
         self.txtLog.WriteText(self.history[self.history_index])
     elif wx.WXK_BACK == code:
         if self.lastpos < self.txtLog.GetInsertionPoint():
             event.Skip()
     else:
         event.Skip()
         return

    def _card_connection_observer_update(self, card_connection, event):
        """CardConnectionObserver interface implementation"""

        if 'connect' == event.type:
            print 'Card inserted\n'

        elif 'disconnect' == event.type:
            print 'Card removed\n'

        elif 'command' == event.type:
            print '> ', toHexString(event.args[0])

        elif 'response' == event.type:
            print '< ', '[{}]\n<  {:02X} {:02X}\n'.format(toHexString(event.args[0]), *event.args[1:])

    def update(self, observable, actions):
        (addedcards, removedcards) = actions
        for card in addedcards:
            print("+Inserted: ", toHexString(card.atr))
            card.connection = card.createConnection()
            card.connection.connect()
            card.connection.addObserver(self.observer)
            apdu = SELECT + DF_TELECOM
            response, sw1, sw2 = card.connection.transmit(apdu)
            if sw1 == 0x9F:
                apdu = GET_RESPONSE + [sw2]
                response, sw1, sw2 = card.connection.transmit(apdu)

        for card in removedcards:
            print("-Removed: ", toHexString(card.atr))

def get_smartcard_atr(logger):
    """return the atr of the current device"""
    if logger is None:
        raise AttributeError

    try:
        readers_list = smartcard.System.readers()  # ottengo la lista dei lettori
    except pcsc.PCSCExceptions.EstablishContextException:
        logger.error("demone pcscd not attivo")  # il lettore di smartcard potrebbe non essere inserito
        return None

    # non sono riuscito a trovare nessun lettore
    if len(readers_list) == 0:
        logger.error("nessun lettore riconosciuto")
        return None

    reader = readers_list[0]  # di default prendo il primo lettore
    connection = reader.createConnection()
    try:
        # Mi connetto e ottengo l'ATR dalla carta
        connection.connect()
        atr_str = toHexString(connection.getATR()).replace(" ", ":").lower()
        connection.disconnect()
    except smartcard.Exceptions.CardConnectionException, errmsg:
        logger.error(errmsg)
        return None