able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/smartcrd/smclib/smcprot.c

1820 lines
52 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (C) Microsoft Corporation, 1996 - 1999
Module Name:
smcprot.c
Author:
Klaus U. Schutz
Environment:
Kernel mode only.
Revision History:
- Dec. 96: Initial version
- Nov. 97: Release 1.0
- Feb. 98: T=1 uses now the min of IFSC, IFSD for SmartcardT1Request
T=1 fixed number of bytes to invert for inverse convention cards
--*/
#ifdef SMCLIB_VXD
#define try
#define leave goto __label
#define finally __label:
#else
#ifndef SMCLIB_CE
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <ntddk.h>
#endif // SMCLIB_CE
#endif
#include "smclib.h"
#define SMARTCARD_POOL_TAG 'bLCS'
#ifdef DEBUG_INTERFACE
BOOLEAN
DebugT1Reply(
PSMARTCARD_EXTENSION SmartcardExtension
);
void
DebugGetT1Request(
PSMARTCARD_EXTENSION SmartcardExtension,
NTSTATUS Status
);
BOOLEAN
DebugSetT1Request(
PSMARTCARD_EXTENSION SmartcardExtension
);
#endif // DEBUG_INTERFACE
void
DumpData(
const ULONG DebugLevel,
PUCHAR Data,
ULONG DataLen
);
//
// Usually an io-request consists only of the SCARD_IO_REQUEST header
// followed by the data to be transmitted. To allow modification of
// protocol data, it is possible to pass down the data to be modified.
// These data are ASN1 encoded.
//
typedef struct _IO_HEADER {
SCARD_IO_REQUEST ScardIoRequest;
UCHAR Asn1Data[1];
} IO_HEADER, *PIO_HEADER;
NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardRawRequest(
#else
SmartcardRawRequest(
#endif
PSMARTCARD_EXTENSION SmartcardExtension
)
/*++
Routine Description:
Arguments:
Return Value:
-
--*/
{
PSMARTCARD_REQUEST smartcardRequest = &(SmartcardExtension->SmartcardRequest);
if (smartcardRequest->BufferLength +
SmartcardExtension->IoRequest.RequestBufferLength >=
smartcardRequest->BufferSize) {
return STATUS_BUFFER_TOO_SMALL;
}
//
// Copy request data to the buffer
//
RtlCopyMemory(
&smartcardRequest->Buffer[smartcardRequest->BufferLength],
SmartcardExtension->IoRequest.RequestBuffer,
SmartcardExtension->IoRequest.RequestBufferLength
);
//
// If the card uses invers convention invert the data
//
if (SmartcardExtension->CardCapabilities.InversConvention) {
SmartcardInvertData(
&smartcardRequest->Buffer[smartcardRequest->BufferLength],
SmartcardExtension->IoRequest.RequestBufferLength
);
}
//
// number of bytes to send to the reader
//
smartcardRequest->BufferLength +=
SmartcardExtension->IoRequest.RequestBufferLength;
return STATUS_SUCCESS;
}
NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardRawReply(
#else
SmartcardRawReply(
#endif
PSMARTCARD_EXTENSION SmartcardExtension
)
/*++
Routine Description:
Arguments:
Return Value:
-
--*/
{
if (SmartcardExtension->IoRequest.ReplyBufferLength <
SmartcardExtension->SmartcardReply.BufferLength) {
return STATUS_BUFFER_TOO_SMALL;
}
//
// Copy data to user buffer
//
RtlCopyMemory(
SmartcardExtension->IoRequest.ReplyBuffer,
SmartcardExtension->SmartcardReply.Buffer,
SmartcardExtension->SmartcardReply.BufferLength
);
//
// Length of data to return
//
*SmartcardExtension->IoRequest.Information =
SmartcardExtension->SmartcardReply.BufferLength;
return STATUS_SUCCESS;
}
NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardT0Request(
#else
SmartcardT0Request(
#endif
PSMARTCARD_EXTENSION SmartcardExtension
)
/*++
Routine Description:
Prepares the buffer SmartcardExtension->SmartcardRequest.Buffer
to send data to the smart card
Arguments:
NOTE: On input SmartcardExtension->SmartcardRequest.BufferLenght indicates
the offset where we should copy the data to. This is usually
used by readers that needs to have some bytes as header bytes
to send to the reader before the data bytes for the card
Return Value:
-
--*/
{
PSMARTCARD_REQUEST smartcardRequest = &SmartcardExtension->SmartcardRequest;
PSCARD_IO_REQUEST scardIoRequest;
PUCHAR ioRequestData;
ULONG ioRequestDataLength, headerSize;
if (smartcardRequest->BufferLength +
SmartcardExtension->IoRequest.RequestBufferLength >=
smartcardRequest->BufferSize) {
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT0Request: IoRequest.RequestBuffer too big\n"),
DRIVER_NAME)
);
return STATUS_BUFFER_OVERFLOW;
}
scardIoRequest = (PSCARD_IO_REQUEST)
SmartcardExtension->IoRequest.RequestBuffer;
ioRequestData =
SmartcardExtension->IoRequest.RequestBuffer +
sizeof(SCARD_IO_REQUEST);
ioRequestDataLength =
SmartcardExtension->IoRequest.RequestBufferLength -
sizeof(SCARD_IO_REQUEST);
//
// Copy T=0 protocol-info into buffer
//
RtlCopyMemory(
&smartcardRequest->Buffer[smartcardRequest->BufferLength],
ioRequestData,
ioRequestDataLength
);
//
// Remember number of bytes for the header offset
//
headerSize =
smartcardRequest->BufferLength;
//
// Number of bytes to send to the reader
//
smartcardRequest->BufferLength +=
ioRequestDataLength;
if (ioRequestDataLength < 4) {
//
// A T=0 request needs at least 4 bytes
//
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT0Request: TPDU is too short (%d). Must be at least 4 bytes\n"),
DRIVER_NAME,
ioRequestDataLength)
);
return STATUS_INVALID_PARAMETER;
} else {
PUCHAR requestBuffer = SmartcardExtension->SmartcardRequest.Buffer;
if (ioRequestDataLength <= 5) {
//
// We request to read data from the card
//
SmartcardExtension->T0.Lc = 0;
if (ioRequestDataLength == 4) {
//
// This is a special case where a 4 byte APDU is mapped to
// a 5 byte TPDU (ISO 7816 - Part 4, Annex A, A.1 Case 1)
// This case requires that we append a 0 to the
// APDU to make it a TPDU
//
SmartcardExtension->T0.Le = 0;
smartcardRequest->Buffer[headerSize + 4] = 0;
smartcardRequest->BufferLength += 1;
} else {
SmartcardExtension->T0.Le =
(requestBuffer[headerSize + 4] ? requestBuffer[headerSize + 4] : 256);
}
} else {
//
// We want to send data to the card
//
SmartcardExtension->T0.Lc = requestBuffer[headerSize + 4];
SmartcardExtension->T0.Le = 0;
if (SmartcardExtension->T0.Lc != ioRequestDataLength - 5) {
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT0Request: Lc(%d) in TPDU doesn't match number of bytes to send(%d).\n"),
DRIVER_NAME,
SmartcardExtension->T0.Lc,
ioRequestDataLength - 5)
);
return STATUS_INVALID_PARAMETER;
}
}
#if DEBUG
{
PUCHAR T0Data = requestBuffer + headerSize;
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT(" CLA: %02X\n INS: %02X\n P1: %02X\n P2: %02X\n Lc: %02X\n Le: %02X\n"),
T0Data[0], T0Data[1], T0Data[2], T0Data[3],
SmartcardExtension->T0.Lc,
SmartcardExtension->T0.Le)
);
if (SmartcardExtension->T0.Lc) {
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT(" Data: ")),
);
DumpData(
DEBUG_PROTOCOL,
T0Data + 5,
SmartcardExtension->T0.Lc
);
}
}
#endif
//
// If the card uses invers convention invert the data
//
if (SmartcardExtension->CardCapabilities.InversConvention) {
SmartcardInvertData(
&smartcardRequest->Buffer[headerSize],
smartcardRequest->BufferLength - headerSize
);
}
return STATUS_SUCCESS;
#ifdef APDU_SUPPORT
ULONG requestLength = SmartcardExtension->SmartcardRequest.BufferLength;
ULONG L;
//
// Figure out Lc and Le
// (See 'Decoding of the command APDUs' in ISO Part 4, 5.3.2)
// (Variable names used are according to ISO designations)
//
L = requestLength - 4;
if (L > 65536) {
return STATUS_INVALID_PARAMETER;
}
if (L == 0) {
//
// Lc = 0, No Data, Le = 0;
//
SmartcardExtension->T0.Lc = 0;
SmartcardExtension->T0.Le = 0;
} else if (L == 1) {
//
// Case 2S, Lc = 0, Le = B1
//
SmartcardExtension->T0.Lc = 0;
SmartcardExtension->T0.Le = requestBuffer[4];
} else {
UCHAR B1 = requestBuffer[4];
if (B1 != 0) {
//
// Short form
//
if (L == (ULONG) (1 + B1)) {
//
// Case 3S, Lc = B1, Le = 0
//
SmartcardExtension->T0.Lc = B1;
SmartcardExtension->T0.Le = 0;
} else {
//
// Case 4S, Lc = B1, Le = BL
//
SmartcardExtension->T0.Lc = B1;
SmartcardExtension->T0.Le = requestBuffer[L - 1];
}
} else {
//
// Extended form
//
if (L == 3) {
//
// Case 2E, Lc = 0, Le = B(L - 1, L)
//
LENGTH length;
length.l.l0 = 0;
length.b.b0 = requestBuffer[L - 1];
length.b.b1 = requestBuffer[L - 2];
SmartcardExtension->T0.Lc = 0;
SmartcardExtension->T0.Le = (length.l.l0 ? length.l.l0 : 65536);
} else {
LENGTH length;
length.l.l0 = 0;
length.b.b0 = requestBuffer[6];
length.b.b1 = requestBuffer[5];
SmartcardExtension->T0.Lc = length.l.l0;
if (L == 3 + length.l.l0) {
//
// Case 3E, Lc = B(2,3)
//
SmartcardExtension->T0.Le = 0;
} else {
//
// Case 4E, Lc = B(2,3), Le = B(L - 1, L)
//
LENGTH length;
length.l.l0 = 0;
length.b.b0 = requestBuffer[L - 1];
length.b.b1 = requestBuffer[L - 2];
SmartcardExtension->T0.Le = (length.l.l0 ? length.l.l0 : 65536);
}
}
}
}
#endif
}
return STATUS_SUCCESS;
}
NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardT0Reply(
#else
SmartcardT0Reply(
#endif
PSMARTCARD_EXTENSION SmartcardExtension
)
/*++
Routine Description:
Arguments:
Return Value:
-
--*/
{
PSMARTCARD_REPLY smartcardReply = &SmartcardExtension->SmartcardReply;
//
// The reply must be at least to 2 bytes long. These 2 bytes are
// the return value (StatusWord) from the smart card
//
if (smartcardReply->BufferLength < 2) {
return STATUS_DEVICE_PROTOCOL_ERROR;
}
if (SmartcardExtension->IoRequest.ReplyBufferLength <
smartcardReply->BufferLength + sizeof(SCARD_IO_REQUEST)) {
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT0Request: ReplyBuffer too small\n"),
DRIVER_NAME)
);
return STATUS_BUFFER_TOO_SMALL;
}
// Copy protocol header to user buffer
RtlCopyMemory(
SmartcardExtension->IoRequest.ReplyBuffer,
SmartcardExtension->IoRequest.RequestBuffer,
sizeof(SCARD_IO_REQUEST)
);
// If the card uses invers convention invert the data
if (SmartcardExtension->CardCapabilities.InversConvention) {
SmartcardInvertData(
smartcardReply->Buffer,
smartcardReply->BufferLength
);
}
// Copy all data to user buffer
RtlCopyMemory(
SmartcardExtension->IoRequest.ReplyBuffer + sizeof(SCARD_IO_REQUEST),
smartcardReply->Buffer,
smartcardReply->BufferLength
);
// Length of answer
*SmartcardExtension->IoRequest.Information =
smartcardReply->BufferLength +
sizeof(SCARD_IO_REQUEST);
return STATUS_SUCCESS;
}
BOOLEAN
SmartcardT1Chksum(
PUCHAR Block,
UCHAR Edc,
BOOLEAN Verify
)
/*++
Routine Description:
This routine calculates the epilogue field for a T1 block. It calculates the LRC
for all the data in the IBlock.
Arguments:
Block - T1 Information block, to be sent, or just read, from the card.
Edc - ErrorDetectionCode as described in ISO
Verify - If this is a block that was recieved form the card, TRUE will cause this routine
to check the epilogue field, included with this buffer, against the calculated one
Return Value:
TRUE if Verify = TRUE and epilogue fields match or Verify = FALSE
FALSE if Verify = TRUE and an error was detected (mismatch)
--*/
{
USHORT i;
UCHAR lrc;
USHORT crc = 0;
USHORT offset = Block[2] + SCARD_T1_PROLOGUE_LENGTH;
unsigned short crc16a[] = {
0000000, 0140301, 0140601, 0000500,
0141401, 0001700, 0001200, 0141101,
0143001, 0003300, 0003600, 0143501,
0002400, 0142701, 0142201, 0002100,
};
unsigned short crc16b[] = {
0000000, 0146001, 0154001, 0012000,
0170001, 0036000, 0024000, 0162001,
0120001, 0066000, 0074000, 0132001,
0050000, 0116001, 0104001, 0043000,
};
if (Edc & T1_CRC_CHECK) {
UCHAR tmp;
// Calculate CRC using tables.
for ( i = 0; i < offset; i++) {
tmp = Block[i] ^ (UCHAR) crc;
crc = (crc >> 8) ^ crc16a[tmp & 0x0f] ^ crc16b[tmp >> 4];
}
if (Verify) {
if (crc == (Block[offset + 1] | (Block[offset] << 8))) {
return TRUE;
} else {
return FALSE;
}
} else {
Block[offset] = (UCHAR) (crc >> 8 ); //MSB of crc
Block[offset + 1] = (UCHAR) (crc & 0x00ff); //LSB of crc
return TRUE;
}
} else {
// Calculate LRC by X-Oring all the bytes.
lrc = Block[0];
for(i = 1; i < offset; i++){
lrc ^= Block[i];
}
if (Verify) {
return (lrc == Block[offset] ? TRUE : FALSE);
} else {
Block[offset] = lrc;
return TRUE;
}
}
return TRUE;
}
#if (DEBUG)
static
void
DumpT1Block(
PUCHAR Buffer,
UCHAR Edc
)
{
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT(" NAD: %02X\n PCB: %02X\n LEN: %02X\n INF: "),
Buffer[0], Buffer[1], Buffer[2])
);
if (Buffer[2] == 0) {
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("- "))
);
}
DumpData(
DEBUG_PROTOCOL,
Buffer + 3,
Buffer[2]
);
if (Edc & T1_CRC_CHECK) {
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("\n CRC: %02X %02X"),
Buffer[Buffer[2] + 3],
Buffer[Buffer[2] + 4])
);
} else {
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("\n LRC: %02X"),
Buffer[Buffer[2] + 3])
);
}
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("\n"))
);
}
#endif
#if DEBUG
#pragma optimize( "", off )
#endif
NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardT1Request(
#else
SmartcardT1Request(
#endif
PSMARTCARD_EXTENSION SmartcardExtension
)
/*++
Routine Description:
Arguments:
SmartcardExtension - Supplies a pointer to the smart card data
Return Value:
--*/
{
PSMARTCARD_REQUEST smartcardRequest = &(SmartcardExtension->SmartcardRequest);
PIO_HEADER IoHeader = (PIO_HEADER) SmartcardExtension->IoRequest.RequestBuffer;
T1_BLOCK_FRAME t1SendFrame;
NTSTATUS status = STATUS_SUCCESS;
#if (DEBUG)
ULONG headerSize = smartcardRequest->BufferLength;
#endif
#ifdef DEBUG_INTERFACE
if (DebugSetT1Request(SmartcardExtension)) {
//
// the debugger gave us a new packet that we have to
// send instead of the original packet which will be sent later
//
return STATUS_SUCCESS;
}
#endif
if (SmartcardExtension->T1.WaitForReply) {
// we did not get an answer to our last request
SmartcardExtension->T1.State = T1_INIT;
}
SmartcardExtension->T1.WaitForReply = TRUE;
__try {
switch (SmartcardExtension->T1.State) {
case T1_INIT:
SmartcardExtension->T1.State = T1_IFS_REQUEST;
// NO break here !!!
case T1_START:
//
// Since this is the very first block in a
// transmission we reset the resynch counter
//
SmartcardExtension->T1.Resynch = 0;
//
// Allocate a buffer that receives the result.
// This is necessary since we otherwise overwite our
// request data which we might wish to resend in case
// of an error
//
if (SmartcardExtension->T1.ReplyData != NULL) {
#ifdef SMCLIB_VXD
_HeapFree(SmartcardExtension->T1.ReplyData, 0);
#elif defined(SMCLIB_CE)
LocalFree(SmartcardExtension->T1.ReplyData);
#else
ExFreePool(SmartcardExtension->T1.ReplyData);
#endif
SmartcardExtension->T1.ReplyData = NULL;
}
if (SmartcardExtension->IoRequest.ReplyBufferLength <
IoHeader->ScardIoRequest.cbPciLength + 2) {
//
// We should at least be able to store
// the io-header plus SW1 and SW2
//
status = STATUS_BUFFER_TOO_SMALL;
__leave;
}
#ifdef SMCLIB_VXD
SmartcardExtension->T1.ReplyData = (PUCHAR) _HeapAllocate(
SmartcardExtension->IoRequest.ReplyBufferLength,
0
);
#elif defined(SMCLIB_CE)
SmartcardExtension->T1.ReplyData = (PUCHAR) LocalAlloc(LPTR,
SmartcardExtension->IoRequest.ReplyBufferLength
);
#else
SmartcardExtension->T1.ReplyData = ExAllocatePool(
NonPagedPool,
SmartcardExtension->IoRequest.ReplyBufferLength
);
#endif
ASSERT(SmartcardExtension->T1.ReplyData != NULL);
if (SmartcardExtension->T1.ReplyData == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
__leave;
}
// No break here !!!
case T1_RESTART:
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Request: T1_%s\n"),
DRIVER_NAME,
(SmartcardExtension->T1.State == T1_START ? TEXT("START") : TEXT("RESTART")))
);
// Copy protocol header back to user buffer
RtlCopyMemory(
SmartcardExtension->T1.ReplyData,
SmartcardExtension->IoRequest.RequestBuffer,
IoHeader->ScardIoRequest.cbPciLength
);
//
// Check for the special case where the io-header is followed
// by asn1 data that contains the NAD value to be used.
// This was done for VISA, because they need access to the NAD.
// The NAD is ASN1 encoded as 81h 00h NAD 00h
//
if (IoHeader->ScardIoRequest.cbPciLength > sizeof(SCARD_IO_REQUEST) &&
IoHeader->Asn1Data[0] == 0x81 &&
IoHeader->Asn1Data[1] == 0x01 &&
IoHeader->Asn1Data[3] == 0x00) {
SmartcardExtension->T1.NAD = IoHeader->Asn1Data[2];
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Request: NAD set to %02xh\n"),
DRIVER_NAME,
SmartcardExtension->T1.NAD)
);
}
// Initialize the T1 protocol data
SmartcardExtension->T1.BytesToSend =
SmartcardExtension->IoRequest.RequestBufferLength -
IoHeader->ScardIoRequest.cbPciLength;
SmartcardExtension->T1.BytesSent = 0;
SmartcardExtension->T1.BytesReceived = 0;
//
// This is the maximum number of bytes that the smartcard can
// accept in a single block. The smartcard can extend this size
// during the transmission
//
SmartcardExtension->T1.IFSC =
SmartcardExtension->CardCapabilities.T1.IFSC;
//
// Since this is the first block in a transmission we reset
// the re-transmission counter.
//
SmartcardExtension->T1.Resend = 0;
SmartcardExtension->T1.OriginalState = 0;
SmartcardExtension->T1.MoreData = FALSE;
//
// NO break here !!!
//
// After a card reset we first send an IFS-Request to the card.
// Otherwise we start with an I-Block
//
case T1_IFS_REQUEST:
if (SmartcardExtension->T1.State == T1_IFS_REQUEST) {
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Request: T1_IFSD_REQUEST\n"),
DRIVER_NAME)
);
SmartcardExtension->T1.State =
T1_IFS_REQUEST;
t1SendFrame.Nad = SmartcardExtension->T1.NAD;
//
// IFS request.
// Send our IFSD size to the card
//
t1SendFrame.Pcb = 0xC1;
t1SendFrame.Len = 1;
t1SendFrame.Inf = &SmartcardExtension->T1.IFSD;
break;
} else {
SmartcardExtension->T1.State = T1_I_BLOCK;
}
// No break here !!
case T1_I_BLOCK:
SmartcardExtension->T1.State = T1_I_BLOCK;
//
// Set the number of bytes we will transmit to the card.
// This is the lesser of IFSD and IFSC
//
SmartcardExtension->T1.InfBytesSent = SmartcardExtension->T1.IFSC;
if (SmartcardExtension->T1.InfBytesSent > SmartcardExtension->T1.IFSD) {
SmartcardExtension->T1.InfBytesSent = SmartcardExtension->T1.IFSD;
}
// Send either max frame size or remaining bytes
if (SmartcardExtension->T1.BytesToSend > SmartcardExtension->T1.InfBytesSent) {
SmartcardExtension->T1.MoreData = TRUE;
t1SendFrame.Len = SmartcardExtension->T1.InfBytesSent;
} else {
SmartcardExtension->T1.MoreData = FALSE;
t1SendFrame.Len = (UCHAR) SmartcardExtension->T1.BytesToSend;
}
t1SendFrame.Nad = SmartcardExtension->T1.NAD;
//
// ProtocolControlByte:
// b7 - SendSequenceNumber
// b6 - MoreDatatBit
//
t1SendFrame.Pcb =
(SmartcardExtension->T1.SSN) << 6 |
(SmartcardExtension->T1.MoreData ? T1_MORE_DATA : 0);
t1SendFrame.Inf =
SmartcardExtension->IoRequest.RequestBuffer +
IoHeader->ScardIoRequest.cbPciLength +
SmartcardExtension->T1.BytesSent;
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Request: I(%d.%d) ->\n"),
DRIVER_NAME,
SmartcardExtension->T1.SSN,
(SmartcardExtension->T1.MoreData ? 1 : 0))
);
break;
case T1_R_BLOCK:
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Request: R(%d) ->\n"),
DRIVER_NAME,
SmartcardExtension->T1.RSN)
);
t1SendFrame.Nad = SmartcardExtension->T1.NAD;
//
// ProtocolControlByte:
// b5 - SequenceNumber
// b1-4 - ErrorCode
//
t1SendFrame.Pcb =
0x80 |
(SmartcardExtension->T1.RSN) << 4 |
(SmartcardExtension->T1.LastError);
//
// If this R-Block is a response to an error
// we have to restore to the original state we had before
//
if (SmartcardExtension->T1.LastError) {
SmartcardExtension->T1.LastError = 0;
//
// We must have a defined original state here
//
ASSERT(SmartcardExtension->T1.OriginalState != 0);
if (SmartcardExtension->T1.OriginalState == 0) {
SmartcardExtension->T1.State = T1_START;
status = STATUS_INTERNAL_ERROR;
__leave;
}
SmartcardExtension->T1.State =
SmartcardExtension->T1.OriginalState;
}
t1SendFrame.Len = 0;
t1SendFrame.Inf = NULL;
break;
case T1_IFS_RESPONSE:
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Request: T1_IFSD_RESPONSE\n"),
DRIVER_NAME)
);
// Restore to the original state we had before
ASSERT(SmartcardExtension->T1.OriginalState != 0);
SmartcardExtension->T1.State =
SmartcardExtension->T1.OriginalState;
t1SendFrame.Nad = SmartcardExtension->T1.NAD;
// Send IFS response
t1SendFrame.Pcb = 0xE1;
t1SendFrame.Len = 1;
// New length of INF-Field
t1SendFrame.Inf = &SmartcardExtension->T1.IFSC;
break;
case T1_RESYNCH_REQUEST:
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Request: T1_RESYNCH_REQUEST\n"),
DRIVER_NAME)
);
t1SendFrame.Nad = SmartcardExtension->T1.NAD;
// Resynch request
t1SendFrame.Pcb = 0xC0;
t1SendFrame.Len = 0;
t1SendFrame.Inf = NULL;
// Set the send sequence number to 0
SmartcardExtension->T1.SSN = 0;
break;
case T1_ABORT_REQUEST:
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Request: T1_ABORT_REQUEST\n"),
DRIVER_NAME)
);
t1SendFrame.Nad = SmartcardExtension->T1.NAD;
// Send ABORT request
t1SendFrame.Pcb = 0xC2;
t1SendFrame.Len = 0;
t1SendFrame.Inf = NULL;
break;
case T1_ABORT_RESPONSE:
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Request: T1_ABORT_RESPONSE\n"),
DRIVER_NAME)
);
SmartcardExtension->T1.State = T1_START;
t1SendFrame.Nad = SmartcardExtension->T1.NAD;
// Send ABORT response
t1SendFrame.Pcb = 0xE2;
t1SendFrame.Len = 0;
t1SendFrame.Inf = NULL;
break;
case T1_WTX_RESPONSE:
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Request: T1_WTX_RESPONSE\n"),
DRIVER_NAME)
);
// Restore to the original state we had before
ASSERT(SmartcardExtension->T1.OriginalState != 0);
SmartcardExtension->T1.State =
SmartcardExtension->T1.OriginalState;
SmartcardExtension->T1.OriginalState = 0;
t1SendFrame.Nad = SmartcardExtension->T1.NAD;
// Send WTX response
t1SendFrame.Pcb = 0xE3;
t1SendFrame.Len = 1;
t1SendFrame.Inf = &SmartcardExtension->T1.Wtx;
break;
}
// Insert Node Address byte
smartcardRequest->Buffer[smartcardRequest->BufferLength] =
t1SendFrame.Nad;
// Insert ProtocolControlByte
smartcardRequest->Buffer[smartcardRequest->BufferLength + 1] =
t1SendFrame.Pcb;
// Length of INF field
smartcardRequest->Buffer[smartcardRequest->BufferLength + 2] =
t1SendFrame.Len;
// Insert INF field data
if (t1SendFrame.Len > 0) {
RtlCopyMemory(
&smartcardRequest->Buffer[smartcardRequest->BufferLength + 3],
t1SendFrame.Inf,
t1SendFrame.Len
);
}
// Compute checksum
SmartcardT1Chksum(
&smartcardRequest->Buffer[smartcardRequest->BufferLength],
SmartcardExtension->CardCapabilities.T1.EDC,
FALSE
);
#if defined(DEBUG)
#if defined(SMCLIB_NT)
if (SmartcardGetDebugLevel() & DEBUG_T1_TEST) {
LARGE_INTEGER Ticks;
UCHAR RandomVal;
KeQueryTickCount(&Ticks);
RandomVal = (UCHAR) Ticks.LowPart % 4;
if (RandomVal == 0) {
smartcardRequest->Buffer[smartcardRequest->BufferLength - 1] += 1;
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT1Request: Simulating bad checksum\n"),
DRIVER_NAME)
);
}
}
#endif
DumpT1Block(
smartcardRequest->Buffer + headerSize,
SmartcardExtension->CardCapabilities.T1.EDC
);
#endif
//
// If the card uses invers convention invert the data
// NOTE: do not invert any header data the reader may use
//
if (SmartcardExtension->CardCapabilities.InversConvention) {
SmartcardInvertData(
&smartcardRequest->Buffer[smartcardRequest->BufferLength],
(SmartcardExtension->CardCapabilities.T1.EDC & T1_CRC_CHECK ? 5 : 4) +
t1SendFrame.Len
);
}
//
// Update the number of bytes that are in the buffer
// A T1 block is at least 4 bytes long with LRC check and 5 bytes with CRC check
//
smartcardRequest->BufferLength +=
(SmartcardExtension->CardCapabilities.T1.EDC & T1_CRC_CHECK ? 5 : 4) +
t1SendFrame.Len;
}
__finally {
#ifdef DEBUG_INTERFACE
DebugGetT1Request(SmartcardExtension, status);
#endif
}
return status;
}
NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardT1Reply(
#else
SmartcardT1Reply(
#endif
PSMARTCARD_EXTENSION SmartcardExtension
)
/*++
Routine Description:
Arguments:
DeviceObject - Supplies a pointer to the device object for this request.
Return Value:
--*/
{
T1_BLOCK_FRAME t1RecFrame;
NTSTATUS status = STATUS_MORE_PROCESSING_REQUIRED;
PIO_HEADER IoHeader = (PIO_HEADER) SmartcardExtension->T1.ReplyData;
BOOLEAN packetOk = TRUE, chksumOk = TRUE;
ASSERT(IoHeader != NULL);
if (IoHeader == NULL) {
return STATUS_INTERNAL_ERROR;
}
#ifdef DEBUG_INTERFACE
if (DebugT1Reply(SmartcardExtension)) {
// the debugger processed this packet which means
// that we should not parse it.
return STATUS_MORE_PROCESSING_REQUIRED;
}
#endif
// signal that we received an answer
SmartcardExtension->T1.WaitForReply = FALSE;
// Invert the data of an inverse convention card
if (SmartcardExtension->CardCapabilities.InversConvention) {
SmartcardInvertData(
SmartcardExtension->SmartcardReply.Buffer,
SmartcardExtension->SmartcardReply.BufferLength
);
}
// Clear waiting time extension
SmartcardExtension->T1.Wtx = 0;
try {
ULONG expectedLength =
SCARD_T1_PROLOGUE_LENGTH +
SmartcardExtension->SmartcardReply.Buffer[2] +
(SmartcardExtension->CardCapabilities.T1.EDC & T1_CRC_CHECK ? 2 : 1);
if (SmartcardExtension->SmartcardReply.BufferLength < 4 ||
SmartcardExtension->SmartcardReply.BufferLength != expectedLength) {
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT1Reply: Packet length incorrect\n"),
DRIVER_NAME)
);
packetOk = FALSE;
} else {
// calculate the checksum
chksumOk = SmartcardT1Chksum(
SmartcardExtension->SmartcardReply.Buffer,
SmartcardExtension->CardCapabilities.T1.EDC,
TRUE
);
#if DEBUG
#ifndef SMCLIB_VXD
if (SmartcardGetDebugLevel() & DEBUG_T1_TEST) {
// inject some checksum errors
LARGE_INTEGER Ticks;
UCHAR RandomVal;
KeQueryTickCount(&Ticks);
RandomVal = (UCHAR) Ticks.LowPart % 4;
if (RandomVal == 0) {
chksumOk = FALSE;
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT1Reply: Simulating bad checksum\n"),
DRIVER_NAME)
);
}
}
#endif
#endif
}
if (chksumOk == FALSE) {
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT1Reply: Bad checksum\n"),
DRIVER_NAME)
);
}
if (packetOk == FALSE || chksumOk == FALSE) {
SmartcardExtension->T1.LastError =
(chksumOk ? T1_ERROR_OTHER : T1_ERROR_CHKSUM);
if (SmartcardExtension->T1.OriginalState == 0) {
SmartcardExtension->T1.OriginalState =
SmartcardExtension->T1.State;
}
if (SmartcardExtension->T1.Resend++ == T1_MAX_RETRIES) {
SmartcardExtension->T1.Resend = 0;
// Try to resynchronize since the resend requests have failed
SmartcardExtension->T1.State = T1_RESYNCH_REQUEST;
__leave;
}
// If the last request was a resynch we try again to resynch
if (SmartcardExtension->T1.State != T1_RESYNCH_REQUEST) {
// Chksum not OK; request resend of last block
SmartcardExtension->T1.State = T1_R_BLOCK;
}
__leave;
}
//
// The checksum of the packet is ok.
// Now check the rest of the packet
//
// Clear the last error
SmartcardExtension->T1.LastError = 0;
t1RecFrame.Nad = SmartcardExtension->SmartcardReply.Buffer[0];
t1RecFrame.Pcb = SmartcardExtension->SmartcardReply.Buffer[1];
t1RecFrame.Len = SmartcardExtension->SmartcardReply.Buffer[2];
t1RecFrame.Inf = &SmartcardExtension->SmartcardReply.Buffer[3];
//
// If the last block we sent was a ifs request,
// we expect the card to reply with an ifs response.
//
if (SmartcardExtension->T1.State == T1_IFS_REQUEST) {
// Check if the card properly responded to an ifs request
if (t1RecFrame.Pcb == T1_IFS_RESPONSE) {
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Reply: T1_IFSC_RESPONSE\n"),
DRIVER_NAME)
);
// The smart card acked our ifsd size
SmartcardExtension->T1.State = T1_I_BLOCK;
__leave;
}
if ((t1RecFrame.Pcb & 0x82) == 0x82) {
//
// The card does not support ifs request, so we stop
// sending this and continue with a data block
// (the card is NOT ISO conform)
//
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT1Reply: Card does not support IFS REQUEST\n"),
DRIVER_NAME)
);
SmartcardExtension->T1.State = T1_I_BLOCK;
__leave;
}
//
// The card replied with junk to our ifs request.
// It doesn't make sense to continue.
//
status = STATUS_DEVICE_PROTOCOL_ERROR;
__leave;
}
//
// If the last block was a resync. request,
// we expect the card to answer with a resynch response.
//
if (SmartcardExtension->T1.State == T1_RESYNCH_REQUEST) {
// Check if the card properly responded to an resynch request
if (t1RecFrame.Pcb != T1_RESYNCH_RESPONSE) {
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT1Reply: Card response is not ISO conform! Aborting...\n"),
DRIVER_NAME)
);
status = STATUS_DEVICE_PROTOCOL_ERROR;
__leave;
}
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Reply: T1_RESYNCH_RESPONSE\n"),
DRIVER_NAME)
);
// Reset error counter
SmartcardExtension->T1.Resend = 0;
// The smart card has successfully responded to a resynch request
SmartcardExtension->T1.RSN = 0;
SmartcardExtension->T1.SSN = 0;
//
// Do a complete restart of the whole transmission
// but without resetting the resynch counter
//
SmartcardExtension->T1.State = T1_RESTART;
__leave;
}
//
// Now check for other protocol states...
//
//
// Copy NAD value back to user buffer if this is an extended io-header
// containing the nad
//
if (IoHeader->ScardIoRequest.cbPciLength > sizeof(SCARD_IO_REQUEST) &&
IoHeader->Asn1Data[0] == 0x81 &&
IoHeader->Asn1Data[1] == 0x01 &&
IoHeader->Asn1Data[3] == 0x00) {
IoHeader->Asn1Data[2] = t1RecFrame.Nad;
}
if ((t1RecFrame.Pcb & 0x80) == 0) {
// This is an I-block
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Reply: I(%d.%d) <-\n"),
DRIVER_NAME,
(t1RecFrame.Pcb & 0x40) >> 6,
(t1RecFrame.Pcb & 0x20) >> 5)
);
if (((t1RecFrame.Pcb & 0x40) >> 6) == SmartcardExtension->T1.RSN) {
// I-Block with correct sequence number
PUCHAR data;
ULONG minBufferSize;
// Reset error counter and error indicator
SmartcardExtension->T1.Resend = 0;
SmartcardExtension->T1.OriginalState = 0;
// We can 'increase' the number of correctly received I-Blocks
SmartcardExtension->T1.RSN ^= 1;
if (SmartcardExtension->T1.State == T1_I_BLOCK) {
// This I-Block is also an acknowledge for the I-Block we sent
SmartcardExtension->T1.SSN ^= 1;
}
// Check size of user buffer
minBufferSize =
IoHeader->ScardIoRequest.cbPciLength +
SmartcardExtension->T1.BytesReceived +
t1RecFrame.Len;
if (SmartcardExtension->IoRequest.ReplyBufferLength < minBufferSize) {
status = STATUS_BUFFER_TOO_SMALL;
__leave;
}
ASSERT(SmartcardExtension->T1.ReplyData);
//
// Let data pointer point behind struct.
// All reply data will be stored there.
//
data =
SmartcardExtension->T1.ReplyData +
IoHeader->ScardIoRequest.cbPciLength +
SmartcardExtension->T1.BytesReceived;
// Copy data to user buffer
RtlCopyMemory(
data,
t1RecFrame.Inf,
t1RecFrame.Len
);
SmartcardExtension->T1.BytesReceived += t1RecFrame.Len;
if (t1RecFrame.Pcb & T1_MORE_DATA) {
// Ack this block and request the next block
SmartcardExtension->T1.State = T1_R_BLOCK;
} else {
//
// This was the last block of the transmission
// Set number of bytes returned by this transmission
//
*SmartcardExtension->IoRequest.Information =
IoHeader->ScardIoRequest.cbPciLength +
SmartcardExtension->T1.BytesReceived;
// Copy the result back to the user buffer
ASSERT(SmartcardExtension->IoRequest.ReplyBuffer != NULL);
RtlCopyMemory(
SmartcardExtension->IoRequest.ReplyBuffer,
SmartcardExtension->T1.ReplyData,
IoHeader->ScardIoRequest.cbPciLength +
SmartcardExtension->T1.BytesReceived
);
status = STATUS_SUCCESS;
}
__leave;
}
//
// I-Block with wrong sequence number
// We try T1_MAX_RETRIES times to resend the last block.
// If this is unsuccessfull, we try to resynch.
// If resynch is unsuccessfull we abort the transmission.
//
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT1Reply: Block number incorrect\n"),
DRIVER_NAME)
);
SmartcardExtension->T1.LastError = T1_ERROR_OTHER;
if (SmartcardExtension->T1.OriginalState == 0) {
SmartcardExtension->T1.OriginalState =
SmartcardExtension->T1.State;
}
if (SmartcardExtension->T1.Resend++ == T1_MAX_RETRIES) {
SmartcardExtension->T1.Resend = 0;
// Try to resynchronize
SmartcardExtension->T1.State = T1_RESYNCH_REQUEST;
__leave;
}
// request the block again.
SmartcardExtension->T1.State = T1_R_BLOCK;
__leave;
}
if ((t1RecFrame.Pcb & 0xC0) == 0x80) {
// This is an R-block
UCHAR RSN = (t1RecFrame.Pcb & 0x10) >> 4;
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Reply: R(%d) <-\n"),
DRIVER_NAME,
RSN)
);
if (RSN != SmartcardExtension->T1.SSN &&
SmartcardExtension->T1.MoreData) {
// The ICC has acked the last block
SmartcardExtension->T1.Resend = 0;
SmartcardExtension->T1.BytesSent += SmartcardExtension->T1.InfBytesSent;
SmartcardExtension->T1.BytesToSend -= SmartcardExtension->T1.InfBytesSent;
SmartcardExtension->T1.SSN ^= 1;
SmartcardExtension->T1.State = T1_I_BLOCK;
__leave;
}
//
// We have an error condition...
//
ASSERT(t1RecFrame.Pcb & 0x0f);
if ((t1RecFrame.Pcb & 0x02) &&
SmartcardExtension->T1.State == T1_IFS_REQUEST) {
//
// The card does not support ifs request, so
// we stop sending this and continue with a data block
// (the card is NOT ISO conform)
//
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT1Reply: Card does not support IFS REQUEST\n"),
DRIVER_NAME)
);
SmartcardExtension->T1.State = T1_I_BLOCK;
__leave;
}
// We have to resend the last block
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT1Reply: Card reports error\n"),
DRIVER_NAME)
);
if (SmartcardExtension->T1.Resend++ == T1_MAX_RETRIES) {
SmartcardExtension->T1.Resend = 0;
if (SmartcardExtension->T1.OriginalState == 0) {
// Save current state
SmartcardExtension->T1.OriginalState =
SmartcardExtension->T1.State;
}
// Try to resynchronize
SmartcardExtension->T1.State = T1_RESYNCH_REQUEST;
}
__leave;
}
//
// This is an S-block
//
switch (t1RecFrame.Pcb) {
case T1_IFS_REQUEST:
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Reply: T1_IFSC_REQUEST\n"),
DRIVER_NAME)
);
// The smart card wants to exend the IFS - size
SmartcardExtension->T1.IFSC =
SmartcardExtension->SmartcardReply.Buffer[3];
// Save current state
ASSERT(SmartcardExtension->T1.OriginalState == 0);
SmartcardExtension->T1.OriginalState =
SmartcardExtension->T1.State;
SmartcardExtension->T1.State = T1_IFS_RESPONSE;
break;
case T1_ABORT_REQUEST:
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Reply: T1_ABORT_REQUEST\n"),
DRIVER_NAME)
);
SmartcardExtension->T1.State = T1_ABORT_RESPONSE;
break;
case T1_WTX_REQUEST:
SmartcardDebug(
DEBUG_PROTOCOL,
(TEXT("%s!SmartcardT1Reply: T1_WTX_REQUEST\n"),
DRIVER_NAME)
);
// Smart card needs longer wait time
SmartcardExtension->T1.Wtx =
SmartcardExtension->SmartcardReply.Buffer[3];
// Save current state
ASSERT(SmartcardExtension->T1.OriginalState == 0 ||
SmartcardExtension->T1.OriginalState == T1_WTX_RESPONSE);
SmartcardExtension->T1.OriginalState =
SmartcardExtension->T1.State;
SmartcardExtension->T1.State = T1_WTX_RESPONSE;
break;
case T1_VPP_ERROR:
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT1Reply: T1_VPP_ERROR\n"),
DRIVER_NAME)
);
status = STATUS_DEVICE_POWER_FAILURE;
break;
default:
ASSERTMSG(
TEXT("SmartcardT1Reply: Invalid Pcb "),
FALSE
);
status = STATUS_DEVICE_PROTOCOL_ERROR;
break;
}
}
finally {
#if DEBUG
if (packetOk && chksumOk) {
DumpT1Block(
SmartcardExtension->SmartcardReply.Buffer,
SmartcardExtension->CardCapabilities.T1.EDC
);
}
#endif
if (SmartcardExtension->T1.State == T1_RESYNCH_REQUEST &&
SmartcardExtension->T1.Resynch++ == T1_MAX_RETRIES) {
SmartcardDebug(
DEBUG_ERROR,
(TEXT("%s!SmartcardT1Reply: Too many errors! Aborting...\n"),
DRIVER_NAME)
);
status = STATUS_DEVICE_PROTOCOL_ERROR;
}
if (status != STATUS_MORE_PROCESSING_REQUIRED) {
if (SmartcardExtension->T1.OriginalState == T1_IFS_REQUEST) {
SmartcardExtension->T1.State = T1_IFS_REQUEST;
} else {
SmartcardExtension->T1.State = T1_START;
}
if (SmartcardExtension->T1.ReplyData) {
// free the reply data buffer
#ifdef SMCLIB_VXD
_HeapFree(SmartcardExtension->T1.ReplyData, 0);
#elif defined(SMCLIB_CE)
LocalFree(SmartcardExtension->T1.ReplyData);
#else
ExFreePool(SmartcardExtension->T1.ReplyData);
#endif
SmartcardExtension->T1.ReplyData = NULL;
}
SmartcardExtension->T1.OriginalState = 0;
SmartcardExtension->T1.NAD = 0;
}
}
return status;
}
#if DEBUG
#pragma optimize( "", on )
#endif
Reference in a new issue Copy permalink