Initial sshsm project structure

Issue-ID: AAF-94
Change-Id: I5e82fff418e7567b161acf9b98013a9b85ffc5b4
Signed-off-by: NingSun <ning.sun@intel.com>

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