diff options
Diffstat (limited to 'SoftHSMv2/src/bin/dump')
| -rw-r--r-- | SoftHSMv2/src/bin/dump/Makefile.am | 24 | ||||
| -rw-r--r-- | SoftHSMv2/src/bin/dump/common.h | 506 | ||||
| -rw-r--r-- | SoftHSMv2/src/bin/dump/softhsm2-dump-db.1 | 18 | ||||
| -rw-r--r-- | SoftHSMv2/src/bin/dump/softhsm2-dump-db.cpp | 968 | ||||
| -rw-r--r-- | SoftHSMv2/src/bin/dump/softhsm2-dump-file.1 | 18 | ||||
| -rw-r--r-- | SoftHSMv2/src/bin/dump/softhsm2-dump-file.cpp | 537 | ||||
| -rw-r--r-- | SoftHSMv2/src/bin/dump/tables.h | 554 |
7 files changed, 2625 insertions, 0 deletions
diff --git a/SoftHSMv2/src/bin/dump/Makefile.am b/SoftHSMv2/src/bin/dump/Makefile.am new file mode 100644 index 0000000..c70d6f6 --- /dev/null +++ b/SoftHSMv2/src/bin/dump/Makefile.am @@ -0,0 +1,24 @@ +MAINTAINERCLEANFILES = $(srcdir)/Makefile.in + +AM_CPPFLAGS = -I$(srcdir)/../../lib \ + -I$(srcdir)/../../lib/object_store \ + -I$(srcdir)/../../lib/pkcs11 \ + @SQLITE3_INCLUDES@ + +dist_man_MANS = softhsm2-dump-file.1 + +bin_PROGRAMS = softhsm2-dump-file + +if BUILD_OBJECTSTORE_BACKEND_DB +dist_man_MANS += softhsm2-dump-db.1 +bin_PROGRAMS += softhsm2-dump-db +endif + +softhsm2_dump_file_SOURCES = softhsm2-dump-file.cpp + +softhsm2_dump_db_SOURCES = softhsm2-dump-db.cpp + +softhsm2_dump_db_LDADD = @SQLITE3_LIBS@ @YIELD_LIB@ + +EXTRA_DIST = $(srcdir)/*.h \ + softhsm2-dump-db.1 diff --git a/SoftHSMv2/src/bin/dump/common.h b/SoftHSMv2/src/bin/dump/common.h new file mode 100644 index 0000000..d38b924 --- /dev/null +++ b/SoftHSMv2/src/bin/dump/common.h @@ -0,0 +1,506 @@ +/* + * Copyright (c) 2013 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + common.h + + Common definitions for SoftHSMv2 dump. + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_COMMON_H +#define _SOFTHSM_V2_COMMON_H + +#include <config.h> + +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <map> +#include <set> +#include <string> +#include <stdexcept> +#include <vector> +#include "tables.h" + +// Table of attribute types +std::map<unsigned long, std::string> CKA_table; + +// Dump an attribute type +void dumpCKA(unsigned long cka, int size) +{ + // Lazy fill + if (CKA_table.empty()) + { + fill_CKA_table(CKA_table); + } + std::string msg; + try + { + msg = CKA_table.at(cka); + printf("%.*s", size, msg.c_str()); + } + catch (const std::out_of_range&) + { + if (cka & CKA_VENDOR_DEFINED) + { + cka &= ~CKA_VENDOR_DEFINED; + printf("CKA_VENDOR_DEFINED | 0x%lx", cka); + } + else + { + printf("unknown 0x%lx", cka); + } + } +} + +// Table of mechanism types +std::map<unsigned long, std::string> CKM_table; + +// Dump a mechanism type +void dumpCKM(unsigned long cka, int size) +{ + // Lazy fill + if (CKM_table.empty()) + { + fill_CKM_table(CKM_table); + } + std::string msg; + try + { + msg = CKM_table.at(cka); + printf("%.*s", size, msg.c_str()); + } + catch (const std::out_of_range&) + { + if (cka & CKM_VENDOR_DEFINED) + { + cka &= ~CKM_VENDOR_DEFINED; + printf("CKM_VENDOR_DEFINED | 0x%lx", cka); + } + else + { + printf("unknown 0x%lx", cka); + } + } +} + +// Table of object classes +std::map<unsigned long, std::string> CKO_table; + +// Dump a object class +void dumpCKO(unsigned long cka, int size) +{ + // Lazy fill + if (CKO_table.empty()) + { + fill_CKO_table(CKO_table); + } + std::string msg; + try + { + msg = CKO_table.at(cka); + printf("%.*s", size, msg.c_str()); + } + catch (const std::out_of_range&) + { + if (cka & CKO_VENDOR_DEFINED) + { + cka &= ~CKO_VENDOR_DEFINED; + printf("CKO_VENDOR_DEFINED | 0x%lx", cka); + } + else + { + printf("unknown 0x%lx", cka); + } + } +} + +// Table of hw feature types +std::map<unsigned long, std::string> CKH_table; + +// Dump a hw feature type +void dumpCKH(unsigned long cka, int size) +{ + // Lazy fill + if (CKH_table.empty()) + { + fill_CKH_table(CKH_table); + } + std::string msg; + try + { + msg = CKH_table.at(cka); + printf("%.*s", size, msg.c_str()); + } + catch (const std::out_of_range&) + { + if (cka & CKH_VENDOR_DEFINED) + { + cka &= ~CKH_VENDOR_DEFINED; + printf("CKH_VENDOR_DEFINED | 0x%lx", cka); + } + else + { + printf("unknown 0x%lx", cka); + } + } +} + +// Table of key types +std::map<unsigned long, std::string> CKK_table; + +// Dump a key type +void dumpCKK(unsigned long cka, int size) +{ + // Lazy fill + if (CKK_table.empty()) + { + fill_CKK_table(CKK_table); + } + std::string msg; + try + { + msg = CKK_table.at(cka); + printf("%.*s", size, msg.c_str()); + } + catch (const std::out_of_range&) + { + if (cka & CKK_VENDOR_DEFINED) + { + cka &= ~CKK_VENDOR_DEFINED; + printf("CKK_VENDOR_DEFINED | 0x%lx", cka); + } + else + { + printf("unknown 0x%lx", cka); + } + } +} + +// Table of certificate types +std::map<unsigned long, std::string> CKC_table; + +// Dump a certificate type +void dumpCKC(unsigned long cka, int size) +{ + // Lazy fill + if (CKC_table.empty()) + { + fill_CKC_table(CKC_table); + } + std::string msg; + try + { + msg = CKC_table.at(cka); + printf("%.*s", size, msg.c_str()); + } + catch (const std::out_of_range&) + { + if (cka & CKC_VENDOR_DEFINED) + { + cka &= ~CKC_VENDOR_DEFINED; + printf("CKC_VENDOR_DEFINED | 0x%lx", cka); + } + else + { + printf("unknown 0x%lx", cka); + } + } +} + +// Dump a PKCS#11 integer type +void dumpCKx(uint64_t cka, uint64_t value, int size) +{ + if ((uint32_t)value == (uint32_t)~0) + { + printf("CK_UNAVAILABLE_INFORMATION"); + return; + } + + switch ((unsigned long) cka) + { + case CKA_CLASS: + if ((uint64_t)((uint32_t)value) != value) + { + printf("overflow object class"); + break; + } + dumpCKO((unsigned long) value, size); + break; + case CKA_CERTIFICATE_TYPE: + if ((uint64_t)((uint32_t)value) != value) + { + printf("overflow certificate type"); + break; + } + dumpCKC((unsigned long) value, size); + break; + case CKA_KEY_TYPE: + if ((uint64_t)((uint32_t)value) != value) + { + printf("overflow key type"); + break; + } + dumpCKK((unsigned long) value, size); + break; + case CKA_KEY_GEN_MECHANISM: + if ((uint64_t)((uint32_t)value) != value) + { + printf("overflow mechanism type"); + break; + } + dumpCKM((unsigned long) value, size); + break; + case CKA_HW_FEATURE_TYPE: + if ((uint64_t)((uint32_t)value) != value) + { + printf("overflow hw feature type"); + break; + } + dumpCKH((unsigned long) value, size); + break; + default: + printf("CK_ULONG %lu(0x%lx)", + (unsigned long) value, + (unsigned long) value); + break; + } +} + +// Dump a boolean (in fact unsigned 8 bit long) value, true is 0xff +void dumpBool(uint8_t value, bool inArray = false) +{ + printf("%02hhx %s", value, inArray ? " " : ""); + switch (value) + { + case 0: + printf("FALSE"); + break; + case 0xff: + printf("TRUE"); + break; + default: + printf("(invalid) TRUE"); + break; + } +} + +// Dump a boolean (in fact unsigned 8 bit long) value, true is 1 +void dumpBool1(uint8_t value, bool inArray = false) +{ + printf("%02hhx %s", value, inArray ? " " : ""); + switch (value) + { + case 0: + printf("FALSE"); + break; + case 1: + printf("TRUE"); + break; + default: + printf("(invalid) TRUE"); + break; + } +} + +// Dump an unsigned 64 bit long value +void dumpULong(uint64_t value, bool inArray = false) +{ + for (int i = 56; i >= 0; i -= 8) + { + uint8_t v; + v = (value >> i) & 0xff; + printf("%02hhx ", v); + } + if (inArray) + { + printf(" "); + } +} + +// Dump an unsigned 32 bit long value +void dumpU32(uint32_t value, bool inArray = false) +{ + for (int i = 24; i >= 0; i -= 8) + { + uint8_t v; + v = (value >> i) & 0xff; + printf("%02hhx ", v); + } + printf(" "); + if (inArray) + { + printf(" "); + } +} + +// Dump a byte string (aka uint8_t vector) value +void dumpBytes(const std::vector<uint8_t>& value, bool inArray = false) +{ + size_t len = value.size(); + size_t i = 0; + while (i + 8 <= len) + { + for (size_t j = 0; j < 8; j++) + { + printf("%02hhx ", value[i + j]); + } + if (inArray) + { + printf(" "); + } + printf("<"); + for (size_t j = 0; j < 8; j++) + { + uint8_t c = value[i + j]; + if (isgraph((int) c) == 0) + { + printf("."); + } + else + { + printf("%c", (int) c); + } + } + printf(">\n"); + i += 8; + } + len -= i; + if (len == 0) + { + return; + } + + for (size_t j = 0; j < len; j++) + { + printf("%02hhx ", value[i + j]); + } + for (size_t j = len; j < 8; j++) + { + printf(" "); + } + if (inArray) + { + printf(" "); + } + printf("<"); + for (size_t j = 0; j < len; j++) + { + uint8_t c = value[i + j]; + if (isgraph((int) c) == 0) + { + printf("."); + } + else + { + printf("%c", (int) c); + } + } + for (size_t j =len; j < 8; j++) + { + printf(" "); + } + printf(">\n"); +} + +// Attribute (in an array) template +template<typename T, typename K, typename I> +class AttributeTK +{ +public: + T type; + K kind; + + uint8_t boolValue; + I ulongValue; + std::vector<uint8_t> bytestrValue; + std::set<I> mechSetValue; + + // Dump an array (in fact an Attribute vector) value + void dumpType() const; + void dumpKind() const; + void dumpBoolValue() const; + void dumpULongValue(I value) const; + bool isBoolean() const; + bool isInteger() const; + bool isBinary() const; + bool isMechSet() const; + void dump() const { + dumpType(); + if ((sizeof(type) > 4) && + ((uint64_t)((uint32_t)type) != type)) + { + printf("overflow attribute type\n"); + } + else + { + dumpCKA((unsigned long) type, 47); + printf("\n"); + } + + dumpKind(); + if (isBoolean()) + { + printf("boolean attribute\n"); + dumpBoolValue(); + printf("\n"); + } + else if (isInteger()) + { + printf("unsigned long attribute\n"); + dumpULongValue(ulongValue); + dumpCKx(type, ulongValue, 47); + printf("\n"); + } + else if (isBinary()) + { + printf("byte string attribute\n"); + I size = bytestrValue.size(); + dumpULongValue(size); + printf("(length %lu)\n", (unsigned long) size); + dumpBytes(bytestrValue, true); + } + else if (isMechSet()) + { + printf("mechanism set attribute\n"); + I size = mechSetValue.size(); + dumpULongValue(size); + printf("(length %lu)\n", (unsigned long) size); + for (typename std::set<I>::const_iterator i = mechSetValue.begin(); i != mechSetValue.end(); ++i) + { + dumpULongValue(*i); + dumpCKM(*i, 47); + printf("\n"); + } + } + else + { + printf("unknown attribute format\n"); + } + } +}; + +#endif // !_SOFTHSM_V2_COMMON_H diff --git a/SoftHSMv2/src/bin/dump/softhsm2-dump-db.1 b/SoftHSMv2/src/bin/dump/softhsm2-dump-db.1 new file mode 100644 index 0000000..00f455b --- /dev/null +++ b/SoftHSMv2/src/bin/dump/softhsm2-dump-db.1 @@ -0,0 +1,18 @@ +.TH SOFTHSM2-DUMP-DB 1 "20 March 2014" "SoftHSM" +.SH NAME +softhsm2-dump-db \- SoftHSM database dump +.SH SYNOPSIS +.PP +.B softhsm2-dump-db +.I path +.SH DESCRIPTION +.B softhsm2-dump +is a tool that can dump SoftHSM v2 database for debugging purposes. +.LP +.SH OPTIONS +.TP +.B \fIpath\fR +The SoftHSM v2 database file that is going to be dumped. +.TP +.B \-\-help\fR, \fB\-h\fR +Show the help information. diff --git a/SoftHSMv2/src/bin/dump/softhsm2-dump-db.cpp b/SoftHSMv2/src/bin/dump/softhsm2-dump-db.cpp new file mode 100644 index 0000000..f55a9db --- /dev/null +++ b/SoftHSMv2/src/bin/dump/softhsm2-dump-db.cpp @@ -0,0 +1,968 @@ +/* + * Copyright (c) 2013 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + softhsm2-dump-db.cpp + + This program can be used for dumping SoftHSM v2 database. + *****************************************************************************/ + +#include <config.h> + +#include <sched.h> +#include <sqlite3.h> +#include <string.h> + +#include "common.h" + +// Attribute types in database arrays +enum AttributeKind +{ + akUnknown, + akBoolean, + akInteger, + akBinary, + akArray +}; + +// Attribute specialization +typedef AttributeTK<CK_ATTRIBUTE_TYPE, AttributeKind, unsigned long> Attribute; + +template<> +bool Attribute::isBoolean() const +{ + return kind == akBoolean; +} + +template<> +bool Attribute::isInteger() const +{ + return kind == akInteger; +} + +template<> +bool Attribute::isBinary() const +{ + return kind == akBinary; +} + +template<> +bool Attribute::isMechSet() const +{ + // Mechanism sets are stored as binary in the database + return false; +} + +template<> +void Attribute::dumpType() const +{ + if (sizeof(type) == 4) + { + dumpU32((uint32_t)type, true); + } + else + { + dumpULong(type, true); + } +} + +template<> +void Attribute::dumpKind() const +{ + dumpU32((uint32_t) kind, true); +} + +template<> +void Attribute::dumpBoolValue() const +{ + dumpBool1(boolValue, true); +} + +template<> +void Attribute::dumpULongValue(unsigned long value) const +{ + if (sizeof(unsigned long) == 4) + { + dumpU32(value, true); + } + else + { + dumpULong(value, true); + } +} + +// dumpArray specialization +typedef std::vector<Attribute> va_type; + +void dumpArray(const va_type& value) +{ + for (va_type::const_iterator attr = value.begin(); attr != value.end(); ++attr) + attr->dump(); +} + +// Get a boolean (in fact unsigned 8 bit long) value +bool getBool(sqlite3* db, long long oid, long long id, uint64_t& type, uint8_t& value) +{ + int rv; + sqlite3_stmt* sql = NULL; + std::string command = "select type,value from attribute_boolean where object_id=? and id=?;"; + + value = 0; + + rv = sqlite3_prepare_v2(db, command.c_str(), -1, &sql, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, + "can't find boolean attribute id=%lld object=%lld: %d(%s)\n", + id, oid, rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + rv = sqlite3_bind_int64(sql, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + sqlite3_bind_int64(sql, 2, id); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the attribute id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + while ((rv = sqlite3_step(sql)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + fprintf(stderr, + "can't read boolean attribute id=%lld object=%lld: %d(%s)\n", + id, oid, rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + type = sqlite3_column_int64(sql, 0); + value = sqlite3_column_int(sql, 1); + sqlite3_finalize(sql); + + return true; +} + +// Get an unsigned 64 bit long value +bool getULong(sqlite3* db, long long oid, long long id, uint64_t& type, uint64_t& value) +{ + int rv; + sqlite3_stmt* sql = NULL; + std::string command = "select type,value from attribute_integer where object_id=? and id=?;"; + + value = 0ULL; + + rv = sqlite3_prepare_v2(db, command.c_str(), -1, &sql, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, + "can't find integer attribute id=%lld object=%lld: %d(%s)\n", + id, oid, rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + rv = sqlite3_bind_int64(sql, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + sqlite3_bind_int64(sql, 2, id); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the attribute id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + while ((rv = sqlite3_step(sql)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + fprintf(stderr, + "can't read integer attribute id=%lld object=%lld: %d(%s)\n", + id, oid, rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + type = sqlite3_column_int64(sql, 0); + value = sqlite3_column_int64(sql, 1); + sqlite3_finalize(sql); + + return true; +} + +// Get a byte string (aka uint8_t vector) value +bool getBytes(sqlite3* db, long long oid, long long id, uint64_t& type, std::vector<uint8_t>& value) +{ + int rv; + sqlite3_stmt* sql = NULL; + std::string command = "select type,value from attribute_binary where object_id=? and id=?;"; + size_t len; + const uint8_t* val; + + value.clear(); + + rv = sqlite3_prepare_v2(db, command.c_str(), -1, &sql, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, + "can't find binary attribute id=%lld object=%lld: %d(%s)\n", + id, oid, rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + rv = sqlite3_bind_int64(sql, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + sqlite3_bind_int64(sql, 2, id); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the attribute id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + while ((rv = sqlite3_step(sql)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + fprintf(stderr, + "can't read binary attribute id=%lld object=%lld: %d(%s)\n", + id, oid, rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + type = sqlite3_column_int64(sql, 0); + len = sqlite3_column_bytes(sql, 1); + val = (const uint8_t*) sqlite3_column_blob(sql, 1); + for (size_t i = 0; i < len; ++i) + { + value.push_back(val[i]); + } + sqlite3_finalize(sql); + + return true; +} + +// Get an array (aka Attribute vector) value +bool getArray(sqlite3* db, long long oid, long long id, uint64_t& type, std::vector<Attribute>& value) +{ + int rv; + sqlite3_stmt* sql = NULL; + std::string command = "select type,value from attribute_array where object_id=? and id=?;"; + size_t len; + const uint8_t* val; + + value.clear(); + + rv = sqlite3_prepare_v2(db, command.c_str(), -1, &sql, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, + "can't find array attribute id=%lld object=%lld: %d(%s)\n", + id, oid, rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + rv = sqlite3_bind_int64(sql, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + sqlite3_bind_int64(sql, 2, id); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the attribute id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + while ((rv = sqlite3_step(sql)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + fprintf(stderr, + "can't read array attribute id=%lld object=%lld: %d(%s)\n", + id, oid, rv, sqlite3_errmsg(db)); + sqlite3_finalize(sql); + return false; + } + type = sqlite3_column_int64(sql, 0); + len = sqlite3_column_bytes(sql, 1); + val = (const uint8_t*) sqlite3_column_blob(sql, 1); + +// CK_ATTRIBUTE_TYPE type, AttributeKind kind +// bool -> int, integer -> unsigned long, binary -> unsigned long + vector + + for (size_t pos = 0; pos < len; ) + { + // finished? + if (pos == len) break; + + Attribute attr; + + if (pos + sizeof(attr.type) > len) + { + fprintf(stderr, "overflow array item type\n"); + sqlite3_finalize(sql); + return false; + } + memcpy(&attr.type, val + pos, sizeof(attr.type)); + pos += sizeof(attr.type); + + if (pos + sizeof(attr.kind) > len) + { + fprintf(stderr, "overflow array item kind\n"); + sqlite3_finalize(sql); + return false; + } + memcpy(&attr.kind, val + pos, sizeof(attr.kind)); + pos += sizeof(attr.kind); + + if (attr.kind == akBoolean) + { + if (pos + sizeof(attr.boolValue) > len) + { + fprintf(stderr, "overflow array boolean item\n"); + sqlite3_finalize(sql); + return false; + } + memcpy(&attr.boolValue, val + pos, sizeof(attr.boolValue)); + pos += sizeof(attr.boolValue); + } + else if (attr.kind == akInteger) + { + if (pos + sizeof(attr.ulongValue) > len) + { + fprintf(stderr, "overflow array integer item\n"); + sqlite3_finalize(sql); + return false; + } + memcpy(&attr.ulongValue, val + pos, sizeof(attr.ulongValue)); + pos += sizeof(attr.ulongValue); + } + else if (attr.kind == akBinary) + { + unsigned long size; + if (pos + sizeof(size) > len) + { + fprintf(stderr, "overflow array binary item\n"); + sqlite3_finalize(sql); + return false; + } + memcpy(&size, val + pos, sizeof(size)); + pos += sizeof(size); + + if (pos + size > len) + { + fprintf(stderr, "overflow array binary item\n"); + sqlite3_finalize(sql); + return false; + } + attr.bytestrValue.resize(size); + for (unsigned long i = 0; i < size; ++i) + { + attr.bytestrValue[i] = val[pos + i]; + } + pos += size; + } + else + { + fprintf(stderr, "unknown array item\n"); + sqlite3_finalize(sql); + return false; + } + + value.push_back(attr); + } + sqlite3_finalize(sql); + + return true; +} + +// Dump boolean attributes of an object +void dump_booleans(sqlite3* db, long long oid) +{ + int rv; + unsigned long count; + sqlite3_stmt* sqlcnt = NULL; + sqlite3_stmt* sqlid = NULL; + std::string commandcnt = "select count(id) from attribute_boolean where object_id=?;"; + std::string commandid = "select id from attribute_boolean where object_id=?;"; + rv = sqlite3_prepare_v2(db, commandcnt.c_str(), -1, &sqlcnt, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + rv = sqlite3_bind_int64(sqlcnt, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + while ((rv = sqlite3_step(sqlcnt)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + count = sqlite3_column_int(sqlcnt, 0); + sqlite3_finalize(sqlcnt); + if (count == 0) + return; + + printf("%lu boolean attributes for object %lld\n", count, oid); + + rv = sqlite3_prepare_v2(db, commandid.c_str(), -1, &sqlid, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlid); + return; + } + rv = sqlite3_bind_int64(sqlid, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlid); + return; + } + while (count-- > 0) { + while ((rv = sqlite3_step(sqlid)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + if (rv != SQLITE_DONE) + { + fprintf(stderr, + "can't get next object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + } + sqlite3_finalize(sqlid); + return; + } + long long id = sqlite3_column_int64(sqlid, 0); + + uint64_t type; + uint8_t value; + if (!getBool(db, oid, id, type, value)) + { + return; + } + dumpULong(type); + if ((uint64_t)((uint32_t)type) != type) + { + printf("overflow attribute type\n"); + } + else + { + dumpCKA((unsigned long) type, 48); + printf("\n"); + } + + dumpBool1(value); + printf("\n"); + } +} + +// Dump integer attributes of an object +void dump_integers(sqlite3* db, long long oid) +{ + int rv; + unsigned long count; + sqlite3_stmt* sqlcnt = NULL; + sqlite3_stmt* sqlid = NULL; + std::string commandcnt = "select count(id) from attribute_integer where object_id=?;"; + std::string commandid = "select id from attribute_integer where object_id=?;"; + rv = sqlite3_prepare_v2(db, commandcnt.c_str(), -1, &sqlcnt, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + rv = sqlite3_bind_int64(sqlcnt, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + while ((rv = sqlite3_step(sqlcnt)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + count = sqlite3_column_int(sqlcnt, 0); + sqlite3_finalize(sqlcnt); + if (count == 0) + return; + + printf("%lu integer attributes for object %lld\n", count, oid); + + rv = sqlite3_prepare_v2(db, commandid.c_str(), -1, &sqlid, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlid); + return; + } + rv = sqlite3_bind_int64(sqlid, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlid); + return; + } + while (count-- > 0) { + while ((rv = sqlite3_step(sqlid)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + if (rv != SQLITE_DONE) + { + fprintf(stderr, + "can't get next object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + } + sqlite3_finalize(sqlid); + return; + } + long long id = sqlite3_column_int64(sqlid, 0); + + uint64_t type; + uint64_t value; + if (!getULong(db, oid, id, type, value)) + { + return; + } + dumpULong(type); + if ((uint64_t)((uint32_t)type) != type) + { + printf("overflow attribute type\n"); + } + else + { + dumpCKA((unsigned long) type, 48); + printf("\n"); + } + dumpULong(value); + dumpCKx(type, value, 48); + printf("\n"); + } +} + +// Dump binary attributes of an object +void dump_binaries(sqlite3* db, long long oid) +{ + int rv; + unsigned long count; + sqlite3_stmt* sqlcnt = NULL; + sqlite3_stmt* sqlid = NULL; + std::string commandcnt = "select count(id) from attribute_binary where object_id=?;"; + std::string commandid = "select id from attribute_binary where object_id=?;"; + rv = sqlite3_prepare_v2(db, commandcnt.c_str(), -1, &sqlcnt, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + rv = sqlite3_bind_int64(sqlcnt, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + while ((rv = sqlite3_step(sqlcnt)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + count = sqlite3_column_int(sqlcnt, 0); + sqlite3_finalize(sqlcnt); + if (count == 0) + return; + + printf("%lu binary attributes for object %lld\n", count, oid); + + rv = sqlite3_prepare_v2(db, commandid.c_str(), -1, &sqlid, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlid); + return; + } + rv = sqlite3_bind_int64(sqlid, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlid); + return; + } + while (count-- > 0) { + while ((rv = sqlite3_step(sqlid)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + if (rv != SQLITE_DONE) + { + fprintf(stderr, + "can't get next object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + } + sqlite3_finalize(sqlid); + return; + } + long long id = sqlite3_column_int64(sqlid, 0); + + uint64_t type; + std::vector<uint8_t> value; + if (!getBytes(db, oid, id, type, value)) + { + return; + } + dumpULong(type); + if ((uint64_t)((uint32_t)type) != type) + { + printf("overflow attribute type\n"); + } + else + { + dumpCKA((unsigned long) type, 48); + printf("\n"); + } + dumpULong((uint64_t) value.size()); + printf("(length %lu)\n", (unsigned long) value.size()); + dumpBytes(value); + } +} + +// Dump array attributes of an object +void dump_arrays(sqlite3* db, long long oid) +{ + int rv; + unsigned long count; + sqlite3_stmt* sqlcnt = NULL; + sqlite3_stmt* sqlid = NULL; + std::string commandcnt = "select count(id) from attribute_array where object_id=?;"; + std::string commandid = "select id from attribute_array where object_id=?;"; + rv = sqlite3_prepare_v2(db, commandcnt.c_str(), -1, &sqlcnt, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + rv = sqlite3_bind_int64(sqlcnt, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + while ((rv = sqlite3_step(sqlcnt)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + count = sqlite3_column_int(sqlcnt, 0); + sqlite3_finalize(sqlcnt); + if (count == 0) + return; + + printf("%lu array attributes for object %lld\n", count, oid); + + rv = sqlite3_prepare_v2(db, commandid.c_str(), -1, &sqlid, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlid); + return; + } + rv = sqlite3_bind_int64(sqlid, 1, oid); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't bind the object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlid); + return; + } + while (count-- > 0) { + while ((rv = sqlite3_step(sqlid)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + if (rv != SQLITE_DONE) + { + fprintf(stderr, + "can't get next object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + } + sqlite3_finalize(sqlid); + return; + } + long long id = sqlite3_column_int64(sqlid, 0); + + uint64_t type; + std::vector<Attribute> value; + if (!getArray(db, oid, id, type, value)) + { + return; + } + dumpULong(type); + if ((uint64_t)((uint32_t)type) != type) + { + printf("overflow attribute type\n"); + } + else + { + dumpCKA((unsigned long) type, 48); + printf("\n"); + } + dumpULong((uint64_t) value.size()); + printf("(length %lu)\n", (unsigned long) value.size()); + dumpArray(value); + } +} + +// Dump an object +void dump_object(sqlite3* db, long long oid) +{ + printf("dump object id=%lld\n", oid); + dump_booleans(db, oid); + dump_integers(db, oid); + dump_binaries(db, oid); + dump_arrays(db, oid); +} + +// Core function +void dump(sqlite3* db) +{ + int rv; + unsigned long count; + sqlite3_stmt* sqlcnt = NULL; + sqlite3_stmt* sqlid = NULL; + std::string commandcnt = "select count(id) from object;"; + std::string commandid = "select id from object;"; + + rv = sqlite3_prepare_v2(db, commandcnt.c_str(), -1, &sqlcnt, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + while ((rv = sqlite3_step(sqlcnt)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlcnt); + return; + } + count = sqlite3_column_int(sqlcnt, 0); + sqlite3_finalize(sqlcnt); + printf("%lu objects\n", count); + + rv = sqlite3_prepare_v2(db, commandid.c_str(), -1, &sqlid, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't count the object table: %d(%s)\n", + rv, sqlite3_errmsg(db)); + sqlite3_finalize(sqlid); + return; + } + while (count-- > 0) { + while ((rv = sqlite3_step(sqlid)) == SQLITE_BUSY) + { + sched_yield(); + } + if (rv != SQLITE_ROW) + { + if (rv != SQLITE_DONE) + { + fprintf(stderr, + "can't get next object id: %d(%s)\n", + rv, sqlite3_errmsg(db)); + } + sqlite3_finalize(sqlid); + return; + } + long long oid = sqlite3_column_int64(sqlid, 0); + dump_object(db, oid); + } +} + +// Display the usage +void usage() +{ + printf("SoftHSM dump tool. From SoftHSM v2 database.\n"); + printf("Usage: softhsm2-dump-db path\n"); +} + +// Check the existence of a table +void check_table_exist(sqlite3* db, std::string name) +{ + int rv; + std::string command = "select count(id) from " + name + ";"; + + rv = sqlite3_exec(db, command.c_str(), NULL, NULL, NULL); + if (rv != SQLITE_OK) + { + fprintf(stderr, "can't find '%s' table\n", name.c_str()); + sqlite3_close(db); + exit(0); + } +} + +// The main function +int main(int argc, char* argv[]) +{ + int rv; + sqlite3* db = NULL; + + if (argc != 2) + { + usage(); + exit(0); + } + + rv = sqlite3_open_v2(argv[1], &db, SQLITE_OPEN_READONLY, NULL); + if (rv != SQLITE_OK) + { + if (db == NULL) + { + fprintf(stderr, + "can't open database file %s\n", + argv[1]); + } + else + { + fprintf(stderr, + "can't open database file %s: %d(%s)\n", + argv[1], + rv, + sqlite3_errmsg(db)); + } + sqlite3_close(db); + exit(0); + } + + // No user version to check + + check_table_exist(db, "object"); + check_table_exist(db, "attribute_boolean"); + check_table_exist(db, "attribute_integer"); + check_table_exist(db, "attribute_binary"); + check_table_exist(db, "attribute_array"); + + printf("Dump of object file \"%s\"\n", argv[1]); + dump(db); + sqlite3_close(db); + exit(1); +} diff --git a/SoftHSMv2/src/bin/dump/softhsm2-dump-file.1 b/SoftHSMv2/src/bin/dump/softhsm2-dump-file.1 new file mode 100644 index 0000000..5167f70 --- /dev/null +++ b/SoftHSMv2/src/bin/dump/softhsm2-dump-file.1 @@ -0,0 +1,18 @@ +.TH SOFTHSM2-DUMP-FILE 1 "20 March 2014" "SoftHSM" +.SH NAME +softhsm2-dump-file \- SoftHSM object file dump +.SH SYNOPSIS +.PP +.B softhsm2-dump-file +.I path +.SH DESCRIPTION +.B softhsm2-dump-file +is a tool that can dump SoftHSM v2 object file for debugging purposes. +.LP +.SH OPTIONS +.TP +.B \fIpath\fR +The SoftHSM v2 object file that is going to be dumped. +.TP +.B \-\-help\fR, \fB\-h\fR +Show the help information. diff --git a/SoftHSMv2/src/bin/dump/softhsm2-dump-file.cpp b/SoftHSMv2/src/bin/dump/softhsm2-dump-file.cpp new file mode 100644 index 0000000..994f67e --- /dev/null +++ b/SoftHSMv2/src/bin/dump/softhsm2-dump-file.cpp @@ -0,0 +1,537 @@ +/* + * Copyright (c) 2013 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + softhsm2-dump-file.cpp + + This program can be used for dumping SoftHSM v2 object files. + *****************************************************************************/ + +#include <config.h> + +#include "common.h" + +// Attribute types on disk +#define BOOLEAN_ATTR 0x1 +#define ULONG_ATTR 0x2 +#define BYTES_ATTR 0x3 +#define ATTRMAP_ATTR 0x4 +#define MECHSET_ATTR 0x5 + +// Maximum byte string length (1Gib) +#define MAX_BYTES 0x3fffffff + +typedef AttributeTK<uint64_t, uint64_t, uint64_t> Attribute; + +// Attribute specialization +template<> +bool Attribute::isBoolean() const +{ + return kind == BOOLEAN_ATTR; +} + +template<> +bool Attribute::isInteger() const +{ + return kind == ULONG_ATTR; +} + +template<> +bool Attribute::isBinary() const +{ + return kind == BYTES_ATTR; +} + +template<> +bool Attribute::isMechSet() const +{ + return kind == MECHSET_ATTR; +} + +template<> +void Attribute::dumpType() const +{ + dumpULong(type, true); +} + +template<> +void Attribute::dumpKind() const +{ + dumpULong(kind, true); +} + +template<> +void Attribute::dumpBoolValue() const +{ + dumpBool(boolValue, true); +} + +template<> +void Attribute::dumpULongValue(uint64_t value) const +{ + dumpULong(value, true); +} + +// dumpMap specialization +typedef std::vector<Attribute> va_type; + +void dumpMap(const va_type& value) +{ + for (va_type::const_iterator attr = value.begin(); attr != value.end(); ++attr) + attr->dump(); +} + +// Read a boolean (in fact unsigned 8 bit long) value +bool readBool(FILE* stream, uint8_t& value) +{ + value = 0; + fpos_t pos; + if (fgetpos(stream, &pos) != 0) + { + return false; + } + uint8_t v; + if (fread(&v, 1, 1, stream) != 1) + { + (void) fsetpos(stream, &pos); + return false; + } + value = v; + return true; +} + +// Read an unsigned 64 bit long value +bool readULong(FILE* stream, uint64_t& value) +{ + value = 0; + fpos_t pos; + if (fgetpos(stream, &pos) != 0) + { + return false; + } + uint8_t v[8]; + if (fread(v, 1, 8, stream) != 8) + { + (void) fsetpos(stream, &pos); + return false; + } + for (size_t i = 0; i < 8; i++) + { + value <<= 8; + value += v[i]; + } + return true; +} + +// Read a byte string (aka uint8_t vector) value +bool readBytes(FILE* stream, std::vector<uint8_t>& value) +{ + size_t len = value.size(); + fpos_t pos; + if (fgetpos(stream, &pos) != 0) + { + return false; + } + if (fread(&value[0], 1, len, stream) != len) + { + (void) fsetpos(stream, &pos); + return false; + } + return true; +} + +// Read a map (aka Attribute vector) value +bool readMap(FILE* stream, uint64_t len, std::vector<Attribute>& value) +{ + fpos_t pos; + if (fgetpos(stream, &pos) != 0) + { + return false; + } + while (len != 0) + { + Attribute attr; + + if (len < 8) + { + (void) fsetpos(stream, &pos); + return false; + } + if (!readULong(stream, attr.type)) + { + (void) fsetpos(stream, &pos); + return false; + } + len -= 8; + + if (len < 8) + { + (void) fsetpos(stream, &pos); + return false; + } + if (!readULong(stream, attr.kind)) + { + (void) fsetpos(stream, &pos); + return false; + } + len -= 8; + + if (attr.kind == BOOLEAN_ATTR) + { + if (len < 1) + { + (void) fsetpos(stream, &pos); + return false; + } + len -= 1; + if (!readBool(stream, attr.boolValue)) + { + (void) fsetpos(stream, &pos); + return false; + } + } + else if (attr.kind == ULONG_ATTR) + { + if (len < 8) + { + (void) fsetpos(stream, &pos); + return false; + } + if (!readULong(stream, attr.ulongValue)) + { + (void) fsetpos(stream, &pos); + return false; + } + len -= 8; + } + else if (attr.kind == BYTES_ATTR) + { + uint64_t size; + if (len < 8) + { + (void) fsetpos(stream, &pos); + return false; + } + if (!readULong(stream, size)) + { + (void) fsetpos(stream, &pos); + return false; + } + len -= 8; + + if (len < size) + { + (void) fsetpos(stream, &pos); + return false; + } + attr.bytestrValue.resize((size_t)size); + if (!readBytes(stream, attr.bytestrValue)) + { + (void) fsetpos(stream, &pos); + return false; + } + len -= size; + } + else if (attr.kind == MECHSET_ATTR) + { + uint64_t size; + if (len < 8) + { + (void) fsetpos(stream, &pos); + return false; + } + if (!readULong(stream, size)) + { + (void) fsetpos(stream, &pos); + return false; + } + len -= 8; + + if (len < size * 8) + { + (void) fsetpos(stream, &pos); + return false; + } + + for (unsigned long i = 0; i < size; i++) + { + uint64_t mech; + if (!readULong(stream, mech)) + { + (void) fsetpos(stream, &pos); + return false; + } + attr.mechSetValue.insert(mech); + } + len -= size * 8; + } + else + { + (void) fsetpos(stream, &pos); + return false; + } + + value.push_back(attr); + } + + return true; +} + +// Error case +void corrupt(FILE* stream) +{ + uint8_t v; + for (size_t i = 0; i < 8; i++) + { + if (fread(&v, 1, 1, stream) != 1) + { + if (ferror(stream)) + { + printf("get an error...\n"); + } + return; + } + if (i != 0) + { + printf(" "); + } + printf("%02hhx", v); + } + if (fread(&v, 1, 1, stream) != 1) + { + if (ferror(stream)) + { + printf("\nget an error...\n"); + } + return; + } + printf("...\n"); +} + +// Core function +void dump(FILE* stream) +{ + uint64_t gen; + if (!readULong(stream, gen)) + { + if (feof(stream)) + { + printf("empty file\n"); + } + else + { + corrupt(stream); + } + return; + } + dumpULong(gen); + printf("generation %lu\n", (unsigned long) gen); + + while (!feof(stream)) + { + uint64_t p11type; + if (!readULong(stream, p11type)) + { + corrupt(stream); + return; + } + dumpULong(p11type); + if ((uint64_t)((uint32_t)p11type) != p11type) + { + printf("overflow attribute type\n"); + } + else + { + dumpCKA((unsigned long) p11type, 48); + printf("\n"); + } + + uint64_t disktype; + if (!readULong(stream, disktype)) + { + corrupt(stream); + return; + } + dumpULong(disktype); + switch (disktype) + { + case BOOLEAN_ATTR: + printf("boolean attribute\n"); + break; + case ULONG_ATTR: + printf("unsigned long attribute\n"); + break; + case BYTES_ATTR: + printf("byte string attribute\n"); + break; + case ATTRMAP_ATTR: + printf("attribute map attribute\n"); + break; + case MECHSET_ATTR: + printf("mechanism set attribute\n"); + break; + default: + printf("unknown attribute format\n"); + break; + } + + if (disktype == BOOLEAN_ATTR) + { + uint8_t value; + if (!readBool(stream, value)) + { + corrupt(stream); + return; + } + dumpBool(value); + printf("\n"); + } + else if (disktype == ULONG_ATTR) + { + uint64_t value; + if (!readULong(stream, value)) + { + corrupt(stream); + return; + } + dumpULong(value); + dumpCKx(p11type, value, 48); + printf("\n"); + } + else if (disktype == BYTES_ATTR) + { + uint64_t len; + if (!readULong(stream, len)) + { + corrupt(stream); + return; + } + dumpULong(len); + if (len > MAX_BYTES) + { + printf("overflow length...\n"); + return; + } + printf("(length %lu)\n", (unsigned long) len); + + std::vector<uint8_t> value((size_t) len); + if (!readBytes(stream, value)) + { + corrupt(stream); + return; + } + dumpBytes(value); + } + else if (disktype == ATTRMAP_ATTR) + { + uint64_t len; + if (!readULong(stream, len)) + { + corrupt(stream); + return; + } + dumpULong(len); + if (len > MAX_BYTES) + { + printf("overflow length...\n"); + return; + } + printf("(length %lu)\n", (unsigned long) len); + + std::vector<Attribute> value; + if (!readMap(stream, len, value)) + { + corrupt(stream); + return; + } + dumpMap(value); + } + else if (disktype == MECHSET_ATTR) + { + uint64_t len; + if (!readULong(stream, len)) + { + corrupt(stream); + return; + } + dumpULong(len); + if (len > MAX_BYTES) + { + printf("overflow length...\n"); + return; + } + printf("(length %lu)\n", (unsigned long) len); + + for (unsigned long i = 0; i < len; i++) + { + uint64_t mech; + if (!readULong(stream, mech)) + { + corrupt(stream); + return; + } + dumpULong(mech); + dumpCKM(mech, 48); + printf("\n"); + } + } + else + { + corrupt(stream); + return; + } + } +} + +// Display the usage +void usage() +{ + printf("SoftHSM dump tool. From SoftHSM v2 object file.\n"); + printf("Usage: softhsm2-dump-file path\n"); +} + +// The main function +int main(int argc, char* argv[]) +{ + FILE* stream; + + if (argc != 2) + { + usage(); + exit(0); + } + + stream = fopen(argv[1], "r"); + if (stream == NULL) + { + fprintf(stderr, "can't open object file %s\n", argv[1]); + exit(0); + } + + printf("Dump of object file \"%s\"\n", argv[1]); + dump(stream); + exit(1); +} diff --git a/SoftHSMv2/src/bin/dump/tables.h b/SoftHSMv2/src/bin/dump/tables.h new file mode 100644 index 0000000..76d64fb --- /dev/null +++ b/SoftHSMv2/src/bin/dump/tables.h @@ -0,0 +1,554 @@ +/* + * Copyright (c) 2013 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + tables.h + + Tables from PKCS#11 specs. + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_TABLES_H +#define _SOFTHSM_V2_TABLES_H + +#include "OSAttributes.h" + +// Attribute types +void fill_CKA_table(std::map<unsigned long, std::string> &t) +{ + t[CKA_CLASS] = "CKA_CLASS"; + t[CKA_TOKEN] = "CKA_TOKEN"; + t[CKA_PRIVATE] = "CKA_PRIVATE"; + t[CKA_LABEL] = "CKA_LABEL"; + t[CKA_APPLICATION] = "CKA_APPLICATION"; + t[CKA_VALUE] = "CKA_VALUE"; + t[CKA_OBJECT_ID] = "CKA_OBJECT_ID"; + t[CKA_CERTIFICATE_TYPE] = "CKA_CERTIFICATE_TYPE"; + t[CKA_ISSUER] = "CKA_ISSUER"; + t[CKA_SERIAL_NUMBER] = "CKA_SERIAL_NUMBER"; + t[CKA_AC_ISSUER] = "CKA_AC_ISSUER"; + t[CKA_OWNER] = "CKA_OWNER"; + t[CKA_ATTR_TYPES] = "CKA_ATTR_TYPES"; + t[CKA_TRUSTED] = "CKA_TRUSTED"; + t[CKA_CERTIFICATE_CATEGORY] = "CKA_CERTIFICATE_CATEGORY"; + t[CKA_JAVA_MIDP_SECURITY_DOMAIN] = "CKA_JAVA_MIDP_SECURITY_DOMAIN"; + t[CKA_URL] = "CKA_URL"; + t[CKA_HASH_OF_SUBJECT_PUBLIC_KEY] = "CKA_HASH_OF_SUBJECT_PUBLIC_KEY"; + t[CKA_HASH_OF_ISSUER_PUBLIC_KEY] = "CKA_HASH_OF_ISSUER_PUBLIC_KEY"; + t[CKA_NAME_HASH_ALGORITHM] = "CKA_NAME_HASH_ALGORITHM"; + t[CKA_CHECK_VALUE] = "CKA_CHECK_VALUE"; + t[CKA_KEY_TYPE] = "CKA_KEY_TYPE"; + t[CKA_SUBJECT] = "CKA_SUBJECT"; + t[CKA_ID] = "CKA_ID"; + t[CKA_SENSITIVE] = "CKA_SENSITIVE"; + t[CKA_ENCRYPT] = "CKA_ENCRYPT"; + t[CKA_DECRYPT] = "CKA_DECRYPT"; + t[CKA_WRAP] = "CKA_WRAP"; + t[CKA_UNWRAP] = "CKA_UNWRAP"; + t[CKA_SIGN] = "CKA_SIGN"; + t[CKA_SIGN_RECOVER] = "CKA_SIGN_RECOVER"; + t[CKA_VERIFY] = "CKA_VERIFY"; + t[CKA_VERIFY_RECOVER] = "CKA_VERIFY_RECOVER"; + t[CKA_DERIVE] = "CKA_DERIVE"; + t[CKA_START_DATE] = "CKA_START_DATE"; + t[CKA_END_DATE] = "CKA_END_DATE"; + t[CKA_MODULUS] = "CKA_MODULUS"; + t[CKA_MODULUS_BITS] = "CKA_MODULUS_BITS"; + t[CKA_PUBLIC_EXPONENT] = "CKA_PUBLIC_EXPONENT"; + t[CKA_PRIVATE_EXPONENT] = "CKA_PRIVATE_EXPONENT"; + t[CKA_PRIME_1] = "CKA_PRIME_1"; + t[CKA_PRIME_2] = "CKA_PRIME_2"; + t[CKA_EXPONENT_1] = "CKA_EXPONENT_1"; + t[CKA_EXPONENT_2] = "CKA_EXPONENT_2"; + t[CKA_COEFFICIENT] = "CKA_COEFFICIENT"; + t[CKA_PUBLIC_KEY_INFO] = "CKA_PUBLIC_KEY_INFO"; + t[CKA_PRIME] = "CKA_PRIME"; + t[CKA_SUBPRIME] = "CKA_SUBPRIME"; + t[CKA_BASE] = "CKA_BASE"; + t[CKA_PRIME_BITS] = "CKA_PRIME_BITS"; + t[CKA_SUBPRIME_BITS] = "CKA_SUBPRIME_BITS"; + t[CKA_VALUE_BITS] = "CKA_VALUE_BITS"; + t[CKA_VALUE_LEN] = "CKA_VALUE_LEN"; + t[CKA_EXTRACTABLE] = "CKA_EXTRACTABLE"; + t[CKA_LOCAL] = "CKA_LOCAL"; + t[CKA_NEVER_EXTRACTABLE] = "CKA_NEVER_EXTRACTABLE"; + t[CKA_ALWAYS_SENSITIVE] = "CKA_ALWAYS_SENSITIVE"; + t[CKA_KEY_GEN_MECHANISM] = "CKA_KEY_GEN_MECHANISM"; + t[CKA_MODIFIABLE] = "CKA_MODIFIABLE"; + t[CKA_COPYABLE] = "CKA_COPYABLE"; + t[CKA_DESTROYABLE] = "CKA_DESTROYABLE"; + t[CKA_EC_PARAMS] = "CKA_EC_PARAMS"; + t[CKA_EC_POINT] = "CKA_EC_POINT"; + t[CKA_SECONDARY_AUTH] = "CKA_SECONDARY_AUTH"; + t[CKA_AUTH_PIN_FLAGS] = "CKA_AUTH_PIN_FLAGS"; + t[CKA_ALWAYS_AUTHENTICATE] = "CKA_ALWAYS_AUTHENTICATE"; + t[CKA_WRAP_WITH_TRUSTED] = "CKA_WRAP_WITH_TRUSTED"; + t[CKA_WRAP_TEMPLATE] = "CKA_WRAP_TEMPLATE"; + t[CKA_UNWRAP_TEMPLATE] = "CKA_UNWRAP_TEMPLATE"; + t[CKA_DERIVE_TEMPLATE] = "CKA_DERIVE_TEMPLATE"; + t[CKA_OTP_FORMAT] = "CKA_OTP_FORMAT"; + t[CKA_OTP_LENGTH] = "CKA_OTP_LENGTH"; + t[CKA_OTP_TIME_INTERVAL] = "CKA_OTP_TIME_INTERVAL"; + t[CKA_OTP_USER_FRIENDLY_MODE] = "CKA_OTP_USER_FRIENDLY_MODE"; + t[CKA_OTP_CHALLENGE_REQUIREMENT] = "CKA_OTP_CHALLENGE_REQUIREMENT"; + t[CKA_OTP_TIME_REQUIREMENT] = "CKA_OTP_TIME_REQUIREMENT"; + t[CKA_OTP_COUNTER_REQUIREMENT] = "CKA_OTP_COUNTER_REQUIREMENT"; + t[CKA_OTP_PIN_REQUIREMENT] = "CKA_OTP_PIN_REQUIREMENT"; + t[CKA_OTP_COUNTER] = "CKA_OTP_COUNTER"; + t[CKA_OTP_TIME] = "CKA_OTP_TIME"; + t[CKA_OTP_USER_IDENTIFIER] = "CKA_OTP_USER_IDENTIFIER"; + t[CKA_OTP_SERVICE_IDENTIFIER] = "CKA_OTP_SERVICE_IDENTIFIER"; + t[CKA_OTP_SERVICE_LOGO] = "CKA_OTP_SERVICE_LOGO"; + t[CKA_OTP_SERVICE_LOGO_TYPE] = "CKA_OTP_SERVICE_LOGO_TYPE"; + t[CKA_GOSTR3410_PARAMS] = "CKA_GOSTR3410_PARAMS"; + t[CKA_GOSTR3411_PARAMS] = "CKA_GOSTR3411_PARAMS"; + t[CKA_GOST28147_PARAMS] = "CKA_GOST28147_PARAMS"; + t[CKA_HW_FEATURE_TYPE] = "CKA_HW_FEATURE_TYPE"; + t[CKA_RESET_ON_INIT] = "CKA_RESET_ON_INIT"; + t[CKA_HAS_RESET] = "CKA_HAS_RESET"; + t[CKA_PIXEL_X] = "CKA_PIXEL_X"; + t[CKA_PIXEL_Y] = "CKA_PIXEL_Y"; + t[CKA_RESOLUTION] = "CKA_RESOLUTION"; + t[CKA_CHAR_ROWS] = "CKA_CHAR_ROWS"; + t[CKA_CHAR_COLUMNS] = "CKA_CHAR_COLUMNS"; + t[CKA_COLOR] = "CKA_COLOR"; + t[CKA_BITS_PER_PIXEL] = "CKA_BITS_PER_PIXEL"; + t[CKA_CHAR_SETS] = "CKA_CHAR_SETS"; + t[CKA_ENCODING_METHODS] = "CKA_ENCODING_METHODS"; + t[CKA_MIME_TYPES] = "CKA_MIME_TYPES"; + t[CKA_MECHANISM_TYPE] = "CKA_MECHANISM_TYPE"; + t[CKA_REQUIRED_CMS_ATTRIBUTES] = "CKA_REQUIRED_CMS_ATTRIBUTES"; + t[CKA_DEFAULT_CMS_ATTRIBUTES] = "CKA_DEFAULT_CMS_ATTRIBUTES"; + t[CKA_SUPPORTED_CMS_ATTRIBUTES] = "CKA_SUPPORTED_CMS_ATTRIBUTES"; + t[CKA_ALLOWED_MECHANISMS] = "CKA_ALLOWED_MECHANISMS"; + // local extensions + t[CKA_VENDOR_SOFTHSM] = "CKA_VENDOR_SOFTHSM"; + t[CKA_OS_TOKENLABEL] = "CKA_OS_TOKENLABEL"; + t[CKA_OS_TOKENSERIAL] = "CKA_OS_TOKENSERIAL"; + t[CKA_OS_TOKENFLAGS] = "CKA_OS_TOKENFLAGS"; + t[CKA_OS_SOPIN] = "CKA_OS_SOPIN"; + t[CKA_OS_USERPIN] = "CKA_OS_USERPIN"; +} + +void fill_CKM_table(std::map<unsigned long, std::string> &t) +{ + t[CKM_RSA_PKCS_KEY_PAIR_GEN] = "CKM_RSA_PKCS_KEY_PAIR_GEN"; + t[CKM_RSA_PKCS] = "CKM_RSA_PKCS"; + t[CKM_RSA_9796] = "CKM_RSA_9796"; + t[CKM_RSA_X_509] = "CKM_RSA_X_509"; + t[CKM_MD2_RSA_PKCS] = "CKM_MD2_RSA_PKCS"; + t[CKM_MD5_RSA_PKCS] = "CKM_MD5_RSA_PKCS"; + t[CKM_SHA1_RSA_PKCS] = "CKM_SHA1_RSA_PKCS"; + t[CKM_RIPEMD128_RSA_PKCS] = "CKM_RIPEMD128_RSA_PKCS"; + t[CKM_RIPEMD160_RSA_PKCS] = "CKM_RIPEMD160_RSA_PKCS"; + t[CKM_RSA_PKCS_OAEP] = "CKM_RSA_PKCS_OAEP"; + t[CKM_RSA_X9_31_KEY_PAIR_GEN] = "CKM_RSA_X9_31_KEY_PAIR_GEN"; + t[CKM_RSA_X9_31] = "CKM_RSA_X9_31"; + t[CKM_SHA1_RSA_X9_31] = "CKM_SHA1_RSA_X9_31"; + t[CKM_RSA_PKCS_PSS] = "CKM_RSA_PKCS_PSS"; + t[CKM_SHA1_RSA_PKCS_PSS] = "CKM_SHA1_RSA_PKCS_PSS"; + t[CKM_DSA_KEY_PAIR_GEN] = "CKM_DSA_KEY_PAIR_GEN"; + t[CKM_DSA] = "CKM_DSA"; + t[CKM_DSA_SHA1] = "CKM_DSA_SHA1"; + t[CKM_DSA_SHA224] = "CKM_DSA_SHA224"; + t[CKM_DSA_SHA256] = "CKM_DSA_SHA256"; + t[CKM_DSA_SHA384] = "CKM_DSA_SHA384"; + t[CKM_DSA_SHA512] = "CKM_DSA_SHA512"; + t[CKM_DH_PKCS_KEY_PAIR_GEN] = "CKM_DH_PKCS_KEY_PAIR_GEN"; + t[CKM_DH_PKCS_DERIVE] = "CKM_DH_PKCS_DERIVE"; + t[CKM_X9_42_DH_KEY_PAIR_GEN] = "CKM_X9_42_DH_KEY_PAIR_GEN"; + t[CKM_X9_42_DH_DERIVE] = "CKM_X9_42_DH_DERIVE"; + t[CKM_X9_42_DH_HYBRID_DERIVE] = "CKM_X9_42_DH_HYBRID_DERIVE"; + t[CKM_X9_42_MQV_DERIVE] = "CKM_X9_42_MQV_DERIVE"; + t[CKM_SHA256_RSA_PKCS] = "CKM_SHA256_RSA_PKCS"; + t[CKM_SHA384_RSA_PKCS] = "CKM_SHA384_RSA_PKCS"; + t[CKM_SHA512_RSA_PKCS] = "CKM_SHA512_RSA_PKCS"; + t[CKM_SHA256_RSA_PKCS_PSS] = "CKM_SHA256_RSA_PKCS_PSS"; + t[CKM_SHA384_RSA_PKCS_PSS] = "CKM_SHA384_RSA_PKCS_PSS"; + t[CKM_SHA512_RSA_PKCS_PSS] = "CKM_SHA512_RSA_PKCS_PSS"; + t[CKM_SHA224_RSA_PKCS] = "CKM_SHA224_RSA_PKCS"; + t[CKM_SHA224_RSA_PKCS_PSS] = "CKM_SHA224_RSA_PKCS_PSS"; + t[CKM_SHA512_224] = "CKM_SHA512_224"; + t[CKM_SHA512_224_HMAC] = "CKM_SHA512_224_HMAC"; + t[CKM_SHA512_224_HMAC_GENERAL] = "CKM_SHA512_224_HMAC_GENERAL"; + t[CKM_SHA512_224_KEY_DERIVATION] = "CKM_SHA512_224_KEY_DERIVATION"; + t[CKM_SHA512_256] = "CKM_SHA512_256"; + t[CKM_SHA512_256_HMAC] = "CKM_SHA512_256_HMAC"; + t[CKM_SHA512_256_HMAC_GENERAL] = "CKM_SHA512_256_HMAC_GENERAL"; + t[CKM_SHA512_256_KEY_DERIVATION] = "CKM_SHA512_256_KEY_DERIVATION"; + t[CKM_SHA512_T] = "CKM_SHA512_T"; + t[CKM_SHA512_T_HMAC] = "CKM_SHA512_T_HMAC"; + t[CKM_SHA512_T_HMAC_GENERAL] = "CKM_SHA512_T_HMAC_GENERAL"; + t[CKM_SHA512_T_KEY_DERIVATION] = "CKM_SHA512_T_KEY_DERIVATION"; + t[CKM_RC2_KEY_GEN] = "CKM_RC2_KEY_GEN"; + t[CKM_RC2_ECB] = "CKM_RC2_ECB"; + t[CKM_RC2_CBC] = "CKM_RC2_CBC"; + t[CKM_RC2_MAC] = "CKM_RC2_MAC"; + t[CKM_RC2_MAC_GENERAL] = "CKM_RC2_MAC_GENERAL"; + t[CKM_RC2_CBC_PAD] = "CKM_RC2_CBC_PAD"; + t[CKM_RC4_KEY_GEN] = "CKM_RC4_KEY_GEN"; + t[CKM_RC4] = "CKM_RC4"; + t[CKM_DES_KEY_GEN] = "CKM_DES_KEY_GEN"; + t[CKM_DES_ECB] = "CKM_DES_ECB"; + t[CKM_DES_CBC] = "CKM_DES_CBC"; + t[CKM_DES_MAC] = "CKM_DES_MAC"; + t[CKM_DES_MAC_GENERAL] = "CKM_DES_MAC_GENERAL"; + t[CKM_DES_CBC_PAD] = "CKM_DES_CBC_PAD"; + t[CKM_DES2_KEY_GEN] = "CKM_DES2_KEY_GEN"; + t[CKM_DES3_KEY_GEN] = "CKM_DES3_KEY_GEN"; + t[CKM_DES3_ECB] = "CKM_DES3_ECB"; + t[CKM_DES3_CBC] = "CKM_DES3_CBC"; + t[CKM_DES3_MAC] = "CKM_DES3_MAC"; + t[CKM_DES3_MAC_GENERAL] = "CKM_DES3_MAC_GENERAL"; + t[CKM_DES3_CBC_PAD] = "CKM_DES3_CBC_PAD"; + t[CKM_DES3_CMAC_GENERAL] = "CKM_DES3_CMAC_GENERAL"; + t[CKM_DES3_CMAC] = "CKM_DES3_CMAC"; + t[CKM_CDMF_KEY_GEN] = "CKM_CDMF_KEY_GEN"; + t[CKM_CDMF_ECB] = "CKM_CDMF_ECB"; + t[CKM_CDMF_CBC] = "CKM_CDMF_CBC"; + t[CKM_CDMF_MAC] = "CKM_CDMF_MAC"; + t[CKM_CDMF_MAC_GENERAL] = "CKM_CDMF_MAC_GENERAL"; + t[CKM_CDMF_CBC_PAD] = "CKM_CDMF_CBC_PAD"; + t[CKM_DES_OFB64] = "CKM_DES_OFB64"; + t[CKM_DES_OFB8] = "CKM_DES_OFB8"; + t[CKM_DES_CFB64] = "CKM_DES_CFB64"; + t[CKM_DES_CFB8] = "CKM_DES_CFB8"; + t[CKM_MD2] = "CKM_MD2"; + t[CKM_MD2_HMAC] = "CKM_MD2_HMAC"; + t[CKM_MD2_HMAC_GENERAL] = "CKM_MD2_HMAC_GENERAL"; + t[CKM_MD5] = "CKM_MD5"; + t[CKM_MD5_HMAC] = "CKM_MD5_HMAC"; + t[CKM_MD5_HMAC_GENERAL] = "CKM_MD5_HMAC_GENERAL"; + t[CKM_SHA_1] = "CKM_SHA_1"; + t[CKM_SHA_1_HMAC] = "CKM_SHA_1_HMAC"; + t[CKM_SHA_1_HMAC_GENERAL] = "CKM_SHA_1_HMAC_GENERAL"; + t[CKM_RIPEMD128] = "CKM_RIPEMD128"; + t[CKM_RIPEMD128_HMAC] = "CKM_RIPEMD128_HMAC"; + t[CKM_RIPEMD128_HMAC_GENERAL] = "CKM_RIPEMD128_HMAC_GENERAL"; + t[CKM_RIPEMD160] = "CKM_RIPEMD160"; + t[CKM_RIPEMD160_HMAC] = "CKM_RIPEMD160_HMAC"; + t[CKM_RIPEMD160_HMAC_GENERAL] = "CKM_RIPEMD160_HMAC_GENERAL"; + t[CKM_SHA256] = "CKM_SHA256"; + t[CKM_SHA256_HMAC] = "CKM_SHA256_HMAC"; + t[CKM_SHA256_HMAC_GENERAL] = "CKM_SHA256_HMAC_GENERAL"; + t[CKM_SHA224] = "CKM_SHA224"; + t[CKM_SHA224_HMAC] = "CKM_SHA224_HMAC"; + t[CKM_SHA224_HMAC_GENERAL] = "CKM_SHA224_HMAC_GENERAL"; + t[CKM_SHA384] = "CKM_SHA384"; + t[CKM_SHA384_HMAC] = "CKM_SHA384_HMAC"; + t[CKM_SHA384_HMAC_GENERAL] = "CKM_SHA384_HMAC_GENERAL"; + t[CKM_SHA512] = "CKM_SHA512"; + t[CKM_SHA512_HMAC] = "CKM_SHA512_HMAC"; + t[CKM_SHA512_HMAC_GENERAL] = "CKM_SHA512_HMAC_GENERAL"; + t[CKM_SECURID_KEY_GEN] = "CKM_SECURID_KEY_GEN"; + t[CKM_SECURID] = "CKM_SECURID"; + t[CKM_HOTP_KEY_GEN] = "CKM_HOTP_KEY_GEN"; + t[CKM_HOTP] = "CKM_HOTP"; + t[CKM_ACTI] = "CKM_ACTI"; + t[CKM_ACTI_KEY_GEN] = "CKM_ACTI_KEY_GEN"; + t[CKM_CAST_KEY_GEN] = "CKM_CAST_KEY_GEN"; + t[CKM_CAST_ECB] = "CKM_CAST_ECB"; + t[CKM_CAST_CBC] = "CKM_CAST_CBC"; + t[CKM_CAST_MAC] = "CKM_CAST_MAC"; + t[CKM_CAST_MAC_GENERAL] = "CKM_CAST_MAC_GENERAL"; + t[CKM_CAST_CBC_PAD] = "CKM_CAST_CBC_PAD"; + t[CKM_CAST3_KEY_GEN] = "CKM_CAST3_KEY_GEN"; + t[CKM_CAST3_ECB] = "CKM_CAST3_ECB"; + t[CKM_CAST3_CBC] = "CKM_CAST3_CBC"; + t[CKM_CAST3_MAC] = "CKM_CAST3_MAC"; + t[CKM_CAST3_MAC_GENERAL] = "CKM_CAST3_MAC_GENERAL"; + t[CKM_CAST3_CBC_PAD] = "CKM_CAST3_CBC_PAD"; + t[CKM_CAST128_KEY_GEN] = "CKM_CAST128_KEY_GEN"; + t[CKM_CAST128_ECB] = "CKM_CAST128_ECB"; + t[CKM_CAST128_CBC] = "CKM_CAST128_CBC"; + t[CKM_CAST128_MAC] = "CKM_CAST128_MAC"; + t[CKM_CAST128_MAC_GENERAL] = "CKM_CAST128_MAC_GENERAL"; + t[CKM_CAST128_CBC_PAD] = "CKM_CAST128_CBC_PAD"; + t[CKM_RC5_KEY_GEN] = "CKM_RC5_KEY_GEN"; + t[CKM_RC5_ECB] = "CKM_RC5_ECB"; + t[CKM_RC5_CBC] = "CKM_RC5_CBC"; + t[CKM_RC5_MAC] = "CKM_RC5_MAC"; + t[CKM_RC5_MAC_GENERAL] = "CKM_RC5_MAC_GENERAL"; + t[CKM_RC5_CBC_PAD] = "CKM_RC5_CBC_PAD"; + t[CKM_IDEA_KEY_GEN] = "CKM_IDEA_KEY_GEN"; + t[CKM_IDEA_ECB] = "CKM_IDEA_ECB"; + t[CKM_IDEA_CBC] = "CKM_IDEA_CBC"; + t[CKM_IDEA_MAC] = "CKM_IDEA_MAC"; + t[CKM_IDEA_MAC_GENERAL] = "CKM_IDEA_MAC_GENERAL"; + t[CKM_IDEA_CBC_PAD] = "CKM_IDEA_CBC_PAD"; + t[CKM_GENERIC_SECRET_KEY_GEN] = "CKM_GENERIC_SECRET_KEY_GEN"; + t[CKM_CONCATENATE_BASE_AND_KEY] = "CKM_CONCATENATE_BASE_AND_KEY"; + t[CKM_CONCATENATE_BASE_AND_DATA] = "CKM_CONCATENATE_BASE_AND_DATA"; + t[CKM_CONCATENATE_DATA_AND_BASE] = "CKM_CONCATENATE_DATA_AND_BASE"; + t[CKM_XOR_BASE_AND_DATA] = "CKM_XOR_BASE_AND_DATA"; + t[CKM_EXTRACT_KEY_FROM_KEY] = "CKM_EXTRACT_KEY_FROM_KEY"; + t[CKM_SSL3_PRE_MASTER_KEY_GEN] = "CKM_SSL3_PRE_MASTER_KEY_GEN"; + t[CKM_SSL3_MASTER_KEY_DERIVE] = "CKM_SSL3_MASTER_KEY_DERIVE"; + t[CKM_SSL3_KEY_AND_MAC_DERIVE] = "CKM_SSL3_KEY_AND_MAC_DERIVE"; + t[CKM_SSL3_MASTER_KEY_DERIVE_DH] = "CKM_SSL3_MASTER_KEY_DERIVE_DH"; + t[CKM_TLS_PRE_MASTER_KEY_GEN] = "CKM_TLS_PRE_MASTER_KEY_GEN"; + t[CKM_TLS_MASTER_KEY_DERIVE] = "CKM_TLS_MASTER_KEY_DERIVE"; + t[CKM_TLS_KEY_AND_MAC_DERIVE] = "CKM_TLS_KEY_AND_MAC_DERIVE"; + t[CKM_TLS_MASTER_KEY_DERIVE_DH] = "CKM_TLS_MASTER_KEY_DERIVE_DH"; + t[CKM_TLS_PRF] = "CKM_TLS_PRF"; + t[CKM_SSL3_MD5_MAC] = "CKM_SSL3_MD5_MAC"; + t[CKM_SSL3_SHA1_MAC] = "CKM_SSL3_SHA1_MAC"; + t[CKM_MD5_KEY_DERIVATION] = "CKM_MD5_KEY_DERIVATION"; + t[CKM_MD2_KEY_DERIVATION] = "CKM_MD2_KEY_DERIVATION"; + t[CKM_SHA1_KEY_DERIVATION] = "CKM_SHA1_KEY_DERIVATION"; + t[CKM_SHA256_KEY_DERIVATION] = "CKM_SHA256_KEY_DERIVATION"; + t[CKM_SHA384_KEY_DERIVATION] = "CKM_SHA384_KEY_DERIVATION"; + t[CKM_SHA512_KEY_DERIVATION] = "CKM_SHA512_KEY_DERIVATION"; + t[CKM_SHA224_KEY_DERIVATION] = "CKM_SHA224_KEY_DERIVATION"; + t[CKM_PBE_MD2_DES_CBC] = "CKM_PBE_MD2_DES_CBC"; + t[CKM_PBE_MD5_DES_CBC] = "CKM_PBE_MD5_DES_CBC"; + t[CKM_PBE_MD5_CAST_CBC] = "CKM_PBE_MD5_CAST_CBC"; + t[CKM_PBE_MD5_CAST3_CBC] = "CKM_PBE_MD5_CAST3_CBC"; + t[CKM_PBE_MD5_CAST128_CBC] = "CKM_PBE_MD5_CAST128_CBC"; + t[CKM_PBE_SHA1_CAST128_CBC] = "CKM_PBE_SHA1_CAST128_CBC"; + t[CKM_PBE_SHA1_RC4_128] = "CKM_PBE_SHA1_RC4_128"; + t[CKM_PBE_SHA1_RC4_40] = "CKM_PBE_SHA1_RC4_40"; + t[CKM_PBE_SHA1_DES3_EDE_CBC] = "CKM_PBE_SHA1_DES3_EDE_CBC"; + t[CKM_PBE_SHA1_DES2_EDE_CBC] = "CKM_PBE_SHA1_DES2_EDE_CBC"; + t[CKM_PBE_SHA1_RC2_128_CBC] = "CKM_PBE_SHA1_RC2_128_CBC"; + t[CKM_PBE_SHA1_RC2_40_CBC] = "CKM_PBE_SHA1_RC2_40_CBC"; + t[CKM_PKCS5_PBKD2] = "CKM_PKCS5_PBKD2"; + t[CKM_PBA_SHA1_WITH_SHA1_HMAC] = "CKM_PBA_SHA1_WITH_SHA1_HMAC"; + t[CKM_WTLS_PRE_MASTER_KEY_GEN] = "CKM_WTLS_PRE_MASTER_KEY_GEN"; + t[CKM_WTLS_MASTER_KEY_DERIVE] = "CKM_WTLS_MASTER_KEY_DERIVE"; + t[CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC] = "CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC"; + t[CKM_WTLS_PRF] = "CKM_WTLS_PRF"; + t[CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE] = "CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE"; + t[CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE] = "CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE"; + t[CKM_TLS10_MAC_SERVER] = "CKM_TLS10_MAC_SERVER"; + t[CKM_TLS10_MAC_CLIENT] = "CKM_TLS10_MAC_CLIENT"; + t[CKM_TLS12_MAC] = "CKM_TLS12_MAC"; + t[CKM_TLS12_KDF] = "CKM_TLS12_KDF"; + t[CKM_TLS12_MASTER_KEY_DERIVE] = "CKM_TLS12_MASTER_KEY_DERIVE"; + t[CKM_TLS12_KEY_AND_MAC_DERIVE] = "CKM_TLS12_KEY_AND_MAC_DERIVE"; + t[CKM_TLS12_MASTER_KEY_DERIVE_DH] = "CKM_TLS12_MASTER_KEY_DERIVE_DH"; + t[CKM_TLS12_KEY_SAFE_DERIVE] = "CKM_TLS12_KEY_SAFE_DERIVE"; + t[CKM_TLS_MAC] = "CKM_TLS_MAC"; + t[CKM_TLS_KDF] = "CKM_TLS_KDF"; + t[CKM_KEY_WRAP_LYNKS] = "CKM_KEY_WRAP_LYNKS"; + t[CKM_KEY_WRAP_SET_OAEP] = "CKM_KEY_WRAP_SET_OAEP"; + t[CKM_CMS_SIG] = "CKM_CMS_SIG"; + t[CKM_KIP_DERIVE] = "CKM_KIP_DERIVE"; + t[CKM_KIP_WRAP] = "CKM_KIP_WRAP"; + t[CKM_KIP_MAC] = "CKM_KIP_MAC"; + t[CKM_CAMELLIA_KEY_GEN] = "CKM_CAMELLIA_KEY_GEN"; + t[CKM_CAMELLIA_ECB] = "CKM_CAMELLIA_ECB"; + t[CKM_CAMELLIA_CBC] = "CKM_CAMELLIA_CBC"; + t[CKM_CAMELLIA_MAC] = "CKM_CAMELLIA_MAC"; + t[CKM_CAMELLIA_MAC_GENERAL] = "CKM_CAMELLIA_MAC_GENERAL"; + t[CKM_CAMELLIA_CBC_PAD] = "CKM_CAMELLIA_CBC_PAD"; + t[CKM_CAMELLIA_ECB_ENCRYPT_DATA] = "CKM_CAMELLIA_ECB_ENCRYPT_DATA"; + t[CKM_CAMELLIA_CBC_ENCRYPT_DATA] = "CKM_CAMELLIA_CBC_ENCRYPT_DATA"; + t[CKM_CAMELLIA_CTR] = "CKM_CAMELLIA_CTR"; + t[CKM_ARIA_KEY_GEN] = "CKM_ARIA_KEY_GEN"; + t[CKM_ARIA_ECB] = "CKM_ARIA_ECB"; + t[CKM_ARIA_CBC] = "CKM_ARIA_CBC"; + t[CKM_ARIA_MAC] = "CKM_ARIA_MAC"; + t[CKM_ARIA_MAC_GENERAL] = "CKM_ARIA_MAC_GENERAL"; + t[CKM_ARIA_CBC_PAD] = "CKM_ARIA_CBC_PAD"; + t[CKM_ARIA_ECB_ENCRYPT_DATA] = "CKM_ARIA_ECB_ENCRYPT_DATA"; + t[CKM_ARIA_CBC_ENCRYPT_DATA] = "CKM_ARIA_CBC_ENCRYPT_DATA"; + t[CKM_SEED_KEY_GEN] = "CKM_SEED_KEY_GEN"; + t[CKM_SEED_ECB] = "CKM_SEED_ECB"; + t[CKM_SEED_CBC] = "CKM_SEED_CBC"; + t[CKM_SEED_MAC] = "CKM_SEED_MAC"; + t[CKM_SEED_MAC_GENERAL] = "CKM_SEED_MAC_GENERAL"; + t[CKM_SEED_CBC_PAD] = "CKM_SEED_CBC_PAD"; + t[CKM_SEED_ECB_ENCRYPT_DATA] = "CKM_SEED_ECB_ENCRYPT_DATA"; + t[CKM_SEED_CBC_ENCRYPT_DATA] = "CKM_SEED_CBC_ENCRYPT_DATA"; + t[CKM_SKIPJACK_KEY_GEN] = "CKM_SKIPJACK_KEY_GEN"; + t[CKM_SKIPJACK_ECB64] = "CKM_SKIPJACK_ECB64"; + t[CKM_SKIPJACK_CBC64] = "CKM_SKIPJACK_CBC64"; + t[CKM_SKIPJACK_OFB64] = "CKM_SKIPJACK_OFB64"; + t[CKM_SKIPJACK_CFB64] = "CKM_SKIPJACK_CFB64"; + t[CKM_SKIPJACK_CFB32] = "CKM_SKIPJACK_CFB32"; + t[CKM_SKIPJACK_CFB16] = "CKM_SKIPJACK_CFB16"; + t[CKM_SKIPJACK_CFB8] = "CKM_SKIPJACK_CFB8"; + t[CKM_SKIPJACK_WRAP] = "CKM_SKIPJACK_WRAP"; + t[CKM_SKIPJACK_PRIVATE_WRAP] = "CKM_SKIPJACK_PRIVATE_WRAP"; + t[CKM_SKIPJACK_RELAYX] = "CKM_SKIPJACK_RELAYX"; + t[CKM_KEA_KEY_PAIR_GEN] = "CKM_KEA_KEY_PAIR_GEN"; + t[CKM_KEA_KEY_DERIVE] = "CKM_KEA_KEY_DERIVE"; + t[CKM_FORTEZZA_TIMESTAMP] = "CKM_FORTEZZA_TIMESTAMP"; + t[CKM_BATON_KEY_GEN] = "CKM_BATON_KEY_GEN"; + t[CKM_BATON_ECB128] = "CKM_BATON_ECB128"; + t[CKM_BATON_ECB96] = "CKM_BATON_ECB96"; + t[CKM_BATON_CBC128] = "CKM_BATON_CBC128"; + t[CKM_BATON_COUNTER] = "CKM_BATON_COUNTER"; + t[CKM_BATON_SHUFFLE] = "CKM_BATON_SHUFFLE"; + t[CKM_BATON_WRAP] = "CKM_BATON_WRAP"; + t[CKM_EC_KEY_PAIR_GEN] = "CKM_EC_KEY_PAIR_GEN"; + t[CKM_ECDSA] = "CKM_ECDSA"; + t[CKM_ECDSA_SHA1] = "CKM_ECDSA_SHA1"; + t[CKM_ECDSA_SHA224] = "CKM_ECDSA_SHA224"; + t[CKM_ECDSA_SHA256] = "CKM_ECDSA_SHA256"; + t[CKM_ECDSA_SHA384] = "CKM_ECDSA_SHA384"; + t[CKM_ECDSA_SHA512] = "CKM_ECDSA_SHA512"; + t[CKM_ECDH1_DERIVE] = "CKM_ECDH1_DERIVE"; + t[CKM_ECDH1_COFACTOR_DERIVE] = "CKM_ECDH1_COFACTOR_DERIVE"; + t[CKM_ECMQV_DERIVE] = "CKM_ECMQV_DERIVE"; + t[CKM_ECDH_AES_KEY_WRAP] = "CKM_ECDH_AES_KEY_WRAP"; + t[CKM_RSA_AES_KEY_WRAP] = "CKM_RSA_AES_KEY_WRAP"; + t[CKM_JUNIPER_KEY_GEN] = "CKM_JUNIPER_KEY_GEN"; + t[CKM_JUNIPER_ECB128] = "CKM_JUNIPER_ECB128"; + t[CKM_JUNIPER_CBC128] = "CKM_JUNIPER_CBC128"; + t[CKM_JUNIPER_COUNTER] = "CKM_JUNIPER_COUNTER"; + t[CKM_JUNIPER_SHUFFLE] = "CKM_JUNIPER_SHUFFLE"; + t[CKM_JUNIPER_WRAP] = "CKM_JUNIPER_WRAP"; + t[CKM_FASTHASH] = "CKM_FASTHASH"; + t[CKM_AES_KEY_GEN] = "CKM_AES_KEY_GEN"; + t[CKM_AES_ECB] = "CKM_AES_ECB"; + t[CKM_AES_CBC] = "CKM_AES_CBC"; + t[CKM_AES_MAC] = "CKM_AES_MAC"; + t[CKM_AES_MAC_GENERAL] = "CKM_AES_MAC_GENERAL"; + t[CKM_AES_CBC_PAD] = "CKM_AES_CBC_PAD"; + t[CKM_AES_CTR] = "CKM_AES_CTR"; + t[CKM_AES_GCM] = "CKM_AES_GCM"; + t[CKM_AES_CCM] = "CKM_AES_CCM"; + t[CKM_AES_CTS] = "CKM_AES_CTS"; + t[CKM_AES_CMAC] = "CKM_AES_CMAC"; + t[CKM_AES_CMAC_GENERAL] = "CKM_AES_CMAC_GENERAL"; + t[CKM_AES_XCBC_MAC] = "CKM_AES_XCBC_MAC"; + t[CKM_AES_XCBC_MAC_96] = "CKM_AES_XCBC_MAC_96"; + t[CKM_AES_GMAC] = "CKM_AES_GMAC"; + t[CKM_BLOWFISH_KEY_GEN] = "CKM_BLOWFISH_KEY_GEN"; + t[CKM_BLOWFISH_CBC] = "CKM_BLOWFISH_CBC"; + t[CKM_TWOFISH_KEY_GEN] = "CKM_TWOFISH_KEY_GEN"; + t[CKM_TWOFISH_CBC] = "CKM_TWOFISH_CBC"; + t[CKM_BLOWFISH_CBC_PAD] = "CKM_BLOWFISH_CBC_PAD"; + t[CKM_TWOFISH_CBC_PAD] = "CKM_TWOFISH_CBC_PAD"; + t[CKM_DES_ECB_ENCRYPT_DATA] = "CKM_DES_ECB_ENCRYPT_DATA"; + t[CKM_DES_CBC_ENCRYPT_DATA] = "CKM_DES_CBC_ENCRYPT_DATA"; + t[CKM_DES3_ECB_ENCRYPT_DATA] = "CKM_DES3_ECB_ENCRYPT_DATA"; + t[CKM_DES3_CBC_ENCRYPT_DATA] = "CKM_DES3_CBC_ENCRYPT_DATA"; + t[CKM_AES_ECB_ENCRYPT_DATA] = "CKM_AES_ECB_ENCRYPT_DATA"; + t[CKM_AES_CBC_ENCRYPT_DATA] = "CKM_AES_CBC_ENCRYPT_DATA"; + t[CKM_GOSTR3410_KEY_PAIR_GEN] = "CKM_GOSTR3410_KEY_PAIR_GEN"; + t[CKM_GOSTR3410] = "CKM_GOSTR3410"; + t[CKM_GOSTR3410_WITH_GOSTR3411] = "CKM_GOSTR3410_WITH_GOSTR3411"; + t[CKM_GOSTR3410_KEY_WRAP] = "CKM_GOSTR3410_KEY_WRAP"; + t[CKM_GOSTR3410_DERIVE] = "CKM_GOSTR3410_DERIVE"; + t[CKM_GOSTR3411] = "CKM_GOSTR3411"; + t[CKM_GOSTR3411_HMAC] = "CKM_GOSTR3411_HMAC"; + t[CKM_GOST28147_KEY_GEN] = "CKM_GOST28147_KEY_GEN"; + t[CKM_GOST28147_ECB] = "CKM_GOST28147_ECB"; + t[CKM_GOST28147] = "CKM_GOST28147"; + t[CKM_GOST28147_MAC] = "CKM_GOST28147_MAC"; + t[CKM_GOST28147_KEY_WRAP] = "CKM_GOST28147_KEY_WRAP"; + t[CKM_DSA_PARAMETER_GEN] = "CKM_DSA_PARAMETER_GEN"; + t[CKM_DH_PKCS_PARAMETER_GEN] = "CKM_DH_PKCS_PARAMETER_GEN"; + t[CKM_X9_42_DH_PARAMETER_GEN] = "CKM_X9_42_DH_PARAMETER_GEN"; + t[CKM_DSA_PROBABLISTIC_PARAMETER_GEN] = "CKM_DSA_PROBABLISTIC_PARAMETER_GEN"; + t[CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN] = "CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN"; + t[CKM_AES_OFB] = "CKM_AES_OFB"; + t[CKM_AES_CFB64] = "CKM_AES_CFB64"; + t[CKM_AES_CFB8] = "CKM_AES_CFB8"; + t[CKM_AES_CFB128] = "CKM_AES_CFB128"; + t[CKM_AES_CFB1] = "CKM_AES_CFB1"; + t[CKM_AES_KEY_WRAP] = "CKM_AES_KEY_WRAP"; + t[CKM_AES_KEY_WRAP_PAD] = "CKM_AES_KEY_WRAP_PAD"; + t[CKM_RSA_PKCS_TPM_1_1] = "CKM_RSA_PKCS_TPM_1_1"; + t[CKM_RSA_PKCS_OAEP_TPM_1_1] = "CKM_RSA_PKCS_OAEP_TPM_1_1"; +} + +void fill_CKO_table(std::map<unsigned long, std::string> &t) +{ + t[CKO_DATA] = "CKO_DATA"; + t[CKO_CERTIFICATE] = "CKO_CERTIFICATE"; + t[CKO_PUBLIC_KEY] = "CKO_PUBLIC_KEY"; + t[CKO_PRIVATE_KEY] = "CKO_PRIVATE_KEY"; + t[CKO_SECRET_KEY] = "CKO_SECRET_KEY"; + t[CKO_HW_FEATURE] = "CKO_HW_FEATURE"; + t[CKO_DOMAIN_PARAMETERS] = "CKO_DOMAIN_PARAMETERS"; + t[CKO_MECHANISM] = "CKO_MECHANISM"; + t[CKO_OTP_KEY] = "CKO_OTP_KEY"; +} + +void fill_CKH_table(std::map<unsigned long, std::string> &t) +{ + t[CKH_MONOTONIC_COUNTER] = "CKH_MONOTONIC_COUNTER"; + t[CKH_CLOCK] = "CKH_CLOCK"; + t[CKH_USER_INTERFACE] = "CKH_USER_INTERFACE"; +} + +void fill_CKK_table(std::map<unsigned long, std::string> &t) +{ + t[CKK_RSA] = "CKK_RSA"; + t[CKK_DSA] = "CKK_DSA"; + t[CKK_DH] = "CKK_DH"; + t[CKK_EC] = "CKK_EC"; + t[CKK_X9_42_DH] = "CKK_X9_42_DH"; + t[CKK_KEA] = "CKK_KEA"; + t[CKK_GENERIC_SECRET] = "CKK_GENERIC_SECRET"; + t[CKK_RC2] = "CKK_RC2"; + t[CKK_RC4] = "CKK_RC4"; + t[CKK_DES] = "CKK_DES"; + t[CKK_DES2] = "CKK_DES2"; + t[CKK_DES3] = "CKK_DES3"; + t[CKK_CAST] = "CKK_CAST"; + t[CKK_CAST3] = "CKK_CAST3"; + t[CKK_CAST128] = "CKK_CAST128"; + t[CKK_RC5] = "CKK_RC5"; + t[CKK_IDEA] = "CKK_IDEA"; + t[CKK_SKIPJACK] = "CKK_SKIPJACK"; + t[CKK_BATON] = "CKK_BATON"; + t[CKK_JUNIPER] = "CKK_JUNIPER"; + t[CKK_CDMF] = "CKK_CDMF"; + t[CKK_AES] = "CKK_AES"; + t[CKK_BLOWFISH] = "CKK_BLOWFISH"; + t[CKK_TWOFISH] = "CKK_TWOFISH"; + t[CKK_SECURID] = "CKK_SECURID"; + t[CKK_HOTP] = "CKK_HOTP"; + t[CKK_ACTI] = "CKK_ACTI"; + t[CKK_CAMELLIA] = "CKK_CAMELLIA"; + t[CKK_ARIA] = "CKK_ARIA"; + t[CKK_MD5_HMAC] = "CKK_MD5_HMAC"; + t[CKK_SHA_1_HMAC] = "CKK_SHA_1_HMAC"; + t[CKK_RIPEMD128_HMAC] = "CKK_RIPEMD128_HMAC"; + t[CKK_RIPEMD160_HMAC] = "CKK_RIPEMD160_HMAC"; + t[CKK_SHA256_HMAC] = "CKK_SHA256_HMAC"; + t[CKK_SHA384_HMAC] = "CKK_SHA384_HMAC"; + t[CKK_SHA512_HMAC] = "CKK_SHA512_HMAC"; + t[CKK_SHA224_HMAC] = "CKK_SHA224_HMAC"; + t[CKK_SEED] = "CKK_SEED"; + t[CKK_GOSTR3410] = "CKK_GOSTR3410"; + t[CKK_GOSTR3411] = "CKK_GOSTR3411"; + t[CKK_GOST28147] = "CKK_GOST28147"; +} + +void fill_CKC_table(std::map<unsigned long, std::string> &t) +{ + t[CKC_X_509] = "CKC_X_509"; + t[CKC_X_509_ATTR_CERT] = "CKC_X_509_ATTR_CERT"; + t[CKC_WTLS] = "CKC_WTLS"; + t[CKC_OPENPGP] = "CKC_OPENPGP"; +} + +#endif // !_SOFTHSM_V2_TABLES_H |