/*

** SQLCipher

** sqlcipher.h developed by Stephen Lombardo (Zetetic LLC)

** sjlombardo at zetetic dot net

** http://zetetic.net

**

** Copyright (c) 2008, ZETETIC LLC

** All rights reserved.

**

** Redistribution and use in source and binary forms, with or without

** modification, are permitted provided that the following conditions are met:

** * Redistributions of source code must retain the above copyright

** notice, this list of conditions and the following disclaimer.

** * 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.

** * Neither the name of the ZETETIC LLC nor the

** names of its contributors may be used to endorse or promote products

** derived from this software without specific prior written permission.

**

** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''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 ZETETIC LLC 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.

**

*/

/* BEGIN SQLCIPHER */

#ifdef SQLITE_HAS_CODEC

#ifndef SQLCIPHER_H

#define SQLCIPHER_H

#include "sqlite3.h"

#include "sqliteInt.h"

#define SQLCIPHER_DECRYPT 0

#define SQLCIPHER_ENCRYPT 1

#define SQLCIPHER_HMAC_SHA1 0

#define SQLCIPHER_HMAC_SHA1_LABEL "HMAC_SHA1"

#define SQLCIPHER_HMAC_SHA256 1

#define SQLCIPHER_HMAC_SHA256_LABEL "HMAC_SHA256"

#define SQLCIPHER_HMAC_SHA512 2

#define SQLCIPHER_HMAC_SHA512_LABEL "HMAC_SHA512"

#define SQLCIPHER_PBKDF2_HMAC_SHA1 0

#define SQLCIPHER_PBKDF2_HMAC_SHA1_LABEL "PBKDF2_HMAC_SHA1"

#define SQLCIPHER_PBKDF2_HMAC_SHA256 1

#define SQLCIPHER_PBKDF2_HMAC_SHA256_LABEL "PBKDF2_HMAC_SHA256"

#define SQLCIPHER_PBKDF2_HMAC_SHA512 2

#define SQLCIPHER_PBKDF2_HMAC_SHA512_LABEL "PBKDF2_HMAC_SHA512"

typedef struct sqlcipher_provider sqlcipher_provider;

struct sqlcipher_provider {

int (*init)(void);

void (*shutdown)(void);

const char* (*get_provider_name)(void *ctx);

int (*add_random)(void *ctx, const void *buffer, int length);

int (*random)(void *ctx, void *buffer, int length);

int (*hmac)(void *ctx, int algorithm,

const unsigned char *hmac_key, int key_sz,

const unsigned char *in, int in_sz,

const unsigned char *in2, int in2_sz,

unsigned char *out);

int (*kdf)(void *ctx, int algorithm,

const unsigned char *pass, int pass_sz,

const unsigned char* salt, int salt_sz,

int workfactor,

int key_sz, unsigned char *key);

int (*cipher)(void *ctx, int mode,

const unsigned char *key, int key_sz,

const unsigned char *iv,

const unsigned char *in, int in_sz,

unsigned char *out);

const char* (*get_cipher)(void *ctx);

int (*get_key_sz)(void *ctx);

int (*get_iv_sz)(void *ctx);

int (*get_block_sz)(void *ctx);

int (*get_hmac_sz)(void *ctx, int algorithm);

int (*ctx_init)(void **ctx);

int (*ctx_free)(void **ctx);

int (*fips_status)(void *ctx);

const char* (*get_provider_version)(void *ctx);

sqlcipher_provider *next;

};

/* public interfaces called externally */

int sqlcipher_extra_init(const char*);

void sqlcipher_extra_shutdown(void);

void sqlcipher_init_memmethods(void);

int sqlcipher_codec_pragma(sqlite3*, int, Parse*, const char *, const char*);

int sqlcipherCodecAttach(sqlite3*, int, const void *, int);

void sqlcipherCodecGetKey(sqlite3*, int, void**, int*);

int sqlcipher_find_db_index(sqlite3 *, const char *);

/* utility functions */

void* sqlcipher_memset(void *, unsigned char, sqlite_uint64);

int sqlcipher_ismemset(const void *, unsigned char, sqlite_uint64);

int sqlcipher_memcmp(const void *, const void *, int);

void* sqlcipher_malloc(sqlite_uint64);

void sqlcipher_free(void *, sqlite_uint64);

char* sqlcipher_version(void);

/* provider interfaces */

int sqlcipher_register_provider(sqlcipher_provider *);

sqlcipher_provider* sqlcipher_get_provider(void);

#define SQLCIPHER_MUTEX_PROVIDER 0

#define SQLCIPHER_MUTEX_PROVIDER_ACTIVATE 1

#define SQLCIPHER_MUTEX_PROVIDER_RAND 2

#define SQLCIPHER_MUTEX_RESERVED1 3

#define SQLCIPHER_MUTEX_RESERVED2 4

#define SQLCIPHER_MUTEX_RESERVED3 5

#define SQLCIPHER_MUTEX_MEM 6

#define SQLCIPHER_MUTEX_SHAREDCACHE 7

#define SQLCIPHER_MUTEX_COUNT 8

sqlite3_mutex* sqlcipher_mutex(int);

#define SQLCIPHER_LOG_NONE 0

#define SQLCIPHER_LOG_ANY 0xffffffff

#define SQLCIPHER_LOG_ERROR (1<<0)

#define SQLCIPHER_LOG_WARN (1<<1)

#define SQLCIPHER_LOG_INFO (1<<2)

#define SQLCIPHER_LOG_DEBUG (1<<3)

#define SQLCIPHER_LOG_TRACE (1<<4)

#define SQLCIPHER_LOG_CORE (1<<0)

#define SQLCIPHER_LOG_MEMORY (1<<1)

#define SQLCIPHER_LOG_MUTEX (1<<2)

#define SQLCIPHER_LOG_PROVIDER (1<<3)

#ifdef SQLCIPHER_OMIT_LOG

#define sqlcipher_log(level, source, message, ...)

#else

void sqlcipher_log(unsigned int level, unsigned int source, const char *message, ...);

#endif

#ifdef CODEC_DEBUG_PAGEDATA

#define CODEC_HEXDUMP(DESC,BUFFER,LEN) \

{ \

int __pctr; \

printf(DESC); \

for(__pctr=0; __pctr < LEN; __pctr++) { \

if(__pctr % 16 == 0) printf("\n%05x: ",__pctr); \

printf("%02x ",((unsigned char*) BUFFER)[__pctr]); \

} \

printf("\n"); \

fflush(stdout); \

}

#else

#define CODEC_HEXDUMP(DESC,BUFFER,LEN)

#endif

#endif

#endif

/* END SQLCIPHER */