src/crypto.h

   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 **
  32 */
  33 /* BEGIN SQLCIPHER */
  34 #ifdef SQLITE_HAS_CODEC
  35 #ifndef CRYPTO_H
  36 #define CRYPTO_H
  37
  38 #include "sqliteInt.h"
  39 #include "btreeInt.h"
  40 #include "pager.h"
  41
  42 #ifdef __ANDROID__
  43 #include <android/log.h>
  44 #endif
  45
  46 /* extensions defined in pager.c */
  47 void *sqlite3PagerGetCodec(Pager*);
  48 void sqlite3PagerSetCodec(Pager*, void *(*)(void*,void*,Pgno,int),  void (*)(void*,int,int),  void (*)(void*), void *);
  49 int sqlite3pager_is_mj_pgno(Pager*, Pgno);
  50 void sqlite3pager_error(Pager*, int);
  51 void sqlite3pager_reset(Pager *pPager);
  52 /* end extensions defined in pager.c */
  53
  54 #if !defined (SQLCIPHER_CRYPTO_CC) \
  55    && !defined (SQLCIPHER_CRYPTO_LIBTOMCRYPT) \
  56    && !defined (SQLCIPHER_CRYPTO_NSS) \
  57    && !defined (SQLCIPHER_CRYPTO_OPENSSL)
  58 #define SQLCIPHER_CRYPTO_OPENSSL
  59 #endif
  60
  61 #define FILE_HEADER_SZ 16
  62
  63 #define CIPHER_XSTR(s) CIPHER_STR(s)
  64 #define CIPHER_STR(s) #s
  65
  66 #ifndef CIPHER_VERSION_NUMBER
  67 #define CIPHER_VERSION_NUMBER 4.5.1
  68 #endif
  69
  70 #ifndef CIPHER_VERSION_BUILD
  71 #define CIPHER_VERSION_BUILD community
  72 #endif
  73
  74 #define CIPHER_DECRYPT 0
  75 #define CIPHER_ENCRYPT 1
  76
  77 #define CIPHER_READ_CTX 0
  78 #define CIPHER_WRITE_CTX 1
  79 #define CIPHER_READWRITE_CTX 2
  80
  81 #ifndef PBKDF2_ITER
  82 #define PBKDF2_ITER 256000
  83 #endif
  84
  85 /* possible flags for cipher_ctx->flags */
  86 #define CIPHER_FLAG_HMAC          0x01
  87 #define CIPHER_FLAG_LE_PGNO       0x02
  88 #define CIPHER_FLAG_BE_PGNO       0x04
  89
  90 #ifndef DEFAULT_CIPHER_FLAGS
  91 #define DEFAULT_CIPHER_FLAGS CIPHER_FLAG_HMAC | CIPHER_FLAG_LE_PGNO
  92 #endif
  93
  94
  95 /* by default, sqlcipher will use a reduced number of iterations to generate
  96    the HMAC key / or transform a raw cipher key
  97    */
  98 #ifndef FAST_PBKDF2_ITER
  99 #define FAST_PBKDF2_ITER 2
 100 #endif
 101
 102 /* this if a fixed random array that will be xor'd with the database salt to ensure that the
 103    salt passed to the HMAC key derivation function is not the same as that used to derive
 104    the encryption key. This can be overridden at compile time but it will make the resulting
 105    binary incompatible with the default builds when using HMAC. A future version of SQLcipher
 106    will likely allow this to be defined at runtime via pragma */
 107 #ifndef HMAC_SALT_MASK
 108 #define HMAC_SALT_MASK 0x3a
 109 #endif
 110
 111 #ifndef CIPHER_MAX_IV_SZ
 112 #define CIPHER_MAX_IV_SZ 16
 113 #endif
 114
 115 #ifndef CIPHER_MAX_KEY_SZ
 116 #define CIPHER_MAX_KEY_SZ 64
 117 #endif
 118
 119
 120 /*
 121 **  Simple shared routines for converting hex char strings to binary data
 122  */
 123 static int cipher_hex2int(char c) {
 124   return (c>='0' && c<='9') ? (c)-'0' :
 125          (c>='A' && c<='F') ? (c)-'A'+10 :
 126          (c>='a' && c<='f') ? (c)-'a'+10 : 0;
 127 }
 128
 129 static void cipher_hex2bin(const unsigned char *hex, int sz, unsigned char *out){
 130   int i;
 131   for(i = 0; i < sz; i += 2){
 132     out[i/2] = (cipher_hex2int(hex[i])<<4) | cipher_hex2int(hex[i+1]);
 133   }
 134 }
 135
 136 static void cipher_bin2hex(const unsigned char* in, int sz, char *out) {
 137     int i;
 138     for(i=0; i < sz; i++) {
 139       sqlite3_snprintf(3, out + (i*2), "%02x ", in[i]);
 140     }
 141 }
 142
 143 static int cipher_isHex(const unsigned char *hex, int sz){
 144   int i;
 145   for(i = 0; i < sz; i++) {
 146     unsigned char c = hex[i];
 147     if ((c < '0' || c > '9') &&
 148         (c < 'A' || c > 'F') &&
 149         (c < 'a' || c > 'f')) {
 150       return 0;
 151     }
 152   }
 153   return 1;
 154 }
 155
 156 /* possible flags for simulating specific test conditions */
 157 #ifdef SQLCIPHER_TEST
 158 #define TEST_FAIL_ENCRYPT 0x01
 159 #define TEST_FAIL_DECRYPT 0x02
 160 #define TEST_FAIL_MIGRATE 0x04
 161 unsigned int sqlcipher_get_test_flags(void);
 162 void sqlcipher_set_test_flags(unsigned int);
 163 int sqlcipher_get_test_rand(void);
 164 void sqlcipher_set_test_rand(int);
 165 int sqlcipher_get_test_fail(void);
 166 #endif
 167
 168 /* extensions defined in crypto_impl.c */
 169 /* the default implementation of SQLCipher uses a cipher_ctx
 170    to keep track of read / write state separately. The following
 171    struct and associated functions are defined here */
 172 typedef struct {
 173   int derive_key;
 174   int pass_sz;
 175   unsigned char *key;
 176   unsigned char *hmac_key;
 177   unsigned char *pass;
 178   char *keyspec;
 179 } cipher_ctx;
 180
 181
 182 typedef struct {
 183   int store_pass;
 184   int kdf_iter;
 185   int fast_kdf_iter;
 186   int kdf_salt_sz;
 187   int key_sz;
 188   int iv_sz;
 189   int block_sz;
 190   int page_sz;
 191   int keyspec_sz;
 192   int reserve_sz;
 193   int hmac_sz;
 194   int plaintext_header_sz;
 195   int hmac_algorithm;
 196   int kdf_algorithm;
 197   unsigned int skip_read_hmac;
 198   unsigned int need_kdf_salt;
 199   unsigned int flags;
 200   unsigned char *kdf_salt;
 201   unsigned char *hmac_kdf_salt;
 202   unsigned char *buffer;
 203   Btree *pBt;
 204   cipher_ctx *read_ctx;
 205   cipher_ctx *write_ctx;
 206   sqlcipher_provider *provider;
 207   void *provider_ctx;
 208 } codec_ctx ;
 209
 210 /* crypto.c functions */
 211 int sqlcipher_codec_pragma(sqlite3*, int, Parse*, const char *, const char*);
 212 int sqlite3CodecAttach(sqlite3*, int, const void *, int);
 213 void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
 214 void sqlcipher_exportFunc(sqlite3_context *, int, sqlite3_value **);
 215
 216 /* crypto_impl.c functions */
 217
 218 void sqlcipher_init_memmethods(void);
 219
 220 /* activation and initialization */
 221 void sqlcipher_activate(void);
 222 void sqlcipher_deactivate(void);
 223
 224 int sqlcipher_codec_ctx_init(codec_ctx **, Db *, Pager *, const void *, int);
 225 void sqlcipher_codec_ctx_free(codec_ctx **);
 226 int sqlcipher_codec_key_derive(codec_ctx *);
 227 int sqlcipher_codec_key_copy(codec_ctx *, int);
 228
 229 /* page cipher implementation */
 230 int sqlcipher_page_cipher(codec_ctx *, int, Pgno, int, int, unsigned char *, unsigned char *);
 231
 232 /* context setters & getters */
 233 void sqlcipher_codec_ctx_set_error(codec_ctx *, int);
 234
 235 void sqlcipher_codec_get_pass(codec_ctx *, void **, int *);
 236 int sqlcipher_codec_ctx_set_pass(codec_ctx *, const void *, int, int);
 237 void sqlcipher_codec_get_keyspec(codec_ctx *, void **zKey, int *nKey);
 238
 239 int sqlcipher_codec_ctx_set_pagesize(codec_ctx *, int);
 240 int sqlcipher_codec_ctx_get_pagesize(codec_ctx *);
 241 int sqlcipher_codec_ctx_get_reservesize(codec_ctx *);
 242
 243 void sqlcipher_set_default_pagesize(int page_size);
 244 int sqlcipher_get_default_pagesize(void);
 245
 246 void sqlcipher_set_default_kdf_iter(int iter);
 247 int sqlcipher_get_default_kdf_iter(void);
 248 int sqlcipher_codec_ctx_set_kdf_iter(codec_ctx *, int);
 249 int sqlcipher_codec_ctx_get_kdf_iter(codec_ctx *ctx);
 250
 251 int sqlcipher_codec_ctx_set_kdf_salt(codec_ctx *ctx, unsigned char *salt, int sz);
 252 int sqlcipher_codec_ctx_get_kdf_salt(codec_ctx *ctx, void **salt);
 253
 254 int sqlcipher_codec_ctx_set_fast_kdf_iter(codec_ctx *, int);
 255 int sqlcipher_codec_ctx_get_fast_kdf_iter(codec_ctx *);
 256
 257 const char* sqlcipher_codec_ctx_get_cipher(codec_ctx *ctx);
 258
 259 void* sqlcipher_codec_ctx_get_data(codec_ctx *);
 260
 261 void sqlcipher_set_default_use_hmac(int use);
 262 int sqlcipher_get_default_use_hmac(void);
 263
 264 void sqlcipher_set_hmac_salt_mask(unsigned char mask);
 265 unsigned char sqlcipher_get_hmac_salt_mask(void);
 266
 267 int sqlcipher_codec_ctx_set_use_hmac(codec_ctx *ctx, int use);
 268 int sqlcipher_codec_ctx_get_use_hmac(codec_ctx *ctx);
 269
 270 int sqlcipher_codec_ctx_set_flag(codec_ctx *ctx, unsigned int flag);
 271 int sqlcipher_codec_ctx_unset_flag(codec_ctx *ctx, unsigned int flag);
 272 int sqlcipher_codec_ctx_get_flag(codec_ctx *ctx, unsigned int flag);
 273
 274 const char* sqlcipher_codec_get_cipher_provider(codec_ctx *ctx);
 275 int sqlcipher_codec_ctx_migrate(codec_ctx *ctx);
 276 int sqlcipher_codec_add_random(codec_ctx *ctx, const char *data, int random_sz);
 277 int sqlcipher_cipher_profile(sqlite3 *db, const char *destination);
 278 int sqlcipher_codec_get_store_pass(codec_ctx *ctx);
 279 void sqlcipher_codec_get_pass(codec_ctx *ctx, void **zKey, int *nKey);
 280 void sqlcipher_codec_set_store_pass(codec_ctx *ctx, int value);
 281 int sqlcipher_codec_fips_status(codec_ctx *ctx);
 282 const char* sqlcipher_codec_get_provider_version(codec_ctx *ctx);
 283
 284 int sqlcipher_set_default_plaintext_header_size(int size);
 285 int sqlcipher_get_default_plaintext_header_size(void);
 286 int sqlcipher_codec_ctx_set_plaintext_header_size(codec_ctx *ctx, int size);
 287 int sqlcipher_codec_ctx_get_plaintext_header_size(codec_ctx *ctx);
 288
 289 int sqlcipher_set_default_hmac_algorithm(int algorithm);
 290 int sqlcipher_get_default_hmac_algorithm(void);
 291 int sqlcipher_codec_ctx_set_hmac_algorithm(codec_ctx *ctx, int algorithm);
 292 int sqlcipher_codec_ctx_get_hmac_algorithm(codec_ctx *ctx);
 293
 294 int sqlcipher_set_default_kdf_algorithm(int algorithm);
 295 int sqlcipher_get_default_kdf_algorithm(void);
 296 int sqlcipher_codec_ctx_set_kdf_algorithm(codec_ctx *ctx, int algorithm);
 297 int sqlcipher_codec_ctx_get_kdf_algorithm(codec_ctx *ctx);
 298
 299 void sqlcipher_set_mem_security(int);
 300 int sqlcipher_get_mem_security(void);
 301
 302 int sqlcipher_find_db_index(sqlite3 *db, const char *zDb);
 303
 304 int sqlcipher_codec_ctx_integrity_check(codec_ctx *, Parse *, char *);
 305
 306 int sqlcipher_set_log(const char *destination);
 307 int sqlcipher_set_log_level(unsigned int level);
 308 void sqlcipher_log(unsigned int tag, const char *message, ...);
 309
 310 #define SQLCIPHER_LOG_NONE          0x00
 311 #define SQLCIPHER_LOG_ERROR         0x01
 312 #define SQLCIPHER_LOG_WARN          0x02
 313 #define SQLCIPHER_LOG_INFO          0x04
 314 #define SQLCIPHER_LOG_DEBUG         0x08
 315 #define SQLCIPHER_LOG_TRACE         0xffffffff
 316
 317 #ifdef CODEC_DEBUG_PAGEDATA
 318 #define CODEC_HEXDUMP(DESC,BUFFER,LEN)  \
 319   { \
 320     int __pctr; \
 321     printf(DESC); \
 322     for(__pctr=0; __pctr < LEN; __pctr++) { \
 323       if(__pctr % 16 == 0) printf("\n%05x: ",__pctr); \
 324       printf("%02x ",((unsigned char*) BUFFER)[__pctr]); \
 325     } \
 326     printf("\n"); \
 327     fflush(stdout); \
 328   }
 329 #else
 330 #define CODEC_HEXDUMP(DESC,BUFFER,LEN)
 331 #endif
 332
 333 #endif
 334 #endif
 335 /* END SQLCIPHER */