trunk/OpenPGPminidriver/CardCryptographicOperations.c

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

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

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <windows.h>
#include <cardmod.h>
#include "Tracing.h"
#include "Context.h"
#include "CryptoOperations.h"

// 4.7 Cryptographic operations

/** This function performs an RSA decryption operation on the passed buffer
by using the private key that a container index refers to. Note that for
ECC-only smart cards, this entry point is not defined and is set to NULL 
in the returned CARD_DATA structure from CardAcquireContext. This operation
is restricted to a single buffer of a size equal to the key modulus.*/

DWORD WINAPI CardRSADecrypt(
    __in PCARD_DATA  pCardData,
    __inout PCARD_RSA_DECRYPT_INFO  pInfo
)
{
        DWORD dwReturn = 0;     
        
        Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
        __try
        {
                if ( pCardData == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }

                if ( pInfo == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pInfo == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }
                if ( pInfo->pbData == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pInfo->pbData == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }
                if (pInfo->dwVersion < CARD_RSA_KEY_DECRYPT_INFO_CURRENT_VERSION 
                        && pCardData->dwVersion == CARD_DATA_CURRENT_VERSION)
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"ERROR_REVISION_MISMATCH");
                        dwReturn  = ERROR_REVISION_MISMATCH;
                        __leave;
                }
                if (pInfo->dwKeySpec != AT_KEYEXCHANGE)
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"AT_KEYEXCHANGE %d", pInfo->dwKeySpec);
                        dwReturn  = SCARD_E_NO_KEY_CONTAINER ;
                        __leave;
                }
                if (pInfo->bContainerIndex != Confidentiality)
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"Confidentiality %d", pInfo->bContainerIndex);
                        dwReturn  = SCARD_E_NO_KEY_CONTAINER ;
                        __leave;
                }
                dwReturn = CheckContext(pCardData);
                if ( dwReturn)
                {
                        __leave;
                }
                dwReturn = SCardDecrypt(pCardData, pInfo);
        }
        __finally
        {
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
        return dwReturn;
}


/** The CardSignData function signs a block of unpadded data. This entry either performs
padding on the card or pads the data by using the PFN_CSP_PAD_DATA callback. All card 
minidrivers must support this entry point.*/

DWORD WINAPI CardSignData(
    __in PCARD_DATA  pCardData,
    __in PCARD_SIGNING_INFO  pInfo
)
{
        DWORD dwReturn = 0;     
        
        Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
        __try
        {
                if ( pCardData == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }

                if ( pInfo == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pInfo == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }
                if ( pInfo->pbData == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pInfo->pbData == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }
                dwReturn = CheckContext(pCardData);
                if ( dwReturn)
                {
                        __leave;
                }
                switch(pInfo->bContainerIndex)
                {
                case Authentication:
                        dwReturn = SCardAuthenticate(pCardData, pInfo);
                        break;
                case Signature:
                        dwReturn = SCardSign(pCardData, pInfo);
                        break;
                default:
                        dwReturn = SCARD_E_NO_KEY_CONTAINER;
                        Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_KEY_CONTAINER %d", pInfo->bContainerIndex);
                        __leave;
                }
        }
        __finally
        {
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
        return dwReturn;
}

/** This function returns the public key sizes that are supported by the card in use.*/
DWORD WINAPI CardQueryKeySizes(
    __in PCARD_DATA  pCardData,
    __in DWORD  dwKeySpec,
    __in DWORD  dwFlags,
    __inout PCARD_KEY_SIZES  pKeySizes
)
{
        DWORD dwReturn = 0, dwVersion;  
        Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
        __try
        {
                if ( pCardData == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }

                if ( dwFlags != 0 )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"dwFlags != 0 : %d", dwFlags);
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }
                if ( pKeySizes == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pKeySizes == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }
                dwVersion = (pKeySizes->dwVersion == 0) ? 1 : pKeySizes->dwVersion;
                if ( dwVersion != CARD_KEY_SIZES_CURRENT_VERSION )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"dwVersion == %d", pKeySizes->dwVersion);
                        dwReturn  = ERROR_REVISION_MISMATCH;
                        __leave;
                }

                switch(dwKeySpec)
                {
                        case AT_ECDHE_P256 :
                        case AT_ECDHE_P384 :
                        case AT_ECDHE_P521 :
                        case AT_ECDSA_P256 :
                        case AT_ECDSA_P384 :
                        case AT_ECDSA_P521 :
                                Trace(WINEVENT_LEVEL_ERROR, L"dwKeySpec == %d", dwKeySpec);
                                dwReturn = SCARD_E_UNSUPPORTED_FEATURE;
                                __leave;
                                break;
                        case AT_KEYEXCHANGE:
                        case AT_SIGNATURE  :
                                break;
                        default:
                                Trace(WINEVENT_LEVEL_ERROR, L"dwKeySpec == %d", dwKeySpec);
                                dwReturn = SCARD_E_INVALID_PARAMETER;
                                __leave;
                                break;
                }

           pKeySizes->dwMinimumBitlen     = 1024;
           pKeySizes->dwDefaultBitlen     = 2048;
           pKeySizes->dwMaximumBitlen     = 2048;
           pKeySizes->dwIncrementalBitlen = 0;
        }
        __finally
        {
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
        return dwReturn;
}


/** The CardConstructDHAgreement function performs a secret agreement calculation 
for Diffie Hellman (DH) key exchange by using a private key that is present on the
card. For RSA-only card minidrivers, this entry point is not defined and is set to
NULL in the CARD_DATA structure that is returned from CardAcquireContext. 
The CARD_DH_AGREEMENT structure changes to allow for return of a handle to
the agreed secret. This raises a point about how to index the DH agreement 
on the card in an opaque manner. Maintaining a map file is unnecessary because
Ncrypt makes no provision for persistent DH agreements and there is no way to 
retrieve one after a provider is closed. DH agreements are addressable on card 
through an opaque BYTE that the card minidriver maintains. This BYTE should be 
associated with a handle to a card-side agreement.*/

DWORD WINAPI CardConstructDHAgreement(
    __in PCARD_DATA  pCardData,
    __inout PCARD_DH_AGREEMENT_INFO  pSecretInfo
)
{
        Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
        return SCARD_E_UNSUPPORTED_FEATURE;
}

/** The key derivation structure represents the majority of the required changes
for FIPS 140-2 compliance for smart cards. It holds the requested key derivation
function (KDF) and the associated input. The KDFs are defined in the CNG Reference 
documentation on MSDN. For RSA-only card minidrivers, this entry point is not defined
and is set to NULL in the CARD_DATA structure that is returned from CardAcquireContext.*/

DWORD WINAPI CardDeriveKey(
    __in PCARD_DATA  pCardData,
    __inout PCARD_DERIVE_KEY  pAgreementInfo
)
{
        Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
        return SCARD_E_UNSUPPORTED_FEATURE;
}

/** The CardDestroyDHAgreement function removes an agreed secret from the card.
For RSA-only card minidrivers, this entry point is not defined and is set to
NULL in the CARD_DATA structure that was returned from CardAcquireContext.*/

DWORD WINAPI CardDestroyDHAgreement(
    __in PCARD_DATA  pCardData,
    __in BYTE  bSecretAgreementIndex,
    __in DWORD  dwFlags
)
{
        Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
        return SCARD_E_UNSUPPORTED_FEATURE;
}
1	vletoux	1	/* OpenPGP Smart Card Mini Driver
2			Copyright (C) 2009 Vincent Le Toux
3
4			This library is Free software; you can redistribute it and/or
5			modify it under the terms of the GNU Lesser General Public
6			License version 2.1 as published by the Free Software Foundation.
7
8			This library is distributed in the hope that it will be useful,
9			but WITHOUT ANY WARRANTY; without even the implied warranty of
10			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11			Lesser General Public License for more details.
12
13			You should have received a copy of the GNU Lesser General Public
14			License along with this library; if not, write to the Free Software
15			Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16			*/
17
18			#include <windows.h>
19			#include <cardmod.h>
20			#include "Tracing.h"
21			#include "Context.h"
22			#include "CryptoOperations.h"
23
24			// 4.7 Cryptographic operations
25
26			/** This function performs an RSA decryption operation on the passed buffer
27			by using the private key that a container index refers to. Note that for
28			ECC-only smart cards, this entry point is not defined and is set to NULL
29			in the returned CARD_DATA structure from CardAcquireContext. This operation
30			is restricted to a single buffer of a size equal to the key modulus.*/
31
32			DWORD WINAPI CardRSADecrypt(
33			__in PCARD_DATA pCardData,
34			__inout PCARD_RSA_DECRYPT_INFO pInfo
35			)
36			{
37			DWORD dwReturn = 0;
38
39			Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
40			__try
41			{
42			if ( pCardData == NULL )
43			{
44			Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
45			dwReturn = SCARD_E_INVALID_PARAMETER;
46			__leave;
47			}
48
49			if ( pInfo == NULL )
50			{
51			Trace(WINEVENT_LEVEL_ERROR, L"pInfo == NULL");
52			dwReturn = SCARD_E_INVALID_PARAMETER;
53			__leave;
54			}
55			if ( pInfo->pbData == NULL )
56			{
57			Trace(WINEVENT_LEVEL_ERROR, L"pInfo->pbData == NULL");
58			dwReturn = SCARD_E_INVALID_PARAMETER;
59			__leave;
60			}
61			if (pInfo->dwVersion < CARD_RSA_KEY_DECRYPT_INFO_CURRENT_VERSION
62			&& pCardData->dwVersion == CARD_DATA_CURRENT_VERSION)
63			{
64			Trace(WINEVENT_LEVEL_ERROR, L"ERROR_REVISION_MISMATCH");
65			dwReturn = ERROR_REVISION_MISMATCH;
66			__leave;
67			}
68			if (pInfo->dwKeySpec != AT_KEYEXCHANGE)
69			{
70			Trace(WINEVENT_LEVEL_ERROR, L"AT_KEYEXCHANGE %d", pInfo->dwKeySpec);
71			dwReturn = SCARD_E_NO_KEY_CONTAINER ;
72			__leave;
73			}
74			if (pInfo->bContainerIndex != Confidentiality)
75			{
76			Trace(WINEVENT_LEVEL_ERROR, L"Confidentiality %d", pInfo->bContainerIndex);
77			dwReturn = SCARD_E_NO_KEY_CONTAINER ;
78			__leave;
79			}
80			dwReturn = CheckContext(pCardData);
81			if ( dwReturn)
82			{
83			__leave;
84			}
85			dwReturn = SCardDecrypt(pCardData, pInfo);
86			}
87			__finally
88			{
89			}
90			Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
91			return dwReturn;
92			}
93
94
95			/** The CardSignData function signs a block of unpadded data. This entry either performs
96			padding on the card or pads the data by using the PFN_CSP_PAD_DATA callback. All card
97			minidrivers must support this entry point.*/
98
99			DWORD WINAPI CardSignData(
100			__in PCARD_DATA pCardData,
101			__in PCARD_SIGNING_INFO pInfo
102			)
103			{
104			DWORD dwReturn = 0;
105
106			Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
107			__try
108			{
109			if ( pCardData == NULL )
110			{
111			Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
112			dwReturn = SCARD_E_INVALID_PARAMETER;
113			__leave;
114			}
115
116			if ( pInfo == NULL )
117			{
118			Trace(WINEVENT_LEVEL_ERROR, L"pInfo == NULL");
119			dwReturn = SCARD_E_INVALID_PARAMETER;
120			__leave;
121			}
122			if ( pInfo->pbData == NULL )
123			{
124			Trace(WINEVENT_LEVEL_ERROR, L"pInfo->pbData == NULL");
125			dwReturn = SCARD_E_INVALID_PARAMETER;
126			__leave;
127			}
128			dwReturn = CheckContext(pCardData);
129			if ( dwReturn)
130			{
131			__leave;
132			}
133	vletoux	5	switch(pInfo->bContainerIndex)
134			{
135			case Authentication:
136			dwReturn = SCardAuthenticate(pCardData, pInfo);
137			break;
138			case Signature:
139			dwReturn = SCardSign(pCardData, pInfo);
140			break;
141			default:
142			dwReturn = SCARD_E_NO_KEY_CONTAINER;
143			Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_KEY_CONTAINER %d", pInfo->bContainerIndex);
144			__leave;
145			}
146	vletoux	1	}
147			__finally
148			{
149			}
150			Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
151			return dwReturn;
152			}
153
154			/** This function returns the public key sizes that are supported by the card in use.*/
155			DWORD WINAPI CardQueryKeySizes(
156			__in PCARD_DATA pCardData,
157			__in DWORD dwKeySpec,
158			__in DWORD dwFlags,
159			__inout PCARD_KEY_SIZES pKeySizes
160			)
161			{
162			DWORD dwReturn = 0, dwVersion;
163			Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
164			__try
165			{
166			if ( pCardData == NULL )
167			{
168			Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
169			dwReturn = SCARD_E_INVALID_PARAMETER;
170			__leave;
171			}
172
173			if ( dwFlags != 0 )
174			{
175			Trace(WINEVENT_LEVEL_ERROR, L"dwFlags != 0 : %d", dwFlags);
176			dwReturn = SCARD_E_INVALID_PARAMETER;
177			__leave;
178			}
179			if ( pKeySizes == NULL )
180			{
181			Trace(WINEVENT_LEVEL_ERROR, L"pKeySizes == NULL");
182			dwReturn = SCARD_E_INVALID_PARAMETER;
183			__leave;
184			}
185			dwVersion = (pKeySizes->dwVersion == 0) ? 1 : pKeySizes->dwVersion;
186			if ( dwVersion != CARD_KEY_SIZES_CURRENT_VERSION )
187			{
188			Trace(WINEVENT_LEVEL_ERROR, L"dwVersion == %d", pKeySizes->dwVersion);
189			dwReturn = ERROR_REVISION_MISMATCH;
190			__leave;
191			}
192
193			switch(dwKeySpec)
194			{
195			case AT_ECDHE_P256 :
196			case AT_ECDHE_P384 :
197			case AT_ECDHE_P521 :
198			case AT_ECDSA_P256 :
199			case AT_ECDSA_P384 :
200			case AT_ECDSA_P521 :
201			Trace(WINEVENT_LEVEL_ERROR, L"dwKeySpec == %d", dwKeySpec);
202			dwReturn = SCARD_E_UNSUPPORTED_FEATURE;
203			__leave;
204			break;
205			case AT_KEYEXCHANGE:
206			case AT_SIGNATURE :
207			break;
208			default:
209			Trace(WINEVENT_LEVEL_ERROR, L"dwKeySpec == %d", dwKeySpec);
210			dwReturn = SCARD_E_INVALID_PARAMETER;
211			__leave;
212			break;
213			}
214
215			pKeySizes->dwMinimumBitlen = 1024;
216			pKeySizes->dwDefaultBitlen = 2048;
217			pKeySizes->dwMaximumBitlen = 2048;
218			pKeySizes->dwIncrementalBitlen = 0;
219			}
220			__finally
221			{
222			}
223			Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
224			return dwReturn;
225			}
226
227
228			/** The CardConstructDHAgreement function performs a secret agreement calculation
229			for Diffie Hellman (DH) key exchange by using a private key that is present on the
230			card. For RSA-only card minidrivers, this entry point is not defined and is set to
231			NULL in the CARD_DATA structure that is returned from CardAcquireContext.
232			The CARD_DH_AGREEMENT structure changes to allow for return of a handle to
233			the agreed secret. This raises a point about how to index the DH agreement
234			on the card in an opaque manner. Maintaining a map file is unnecessary because
235			Ncrypt makes no provision for persistent DH agreements and there is no way to
236			retrieve one after a provider is closed. DH agreements are addressable on card
237			through an opaque BYTE that the card minidriver maintains. This BYTE should be
238			associated with a handle to a card-side agreement.*/
239
240			DWORD WINAPI CardConstructDHAgreement(
241			__in PCARD_DATA pCardData,
242			__inout PCARD_DH_AGREEMENT_INFO pSecretInfo
243			)
244			{
245			Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
246			return SCARD_E_UNSUPPORTED_FEATURE;
247			}
248
249			/** The key derivation structure represents the majority of the required changes
250			for FIPS 140-2 compliance for smart cards. It holds the requested key derivation
251			function (KDF) and the associated input. The KDFs are defined in the CNG Reference
252			documentation on MSDN. For RSA-only card minidrivers, this entry point is not defined
253			and is set to NULL in the CARD_DATA structure that is returned from CardAcquireContext.*/
254
255			DWORD WINAPI CardDeriveKey(
256			__in PCARD_DATA pCardData,
257			__inout PCARD_DERIVE_KEY pAgreementInfo
258			)
259			{
260			Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
261			return SCARD_E_UNSUPPORTED_FEATURE;
262			}
263
264			/** The CardDestroyDHAgreement function removes an agreed secret from the card.
265			For RSA-only card minidrivers, this entry point is not defined and is set to
266			NULL in the CARD_DATA structure that was returned from CardAcquireContext.*/
267
268			DWORD WINAPI CardDestroyDHAgreement(
269			__in PCARD_DATA pCardData,
270			__in BYTE bSecretAgreementIndex,
271			__in DWORD dwFlags
272			)
273			{
274			Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
275			return SCARD_E_UNSUPPORTED_FEATURE;
276			}