trunk/OpenPGPminidriver/SmartCard.c

/*      OpenPGP Smart Card Mini Driver
    Copyright (C) 2009 Vincent Le Toux

    This library is Free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License version 2.1 as published by the Free Software Foundation.

    This library 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 this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <windows.h>
#include <cardmod.h>
#include <stdio.h>
#include "Tracing.h"
#include "Context.h"
#include "SmartCard.h"

#pragma comment(lib,"Winscard")


DWORD SCardSendCommand(__in PCARD_DATA  pCardData, __in PBYTE pbCmd, __in DWORD dwCmdSize)
{
        DWORD             dwReturn = 0;

        SCARD_IO_REQUEST  ioSendPci = {1, sizeof(SCARD_IO_REQUEST)};
        SCARD_IO_REQUEST  ioRecvPci = {1, sizeof(SCARD_IO_REQUEST)};
        BYTE     recvbuf[256];
        DWORD     recvlen = sizeof(recvbuf);
        BYTE              SW1, SW2;
        __try
        {

                dwReturn = SCardTransmit(pCardData->hScard, 
                                                                        SCARD_PCI_T1, 
                                                                        pbCmd, 
                                                                        dwCmdSize, 
                                                                        NULL, 
                                                                        recvbuf, 
                                                                        &recvlen);
                if ( dwReturn != SCARD_S_SUCCESS )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"SCardTransmit errorcode: [0x%02X]", dwReturn);
                        __leave;
                }
                SW1 = recvbuf[recvlen-2];
                SW2 = recvbuf[recvlen-1];
                if ( ( SW1 == 0x90 ) && ( SW2 == 0x00 ) )
                {

                }
                else if ( (SW1 == 0x69) && (SW2 == 0x82) )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_WRONG_CHV");
                        dwReturn = SCARD_W_WRONG_CHV;
                        __leave;
                }
                else if ( (SW1 == 0x69) && (SW2 == 0x83) )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_CHV_BLOCKED");
                        dwReturn = SCARD_W_CHV_BLOCKED;
                        __leave;
                }
                else
                {
                        TraceDump(WINEVENT_LEVEL_ERROR, pbCmd,dwCmdSize);
                        Trace(WINEVENT_LEVEL_ERROR, L"SW1=0x%02X SW2=0x%02X", SW1, SW2);
                        dwReturn = SCARD_F_UNKNOWN_ERROR;
                        __leave;
                }
        }
        __finally
        {
        }
        return dwReturn;
}

DWORD SelectOpenPGPApplication(__in PCARD_DATA  pCardData)
{
        BYTE pbCmd[] = {0x00, 
                                    0xA4,
                                        0x04,
                                        0x00,
                                        0x06,
                                        0xD2, 0x76, 0x00, 0x01, 0x24, 0x01,
                                        0x00
                                        };
        
        return SCardSendCommand(pCardData, pbCmd, sizeof(pbCmd));
}


DWORD SCardGetData(__in PCARD_DATA  pCardData, 
                                        __in PBYTE pbCmd, __in DWORD dwCmdSize,
                                        __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)
{

        DWORD dwReturn;
        BYTE pbGetResponse[] = {0x00, 
                                    0xC0,
                                        0x00,
                                        0x00,
                                        0x00
                                        };
        DWORD dwGetResponseSize = ARRAYSIZE(pbGetResponse);
        BYTE                    recvbuf[0x800];
        DWORD                   recvlen = sizeof(recvbuf);
        BYTE            SW1, SW2;
        DWORD                   dwDataSize = 0;
        __try
        {

                *pbResponse = NULL;
                dwReturn = SCardTransmit(pCardData->hScard, 
                                                                        SCARD_PCI_T1, 
                                                                        pbCmd, 
                                                                        dwCmdSize, 
                                                                        NULL, 
                                                                        recvbuf, 
                                                                        &recvlen);
                
                do
                {
                        if ( dwReturn != SCARD_S_SUCCESS )
                        {
                                Trace(WINEVENT_LEVEL_ERROR, L"SCardTransmit errorcode: [0x%02X]", dwReturn);
                                __leave;
                        }
                        SW1 = recvbuf[recvlen-2];
                        SW2 = recvbuf[recvlen-1];
                        if ( ( SW1 == 0x90 ) && ( SW2 == 0x00 ) )
                        {
                                dwDataSize = recvlen-2;
                                *pbResponse = pCardData->pfnCspAlloc(dwDataSize);
                                memcpy(*pbResponse, recvbuf, dwDataSize);
                        }
                        else if (SW1 == 0x61)
                        {
                                dwDataSize += SW2;
                                if (*pbResponse)
                                {
                                        *pbResponse = pCardData->pfnCspReAlloc(*pbResponse, dwDataSize);
                                }
                                else
                                {
                                        *pbResponse = pCardData->pfnCspAlloc(dwDataSize);
                                }
                                dwGetResponseSize = ARRAYSIZE(pbGetResponse);
                                dwReturn = SCardTransmit(pCardData->hScard, 
                                                                        SCARD_PCI_T1, 
                                                                        pbGetResponse, 
                                                                        dwGetResponseSize, 
                                                                        NULL, 
                                                                        recvbuf, 
                                                                        &recvlen);
                        }
                        else if ( (SW1 == 0x69) && (SW2 == 0x82) )
                        {
                                Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_WRONG_CHV");
                                dwReturn = SCARD_W_WRONG_CHV;
                                __leave;
                        }
                        else if ( (SW1 == 0x69) && (SW2 == 0x83) )
                        {
                                Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_CHV_BLOCKED");
                                dwReturn = SCARD_W_CHV_BLOCKED;
                                __leave;
                        }
                        else if ( (SW1 == 0x6A) && (SW2 == 0x88) )
                        {
                                Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND");
                                dwReturn = SCARD_E_FILE_NOT_FOUND;
                                __leave;
                        }
                        else
                        {
                                TraceDump(WINEVENT_LEVEL_ERROR, pbCmd,dwCmdSize);
                                Trace(WINEVENT_LEVEL_ERROR, L"SW1=0x%02X SW2=0x%02X", SW1, SW2);
                                dwReturn = SCARD_F_UNKNOWN_ERROR;
                                __leave;
                        }

                } while (SW1 == 0x61);
                if (pdwResponseSize)
                {
                        *pdwResponseSize = dwDataSize;
                }
        }
        __finally
        {
        }
        return dwReturn;
}

DWORD CCIDfindFeature(BYTE featureTag, BYTE* features, DWORD featuresLength) 
{
    DWORD idx = 0;
    int count;
    while (idx < featuresLength) {
        BYTE tag = features[idx];
        idx++;
        idx++;
        if (featureTag == tag) {
            DWORD feature = 0;
            for (count = 0; count < 3; count++) {
                feature |= features[idx] & 0xff;
                idx++;
                feature <<= 8;
            }
            feature |= features[idx] & 0xff;
            return feature;
        }
        idx += 4;
    }
    return 0;
}

DWORD CCIDgetFeatures(__in PCARD_DATA  pCardData) 
{
        BYTE pbRecvBuffer[200];
        DWORD dwRecvLength, dwReturn;
        __try
        {
                POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;

                pContext->SmartCardReaderFeatures.VERIFY_PIN_START = 0;
                pContext->SmartCardReaderFeatures.VERIFY_PIN_FINISH = 0;
                pContext->SmartCardReaderFeatures.VERIFY_PIN_DIRECT = 0;
                pContext->SmartCardReaderFeatures.MODIFY_PIN_START = 0;
                pContext->SmartCardReaderFeatures.MODIFY_PIN_FINISH = 0;
                pContext->SmartCardReaderFeatures.MODIFY_PIN_DIRECT = 0;
                pContext->SmartCardReaderFeatures.GET_KEY_PRESSED = 0;
                pContext->SmartCardReaderFeatures.ABORT = 0;

                dwReturn = SCardControl(pCardData->hScard, 
                        SCARD_CTL_CODE(3400),
                        NULL,
                        0,
                        pbRecvBuffer,
                        sizeof(pbRecvBuffer),
                        &dwRecvLength);
                if ( dwReturn ) 
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"SCardControl errorcode: [0x%02X]", dwReturn);
                        __leave;
                }
                pContext->SmartCardReaderFeatures.VERIFY_PIN_START = CCIDfindFeature(FEATURE_VERIFY_PIN_START, pbRecvBuffer, dwRecvLength);
                pContext->SmartCardReaderFeatures.VERIFY_PIN_FINISH = CCIDfindFeature(FEATURE_VERIFY_PIN_FINISH, pbRecvBuffer, dwRecvLength);
                pContext->SmartCardReaderFeatures.VERIFY_PIN_DIRECT = CCIDfindFeature(FEATURE_VERIFY_PIN_DIRECT, pbRecvBuffer, dwRecvLength);
                pContext->SmartCardReaderFeatures.MODIFY_PIN_START = CCIDfindFeature(FEATURE_MODIFY_PIN_START, pbRecvBuffer, dwRecvLength);
                pContext->SmartCardReaderFeatures.MODIFY_PIN_FINISH = CCIDfindFeature(FEATURE_MODIFY_PIN_FINISH, pbRecvBuffer, dwRecvLength);
                pContext->SmartCardReaderFeatures.MODIFY_PIN_DIRECT = CCIDfindFeature(FEATURE_MODIFY_PIN_DIRECT, pbRecvBuffer, dwRecvLength);
                pContext->SmartCardReaderFeatures.GET_KEY_PRESSED = CCIDfindFeature(FEATURE_GET_KEY_PRESSED, pbRecvBuffer, dwRecvLength);
                pContext->SmartCardReaderFeatures.ABORT = CCIDfindFeature(FEATURE_ABORT, pbRecvBuffer, dwRecvLength);
        }
        __finally
        {
        }
   return dwReturn;
}
1	vletoux	1	/* OpenPGP Smart Card Mini Driver
2			Copyright (C) 2009 Vincent Le Toux
3
4			This library is Free software; you can redistribute it and/or
5			modify it under the terms of the GNU Lesser General Public
6			License version 2.1 as published by the Free Software Foundation.
7
8			This library is distributed in the hope that it will be useful,
9			but WITHOUT ANY WARRANTY; without even the implied warranty of
10			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11			Lesser General Public License for more details.
12
13			You should have received a copy of the GNU Lesser General Public
14			License along with this library; if not, write to the Free Software
15			Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16			*/
17
18			#include <windows.h>
19			#include <cardmod.h>
20			#include <stdio.h>
21			#include "Tracing.h"
22			#include "Context.h"
23			#include "SmartCard.h"
24
25			#pragma comment(lib,"Winscard")
26
27
28			DWORD SCardSendCommand(__in PCARD_DATA pCardData, __in PBYTE pbCmd, __in DWORD dwCmdSize)
29			{
30			DWORD dwReturn = 0;
31
32			SCARD_IO_REQUEST ioSendPci = {1, sizeof(SCARD_IO_REQUEST)};
33			SCARD_IO_REQUEST ioRecvPci = {1, sizeof(SCARD_IO_REQUEST)};
34			BYTE recvbuf[256];
35			DWORD recvlen = sizeof(recvbuf);
36			BYTE SW1, SW2;
37			__try
38			{
39
40			dwReturn = SCardTransmit(pCardData->hScard,
41			SCARD_PCI_T1,
42			pbCmd,
43			dwCmdSize,
44			NULL,
45			recvbuf,
46			&recvlen);
47			if ( dwReturn != SCARD_S_SUCCESS )
48			{
49			Trace(WINEVENT_LEVEL_ERROR, L"SCardTransmit errorcode: [0x%02X]", dwReturn);
50			__leave;
51			}
52			SW1 = recvbuf[recvlen-2];
53			SW2 = recvbuf[recvlen-1];
54			if ( ( SW1 == 0x90 ) && ( SW2 == 0x00 ) )
55			{
56
57			}
58			else if ( (SW1 == 0x69) && (SW2 == 0x82) )
59			{
60			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_WRONG_CHV");
61			dwReturn = SCARD_W_WRONG_CHV;
62			__leave;
63			}
64			else if ( (SW1 == 0x69) && (SW2 == 0x83) )
65			{
66			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_CHV_BLOCKED");
67			dwReturn = SCARD_W_CHV_BLOCKED;
68			__leave;
69			}
70			else
71			{
72			TraceDump(WINEVENT_LEVEL_ERROR, pbCmd,dwCmdSize);
73			Trace(WINEVENT_LEVEL_ERROR, L"SW1=0x%02X SW2=0x%02X", SW1, SW2);
74			dwReturn = SCARD_F_UNKNOWN_ERROR;
75			__leave;
76			}
77			}
78			__finally
79			{
80			}
81			return dwReturn;
82			}
83
84			DWORD SelectOpenPGPApplication(__in PCARD_DATA pCardData)
85			{
86			BYTE pbCmd[] = {0x00,
87			0xA4,
88			0x04,
89			0x00,
90			0x06,
91			0xD2, 0x76, 0x00, 0x01, 0x24, 0x01,
92			0x00
93			};
94
95			return SCardSendCommand(pCardData, pbCmd, sizeof(pbCmd));
96			}
97
98
99			DWORD SCardGetData(__in PCARD_DATA pCardData,
100			__in PBYTE pbCmd, __in DWORD dwCmdSize,
101			__in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)
102			{
103
104			DWORD dwReturn;
105			BYTE pbGetResponse[] = {0x00,
106			0xC0,
107			0x00,
108			0x00,
109			0x00
110			};
111			DWORD dwGetResponseSize = ARRAYSIZE(pbGetResponse);
112			BYTE recvbuf[0x800];
113			DWORD recvlen = sizeof(recvbuf);
114			BYTE SW1, SW2;
115			DWORD dwDataSize = 0;
116			__try
117			{
118
119			*pbResponse = NULL;
120			dwReturn = SCardTransmit(pCardData->hScard,
121			SCARD_PCI_T1,
122			pbCmd,
123			dwCmdSize,
124			NULL,
125			recvbuf,
126			&recvlen);
127
128			do
129			{
130			if ( dwReturn != SCARD_S_SUCCESS )
131			{
132			Trace(WINEVENT_LEVEL_ERROR, L"SCardTransmit errorcode: [0x%02X]", dwReturn);
133			__leave;
134			}
135			SW1 = recvbuf[recvlen-2];
136			SW2 = recvbuf[recvlen-1];
137			if ( ( SW1 == 0x90 ) && ( SW2 == 0x00 ) )
138			{
139			dwDataSize = recvlen-2;
140			*pbResponse = pCardData->pfnCspAlloc(dwDataSize);
141			memcpy(*pbResponse, recvbuf, dwDataSize);
142			}
143			else if (SW1 == 0x61)
144			{
145			dwDataSize += SW2;
146			if (*pbResponse)
147			{
148			pbResponse = pCardData->pfnCspReAlloc(pbResponse, dwDataSize);
149			}
150			else
151			{
152			*pbResponse = pCardData->pfnCspAlloc(dwDataSize);
153			}
154			dwGetResponseSize = ARRAYSIZE(pbGetResponse);
155			dwReturn = SCardTransmit(pCardData->hScard,
156			SCARD_PCI_T1,
157			pbGetResponse,
158			dwGetResponseSize,
159			NULL,
160			recvbuf,
161			&recvlen);
162			}
163			else if ( (SW1 == 0x69) && (SW2 == 0x82) )
164			{
165			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_WRONG_CHV");
166			dwReturn = SCARD_W_WRONG_CHV;
167			__leave;
168			}
169			else if ( (SW1 == 0x69) && (SW2 == 0x83) )
170			{
171			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_CHV_BLOCKED");
172			dwReturn = SCARD_W_CHV_BLOCKED;
173			__leave;
174			}
175			else if ( (SW1 == 0x6A) && (SW2 == 0x88) )
176			{
177			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND");
178			dwReturn = SCARD_E_FILE_NOT_FOUND;
179			__leave;
180			}
181			else
182			{
183			TraceDump(WINEVENT_LEVEL_ERROR, pbCmd,dwCmdSize);
184			Trace(WINEVENT_LEVEL_ERROR, L"SW1=0x%02X SW2=0x%02X", SW1, SW2);
185			dwReturn = SCARD_F_UNKNOWN_ERROR;
186			__leave;
187			}
188
189			} while (SW1 == 0x61);
190			if (pdwResponseSize)
191			{
192			*pdwResponseSize = dwDataSize;
193			}
194			}
195			__finally
196			{
197			}
198			return dwReturn;
199			}
200
201			DWORD CCIDfindFeature(BYTE featureTag, BYTE* features, DWORD featuresLength)
202			{
203			DWORD idx = 0;
204			int count;
205			while (idx < featuresLength) {
206			BYTE tag = features[idx];
207			idx++;
208			idx++;
209			if (featureTag == tag) {
210			DWORD feature = 0;
211			for (count = 0; count < 3; count++) {
212			feature \|= features[idx] & 0xff;
213			idx++;
214			feature <<= 8;
215			}
216			feature \|= features[idx] & 0xff;
217			return feature;
218			}
219			idx += 4;
220			}
221			return 0;
222			}
223
224			DWORD CCIDgetFeatures(__in PCARD_DATA pCardData)
225			{
226			BYTE pbRecvBuffer[200];
227			DWORD dwRecvLength, dwReturn;
228			__try
229			{
230			POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;
231
232			pContext->SmartCardReaderFeatures.VERIFY_PIN_START = 0;
233			pContext->SmartCardReaderFeatures.VERIFY_PIN_FINISH = 0;
234			pContext->SmartCardReaderFeatures.VERIFY_PIN_DIRECT = 0;
235			pContext->SmartCardReaderFeatures.MODIFY_PIN_START = 0;
236			pContext->SmartCardReaderFeatures.MODIFY_PIN_FINISH = 0;
237			pContext->SmartCardReaderFeatures.MODIFY_PIN_DIRECT = 0;
238			pContext->SmartCardReaderFeatures.GET_KEY_PRESSED = 0;
239			pContext->SmartCardReaderFeatures.ABORT = 0;
240
241			dwReturn = SCardControl(pCardData->hScard,
242			SCARD_CTL_CODE(3400),
243			NULL,
244			0,
245			pbRecvBuffer,
246			sizeof(pbRecvBuffer),
247			&dwRecvLength);
248			if ( dwReturn )
249			{
250			Trace(WINEVENT_LEVEL_ERROR, L"SCardControl errorcode: [0x%02X]", dwReturn);
251			__leave;
252			}
253			pContext->SmartCardReaderFeatures.VERIFY_PIN_START = CCIDfindFeature(FEATURE_VERIFY_PIN_START, pbRecvBuffer, dwRecvLength);
254			pContext->SmartCardReaderFeatures.VERIFY_PIN_FINISH = CCIDfindFeature(FEATURE_VERIFY_PIN_FINISH, pbRecvBuffer, dwRecvLength);
255			pContext->SmartCardReaderFeatures.VERIFY_PIN_DIRECT = CCIDfindFeature(FEATURE_VERIFY_PIN_DIRECT, pbRecvBuffer, dwRecvLength);
256			pContext->SmartCardReaderFeatures.MODIFY_PIN_START = CCIDfindFeature(FEATURE_MODIFY_PIN_START, pbRecvBuffer, dwRecvLength);
257			pContext->SmartCardReaderFeatures.MODIFY_PIN_FINISH = CCIDfindFeature(FEATURE_MODIFY_PIN_FINISH, pbRecvBuffer, dwRecvLength);
258			pContext->SmartCardReaderFeatures.MODIFY_PIN_DIRECT = CCIDfindFeature(FEATURE_MODIFY_PIN_DIRECT, pbRecvBuffer, dwRecvLength);
259			pContext->SmartCardReaderFeatures.GET_KEY_PRESSED = CCIDfindFeature(FEATURE_GET_KEY_PRESSED, pbRecvBuffer, dwRecvLength);
260			pContext->SmartCardReaderFeatures.ABORT = CCIDfindFeature(FEATURE_ABORT, pbRecvBuffer, dwRecvLength);
261			}
262			__finally
263			{
264			}
265			return dwReturn;
266			}