#ifdef SQLITE_HAS_CODEC

#include "sqliteInt.h"

#include "btreeInt.h"

#include "sqlcipher.h"

#include "crypto.h"

#ifndef OMIT_MEMLOCK

#if defined(__unix__) || defined(__APPLE__)

#include <sys/mman.h>

#elif defined(_WIN32)

# include <windows.h>

typedef struct {

int derive_key;

int kdf_iter;

int fast_kdf_iter;

int key_sz;

int iv_sz;

int block_sz;

int pass_sz;

int reserve_sz;

int hmac_sz;

int keyspec_sz;

unsigned int flags;

unsigned char *key;

unsigned char *hmac_key;

char *pass;

char *keyspec;

sqlcipher_provider *provider;

void *provider_ctx;

} cipher_ctx;

static unsigned int default_flags = DEFAULT_CIPHER_FLAGS;

static unsigned char hmac_salt_mask = HMAC_SALT_MASK;

static int default_kdf_iter = PBKDF2_ITER;

static unsigned int sqlcipher_activate_count = 0;

static sqlite3_mutex* sqlcipher_provider_mutex = NULL;

static sqlcipher_provider *default_provider = NULL;

struct codec_ctx {

};

int sqlcipher_register_provider(sqlcipher_provider *p) {

sqlite3_mutex_enter(sqlcipher_provider_mutex);

if(default_provider != NULL && default_provider != p) {

/* only free the current registerd provider if it has been initialized

sqlcipher_free(default_provider, sizeof(sqlcipher_provider));

}

default_provider = p;

sqlite3_mutex_leave(sqlcipher_provider_mutex);

return SQLITE_OK;

}

sqlcipher_provider* sqlcipher_get_provider() {

return default_provider;

}

void sqlcipher_activate() {

sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));

if(sqlcipher_provider_mutex == NULL) {

/* allocate a new mutex to guard access to the provider */

sqlcipher_provider_mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);

}

/* check to see if there is a provider registered at this point

if(sqlcipher_get_provider() == NULL) {

sqlcipher_provider *p = sqlcipher_malloc(sizeof(sqlcipher_provider));

#if defined (SQLCIPHER_CRYPTO_CC)

extern int sqlcipher_cc_setup(sqlcipher_provider *p);

sqlcipher_cc_setup(p);

#elif defined (SQLCIPHER_CRYPTO_LIBTOMCRYPT)

extern int sqlcipher_ltc_setup(sqlcipher_provider *p);

sqlcipher_ltc_setup(p);

#elif defined (SQLCIPHER_CRYPTO_OPENSSL)

extern int sqlcipher_openssl_setup(sqlcipher_provider *p);

sqlcipher_openssl_setup(p);

#error "NO DEFAULT SQLCIPHER CRYPTO PROVIDER DEFINED"

sqlcipher_register_provider(p);

}

sqlcipher_activate_count++; /* increment activation count */

sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));

}

void sqlcipher_deactivate() {

sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));

sqlcipher_activate_count--;

/* if no connections are using sqlcipher, cleanup globals */

if(sqlcipher_activate_count < 1) {

sqlite3_mutex_enter(sqlcipher_provider_mutex);

if(default_provider != NULL) {

sqlcipher_free(default_provider, sizeof(sqlcipher_provider));

default_provider = NULL;

}

sqlite3_mutex_leave(sqlcipher_provider_mutex);

/* last connection closed, free provider mutex*/

sqlite3_mutex_free(sqlcipher_provider_mutex);

sqlcipher_provider_mutex = NULL;

sqlcipher_activate_count = 0; /* reset activation count */

}

sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));

}

void* sqlcipher_memset(void *v, unsigned char value, int len) {

int i = 0;

volatile unsigned char *a = v;

if (v == NULL) return v;

for(i = 0; i < len; i++) {

a[i] = value;

}

return v;

}

int sqlcipher_ismemset(const void *v, unsigned char value, int len) {

const unsigned char *a = v;

int i = 0, result = 0;

for(i = 0; i < len; i++) {

result |= a[i] ^ value;

}

return (result != 0);

}

int sqlcipher_memcmp(const void *v0, const void *v1, int len) {

const unsigned char *a0 = v0, *a1 = v1;

int i = 0, result = 0;

for(i = 0; i < len; i++) {

result |= a0[i] ^ a1[i];

}

return (result != 0);

}

void sqlcipher_free(void *ptr, int sz) {

if(ptr) {

if(sz > 0) {

sqlcipher_memset(ptr, 0, sz);

#ifndef OMIT_MEMLOCK

#if defined(__unix__) || defined(__APPLE__)

munlock(ptr, sz);

#elif defined(_WIN32)

VirtualUnlock(ptr, sz);

}

sqlite3_free(ptr);

}

}

void* sqlcipher_malloc(int sz) {

void *ptr = sqlite3Malloc(sz);

sqlcipher_memset(ptr, 0, sz);

#ifndef OMIT_MEMLOCK

if(ptr) {

#if defined(__unix__) || defined(__APPLE__)

mlock(ptr, sz);

#elif defined(_WIN32)

VirtualLock(ptr, sz);

}

return ptr;

}

static int sqlcipher_cipher_ctx_init(cipher_ctx **iCtx) {

int rc;

cipher_ctx *ctx;

*iCtx = (cipher_ctx *) sqlcipher_malloc(sizeof(cipher_ctx));

ctx = *iCtx;

if(ctx == NULL) return SQLITE_NOMEM;

ctx->provider = (sqlcipher_provider *) sqlcipher_malloc(sizeof(sqlcipher_provider));

if(ctx->provider == NULL) return SQLITE_NOMEM;

/* make a copy of the provider to be used for the duration of the context */

sqlite3_mutex_enter(sqlcipher_provider_mutex);

memcpy(ctx->provider, default_provider, sizeof(sqlcipher_provider));

sqlite3_mutex_leave(sqlcipher_provider_mutex);

if((rc = ctx->provider->ctx_init(&ctx->provider_ctx)) != SQLITE_OK) return rc;

ctx->key = (unsigned char *) sqlcipher_malloc(CIPHER_MAX_KEY_SZ);

ctx->hmac_key = (unsigned char *) sqlcipher_malloc(CIPHER_MAX_KEY_SZ);

if(ctx->key == NULL) return SQLITE_NOMEM;

if(ctx->hmac_key == NULL) return SQLITE_NOMEM;

/* setup default flags */

ctx->flags = default_flags;

return SQLITE_OK;

}

static void sqlcipher_cipher_ctx_free(cipher_ctx **iCtx) {

cipher_ctx *ctx = *iCtx;

CODEC_TRACE(("cipher_ctx_free: entered iCtx=%p\n", iCtx));

ctx->provider->ctx_free(&ctx->provider_ctx);

sqlcipher_free(ctx->provider, sizeof(sqlcipher_provider));

sqlcipher_free(ctx->key, ctx->key_sz);

sqlcipher_free(ctx->hmac_key, ctx->key_sz);

sqlcipher_free(ctx->pass, ctx->pass_sz);

sqlcipher_free(ctx->keyspec, ctx->keyspec_sz);

sqlcipher_free(ctx, sizeof(cipher_ctx));

}

static int sqlcipher_cipher_ctx_cmp(cipher_ctx *c1, cipher_ctx *c2) {

CODEC_TRACE(("sqlcipher_cipher_ctx_cmp: entered c1=%p c2=%p\n", c1, c2));

if(

c1->iv_sz == c2->iv_sz

&& c1->kdf_iter == c2->kdf_iter

&& c1->fast_kdf_iter == c2->fast_kdf_iter

&& c1->key_sz == c2->key_sz

&& c1->pass_sz == c2->pass_sz

&& c1->flags == c2->flags

&& c1->hmac_sz == c2->hmac_sz

&& c1->provider->ctx_cmp(c1->provider_ctx, c2->provider_ctx)

&& (

c1->pass == c2->pass

|| !sqlcipher_memcmp((const unsigned char*)c1->pass,

(const unsigned char*)c2->pass,

c1->pass_sz)

)

) return 0;

return 1;

}

static int sqlcipher_cipher_ctx_copy(cipher_ctx *target, cipher_ctx *source) {

void *key = target->key;

void *hmac_key = target->hmac_key;

void *provider = target->provider;

void *provider_ctx = target->provider_ctx;

CODEC_TRACE(("sqlcipher_cipher_ctx_copy: entered target=%p, source=%p\n", target, source));

sqlcipher_free(target->pass, target->pass_sz);

sqlcipher_free(target->keyspec, target->keyspec_sz);

memcpy(target, source, sizeof(cipher_ctx));

target->key = key; //restore pointer to previously allocated key data

memcpy(target->key, source->key, CIPHER_MAX_KEY_SZ);

target->hmac_key = hmac_key; //restore pointer to previously allocated hmac key data

memcpy(target->hmac_key, source->hmac_key, CIPHER_MAX_KEY_SZ);

target->provider = provider; // restore pointer to previouly allocated provider;

memcpy(target->provider, source->provider, sizeof(sqlcipher_provider));

target->provider_ctx = provider_ctx; // restore pointer to previouly allocated provider context;

target->provider->ctx_copy(target->provider_ctx, source->provider_ctx);

if(source->pass && source->pass_sz) {

target->pass = sqlcipher_malloc(source->pass_sz);

if(target->pass == NULL) return SQLITE_NOMEM;

memcpy(target->pass, source->pass, source->pass_sz);

}

if(source->keyspec && source->keyspec_sz) {

target->keyspec = sqlcipher_malloc(source->keyspec_sz);

if(target->keyspec == NULL) return SQLITE_NOMEM;

memcpy(target->keyspec, source->keyspec, source->keyspec_sz);

}

return SQLITE_OK;

}

static int sqlcipher_cipher_ctx_set_keyspec(cipher_ctx *ctx, const unsigned char *key, int key_sz, const unsigned char *salt, int salt_sz) {

/* free, zero existing pointers and size */

sqlcipher_free(ctx->keyspec, ctx->keyspec_sz);

ctx->keyspec = NULL;

ctx->keyspec_sz = 0;

/* establic a hex-formated key specification, containing the raw encryption key and

ctx->keyspec_sz = ((key_sz + salt_sz) * 2) + 3;

ctx->keyspec = sqlcipher_malloc(ctx->keyspec_sz);

if(ctx->keyspec == NULL) return SQLITE_NOMEM;

ctx->keyspec[0] = 'x';

ctx->keyspec[1] = '\'';

cipher_bin2hex(key, key_sz, ctx->keyspec + 2);

cipher_bin2hex(salt, salt_sz, ctx->keyspec + (key_sz * 2) + 2);

ctx->keyspec[ctx->keyspec_sz - 1] = '\'';

return SQLITE_OK;

}

static int sqlcipher_cipher_ctx_set_pass(cipher_ctx *ctx, const void *zKey, int nKey) {

/* free, zero existing pointers and size */

sqlcipher_free(ctx->pass, ctx->pass_sz);

ctx->pass = NULL;

ctx->pass_sz = 0;

if(zKey && nKey) { /* if new password is provided, copy it */

ctx->pass_sz = nKey;

ctx->pass = sqlcipher_malloc(nKey);

if(ctx->pass == NULL) return SQLITE_NOMEM;

memcpy(ctx->pass, zKey, nKey);

}

return SQLITE_OK;

}

int sqlcipher_codec_ctx_set_pass(codec_ctx *ctx, const void *zKey, int nKey, int for_ctx) {

cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;

int rc;

if((rc = sqlcipher_cipher_ctx_set_pass(c_ctx, zKey, nKey)) != SQLITE_OK) return rc;

c_ctx->derive_key = 1;

if(for_ctx == 2)

if((rc = sqlcipher_cipher_ctx_copy( for_ctx ? ctx->read_ctx : ctx->write_ctx, c_ctx)) != SQLITE_OK)

return rc;

return SQLITE_OK;

}

int sqlcipher_codec_ctx_set_cipher(codec_ctx *ctx, const char *cipher_name, int for_ctx) {

cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;

int rc;

c_ctx->provider->set_cipher(c_ctx->provider_ctx, cipher_name);

c_ctx->key_sz = c_ctx->provider->get_key_sz(c_ctx->provider_ctx);

c_ctx->iv_sz = c_ctx->provider->get_iv_sz(c_ctx->provider_ctx);

c_ctx->block_sz = c_ctx->provider->get_block_sz(c_ctx->provider_ctx);

c_ctx->hmac_sz = c_ctx->provider->get_hmac_sz(c_ctx->provider_ctx);

c_ctx->derive_key = 1;

if(for_ctx == 2)

if((rc = sqlcipher_cipher_ctx_copy( for_ctx ? ctx->read_ctx : ctx->write_ctx, c_ctx)) != SQLITE_OK)

return rc;

return SQLITE_OK;

}

const char* sqlcipher_codec_ctx_get_cipher(codec_ctx *ctx, int for_ctx) {

cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;

return c_ctx->provider->get_cipher(c_ctx->provider_ctx);

}

void sqlcipher_set_default_kdf_iter(int iter) {

default_kdf_iter = iter;

}

int sqlcipher_get_default_kdf_iter() {

return default_kdf_iter;

}

int sqlcipher_codec_ctx_set_kdf_iter(codec_ctx *ctx, int kdf_iter, int for_ctx) {

cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;

int rc;

c_ctx->kdf_iter = kdf_iter;

c_ctx->derive_key = 1;

if(for_ctx == 2)

if((rc = sqlcipher_cipher_ctx_copy( for_ctx ? ctx->read_ctx : ctx->write_ctx, c_ctx)) != SQLITE_OK)

return rc;

return SQLITE_OK;

}

int sqlcipher_codec_ctx_get_kdf_iter(codec_ctx *ctx, int for_ctx) {

cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;

return c_ctx->kdf_iter;

}

int sqlcipher_codec_ctx_set_fast_kdf_iter(codec_ctx *ctx, int fast_kdf_iter, int for_ctx) {

cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;

int rc;

c_ctx->fast_kdf_iter = fast_kdf_iter;

c_ctx->derive_key = 1;

if(for_ctx == 2)

if((rc = sqlcipher_cipher_ctx_copy( for_ctx ? ctx->read_ctx : ctx->write_ctx, c_ctx)) != SQLITE_OK)

return rc;

return SQLITE_OK;

}

int sqlcipher_codec_ctx_get_fast_kdf_iter(codec_ctx *ctx, int for_ctx) {

cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;

return c_ctx->fast_kdf_iter;

}

void sqlcipher_set_default_use_hmac(int use) {

if(use) default_flags |= CIPHER_FLAG_HMAC;

else default_flags &= ~CIPHER_FLAG_HMAC;

}

int sqlcipher_get_default_use_hmac() {

return (default_flags & CIPHER_FLAG_HMAC) != 0;

}

void sqlcipher_set_hmac_salt_mask(unsigned char mask) {

hmac_salt_mask = mask;

}

unsigned char sqlcipher_get_hmac_salt_mask() {

return hmac_salt_mask;

}

int sqlcipher_codec_ctx_set_use_hmac(codec_ctx *ctx, int use) {

int reserve = CIPHER_MAX_IV_SZ; /* base reserve size will be IV only */

if(use) reserve += ctx->read_ctx->hmac_sz; /* if reserve will include hmac, update that size */

/* calculate the amount of reserve needed in even increments of the cipher block size */

reserve = ((reserve % ctx->read_ctx->block_sz) == 0) ? reserve :

((reserve / ctx->read_ctx->block_sz) + 1) * ctx->read_ctx->block_sz;

CODEC_TRACE(("sqlcipher_codec_ctx_set_use_hmac: use=%d block_sz=%d md_size=%d reserve=%d\n",

use, ctx->read_ctx->block_sz, ctx->read_ctx->hmac_sz, reserve));

if(use) {

sqlcipher_codec_ctx_set_flag(ctx, CIPHER_FLAG_HMAC);

} else {

sqlcipher_codec_ctx_unset_flag(ctx, CIPHER_FLAG_HMAC);

}

ctx->write_ctx->reserve_sz = ctx->read_ctx->reserve_sz = reserve;

return SQLITE_OK;

}

int sqlcipher_codec_ctx_get_use_hmac(codec_ctx *ctx, int for_ctx) {

cipher_ctx * c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;

return (c_ctx->flags & CIPHER_FLAG_HMAC) != 0;

}

int sqlcipher_codec_ctx_set_flag(codec_ctx *ctx, unsigned int flag) {

ctx->write_ctx->flags |= flag;

ctx->read_ctx->flags |= flag;

return SQLITE_OK;

}

int sqlcipher_codec_ctx_unset_flag(codec_ctx *ctx, unsigned int flag) {

ctx->write_ctx->flags &= ~flag;

ctx->read_ctx->flags &= ~flag;

return SQLITE_OK;

}

int sqlcipher_codec_ctx_get_flag(codec_ctx *ctx, unsigned int flag, int for_ctx) {

cipher_ctx * c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;

return (c_ctx->flags & flag) != 0;

}

void sqlcipher_codec_ctx_set_error(codec_ctx *ctx, int error) {

CODEC_TRACE(("sqlcipher_codec_ctx_set_error: ctx=%p, error=%d\n", ctx, error));

sqlite3pager_sqlite3PagerSetError(ctx->pBt->pBt->pPager, error);

ctx->pBt->pBt->db->errCode = error;

}

int sqlcipher_codec_ctx_get_reservesize(codec_ctx *ctx) {

return ctx->read_ctx->reserve_sz;

}

void* sqlcipher_codec_ctx_get_data(codec_ctx *ctx) {

return ctx->buffer;

}

void* sqlcipher_codec_ctx_get_kdf_salt(codec_ctx *ctx) {

return ctx->kdf_salt;

}

void sqlcipher_codec_get_keyspec(codec_ctx *ctx, void **zKey, int *nKey) {

*zKey = ctx->read_ctx->keyspec;

*nKey = ctx->read_ctx->keyspec_sz;

}

int sqlcipher_codec_ctx_set_pagesize(codec_ctx *ctx, int size) {

/* attempt to free the existing page buffer */

sqlcipher_free(ctx->buffer,ctx->page_sz);

ctx->page_sz = size;

/* pre-allocate a page buffer of PageSize bytes. This will

ctx->buffer = sqlcipher_malloc(size);

if(ctx->buffer == NULL) return SQLITE_NOMEM;

return SQLITE_OK;

}

int sqlcipher_codec_ctx_get_pagesize(codec_ctx *ctx) {

return ctx->page_sz;

}

int sqlcipher_codec_ctx_init(codec_ctx **iCtx, Db *pDb, Pager *pPager, sqlite3_file *fd, const void *zKey, int nKey) {

int rc;

codec_ctx *ctx;

*iCtx = sqlcipher_malloc(sizeof(codec_ctx));

ctx = *iCtx;

if(ctx == NULL) return SQLITE_NOMEM;

ctx->pBt = pDb->pBt; /* assign pointer to database btree structure */

/* allocate space for salt data. Then read the first 16 bytes

ctx->kdf_salt_sz = FILE_HEADER_SZ;

ctx->kdf_salt = sqlcipher_malloc(ctx->kdf_salt_sz);

if(ctx->kdf_salt == NULL) return SQLITE_NOMEM;

/* allocate space for separate hmac salt data. We want the

ctx->hmac_kdf_salt = sqlcipher_malloc(ctx->kdf_salt_sz);

if(ctx->hmac_kdf_salt == NULL) return SQLITE_NOMEM;

/*

if((rc = sqlcipher_codec_ctx_set_pagesize(ctx, SQLITE_DEFAULT_PAGE_SIZE)) != SQLITE_OK) return rc;

if((rc = sqlcipher_cipher_ctx_init(&ctx->read_ctx)) != SQLITE_OK) return rc;

if((rc = sqlcipher_cipher_ctx_init(&ctx->write_ctx)) != SQLITE_OK) return rc;

if(fd == NULL || sqlite3OsRead(fd, ctx->kdf_salt, FILE_HEADER_SZ, 0) != SQLITE_OK) {

/* if unable to read the bytes, generate random salt */

if(ctx->read_ctx->provider->random(ctx->read_ctx->provider_ctx, ctx->kdf_salt, FILE_HEADER_SZ) != SQLITE_OK) return SQLITE_ERROR;

}

if((rc = sqlcipher_codec_ctx_set_cipher(ctx, CIPHER, 0)) != SQLITE_OK) return rc;

if((rc = sqlcipher_codec_ctx_set_kdf_iter(ctx, default_kdf_iter, 0)) != SQLITE_OK) return rc;

if((rc = sqlcipher_codec_ctx_set_fast_kdf_iter(ctx, FAST_PBKDF2_ITER, 0)) != SQLITE_OK) return rc;

if((rc = sqlcipher_codec_ctx_set_pass(ctx, zKey, nKey, 0)) != SQLITE_OK) return rc;

/* Note that use_hmac is a special case that requires recalculation of page size

if((rc = sqlcipher_codec_ctx_set_use_hmac(ctx, default_flags & CIPHER_FLAG_HMAC)) != SQLITE_OK) return rc;

if((rc = sqlcipher_cipher_ctx_copy(ctx->write_ctx, ctx->read_ctx)) != SQLITE_OK) return rc;

return SQLITE_OK;

}

void sqlcipher_codec_ctx_free(codec_ctx **iCtx) {

codec_ctx *ctx = *iCtx;

CODEC_TRACE(("codec_ctx_free: entered iCtx=%p\n", iCtx));

sqlcipher_free(ctx->kdf_salt, ctx->kdf_salt_sz);

sqlcipher_free(ctx->hmac_kdf_salt, ctx->kdf_salt_sz);

sqlcipher_free(ctx->buffer, 0);

sqlcipher_cipher_ctx_free(&ctx->read_ctx);

sqlcipher_cipher_ctx_free(&ctx->write_ctx);

sqlcipher_free(ctx, sizeof(codec_ctx));

}

static void sqlcipher_put4byte_le(unsigned char *p, u32 v) {

p[0] = (u8)v;

p[1] = (u8)(v>>8);

p[2] = (u8)(v>>16);

p[3] = (u8)(v>>24);

}

static int sqlcipher_page_hmac(cipher_ctx *ctx, Pgno pgno, unsigned char *in, int in_sz, unsigned char *out) {

unsigned char pgno_raw[sizeof(pgno)];

/* we may convert page number to consistent representation before calculating MAC for

if(ctx->flags & CIPHER_FLAG_LE_PGNO) { /* compute hmac using little endian pgno*/

sqlcipher_put4byte_le(pgno_raw, pgno);

} else if(ctx->flags & CIPHER_FLAG_BE_PGNO) { /* compute hmac using big endian pgno */

sqlite3Put4byte(pgno_raw, pgno); /* sqlite3Put4byte converts 32bit uint to big endian */

} else { /* use native byte ordering */

memcpy(pgno_raw, &pgno, sizeof(pgno));

}

/* include the encrypted page data, initialization vector, and page number in HMAC. This will

valid pages out of order in a database */

ctx->provider->hmac(

ctx->provider_ctx, ctx->hmac_key,

ctx->key_sz, in,

in_sz, (unsigned char*) &pgno_raw,

sizeof(pgno), out);

return SQLITE_OK;

}

int sqlcipher_page_cipher(codec_ctx *ctx, int for_ctx, Pgno pgno, int mode, int page_sz, unsigned char *in, unsigned char *out) {

cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;

unsigned char *iv_in, *iv_out, *hmac_in, *hmac_out, *out_start;

int size;

/* calculate some required positions into various buffers */

size = page_sz - c_ctx->reserve_sz; /* adjust size to useable size and memset reserve at end of page */

iv_out = out + size;

iv_in = in + size;

/* hmac will be written immediately after the initialization vector. the remainder of the page reserve will contain

hmac_in = in + size + c_ctx->iv_sz;

hmac_out = out + size + c_ctx->iv_sz;

out_start = out; /* note the original position of the output buffer pointer, as out will be rewritten during encryption */

CODEC_TRACE(("codec_cipher:entered pgno=%d, mode=%d, size=%d\n", pgno, mode, size));

CODEC_HEXDUMP("codec_cipher: input page data", in, page_sz);

/* the key size should never be zero. If it is, error out. */

if(c_ctx->key_sz == 0) {

CODEC_TRACE(("codec_cipher: error possible context corruption, key_sz is zero for pgno=%d\n", pgno));

sqlcipher_memset(out, 0, page_sz);

return SQLITE_ERROR;

}

if(mode == CIPHER_ENCRYPT) {

/* start at front of the reserve block, write random data to the end */

if(c_ctx->provider->random(c_ctx->provider_ctx, iv_out, c_ctx->reserve_sz) != SQLITE_OK) return SQLITE_ERROR;

} else { /* CIPHER_DECRYPT */

memcpy(iv_out, iv_in, c_ctx->iv_sz); /* copy the iv from the input to output buffer */

}

if((c_ctx->flags & CIPHER_FLAG_HMAC) && (mode == CIPHER_DECRYPT)) {

if(sqlcipher_page_hmac(c_ctx, pgno, in, size + c_ctx->iv_sz, hmac_out) != SQLITE_OK) {

sqlcipher_memset(out, 0, page_sz);

CODEC_TRACE(("codec_cipher: hmac operations failed for pgno=%d\n", pgno));

return SQLITE_ERROR;

}

CODEC_TRACE(("codec_cipher: comparing hmac on in=%p out=%p hmac_sz=%d\n", hmac_in, hmac_out, c_ctx->hmac_sz));

if(sqlcipher_memcmp(hmac_in, hmac_out, c_ctx->hmac_sz) != 0) { /* the hmac check failed */

if(sqlcipher_ismemset(in, 0, page_sz) == 0) {

/* first check if the entire contents of the page is zeros. If so, this page

CODEC_TRACE(("codec_cipher: zeroed page (short read) for pgno %d, encryption but returning SQLITE_OK\n", pgno));

sqlcipher_memset(out, 0, page_sz);

return SQLITE_OK;

} else {

/* if the page memory is not all zeros, it means the there was data and a hmac on the page.

CODEC_TRACE(("codec_cipher: hmac check failed for pgno=%d returning SQLITE_ERROR\n", pgno));

sqlcipher_memset(out, 0, page_sz);

return SQLITE_ERROR;

}

}

}

c_ctx->provider->cipher(c_ctx->provider_ctx, mode, c_ctx->key, c_ctx->key_sz, iv_out, in, size, out);

if((c_ctx->flags & CIPHER_FLAG_HMAC) && (mode == CIPHER_ENCRYPT)) {

sqlcipher_page_hmac(c_ctx, pgno, out_start, size + c_ctx->iv_sz, hmac_out);

}

CODEC_HEXDUMP("codec_cipher: output page data", out_start, page_sz);

return SQLITE_OK;

}

static int sqlcipher_cipher_ctx_key_derive(codec_ctx *ctx, cipher_ctx *c_ctx) {

int rc;

CODEC_TRACE(("cipher_ctx_key_derive: entered c_ctx->pass=%s, c_ctx->pass_sz=%d \

ctx->hmac_kdf_salt=%p, c_ctx->fast_kdf_iter=%d c_ctx->key_sz=%d\n",

c_ctx->pass, c_ctx->pass_sz, ctx->kdf_salt, ctx->kdf_salt_sz, c_ctx->kdf_iter,

ctx->hmac_kdf_salt, c_ctx->fast_kdf_iter, c_ctx->key_sz));

if(c_ctx->pass && c_ctx->pass_sz) { // if pass is not null

if (c_ctx->pass_sz == ((c_ctx->key_sz * 2) + 3) && sqlite3StrNICmp(c_ctx->pass ,"x'", 2) == 0) {

int n = c_ctx->pass_sz - 3; /* adjust for leading x' and tailing ' */

const char *z = c_ctx->pass + 2; /* adjust lead offset of x' */

CODEC_TRACE(("cipher_ctx_key_derive: using raw key from hex\n"));

cipher_hex2bin(z, n, c_ctx->key);

} else if (c_ctx->pass_sz == (((c_ctx->key_sz + ctx->kdf_salt_sz) * 2) + 3) && sqlite3StrNICmp(c_ctx->pass ,"x'", 2) == 0) {

const char *z = c_ctx->pass + 2; /* adjust lead offset of x' */

CODEC_TRACE(("cipher_ctx_key_derive: using raw key from hex\n"));

cipher_hex2bin(z, (c_ctx->key_sz * 2), c_ctx->key);

cipher_hex2bin(z + (c_ctx->key_sz * 2), (ctx->kdf_salt_sz * 2), ctx->kdf_salt);

} else {

CODEC_TRACE(("cipher_ctx_key_derive: deriving key using full PBKDF2 with %d iterations\n", c_ctx->kdf_iter));

c_ctx->provider->kdf(c_ctx->provider_ctx, (const char*) c_ctx->pass, c_ctx->pass_sz,

ctx->kdf_salt, ctx->kdf_salt_sz, c_ctx->kdf_iter,

c_ctx->key_sz, c_ctx->key);

}

/* set the context "keyspec" containing the hex-formatted key and salt to be used when attaching databases */

if((rc = sqlcipher_cipher_ctx_set_keyspec(c_ctx, c_ctx->key, c_ctx->key_sz, ctx->kdf_salt, ctx->kdf_salt_sz)) != SQLITE_OK) return rc;

/* if this context is setup to use hmac checks, generate a seperate and different

if(c_ctx->flags & CIPHER_FLAG_HMAC) {

int i;

/* start by copying the kdf key into the hmac salt slot

to generate the encryption key */

memcpy(ctx->hmac_kdf_salt, ctx->kdf_salt, ctx->kdf_salt_sz);

for(i = 0; i < ctx->kdf_salt_sz; i++) {

ctx->hmac_kdf_salt[i] ^= hmac_salt_mask;

}

CODEC_TRACE(("cipher_ctx_key_derive: deriving hmac key from encryption key using PBKDF2 with %d iterations\n",

c_ctx->fast_kdf_iter));

c_ctx->provider->kdf(c_ctx->provider_ctx, (const char*)c_ctx->key, c_ctx->key_sz,

ctx->hmac_kdf_salt, ctx->kdf_salt_sz, c_ctx->fast_kdf_iter,

c_ctx->key_sz, c_ctx->hmac_key);

}

c_ctx->derive_key = 0;

return SQLITE_OK;

};

return SQLITE_ERROR;

}

int sqlcipher_codec_key_derive(codec_ctx *ctx) {

/* derive key on first use if necessary */

if(ctx->read_ctx->derive_key) {

if(sqlcipher_cipher_ctx_key_derive(ctx, ctx->read_ctx) != SQLITE_OK) return SQLITE_ERROR;

}

if(ctx->write_ctx->derive_key) {

if(sqlcipher_cipher_ctx_cmp(ctx->write_ctx, ctx->read_ctx) == 0) {

/* the relevant parameters are the same, just copy read key */

if(sqlcipher_cipher_ctx_copy(ctx->write_ctx, ctx->read_ctx) != SQLITE_OK) return SQLITE_ERROR;

} else {

if(sqlcipher_cipher_ctx_key_derive(ctx, ctx->write_ctx) != SQLITE_OK) return SQLITE_ERROR;

}

}

/* TODO: wipe and free passphrase after key derivation */

sqlcipher_cipher_ctx_set_pass(ctx->read_ctx, NULL, 0);

sqlcipher_cipher_ctx_set_pass(ctx->write_ctx, NULL, 0);

return SQLITE_OK;

}

int sqlcipher_codec_key_copy(codec_ctx *ctx, int source) {

if(source == CIPHER_READ_CTX) {

return sqlcipher_cipher_ctx_copy(ctx->write_ctx, ctx->read_ctx);

} else {

return sqlcipher_cipher_ctx_copy(ctx->read_ctx, ctx->write_ctx);

}

}

const char* sqlcipher_codec_get_cipher_provider(codec_ctx *ctx) {

return ctx->read_ctx->provider->get_provider_name(ctx->read_ctx);

}

static int sqlcipher_check_connection(const char *filename, char *key, int key_sz, char *sql, int *user_version) {

int rc;

sqlite3 *db = NULL;

sqlite3_stmt *statement = NULL;

char *query_user_version = "PRAGMA user_version;";

rc = sqlite3_open(filename, &db);

if(rc != SQLITE_OK){

goto cleanup;

}

rc = sqlite3_key(db, key, key_sz);

if(rc != SQLITE_OK){

goto cleanup;

}

rc = sqlite3_exec(db, sql, NULL, NULL, NULL);

if(rc != SQLITE_OK){

goto cleanup;

}

rc = sqlite3_prepare(db, query_user_version, -1, &statement, NULL);

if(rc != SQLITE_OK){

goto cleanup;

}

rc = sqlite3_step(statement);

if(rc == SQLITE_ROW){

*user_version = sqlite3_column_int(statement, 0);

rc = SQLITE_OK;

}

cleanup:

if(statement){

sqlite3_finalize(statement);

}

if(db){

sqlite3_close(db);

}

return rc;

}

int sqlcipher_codec_ctx_migrate(codec_ctx *ctx) {

u32 meta;

int rc = 0;

int command_idx = 0;

int password_sz;

int saved_flags;

int saved_nChange;

int saved_nTotalChange;

void (*saved_xTrace)(void*,const char*);

Db *pDb = 0;

sqlite3 *db = ctx->pBt->db;

const char *db_filename = sqlite3_db_filename(db, "main");

char *migrated_db_filename = sqlite3_mprintf("%s-migrated", db_filename);

char *pragma_hmac_off = "PRAGMA cipher_use_hmac = OFF;";

char *pragma_4k_kdf_iter = "PRAGMA kdf_iter = 4000;";

char *pragma_1x_and_4k;

char *set_user_version;

char *key;

int key_sz;

int user_version = 0;

int upgrade_1x_format = 0;

int upgrade_4k_format = 0;

static const unsigned char aCopy[] = {

BTREE_SCHEMA_VERSION, 1, /* Add one to the old schema cookie */

BTREE_DEFAULT_CACHE_SIZE, 0, /* Preserve the default page cache size */

BTREE_TEXT_ENCODING, 0, /* Preserve the text encoding */

BTREE_USER_VERSION, 0, /* Preserve the user version */

BTREE_APPLICATION_ID, 0, /* Preserve the application id */

};

key_sz = ctx->read_ctx->pass_sz + 1;

key = sqlcipher_malloc(key_sz);

memset(key, 0, key_sz);

memcpy(key, ctx->read_ctx->pass, ctx->read_ctx->pass_sz);

if(db_filename){

const char* commands[5];

char *attach_command = sqlite3_mprintf("ATTACH DATABASE '%s-migrated' as migrate KEY '%q';",

db_filename, key);

int rc = sqlcipher_check_connection(db_filename, key, key_sz, "", &user_version);

if(rc == SQLITE_OK){

CODEC_TRACE(("No upgrade required - exiting\n"));

goto exit;

}

// Version 2 - check for 4k with hmac format

rc = sqlcipher_check_connection(db_filename, key, key_sz, pragma_4k_kdf_iter, &user_version);

if(rc == SQLITE_OK) {

CODEC_TRACE(("Version 2 format found\n"));

upgrade_4k_format = 1;

}