trunk/OpenPGPminidriver/PublicDataOperations.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 <stdio.h>
#include <cardmod.h>
#include "Tracing.h"
#include "Context.h"
#include "SmartCard.h"
#include "PublicDataOperations.h"
#include "CryptoOperations.h"
#include "tlv.h"

typedef enum _OPENPGP_FILE_TYPE
{
        StoredOnSmartCard,
        Virtual,
} OPENPGP_FILE_TYPE;

#define OPENPGP_FILE_OPTIONAL 1
#define OPENPGP_FILE_WRITE_ONLY 2
#define OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING 4
#define OPENPGP_FILE_CONF_IS_AUTH 8

typedef struct _OPENPGP_FILE
{
        PCHAR szDirectory;
        PCHAR szFile;
        OPENPGP_FILE_TYPE dwFileType;
        DWORD dwTag;
        DWORD dwTlv;
        CARD_FILE_ACCESS_CONDITION dwAccess;
        DWORD dwFlag;
} OPENPGP_FILE, *POPENPGP_FILE;


#define szCARD_APPLICATION_FILE "cardapps"

OPENPGP_FILE Files[] =
{
        {szOpenPGPDir, szOpenPGPFingerprint, StoredOnSmartCard, 0x6E, 0xC5, EveryoneReadAdminWriteAc},
        {szOpenPGPDir, szOpenPGPStatus, StoredOnSmartCard, 0xC4, 0, EveryoneReadAdminWriteAc},
        {szOpenPGPDir, szOpenPGPStatusPW1, StoredOnSmartCard, 0xC4, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_WRITE_ONLY},
        {szOpenPGPDir, szOpenPGPApplicationIdentifier, StoredOnSmartCard, 0x4F, 0, UnknownAc},
        {szOpenPGPDir, szOpenPGPLogin, StoredOnSmartCard, 0x5E, 0, EveryoneReadAdminWriteAc},
        {szOpenPGPDir, szOpenPGPName, StoredOnSmartCard, 0x65, 0x5B, EveryoneReadAdminWriteAc},
        {szOpenPGPDir, szOpenPGPLanguage, StoredOnSmartCard, 0x65, 0x5F2D, EveryoneReadAdminWriteAc},
        {szOpenPGPDir, szOpenPGPSex, StoredOnSmartCard, 0x65, 0x5F35,EveryoneReadAdminWriteAc},
        {szOpenPGPDir, szOpenPGPUrl, StoredOnSmartCard, 0x5F50, 0, EveryoneReadAdminWriteAc},
        {szOpenPGPDir, szOpenPGPHistoricalBytes, StoredOnSmartCard, 0x5F52, 0, UnknownAc},
        {szOpenPGPDir, szOpenPGPCertificate, StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc},
        {szOpenPGPDir, szOpenPGPExtendedCap, StoredOnSmartCard, 0x6E, 0xC0, UnknownAc},
        {szOpenPGPDir, szOpenPGPAlgoAttributesSignature, StoredOnSmartCard, 0x6E, 0xC1, UnknownAc},
        {szOpenPGPDir, szOpenPGPAlgoAttributesDecryption, StoredOnSmartCard, 0x6E, 0xC2,UnknownAc},
        {szOpenPGPDir, szOpenPGPAlgoAttributesAuthentication, StoredOnSmartCard, 0x6E, 0xC3, UnknownAc },
        {szOpenPGPDir, szOpenPGPPUK, StoredOnSmartCard, 0xD3, 0, UnknownAc, OPENPGP_FILE_WRITE_ONLY },
        {szOpenPGPDir, szOpenPGPSecureMessaging, StoredOnSmartCard, 0xF4, 0, UnknownAc, OPENPGP_FILE_WRITE_ONLY },
        {szOpenPGPDir, szOpenPGPSecureMessagingCryptographicCheksum, StoredOnSmartCard, 0xD2, 0, UnknownAc, OPENPGP_FILE_WRITE_ONLY },
        {szOpenPGPDir, szOpenPGPSecureMessagingCryptogram, StoredOnSmartCard, 0xD1, 0, UnknownAc, OPENPGP_FILE_WRITE_ONLY },
        {NULL, szCARD_IDENTIFIER_FILE, StoredOnSmartCard, 0x4F, 0, EveryoneReadAdminWriteAc},
        {NULL, szCARD_APPLICATION_FILE, Virtual, 0, 0, EveryoneReadAdminWriteAc},
        {NULL, szCACHE_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
        {szBASE_CSP_DIR, szCONTAINER_MAP_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
        {szBASE_CSP_DIR, "kxc01", StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING | OPENPGP_FILE_CONF_IS_AUTH},
        {szBASE_CSP_DIR, "ksc02", StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING},

};

DWORD dwFileCount = ARRAYSIZE(Files);

DWORD OCardDirectoryList(__in PCARD_DATA  pCardData, 
                                        __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)
{
        // hardcoded
        *pdwResponseSize = 16;
        *pbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);
        if (!*pbResponse)
        {
                return SCARD_E_NO_MEMORY;
        }
        memcpy(*pbResponse, "openpgp\0mscp\0\0\0\0", *pdwResponseSize);
        return 0;
}


// read file
DWORD OCardReadFile(__in PCARD_DATA  pCardData, 
                                        __in_opt PSTR szDirectory, __in PSTR szFile,
                                        __in PBYTE* ppbResponse, __in PDWORD pdwResponseSize)
{
        DWORD dwI;
        DWORD dwReturn = 0;
        BOOL fDirectoryFound = FALSE;
        BOOL fFileFound = FALSE;
        BYTE pbCmd[] = {0x00, 0xCA, 0x00, 0x00, 0x00, 0x00,0x00};
        DWORD dwCmdSize = ARRAYSIZE(pbCmd);
        POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;
        PBYTE pbData = NULL;
        __try
        {
                *pdwResponseSize = 0;
                for(dwI = 0; dwI < dwFileCount; dwI++)
                {
                        BOOL fMatch = FALSE;
                        if (szDirectory == NULL)
                        {
                                if (!Files[dwI].szDirectory) fMatch = TRUE;
                        }
                        else
                        {
                                if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
                        }
                        if (fMatch)
                        {
                                fDirectoryFound = TRUE;
                                if (_stricmp(szFile, Files[dwI].szFile) == 0)
                                {
                                        fFileFound = TRUE;
                                        break;
                                }
                        }
                }
                if (!fFileFound)
                {
                        if (fDirectoryFound)
                        {
                                dwReturn = SCARD_E_FILE_NOT_FOUND;
                                Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
                        }
                        else
                        {
                                dwReturn = SCARD_E_DIR_NOT_FOUND;
                                Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szDirectory);
                        }       
                        __leave;
                }
                if (Files[dwI].dwFileType == StoredOnSmartCard)
                {
                        pbCmd[2] = (BYTE) (Files[dwI].dwTag / 0x100);
                        pbCmd[3] = (BYTE) (Files[dwI].dwTag % 0x100);
                        dwReturn = OCardGetData(pCardData, pbCmd, dwCmdSize, &pbData, pdwResponseSize);
                        if (dwReturn)
                        {
                                __leave;
                        }
                        if (Files[dwI].dwTlv)
                        {
                                PBYTE pbPointer;
                                //TraceDump(0,pbData,*pdwResponseSize);
                                if (find_tlv(pbData, Files[dwI].dwTlv, *pdwResponseSize, &pbPointer, pdwResponseSize))
                                {
                                        *ppbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);
                                        if (!*ppbResponse )
                                        {
                                                Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_MEMORY");
                                                dwReturn = SCARD_E_NO_MEMORY;
                                                __leave;
                                        }
                                        memcpy(*ppbResponse, pbPointer, *pdwResponseSize);
                                }
                                else
                                {
                                        dwReturn = SCARD_E_FILE_NOT_FOUND;
                                        Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
                                        __leave;
                                }
                        }
                        else
                        {
                                *ppbResponse = pbData;
                                // do not free the data !
                                pbData = NULL;
                        }
                        if (Files[dwI].dwFlag & OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING)
                        {
                                if (*pdwResponseSize == 0)
                                {
                                        pCardData->pfnCspFree(*ppbResponse);
                                        *pdwResponseSize = 0;
                                        *ppbResponse = NULL;
                                        dwReturn = SCARD_E_FILE_NOT_FOUND;
                                        Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING",szFile);
                                        __leave;
                                }
                        }
                        if (Files[dwI].dwFlag & OPENPGP_FILE_CONF_IS_AUTH)
                        {
                                DWORD dwTempReturn = OCardIsConfidentialityKeyTheSameThanAuthentication(pCardData);
                                if (dwTempReturn)
                                {
                                        pCardData->pfnCspFree(*ppbResponse);
                                        *pdwResponseSize = 0;
                                        *ppbResponse = NULL;
                                        dwReturn = SCARD_E_FILE_NOT_FOUND;
                                        Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S OPENPGP_FILE_CONF_IS_AUTH",szFile);
                                        __leave;
                                }
                        }
                }
                else
                {
                        if (szDirectory == NULL)
                        {
                                if (_stricmp(szFile, szCARD_APPLICATION_FILE) == 0)
                                {
                                        dwReturn = OCardDirectoryList(pCardData, ppbResponse, pdwResponseSize);
                                }
                                else if (_stricmp(szFile, szCACHE_FILE) == 0)
                                {
                                        *pdwResponseSize = sizeof(CARD_CACHE_FILE_FORMAT);
                                        *ppbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);
                                        memset(*ppbResponse,0,*pdwResponseSize);
                                }
                                else
                                {
                                        dwReturn = SCARD_E_FILE_NOT_FOUND;
                                        Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
                                }
                        }
                        else if (_stricmp(szDirectory,szBASE_CSP_DIR) == 0)
                        {
                                if (_stricmp(szFile, szCONTAINER_MAP_FILE) == 0)
                                {
                                        dwReturn = OCardReadContainerMapFile(pCardData, ppbResponse, pdwResponseSize);
                                }
                                else
                                {
                                        dwReturn = SCARD_E_FILE_NOT_FOUND;
                                        Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
                                }
                        }
                        else
                        {
                                dwReturn = SCARD_E_DIR_NOT_FOUND;
                                Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szDirectory);
                        }
                }
                if (dwReturn)
                {
                        __leave;
                }
                // add to the cache
                dwReturn = 0;

        }
        __finally
        {
                if( pbData)
                        pCardData->pfnCspFree(pbData);
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"%S\\%S dwReturn = 0x%08X size = %d",szDirectory, szFile, dwReturn, *pdwResponseSize);
        return dwReturn;
}

DWORD OCardEnumFile(__in PCARD_DATA  pCardData, 
                                        __in_opt PSTR szDirectory,
                                        __in PBYTE* pbResponse, __in PDWORD pdwResponseSize)
{
        DWORD dwReturn = 0, dwTempReturn;
        DWORD dwI, dwSize;
        BOOL fDirectoryFound = FALSE;
        BOOL fAddToOuput;
        __try
        {
                *pbResponse = NULL;
                *pdwResponseSize = 0;
                
                // compute the max size of the buffer
                dwSize = 0;
                for(dwI = 0; dwI < dwFileCount; dwI++)
                {
                        BOOL fMatch = FALSE;
                        if (szDirectory == NULL)
                        {
                                if (!Files[dwI].szDirectory) fMatch = TRUE;
                        }
                        else
                        {
                                if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
                        }
                        if (fMatch && !(Files[dwI].dwFileType & OPENPGP_FILE_WRITE_ONLY))
                        {
                                dwSize += (DWORD) strlen( Files[dwI].szFile) + 1;
                        }
                }
                dwSize += 1;
                *pbResponse = pCardData->pfnCspAlloc(dwSize);
                if (!*pbResponse)
                {
                        dwReturn = SCARD_E_NO_MEMORY;
                        __leave;
                }
                for(dwI = 0; dwI < dwFileCount; dwI++)
                {
                        BOOL fMatch = FALSE;
                        if (szDirectory == NULL)
                        {
                                if (!Files[dwI].szDirectory) fMatch = TRUE;
                        }
                        else
                        {
                                if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
                        }
                        if (fMatch)
                        {
                                fDirectoryFound = TRUE;
                                fAddToOuput = TRUE;
                                if (Files[dwI].dwFlag & OPENPGP_FILE_WRITE_ONLY)
                                {
                                        fAddToOuput = FALSE;
                                }
                                if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING))
                                {
                                        PBYTE pbData = NULL;
                                        DWORD dwSize;
                                        fAddToOuput = FALSE;
                                        // check if the file exists and be read
                                        dwTempReturn = OCardReadFile(pCardData, szDirectory, Files[dwI].szFile, &pbData, &dwSize);
                                        if (!dwTempReturn)
                                        {
                                                pCardData->pfnCspFree(pbData);
                                                if (dwSize > 0)
                                                {
                                                        fAddToOuput = TRUE;
                                                }
                                        }
                                }
                                if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_CONF_IS_AUTH))
                                {
                                        dwTempReturn = OCardIsConfidentialityKeyTheSameThanAuthentication(pCardData);
                                        if (dwTempReturn)
                                        {
                                                fAddToOuput = FALSE;
                                        }
                                }
                                if (fAddToOuput)
                                {
                                        dwSize = (DWORD) strlen( Files[dwI].szFile) + 1;
                                        memcpy(*pbResponse + *pdwResponseSize,  Files[dwI].szFile, dwSize);
                                        *pdwResponseSize += dwSize;
                                }
                        }
                }
                if (!fDirectoryFound)
                {
                        dwReturn = SCARD_E_DIR_NOT_FOUND;
                        __leave;
                }
                (*pbResponse)[*pdwResponseSize] = '\0';
                *pdwResponseSize += 1;
                dwReturn = 0;
        }
        __finally
        {
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
        return dwReturn;
}

// read file
DWORD OCardGetFileInfo(__in PCARD_DATA  pCardData, 
                                        __in_opt PSTR szDirectory, __in PSTR szFile,
                                         __inout PCARD_FILE_INFO  pCardFileInfo)
{
        DWORD dwReturn = 0;
        PBYTE pbData = NULL;
        DWORD dwSize, dwI;
        __try
        {
                dwReturn = OCardReadFile(pCardData, szDirectory, szFile, &pbData, &dwSize);
                if (dwReturn)
                {
                        __leave;
                }
                pCardData->pfnCspFree(pbData);
                pCardFileInfo->cbFileSize = dwSize;
                pCardFileInfo->AccessCondition = InvalidAc;
                for(dwI = 0; dwI < dwFileCount; dwI++)
                {
                        BOOL fMatch = FALSE;
                        if (szDirectory == NULL)
                        {
                                if (!Files[dwI].szDirectory) fMatch = TRUE;
                        }
                        else
                        {
                                if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
                        }
                        if (fMatch)
                        {
                                if (_stricmp(szFile, Files[dwI].szFile) == 0)
                                {
                                        pCardFileInfo->AccessCondition = Files[dwI].dwAccess;
                                        break;
                                }
                        }
                }
                dwReturn = 0;
        }
        __finally
        {
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
        return dwReturn;        
}

DWORD OCardWriteFileOnSmartCard(__in PCARD_DATA  pCardData, 
                                        __in OPENPGP_FILE File,
                                        __in PBYTE pbData, __in DWORD dwSize)
{
        DWORD dwReturn = 0;
        BYTE pbCmd[5 + 256] = {0x00, 0xDA, 0x00, 0x00, 0x00};
        DWORD dwCmdSize = 0;
        PBYTE pbCmdExtended = NULL;
        __try
        {
                if (dwSize > 0xFFFF)
                {
                        dwReturn = SCARD_E_INVALID_PARAMETER;
                        Trace(WINEVENT_LEVEL_ERROR, L"dwSize %d",dwSize);
                        __leave;
                }
                if (dwSize < 256)
                {
                        if (File.dwTlv > 0)
                        {
                                pbCmd[2] = (BYTE) (File.dwTlv / 0x100);
                                pbCmd[3] = (BYTE) (File.dwTlv % 0x100);
                        }
                        else
                        {
                                pbCmd[2] = (BYTE) (File.dwTag / 0x100);
                                pbCmd[3] = (BYTE) (File.dwTag % 0x100);
                        }
                        pbCmd[4] = (BYTE) dwSize;
                        if (dwSize)
                        {
                                memcpy(pbCmd + 5, pbData, dwSize);
                        }
                        dwCmdSize = dwSize + 5;
                        dwReturn = OCardSendCommand(pCardData, pbCmd, dwCmdSize);
                        if (dwReturn)
                        {
                                __leave;
                        }
                }
                else
                {
                        dwCmdSize = dwSize + 7;
                        pbCmdExtended = pCardData->pfnCspAlloc(dwCmdSize);
                        if (!pbCmdExtended)
                        {
                                Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_MEMORY");
                                dwReturn = SCARD_E_NO_MEMORY;
                                __leave;
                        }
                        pbCmdExtended[0] = 0;
                        pbCmdExtended[1] = 0xDA;
                        if (File.dwTlv > 0)
                        {
                                pbCmdExtended[2] = (BYTE) (File.dwTlv / 0x100);
                                pbCmdExtended[3] = (BYTE) (File.dwTlv % 0x100);
                        }
                        else
                        {
                                pbCmdExtended[2] = (BYTE) (File.dwTag / 0x100);
                                pbCmdExtended[3] = (BYTE) (File.dwTag % 0x100);
                        }
                        pbCmdExtended[4] = 0;
                        pbCmdExtended[5] = (BYTE)(dwSize / 0x100);
                        pbCmdExtended[6] = (BYTE)(dwSize % 0x100);
                        memcpy(pbCmdExtended + 7, pbData, dwSize);
                        dwReturn = OCardSendCommand(pCardData, pbCmdExtended, dwCmdSize);
                        if (dwReturn)
                        {
                                __leave;
                        }
                }
        }
        __finally
        {
                if(pbCmdExtended)
                        pCardData->pfnCspFree(pbCmdExtended);
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
        return dwReturn;
}

DWORD OCardWriteFile(__in PCARD_DATA  pCardData, 
                                        __in_opt PSTR szDirectory, __in PSTR szFile,
                                        __in PBYTE pbData, __in DWORD dwSize)
{
        DWORD dwI;
        DWORD dwReturn = 0;
        BOOL fDirectoryFound = FALSE;
        BOOL fFileFound = FALSE;
        __try
        {

                for(dwI = 0; dwI < dwFileCount; dwI++)
                {
                        BOOL fMatch = FALSE;
                        if (szDirectory == NULL)
                        {
                                if (!Files[dwI].szDirectory) fMatch = TRUE;
                        }
                        else
                        {
                                if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
                        }
                        if (fMatch)
                        {
                                fDirectoryFound = TRUE;
                                if (_stricmp(szFile, Files[dwI].szFile) == 0)
                                {
                                        fFileFound = TRUE;
                                        break;
                                }
                        }
                }
                if (!fFileFound)
                {
                        if (fDirectoryFound)
                        {
                                dwReturn = SCARD_E_FILE_NOT_FOUND;
                                Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
                        }
                        else
                        {
                                dwReturn = SCARD_E_DIR_NOT_FOUND;
                                Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szDirectory);
                        }       
                        __leave;
                }
                if (Files[dwI].dwFileType == StoredOnSmartCard)
                {
                        dwReturn = OCardWriteFileOnSmartCard(pCardData, Files[dwI], pbData, dwSize);
                }
                else
                {
                        dwReturn = SCARD_W_SECURITY_VIOLATION;
                        Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_SECURITY_VIOLATION %S",szFile);
                        __leave;
                }
        }
        __finally
        {
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
        return dwReturn;
}

DWORD OCardDeleteFile(__in PCARD_DATA  pCardData, 
                                        __in_opt PSTR szDirectory, __in PSTR szFile)
{
        return OCardWriteFile(pCardData, szDirectory, szFile, NULL, 0);
}

// just change the flag in Files
DWORD OCardCreateFile(__in PCARD_DATA  pCardData, 
                                        __in_opt PSTR szDirectory, __in PSTR szFile)
{
        DWORD dwI;
        DWORD dwReturn = 0;
        BOOL fDirectoryFound = FALSE;
        BOOL fFileFound = FALSE;
        __try
        {
                for(dwI = 0; dwI < dwFileCount; dwI++)
                {
                        BOOL fMatch = FALSE;
                        if (szDirectory == NULL)
                        {
                                if (!Files[dwI].szDirectory) fMatch = TRUE;
                        }
                        else
                        {
                                if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
                        }
                        if (fMatch)
                        {
                                fDirectoryFound = TRUE;
                                if (_stricmp(szFile, Files[dwI].szFile) == 0)
                                {
                                        fFileFound = TRUE;
                                        break;
                                }
                        }
                }
                if (!fDirectoryFound)
                {
                        dwReturn = SCARD_E_DIR_NOT_FOUND;
                        Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szFile);
                        __leave;
                }
                if (!fFileFound)
                {
                        dwReturn = SCARD_W_SECURITY_VIOLATION;
                        Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_SECURITY_VIOLATION %S",szFile);
                        __leave;
                }
                
        }
        __finally
        {
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
        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 <stdio.h>
20			#include <cardmod.h>
21			#include "Tracing.h"
22			#include "Context.h"
23			#include "SmartCard.h"
24			#include "PublicDataOperations.h"
25			#include "CryptoOperations.h"
26	vletoux	6	#include "tlv.h"
27	vletoux	1
28			typedef enum _OPENPGP_FILE_TYPE
29			{
30			StoredOnSmartCard,
31			Virtual,
32			} OPENPGP_FILE_TYPE;
33
34	vletoux	9	#define OPENPGP_FILE_OPTIONAL 1
35			#define OPENPGP_FILE_WRITE_ONLY 2
36			#define OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING 4
37	vletoux	10	#define OPENPGP_FILE_CONF_IS_AUTH 8
38	vletoux	9
39	vletoux	1	typedef struct _OPENPGP_FILE
40			{
41			PCHAR szDirectory;
42			PCHAR szFile;
43			OPENPGP_FILE_TYPE dwFileType;
44	vletoux	6	DWORD dwTag;
45			DWORD dwTlv;
46	vletoux	1	CARD_FILE_ACCESS_CONDITION dwAccess;
47	vletoux	9	DWORD dwFlag;
48	vletoux	1	} OPENPGP_FILE, *POPENPGP_FILE;
49
50
51			#define szCARD_APPLICATION_FILE "cardapps"
52
53			OPENPGP_FILE Files[] =
54			{
55	vletoux	6	{szOpenPGPDir, szOpenPGPFingerprint, StoredOnSmartCard, 0x6E, 0xC5, EveryoneReadAdminWriteAc},
56			{szOpenPGPDir, szOpenPGPStatus, StoredOnSmartCard, 0xC4, 0, EveryoneReadAdminWriteAc},
57	vletoux	11	{szOpenPGPDir, szOpenPGPStatusPW1, StoredOnSmartCard, 0xC4, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_WRITE_ONLY},
58	vletoux	6	{szOpenPGPDir, szOpenPGPApplicationIdentifier, StoredOnSmartCard, 0x4F, 0, UnknownAc},
59			{szOpenPGPDir, szOpenPGPLogin, StoredOnSmartCard, 0x5E, 0, EveryoneReadAdminWriteAc},
60			{szOpenPGPDir, szOpenPGPName, StoredOnSmartCard, 0x65, 0x5B, EveryoneReadAdminWriteAc},
61			{szOpenPGPDir, szOpenPGPLanguage, StoredOnSmartCard, 0x65, 0x5F2D, EveryoneReadAdminWriteAc},
62			{szOpenPGPDir, szOpenPGPSex, StoredOnSmartCard, 0x65, 0x5F35,EveryoneReadAdminWriteAc},
63			{szOpenPGPDir, szOpenPGPUrl, StoredOnSmartCard, 0x5F50, 0, EveryoneReadAdminWriteAc},
64			{szOpenPGPDir, szOpenPGPHistoricalBytes, StoredOnSmartCard, 0x5F52, 0, UnknownAc},
65	vletoux	11	{szOpenPGPDir, szOpenPGPCertificate, StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc},
66	vletoux	6	{szOpenPGPDir, szOpenPGPExtendedCap, StoredOnSmartCard, 0x6E, 0xC0, UnknownAc},
67			{szOpenPGPDir, szOpenPGPAlgoAttributesSignature, StoredOnSmartCard, 0x6E, 0xC1, UnknownAc},
68			{szOpenPGPDir, szOpenPGPAlgoAttributesDecryption, StoredOnSmartCard, 0x6E, 0xC2,UnknownAc},
69			{szOpenPGPDir, szOpenPGPAlgoAttributesAuthentication, StoredOnSmartCard, 0x6E, 0xC3, UnknownAc },
70	vletoux	9	{szOpenPGPDir, szOpenPGPPUK, StoredOnSmartCard, 0xD3, 0, UnknownAc, OPENPGP_FILE_WRITE_ONLY },
71	vletoux	12	{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	vletoux	6	{NULL, szCARD_IDENTIFIER_FILE, StoredOnSmartCard, 0x4F, 0, EveryoneReadAdminWriteAc},
75	vletoux	1	{NULL, szCARD_APPLICATION_FILE, Virtual, 0, 0, EveryoneReadAdminWriteAc},
76			{NULL, szCACHE_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
77			{szBASE_CSP_DIR, szCONTAINER_MAP_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
78	vletoux	11	{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	vletoux	1
81			};
82
83			DWORD dwFileCount = ARRAYSIZE(Files);
84
85	vletoux	8	DWORD OCardDirectoryList(__in PCARD_DATA pCardData,
86	vletoux	1	__in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)
87			{
88			// hardcoded
89			*pdwResponseSize = 16;
90			pbResponse = pCardData->pfnCspAlloc(pdwResponseSize);
91			if (!*pbResponse)
92			{
93			return SCARD_E_NO_MEMORY;
94			}
95			memcpy(pbResponse, "openpgp\0mscp\0\0\0\0", pdwResponseSize);
96			return 0;
97			}
98
99	vletoux	8
100	vletoux	1	// read file
101	vletoux	8	DWORD OCardReadFile(__in PCARD_DATA pCardData,
102	vletoux	1	__in_opt PSTR szDirectory, __in PSTR szFile,
103	vletoux	6	__in PBYTE* ppbResponse, __in PDWORD pdwResponseSize)
104	vletoux	1	{
105			DWORD dwI;
106			DWORD dwReturn = 0;
107			BOOL fDirectoryFound = FALSE;
108			BOOL fFileFound = FALSE;
109	vletoux	11	BYTE pbCmd[] = {0x00, 0xCA, 0x00, 0x00, 0x00, 0x00,0x00};
110	vletoux	1	DWORD dwCmdSize = ARRAYSIZE(pbCmd);
111			POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;
112	vletoux	6	PBYTE pbData = NULL;
113	vletoux	1	__try
114			{
115	vletoux	6	*pdwResponseSize = 0;
116	vletoux	1	for(dwI = 0; dwI < dwFileCount; dwI++)
117			{
118			BOOL fMatch = FALSE;
119			if (szDirectory == NULL)
120			{
121			if (!Files[dwI].szDirectory) fMatch = TRUE;
122			}
123			else
124			{
125	vletoux	8	if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
126	vletoux	1	}
127			if (fMatch)
128			{
129			fDirectoryFound = TRUE;
130	vletoux	8	if (_stricmp(szFile, Files[dwI].szFile) == 0)
131	vletoux	1	{
132			fFileFound = TRUE;
133			break;
134			}
135			}
136			}
137			if (!fFileFound)
138			{
139			if (fDirectoryFound)
140			{
141			dwReturn = SCARD_E_FILE_NOT_FOUND;
142			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
143			}
144			else
145			{
146			dwReturn = SCARD_E_DIR_NOT_FOUND;
147			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szDirectory);
148			}
149			__leave;
150			}
151			if (Files[dwI].dwFileType == StoredOnSmartCard)
152			{
153	vletoux	6	pbCmd[2] = (BYTE) (Files[dwI].dwTag / 0x100);
154			pbCmd[3] = (BYTE) (Files[dwI].dwTag % 0x100);
155	vletoux	8	dwReturn = OCardGetData(pCardData, pbCmd, dwCmdSize, &pbData, pdwResponseSize);
156	vletoux	6	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	vletoux	11	__leave;
172	vletoux	6	}
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	vletoux	11	__leave;
180	vletoux	6	}
181			}
182			else
183			{
184			*ppbResponse = pbData;
185			// do not free the data !
186			pbData = NULL;
187			}
188	vletoux	11	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	vletoux	1	}
214			else
215			{
216			if (szDirectory == NULL)
217			{
218	vletoux	8	if (_stricmp(szFile, szCARD_APPLICATION_FILE) == 0)
219	vletoux	1	{
220	vletoux	8	dwReturn = OCardDirectoryList(pCardData, ppbResponse, pdwResponseSize);
221	vletoux	1	}
222	vletoux	8	else if (_stricmp(szFile, szCACHE_FILE) == 0)
223	vletoux	1	{
224			*pdwResponseSize = sizeof(CARD_CACHE_FILE_FORMAT);
225	vletoux	6	ppbResponse = pCardData->pfnCspAlloc(pdwResponseSize);
226			memset(ppbResponse,0,pdwResponseSize);
227	vletoux	1	}
228			else
229			{
230			dwReturn = SCARD_E_FILE_NOT_FOUND;
231			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
232			}
233			}
234	vletoux	8	else if (_stricmp(szDirectory,szBASE_CSP_DIR) == 0)
235	vletoux	1	{
236	vletoux	8	if (_stricmp(szFile, szCONTAINER_MAP_FILE) == 0)
237	vletoux	1	{
238	vletoux	8	dwReturn = OCardReadContainerMapFile(pCardData, ppbResponse, pdwResponseSize);
239	vletoux	1	}
240			else
241			{
242			dwReturn = SCARD_E_FILE_NOT_FOUND;
243			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
244			}
245			}
246			else
247			{
248			dwReturn = SCARD_E_DIR_NOT_FOUND;
249			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szDirectory);
250			}
251			}
252			if (dwReturn)
253			{
254			__leave;
255			}
256			// add to the cache
257			dwReturn = 0;
258
259			}
260			__finally
261			{
262	vletoux	6	if( pbData)
263			pCardData->pfnCspFree(pbData);
264	vletoux	1	}
265	vletoux	6	Trace(WINEVENT_LEVEL_VERBOSE, L"%S\\%S dwReturn = 0x%08X size = %d",szDirectory, szFile, dwReturn, *pdwResponseSize);
266	vletoux	1	return dwReturn;
267			}
268
269	vletoux	8	DWORD OCardEnumFile(__in PCARD_DATA pCardData,
270	vletoux	1	__in_opt PSTR szDirectory,
271			__in PBYTE* pbResponse, __in PDWORD pdwResponseSize)
272			{
273	vletoux	10	DWORD dwReturn = 0, dwTempReturn;
274	vletoux	1	DWORD dwI, dwSize;
275			BOOL fDirectoryFound = FALSE;
276	vletoux	9	BOOL fAddToOuput;
277	vletoux	1	__try
278			{
279			*pbResponse = NULL;
280			*pdwResponseSize = 0;
281	vletoux	9
282			// compute the max size of the buffer
283			dwSize = 0;
284	vletoux	1	for(dwI = 0; dwI < dwFileCount; dwI++)
285			{
286			BOOL fMatch = FALSE;
287			if (szDirectory == NULL)
288			{
289			if (!Files[dwI].szDirectory) fMatch = TRUE;
290			}
291			else
292			{
293	vletoux	8	if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
294	vletoux	1	}
295	vletoux	9	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	vletoux	1	if (fMatch)
319			{
320			fDirectoryFound = TRUE;
321	vletoux	9	fAddToOuput = TRUE;
322			if (Files[dwI].dwFlag & OPENPGP_FILE_WRITE_ONLY)
323	vletoux	1	{
324	vletoux	9	fAddToOuput = FALSE;
325			}
326			if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING))
327			{
328	vletoux	1	PBYTE pbData = NULL;
329			DWORD dwSize;
330	vletoux	9	fAddToOuput = FALSE;
331	vletoux	1	// check if the file exists and be read
332	vletoux	10	dwTempReturn = OCardReadFile(pCardData, szDirectory, Files[dwI].szFile, &pbData, &dwSize);
333			if (!dwTempReturn)
334	vletoux	1	{
335			pCardData->pfnCspFree(pbData);
336	vletoux	9	if (dwSize > 0)
337			{
338			fAddToOuput = TRUE;
339			}
340	vletoux	1	}
341			}
342	vletoux	10	if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_CONF_IS_AUTH))
343			{
344			dwTempReturn = OCardIsConfidentialityKeyTheSameThanAuthentication(pCardData);
345	vletoux	11	if (dwTempReturn)
346	vletoux	10	{
347			fAddToOuput = FALSE;
348			}
349			}
350	vletoux	9	if (fAddToOuput)
351	vletoux	1	{
352			dwSize = (DWORD) strlen( Files[dwI].szFile) + 1;
353			memcpy(pbResponse + pdwResponseSize, Files[dwI].szFile, dwSize);
354			*pdwResponseSize += dwSize;
355			}
356			}
357			}
358			if (!fDirectoryFound)
359			{
360			dwReturn = SCARD_E_DIR_NOT_FOUND;
361			__leave;
362			}
363			(pbResponse)[pdwResponseSize] = '\0';
364			*pdwResponseSize += 1;
365			dwReturn = 0;
366			}
367			__finally
368			{
369			}
370			Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
371			return dwReturn;
372			}
373
374			// read file
375	vletoux	8	DWORD OCardGetFileInfo(__in PCARD_DATA pCardData,
376	vletoux	1	__in_opt PSTR szDirectory, __in PSTR szFile,
377			__inout PCARD_FILE_INFO pCardFileInfo)
378			{
379			DWORD dwReturn = 0;
380			PBYTE pbData = NULL;
381			DWORD dwSize, dwI;
382			__try
383			{
384	vletoux	8	dwReturn = OCardReadFile(pCardData, szDirectory, szFile, &pbData, &dwSize);
385	vletoux	1	if (dwReturn)
386			{
387			__leave;
388			}
389			pCardData->pfnCspFree(pbData);
390			pCardFileInfo->cbFileSize = dwSize;
391			pCardFileInfo->AccessCondition = InvalidAc;
392			for(dwI = 0; dwI < dwFileCount; dwI++)
393			{
394	vletoux	8	BOOL fMatch = FALSE;
395			if (szDirectory == NULL)
396	vletoux	1	{
397	vletoux	8	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	vletoux	1	{
407			pCardFileInfo->AccessCondition = Files[dwI].dwAccess;
408			break;
409			}
410			}
411			}
412			dwReturn = 0;
413			}
414			__finally
415			{
416			}
417			Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
418			return dwReturn;
419			}
420
421	vletoux	11	DWORD OCardWriteFileOnSmartCard(__in PCARD_DATA pCardData,
422			__in OPENPGP_FILE File,
423	vletoux	1	__in PBYTE pbData, __in DWORD dwSize)
424			{
425			DWORD dwReturn = 0;
426			BYTE pbCmd[5 + 256] = {0x00, 0xDA, 0x00, 0x00, 0x00};
427			DWORD dwCmdSize = 0;
428	vletoux	11	PBYTE pbCmdExtended = NULL;
429	vletoux	1	__try
430			{
431	vletoux	11	if (dwSize > 0xFFFF)
432	vletoux	1	{
433			dwReturn = SCARD_E_INVALID_PARAMETER;
434			Trace(WINEVENT_LEVEL_ERROR, L"dwSize %d",dwSize);
435			__leave;
436			}
437	vletoux	11	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	vletoux	1
503	vletoux	11	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	vletoux	1
514			for(dwI = 0; dwI < dwFileCount; dwI++)
515			{
516			BOOL fMatch = FALSE;
517			if (szDirectory == NULL)
518			{
519			if (!Files[dwI].szDirectory) fMatch = TRUE;
520			}
521			else
522			{
523	vletoux	8	if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
524	vletoux	1	}
525			if (fMatch)
526			{
527			fDirectoryFound = TRUE;
528	vletoux	8	if (_stricmp(szFile, Files[dwI].szFile) == 0)
529	vletoux	1	{
530			fFileFound = TRUE;
531			break;
532			}
533			}
534			}
535			if (!fFileFound)
536			{
537			if (fDirectoryFound)
538			{
539			dwReturn = SCARD_E_FILE_NOT_FOUND;
540			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
541			}
542			else
543			{
544			dwReturn = SCARD_E_DIR_NOT_FOUND;
545			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szDirectory);
546			}
547			__leave;
548			}
549			if (Files[dwI].dwFileType == StoredOnSmartCard)
550			{
551	vletoux	11	dwReturn = OCardWriteFileOnSmartCard(pCardData, Files[dwI], pbData, dwSize);
552	vletoux	1	}
553			else
554			{
555			dwReturn = SCARD_W_SECURITY_VIOLATION;
556			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_SECURITY_VIOLATION %S",szFile);
557			__leave;
558			}
559			}
560			__finally
561			{
562			}
563			Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
564			return dwReturn;
565			}
566
567	vletoux	8	DWORD OCardDeleteFile(__in PCARD_DATA pCardData,
568	vletoux	1	__in_opt PSTR szDirectory, __in PSTR szFile)
569			{
570	vletoux	8	return OCardWriteFile(pCardData, szDirectory, szFile, NULL, 0);
571	vletoux	1	}
572
573			// just change the flag in Files
574	vletoux	8	DWORD OCardCreateFile(__in PCARD_DATA pCardData,
575	vletoux	1	__in_opt PSTR szDirectory, __in PSTR szFile)
576			{
577			DWORD dwI;
578			DWORD dwReturn = 0;
579			BOOL fDirectoryFound = FALSE;
580			BOOL fFileFound = FALSE;
581			__try
582			{
583			for(dwI = 0; dwI < dwFileCount; dwI++)
584			{
585			BOOL fMatch = FALSE;
586			if (szDirectory == NULL)
587			{
588			if (!Files[dwI].szDirectory) fMatch = TRUE;
589			}
590			else
591			{
592	vletoux	8	if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
593	vletoux	1	}
594			if (fMatch)
595			{
596			fDirectoryFound = TRUE;
597	vletoux	8	if (_stricmp(szFile, Files[dwI].szFile) == 0)
598	vletoux	1	{
599			fFileFound = TRUE;
600			break;
601			}
602			}
603			}
604			if (!fDirectoryFound)
605			{
606			dwReturn = SCARD_E_DIR_NOT_FOUND;
607			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szFile);
608			__leave;
609			}
610			if (!fFileFound)
611			{
612			dwReturn = SCARD_W_SECURITY_VIOLATION;
613			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_SECURITY_VIOLATION %S",szFile);
614			__leave;
615			}
616
617			}
618			__finally
619			{
620			}
621			Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
622			return dwReturn;
623			}