作者：	peliao (国家电位) ▲▲▲▲▲ – 盒子活跃会员	2009-10-14 21:33:45
标题：	sqlite3.6.18加密模块change(讨论) 附asqlite控件bug 浏览:4467	加入我的收藏
楼主：	很多人使用xxtea的sqlite加密 3.6.18版， sqlite3PagerSetCodec变化非常大 static void sqlite3PagerSetCodec( Pager *pPager, void *(*xCodec)(void*,void*,Pgno,int), void (*xCodecSizeChng)(void*,int,int),  //新加的 void (*xCodecFree)(void*), //新加的 void *pCodec //对应原来的 pCodecArg另外，xxtea中（如下），  pAux 和 xFreeAux  已经完全消失了 db->aDb[0].pAux = pBlock; db->aDb[0].xFreeAux = DestroyCryptBlock;**** 问题： xFreeAux 能否用 xCodecFree 代替， 代替后，xxtea怎么变动   **** 关于asqlite 风铃兄的sqlite控件看样子是改的disqlite的，对dataset数据行buffer存取 比asqlite好，但太过庞大，且最重要的bug：固定大小varchar截取问题，以及text支持不太好，不支持多条sql语言同时执行（带“；”的sql） asqlite官版在操作text及widestring上，read做了很多次重复widestring转换，效率低，unicode更是有转换bug ———————————————- 3291763

作者：	ntp2000 (ntp2000) ▲▲▲▲△ – 普通会员	2009-10-14 22:35:47
1楼：	今天刚好改 风铃兄 的sqlite,随便说说,不对的请大家指正.   sqlite3PagerSetCodec变化非常大 static void sqlite3PagerSetCodec( Pager *pPager, void *(*xCodec)(void*,void*,Pgno,int), void (*xCodecSizeChng)(void*,int,int),  //新加的 void (*xCodecFree)(void*), //新加的 void *pCodec //对应原来的 pCodecArg xCodecSizeChng 更改page大小时候调用的函数，暂时没用上直接NULL xCodecFree 其实就是代替了xFreeAux的作用，现在释放page,不用我们自己做了。 DestroyCryptBlock 函数要改一下参数类型，不然编译不过。 用20M的Demo测试，未发现明显问题。 ———————————————- –

作者：	laihongbo (风铃夜思雨) ▲▲▲▲△ – 普通会员	2009-10-15 0:42:25
2楼：	即然你都提了,我也发我最新修改的xxteacrypt.c代码   #ifdef SQLITE_SOURCESTD #include <pager.c> #else #include <sqlite3.c> #endif #ifndef SQLITE_OMIT_DISKIO #ifdef SQLITE_HAS_CODEC #include “md5c.c” #define CRYPT_OFFSET 8 #define BYTE unsigned char #define WX_PAGER_MJ_PGNO(x) ((PENDING_BYTE/(x))+1) Btree *m_bt; typedef struct _CryptBlock { BYTE*     ReadKey;     // 读数据库和写入事务的密钥 BYTE*     WriteKey;    // 写入数据库的密钥 int       PageSize;    // 页的大小 BYTE*     Data; } CryptBlock, *LPCryptBlock; int xxtea( int * v, int n , int * k ) { unsigned int z/*=v[n-1]*/, y=v[0], sum=0,  e,    DELTA=0x9e3779b9 ; int m, p, q ; if ( n>1) { /* Coding Part */ z = v[n-1]; q = 6+52/n ; while ( q– > 0 ) { sum += DELTA ; e = sum >> 2&3 ; for ( p = 0 ; p < n-1 ; p++ ){ y = v[p+1], z = v[p] += (z>>5^y<<2)+(y>>3^z<<4)^(sum^y)+(k[p&3^e]^z); } y = v[0] ; z = v[n-1] += (z>>5^y<<2)+(y>>3^z<<4)^(sum^y)+(k[p&3^e]^z); } return 0 ; /* Decoding Part */ }else if ( n <-1 ) { n = -n ; q = 6+52/n ; sum = q*DELTA ; while (sum != 0) { e = sum>>2 & 3 ; for (p = n-1 ; p > 0 ; p– ){ z = v[p-1], y = v[p] -= (z>>5^y<<2)+(y>>3^z<<4)^(sum^y)+(k[p&3^e]^z); } z = v[n-1] ; y = v[0] -= (z>>5^y<<2)+(y>>3^z<<4)^(sum^y)+(k[p&3^e]^z); sum -= DELTA ; } return 0 ; } return 1 ; } /* Signal n=0,1,-1 */ void sqlite3_activate_see(const char *info) { } void sqlite3CodecSizeChange(void *pArg, int pageSize, int reservedSize) { } /* ** Get the codec argument for this pager */ void* mySqlite3PagerGetCodec( Pager *pPager ){ #if (SQLITE_VERSION_NUMBER >= 3006016) return sqlite3PagerGetCodec(pPager); #else return (pPager->xCodec) ? pPager->pCodecArg : NULL; #endif } /* ** Set the codec argument for this pager */ void mySqlite3PagerSetCodec( Pager *pPager, void *(*xCodec)(void*,void*,Pgno,int), void (*xCodecSizeChng)(void*,int,int), void (*xCodecFree)(void*), void *pCodec ){ sqlite3PagerSetCodec(pPager, xCodec, xCodecSizeChng, xCodecFree, pCodec); } //创建或更新一个页的加密算法索引.此函数会申请缓冲区. static LPCryptBlock CreateCryptBlock(BYTE* hKey, Pager *pager, LPCryptBlock pExisting) { LPCryptBlock pBlock; if (!pExisting) //创建新加密块 { pBlock = sqlite3_malloc(sizeof(CryptBlock)); ZeroMemory(pBlock, sizeof(CryptBlock)); pBlock->ReadKey = hKey; pBlock->WriteKey = hKey; pBlock->PageSize = pager->pageSize; pBlock->Data = (BYTE*)sqlite3_malloc(pBlock->PageSize + CRYPT_OFFSET); } else //更新存在的加密块 { pBlock = pExisting; if ( pBlock->PageSize != pager->pageSize && !pBlock->Data){ sqlite3_free(pBlock->Data); pBlock->PageSize = pager->pageSize; pBlock->Data = (BYTE*)sqlite3_malloc(pBlock->PageSize + CRYPT_OFFSET); } } ZeroMemory(pBlock->Data, pBlock->PageSize + CRYPT_OFFSET); return pBlock; } //销毁一个加密块及相关的缓冲区,密钥. static void DestroyCryptBlock(LPCryptBlock pBlock) { //销毁读密钥. if (pBlock->ReadKey){ sqlite3_free(pBlock->ReadKey); } //如果写密钥存在并且不等于读密钥,也销毁. if (pBlock->WriteKey && pBlock->WriteKey != pBlock->ReadKey){ sqlite3_free(pBlock->WriteKey); } if(pBlock->Data){ sqlite3_free(pBlock->Data); } //释放加密块. sqlite3_free(pBlock); } // 释放与一个页相关的加密块 void sqlite3CodecFree(void *pArg) { if (pArg) DestroyCryptBlock((LPCryptBlock)pArg); } //加密/解密函数, 被pager调用 void * sqlite3Codec(void *pArg, BYTE *data, Pgno nPageNum, int nMode) { LPCryptBlock pBlock = (LPCryptBlock)pArg; int len = 0; if (!pBlock) return data; // 确保pager的页长度和加密块的页长度相等.如果改变,就需要调整. if (nMode != 2) { Pager *pageHeader = sqlite3BtreePager(m_bt); if (pageHeader->pageSize != pBlock->PageSize)  //适用旧版 { CreateCryptBlock(0, pageHeader, pBlock); } } switch(nMode) { case 0: // Undo a “case 7” journal file encryption case 2: //重载一个页 case 3: //载入一个页 if (!pBlock->ReadKey) break; len = 0 – (pBlock->PageSize / 4); xxtea(data, len, pBlock->ReadKey); break; case 6: //加密一个主数据库文件的页 if (!pBlock->WriteKey) break; CopyMemory(pBlock->Data + CRYPT_OFFSET, data, pBlock->PageSize); data = pBlock->Data + CRYPT_OFFSET; len = pBlock->PageSize / 4; xxtea(data , len, pBlock->WriteKey); break; case 7: //加密事务文件的页 /*在正常环境下, 读密钥和写密钥相同. 当数据库是被重新加密的,读密钥和写密钥未必相同. 回滚事务必要用数据库文件的原始密钥写入.因此,当一次回滚被写入,总是用数据库的读密钥, 这是为了保证与读取原始数据的密钥相同. */ if (!pBlock->ReadKey) break; CopyMemory(pBlock->Data + CRYPT_OFFSET, data, pBlock->PageSize); data = pBlock->Data + CRYPT_OFFSET; len = pBlock->PageSize / 4; xxtea(data, len, pBlock->ReadKey); break; } return data; } // 从用户提供的缓冲区中得到一个加密密钥 static BYTE * DeriveKey(const void *pKey, int nKeyLen) { BYTE *  hKey = NULL; BYTE *  digest = NULL; MD5_CTX md5ctx; if ((pKey == NULL) || (nKeyLen <1 )) { return NULL; } digest = sqlite3_malloc(16); MD5Init(&md5ctx); MD5Update(&md5ctx, (unsigned char*)pKey, nKeyLen); MD5Final(digest, &md5ctx); hKey = digest; return hKey; } //被sqlite 和 sqlite3_key_interop 调用, 附加密钥到数据库. int sqlite3CodecAttach(sqlite3 *db, int nDb, const void *pKey, int nKeyLen) { int rc = SQLITE_ERROR; BYTE* hKey = 0; //如果没有指定密匙,可能标识用了主数据库的加密或没加密. if (!pKey || !nKeyLen) { if (!nDb) { return SQLITE_OK; //主数据库, 没有指定密钥所以没有加密. } else //附加数据库,使用主数据库的密钥. { //获取主数据库的加密块并复制密钥给附加数据库使用 LPCryptBlock pBlock = (LPCryptBlock)mySqlite3PagerGetCodec(sqlite3BtreePager(db->aDb[0].pBt)); if (!pBlock) return SQLITE_OK; //主数据库没有加密 if (!pBlock->ReadKey) return SQLITE_OK; //没有加密 memcpy(pBlock->ReadKey, &hKey, 16); } } else //用户提供了密码,从中创建密钥. { hKey = DeriveKey(pKey, nKeyLen); } //创建一个新的加密块,并将解码器指向新的附加数据库. if (hKey) { LPCryptBlock pBlock = CreateCryptBlock(hKey, sqlite3BtreePager(db->aDb[nDb].pBt), NULL); m_bt = db->aDb[nDb].pBt; #if (SQLITE_VERSION_NUMBER >= 3006016) mySqlite3PagerSetCodec(sqlite3BtreePager(db->aDb[nDb].pBt), sqlite3Codec, sqlite3CodecSizeChange, sqlite3CodecFree, pBlock); #else #if (SQLITE_VERSION_NUMBER >= 3003014) sqlite3PagerSetCodec(sqlite3BtreePager(db->aDb[nDb].pBt), sqlite3Codec, pBlock); #else sqlite3pager_set_codec(sqlite3BtreePager(db->aDb[nDb].pBt), sqlite3Codec, pBlock); #endif db->aDb[nDb].pAux = pBlock; db->aDb[nDb].xFreeAux = sqlite3CodecFree; #endif rc = SQLITE_OK; } return rc; } //不保存用户的原始密码.返回NULL. void sqlite3CodecGetKey(sqlite3 *db, int nDb, void **ppKey, int *pnKeyLen) { *ppKey = NULL; *pnKeyLen = 0; } //密钥并不保留到临时空间,仅保存于主数据库. int sqlite3_key_interop(sqlite3 *db, const void *pKey, int nKeySize) { return sqlite3CodecAttach(db, 0, pKey, nKeySize); } //改变已有数据库的加密密钥 int sqlite3_rekey_interop(sqlite3 *db, const void *pKey, int nKeySize) { Btree *pbt = db->aDb[0].pBt; Pager *pPager = sqlite3BtreePager(pbt); LPCryptBlock pBlock = (LPCryptBlock)mySqlite3PagerGetCodec(pPager); BYTE * hKey = DeriveKey(pKey, nKeySize); int rc = SQLITE_ERROR; if (!pBlock && !hKey) return SQLITE_OK; //重新加密一个数据库,改变pager的写密钥, 读密钥依旧保留. if (!pBlock) //加密一个未加密的数据库 { pBlock = CreateCryptBlock(hKey, pPager, NULL); pBlock->ReadKey = 0; // 原始数据库未加密 m_bt = db->aDb[0].pBt; #if (SQLITE_VERSION_NUMBER >= 3006016) mySqlite3PagerSetCodec(pPager, sqlite3Codec, sqlite3CodecSizeChange, sqlite3CodecFree, pBlock); #else #if (SQLITE_VERSION_NUMBER >= 3003014) sqlite3PagerSetCodec(sqlite3BtreePager(pbt), sqlite3Codec, pBlock); #else sqlite3pager_set_codec(pPager, sqlite3Codec, pBlock); #endif db->aDb[0].pAux = pBlock; db->aDb[0].xFreeAux = sqlite3CodecFree; #endif } else // 改变已加密数据库的写密钥 { pBlock->WriteKey = hKey; } // 开始一个事务 rc = sqlite3BtreeBeginTrans(pbt, 1); if (!rc) { // 用新密钥重写所有的页到数据库。 #if (SQLITE_VERSION_NUMBER >= 3006000) int nPageCount = -1; int rc = sqlite3PagerPagecount(pPager, &nPageCount); Pgno nPage = (Pgno) nPageCount; #elif (SQLITE_VERSION_NUMBER >= 3003014) Pgno nPage = sqlite3PagerPagecount(pPager); #else Pgno nPage = sqlite3pager_pagecount(pPager); #endif int pageSize = sqlite3BtreeGetPageSize(pbt); Pgno nSkip = WX_PAGER_MJ_PGNO(pageSize); #if (SQLITE_VERSION_NUMBER >= 3003014) DbPage *pPage; #else void *pPage; #endif Pgno n; for(n = 1; rc == SQLITE_OK && n <= nPage; n ++) { if (n == nSkip) continue; #if (SQLITE_VERSION_NUMBER >= 3003014) rc = sqlite3PagerGet(pPager, n, &pPage); #else rc = sqlite3pager_get(pPager, n, &pPage); #endif if(!rc) { #if (SQLITE_VERSION_NUMBER >= 3003014) rc = sqlite3PagerWrite(pPage); sqlite3PagerUnref(pPage); #else rc = sqlite3pager_write(pPage); sqlite3pager_unref(pPage); #endif } } } // 如果成功，提交事务。 if (!rc) { rc = sqlite3BtreeCommit(pbt); } // 如果失败，回滚。 if (rc) { sqlite3BtreeRollback(pbt); } // 如果成功，销毁先前的读密钥。并使读密钥等于当前的写密钥。 if (!rc) { if (pBlock->ReadKey) { sqlite3_free(pBlock->ReadKey); } pBlock->ReadKey = pBlock->WriteKey; } else// 如果失败，销毁当前的写密钥，并恢复为当前的读密钥。 { if (pBlock->WriteKey) { sqlite3_free(pBlock->WriteKey); } pBlock->WriteKey = pBlock->ReadKey; } // 如果读密钥和写密钥皆为空，就不需要再对页进行编解码。 // 销毁加密块并移除页的编解码器 if (!pBlock->ReadKey && !pBlock->WriteKey) { #if (SQLITE_VERSION_NUMBER >= 3006016) mySqlite3PagerSetCodec(pPager, NULL, NULL, NULL, NULL); #else #if (SQLITE_VERSION_NUMBER >= 3003014) sqlite3PagerSetCodec(pPager, NULL, NULL); #else sqlite3pager_set_codec(pPager, NULL, NULL); #endif db->aDb[0].pAux = NULL; db->aDb[0].xFreeAux = NULL; sqlite3CodecFree(pBlock); #endif } return rc; } SQLITE_API int sqlite3_key(sqlite3 *db, const void *pKey, int nKey) { return sqlite3_key_interop(db, pKey, nKey); } SQLITE_API int sqlite3_rekey(sqlite3 *db, const void *pKey, int nKey) { return sqlite3_rekey_interop(db, pKey, nKey); } #endif // SQLITE_HAS_CODEC #endif // SQLITE_OMIT_DISKIO ———————————————- –

作者：	ntp2000 (ntp2000) ▲▲▲▲△ – 普通会员	2009-10-15 9:11:29
3楼：	非常感谢,改的比我完善多了. 其实按风兄的思路,改UniDAC的liteprovier支持 sqlite3密码也很简单,这样UniDAC也能支持读取带密码的sqlite3数据库了. ———————————————- –

作者：	peliao (国家电位) ▲▲▲▲▲ – 盒子活跃会员	2009-10-15 10:37:14
4楼：	谢谢风铃兄修改的xxtea, 这下可以兼容旧的版本了 ———————————————-3291763

作者：	ntp2000 (ntp2000) ▲▲▲▲△ – 普通会员	2009-10-15 12:03:04
5楼：	另外如果用的BDS2010的话,用BDS2010自带的cw32.lib测试20M Demo   内存占用约多7%, 但速度约快7% ———————————————- –

作者：	peliao (国家电位) ▲▲▲▲▲ – 盒子活跃会员	2009-11-16 13:28:31
6楼：	最好，接过讨论一下风兄的AES加密版的sqlite，如何让bcc32编译通过 ———————————————-3291763

作者：	capelin (多春鱼) ▲▲▲▲▲ – 盒子活跃会员	2010-2-25 23:05:40
7楼：	我一直想改unidac支持加密的sqlite，但没成功，有谁可以贴出代码？感谢！ ———————————————- –

作者：	capelin (多春鱼) ▲▲▲▲▲ – 盒子活跃会员	2010-3-2 14:01:24
8楼：	有谁可以告诉我如何修改unidac让它支持wxsqlite3.dll的加密功能？我修改了litecalluni.pas和sqliteclassesuni.pas，但都没有成功。 ———————————————- –

作者：	jone_h (dodo) ▲▲▲▲△ – 普通会员	2010-3-28 19:05:19
9楼：	ntp2000 :你可发一个带密码的SQlite3.dll和一个支持SQLite加密功能的UniDac组件吗？谢谢~~ ———————————————- 没有最好，只有更好！

作者：	we96127i (weiweijie) ▲▲△△△ – 注册会员	2012-7-3 11:52:47
10楼：	我把这些方法移植到3.7.13的源码中发现这个不能加密，原来能看到的数据加密后任然可见.后面发现xxtea这个算法根本就没被调用,即使赋值给sqlite3中pager->xCodec后也没见做任何操作，请问这是为什么不能加密。是不是这组代码不完善啊？还有就是如果我需要在linux下编译添加接口后的sqlite3如何编译呢？求大侠尽快回复！！ ———————————————- –

作者：	we96127i (weiweijie) ▲▲△△△ – 注册会员	2012-7-3 13:42:47
11楼：	有人帮我解释一下这是为什么啊?加密部分函数mySqlite3PagerSetCodec这个函数什么都没做啊。 ———————————————- –

作者：	we96127i (weiweijie) ▲▲△△△ – 注册会员	2012-7-3 16:50:55
12楼：	加密/解密函数, 被pager调用sqlite3Codec这个函数是在哪里被调用的呢 ———————————————- –

作者：	cool_fish (fish) ▲▲△△△ – 注册会员	2012-7-10 12:57:39
13楼：	楼主，可不可以指导一下如何实现这个sqlite数据库的加密功能，真心急用呀。 ———————————————- 交朋友

作者：	cool_fish (fish) ▲▲△△△ – 注册会员	2012-7-10 13:21:33
14楼：	另外楼主，你的sqlite3Codec()这个函数中的CopyMemory(pBlock->Data + CRYPT_OFFSET, data, pBlock->PageSize);这个函数是从哪来的呢？ ———————————————- 交朋友

sqlite3 加解密

(2013-08-27 09:12:35)

转载▼

分类：

SQLite3（5）

SQLITE3 加密总结 (sqlite 3.6.12版本)
董淳光 42530 (老工号)
dcg1981@163.com
2009年4月9日星期四
I. 序 1
II. 问题初分析 2
III. 研究结果(附代码) 3
IV. 可靠性 17
V. 关键点说明 17
I. 序
时隔上次写《Sqlite3 使用总结》已过去2年。这2年时间我做了好些对自己人生影响很大的事情。
不扯太远了。2年来一直想把 sqlite3 的加密搞清楚一些，但一直没时间去做。这两天终于有空坐下来研究 sqlite3 的加密方法。有点收获。记录下来免得忘记。
我写本文章时，sqlite3 最新版本是 3.6.12 。我就以这个版本的源代码为例进行分析。并且，我喜欢它那整合代码，整合成一个 .c 和一个 .h 文件。虽然在 vc2003 里编辑慢如蜗牛，但是一旦编辑好，以后使用起来不至于每个工程都拖上一堆文件。工程简洁方便。所以下面的叙述全部都是以 sqlite3 v3.6.12 整合的源代码为基础展开。
我认为未来 sqlite3 v3.XX 的整合版本大体上都可以用下面介绍的代码进行加解密。Sqlite3 在版本变化中，有一些宏、函数被改名，读者很容易查出来并自己修正。也有一些函数会被丢弃。读者应该也可以自行分析出来。我下面的代码尽可能保持与 sqlite 版本的兼容性。不使用那些容易被丢弃的结构或函数。这样以后就不会常常有人发邮件咨询我能否制作一个最新版本sqlite加密了。

II. 问题初分析
首先是要理清 sqlite3 加解密思路。这点在2年前就没有做到位。
我本人愚笨，不擅长凭空分析太抽象的事情。对于软件问题最希望的就是边看现象边理解。分析 sqlite3 加密思路也采用具体现象具体分析的方法。
还是 vc2003 编译器（使用其它编译器的读者可以自行对应着设置，我下面的叙述并没有使用过多的vc2003 编译技巧，对应到 vc2005、2008，甚至 unix 下的 cc 等等都是通用的）。首先在工程属性里的“C/C++”选项里找到“命令行”，如图：

自己手工敲上“/D “SQLITE_HAS_CODEC””。 这个意思是在整个工程里预先 define “SQLITE_HAS_CODEC”这个宏。
这个宏是 sqlite3 作者留下的加密接口。缺省没有这个宏， sqlite3 就是不加密的标准版。定义有这个宏，那么就是要开启加密功能。
设定好宏后，开始编译。
结果，问题现象就出现了：
testSqliteEnc error LNK2019: 无法解析的外部符号 _sqlite3_activate_see ，该符号在函数 _sqlite3Pragma 中被引用
testSqliteEnc error LNK2019: 无法解析的外部符号 _sqlite3_key ，该符号在函数 _sqlite3Pragma 中被引用
testSqliteEnc error LNK2019: 无法解析的外部符号 _sqlite3_rekey ，该符号在函数 _sqlite3Pragma 中被引用
testSqliteEnc error LNK2019: 无法解析的外部符号 _sqlite3CodecAttach ，该符号在函数 _attachFunc 中被引用
testSqliteEnc error LNK2019: 无法解析的外部符号 _sqlite3CodecGetKey ，该符号在函数 _attachFunc 中被引用

意思很明显，有这些函数的定义，但作者没有实现这些函数。需要我们自己实现。反之，大概实现了这些函数后就能进行加密了。
III. 研究结果
参阅了网上某文章，照着他的做法的确可以做出加密效果。在这里十分感谢那文章的作者。
但我并不满足于此。我无法确认人家的代码有没有问题。而且看过他代码，觉得封装程度也并不好。
于是希望通过一些研究判断人家代码可靠性。同时更进一步进行封装。
研究过程不再赘述，无非就是简单编写先前编译缺少的那些函数体，再对照网上代码编写那些函数内容，然后反复参考、单步调试sqlite3源代码。
这里直接给出最终结果。下面章节再简述关键点。
我本想做到另外建立配套程序文件来实现，力求跟原始 sqlite.c 文件全兼容，但可惜的是加解密需要操作sqlite内部数据结构以及内部函数，这些函数和结构没有在 sqlite3.h 头文件里定义。所以我不得不把代码写到了 sqlite3.c 文件里。
最终结果虽然是要修改 sqlite.c 文件，但我已经让修改地方尽量少。这样改起来不容易出错。
修改地方总共加有 3 处，这3处都是添加代码，不需要修改，也没有删除。
需要添加的代码下面全部都有。Sqlite3.c 里需要添加代码的位置大概如下图所示：

下面列出源码。
打开 sqlite3.c 文件。在最顶端添加:
#ifdef SQLITE_HAS_CODEC
void DestroyKeyInBtree(void * lpTree );
#define MY_DESTROY_KEY(BTREE) DestroyKeyInBtree (BTREE)
#else
#define MY_DESTROY_KEY(BTREE)
#endif
这段代码用于释放我们自己分配的密钥数据块。密钥数据块都是我们申请的内存，当数据库关闭时，我希望能释放密钥块内存，否则内存泄露。
但是，sqlite3没有提供数据库关闭进行释放密钥块的接口，得自己添加。
根据网上代码分析，我们释放密钥块时需要获得指定的数据库 BTree 结构体。因为每个密钥块是关联到特定的数据库BTree结构体上的。
通过分析代码，不难找到 sqlite3_close 会调用下面这个函数
SQLITE_PRIVATE int sqlite3BtreeClose(Btree *p)
这是 sqlite3 的函数。我确认销毁密钥块的时机就是在这个函数里。
搜索到这代码：
sqlite3BtreeRollback(p);
sqlite3BtreeLeave(p);
就在 Leave 后面添加我们销毁功能，如下：
/* Rollback any active transaction and free the handle structure.
The call to sqlite3BtreeRollback() drops any table-locks held by
this handle.
*/
sqlite3BtreeRollback(p);
sqlite3BtreeLeave(p);

MY_DESTROY_KEY(p ); // 我们添加的删除密钥的功能

/* If there are still other outstanding references to the shared-btree
structure, return now. The remainder of this procedure cleans
up the shared-btree.
*/
assert(p->wantToLock==0 && p->locked==0 );
这个销毁时机不能再往后放了，再往后BTree相关结构体都已被销毁，我们再从它里面获取我们密钥块指针就会崩溃。因此在我上面代码那里销毁时机刚好。

接下来修改就简单了。
直接拖到最末尾，3.6.12 版本的最后两行有效代码应该是：
#endif /* defined(SQLITE_ENABLE_ICU) */
#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
就在最后那个 endif 后面添加我下面列出来的所有代码。
//////////////////////////////////////////////////////////////////////////
////////////////////下面是我们自己添加的加密函数实现//////////////////////
//////////////////////我认为每个版本的整合sqlite//////////////////////////
////////////////////////只要添加这些函数就可以实现加密功能////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
#ifndef SQLITE_HAS_CODEC
#ifdef WIN32
#pragma message(“We do not use encryption”)
#endif

#else
#include “./Encrypt.h”
#ifdef WIN32
#pragma message(“&&&&&&&& We use encryption ! &&&&&&&&”)
#endif
/*
下面结构体是我们封装的一个中间结构体
目的是为了给用户加解密环境提供更为独立的功能，不依赖一些 sqlite 莫名其妙设计带来的骚扰
结构体中的 lpUserBlock 才是用户自己 DeriveKey 返回的结构体
*/
struct _TmpUserKeyBlock
{
void * lpUserBlock_old;
void * lpUserBlock_new;
};
typedef struct _TMP_ENCRYPT_BLOCK
{
struct _TmpUserKeyBlock lpUserKey;
int iPageSize;

int iEncryptingBufSize;
char pEncryptingBuf[1];
} TMP_ENCRYPT_BLOCK, * PTMP_ENCRYPT_BLOCK;

/*
下面是对用户 DeriveKey、CopyKey、DestroyKey 的封装。
封装目的是sqlite解密和加密操作的目标数据内存是不一样的。如果不加以封装，后面编写加解密函数就
不得不考虑这些细节。封装后用户函数就不需要再考虑这些部分了。
*/
PTMP_ENCRYPT_BLOCK DeriveKey_Tmp(const void *pKey, int nKeyLen, int iPageSize )
{
void * pUserKey;
PTMP_ENCRYPT_BLOCK pTmpBlock;
int iSize = iPageSize + 128;

if( NULL == pKey || 0 == nKeyLen )
{
return NULL;
}

pTmpBlock = (PTMP_ENCRYPT_BLOCK)malloc( sizeof(TMP_ENCRYPT_BLOCK) + iSize );
if( NULL == pTmpBlock )
{
return NULL;
}
pTmpBlock->iEncryptingBufSize = iSize; // +128 是为了多分配一些内存，免得跟sqlite打交道哪里出现溢出
pTmpBlock->iPageSize = iPageSize;
pUserKey = (void*)DeriveKey( pKey, nKeyLen, iPageSize );
if( NULL == pUserKey )
{
free( pTmpBlock );
return NULL;
}

// 刚开始时，新旧密钥应该都一致

pTmpBlock->lpUserKey.lpUserBlock_old = pUserKey;
pTmpBlock->lpUserKey.lpUserBlock_new = pUserKey;
return pTmpBlock;
}

// 复制一份数据库
PTMP_ENCRYPT_BLOCK CopyKey_Tmp( const PTMP_ENCRYPT_BLOCK lpKey )
{
PTMP_ENCRYPT_BLOCK pNew;
void * pUserKey;
int iSize;

if( NULL == lpKey )
return NULL;

iSize = lpKey->iEncryptingBufSize;
pNew = (PTMP_ENCRYPT_BLOCK)malloc( iSize + sizeof(TMP_ENCRYPT_BLOCK) );
if( NULL == pNew )
return NULL;

pUserKey = CopyKey( lpKey->lpUserKey.lpUserBlock_new );
if( NULL == pUserKey )
{
free( pNew );
return NULL;
}

pNew->lpUserKey.lpUserBlock_old = pUserKey;
pNew->lpUserKey.lpUserBlock_new = pUserKey;
pNew->iPageSize = lpKey->iPageSize;
pNew->iEncryptingBufSize = iSize;

return pNew;
}

// 释放密钥
void DestroyKey_Tmp( PTMP_ENCRYPT_BLOCK lpKey )
{
if( NULL == lpKey )
return;
if( NULL != lpKey->lpUserKey.lpUserBlock_new )
DestroyKey( lpKey->lpUserKey.lpUserBlock_new );
free( lpKey );
return;
}
// 文件加密解密的中间函数
// 本函数做简单处理之后会调用 My_sqlite3Codec 函数
// nMode 类型:
// case 0: // Undo a “case 7” journal file encryption
// case 2: // Reload a page
// case 3: // Load a page
// case 6: // Encrypt a page for the main database file
// case 7: // Encrypt a page for the journal file
void * My_sqlite3Codec_tmp(void *pArg, void *data, unsigned int nPageNum, int nMode)
{
PTMP_ENCRYPT_BLOCK lpTmpArg;
void *lpRet;
void * lpUserKey;

if (!pArg)
{
return data;
}

lpTmpArg = (PTMP_ENCRYPT_BLOCK) pArg;
if( nMode <= 5 )
{
// 解密
lpRet = data;
lpUserKey = lpTmpArg->lpUserKey.lpUserBlock_old;
}
else
{
// 加密
lpRet = lpTmpArg->pEncryptingBuf;
memcpy( lpRet, data, lpTmpArg->iPageSize );

if( nMode == 7 )
{
// 操作事务文件，需要用旧密钥
lpUserKey = lpTmpArg->lpUserKey.lpUserBlock_old;
}
else
{
// 否则就是写入数据库页面，用新密钥
lpUserKey = lpTmpArg->lpUserKey.lpUserBlock_new;
}
}
if( NULL == lpUserKey )
return lpRet;
My_sqlite3Codec( lpUserKey, lpRet, lpTmpArg->iPageSize, nPageNum, nMode );
return lpRet;
}

// 用于重设密钥
static void * My_sqlite3pager_get_codecarg(Pager *pPager)
{
return (pPager->xCodec) ? pPager->pCodecArg: NULL;
}

/*
设置数据库页面加解密参数
*/
void My_sqlite3pager_set_codec( Pager *pPager, void *(*xCodec)(void*,void*,Pgno,int), void *pCodecArg )
{
pPager->xCodec = xCodec;
pPager->pCodecArg = pCodecArg;
}

/*
** 返回数据库磁盘文件总页面数
** If the PENDING_BYTE lies on the page directly after the end of the
** file, then consider this page part of the file too. For example, if
** PENDING_BYTE is byte 4096 (the first byte of page 5) and the size of the
** file is 4096 bytes, 5 is returned instead of 4.
*/
int My_sqlite3pager_pagecount(Pager *pPager)
{
sqlite_int64 n;
assert( pPager );
if( pPager->dbSize >= 0 )
{
n = pPager->dbSize;
}
else
{
if( sqlite3OsFileSize(pPager->fd, &n) != SQLITE_OK )
{
pager_error( pPager, SQLITE_IOERR );
return 0;
}
if( n > 0 && n < pPager->pageSize )
{
n = 1;
}
else
{
n /= pPager->pageSize;
}
if( pPager->state!=PAGER_UNLOCK )
{
pPager->dbSize = (Pgno)n;
}
}
if( n==(PENDING_BYTE/pPager->pageSize) )
{
n++;
}
return (int)n;
}
// 设置密钥
void MySetKey( sqlite3 *db, const void *pKey, int nKey )
{
// 设置密钥简单，直接调用密钥设置接口就行了
sqlite3CodecAttach( db, 0, pKey, nKey );
}

// 重新设置密钥
int MyResetKey( sqlite3 *db, const void *pKey, int nKey )
{
Btree *pbt = db->aDb[0].pBt;
Pager *p = sqlite3BtreePager(pbt);
PTMP_ENCRYPT_BLOCK pNewKey = NULL;
PTMP_ENCRYPT_BLOCK pOldKey = (PTMP_ENCRYPT_BLOCK)My_sqlite3pager_get_codecarg(p);
void * lpUserOld = NULL;
int rc = SQLITE_ERROR;

// 总之都是要新分配一个新密钥空间的
pNewKey = DeriveKey_Tmp( pKey, nKey, (int)(p->pageSize) );
if( NULL == pOldKey && NULL == pNewKey )
{
return SQLITE_OK;
}
if( NULL == pOldKey )
{
pNewKey->lpUserKey.lpUserBlock_old = NULL;
My_sqlite3pager_set_codec(sqlite3BtreePager(pbt), My_sqlite3Codec_tmp, pNewKey);
}
else
{
lpUserOld = pOldKey->lpUserKey.lpUserBlock_new;
if( NULL != pNewKey )
pOldKey->lpUserKey.lpUserBlock_new = pNewKey->lpUserKey.lpUserBlock_new;
else
pOldKey->lpUserKey.lpUserBlock_new = NULL;
}
// 开始事务，加密应该要加密的页面
rc = sqlite3BtreeBeginTrans(pbt, 1);
if (!rc)
{
// 用新密钥重新加密并写入页面
Pgno nPage = My_sqlite3pager_pagecount( p );
Pgno nSkip = PAGER_MJ_PGNO(p);
void *pPage;
Pgno n;

for( n = 1; rc == SQLITE_OK && n <= nPage; n ++ )
{
if ( n == nSkip ) continue;
rc = sqlite3PagerGet(p, n, &pPage);
if( !rc )
{
rc = sqlite3PagerWrite(pPage);
sqlite3PagerUnref( pPage );
}
}
}

// 尝试提交事务
if (!rc)
{
rc = sqlite3BtreeCommit(pbt);
}
// 如果失败，就回滚事务
if (rc)
{
sqlite3BtreeRollback(pbt);
}

if( NULL != pOldKey )
{
if( NULL != lpUserOld )
{
pOldKey->lpUserKey.lpUserBlock_new = lpUserOld;
}
else
{
pOldKey->lpUserKey.lpUserBlock_new = pOldKey->lpUserKey.lpUserBlock_old;
}
DestroyKey_Tmp( pOldKey );
}
if( NULL != pNewKey )
{
pNewKey->lpUserKey.lpUserBlock_old = pNewKey->lpUserKey.lpUserBlock_new;
My_sqlite3pager_set_codec(sqlite3BtreePager(pbt), My_sqlite3Codec_tmp, pNewKey);
}
else
{
My_sqlite3pager_set_codec( p, NULL, NULL );
}
return rc;
}
// 这个函数我都不知道用来干什么的
// 好像相当于打日志，观察 zRight 结果的
void sqlite3_activate_see( const char* zRight )
{
return;
}

// 这个函数作用是把传入的用户 Key 信息设置写到特定的数据库相关结构去，保存
// sqlite3 里面包含n多库结构，就是里面那个 Db *aDb; 的数组结构， nDB 参数就是表示是第几个数组结构（nDB从0开始计算）
// 本函数要调用 sqlite3pager_set_codec 函数，把我们的加解密函数指针，以及密钥指针关联起来，关联方法类似：
// sqlite3pager_set_codec(sqlite3BtreePager(pbt), MyCodecFunc, lpKeyBlock);
int sqlite3CodecAttach(sqlite3* lpDB , int nDB, const void * lpUserKeyText, int iKeyLen )
{
int rc = SQLITE_ERROR;
PTMP_ENCRYPT_BLOCK lpBlock = NULL;

// 如果没有指定密钥数据，可能意味着使用主数据库加密方法，或不加密
if( !lpUserKeyText || iKeyLen <= 0 )
{
if( nDB <= 0 )
{
return SQLITE_OK; // 主数据库，又没有密钥，所以不加密
}
else // 否则是附加数据库，要采用主数据库密钥
{
// 先获得主数据库密钥，然后复制一份
// 然后用到附加数据库身上
PTMP_ENCRYPT_BLOCK pBlock = (PTMP_ENCRYPT_BLOCK)My_sqlite3pager_get_codecarg( sqlite3BtreePager(lpDB->aDb[0].pBt) );

if (!pBlock) return SQLITE_OK; // 主数据库也不加密，那么我们就不加密附加数据库了
if ( NULL == pBlock->lpUserKey.lpUserBlock_new ) return SQLITE_OK; // 看来不用加密

lpBlock = CopyKey_Tmp( pBlock );
if ( !lpBlock )
return rc; // 复制密钥失败！（应该是内存不够之类）
}
}
else // 用户提供了密钥串，那么就按要求创建密钥
{
Btree *pbt = lpDB->aDb[nDB].pBt;
Pager *p = sqlite3BtreePager(pbt);

lpBlock = DeriveKey_Tmp( lpUserKeyText, iKeyLen, (int)p->pageSize );
if( lpBlock == NULL )
{
My_sqlite3pager_set_codec( sqlite3BtreePager( lpDB->aDb[nDB].pBt ), NULL, NULL );
return 0;
}
}

// 将核心加解密函数设置到对应数据库
My_sqlite3pager_set_codec( sqlite3BtreePager( lpDB->aDb[nDB].pBt ), My_sqlite3Codec_tmp, lpBlock );
return 0;
}

// 删除密钥的功能
void DestroyKeyInBtree( Btree * lpTree )
{
Pager *p;
PTMP_ENCRYPT_BLOCK pBlock;

if( NULL == lpTree )
{
return;
}
p = sqlite3BtreePager(lpTree);
if( NULL == p )
return;
pBlock = (PTMP_ENCRYPT_BLOCK)My_sqlite3pager_get_codecarg(p);
if( NULL == pBlock )
return;
DestroyKey_Tmp( pBlock );
}
// 这个函数作用是设法从指定的库里重新分解出 sqlite3CodecAttach 函数设置的密钥信息
// sqlite3 里面包含n多库结构，就是里面那个 Db *aDb; 的数组结构， nDB 参数就是表示是第几个数组结构（nDB从0开始计算）
void sqlite3CodecGetKey(sqlite3* lpDB, int nDB, void** lplpUserKeyText, int* lpOutKeyLen )
{
return;
}

// 设置某数据库的密钥
// 用户ap真正调用的设置密码的函数就是这个
// 看参数名字就应该知道这是写参数含义了，更何况人家还做了这么充分的注释
int sqlite3_key( sqlite3 *db,/* Database to be rekeyed */ const void *pKey, int nKey /* The key */ )
{
MySetKey( db, pKey, nKey );
return SQLITE_OK;
}
// 重新设置某个数据库的密钥
// 用户ap真正调用的重设密码的函数就是这个
// 看参数名字就应该知道这是写参数含义了，更何况人家还做了这么充分的注释
int sqlite3_rekey( sqlite3 *db, /* Database to be rekeyed */ const void *pKey, int nKey /* The new key */ )
{
MyResetKey( db, pKey, nKey );
return SQLITE_OK;
}
#endif //SQLITE_HAS_CODEC
这段代码的使用说明：
1、 必须定义一个用户扩展加密文件 《Encrypt.h》。以及 Encrypt.c 。
以后要修改密码算法，密钥获得，就只修改这两个文件，对 sqlite3.c 文件不需要再做任何修改。

2、 Encrypt.h 里必须提供下面这些函数：

// 制作密钥。用户调用 sqlite3_key 和 sqlite3_rekey 时都会调用到本函数。
// 本函数通过用户提供的基本信息，构造出自己的密钥缓冲区（密钥块），函数里需要自己 malloc 一个
// 空间出来。设定好这个密钥块后将其指针返回出来。系统会在 rekey 或数据库关闭时调用 DestroyKey
// 函数来销毁这个密钥块。
// 参数 pKey 和 nKeyLen 是用户传入的基本密钥信息。后面 iPageSize 是 sqlite3 的页面大小，
// 通常 iPageSize 都是 1024。 Sqlite3 每次加解密一块数据大小都是这个长度。因此可以放心地
// 使用分块加解密算法。
LPCRYPTBLOCK DeriveKey(const void *pKey, int nKeyLen, int iPageSize );

// 复制一份密钥块，新复制出来的密钥块也必须是自己 malloc 出来的新空间，设定好后
// 将新结构体指针返回出来
LPCRYPTBLOCK CopyKey( const LPCRYPTBLOCK lpKey );

// 释放密钥。自己根据需要释放申请过的空间。
void DestroyKey( LPCRYPTBLOCK lpKey );
// 加解密函数核心，包括加密和解密
// 参数 pArg 是我们前面 DeriveKey 函数构造出来的密钥块。
// data 是用户数据区域， iDataSize 是此区域大小(通常就是页面大小，即1024字节)
// nPageNum 是当前页面在数据库里的下标，可以忽略。
// 加解密时直接读取，并写回到 data 指向的数据区。
// nMode 参数含义 (看起来，小于5的都是解密，大于5的都是加密。)
// case 0: // Undo a “case 7” journal file encryption
// case 2: // Reload a page
// case 3: // Load a page
// case 6: // Encrypt a page for the main database file
// case 7: // Encrypt a page for the journal file
void My_sqlite3Codec(void *pArg, void *data, int iDataSize, unsigned int nPageNum, int nMode);
3、 在 sqlite3_open 之后立刻使用 sqlite3_key 函数就可以设置数据库密码。
4、 如果需要修改数据库密码，则需要使用 sqlite3_rekey 函数。更改密码之前如果原数据库有密码，就要先用 sqlite3_key 函数设置过原始密码。
5、 如果数据库密码不正确，对数据库的所有操作都会被返回错误码 SQLITE_NOTADB，错误码含义是 “file is encrypted or is not a database” 。
6、 sqlite3_key 函数或 sqlite3_rekey 函数 如果传入的密钥信息为 NULL，或密钥信息长度为0，都表示不使用密钥、取消密钥、并解密原来数据库。

到此就可以完成加解密了。很简单。
这里附带我制作好的 sqlite3 (3.6.12) 。

IV. 可靠性
在没有加密功能（没有定义 “SQLITE_HAS_CODEC” 宏）的情况下，用 Purify 跑，发现 sqlite3 基本正常。
说基本正常是因为每次 sqlite3 尝试创建一个已经存在的表时都会出现 40KB 内存泄露。所以，千万不要创建已经存在的表。免得内存泄露。
除了这个内存泄露，没有其它异常出现。没有其它内存泄露，也没有指针越界访问，也没有指针非法使用。即使采用事务过程，也没有任何异常出现。
添加了我修改的那些代码，然后开启加密功能，结果跟前面一致，除了可能的40KB内存泄露外，没有其它异常，即使使用事务也没有异常。

V. 关键点说明
1、 为了销毁我们数据块，MY_DESTROY_KEY 能不能更早地执行，我还没有深入分析。但是可以肯定的是不能更晚销毁，否则BTree 已被sqlite删除，我们再访问就指针非法访问，程序崩溃。
2、 Sqlite 对于加解密过程的处理有点奇怪。加解密函数它都传入数据块，但是解密时，一定要将解密结果直接写入它提供的数据块空间；加密时则相反，必须自己申请空间，将它提供的原始数据 memcpy 到自己空间，然后加密自己的空间数据，最后将自己空间指针返回给它。即，加密过程不能修改任何原始数据。——当然，这个过程我已经封装到代码里，以后在 Encrypt.h 里封装的函数和密钥块不需要处理这个过程，一律直接将加解密数据写回到 data 数据块空间就行了。
3、 加解密时 nMode 参数为什么只有那几个取值，为什么不会有其它值？看 sqlite3 代码的确不会有其他值出现，连5都没有。不知道sqlite3为什么这么设计。总之，我认为 nMode <=5 是解密，>5 是加密。这个做法在 3.6.12 版本没有问题。
4、 根据网上代码，nMode == 7 时是操作事务文件。如果在事务执行过程中进行 rekey，这时候要用老密码加密事务文件内容。为什么要用老密码？而且还是加密不是解密？不清楚。但是我测试的确用老密码加密是对的。即，nMode == 7 时要用老密码加密数据。
5、 如果在事务开启过程中 rekey，会导致事务提交。即，一旦rekey，那么已开启的事务就被自动提交，不能回滚了。所以，如果要修改数据库密码，最好不要在事务开启时进行。否则先前开启的事务将失去回滚的机会。
(END)

http://brightguo.com/sqlite-xxtea/

SQLite XXTea加密学习

https://www.u72.net/daima/10dv.html