deactivation routine to call EVP_cleanup

sjlombardo · sjlombardo · commit 9a6807e1b600 · 2012-10-02T11:55:07.000-04:00
diff --git a/src/crypto.c b/src/crypto.c
@@ -205,21 +205,23 @@ void sqlite3FreeCodecArg(void *pCodecArg) {
   codec_ctx *ctx = (codec_ctx *) pCodecArg;
   if(pCodecArg == NULL) return;
   sqlcipher_codec_ctx_free(&ctx); // wipe and free allocated memory for the context 
+  sqlcipher_deactivate(); /* cleanup related structures, OpenSSL etc, when codec is detatched */
 }
 
 int sqlite3CodecAttach(sqlite3* db, int nDb, const void *zKey, int nKey) {
   struct Db *pDb = &db->aDb[nDb];
 
   CODEC_TRACE(("sqlite3CodecAttach: entered nDb=%d zKey=%s, nKey=%d\n", nDb, (char *)zKey, nKey));
 
-  sqlcipher_activate();
 
   if(nKey && zKey && pDb->pBt) {
     int rc;
     Pager *pPager = pDb->pBt->pBt->pPager;
     sqlite3_file *fd = sqlite3Pager_get_fd(pPager);
     codec_ctx *ctx;
 
+    sqlcipher_activate(); /* perform internal initialization for sqlcipher */
+
     /* point the internal codec argument against the contet to be prepared */
     rc = sqlcipher_codec_ctx_init(&ctx, pDb, pDb->pBt->pBt->pPager, fd, zKey, nKey); 
 
@@ -272,7 +274,6 @@ int sqlite3_key(sqlite3 *db, const void *pKey, int nKey) {
 */
 int sqlite3_rekey(sqlite3 *db, const void *pKey, int nKey) {
   CODEC_TRACE(("sqlite3_rekey: entered db=%p pKey=%s, nKey=%d\n", db, (char *)pKey, nKey));
-  sqlcipher_activate();
   if(db && pKey && nKey) {
     struct Db *pDb = &db->aDb[0];
     CODEC_TRACE(("sqlite3_rekey: database pDb=%p\n", pDb));
diff --git a/src/crypto.h b/src/crypto.h
@@ -146,6 +146,7 @@ void sqlcipher_free(void *, int);
 
 /* activation and initialization */
 void sqlcipher_activate();
+void sqlcipher_deactivate();
 int sqlcipher_codec_ctx_init(codec_ctx **, Db *, Pager *, sqlite3_file *, const void *, int);
 void sqlcipher_codec_ctx_free(codec_ctx **);
 int sqlcipher_codec_key_derive(codec_ctx *);
diff --git a/src/crypto_impl.c b/src/crypto_impl.c
@@ -81,6 +81,9 @@ int sqlcipher_page_hmac(cipher_ctx *, Pgno, unsigned char *, int, unsigned char
 
 static unsigned int default_flags = DEFAULT_CIPHER_FLAGS;
 
+static unsigned int openssl_external_init = 0;
+static unsigned int openssl_init_count = 0;
+
 struct codec_ctx {
   int kdf_salt_sz;
   int page_sz;
@@ -94,12 +97,40 @@ struct codec_ctx {
 
 void sqlcipher_activate() {
   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
-  if(EVP_get_cipherbyname(CIPHER) == NULL) {
-    OpenSSL_add_all_algorithms();
+
+  /* we'll initialize openssl and increment the internal init counter
+     but only if it hasn't been initalized outside of SQLCipher by this program 
+     e.g. on startup */
+  if(openssl_init_count == 0 && EVP_get_cipherbyname(CIPHER) != NULL) {
+    openssl_external_init = 1;
+  }
+
+  if(openssl_external_init == 0) {
+    if(openssl_init_count == 0)  {
+      OpenSSL_add_all_algorithms();
+    }
+    openssl_init_count++; 
   } 
   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
 }
 
+void sqlcipher_deactivate() {
+  sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
+  /* If it is initialized externally, then the init counter should never be greater than zero.
+     This should prevent SQLCipher from "cleaning up" openssl 
+     when something else in the program might be using it. */
+  if(openssl_external_init == 0) {
+    openssl_init_count--;
+    /* if the counter reaches zero after it's decremented release EVP memory
+       Note: this code will only be reached if OpensSSL_add_all_algorithms()
+       is called by SQLCipher internally. */
+    if(openssl_init_count == 0) {
+      EVP_cleanup();
+    }
+  }
+  sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
+}
+
 /* fixed time zero memory check tests every position of a memory segement
    matches a single value (i.e. the memory is all zeros)*/
 int sqlcipher_ismemset(const unsigned char *a0, unsigned char value, int len) {
