/**********************************************************************

*

* This file is part of Cardpeek, the smartcard reader utility.

*

* Copyright 2009-2013 by 'L1L1'

*

* Cardpeek is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* Cardpeek 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 General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with Cardpeek. If not, see <http://www.gnu.org/licenses/>.

*

*/

#include <winscard.h>

#include "pcsc_driver.h"

#include "log_util.h"

#ifdef _WIN32

/*

* On linux pioRecvPci is expected to point somewhere in the

* SCardTransmit() call but on windows, we must make it NULL.

* So here is an ugly trick.

*/

#define SCARD_PCI_NULL NULL

#elif defined(__APPLE__)

SCARD_IO_REQUEST pioRecvPci_dummy;

#define SCARD_PCI_NULL (&pioRecvPci_dummy)

#include <wintypes.h>

#define SCARD_ATTR_MAXINPUT 0x7A007

#else /* Linux et al. */

SCARD_IO_REQUEST pioRecvPci_dummy;

#define SCARD_PCI_NULL (&pioRecvPci_dummy)

#include <reader.h>

#endif

/* #ifndef _WIN32

* #ifndef __APPLE__

* #include <reader.h>

* #endif

* SCARD_IO_REQUEST pioRecvPci_dummy;

* #define SCARD_PCI_NULL (&pioRecvPci_dummy)

* #else

* *

* On linux pioRecvPci is expected to point somewhere in the

* SCardTransmit() call but on windows, we must make it NULL.

* So here is an ugly trick.

*

* #define SCARD_PCI_NULL NULL

* #endif

* #ifdef __APPLE__

* #include <wintypes.h>

* #define SCARD_ATTR_MAXINPUT 0x7A007

* #endif

*/

#define MAX_PCSC_READ_LENGTH 270

typedef struct

{

LONG hcontext;

SCARDHANDLE hcard;

DWORD protocol;

LONG status;

} pcsc_data_t;

static const char *pcsc_stringify_protocol(DWORD proto)

{

static char proto_string[32];

switch (proto)

{

case SCARD_PROTOCOL_T0:

return "T=0";

case SCARD_PROTOCOL_T1:

return "T=1";

case SCARD_PROTOCOL_RAW:

return "Raw";

}

sprintf(proto_string,"UNKNOWN(0x%x)",(unsigned)proto);

return proto_string;

}

static const char *pcsc_stringify_state(DWORD state)

{

static char state_string[500];

int state_string_len;

*state_string = 0;

if (state & SCARD_STATE_CHANGED)

strcat(state_string," Changed state,");

if (state & SCARD_STATE_IGNORE)

strcat(state_string," Ignore reader,");

if (state & SCARD_STATE_UNKNOWN)

strcat(state_string," Unknown reader,");

if (state & SCARD_STATE_UNAVAILABLE)

strcat(state_string," Status unavailable,");

if (state & SCARD_STATE_EMPTY)

strcat(state_string," Card removed,");

if (state & SCARD_STATE_PRESENT)

strcat(state_string," Card present,");

if (state & SCARD_STATE_EXCLUSIVE)

strcat(state_string," Exclusive access,");

if (state & SCARD_STATE_INUSE)

strcat(state_string," Shared access,");

if (state & SCARD_STATE_MUTE)

strcat(state_string," Silent card,");

state_string_len=strlen(state_string);

if (state_string[state_string_len-1]==',')

state_string[state_string_len-1]=0;

else

strcat(state_string,"UNDEFINED");

return state_string;

}

static int pcsc_connect(cardreader_t *cr, unsigned prefered_protocol)

{

DWORD attr_maxinput = 0;

DWORD attr_maxinput_len = sizeof(unsigned int);

SCARD_READERSTATE reader_state;

pcsc_data_t* pcsc = cr->extra_data;

int counter = 0;

void *progress;

memset(&reader_state,0,sizeof(reader_state));

reader_state.szReader = cr->name+7;

reader_state.dwCurrentState = SCARD_STATE_UNAWARE;

pcsc->status = SCardGetStatusChange(pcsc->hcontext,INFINITE,&reader_state,1);

if (pcsc->status != SCARD_S_SUCCESS)

{

log_printf(LOG_ERROR,"Failed to query reader status before connecting: %s (error 0x%08x).",

pcsc_stringify_error(pcsc->status),

pcsc->status );

return 0;

}

progress = ui_inprogress_new("Connection","Waiting for the reader to connect to a card.");

while ((reader_state.dwEventState & SCARD_STATE_PRESENT)==0)

{

reader_state.dwCurrentState = reader_state.dwEventState;

if (((counter++)%30)==0)

{

log_printf(LOG_INFO,"Waiting for card to be present (current state: %s)...",

pcsc_stringify_state(reader_state.dwEventState));

}

if (!ui_inprogress_pulse(progress))

{

log_printf(LOG_ERROR,"Connection aborted by user");

ui_inprogress_free(progress);

pcsc->status = 0x6FFF;

return 0;

}

pcsc->status = SCardGetStatusChange(pcsc->hcontext,100,&reader_state,1);

if ((pcsc->status!=(LONG)SCARD_S_SUCCESS) && (pcsc->status!=(LONG)SCARD_E_TIMEOUT))

{

log_printf(LOG_ERROR,"Failed to query reader status change before connecting: %s (error 0x%08x/%08x).",

pcsc_stringify_error(pcsc->status),

pcsc->status,

SCARD_E_TIMEOUT );

return 0;

}

}

ui_inprogress_free(progress);

log_printf(LOG_DEBUG,"Attempting to connect to '%s'",cr->name);

pcsc->status = SCardConnect(pcsc->hcontext,

cr->name+7,

/* SCARD_SHARE_EXCLUSIVE, */

SCARD_SHARE_SHARED,

prefered_protocol,

&(pcsc->hcard),

&(cr->protocol));

if (pcsc->status!=SCARD_S_SUCCESS)

{

log_printf(LOG_ERROR,"Connection failed: %s (error 0x%08x).",

pcsc_stringify_error(pcsc->status),

pcsc->status );

return 0;

}

if (SCardGetAttrib(pcsc->hcard,SCARD_ATTR_MAXINPUT,(LPBYTE)&attr_maxinput,(LPDWORD)&attr_maxinput_len)==SCARD_S_SUCCESS)

log_printf(LOG_INFO,"Reader maximum input length is %u bytes",attr_maxinput);

else

log_printf(LOG_DEBUG,"Could not determinate reader maximum input length");

log_printf(LOG_INFO,"Connection successful, protocol is %s",pcsc_stringify_protocol(cr->protocol));

cr->connected=1;

return 1;

}

static int pcsc_disconnect(cardreader_t *cr)

{

pcsc_data_t* pcsc = cr->extra_data;

pcsc->status = SCardDisconnect(pcsc->hcard,SCARD_UNPOWER_CARD);

if (pcsc->status==SCARD_S_SUCCESS)

{

cr->connected=0;

log_printf(LOG_INFO,"Disconnected reader");

return 1;

}

log_printf(LOG_ERROR,"Failed to disconnect reader: %s (error 0x%08x).",

pcsc_stringify_error(pcsc->status),

pcsc->status );

return 0;

}

static int pcsc_reset(cardreader_t *cr)

{

pcsc_data_t* pcsc = cr->extra_data;

pcsc->status = SCardReconnect(pcsc->hcard,

SCARD_SHARE_SHARED,

/* SCARD_SHARE_EXCLUSIVE, */

cr->protocol,

SCARD_RESET_CARD,

&(cr->protocol));

#ifdef __APPLE__

pcsc->status = SCardReconnect(pcsc->hcard,

SCARD_SHARE_SHARED,

/* SCARD_SHARE_EXCLUSIVE, */

cr->protocol,

SCARD_LEAVE_CARD,

&(cr->protocol));

#endif

if (pcsc->status==SCARD_S_SUCCESS)

{

log_printf(LOG_INFO,"Reconnected reader");

cr->connected=1;

return 1;

}

log_printf(LOG_ERROR,"Failed to reconnect reader: %s (error 0x%08x).",

pcsc_stringify_error(pcsc->status),

pcsc->status );

cr->connected=0;

return 0;

}

static unsigned short pcsc_transmit(cardreader_t* cr,

const bytestring_t* command,

bytestring_t* result)

{

pcsc_data_t* pcsc = cr->extra_data;

BYTE REC_DAT[MAX_PCSC_READ_LENGTH];

DWORD REC_LEN=MAX_PCSC_READ_LENGTH;

unsigned short SW;

if (cr->protocol==SCARD_PROTOCOL_T0)

{

pcsc->status = SCardTransmit(pcsc->hcard,SCARD_PCI_T0,

bytestring_get_data(command),

bytestring_get_size(command),

SCARD_PCI_NULL,

REC_DAT,&REC_LEN);

}

else if (cr->protocol==SCARD_PROTOCOL_T1)

{

pcsc->status = SCardTransmit(pcsc->hcard,SCARD_PCI_T1,

bytestring_get_data(command),

bytestring_get_size(command),

SCARD_PCI_NULL,

REC_DAT,&REC_LEN);

}

else

{

log_printf(LOG_ERROR,"Unknown smartcard protocol: %i",cr->protocol);

return CARDPEEK_ERROR_SW;

}

if (pcsc->status!=SCARD_S_SUCCESS)

{

log_printf(LOG_ERROR,"Failed to transmit command to card: %s (error 0x%08x).",

pcsc_stringify_error(pcsc->status),

pcsc->status );

return CARDPEEK_ERROR_SW;

}

if (REC_LEN>=2)

{

bytestring_assign_data(result,REC_LEN-2,REC_DAT);

SW = (REC_DAT[REC_LEN-2]<<8)|REC_DAT[REC_LEN-1];

}

else if (REC_LEN==1)

{

bytestring_clear(result);

SW = REC_DAT[0];

}

else

{

log_printf(LOG_ERROR,"Transmited %i bytes to the card (%s), but recieved a response of length %i, without any status word included.",

bytestring_get_size(command),

pcsc_stringify_protocol(cr->protocol),

REC_LEN);

return CARDPEEK_ERROR_SW;

}

return SW;

}

static const bytestring_t* pcsc_last_atr(cardreader_t* cr)

{

pcsc_data_t* pcsc = cr->extra_data;

DWORD state;

DWORD protocol;

BYTE pbAtr[MAX_ATR_SIZE];

DWORD atrlen=MAX_ATR_SIZE;

char readername[MAX_READERNAME];

DWORD readernamelen=MAX_READERNAME;

/*char *tmp;*/

pcsc->status = SCardStatus(pcsc->hcard,

readername,&readernamelen,

&state,

&protocol,

pbAtr,&atrlen);

if (pcsc->status==SCARD_S_SUCCESS)

{

bytestring_assign_data(cr->atr,atrlen,pbAtr);

/*tmp = bytestring_to_format("%D",cr->atr);

log_printf(LOG_INFO,"ATR is %i bytes: %s",atrlen,tmp);

free(tmp);*/

}

else

{

bytestring_clear(cr->atr);

log_printf(LOG_ERROR,"Failed to query card status: %s (error 0x%08x).",

pcsc_stringify_error(pcsc->status),

pcsc->status );

}

return cr->atr;

}

#define NUM_INFO_FIELDS 3

static char **pcsc_get_info(cardreader_t* cr)

{

pcsc_data_t* pcsc = cr->extra_data;

DWORD state = 0;

DWORD protocol;

BYTE pbAtr[MAX_ATR_SIZE];

DWORD atrlen=MAX_ATR_SIZE;

char readername[MAX_READERNAME];

DWORD readernamelen=MAX_READERNAME;

char num_buf[20];

char **info;

pcsc->status = SCardStatus(pcsc->hcard,

readername,&readernamelen,

&state,

&protocol,

pbAtr,&atrlen);

if (pcsc->status!=SCARD_S_SUCCESS)

{

cr->connected = 0;

info = g_malloc(3 * sizeof(char *));

info[0]=g_strdup("pcsc_status");

sprintf(num_buf,"%u",(unsigned)(pcsc->status));

info[1]=g_strdup(num_buf);

info[2]=NULL;

return info;

}

info = g_malloc((NUM_INFO_FIELDS*2+1)*sizeof(char *));

info[0]=g_strdup("state");

sprintf(num_buf,"%u",(unsigned)(state));

info[1]=g_strdup(num_buf);

bytestring_assign_data(cr->atr,atrlen,pbAtr);

info[2]=g_strdup("atr");

info[3]=bytestring_to_format("%D",cr->atr);

info[4]=g_strdup("pcsc_status");

sprintf(num_buf,"%u",(unsigned)(pcsc->status));

info[5]=g_strdup(num_buf);

info[NUM_INFO_FIELDS*2]=NULL;

return info;

}

static int pcsc_fail(cardreader_t* cr)

{

pcsc_data_t* pcsc = cr->extra_data;

return (pcsc->status!=SCARD_S_SUCCESS);

}

static void pcsc_finalize(cardreader_t* cr)

{

pcsc_data_t* pcsc = cr->extra_data;

SCardReleaseContext(pcsc->hcontext);

free(pcsc);

}

static int pcsc_initialize(cardreader_t *reader)

{

pcsc_data_t* pcsc = malloc(sizeof(pcsc_data_t));

memset(pcsc,0,sizeof(pcsc_data_t));

pcsc->status = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL,

&(pcsc->hcontext));

if (pcsc->status!=SCARD_S_SUCCESS)

{

log_printf(LOG_ERROR,"Failed to establish PCSC card manager context: %s (error 0x%08x).",

pcsc_stringify_error(pcsc->status),

pcsc->status );

return 0;

}

reader->extra_data = pcsc;

reader->connect = pcsc_connect;

reader->disconnect = pcsc_disconnect;

reader->reset = pcsc_reset;

reader->transmit = pcsc_transmit;

reader->last_atr = pcsc_last_atr;

reader->get_info = pcsc_get_info;

reader->fail = pcsc_fail;

reader->finalize = pcsc_finalize;

return 1;

}