逆向协议风控大师
逆向协议风控大师

零基础算法还原01以及使用python和JS还原C++部分细节

题目一

使用jadx 打开algorithmbase_10.apk

零基础算法还原01以及使用python和JS还原C++部分细节_第1张图片

JAVA层

使用Frida获取先生成的随机字符串

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

// 定义一个名为hook_js的JavaScript函数

function hook_js(){

    // 使用Java.perform()函数来执行JavaScript代码

    Java.perform(function(){

        // 使用Java.use()函数来获取Java类com.kanxue.algorithmbase.MainActivity

        var m_randomAscii = Java.use("com.kanxue.algorithmbase.MainActivity")

        // 检查获取的类对象是否存在

        if(m_randomAscii!=undefined){

            console.log("开始Hook"); // 打印开始Hook的消息

            // 重写函数encodeFromJni_11的实现

            m_randomAscii.encodeFromJni_11.implementation = function(input){

                // 获取输入参数input

                var res = this.encodeFromJni_11(input);

                // 打印输入参数和返回值

                console.log("input:==>"+input);

                console.log("res:==>"+res);

                // 返回结果

                return res;

            }

        }

    })

}

function main(){

    hook_js();

}

setImmediate(main);

传入的随机字符串和字符串在Native层加密后的结果如下

1

2

input:==> meUx3DppB%Gj]-2J

res:==> LCllTadbMHYZ0kNnDitri5== 
  • 随机字符串:meUx3DppB%Gj]-2J
  • 加密后的结果: LCllTadbMHYZ0kNnDitri5==

零基础算法还原01以及使用python和JS还原C++部分细节_第2张图片

我们进入Native层查看加密后的结果

Native层

使用unzip命令解压apk获取so文件

unzip algorithmbase_10.apk -d fileso10

零基础算法还原01以及使用python和JS还原C++部分细节_第3张图片

使用Ida打开so文件，在Export表输入JNI查看加密函数的位置

零基础算法还原01以及使用python和JS还原C++部分细节_第4张图片

使用快捷键Y和N修改传入的参数名称，以便我们方便我们后续分析

零基础算法还原01以及使用python和JS还原C++部分细节_第5张图片

返回值是v13

我们从下往上回溯来到 sub_EE38(v9, v10, v11) 函数

使用Frida 对sub_EE38 函数进行hook，目的是为了查看传入的参数和传出的参数

脚本如下

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

function hook_js(){

    Java.perform(function(){

        var m_randomAscii = Java.use("com.kanxue.algorithmbase.MainActivity") //获取MainActivity类

        if(m_randomAscii!=undefined){

            console.log("开始Hook");

            m_randomAscii.encodeFromJni_11.implementation = function(input){ //找到encodeFromJni_11方法，并拦截调用

                var res = this.encodeFromJni_11(input); //调用原始方法

                console.log("input:==>"+input); //打印输入参数

                console.log("res:==>"+res); //打印返回结果

                return res; //返回结果

            }

        }

    })

}

function hook_native(){

    Java.perform(function(){

        //找到基地址

        var base_address = Module.getBaseAddress("libnative-lib.so") //获取libnative-lib.so的基地址

        var sub_EE38 = base_address.add(0xEE38); //计算函数偏移地址

        //开启拦截器

        Interceptor.attach(sub_EE38,{

            //进入函数

            onEnter:function(args){

            this.arg0 = args[0]; //保存第一个参数

            console.log("======>onENter<==========");

            console.log("第一个参数未处理前===>"+args[0].readCString()); //打印第一个参数内容

            console.log("第二个参数未处理前===>"+args[1].readCString()); //打印第二个参数内容

            console.log("第三个参数未处理前===>"+args[2]); //打印第三个参数内容

            },

            onLeave:function(nresult){  

                console.log("======>onLeave<==========");

                console.log("第一个参数处理后======>"+this.arg0.readCString()); //打印处理后的第一个参数

            }

        })

    })

}

function main(){

    hook_js();

    hook_native();

}

setImmediate(main);

点击app按钮，Hook的代码如下所示

零基础算法还原01以及使用python和JS还原C++部分细节_第6张图片

我们获取到如下参数

sub_EE38(_BYTE *a1, __int64 a2, int a3) 第一个参数 第二个参数 第三个参数
未处理前 "" meUx3DppB%Gj]-2J 0x10
处理后后 LCllTadbMHYZ0kNnDitri5==

1

2

3

4

5

6

7

第一个参数未处理前===>

第二个参数未处理前===>meUx3DppB%Gj]-2J

第三个参数未处理前===>0x10

======>onLeave<==========

第一个参数处理后======>LCllTadbMHYZ0kNnDitri5==

input:==>meUx3DppB%Gj]-2J

res:==>LCllTadbMHYZ0kNnDitri5== 

也就是说 sub_EE38 就是我们找的加密call

我们不妨进入sub_EE38 查看加密细节

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

__int64 __fastcall sub_EE38(_BYTE *a1, __int64 a2, int a3)

{

  __int64 v3; // x9，循环计数器

  _BYTE *v4; // x12，用于存储结果的指针

  unsigned __int8 *v5; // x10，用于指向输入数据的指针

  unsigned __int64 v6; // x13，临时变量

  _BYTE *v7; // x10，下一个结果的存储位置

  __int64 v8; // x11，临时变量

  char v9; // w8，临时变量

  __int64 v10; // x9，临时变量

  __int64 result; // x0，函数返回值

  if (a3 - 2 < 1) // 当数据长度小于等于2时

  {

    LODWORD(v3) = 0;

    v7 = a1;

    if (a3 <= 0)

      goto LABEL_11;

  }

  else

  {

    v3 = 0LL;

    v4 = a1;

    do

    {

      v5 = (unsigned __int8 *)(a2 + v3); // 从输入数据中取出三个字节进行处理

      v6 = *(unsigned __int8 *)(a2 + v3);

      v3 += 3LL;

      *v4 = aAyzabfghz0cmbd[v6 >> 2]; // 取出第一个字节的前6位对应的字符

      v4[1] = aAyzabfghz0cmbd[(16 * (unsigned int)*v5) & 0x30LL | ((unsigned __int64)v5[1] >> 4)]; // 取出第二个字节的前4位和第一个字节的后2位所对应的字符

      v4[2] = aAyzabfghz0cmbd[(4 * (unsigned int)v5[1]) & 0x3CLL | ((unsigned __int64)v5[2] >> 6)]; // 取出第三个字节的前2位和第二个字节的后4位所对应的字符

      LOBYTE(v6) = aAyzabfghz0cmbd[v5[2] & 0x3F]; // 取出第三个字节的后6位对应的字符

      v7 = v4 + 4; // 指向下一个结果的存储位置

      v4[3] = v6; // 存储刚才取出的字符

      v4 += 4; // 指向下一个处理位置

    }

    while (v3 < a3 - 2); // 处理到倒数第三个字节为止

    if ((int)v3 >= a3) // 如果处理到倒数第二个字节或最后一个字节

      goto LABEL_11;

  }

  *v7 = aAyzabfghz0cmbd[(unsigned __int64)*(unsigned __int8 *)(a2 + (unsigned int)v3) >> 2]; // 取出最后一个字节的前6位对应的字符

  v8 = (16 * (unsigned int)*(unsigned __int8 *)(a2 + (unsigned int)v3)) & 0x30LL; // 取出最后一个字节的前4位

  if ((_DWORD)v3 == a3 - 1) // 如果只有最后一个字节

  {

    v7[1] = aAyzabfghz0cmbd[v8]; // 存储最后一个字节的前4位对应的字符

    v9 = 61; // 存储'='字符

  }

  else

  {

    v10 = a2 + (unsigned int)v3; // 最后两个字节的指针

    v7[1] = aAyzabfghz0cmbd[v8 | ((unsigned __int64)*(unsigned __int8 *)(v10 + 1) >> 4)]; // 存储最后一个字节的前4位和倒数第二个字节的后2位对应的字符

    v9 = aAyzabfghz0cmbd[(4 * (unsigned int)*(unsigned __int8 *)(v10 + 1)) & 0x3CLL]; // 存储倒数第二个字节的后4位对应的字符

  }

  v7[2] = v9; // 存储倒数第二个字节的后4位或'='字符

  v7[3] = 61; // 存储'='字符

  v7 += 4; // 指向下一个结果的存储位置

LABEL_11:

  result = (unsigned int)((_DWORD)v7 - (_DWORD)a1 + 1); // 计算结果的长度

  *v7 = 0; // 结果字符串结尾添加NULL字符

  return result; // 返回结果长度

}

根据call，还原加密算法

用C代码还原加密算法如下

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

// 01.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。

//

#include

#include

#include  

#include

#include

using namespace std;

unsigned char* sub_EE38(char* strResult, long long inPut, signed int nCnt)

{

    long long v3 = 0;

    unsigned char* v4 = new unsigned char[100];

    unsigned char* v5 = nullptr;

    unsigned long long v6 = 0;

    char aAyzabfghz0cmbd[] = "AYZabFGHz0cmBdefghijklCDE1KLMNTU56789+/VWXnopq23IJrstuvwOPQRSxy4";

    long long result = 0;

    unsigned long long v8 = 0;

    char v9;

    unsigned char* v7;

    long long v10;

    //记录v4初始

    unsigned char* vCount = v4;

    do

    {

        *v4 = 0;

        v5 = (unsigned char*)(inPut + v3);

        v6 = *(unsigned char*)(inPut + v3);

        v3 += 3;

        *v4 = aAyzabfghz0cmbd[v6 >> 2];

        v4[1] = aAyzabfghz0cmbd[(16 * (unsigned int)*v5) & 0x30 | ((unsigned long long)v5[1] >> 4)];

        v4[2] = aAyzabfghz0cmbd[(4 * (unsigned int)v5[1]) & 0x3C | ((unsigned long long)v5[2] >> 6)];

        unsigned char lowByte = aAyzabfghz0cmbd[v5[2] & 0x3F];

        v6 = (v6 & ~(0xFFull)) | lowByte;

        v7 = v4 + 4;

        v4[3] = v6;

        v4 += 4;

    } while (v3 < nCnt - 2);

    if ((int)v3 >= nCnt)

        goto LABEL_11;

    *v7 = aAyzabfghz0cmbd[(unsigned long long) * (unsigned char*)(inPut + (unsigned int)v3) >> 2];

    v8 = (16 * (unsigned int)*(unsigned __int8*)(inPut + (unsigned int)v3)) & 0x30LL;

    if (v3 == nCnt - 1)

    {

        v7[1] = aAyzabfghz0cmbd[v8];

        v9 = 61;

    }

    else

    {

        v10 = inPut + (unsigned int)v3;

        v7[1] = aAyzabfghz0cmbd[v8 | ((unsigned long long) * (unsigned char*)(v10 + 1) >> 4)];

        v9 = aAyzabfghz0cmbd[(4 * (unsigned int)*(unsigned char*)(v10 + 1)) & 0x3CLL];

    }

    v7[2] = v9;

    v7[3] = 61;

    v7 += 4;

    std::cout << (unsigned char*)vCount;

     return (unsigned char*)vCount;

LABEL_11:

    result = (unsigned int)((DWORD)v7 - (DWORD)strResult + 1);

    *v7 = 0;

    delete[] v4;

    std::cout << result;

    return (unsigned char*)result;

}

int main()

{

    char str[] = "";

    unsigned char* str2=  sub_EE38(str, (__int64)"meUx3DppB%Gj]-2J", 0x10);

     std::cout << str2;

}

image-20231101171459516

还原得到加密结果

1

LCllTadbMHYZ0kNnDitri5==

使用JS还原加密算法如下

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

function stringToUint8Array(str){

    var arr = [];

    for (var i=0;i

    {

     arr.push(str.charCodeAt(i));

    }

    var outputbytes = new Uint8Array(arr);

    return outputbytes;

}

function sub_EE38(str,input,nCnt){

    var input_bytes = stringToUint8Array(input);

    var aAyzabfghz0cmbd = "AYZabFGHz0cmBdefghijklCDE1KLMNTU56789+/VWXnopq23IJrstuvwOPQRSxy4";

    var result =0;

    var v4 ="";

    var  v7=0;

    var v3 =0;

    var v6 =0

    var v8 =0

    var v9 = ""

    while (v3

    var v5 = input_bytes[v3];

    var v5_1 = input_bytes[v3+1]

    var v5_2 = input_bytes[v3+2]

    v6 = input_bytes[v3];

    v3 +=3;

    v4 +=  aAyzabfghz0cmbd.charAt(v6 >>2)

    v4 +=  aAyzabfghz0cmbd.charAt(((16*v5)& 0x30) | v5_1 >>4);

    v4 += aAyzabfghz0cmbd.charAt((4*v5_1)&0x3C |v5_2 >>6 );

    v6 = aAyzabfghz0cmbd[v5_2 & 0x3F]

    v4 += v6;

    }

    v4 +=aAyzabfghz0cmbd[(input_bytes[v3]) >> 2];

    v8 = 16 * input_bytes[v3] & 0x30

    if (v3 >= nCnt -1){

        v4 += aAyzabfghz0cmbd[v8]

        v9 = "="

    }else{

        v4 += aAyzabfghz0cmbd[v8 |(v4[v3+1] >>4)]

        v9 = aAyzabfghz0cmbd[(4*v4[v3+1] & 0x3C)]

    }

    v4 += v9

    v4 += "="

    return v4

}

console.log(sub_EE38("","meUx3DppB%Gj]-2J",0x10))

零基础算法还原01以及使用python和JS还原C++部分细节_第7张图片

使用Python还原算法如下

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

def sub_EE38(strResult,inPut,nCnt):

    v3 =0

    v4 = bytes(inPut, "utf-8")

    aAyzabfghz0cmbd ="AYZabFGHz0cmBdefghijklCDE1KLMNTU56789+/VWXnopq23IJrstuvwOPQRSxy4"

    v6=0

    result =0

    v8=0

    output = ""

    v7 =0

    while True:

        v5= v4[v3]

        v5_1 = v4[v3+1]

        v5_2 = v4[v3+2]

        v6 =v4[v3]

        v3 +=3

        output += aAyzabfghz0cmbd[v6>>2]

        output+= aAyzabfghz0cmbd[(16*v5) & 0x30 | (v5_1 >>4)]

        output+= aAyzabfghz0cmbd[(4*v5_1)&0x3C | (v5_2>>6)]

        v6 = aAyzabfghz0cmbd[v5_2&0x3F]

        output +=v6

        v7 +=4

        if v3>=nCnt-2:

            break

    output += aAyzabfghz0cmbd[v4[v3] >>2]

    v8 = 16 * v4[v3] & 0x30

    if(v3 >=nCnt -1):

        output +=  aAyzabfghz0cmbd[v8]

        v9 = '='

    else:

        output += aAyzabfghz0cmbd[v8 | (v4[v3+1]>>4)]

        v9 = aAyzabfghz0cmbd[(4*v4[v3+1]&0x3C)]

    output += v9

    output += '='

    return output

# Press the green button in the gutter to run the script.

if __name__ == '__main__':

     print(sub_EE38("","meUx3DppB%Gj]-2J",0x10))

零基础算法还原01以及使用python和JS还原C++部分细节_第8张图片

题目二

algorithmbase_12.apk

image-20231104100416930

使用apkInfo打开发现是32位程序

JAVA层

零基础算法还原01以及使用python和JS还原C++部分细节_第9张图片

分析如图，先生成随机字符串(我们可以通过Hook encodeFromJni_12 函数来查看生成的随机字符串的值)，然后把生成的随机字符串丢到encodeFromJni_12里面处理

我们先Hook一下encodeFromJni_12函数，查看加密前的字符串和加密后的字符串

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

// 定义一个名为hook_js的函数

function hook_js() {

    // 使用Java.perform方法执行函数体

    Java.perform(function() {

        // 定义变量enrandomcode并使用Java.use方法获取com.kanxue.algorithmbase.MainActivity类

        var enrandomcode = Java.use("com.kanxue.algorithmbase.MainActivity")

        // 如果enrandomcode已定义

        if(enrandomcode != undefined) {

            // 打印开始JAVA层Hook

            console.log("开始JAVA层Hook");

            // 重写encodeFromJni_12方法的实现

            enrandomcode.encodeFromJni_12.implementation = function(intput) {

                // 调用原始的encodeFromJni_12方法，并将结果赋值给变量res

                var res = this.encodeFromJni_12(intput);

                // 打印传入参数的值

                console.log("传入参数是====>" + intput);

                // 打印加密后的参数的值

                console.log("加密后的参数是====>" + res);

                // 返回加密后的结果

                return res;

            }

        }

    })

}

结果如下

image-20231104101314842

1

2

传入参数是====>xVjHx-D&nji8i*rBZ)j

加密后的参数是====>`!^fZFrxI^q~[+\~p#p~F==

加密的结果看起来很像是Base64 ，我们用64编码后的结果对比一下

零基础算法还原01以及使用python和JS还原C++部分细节_第10张图片

不是64编码，但是结果很像。猜测可能是换了码表或并非完全的base64加密

so

打开IDA，来到加密函数Java_com_kanxue_algorithmbase_MainActivity_encodeFromJni_112(int a1, int a2, int a3, char *a4) 里面 进行分析

从下往上回溯，定位到sub_8B04 函数

零基础算法还原01以及使用python和JS还原C++部分细节_第11张图片

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

// 定义一个名为sub_8B04的函数，参数为a1、a2和a3，返回值为_BYTE类型的指针

_BYTE *__fastcall sub_8B04(int a1, int a2, int a3)

{

  int v3; // r12

  int v6; // r6

  int v7; // r5

  _BYTE *v8; // r3

  int v9; // r2

  unsigned int v10; // r0

  char v11; // r4

  int v12; // r6

  char v13; // r1

  // 计算v3的值

  v3 = a3 - 2;

  v6 = 0;

  v7 = 0;

  // 进入while循环，直到v7 >= v3

  while ( 1 )

  {

    // 获取a1+v6处的_BYTE类型指针

    v8 = (_BYTE *)(a1 + v6);

    if ( v7 >= v3 )

      break;

    // 计算v9的值

    v9 = a2 + v7;

    // v6加上4

    v6 += 4;

    // 将aAyzpq23ijrtffg[*(unsigned __int8 *)(a2 + v7) >> 2]的值赋给v8指向的地址

    *v8 = aAyzpq23ijrtffg[*(unsigned __int8 *)(a2 + v7) >> 2];

    // 计算v10的值

    v10 = *(unsigned __int8 *)(a2 + v7 + 1);

    // 获取a2+v7处的值

    v11 = *(_BYTE *)(a2 + v7);

    // v7加上3

    v7 += 3;

    // 将aAyzpq23ijrtffg[(v10 >> 4) & 0xFFFFFFCF | (16 * (v11 & 3))]的值赋给v8指向的地址+1处

    v8[1] = aAyzpq23ijrtffg[(v10 >> 4) & 0xFFFFFFCF | (16 * (v11 & 3))];

    // 将aAyzpq23ijrtffg[(*(unsigned __int8 *)(v9 + 2) >> 6) & 0xFFFFFFC3 | (4 * (*(_BYTE *)(v9 + 1) & 0xF))]的值赋给v8指向的地址+2处

    v8[2] = aAyzpq23ijrtffg[(*(unsigned __int8 *)(v9 + 2) >> 6) & 0xFFFFFFC3 | (4 * (*(_BYTE *)(v9 + 1) & 0xF))];

    // 将*(_BYTE *)(v9 + 2) & 0x3F的值赋给v8指向的地址+3处

    v8[3] = aAyzpq23ijrtffg[*(_BYTE *)(v9 + 2) & 0x3F];

  }

  // 如果v7 < a3，执行以下代码

  if ( v7 < a3 )

  {

    // 将aAyzpq23ijrtffg[*(unsigned __int8 *)(a2 + v7) >> 2]的值赋给v8指向的地址

    *v8 = aAyzpq23ijrtffg[*(unsigned __int8 *)(a2 + v7) >> 2];

    // 计算v12的值

    v12 = (16 * *(unsigned __int8 *)(a2 + v7)) & 0x30;

    // 如果a3 - 1 == v7，执行以下代码

    if ( a3 - 1 == v7 )

    {

      v13 = 61;

      // 将aAyzpq23ijrtffg[v12]的值赋给v8指向的地址+1处

      v8[1] = aAyzpq23ijrtffg[v12];

    }

    else

    {

      // 将aAyzpq23ijrtffg[v12 | (*(unsigned __int8 *)(a2 + v7 + 1) >> 4)]的值赋给v8指向的地址+1处

      v8[1] = aAyzpq23ijrtffg[v12 | (*(unsigned __int8 *)(a2 + v7 + 1) >> 4)];

      // 将aAyzpq23ijrtffg[4 * (*(_BYTE *)(a2 + v7 + 1) & 0xF)]的值赋给v13

      v13 = aAyzpq23ijrtffg[4 * (*(_BYTE *)(a2 + v7 + 1) & 0xF)];

    }

    // 将61的值赋给v8指向的地址+3处

    v8[3] = 61;

    // 将v13的值赋给v8指向的地址+2处

    v8[2] = v13;

    // v8加上4

    v8 += 4;

  }

  // 将0赋给v8指向的地址

  *v8 = 0;

  // 返回&v8[-a1 + 1]的值

  return &v8[-a1 + 1];

}

进行hook

这里有个坑，就是在使用拦截器对sub_8B04 位置进行定位，如果使用var sub_8B04 = base_address.add(0x8B04); 拦截出错就加一

这样才能进入函数里面

1

var sub_8B04 = base_address.add(0x8B04+1);

hook代码如下

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

function hook_native(){

    Java.perform(function(){

        var base_address = Module.getBaseAddress("libnative-lib.so");

        if(base_address !=undefined){

        console.log("开始native层hook");

        //定位拦截位置

        var sub_8B04 = base_address.add(0x8B04+1);

        console.log("sub_8b04:",sub_8B04)

        if(sub_8B04!=undefined){

        console.log("进入native层0x8B04");

        }else{

        console.log("拦截器加载失败");

        }

        //使用拦截器

        Interceptor.attach(sub_8B04,{

        //开始进入函数,传入了三个参数依次打印

        onEnter:function(args){

            //保存参数

            this.arg0 = args[0];

            this.arg1 = args[1];

            this.arg2 = args[2];

            console.log("========>ENTER<========");

            console.log("sub_8B04未初始化时第一个参数是===>"+this.arg0.readCString());

            console.log("sub_8B04未初始化时第二个参数是===>"+this.arg1.readCString());

            console.log("sub_8B04未初始化时第三个参数是===>"+this.arg2.readCString());           

        },

        onLeave:function(result){

            console.log("========>LEAVE<========");

            console.log("sub_8B04已经初始化时第一个参数是===>"+this.arg0.readCString());

        }

        }

        )

        }

    })

}

hook显示的结果如下

1

2

3

4

sub_8B04未初始化时第一个参数是===>

sub_8B04未初始化时第二个参数是===>xVjHx-D&nji8i*rBZ)j

sub_8B04未初始化时第三个参数是===>0x13(传入参数的字符串大小)

sub_8B04已经初始化时第一个参数是===>`!^fZFrxI^q~[+\~p#p~F==

使用IDA 对libnative-lib.so进行动态调试的时候会发现 aAyzpq23ijrtffg 字符串和我们之前记录的字符串(aAyzpq23ijrtffg DCB "AYZpq23IJrTFfghijklCDE1KLMmBdestU5678GHz0cuvwabN9+/VWXnoOPQRSxy4",0)并不相同，结合前面的思考，换了码表可能性更大

image-20231104105122522

我们开始hook aAyzpq23ijrtffg 码表(0x1B000),这个有个hook技巧: 复制使用readCString打印字符串 可能会造成数据丢失，所以我们使用hexdump(16进制)显示码表的内容会更精确

hook代码如下

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

function hook_native_sub_8B04(){

    Java.perform(function(){

        var base_address = Module.getBaseAddress("libnative-lib.so");

        if(base_address !=undefined){

        console.log("开始native层hook");

        //定位拦截位置

        var sub_8B04 = base_address.add(0x8B04+1);

        if(sub_8B04){

        console.log("进入native层0x8B04");

    }else{

        console.log("拦截器加载失败");

    }

        //使用拦截器

        Interceptor.attach(sub_8B04,{

        //开始进入函数,传入了三个参数依次打印

        onEnter:function(args){

            //保存第一个参数

            this.arg0 = args[0];

            this.arg1 = args[1];

            this.arg2 = args[2];

            console.log("========>ENTER<========");

            // console.log("sub_8B04未初始化时第一个参数是===>"+hexdump(this.arg0,{length:32,header:false}));

            // console.log("sub_8B04未初始化时第一个参数是===>"+hexdump(this.arg1,{length:32,header:false}));

            //console.log("sub_8B04未初始化时第一个参数是===>"+hexdump(this.arg2,{length:32,header:false}));

            var hook_aAyzpq23ijrtffg = base_address.add(0x1B000);

            if(hook_aAyzpq23ijrtffg!=undefined){console.log("aAyzpq23ijrtffg进入8B04的形状=====>"+hexdump(hook_aAyzpq23ijrtffg))};

     

        },

        onLeave:function(result){

            console.log("========>LEAVE<========");

            console.log("sub_8B04第一个参数处理后======>"+hexdump(this.arg0)); //打印处理后的第一个参数

            //console.log("sub_8B04得到的结果是====>"+result.readCString());

            // console.log("sub_8B04处理后第一个参数是===>"+hexdump(this.arg0,{length:32,header:false}));

            console.log("sub_8B04处理后时第一个参数是===>"+result);

            // console.log("sub_8B04处理后时第一个参数是===>"+hexdump(this.arg2,{length:32,header:false}));

        }

        })

        }

    })

}

码表果然发生改变

零基础算法还原01以及使用python和JS还原C++部分细节_第12张图片

看看是不是只是简单换了码表，其他地方有没有进行加密

零基础算法还原01以及使用python和JS还原C++部分细节_第13张图片

是的，和猜测的结果完全一致！

再来看看码表是在哪个位置发生改变的，在sub_8ABC 找到码表发生变化的位置,并且发现传参(a1)就是加密前的字符串被int强转

零基础算法还原01以及使用python和JS还原C++部分细节_第14张图片

完整的hook代码如下

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

function hook_js(){

    Java.perform(function(){

    var enrandomcode = Java.use("com.kanxue.algorithmbase.MainActivity")

    //如果定义好了

    if(enrandomcode !=undefined)

        {

          console.log("开始JAVA层Hook");

          enrandomcode.encodeFromJni_12.implementation = function(intput){

            var res = this.encodeFromJni_12(intput);

            console.log("传入参数是====>"+intput);

            console.log("加密后的参数是====>"+res);

            return res;

          }

           

        }

    })

}

function hook_native(){

    Java.perform(function(){

        var base_address = Module.getBaseAddress("libnative-lib.so");

        if(base_address !=undefined){

        console.log("开始native层hook");

        //定位拦截位置

        var sub_8B04 = base_address.add(0x8B04+1);

        console.log("sub_8b04:",sub_8B04)

        if(sub_8B04){

        console.log("进入native层0x8B04");

        }else{

        console.log("拦截器加载失败");

        }

        //使用拦截器

        Interceptor.attach(sub_8B04,{

        //开始进入函数,传入了三个参数依次打印

        onEnter:function(args){

            //保存第一个参数

            this.arg0 = args[0];

            this.arg1 = args[1];

            this.arg2 = args[2];

            console.log("========>ENTER<========");

            // console.log("sub_8B04未初始化时第一个参数是===>"+this.arg0.readCString());

            // console.log("sub_8B04未初始化时第二个参数是===>"+this.arg1.readCString());

            //console.log("sub_8B04未初始化时第三个参数是===>"+hexdump(this.arg2,{length:64,header:false}));

            var hook_aAyzpq23ijrtffg = base_address.add(0x1B000);

             

            if(hook_aAyzpq23ijrtffg!=undefined){console.log("aAyzpq23ijrtffg进入8B04的形状=====>"+hook_aAyzpq23ijrtffg.readCString().length())};

             

        },

        onLeave:function(result){

            console.log("========>LEAVE<========");

            // console.log("sub_8B04已经初始化时第一个参数是===>"+hexdump(this.arg0,{length:64,header:false}));

            // console.log("sub_8B04已经初始化时第二个参数是===>"+hexdump(this.arg1,{length:64,header:false}));

            //console.log("sub_8B04已经初始化时第三个参数是===>"+hexdump(this.arg2,{length:64,header:false}));

        }

        }

        )

        }

    })

}

function hookencodeFromJni(){

    Java.perform(function(){

        var base_address = Module.getBaseAddress("libnative-lib.so");

        var base_address_method = Module.findExportByName("libnative-lib.so","Java_com_kanxue_algorithmbase_MainActivity_encodeFromJni_112")

        if(base_address_method!=undefined)

        {

            console.log("=======>进入初始界面进行Hook<=======");

            //使用拦截器

            Interceptor.attach(base_address_method,{

                onEnter:function(args){

                    //打印我们想要的param1和param2

                    // console.log("args[0]===>"+args[0]);

                    // console.log("args[1]===>"+args[1]);

                     

                    // console.log("args[2]===>"+args[2]);

                    // console.log("args[3]===>"+args[3]);

                    var hook_aAyzpq23ijrtffghijklmn = base_address.add(0x1B000+1);

                    console.log("aAyzpq23ijrtffghijklmn在导出函数里面=====>"+hook_aAyzpq23ijrtffghijklmn.readCString());

                     

                },

                onLeave:function(nreval){

                    nreval.replace(0);

                    console.log(nreval);

                }

            })

        }

    })

}

function hook_native_sub_8B04(){

    Java.perform(function(){

        var base_address = Module.getBaseAddress("libnative-lib.so");

        if(base_address !=undefined){

        console.log("开始native层hook");

        //定位拦截位置

        var sub_8B04 = base_address.add(0x8B04+1);

        if(sub_8B04){

        console.log("进入native层0x8B04");

    }else{

        console.log("拦截器加载失败");

    }

        //使用拦截器

        Interceptor.attach(sub_8B04,{

        //开始进入函数,传入了三个参数依次打印

        onEnter:function(args){

            //保存第一个参数

            this.arg0 = args[0];

            this.arg1 = args[1];

            this.arg2 = args[2];

            console.log("========>ENTER<========");

            // console.log("sub_8B04未初始化时第一个参数是===>"+hexdump(this.arg0,{length:32,header:false}));

            // console.log("sub_8B04未初始化时第一个参数是===>"+hexdump(this.arg1,{length:32,header:false}));

            //console.log("sub_8B04未初始化时第一个参数是===>"+hexdump(this.arg2,{length:32,header:false}));

            var hook_aAyzpq23ijrtffg = base_address.add(0x1B000);

            if(hook_aAyzpq23ijrtffg!=undefined){console.log("aAyzpq23ijrtffg进入8B04的形状=====>"+hexdump(hook_aAyzpq23ijrtffg))};

     

        },

        onLeave:function(result){

            console.log("========>LEAVE<========");

            console.log("sub_8B04第一个参数处理后======>"+hexdump(this.arg0)); //打印处理后的第一个参数

            //console.log("sub_8B04得到的结果是====>"+result.readCString());

            // console.log("sub_8B04处理后第一个参数是===>"+hexdump(this.arg0,{length:32,header:false}));

            console.log("sub_8B04处理后时第一个参数是===>"+result);

            // console.log("sub_8B04处理后时第一个参数是===>"+hexdump(this.arg2,{length:32,header:false}));

        }

        })

        }

    })

}

function main(){

    hook_js();

    hook_native_sub_8B04()

    hook_native();

    hookencodeFromJni()

}

setImmediate(main);

使用C++还原加密流程

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

#include

#include

#include  

#include

#include

#include

#include

#include

#include

#include

#define  _DWORD DWORD

using namespace std;

DWORD v16[2] = { 1, 2 };  // 将数组的所有元素初始化为0

string Hex2Ascii(string input) {

    std::stringstream ss(input);

    std::string token;

    std::vector<char> characters;

    while (std::getline(ss, token, ' ')) {

        int ascii = std::stoi(token, nullptr, 16);

        char c = static_cast<char>(ascii);

        characters.push_back(c);

    }

    std::string result(characters.begin(), characters.end());

    return result;

}

unsigned char* sub_8B04(int a1, int a2, int a3)

{

    int v3 =0; // r12

    int v6 =0; // r6

    int v7 =0; // r5

    unsigned char* v8 = new unsigned char[100]; // r3

    unsigned char* address = v8;//保存v8的首地址

    memset(v8, '\0', 100); // 将 v8 的所有元素都设置为 '1'

    int v9 =0; // r2

    unsigned int v10 =0; // r0

    char v11 ='\0'; // r4

    int v12 =0; // r6

    char v13 ='\0'; // r1

    std::string input = "52 4a 49 63 62 21 20 5a 59 61 47 55 75 74 7b 7a 79 78 7f 50 57 56 22 58 5f 5e 7e 51 77 76 60 67 46 26 25 24 2b 54 5b 69 23 70 66 65 64 72 71 5d 2a 38 3c 45 44 4b 7d 7c 5c 43 42 41 40 6b 6a 27";

    string aAyzpq23ijrtffg = Hex2Ascii(input);

    v3 = a3 - 2;

    v6 = 0;

    v7 = 0;

    while (1)

    {

        v8 = (unsigned __int8*)(address + v6);

        if (v7 >= v3)

            break;

        v9 = a2 + v7;   //开始出现a2(传进来的参数)

        v6 += 4;

        *v8 = aAyzpq23ijrtffg[*(unsigned __int8*)(a2 + v7) >> 2];

        v10 = *(unsigned __int8*)(a2 + v7 + 1);

        v11 = *(unsigned char*)(a2 + v7);

        v7 += 3;

        v8[1] = aAyzpq23ijrtffg[(v10 >> 4) & 0xFFFFFFCF | (16 * (v11 & 3))];

        v8[2] = aAyzpq23ijrtffg[(*(unsigned __int8*)(v9 + 2) >> 6) & 0xFFFFFFC3 | (4 * (*(unsigned char*)(v9 + 1) & 0xF))];

        v8[3] = aAyzpq23ijrtffg[*(unsigned char*)(v9 + 2) & 0x3F];

         

         

    }

    if (v7 < a3)

    {

        *v8 = aAyzpq23ijrtffg[*(unsigned __int8*)(a2 + v7) >> 2];

        v12 = (16 * *(unsigned __int8*)(a2 + v7)) & 0x30;

        if (a3 - 1 == v7)

        {

            v13 = 61;

            v8[1] = aAyzpq23ijrtffg[v12];

        }

        else

        {

            v8[1] = aAyzpq23ijrtffg[v12 | (*(unsigned __int8*)(a2 + v7 + 1) >> 4)];

            v13 = aAyzpq23ijrtffg[4 * (*(unsigned __int8*)(a2 + v7 + 1) & 0xF)];

        }

         

        v8[2] = v13;

        v8[3] = 61;

        v8 += 4;

    }

    *v8 = 0;

    return &v8[-a1 + 1];

}

__int64 sub_882C(__int64 result)

{

    int i; // r2

    result &= 0xFFFFFFFFFFFFFFFFULL;  // 将result的低64位保留，高64位设置为0

    for (i = 0; i != 3; ++i)

        *(_DWORD*)(result + 4 * i) = 0;

    return result;

}

DWORD* sub_8740(__int64 a1)

{

    int v1=0; // r4

    v1 = a1;

    *(_DWORD*)a1 = 0;

    *(_DWORD*)(a1 + 4) = 0;

    *(_DWORD*)(a1 + 8) = 0;

    sub_882C(a1);

    return (_DWORD*)v1;

}

int main()

{  

    char str1[] = "xVjHx-D&nji8i*rBZ)j";

    string str(str1);

    int n = str.length();

    int param2 = 0;

    char* v17=nullptr;

    v17 = (char*)param2;

    unsigned char* str2 = sub_8B04(int(""), (int)str1, n);

}

零基础算法还原01以及使用python和JS还原C++部分细节_第15张图片

使用JS对加密算法进行还原

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

function Hex2Ascii(string){

    var hexArray = string.split(" ");   // 拆分字符串为数组

    var asciiArray = hexArray.map(function(hex) {

        var decimal = parseInt(hex, 16);  // 将16进制数转换为10进制数

        return String.fromCharCode(decimal);  // 将10进制数转换为对应的ASCII字符

    });

    var result = asciiArray.join("");  // 将字符数组合并为一个字符串

    return result;

}

function stringToUint8Array(str){

    var arr = [];

    for (var i=0;i

    {

        arr.push(str.charCodeAt(i));

    }

    var outputbytes = new Uint8Array(arr);

    return outputbytes;

}

function sub_8B04(str,len){

    var string = "52 4a 49 63 62 21 20 5a 59 61 47 55 75 74 7b 7a 79 78 7f 50 57 56 22 58 5f 5e 7e 51 77 76 60 67 46 26 25 24 2b 54 5b 69 23 70 66 65 64 72 71 5d 2a 38 3c 45 44 4b 7d 7c 5c 43 42 41 40 6b 6a 27"

    var aAyzpq23ijrtffg = Hex2Ascii(string);    //生成码表

    var v8 ="";

    var v3 = len-2;

    var v6 =0;

    var v7=0;

    var v9=0;

    var v12 =0;

    var a2 = stringToUint8Array(str);

    while (1){

    if (v7>=v3){

        break;

    }

    v9 = a2[v7];

    var v9_1 = a2[v7+1];

    var v9_2 =a2[v7+2];

    v6 +=4;

    v8 += aAyzpq23ijrtffg.charAt(a2[v7] >>2 );

    var v10 = a2[v7+1];

    var v11 = a2[v7];

    v7 +=3;

    v8 += aAyzpq23ijrtffg.charAt((v10>>4)&0xFFFFFFCF |(16* (v11 &3)));

    v8 += aAyzpq23ijrtffg.charAt(((v9_2) >>6)& 0xFFFFFFC3 | 4*((v9_1)&0xF));

    v8 += aAyzpq23ijrtffg[(v9_2)&0x3F]

    }

    if(v7

        v8+=aAyzpq23ijrtffg[a2[v7]];

        v12 =(16 * a2[v7])&0x03;

        if (len -1 ==v7){

            var v13 = 61;

            v8 += aAyzpq23ijrtffg[v12];

        }

        else {

            v8 +=aAyzpq23ijrtffg[v12 | (a2[v7+1]) >>4];

            v13 = aAyzpq23ijrtffg[4*a2[v7+1] & 0xF]

        }

        v8 += String.fromCharCode(v13);

        v8 += String.fromCharCode(61);

        return v8;

    }

}

var str = "xVjHx-D&nji8i*rBZ)j";

console.log(sub_8B04(str,str.length))

零基础算法还原01以及使用python和JS还原C++部分细节_第16张图片

使用python还原加密流程

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

def Hex2Ascii(string):

    hex_list = string.split()  # 分割字符串生成包含十六进制数的列表

    ascii_list = []

    for hex_str in hex_list:

        decimal = int(hex_str, 16)  # 将十六进制数转换为十进制数

        ascii_char = chr(decimal)  # 将十进制数转换为ASCII字符

        ascii_list.append(ascii_char)

    result = ''.join(ascii_list)  # 将ASCII字符列表合并为一个字符串

    return  result

def sub_8B04(str,len):

    string = "52 4a 49 63 62 21 20 5a 59 61 47 55 75 74 7b 7a 79 78 7f 50 57 56 22 58 5f 5e 7e 51 77 76 60 67 46 26 25 24 2b 54 5b 69 23 70 66 65 64 72 71 5d 2a 38 3c 45 44 4b 7d 7c 5c 43 42 41 40 6b 6a 27"

    # 生成码表

    aAyzpq23ijrtffg = Hex2Ascii(string)

    v8 =""

    v3 = len-2

    v6 =0

    v7=0

    v9=0

    a2 = bytes(str,"utf-8")

    while True:

        if v7>=v3:

            break

        v9=a2[v7]

        v9_1 = a2[v7+1]

        v9_2 =a2[v7+2]

        v6+=4

        v8 += aAyzpq23ijrtffg[a2[v7] >>2]

        v10 =a2[v7+1]

        v11 = a2[v7]

        v7+=3

        v8+=aAyzpq23ijrtffg[(v10>>4)&0xFFFFFFCF |(16* (v11 &3))]

        v8+=aAyzpq23ijrtffg[((v9_2) >>6)& 0xFFFFFFC3 | 4*((v9_1)&0xF)]

        v8+=aAyzpq23ijrtffg[(v9_2)&0x3F]

    if v7<len:

        v8 += aAyzpq23ijrtffg[a2[v7] >>2]

        v12 = (16* a2[v7]) &0x30

        if(len -1 == v7):

            v13 =61

            v8 +=aAyzpq23ijrtffg[v12]

        else:

            v8+=aAyzpq23ijrtffg[v12 | (a2[v7+1]) >>4]

            v13 = aAyzpq23ijrtffg[4*a2[v7+1] &0xF]

        v8+=chr(v13)

        v8+=chr(61)

        return v8

if __name__ == '__main__':

    str1="xVjHx-D&nji8i*rBZ)j"

    result=sub_8B04(str1,len(str1))

    print(result)

零基础算法还原01以及使用python和JS还原C++部分细节_第17张图片

题目三:

JAVA层

algorithmbase_13.apk

使用JADX打开apk文件

image-20231104215709725

通过调用MainActivity类中的encodeFromJni_12方法，将randomAscii字符串进行加密，并将加密后的结果存储在encodeFromJni_12字符串中。然后，使用Log.e方法将randomAscii字符串和加密后的结果一起打印出来，以便进行调试和分析。

SO

使用IDA打开，按照以前的思路继续从下往上分析

按照第二题的思路，来到sub_8B04

零基础算法还原01以及使用python和JS还原C++部分细节_第18张图片

发现和上一题加密没啥区别就只是多了和参数a3的异或

使用Frida Hook 一下传入参数和传出参数

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

function hook_js(){

    Java.perform(function(){

    var enrandomcode = Java.use("com.kanxue.algorithmbase.MainActivity")

    //如果定义好了

    if(enrandomcode !=undefined)

        {

          console.log("开始JAVA层Hook\r\n");

          enrandomcode.encodeFromJni_13.implementation = function(intput){

            var res = this.encodeFromJni_13(intput);

            console.log("\n传入参数是====>"+intput);

            console.log("加密后的参数是====>"+res);

            return res;

          }

        }

    })

}

function hook_native(){

    Java.perform(function(){

        var base_address = Module.getBaseAddress("libnative-lib.so");

        if(base_address!=undefined)

        {

            console.log("获取到基地址");

            var sub_8B04=base_address.add(0x8B04+1);

            //开启拦截器

            Interceptor.attach(sub_8B04,{

                onEnter:function(args){

                    this.arg0 = args[0];

                    this.arg1 = args[1];

                    this.arg2 = args[2];

                    console.log("sub_80B4传进来的第一个参数是===>"+this.arg0.readCString());

                    console.log("sub_80B4传进来的第二个参数是===>"+this.arg1.readCString());

                    //console.log("sub_80B4传进来的第三个参数是===>"+this.arg2.readCString());

                    var sub_1B000 = base_address.add(0x1B000);

                    if(sub_1B000!=undefined){

                    console.log("aAyzpq23ijrtffg===>"+ hexdump(sub_1B000));

                    }

     

                },onLeave:function(nresult){

                    console.log("sub_80B4对传入参数处理后的结果是===>"+nresult);

                    console.log("sub_80B4对传入参数处理后的结果是===>"+this.arg0.readCString());

     

                }

            })

        }

    })

}

function main(){

    hook_js();

    hook_native();

}

setImmediate(main);

零基础算法还原01以及使用python和JS还原C++部分细节_第19张图片

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

[LGE Nexus 5X::com.kanxue.algorithmbase]-> 开始JAVA层Hook

获取到基地址

sub_80B4传进来的第一个参数是===>

sub_80B4传进来的第二个参数是===>cPN~zk)|Kpehw7zZn;PU6Gg_kj*[Z

aAyzpq23ijrtffg===>           0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F  0123456789ABCDEF

ca86a000  5c 44 47 6d 6c 2f 2e 54 57 6f 49 5b 7b 7a 75 74  \DGml/.TWoI[{zut

ca86a010  77 76 71 5e 59 58 2c 56 51 50 70 5f 79 78 6e 69  wvq^YX,VQPp_yxni                                                                                 

ca86a020  48 28 2b 2a 25 5a 55 67 2d 7e 68 6b 6a 7c 7f 53  H(+*%ZUg-~hkj|.S

ca86a030  24 36 32 4b 4a 45 73 72 52 4d 4c 4f 4e 65 64 29  $62KJEsrRMLONed)

ca86a040  00 00 00 00 fd 91 85 ca d9 92 85 ca b8 47 86 ca  .............G..

ca86a050  78 a2 86 ca 00 00 00 00 00 00 00 00 00 00 00 00  x...............

ca86a060  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

ca86a070  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

ca86a080  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

ca86a090  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

ca86a0a0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

ca86a0b0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

ca86a0c0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

ca86a0d0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

ca86a0e0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

ca86a0f0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

sub_80B4对传入参数处理后的结果是===>0x29

sub_80B4对传入参数处理后的结果是===>LEYutgckTV+[d.E-eKeL1UOOD/Dskseims0h,E-=

hook的结果更加验证了我们的思路

直接开始还原算法验证

C++代码如下

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

#include

#include

#include  

#include

#include

#include

#include

#include

#include

#include

#define  _DWORD DWORD

using namespace std;

DWORD v16[2] = { 1, 2 };  // 将数组的所有元素初始化为0

string Hex2Ascii(string input) {

    std::stringstream ss(input);

    std::string token;

    std::vector<char> characters;

    while (std::getline(ss, token, ' ')) {

        int ascii = std::stoi(token, nullptr, 16);

        char c = static_cast<char>(ascii);

        characters.push_back(c);

    }

    std::string result(characters.begin(), characters.end());

    return result;

}

unsigned char* sub_8B04(int a1, int a2, int a3)

{

    int v3 = 0; // r12

    int v6 = 0; // r6

    int v7 = 0; // r5

    unsigned char* v8 = new unsigned char[100]; // r3

    unsigned char* address = v8;//保存v8的首地址

    memset(v8, '\0', 100); // 将 v8 的所有元素都设置为 '1'

    int v9 = 0; // r2

    unsigned int v10 = 0; // r0

    char v11 = '\0'; // r4

    int v12 = 0; // r6

    char v13 = '\0'; // r1

    std::string input = "5c 44 47 6d 6c 2f 2e 54 57 6f 49 5b 7b 7a 75 74 77 76 71 5e 59 58 2c 56 51 50 70 5f 79 78 6e 69 48 28 2b 2a 25 5a 55 67 2d 7e 68 6b 6a 7c 7f 53 24 36 32 4b 4a 45 73 72 52 4d 4c 4f 4e 65 64 29";

    string aAyzpq23ijrtffg = Hex2Ascii(input);

    v3 = a3 - 2;

    v6 = 0;

    v7 = 0;

    while (1)

    {

        v8 = (unsigned __int8*)(address + v6);

        if (v7 >= v3)

            break;

        v9 = a2 + v7;   //开始出现a2(传进来的参数)

        v6 += 4;

        *v8 = aAyzpq23ijrtffg[*(unsigned __int8*)(a2 + v7) >> 2] ^a3;

        v10 = *(unsigned __int8*)(a2 + v7 + 1);

        v11 = *(unsigned char*)(a2 + v7);

        v7 += 3;

        v8[1] = aAyzpq23ijrtffg[(v10 >> 4) & 0xFFFFFFCF | (16 * (v11 & 3))];

        v8[2] = aAyzpq23ijrtffg[(*(unsigned __int8*)(v9 + 2) >> 6) & 0xFFFFFFC3 | (4 * (*(unsigned char*)(v9 + 1) & 0xF))] ^ a3;

        v8[3] = aAyzpq23ijrtffg[*(unsigned char*)(v9 + 2) & 0x3F];

    }

    if (v7 < a3)

    {

        *v8 = aAyzpq23ijrtffg[*(unsigned __int8*)(a2 + v7) >> 2];

        v12 = (16 * *(unsigned __int8*)(a2 + v7)) & 0x30;

        if (a3 - 1 == v7)

        {

            v13 = 61;

            v8[1] = aAyzpq23ijrtffg[v12];

        }

        else

        {

            v8[1] = aAyzpq23ijrtffg[v12 | (*(unsigned __int8*)(a2 + v7 + 1) >> 4)];

            v13 = aAyzpq23ijrtffg[4 * (*(unsigned __int8*)(a2 + v7 + 1) & 0xF)];

        }

        v8[2] = v13;

        v8[3] = 61;

        v8 += 4;

    }

    *v8 = 0;

    return &v8[-a1 + 1];

}

__int64 sub_882C(__int64 result)

{

    int i; // r2

    result &= 0xFFFFFFFFFFFFFFFFULL;  // 将result的低64位保留，高64位设置为0

    for (i = 0; i != 3; ++i)

        *(_DWORD*)(result + 4 * i) = 0;

    return result;

}

DWORD* sub_8740(__int64 a1)

{

    int v1 = 0; // r4

    v1 = a1;

    *(_DWORD*)a1 = 0;

    *(_DWORD*)(a1 + 4) = 0;

    *(_DWORD*)(a1 + 8) = 0;

    sub_882C(a1);

    return (_DWORD*)v1;

}

int main()

{

    char str1[] = "cPN~zk)|Kpehw7zZn;PU6Gg_kj*[Z";

    string str(str1);

    int n = str.length();

    int param2 = 0;

    char* v17 = nullptr;

    v17 = (char*)param2;

    unsigned char* str2 = sub_8B04(int(""), (int)str1, n);

    std::cout << str2 << std::endl;

}

零基础算法还原01以及使用python和JS还原C++部分细节_第20张图片

JS代码如下

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

function Hex2Ascii(string){

    var hexArray = string.split(" ");   // 拆分字符串为数组

    var asciiArray = hexArray.map(function(hex) {

        var decimal = parseInt(hex, 16);  // 将16进制数转换为10进制数

        return String.fromCharCode(decimal);  // 将10进制数转换为对应的ASCII字符

    });

    var result = asciiArray.join("");  // 将字符数组合并为一个字符串

    return result;

}

function stringToUint8Array(str){

    var arr = [];

    for (var i=0;i

    {

        arr.push(str.charCodeAt(i));

    }

    var outputbytes = new Uint8Array(arr);

    return outputbytes;

}

function sub_8B04(str,len){

    var string =  "5c 44 47 6d 6c 2f 2e 54 57 6f 49 5b 7b 7a 75 74 77 76 71 5e 59 58 2c 56 51 50 70 5f 79 78 6e 69 48 28 2b 2a 25 5a 55 67 2d 7e 68 6b 6a 7c 7f 53 24 36 32 4b 4a 45 73 72 52 4d 4c 4f 4e 65 64 29";

    var aAyzpq23ijrtffg = Hex2Ascii(string);    //生成码表

    var v8 ="";

    var v3 = len-2;

    var v6 =0;

    var v7=0;

    var v9=0;

    var v12 =0;

    var a2 = stringToUint8Array(str);

    var a3 = len;

    while (1){

    if (v7>=v3){

        break;

    }

    v9 = a2[v7];

    var v9_1 = a2[v7+1];

    var v9_2 =a2[v7+2];

    v6 +=4;

    v8 += String.fromCharCode(aAyzpq23ijrtffg.charCodeAt(a2[v7] >>2 ) ^ a3);

    var v10 = a2[v7+1];

    var v11 = a2[v7];

    v7 +=3;

    v8 += aAyzpq23ijrtffg.charAt((v10>>4)&0xFFFFFFCF |(16* (v11 &3))) ;

    v8 += String.fromCharCode(aAyzpq23ijrtffg.charCodeAt(((v9_2) >>6)& 0xFFFFFFC3 | 4*((v9_1)&0xF)) ^ a3);

    v8 += aAyzpq23ijrtffg[(v9_2)&0x3F]

    }

    if(v7

        v8+=aAyzpq23ijrtffg[a2[v7] >>2];

        v12 =(16 * a2[v7])& 0x30;

        if (len -1 ==v7){

            var v13 = 61;

            v8 += aAyzpq23ijrtffg[v12];

        }

        else {

            v8 +=aAyzpq23ijrtffg[v12 | (a2[v7+1]) >>4];

            v13 = aAyzpq23ijrtffg[4*(a2[v7+1] & 0xF)]

        }

        v8 += v13;

        v8 += String.fromCharCode(61);

        return v8;

    }

}

var str = "cPN~zk)|Kpehw7zZn;PU6Gg_kj*[Z";

console.log(sub_8B04(str,str.length))

零基础算法还原01以及使用python和JS还原C++部分细节_第21张图片

python代码如下

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

def Hex2Ascii(string):

    hex_list = string.split()  # 分割字符串生成包含十六进制数的列表

    ascii_list = []

    for hex_str in hex_list:

        decimal = int(hex_str, 16)  # 将十六进制数转换为十进制数

        ascii_char = chr(decimal)  # 将十进制数转换为ASCII字符

        ascii_list.append(ascii_char)

    result = ''.join(ascii_list)  # 将ASCII字符列表合并为一个字符串

    return  result

def sub_8B04(str,len):

    string = "5c 44 47 6d 6c 2f 2e 54 57 6f 49 5b 7b 7a 75 74 77 76 71 5e 59 58 2c 56 51 50 70 5f 79 78 6e 69 48 28 2b 2a 25 5a 55 67 2d 7e 68 6b 6a 7c 7f 53 24 36 32 4b 4a 45 73 72 52 4d 4c 4f 4e 65 64 29";

    # 生成码表

    aAyzpq23ijrtffg = Hex2Ascii(string)

    v8 =""

    v3 = len-2

    v6 =0

    v7=0

    v9=0

    a2 = bytes(str,"utf-8")

    a3 = len

    while True:

        if v7>=v3:

            break

        v9=a2[v7]

        v9_1 = a2[v7+1]

        v9_2 =a2[v7+2]

        v6+=4

        v8 += chr(ord(aAyzpq23ijrtffg[a2[v7] >>2]) ^ a3)

        v10 =a2[v7+1]

        v11 = a2[v7]

        v7+=3

        v8+=aAyzpq23ijrtffg[(v10>>4)&0xFFFFFFCF |(16* (v11 &3))]

        v8+= chr(ord(aAyzpq23ijrtffg[((v9_2) >>6)& 0xFFFFFFC3 | 4*((v9_1)&0xF)])^ a3)

        v8+=aAyzpq23ijrtffg[(v9_2)&0x3F]

    if v7

        v8 += aAyzpq23ijrtffg[a2[v7] >>2]

        v12 = (16* a2[v7]) &0x30

        if(a3 -1 == v7):

            v13 =61

            v8 +=aAyzpq23ijrtffg[v12]

        else:

            v8+=aAyzpq23ijrtffg[v12 | (a2[v7+1]) >>4]

            v13 = aAyzpq23ijrtffg[4*(a2[v7+1] &0xF)]

        v8+=v13

        v8+=chr(61)

        return v8

if __name__ == '__main__':

    str1="cPN~zk)|Kpehw7zZn;PU6Gg_kj*[Z"

    result=sub_8B04(str1,len(str1))

    print(result)

零基础算法还原01以及使用python和JS还原C++部分细节_第22张图片

JS还原C++函数总结

字符串篇
C++字符串型的传参在JS中的变化

C++的函数传参是如果char数组,当使用JS对其进行还原时候，为了方便后面字符串型参数在JS中计算字符串偏移，最好把字符串转为8位无符号整型数组Uint8Array（对应是C++中的(unsigned char*)）

如下

1

2

3

4

5

6

7

8

9

10

function stringToUint8Array(str){

    var arr = [];

    for (var i=0;i

    {

        arr.push(str.charCodeAt(i));

    }

    var outputbytes = new Uint8Array(arr);

    return outputbytes;

}

这么看不太直观。拿刚才的第三题举例
C++中

1

2

3

4

5

6

7

char str1[] = "cPN~zk)|Kpehw7zZn;PU6Gg_kj*[Z";

string str(str1);

int n = str.length();

int param2 = 0;

char* v17 = nullptr;

v17 = (char*)param2;

unsigned char* str2 = sub_8B04(int(""), (int)str1, n);

这里面str1是char数组被强转为整型当成传参进入的sub_8B04 函数

但在JS中，我们进入sub_8B04 就是传参str是字符串，不需要变整型

image-20231105115216312

为了方便后面的字节偏移计算，我们再把字符串str 转为8位无符号整型数组

1

var a2 = stringToUint8Array(str);
C++ 函数里面与字符串类型传参相关的参数 在JS中的还原

1

2

3

4

5

unsigned char* sub_8B04(int a1, int a2, int a3)

{  

    int v7 = 0; // r5

    v9 = a2 + v7;   //开始出现a2(传进来的参数)

}

在JS中还原C++函数sub_8B04里面的参数V9思路:

因为a2 原先是被int强转char数组。v9是(char*)a2数组偏移v7个字节后的参数
在前面的步骤中，a2在JS中已经被我们设置为8位无符号整型数组，所以v9=a2[v7]

1

2

3

4

function sub_8B04(str,len){

    var a2 = stringToUint8Array(str);

    v9 = a2[v7];

}  

根据这个思路

使用JS还原一下C++代码中* (unsigned __int8*)(v9 + 2) 和 * (unsigned __int8*)(v9 + 2) 代码如下

1

2

var v9_1 = a2[v7+1];

var v9_2 =a2[v7+2];
字节运算

由于JS语言的特性，不能直接把字符和数字进行直接的运算，所以要把字符转为Unicode 编码与数字进行运算后，再把得到的结果重新转为字符

需要用js的charat charCodeAt fromCharCode 三个函数进行转化这里面贴一下介绍

charAt 方法用于返回指定索引位置的字符。索引位置从0开始计数。

语法: string.charAt(index)

示例:

Copy

1

2

3

var str = "Hello World";

console.log(str.charAt(0)); // 输出 "H"

console.log(str.charAt(6)); // 输出 "W"

charCodeAt 方法返回指定索引位置的字符的Unicode编码。索引位置从0开始计数。

语法: string.charCodeAt(index)

示例:

1

2

3

var str = "Hello World";

console.log(str.charCodeAt(0)); // 输出 72

console.log(str.charCodeAt(6)); // 输出 87

fromCharCode 方法从Unicode编码创建一个字符串。

语法: String.fromCharCode(number1, number2, ... , numberX)

示例:

1

console.log(String.fromCharCode(72, 101, 108, 108, 111)); // 输出 "Hello"

现在分析一下前面第三题贴的C代码

1

*v8 = aAyzpq23ijrtffg[*(unsigned __int8*)(a2 + v7) >> 2] ^a3;

这段C代码的含义是将变量a2和v7的和作为地址，取出该地址处的一个字节数据，将其右移两位后转换为无符号8位整数，然后使用这个值作为索引，从数组aAyzpq23ijrtffg中取出对应位置的值，与变量a3进行异或操作，并将结果赋给变量v8。

在JS中aAyzpq23ijrtffg[*(unsigned __int8*)(a2 + v7) >> 2] 这个字符要和a3进行异或，a3是整型不能和字符异或，所以我们要把先把字符转为Unicode码再和a3进行异或运算，然后转为字符串如下

1

v8 += String.fromCharCode(aAyzpq23ijrtffg.charCodeAt(a2[v7] >>2 ) ^ a3);

Python 还原C++函数总结

字符串篇
C++字符串型的传参在python中的变化

C++的函数传参是如果char数组,当使用python对其进行还原时候，为了方便后面字符串型参数在python中计算字符串偏移，最好把字符串转为bytes数组（对应是C++中的(unsigned char*)）

如下

1

2

def sub_8B04(str,len):

    a2 = bytes(str,"utf-8")
C++ 函数里面与字符串类型传参相关的参数 在python中的还原

1

2

3

4

5

unsigned char* sub_8B04(int a1, int a2, int a3)

{  

    int v7 = 0; // r5

    v9 = a2 + v7;   //开始出现a2(传进来的参数)

}

在python中还原C++函数sub_8B04里面的参数V9思路:

因为a2 原先是被int强转char数组。v9是(char*)a2数组偏移v7个字节后的参数
在前面的步骤中，a2在python中已经被我们设置为bytes数组，所以v9=a2[v7]

1

v9 = a2[v7];

根据这个思路

使用python还原一下C++代码中* (unsigned __int8*)(v9 + 2) 和 * (unsigned __int8*)(v9 + 2) 代码如下

1

2

v9_1 = a2[v7+1]

v9_2 =a2[v7+2]
字节运算

由于python语言的特性，不能直接把字符和数字进行直接的运算，所以要把字符转为Unicode 编码与数字进行运算后，再把得到的结果重新转为字符

chr和ord是Python中的内置函数，用于字符和对应的Unicode编码之间的转换。

chr函数接受一个整数参数，返回对应的字符。例如：

1

2

3

print(chr(65))  # 输出A

print(chr(97))  # 输出a

print(chr(8364))  # 输出€

ord函数接受一个字符参数，返回对应的Unicode编码。例如：

1

2

3

print(ord('A'))  # 输出65

print(ord('a'))  # 输出97

print(ord('€'))  # 输出8364

通过chr和ord函数，我们可以方便地在字符和对应的Unicode编码之间进行转换。

现在分析一下前面第三题贴的C代码

1

*v8 = aAyzpq23ijrtffg[*(unsigned __int8*)(a2 + v7) >> 2] ^a3;

这段C代码的含义是将变量a2和v7的和作为地址，取出该地址处的一个字节数据，将其右移两位后转换为无符号8位整数，然后使用这个值作为索引，从数组aAyzpq23ijrtffg中取出对应位置的值，与变量a3进行异或操作，并将结果赋给变量v8。

在python中aAyzpq23ijrtffg[*(unsigned __int8*)(a2 + v7) >> 2] 这个字符要和a3进行异或，a3是整型不能和字符异或，所以我们要把先把字符转为Unicode码再和a3进行异或运算，然后转为字符串如下

1

v8 += chr(ord(aAyzpq23ijrtffg[a2[v7] >>2]) ^ a3)

你可能感兴趣的:(软件开发,算法,python,javascript)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • 利用Requests Toolkit轻松完成HTTP请求 nseejrukjhad http网络协议网络python
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • 121. 买卖股票的最佳时机 薄荷糖的味道_fb40
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • ios内付费 374016526 ios内付费
    近年来写了很多IOS的程序，内付费也用到不少，使用IOS的内付费实现起来比较麻烦，这里我写了一个简单的内付费包，希望对大家有帮助。   具体使用如下: 这里的sender其实就是调用者，这里主要是为了回调使用。 [KuroStoreApi kuroStoreProductId:@"产品ID" storeSender:self storeFinishCallBa
  • 20 款优秀的 Linux 终端仿真器 brotherlamp linuxlinux视频linux资料linux自学linux教程
      终端仿真器是一款用其它显示架构重现可视终端的计算机程序。换句话说就是终端仿真器能使哑终端看似像一台连接上了服务器的客户机。终端仿真器允许最终用户用文本用户界面和命令行来访问控制台和应用程序。（LCTT 译注：终端仿真器原意指对大型机-哑终端方式的模拟，不过在当今的 Linux 环境中，常指通过远程或本地方式连接的伪终端，俗称“终端”。） 你能从开源世界中找到大量的终端仿真器，它们
  • Solr Deep Paging(solr 深分页) eksliang solr深分页solr分页性能问题
    转载请出自出处：http://eksliang.iteye.com/blog/2148370 作者：eksliang(ickes) blg:http://eksliang.iteye.com/ 概述 长期以来，我们一直有一个深分页问题。如果直接跳到很靠后的页数，查询速度会比较慢。这是因为Solr的需要为查询从开始遍历所有数据。直到Solr的4.7这个问题一直没有一个很好的解决方案。直到solr
  • 数据库面试题 18289753290 面试题 数据库
    1.union ,union all 网络搜索出的最佳答案： union和union all的区别是,union会自动压缩多个结果集合中的重复结果，而union all则将所有的结果全部显示出来，不管是不是重复。 Union：对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序； Union All：对两个结果集进行并集操作，包括重复行，不进行排序； 2.索引有哪些分类？作用是
  • Android TV屏幕适配 酷的飞上天空 android
    先说下现在市面上TV分辨率的大概情况 两种分辨率为主 1.720标清，分辨率为1280x720. 屏幕尺寸以32寸为主，部分电视为42寸 2.1080p全高清，分辨率为1920x1080 屏幕尺寸以42寸为主，此分辨率电视屏幕从32寸到50寸都有   适配遇到问题，已1080p尺寸为例： 分辨率固定不变，屏幕尺寸变化较大。 如：效果图尺寸为1920x1080，如果使用d
  • Timer定时器与ActionListener联合应用 永夜-极光 java
    功能:在控制台每秒输出一次   代码: package Main; import javax.swing.Timer; import java.awt.event.*; public class T { private static int count = 0; public static void main(String[] args){
  • Ubuntu14.04系统Tab键不能自动补全问题解决 随便小屋 Ubuntu 14.04
    Unbuntu 14.4安装之后就在终端中使用Tab键不能自动补全，解决办法如下：   1、利用vi编辑器打开/etc/bash.bashrc文件（需要root权限） sudo vi /etc/bash.bashrc  接下来会提示输入密码 2、找到文件中的下列代码 #enable bash completion in interactive shells #if
  • 学会人际关系三招 轻松走职场 aijuans 职场
    要想成功，仅有专业能力是不够的，处理好与老板、同事及下属的人际关系也是门大学问。如何才能在职场如鱼得水、游刃有余呢？在此，教您简单实用的三个窍门。 　　第一，多汇报 最近，管理学又提出了一个新名词“追随力”。它告诉我们，做下属最关键的就是要多请示汇报，让上司随时了解你的工作进度，有了新想法也要及时建议。不知不觉，你就有了“追随力”，上司会越来越了解和信任你。 　　第二，勤沟通 团队的力
  • 《O2O：移动互联网时代的商业革命》读书笔记 aoyouzi 读书笔记
    移动互联网的未来：碎片化内容+碎片化渠道=各式精准、互动的新型社会化营销。   O2O：Online to OffLine 线上线下活动 O2O就是在移动互联网时代，生活消费领域通过线上和线下互动的一种新型商业模式。   手机二维码本质：O2O商务行为从线下现实世界到线上虚拟世界的入口。   线上虚拟世界创造的本意是打破信息鸿沟，让不同地域、不同需求的人
  • js实现图片随鼠标滚动的效果 百合不是茶 JavaScript滚动属性的获取图片滚动属性获取页面加载
    1,获取样式属性值 top 与顶部的距离 left 与左边的距离 right 与右边的距离 bottom 与下边的距离 zIndex 层叠层次     例子:获取左边的宽度,当css写在body标签中时 <div id="adver" style="position:absolute;top:50px;left:1000p
  • ajax同步异步参数async bijian1013 jqueryAjaxasync
            开发项目开发过程中，需要将ajax的返回值赋到全局变量中，然后在该页面其他地方引用，因为ajax异步的原因一直无法成功，需将async:false，使其变成同步的。         格式： $.ajax({ type: 'POST', ur
  • Webx3框架（1） Bill_chen eclipsespringmaven框架ibatis
    Webx是淘宝开发的一套Web开发框架，Webx3是其第三个升级版本；采用Eclipse的开发环境，现在支持java开发； 采用turbine原型的MVC框架，扩展了Spring容器，利用Maven进行项目的构建管理，灵活的ibatis持久层支持，总的来说，还是一套很不错的Web框架。 Webx3遵循turbine风格，velocity的模板被分为layout/screen/control三部
  • 【MongoDB学习笔记五】MongoDB概述 bit1129 mongodb
    MongoDB是面向文档的NoSQL数据库，尽量业界还对MongoDB存在一些质疑的声音，比如性能尤其是查询性能、数据一致性的支持没有想象的那么好，但是MongoDB用户群确实已经够多。MongoDB的亮点不在于它的性能，而是它处理非结构化数据的能力以及内置对分布式的支持(复制、分片达到的高可用、高可伸缩)，同时它提供的近似于SQL的查询能力，也是在做NoSQL技术选型时，考虑的一个重要因素。Mo
  • spring/hibernate/struts2常见异常总结 白糖_ Hibernate
    Spring ①ClassNotFoundException: org.aspectj.weaver.reflect.ReflectionWorld$ReflectionWorldException 缺少aspectjweaver.jar，该jar包常用于spring aop中   ②java.lang.ClassNotFoundException: org.sprin
  • jquery easyui表单重置(reset)扩展思路 bozch formjquery easyuireset
    在jquery easyui表单中 尚未提供表单重置的功能，这就需要自己对其进行扩展。 扩展的时候要考虑的控件有： combo,combobox,combogrid,combotree,datebox,datetimebox 需要对其添加reset方法，reset方法就是把初始化的值赋值给当前的组件，这就需要在组件的初始化时将值保存下来。 在所有的reset方法添加完毕之后，就需要对fo
  • 编程之美-烙饼排序 bylijinnan 编程之美
    package beautyOfCoding; import java.util.Arrays; /* *《编程之美》的思路是：搜索+剪枝。有点像是写下棋程序：当前情况下，把所有可能的下一步都做一遍；在这每一遍操作里面，计算出如果按这一步走的话，能不能赢（得出最优结果）。 *《编程之美》上代码有很多错误，且每个变量的含义令人费解。因此我按我的理解写了以下代码： */
  • Struts1.X 源码分析之ActionForm赋值原理 chenbowen00 struts
    struts1在处理请求参数之前，首先会根据配置文件action节点的name属性创建对应的ActionForm。如果配置了name属性，却找不到对应的ActionForm类也不会报错，只是不会处理本次请求的请求参数。 如果找到了对应的ActionForm类，则先判断是否已经存在ActionForm的实例，如果不存在则创建实例，并将其存放在对应的作用域中。作用域由配置文件action节点的s
  • [空天防御与经济]在获得充足的外部资源之前,太空投资需有限度 comsci 资源
          这里有一个常识性的问题:       地球的资源,人类的资金是有限的,而太空是无限的.....       就算全人类联合起来,要在太空中修建大型空间站,也不一定能够成功,因为资源和资金,技术有客观的限制.... &
  • ORACLE临时表—ON COMMIT PRESERVE ROWS daizj oracle临时表
    ORACLE临时表 转 临时表：像普通表一样，有结构，但是对数据的管理上不一样，临时表存储事务或会话的中间结果集，临时表中保存的数据只对当前 会话可见，所有会话都看不到其他会话的数据，即使其他会话提交了，也看不到。临时表不存在并发行为，因为他们对于当前会话都是独立的。 创建临时表时，ORACLE只创建了表的结构（在数据字典中定义），并没有初始化内存空间，当某一会话使用临时表时，ORALCE会
  • 基于Nginx XSendfile+SpringMVC进行文件下载 denger 应用服务器Webnginx网络应用lighttpd
        在平常我们实现文件下载通常是通过普通 read-write方式，如下代码所示。 @RequestMapping("/courseware/{id}") public void download(@PathVariable("id") String courseID, HttpServletResp
  • scanf接受char类型的字符 dcj3sjt126com c
    /* 2013年3月11日22:35:54 目的：学习char只接受一个字符 */ # include <stdio.h> int main(void) { int i; char ch; scanf("%d", &i); printf("i = %d\n", i); scanf("%
  • 学编程的价值 dcj3sjt126com 编程
    发一个人会编程, 想想以后可以教儿女, 是多么美好的事啊, 不管儿女将来从事什么样的职业, 教一教, 对他思维的开拓大有帮助   像这位朋友学习:   http://blog.sina.com.cn/s/articlelist_2584320772_0_1.html   VirtualGS教程 (By @林泰前): 几十年的老程序员，资深的
  • 二维数组（矩阵）对角线输出 飞天奔月 二维数组
    今天在BBS里面看到这样的面试题目,   1，二维数组（N*N），沿对角线方向，从右上角打印到左下角如N=4： 4*4二维数组  { 1 2 3 4 } { 5 6 7 8 } { 9 10 11 12 } {13 14 15 16 } 打印顺序  4 3 8 2 7 12 1 6 11 16 5 10 15 9 14 13 要
  • Ehcache（08）——可阻塞的Cache——BlockingCache 234390216 并发ehcacheBlockingCache阻塞
    可阻塞的Cache—BlockingCache          在上一节我们提到了显示使用Ehcache锁的问题，其实我们还可以隐式的来使用Ehcache的锁，那就是通过BlockingCache。BlockingCache是Ehcache的一个封装类，可以让我们对Ehcache进行并发操作。其内部的锁机制是使用的net.
  • mysqldiff对数据库间进行差异比较 jackyrong mysqld
      mysqldiff该工具是官方mysql-utilities工具集的一个脚本，可以用来对比不同数据库之间的表结构，或者同个数据库间的表结构    如果在windows下，直接下载mysql-utilities安装就可以了，然后运行后，会跑到命令行下： 1） 基本用法    mysqldiff --server1=admin:12345
  • spring data jpa 方法中可用的关键字 lawrence.li javaspring
    spring data jpa 支持以方法名进行查询/删除/统计。 查询的关键字为find 删除的关键字为delete/remove (>=1.7.x) 统计的关键字为count (>=1.7.x)   修改需要使用@Modifying注解 @Modifying @Query("update User u set u.firstna
  • Spring的ModelAndView类 nicegege spring
    项目中controller的方法跳转的到ModelAndView类，一直很好奇spring怎么实现的？ /* * Copyright 2002-2010 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * yo
  • 搭建 CentOS 6 服务器(13) - rsync、Amanda rensanning centos
    （一）rsync Server端 # yum install rsync # vi /etc/xinetd.d/rsync service rsync { disable = no flags = IPv6 socket_type = stream wait
  • Learn Nodejs 02 toknowme nodejs
    （1）npm是什么 npm is the package manager for node 官方网站：https://www.npmjs.com/ npm上有很多优秀的nodejs包，来解决常见的一些问题，比如用node-mysql，就可以方便通过nodejs链接到mysql，进行数据库的操作 在开发过程往往会需要用到其他的包，使用npm就可以下载这些包来供程序调用 &nb
  • Spring MVC 拦截器 xp9802 spring mvc
    Controller层的拦截器继承于HandlerInterceptorAdapter HandlerInterceptorAdapter.java  1  public   abstract   class  HandlerInterceptorAdapter  implements  HandlerIntercep
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他