diff --git a/source/libs/tdb/src/db/tdbPager.c b/source/libs/tdb/src/db/tdbPager.c
index 42823c9dfb..94481039fe 100644
--- a/source/libs/tdb/src/db/tdbPager.c
+++ b/source/libs/tdb/src/db/tdbPager.c
@@ -459,6 +459,49 @@ int tdbPagerPrepareAsyncCommit(SPager *pPager, TXN *pTxn) {
   return 0;
 }
 
+static char* tdbEncryptPage(SPager *pPager, char* pPageData, int32_t pageSize, const char* function, 
+                            int64_t offset){
+  int32_t encryptAlgorithm = pPager->pEnv->encryptAlgorithm;
+  char* encryptKey = pPager->pEnv->encryptKey;
+
+  char* buf = pPageData; 
+
+  if(encryptAlgorithm == DND_CA_SM4){
+    //tdbInfo("CBC_Encrypt key:%d %s %s", encryptAlgorithm, encryptKey, __FUNCTION__);
+    //ASSERT(strlen(encryptKey) > 0);
+
+    //tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d before Encrypt", offset, pPage->pData[0]);
+
+    buf = taosMemoryMalloc(pageSize);
+
+    unsigned char		packetData[128];
+
+    int32_t count = 0;
+    while (count < pageSize) {
+      SCryptOpts opts = {0};
+      opts.len = 128;
+      opts.source = pPageData + count;
+      opts.result = packetData;
+      opts.unitLen = 128;
+      strncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
+
+      int32_t newLen = CBC_Encrypt(&opts);
+
+      memcpy(buf + count, packetData, newLen);
+      count += newLen; 
+    }
+    //tdbInfo("CBC tdb offset:%" PRId64 ", Encrypt count:%d %s", offset, count, function);
+
+    //tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d after Encrypt", offset, (uint8_t)buf[0]);
+  }
+
+  return buf;
+}
+
+void tdbFreeEncryptBuf(SPager *pPager, char* buf){
+  int32_t encryptAlgorithm = pPager->pEnv->encryptAlgorithm;
+  if(encryptAlgorithm == DND_CA_SM4) taosMemoryFreeClear(buf);
+}
 // recovery dirty pages
 int tdbPagerAbort(SPager *pPager, TXN *pTxn) {
   SPage *pPage;
@@ -527,14 +570,19 @@ int tdbPagerAbort(SPager *pPager, TXN *pTxn) {
       return -1;
     }
 
-    ret = tdbOsWrite(pPager->fd, pageBuf, pPager->pageSize);
+    char* buf = tdbEncryptPage(pPager, pPage->pData, pPage->pageSize, __FUNCTION__, offset);
+
+    ret = tdbOsWrite(pPager->fd, buf, pPager->pageSize);
     if (ret < 0) {
       tdbError("failed to write buf due to %s. file: %s, bufsize:%d", strerror(errno), pPager->dbFileName,
                pPager->pageSize);
+      tdbFreeEncryptBuf(pPager, buf);
       terrno = TAOS_SYSTEM_ERROR(errno);
       tdbOsFree(pageBuf);
       return -1;
     }
+
+    tdbFreeEncryptBuf(pPager, buf);
   }
 
   if (tdbOsFSync(pPager->fd) < 0) {
@@ -879,8 +927,13 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage
       char* encryptKey = pPager->pEnv->encryptKey;
 
       if(encryptAlgorithm == DND_CA_SM4){
-        unsigned char		PacketData[128];
-        int		NewLen;
+        //tdbInfo("CBC_Decrypt key:%d %s %s", encryptAlgorithm, encryptKey, __FUNCTION__);
+        //ASSERT(strlen(encryptKey) > 0);
+
+        //uint8_t flags = pPage->pData[0];
+        //tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d before Decrypt", ((i64)pPage->pageSize) * (pgno - 1), flags);
+
+        unsigned char		packetData[128];
 
         int32_t count = 0;
         while(count < pPage->pageSize)
@@ -888,21 +941,25 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage
           SCryptOpts opts = {0};
           opts.len = 128;
           opts.source = pPage->pData + count;
-          opts.result = PacketData;
+          opts.result = packetData;
           opts.unitLen = 128;
           strncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
 
-          NewLen = CBC_Decrypt(&opts);
+          int	newLen = CBC_Decrypt(&opts);
 
-          memcpy(pPage->pData + count, PacketData, NewLen);
-          count += NewLen;
+          memcpy(pPage->pData + count, packetData, newLen);
+          count += newLen;
         }
-        tdbDebug("CBC_Decrypt count:%d %s", count, __FUNCTION__);
+        //tdbInfo("CBC tdb offset:%" PRId64 ", Decrypt count:%d %s", ((i64)pPage->pageSize) * (pgno - 1), count, __FUNCTION__);
+
+        //tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d after Decrypt %s", ((i64)pPage->pageSize) * (pgno - 1), pPage->pData[0], __FUNCTION__);
       }
     } else {
       init = 0;
     }
 
+    //tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d initPage %s", ((i64)pPage->pageSize) * (pgno - 1), pPage->pData[0], __FUNCTION__);
+
     ret = (*initPage)(pPage, arg, init);
     if (ret < 0) {
       tdbError("tdb/pager:%p, pgno:%d, nRead:%" PRId64 "pgSize:%" PRId32 " init page failed.", pPager, pgno, nRead,
@@ -987,43 +1044,18 @@ static int tdbPagerPWritePageToDB(SPager *pPager, SPage *pPage) {
 
   offset = (i64)pPage->pageSize * (TDB_PAGE_PGNO(pPage) - 1);
 
-  int32_t encryptAlgorithm = pPager->pEnv->encryptAlgorithm;
-  char* encryptKey = pPager->pEnv->encryptKey;
-
-  char* buf = pPage->pData; 
-
-  if(encryptAlgorithm == DND_CA_SM4){
-    buf = taosMemoryMalloc(pPage->pageSize);
-
-    unsigned char		PacketData[128];
-    int		NewLen;
-    int32_t count = 0;
-    while (count < pPage->pageSize) {
-      SCryptOpts opts = {0};
-      opts.len = 128;
-      opts.source = pPage->pData + count;
-      opts.result = PacketData;
-      opts.unitLen = 128;
-      strncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN);
-
-      NewLen = CBC_Encrypt(&opts);
-
-      memcpy(buf + count, PacketData, NewLen);
-      count += NewLen; 
-    }
-    tdbDebug("CBC_Encrypt count:%d %s", count, __FUNCTION__);
-  }
+  char* buf = tdbEncryptPage(pPager, pPage->pData, pPage->pageSize, __FUNCTION__, offset);
 
   ret = tdbOsPWrite(pPager->fd, buf, pPage->pageSize, offset);
   if (ret < 0) {
-    if(encryptAlgorithm == DND_CA_SM4) taosMemoryFreeClear(buf);
+    tdbFreeEncryptBuf(pPager, buf);
     tdbError("failed to pwrite page data due to %s. file:%s, pageSize:%d", strerror(errno), pPager->dbFileName,
              pPage->pageSize);
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
   }
 
-  if(encryptAlgorithm == DND_CA_SM4) taosMemoryFreeClear(buf);
+  tdbFreeEncryptBuf(pPager, buf);
 
   return 0;
 }
@@ -1082,14 +1114,19 @@ static int tdbPagerRestore(SPager *pPager, const char *jFileName) {
       return -1;
     }
 
-    ret = tdbOsWrite(pPager->fd, pageBuf, pPager->pageSize);
+    char* buf = tdbEncryptPage(pPager, pageBuf, pPager->pageSize, __FUNCTION__, offset);
+
+    ret = tdbOsWrite(pPager->fd, buf, pPager->pageSize);
     if (ret < 0) {
       tdbError("failed to write buf due to %s. file: %s, bufsize:%d", strerror(errno), pPager->dbFileName,
                pPager->pageSize);
+      tdbFreeEncryptBuf(pPager, buf);
       terrno = TAOS_SYSTEM_ERROR(errno);
       tdbOsFree(pageBuf);
       return -1;
     }
+
+    tdbFreeEncryptBuf(pPager, buf);
   }
 
   if (tdbOsFSync(pPager->fd) < 0) {