This file is indexed.

/usr/share/pyshared/smartcard/pcsc/PCSCReader.py is in python-pyscard 1.6.12.1-4.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
"""PCSCReader: concrete reader class for PCSC Readers

__author__ = "gemalto http://www.gemalto.com"

Copyright 2001-2012 gemalto
Author: Jean-Daniel Aussel, mailto:jean-daniel.aussel@gemalto.com

This file is part of pyscard.

pyscard is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

pyscard is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with pyscard; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
"""

from smartcard.CardConnectionDecorator import CardConnectionDecorator
from smartcard.reader.Reader import Reader
from smartcard.pcsc.PCSCContext import PCSCContext
from smartcard.pcsc.PCSCCardConnection import PCSCCardConnection
from smartcard.Exceptions import *
from smartcard.pcsc.PCSCExceptions import *
from smartcard.scard import *


def __PCSCreaders__(hcontext, groups=[]):
    """Returns the list of PCSC smartcard readers in PCSC group.

    If group is not specified, returns the list of all PCSC smartcard readers.
    """

    # in case we have a string instead of a list
    if isinstance(groups, type("")):
        groups = [groups]
    hresult, readers = SCardListReaders(hcontext, groups)
    if hresult != 0:
        if hresult == SCARD_E_NO_READERS_AVAILABLE:
            readers = []
        else:
            raise ListReadersException(hresult)

    return readers


class PCSCReader(Reader):
    """PCSC reader class."""

    def __init__(self, readername):
        """Constructs a new PCSC reader."""
        Reader.__init__(self, readername)

    def addtoreadergroup(self, groupname):
        """Add reader to a reader group."""

        hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
        if 0 != hresult:
            raise EstablishContextException(hresult)
        try:
            hresult = SCardIntroduceReader(hcontext, self.name, self.name)
            if 0 != hresult and SCARD_E_DUPLICATE_READER != hresult:
                raise IntroduceReaderException(hresult, self.name)
            hresult = SCardAddReaderToGroup(hcontext, self.name, groupname)
            if 0 != hresult:
                raise AddReaderToGroupException(hresult, self.name, groupname)
        finally:
            hresult = SCardReleaseContext(hcontext)
            if 0 != hresult:
                raise ReleaseContextException(hresult)

    def removefromreadergroup(self, groupname):
        """Remove a reader from a reader group"""

        hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
        if 0 != hresult:
            raise EstablishContextException(hresult)
        try:
            hresult = SCardRemoveReaderFromGroup(hcontext, self.name,
                groupname)
            if 0 != hresult:
                raise RemoveReaderFromGroupException(hresult, self.name,
                    groupname)
        finally:
            hresult = SCardReleaseContext(hcontext)
            if 0 != hresult:
                raise ReleaseContextException(hresult)

    def createConnection(self):
        """Return a card connection thru PCSC reader."""
        return CardConnectionDecorator(PCSCCardConnection(self.name))

    class Factory:

        def create(readername):
            return PCSCReader(readername)
        create = staticmethod(create)

    def readers(groups=[]):
        creaders = []
        hcontext = PCSCContext().getContext()

        for reader in __PCSCreaders__(hcontext, groups):
            creaders.append(PCSCReader.Factory.create(reader))
        return creaders
    readers = staticmethod(readers)

if __name__ == '__main__':
    from smartcard.util import *
    SELECT = [0xA0, 0xA4, 0x00, 0x00, 0x02]
    DF_TELECOM = [0x7F, 0x10]

    creaders = PCSCReader.readers()
    for reader in creaders:
        try:
            print reader.name
            connection = reader.createConnection()
            connection.connect()
            print toHexString(connection.getATR())
            data, sw1, sw2 = connection.transmit(SELECT + DF_TELECOM)
            print "%X %X" % (sw1, sw2)
        except NoCardException, x:
            print 'no card in reader'