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 },
        {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	6	{NULL, szCARD_IDENTIFIER_FILE, StoredOnSmartCard, 0x4F, 0, EveryoneReadAdminWriteAc},
72	vletoux	1	{NULL, szCARD_APPLICATION_FILE, Virtual, 0, 0, EveryoneReadAdminWriteAc},
73			{NULL, szCACHE_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
74			{szBASE_CSP_DIR, szCONTAINER_MAP_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
75	vletoux	11	{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	vletoux	1
78			};
79
80			DWORD dwFileCount = ARRAYSIZE(Files);
81
82	vletoux	8	DWORD OCardDirectoryList(__in PCARD_DATA pCardData,
83	vletoux	1	__in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)
84			{
85			// hardcoded
86			*pdwResponseSize = 16;
87			pbResponse = pCardData->pfnCspAlloc(pdwResponseSize);
88			if (!*pbResponse)
89			{
90			return SCARD_E_NO_MEMORY;
91			}
92			memcpy(pbResponse, "openpgp\0mscp\0\0\0\0", pdwResponseSize);
93			return 0;
94			}
95
96	vletoux	8
97	vletoux	1	// read file
98	vletoux	8	DWORD OCardReadFile(__in PCARD_DATA pCardData,
99	vletoux	1	__in_opt PSTR szDirectory, __in PSTR szFile,
100	vletoux	6	__in PBYTE* ppbResponse, __in PDWORD pdwResponseSize)
101	vletoux	1	{
102			DWORD dwI;
103			DWORD dwReturn = 0;
104			BOOL fDirectoryFound = FALSE;
105			BOOL fFileFound = FALSE;
106	vletoux	11	BYTE pbCmd[] = {0x00, 0xCA, 0x00, 0x00, 0x00, 0x00,0x00};
107	vletoux	1	DWORD dwCmdSize = ARRAYSIZE(pbCmd);
108			POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;
109	vletoux	6	PBYTE pbData = NULL;
110	vletoux	1	__try
111			{
112	vletoux	6	*pdwResponseSize = 0;
113	vletoux	1	for(dwI = 0; dwI < dwFileCount; dwI++)
114			{
115			BOOL fMatch = FALSE;
116			if (szDirectory == NULL)
117			{
118			if (!Files[dwI].szDirectory) fMatch = TRUE;
119			}
120			else
121			{
122	vletoux	8	if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
123	vletoux	1	}
124			if (fMatch)
125			{
126			fDirectoryFound = TRUE;
127	vletoux	8	if (_stricmp(szFile, Files[dwI].szFile) == 0)
128	vletoux	1	{
129			fFileFound = TRUE;
130			break;
131			}
132			}
133			}
134			if (!fFileFound)
135			{
136			if (fDirectoryFound)
137			{
138			dwReturn = SCARD_E_FILE_NOT_FOUND;
139			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
140			}
141			else
142			{
143			dwReturn = SCARD_E_DIR_NOT_FOUND;
144			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szDirectory);
145			}
146			__leave;
147			}
148			if (Files[dwI].dwFileType == StoredOnSmartCard)
149			{
150	vletoux	6	pbCmd[2] = (BYTE) (Files[dwI].dwTag / 0x100);
151			pbCmd[3] = (BYTE) (Files[dwI].dwTag % 0x100);
152	vletoux	8	dwReturn = OCardGetData(pCardData, pbCmd, dwCmdSize, &pbData, pdwResponseSize);
153	vletoux	6	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	vletoux	11	__leave;
169	vletoux	6	}
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	vletoux	11	__leave;
177	vletoux	6	}
178			}
179			else
180			{
181			*ppbResponse = pbData;
182			// do not free the data !
183			pbData = NULL;
184			}
185	vletoux	11	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	vletoux	1	}
211			else
212			{
213			if (szDirectory == NULL)
214			{
215	vletoux	8	if (_stricmp(szFile, szCARD_APPLICATION_FILE) == 0)
216	vletoux	1	{
217	vletoux	8	dwReturn = OCardDirectoryList(pCardData, ppbResponse, pdwResponseSize);
218	vletoux	1	}
219	vletoux	8	else if (_stricmp(szFile, szCACHE_FILE) == 0)
220	vletoux	1	{
221			*pdwResponseSize = sizeof(CARD_CACHE_FILE_FORMAT);
222	vletoux	6	ppbResponse = pCardData->pfnCspAlloc(pdwResponseSize);
223			memset(ppbResponse,0,pdwResponseSize);
224	vletoux	1	}
225			else
226			{
227			dwReturn = SCARD_E_FILE_NOT_FOUND;
228			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
229			}
230			}
231	vletoux	8	else if (_stricmp(szDirectory,szBASE_CSP_DIR) == 0)
232	vletoux	1	{
233	vletoux	8	if (_stricmp(szFile, szCONTAINER_MAP_FILE) == 0)
234	vletoux	1	{
235	vletoux	8	dwReturn = OCardReadContainerMapFile(pCardData, ppbResponse, pdwResponseSize);
236	vletoux	1	}
237			else
238			{
239			dwReturn = SCARD_E_FILE_NOT_FOUND;
240			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
241			}
242			}
243			else
244			{
245			dwReturn = SCARD_E_DIR_NOT_FOUND;
246			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szDirectory);
247			}
248			}
249			if (dwReturn)
250			{
251			__leave;
252			}
253			// add to the cache
254			dwReturn = 0;
255
256			}
257			__finally
258			{
259	vletoux	6	if( pbData)
260			pCardData->pfnCspFree(pbData);
261	vletoux	1	}
262	vletoux	6	Trace(WINEVENT_LEVEL_VERBOSE, L"%S\\%S dwReturn = 0x%08X size = %d",szDirectory, szFile, dwReturn, *pdwResponseSize);
263	vletoux	1	return dwReturn;
264			}
265
266	vletoux	8	DWORD OCardEnumFile(__in PCARD_DATA pCardData,
267	vletoux	1	__in_opt PSTR szDirectory,
268			__in PBYTE* pbResponse, __in PDWORD pdwResponseSize)
269			{
270	vletoux	10	DWORD dwReturn = 0, dwTempReturn;
271	vletoux	1	DWORD dwI, dwSize;
272			BOOL fDirectoryFound = FALSE;
273	vletoux	9	BOOL fAddToOuput;
274	vletoux	1	__try
275			{
276			*pbResponse = NULL;
277			*pdwResponseSize = 0;
278	vletoux	9
279			// compute the max size of the buffer
280			dwSize = 0;
281	vletoux	1	for(dwI = 0; dwI < dwFileCount; dwI++)
282			{
283			BOOL fMatch = FALSE;
284			if (szDirectory == NULL)
285			{
286			if (!Files[dwI].szDirectory) fMatch = TRUE;
287			}
288			else
289			{
290	vletoux	8	if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
291	vletoux	1	}
292	vletoux	9	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	vletoux	1	if (fMatch)
316			{
317			fDirectoryFound = TRUE;
318	vletoux	9	fAddToOuput = TRUE;
319			if (Files[dwI].dwFlag & OPENPGP_FILE_WRITE_ONLY)
320	vletoux	1	{
321	vletoux	9	fAddToOuput = FALSE;
322			}
323			if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING))
324			{
325	vletoux	1	PBYTE pbData = NULL;
326			DWORD dwSize;
327	vletoux	9	fAddToOuput = FALSE;
328	vletoux	1	// check if the file exists and be read
329	vletoux	10	dwTempReturn = OCardReadFile(pCardData, szDirectory, Files[dwI].szFile, &pbData, &dwSize);
330			if (!dwTempReturn)
331	vletoux	1	{
332			pCardData->pfnCspFree(pbData);
333	vletoux	9	if (dwSize > 0)
334			{
335			fAddToOuput = TRUE;
336			}
337	vletoux	1	}
338			}
339	vletoux	10	if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_CONF_IS_AUTH))
340			{
341			dwTempReturn = OCardIsConfidentialityKeyTheSameThanAuthentication(pCardData);
342	vletoux	11	if (dwTempReturn)
343	vletoux	10	{
344			fAddToOuput = FALSE;
345			}
346			}
347	vletoux	9	if (fAddToOuput)
348	vletoux	1	{
349			dwSize = (DWORD) strlen( Files[dwI].szFile) + 1;
350			memcpy(pbResponse + pdwResponseSize, Files[dwI].szFile, dwSize);
351			*pdwResponseSize += dwSize;
352			}
353			}
354			}
355			if (!fDirectoryFound)
356			{
357			dwReturn = SCARD_E_DIR_NOT_FOUND;
358			__leave;
359			}
360			(pbResponse)[pdwResponseSize] = '\0';
361			*pdwResponseSize += 1;
362			dwReturn = 0;
363			}
364			__finally
365			{
366			}
367			Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
368			return dwReturn;
369			}
370
371			// read file
372	vletoux	8	DWORD OCardGetFileInfo(__in PCARD_DATA pCardData,
373	vletoux	1	__in_opt PSTR szDirectory, __in PSTR szFile,
374			__inout PCARD_FILE_INFO pCardFileInfo)
375			{
376			DWORD dwReturn = 0;
377			PBYTE pbData = NULL;
378			DWORD dwSize, dwI;
379			__try
380			{
381	vletoux	8	dwReturn = OCardReadFile(pCardData, szDirectory, szFile, &pbData, &dwSize);
382	vletoux	1	if (dwReturn)
383			{
384			__leave;
385			}
386			pCardData->pfnCspFree(pbData);
387			pCardFileInfo->cbFileSize = dwSize;
388			pCardFileInfo->AccessCondition = InvalidAc;
389			for(dwI = 0; dwI < dwFileCount; dwI++)
390			{
391	vletoux	8	BOOL fMatch = FALSE;
392			if (szDirectory == NULL)
393	vletoux	1	{
394	vletoux	8	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	vletoux	1	{
404			pCardFileInfo->AccessCondition = Files[dwI].dwAccess;
405			break;
406			}
407			}
408			}
409			dwReturn = 0;
410			}
411			__finally
412			{
413			}
414			Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
415			return dwReturn;
416			}
417
418	vletoux	11	DWORD OCardWriteFileOnSmartCard(__in PCARD_DATA pCardData,
419			__in OPENPGP_FILE File,
420	vletoux	1	__in PBYTE pbData, __in DWORD dwSize)
421			{
422			DWORD dwReturn = 0;
423			BYTE pbCmd[5 + 256] = {0x00, 0xDA, 0x00, 0x00, 0x00};
424			DWORD dwCmdSize = 0;
425	vletoux	11	PBYTE pbCmdExtended = NULL;
426	vletoux	1	__try
427			{
428	vletoux	11	if (dwSize > 0xFFFF)
429	vletoux	1	{
430			dwReturn = SCARD_E_INVALID_PARAMETER;
431			Trace(WINEVENT_LEVEL_ERROR, L"dwSize %d",dwSize);
432			__leave;
433			}
434	vletoux	11	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	vletoux	1
500	vletoux	11	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	vletoux	1
511			for(dwI = 0; dwI < dwFileCount; dwI++)
512			{
513			BOOL fMatch = FALSE;
514			if (szDirectory == NULL)
515			{
516			if (!Files[dwI].szDirectory) fMatch = TRUE;
517			}
518			else
519			{
520	vletoux	8	if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
521	vletoux	1	}
522			if (fMatch)
523			{
524			fDirectoryFound = TRUE;
525	vletoux	8	if (_stricmp(szFile, Files[dwI].szFile) == 0)
526	vletoux	1	{
527			fFileFound = TRUE;
528			break;
529			}
530			}
531			}
532			if (!fFileFound)
533			{
534			if (fDirectoryFound)
535			{
536			dwReturn = SCARD_E_FILE_NOT_FOUND;
537			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
538			}
539			else
540			{
541			dwReturn = SCARD_E_DIR_NOT_FOUND;
542			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szDirectory);
543			}
544			__leave;
545			}
546			if (Files[dwI].dwFileType == StoredOnSmartCard)
547			{
548	vletoux	11	dwReturn = OCardWriteFileOnSmartCard(pCardData, Files[dwI], pbData, dwSize);
549	vletoux	1	}
550			else
551			{
552			dwReturn = SCARD_W_SECURITY_VIOLATION;
553			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_SECURITY_VIOLATION %S",szFile);
554			__leave;
555			}
556			}
557			__finally
558			{
559			}
560			Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
561			return dwReturn;
562			}
563
564	vletoux	8	DWORD OCardDeleteFile(__in PCARD_DATA pCardData,
565	vletoux	1	__in_opt PSTR szDirectory, __in PSTR szFile)
566			{
567	vletoux	8	return OCardWriteFile(pCardData, szDirectory, szFile, NULL, 0);
568	vletoux	1	}
569
570			// just change the flag in Files
571	vletoux	8	DWORD OCardCreateFile(__in PCARD_DATA pCardData,
572	vletoux	1	__in_opt PSTR szDirectory, __in PSTR szFile)
573			{
574			DWORD dwI;
575			DWORD dwReturn = 0;
576			BOOL fDirectoryFound = FALSE;
577			BOOL fFileFound = FALSE;
578			__try
579			{
580			for(dwI = 0; dwI < dwFileCount; dwI++)
581			{
582			BOOL fMatch = FALSE;
583			if (szDirectory == NULL)
584			{
585			if (!Files[dwI].szDirectory) fMatch = TRUE;
586			}
587			else
588			{
589	vletoux	8	if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
590	vletoux	1	}
591			if (fMatch)
592			{
593			fDirectoryFound = TRUE;
594	vletoux	8	if (_stricmp(szFile, Files[dwI].szFile) == 0)
595	vletoux	1	{
596			fFileFound = TRUE;
597			break;
598			}
599			}
600			}
601			if (!fDirectoryFound)
602			{
603			dwReturn = SCARD_E_DIR_NOT_FOUND;
604			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_DIR_NOT_FOUND %S",szFile);
605			__leave;
606			}
607			if (!fFileFound)
608			{
609			dwReturn = SCARD_W_SECURITY_VIOLATION;
610			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_W_SECURITY_VIOLATION %S",szFile);
611			__leave;
612			}
613
614			}
615			__finally
616			{
617			}
618			Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
619			return dwReturn;
620			}