Botan 3.14.1
Crypto and TLS for C&
p11.cpp
Go to the documentation of this file.
1/*
2* PKCS#11
3* (C) 2016 Daniel Neus, Sirrix AG
4* (C) 2016 Philipp Weber, Sirrix AG
5* (C) 2025 Fabian Albert, Rohde & Schwarz Cybersecurity GmbH
6*
7* Botan is released under the Simplified BSD License (see license.txt)
8*/
9
10#include <botan/p11.h>
11
12#include <botan/assert.h>
13#include <botan/p11_types.h>
14#include <botan/internal/dyn_load.h>
15
16#include <algorithm>
17#include <string>
18
19namespace Botan::PKCS11 {
20
21// NOLINTNEXTLINE(*-no-int-to-ptr,*-avoid-non-const-global-variables)
22ReturnValue* ThrowException = reinterpret_cast<ReturnValue*>(-1);
23
24/// @param function_result Return value of the PKCS11 module function
25/// @param return_value if (`ThrowException`) is passed the function throws an exception, otherwise if a non-NULL pointer is passed:
26/// return_value receives the return value of the PKCS#11 function and no exception is thrown.
27/// @return true if function call was successful, false otherwise
28bool LowLevel::handle_return_value(const CK_RV function_result, ReturnValue* return_value) {
29 if(return_value == ThrowException) {
30 if(static_cast<ReturnValue>(function_result) != ReturnValue::OK) {
31 // caller wants exception
32 throw PKCS11_ReturnError(static_cast<ReturnValue>(function_result));
33 }
34 } else if(return_value != nullptr) {
35 // caller wants return value
36 *return_value = static_cast<ReturnValue>(function_result);
37 }
38
39 return static_cast<ReturnValue>(function_result) == ReturnValue::OK;
40}
41
42namespace {
43
44/*
45* Some modules reject a null data pointer even if the length is zero, which
46* is what an empty std::vector or std::span usually provides.
47*/
48Byte* nonnull_input(const Byte* ptr, Ulong len) {
49 if(ptr == nullptr && len == 0) {
50 static constexpr Byte empty_input = 0;
51 return const_cast<Byte*>(&empty_input);
52 }
53 return const_cast<Byte*>(ptr);
54}
55
56} // namespace
57
58void initialize_token(Slot& slot, std::string_view label, const secure_string& so_pin, const secure_string& pin) {
59 slot.initialize(label, so_pin);
60 set_pin(slot, so_pin, pin);
61}
62
63void change_pin(Slot& slot, const secure_string& old_pin, const secure_string& new_pin) {
64 Session session(slot, false);
65 session.login(UserType::User, old_pin);
66 session.set_pin(old_pin, new_pin);
67}
68
69void change_so_pin(Slot& slot, const secure_string& old_so_pin, const secure_string& new_so_pin) {
70 Session session(slot, false);
71 session.login(UserType::SO, old_so_pin);
72 session.set_pin(old_so_pin, new_so_pin);
73}
74
75void set_pin(Slot& slot, const secure_string& so_pin, const secure_string& pin) {
76 Session session(slot, false);
77 session.login(UserType::SO, so_pin);
78 session.init_pin(pin);
79}
80
82 m_interface_wrapper([&] {
83 BOTAN_ARG_CHECK(ptr != nullptr, "Function list pointer must not be nullptr");
86 .pFunctionList = ptr,
87 .flags = 0,
88 });
89 }()) {}
90
91LowLevel::LowLevel(InterfaceWrapper interface_wrapper) : m_interface_wrapper(interface_wrapper) {}
92
93/****************************** General purpose functions ******************************/
94
95bool LowLevel::C_Initialize(const void* init_args, ReturnValue* return_value) const {
96 return handle_return_value(m_interface_wrapper.func_2_40().C_Initialize(const_cast<void*>(init_args)), return_value);
97}
98
99bool LowLevel::C_Finalize(void* reserved, ReturnValue* return_value) const {
100 return handle_return_value(m_interface_wrapper.func_2_40().C_Finalize(reserved), return_value);
101}
102
103bool LowLevel::C_GetInfo(Info* info_ptr, ReturnValue* return_value) const {
104 return handle_return_value(m_interface_wrapper.func_2_40().C_GetInfo(info_ptr), return_value);
105}
106
108 FunctionList** function_list_ptr_ptr,
109 ReturnValue* return_value) {
110 using get_function_list = CK_RV (*)(FunctionList**);
111
112 get_function_list get_function_list_ptr = pkcs11_module.resolve<get_function_list>("C_GetFunctionList");
113
114 return handle_return_value(get_function_list_ptr(function_list_ptr_ptr), return_value);
115}
116
118 Interface* interface_list_ptr,
119 Ulong* count_ptr,
120 ReturnValue* return_value) {
121 using get_interface_list = CK_RV (*)(Interface*, Ulong*);
122 if(auto get_interface_list_ptr = pkcs11_module.try_resolve_symbol<get_interface_list>("C_GetInterfaceList");
123 get_interface_list_ptr.has_value()) {
124 return handle_return_value(get_interface_list_ptr.value()(interface_list_ptr, count_ptr), return_value);
125 }
126 // Loading the library function failed. Probably due to a cryptoki library with PKCS #11 < 3.0.
127 return handle_return_value(CKR_GENERAL_ERROR, return_value);
128}
129
131 const Utf8Char* interface_name_ptr,
132 const Version* version_ptr,
133 Interface** interface_ptr_ptr,
134 Flags flags,
135 ReturnValue* return_value) {
136 using get_interface =
137 CK_RV (*)(Utf8Char* interface_name_ptr, Version* version_ptr, Interface** interface_ptr_ptr, Flags flags);
138 if(auto get_interface_ptr = pkcs11_module.try_resolve_symbol<get_interface>("C_GetInterface");
139 get_interface_ptr.has_value()) {
140 return handle_return_value(
141 get_interface_ptr.value()(
142 const_cast<Utf8Char*>(interface_name_ptr), const_cast<Version*>(version_ptr), interface_ptr_ptr, flags),
143 return_value);
144 }
145 // Loading the library function failed. Probably due to a cryptoki library with PKCS #11 < 3.0.
146 return handle_return_value(CKR_GENERAL_ERROR, return_value);
147}
148
149/****************************** Slot and token management functions ******************************/
150
152 SlotId* slot_list_ptr,
153 Ulong* count_ptr,
154 ReturnValue* return_value) const {
155 return handle_return_value(m_interface_wrapper.func_2_40().C_GetSlotList(token_present, slot_list_ptr, count_ptr),
156 return_value);
157}
158
159bool LowLevel::C_GetSlotList(bool token_present, std::vector<SlotId>& slot_ids, ReturnValue* return_value) const {
160 slot_ids.clear();
161
162 // first get available slots
163 Ulong number_slots = 0;
164
165 const bool success = C_GetSlotList(static_cast<Bbool>(token_present), nullptr, &number_slots, return_value);
166
167 if(!success || number_slots == 0) {
168 return success;
169 }
170
171 // get actual slot ids
172 slot_ids.resize(number_slots);
173 if(!C_GetSlotList(static_cast<Bbool>(token_present), slot_ids.data(), &number_slots, return_value)) {
174 return false;
175 }
176 // the count may have shrunk between the calls
177 slot_ids.resize(std::min<size_t>(slot_ids.size(), number_slots));
178 return true;
179}
180
181bool LowLevel::C_GetSlotInfo(SlotId slot_id, SlotInfo* info_ptr, ReturnValue* return_value) const {
182 return handle_return_value(m_interface_wrapper.func_2_40().C_GetSlotInfo(slot_id, info_ptr), return_value);
183}
184
185bool LowLevel::C_GetTokenInfo(SlotId slot_id, TokenInfo* info_ptr, ReturnValue* return_value) const {
186 return handle_return_value(m_interface_wrapper.func_2_40().C_GetTokenInfo(slot_id, info_ptr), return_value);
187}
188
189bool LowLevel::C_WaitForSlotEvent(Flags flags, SlotId* slot_ptr, void* reserved, ReturnValue* return_value) const {
190 return handle_return_value(m_interface_wrapper.func_2_40().C_WaitForSlotEvent(flags, slot_ptr, reserved),
191 return_value);
192}
193
195 MechanismType* mechanism_list_ptr,
196 Ulong* count_ptr,
197 ReturnValue* return_value) const {
198 return handle_return_value(m_interface_wrapper.func_2_40().C_GetMechanismList(
199 slot_id, reinterpret_cast<CK_MECHANISM_TYPE_PTR>(mechanism_list_ptr), count_ptr),
200 return_value);
201}
202
204 std::vector<MechanismType>& mechanisms,
205 ReturnValue* return_value) const {
206 mechanisms.clear();
207
208 // first get number of mechanisms
209 Ulong number_mechanisms = 0;
210
211 const bool success = C_GetMechanismList(slot_id, nullptr, &number_mechanisms, return_value);
212
213 if(!success || number_mechanisms == 0) {
214 return success;
215 }
216
217 // get actual mechanisms
218 mechanisms.resize(number_mechanisms);
220 slot_id, reinterpret_cast<MechanismType*>(mechanisms.data()), &number_mechanisms, return_value)) {
221 return false;
222 }
223 // the count may have shrunk between the calls
224 mechanisms.resize(std::min<size_t>(mechanisms.size(), number_mechanisms));
225 return true;
226}
227
229 MechanismType type,
230 MechanismInfo* info_ptr,
231 ReturnValue* return_value) const {
232 return handle_return_value(
233 m_interface_wrapper.func_2_40().C_GetMechanismInfo(slot_id, static_cast<CK_MECHANISM_TYPE>(type), info_ptr),
234 return_value);
235}
236
238 const Utf8Char* so_pin_ptr,
239 Ulong so_pin_len,
240 const Utf8Char* label_ptr,
241 ReturnValue* return_value) const {
242 return handle_return_value(
243 m_interface_wrapper.func_2_40().C_InitToken(
244 slot_id, const_cast<Utf8Char*>(so_pin_ptr), so_pin_len, const_cast<Utf8Char*>(label_ptr)),
245 return_value);
246}
247
249 const Utf8Char* pin_ptr,
250 Ulong pin_len,
251 ReturnValue* return_value) const {
252 return handle_return_value(
253 m_interface_wrapper.func_2_40().C_InitPIN(session, const_cast<Utf8Char*>(pin_ptr), pin_len), return_value);
254}
255
257 const Utf8Char* old_pin_ptr,
258 Ulong old_len,
259 const Utf8Char* new_pin_ptr,
260 Ulong new_len,
261 ReturnValue* return_value) const {
262 return handle_return_value(
263 m_interface_wrapper.func_2_40().C_SetPIN(
264 session, const_cast<Utf8Char*>(old_pin_ptr), old_len, const_cast<Utf8Char*>(new_pin_ptr), new_len),
265 return_value);
266}
267
268/****************************** Session management ******************************/
269
271 Flags flags,
272 void* application,
273 Notify notify,
274 SessionHandle* session_ptr,
275 ReturnValue* return_value) const {
276 return handle_return_value(
277 m_interface_wrapper.func_2_40().C_OpenSession(slot_id, flags, application, notify, session_ptr), return_value);
278}
279
280bool LowLevel::C_CloseSession(SessionHandle session, ReturnValue* return_value) const {
281 return handle_return_value(m_interface_wrapper.func_2_40().C_CloseSession(session), return_value);
282}
283
284bool LowLevel::C_CloseAllSessions(SlotId slot_id, ReturnValue* return_value) const {
285 return handle_return_value(m_interface_wrapper.func_2_40().C_CloseAllSessions(slot_id), return_value);
286}
287
288bool LowLevel::C_GetSessionInfo(SessionHandle session, SessionInfo* info_ptr, ReturnValue* return_value) const {
289 return handle_return_value(m_interface_wrapper.func_2_40().C_GetSessionInfo(session, info_ptr), return_value);
290}
291
293 return handle_return_value(m_interface_wrapper.func_3_0().C_SessionCancel(session, flags), return_value);
294}
295
297 Byte* operation_state_ptr,
298 Ulong* operation_state_len_ptr,
299 ReturnValue* return_value) const {
300 return handle_return_value(
301 m_interface_wrapper.func_2_40().C_GetOperationState(session, operation_state_ptr, operation_state_len_ptr),
302 return_value);
303}
304
306 const Byte* operation_state_ptr,
307 Ulong operation_state_len,
308 ObjectHandle encryption_key,
309 ObjectHandle authentication_key,
310 ReturnValue* return_value) const {
311 return handle_return_value(
312 m_interface_wrapper.func_2_40().C_SetOperationState(
313 session, const_cast<Byte*>(operation_state_ptr), operation_state_len, encryption_key, authentication_key),
314 return_value);
315}
316
318 SessionHandle session, UserType user_type, const Utf8Char* pin_ptr, Ulong pin_len, ReturnValue* return_value) const {
319 return handle_return_value(
320 m_interface_wrapper.func_2_40().C_Login(
321 session, static_cast<CK_USER_TYPE>(user_type), const_cast<Utf8Char*>(pin_ptr), pin_len),
322 return_value);
323}
324
326 UserType user_type,
327 const Utf8Char* pin_ptr,
328 Ulong pin_len,
329 const Utf8Char* username_ptr,
330 Ulong username_len,
331 ReturnValue* return_value) {
332 return handle_return_value(m_interface_wrapper.func_3_0().C_LoginUser(session,
333 static_cast<CK_USER_TYPE>(user_type),
334 const_cast<Utf8Char*>(pin_ptr),
335 pin_len,
336 const_cast<Utf8Char*>(username_ptr),
337 username_len),
338 return_value);
339}
340
341bool LowLevel::C_Logout(SessionHandle session, ReturnValue* return_value) const {
342 return handle_return_value(m_interface_wrapper.func_2_40().C_Logout(session), return_value);
343}
344
346 Ulong type,
347 Flags* flags_ptr,
348 ReturnValue* return_value) {
349 return handle_return_value(m_interface_wrapper.func_3_2().C_GetSessionValidationFlags(session, type, flags_ptr),
350 return_value);
351}
352
353/****************************** Object management functions ******************************/
354
356 Attribute* attribute_template_ptr,
357 Ulong count,
358 ObjectHandle* object_ptr,
359 ReturnValue* return_value) const {
360 return handle_return_value(
361 m_interface_wrapper.func_2_40().C_CreateObject(session, attribute_template_ptr, count, object_ptr), return_value);
362}
363
365 ObjectHandle object,
366 Attribute* attribute_template_ptr,
367 Ulong count,
368 ObjectHandle* new_object_ptr,
369 ReturnValue* return_value) const {
370 return handle_return_value(
371 m_interface_wrapper.func_2_40().C_CopyObject(session, object, attribute_template_ptr, count, new_object_ptr),
372 return_value);
373}
374
375bool LowLevel::C_DestroyObject(SessionHandle session, ObjectHandle object, ReturnValue* return_value) const {
376 return handle_return_value(m_interface_wrapper.func_2_40().C_DestroyObject(session, object), return_value);
377}
378
380 ObjectHandle object,
381 Ulong* size_ptr,
382 ReturnValue* return_value) const {
383 return handle_return_value(m_interface_wrapper.func_2_40().C_GetObjectSize(session, object, size_ptr), return_value);
384}
385
387 ObjectHandle object,
388 Attribute* attribute_template_ptr,
389 Ulong count,
390 ReturnValue* return_value) const {
391 return handle_return_value(
392 m_interface_wrapper.func_2_40().C_GetAttributeValue(session, object, attribute_template_ptr, count),
393 return_value);
394}
395
397 ObjectHandle object,
398 Attribute* attribute_template_ptr,
399 Ulong count,
400 ReturnValue* return_value) const {
401 return handle_return_value(
402 m_interface_wrapper.func_2_40().C_SetAttributeValue(session, object, attribute_template_ptr, count),
403 return_value);
404}
405
407 Attribute* attribute_template_ptr,
408 Ulong count,
409 ReturnValue* return_value) const {
410 return handle_return_value(m_interface_wrapper.func_2_40().C_FindObjectsInit(session, attribute_template_ptr, count),
411 return_value);
412}
413
415 ObjectHandle* object_ptr,
416 Ulong max_object_count,
417 Ulong* object_count_ptr,
418 ReturnValue* return_value) const {
419 return handle_return_value(
420 m_interface_wrapper.func_2_40().C_FindObjects(session, object_ptr, max_object_count, object_count_ptr),
421 return_value);
422}
423
424bool LowLevel::C_FindObjectsFinal(SessionHandle session, ReturnValue* return_value) const {
425 return handle_return_value(m_interface_wrapper.func_2_40().C_FindObjectsFinal(session), return_value);
426}
427
428/****************************** Encryption functions ******************************/
429
431 const Mechanism* mechanism_ptr,
432 ObjectHandle key,
433 ReturnValue* return_value) const {
434 return handle_return_value(
435 m_interface_wrapper.func_2_40().C_EncryptInit(session, const_cast<Mechanism*>(mechanism_ptr), key), return_value);
436}
437
439 const Byte* data_ptr,
440 Ulong data_len,
441 Byte* encrypted_data_ptr,
442 Ulong* encrypted_data_len_ptr,
443 ReturnValue* return_value) const {
444 return handle_return_value(
445 m_interface_wrapper.func_2_40().C_Encrypt(
446 session, nonnull_input(data_ptr, data_len), data_len, encrypted_data_ptr, encrypted_data_len_ptr),
447 return_value);
448}
449
451 const Byte* part_ptr,
452 Ulong part_len,
453 Byte* encrypted_part_ptr,
454 Ulong* encrypted_part_len_ptr,
455 ReturnValue* return_value) const {
456 return handle_return_value(
457 m_interface_wrapper.func_2_40().C_EncryptUpdate(
458 session, const_cast<Byte*>(part_ptr), part_len, encrypted_part_ptr, encrypted_part_len_ptr),
459 return_value);
460}
461
463 Byte* last_encrypted_part_ptr,
464 Ulong* last_encrypted_part_len_ptr,
465 ReturnValue* return_value) const {
466 return handle_return_value(
467 m_interface_wrapper.func_2_40().C_EncryptFinal(session, last_encrypted_part_ptr, last_encrypted_part_len_ptr),
468 return_value);
469}
470
471/*********************** Message-based encryption functions ***********************/
472
474 const Mechanism* mechanism_ptr,
475 ObjectHandle key,
476 ReturnValue* return_value) {
477 return handle_return_value(
478 m_interface_wrapper.func_3_0().C_MessageEncryptInit(session, const_cast<Mechanism*>(mechanism_ptr), key),
479 return_value);
480}
481
483 const void* parameter_ptr,
484 Ulong parameter_len,
485 const Byte* associated_data_ptr,
486 Ulong associated_data_len,
487 const Byte* plaintext_ptr,
488 Ulong plaintext_len,
489 Byte* ciphertext_ptr,
490 Ulong* ciphertext_len_ptr,
491 ReturnValue* return_value) {
492 return handle_return_value(m_interface_wrapper.func_3_0().C_EncryptMessage(session,
493 const_cast<void*>(parameter_ptr),
494 parameter_len,
495 const_cast<Byte*>(associated_data_ptr),
496 associated_data_len,
497 const_cast<Byte*>(plaintext_ptr),
498 plaintext_len,
499 ciphertext_ptr,
500 ciphertext_len_ptr),
501 return_value);
502}
503
505 const void* parameter_ptr,
506 Ulong parameter_len,
507 const Byte* associated_data_ptr,
508 Ulong associated_data_len,
509 ReturnValue* return_value) {
510 return handle_return_value(
511 m_interface_wrapper.func_3_0().C_EncryptMessageBegin(session,
512 const_cast<void*>(parameter_ptr),
513 parameter_len,
514 const_cast<Byte*>(associated_data_ptr),
515 associated_data_len),
516 return_value);
517}
518
520 const void* parameter_ptr,
521 Ulong parameter_len,
522 const Byte* plaintext_part_ptr,
523 Ulong plaintext_part_len,
524 Byte* ciphertext_ptr,
525 Ulong* ciphertext_part_len_ptr,
526 Flags flags,
527 ReturnValue* return_value) {
528 return handle_return_value(m_interface_wrapper.func_3_0().C_EncryptMessageNext(session,
529 const_cast<void*>(parameter_ptr),
530 parameter_len,
531 const_cast<Byte*>(plaintext_part_ptr),
532 plaintext_part_len,
533 ciphertext_ptr,
534 ciphertext_part_len_ptr,
535 flags),
536 return_value);
537}
538
540 return handle_return_value(m_interface_wrapper.func_3_0().C_MessageEncryptFinal(session), return_value);
541}
542
543/****************************** Decryption functions ******************************/
544
546 const Mechanism* mechanism_ptr,
547 ObjectHandle key,
548 ReturnValue* return_value) const {
549 return handle_return_value(
550 m_interface_wrapper.func_2_40().C_DecryptInit(session, const_cast<Mechanism*>(mechanism_ptr), key), return_value);
551}
552
554 const Byte* encrypted_data_ptr,
555 Ulong encrypted_data_len,
556 Byte* data_ptr,
557 Ulong* data_len_ptr,
558 ReturnValue* return_value) const {
559 return handle_return_value(
560 m_interface_wrapper.func_2_40().C_Decrypt(
561 session, const_cast<Byte*>(encrypted_data_ptr), encrypted_data_len, data_ptr, data_len_ptr),
562 return_value);
563}
564
566 const Byte* encrypted_part_ptr,
567 Ulong encrypted_part_len,
568 Byte* part_ptr,
569 Ulong* part_len_ptr,
570 ReturnValue* return_value) const {
571 return handle_return_value(
572 m_interface_wrapper.func_2_40().C_DecryptUpdate(
573 session, const_cast<Byte*>(encrypted_part_ptr), encrypted_part_len, part_ptr, part_len_ptr),
574 return_value);
575}
576
578 Byte* last_part_ptr,
579 Ulong* last_part_len_ptr,
580 ReturnValue* return_value) const {
581 return handle_return_value(m_interface_wrapper.func_2_40().C_DecryptFinal(session, last_part_ptr, last_part_len_ptr),
582 return_value);
583}
584
585/*********************** Message-based decryption functions ***********************/
586
588 const Mechanism* mechanism_ptr,
589 ObjectHandle key,
590 ReturnValue* return_value) {
591 return handle_return_value(
592 m_interface_wrapper.func_3_0().C_MessageDecryptInit(session, const_cast<Mechanism*>(mechanism_ptr), key),
593 return_value);
594}
595
597 const void* parameter_ptr,
598 Ulong parameter_len,
599 const Byte* associated_data_ptr,
600 Ulong associated_data_len,
601 const Byte* ciphertext_ptr,
602 Ulong ciphertext_len,
603 Byte* plaintext_ptr,
604 Ulong* plaintext_len_ptr,
605 ReturnValue* return_value) {
606 return handle_return_value(m_interface_wrapper.func_3_0().C_DecryptMessage(session,
607 const_cast<void*>(parameter_ptr),
608 parameter_len,
609 const_cast<Byte*>(associated_data_ptr),
610 associated_data_len,
611 const_cast<Byte*>(ciphertext_ptr),
612 ciphertext_len,
613 plaintext_ptr,
614 plaintext_len_ptr),
615 return_value);
616}
617
619 const void* parameter_ptr,
620 Ulong parameter_len,
621 const Byte* associated_data_ptr,
622 Ulong associated_data_len,
623 ReturnValue* return_value) {
624 return handle_return_value(
625 m_interface_wrapper.func_3_0().C_DecryptMessageBegin(session,
626 const_cast<void*>(parameter_ptr),
627 parameter_len,
628 const_cast<Byte*>(associated_data_ptr),
629 associated_data_len),
630 return_value);
631}
632
634 const void* parameter_ptr,
635 Ulong parameter_len,
636 const Byte* ciphertext_part_ptr,
637 Ulong ciphertext_part_len,
638 Byte* plaintext_ptr,
639 Ulong* plaintext_part_len_ptr,
640 Flags flags,
641 ReturnValue* return_value) {
642 return handle_return_value(
643 m_interface_wrapper.func_3_0().C_DecryptMessageNext(session,
644 const_cast<void*>(parameter_ptr),
645 parameter_len,
646 const_cast<Byte*>(ciphertext_part_ptr),
647 ciphertext_part_len,
648 plaintext_ptr,
649 plaintext_part_len_ptr,
650 flags),
651 return_value);
652}
653
655 return handle_return_value(m_interface_wrapper.func_3_0().C_MessageDecryptFinal(session), return_value);
656}
657
658/****************************** Message digesting functions ******************************/
659
660bool LowLevel::C_DigestInit(SessionHandle session, const Mechanism* mechanism, ReturnValue* return_value) const {
661 return handle_return_value(m_interface_wrapper.func_2_40().C_DigestInit(session, const_cast<Mechanism*>(mechanism)),
662 return_value);
663}
664
666 const Byte* data_ptr,
667 Ulong data_len,
668 Byte* digest_ptr,
669 Ulong* digest_len_ptr,
670 ReturnValue* return_value) const {
671 return handle_return_value(m_interface_wrapper.func_2_40().C_Digest(
672 session, const_cast<Byte*>(data_ptr), data_len, digest_ptr, digest_len_ptr),
673 return_value);
674}
675
677 const Byte* part_ptr,
678 Ulong part_len,
679 ReturnValue* return_value) const {
680 return handle_return_value(
681 m_interface_wrapper.func_2_40().C_DigestUpdate(session, const_cast<Byte*>(part_ptr), part_len), return_value);
682}
683
684bool LowLevel::C_DigestKey(SessionHandle session, ObjectHandle key, ReturnValue* return_value) const {
685 return handle_return_value(m_interface_wrapper.func_2_40().C_DigestKey(session, key), return_value);
686}
687
689 Byte* digest_ptr,
690 Ulong* digest_len_ptr,
691 ReturnValue* return_value) const {
692 return handle_return_value(m_interface_wrapper.func_2_40().C_DigestFinal(session, digest_ptr, digest_len_ptr),
693 return_value);
694}
695
696/****************************** Signing and MACing functions ******************************/
697
699 const Mechanism* mechanism_ptr,
700 ObjectHandle key,
701 ReturnValue* return_value) const {
702 return handle_return_value(
703 m_interface_wrapper.func_2_40().C_SignInit(session, const_cast<Mechanism*>(mechanism_ptr), key), return_value);
704}
705
707 const Byte* data_ptr,
708 Ulong data_len,
709 Byte* signature_ptr,
710 Ulong* signature_len_ptr,
711 ReturnValue* return_value) const {
712 return handle_return_value(
713 m_interface_wrapper.func_2_40().C_Sign(
714 session, nonnull_input(data_ptr, data_len), data_len, signature_ptr, signature_len_ptr),
715 return_value);
716}
717
719 const Byte* part_ptr,
720 Ulong part_len,
721 ReturnValue* return_value) const {
722 return handle_return_value(
723 m_interface_wrapper.func_2_40().C_SignUpdate(session, nonnull_input(part_ptr, part_len), part_len), return_value);
724}
725
727 Byte* signature_ptr,
728 Ulong* signature_len_ptr,
729 ReturnValue* return_value) const {
730 return handle_return_value(m_interface_wrapper.func_2_40().C_SignFinal(session, signature_ptr, signature_len_ptr),
731 return_value);
732}
733
735 const Mechanism* mechanism_ptr,
736 ObjectHandle key,
737 ReturnValue* return_value) const {
738 return handle_return_value(
739 m_interface_wrapper.func_2_40().C_SignRecoverInit(session, const_cast<Mechanism*>(mechanism_ptr), key),
740 return_value);
741}
742
744 const Byte* data,
745 Ulong data_len,
746 Byte* signature,
747 Ulong* signature_len,
748 ReturnValue* return_value) const {
749 return handle_return_value(m_interface_wrapper.func_2_40().C_SignRecover(
750 session, const_cast<Byte*>(data), data_len, signature, signature_len),
751 return_value);
752}
753
754/******************* Message-based signing and MACing functions *******************/
755
757 const Mechanism* mechanism_ptr,
758 ObjectHandle key,
759 ReturnValue* return_value) {
760 return handle_return_value(
761 m_interface_wrapper.func_3_0().C_MessageSignInit(session, const_cast<Mechanism*>(mechanism_ptr), key),
762 return_value);
763}
764
766 const void* parameter_ptr,
767 Ulong parameter_len,
768 const Byte* data_ptr,
769 Ulong data_len,
770 Byte* signature_ptr,
771 Ulong* signature_len_ptr,
772 ReturnValue* return_value) {
773 return handle_return_value(m_interface_wrapper.func_3_0().C_SignMessage(session,
774 const_cast<void*>(parameter_ptr),
775 parameter_len,
776 const_cast<Byte*>(data_ptr),
777 data_len,
778 signature_ptr,
779 signature_len_ptr),
780 return_value);
781}
782
784 const void* parameter_ptr,
785 Ulong parameter_len,
786 ReturnValue* return_value) {
787 return handle_return_value(
788 m_interface_wrapper.func_3_0().C_SignMessageBegin(session, const_cast<void*>(parameter_ptr), parameter_len),
789 return_value);
790}
791
793 const void* parameter_ptr,
794 Ulong parameter_len,
795 const Byte* data_ptr,
796 Ulong data_len,
797 Byte* signature_ptr,
798 Ulong* signature_len_ptr,
799 ReturnValue* return_value) {
800 return handle_return_value(m_interface_wrapper.func_3_0().C_SignMessageNext(session,
801 const_cast<void*>(parameter_ptr),
802 parameter_len,
803 const_cast<Byte*>(data_ptr),
804 data_len,
805 signature_ptr,
806 signature_len_ptr),
807 return_value);
808}
809
811 return handle_return_value(m_interface_wrapper.func_3_0().C_MessageSignFinal(session), return_value);
812}
813
814/****************************** Functions for verifying signatures and MACs ******************************/
815
817 const Mechanism* mechanism_ptr,
818 ObjectHandle key,
819 ReturnValue* return_value) const {
820 return handle_return_value(
821 m_interface_wrapper.func_2_40().C_VerifyInit(session, const_cast<Mechanism*>(mechanism_ptr), key), return_value);
822}
823
825 const Byte* data_ptr,
826 Ulong data_len,
827 const Byte* signature_ptr,
828 Ulong signature_len,
829 ReturnValue* return_value) const {
830 return handle_return_value(
831 m_interface_wrapper.func_2_40().C_Verify(
832 session, nonnull_input(data_ptr, data_len), data_len, const_cast<Byte*>(signature_ptr), signature_len),
833 return_value);
834}
835
837 const Byte* part_ptr,
838 Ulong part_len,
839 ReturnValue* return_value) const {
840 return handle_return_value(
841 m_interface_wrapper.func_2_40().C_VerifyUpdate(session, nonnull_input(part_ptr, part_len), part_len),
842 return_value);
843}
844
846 const Byte* signature_ptr,
847 Ulong signature_len,
848 ReturnValue* return_value) const {
849 return handle_return_value(
850 m_interface_wrapper.func_2_40().C_VerifyFinal(session, const_cast<Byte*>(signature_ptr), signature_len),
851 return_value);
852}
853
855 const Mechanism* mechanism_ptr,
856 ObjectHandle key,
857 ReturnValue* return_value) const {
858 return handle_return_value(
859 m_interface_wrapper.func_2_40().C_VerifyRecoverInit(session, const_cast<Mechanism*>(mechanism_ptr), key),
860 return_value);
861}
862
864 const Byte* signature_ptr,
865 Ulong signature_len,
866 Byte* data_ptr,
867 Ulong* data_len_ptr,
868 ReturnValue* return_value) const {
869 return handle_return_value(m_interface_wrapper.func_2_40().C_VerifyRecover(
870 session, const_cast<Byte*>(signature_ptr), signature_len, data_ptr, data_len_ptr),
871 return_value);
872}
873
875 const Mechanism* mechanism_ptr,
876 ObjectHandle key,
877 const Byte* signature_ptr,
878 Ulong signature_len,
879 ReturnValue* return_value) {
880 return handle_return_value(
881 m_interface_wrapper.func_3_2().C_VerifySignatureInit(
882 session, const_cast<Mechanism*>(mechanism_ptr), key, const_cast<Byte*>(signature_ptr), signature_len),
883 return_value);
884}
885
887 const Byte* data_ptr,
888 Ulong data_len,
889 ReturnValue* return_value) {
890 return handle_return_value(
891 m_interface_wrapper.func_3_2().C_VerifySignature(session, const_cast<Byte*>(data_ptr), data_len), return_value);
892}
893
895 const Byte* part_ptr,
896 Ulong part_len,
897 ReturnValue* return_value) {
898 return handle_return_value(
899 m_interface_wrapper.func_3_2().C_VerifySignatureUpdate(session, const_cast<Byte*>(part_ptr), part_len),
900 return_value);
901}
902
904 return handle_return_value(m_interface_wrapper.func_3_2().C_VerifySignatureFinal(session), return_value);
905}
906
907/*********** Message-based functions for verifying signatures and MACs ************/
908
910 const Mechanism* mechanism_ptr,
911 ObjectHandle key,
912 ReturnValue* return_value) {
913 return handle_return_value(
914 m_interface_wrapper.func_3_0().C_MessageVerifyInit(session, const_cast<Mechanism*>(mechanism_ptr), key),
915 return_value);
916}
917
919 const void* parameter_ptr,
920 Ulong parameter_len,
921 const Byte* data_ptr,
922 Ulong data_len,
923 const Byte* signature_ptr,
924 Ulong signature_len,
925 ReturnValue* return_value) {
926 return handle_return_value(m_interface_wrapper.func_3_0().C_VerifyMessage(session,
927 const_cast<void*>(parameter_ptr),
928 parameter_len,
929 const_cast<Byte*>(data_ptr),
930 data_len,
931 const_cast<Byte*>(signature_ptr),
932 signature_len),
933 return_value);
934}
935
937 const void* parameter_ptr,
938 Ulong parameter_len,
939 ReturnValue* return_value) {
940 return handle_return_value(
941 m_interface_wrapper.func_3_0().C_VerifyMessageBegin(session, const_cast<void*>(parameter_ptr), parameter_len),
942 return_value);
943}
944
946 const void* parameter_ptr,
947 Ulong parameter_len,
948 const Byte* data_ptr,
949 Ulong data_len,
950 const Byte* signature_ptr,
951 Ulong signature_len,
952 ReturnValue* return_value) {
953 return handle_return_value(m_interface_wrapper.func_3_0().C_VerifyMessageNext(session,
954 const_cast<void*>(parameter_ptr),
955 parameter_len,
956 const_cast<Byte*>(data_ptr),
957 data_len,
958 const_cast<Byte*>(signature_ptr),
959 signature_len),
960 return_value);
961}
962
964 return handle_return_value(m_interface_wrapper.func_3_0().C_MessageVerifyFinal(session), return_value);
965}
966
967/****************************** Dual-purpose cryptographic functions ******************************/
968
970 const Byte* part_ptr,
971 Ulong part_len,
972 Byte* encrypted_part_ptr,
973 Ulong* encrypted_part_len_ptr,
974 ReturnValue* return_value) const {
975 return handle_return_value(
976 m_interface_wrapper.func_2_40().C_DigestEncryptUpdate(
977 session, const_cast<Byte*>(part_ptr), part_len, encrypted_part_ptr, encrypted_part_len_ptr),
978 return_value);
979}
980
982 const Byte* encrypted_part_ptr,
983 Ulong encrypted_part_len,
984 Byte* part_ptr,
985 Ulong* part_len_ptr,
986 ReturnValue* return_value) const {
987 return handle_return_value(
988 m_interface_wrapper.func_2_40().C_DecryptDigestUpdate(
989 session, const_cast<Byte*>(encrypted_part_ptr), encrypted_part_len, part_ptr, part_len_ptr),
990 return_value);
991}
992
994 const Byte* part_ptr,
995 Ulong part_len,
996 Byte* encrypted_part_ptr,
997 Ulong* encrypted_part_len_ptr,
998 ReturnValue* return_value) const {
999 return handle_return_value(
1000 m_interface_wrapper.func_2_40().C_SignEncryptUpdate(
1001 session, const_cast<Byte*>(part_ptr), part_len, encrypted_part_ptr, encrypted_part_len_ptr),
1002 return_value);
1003}
1004
1006 const Byte* encrypted_part_ptr,
1007 Ulong encrypted_part_len,
1008 Byte* part_ptr,
1009 Ulong* part_len_ptr,
1010 ReturnValue* return_value) const {
1011 return handle_return_value(
1012 m_interface_wrapper.func_2_40().C_DecryptVerifyUpdate(
1013 session, const_cast<Byte*>(encrypted_part_ptr), encrypted_part_len, part_ptr, part_len_ptr),
1014 return_value);
1015}
1016
1017/****************************** Key management functions ******************************/
1018
1020 const Mechanism* mechanism_ptr,
1021 Attribute* attribute_template_ptr,
1022 Ulong count,
1023 ObjectHandle* key_ptr,
1024 ReturnValue* return_value) const {
1025 return handle_return_value(
1026 m_interface_wrapper.func_2_40().C_GenerateKey(
1027 session, const_cast<Mechanism*>(mechanism_ptr), attribute_template_ptr, count, key_ptr),
1028 return_value);
1029}
1030
1032 const Mechanism* mechanism_ptr,
1033 Attribute* public_key_template_ptr,
1034 Ulong public_key_attribute_count,
1035 Attribute* private_key_template_ptr,
1036 Ulong private_key_attribute_count,
1037 ObjectHandle* public_key_ptr,
1038 ObjectHandle* private_key_ptr,
1039 ReturnValue* return_value) const {
1040 return handle_return_value(m_interface_wrapper.func_2_40().C_GenerateKeyPair(session,
1041 const_cast<Mechanism*>(mechanism_ptr),
1042 public_key_template_ptr,
1043 public_key_attribute_count,
1044 private_key_template_ptr,
1045 private_key_attribute_count,
1046 public_key_ptr,
1047 private_key_ptr),
1048 return_value);
1049}
1050
1052 const Mechanism* mechanism_ptr,
1053 ObjectHandle wrapping_key,
1054 ObjectHandle key,
1055 Byte* wrapped_key_ptr,
1056 Ulong* wrapped_key_len_ptr,
1057 ReturnValue* return_value) const {
1058 return handle_return_value(
1059 m_interface_wrapper.func_2_40().C_WrapKey(
1060 session, const_cast<Mechanism*>(mechanism_ptr), wrapping_key, key, wrapped_key_ptr, wrapped_key_len_ptr),
1061 return_value);
1062}
1063
1065 const Mechanism* mechanism_ptr,
1066 ObjectHandle unwrapping_key,
1067 const Byte* wrapped_key_ptr,
1068 Ulong wrapped_key_len,
1069 Attribute* attribute_template_ptr,
1070 Ulong attribute_count,
1071 ObjectHandle* key_ptr,
1072 ReturnValue* return_value) const {
1073 return handle_return_value(m_interface_wrapper.func_2_40().C_UnwrapKey(session,
1074 const_cast<Mechanism*>(mechanism_ptr),
1075 unwrapping_key,
1076 const_cast<Byte*>(wrapped_key_ptr),
1077 wrapped_key_len,
1078 attribute_template_ptr,
1079 attribute_count,
1080 key_ptr),
1081 return_value);
1082}
1083
1085 const Mechanism* mechanism_ptr,
1086 ObjectHandle base_key,
1087 Attribute* attribute_template_ptr,
1088 Ulong attribute_count,
1089 ObjectHandle* key_ptr,
1090 ReturnValue* return_value) const {
1091 return handle_return_value(
1092 m_interface_wrapper.func_2_40().C_DeriveKey(
1093 session, const_cast<Mechanism*>(mechanism_ptr), base_key, attribute_template_ptr, attribute_count, key_ptr),
1094 return_value);
1095}
1096
1098 const Mechanism* mechanism_ptr,
1099 ObjectHandle wrapping_key,
1100 ObjectHandle key,
1101 const Byte* associated_data_ptr,
1102 Ulong associated_data_len,
1103 Byte* wrapped_key_ptr,
1104 Ulong* wrapped_key_len_ptr,
1105 ReturnValue* return_value) const {
1106 return handle_return_value(
1107 m_interface_wrapper.func_3_2().C_WrapKeyAuthenticated(session,
1108 const_cast<Mechanism*>(mechanism_ptr),
1109 wrapping_key,
1110 key,
1111 const_cast<Byte*>(associated_data_ptr),
1112 associated_data_len,
1113 wrapped_key_ptr,
1114 wrapped_key_len_ptr),
1115 return_value);
1116}
1117
1119 const Mechanism* mechanism_ptr,
1120 ObjectHandle unwrapping_key,
1121 const Byte* wrapped_key_ptr,
1122 Ulong wrapped_key_len,
1123 Attribute* attribute_template_ptr,
1124 Ulong attribute_count,
1125 const Byte* associated_data_ptr,
1126 Ulong associated_data_len,
1127 ObjectHandle* key_ptr,
1128 ReturnValue* return_value) const {
1129 return handle_return_value(
1130 m_interface_wrapper.func_3_2().C_UnwrapKeyAuthenticated(session,
1131 const_cast<Mechanism*>(mechanism_ptr),
1132 unwrapping_key,
1133 const_cast<Byte*>(wrapped_key_ptr),
1134 wrapped_key_len,
1135 attribute_template_ptr,
1136 attribute_count,
1137 const_cast<Byte*>(associated_data_ptr),
1138 associated_data_len,
1139 key_ptr),
1140 return_value);
1141}
1142
1144 const Mechanism* mechanism_ptr,
1145 ObjectHandle public_key,
1146 Attribute* template_ptr,
1147 Ulong attribute_count,
1148 Byte* ciphertext_ptr,
1149 Ulong* ciphertext_len_ptr,
1150 ObjectHandle* key_ptr,
1151 ReturnValue* return_value) {
1152 return handle_return_value(m_interface_wrapper.func_3_2().C_EncapsulateKey(session,
1153 const_cast<Mechanism*>(mechanism_ptr),
1154 public_key,
1155 template_ptr,
1156 attribute_count,
1157 ciphertext_ptr,
1158 ciphertext_len_ptr,
1159 key_ptr),
1160 return_value);
1161}
1162
1164 const Mechanism* mechanism_ptr,
1165 ObjectHandle private_key,
1166 Attribute* template_ptr,
1167 Ulong attribute_count,
1168 const Byte* ciphertext_ptr,
1169 Ulong ciphertext_len,
1170 ObjectHandle* key_ptr,
1171 ReturnValue* return_value) {
1172 return handle_return_value(m_interface_wrapper.func_3_2().C_DecapsulateKey(session,
1173 const_cast<Mechanism*>(mechanism_ptr),
1174 private_key,
1175 template_ptr,
1176 attribute_count,
1177 const_cast<Byte*>(ciphertext_ptr),
1178 ciphertext_len,
1179 key_ptr),
1180 return_value);
1181}
1182
1183/****************************** Random number generation functions ******************************/
1184
1186 const Byte* seed_ptr,
1187 Ulong seed_len,
1188 ReturnValue* return_value) const {
1189 return handle_return_value(
1190 m_interface_wrapper.func_2_40().C_SeedRandom(session, const_cast<Byte*>(seed_ptr), seed_len), return_value);
1191}
1192
1194 Byte* random_data_ptr,
1195 Ulong random_len,
1196 ReturnValue* return_value) const {
1197 return handle_return_value(m_interface_wrapper.func_2_40().C_GenerateRandom(session, random_data_ptr, random_len),
1198 return_value);
1199}
1200
1201/****************************** Parallel function management functions ******************************/
1202
1203bool LowLevel::C_GetFunctionStatus(SessionHandle session, ReturnValue* return_value) const {
1204 return handle_return_value(m_interface_wrapper.func_2_40().C_GetFunctionStatus(session), return_value);
1205}
1206
1207bool LowLevel::C_CancelFunction(SessionHandle session, ReturnValue* return_value) const {
1208 return handle_return_value(m_interface_wrapper.func_2_40().C_CancelFunction(session), return_value);
1209}
1210
1211/******************* Asynchronous function management functions *******************/
1212
1214 const Utf8Char* function_name_ptr,
1215 AsyncData* result_ptr,
1216 ReturnValue* return_value) {
1217 return handle_return_value(
1218 m_interface_wrapper.func_3_2().C_AsyncComplete(session, const_cast<Utf8Char*>(function_name_ptr), result_ptr),
1219 return_value);
1220}
1221
1223 const Utf8Char* function_name_ptr,
1224 Ulong* id_ptr,
1225 ReturnValue* return_value) {
1226 return handle_return_value(
1227 m_interface_wrapper.func_3_2().C_AsyncGetID(session, const_cast<Utf8Char*>(function_name_ptr), id_ptr),
1228 return_value);
1229}
1230
1232 const Utf8Char* function_name_ptr,
1233 Ulong id,
1234 Byte* data_ptr,
1235 Ulong data_len,
1236 ReturnValue* return_value) {
1237 return handle_return_value(m_interface_wrapper.func_3_2().C_AsyncJoin(
1238 session, const_cast<Utf8Char*>(function_name_ptr), id, data_ptr, data_len),
1239 return_value);
1240}
1241
1243 return reinterpret_cast<FunctionList*>(m_interface_wrapper.raw_interface().pFunctionList);
1244}
1245
1246} // namespace Botan::PKCS11
#define BOTAN_ARG_CHECK(expr, msg)
Definition assert.h:33
std::optional< PtrT > try_resolve_symbol(const std::string &symbol) const
Definition dyn_load.h:47
PtrT resolve(const std::string &symbol) const
Definition dyn_load.h:69
Wraps a PKCS #11 Interface object.
Definition p11.h:1283
static Utf8Char * p11_interface_name_ptr()
bool C_VerifyMessage(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, const Byte *data_ptr, Ulong data_len, const Byte *signature_ptr, Ulong signature_len, ReturnValue *return_value=ThrowException)
Definition p11.cpp:918
bool C_CancelFunction(SessionHandle session, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1207
static bool C_GetInterface(const Dynamically_Loaded_Library &pkcs11_module, const Utf8Char *interface_name_ptr, const Version *version_ptr, Interface **interface_ptr_ptr, Flags flags, ReturnValue *return_value=ThrowException)
Definition p11.cpp:130
bool C_MessageSignFinal(SessionHandle session, ReturnValue *return_value=ThrowException)
Definition p11.cpp:810
bool C_EncryptMessageBegin(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, const Byte *associated_data_ptr, Ulong associated_data_len, ReturnValue *return_value=ThrowException)
Definition p11.cpp:504
bool C_SignEncryptUpdate(SessionHandle session, const Byte *part_ptr, Ulong part_len, Byte *encrypted_part_ptr, Ulong *encrypted_part_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:993
bool C_GetSessionInfo(SessionHandle session, SessionInfo *info_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:288
bool C_VerifySignatureInit(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle key, const Byte *signature_ptr, Ulong signature_len, ReturnValue *return_value=ThrowException)
Definition p11.cpp:874
bool C_Logout(SessionHandle session, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:341
bool C_MessageEncryptFinal(SessionHandle session, ReturnValue *return_value=ThrowException)
Definition p11.cpp:539
bool C_WrapKey(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle wrapping_key, ObjectHandle key, Byte *wrapped_key_ptr, Ulong *wrapped_key_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1051
bool C_InitPIN(SessionHandle session, const Utf8Char *pin_ptr, Ulong pin_len, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:248
bool C_GetOperationState(SessionHandle session, Byte *operation_state_ptr, Ulong *operation_state_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:296
bool C_DigestKey(SessionHandle session, ObjectHandle key, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:684
bool C_DecryptUpdate(SessionHandle session, const Byte *encrypted_part_ptr, Ulong encrypted_part_len, Byte *part_ptr, Ulong *part_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:565
bool C_MessageDecryptFinal(SessionHandle session, ReturnValue *return_value=ThrowException)
Definition p11.cpp:654
bool C_GetTokenInfo(SlotId slot_id, TokenInfo *info_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:185
bool C_SetAttributeValue(SessionHandle session, ObjectHandle object, Attribute *attribute_template_ptr, Ulong count, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:396
bool C_VerifyMessageNext(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, const Byte *data_ptr, Ulong data_len, const Byte *signature_ptr, Ulong signature_len, ReturnValue *return_value=ThrowException)
Definition p11.cpp:945
bool C_SignRecover(SessionHandle session, const Byte *data_ptr, Ulong data_len, Byte *signature_ptr, Ulong *signature_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:743
bool C_MessageDecryptInit(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle key, ReturnValue *return_value=ThrowException)
Definition p11.cpp:587
bool C_DecryptFinal(SessionHandle session, Byte *last_part_ptr, Ulong *last_part_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:577
bool C_VerifyRecover(SessionHandle session, const Byte *signature_ptr, Ulong signature_len, Byte *data_ptr, Ulong *data_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:863
static bool C_GetFunctionList(const Dynamically_Loaded_Library &pkcs11_module, FunctionList **function_list_ptr_ptr, ReturnValue *return_value=ThrowException)
Definition p11.cpp:107
bool C_EncapsulateKey(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle public_key, Attribute *template_ptr, Ulong attribute_count, Byte *ciphertext_ptr, Ulong *ciphertext_len_ptr, ObjectHandle *key_ptr, ReturnValue *return_value=ThrowException)
Definition p11.cpp:1143
bool C_InitToken(SlotId slot_id, const Utf8Char *so_pin_ptr, Ulong so_pin_len, const Utf8Char *label_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:237
bool C_GetSlotInfo(SlotId slot_id, SlotInfo *info_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:181
bool C_EncryptFinal(SessionHandle session, Byte *last_encrypted_part_ptr, Ulong *last_encrypted_part_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:462
bool C_FindObjectsInit(SessionHandle session, Attribute *attribute_template_ptr, Ulong count, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:406
bool C_VerifyUpdate(SessionHandle session, const Byte *part_ptr, Ulong part_len, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:836
bool C_GetAttributeValue(SessionHandle session, ObjectHandle object, Attribute *attribute_template_ptr, Ulong count, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:386
bool C_DestroyObject(SessionHandle session, ObjectHandle object, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:375
bool C_VerifyMessageBegin(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, ReturnValue *return_value=ThrowException)
Definition p11.cpp:936
bool C_Login(SessionHandle session, UserType user_type, const Utf8Char *pin_ptr, Ulong pin_len, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:317
bool C_CopyObject(SessionHandle session, ObjectHandle object, Attribute *attribute_template_ptr, Ulong count, ObjectHandle *new_object_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:364
bool C_EncryptMessage(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, const Byte *associated_data_ptr, Ulong associated_data_len, const Byte *plaintext_ptr, Ulong plaintext_len, Byte *ciphertext_ptr, Ulong *ciphertext_len_ptr, ReturnValue *return_value=ThrowException)
Definition p11.cpp:482
bool C_GenerateRandom(SessionHandle session, Byte *random_data_ptr, Ulong random_len, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1193
LowLevel(FunctionList *ptr)
Definition p11.cpp:81
bool C_VerifySignature(SessionHandle session, const Byte *data_ptr, Ulong data_len, ReturnValue *return_value=ThrowException)
Definition p11.cpp:886
bool C_EncryptMessageNext(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, const Byte *plaintext_part_ptr, Ulong plaintext_part_len, Byte *ciphertext_ptr, Ulong *ciphertext_part_len_ptr, Flags flags, ReturnValue *return_value=ThrowException)
Definition p11.cpp:519
bool C_Sign(SessionHandle session, const Byte *data_ptr, Ulong data_len, Byte *signature_ptr, Ulong *signature_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:706
bool C_DecryptMessage(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, const Byte *associated_data_ptr, Ulong associated_data_len, const Byte *ciphertext_ptr, Ulong ciphertext_len, Byte *plaintext_ptr, Ulong *plaintext_len_ptr, ReturnValue *return_value=ThrowException)
Definition p11.cpp:596
bool C_GetFunctionStatus(SessionHandle session, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1203
bool C_AsyncGetID(SessionHandle session, const Utf8Char *function_name_ptr, Ulong *id_ptr, ReturnValue *return_value=ThrowException)
Definition p11.cpp:1222
bool C_CloseSession(SessionHandle session, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:280
const InterfaceWrapper & get_interface()
Definition p11.h:4024
bool C_Initialize(const void *init_args, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:95
bool C_Encrypt(SessionHandle session, const Byte *data_ptr, Ulong data_len, Byte *encrypted_data, Ulong *encrypted_data_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:438
static bool C_GetInterfaceList(const Dynamically_Loaded_Library &pkcs11_module, Interface *interface_list_ptr, Ulong *count_ptr, ReturnValue *return_value=ThrowException)
Definition p11.cpp:117
bool C_LoginUser(SessionHandle session, UserType user_type, const Utf8Char *pin_ptr, Ulong pin_len, const Utf8Char *username_ptr, Ulong username_len, ReturnValue *return_value=ThrowException)
Definition p11.cpp:325
bool C_SignUpdate(SessionHandle session, const Byte *part_ptr, Ulong part_len, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:718
bool C_DecapsulateKey(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle private_key, Attribute *template_ptr, Ulong attribute_count, const Byte *ciphertext_ptr, Ulong ciphertext_len, ObjectHandle *key_ptr, ReturnValue *return_value=ThrowException)
Definition p11.cpp:1163
bool C_GetInfo(Info *info_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:103
bool C_GetMechanismList(SlotId slot_id, MechanismType *mechanism_list_ptr, Ulong *count_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:194
bool C_WaitForSlotEvent(Flags flags, SlotId *slot_ptr, void *reserved, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:189
bool C_MessageVerifyInit(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle key, ReturnValue *return_value=ThrowException)
Definition p11.cpp:909
bool C_GetSessionValidationFlags(SessionHandle session, Ulong type, Flags *flags_ptr, ReturnValue *return_value=ThrowException)
Definition p11.cpp:345
bool C_OpenSession(SlotId slot_id, Flags flags, void *application, Notify notify, SessionHandle *session_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:270
bool C_FindObjectsFinal(SessionHandle session, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:424
static bool handle_return_value(CK_RV function_result, ReturnValue *return_value)
Definition p11.cpp:28
bool C_Decrypt(SessionHandle session, const Byte *encrypted_data_ptr, Ulong encrypted_data_len, Byte *data_ptr, Ulong *data_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:553
bool C_DigestInit(SessionHandle session, const Mechanism *mechanism_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:660
bool C_VerifySignatureFinal(SessionHandle session, ReturnValue *return_value=ThrowException)
Definition p11.cpp:903
bool C_AsyncComplete(SessionHandle session, const Utf8Char *function_name_ptr, AsyncData *result_ptr, ReturnValue *return_value=ThrowException)
Definition p11.cpp:1213
bool C_DecryptInit(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle key, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:545
bool C_MessageSignInit(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle key, ReturnValue *return_value=ThrowException)
Definition p11.cpp:756
bool C_SessionCancel(SessionHandle session, Flags flags, ReturnValue *return_value=ThrowException)
Definition p11.cpp:292
bool C_CloseAllSessions(SlotId slot_id, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:284
bool C_AsyncJoin(SessionHandle session, const Utf8Char *function_name_ptr, Ulong id, Byte *data_ptr, Ulong data_len, ReturnValue *return_value=ThrowException)
Definition p11.cpp:1231
bool C_SeedRandom(SessionHandle session, const Byte *seed_ptr, Ulong seed_len, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1185
bool C_CreateObject(SessionHandle session, Attribute *attribute_template_ptr, Ulong count, ObjectHandle *object_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:355
bool C_Finalize(void *reserved, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:99
bool C_SignMessageNext(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, const Byte *data_ptr, Ulong data_len, Byte *signature_ptr, Ulong *signature_len_ptr, ReturnValue *return_value=ThrowException)
Definition p11.cpp:792
bool C_FindObjects(SessionHandle session, ObjectHandle *object_ptr, Ulong max_object_count, Ulong *object_count_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:414
bool C_GenerateKeyPair(SessionHandle session, const Mechanism *mechanism_ptr, Attribute *public_key_template_ptr, Ulong public_key_attribute_count, Attribute *private_key_template_ptr, Ulong private_key_attribute_count, ObjectHandle *public_key_ptr, ObjectHandle *private_key_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1031
bool C_UnwrapKeyAuthenticated(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle unwrapping_key, const Byte *wrapped_key_ptr, Ulong wrapped_key_len, Attribute *attribute_template_ptr, Ulong attribute_count, const Byte *associated_data_ptr, Ulong associated_data_len, ObjectHandle *key_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1118
bool C_VerifyInit(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle key, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:816
bool C_GetSlotList(Bbool token_present, SlotId *slot_list_ptr, Ulong *count_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:151
bool C_GetMechanismInfo(SlotId slot_id, MechanismType type, MechanismInfo *info_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:228
bool C_DigestEncryptUpdate(SessionHandle session, const Byte *part_ptr, Ulong part_len, Byte *encrypted_part_ptr, Ulong *encrypted_part_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:969
bool C_DecryptMessageNext(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, const Byte *ciphertext_part_ptr, Ulong ciphertext_part_len, Byte *plaintext_ptr, Ulong *plaintext_part_len_ptr, Flags flags, ReturnValue *return_value=ThrowException)
Definition p11.cpp:633
bool C_SignMessage(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, const Byte *data_ptr, Ulong data_len, Byte *signature_ptr, Ulong *signature_len_ptr, ReturnValue *return_value=ThrowException)
Definition p11.cpp:765
bool C_SetPIN(SessionHandle session, const Utf8Char *old_pin_ptr, Ulong old_len, const Utf8Char *new_pin_ptr, Ulong new_len, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:256
bool C_VerifyFinal(SessionHandle session, const Byte *signature_ptr, Ulong signature_len, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:845
bool C_Digest(SessionHandle session, const Byte *data_ptr, Ulong data_len, Byte *digest_ptr, Ulong *digest_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:665
bool C_MessageVerifyFinal(SessionHandle session, ReturnValue *return_value=ThrowException)
Definition p11.cpp:963
FunctionList * get_functions() const
Definition p11.cpp:1242
bool C_UnwrapKey(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle unwrapping_key, const Byte *wrapped_key_ptr, Ulong wrapped_key_len, Attribute *attribute_template_ptr, Ulong attribute_count, ObjectHandle *key_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1064
bool C_VerifySignatureUpdate(SessionHandle session, const Byte *part_ptr, Ulong part_len, ReturnValue *return_value=ThrowException)
Definition p11.cpp:894
bool C_EncryptInit(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle key, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:430
bool C_WrapKeyAuthenticated(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle wrapping_key, ObjectHandle key, const Byte *associated_data_ptr, Ulong associated_data_len, Byte *wrapped_key_ptr, Ulong *wrapped_key_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1097
bool C_SignFinal(SessionHandle session, Byte *signature_ptr, Ulong *signature_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:726
bool C_SignMessageBegin(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, ReturnValue *return_value=ThrowException)
Definition p11.cpp:783
bool C_MessageEncryptInit(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle key, ReturnValue *return_value=ThrowException)
Definition p11.cpp:473
bool C_VerifyRecoverInit(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle key, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:854
bool C_DigestUpdate(SessionHandle session, const Byte *part_ptr, Ulong part_len, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:676
bool C_SignInit(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle key, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:698
bool C_DigestFinal(SessionHandle session, Byte *digest_ptr, Ulong *digest_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:688
bool C_Verify(SessionHandle session, const Byte *data_ptr, Ulong data_len, const Byte *signature_ptr, Ulong signature_len, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:824
bool C_GetObjectSize(SessionHandle session, ObjectHandle object, Ulong *size_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:379
bool C_SetOperationState(SessionHandle session, const Byte *operation_state_ptr, Ulong operation_state_len, ObjectHandle encryption_key, ObjectHandle authentication_key, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:305
bool C_GenerateKey(SessionHandle session, const Mechanism *mechanism_ptr, Attribute *attribute_template_ptr, Ulong count, ObjectHandle *key_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1019
bool C_EncryptUpdate(SessionHandle session, const Byte *part_ptr, Ulong part_len, Byte *encrypted_part_ptr, Ulong *encrypted_part_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:450
bool C_DecryptMessageBegin(SessionHandle session, const void *parameter_ptr, Ulong parameter_len, const Byte *associated_data_ptr, Ulong associated_data_len, ReturnValue *return_value=ThrowException)
Definition p11.cpp:618
bool C_DecryptDigestUpdate(SessionHandle session, const Byte *encrypted_part_ptr, Ulong encrypted_part_len, Byte *part_ptr, Ulong *part_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:981
bool C_SignRecoverInit(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle key, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:734
bool C_DecryptVerifyUpdate(SessionHandle session, const Byte *encrypted_part_ptr, Ulong encrypted_part_len, Byte *part_ptr, Ulong *part_len_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1005
bool C_DeriveKey(SessionHandle session, const Mechanism *mechanism_ptr, ObjectHandle base_key, Attribute *attribute_template_ptr, Ulong attribute_count, ObjectHandle *key_ptr, ReturnValue *return_value=ThrowException) const
Definition p11.cpp:1084
Represents a PKCS#11 session.
Definition p11_types.h:139
void set_pin(const secure_string &old_pin, const secure_string &new_pin)
Calls C_SetPIN to change the PIN using the old PIN (requires a logged in session).
void init_pin(const secure_string &new_pin)
Calls C_InitPIN to change or initialize the PIN using the SO_PIN (requires a logged in session).
void login(UserType userType, const secure_string &pin)
Represents a PKCS#11 Slot, i.e., a card reader.
Definition p11_types.h:92
void initialize(std::string_view label, const secure_string &so_pin) const
Definition p11_slot.cpp:45
CK_SLOT_ID SlotId
Definition p11.h:1203
ReturnValue * ThrowException
Definition p11.cpp:22
secure_vector< uint8_t > secure_string
Definition p11.h:46
CK_FUNCTION_LIST FunctionList
Definition p11.h:1188
CK_MECHANISM Mechanism
Definition p11.h:1207
CK_NOTIFY Notify
Definition p11.h:1210
void change_pin(Slot &slot, const secure_string &old_pin, const secure_string &new_pin)
Definition p11.cpp:63
CK_OBJECT_HANDLE ObjectHandle
Definition p11.h:1214
void change_so_pin(Slot &slot, const secure_string &old_so_pin, const secure_string &new_so_pin)
Definition p11.cpp:69
CK_ATTRIBUTE Attribute
Definition p11.h:1213
CK_VERSION Version
Definition p11.h:1201
CK_BYTE Byte
Definition p11.h:1215
CK_INFO Info
Definition p11.h:1200
CK_SLOT_INFO SlotInfo
Definition p11.h:1205
CK_INTERFACE Interface
Definition p11.h:1192
CK_FLAGS Flags
Definition p11.h:1199
CK_SESSION_INFO SessionInfo
Definition p11.h:1212
CK_TOKEN_INFO TokenInfo
Definition p11.h:1206
CK_ASYNC_DATA AsyncData
Definition p11.h:1220
CK_UTF8CHAR Utf8Char
Definition p11.h:1209
CK_ULONG Ulong
Definition p11.h:1204
CK_BBOOL Bbool
Definition p11.h:1202
void set_pin(Slot &slot, const secure_string &so_pin, const secure_string &pin)
Definition p11.cpp:75
CK_MECHANISM_INFO MechanismInfo
Definition p11.h:1208
Flags flags(Flag flags)
Definition p11.h:1235
void initialize_token(Slot &slot, std::string_view label, const secure_string &so_pin, const secure_string &pin)
Definition p11.cpp:58
CK_SESSION_HANDLE SessionHandle
Definition p11.h:1211
#define CKR_GENERAL_ERROR
Definition pkcs11.h:1092
CK_MECHANISM_TYPE * CK_MECHANISM_TYPE_PTR
Definition pkcs11.h:59
CK_ULONG CK_RV
Definition pkcs11.h:73
CK_ULONG CK_USER_TYPE
Definition pkcs11.h:81
CK_ULONG CK_MECHANISM_TYPE
Definition pkcs11.h:59