Merge sqlite-release(3.40.1) into prerelease-integration
[sqlcipher.git] / src / crypto.h
blob12fc0aaf639456f6c892a447a6ed136241d6c3aa
1 /*
2 ** SQLCipher
3 ** crypto.h developed by Stephen Lombardo (Zetetic LLC)
4 ** sjlombardo at zetetic dot net
5 ** http://zetetic.net
6 **
7 ** Copyright (c) 2008, ZETETIC LLC
8 ** All rights reserved.
9 **
10 ** Redistribution and use in source and binary forms, with or without
11 ** modification, are permitted provided that the following conditions are met:
12 ** * Redistributions of source code must retain the above copyright
13 ** notice, this list of conditions and the following disclaimer.
14 ** * Redistributions in binary form must reproduce the above copyright
15 ** notice, this list of conditions and the following disclaimer in the
16 ** documentation and/or other materials provided with the distribution.
17 ** * Neither the name of the ZETETIC LLC nor the
18 ** names of its contributors may be used to endorse or promote products
19 ** derived from this software without specific prior written permission.
20 **
21 ** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY
22 ** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23 ** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 ** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY
25 ** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26 ** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27 ** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
28 ** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30 ** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 **
33 /* BEGIN SQLCIPHER */
34 #ifdef SQLITE_HAS_CODEC
35 #ifndef CRYPTO_H
36 #define CRYPTO_H
38 #include "sqliteInt.h"
39 #include "btreeInt.h"
40 #include "pager.h"
41 #include "vdbeInt.h"
43 #ifdef __ANDROID__
44 #include <android/log.h>
45 #endif
47 #include <time.h>
49 #if defined(_WIN32) || defined(SQLITE_OS_WINRT)
50 #include <windows.h> /* amalgamator: dontcache */
51 #else
52 #include <sys/time.h> /* amalgamator: dontcache */
53 #endif
55 #ifndef OMIT_MEMLOCK
56 #if defined(__unix__) || defined(__APPLE__) || defined(_AIX)
57 #include <errno.h> /* amalgamator: dontcache */
58 #include <unistd.h> /* amalgamator: dontcache */
59 #include <sys/resource.h> /* amalgamator: dontcache */
60 #include <sys/mman.h> /* amalgamator: dontcache */
61 #endif
62 #endif
64 #include "sqlcipher.h"
66 /* extensions defined in pager.c */
67 void *sqlcipherPagerGetCodec(Pager*);
68 void sqlcipherPagerSetCodec(Pager*, void *(*)(void*,void*,Pgno,int), void (*)(void*,int,int), void (*)(void*), void *);
69 int sqlite3pager_is_sj_pgno(Pager*, Pgno);
70 void sqlite3pager_error(Pager*, int);
71 void sqlite3pager_reset(Pager *pPager);
72 /* end extensions defined in pager.c */
74 #if !defined (SQLCIPHER_CRYPTO_CC) \
75 && !defined (SQLCIPHER_CRYPTO_LIBTOMCRYPT) \
76 && !defined (SQLCIPHER_CRYPTO_NSS) \
77 && !defined (SQLCIPHER_CRYPTO_OPENSSL)
78 #define SQLCIPHER_CRYPTO_OPENSSL
79 #endif
81 #define FILE_HEADER_SZ 16
83 #define CIPHER_XSTR(s) CIPHER_STR(s)
84 #define CIPHER_STR(s) #s
86 #ifndef CIPHER_VERSION_NUMBER
87 #define CIPHER_VERSION_NUMBER 4.5.3
88 #endif
90 #ifndef CIPHER_VERSION_BUILD
91 #define CIPHER_VERSION_BUILD community
92 #endif
94 #define CIPHER_DECRYPT 0
95 #define CIPHER_ENCRYPT 1
97 #define CIPHER_READ_CTX 0
98 #define CIPHER_WRITE_CTX 1
99 #define CIPHER_READWRITE_CTX 2
101 #ifndef PBKDF2_ITER
102 #define PBKDF2_ITER 256000
103 #endif
105 /* possible flags for cipher_ctx->flags */
106 #define CIPHER_FLAG_HMAC 0x01
107 #define CIPHER_FLAG_LE_PGNO 0x02
108 #define CIPHER_FLAG_BE_PGNO 0x04
110 #ifndef DEFAULT_CIPHER_FLAGS
111 #define DEFAULT_CIPHER_FLAGS CIPHER_FLAG_HMAC | CIPHER_FLAG_LE_PGNO
112 #endif
115 /* by default, sqlcipher will use a reduced number of iterations to generate
116 the HMAC key / or transform a raw cipher key
118 #ifndef FAST_PBKDF2_ITER
119 #define FAST_PBKDF2_ITER 2
120 #endif
122 /* this if a fixed random array that will be xor'd with the database salt to ensure that the
123 salt passed to the HMAC key derivation function is not the same as that used to derive
124 the encryption key. This can be overridden at compile time but it will make the resulting
125 binary incompatible with the default builds when using HMAC. A future version of SQLcipher
126 will likely allow this to be defined at runtime via pragma */
127 #ifndef HMAC_SALT_MASK
128 #define HMAC_SALT_MASK 0x3a
129 #endif
131 #ifndef CIPHER_MAX_IV_SZ
132 #define CIPHER_MAX_IV_SZ 16
133 #endif
135 #ifndef CIPHER_MAX_KEY_SZ
136 #define CIPHER_MAX_KEY_SZ 64
137 #endif
141 ** Simple shared routines for converting hex char strings to binary data
143 static int cipher_hex2int(char c) {
144 return (c>='0' && c<='9') ? (c)-'0' :
145 (c>='A' && c<='F') ? (c)-'A'+10 :
146 (c>='a' && c<='f') ? (c)-'a'+10 : 0;
149 static void cipher_hex2bin(const unsigned char *hex, int sz, unsigned char *out){
150 int i;
151 for(i = 0; i < sz; i += 2){
152 out[i/2] = (cipher_hex2int(hex[i])<<4) | cipher_hex2int(hex[i+1]);
156 static void cipher_bin2hex(const unsigned char* in, int sz, char *out) {
157 int i;
158 for(i=0; i < sz; i++) {
159 sqlite3_snprintf(3, out + (i*2), "%02x ", in[i]);
163 static int cipher_isHex(const unsigned char *hex, int sz){
164 int i;
165 for(i = 0; i < sz; i++) {
166 unsigned char c = hex[i];
167 if ((c < '0' || c > '9') &&
168 (c < 'A' || c > 'F') &&
169 (c < 'a' || c > 'f')) {
170 return 0;
173 return 1;
176 /* possible flags for simulating specific test conditions */
177 #ifdef SQLCIPHER_TEST
178 #define TEST_FAIL_ENCRYPT 0x01
179 #define TEST_FAIL_DECRYPT 0x02
180 #define TEST_FAIL_MIGRATE 0x04
181 unsigned int sqlcipher_get_test_flags(void);
182 void sqlcipher_set_test_flags(unsigned int);
183 int sqlcipher_get_test_rand(void);
184 void sqlcipher_set_test_rand(int);
185 int sqlcipher_get_test_fail(void);
186 #endif
188 /* extensions defined in crypto_impl.c */
189 /* the default implementation of SQLCipher uses a cipher_ctx
190 to keep track of read / write state separately. The following
191 struct and associated functions are defined here */
192 typedef struct {
193 int derive_key;
194 int pass_sz;
195 unsigned char *key;
196 unsigned char *hmac_key;
197 unsigned char *pass;
198 char *keyspec;
199 } cipher_ctx;
202 typedef struct {
203 int store_pass;
204 int kdf_iter;
205 int fast_kdf_iter;
206 int kdf_salt_sz;
207 int key_sz;
208 int iv_sz;
209 int block_sz;
210 int page_sz;
211 int keyspec_sz;
212 int reserve_sz;
213 int hmac_sz;
214 int plaintext_header_sz;
215 int hmac_algorithm;
216 int kdf_algorithm;
217 unsigned int skip_read_hmac;
218 unsigned int need_kdf_salt;
219 unsigned int flags;
220 unsigned char *kdf_salt;
221 unsigned char *hmac_kdf_salt;
222 unsigned char *buffer;
223 Btree *pBt;
224 cipher_ctx *read_ctx;
225 cipher_ctx *write_ctx;
226 sqlcipher_provider *provider;
227 void *provider_ctx;
228 } codec_ctx ;
230 /* crypto.c functions */
231 int sqlcipher_codec_pragma(sqlite3*, int, Parse*, const char *, const char*);
232 int sqlcipherCodecAttach(sqlite3*, int, const void *, int);
233 void sqlcipherCodecGetKey(sqlite3*, int, void**, int*);
234 void sqlcipher_exportFunc(sqlite3_context *, int, sqlite3_value **);
236 /* crypto_impl.c functions */
238 void sqlcipher_init_memmethods(void);
240 /* activation and initialization */
241 void sqlcipher_activate(void);
242 void sqlcipher_deactivate(void);
244 int sqlcipher_codec_ctx_init(codec_ctx **, Db *, Pager *, const void *, int);
245 void sqlcipher_codec_ctx_free(codec_ctx **);
246 int sqlcipher_codec_key_derive(codec_ctx *);
247 int sqlcipher_codec_key_copy(codec_ctx *, int);
249 /* page cipher implementation */
250 int sqlcipher_page_cipher(codec_ctx *, int, Pgno, int, int, unsigned char *, unsigned char *);
252 /* context setters & getters */
253 void sqlcipher_codec_ctx_set_error(codec_ctx *, int);
255 void sqlcipher_codec_get_pass(codec_ctx *, void **, int *);
256 int sqlcipher_codec_ctx_set_pass(codec_ctx *, const void *, int, int);
257 void sqlcipher_codec_get_keyspec(codec_ctx *, void **zKey, int *nKey);
259 int sqlcipher_codec_ctx_set_pagesize(codec_ctx *, int);
260 int sqlcipher_codec_ctx_get_pagesize(codec_ctx *);
261 int sqlcipher_codec_ctx_get_reservesize(codec_ctx *);
263 void sqlcipher_set_default_pagesize(int page_size);
264 int sqlcipher_get_default_pagesize(void);
266 void sqlcipher_set_default_kdf_iter(int iter);
267 int sqlcipher_get_default_kdf_iter(void);
268 int sqlcipher_codec_ctx_set_kdf_iter(codec_ctx *, int);
269 int sqlcipher_codec_ctx_get_kdf_iter(codec_ctx *ctx);
271 int sqlcipher_codec_ctx_set_kdf_salt(codec_ctx *ctx, unsigned char *salt, int sz);
272 int sqlcipher_codec_ctx_get_kdf_salt(codec_ctx *ctx, void **salt);
274 int sqlcipher_codec_ctx_set_fast_kdf_iter(codec_ctx *, int);
275 int sqlcipher_codec_ctx_get_fast_kdf_iter(codec_ctx *);
277 const char* sqlcipher_codec_ctx_get_cipher(codec_ctx *ctx);
279 void* sqlcipher_codec_ctx_get_data(codec_ctx *);
281 void sqlcipher_set_default_use_hmac(int use);
282 int sqlcipher_get_default_use_hmac(void);
284 void sqlcipher_set_hmac_salt_mask(unsigned char mask);
285 unsigned char sqlcipher_get_hmac_salt_mask(void);
287 int sqlcipher_codec_ctx_set_use_hmac(codec_ctx *ctx, int use);
288 int sqlcipher_codec_ctx_get_use_hmac(codec_ctx *ctx);
290 int sqlcipher_codec_ctx_set_flag(codec_ctx *ctx, unsigned int flag);
291 int sqlcipher_codec_ctx_unset_flag(codec_ctx *ctx, unsigned int flag);
292 int sqlcipher_codec_ctx_get_flag(codec_ctx *ctx, unsigned int flag);
294 const char* sqlcipher_codec_get_cipher_provider(codec_ctx *ctx);
295 int sqlcipher_codec_ctx_migrate(codec_ctx *ctx);
296 int sqlcipher_codec_add_random(codec_ctx *ctx, const char *data, int random_sz);
297 int sqlcipher_cipher_profile(sqlite3 *db, const char *destination);
298 int sqlcipher_codec_get_store_pass(codec_ctx *ctx);
299 void sqlcipher_codec_get_pass(codec_ctx *ctx, void **zKey, int *nKey);
300 void sqlcipher_codec_set_store_pass(codec_ctx *ctx, int value);
301 int sqlcipher_codec_fips_status(codec_ctx *ctx);
302 const char* sqlcipher_codec_get_provider_version(codec_ctx *ctx);
304 int sqlcipher_set_default_plaintext_header_size(int size);
305 int sqlcipher_get_default_plaintext_header_size(void);
306 int sqlcipher_codec_ctx_set_plaintext_header_size(codec_ctx *ctx, int size);
307 int sqlcipher_codec_ctx_get_plaintext_header_size(codec_ctx *ctx);
309 int sqlcipher_set_default_hmac_algorithm(int algorithm);
310 int sqlcipher_get_default_hmac_algorithm(void);
311 int sqlcipher_codec_ctx_set_hmac_algorithm(codec_ctx *ctx, int algorithm);
312 int sqlcipher_codec_ctx_get_hmac_algorithm(codec_ctx *ctx);
314 int sqlcipher_set_default_kdf_algorithm(int algorithm);
315 int sqlcipher_get_default_kdf_algorithm(void);
316 int sqlcipher_codec_ctx_set_kdf_algorithm(codec_ctx *ctx, int algorithm);
317 int sqlcipher_codec_ctx_get_kdf_algorithm(codec_ctx *ctx);
319 void sqlcipher_set_mem_security(int);
320 int sqlcipher_get_mem_security(void);
322 int sqlcipher_find_db_index(sqlite3 *db, const char *zDb);
324 int sqlcipher_codec_ctx_integrity_check(codec_ctx *, Parse *, char *);
326 int sqlcipher_set_log(const char *destination);
327 void sqlcipher_set_log_level(unsigned int level);
328 void sqlcipher_log(unsigned int tag, const char *message, ...);
330 #define SQLCIPHER_LOG_NONE 0x00
331 #define SQLCIPHER_LOG_ERROR 0x01
332 #define SQLCIPHER_LOG_WARN 0x02
333 #define SQLCIPHER_LOG_INFO 0x04
334 #define SQLCIPHER_LOG_DEBUG 0x08
335 #define SQLCIPHER_LOG_TRACE 0x10
336 #define SQLCIPHER_LOG_ALL 0xffffffff
338 void sqlcipher_vdbe_return_string(Parse*, const char*, const char*, int);
340 #ifdef CODEC_DEBUG_PAGEDATA
341 #define CODEC_HEXDUMP(DESC,BUFFER,LEN) \
343 int __pctr; \
344 printf(DESC); \
345 for(__pctr=0; __pctr < LEN; __pctr++) { \
346 if(__pctr % 16 == 0) printf("\n%05x: ",__pctr); \
347 printf("%02x ",((unsigned char*) BUFFER)[__pctr]); \
349 printf("\n"); \
350 fflush(stdout); \
352 #else
353 #define CODEC_HEXDUMP(DESC,BUFFER,LEN)
354 #endif
356 #endif
357 #endif
358 /* END SQLCIPHER */