コード例 #1
1
def main():
        known_ids = {}
        cardtype = AnyCardType()
        #times out every 0.5 seconds
        cardrequest = CardRequest( timeout=0.5, cardType=cardtype )
        while True:
                try: 
                        # try to connect to a card, if the process 
                        # times out, continue
                        cardservice = cardrequest.waitforcard()
                        cardservice.connection.connect()
                        # compare ATRs
                        if ATR == cardservice.connection.getATR():
                                response, sw1, sw2 = \
                                    cardservice.connection.transmit( APDU )
                                tagid = toHexString(response).replace(' ','')
                                if tagid in known_ids:
                                        print "found uid"
                                        print tagid
                                else:
                                        known_ids[tagid] = True
                                        print "new uid"
                                        print tagid
                                # do appropriate things
                                post_to_server(tagid)
                                play_sound()
                except:
                        continue
コード例 #2
0
	def wait_for_card(self, timeout=None, newcardonly=False):
		cr = CardRequest(readers=[self._reader], timeout=timeout, newcardonly=newcardonly)
		try:
			cr.waitforcard()
		except CardRequestTimeoutException:
			raise NoCardError()
		self.connect()
コード例 #3
0
    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
コード例 #4
0
class SIMController:
    def __init__(self):
        self.c = None  # f**k pyscard. seriously.
        pass

    def nextg_apdu(self, rand=None, autn=None, debug=False):
        self.cardrequest = CardRequest(timeout=5, cardType=AnyCardType())
        self.cardservice = self.cardrequest.waitforcard()
        if debug:
            obs = ConsoleCardConnectionObserver()
            self.cardservice.connection.addObserver(obs)
        self.cardservice.connection.connect()
        self.c = self.cardservice.connection
        # print("ATR... : %s" % self.cardservice.connection.getATR())
        r, sw1, sw2 = self.c.transmit(
            [0x00, 0xa4, 0x08, 0x04, 0x02, 0x2f, 0x00])
        r, sw1, sw2 = self.c.transmit([0x00, 0xc0, 0x00, 0x00, 0x28])
        r, sw1, sw2 = self.c.transmit([0x00, 0xb2, 0x01, 0x04, 0x26])
        r, sw1, sw2 = self.c.transmit([
            0x00, 0xa4, 0x04, 0x04, 0x10, 0xa0, 0x00, 0x00, 0x00, 0x87, 0x10,
            0x02, 0xff, 0x33, 0xff, 0xff, 0x89, 0x01, 0x01, 0x01, 0x00
        ])
        r, sw1, sw2 = self.c.transmit([0x00, 0xc0, 0x00, 0x00, 0x3e])
        r, sw1, sw2 = self.c.transmit(
            [0x00, 0xa4, 0x00, 0x04, 0x02, 0x6f, 0x07])
        r, sw1, sw2 = self.c.transmit([0x00, 0xc0, 0x00, 0x00, 0x25])
        r, sw1, sw2 = self.c.transmit([0x00, 0xb0, 0x00, 0x00, 0x09])
        if rand is None and autn is None:
            authcmd = [0x00, 0x88, 0x00, 0x81, 0x22, 0x10
                       ] + [0xaa] * 16 + [0x10] + [0xbb] * 16
        else:
            authcmd = [0x00, 0x88, 0x00, 0x81, 0x22, 0x10] + rand + [0x10
                                                                     ] + autn
        r, sw1, sw2 = self.c.transmit(authcmd)

    def fuzzFile(self, observer=False):
        self.cardrequest = CardRequest(timeout=5, cardType=AnyCardType())
        self.cardservice = self.cardrequest.waitforcard()
        if observer:
            obs = ConsoleCardConnectionObserver()
            self.cardservice.connection.addObserver(obs)
        self.cardservice.connection.connect()
        self.c = self.cardservice.connection
        print("ATR... : %s" % self.cardservice.connection.getATR())
        print("Brute forcing...")
        out = ""
        for i in range(0, 0xFF):
            for x in range(0, 0xFF):
                response, sw1, sw2 = self.cardservice.connection.transmit(
                    [0x00, 0xA4, 0x08, 0x04, 0x02, i, x])
                if sw1 == 0x61:
                    out += "Valid APDU from MF: %02x::%02x\n" % (i, x)
        return out
    def __init__(self, threadindex):
        '''Connect to a card with an ExclusiveTransmitCardConnection.'''
        threading.Thread.__init__(self)

        self.threadindex = threadindex

        # request any card type
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=5, cardType=cardtype)
        cardservice = cardrequest.waitforcard()

        # attach our decorator
        cardservice.connection = ExclusiveTransmitCardConnection(
            cardservice.connection)

        # uncomment to attach the console tracer
        #observer=ConsoleCardConnectionObserver()
        #cardservice.connection.addObserver(observer)

        # connect to the card
        cardservice.connection.connect()

        self.cardservice = cardservice

        # this event will signal the end of the thread
        self.evtStop = threading.Event()

        # this timer will set the event stop event in 30s
        timer = threading.Timer(30, signalEvent, [self.evtStop])
        timer.start()
        self.countTransmitted = 0
コード例 #6
0
    def run(self):
        from smartcard.CardRequest import CardRequest
        from smartcard.Exceptions import NoCardException, CardConnectionException
        from smartcard.util import toHexString

        super().run()

        self.logger.info('Initialized smart card reader backend - ATR filter: {}'.
                     format(self.ATRs))

        prev_atr = None
        reader = None

        while not self.should_stop():
            try:
                cardrequest = CardRequest(timeout=None, cardType=self.cardtype)
                cardservice = cardrequest.waitforcard()
                cardservice.connection.connect()

                reader = cardservice.connection.getReader()
                atr = toHexString(cardservice.connection.getATR())

                if atr != prev_atr:
                    self.logger.info('Smart card detected on reader {}, ATR: {}'.
                                format(reader, atr))

                    self.bus.post(SmartCardDetectedEvent(atr=atr, reader=reader))
                    prev_atr = atr
            except Exception as e:
                if isinstance(e, NoCardException) or isinstance(e, CardConnectionException):
                    self.bus.post(SmartCardRemovedEvent(atr=prev_atr, reader=reader))
                else:
                    self.logger.exception(e)

                prev_atr = None
コード例 #7
0
ファイル: class_nfc_old.py プロジェクト: jjcc/Py-Library-NFC
    def initialize(card_type=""):

        if card_type == "":
            cardtype = AnyCardType()  # for accepting any type of card
        else:
            cardtype = ATRCardType(card_type)

        cardrequest = CardRequest(timeout=1, cardType=cardtype)

        # print("Waiting for card")
        cardservice = cardrequest.waitforcard()
        # print("Card found")

        # connecting to card
        cardservice.connection.connect()
        reader = cardservice.connection.getReader()
        print(f"Success: NFC Connection established on reader {reader}")

        # set up object
        nfc_connection = NFCconnection(
            cardservice=cardservice,
            metadata={},
        )

        # get metadata
        nfc_connection.get_card_atr_info()
        nfc_connection.get_card_uid()
        nfc_connection.get_card_size()

        uid = nfc_connection.metadata["UID"]
        size = nfc_connection.metadata["Size"]
        print(f"Success: NFC Connection identified as {uid} with size {size}")

        return nfc_connection
コード例 #8
0
 def detect_smartcard_reader(self):
     print_error("[satochip] SatochipPlugin: detect_smartcard_reader"
                 )  #debugSatochip
     self.cardtype = AnyCardType()
     try:
         cardrequest = CardRequest(timeout=5, cardType=self.cardtype)
         cardservice = cardrequest.waitforcard()
         print_error(
             "[satochip] SatochipPlugin: detect_smartcard_reader: found card!"
         )  #debugSatochip
         return [
             Device(path="/satochip",
                    interface_number=-1,
                    id_="/satochip",
                    product_key=(SATOCHIP_VID, SATOCHIP_PID),
                    usage_page=0)
         ]
         #transport_ui_string='ccid')]
     except CardRequestTimeoutException:
         print('time-out: no card inserted during last 5s')
         return []
     except Exception as exc:
         print("Error during connection:", exc)
         return []
     return []
コード例 #9
0
def connectionObserver():
    # request any card type
    cardtype = AnyCardType()
    cardrequest = CardRequest(timeout=1, cardType=cardtype)
    cardservice = cardrequest.waitforcard()

    observer = ConsoleCardConnectionObserver()
    cardservice.connection.addObserver(observer)

    cardservice.connection.connect()
    print('ATR: ' + toHexString(cardservice.connection.getATR()))
    # get reader used for the connection
    # device = cardservice.connection.getReader()

    GET_RESPONSE = [0XA0, 0XC0, 00, 00]
    SELECT = [0xA0, 0xA4, 0x00, 0x00, 0x02]
    DF_TELECOM = [0x7F, 0x10]

    apdu = SELECT + DF_TELECOM
    response, sw1, sw2 = cardservice.connection.transmit(apdu)
    if sw1 == 0x9F:
        apdu = GET_RESPONSE + [sw2]
        response, sw1, sw2 = cardservice.connection.transmit(apdu)
    else:
        print('no DF_TELECOM')
コード例 #10
0
ファイル: readthaiid.py プロジェクト: wingkopu/Project
    def __init__(self):

        cardtype = AnyCardType()
        self.resetCmd = [0x0, 0xA4, 0x4, 0x0, 0x8, 0xA0, 0x0, 0x0, 0x0, 0x54, 0x48, 0x0, 0x1]
        self.resetCmd1 = [0x0, 0xC0, 0x0, 0x0, 0xA]

        self.citizenCmd = [0x80, 0xB0, 0x0, 0x4, 0x2, 0x0, 0xD]
        self.citizenResponse = [0x0, 0xC0, 0x0, 0x0, 0xD]

        try:
            # request card insertion
            cardrequest = CardRequest(timeout=5, cardType=cardtype)
            self.cardservice = cardrequest.waitforcard()
            # attach the console tracer
            # observer = ConsoleCardConnectionObserver()
            # self.cardservice.connection.addObserver(observer)

            # connect to the card and perform a few transmits
            self.cardservice.connection.connect()
        except CardRequestTimeoutException:
            print 'time-out: no card inserted during last 5s'

        except:
            import sys
            print sys.exc_info()[1]
コード例 #11
0
    def getATR(self):
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=1, cardType=cardtype)
        cardservice = cardrequest.waitforcard()

        cardservice.connection.connect()
        return toHexString(cardservice.connection.getATR())
コード例 #12
0
    def __init__(self):
        """
        Generic constructor
        """

        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=3, cardType=cardtype)

        self.seq = None
        self.kSessEnc = None
        self.kSessMac = None

        self.index = 0

        # Wait for the card
        print('Waiting for the CIE...')
        try:
            self.cardservice = cardrequest.waitforcard()
        except CardRequestTimeoutException:
            print('Card not found, exiting')
            sys.exit(1)

        # Connect to the card if found
        self.cardservice.connection.connect()
        print('Connected!')
コード例 #13
0
    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()
コード例 #14
0
ファイル: fingerPrint.py プロジェクト: tgie/epassportviewer
    def getATR(self):
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=1, cardType=cardtype)
        cardservice = cardrequest.waitforcard()

        cardservice.connection.connect()
        return toHexString(cardservice.connection.getATR())
コード例 #15
0
    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()
コード例 #16
0
class SIMController:
    def __init__(self):
        self.c = None  # f**k pyscard. seriously.
        pass

    def french_apdu(self, rand=None, autn=None, scope=None, debug=False):
        self.cardrequest = CardRequest(timeout=5, cardType=AnyCardType())
        self.cardservice = self.cardrequest.waitforcard()
        if debug:
            obs = ConsoleCardConnectionObserver()
            self.cardservice.connection.addObserver(obs)
        self.cardservice.connection.connect()
        self.c = self.cardservice.connection
        r, sw1, sw2 = self.c.transmit(
            [0x00, 0xa4, 0x08, 0x04, 0x02, 0x2f, 0x00])
        r, sw1, sw2 = self.c.transmit([0x00, 0xC0, 0x00, 0x00] + [sw2])
        r, sw1, sw2 = self.c.transmit([0x00, 0xB2, 0x01, 0x04] + [r[7]])
        r, sw1, sw2 = self.c.transmit([0x00, 0xA4, 0x04, 0x04] +
                                      list(r[3:4 + r[3]]))
        scope.arm()
        r, sw1, sw2 = self.c.transmit([0x00, 0xC0, 0x00, 0x00] + [sw2])
        if rand is None and autn is None:
            authcmd = [0x00, 0x88, 0x00, 0x81, 0x22, 0x10
                       ] + [0xaa] * 16 + [0x10] + [0xbb] * 16
        else:
            authcmd = [0x00, 0x88, 0x00, 0x81, 0x22, 0x10] + rand + [0x10
                                                                     ] + autn
        r, sw1, sw2 = self.c.transmit(authcmd)
コード例 #17
0
def writeTag(value):
    page = 4
    cardtype = AnyCardType()
    cardreq = CardRequest(timeout=100, cardType=cardtype)
    cardservice = cardreq.waitforcard()
    cardservice.connection.connect()
    print(toHexString(cardservice.connection.getATR()))
    WRITE_COMMAND = [
        0xFF, 0xD6, 0x00, 0x04, 0x04,
        int(value[0:2], 16),
        int(value[2:4], 16),
        int(value[4:6], 16),
        int(value[6:8], 16)
    ]
    print(WRITE_COMMAND)
    #[0xFF, 0xD6, 0x00, int(page), 0x04, int(value[0:2], 16), int(value[2:4], 16), int(value[4:6], 16), int(value[6:8], 16)]
    #Let's write a page Page 9 is usually 00000000
    #resp = cardservice.connection.transmit(AUTHENTICATE_COMMAND)
    #print(resp)
    resp = cardservice.connection.transmit(WRITE_COMMAND)
    print(resp)
    if resp[1] == 144:
        print("Wrote " + str(value))
    else:
        print("Error occured during write operation")
コード例 #18
0
ファイル: readthaiid.py プロジェクト: wingkopu/Project
    def __init__(self):

        cardtype = AnyCardType()
        self.resetCmd = [
            0x0, 0xA4, 0x4, 0x0, 0x8, 0xA0, 0x0, 0x0, 0x0, 0x54, 0x48, 0x0, 0x1
        ]
        self.resetCmd1 = [0x0, 0xC0, 0x0, 0x0, 0xA]

        self.citizenCmd = [0x80, 0xB0, 0x0, 0x4, 0x2, 0x0, 0xD]
        self.citizenResponse = [0x0, 0xC0, 0x0, 0x0, 0xD]

        try:
            # request card insertion
            cardrequest = CardRequest(timeout=5, cardType=cardtype)
            self.cardservice = cardrequest.waitforcard()
            # attach the console tracer
            # observer = ConsoleCardConnectionObserver()
            # self.cardservice.connection.addObserver(observer)

            # connect to the card and perform a few transmits
            self.cardservice.connection.connect()
        except CardRequestTimeoutException:
            print 'time-out: no card inserted during last 5s'

        except:
            import sys
            print sys.exc_info()[1]
コード例 #19
0
    def __init__(self, threadindex):
        '''Connect to a card with an ExclusiveTransmitCardConnection.'''
        threading.Thread.__init__(self)

        self.threadindex = threadindex

        # request any card type
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=5, cardType=cardtype)
        cardservice = cardrequest.waitforcard()

        # attach our decorator
        cardservice.connection = ExclusiveTransmitCardConnection(cardservice.connection)

        # uncomment to attach the console tracer
        #observer=ConsoleCardConnectionObserver()
        #cardservice.connection.addObserver(observer)

        # connect to the card
        cardservice.connection.connect()

        self.cardservice = cardservice

        # this event will signal the end of the thread
        self.evtStop = threading.Event()

        # this timer will set the event stop event in 30s
        timer = threading.Timer(30, signalEvent, [self.evtStop])
        timer.start()
        self.countTransmitted = 0
コード例 #20
0
ファイル: custom.py プロジェクト: akpotter/epassportviewer
    def getATR(self):
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=1, cardType=cardtype)
        cardservice = cardrequest.waitforcard()

        cardservice.connection.connect()
        atr = toHexString(cardservice.connection.getATR())
        self.writeToLog("ATR: {0}".format(atr))
コード例 #21
0
def getCard():
    try:
        cardrequest = CardRequest(timeout=60)
        cardservice = cardrequest.waitforcard()
        cardservice.connection.connect()
        return cardservice
    except Exception:
        return None
コード例 #22
0
ファイル: custom.py プロジェクト: ohleck/ePassportViewer
    def getATR(self):
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=1, cardType=cardtype)
        cardservice = cardrequest.waitforcard()

        cardservice.connection.connect()
        atr = toHexString(cardservice.connection.getATR())
        self.writeToLog("ATR: {0}".format(atr))
コード例 #23
0
ファイル: serv.py プロジェクト: Saladin2020/dsmartcard
def get_photo_byte():
    cardtype = AnyCardType()
    cardrequest = CardRequest(timeout=1, cardType=cardtype)

    try:
        cardservice = cardrequest.waitforcard()
    except:
        resultdict = {
            'status': 'inactive'
        }
        return json.dumps(resultdict)

    cardservice.connection.connect()

    REQ_PHOTO_P1 = [0x80, 0xB0, 0x01, 0x7B, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P2 = [0x80, 0xB0, 0x02, 0x7A, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P3 = [0x80, 0xB0, 0x03, 0x79, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P4 = [0x80, 0xB0, 0x04, 0x78, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P5 = [0x80, 0xB0, 0x05, 0x77, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P6 = [0x80, 0xB0, 0x06, 0x76, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P7 = [0x80, 0xB0, 0x07, 0x75, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P8 = [0x80, 0xB0, 0x08, 0x74, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P9 = [0x80, 0xB0, 0x09, 0x73, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P10 = [0x80, 0xB0, 0x0A, 0x72, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P11 = [0x80, 0xB0, 0x0B, 0x71, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P12 = [0x80, 0xB0, 0x0C, 0x70, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P13 = [0x80, 0xB0, 0x0D, 0x6F, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P14 = [0x80, 0xB0, 0x0E, 0x6E, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P15 = [0x80, 0xB0, 0x0F, 0x6D, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P16 = [0x80, 0xB0, 0x10, 0x6C, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P17 = [0x80, 0xB0, 0x11, 0x6B, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P18 = [0x80, 0xB0, 0x12, 0x6A, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P19 = [0x80, 0xB0, 0x13, 0x69, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P20 = [0x80, 0xB0, 0x14, 0x68, 0x02, 0x00, 0xFF]

    PHOTO = [REQ_PHOTO_P1, REQ_PHOTO_P2, REQ_PHOTO_P3, REQ_PHOTO_P4, REQ_PHOTO_P5,
             REQ_PHOTO_P6, REQ_PHOTO_P7, REQ_PHOTO_P8, REQ_PHOTO_P9, REQ_PHOTO_P10, REQ_PHOTO_P11, REQ_PHOTO_P12, REQ_PHOTO_P13, REQ_PHOTO_P14, REQ_PHOTO_P15, REQ_PHOTO_P16, REQ_PHOTO_P17,
             REQ_PHOTO_P18, REQ_PHOTO_P19, REQ_PHOTO_P20]

    photobytearray = bytearray()

    apdu = SELECT+THAI_ID_CARD
    response, sw1, sw2 = cardservice.connection.transmit(apdu)

    # custom
    fphoto = open("photos/current.jpeg", "wb")

    for d in PHOTO:
        response, sw1, sw2 = cardservice.connection.transmit(d)
        if sw1 == 0x61:
            GET_RESPONSE = [0X00, 0XC0, 0x00, 0x00]
            apdu = GET_RESPONSE + [sw2]
            response, sw1, sw2 = cardservice.connection.transmit(apdu)
            photobytearray.extend(bytearray(response))
            # custom
            fphoto.write(bytearray(response))

    return photobytearray
コード例 #24
0
ファイル: scp10Client.py プロジェクト: ddealmei/SCP10-attack
    def __init__(self,
                 clientkey_enc,
                 clientcert_enc,
                 clientkey_sig,
                 clientcert_sig,
                 tp_key,
                 tp_cert,
                 key_transport=False,
                 mutual_auth=True,
                 cert_verif=True,
                 debug=False,
                 chan=0,
                 vuln=True):
        self.vuln = vuln
        if chan > 3 or chan < 0:
            raise ValueError("Logical channel number must be in [0, 3]")
        self.cla = self.DEFAULT_CLA + chan

        self.security_lvl = 0x42  # ANY_AUTHENTICATED + C_DECRYPTION

        self.clientKey_enc = RsaKeyHolder(clientkey_enc)
        self.clientCert_enc = CVCertificate(clientcert_enc)
        self.clientKey_sig = RsaKeyHolder(clientkey_sig)
        self.clientCert_sig = CVCertificate(clientcert_sig)

        self.tp_key = RsaKeyHolder(tp_key)
        self.tp_cert = CVCertificate(tp_cert)

        self.cardKey_enc = None
        self.cardCert_enc = None
        self.cardKey_sig = None
        self.cardCert_sig = None

        self.key_transport = key_transport
        self.mutual_auth = mutual_auth
        self.cert_verif = cert_verif

        self.session_keys = []
        self.session_ivs = []
        self.client_secret = []
        self.card_secret = []

        # Wait for any card to be put on a reader, and initiate a connection
        card_type = AnyCardType()
        card_request = CardRequest(timeout=None, cardType=card_type)
        self.card = card_request.waitforcard()
        self.card.connection.connect()

        error_chain = []
        error_chain = [
            ErrorCheckingChain(error_chain, ISO7816_4ErrorChecker())
        ]
        self.card.connection.setErrorCheckingChain(error_chain)
        # Set an observer for debugging
        if debug:
            observer = SCP10Observer()
            self.card.connection.addObserver(observer)
コード例 #25
0
ファイル: token_utils.py プロジェクト: rb-anssi/tataouine
def connect_to_smartcard(verbose=True):
    cardtype = AnyCardType()
    cardrequest = CardRequest(timeout=.2, cardType=cardtype)
    cardservice = cardrequest.waitforcard()
    cardservice.connection.connect()
    atr = cardservice.connection.getATR()
    if verbose == True:
        print("ATR: " + toHexString(atr))
    return cardservice
コード例 #26
0
	def __init__(self):
		cardtype = AnyCardType()
		cardrequest = CardRequest(timeout=10, cardType=cardtype)
		self.card = cardrequest.waitforcard()
		self.card.connection.connect()
		self.ins_db = []
		self.ins_db_update(INS_DB)
		self.log = []
	
		self.auto_get_response = True
コード例 #27
0
def connect():
    try:
        cardtype = AnyCardType()
        cardrequest = CardRequest(cardType=cardtype)
        cardservice = cardrequest.waitforcard()
        cardservice.connection.connect()
        return cardservice
    except:
        print(RED + "[x] please enter your card" + ENDC)
        sys.exit()
コード例 #28
0
    def __init__(self):
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=10, cardType=cardtype)
        self.card = cardrequest.waitforcard()
        self.card.connection.connect()
        self.ins_db = []
        self.ins_db_update(INS_DB)
        self.log = []

        self.auto_get_response = True
コード例 #29
0
def readTag():
	cardtype = AnyCardType()
	cardrequest = CardRequest( timeout=10, cardType=cardtype )
	cardservice = cardrequest.waitforcard()
	cardservice.connection.connect()

	COMMAND = [0xFF, 0xCA, 0x00, 0x00, 0x00] 	#cmd necessari per inicialitzar la transmissió de dades
	tagID, sw1, sw2 = cardservice.connection.transmit(COMMAND) 	#retorna 3 dades

	print("\t>>> Your UID is: ")
	print("\t>>> 0x{}".format(listenToString(toHexString(tagID))))
コード例 #30
0
class SmartCardReader(object):
    def __init__(self):
        self.cardtype = AnyCardType()

    def is_card_inserted(self, timeout=1):
        self.cardrequest = CardRequest( timeout=timeout, cardType=self.cardtype )
        try:
            self.cardservice = self.cardrequest.waitforcard()
        except CardRequestTimeoutException:
            return False
        return True 
コード例 #31
0
def request_any_card(cardtype):
    cardrequest = CardRequest(timeout=10, cardType=cardtype)
    cardservice = cardrequest.waitforcard()

    cardservice.connection.connect()

    atr = ATR(cardservice.connection.getATR())
    atr_hex = toHexString(cardservice.connection.getATR())

    # print_atr_info(atr)
    return atr_hex, atr
コード例 #32
0
ファイル: pinpadtest.py プロジェクト: vgisc/gnuk
 def __init__(self, add_a_byte, pinmin, pinmax, fixed):
     cardtype = AnyCardType()
     cardrequest = CardRequest(timeout=10, cardType=cardtype)
     cardservice = cardrequest.waitforcard()
     self.connection = cardservice.connection
     self.verify_ioctl = -1
     self.modify_ioctl = -1
     self.another_byte = add_a_byte
     self.pinmin = pinmin
     self.pinmax = pinmax
     self.fixed = fixed
コード例 #33
0
def get_photo_json():
    cardtype = AnyCardType()
    cardrequest = CardRequest(timeout=1, cardType=cardtype)
    cardservice = cardrequest.waitforcard()
    cardservice.connection.connect()

    REQ_PHOTO_P1 = [0x80, 0xB0, 0x01, 0x7B, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P2 = [0x80, 0xB0, 0x02, 0x7A, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P3 = [0x80, 0xB0, 0x03, 0x79, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P4 = [0x80, 0xB0, 0x04, 0x78, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P5 = [0x80, 0xB0, 0x05, 0x77, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P6 = [0x80, 0xB0, 0x06, 0x76, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P7 = [0x80, 0xB0, 0x07, 0x75, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P8 = [0x80, 0xB0, 0x08, 0x74, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P9 = [0x80, 0xB0, 0x09, 0x73, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P10 = [0x80, 0xB0, 0x0A, 0x72, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P11 = [0x80, 0xB0, 0x0B, 0x71, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P12 = [0x80, 0xB0, 0x0C, 0x70, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P13 = [0x80, 0xB0, 0x0D, 0x6F, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P14 = [0x80, 0xB0, 0x0E, 0x6E, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P15 = [0x80, 0xB0, 0x0F, 0x6D, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P16 = [0x80, 0xB0, 0x10, 0x6C, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P17 = [0x80, 0xB0, 0x11, 0x6B, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P18 = [0x80, 0xB0, 0x12, 0x6A, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P19 = [0x80, 0xB0, 0x13, 0x69, 0x02, 0x00, 0xFF]
    REQ_PHOTO_P20 = [0x80, 0xB0, 0x14, 0x68, 0x02, 0x00, 0xFF]

    PHOTO = [
        REQ_PHOTO_P1, REQ_PHOTO_P2, REQ_PHOTO_P3, REQ_PHOTO_P4, REQ_PHOTO_P5,
        REQ_PHOTO_P6, REQ_PHOTO_P7, REQ_PHOTO_P8, REQ_PHOTO_P9, REQ_PHOTO_P10,
        REQ_PHOTO_P11, REQ_PHOTO_P12, REQ_PHOTO_P13, REQ_PHOTO_P14,
        REQ_PHOTO_P15, REQ_PHOTO_P16, REQ_PHOTO_P17, REQ_PHOTO_P18,
        REQ_PHOTO_P19, REQ_PHOTO_P20
    ]

    resultdict = dict()
    photobytearray = list()

    apdu = SELECT + THAI_ID_CARD
    response, sw1, sw2 = cardservice.connection.transmit(apdu)

    for d in PHOTO:
        response, sw1, sw2 = cardservice.connection.transmit(d)
        if sw1 == 0x61:
            GET_RESPONSE = [0X00, 0XC0, 0x00, 0x00]
            apdu = GET_RESPONSE + [sw2]
            response, sw1, sw2 = cardservice.connection.transmit(apdu)

            for i in response:
                photobytearray.append(i)

    resultdict = {'status': 'active', 'photo': photobytearray}

    return Response(json.dumps(resultdict), mimetype='application/json')
コード例 #34
0
ファイル: pinpadtest.py プロジェクト: ggkitsas/gnuk
 def __init__(self, add_a_byte, pinmin, pinmax, fixed):
     cardtype = AnyCardType()
     cardrequest = CardRequest(timeout=10, cardType=cardtype)
     cardservice = cardrequest.waitforcard()
     self.connection = cardservice.connection
     self.verify_ioctl = -1
     self.modify_ioctl = -1
     self.another_byte = add_a_byte
     self.pinmin = pinmin
     self.pinmax = pinmax
     self.fixed = fixed
コード例 #35
0
ファイル: testcase_CardRequest.py プロジェクト: 12019/pyscard
    def testcase_CardRequestATRCardType(self):
        """Test smartcard.AnyCardType."""

        for atr in expectedATRs:
            if [] != atr:
                ct = ATRCardType(atr)
                cr = CardRequest(timeout=10, cardType=ct)
                cs = cr.waitforcard()
                cs.connection.connect()
                self.assertEquals(atr, cs.connection.getATR())
                self.assertEquals(cs.connection.getReader(), expectedReaderForATR[toHexString(atr)])
                cs.connection.disconnect()
コード例 #36
0
ファイル: testcase_CardRequest.py プロジェクト: 12019/pyscard
    def testcase_CardRequestAnyCardTypeInSelectedReader(self):
        """Test smartcard.AnyCardType."""

        for reader in expectedReaders:
            atr = expectedATRinReader[reader]
            if [] != atr:
                ct = AnyCardType()
                cr = CardRequest(timeout=10.6, readers=[reader], cardType=ct)
                cs = cr.waitforcard()
                cs.connection.connect()
                self.assertEquals(atr, cs.connection.getATR())
                self.assertEquals(cs.connection.getReader(), expectedReaderForATR[toHexString(atr)])
コード例 #37
0
def get_status():
    ##header("Content-type: application/json")
    cardtype = AnyCardType()
    cardrequest = CardRequest(timeout=1, cardType=cardtype)
    try:
        cardservice = cardrequest.waitforcard()
    except:
        resultdict = {'status': 'inactive'}
        return json.dumps(resultdict)

    resultdict = {'status': 'active'}
    return Response(json.dumps(resultdict), mimetype='application/json')
コード例 #38
0
def connect_to_card():
    cardtype = AnyCardType()
    cardrequest = CardRequest(timeout=None,
                              cardType=cardtype,
                              newcardonly=True)
    print("Waiting for card insertion...")
    cardservice = cardrequest.waitforcard()

    cardservice.connection.connect()
    print("Card ATR: %s" % toHexString(cardservice.connection.getATR()))

    return cardservice
コード例 #39
0
ファイル: reader.py プロジェクト: 12019/pintar-os-framework
def run():
    global cardservice
    try:
        cardtype = AnyCardType()
        cardreq = CardRequest(timeout=30,cardType=cardtype)
        cardservice = cardreq.waitforcard()
        cardservice.connection.setErrorCheckingChain(errorchain)
        cardservice.connection.connect()
        print "ATR = ", toHexString(cardservice.connection.getATR())
    except SWException, e:
        print str(e)
        return False
コード例 #40
0
def run():
    global cardservice
    try:
        cardtype = AnyCardType()
        cardreq = CardRequest(timeout=30, cardType=cardtype)
        cardservice = cardreq.waitforcard()
        cardservice.connection.setErrorCheckingChain(errorchain)
        cardservice.connection.connect()
        print "ATR = ", toHexString(cardservice.connection.getATR())
    except SWException, e:
        print str(e)
        return False
コード例 #41
0
ファイル: serv.py プロジェクト: Saladin2020/dsmartcard
def get_data():
    cardtype = AnyCardType()
    cardrequest = CardRequest(timeout=1, cardType=cardtype)

    try:
        cardservice = cardrequest.waitforcard()
    except:
        resultdict = {
            'status': 'inactive'
        }
        return json.dumps(resultdict)

    stat = cardservice.connection.connect()

    REQ_CID = [0x80, 0xb0, 0x00, 0x04, 0x02, 0x00, 0x0d]
    REQ_THAI_NAME = [0x80, 0xb0, 0x00, 0x11, 0x02, 0x00, 0x64]
    REQ_ENG_NAME = [0x80, 0xb0, 0x00, 0x75, 0x02, 0x00, 0x64]
    REQ_GENDER = [0x80, 0xb0, 0x00, 0xE1, 0x02, 0x00, 0x01]
    REQ_DOB = [0x80, 0xb0, 0x00, 0xD9, 0x02, 0x00, 0x08]
    REQ_ADDRESS = [0x80, 0xb0, 0x15, 0x79, 0x02, 0x00, 0x64]
    REQ_ISSUE_EXPIRE = [0x80, 0xb0, 0x01, 0x67, 0x02, 0x00, 0x0C]

    DATA = [REQ_CID, REQ_THAI_NAME, REQ_ENG_NAME, REQ_GENDER, REQ_DOB,
            REQ_ADDRESS, REQ_ISSUE_EXPIRE]

    apdu = SELECT+THAI_ID_CARD
    response, sw1, sw2 = cardservice.connection.transmit(apdu)

    resultlist = list()

    for d in DATA:
        response, sw1, sw2 = cardservice.connection.transmit(d)
        if sw1 == 0x61:
            GET_RESPONSE = [0X00, 0XC0, 0x00, 0x00]
            apdu = GET_RESPONSE + [sw2]
            response, sw1, sw2 = cardservice.connection.transmit(apdu)
            result = ''
            for i in response:
                result = result + tis620encoding[i]
            resultlist.append(result)

    resultdict = {
        'status': 'active',
        'idnumber': resultlist[0],
        'thainame': resultlist[1],
        'englishname': resultlist[2],
        'gender': resultlist[3],
        'dob': resultlist[4],
        'address': resultlist[5],
        'issueexpire': resultlist[6],
    }
    return Response(json.dumps(resultdict), mimetype='application/json')
コード例 #42
0
ファイル: connect.py プロジェクト: PhoenixBaymax/EMVConsole
def receiveCard():
	cardtype = AnyCardType()
	cardrequest = CardRequest(timeout = 120, cardType = cardtype)
	
	while (1):
		try:
			cardservice = cardrequest.waitforcard()
			
		except CardRequestTimeoutException:
			continue
			
			
		return cardservice.connection
コード例 #43
0
ファイル: testcase_CardRequest.py プロジェクト: 12019/pyscard
    def testcase_CardRequestAnyCardTypeAnyReaderPassThru(self):
        """Test smartcard.AnyCardType."""

        for reader in expectedReaders:
            atr = expectedATRinReader[reader]
            if [] != atr:
                ct = AnyCardType()
                cardservice = smartcard.PassThruCardService.PassThruCardService
                cr = CardRequest(timeout=10.6, readers=[reader], cardType=ct, cardServiceClass=cardservice)
                cs = cr.waitforcard()
                cs.connection.connect()
                self.assertEquals(cs.__class__, smartcard.PassThruCardService.PassThruCardService)
                self.assertEquals(atr, cs.connection.getATR())
                self.assertEquals(cs.connection.getReader(), expectedReaderForATR[toHexString(atr)])
コード例 #44
0
def sc_connect():
	global cardservice	
	# detect the smart card based on the content of the ATR (card-centric approach)
	print('Initializing card connection...')
	try:
		cardtype = ATRCardType( toBytes( "3B 90 11 00" ) )
		cardrequest = CardRequest( timeout=5, cardType=cardtype )
		cardservice = cardrequest.waitforcard()
		print('Card connection established correctly')
	except:
		print('ERROR: Timeout exceeded')
		sys.exit(0)
	# connect to the card using T0 protocol.
	cardservice.connection.connect( CardConnection.T0_protocol )
コード例 #45
0
    def testcase_CardRequestNewCardAnyCardTypeInfiniteTimeOut(self):
        """Test smartcard.CardRequest for any new card without time-out."""

        self.removeAllCards()
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=None, cardType=cardtype, newcardonly=True)
        print("re-insert any combination of cards six time")
        count = 0
        for i in range(0, 6):
            cardservice = cardrequest.waitforcard()
            try:
                cardservice.connection.connect()
                print(toHexString(cardservice.connection.getATR()), "in", cardservice.connection.getReader())
            except CardConnectionException:
                # card was removed too fast
                pass
            cardservice.connection.disconnect()
            count += 1
        self.assertEqual(6, count)
コード例 #46
0
    def testcase_CardRequestNewCardAnyCardTypeFiniteTimeOutNoInsertion(self):
        """Test smartcard.CardRequest for new card with time-out and no
        insertion before time-out."""

        self.removeAllCards()

        # make sure we have 6 time-outs
        cardtype = AnyCardType()
        cardrequest = CardRequest(
            timeout=1, cardType=cardtype, newcardonly=True)
        count = 0
        for i in range(0, 6):
            try:
                before = time.time()
                cardservice = cardrequest.waitforcard()
            except CardRequestTimeoutException, e:
                elapsed = int(10 * (time.time() - before))
                print '.',
                self.assert_(elapsed >= 10 and elapsed <= 11.)
                count += 1
コード例 #47
0
ファイル: NFCReader.py プロジェクト: chaycv/reader-unican
 def update(self, observable, actions):
     (addedcards, removedcards) = actions
     for card in addedcards:
         try:
             cardType =  ATRCardType( toBytes( "%s" %toHexString(card.atr) ))
             cardRequest = CardRequest(timeout = 1, cardType = cardType)
             cardService = cardRequest.waitforcard()
             cardService.connection.connect()
             SELECT = [0xFF, 0xCA, 0x00, 0x00, 0x00]
             apdu = SELECT
             #print ("sending"  + toHexString(apdu))
             response, sw1, sw2 = cardService.connection.transmit( apdu )
             #print ('response: ', response, ' status words: ', "%x %x" % (sw1, sw2))
             hexUID = self.getParseHexUID(response)
             #print (hexUID)
             self.process(hexUID)
             # id = tagid
             # print ("UID is",id)
         except Exception as e:
             print (e)
コード例 #48
0
    def testcase_CardRequestNewCardAnyCardTypeFiniteTimeOutInsertion(self):
        """Test smartcard.CardRequest for new card with time-out and
        insertion before time-out."""

        self.removeAllCards()

        # make sure insertion is within 5s
        cardtype = AnyCardType()
        cardrequest = CardRequest(
            timeout=5, cardType=cardtype, newcardonly=True)
        count = 0
        for i in range(0, 6):
            try:
                print 're-insert any card within the next 5 seconds'
                before = time.time()
                cardservice = cardrequest.waitforcard()
                count += 1
                elapsed = int(10 * (time.time() - before))
                self.assert_(elapsed <= 55.)
            except CardRequestTimeoutException, e:
                print 'too slow... Test will show a failure'
コード例 #49
0
    def testcase_CardRequestNewCardATRCardTypeInfiniteTimeOut(self):
        """Test smartcard.CardRequest for new card with given ATR
        without time-out."""

        self.removeAllCards()
        count = 0
        for i in range(0, 6):
            card = random.choice(cardz)
            cardtype = ATRCardType(card.atr)
            cardrequest = CardRequest(timeout=None, cardType=cardtype, newcardonly=True)
            print("re-insert card", toHexString(card.atr), "into", card.reader)
            cardservice = cardrequest.waitforcard()
            print("ok")
            try:
                cardservice.connection.connect()
                self.assertEqual(cardservice.connection.getATR(), card.atr)
            except CardConnectionException:
                # card was removed too fast
                pass
            cardservice.connection.disconnect()
            count += 1
        self.assertEqual(6, count)
コード例 #50
0
ファイル: rfidrink.py プロジェクト: madonius/rfidrink
def main():
    """
        Retrieves the ID of the attached Card and returns it as keyboard-presses
    """
    while True:
        try:
            # define the apdus used in this script
            apdu = [0xFF, 0xCA, 0x00, 0x00, 0x00]

            # request card insertion
            card_request = CardRequest(timeout=None, cardType=AnyCardType(), newcardonly=True)
            card_service = card_request.waitforcard()

            # connect to the card and perform a few transmits
            card_service.connection.connect()
            response, sw1, sw2 = card_service.connection.transmit(apdu)
            rfid_string = '_'.join([str(id_val) for id_val in response])

            keyboard = PyKeyboard()
            keyboard.type_string('<U>RFID_ID_'+rfid_string)
        except:
            continue
コード例 #51
0
ファイル: ChAP.py プロジェクト: AdamLaurie/RFIDIOt
PIN= ''
if args:
	if not args[0].isdigit():
		print 'Invalid PIN', args[0]
		sys.exit(True)
	else:
		PIN= args[0]

try:
	# request any card type
	cardtype = AnyCardType()
	# request card insertion
	print 'insert a card within 10s'
	cardrequest = CardRequest( timeout=10, cardType=cardtype )
	cardservice = cardrequest.waitforcard()

	# attach the console tracer
	if Debug:
		observer=ConsoleCardConnectionObserver()
    		cardservice.connection.addObserver( observer )

	# connect to the card
	cardservice.connection.connect(Protocol)

	#get_challenge(0)

	# try to select PSE
	apdu = SELECT + [len(DF_PSE)] + DF_PSE
	response, sw1, sw2 = send_apdu( apdu )
コード例 #52
0
ファイル: dumpd.py プロジェクト: djoproject/iso15693dumper
    def run(self):
        ### INIT GPS SUPPORT ### 
        if pysharegpsloaded:
            logging.info("gps support enabling...")
            gpsProxy = sharedGpsClient()
            if gpsProxy.isInit():
                logging.info("gps support enabled")
            else:
                logging.info("gps support not enabled. retry later.")
        else:
            logging.warning("gps support not installed")
            gpsProxy = None
        
        ### INIT SMARTCARD ###
        
        while True: #sometime, pcscd take time to start
            try:
                from smartcard.CardType import AnyCardType
                from smartcard.CardRequest import CardRequest
                from smartcard.scard import INFINITE
                from smartcard.Exceptions import CardConnectionException
                
                #card type
                cardtype = AnyCardType()

                #card request
                cardrequest = CardRequest(timeout=INFINITE, newcardonly=True,cardType=cardtype )
            
                break
            except Exception as ex:
                logging.exception("failed to load smartcard : "+str(ex))
                logging.shutdown()
                time.sleep(2)
                continue
        logging.info("smartcard loaded")
        
        ### DUMP PROCESS ###
        
        while True:
            logging.info("wait card")
            try:
                cardservice = cardrequest.waitforcard()
            except Exception as cte:
                logging.exception("wait card Exception : "+str(cte))
                time.sleep(2)
                continue
            
            logging.info("new card")
            currentDump = None
            fileName = None
            try:
                #init dump recording
                currentDump = dump() #and new dump object
                
                ## dump the tag ##
                try:
                    cardservice.connection.connect()#connect to the card
                    dumpSkipass(cardservice.connection, currentDump)             
                    cardservice.connection.disconnect()## disconnect dump
                except CardConnectionException as cce:
                    logging.exception("CardConnectionException : "+str(cce))
                except Exception as e:
                    logging.exception("save dump exception : "+str(e))
                
                ## recolt and process env info ##
                
                #build a first simple file name
                dtime = datetime.datetime.now()
                fileName = str(dtime).replace(" ","_").replace(":","_").replace(".","_")+".txt"

                currentDump.setCurrentDatetime()
                currentDump.setExtraInformation("DumpProcessLogId",self.localid)
                nextDumpID = getLogNextId(MAINREP)
                fileName = str(nextDumpID)+"_"+fileName
                currentDump.setExtraInformation("DumpFileId",nextDumpID)
                logging.info("DumpFileId : "+str(nextDumpID))
                
                ## UID management ##
                    #uid is the minimal information needed to save a dump, if it is not available, not saved
                        #a tag has always an uid, if it is not set, the connection had been broke before to read it
                
                uid = None
                if len(currentDump.getUID()) == 0:
                    logging.warning("empty uid")
                else:
                    # update path name
                    uid = currentDump.getUIDString().replace(" ","")
                    fileName = uid+"_"+fileName
                    
                    if uid in owners:
                        currentDump.setOwner(owners[uid])
                    else:
                        currentDump.setOwner("unknown")
                        logging.warning("uid not in the owner list")
                    
                    logging.info("dump uid: "+uid)
                    
                ## gps management ##
                if gpsProxy != None: #is there gps support ?
                    if gpsProxy.isInit():
                        position = gpsProxy.getSharedObject().getPosition()
                        print position
                        currentDump.setPosition(*position) 
                        print gpsProxy.getSharedObject().getAltitude()
                        currentDump.setAltitude(*gpsProxy.getSharedObject().getAltitude())
                        
                        place = gpsProxy.getSharedObject().getPlace()
                        if place[4] != None:
                            currentDump.setLocation(*place)
                        
                        currentDump.setExtraInformation("GpsLogId",gpsProxy.getSharedObject().getGpsLogId())
                        
                        if uid != None:
                            gpsProxy.getSharedObject().addPointOfInterest(position[0], position[1], uid, "dump of "+uid+" at "+dtime.isoformat()+" (file key ="+str(nextDumpID)+")")
                    else:
                        currentDump.setExtraInformation("gps","gps support does not work")
                        logging.warning("need to re init pyro")
                        gpsProxy.reInit()
                else:
                    currentDump.setExtraInformation("gps","gps support is not supported")
            except Exception as ex:
                logging.exception("dump exception : "+str(ex))
                
                if self.debug:
                    exit()
                time.sleep(2) 
                #wait two secs to allow the system to stabilyse if the environment is not ready
                #and also to prevent a log rush if the problem is still present at the next iteration
            finally: ## save the dump ##
                if currentDump == None or fileName == None:
                    logging.critical("Can't save the dump, currentDump or fileName is None")
                else:
                    try:
                        saveDump(currentDump, MAINREP+"dump_"+fileName)
                    except Exception as e:
                        logging.exception("save dump exception : "+str(e))
コード例 #53
0
ファイル: pbocreader.py プロジェクト: 0x554simon/pbocreader
    if ret == True:
        readafl()
    readcardinfo()
    readhist()
    printcardinfo()
    printtranshist()

'''    apdu = readrecord(0xC, 0x1)
    resp = transmit(apdu)
    gotresp(resp)

    apdu = selectcmd('a0  00  00  03  33  01  01  01')
    resp = transmit(apdu)
    print toHexString(apdu)
    gotresp(resp)

    apdu = gpo('600000000000000000000000000000000156000000000001561309250000000000')
    resp = transmit(apdu)
    gotresp(resp)
'''


cardtype = AnyCardType()
cardrequest = CardRequest( timeout=10, cardType=cardtype )
card = cardrequest.waitforcard()
card.connection.connect()

logic()
#transhist()

コード例 #54
0
 def __init__(self):
     cardtype = AnyCardType()
     cardrequest = CardRequest(timeout=1, cardType=cardtype)
     cardservice = cardrequest.waitforcard()
     self.connection = cardservice.connection
コード例 #55
0
ファイル: context.py プロジェクト: bartfrenk/pyscard-wrapper
 def __enter__(self):
     """Set up context with a connection to the card."""
     cr = CardRequest(timeout=self._timeout, cardType=self._card_type)
     self.cardservice = cr.waitforcard()
     self.cardservice.connection.connect()
     return self
コード例 #56
0
ファイル: pcsc.py プロジェクト: phonchi/chipwhisperer
class ReaderPCSC(ReaderTemplate):
    _name = "PC/SC Reader"

    def __init__(self):
        ReaderTemplate.__init__(self)

        self.timeoutTimer = timer.Timer()
        self.timeoutTimer.timeout.connect(self.timeoutFired)
        self.timeoutTimer.setInterval(2000)
        self.getParams().addChildren([
            {'name':'Keep-Alive Interval (off=0)', 'type':'int', 'value':2, 'set':self.setKeepalive}
        ])

    @setupSetParam("Keep-Alive Interval (off=0)")
    def setKeepalive(self, kinterval):
        self.timeoutTimer.setInterval(kinterval*1000)

    def timeoutFired(self):
        self.scserv.connection.connect()

    def sendAPDU(self, cla, ins, p1, p2, txdata=None, rxdatalen=0):
        """Send APDU to SmartCard, get Response"""

        data = [cla,ins, p1, p2]

        if txdata is not None:
            txdatalen = len(txdata)
            data.append(txdatalen)
        else:
            txdatalen = 0

        if (txdata is None) & (rxdatalen == 0):
            data.append(0)

        # Append payload
        if txdata is not None:
            for b in txdata: data.append(b)

        if rxdatalen != 0:
            data.append(rxdatalen)

        response, sw1, sw2 = self.scserv.connection.transmit(data , CardConnection.T0_protocol)

        status = (sw1 << 8) | sw2

        if rxdatalen > 0:
            return (status, response)

        return status

    def con(self, scope=None):
        """Connect to reader. scope parameter is OpenADC/ChipWhisperer hardware, only used to integrated readers"""
        try:
            self.sccard = AnyCardType()
            self.screq = CardRequest(timeout=1, cardType=self.sccard)
            self.scserv = self.screq.waitforcard()

            if not self.timeoutTimer.isActive():
                self.timeoutTimer.start()

            print "SCARD: Connected..."
        except Exception:
            raise Exception("SCARD: Failed to connect...")

    def flush(self):
        """Discard all input buffers"""
        pass

    def reset(self):
        """Reset card & save the ATR"""
        pass

    def getATR(self):
        """Get the ATR from the SmartCard. Reads a saved value, user reset() to actually reset card."""
        pass

    def dis(self):
        self.scserv.connection.disconnect()
        self.timeoutTimer.stop()
コード例 #57
0
ファイル: SmartCard.py プロジェクト: firebitsbr/chipwhisperer
class ReaderPCSC(ReaderTemplate):    

    def __init__(self, console=None, showScriptParameter=None):
        super(ReaderPCSC, self).__init__(console, showScriptParameter)
        
        if AnyCardType is None:
            raise ImportError("smartcard libraries missing")           

    def setupParameters(self):
        ssParams = [{'name':'Keep-Alive Interval (off=0)', 'type':'int', 'value':2, 'set':self.setKeepalive}                                                            
                    ]        
        self.params = Parameter.create(name='Target Connection', type='group', children=ssParams)
        ExtendedParameter.setupExtended(self.params, self)    
        
        
        self.timeoutTimer = QTimer()  
        self.timeoutTimer.timeout.connect(self.timeoutFired)
        self.timeoutTimer.setInterval(2000)

    def setKeepalive(self, kinterval):
        self.timeoutTimer.setInterval(kinterval*1000)
    
    def timeoutFired(self):
        self.scserv.connection.connect()       
    
    def sendAPDU(self, cla, ins, p1, p2, txdata=None, rxdatalen=0):
        """Send APDU to SmartCard, get Response"""       

        data = [cla,ins, p1, p2]
        
        if txdata is not None:
            txdatalen = len(txdata)
            data.append(txdatalen)
        else:
            txdatalen = 0
            
        if (txdata is None) & (rxdatalen == 0):
            data.append(0)
                
        #Append payload
        if txdata is not None:
            for b in txdata: data.append(b)
            
        if rxdatalen != 0:
            data.append(rxdatalen)
        
        response, sw1, sw2 = self.scserv.connection.transmit(data , CardConnection.T1_protocol)
            
        status = (sw1 << 8) | sw2;
        
        if rxdatalen > 0:
            return (status, response)
        
        return status
    
    def con(self, oa=None):
        """Connect to reader. oa parameter is OpenADC/ChipWhisperer hardware, only used to integrated readers"""
        try:
            self.sccard = AnyCardType()
            self.screq = CardRequest(timeout=1, cardType=self.sccard)
            self.scserv = self.screq.waitforcard()

            #observer = ConsoleCardConnectionObserver()
            #self.scserv.connection.addObserver( observer )           
            
            if not self.timeoutTimer.isActive():
                self.timeoutTimer.start()

        except CardRequestTimeoutException:
            return False

        return True        
    
    def flush(self):
        """Discard all input buffers"""
        pass
    
    def reset(self):
        """Reset card & save the ATR"""
        pass
    
    def getATR(self):
        """Get the ATR from the SmartCard. Reads a saved value, user reset() to actually reset card."""
        pass
    
    def dis(self):
        self.scserv.connection.disconnect()
        self.timeoutTimer.stop()