• 勒索病毒LockBit2.0 数据库（mysql与sqlsever）解锁恢复思路分享

    0.前言

    今天公司服务器中招LockBit2.0勒索病毒，损失惨重，全体加班了一天基本解决了部分问题，首先是丢失的文件数据就没法恢复了，这一块没有理睬，主要恢复的是两个数据库，一个是16GB大小的SQLserver数据库，另一个是一个15GB大小的Mysql数据库，最后丢失了1%左右的内容顺利恢复了两个数据库，因为lockbit勒索病毒的分享给文章太少，这里就记录下自己恢复的过程。

    1.恢复逻辑

    lockbit2.0的锁定逻辑是针对有价值的文件，头部4KB给你加密，尾部4KB给你加密，然后中间隔一段随机（也可能是固定间隔，没有考证过）给你加密大约4KB，全局给你大约加密不到1%的数据，因此恢复的逻辑也就是舍弃这些被加密的数据，尽可能恢复数据库正常。

    注意！！！，lockbit2.0不存在找人破解的可能性，找人弄也是按照上面的逻辑，懂程序原理的都知道lockbit的加密是无法被破解的，因此注意各位不要被骗！

    另外我们能恢复数据库主要是我们的数据库有以下特点，数据库极大，表内条数极多，这样被损坏的数据才能最大概率着落在表内数据的，并且表内多是流水账数据，丢失部分的损失可控，因此修复的可能性最高，如果你的数据库不大，几百兆，内容不多表结构复杂的，没什么修复的价值。

    2.sqlserver恢复

    sqlserver市面是存在恢复软件的，我找的是达思科技的软件，1399元买了一天的使用权限，通过被锁的文件和1年前数据库文件（一半大小）一起合并进行了恢复，最后的回复结果是大致回复了99%的数据，部分表格少几条数据，有一个表格是40000多条数据，少了20条，另一个表格18000条数据，少了8条，少的数据就是被加密的数据，被舍掉了。因为sqlsever按照我查的资料，主要被加密的数据一个是头文件，也就是表结构，主要是通过过去的备份文件恢复的，中间的数据就是舍弃。这个恢复成功的思路对我后面回复mysql提供了较大的帮助。

    最终sqlsever恢复，但是因为是财务软件的数据库，少的数据还是会导致很多模块计算有问题，这个只能后续慢慢反查和处理了。

    注意，一天时间比较宝贵，请提前给自己的机子搭建好本地sql server环境，到恢复成功大约耗时要18个小时，需要通宵干。

    3，mysql恢复

    mysql恢复是最复杂的，首先mysql市面上是没有成品恢复软件的，不要被骗。因此只能动手恢复mysql的原始文件是分立的文件，每一个文件都被加密了，原始数据库是二进制文件，因此恢复原始数据库文件的难度最大，几乎是不可能被恢复。

    因此我们恢复瞄准的是备份的.sql文件，.sql文件是一个类似文本文件，可读性高，恢复起来比较容易。

    3.1 mysql文件的逻辑与查看

    mysql文件的基本逻辑是如下

    建立数据库（一句话）

    {

     建立表A

    建立表A结构（列）

    插入表A的数据 *N

    。。。。

    }  *N个表循环

    其中头部的4KB是建立表头和建立表结构，这一块只能手敲，具体方法是自己建立数据库，复原表结构后导出为sql文件，然后比对着sql文件自己手动恢复头部4KB文件。

    第二部分是建立表结构，表结构不复杂的话大约是1KB左右的样子

    第三部分是插入表数据，这个是数据库中最大的一块，我们的mysql会将一大堆数据写成一个insert插入，每一个insert的最长是2MB字节的大小，因此如果损坏的4KB落在这里的话，就要排除掉这2MB，后续再维修这2MB。

    加密的逻辑是随机加密（待考），因此文件内部被锁的4KB落在insert中的概率最大。

    对于这种单文件超大的sql文件，是没有查看工具的，因此首先用c#写一个分析工具，逐行分析这个sql文件是干什么的

    使用下面的代码，可以将每一行都打印到log文件中，使用文本打开log文件可以查看sql语句的结构。

    1. static void Main(string[] args)
    2.         {
    3.  
    4.             ///*          sql有效性验证算法+打印算法
    5.             int linenum = 0;
    6.             string filename = "I:\\mysql_backup_20231008__00_00.sql.lockbit";
    7.             string filename1 = "I:\\log.text";
    8.             string filename2 = "I:\\xiufuz_error.sql";
    9.             String line;
    10.             bool bResult;
    11.             int[] errorcode = new int[5];
    12.  
    13.  
    14.             try
    15.             {
    16.                 StreamReader sr = new StreamReader(filename);
    17.                 StreamWriter sw1 = new StreamWriter(filename1);
    18.                 //StreamWriter sw2 = new StreamWriter(filename2);
    19.                 StringBuilder sb = new StringBuilder();     //定义
    20.                 sb.Clear();
    21.                 int isbinary = 0;
    22.                 int errortick = 0;
    23.                 int isrightorerror = 0;
    24.                 while (!sr.EndOfStream)
    25.                 {
    26.                     //lstchar2 = lstchar1;
    27.                     //lstchar1 = currentChar;
    28.                     string readlinest = sr.ReadLine();
    29.                     byte[] charArray = Encoding.Default.GetBytes(readlinest);
    30.                     sb.Append(readlinest);
    31.                     if (charArray.Count() > 0)
    32.                     {
    33.                         if (charArray[charArray.Count() - 1] == 0x3b)
    34.                         {
    35.                             line = sb.ToString();
    36.                             sb.Clear();     //清空
    37.                             linenum++;
    38.                             byte[] bytetemp = Encoding.Default.GetBytes(line);
    39.                             isbinary = 0;
    40.                             errortick = 0;
    41.                             isrightorerror = 0;     //正确
    42.                             for (int i = 0; i < line.Length; i++)
    43.                             {
    44.                                 if (i + 7 < line.Length)
    45.                                 {
    46.                                     if (line[i] == '_')
    47.                                     {
    48.                                         try
    49.                                         {
    50.                                             if (line[i+1]=='b'&&line[i+2]=='i'&&line[i+3]=='n'&&line[i+4]=='a'&&line[i+5]=='r')
    51.                                             {
    52.                                                 isbinary = 1;
    53.                                             }
    54.                                         }
    55.                                         catch
    56.                                         {
    57.  
    58.                                         }
    59.                                     }
    60.                                             
    61.                                 }
    62.                                         
    63.                                 if (isbinary == 0)
    64.                                 {
    65.                                     if (!IsChineseLetter(line, i))
    66.                                     {
    67.                                         errorcode[errortick] = Char.ConvertToUtf32(line, i);
    68.                                         errortick++;
    69.                                         if (errortick > 3)
    70.                                         {
    71.                                             
    72.                                             if (Char.ConvertToUtf32(line, i) < 0xff00)
    73.                                             {
    74.  
    75.                                             }
    76.                                             isrightorerror = 1; //错误
    77.                                             break;
    78.                                         }
    79.                                                 
    80.                                     }
    81.                                 }
    82.                                 else
    83.                                 { 
    84.                                             
    85.                                 }
    86.                             }
    87.  
    88.                             if (isrightorerror == 1)
    89.                             {
    90.                                 //错误
    91.                                 //sw2.WriteLine(line);
    92.                                 sw1.WriteLine("行:" + linenum.ToString("D5") + "错误,内容:" + line.Substring(0, 50) + "---" + errorcode[0].ToString("X4") + ',' + errorcode[1].ToString("X4") + ',' + errorcode[2].ToString("X4"));
    93.                                 //Console.WriteLine("错误字符,line:" + linenum.ToString() + ",长度:"+line.Length.ToString()+"---" + errorcode[0].ToString("X4") + ',' + errorcode[1].ToString("X4") + ',' + errorcode[2].ToString("X4"));
    94.                             }
    95.                             else
    96.                             { 
    97.                                 //正确
    98.                                 //sw1.WriteLine(line);
    99.                                 sw1.WriteLine("行:" + linenum.ToString("D5") + "正确,内容:" + line.Substring(0, line.Length > 50 ? 50 : line.Length));
    100.                             }
    101.                             if (linenum % 100 == 0)
    102.                                 Console.WriteLine("Line:" + linenum.ToString());
    103.  
    104.                         }
    105.                     }
    106.  
    107.                 }
    108.  
    109.                 sr.Close();
    110.                 sw1.Close();
    111.                 //sw2.Close();
    112.                 Console.WriteLine("Final Line:" + linenum.ToString());
    113.             }
    114.             catch (Exception e)
    115.             {
    116.                 Console.WriteLine("Exception: " + e.Message);
    117.             }
    118.             finally
    119.             {
    120.                 Console.WriteLine("Executing finally block.");
    121.             }
    122.                     
    123.  
    124.             while (true) ;
    125. }

    通过上述文件打印出来的log可以观察到非常多的信息：

    如下图，这是一个正确的建立表格，插入数据的结构，由7行的建立表头，若干行的INSERT数据和1行的解锁组成，按照这个逻辑可以查看每一个表格的语句是否完成，如图我战士的after_sales这个表格就非常完整。

    如下图所示，这是一个典型的中间有损失的表，可以看到表结构是正确的，插入语句在21393行出现了错误，这一条语句的数据就要被舍弃，后续再根据重要性选择恢复剩余的细节，但是这个表的绝大多数部分都会恢复并且是好的

    3.2 使用程序辅助分离sql文件中的好的部分和坏的部分

    这里我使用的C#写的处理程序，处理逻辑是，按照分号加换行符来确认不同的sql语句行，在每一行中逐个字节判断字节是不是有效的文本信息，如果本行文件中出现了三次以上的非Unicode字符的字节，我们就判定这一行被加密了，将这一行复制到错误的文件中等待修复，反之则复制到正确的文件中修复。

    附C#代码

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using System.IO;
    7. namespace 勒索修复程序
    8. {
    9.     class Program
    10.     {
    11.         //我的数据库中各个国家的文字都有，因此这里做了针对性的排除
    12.         static bool IsChineseLetter(string input, int index)
    13.         {
    14.             int code = 0;
    15.             int chfrom = Convert.ToInt32("4e00", 16); //范围（0x4e00～0x9fff）转换成int（chfrom～chend）
    16.             int chend = Convert.ToInt32("9fff", 16);
    17.             if (input != "")
    18.             {
    19.                 code = Char.ConvertToUtf32(input, index); //获得字符串input中指定索引index处字符unicode编码
    20.                 if (code < 0x80)        //英文是正确的
    21.                     return true;
    22.                 if (code >= chfrom && code <= chend)
    23.                 {
    24.                     return true; //当code在中文范围内返回true
    25.                 }
    26.                 if (code >= 0xa0 && code <= 0xff)
    27.                 {
    28.                     return true; //当code在中文范围内返回true
    29.                 }
    30.                 if (code >= 0xff00 && code <= 0xffee)
    31.                 {
    32.                     return true; //当code在中文范围内返回true
    33.                 }
    34.                 if (code >= 0x3000 && code <= 0x30ff)
    35.                 {
    36.                     return true; //当code在中文范围内返回true
    37.                 }
    38.                 if (code >= 0x3300 && code <= 0x36ff)
    39.                 {
    40.                     return true; //当code在中文范围内返回true
    41.                 }
    42.                 if (code >= 0x13a0 && code <= 0x13ff)
    43.                 {
    44.                     return true; //当code在中文范围内返回true
    45.                 }
    46.                 if (code >= 0x2000 && code <= 0x22ff)
    47.                 {
    48.                     return true; //当code在中文范围内返回true
    49.                 }
    50.                 if (code >= 0x2400 && code <= 0x27ff)
    51.                 {
    52.                     return true; //当code在中文范围内返回true
    53.                 }
    54.                 if (code >= 0x0100 && code <= 0x02ff)
    55.                 {
    56.                     return true; //当code在中文范围内返回true
    57.                 }
    58.                 if (code >= 0x0370 && code <= 0x03ff)
    59.                 {
    60.                     return true; //当code在中文范围内返回true
    61.                 }
    62.                 if (code >= 0x0400 && code <= 0x05ff)
    63.                 {
    64.                     return true; //当code在中文范围内返回true
    65.                 }
    66.                 if (code >= 0x0600 && code <= 0x06ff)
    67.                 {
    68.                     return true; //当code在中文范围内返回true
    69.                 }
    70.                 if (code >= 0x0e00 && code <= 0x0fda)
    71.                 {
    72.                     return true; //当code在中文范围内返回true
    73.                 }
    74.                 if (code >= 0xac00 && code <= 0xd7a3)       //韩文
    75.                 {
    76.                     return true; //当code在中文范围内返回true
    77.                 }
    78.                 if (code >= 0xaa80 && code <= 0xaac2)       
    79.                 {
    80.                     return true; //当code在中文范围内返回true
    81.                 }
    82.                 if (code >= 0x1d00 && code <= 0x1eff)
    83.                 {
    84.                     return true; //当code在中文范围内返回true
    85.                 }
    86.                 if (code >= 0x0900 && code <= 0x0bff)
    87.                 {
    88.                     return true; //当code在中文范围内返回true
    89.                 }
    90.                 if (code >= 0x3400 && code <= 0x4dbf)       //繁体
    91.                 {
    92.                     return true; //当code在中文范围内返回true
    93.                 }
    94.                 else
    95.                 {
    96.                     return false; //当code不在中文范围内返回false
    97.                 }
    98.             }
    99.             return false;
    100.         }
    101.         static void Main(string[] args)
    102.         {
    103.  
    104.             ///*          sql有效性验证算法
    105.             int linenum = 0;
    106.             string filename = "I:\\mysql_backup_20231008__00_00.sql.lockbit";    //目标文件
    107.             string filename1 = "I:\\xiufuz_right.sql";    //正确的保存文件
    108.             string filename2 = "I:\\xiufuz_error.sql";    //错误的保存文件
    109.             String line;
    110.             bool bResult;
    111.             try
    112.             {
    113.                 StreamReader sr = new StreamReader(filename);
    114.                 StreamWriter sw1 = new StreamWriter(filename1);
    115.                 StreamWriter sw2 = new StreamWriter(filename2);
    116.                 StringBuilder sb = new StringBuilder();     //定义
    117.                 sb.Clear();
    118.                 int isbinary = 0;
    119.                 int errortick = 0;
    120.                 int isrightorerror = 0;
    121.                 while (!sr.EndOfStream)
    122.                 {
    123.                     //lstchar2 = lstchar1;
    124.                     //lstchar1 = currentChar;
    125.                     string readlinest = sr.ReadLine();
    126.                     byte[] charArray = Encoding.Default.GetBytes(readlinest);
    127.                     sb.Append(readlinest);
    128.                     if (charArray.Count() > 0)
    129.                     {
    130.                         if (charArray[charArray.Count() - 1] == 0x3b)
    131.                         {
    132.                             line = sb.ToString();
    133.                             sb.Clear();     //清空
    134.                             linenum++;
    135.                             byte[] bytetemp = Encoding.Default.GetBytes(line);
    136.                             isbinary = 0;
    137.                             errortick = 0;
    138.                             isrightorerror = 0;     //正确
    139.                             for (int i = 0; i < line.Length; i++)
    140.                             {
    141.                                 if (i + 7 < line.Length)
    142.                                 {
    143.                                     if (line[i] == '_')
    144.                                     {
    145.                                         try
    146.                                         {
    147.                                             if (line[i+1]=='b'&&line[i+2]=='i'&&line[i+3]=='n'&&line[i+4]=='a'&&line[i+5]=='r')
    148.                                             {
    149.                                                 isbinary = 1;
    150.                                             }
    151.                                         }
    152.                                         catch
    153.                                         {
    154.  
    155.                                         }
    156.                                     }
    157.                                             
    158.                                 }
    159.                                         
    160.                                 if (isbinary == 0)
    161.                                 {
    162.                                     if (!IsChineseLetter(line, i))
    163.                                     {
    164.                                         errorcode[errortick] = Char.ConvertToUtf32(line, i);
    165.                                         errortick++;
    166.                                         if (errortick > 3)
    167.                                         {
    168.                                             Console.WriteLine("错误字符,line:" + linenum.ToString() + ",长度:"+line.Length.ToString()+"---" + errorcode[0].ToString("X4") + ',' + errorcode[1].ToString("X4") + ',' + errorcode[2].ToString("X4"));
    169.                                             if (Char.ConvertToUtf32(line, i) < 0xff00)
    170.                                             {
    171.  
    172.                                             }
    173.                                             isrightorerror = 1; //错误
    174.                                             break;
    175.                                         }
    176.                                                 
    177.                                     }
    178.                                 }
    179.                                 else
    180.                                 { 
    181.                                             
    182.                                 }
    183.                             }
    184.  
    185.                             if (isrightorerror == 1)
    186.                             {
    187.                                 //错误
    188.                                 sw2.WriteLine(line);
    189.                             }
    190.                             else
    191.                             { 
    192.                                 //正确
    193.                                 sw1.WriteLine(line);
    194.                             }
    195.  
    196.                         }
    197.                     }
    198.  
    199.                 }
    200.  
    201.                 sr.Close();
    202.                 sw1.Close();
    203.                 sw2.Close();
    204.                 Console.WriteLine("Final Line:" + linenum.ToString());
    205.             }
    206.             catch (Exception e)
    207.             {
    208.                 Console.WriteLine("Exception: " + e.Message);
    209.             }
    210.             finally
    211.             {
    212.                 Console.WriteLine("Executing finally block.");
    213.             }
    214.                     
    215.  
    216.             while (true) ;
    217.             // */
    218.  
    219.             
    220.             while(true);
    221.         }
    222.     }
    223. }

    执行效果如下图

    可以看到，被攻击的段落中至少出现三个FFFD以上的，这个就是被攻击的段落的特点，将没被攻击的干净的sql文件导出后进行下一步处理。

    3.3 mysql文件导入库

    mysql文件导入mysql库的过程需要自己执行，导入过程中发现错误随时进行处理和补全表结构，这里因为表是你自己建的，别人也帮不了你，是一个苦功夫，但是我的数据库16GB大小，表结构占位不到1MB，因此表结构被加密的概率较低，实际恢复过程中我的数据库就一个表结构被损坏了，因此就补了一个表结构就完成了数据库的恢复。

    3.4 其他被损坏的文件的处理

    首先我通过C#将500MB左右的损坏文件拆成了10个50MB的文件，按照每个文件50行

    附代码

    1. static void Main(string[] args)
    2.         {
    3.  
    4.             ///*     //拆分算法
    5.             try
    6.             {
    7.                 string line="";
    8.                 int linenum=0;
    9.                 byte lstchar1=0, lstchar2=0;
    10.                 byte currentChar=0;
    11.                 int block = 0;
    12.                 string filename = "I:\\xiufuz_error.sql";
    13.                 string filename1 = "I:\\error1.sql";
    14.                 string filename2 = "I:\\error2.sql";
    15.                 string filename3 = "I:\\error3.sql";
    16.                 string filename4 = "I:\\error4.sql";
    17.                 string filename5 = "I:\\error5.sql";
    18.                 string filename6 = "I:\\error6.sql";
    19.                 string filename7 = "I:\\error7.sql";
    20.                 string filename8 = "I:\\error8.sql";
    21.                 string filename9 = "I:\\error9.sql";
    22.                 string filename10 = "I:\\error10.sql";
    23.                 StreamReader sr = new StreamReader(filename);
    24.                 StreamWriter sw1 = new StreamWriter(filename1);
    25.                 StreamWriter sw2 = new StreamWriter(filename2);
    26.                 StreamWriter sw3 = new StreamWriter(filename3);
    27.                 StreamWriter sw4 = new StreamWriter(filename4);
    28.                 StreamWriter sw5 = new StreamWriter(filename5);
    29.                 StreamWriter sw6 = new StreamWriter(filename6);
    30.                 StreamWriter sw7 = new StreamWriter(filename7);
    31.                 StreamWriter sw8 = new StreamWriter(filename8);
    32.                 StreamWriter sw9 = new StreamWriter(filename9);
    33.                 StreamWriter sw10 = new StreamWriter(filename10);
    34.                 //Read the first line of text
    35.  
    36.                 StringBuilder sb = new StringBuilder();     //定义
    37.                 sb.Clear();
    38.  
    39.                 while (!sr.EndOfStream)
    40.                 {
    41.                     //lstchar2 = lstchar1;
    42.                     //lstchar1 = currentChar;
    43.                     string readlinest = sr.ReadLine();
    44.                     byte[] charArray = Encoding.Default.GetBytes(readlinest);
    45.                     sb.Append(readlinest);
    46.                     if (charArray.Count() > 0)
    47.                     {
    48.                         if (charArray[charArray.Count() - 1] == 0x3b)
    49.                         {
    50.                             line = sb.ToString();
    51.                             sb.Clear();     //清空
    52.                             linenum++;
    53.                             if (linenum % 100 == 0)
    54.                                 Console.WriteLine("Line:" + linenum.ToString());
    55.                             //清空前处理
    56.                             if (block == 0)
    57.                                 sw1.WriteLine(line);
    58.                             else if (block == 1)
    59.                                 sw2.WriteLine(line);
    60.                             else if (block == 2)
    61.                                 sw3.WriteLine(line);
    62.                             else if (block == 3)
    63.                                 sw4.WriteLine(line);
    64.                             else if (block == 4)
    65.                                 sw5.WriteLine(line);
    66.                             else if (block == 5)
    67.                                 sw6.WriteLine(line);
    68.                             else if (block == 6)
    69.                                 sw7.WriteLine(line);
    70.                             else if (block == 7)
    71.                                 sw8.WriteLine(line);
    72.                             else if (block == 8)
    73.                                 sw9.WriteLine(line);
    74.                             else if (block == 9)
    75.                                 sw10.WriteLine(line);
    76.                             if (linenum > 50)
    77.                             {
    78.                                 if (block < 9)
    79.                                 {
    80.                                     linenum = 0;
    81.                                     block++;
    82.                                 }
    83.                             }
    84.                         } 
    85.                     }
    86.                     
    87.                 }
    88.                 sw1.Close();
    89.                 sw2.Close();
    90.                 sw3.Close();
    91.                 sw4.Close();
    92.                 sw5.Close();
    93.                 sw6.Close();
    94.                 sw7.Close();
    95.                 sw8.Close();
    96.                 sw9.Close();
    97.                 sw10.Close();
    98.                 Console.WriteLine("Final Line:" + linenum.ToString());
    99.                 while(true);
    100.                
    101.                 
    102.             }
    103.             catch (Exception e)
    104.             {
    105.                 Console.WriteLine("Exception: " + e.Message);
    106.             }
    107.             finally
    108.             {
    109.                 Console.WriteLine("Executing finally block.");
    110.             }
    111.      
    112.            // */
    113.             while(true);
    114.         }

    拆成50MB左右的文件后就可以使用notepad打开了，打开后根据每一条的重要程度选择性恢复，这里的回复只能自己手动回复的，具体的办法是将里面损坏的部分删除后，手动对齐格式，把剩余能插入的数据再执行插入回数据库中。是一个手工的水磨细活。

    4 总结

    全部恢复耗时两个人24小时通宵解决了，尽可能的减少了勒索病毒对公司的影响。

    勒索病毒是对公司的损失是重大的，本次勒索病毒我们自己总结如下经验

    1，首先杀毒系统要装，有钱就买个卡巴斯基装上（淘宝有便宜的），没钱装一个360，一定要有杀软

    2，内网别偷懒，该划分vlan就划分vlan，至少能做好数据隔离

    3，核心数据库资产一定要做一个云端备份，可以用阿里云或者腾讯云的付费产品，不要迷信本地备份，我们就是本地备份顺着共享文件夹全部一锅端了，三个备份机制全部失效。

    4，如果真的依靠本地备份，就在vm exsi中做镜像级别的备份，这个备份不会被干掉，反之所有的windows级别的备份都会被勒索病毒干掉。

  • 相关阅读:
    单元测试与集成测试：软件质量的双重保障
    树莓派4B(Ubuntu 22.04 server)与Windows11网线直连(无显示器)
    基于LeNet实现手写体数字识别实验
    unity urp 棉麻织物渲染
    深度神经网络算法有哪些,python深度神经网络算法
    wininet,winhttp,xmlhttprequest,各版本区别 《转》
    OpenFeign的三种远程调用方式
    BottomSheetDialogFragment大量踩坑-自适应高度和最大高度和滚动问题等等
    如何在 Excel 中进行加，减，乘，除
    如何將人臉變漂亮(七)
  • 原文地址：https://blog.csdn.net/qq1003442507/article/details/133872984