Skip to content

Commit d9175b6

Browse files
sjlombardosjlombardo
committed
Partial revert of 3607cf6 to restore LibTomCrypt provider
1 parent 693abfa commit d9175b6

5 files changed

Lines changed: 326 additions & 0 deletions

File tree

‎Makefile.msc‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1403,6 +1403,7 @@ LIBRESOBJS =
14031403
SRC00 = \
14041404
$(TOP)\src\sqlcipher.c \
14051405
$(TOP)\src\crypto_cc.c \
1406+
$(TOP)\src\crypto_libtomcrypt.c \
14061407
$(TOP)\src\crypto_openssl.c \
14071408
$(TOP)\src\sqlcipher.h \
14081409
$(TOP)\src\alter.c \

‎main.mk‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -534,18 +534,22 @@ clean: clean-sanity-check
534534
SQLCIPHER_OBJ = \
535535
sqlcipher.o \
536536
crypto_openssl.o \
537+
crypto_libtomcrypt.o \
537538
crypto_cc.o
538539

539540
SQLCIPHER_SRC = \
540541
$(TOP)/src/sqlcipher.h \
541542
$(TOP)/src/sqlcipher.c \
543+
$(TOP)/src/crypto_libtomcrypt.c \
542544
$(TOP)/src/crypto_openssl.c \
543545
$(TOP)/src/crypto_cc.c
544546

545547
sqlcipher.o: $(TOP)/src/sqlcipher.c $(DEPS_OBJ_COMMON)
546548
$(T.cc.sqlite) $(CFLAGS.libsqlite3) -c $(TOP)/src/sqlcipher.c
547549
crypto_openssl.o: $(TOP)/src/crypto_openssl.c $(DEPS_OBJ_COMMON)
548550
$(T.cc.sqlite) $(CFLAGS.libsqlite3) -c $(TOP)/src/crypto_openssl.c
551+
crypto_libtomcrypt.o: $(TOP)/src/crypto_libtomcrypt.c $(DEPS_OBJ_COMMON)
552+
$(T.cc.sqlite) $(CFLAGS.libsqlite3) -c $(TOP)/src/crypto_libtomcrypt.c
549553
crypto_cc.o: $(TOP)/src/crypto_cc.c $(DEPS_OBJ_COMMON)
550554
$(T.cc.sqlite) $(CFLAGS.libsqlite3) -c $(TOP)/src/crypto_cc.c
551555

‎src/crypto_libtomcrypt.c‎

Lines changed: 316 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,316 @@
1+
/*
2+
** SQLCipher
3+
** http://sqlcipher.net
4+
**
5+
** Copyright (c) 2008 - 2013, ZETETIC LLC
6+
** All rights reserved.
7+
**
8+
** Redistribution and use in source and binary forms, with or without
9+
** modification, are permitted provided that the following conditions are met:
10+
** * Redistributions of source code must retain the above copyright
11+
** notice, this list of conditions and the following disclaimer.
12+
** * Redistributions in binary form must reproduce the above copyright
13+
** notice, this list of conditions and the following disclaimer in the
14+
** documentation and/or other materials provided with the distribution.
15+
** * Neither the name of the ZETETIC LLC nor the
16+
** names of its contributors may be used to endorse or promote products
17+
** derived from this software without specific prior written permission.
18+
**
19+
** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY
20+
** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21+
** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22+
** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY
23+
** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24+
** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25+
** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26+
** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27+
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28+
** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29+
**
30+
*/
31+
/* BEGIN SQLCIPHER */
32+
#ifdef SQLITE_HAS_CODEC
33+
#ifdef SQLCIPHER_CRYPTO_LIBTOMCRYPT
34+
#include "sqliteInt.h"
35+
#include "sqlcipher.h"
36+
#include <tomcrypt.h>
37+
38+
#define FORTUNA_MAX_SZ 32
39+
static prng_state prng;
40+
static volatile unsigned int ltc_init = 0;
41+
static volatile unsigned int ltc_ref_count = 0;
42+
43+
#define LTC_CIPHER "rijndael"
44+
45+
static int sqlcipher_ltc_add_random(void *ctx, const void *buffer, int length) {
46+
int rc = 0;
47+
int data_to_read = length;
48+
int block_sz = data_to_read < FORTUNA_MAX_SZ ? data_to_read : FORTUNA_MAX_SZ;
49+
const unsigned char * data = (const unsigned char *)buffer;
50+
51+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_add_random: entering SQLCIPHER_MUTEX_PROVIDER_RAND");
52+
sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND));
53+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_add_random: entered SQLCIPHER_MUTEX_PROVIDER_RAND");
54+
55+
while(data_to_read > 0){
56+
rc = fortuna_add_entropy(data, block_sz, &prng);
57+
rc = rc != CRYPT_OK ? SQLITE_ERROR : SQLITE_OK;
58+
if(rc != SQLITE_OK){
59+
break;
60+
}
61+
data_to_read -= block_sz;
62+
data += block_sz;
63+
block_sz = data_to_read < FORTUNA_MAX_SZ ? data_to_read : FORTUNA_MAX_SZ;
64+
}
65+
fortuna_ready(&prng);
66+
67+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_add_random: leaving SQLCIPHER_MUTEX_PROVIDER_RAND");
68+
sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND));
69+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_add_random: left SQLCIPHER_MUTEX_PROVIDER_RAND");
70+
71+
return rc;
72+
}
73+
74+
static int sqlcipher_ltc_activate(void *ctx) {
75+
unsigned char random_buffer[FORTUNA_MAX_SZ];
76+
int bytes = 0;
77+
78+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_activate: entering SQLCIPHER_MUTEX_PROVIDER_ACTIVATE");
79+
sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE));
80+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_activate: entered SQLCIPHER_MUTEX_PROVIDER_ACTIVATE");
81+
82+
sqlcipher_memset(random_buffer, 0, FORTUNA_MAX_SZ);
83+
if(ltc_init == 0) {
84+
if(register_prng(&fortuna_desc) < 0) return SQLITE_ERROR;
85+
if(register_cipher(&rijndael_desc) < 0) return SQLITE_ERROR;
86+
if(register_hash(&sha512_desc) < 0) return SQLITE_ERROR;
87+
if(register_hash(&sha256_desc) < 0) return SQLITE_ERROR;
88+
if(register_hash(&sha1_desc) < 0) return SQLITE_ERROR;
89+
if(fortuna_start(&prng) != CRYPT_OK) {
90+
return SQLITE_ERROR;
91+
}
92+
93+
ltc_init = 1;
94+
}
95+
ltc_ref_count++;
96+
97+
#ifndef SQLCIPHER_TEST
98+
bytes = rng_get_bytes(random_buffer, FORTUNA_MAX_SZ, NULL);
99+
#endif
100+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_PROVIDER, "sqlcipher_ltc_activate: seeded fortuna with %d bytes from rng_get_bytes", bytes);
101+
102+
if(sqlcipher_ltc_add_random(ctx, random_buffer, FORTUNA_MAX_SZ) != SQLITE_OK) {
103+
return SQLITE_ERROR;
104+
}
105+
sqlcipher_memset(random_buffer, 0, FORTUNA_MAX_SZ);
106+
107+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_activate: leaving SQLCIPHER_MUTEX_PROVIDER_ACTIVATE");
108+
sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE));
109+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_activate: left SQLCIPHER_MUTEX_PROVIDER_ACTIVATE");
110+
111+
return SQLITE_OK;
112+
}
113+
114+
static int sqlcipher_ltc_deactivate(void *ctx) {
115+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_deactivate: entering SQLCIPHER_MUTEX_PROVIDER_ACTIVATE");
116+
sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE));
117+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_deactivate: entered SQLCIPHER_MUTEX_PROVIDER_ACTIVATE");
118+
119+
ltc_ref_count--;
120+
if(ltc_ref_count == 0){
121+
fortuna_done(&prng);
122+
sqlcipher_memset((void *)&prng, 0, sizeof(prng));
123+
}
124+
125+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_deactivate: leaving SQLCIPHER_MUTEX_PROVIDER_ACTIVATE");
126+
sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE));
127+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_deactivate: left SQLCIPHER_MUTEX_PROVIDER_ACTIVATE");
128+
129+
return SQLITE_OK;
130+
}
131+
132+
static const char* sqlcipher_ltc_get_provider_name(void *ctx) {
133+
return "libtomcrypt";
134+
}
135+
136+
static const char* sqlcipher_ltc_get_provider_version(void *ctx) {
137+
return SCRYPT;
138+
}
139+
140+
static int sqlcipher_ltc_random(void *ctx, void *buffer, int length) {
141+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_random: entering SQLCIPHER_MUTEX_PROVIDER_RAND");
142+
sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND));
143+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_random: entered SQLCIPHER_MUTEX_PROVIDER_RAND");
144+
145+
fortuna_read(buffer, length, &prng);
146+
147+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_random: leaving SQLCIPHER_MUTEX_PROVIDER_RAND");
148+
sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND));
149+
sqlcipher_log(SQLCIPHER_LOG_TRACE, SQLCIPHER_LOG_MUTEX, "sqlcipher_ltc_random: left SQLCIPHER_MUTEX_PROVIDER_RAND");
150+
151+
return SQLITE_OK;
152+
}
153+
154+
static int sqlcipher_ltc_hmac(
155+
void *ctx, int algorithm,
156+
const unsigned char *hmac_key, int key_sz,
157+
const unsigned char *in, int in_sz,
158+
const unsigned char *in2, int in2_sz,
159+
unsigned char *out
160+
) {
161+
int rc, hash_idx;
162+
hmac_state hmac;
163+
unsigned long outlen;
164+
switch(algorithm) {
165+
case SQLCIPHER_HMAC_SHA1:
166+
hash_idx = find_hash("sha1");
167+
break;
168+
case SQLCIPHER_HMAC_SHA256:
169+
hash_idx = find_hash("sha256");
170+
break;
171+
case SQLCIPHER_HMAC_SHA512:
172+
hash_idx = find_hash("sha512");
173+
break;
174+
default:
175+
return SQLITE_ERROR;
176+
}
177+
178+
if(hash_idx < 0) return SQLITE_ERROR;
179+
outlen = hash_descriptor[hash_idx].hashsize;
180+
181+
if(in == NULL) return SQLITE_ERROR;
182+
if((rc = hmac_init(&hmac, hash_idx, hmac_key, key_sz)) != CRYPT_OK) return SQLITE_ERROR;
183+
if((rc = hmac_process(&hmac, in, in_sz)) != CRYPT_OK) return SQLITE_ERROR;
184+
if(in2 != NULL && (rc = hmac_process(&hmac, in2, in2_sz)) != CRYPT_OK) return SQLITE_ERROR;
185+
if((rc = hmac_done(&hmac, out, &outlen)) != CRYPT_OK) return SQLITE_ERROR;
186+
return SQLITE_OK;
187+
}
188+
189+
static int sqlcipher_ltc_kdf(
190+
void *ctx, int algorithm,
191+
const unsigned char *pass, int pass_sz,
192+
const unsigned char* salt, int salt_sz,
193+
int workfactor,
194+
int key_sz, unsigned char *key
195+
) {
196+
int rc, hash_idx;
197+
unsigned long outlen = key_sz;
198+
199+
switch(algorithm) {
200+
case SQLCIPHER_HMAC_SHA1:
201+
hash_idx = find_hash("sha1");
202+
break;
203+
case SQLCIPHER_HMAC_SHA256:
204+
hash_idx = find_hash("sha256");
205+
break;
206+
case SQLCIPHER_HMAC_SHA512:
207+
hash_idx = find_hash("sha512");
208+
break;
209+
default:
210+
return SQLITE_ERROR;
211+
}
212+
if(hash_idx < 0) return SQLITE_ERROR;
213+
214+
if((rc = pkcs_5_alg2(pass, pass_sz, salt, salt_sz,
215+
workfactor, hash_idx, key, &outlen)) != CRYPT_OK) {
216+
return SQLITE_ERROR;
217+
}
218+
return SQLITE_OK;
219+
}
220+
221+
static const char* sqlcipher_ltc_get_cipher(void *ctx) {
222+
return "aes-256-cbc";
223+
}
224+
225+
static int sqlcipher_ltc_cipher(
226+
void *ctx, int mode,
227+
const unsigned char *key, int key_sz,
228+
const unsigned char *iv,
229+
const unsigned char *in, int in_sz,
230+
unsigned char *out
231+
) {
232+
int rc, cipher_idx;
233+
symmetric_CBC cbc;
234+
235+
if((cipher_idx = find_cipher(LTC_CIPHER)) == -1) return SQLITE_ERROR;
236+
if((rc = cbc_start(cipher_idx, iv, key, key_sz, 0, &cbc)) != CRYPT_OK) return SQLITE_ERROR;
237+
rc = mode == SQLCIPHER_ENCRYPT ? cbc_encrypt(in, out, in_sz, &cbc) : cbc_decrypt(in, out, in_sz, &cbc);
238+
if(rc != CRYPT_OK) return SQLITE_ERROR;
239+
cbc_done(&cbc);
240+
return SQLITE_OK;
241+
}
242+
243+
static int sqlcipher_ltc_get_key_sz(void *ctx) {
244+
int cipher_idx = find_cipher(LTC_CIPHER);
245+
return cipher_descriptor[cipher_idx].max_key_length;
246+
}
247+
248+
static int sqlcipher_ltc_get_iv_sz(void *ctx) {
249+
int cipher_idx = find_cipher(LTC_CIPHER);
250+
return cipher_descriptor[cipher_idx].block_length;
251+
}
252+
253+
static int sqlcipher_ltc_get_block_sz(void *ctx) {
254+
int cipher_idx = find_cipher(LTC_CIPHER);
255+
return cipher_descriptor[cipher_idx].block_length;
256+
}
257+
258+
static int sqlcipher_ltc_get_hmac_sz(void *ctx, int algorithm) {
259+
int hash_idx;
260+
switch(algorithm) {
261+
case SQLCIPHER_HMAC_SHA1:
262+
hash_idx = find_hash("sha1");
263+
break;
264+
case SQLCIPHER_HMAC_SHA256:
265+
hash_idx = find_hash("sha256");
266+
break;
267+
case SQLCIPHER_HMAC_SHA512:
268+
hash_idx = find_hash("sha512");
269+
break;
270+
default:
271+
return 0;
272+
}
273+
274+
if(hash_idx < 0) return 0;
275+
276+
return hash_descriptor[hash_idx].hashsize;
277+
}
278+
279+
static int sqlcipher_ltc_ctx_init(void **ctx) {
280+
sqlcipher_ltc_activate(NULL);
281+
return SQLITE_OK;
282+
}
283+
284+
static int sqlcipher_ltc_ctx_free(void **ctx) {
285+
sqlcipher_ltc_deactivate(&ctx);
286+
return SQLITE_OK;
287+
}
288+
289+
static int sqlcipher_ltc_fips_status(void *ctx) {
290+
return 0;
291+
}
292+
293+
int sqlcipher_ltc_setup(sqlcipher_provider *p) {
294+
p->init = NULL;
295+
p->shutdown = NULL;
296+
p->get_provider_name = sqlcipher_ltc_get_provider_name;
297+
p->random = sqlcipher_ltc_random;
298+
p->hmac = sqlcipher_ltc_hmac;
299+
p->kdf = sqlcipher_ltc_kdf;
300+
p->cipher = sqlcipher_ltc_cipher;
301+
p->get_cipher = sqlcipher_ltc_get_cipher;
302+
p->get_key_sz = sqlcipher_ltc_get_key_sz;
303+
p->get_iv_sz = sqlcipher_ltc_get_iv_sz;
304+
p->get_block_sz = sqlcipher_ltc_get_block_sz;
305+
p->get_hmac_sz = sqlcipher_ltc_get_hmac_sz;
306+
p->ctx_init = sqlcipher_ltc_ctx_init;
307+
p->ctx_free = sqlcipher_ltc_ctx_free;
308+
p->add_random = sqlcipher_ltc_add_random;
309+
p->fips_status = sqlcipher_ltc_fips_status;
310+
p->get_provider_version = sqlcipher_ltc_get_provider_version;
311+
return SQLITE_OK;
312+
}
313+
314+
#endif
315+
#endif
316+
/* END SQLCIPHER */

‎src/sqlcipher.c‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -84,6 +84,7 @@ void sqlite3pager_reset(Pager *pPager);
8484
/* end extensions defined in pager.c */
8585

8686
#if !defined (SQLCIPHER_CRYPTO_CC) \
87+
&& !defined (SQLCIPHER_CRYPTO_LIBTOMCRYPT) \
8788
&& !defined (SQLCIPHER_CRYPTO_OPENSSL) \
8889
&& !defined (SQLCIPHER_CRYPTO_CUSTOM)
8990
#define SQLCIPHER_CRYPTO_OPENSSL
@@ -504,6 +505,9 @@ int sqlcipher_extra_init(const char* arg) {
504505
#if defined (SQLCIPHER_CRYPTO_CC)
505506
extern int sqlcipher_cc_setup(sqlcipher_provider *p);
506507
sqlcipher_cc_setup(p);
508+
#elif defined (SQLCIPHER_CRYPTO_LIBTOMCRYPT)
509+
extern int sqlcipher_ltc_setup(sqlcipher_provider *p);
510+
sqlcipher_ltc_setup(p);
507511
#elif defined (SQLCIPHER_CRYPTO_OPENSSL)
508512
extern int sqlcipher_openssl_setup(sqlcipher_provider *p);
509513
sqlcipher_openssl_setup(p);

‎tool/mksqlite3c.tcl‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -436,6 +436,7 @@ set flist {
436436
memjournal.c
437437

438438
sqlcipher.c
439+
crypto_libtomcrypt.c
439440
crypto_openssl.c
440441
crypto_cc.c
441442

0 commit comments

Comments
 (0)