/[openpgpmdrv]/trunk/OpenPGPminidriver/PublicDataOperations.c
ViewVC logotype

Diff of /trunk/OpenPGPminidriver/PublicDataOperations.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1 by vletoux, Tue Feb 23 19:18:59 2010 UTC revision 12 by vletoux, Wed Mar 31 08:58:46 2010 UTC
# Line 23  Line 23 
23  #include "SmartCard.h"  #include "SmartCard.h"
24  #include "PublicDataOperations.h"  #include "PublicDataOperations.h"
25  #include "CryptoOperations.h"  #include "CryptoOperations.h"
26    #include "tlv.h"
27    
28  typedef enum _OPENPGP_FILE_TYPE  typedef enum _OPENPGP_FILE_TYPE
29  {  {
# Line 30  typedef enum _OPENPGP_FILE_TYPE Line 31  typedef enum _OPENPGP_FILE_TYPE
31          Virtual,          Virtual,
32  } OPENPGP_FILE_TYPE;  } OPENPGP_FILE_TYPE;
33    
34    #define OPENPGP_FILE_OPTIONAL 1
35    #define OPENPGP_FILE_WRITE_ONLY 2
36    #define OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING 4
37    #define OPENPGP_FILE_CONF_IS_AUTH 8
38    
39  typedef struct _OPENPGP_FILE  typedef struct _OPENPGP_FILE
40  {  {
41          PCHAR szDirectory;          PCHAR szDirectory;
42          PCHAR szFile;          PCHAR szFile;
43          OPENPGP_FILE_TYPE dwFileType;          OPENPGP_FILE_TYPE dwFileType;
44          BYTE  bP1;          DWORD dwTag;
45          BYTE  bP2;          DWORD dwTlv;
46          CARD_FILE_ACCESS_CONDITION dwAccess;          CARD_FILE_ACCESS_CONDITION dwAccess;
47            DWORD dwFlag;
48  } OPENPGP_FILE, *POPENPGP_FILE;  } OPENPGP_FILE, *POPENPGP_FILE;
49    
50    
# Line 45  typedef struct _OPENPGP_FILE Line 52  typedef struct _OPENPGP_FILE
52    
53  OPENPGP_FILE Files[] =  OPENPGP_FILE Files[] =
54  {  {
55          {szOpenPGPDir, szOpenPGPFingerprint, StoredOnSmartCard, 0x00, 0xC5, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPFingerprint, StoredOnSmartCard, 0x6E, 0xC5, EveryoneReadAdminWriteAc},
56          {szOpenPGPDir, szOpenPGPStatus, StoredOnSmartCard, 0x00, 0xC4, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPStatus, StoredOnSmartCard, 0xC4, 0, EveryoneReadAdminWriteAc},
57          {szOpenPGPDir, szOpenPGPApplicationIdentifier, StoredOnSmartCard, 0x00, 0x4F, UnknownAc},          {szOpenPGPDir, szOpenPGPStatusPW1, StoredOnSmartCard, 0xC4, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_WRITE_ONLY},
58          {szOpenPGPDir, szOpenPGPLogin, StoredOnSmartCard, 0x00, 0x5E, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPApplicationIdentifier, StoredOnSmartCard, 0x4F, 0, UnknownAc},
59          {szOpenPGPDir, szOpenPGPName, StoredOnSmartCard, 0x00, 0x5B, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPLogin, StoredOnSmartCard, 0x5E, 0, EveryoneReadAdminWriteAc},
60          {szOpenPGPDir, szOpenPGPLanguage, StoredOnSmartCard, 0x5F, 0x2D, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPName, StoredOnSmartCard, 0x65, 0x5B, EveryoneReadAdminWriteAc},
61          {szOpenPGPDir, szOpenPGPSex, StoredOnSmartCard, 0x5F, 0x35, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPLanguage, StoredOnSmartCard, 0x65, 0x5F2D, EveryoneReadAdminWriteAc},
62          {szOpenPGPDir, szOpenPGPUrl, StoredOnSmartCard, 0x5F, 0x50, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPSex, StoredOnSmartCard, 0x65, 0x5F35,EveryoneReadAdminWriteAc},
63          {szOpenPGPDir, szOpenPGPHistoricalBytes, StoredOnSmartCard, 0x5F, 0x52, UnknownAc},          {szOpenPGPDir, szOpenPGPUrl, StoredOnSmartCard, 0x5F50, 0, EveryoneReadAdminWriteAc},
64          {szOpenPGPDir, szOpenPGPCertificate, StoredOnSmartCard, 0x7F, 0x21, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPHistoricalBytes, StoredOnSmartCard, 0x5F52, 0, UnknownAc},
65          {szOpenPGPDir, szOpenPGPExtendedCap, StoredOnSmartCard, 0x00, 0xC0, UnknownAc},          {szOpenPGPDir, szOpenPGPCertificate, StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc},
66          {szOpenPGPDir, szOpenPGPAlgoAttributesSignature, StoredOnSmartCard, 0x00, 0xC1, UnknownAc},          {szOpenPGPDir, szOpenPGPExtendedCap, StoredOnSmartCard, 0x6E, 0xC0, UnknownAc},
67          {szOpenPGPDir, szOpenPGPAlgoAttributesDecryption, StoredOnSmartCard, 0x00, 0xC2, UnknownAc},          {szOpenPGPDir, szOpenPGPAlgoAttributesSignature, StoredOnSmartCard, 0x6E, 0xC1, UnknownAc},
68          {szOpenPGPDir, szOpenPGPAlgoAttributesAuthentication, StoredOnSmartCard, 0x00, 0xC3, UnknownAc },          {szOpenPGPDir, szOpenPGPAlgoAttributesDecryption, StoredOnSmartCard, 0x6E, 0xC2,UnknownAc},
69          {NULL, szCARD_IDENTIFIER_FILE, StoredOnSmartCard, 0x00, 0x4F, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPAlgoAttributesAuthentication, StoredOnSmartCard, 0x6E, 0xC3, UnknownAc },
70            {szOpenPGPDir, szOpenPGPPUK, StoredOnSmartCard, 0xD3, 0, UnknownAc, OPENPGP_FILE_WRITE_ONLY },
71            {szOpenPGPDir, szOpenPGPSecureMessaging, StoredOnSmartCard, 0xF4, 0, UnknownAc, OPENPGP_FILE_WRITE_ONLY },
72            {szOpenPGPDir, szOpenPGPSecureMessagingCryptographicCheksum, StoredOnSmartCard, 0xD2, 0, UnknownAc, OPENPGP_FILE_WRITE_ONLY },
73            {szOpenPGPDir, szOpenPGPSecureMessagingCryptogram, StoredOnSmartCard, 0xD1, 0, UnknownAc, OPENPGP_FILE_WRITE_ONLY },
74            {NULL, szCARD_IDENTIFIER_FILE, StoredOnSmartCard, 0x4F, 0, EveryoneReadAdminWriteAc},
75          {NULL, szCARD_APPLICATION_FILE, Virtual, 0, 0, EveryoneReadAdminWriteAc},          {NULL, szCARD_APPLICATION_FILE, Virtual, 0, 0, EveryoneReadAdminWriteAc},
76          {NULL, szCACHE_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},          {NULL, szCACHE_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
77          {szBASE_CSP_DIR, szCONTAINER_MAP_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},          {szBASE_CSP_DIR, szCONTAINER_MAP_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
78            {szBASE_CSP_DIR, "kxc01", StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING | OPENPGP_FILE_CONF_IS_AUTH},
79            {szBASE_CSP_DIR, "ksc02", StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING},
80    
81  };  };
82    
83  DWORD dwFileCount = ARRAYSIZE(Files);  DWORD dwFileCount = ARRAYSIZE(Files);
84    
85  DWORD SCardDirectoryList(__in PCARD_DATA  pCardData,  DWORD OCardDirectoryList(__in PCARD_DATA  pCardData,
86                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)
87  {  {
88          // hardcoded          // hardcoded
# Line 82  DWORD SCardDirectoryList(__in PCARD_DATA Line 96  DWORD SCardDirectoryList(__in PCARD_DATA
96          return 0;          return 0;
97  }  }
98    
99    
100  // read file  // read file
101  DWORD SCardReadFile(__in PCARD_DATA  pCardData,  DWORD OCardReadFile(__in PCARD_DATA  pCardData,
102                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in_opt PSTR szDirectory, __in PSTR szFile,
103                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)                                          __in PBYTE* ppbResponse, __in PDWORD pdwResponseSize)
104  {  {
105          DWORD dwI;          DWORD dwI;
106          DWORD dwReturn = 0;          DWORD dwReturn = 0;
107          BOOL fDirectoryFound = FALSE;          BOOL fDirectoryFound = FALSE;
108          BOOL fFileFound = FALSE;          BOOL fFileFound = FALSE;
109          BYTE pbCmd[] = {0x00, 0xCA, 0x00, 0x00, 0x00};          BYTE pbCmd[] = {0x00, 0xCA, 0x00, 0x00, 0x00, 0x00,0x00};
110          DWORD dwCmdSize = ARRAYSIZE(pbCmd);          DWORD dwCmdSize = ARRAYSIZE(pbCmd);
111          POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;          POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;
112            PBYTE pbData = NULL;
113          __try          __try
114          {          {
115                    *pdwResponseSize = 0;
116                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
117                  {                  {
118                          BOOL fMatch = FALSE;                          BOOL fMatch = FALSE;
# Line 105  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 122  DWORD SCardReadFile(__in PCARD_DATA  pCa
122                          }                          }
123                          else                          else
124                          {                          {
125                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
126                          }                          }
127                          if (fMatch)                          if (fMatch)
128                          {                          {
129                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
130                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
131                                  {                                  {
132                                          fFileFound = TRUE;                                          fFileFound = TRUE;
133                                          break;                                          break;
# Line 133  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 150  DWORD SCardReadFile(__in PCARD_DATA  pCa
150                  }                  }
151                  if (Files[dwI].dwFileType == StoredOnSmartCard)                  if (Files[dwI].dwFileType == StoredOnSmartCard)
152                  {                  {
153                          pbCmd[2] = Files[dwI].bP1;                          pbCmd[2] = (BYTE) (Files[dwI].dwTag / 0x100);
154                          pbCmd[3] = Files[dwI].bP2;                          pbCmd[3] = (BYTE) (Files[dwI].dwTag % 0x100);
155                          dwReturn = SCardGetData(pCardData, pbCmd, dwCmdSize, pbResponse, pdwResponseSize);                          dwReturn = OCardGetData(pCardData, pbCmd, dwCmdSize, &pbData, pdwResponseSize);
156                            if (dwReturn)
157                            {
158                                    __leave;
159                            }
160                            if (Files[dwI].dwTlv)
161                            {
162                                    PBYTE pbPointer;
163                                    //TraceDump(0,pbData,*pdwResponseSize);
164                                    if (find_tlv(pbData, Files[dwI].dwTlv, *pdwResponseSize, &pbPointer, pdwResponseSize))
165                                    {
166                                            *ppbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);
167                                            if (!*ppbResponse )
168                                            {
169                                                    Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_MEMORY");
170                                                    dwReturn = SCARD_E_NO_MEMORY;
171                                                    __leave;
172                                            }
173                                            memcpy(*ppbResponse, pbPointer, *pdwResponseSize);
174                                    }
175                                    else
176                                    {
177                                            dwReturn = SCARD_E_FILE_NOT_FOUND;
178                                            Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
179                                            __leave;
180                                    }
181                            }
182                            else
183                            {
184                                    *ppbResponse = pbData;
185                                    // do not free the data !
186                                    pbData = NULL;
187                            }
188                            if (Files[dwI].dwFlag & OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING)
189                            {
190                                    if (*pdwResponseSize == 0)
191                                    {
192                                            pCardData->pfnCspFree(*ppbResponse);
193                                            *pdwResponseSize = 0;
194                                            *ppbResponse = NULL;
195                                            dwReturn = SCARD_E_FILE_NOT_FOUND;
196                                            Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING",szFile);
197                                            __leave;
198                                    }
199                            }
200                            if (Files[dwI].dwFlag & OPENPGP_FILE_CONF_IS_AUTH)
201                            {
202                                    DWORD dwTempReturn = OCardIsConfidentialityKeyTheSameThanAuthentication(pCardData);
203                                    if (dwTempReturn)
204                                    {
205                                            pCardData->pfnCspFree(*ppbResponse);
206                                            *pdwResponseSize = 0;
207                                            *ppbResponse = NULL;
208                                            dwReturn = SCARD_E_FILE_NOT_FOUND;
209                                            Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S OPENPGP_FILE_CONF_IS_AUTH",szFile);
210                                            __leave;
211                                    }
212                            }
213                  }                  }
214                  else                  else
215                  {                  {
216                          if (szDirectory == NULL)                          if (szDirectory == NULL)
217                          {                          {
218                                  if (strcmp(szFile, szCARD_APPLICATION_FILE) == 0)                                  if (_stricmp(szFile, szCARD_APPLICATION_FILE) == 0)
219                                  {                                  {
220                                          dwReturn = SCardDirectoryList(pCardData, pbResponse, pdwResponseSize);                                          dwReturn = OCardDirectoryList(pCardData, ppbResponse, pdwResponseSize);
221                                  }                                  }
222                                  else if (strcmp(szFile, szCACHE_FILE) == 0)                                  else if (_stricmp(szFile, szCACHE_FILE) == 0)
223                                  {                                  {
224                                          *pdwResponseSize = sizeof(CARD_CACHE_FILE_FORMAT);                                          *pdwResponseSize = sizeof(CARD_CACHE_FILE_FORMAT);
225                                          *pbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);                                          *ppbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);
226                                          memset(*pbResponse,0,*pdwResponseSize);                                          memset(*ppbResponse,0,*pdwResponseSize);
227                                  }                                  }
228                                  else                                  else
229                                  {                                  {
# Line 157  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 231  DWORD SCardReadFile(__in PCARD_DATA  pCa
231                                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);                                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
232                                  }                                  }
233                          }                          }
234                          else if (strcmp(szDirectory,szBASE_CSP_DIR) == 0)                          else if (_stricmp(szDirectory,szBASE_CSP_DIR) == 0)
235                          {                          {
236                                  if (strcmp(szFile, szCONTAINER_MAP_FILE) == 0)                                  if (_stricmp(szFile, szCONTAINER_MAP_FILE) == 0)
237                                  {                                  {
238                                          PCONTAINER_MAP_RECORD pContainer = NULL;                                          dwReturn = OCardReadContainerMapFile(pCardData, ppbResponse, pdwResponseSize);
                                         *pdwResponseSize = sizeof(CONTAINER_MAP_RECORD) * MaxContainer;  
                                         *pbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);  
                                         if (! *pbResponse )  
                                         {  
                                                 dwReturn = SCARD_E_NO_MEMORY;  
                                                 Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_MEMORY");  
                                                 __leave;  
                                         }  
                                         pContainer = (PCONTAINER_MAP_RECORD) *pbResponse;  
                                         memset(pContainer,0,sizeof(CONTAINER_MAP_RECORD) * 3);  
                                         swprintf_s(pContainer[Signature].wszGuid,MAX_CONTAINER_NAME_LEN + 1,  
                                                 L"OPENPGP_%02X%02X_%02X%02X_%02X%02X%02X%02X_Signature",  
                                                 pContext->Aid.AidVersion[0],pContext->Aid.AidVersion[1],  
                                                 pContext->Aid.AidManufacturer[0],pContext->Aid.AidManufacturer[1],  
                                                 pContext->Aid.AidSerialNumber[0],pContext->Aid.AidSerialNumber[1],  
                                                 pContext->Aid.AidSerialNumber[2],pContext->Aid.AidSerialNumber[3]);  
                                         pContainer[Signature].bFlags = CONTAINER_MAP_VALID_CONTAINER;  
                                         pContainer[Signature].wSigKeySizeBits = 1024;  
                                         swprintf_s(pContainer[Authentication].wszGuid,MAX_CONTAINER_NAME_LEN + 1,  
                                                 L"OPENPGP_%02X%02X_%02X%02X_%02X%02X%02X%02X_Authenticate",  
                                                 pContext->Aid.AidVersion[0],pContext->Aid.AidVersion[1],  
                                                 pContext->Aid.AidManufacturer[0],pContext->Aid.AidManufacturer[1],  
                                                 pContext->Aid.AidSerialNumber[0],pContext->Aid.AidSerialNumber[1],  
                                                 pContext->Aid.AidSerialNumber[2],pContext->Aid.AidSerialNumber[3]);  
                                         pContainer[Authentication].bFlags = CONTAINER_MAP_VALID_CONTAINER | CONTAINER_MAP_DEFAULT_CONTAINER;  
                                         pContainer[Authentication].wSigKeySizeBits = 1024;  
                                         swprintf_s(pContainer[Confidentiality].wszGuid,MAX_CONTAINER_NAME_LEN + 1,  
                                                 L"OPENPGP_%02X%02X_%02X%02X_%02X%02X%02X%02X_Confidential",  
                                                 pContext->Aid.AidVersion[0],pContext->Aid.AidVersion[1],  
                                                 pContext->Aid.AidManufacturer[0],pContext->Aid.AidManufacturer[1],  
                                                 pContext->Aid.AidSerialNumber[0],pContext->Aid.AidSerialNumber[1],  
                                                 pContext->Aid.AidSerialNumber[2],pContext->Aid.AidSerialNumber[3]);  
                                         pContainer[Confidentiality].bFlags = CONTAINER_MAP_VALID_CONTAINER;  
                                         pContainer[Confidentiality].wKeyExchangeKeySizeBits = 1024;  
239                                  }                                  }
240                                  else                                  else
241                                  {                                  {
# Line 219  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 259  DWORD SCardReadFile(__in PCARD_DATA  pCa
259          }          }
260          __finally          __finally
261          {          {
262                    if( pbData)
263                            pCardData->pfnCspFree(pbData);
264          }          }
265          Trace(WINEVENT_LEVEL_VERBOSE, L"%S\\%S dwReturn = 0x%08X",szDirectory, szFile, dwReturn);          Trace(WINEVENT_LEVEL_VERBOSE, L"%S\\%S dwReturn = 0x%08X size = %d",szDirectory, szFile, dwReturn, *pdwResponseSize);
266          return dwReturn;          return dwReturn;
267  }  }
268    
269  DWORD SCardEnumFile(__in PCARD_DATA  pCardData,  DWORD OCardEnumFile(__in PCARD_DATA  pCardData,
270                                          __in_opt PSTR szDirectory,                                          __in_opt PSTR szDirectory,
271                                          __in PBYTE* pbResponse, __in PDWORD pdwResponseSize)                                          __in PBYTE* pbResponse, __in PDWORD pdwResponseSize)
272  {  {
273          DWORD dwReturn = 0, dwNotExists;          DWORD dwReturn = 0, dwTempReturn;
274          DWORD dwI, dwSize;          DWORD dwI, dwSize;
275          BOOL fDirectoryFound = FALSE;          BOOL fDirectoryFound = FALSE;
276            BOOL fAddToOuput;
277          __try          __try
278          {          {
279                  *pbResponse = NULL;                  *pbResponse = NULL;
280                  *pdwResponseSize = 0;                  *pdwResponseSize = 0;
281                    
282                    // compute the max size of the buffer
283                    dwSize = 0;
284                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
285                  {                  {
286                          BOOL fMatch = FALSE;                          BOOL fMatch = FALSE;
# Line 245  DWORD SCardEnumFile(__in PCARD_DATA  pCa Line 290  DWORD SCardEnumFile(__in PCARD_DATA  pCa
290                          }                          }
291                          else                          else
292                          {                          {
293                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
294                            }
295                            if (fMatch && !(Files[dwI].dwFileType & OPENPGP_FILE_WRITE_ONLY))
296                            {
297                                    dwSize += (DWORD) strlen( Files[dwI].szFile) + 1;
298                            }
299                    }
300                    dwSize += 1;
301                    *pbResponse = pCardData->pfnCspAlloc(dwSize);
302                    if (!*pbResponse)
303                    {
304                            dwReturn = SCARD_E_NO_MEMORY;
305                            __leave;
306                    }
307                    for(dwI = 0; dwI < dwFileCount; dwI++)
308                    {
309                            BOOL fMatch = FALSE;
310                            if (szDirectory == NULL)
311                            {
312                                    if (!Files[dwI].szDirectory) fMatch = TRUE;
313                            }
314                            else
315                            {
316                                    if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
317                          }                          }
318                          if (fMatch)                          if (fMatch)
319                          {                          {
320                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
321                                  dwNotExists = 0;                                  fAddToOuput = TRUE;
322                                  if (StoredOnSmartCard == Files[dwI].dwFileType)                                  if (Files[dwI].dwFlag & OPENPGP_FILE_WRITE_ONLY)
323                                    {
324                                            fAddToOuput = FALSE;
325                                    }
326                                    if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING))
327                                  {                                  {
328                                          PBYTE pbData = NULL;                                          PBYTE pbData = NULL;
329                                          DWORD dwSize;                                          DWORD dwSize;
330                                            fAddToOuput = FALSE;
331                                          // check if the file exists and be read                                          // check if the file exists and be read
332                                          dwNotExists = SCardReadFile(pCardData, szDirectory, Files[dwI].szFile, &pbData, &dwSize);                                          dwTempReturn = OCardReadFile(pCardData, szDirectory, Files[dwI].szFile, &pbData, &dwSize);
333                                          if (!dwNotExists)                                          if (!dwTempReturn)
334                                          {                                          {
335                                                  pCardData->pfnCspFree(pbData);                                                  pCardData->pfnCspFree(pbData);
336                                                    if (dwSize > 0)
337                                                    {
338                                                            fAddToOuput = TRUE;
339                                                    }
340                                          }                                          }
341                                  }                                  }
342                                  if (!dwNotExists)                                  if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_CONF_IS_AUTH))
343                                  {                                  {
344                                          dwSize = (DWORD) strlen( Files[dwI].szFile) + 1;                                          dwTempReturn = OCardIsConfidentialityKeyTheSameThanAuthentication(pCardData);
345                                          // + 1 to add the final \0                                          if (dwTempReturn)
                                         if (*pbResponse)  
                                         {  
                                                 *pbResponse = pCardData->pfnCspReAlloc(*pbResponse, *pdwResponseSize + dwSize + 1);  
                                         }  
                                         else  
                                         {  
                                                 *pbResponse = pCardData->pfnCspAlloc(*pdwResponseSize + dwSize + 1);  
                                         }  
                                         if (!*pbResponse)  
346                                          {                                          {
347                                                  dwReturn = SCARD_E_NO_MEMORY;                                                  fAddToOuput = FALSE;
                                                 __leave;  
348                                          }                                          }
349                                    }
350                                    if (fAddToOuput)
351                                    {
352                                            dwSize = (DWORD) strlen( Files[dwI].szFile) + 1;
353                                          memcpy(*pbResponse + *pdwResponseSize,  Files[dwI].szFile, dwSize);                                          memcpy(*pbResponse + *pdwResponseSize,  Files[dwI].szFile, dwSize);
354                                          *pdwResponseSize += dwSize;                                          *pdwResponseSize += dwSize;
355                                  }                                  }
# Line 301  DWORD SCardEnumFile(__in PCARD_DATA  pCa Line 372  DWORD SCardEnumFile(__in PCARD_DATA  pCa
372  }  }
373    
374  // read file  // read file
375  DWORD SCardGetFileInfo(__in PCARD_DATA  pCardData,  DWORD OCardGetFileInfo(__in PCARD_DATA  pCardData,
376                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in_opt PSTR szDirectory, __in PSTR szFile,
377                                           __inout PCARD_FILE_INFO  pCardFileInfo)                                           __inout PCARD_FILE_INFO  pCardFileInfo)
378  {  {
# Line 310  DWORD SCardGetFileInfo(__in PCARD_DATA Line 381  DWORD SCardGetFileInfo(__in PCARD_DATA
381          DWORD dwSize, dwI;          DWORD dwSize, dwI;
382          __try          __try
383          {          {
384                  dwReturn = SCardReadFile(pCardData, szDirectory, szFile, &pbData, &dwSize);                  dwReturn = OCardReadFile(pCardData, szDirectory, szFile, &pbData, &dwSize);
385                  if (dwReturn)                  if (dwReturn)
386                  {                  {
387                          __leave;                          __leave;
# Line 320  DWORD SCardGetFileInfo(__in PCARD_DATA Line 391  DWORD SCardGetFileInfo(__in PCARD_DATA
391                  pCardFileInfo->AccessCondition = InvalidAc;                  pCardFileInfo->AccessCondition = InvalidAc;
392                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
393                  {                  {
394                          if ((strcmp(szDirectory, Files[dwI].szDirectory) == 0)                          BOOL fMatch = FALSE;
395                                  || (!szDirectory && !Files[dwI].szDirectory) )                          if (szDirectory == NULL)
396                          {                          {
397                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (!Files[dwI].szDirectory) fMatch = TRUE;
398                            }
399                            else
400                            {
401                                    if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
402                            }
403                            if (fMatch)
404                            {
405                                    if (_stricmp(szFile, Files[dwI].szFile) == 0)
406                                  {                                  {
407                                          pCardFileInfo->AccessCondition = Files[dwI].dwAccess;                                          pCardFileInfo->AccessCondition = Files[dwI].dwAccess;
408                                          break;                                          break;
# Line 339  DWORD SCardGetFileInfo(__in PCARD_DATA Line 418  DWORD SCardGetFileInfo(__in PCARD_DATA
418          return dwReturn;                  return dwReturn;        
419  }  }
420    
421  DWORD SCardWriteFile(__in PCARD_DATA  pCardData,  DWORD OCardWriteFileOnSmartCard(__in PCARD_DATA  pCardData,
422                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in OPENPGP_FILE File,
423                                          __in PBYTE pbData, __in DWORD dwSize)                                          __in PBYTE pbData, __in DWORD dwSize)
424  {  {
         DWORD dwI;  
425          DWORD dwReturn = 0;          DWORD dwReturn = 0;
         BOOL fDirectoryFound = FALSE;  
         BOOL fFileFound = FALSE;  
426          BYTE pbCmd[5 + 256] = {0x00, 0xDA, 0x00, 0x00, 0x00};          BYTE pbCmd[5 + 256] = {0x00, 0xDA, 0x00, 0x00, 0x00};
427          DWORD dwCmdSize = 0;          DWORD dwCmdSize = 0;
428            PBYTE pbCmdExtended = NULL;
429          __try          __try
430          {          {
431                  if (dwSize > 255)                  if (dwSize > 0xFFFF)
432                  {                  {
433                          dwReturn = SCARD_E_INVALID_PARAMETER;                          dwReturn = SCARD_E_INVALID_PARAMETER;
434                          Trace(WINEVENT_LEVEL_ERROR, L"dwSize %d",dwSize);                          Trace(WINEVENT_LEVEL_ERROR, L"dwSize %d",dwSize);
435                          __leave;                          __leave;
436                  }                  }
437                    if (dwSize < 256)
438                    {
439                            if (File.dwTlv > 0)
440                            {
441                                    pbCmd[2] = (BYTE) (File.dwTlv / 0x100);
442                                    pbCmd[3] = (BYTE) (File.dwTlv % 0x100);
443                            }
444                            else
445                            {
446                                    pbCmd[2] = (BYTE) (File.dwTag / 0x100);
447                                    pbCmd[3] = (BYTE) (File.dwTag % 0x100);
448                            }
449                            pbCmd[4] = (BYTE) dwSize;
450                            if (dwSize)
451                            {
452                                    memcpy(pbCmd + 5, pbData, dwSize);
453                            }
454                            dwCmdSize = dwSize + 5;
455                            dwReturn = OCardSendCommand(pCardData, pbCmd, dwCmdSize);
456                            if (dwReturn)
457                            {
458                                    __leave;
459                            }
460                    }
461                    else
462                    {
463                            dwCmdSize = dwSize + 7;
464                            pbCmdExtended = pCardData->pfnCspAlloc(dwCmdSize);
465                            if (!pbCmdExtended)
466                            {
467                                    Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_MEMORY");
468                                    dwReturn = SCARD_E_NO_MEMORY;
469                                    __leave;
470                            }
471                            pbCmdExtended[0] = 0;
472                            pbCmdExtended[1] = 0xDA;
473                            if (File.dwTlv > 0)
474                            {
475                                    pbCmdExtended[2] = (BYTE) (File.dwTlv / 0x100);
476                                    pbCmdExtended[3] = (BYTE) (File.dwTlv % 0x100);
477                            }
478                            else
479                            {
480                                    pbCmdExtended[2] = (BYTE) (File.dwTag / 0x100);
481                                    pbCmdExtended[3] = (BYTE) (File.dwTag % 0x100);
482                            }
483                            pbCmdExtended[4] = 0;
484                            pbCmdExtended[5] = (BYTE)(dwSize / 0x100);
485                            pbCmdExtended[6] = (BYTE)(dwSize % 0x100);
486                            memcpy(pbCmdExtended + 7, pbData, dwSize);
487                            dwReturn = OCardSendCommand(pCardData, pbCmdExtended, dwCmdSize);
488                            if (dwReturn)
489                            {
490                                    __leave;
491                            }
492                    }
493            }
494            __finally
495            {
496                    if(pbCmdExtended)
497                            pCardData->pfnCspFree(pbCmdExtended);
498            }
499            Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
500            return dwReturn;
501    }
502    
503    DWORD OCardWriteFile(__in PCARD_DATA  pCardData,
504                                            __in_opt PSTR szDirectory, __in PSTR szFile,
505                                            __in PBYTE pbData, __in DWORD dwSize)
506    {
507            DWORD dwI;
508            DWORD dwReturn = 0;
509            BOOL fDirectoryFound = FALSE;
510            BOOL fFileFound = FALSE;
511            __try
512            {
513    
514                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
515                  {                  {
# Line 368  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 520  DWORD SCardWriteFile(__in PCARD_DATA  pC
520                          }                          }
521                          else                          else
522                          {                          {
523                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
524                          }                          }
525                          if (fMatch)                          if (fMatch)
526                          {                          {
527                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
528                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
529                                  {                                  {
530                                          fFileFound = TRUE;                                          fFileFound = TRUE;
531                                          break;                                          break;
# Line 396  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 548  DWORD SCardWriteFile(__in PCARD_DATA  pC
548                  }                  }
549                  if (Files[dwI].dwFileType == StoredOnSmartCard)                  if (Files[dwI].dwFileType == StoredOnSmartCard)
550                  {                  {
551                          // fail because the PUT DO doesn't work => too much data                          dwReturn = OCardWriteFileOnSmartCard(pCardData, Files[dwI], pbData, dwSize);
                         if (Files[dwI].bP1 != 0)  
                         {  
                                 dwReturn = SCARD_E_WRITE_TOO_MANY ;  
                                 Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_WRITE_TOO_MANY  %S",szFile);  
                                 __leave;  
                         }  
                         pbCmd[3] = Files[dwI].bP2;  
                         pbCmd[4] = (BYTE) dwSize;  
                         if (dwSize)  
                         {  
                                 memcpy(pbCmd + 5, pbData, dwSize);  
                         }  
                         dwCmdSize = dwSize + 5;  
                         dwReturn = SCardSendCommand(pCardData, pbCmd, dwCmdSize);  
                         if (dwReturn)  
                         {  
                                 __leave;  
                         }  
552                  }                  }
553                  else                  else
554                  {                  {
# Line 422  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 556  DWORD SCardWriteFile(__in PCARD_DATA  pC
556                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_SECURITY_VIOLATION %S",szFile);                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_SECURITY_VIOLATION %S",szFile);
557                          __leave;                          __leave;
558                  }                  }
   
                   
559          }          }
560          __finally          __finally
561          {          {
# Line 432  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 564  DWORD SCardWriteFile(__in PCARD_DATA  pC
564          return dwReturn;          return dwReturn;
565  }  }
566    
567  DWORD SCardDeleteFile(__in PCARD_DATA  pCardData,  DWORD OCardDeleteFile(__in PCARD_DATA  pCardData,
568                                          __in_opt PSTR szDirectory, __in PSTR szFile)                                          __in_opt PSTR szDirectory, __in PSTR szFile)
569  {  {
570          return SCardWriteFile(pCardData, szDirectory, szFile, NULL, 0);          return OCardWriteFile(pCardData, szDirectory, szFile, NULL, 0);
571  }  }
572    
573  // just change the flag in Files  // just change the flag in Files
574  DWORD SCardCreateFile(__in PCARD_DATA  pCardData,  DWORD OCardCreateFile(__in PCARD_DATA  pCardData,
575                                          __in_opt PSTR szDirectory, __in PSTR szFile)                                          __in_opt PSTR szDirectory, __in PSTR szFile)
576  {  {
577          DWORD dwI;          DWORD dwI;
# Line 457  DWORD SCardCreateFile(__in PCARD_DATA  p Line 589  DWORD SCardCreateFile(__in PCARD_DATA  p
589                          }                          }
590                          else                          else
591                          {                          {
592                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
593                          }                          }
594                          if (fMatch)                          if (fMatch)
595                          {                          {
596                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
597                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
598                                  {                                  {
599                                          fFileFound = TRUE;                                          fFileFound = TRUE;
600                                          break;                                          break;
Legend:
Removed from v.1  
changed lines
  Added in v.12
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26