diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/tls/sessions_sqlite/info.txt | 7 | ||||
| -rw-r--r-- | src/tls/sessions_sqlite/tls_sqlite_sess_mgr.cpp | 187 | ||||
| -rw-r--r-- | src/tls/sessions_sqlite/tls_sqlite_sess_mgr.h | 6 | ||||
| -rw-r--r-- | src/utils/sqlite/info.txt | 14 | ||||
| -rw-r--r-- | src/utils/sqlite/sqlite.cpp | 138 | ||||
| -rw-r--r-- | src/utils/sqlite/sqlite.h | 68 |
6 files changed, 253 insertions, 167 deletions
diff --git a/src/tls/sessions_sqlite/info.txt b/src/tls/sessions_sqlite/info.txt index c5fc35952..5761d53ea 100644 --- a/src/tls/sessions_sqlite/info.txt +++ b/src/tls/sessions_sqlite/info.txt @@ -1,11 +1,6 @@ define TLS_SQLITE_SESSION_MANAGER -load_on request - -<libs> -all -> sqlite3 -</libs> - <requires> pbkdf2 +sqlite </requires> diff --git a/src/tls/sessions_sqlite/tls_sqlite_sess_mgr.cpp b/src/tls/sessions_sqlite/tls_sqlite_sess_mgr.cpp index 24efa74f3..dcfc79ed2 100644 --- a/src/tls/sessions_sqlite/tls_sqlite_sess_mgr.cpp +++ b/src/tls/sessions_sqlite/tls_sqlite_sess_mgr.cpp @@ -4,8 +4,9 @@ * * Released under the terms of the Botan license */ - + #include <botan/tls_sqlite_sess_mgr.h> +#include <botan/internal/sqlite.h> #include <botan/internal/assert.h> #include <botan/lookup.h> #include <botan/hex.h> @@ -13,122 +14,10 @@ #include <memory> #include <chrono> -#include <sqlite3.h> - namespace Botan { namespace TLS { -namespace { - -class sqlite3_statement - { - public: - sqlite3_statement(sqlite3* db, const std::string& base_sql) - { - int rc = sqlite3_prepare_v2(db, base_sql.c_str(), -1, &m_stmt, 0); - - if(rc != SQLITE_OK) - throw std::runtime_error("sqlite3_prepare failed " + base_sql + - ", code " + std::to_string(rc)); - } - - void bind(int column, const std::string& val) - { - int rc = sqlite3_bind_text(m_stmt, column, val.c_str(), -1, SQLITE_TRANSIENT); - if(rc != SQLITE_OK) - throw std::runtime_error("sqlite3_bind_text failed, code " + std::to_string(rc)); - } - - void bind(int column, int val) - { - int rc = sqlite3_bind_int(m_stmt, column, val); - if(rc != SQLITE_OK) - throw std::runtime_error("sqlite3_bind_int failed, code " + std::to_string(rc)); - } - - void bind(int column, std::chrono::system_clock::time_point time) - { - const int timeval = std::chrono::duration_cast<std::chrono::seconds>(time.time_since_epoch()).count(); - bind(column, timeval); - } - - void bind(int column, const std::vector<byte>& val) - { - int rc = sqlite3_bind_blob(m_stmt, column, &val[0], val.size(), SQLITE_TRANSIENT); - if(rc != SQLITE_OK) - throw std::runtime_error("sqlite3_bind_text failed, code " + std::to_string(rc)); - } - - std::pair<const byte*, size_t> get_blob(int column) - { - BOTAN_ASSERT(sqlite3_column_type(m_stmt, 0) == SQLITE_BLOB, - "Return value is a blob"); - - const void* session_blob = sqlite3_column_blob(m_stmt, column); - const int session_blob_size = sqlite3_column_bytes(m_stmt, column); - - BOTAN_ASSERT(session_blob_size >= 0, "Blob size is non-negative"); - - return std::make_pair(static_cast<const byte*>(session_blob), - static_cast<size_t>(session_blob_size)); - } - - size_t get_size_t(int column) - { - BOTAN_ASSERT(sqlite3_column_type(m_stmt, column) == SQLITE_INTEGER, - "Return count is an integer"); - - const int sessions_int = sqlite3_column_int(m_stmt, column); - - BOTAN_ASSERT(sessions_int >= 0, "Expected size_t is non-negative"); - - return static_cast<size_t>(sessions_int); - } - - void spin() - { - while(sqlite3_step(m_stmt) == SQLITE_ROW) - {} - } - - int step() - { - return sqlite3_step(m_stmt); - } - - sqlite3_stmt* stmt() { return m_stmt; } - - ~sqlite3_statement() { sqlite3_finalize(m_stmt); } - private: - sqlite3_stmt* m_stmt; - }; - -size_t row_count(sqlite3* db, const std::string& table_name) - { - sqlite3_statement stmt(db, "select count(*) from " + table_name); - - if(stmt.step() == SQLITE_ROW) - return stmt.get_size_t(0); - else - throw std::runtime_error("Querying size of table " + table_name + " failed"); - } - -void create_table(sqlite3* db, const char* table_schema) - { - char* errmsg = 0; - int rc = sqlite3_exec(db, table_schema, 0, 0, &errmsg); - - if(rc != SQLITE_OK) - { - const std::string err_msg = errmsg; - sqlite3_free(errmsg); - sqlite3_close(db); - throw std::runtime_error("sqlite3_exec for table failed - " + err_msg); - } - } - - SymmetricKey derive_key(const std::string& passphrase, const byte salt[], size_t salt_len, @@ -146,8 +35,6 @@ SymmetricKey derive_key(const std::string& passphrase, return SymmetricKey(&x[3], x.size() - 3); } -} - Session_Manager_SQLite::Session_Manager_SQLite(const std::string& passphrase, RandomNumberGenerator& rng, const std::string& db_filename, @@ -157,42 +44,34 @@ Session_Manager_SQLite::Session_Manager_SQLite(const std::string& passphrase, m_max_sessions(max_sessions), m_session_lifetime(session_lifetime) { - int rc = sqlite3_open(db_filename.c_str(), &m_db); - - if(rc) - { - const std::string err_msg = sqlite3_errmsg(m_db); - sqlite3_close(m_db); - throw std::runtime_error("sqlite3_open failed - " + err_msg); - } - - create_table(m_db, - "create table if not exists tls_sessions " - "(" - "session_id TEXT PRIMARY KEY, " - "session_start INTEGER, " - "hostname TEXT, " - "hostport INTEGER, " - "session BLOB" - ")"); - - create_table(m_db, - "create table if not exists tls_sessions_metadata " - "(" - "passphrase_salt BLOB, " - "passphrase_iterations INTEGER, " - "passphrase_check INTEGER " - ")"); - - const size_t salts = row_count(m_db, "tls_sessions_metadata"); + m_db = new sqlite3_database(db_filename); + + m_db->create_table( + "create table if not exists tls_sessions " + "(" + "session_id TEXT PRIMARY KEY, " + "session_start INTEGER, " + "hostname TEXT, " + "hostport INTEGER, " + "session BLOB" + ")"); + + m_db->create_table( + "create table if not exists tls_sessions_metadata " + "(" + "passphrase_salt BLOB, " + "passphrase_iterations INTEGER, " + "passphrase_check INTEGER " + ")"); + + const size_t salts = m_db->row_count("tls_sessions_metadata"); if(salts == 1) { // existing db sqlite3_statement stmt(m_db, "select * from tls_sessions_metadata"); - int rc = stmt.step(); - if(rc == SQLITE_ROW) + if(stmt.step()) { std::pair<const byte*, size_t> salt = stmt.get_blob(0); const size_t iterations = stmt.get_size_t(1); @@ -218,7 +97,7 @@ Session_Manager_SQLite::Session_Manager_SQLite(const std::string& passphrase, // new database case std::vector<byte> salt = unlock(rng.random_vec(16)); - const size_t iterations = 64 * 1024; + const size_t iterations = 256 * 1024; size_t check_val = 0; m_session_key = derive_key(passphrase, &salt[0], salt.size(), @@ -237,7 +116,7 @@ Session_Manager_SQLite::Session_Manager_SQLite(const std::string& passphrase, Session_Manager_SQLite::~Session_Manager_SQLite() { - sqlite3_close(m_db); + delete m_db; } bool Session_Manager_SQLite::load_from_session_id(const std::vector<byte>& session_id, @@ -247,9 +126,7 @@ bool Session_Manager_SQLite::load_from_session_id(const std::vector<byte>& sessi stmt.bind(1, hex_encode(session_id)); - int rc = stmt.step(); - - while(rc == SQLITE_ROW) + while(stmt.step()) { std::pair<const byte*, size_t> blob = stmt.get_blob(0); @@ -261,8 +138,6 @@ bool Session_Manager_SQLite::load_from_session_id(const std::vector<byte>& sessi catch(...) { } - - rc = stmt.step(); } return false; @@ -279,9 +154,7 @@ bool Session_Manager_SQLite::load_from_host_info(const std::string& hostname, stmt.bind(1, hostname); stmt.bind(2, port); - int rc = stmt.step(); - - while(rc == SQLITE_ROW) + while(stmt.step()) { std::pair<const byte*, size_t> blob = stmt.get_blob(0); @@ -293,8 +166,6 @@ bool Session_Manager_SQLite::load_from_host_info(const std::string& hostname, catch(...) { } - - rc = stmt.step(); } return false; @@ -333,7 +204,7 @@ void Session_Manager_SQLite::prune_session_cache() remove_expired.spin(); - const size_t sessions = row_count(m_db, "tls_sessions"); + const size_t sessions = m_db->row_count("tls_sessions"); if(sessions > m_max_sessions) { diff --git a/src/tls/sessions_sqlite/tls_sqlite_sess_mgr.h b/src/tls/sessions_sqlite/tls_sqlite_sess_mgr.h index 923915496..1bcf88892 100644 --- a/src/tls/sessions_sqlite/tls_sqlite_sess_mgr.h +++ b/src/tls/sessions_sqlite/tls_sqlite_sess_mgr.h @@ -11,10 +11,10 @@ #include <botan/tls_session_manager.h> #include <botan/rng.h> -class sqlite3; - namespace Botan { +class sqlite3_database; + namespace TLS { /** @@ -61,7 +61,7 @@ class BOTAN_DLL Session_Manager_SQLite : public Session_Manager RandomNumberGenerator& m_rng; size_t m_max_sessions; std::chrono::seconds m_session_lifetime; - class sqlite3* m_db; + sqlite3_database* m_db; }; } diff --git a/src/utils/sqlite/info.txt b/src/utils/sqlite/info.txt new file mode 100644 index 000000000..9b2fe575d --- /dev/null +++ b/src/utils/sqlite/info.txt @@ -0,0 +1,14 @@ + +load_on request + +<libs> +all -> sqlite3 +</libs> + +<header:internal> +sqlite.h +</header:internal> + +<source> +sqlite.cpp +</source> diff --git a/src/utils/sqlite/sqlite.cpp b/src/utils/sqlite/sqlite.cpp new file mode 100644 index 000000000..b78112e28 --- /dev/null +++ b/src/utils/sqlite/sqlite.cpp @@ -0,0 +1,138 @@ +/* +* SQLite wrapper +* (C) 2012 Jack Lloyd +* +* Released under the terms of the Botan license +*/ + +#include <botan/internal/sqlite.h> +#include <botan/internal/assert.h> +#include <stdexcept> +#include <sqlite3.h> + +namespace Botan { + +sqlite3_database::sqlite3_database(const std::string& db_filename) + { + int rc = ::sqlite3_open(db_filename.c_str(), &m_db); + + if(rc) + { + const std::string err_msg = ::sqlite3_errmsg(m_db); + ::sqlite3_close(m_db); + m_db = nullptr; + throw std::runtime_error("sqlite3_open failed - " + err_msg); + } + } + +sqlite3_database::~sqlite3_database() + { + if(m_db) + ::sqlite3_close(m_db); + m_db = nullptr; + } + +size_t sqlite3_database::row_count(const std::string& table_name) + { + sqlite3_statement stmt(this, "select count(*) from " + table_name); + + if(stmt.step()) + return stmt.get_size_t(0); + else + throw std::runtime_error("Querying size of table " + table_name + " failed"); + } + +void sqlite3_database::create_table(const std::string& table_schema) + { + char* errmsg = 0; + int rc = ::sqlite3_exec(m_db, table_schema.c_str(), 0, 0, &errmsg); + + if(rc != SQLITE_OK) + { + const std::string err_msg = errmsg; + ::sqlite3_free(errmsg); + ::sqlite3_close(m_db); + m_db = nullptr; + throw std::runtime_error("sqlite3_exec for table failed - " + err_msg); + } + } + + +sqlite3_statement::sqlite3_statement(sqlite3_database* db, const std::string& base_sql) + { + int rc = ::sqlite3_prepare_v2(db->m_db, base_sql.c_str(), -1, &m_stmt, 0); + + if(rc != SQLITE_OK) + throw std::runtime_error("sqlite3_prepare failed " + base_sql + + ", code " + std::to_string(rc)); + } + +void sqlite3_statement::bind(int column, const std::string& val) + { + int rc = ::sqlite3_bind_text(m_stmt, column, val.c_str(), -1, SQLITE_TRANSIENT); + if(rc != SQLITE_OK) + throw std::runtime_error("sqlite3_bind_text failed, code " + std::to_string(rc)); + } + +void sqlite3_statement::bind(int column, int val) + { + int rc = ::sqlite3_bind_int(m_stmt, column, val); + if(rc != SQLITE_OK) + throw std::runtime_error("sqlite3_bind_int failed, code " + std::to_string(rc)); + } + +void sqlite3_statement::bind(int column, std::chrono::system_clock::time_point time) + { + const int timeval = std::chrono::duration_cast<std::chrono::seconds>(time.time_since_epoch()).count(); + bind(column, timeval); + } + +void sqlite3_statement::bind(int column, const std::vector<byte>& val) + { + int rc = ::sqlite3_bind_blob(m_stmt, column, &val[0], val.size(), SQLITE_TRANSIENT); + if(rc != SQLITE_OK) + throw std::runtime_error("sqlite3_bind_text failed, code " + std::to_string(rc)); + } + +std::pair<const byte*, size_t> sqlite3_statement::get_blob(int column) + { + BOTAN_ASSERT(::sqlite3_column_type(m_stmt, 0) == SQLITE_BLOB, + "Return value is a blob"); + + const void* session_blob = ::sqlite3_column_blob(m_stmt, column); + const int session_blob_size = ::sqlite3_column_bytes(m_stmt, column); + + BOTAN_ASSERT(session_blob_size >= 0, "Blob size is non-negative"); + + return std::make_pair(static_cast<const byte*>(session_blob), + static_cast<size_t>(session_blob_size)); + } + +size_t sqlite3_statement::get_size_t(int column) + { + BOTAN_ASSERT(::sqlite3_column_type(m_stmt, column) == SQLITE_INTEGER, + "Return count is an integer"); + + const int sessions_int = ::sqlite3_column_int(m_stmt, column); + + BOTAN_ASSERT(sessions_int >= 0, "Expected size_t is non-negative"); + + return static_cast<size_t>(sessions_int); + } + +void sqlite3_statement::spin() + { + while(step()) {} + } + +bool sqlite3_statement::step() + { + return (::sqlite3_step(m_stmt) == SQLITE_ROW); + } + +sqlite3_statement::~sqlite3_statement() + { + ::sqlite3_finalize(m_stmt); + } + +} diff --git a/src/utils/sqlite/sqlite.h b/src/utils/sqlite/sqlite.h new file mode 100644 index 000000000..aef04ab4d --- /dev/null +++ b/src/utils/sqlite/sqlite.h @@ -0,0 +1,68 @@ +/* +* SQLite wrapper +* (C) 2012 Jack Lloyd +* +* Released under the terms of the Botan license +*/ + +#ifndef BOTAN_UTILS_SQLITE_WRAPPER_H__ +#define BOTAN_UTILS_SQLITE_WRAPPER_H__ + +#include <botan/types.h> +#include <string> +#include <chrono> +#include <vector> + +class sqlite3; +class sqlite3_stmt; + +namespace Botan { + +class sqlite3_database + { + public: + sqlite3_database(const std::string& file); + + ~sqlite3_database(); + + size_t row_count(const std::string& table_name); + + void create_table(const std::string& table_schema); + private: + friend class sqlite3_statement; + + sqlite3* m_db; + }; + +class sqlite3_statement + { + public: + sqlite3_statement(sqlite3_database* db, + const std::string& base_sql); + + void bind(int column, const std::string& val); + + void bind(int column, int val); + + void bind(int column, std::chrono::system_clock::time_point time); + + void bind(int column, const std::vector<byte>& val); + + std::pair<const byte*, size_t> get_blob(int column); + + size_t get_size_t(int column); + + void spin(); + + bool step(); + + sqlite3_stmt* stmt() { return m_stmt; } + + ~sqlite3_statement(); + private: + sqlite3_stmt* m_stmt; + }; + +} + +#endif |