/[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 11 by vletoux, Thu Mar 18 16:03:39 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            {NULL, szCARD_IDENTIFIER_FILE, StoredOnSmartCard, 0x4F, 0, EveryoneReadAdminWriteAc},
72          {NULL, szCARD_APPLICATION_FILE, Virtual, 0, 0, EveryoneReadAdminWriteAc},          {NULL, szCARD_APPLICATION_FILE, Virtual, 0, 0, EveryoneReadAdminWriteAc},
73          {NULL, szCACHE_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},          {NULL, szCACHE_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
74          {szBASE_CSP_DIR, szCONTAINER_MAP_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},          {szBASE_CSP_DIR, szCONTAINER_MAP_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
75            {szBASE_CSP_DIR, "kxc01", StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING | OPENPGP_FILE_CONF_IS_AUTH},
76            {szBASE_CSP_DIR, "ksc02", StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING},
77    
78  };  };
79    
80  DWORD dwFileCount = ARRAYSIZE(Files);  DWORD dwFileCount = ARRAYSIZE(Files);
81    
82  DWORD SCardDirectoryList(__in PCARD_DATA  pCardData,  DWORD OCardDirectoryList(__in PCARD_DATA  pCardData,
83                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)
84  {  {
85          // hardcoded          // hardcoded
# Line 82  DWORD SCardDirectoryList(__in PCARD_DATA Line 93  DWORD SCardDirectoryList(__in PCARD_DATA
93          return 0;          return 0;
94  }  }
95    
96    
97  // read file  // read file
98  DWORD SCardReadFile(__in PCARD_DATA  pCardData,  DWORD OCardReadFile(__in PCARD_DATA  pCardData,
99                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in_opt PSTR szDirectory, __in PSTR szFile,
100                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)                                          __in PBYTE* ppbResponse, __in PDWORD pdwResponseSize)
101  {  {
102          DWORD dwI;          DWORD dwI;
103          DWORD dwReturn = 0;          DWORD dwReturn = 0;
104          BOOL fDirectoryFound = FALSE;          BOOL fDirectoryFound = FALSE;
105          BOOL fFileFound = FALSE;          BOOL fFileFound = FALSE;
106          BYTE pbCmd[] = {0x00, 0xCA, 0x00, 0x00, 0x00};          BYTE pbCmd[] = {0x00, 0xCA, 0x00, 0x00, 0x00, 0x00,0x00};
107          DWORD dwCmdSize = ARRAYSIZE(pbCmd);          DWORD dwCmdSize = ARRAYSIZE(pbCmd);
108          POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;          POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;
109            PBYTE pbData = NULL;
110          __try          __try
111          {          {
112                    *pdwResponseSize = 0;
113                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
114                  {                  {
115                          BOOL fMatch = FALSE;                          BOOL fMatch = FALSE;
# Line 105  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 119  DWORD SCardReadFile(__in PCARD_DATA  pCa
119                          }                          }
120                          else                          else
121                          {                          {
122                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
123                          }                          }
124                          if (fMatch)                          if (fMatch)
125                          {                          {
126                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
127                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
128                                  {                                  {
129                                          fFileFound = TRUE;                                          fFileFound = TRUE;
130                                          break;                                          break;
# Line 133  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 147  DWORD SCardReadFile(__in PCARD_DATA  pCa
147                  }                  }
148                  if (Files[dwI].dwFileType == StoredOnSmartCard)                  if (Files[dwI].dwFileType == StoredOnSmartCard)
149                  {                  {
150                          pbCmd[2] = Files[dwI].bP1;                          pbCmd[2] = (BYTE) (Files[dwI].dwTag / 0x100);
151                          pbCmd[3] = Files[dwI].bP2;                          pbCmd[3] = (BYTE) (Files[dwI].dwTag % 0x100);
152                          dwReturn = SCardGetData(pCardData, pbCmd, dwCmdSize, pbResponse, pdwResponseSize);                          dwReturn = OCardGetData(pCardData, pbCmd, dwCmdSize, &pbData, pdwResponseSize);
153                            if (dwReturn)
154                            {
155                                    __leave;
156                            }
157                            if (Files[dwI].dwTlv)
158                            {
159                                    PBYTE pbPointer;
160                                    //TraceDump(0,pbData,*pdwResponseSize);
161                                    if (find_tlv(pbData, Files[dwI].dwTlv, *pdwResponseSize, &pbPointer, pdwResponseSize))
162                                    {
163                                            *ppbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);
164                                            if (!*ppbResponse )
165                                            {
166                                                    Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_MEMORY");
167                                                    dwReturn = SCARD_E_NO_MEMORY;
168                                                    __leave;
169                                            }
170                                            memcpy(*ppbResponse, pbPointer, *pdwResponseSize);
171                                    }
172                                    else
173                                    {
174                                            dwReturn = SCARD_E_FILE_NOT_FOUND;
175                                            Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
176                                            __leave;
177                                    }
178                            }
179                            else
180                            {
181                                    *ppbResponse = pbData;
182                                    // do not free the data !
183                                    pbData = NULL;
184                            }
185                            if (Files[dwI].dwFlag & OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING)
186                            {
187                                    if (*pdwResponseSize == 0)
188                                    {
189                                            pCardData->pfnCspFree(*ppbResponse);
190                                            *pdwResponseSize = 0;
191                                            *ppbResponse = NULL;
192                                            dwReturn = SCARD_E_FILE_NOT_FOUND;
193                                            Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING",szFile);
194                                            __leave;
195                                    }
196                            }
197                            if (Files[dwI].dwFlag & OPENPGP_FILE_CONF_IS_AUTH)
198                            {
199                                    DWORD dwTempReturn = OCardIsConfidentialityKeyTheSameThanAuthentication(pCardData);
200                                    if (dwTempReturn)
201                                    {
202                                            pCardData->pfnCspFree(*ppbResponse);
203                                            *pdwResponseSize = 0;
204                                            *ppbResponse = NULL;
205                                            dwReturn = SCARD_E_FILE_NOT_FOUND;
206                                            Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S OPENPGP_FILE_CONF_IS_AUTH",szFile);
207                                            __leave;
208                                    }
209                            }
210                  }                  }
211                  else                  else
212                  {                  {
213                          if (szDirectory == NULL)                          if (szDirectory == NULL)
214                          {                          {
215                                  if (strcmp(szFile, szCARD_APPLICATION_FILE) == 0)                                  if (_stricmp(szFile, szCARD_APPLICATION_FILE) == 0)
216                                  {                                  {
217                                          dwReturn = SCardDirectoryList(pCardData, pbResponse, pdwResponseSize);                                          dwReturn = OCardDirectoryList(pCardData, ppbResponse, pdwResponseSize);
218                                  }                                  }
219                                  else if (strcmp(szFile, szCACHE_FILE) == 0)                                  else if (_stricmp(szFile, szCACHE_FILE) == 0)
220                                  {                                  {
221                                          *pdwResponseSize = sizeof(CARD_CACHE_FILE_FORMAT);                                          *pdwResponseSize = sizeof(CARD_CACHE_FILE_FORMAT);
222                                          *pbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);                                          *ppbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);
223                                          memset(*pbResponse,0,*pdwResponseSize);                                          memset(*ppbResponse,0,*pdwResponseSize);
224                                  }                                  }
225                                  else                                  else
226                                  {                                  {
# Line 157  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 228  DWORD SCardReadFile(__in PCARD_DATA  pCa
228                                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);                                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
229                                  }                                  }
230                          }                          }
231                          else if (strcmp(szDirectory,szBASE_CSP_DIR) == 0)                          else if (_stricmp(szDirectory,szBASE_CSP_DIR) == 0)
232                          {                          {
233                                  if (strcmp(szFile, szCONTAINER_MAP_FILE) == 0)                                  if (_stricmp(szFile, szCONTAINER_MAP_FILE) == 0)
234                                  {                                  {
235                                          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;  
236                                  }                                  }
237                                  else                                  else
238                                  {                                  {
# Line 219  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 256  DWORD SCardReadFile(__in PCARD_DATA  pCa
256          }          }
257          __finally          __finally
258          {          {
259                    if( pbData)
260                            pCardData->pfnCspFree(pbData);
261          }          }
262          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);
263          return dwReturn;          return dwReturn;
264  }  }
265    
266  DWORD SCardEnumFile(__in PCARD_DATA  pCardData,  DWORD OCardEnumFile(__in PCARD_DATA  pCardData,
267                                          __in_opt PSTR szDirectory,                                          __in_opt PSTR szDirectory,
268                                          __in PBYTE* pbResponse, __in PDWORD pdwResponseSize)                                          __in PBYTE* pbResponse, __in PDWORD pdwResponseSize)
269  {  {
270          DWORD dwReturn = 0, dwNotExists;          DWORD dwReturn = 0, dwTempReturn;
271          DWORD dwI, dwSize;          DWORD dwI, dwSize;
272          BOOL fDirectoryFound = FALSE;          BOOL fDirectoryFound = FALSE;
273            BOOL fAddToOuput;
274          __try          __try
275          {          {
276                  *pbResponse = NULL;                  *pbResponse = NULL;
277                  *pdwResponseSize = 0;                  *pdwResponseSize = 0;
278                    
279                    // compute the max size of the buffer
280                    dwSize = 0;
281                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
282                  {                  {
283                          BOOL fMatch = FALSE;                          BOOL fMatch = FALSE;
# Line 245  DWORD SCardEnumFile(__in PCARD_DATA  pCa Line 287  DWORD SCardEnumFile(__in PCARD_DATA  pCa
287                          }                          }
288                          else                          else
289                          {                          {
290                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
291                            }
292                            if (fMatch && !(Files[dwI].dwFileType & OPENPGP_FILE_WRITE_ONLY))
293                            {
294                                    dwSize += (DWORD) strlen( Files[dwI].szFile) + 1;
295                            }
296                    }
297                    dwSize += 1;
298                    *pbResponse = pCardData->pfnCspAlloc(dwSize);
299                    if (!*pbResponse)
300                    {
301                            dwReturn = SCARD_E_NO_MEMORY;
302                            __leave;
303                    }
304                    for(dwI = 0; dwI < dwFileCount; dwI++)
305                    {
306                            BOOL fMatch = FALSE;
307                            if (szDirectory == NULL)
308                            {
309                                    if (!Files[dwI].szDirectory) fMatch = TRUE;
310                            }
311                            else
312                            {
313                                    if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
314                          }                          }
315                          if (fMatch)                          if (fMatch)
316                          {                          {
317                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
318                                  dwNotExists = 0;                                  fAddToOuput = TRUE;
319                                  if (StoredOnSmartCard == Files[dwI].dwFileType)                                  if (Files[dwI].dwFlag & OPENPGP_FILE_WRITE_ONLY)
320                                    {
321                                            fAddToOuput = FALSE;
322                                    }
323                                    if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING))
324                                  {                                  {
325                                          PBYTE pbData = NULL;                                          PBYTE pbData = NULL;
326                                          DWORD dwSize;                                          DWORD dwSize;
327                                            fAddToOuput = FALSE;
328                                          // check if the file exists and be read                                          // check if the file exists and be read
329                                          dwNotExists = SCardReadFile(pCardData, szDirectory, Files[dwI].szFile, &pbData, &dwSize);                                          dwTempReturn = OCardReadFile(pCardData, szDirectory, Files[dwI].szFile, &pbData, &dwSize);
330                                          if (!dwNotExists)                                          if (!dwTempReturn)
331                                          {                                          {
332                                                  pCardData->pfnCspFree(pbData);                                                  pCardData->pfnCspFree(pbData);
333                                                    if (dwSize > 0)
334                                                    {
335                                                            fAddToOuput = TRUE;
336                                                    }
337                                          }                                          }
338                                  }                                  }
339                                  if (!dwNotExists)                                  if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_CONF_IS_AUTH))
340                                  {                                  {
341                                          dwSize = (DWORD) strlen( Files[dwI].szFile) + 1;                                          dwTempReturn = OCardIsConfidentialityKeyTheSameThanAuthentication(pCardData);
342                                          // + 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)  
343                                          {                                          {
344                                                  dwReturn = SCARD_E_NO_MEMORY;                                                  fAddToOuput = FALSE;
                                                 __leave;  
345                                          }                                          }
346                                    }
347                                    if (fAddToOuput)
348                                    {
349                                            dwSize = (DWORD) strlen( Files[dwI].szFile) + 1;
350                                          memcpy(*pbResponse + *pdwResponseSize,  Files[dwI].szFile, dwSize);                                          memcpy(*pbResponse + *pdwResponseSize,  Files[dwI].szFile, dwSize);
351                                          *pdwResponseSize += dwSize;                                          *pdwResponseSize += dwSize;
352                                  }                                  }
# Line 301  DWORD SCardEnumFile(__in PCARD_DATA  pCa Line 369  DWORD SCardEnumFile(__in PCARD_DATA  pCa
369  }  }
370    
371  // read file  // read file
372  DWORD SCardGetFileInfo(__in PCARD_DATA  pCardData,  DWORD OCardGetFileInfo(__in PCARD_DATA  pCardData,
373                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in_opt PSTR szDirectory, __in PSTR szFile,
374                                           __inout PCARD_FILE_INFO  pCardFileInfo)                                           __inout PCARD_FILE_INFO  pCardFileInfo)
375  {  {
# Line 310  DWORD SCardGetFileInfo(__in PCARD_DATA Line 378  DWORD SCardGetFileInfo(__in PCARD_DATA
378          DWORD dwSize, dwI;          DWORD dwSize, dwI;
379          __try          __try
380          {          {
381                  dwReturn = SCardReadFile(pCardData, szDirectory, szFile, &pbData, &dwSize);                  dwReturn = OCardReadFile(pCardData, szDirectory, szFile, &pbData, &dwSize);
382                  if (dwReturn)                  if (dwReturn)
383                  {                  {
384                          __leave;                          __leave;
# Line 320  DWORD SCardGetFileInfo(__in PCARD_DATA Line 388  DWORD SCardGetFileInfo(__in PCARD_DATA
388                  pCardFileInfo->AccessCondition = InvalidAc;                  pCardFileInfo->AccessCondition = InvalidAc;
389                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
390                  {                  {
391                          if ((strcmp(szDirectory, Files[dwI].szDirectory) == 0)                          BOOL fMatch = FALSE;
392                                  || (!szDirectory && !Files[dwI].szDirectory) )                          if (szDirectory == NULL)
393                          {                          {
394                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (!Files[dwI].szDirectory) fMatch = TRUE;
395                            }
396                            else
397                            {
398                                    if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
399                            }
400                            if (fMatch)
401                            {
402                                    if (_stricmp(szFile, Files[dwI].szFile) == 0)
403                                  {                                  {
404                                          pCardFileInfo->AccessCondition = Files[dwI].dwAccess;                                          pCardFileInfo->AccessCondition = Files[dwI].dwAccess;
405                                          break;                                          break;
# Line 339  DWORD SCardGetFileInfo(__in PCARD_DATA Line 415  DWORD SCardGetFileInfo(__in PCARD_DATA
415          return dwReturn;                  return dwReturn;        
416  }  }
417    
418  DWORD SCardWriteFile(__in PCARD_DATA  pCardData,  DWORD OCardWriteFileOnSmartCard(__in PCARD_DATA  pCardData,
419                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in OPENPGP_FILE File,
420                                          __in PBYTE pbData, __in DWORD dwSize)                                          __in PBYTE pbData, __in DWORD dwSize)
421  {  {
         DWORD dwI;  
422          DWORD dwReturn = 0;          DWORD dwReturn = 0;
         BOOL fDirectoryFound = FALSE;  
         BOOL fFileFound = FALSE;  
423          BYTE pbCmd[5 + 256] = {0x00, 0xDA, 0x00, 0x00, 0x00};          BYTE pbCmd[5 + 256] = {0x00, 0xDA, 0x00, 0x00, 0x00};
424          DWORD dwCmdSize = 0;          DWORD dwCmdSize = 0;
425            PBYTE pbCmdExtended = NULL;
426          __try          __try
427          {          {
428                  if (dwSize > 255)                  if (dwSize > 0xFFFF)
429                  {                  {
430                          dwReturn = SCARD_E_INVALID_PARAMETER;                          dwReturn = SCARD_E_INVALID_PARAMETER;
431                          Trace(WINEVENT_LEVEL_ERROR, L"dwSize %d",dwSize);                          Trace(WINEVENT_LEVEL_ERROR, L"dwSize %d",dwSize);
432                          __leave;                          __leave;
433                  }                  }
434                    if (dwSize < 256)
435                    {
436                            if (File.dwTlv > 0)
437                            {
438                                    pbCmd[2] = (BYTE) (File.dwTlv / 0x100);
439                                    pbCmd[3] = (BYTE) (File.dwTlv % 0x100);
440                            }
441                            else
442                            {
443                                    pbCmd[2] = (BYTE) (File.dwTag / 0x100);
444                                    pbCmd[3] = (BYTE) (File.dwTag % 0x100);
445                            }
446                            pbCmd[4] = (BYTE) dwSize;
447                            if (dwSize)
448                            {
449                                    memcpy(pbCmd + 5, pbData, dwSize);
450                            }
451                            dwCmdSize = dwSize + 5;
452                            dwReturn = OCardSendCommand(pCardData, pbCmd, dwCmdSize);
453                            if (dwReturn)
454                            {
455                                    __leave;
456                            }
457                    }
458                    else
459                    {
460                            dwCmdSize = dwSize + 7;
461                            pbCmdExtended = pCardData->pfnCspAlloc(dwCmdSize);
462                            if (!pbCmdExtended)
463                            {
464                                    Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_MEMORY");
465                                    dwReturn = SCARD_E_NO_MEMORY;
466                                    __leave;
467                            }
468                            pbCmdExtended[0] = 0;
469                            pbCmdExtended[1] = 0xDA;
470                            if (File.dwTlv > 0)
471                            {
472                                    pbCmdExtended[2] = (BYTE) (File.dwTlv / 0x100);
473                                    pbCmdExtended[3] = (BYTE) (File.dwTlv % 0x100);
474                            }
475                            else
476                            {
477                                    pbCmdExtended[2] = (BYTE) (File.dwTag / 0x100);
478                                    pbCmdExtended[3] = (BYTE) (File.dwTag % 0x100);
479                            }
480                            pbCmdExtended[4] = 0;
481                            pbCmdExtended[5] = (BYTE)(dwSize / 0x100);
482                            pbCmdExtended[6] = (BYTE)(dwSize % 0x100);
483                            memcpy(pbCmdExtended + 7, pbData, dwSize);
484                            dwReturn = OCardSendCommand(pCardData, pbCmdExtended, dwCmdSize);
485                            if (dwReturn)
486                            {
487                                    __leave;
488                            }
489                    }
490            }
491            __finally
492            {
493                    if(pbCmdExtended)
494                            pCardData->pfnCspFree(pbCmdExtended);
495            }
496            Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
497            return dwReturn;
498    }
499    
500    DWORD OCardWriteFile(__in PCARD_DATA  pCardData,
501                                            __in_opt PSTR szDirectory, __in PSTR szFile,
502                                            __in PBYTE pbData, __in DWORD dwSize)
503    {
504            DWORD dwI;
505            DWORD dwReturn = 0;
506            BOOL fDirectoryFound = FALSE;
507            BOOL fFileFound = FALSE;
508            __try
509            {
510    
511                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
512                  {                  {
# Line 368  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 517  DWORD SCardWriteFile(__in PCARD_DATA  pC
517                          }                          }
518                          else                          else
519                          {                          {
520                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
521                          }                          }
522                          if (fMatch)                          if (fMatch)
523                          {                          {
524                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
525                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
526                                  {                                  {
527                                          fFileFound = TRUE;                                          fFileFound = TRUE;
528                                          break;                                          break;
# Line 396  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 545  DWORD SCardWriteFile(__in PCARD_DATA  pC
545                  }                  }
546                  if (Files[dwI].dwFileType == StoredOnSmartCard)                  if (Files[dwI].dwFileType == StoredOnSmartCard)
547                  {                  {
548                          // 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;  
                         }  
549                  }                  }
550                  else                  else
551                  {                  {
# Line 422  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 553  DWORD SCardWriteFile(__in PCARD_DATA  pC
553                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_SECURITY_VIOLATION %S",szFile);                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_SECURITY_VIOLATION %S",szFile);
554                          __leave;                          __leave;
555                  }                  }
   
                   
556          }          }
557          __finally          __finally
558          {          {
# Line 432  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 561  DWORD SCardWriteFile(__in PCARD_DATA  pC
561          return dwReturn;          return dwReturn;
562  }  }
563    
564  DWORD SCardDeleteFile(__in PCARD_DATA  pCardData,  DWORD OCardDeleteFile(__in PCARD_DATA  pCardData,
565                                          __in_opt PSTR szDirectory, __in PSTR szFile)                                          __in_opt PSTR szDirectory, __in PSTR szFile)
566  {  {
567          return SCardWriteFile(pCardData, szDirectory, szFile, NULL, 0);          return OCardWriteFile(pCardData, szDirectory, szFile, NULL, 0);
568  }  }
569    
570  // just change the flag in Files  // just change the flag in Files
571  DWORD SCardCreateFile(__in PCARD_DATA  pCardData,  DWORD OCardCreateFile(__in PCARD_DATA  pCardData,
572                                          __in_opt PSTR szDirectory, __in PSTR szFile)                                          __in_opt PSTR szDirectory, __in PSTR szFile)
573  {  {
574          DWORD dwI;          DWORD dwI;
# Line 457  DWORD SCardCreateFile(__in PCARD_DATA  p Line 586  DWORD SCardCreateFile(__in PCARD_DATA  p
586                          }                          }
587                          else                          else
588                          {                          {
589                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
590                          }                          }
591                          if (fMatch)                          if (fMatch)
592                          {                          {
593                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
594                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
595                                  {                                  {
596                                          fFileFound = TRUE;                                          fFileFound = TRUE;
597                                          break;                                          break;
Legend:
Removed from v.1  
changed lines
  Added in v.11
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26