This library provides a simple and nice C++ wrapper around these libraries, so that programmers can concentrate on functionality. It offers general support for PCSC-lite, OpenSSL, PKCS#11, plus specific functionality for the SuisseID.
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
413 lines
17 KiB
413 lines
17 KiB
/*! @file |
|
|
|
@id $Id$ |
|
*/ |
|
// 1 2 3 4 5 6 7 8 |
|
// 45678901234567890123456789012345678901234567890123456789012345678901234567890 |
|
|
|
#include <cryptoki.hxx> |
|
|
|
#include <sstream> |
|
#include <mrw/checkcxx11.hxx> |
|
#include <memory> |
|
#ifndef WIN32 |
|
#include <dlfcn.h> |
|
#define CK_PTR * |
|
typedef CK_FUNCTION_LIST CK_PTR CK_FUNCTION_LIST_PTR; |
|
typedef CK_FUNCTION_LIST_PTR CK_PTR CK_FUNCTION_LIST_PTR_PTR; |
|
typedef CK_RV (*CK_C_GetFunctionList) |
|
(CK_FUNCTION_LIST_PTR_PTR ppFunctionList); |
|
#else |
|
#include <windows.h> |
|
#undef ERROR |
|
#endif |
|
|
|
namespace cryptoki { |
|
|
|
bool Library::Init::functionList(const std::string& library) { |
|
CRYPTOLOG("try to load: "<<library); |
|
#ifndef WIN32 |
|
_lib = dlopen(library.c_str(), RTLD_NOW); |
|
#else |
|
_lib = LoadLibrary(library.c_str()); |
|
#endif |
|
if (!_lib) throw exception("open of library failed: "+library); |
|
CRYPTOLOG("loaded: "<<library); |
|
#ifndef WIN32 |
|
/// @bug in dlsym: returns void* but should return void(*)() |
|
CK_C_GetFunctionList fnl |
|
(reinterpret_cast<CK_C_GetFunctionList> |
|
(reinterpret_cast<long long> |
|
(dlsym(_lib, "C_GetFunctionList")))); |
|
#else |
|
CK_C_GetFunctionList fnl |
|
((CK_C_GetFunctionList)GetProcAddress(_lib, "C_GetFunctionList")); |
|
#endif |
|
if (!fnl) |
|
throw exception("required library symbol C_GetFunctionList not found in " |
|
+library); |
|
CRYPTOLOG("Got C_GetFunctionList, now call it"); |
|
//! calls @c C_GetFunctionList |
|
return check(fnl(&_fn), CRYPTOKI_FN_LOG("C_GetFunctionList")); |
|
} |
|
|
|
bool Library::Init::check(CK_RV result, const std::string& context) { |
|
_res = result; |
|
if (_exc && !*this) { |
|
if (context.size()) { |
|
if (_res==CKR_PIN_INCORRECT) |
|
throw wrong_pin(context+": "+error()); |
|
else |
|
throw access_error(context+": "+error()); |
|
} else { |
|
if (_res==CKR_PIN_INCORRECT) |
|
throw wrong_pin(error()); |
|
else |
|
throw access_error(error()); |
|
} |
|
} |
|
return _res==CKR_OK; |
|
} |
|
|
|
std::string Library::Init::error(CK_RV res) { |
|
switch (res) { |
|
case CKR_OK: return "CKR_OK"; |
|
case CKR_CANCEL: return "CKR_CANCEL"; |
|
case CKR_HOST_MEMORY: return "CKR_HOST_MEMORY"; |
|
case CKR_SLOT_ID_INVALID: return "CKR_SLOT_ID_INVALID"; |
|
case CKR_GENERAL_ERROR: return "CKR_GENERAL_ERROR"; |
|
case CKR_FUNCTION_FAILED: return "CKR_FUNCTION_FAILED"; |
|
case CKR_ARGUMENTS_BAD: return "CKR_ARGUMENTS_BAD"; |
|
case CKR_NO_EVENT: return "CKR_NO_EVENT"; |
|
case CKR_NEED_TO_CREATE_THREADS: return "CKR_NEED_TO_CREATE_THREADS"; |
|
case CKR_CANT_LOCK: return "CKR_CANT_LOCK"; |
|
case CKR_ATTRIBUTE_READ_ONLY: return "CKR_ATTRIBUTE_READ_ONLY"; |
|
case CKR_ATTRIBUTE_SENSITIVE: return "CKR_ATTRIBUTE_SENSITIVE"; |
|
case CKR_ATTRIBUTE_TYPE_INVALID: return "CKR_ATTRIBUTE_TYPE_INVALID"; |
|
case CKR_ATTRIBUTE_VALUE_INVALID: return "CKR_ATTRIBUTE_VALUE_INVALID"; |
|
case CKR_DATA_INVALID: return "CKR_DATA_INVALID"; |
|
case CKR_DATA_LEN_RANGE: return "CKR_DATA_LEN_RANGE"; |
|
case CKR_DEVICE_ERROR: return "CKR_DEVICE_ERROR"; |
|
case CKR_DEVICE_MEMORY: return "CKR_DEVICE_MEMORY"; |
|
case CKR_DEVICE_REMOVED: return "CKR_DEVICE_REMOVED"; |
|
case CKR_ENCRYPTED_DATA_INVALID: return "CKR_ENCRYPTED_DATA_INVALID"; |
|
case CKR_ENCRYPTED_DATA_LEN_RANGE: return "CKR_ENCRYPTED_DATA_LEN_RANGE"; |
|
case CKR_FUNCTION_CANCELED: return "CKR_FUNCTION_CANCELED"; |
|
case CKR_FUNCTION_NOT_PARALLEL: return "CKR_FUNCTION_NOT_PARALLEL"; |
|
case CKR_FUNCTION_NOT_SUPPORTED: return "CKR_FUNCTION_NOT_SUPPORTED"; |
|
case CKR_KEY_HANDLE_INVALID: return "CKR_KEY_HANDLE_INVALID"; |
|
case CKR_KEY_SIZE_RANGE: return "CKR_KEY_SIZE_RANGE"; |
|
case CKR_KEY_TYPE_INCONSISTENT: return "CKR_KEY_TYPE_INCONSISTENT"; |
|
case CKR_KEY_NOT_NEEDED: return "CKR_KEY_NOT_NEEDED"; |
|
case CKR_KEY_CHANGED: return "CKR_KEY_CHANGED"; |
|
case CKR_KEY_NEEDED: return "CKR_KEY_NEEDED"; |
|
case CKR_KEY_INDIGESTIBLE: return "CKR_KEY_INDIGESTIBLE"; |
|
case CKR_KEY_FUNCTION_NOT_PERMITTED: |
|
return "CKR_KEY_FUNCTION_NOT_PERMITTED"; |
|
case CKR_KEY_NOT_WRAPPABLE: return "CKR_KEY_NOT_WRAPPABLE"; |
|
case CKR_KEY_UNEXTRACTABLE: return "CKR_KEY_UNEXTRACTABLE"; |
|
case CKR_MECHANISM_INVALID: return "CKR_MECHANISM_INVALID"; |
|
case CKR_MECHANISM_PARAM_INVALID: return "CKR_MECHANISM_PARAM_INVALID"; |
|
case CKR_OBJECT_HANDLE_INVALID: return "CKR_OBJECT_HANDLE_INVALID"; |
|
case CKR_OPERATION_ACTIVE: return "CKR_OPERATION_ACTIVE"; |
|
case CKR_OPERATION_NOT_INITIALIZED: |
|
return "CKR_OPERATION_NOT_INITIALIZED"; |
|
case CKR_PIN_INCORRECT: return "CKR_PIN_INCORRECT"; |
|
case CKR_PIN_INVALID: return "CKR_PIN_INVALID"; |
|
case CKR_PIN_LEN_RANGE: return "CKR_PIN_LEN_RANGE"; |
|
case CKR_PIN_EXPIRED: return "CKR_PIN_EXPIRED"; |
|
case CKR_PIN_LOCKED: return "CKR_PIN_LOCKED"; |
|
case CKR_SESSION_CLOSED: return "CKR_SESSION_CLOSED"; |
|
case CKR_SESSION_COUNT: return "CKR_SESSION_COUNT"; |
|
case CKR_SESSION_HANDLE_INVALID: return "CKR_SESSION_HANDLE_INVALID"; |
|
case CKR_SESSION_PARALLEL_NOT_SUPPORTED: |
|
return "CKR_SESSION_PARALLEL_NOT_SUPPORTED"; |
|
case CKR_SESSION_READ_ONLY: return "CKR_SESSION_READ_ONLY"; |
|
case CKR_SESSION_EXISTS: return "CKR_SESSION_EXISTS"; |
|
case CKR_SESSION_READ_ONLY_EXISTS: return "CKR_SESSION_READ_ONLY_EXISTS"; |
|
case CKR_SESSION_READ_WRITE_SO_EXISTS: |
|
return "CKR_SESSION_READ_WRITE_SO_EXISTS"; |
|
case CKR_SIGNATURE_INVALID: return "CKR_SIGNATURE_INVALID"; |
|
case CKR_SIGNATURE_LEN_RANGE: return "CKR_SIGNATURE_LEN_RANGE"; |
|
case CKR_TEMPLATE_INCOMPLETE: return "CKR_TEMPLATE_INCOMPLETE"; |
|
case CKR_TEMPLATE_INCONSISTENT: return "CKR_TEMPLATE_INCONSISTENT"; |
|
case CKR_TOKEN_NOT_PRESENT: return "CKR_TOKEN_NOT_PRESENT"; |
|
case CKR_TOKEN_NOT_RECOGNIZED: return "CKR_TOKEN_NOT_RECOGNIZED"; |
|
case CKR_TOKEN_WRITE_PROTECTED: return "CKR_TOKEN_WRITE_PROTECTED"; |
|
case CKR_UNWRAPPING_KEY_HANDLE_INVALID: |
|
return "CKR_UNWRAPPING_KEY_HANDLE_INVALID"; |
|
case CKR_UNWRAPPING_KEY_SIZE_RANGE: |
|
return "CKR_UNWRAPPING_KEY_SIZE_RANGE"; |
|
case CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT: |
|
return "CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT"; |
|
case CKR_USER_ALREADY_LOGGED_IN: return "CKR_USER_ALREADY_LOGGED_IN"; |
|
case CKR_USER_NOT_LOGGED_IN: return "CKR_USER_NOT_LOGGED_IN"; |
|
case CKR_USER_PIN_NOT_INITIALIZED: return "CKR_USER_PIN_NOT_INITIALIZED"; |
|
case CKR_USER_TYPE_INVALID: return "CKR_USER_TYPE_INVALID"; |
|
case CKR_USER_ANOTHER_ALREADY_LOGGED_IN: |
|
return "CKR_USER_ANOTHER_ALREADY_LOGGED_IN"; |
|
case CKR_USER_TOO_MANY_TYPES: return "CKR_USER_TOO_MANY_TYPES"; |
|
case CKR_WRAPPED_KEY_INVALID: return "CKR_WRAPPED_KEY_INVALID"; |
|
case CKR_WRAPPED_KEY_LEN_RANGE: return "CKR_WRAPPED_KEY_LEN_RANGE"; |
|
case CKR_WRAPPING_KEY_HANDLE_INVALID: |
|
return "CKR_WRAPPING_KEY_HANDLE_INVALID"; |
|
case CKR_WRAPPING_KEY_SIZE_RANGE: return "CKR_WRAPPING_KEY_SIZE_RANGE"; |
|
case CKR_WRAPPING_KEY_TYPE_INCONSISTENT: |
|
return "CKR_WRAPPING_KEY_TYPE_INCONSISTENT"; |
|
case CKR_RANDOM_SEED_NOT_SUPPORTED: |
|
return "CKR_RANDOM_SEED_NOT_SUPPORTED"; |
|
case CKR_RANDOM_NO_RNG: return "CKR_RANDOM_NO_RNG"; |
|
case CKR_DOMAIN_PARAMS_INVALID: return "CKR_DOMAIN_PARAMS_INVALID"; |
|
case CKR_BUFFER_TOO_SMALL: return "CKR_BUFFER_TOO_SMALL"; |
|
case CKR_SAVED_STATE_INVALID: return "CKR_SAVED_STATE_INVALID"; |
|
case CKR_INFORMATION_SENSITIVE: return "CKR_INFORMATION_SENSITIVE"; |
|
case CKR_STATE_UNSAVEABLE: return "CKR_STATE_UNSAVEABLE"; |
|
case CKR_CRYPTOKI_NOT_INITIALIZED: return "CKR_CRYPTOKI_NOT_INITIALIZED"; |
|
case CKR_CRYPTOKI_ALREADY_INITIALIZED: |
|
return "CKR_CRYPTOKI_ALREADY_INITIALIZED"; |
|
case CKR_MUTEX_BAD: return "CKR_MUTEX_BAD"; |
|
case CKR_MUTEX_NOT_LOCKED: return "CKR_MUTEX_NOT_LOCKED"; |
|
case CKR_VENDOR_DEFINED: return "CKR_VENDOR_DEFINED"; |
|
default: { |
|
std::stringstream ss; |
|
ss<<"unknown error code ("<<res<<')'; |
|
return ss.str(); |
|
} |
|
} |
|
} |
|
|
|
Library::Init::Init(const std::string& library, bool exc) try: |
|
_exc(exc), _res(CKR_OK), _fn(0) { |
|
CRYPTOLOG("library: "<<library); |
|
//! calls @c functionList |
|
if (!functionList(library)) return; |
|
CRYPTOLOG("now initialize "<<library); |
|
assert(_fn); |
|
//! calls @c C_Initialize |
|
check(_fn->C_Initialize(0), //! @todo add optional argument |
|
CRYPTOKI_FN_LOG("C_Initialize")); |
|
} catch (...) { |
|
throw access_error(CRYPTOKI_FN_LOG("C_Initialize") |
|
+": Error in initialization of library "+library); |
|
} |
|
|
|
Library::Init::~Init() { |
|
CRYPTOLOG("log"); |
|
/// ignore failure in disconnect, possibly smartcard has |
|
/// been removed |
|
try { |
|
//! calls @c C_Finalize |
|
check(_fn->C_Finalize(0), CRYPTOKI_FN_LOG("C_Finalize")); |
|
#ifndef WIN32 |
|
if (_lib) dlclose(_lib); |
|
_lib = 0; |
|
#else |
|
FreeLibrary(_lib); |
|
_lib = 0; |
|
#endif |
|
_fn = 0; |
|
} catch (std::exception& e) { |
|
CRYPTOLOG("unloading cryptoki library failed, reason: "<<e.what()); |
|
} catch (...) { |
|
CRYPTOLOG("unloading cryptoki library failed"); |
|
} |
|
} |
|
|
|
Library::Init::operator bool() { |
|
return _res==CKR_OK; |
|
} |
|
|
|
std::string Library::Init::error() { |
|
return error(_res); |
|
} |
|
|
|
/*! @todo Not implemented: |
|
@code |
|
bool Library::Init::getinfo() { |
|
//! calls @c C_GetInfo |
|
return check(_init._fn->C_GetInfo(CK_INFO_PTR), |
|
CRYPTOKI_FN_LOG("C_GetInfo")); |
|
} |
|
@endcode */ |
|
|
|
SlotList Library::slotList(bool tokenPresent, std::string name) { |
|
CRYPTOLOG("log"); |
|
CRYPTOLOG("looking for card name: \"" |
|
<<name<<(tokenPresent?"\" with token":"")); |
|
SlotList res; |
|
CK_ULONG count(0); |
|
//! calls @c C_GetSlotList |
|
_init->check(_init->_fn->C_GetSlotList(tokenPresent?TRUE:FALSE, 0, &count), |
|
CRYPTOKI_FN_LOG("C_GetSlotList")); |
|
CRYPTOLOG("found "<<count<<" readers, result: "<<(*this?"success":"error")); |
|
if (!count || !*this) return res; |
|
CK_SLOT_ID* slots = 0; |
|
try { |
|
CK_RV r(0); |
|
do { |
|
delete[] slots; |
|
slots = new CK_SLOT_ID[count]; |
|
r = _init->_fn->C_GetSlotList(tokenPresent?TRUE:FALSE, slots, &count); |
|
} while (r==CKR_BUFFER_TOO_SMALL); |
|
_init->check(r, CRYPTOKI_FN_LOG("C_GetSlotList")); |
|
if (!*this) return res; |
|
for (CK_ULONG i(0); i<count; ++i) { |
|
Slot s(*this, slots[i]); |
|
CRYPTOLOG("found slot \""<<s.slotinfo().slotDescription<<"\""); |
|
if (!name.size() || name==s.slotinfo().slotDescription) { |
|
CRYPTOLOG("-> slot matches"); |
|
res.push_back(s); |
|
} |
|
} |
|
} catch (...) { |
|
delete[] slots; |
|
throw; |
|
} |
|
delete[] slots; |
|
return res; |
|
} |
|
|
|
//============================================================================ |
|
|
|
ObjectList Session::find(const AttributeList& attrs) { |
|
CRYPTOLOG("log"); |
|
ObjectList res; |
|
CK_ATTRIBUTE* a(0); |
|
try { |
|
if (attrs.size()) { |
|
a = new CK_ATTRIBUTE[attrs.size()]; |
|
for (AttributeList::size_type i(0); i<attrs.size(); ++i) |
|
a[i] = attrs[i]; |
|
} |
|
//! calls @c C_FindObjectsInit |
|
if (check(_slot._library->C_FindObjectsInit |
|
(_session, a, attrs.size()), |
|
CRYPTOKI_FN_LOG("C_FindObjectsInit"))) { |
|
CK_OBJECT_HANDLE obj; |
|
//! calls @c C_FindObjects |
|
for (CK_ULONG objs(0); |
|
check(_slot._library->C_FindObjects |
|
(_session, &obj, 1, &objs), |
|
CRYPTOKI_FN_LOG("C_FindObjects")) && objs; |
|
res.push_back(Object(*this, obj))); |
|
} |
|
//! calls @c C_FindObjectsFinal |
|
check(_slot._library->C_FindObjectsFinal(_session), |
|
CRYPTOKI_FN_LOG("C_FindObjectsFinal")); |
|
delete[] a; |
|
return res; |
|
} catch (...) { |
|
delete[] a; |
|
throw; |
|
} |
|
} |
|
|
|
//---------------------------------------------------------------------------- |
|
ObjectList Session::find(const Attribute& a) { |
|
CRYPTOLOG("log"); |
|
AttributeList al; |
|
al.push_back(a); |
|
return find(al); |
|
} |
|
|
|
//---------------------------------------------------------------------------- |
|
ObjectList Session::find(const Attribute& a1, const Attribute& a2) { |
|
CRYPTOLOG("log"); |
|
AttributeList al; |
|
al.push_back(a1); |
|
al.push_back(a2); |
|
return find(al); |
|
} |
|
|
|
//---------------------------------------------------------------------------- |
|
Object Session::create(const std::string& label, const openssl::X509& cert) { |
|
CRYPTOLOG("log"); |
|
AttributeList attrs; |
|
attrs.push_back(Attribute(CKA_CLASS) |
|
.from<CK_OBJECT_CLASS>(CKO_CERTIFICATE)); |
|
attrs.push_back(Attribute(CKA_TOKEN).from<CK_BBOOL>(TRUE)); |
|
attrs.push_back(Attribute(CKA_PRIVATE).from<CK_BBOOL>(FALSE)); |
|
attrs.push_back(Attribute(CKA_MODIFIABLE).from<CK_BBOOL>(TRUE)); |
|
attrs.push_back(Attribute(CKA_LABEL, label)); |
|
attrs.push_back(Attribute(CKA_CERTIFICATE_TYPE) |
|
.from<CK_CERTIFICATE_TYPE>(CKC_X_509)); |
|
attrs.push_back(Attribute(CKA_SUBJECT, cert.subjectDER())); |
|
attrs.push_back(Attribute(CKA_ID, cert.id())); |
|
//attrs.push_back(Attribute(CKA_ISSUER, cert.issuerDER())); |
|
// attrs.push_back(Attribute(CKA_SERIAL_NUMBER, cert.serialDER())); |
|
attrs.push_back(Attribute(CKA_VALUE, cert.valueDER())); |
|
CRYPTOLOG("create: serial = "<<crypto::hex(cert.serial())); |
|
return create(attrs); |
|
} |
|
|
|
Object Session::create(const std::string& label, |
|
const openssl::PrivateKey& key, |
|
const openssl::X509& cert) { |
|
CRYPTOLOG("log"); |
|
int usage(cert.keyUsageFlags()); |
|
AttributeList attrs; |
|
attrs.push_back(Attribute(CKA_CLASS) |
|
.from<CK_OBJECT_CLASS>(CKO_PRIVATE_KEY)); |
|
attrs.push_back(Attribute(CKA_TOKEN).from<CK_BBOOL>(TRUE)); |
|
attrs.push_back(Attribute(CKA_PRIVATE).from<CK_BBOOL>(TRUE)); |
|
attrs.push_back(Attribute(CKA_MODIFIABLE).from<CK_BBOOL>(TRUE)); |
|
attrs.push_back(Attribute(CKA_LABEL, label)); |
|
attrs.push_back(Attribute(CKA_KEY_TYPE).from<CK_KEY_TYPE>(CKK_RSA)); |
|
attrs.push_back(Attribute(CKA_ID, cert.id())); |
|
attrs.push_back(Attribute(CKA_DERIVE).from<CK_BBOOL>(FALSE)); |
|
attrs.push_back(Attribute(CKA_SUBJECT, cert.subjectDER())); |
|
attrs.push_back(Attribute(CKA_SENSITIVE).from<CK_BBOOL>(TRUE)); |
|
attrs.push_back(Attribute(CKA_SECONDARY_AUTH).from<CK_BBOOL>(FALSE)); |
|
attrs.push_back(Attribute(CKA_DECRYPT) // Required by Doujak/Inverardi |
|
.from<CK_BBOOL>(usage&(X509v3_KU_DATA_ENCIPHERMENT |
|
|(usage&X509v3_KU_KEY_ENCIPHERMENT)) |
|
?TRUE:FALSE)); // instead of CKA_UNWRAP |
|
attrs.push_back(Attribute(CKA_SIGN) |
|
.from<CK_BBOOL>(usage&(X509v3_KU_DIGITAL_SIGNATURE |
|
|X509v3_KU_NON_REPUDIATION) |
|
?TRUE:FALSE)); |
|
attrs.push_back(Attribute(CKA_SIGN_RECOVER) // same as CKA_SIGN |
|
.from<CK_BBOOL>(usage&(X509v3_KU_DIGITAL_SIGNATURE |
|
|X509v3_KU_NON_REPUDIATION) |
|
?TRUE:FALSE)); |
|
attrs.push_back(Attribute(CKA_EXTRACTABLE).from<CK_BBOOL>(FALSE)); |
|
attrs.push_back(Attribute(CKA_MODULUS, key.modulus())); |
|
attrs.push_back(Attribute(CKA_PUBLIC_EXPONENT, key.publicExponent())); |
|
attrs.push_back(Attribute(CKA_PRIVATE_EXPONENT, key.privateExponent())); |
|
attrs.push_back(Attribute(CKA_PRIME_1, key.prime1())); |
|
attrs.push_back(Attribute(CKA_PRIME_2, key.prime2())); |
|
attrs.push_back(Attribute(CKA_EXPONENT_1, key.exponent1())); |
|
attrs.push_back(Attribute(CKA_EXPONENT_2, key.exponent2())); |
|
attrs.push_back(Attribute(CKA_COEFFICIENT, key.coefficient())); |
|
return create(attrs); |
|
} |
|
|
|
//---------------------------------------------------------------------------- |
|
Object Session::create(const AttributeList& attrs) { |
|
CRYPTOLOG("log"); |
|
CK_ATTRIBUTE* a(0); |
|
try { |
|
if (attrs.size()) { |
|
a = new CK_ATTRIBUTE[attrs.size()]; |
|
for (AttributeList::size_type i(0); i<attrs.size(); ++i) |
|
a[i] = attrs[i]; |
|
} |
|
for (AttributeList::size_type i(0); i<attrs.size(); ++i) { |
|
std::string value((char*)a[i].pValue, a[i].ulValueLen); |
|
Attribute xxx(a[i].type, value); |
|
CRYPTOLOG("Attribute: "<<xxx.name()<<" = "<<xxx.readableValue()); |
|
}; |
|
CK_OBJECT_HANDLE object; |
|
//! calls @c C_CreateObject |
|
check(_slot._library->C_CreateObject |
|
(_session, a, attrs.size(), &object), |
|
CRYPTOKI_FN_LOG("C_CreateObject")); |
|
delete[] a; |
|
return Object(*this, object); |
|
} catch (...) { |
|
delete[] a; |
|
throw; |
|
} |
|
} |
|
|
|
}
|
|
|