1 /*
2 * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation)
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
18 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
20 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
22 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
24 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 /*****************************************************************************
28 InfoTests.cpp
29
30 Contains test cases to C_GetInfo, C_GetFunctionList, C_GetSlotList,
31 C_GetSlotInfo, C_GetTokenInfo, C_GetMechanismList, and C_GetMechanismInfo
32 *****************************************************************************/
33
34 #include <config.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include "InfoTests.h"
38
39 CPPUNIT_TEST_SUITE_REGISTRATION(InfoTests);
40
testGetInfo()41 void InfoTests::testGetInfo()
42 {
43 CK_RV rv;
44 CK_INFO ckInfo;
45
46 // Just make sure that we finalize any previous failed tests
47 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
48
49 rv = CRYPTOKI_F_PTR( C_GetInfo(&ckInfo) );
50 CPPUNIT_ASSERT(rv == CKR_CRYPTOKI_NOT_INITIALIZED);
51
52 rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) );
53 CPPUNIT_ASSERT(rv == CKR_OK);
54
55 rv = CRYPTOKI_F_PTR( C_GetInfo(NULL_PTR) );
56 CPPUNIT_ASSERT(rv == CKR_ARGUMENTS_BAD);
57
58 rv = CRYPTOKI_F_PTR( C_GetInfo(&ckInfo) );
59 CPPUNIT_ASSERT(rv == CKR_OK);
60
61 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
62 }
63
testGetFunctionList()64 void InfoTests::testGetFunctionList()
65 {
66 CK_RV rv;
67 CK_FUNCTION_LIST_PTR ckFuncList;
68
69 rv = CRYPTOKI_F_PTR( C_GetFunctionList(NULL_PTR) );
70 CPPUNIT_ASSERT(rv == CKR_ARGUMENTS_BAD);
71
72 rv = CRYPTOKI_F_PTR( C_GetFunctionList(&ckFuncList) );
73 CPPUNIT_ASSERT(rv == CKR_OK);
74 }
75
testGetSlotList()76 void InfoTests::testGetSlotList()
77 {
78 CK_RV rv;
79 CK_ULONG ulSlotCount = 0;
80 CK_SLOT_ID_PTR pSlotList;
81
82 // Just make sure that we finalize any previous failed tests
83 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
84
85 rv = CRYPTOKI_F_PTR( C_GetSlotList(CK_FALSE, NULL_PTR, &ulSlotCount) );
86 CPPUNIT_ASSERT(rv == CKR_CRYPTOKI_NOT_INITIALIZED);
87
88 rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) );
89 CPPUNIT_ASSERT(rv == CKR_OK);
90
91 rv = CRYPTOKI_F_PTR( C_GetSlotList(CK_FALSE, NULL_PTR, NULL_PTR) );
92 CPPUNIT_ASSERT(rv == CKR_ARGUMENTS_BAD);
93
94 // Get the size of the buffer
95 rv = CRYPTOKI_F_PTR( C_GetSlotList(CK_FALSE, NULL_PTR, &ulSlotCount) );
96 CPPUNIT_ASSERT(rv == CKR_OK);
97 pSlotList = (CK_SLOT_ID_PTR)malloc(ulSlotCount * sizeof(CK_SLOT_ID));
98
99 // Check if we have a too small buffer
100 ulSlotCount = 0;
101 rv = CRYPTOKI_F_PTR( C_GetSlotList(CK_FALSE, pSlotList, &ulSlotCount) );
102 CPPUNIT_ASSERT(rv == CKR_BUFFER_TOO_SMALL);
103
104 // Get the slot list
105 rv = CRYPTOKI_F_PTR( C_GetSlotList(CK_FALSE, pSlotList, &ulSlotCount) );
106 CPPUNIT_ASSERT(rv == CKR_OK);
107 free(pSlotList);
108
109 // Get the number of slots with tokens
110 rv = CRYPTOKI_F_PTR( C_GetSlotList(CK_TRUE, NULL_PTR, &ulSlotCount) );
111 CPPUNIT_ASSERT(rv == CKR_OK);
112 pSlotList = (CK_SLOT_ID_PTR)malloc(ulSlotCount * sizeof(CK_SLOT_ID));
113
114 // Check if we have a too small buffer
115 ulSlotCount = 0;
116 rv = CRYPTOKI_F_PTR( C_GetSlotList(CK_TRUE, pSlotList, &ulSlotCount) );
117 CPPUNIT_ASSERT(rv == CKR_BUFFER_TOO_SMALL);
118
119 // Get the slot list
120 rv = CRYPTOKI_F_PTR( C_GetSlotList(CK_TRUE, pSlotList, &ulSlotCount) );
121 CPPUNIT_ASSERT(rv == CKR_OK);
122 free(pSlotList);
123
124 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
125 }
126
testGetSlotInfo()127 void InfoTests::testGetSlotInfo()
128 {
129 CK_RV rv;
130 CK_SLOT_INFO slotInfo;
131
132 // Just make sure that we finalize any previous failed tests
133 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
134
135 rv = CRYPTOKI_F_PTR( C_GetSlotInfo(m_notInitializedTokenSlotID, &slotInfo) );
136 CPPUNIT_ASSERT(rv == CKR_CRYPTOKI_NOT_INITIALIZED);
137
138 rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) );
139 CPPUNIT_ASSERT(rv == CKR_OK);
140
141 rv = CRYPTOKI_F_PTR( C_GetSlotInfo(m_notInitializedTokenSlotID, NULL_PTR) );
142 CPPUNIT_ASSERT(rv == CKR_ARGUMENTS_BAD);
143
144 rv = CRYPTOKI_F_PTR( C_GetSlotInfo(m_invalidSlotID, &slotInfo) );
145 CPPUNIT_ASSERT(rv == CKR_SLOT_ID_INVALID);
146
147 rv = CRYPTOKI_F_PTR( C_GetSlotInfo(m_notInitializedTokenSlotID, &slotInfo) );
148 CPPUNIT_ASSERT(rv == CKR_OK);
149 CPPUNIT_ASSERT((slotInfo.flags & CKF_TOKEN_PRESENT ) == CKF_TOKEN_PRESENT);
150 CPPUNIT_ASSERT((slotInfo.flags & CKF_REMOVABLE_DEVICE ) == 0);
151
152 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
153 }
154
testGetSlotInfoAlt()155 void InfoTests::testGetSlotInfoAlt()
156 {
157 CK_RV rv;
158 CK_SLOT_INFO slotInfo;
159
160 // Just make sure that we finalize any previous failed tests
161 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
162
163 #ifndef _WIN32
164 setenv("SOFTHSM2_CONF", "./softhsm2-alt.conf", 1);
165 #else
166 setenv("SOFTHSM2_CONF", ".\\softhsm2-alt.conf", 1);
167 #endif
168
169 CK_UTF8CHAR label[32];
170 memset(label, ' ', 32);
171 memcpy(label, "token1", strlen("token1"));
172
173 // (Re)initialize the token
174 rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) );
175 CPPUNIT_ASSERT(rv == CKR_OK);
176 rv = CRYPTOKI_F_PTR( C_InitToken(m_initializedTokenSlotID, m_soPin1, m_soPin1Length, label) );
177 CPPUNIT_ASSERT(rv == CKR_OK);
178 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
179
180 rv = CRYPTOKI_F_PTR( C_GetSlotInfo(m_notInitializedTokenSlotID, &slotInfo) );
181 CPPUNIT_ASSERT(rv == CKR_CRYPTOKI_NOT_INITIALIZED);
182
183 rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) );
184 CPPUNIT_ASSERT(rv == CKR_OK);
185
186 rv = CRYPTOKI_F_PTR( C_GetSlotInfo(m_notInitializedTokenSlotID, NULL_PTR) );
187 CPPUNIT_ASSERT(rv == CKR_ARGUMENTS_BAD);
188
189 rv = CRYPTOKI_F_PTR( C_GetSlotInfo(m_invalidSlotID, &slotInfo) );
190 CPPUNIT_ASSERT(rv == CKR_SLOT_ID_INVALID);
191
192 rv = CRYPTOKI_F_PTR( C_GetSlotInfo(m_notInitializedTokenSlotID, &slotInfo) );
193 CPPUNIT_ASSERT(rv == CKR_OK);
194 CPPUNIT_ASSERT((slotInfo.flags & CKF_TOKEN_PRESENT ) == CKF_TOKEN_PRESENT);
195 CPPUNIT_ASSERT((slotInfo.flags & CKF_REMOVABLE_DEVICE ) == CKF_REMOVABLE_DEVICE);
196
197 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
198 #ifndef _WIN32
199 setenv("SOFTHSM2_CONF", "./softhsm2.conf", 1);
200 #else
201 setenv("SOFTHSM2_CONF", ".\\softhsm2.conf", 1);
202 #endif
203 }
204
205
testGetTokenInfo()206 void InfoTests::testGetTokenInfo()
207 {
208 CK_RV rv;
209 CK_TOKEN_INFO tokenInfo;
210
211 // Just make sure that we finalize any previous failed tests
212 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
213
214 rv = CRYPTOKI_F_PTR( C_GetTokenInfo(m_notInitializedTokenSlotID, &tokenInfo) );
215 CPPUNIT_ASSERT(rv == CKR_CRYPTOKI_NOT_INITIALIZED);
216
217 rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) );
218 CPPUNIT_ASSERT(rv == CKR_OK);
219
220 rv = CRYPTOKI_F_PTR( C_GetTokenInfo(m_notInitializedTokenSlotID, NULL_PTR) );
221 CPPUNIT_ASSERT(rv == CKR_ARGUMENTS_BAD);
222
223 rv = CRYPTOKI_F_PTR( C_GetTokenInfo(m_invalidSlotID, &tokenInfo) );
224 CPPUNIT_ASSERT(rv == CKR_SLOT_ID_INVALID);
225
226 rv = CRYPTOKI_F_PTR( C_GetTokenInfo(m_notInitializedTokenSlotID, &tokenInfo) );
227 CPPUNIT_ASSERT(rv == CKR_OK);
228
229 CPPUNIT_ASSERT((tokenInfo.flags & CKF_TOKEN_INITIALIZED) == 0);
230
231 rv = CRYPTOKI_F_PTR( C_GetTokenInfo(m_initializedTokenSlotID, &tokenInfo) );
232 CPPUNIT_ASSERT(rv == CKR_OK);
233
234 CPPUNIT_ASSERT((tokenInfo.flags & CKF_TOKEN_INITIALIZED) == CKF_TOKEN_INITIALIZED);
235
236 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
237 }
238
testGetMechanismList()239 void InfoTests::testGetMechanismList()
240 {
241 CK_RV rv;
242 CK_ULONG ulMechCount = 0;
243 CK_MECHANISM_TYPE_PTR pMechanismList;
244
245 // Just make sure that we finalize any previous failed tests
246 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
247
248 rv = CRYPTOKI_F_PTR( C_GetMechanismList(m_initializedTokenSlotID, NULL_PTR, &ulMechCount) );
249 CPPUNIT_ASSERT(rv == CKR_CRYPTOKI_NOT_INITIALIZED);
250
251 rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) );
252 CPPUNIT_ASSERT(rv == CKR_OK);
253
254 rv = CRYPTOKI_F_PTR( C_GetMechanismList(m_initializedTokenSlotID, NULL_PTR, NULL_PTR) );
255 CPPUNIT_ASSERT(rv == CKR_ARGUMENTS_BAD);
256
257 rv = CRYPTOKI_F_PTR( C_GetMechanismList(m_invalidSlotID, NULL_PTR, &ulMechCount) );
258 CPPUNIT_ASSERT(rv == CKR_SLOT_ID_INVALID);
259
260 // Get the size of the buffer
261 rv = CRYPTOKI_F_PTR( C_GetMechanismList(m_initializedTokenSlotID, NULL_PTR, &ulMechCount) );
262 CPPUNIT_ASSERT(rv == CKR_OK);
263 CPPUNIT_ASSERT(ulMechCount > 2);
264 pMechanismList = (CK_MECHANISM_TYPE_PTR)malloc(ulMechCount * sizeof(CK_MECHANISM_TYPE_PTR));
265
266 // Check if we have a too small buffer
267 ulMechCount = 0;
268 rv = CRYPTOKI_F_PTR( C_GetMechanismList(m_initializedTokenSlotID, pMechanismList, &ulMechCount) );
269 CPPUNIT_ASSERT(rv == CKR_BUFFER_TOO_SMALL);
270
271 // Get the mechanism list
272 rv = CRYPTOKI_F_PTR( C_GetMechanismList(m_initializedTokenSlotID, pMechanismList, &ulMechCount) );
273 CPPUNIT_ASSERT(rv == CKR_OK);
274 free(pMechanismList);
275
276 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
277 }
278
testGetMechanismInfo()279 void InfoTests::testGetMechanismInfo()
280 {
281 CK_RV rv;
282 CK_MECHANISM_INFO info;
283 CK_ULONG ulMechCount = 0;
284 CK_MECHANISM_TYPE_PTR pMechanismList;
285
286 // Just make sure that we finalize any previous failed tests
287 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
288
289 rv = CRYPTOKI_F_PTR( C_GetMechanismInfo(m_initializedTokenSlotID, CKM_RSA_PKCS, &info) );
290 CPPUNIT_ASSERT(rv == CKR_CRYPTOKI_NOT_INITIALIZED);
291
292 rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) );
293 CPPUNIT_ASSERT(rv == CKR_OK);
294
295 // Get the mechanism list
296 rv = CRYPTOKI_F_PTR( C_GetMechanismList(m_initializedTokenSlotID, NULL_PTR, &ulMechCount) );
297 CPPUNIT_ASSERT(rv == CKR_OK);
298 CPPUNIT_ASSERT(ulMechCount != 0);
299 pMechanismList = (CK_MECHANISM_TYPE_PTR)malloc(ulMechCount * sizeof(CK_MECHANISM_TYPE_PTR));
300 rv = CRYPTOKI_F_PTR( C_GetMechanismList(m_initializedTokenSlotID, pMechanismList, &ulMechCount) );
301 CPPUNIT_ASSERT(rv == CKR_OK);
302
303 rv = CRYPTOKI_F_PTR( C_GetMechanismInfo(m_initializedTokenSlotID, pMechanismList[0], NULL_PTR) );
304 CPPUNIT_ASSERT(rv == CKR_ARGUMENTS_BAD);
305
306 rv = CRYPTOKI_F_PTR( C_GetMechanismInfo(m_invalidSlotID, pMechanismList[0], &info) );
307 CPPUNIT_ASSERT(rv == CKR_SLOT_ID_INVALID);
308
309 rv = CRYPTOKI_F_PTR( C_GetMechanismInfo(m_initializedTokenSlotID, CKM_VENDOR_DEFINED, &info) );
310 CPPUNIT_ASSERT(rv == CKR_MECHANISM_INVALID);
311
312 for (unsigned int i = 0; i < ulMechCount; i++)
313 {
314 rv = CRYPTOKI_F_PTR( C_GetMechanismInfo(m_initializedTokenSlotID, pMechanismList[i], &info) );
315 CPPUNIT_ASSERT(rv == CKR_OK);
316 }
317
318 free(pMechanismList);
319
320 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
321 }
322
323
testGetMechanismListConfig()324 void InfoTests::testGetMechanismListConfig()
325 {
326 CK_RV rv;
327 CK_ULONG ulMechCount = 0;
328 CK_MECHANISM_TYPE_PTR pMechanismList;
329
330 #ifndef _WIN32
331 setenv("SOFTHSM2_CONF", "./softhsm2-mech.conf", 1);
332 #else
333 setenv("SOFTHSM2_CONF", ".\\softhsm2-mech.conf", 1);
334 #endif
335
336 // Just make sure that we finalize any previous failed tests
337 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
338
339 rv = CRYPTOKI_F_PTR( C_GetMechanismList(m_initializedTokenSlotID, NULL_PTR, &ulMechCount) );
340 CPPUNIT_ASSERT(rv == CKR_CRYPTOKI_NOT_INITIALIZED);
341
342 rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) );
343 CPPUNIT_ASSERT(rv == CKR_OK);
344
345 // Get the size of the buffer
346 rv = CRYPTOKI_F_PTR( C_GetMechanismList(m_initializedTokenSlotID, NULL_PTR, &ulMechCount) );
347 CPPUNIT_ASSERT(rv == CKR_OK);
348 CPPUNIT_ASSERT_EQUAL((CK_ULONG)2, ulMechCount);
349 pMechanismList = (CK_MECHANISM_TYPE_PTR)malloc(ulMechCount * sizeof(CK_MECHANISM_TYPE_PTR));
350
351 // Get the mechanism list
352 rv = CRYPTOKI_F_PTR( C_GetMechanismList(m_initializedTokenSlotID, pMechanismList, &ulMechCount) );
353 CPPUNIT_ASSERT(rv == CKR_OK);
354 CPPUNIT_ASSERT(pMechanismList[0] == CKM_RSA_X_509);
355 CPPUNIT_ASSERT(pMechanismList[1] == CKM_RSA_PKCS);
356 free(pMechanismList);
357
358 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
359 #ifndef _WIN32
360 setenv("SOFTHSM2_CONF", "./softhsm2.conf", 1);
361 #else
362 setenv("SOFTHSM2_CONF", ".\\softhsm2.conf", 1);
363 #endif
364 }
365
testWaitForSlotEvent()366 void InfoTests::testWaitForSlotEvent()
367 {
368 CK_RV rv;
369
370 // Just make sure that we finalize any previous failed tests
371 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
372
373 rv = CRYPTOKI_F_PTR( C_WaitForSlotEvent(CKF_DONT_BLOCK, NULL_PTR, NULL_PTR) );
374 CPPUNIT_ASSERT(rv == CKR_CRYPTOKI_NOT_INITIALIZED);
375
376 rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) );
377 CPPUNIT_ASSERT(rv == CKR_OK);
378
379 // Blocking version should fail
380 rv = CRYPTOKI_F_PTR( C_WaitForSlotEvent(0, NULL_PTR, NULL_PTR) );
381 CPPUNIT_ASSERT(rv == CKR_FUNCTION_NOT_SUPPORTED);
382
383 // Should always return CKR_NO_EVENT
384 rv = CRYPTOKI_F_PTR( C_WaitForSlotEvent(CKF_DONT_BLOCK, NULL_PTR, NULL_PTR) );
385 CPPUNIT_ASSERT(rv == CKR_NO_EVENT);
386
387 CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) );
388 }
389