trunk/OpenPGPminidriver/CardKeyContainer.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.6 Key Container

/** The CardCreateContainer function creates a new key container that is 
identified by the container index that the bContainerIndex argument specifies.
For applications in which the card does not support on-card key generation or
if it is desired to archive the keys, the key material can be supplied with
the call by specifying in flags that the card is to import the supplied key material.*/

DWORD WINAPI CardCreateContainer(
    __in PCARD_DATA  pCardData,
    __in BYTE  bContainerIndex,
    __in DWORD  dwFlags,
    __in DWORD  dwKeySpec,
    __in DWORD  dwKeySize,
    __in PBYTE  pbKeyData
)
{
        DWORD dwReturn = 0;     
        POPENPGP_CONTEXT pContext = NULL;
        Trace(WINEVENT_LEVEL_VERBOSE, L"Enter bContainerIndex=%d",bContainerIndex);
        __try
        {
                if ( pCardData == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }
                if (bContainerIndex >= ContainerMax)
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"bContainerIndex == %d",bContainerIndex);
                        dwReturn  = SCARD_E_NO_KEY_CONTAINER;
                        __leave; 
                }
                // controls are done in CardCreateContainerEx
                dwReturn = CardCreateContainerEx(pCardData, 
                                                                bContainerIndex,
                                                                dwFlags,
                                                                dwKeySpec,
                                                                dwKeySize,
                                                                pbKeyData,
                                                                Containers[bContainerIndex].PinId);
        }
        __finally
        {
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
        return dwReturn;
}

/** The CardCreateContainerEx function creates a new key container that the 
container index identifies and the bContainerIndex parameter specifies. The function 
associates the key container with the PIN that the PinId parameter specified.
This function is useful if the card-edge does not allow for changing the key attributes
after the key container is created. This function replaces the need to call 
CardSetContainerProperty to set the CCP_PIN_IDENTIFIER property CardCreateContainer
is called.
The caller of this function can provide the key material that the card imports.
This is useful in those situations in which the card either does not support internal
key generation or the caller requests that the key be archived in the card.*/

DWORD WINAPI CardCreateContainerEx(
    __in PCARD_DATA  pCardData,
    __in BYTE  bContainerIndex,
    __in DWORD  dwFlags,
    __in DWORD  dwKeySpec,
    __in DWORD  dwKeySize,
    __in PBYTE  pbKeyData,
    __in PIN_ID  PinId
)
{
        DWORD dwReturn = 0;     
        POPENPGP_CONTEXT pContext = NULL;
        Trace(WINEVENT_LEVEL_VERBOSE, L"Enter bContainerIndex=%d",bContainerIndex);
        __try
        {
                if ( pCardData == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }
                if (bContainerIndex >= ContainerMax)
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"bContainerIndex == %d",bContainerIndex);
                        dwReturn  = SCARD_E_NO_KEY_CONTAINER;
                        __leave; 
                }
                if (Containers[bContainerIndex].dwKeySpec != dwKeySpec)
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"dwKeySpec == %d",dwKeySpec);
                        dwReturn  = SCARD_E_UNSUPPORTED_FEATURE;
                        __leave; 
                }
                if (Containers[bContainerIndex].PinId != PinId)
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"PinId == %d",PinId);
                        dwReturn  = SCARD_E_UNSUPPORTED_FEATURE;
                        __leave; 
                }
                dwReturn = CheckContext(pCardData);
                if (dwReturn)
                {
                        __leave;
                }
                pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;
                if (pContext->fIsReadOnly)
                {
                        dwReturn = SCARD_E_UNSUPPORTED_FEATURE;
                        Trace(WINEVENT_LEVEL_ERROR, L"Readonly card");
                        __leave;
                }
                if (dwFlags == CARD_CREATE_CONTAINER_KEY_GEN)
                {
                        dwReturn = OCardCreateKey(pCardData, bContainerIndex, dwKeySize);
                }
                else if (dwFlags == CARD_CREATE_CONTAINER_KEY_IMPORT)
                {
                        if (pbKeyData == NULL)
                        {
                                Trace(WINEVENT_LEVEL_ERROR, L"pbKeyData == NULL");
                                dwReturn  = SCARD_E_INVALID_PARAMETER;
                                __leave;
                        }
                        dwReturn = OCardImportKey(pCardData, bContainerIndex, pbKeyData, dwKeySize);
                }
                else
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"dwFlags == %d",dwFlags);
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave; 
                }
        }
        __finally
        {
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
        return dwReturn;
}

/** The CardDeleteContainer function deletes the key container specified by its index value.
This is done by deleting all key material (public and private) that is associated with 
that index value.*/

DWORD WINAPI CardDeleteContainer(
    __in PCARD_DATA  pCardData,
    __in BYTE  bContainerIndex,
    __in DWORD  dwReserved
)
{
        Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
        return SCARD_E_UNSUPPORTED_FEATURE;
}

/** The CardGetContainerInfo function queries the specified key container for more
information about which keys are present, such as its key specification (such as AT_ECDSA_P384).*/

DWORD WINAPI CardGetContainerInfo(
    __in PCARD_DATA  pCardData,
    __in BYTE  bContainerIndex,
    __in DWORD  dwFlags,
    __inout PCONTAINER_INFO  pContainerInfo
)
{
        DWORD dwReturn = 0, dwVersion;  
        Trace(WINEVENT_LEVEL_VERBOSE, L"Enter bContainerIndex=%d",bContainerIndex);
        __try
        {
                if ( pCardData == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }
                if ( pContainerInfo == NULL )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"pContainerInfo == NULL");
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }
                dwVersion = (pContainerInfo->dwVersion == 0) ? 1 : pContainerInfo->dwVersion;
                if ( dwVersion != CONTAINER_INFO_CURRENT_VERSION )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"dwVersion == %d", pContainerInfo->dwVersion);
                        dwReturn  = ERROR_REVISION_MISMATCH;
                        __leave;
                }
                if ( dwFlags )
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"dwFlags == %d", dwFlags);
                        dwReturn  = SCARD_E_INVALID_PARAMETER;
                        __leave;
                }
                if (bContainerIndex >= ContainerMax)
                {
                        Trace(WINEVENT_LEVEL_ERROR, L"bContainerIndex == %d",bContainerIndex);
                        dwReturn  = SCARD_E_NO_KEY_CONTAINER;
                        __leave; 
                }
                dwReturn = CheckContext(pCardData);
                if (dwReturn)
                {
                        __leave;
                }
                pContainerInfo->pbSigPublicKey = NULL;
                pContainerInfo->pbKeyExPublicKey = NULL;
                pContainerInfo->cbSigPublicKey = 0;
                pContainerInfo->cbKeyExPublicKey = 0;
                switch(bContainerIndex)
                {
                        case ContainerSignature:
                        case ContainerAuthentication:
                                dwReturn = OCardReadPublicKey(pCardData, bContainerIndex, 
                                        &(pContainerInfo->pbSigPublicKey),&(pContainerInfo->cbSigPublicKey));
                                break;
                        case ContainerConfidentiality:
                                dwReturn = OCardReadPublicKey(pCardData, bContainerIndex, 
                                        &(pContainerInfo->pbKeyExPublicKey),&(pContainerInfo->cbKeyExPublicKey));
                                break;
                }
        }
        __finally
        {
        }
        Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
        return dwReturn;
}
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.6 Key Container
25
26	/** The CardCreateContainer function creates a new key container that is
27	identified by the container index that the bContainerIndex argument specifies.
28	For applications in which the card does not support on-card key generation or
29	if it is desired to archive the keys, the key material can be supplied with
30	the call by specifying in flags that the card is to import the supplied key material.*/
31
32	DWORD WINAPI CardCreateContainer(
33	__in PCARD_DATA pCardData,
34	__in BYTE bContainerIndex,
35	__in DWORD dwFlags,
36	__in DWORD dwKeySpec,
37	__in DWORD dwKeySize,
38	__in PBYTE pbKeyData
39	)
40	{
41	DWORD dwReturn = 0;
42	POPENPGP_CONTEXT pContext = NULL;
43	Trace(WINEVENT_LEVEL_VERBOSE, L"Enter bContainerIndex=%d",bContainerIndex);
44	__try
45	{
46	if ( pCardData == NULL )
47	{
48	Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
49	dwReturn = SCARD_E_INVALID_PARAMETER;
50	__leave;
51	}
52	if (bContainerIndex >= ContainerMax)
53	{
54	Trace(WINEVENT_LEVEL_ERROR, L"bContainerIndex == %d",bContainerIndex);
55	dwReturn = SCARD_E_NO_KEY_CONTAINER;
56	__leave;
57	}
58	// controls are done in CardCreateContainerEx
59	dwReturn = CardCreateContainerEx(pCardData,
60	bContainerIndex,
61	dwFlags,
62	dwKeySpec,
63	dwKeySize,
64	pbKeyData,
65	Containers[bContainerIndex].PinId);
66	}
67	__finally
68	{
69	}
70	Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
71	return dwReturn;
72	}
73
74	/** The CardCreateContainerEx function creates a new key container that the
75	container index identifies and the bContainerIndex parameter specifies. The function
76	associates the key container with the PIN that the PinId parameter specified.
77	This function is useful if the card-edge does not allow for changing the key attributes
78	after the key container is created. This function replaces the need to call
79	CardSetContainerProperty to set the CCP_PIN_IDENTIFIER property CardCreateContainer
80	is called.
81	The caller of this function can provide the key material that the card imports.
82	This is useful in those situations in which the card either does not support internal
83	key generation or the caller requests that the key be archived in the card.*/
84
85	DWORD WINAPI CardCreateContainerEx(
86	__in PCARD_DATA pCardData,
87	__in BYTE bContainerIndex,
88	__in DWORD dwFlags,
89	__in DWORD dwKeySpec,
90	__in DWORD dwKeySize,
91	__in PBYTE pbKeyData,
92	__in PIN_ID PinId
93	)
94	{
95	DWORD dwReturn = 0;
96	POPENPGP_CONTEXT pContext = NULL;
97	Trace(WINEVENT_LEVEL_VERBOSE, L"Enter bContainerIndex=%d",bContainerIndex);
98	__try
99	{
100	if ( pCardData == NULL )
101	{
102	Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
103	dwReturn = SCARD_E_INVALID_PARAMETER;
104	__leave;
105	}
106	if (bContainerIndex >= ContainerMax)
107	{
108	Trace(WINEVENT_LEVEL_ERROR, L"bContainerIndex == %d",bContainerIndex);
109	dwReturn = SCARD_E_NO_KEY_CONTAINER;
110	__leave;
111	}
112	if (Containers[bContainerIndex].dwKeySpec != dwKeySpec)
113	{
114	Trace(WINEVENT_LEVEL_ERROR, L"dwKeySpec == %d",dwKeySpec);
115	dwReturn = SCARD_E_UNSUPPORTED_FEATURE;
116	__leave;
117	}
118	if (Containers[bContainerIndex].PinId != PinId)
119	{
120	Trace(WINEVENT_LEVEL_ERROR, L"PinId == %d",PinId);
121	dwReturn = SCARD_E_UNSUPPORTED_FEATURE;
122	__leave;
123	}
124	dwReturn = CheckContext(pCardData);
125	if (dwReturn)
126	{
127	__leave;
128	}
129	pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;
130	if (pContext->fIsReadOnly)
131	{
132	dwReturn = SCARD_E_UNSUPPORTED_FEATURE;
133	Trace(WINEVENT_LEVEL_ERROR, L"Readonly card");
134	__leave;
135	}
136	if (dwFlags == CARD_CREATE_CONTAINER_KEY_GEN)
137	{
138	dwReturn = OCardCreateKey(pCardData, bContainerIndex, dwKeySize);
139	}
140	else if (dwFlags == CARD_CREATE_CONTAINER_KEY_IMPORT)
141	{
142	if (pbKeyData == NULL)
143	{
144	Trace(WINEVENT_LEVEL_ERROR, L"pbKeyData == NULL");
145	dwReturn = SCARD_E_INVALID_PARAMETER;
146	__leave;
147	}
148	dwReturn = OCardImportKey(pCardData, bContainerIndex, pbKeyData, dwKeySize);
149	}
150	else
151	{
152	Trace(WINEVENT_LEVEL_ERROR, L"dwFlags == %d",dwFlags);
153	dwReturn = SCARD_E_INVALID_PARAMETER;
154	__leave;
155	}
156	}
157	__finally
158	{
159	}
160	Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
161	return dwReturn;
162	}
163
164	/** The CardDeleteContainer function deletes the key container specified by its index value.
165	This is done by deleting all key material (public and private) that is associated with
166	that index value.*/
167
168	DWORD WINAPI CardDeleteContainer(
169	__in PCARD_DATA pCardData,
170	__in BYTE bContainerIndex,
171	__in DWORD dwReserved
172	)
173	{
174	Trace(WINEVENT_LEVEL_VERBOSE, L"Enter");
175	return SCARD_E_UNSUPPORTED_FEATURE;
176	}
177
178	/** The CardGetContainerInfo function queries the specified key container for more
179	information about which keys are present, such as its key specification (such as AT_ECDSA_P384).*/
180
181	DWORD WINAPI CardGetContainerInfo(
182	__in PCARD_DATA pCardData,
183	__in BYTE bContainerIndex,
184	__in DWORD dwFlags,
185	__inout PCONTAINER_INFO pContainerInfo
186	)
187	{
188	DWORD dwReturn = 0, dwVersion;
189	Trace(WINEVENT_LEVEL_VERBOSE, L"Enter bContainerIndex=%d",bContainerIndex);
190	__try
191	{
192	if ( pCardData == NULL )
193	{
194	Trace(WINEVENT_LEVEL_ERROR, L"pCardData == NULL");
195	dwReturn = SCARD_E_INVALID_PARAMETER;
196	__leave;
197	}
198	if ( pContainerInfo == NULL )
199	{
200	Trace(WINEVENT_LEVEL_ERROR, L"pContainerInfo == NULL");
201	dwReturn = SCARD_E_INVALID_PARAMETER;
202	__leave;
203	}
204	dwVersion = (pContainerInfo->dwVersion == 0) ? 1 : pContainerInfo->dwVersion;
205	if ( dwVersion != CONTAINER_INFO_CURRENT_VERSION )
206	{
207	Trace(WINEVENT_LEVEL_ERROR, L"dwVersion == %d", pContainerInfo->dwVersion);
208	dwReturn = ERROR_REVISION_MISMATCH;
209	__leave;
210	}
211	if ( dwFlags )
212	{
213	Trace(WINEVENT_LEVEL_ERROR, L"dwFlags == %d", dwFlags);
214	dwReturn = SCARD_E_INVALID_PARAMETER;
215	__leave;
216	}
217	if (bContainerIndex >= ContainerMax)
218	{
219	Trace(WINEVENT_LEVEL_ERROR, L"bContainerIndex == %d",bContainerIndex);
220	dwReturn = SCARD_E_NO_KEY_CONTAINER;
221	__leave;
222	}
223	dwReturn = CheckContext(pCardData);
224	if (dwReturn)
225	{
226	__leave;
227	}
228	pContainerInfo->pbSigPublicKey = NULL;
229	pContainerInfo->pbKeyExPublicKey = NULL;
230	pContainerInfo->cbSigPublicKey = 0;
231	pContainerInfo->cbKeyExPublicKey = 0;
232	switch(bContainerIndex)
233	{
234	case ContainerSignature:
235	case ContainerAuthentication:
236	dwReturn = OCardReadPublicKey(pCardData, bContainerIndex,
237	&(pContainerInfo->pbSigPublicKey),&(pContainerInfo->cbSigPublicKey));
238	break;
239	case ContainerConfidentiality:
240	dwReturn = OCardReadPublicKey(pCardData, bContainerIndex,
241	&(pContainerInfo->pbKeyExPublicKey),&(pContainerInfo->cbKeyExPublicKey));
242	break;
243	}
244	}
245	__finally
246	{
247	}
248	Trace(WINEVENT_LEVEL_VERBOSE, L"dwReturn = 0x%08X",dwReturn);
249	return dwReturn;
250	}