#ifdef SQLITE_HAS_CODEC

#if !defined(SQLCIPHER_OMIT_LOG_DEVICE)

#if defined(__ANDROID__)

#include <android/log.h>

#elif defined(__APPLE__)

#include <TargetConditionals.h>

#include <os/log.h>

#include <time.h>

#if defined(_WIN32) || defined(SQLITE_OS_WINRT)

#include <windows.h> /* amalgamator: dontcache */

#include <sys/time.h> /* amalgamator: dontcache */

#ifndef OMIT_MEMLOCK

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

#include <errno.h> /* amalgamator: dontcache */

#include <unistd.h> /* amalgamator: dontcache */

#include <sys/resource.h> /* amalgamator: dontcache */

#include <sys/mman.h> /* amalgamator: dontcache */

#include <assert.h>

#include "sqlcipher.h"

#include "btreeInt.h"

#include "pager.h"

#include "vdbeInt.h"

#if !defined(SQLITE_EXTRA_INIT) || !defined(SQLITE_EXTRA_SHUTDOWN)

#error "SQLCipher must be compiled with -DSQLITE_EXTRA_INIT=sqlcipher_extra_init -DSQLITE_EXTRA_SHUTDOWN=sqlcipher_extra_shutdown"

#if !defined(SQLITE_THREADSAFE) || !(SQLITE_THREADSAFE == 1 || SQLITE_THREADSAFE == 2)

#error "SQLCipher must be compiled with -DSQLITE_THREADSAFE=<1 or 2>"

#if !defined(SQLITE_TEMP_STORE) || SQLITE_TEMP_STORE == 0 || SQLITE_TEMP_STORE == 1

#error "SQLCipher must be compiled with -DSQLITE_TEMP_STORE=<2 or 3>"

/* extensions defined in pager.c */

void *sqlcipherPagerGetCodec(Pager*);

void sqlcipherPagerSetCodec(Pager*, void *(*)(void*,void*,Pgno,int), void (*)(void*,int,int), void (*)(void*), void *);

int sqlite3pager_is_sj_pgno(Pager*, Pgno);

void sqlite3pager_error(Pager*, int);

void sqlite3pager_reset(Pager *pPager);

#if !defined (SQLCIPHER_CRYPTO_CC) \

&& !defined (SQLCIPHER_CRYPTO_OPENSSL) \

&& !defined (SQLCIPHER_CRYPTO_CUSTOM)

#define SQLCIPHER_CRYPTO_OPENSSL

#define FILE_HEADER_SZ 16

#define CIPHER_XSTR(s) CIPHER_STR(s)

#define CIPHER_STR(s) #s

#ifndef CIPHER_VERSION_NUMBER

#define CIPHER_VERSION_NUMBER 4.13.0

#ifndef CIPHER_VERSION_BUILD

#define CIPHER_VERSION_BUILD community

#define CIPHER_READ_CTX 0

#define CIPHER_WRITE_CTX 1

#define CIPHER_READWRITE_CTX 2

#ifndef PBKDF2_ITER

#define PBKDF2_ITER 256000

#define SQLCIPHER_FLAG_GET(FLAG,BIT) ((FLAG & BIT) != 0)

#define SQLCIPHER_FLAG_SET(FLAG,BIT) FLAG |= BIT

#define SQLCIPHER_FLAG_UNSET(FLAG,BIT) FLAG &= ~BIT

#define CIPHER_FLAG_HMAC (1 << 0)

#define CIPHER_FLAG_LE_PGNO (1 << 1)

#define CIPHER_FLAG_BE_PGNO (1 << 2)

#define CIPHER_FLAG_KEY_USED (1 << 3)

#define CIPHER_FLAG_HAS_KDF_SALT (1 << 4)

#ifndef DEFAULT_CIPHER_FLAGS

#define DEFAULT_CIPHER_FLAGS CIPHER_FLAG_HMAC | CIPHER_FLAG_LE_PGNO

#ifndef FAST_PBKDF2_ITER

#define FAST_PBKDF2_ITER 2

will likely allow this to be defined at runtime via pragma */

#ifndef HMAC_SALT_MASK

#define HMAC_SALT_MASK 0x3a

#ifndef CIPHER_MAX_IV_SZ

#define CIPHER_MAX_IV_SZ 16

#ifndef CIPHER_MAX_KEY_SZ

#define CIPHER_MAX_KEY_SZ 64

typedef struct {

int derive_key;

int pass_sz;

unsigned char *key;

unsigned char *hmac_key;

unsigned char *pass;

} cipher_ctx;

typedef struct {

int store_pass;

int kdf_iter;

int fast_kdf_iter;

int kdf_salt_sz;

int key_sz;

int iv_sz;

int block_sz;

int page_sz;

int reserve_sz;

int hmac_sz;

int plaintext_header_sz;

int hmac_algorithm;

int kdf_algorithm;

int error;

unsigned int flags;

unsigned char *kdf_salt;

unsigned char *hmac_kdf_salt;

unsigned char *buffer;

Btree *pBt;

cipher_ctx *read_ctx;

cipher_ctx *write_ctx;

sqlcipher_provider *provider;

void *provider_ctx;

} codec_ctx ;

typedef struct private_block private_block;

struct private_block {

};

static volatile uint64_t xoshiro_s[4];

static inline uint64_t xoshiro_rotl(const uint64_t x, int k) {

return (x << k) | (x >> (64 - k));

}

uint64_t xoshiro_next(void) {

volatile uint64_t result = xoshiro_rotl(xoshiro_s[0] + xoshiro_s[3], 23) + xoshiro_s[0];

volatile uint64_t t = xoshiro_s[1] << 17;

xoshiro_s[2] ^= xoshiro_s[0];

xoshiro_s[3] ^= xoshiro_s[1];

xoshiro_s[1] ^= xoshiro_s[2];

xoshiro_s[0] ^= xoshiro_s[3];

xoshiro_s[2] ^= t;

xoshiro_s[3] = xoshiro_rotl(xoshiro_s[3], 45);

return result;

}

static void xoshiro_randomness(unsigned char *ptr, int sz) {

volatile uint64_t val;

volatile int to_copy;

while (sz > 0) {

val = xoshiro_next();

to_copy = (sz >= sizeof(val)) ? sizeof(val) : sz;

memcpy(ptr, (void *) &val, to_copy);

ptr += to_copy;

sz -= to_copy;

}

}

#ifdef SQLCIPHER_TEST

#define TEST_FAIL_ENCRYPT 0x01

#define TEST_FAIL_DECRYPT 0x02

#define TEST_FAIL_MIGRATE 0x04

static volatile unsigned int cipher_test_flags = 0;

static volatile int cipher_test_rand = 0;

static int sqlcipher_get_test_fail() {

int x;

/* if cipher_test_rand is not set to a non-zero value always fail (return true) */

if (cipher_test_rand == 0) return 1;

xoshiro_randomness((unsigned char *) &x, sizeof(x));

return ((x % cipher_test_rand) == 0);

}

static volatile unsigned int default_flags = DEFAULT_CIPHER_FLAGS;

static volatile unsigned char hmac_salt_mask = HMAC_SALT_MASK;

static volatile int default_kdf_iter = PBKDF2_ITER;

static volatile int default_page_size = 4096;

static volatile int default_plaintext_header_size = 0;

static volatile int default_hmac_algorithm = SQLCIPHER_HMAC_SHA512;

static volatile int default_kdf_algorithm = SQLCIPHER_PBKDF2_HMAC_SHA512;

static volatile int sqlcipher_mem_security_on = 0;

static volatile int sqlcipher_mem_executed = 0;

static volatile int sqlcipher_mem_initialized = 0;

static volatile sqlite3_mem_methods default_mem_methods;

static sqlcipher_provider *default_provider = NULL;

static sqlite3_mutex* sqlcipher_static_mutex[SQLCIPHER_MUTEX_COUNT];

#ifndef SQLCIPHER_LOG_LEVEL_DEFAULT

#define SQLCIPHER_LOG_LEVEL_DEFAULT SQLCIPHER_LOG_WARN

static FILE* sqlcipher_log_file = NULL;

static volatile int sqlcipher_log_device = 0;

static volatile unsigned int sqlcipher_log_level = SQLCIPHER_LOG_NONE;

static volatile unsigned int sqlcipher_log_source = SQLCIPHER_LOG_ANY;

static volatile int sqlcipher_log_set = 0;

static size_t sqlcipher_shield_mask_sz = 32;

static u8* sqlcipher_shield_mask = NULL;

#ifndef SQLCIPHER_PRIVATE_HEAP_SIZE_DEFAULT

#define SQLCIPHER_PRIVATE_HEAP_SIZE_DEFAULT 49152

#define SQLCIPHER_PRIVATE_HEAP_SIZE_STEP 16384

static volatile size_t private_heap_sz = SQLCIPHER_PRIVATE_HEAP_SIZE_DEFAULT;

static u8* private_heap = NULL;

static volatile size_t private_heap_used = 0; /* bytes currently used on private heap */

static volatile size_t private_heap_hwm = 0; /* larged number of bytes used on the private heap at one time */

static volatile size_t private_heap_alloc = 0; /* total bytes allocated on private heap over time */

static volatile u32 private_heap_allocs = 0; /* total number of allocations on private heap over time */

static volatile size_t private_heap_overflow = 0; /* total bytes overflowing private heap over time */

static volatile u32 private_heap_overflows = 0; /* number of overlow allocations over time */

#define SQLCIPHER_PRIVATE_HEAP_MIN_SPLIT_SIZE 32

#define SQLCIPHER_PRIVATE_HEAP_ALIGNMENT 8

#define SQLCIPHER_PRIVATE_HEAP_ROUNDUP(x) ((x % SQLCIPHER_PRIVATE_HEAP_ALIGNMENT) ? \

((x / SQLCIPHER_PRIVATE_HEAP_ALIGNMENT) + 1) * SQLCIPHER_PRIVATE_HEAP_ALIGNMENT : x)

static volatile int sqlcipher_init = 0;

static volatile int sqlcipher_shutdown = 0;

static volatile int sqlcipher_cleanup = 0;

static int sqlcipher_init_error = SQLITE_ERROR;

static void sqlcipher_internal_free(void *, sqlite_uint64);

static void *sqlcipher_internal_malloc(sqlite_uint64);

static int cipher_hex2int(char c) {

return (c>='0' && c<='9') ? (c)-'0' :

(c>='A' && c<='F') ? (c)-'A'+10 :

(c>='a' && c<='f') ? (c)-'a'+10 : 0;

}

static void cipher_hex2bin(const unsigned char *hex, int sz, unsigned char *out){

int i;

for(i = 0; i < sz; i += 2){

out[i/2] = (cipher_hex2int(hex[i])<<4) | cipher_hex2int(hex[i+1]);

}

}

static void cipher_bin2hex(const unsigned char* in, int sz, char *out) {

int i;

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

sqlite3_snprintf(3, out + (i*2), "%02x ", in[i]);

}

}

static int cipher_isHex(const unsigned char *hex, int sz){

int i;

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

unsigned char c = hex[i];

if ((c < '0' || c > '9') &&

(c < 'A' || c > 'F') &&

(c < 'a' || c > 'f')) {

return 0;

}

}

return 1;

}

sqlite3_mutex* sqlcipher_mutex(int mutex) {

if(mutex < 0 || mutex >= SQLCIPHER_MUTEX_COUNT) return NULL;

return sqlcipher_static_mutex[mutex];

}

static void sqlcipher_atexit(void) {

sqlcipher_log(SQLCIPHER_LOG_DEBUG, SQLCIPHER_LOG_CORE, "%s: calling sqlcipher_extra_shutdown()", __func__);

sqlcipher_extra_shutdown();

}

static void sqlcipher_fini(void) {

sqlcipher_log(SQLCIPHER_LOG_DEBUG, SQLCIPHER_LOG_CORE, "%s: calling sqlcipher_extra_shutdown()", __func__);

sqlcipher_extra_shutdown();

}

#if defined(_WIN32)

#ifndef SQLCIPHER_OMIT_DLLMAIN

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {

switch (fdwReason) {

case DLL_PROCESS_DETACH:

sqlcipher_log(SQLCIPHER_LOG_DEBUG, SQLCIPHER_LOG_CORE, "%s: calling sqlcipher_extra_shutdown()", __func__);

sqlcipher_extra_shutdown();

break;

default:

break;

}

return TRUE;

}

#endif

#elif defined(__APPLE__)

#if defined(__has_feature)

#if __has_feature(address_sanitizer)

static void sqlcipher_cleanup_destructor(void) __attribute__((destructor));

static void sqlcipher_cleanup_destructor(void) { sqlcipher_fini(); }

#else

static void (*const sqlcipher_fini_func)(void) __attribute__((used, section("__DATA,__mod_term_func"))) = sqlcipher_fini;

#endif

#else

static void (*const sqlcipher_fini_func)(void) __attribute__((used, section("__DATA,__mod_term_func"))) = sqlcipher_fini;

#endif

static void (*const sqlcipher_fini_func)(void) __attribute__((used, section(".fini_array"))) = sqlcipher_fini;

static void sqlcipher_exportFunc(sqlite3_context*, int, sqlite3_value**);

static int sqlcipher_export_init(sqlite3* db, const char** errmsg, const struct sqlite3_api_routines* api) {

sqlite3_create_function_v2(db, "sqlcipher_export", -1, SQLITE_UTF8, 0, sqlcipher_exportFunc, 0, 0, 0);

return SQLITE_OK;

}

int sqlcipher_extra_init(const char* arg) {

int rc = SQLITE_OK, i=0;

void* provider_ctx = NULL;

sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));

if(sqlcipher_init) {

/* if this init routine already completed successfully return immediately */

sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));

return SQLITE_OK;

}

/* only register cleanup handlers once per process */

if(!sqlcipher_cleanup) {

atexit(sqlcipher_atexit);

sqlcipher_cleanup = 1;

}

#ifndef SQLCIPHER_OMIT_DEFAULT_LOGGING

/* when sqlcipher is first activated, set a default log target and level of WARN if the

android (logcat) or apple (console). Use stderr on all other platforms. */

if(!sqlcipher_log_set) {

/* set log level if it is different than the uninitalized default value of NONE */

if(sqlcipher_log_level == SQLCIPHER_LOG_NONE) {

sqlcipher_log_level = SQLCIPHER_LOG_LEVEL_DEFAULT;

}

/* set the default file or device if neither is already set */

if(sqlcipher_log_device == 0 && sqlcipher_log_file == NULL) {

#if defined(__ANDROID__) || defined(__APPLE__)

sqlcipher_log_device = 1;

sqlcipher_log_file = stderr;

}

sqlcipher_log_set = 1;

}

/* allocate static mutexe, and return error if any fail to allocate */

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

if(sqlcipher_static_mutex[i] == NULL) {

if((sqlcipher_static_mutex[i] = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST)) == NULL) {

sqlcipher_log(SQLCIPHER_LOG_ERROR, SQLCIPHER_LOG_MEMORY, "%s: failed to allocate static mutex %d", __func__, i);

rc = SQLITE_NOMEM;

goto error;

}

}

}

/* initialize the private heap for use in internal SQLCipher memory allocations */

if(private_heap == NULL) {

while(private_heap_sz >= SQLCIPHER_PRIVATE_HEAP_SIZE_STEP) {

/* attempt to allocate the private heap. If allocation fails, reduce the size and try again */

if((private_heap = sqlcipher_internal_malloc(private_heap_sz))) {

xoshiro_randomness(private_heap, (int) private_heap_sz);

/* initialize the head block of the linked list at the start of the heap */

private_block *head = (private_block *) private_heap;

head->is_used = 0;

head->size = (u32) private_heap_sz - sizeof(private_block);

head->next = NULL;

break;

}

/* allocation failed, reduce the requested size of the heap */

private_heap_sz -= SQLCIPHER_PRIVATE_HEAP_SIZE_STEP;

}

}

if(!private_heap) {

sqlcipher_log(SQLCIPHER_LOG_ERROR, SQLCIPHER_LOG_MEMORY, "%s: failed to allocate private heap", __func__);

rc = SQLITE_NOMEM;

goto error;

}

/* 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_OPENSSL)

extern int sqlcipher_openssl_setup(sqlcipher_provider *p);

sqlcipher_openssl_setup(p);

#elif defined (SQLCIPHER_CRYPTO_OSSL3)

extern int sqlcipher_ossl3_setup(sqlcipher_provider *p);

sqlcipher_ossl3_setup(p);

#elif defined (SQLCIPHER_CRYPTO_CUSTOM)

extern int SQLCIPHER_CRYPTO_CUSTOM(sqlcipher_provider *p);

SQLCIPHER_CRYPTO_CUSTOM(p);

#error "NO DEFAULT SQLCIPHER CRYPTO PROVIDER DEFINED"

if((rc = sqlcipher_register_provider(p)) != SQLITE_OK) {

sqlcipher_log(SQLCIPHER_LOG_ERROR, SQLCIPHER_LOG_PROVIDER, "%s: failed to register provider %p %d", __func__, p, rc);

goto error;

}

}

/* required random data */

if((rc = default_provider->ctx_init(&provider_ctx)) != SQLITE_OK) {

sqlcipher_log(SQLCIPHER_LOG_ERROR, SQLCIPHER_LOG_MEMORY, "%s: failed to initilize provider context %d", __func__, rc);

goto error;

}

if((rc = default_provider->random(provider_ctx, (void *)xoshiro_s, sizeof(xoshiro_s))) != SQLITE_OK) {

sqlcipher_log(SQLCIPHER_LOG_ERROR, SQLCIPHER_LOG_MEMORY, "%s: failed to generate xoshiro seed %d", __func__, rc);

goto error;

}

if(!sqlcipher_shield_mask) {

if(!(sqlcipher_shield_mask = sqlcipher_internal_malloc(sqlcipher_shield_mask_sz))) {

sqlcipher_log(SQLCIPHER_LOG_ERROR, SQLCIPHER_LOG_MEMORY, "%s: failed to allocate shield mask", __func__);

goto error;

}

if((rc = default_provider->random(provider_ctx, sqlcipher_shield_mask, (int) sqlcipher_shield_mask_sz)) != SQLITE_OK) {

sqlcipher_log(SQLCIPHER_LOG_ERROR, SQLCIPHER_LOG_MEMORY, "%s: failed to generate requisite random mask data %d", __func__, rc);

goto error;

}

}

default_provider->ctx_free(&provider_ctx);

sqlcipher_init = 1;

sqlcipher_shutdown = 0;

/* leave the master mutex so we can proceed with auto extension registration */

sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));

/* finally, extension registration occurs outside of the mutex because it is

sqlite3_auto_extension((void (*)(void))sqlcipher_export_init);

return SQLITE_OK;

error:

/* if an error occurs during initialization, tear down everything that was setup */

if(private_heap) {

sqlcipher_internal_free(private_heap, private_heap_sz);

private_heap = NULL;

}

if(sqlcipher_shield_mask) {

sqlcipher_internal_free(sqlcipher_shield_mask, sqlcipher_shield_mask_sz);

sqlcipher_shield_mask = NULL;

}

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

if(sqlcipher_static_mutex[i]) {

sqlite3_mutex_free(sqlcipher_static_mutex[i]);

sqlcipher_static_mutex[i] = NULL;

}

}

/* post cleanup return the error code back up to sqlite3_init() */

sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));

sqlcipher_init_error = rc;

return rc;

}

void sqlcipher_extra_shutdown(void) {

int i = 0;

sqlcipher_provider *provider = NULL;

/* if sqlcipher hasn't been initialized or the shutdown already completed exit early */

if(!sqlcipher_init || sqlcipher_shutdown) {

goto cleanup;

}

if(sqlcipher_shield_mask) {

sqlcipher_internal_free(sqlcipher_shield_mask, sqlcipher_shield_mask_sz);

sqlcipher_shield_mask = NULL;

}

/* free the provider list. start at the default provider and move through the list

provider = default_provider;

while(provider) {

sqlcipher_provider *next = provider->next;

if(provider->shutdown) {

provider->shutdown();

}

sqlcipher_free(provider, sizeof(sqlcipher_provider));

provider = next;

}

default_provider = NULL;

/* free private heap. If SQLCipher is compiled in test mode, it will deliberately

if(private_heap) {

#ifdef SQLCIPHER_TEST

size_t used = 0;

private_block *block = NULL;

block = (private_block *) private_heap;

while (block != NULL) {

if(block->is_used) {

used+= block->size;

i++;

}

block = block->next;

}

if(used > 0) {

/* don't free the heap so that sqlite treats this as unfreed memory */

sqlcipher_log(SQLCIPHER_LOG_ERROR, SQLCIPHER_LOG_MEMORY,

"%s: SQLCipher private heap unfreed memory %u bytes in %d allocations", __func__, used, i);

} else {

sqlcipher_internal_free(private_heap, private_heap_sz);

private_heap = NULL;

}

sqlcipher_internal_free(private_heap, private_heap_sz);

private_heap = NULL;

sqlcipher_log(SQLCIPHER_LOG_INFO, SQLCIPHER_LOG_MEMORY,

"%s: SQLCipher private heap stats: size=%u, hwm=%u, alloc=%u, allocs=%u, overflow=%u, overflows=%u", __func__,

private_heap_sz, private_heap_hwm, private_heap_alloc, private_heap_allocs, private_heap_overflow, private_heap_overflows

);

}

/* free all of sqlcipher's static mutexes */

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

if(sqlcipher_static_mutex[i]) {

sqlite3_mutex_free(sqlcipher_static_mutex[i]);

sqlcipher_static_mutex[i] = NULL;

}

}

cleanup:

sqlcipher_init = 0;

sqlcipher_init_error = SQLITE_ERROR;

sqlcipher_shutdown = 1;

}

static void sqlcipher_shield(unsigned char *in, int sz) {

int i = 0;

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

in[i] ^= sqlcipher_shield_mask[i % sqlcipher_shield_mask_sz];

}

}

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

volatile sqlite_uint64 i = 0;

volatile unsigned char *a = v;

if (v == NULL) return v;

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MEMORY, "sqlcipher_memset: setting %p[0-%u]=%d)", a, len, value);

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

a[i] = value;

}

return v;

}

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

const volatile unsigned char *a = v;

volatile sqlite_uint64 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 volatile unsigned char *a0 = v0, *a1 = v1;

volatile int i = 0, result = 0;

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

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

}

return (result != 0);

}

static void sqlcipher_mlock(void *ptr, sqlite_uint64 sz) {

#ifndef OMIT_MEMLOCK

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

int rc;

unsigned long pagesize = sysconf(_SC_PAGESIZE);

unsigned long offset = (unsigned long) ptr % pagesize;

if(ptr == NULL || sz == 0) return;

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MEMORY, "sqlcipher_mlock: calling mlock(%p,%lu); _SC_PAGESIZE=%lu", ptr - offset, sz + offset, pagesize);

rc = mlock(ptr - offset, sz + offset);

if(rc!=0) {

sqlcipher_log(SQLCIPHER_LOG_WARN, SQLCIPHER_LOG_MEMORY, "sqlcipher_mlock: mlock() returned %d errno=%d", rc, errno);

sqlcipher_log(SQLCIPHER_LOG_INFO, SQLCIPHER_LOG_MEMORY, "sqlcipher_mlock: mlock(%p,%lu) returned %d errno=%d", ptr - offset, sz + offset, rc, errno);

}

#elif defined(_WIN32)

#if !(defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP || WINAPI_FAMILY == WINAPI_FAMILY_PC_APP))

int rc;

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MEMORY, "sqlcipher_mlock: calling VirtualLock(%p,%d)", ptr, sz);

rc = VirtualLock(ptr, sz);

if(rc==0) {

sqlcipher_log(SQLCIPHER_LOG_WARN, SQLCIPHER_LOG_MEMORY, "sqlcipher_mlock: VirtualLock() returned %d LastError=%d", rc, GetLastError());

sqlcipher_log(SQLCIPHER_LOG_INFO, SQLCIPHER_LOG_MEMORY, "sqlcipher_mlock: VirtualLock(%p,%d) returned %d LastError=%d", ptr, sz, rc, GetLastError());

}

}

static void sqlcipher_munlock(void *ptr, sqlite_uint64 sz) {

#ifndef OMIT_MEMLOCK

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

int rc;

unsigned long pagesize = sysconf(_SC_PAGESIZE);

unsigned long offset = (unsigned long) ptr % pagesize;

if(ptr == NULL || sz == 0) return;

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MEMORY, "sqlcipher_munlock: calling munlock(%p,%lu)", ptr - offset, sz + offset);

rc = munlock(ptr - offset, sz + offset);

if(rc!=0) {

sqlcipher_log(SQLCIPHER_LOG_INFO, SQLCIPHER_LOG_MEMORY, "sqlcipher_munlock: munlock(%p,%lu) returned %d errno=%d", ptr - offset, sz + offset, rc, errno);

}

#elif defined(_WIN32)

#if !(defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP || WINAPI_FAMILY == WINAPI_FAMILY_PC_APP))

int rc;

if(ptr == NULL || sz == 0) return;

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MEMORY, "sqlcipher_munlock: calling VirtualUnlock(%p,%d)", ptr, sz);

rc = VirtualUnlock(ptr, sz);

/* because memory allocations may be made from the same individual page, it is possible for VirtualUnlock to be called

if(!rc) {

sqlcipher_log(SQLCIPHER_LOG_INFO, SQLCIPHER_LOG_MEMORY, "sqlcipher_munlock: VirtualUnlock(%p,%d) returned %d LastError=%d", ptr, sz, rc, GetLastError());

}

}

static int sqlcipher_mem_init(void *pAppData) {

return default_mem_methods.xInit(pAppData);

}

static void sqlcipher_mem_shutdown(void *pAppData) {

default_mem_methods.xShutdown(pAppData);

}

static void *sqlcipher_mem_malloc(int n) {

void *ptr = default_mem_methods.xMalloc(n);

if(!sqlcipher_mem_executed) sqlcipher_mem_executed = 1;

if(sqlcipher_mem_security_on) {

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MEMORY, "sqlcipher_mem_malloc: calling sqlcipher_mlock(%p,%d)", ptr, n);

sqlcipher_mlock(ptr, n);

}

return ptr;

}

static int sqlcipher_mem_size(void *p) {

return default_mem_methods.xSize(p);

}

static void sqlcipher_mem_free(void *p) {

int sz;

if(!sqlcipher_mem_executed) sqlcipher_mem_executed = 1;

if(sqlcipher_mem_security_on) {

sz = sqlcipher_mem_size(p);

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MEMORY, "%s: calling xoshiro_randomness(%p,%d) and sqlcipher_munlock(%p, %d)", __func__, p, sz, p, sz);

xoshiro_randomness(p, sz);

sqlcipher_munlock(p, sz);

}

default_mem_methods.xFree(p);

}

static void *sqlcipher_mem_realloc(void *p, int n) {

void *new = NULL;

int orig_sz = 0;

if(sqlcipher_mem_security_on) {

orig_sz = sqlcipher_mem_size(p);

if (n==0) {

sqlcipher_mem_free(p);

return NULL;

} else if (!p) {

return sqlcipher_mem_malloc(n);

} else if(n <= orig_sz) {

return p;

} else {

new = sqlcipher_mem_malloc(n);

if(new) {

memcpy(new, p, orig_sz);

sqlcipher_mem_free(p);

}

return new;

}

} else {

return default_mem_methods.xRealloc(p, n);

}

}

static int sqlcipher_mem_roundup(int n) {

return default_mem_methods.xRoundup(n);

}

static sqlite3_mem_methods sqlcipher_mem_methods = {

sqlcipher_mem_malloc,

sqlcipher_mem_free,

sqlcipher_mem_realloc,

sqlcipher_mem_size,

sqlcipher_mem_roundup,

sqlcipher_mem_init,

sqlcipher_mem_shutdown,

0

};

void sqlcipher_init_memmethods() {

if(sqlcipher_mem_initialized) return;

if(sqlite3_config(SQLITE_CONFIG_GETMALLOC, &default_mem_methods) != SQLITE_OK ||

sqlite3_config(SQLITE_CONFIG_MALLOC, &sqlcipher_mem_methods) != SQLITE_OK) {

sqlcipher_mem_security_on = sqlcipher_mem_executed = sqlcipher_mem_initialized = 0;

} else {

sqlcipher_mem_initialized = 1;

}

}

static void sqlcipher_internal_free(void *ptr, sqlite_uint64 sz) {

xoshiro_randomness(ptr, sz);

sqlcipher_munlock(ptr, sz);

sqlite3_free(ptr);

}

static void* sqlcipher_internal_malloc(sqlite_uint64 sz) {

void *ptr;

ptr = sqlite3_malloc(sz);

sqlcipher_memset(ptr, 0, sz);

sqlcipher_mlock(ptr, sz);

return ptr;

}

void *sqlcipher_malloc(sqlite3_uint64 size) {

void *alloc = NULL;

private_block *block = NULL, *split = NULL;

if(size < 1) return NULL;

size = SQLCIPHER_PRIVATE_HEAP_ROUNDUP(size);

block = (private_block *) private_heap;

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "%s: entering SQLCIPHER_MUTEX_MEM", __func__);

sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_MEM));

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "%s: entered SQLCIPHER_MUTEX_MEM", __func__);

/* iterate through the blocks in the heap to find one which is big enough to hold

while(block != NULL && alloc == NULL) {

if(!block->is_used && block->size >= size) {

/* mark the block as in use and set the return pointer to the start

block->is_used = 1;

alloc = ((u8*)block) + sizeof(private_block);

sqlcipher_memset(alloc, 0, size);

/* if there is at least the minimim amount of required space left after allocation,

split off a new free block and insert it after the in-use block */

if(block->size >= size + sizeof(private_block) + SQLCIPHER_PRIVATE_HEAP_MIN_SPLIT_SIZE) {

split = (private_block*) (((u8*) block) + size + sizeof(private_block));

split->is_used = 0;

split->size = block->size - size - sizeof(private_block);

/* insert inbetween current block and next */

split->next = block->next;

block->next = split;

/* only set the size of the current block to the requested amount

block->size = size;

}

}

block = block->next;

}

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "%s: leaving SQLCIPHER_MUTEX_MEM", __func__);

sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_MEM));

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "%s: left SQLCIPHER_MUTEX_MEM", __func__);

/* If we were unable to locate a free block large enough to service the request, the fallback

if(alloc == NULL) {

private_heap_overflow += size;

private_heap_overflows++;

alloc = sqlcipher_internal_malloc(size);

sqlcipher_log(SQLCIPHER_LOG_INFO, SQLCIPHER_LOG_MEMORY, "%s: unable to allocate %u bytes on private heap, allocated %p using sqlcipher_internal_malloc fallback", __func__, size, alloc);

} else {

private_heap_used += size;

if(private_heap_used > private_heap_hwm) {

/* if the current bytes allocated on the private heap are greater than the high water mark, set the HWM to the new amount */

private_heap_hwm = private_heap_used;

}

private_heap_alloc += size;

private_heap_allocs++;

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MEMORY, "%s allocated %u bytes on private heap at %p", __func__, size, alloc);

}

return alloc;

}

void sqlcipher_free(void *mem, sqlite3_uint64 sz) {

private_block *block = NULL, *prev = NULL;

void *alloc = NULL;

u32 block_size = 0;

block = (private_block *) private_heap;

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "%s: entering SQLCIPHER_MUTEX_MEM", __func__);

sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_MEM));

sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "%s: entered SQLCIPHER_MUTEX_MEM", __func__);

/* search the heap for the block that contains this address */

while(block != NULL) {

alloc = ((u8*)block)+sizeof(private_block);

/* if the memory address to be freed corresponds to this block's

if(mem == alloc) {

block->is_used = 0;

block_size = block->size; /* retain the acual size of the block in use for stats adjustment */

xoshiro_randomness(alloc, block->size);

/* check whether the previous block is free, if so merge*/

if(prev && !prev->is_used) {

prev->size = prev->size + sizeof(private_block) + block->size;

prev->next = block->next;

block = prev;

}

/* check to see whether the next block is free, if so merge */

if(block->next && !block->next->is_used) {

block->size = block->size + sizeof(private_block) + block->next->size;

block->next = block->next->next;

}

/* once the block has been identified, marked free, and optionally

break;

}

prev = block;