MFC逆向之CrackMe Level3 过反调试 + 写注册机

news2024/11/16 17:55:52

今天我来分享一下,过反调试的方法以及使用IDA还原代码 + 写注册机的过程

由于内容太多,我准备分为两个帖子写,这个帖子主要是写IDA还原代码,下一个帖子是写反调试的分析以及过反调试和异常

这个CrackMe Level3是一个朋友发我的,我也不知道他在哪里弄的,我感觉挺好玩的,对反调试 异常 以及代码还原的学习有一些帮助

调试器:X64和OD

反编译工具:IDA

PE工具:Detect It Easy

反调试插件:OD的StrongOD和虫子的ScyllaHide

ARK工具:Pchunter

MFC工具:MfcSpy

初步分析

第一步先看看PE文件 工具说:软件是使用2008的MFC写的

上面得知是MFC写的软件,我们可以利用MFC的RTTI(动态类型识别)获取信息,如果不是MFC写的,我们可以运行一下软件看看,有没有报错信息

当然这个软件,输入注册码点击注册没有任何提示

 

打开调试器附加看看字符串,结果软件会闪退,无法附加,估计是有反调试,遇到这种情况我有三种方式可以解决

第一种:静态分析解决反调试

第二种:使用ARK工具把软件暂停,然后在用调试器附加

第三种:直接使用调试器打开程序,让软件断到入口或者系统断点

我们先使用第二种吧,因为X32调试器对中文字符串的支持不是很好,我没有装插件,所以先用OD看看字符串吧

验证函数中有一个异常 OD的反汇编已经出现了BUG,可以使用删除分析,我这里就不删除了 直接打开IDA F5吧 

 

虽然不能F5 但是我们可以很清晰的看到,两个GetWindowText 估计一个是获取用户名 一个是获取密码

至于为什么不能F5 是因为有一个jmp [ebx + 0xXXX] 这样的代码 IDA在解析代码的时候 它不知道跳到那里去 导致无法解析

我们直接把这个Jmp [ebp + var_8A8] 给nop掉就好了 然后删除这个函数的分析 接着在把这个函数分析为代码即可

我们可以向上看,在OD反汇编的时候也是到这个位置 反汇编失败了

下面是IDA F5后的代码 很明显 这IDA还原出来的根本不能用,这是需要我们进行修理变量的,另外我们给它重新命名一下

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

int __thiscall sub_401810(CWnd *this)

{

  CWnd *DlgItem; // eax

  CWnd *v2; // eax

  int result; // eax

  char *v4; // [esp+10h] [ebp-8C8h]

  CHAR *v5; // [esp+14h] [ebp-8C4h]

  unsigned int v6; // [esp+18h] [ebp-8C0h]

  unsigned __int8 v8; // [esp+21h] [ebp-8B7h]

  unsigned __int8 v9; // [esp+22h] [ebp-8B6h]

  unsigned __int8 v10; // [esp+23h] [ebp-8B5h]

  int k; // [esp+24h] [ebp-8B4h]

  int j; // [esp+28h] [ebp-8B0h]

  int i; // [esp+2Ch] [ebp-8ACh]

  int v14; // [esp+34h] [ebp-8A4h]

  int v15; // [esp+34h] [ebp-8A4h]

  char v16; // [esp+38h] [ebp-8A0h] BYREF

  int v17[6]; // [esp+39h] [ebp-89Fh] BYREF

  char v18; // [esp+51h] [ebp-887h]

  char v19; // [esp+53h] [ebp-885h]

  char v20; // [esp+54h] [ebp-884h]

  int v21; // [esp+55h] [ebp-883h]

  int v22[5]; // [esp+59h] [ebp-87Fh] BYREF

  char v23; // [esp+6Dh] [ebp-86Bh]

  int v24; // [esp+70h] [ebp-868h]

  char v25; // [esp+74h] [ebp-864h]

  int v26; // [esp+75h] [ebp-863h]

  int v27; // [esp+79h] [ebp-85Fh]

  int v28; // [esp+7Dh] [ebp-85Bh]

  int v29; // [esp+81h] [ebp-857h]

  int v30; // [esp+85h] [ebp-853h]

  int v31; // [esp+89h] [ebp-84Fh]

  char v32; // [esp+8Dh] [ebp-84Bh]

  char v33; // [esp+93h] [ebp-845h]

  char v34; // [esp+94h] [ebp-844h]

  int v35; // [esp+95h] [ebp-843h]

  int v36[5]; // [esp+99h] [ebp-83Fh] BYREF

  char v37; // [esp+ADh] [ebp-82Bh]

  CHAR String[1028]; // [esp+B0h] [ebp-828h] BYREF

  int v39; // [esp+4B4h] [ebp-424h]

  CHAR v40[1028]; // [esp+4B8h] [ebp-420h] BYREF

  CPPEH_RECORD ms_exc; // [esp+8C0h] [ebp-18h]

  MEMORY[0] = 6530;

  ms_exc.registration.TryLevel = -2;

  v33 = sub_402D60();

  v14 = sub_402C60(v33);

  sub_402750(v14);

  v26 = 0;

  v27 = 0;

  v28 = 0;

  v29 = 0;

  v30 = 0;

  v31 = 0;

  v32 = 0;

  v35 = 0;

  memset(v36, 0, sizeof(v36));

  v37 = 0;

  v21 = 0;

  memset(v22, 0, sizeof(v22));

  v23 = 0;

  v25 = 48;

  v34 = 66;

  v20 = 98;

  for ( i = 1; i < 26; ++i )

  {

    *(&v25 + i) = *((_BYTE *)&v24 + i + 3) + 1;

    *(&v34 + i) = *(&v33 + i) + 1;

    *(&v20 + i) = *(&v19 + i) + 1;

  }

  CWnd::UpdateData(this, 1);

  memset(String, 0, 1024);

  memset(v40, 0, 1024);

  ms_exc.registration.Next = (struct _EH3_EXCEPTION_REGISTRATION *)1024;

  ms_exc.exc_ptr = (EXCEPTION_POINTERS *)String;

  DlgItem = CWnd::GetDlgItem(this, 1000);

  CWnd::GetWindowTextA(DlgItem, (LPSTR)ms_exc.exc_ptr, (int)ms_exc.registration.Next);

  ms_exc.registration.Next = (struct _EH3_EXCEPTION_REGISTRATION *)1024;

  ms_exc.exc_ptr = (EXCEPTION_POINTERS *)v40;

  v2 = CWnd::GetDlgItem(this, 1001);

  result = CWnd::GetWindowTextA(v2, (LPSTR)ms_exc.exc_ptr, (int)ms_exc.registration.Next);

  if ( String[7] )

  {

    result = String[8];

    if ( !String[8] && v40[23] && !v40[24] )

    {

      v39 = 16;

      v24 = 32;

      for ( j = 0; j < 8; ++j )

      {

        String[j] ^= j;

        String[j] ^= *(_BYTE *)(j + v39);

        String[j] ^= *(_BYTE *)(j + v24);

      }

      v16 = 0;

      memset(v17, 0, sizeof(v17));

      v18 = 0;

      for ( k = 0; k < 8; ++k )

      {

        v10 = (unsigned __int8)(String[k] & 0xE0) / 32;

        v8 = (String[k] & 0x1C) / 4;

        v9 = String[k] & 3;

        if ( k % 3 == 2 )

        {

          *(&v16 + 3 * k) = *(&v25 + v9);

          *((_BYTE *)v17 + 3 * k) = *((_BYTE *)v36 + v10 + 3);

          *((_BYTE *)v17 + 3 * k + 1) = *((_BYTE *)&v22[2] + v8 + 3);

        }

        if ( k % 3 == 1 )

        {

          *(&v16 + 3 * k) = *((_BYTE *)&v36[2] + v10 + 3);

          *((_BYTE *)v17 + 3 * k) = *((_BYTE *)v22 + v8 + 3);

          *((_BYTE *)v17 + 3 * k + 1) = *(&v25 + v9);

        }

        if ( !(k % 3) )

        {

          *(&v16 + 3 * k) = *((_BYTE *)&v36[2] + v8 + 3);

          *((_BYTE *)v17 + 3 * k) = *((_BYTE *)v22 + v9 + 3);

          *((_BYTE *)v17 + 3 * k + 1) = *(&v25 + v10);

        }

      }

      sub_401790();

      v33 = sub_402D90();

      v15 = sub_402C60(v33);

      sub_4028A0(v15);

      v6 = 24;

      v5 = v40;

      v4 = &v16;

      while ( v6 >= 4 )

      {

        result = (int)v5;

        if ( *(_DWORD *)v4 != *(_DWORD *)v5 )

          return result;

        v6 -= 4;

        v5 += 4;

        v4 += 4;

      }

      return CWnd::MessageBoxA(this, &Text, 0, 0);

    }

  }

  return result;

}

1.根据循环可以知道对应数组大小和数组首地址

2.根据MemSet也可以知道对应数组的大小和数组首地址

3.根据GetWindowsText也可以知道数组的大小

修正变量要结合代码怎么去操作这个变量的 根据它的逻辑来猜测大小

这是变量重命名后的汇编代码

经过修理后的IDA F5代码 可以看到基本上很清晰了 效果跟源代码应该很接近

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

int __thiscall sub_401810(CWnd *this)

{

  CWnd *DlgItem; // eax

  CWnd *v2; // eax

  int result; // eax

  char *pFinalKey_1; // [esp+10h] [ebp-8C8h]

  char *pGetWindowTextString1_1; // [esp+14h] [ebp-8C4h]

  unsigned int Var24_1; // [esp+18h] [ebp-8C0h]

  unsigned __int8 Var8_1; // [esp+21h] [ebp-8B7h]

  unsigned __int8 Var9_1; // [esp+22h] [ebp-8B6h]

  unsigned __int8 Var10_1; // [esp+23h] [ebp-8B5h]

  int K; // [esp+24h] [ebp-8B4h]

  int J; // [esp+28h] [ebp-8B0h]

  int I; // [esp+2Ch] [ebp-8ACh]

  int Unknown2_1; // [esp+34h] [ebp-8A4h]

  int unknown1; // [esp+34h] [ebp-8A4h]

  char FinalKey_1[26]; // [esp+38h] [ebp-8A0h] BYREF

  char SecretKey3[28]; // [esp+54h] [ebp-884h] BYREF

  int v19; // [esp+70h] [ebp-868h]

  char SecretKey1[31]; // [esp+74h] [ebp-864h] BYREF

  char Unknown3_1; // [esp+93h] [ebp-845h]

  char SecretKey2[28]; // [esp+94h] [ebp-844h] BYREF

  char GetWindowTextString2_1[1028]; // [esp+B0h] [ebp-828h] BYREF

  int v24; // [esp+4B4h] [ebp-424h]

  char GetWindowTextString1[1028]; // [esp+4B8h] [ebp-420h] BYREF

  CPPEH_RECORD ms_exc; // [esp+8C0h] [ebp-18h]

  MEMORY[0] = 6530;

  ms_exc.registration.TryLevel = -2;

  Unknown3_1 = sub_402D60();

  Unknown2_1 = sub_402C60(&dword_42FA04, Unknown3_1);

  sub_402750(Unknown2_1);

  memset(&SecretKey1[1], 0, 25);

  memset(&SecretKey2[1], 0, 25);

  memset(&SecretKey3[1], 0, 25);

  SecretKey1[0] = 48;

  SecretKey2[0] = 66;

  SecretKey3[0] = 98;

  for ( I = 1; I < 26; ++I )

  {

    SecretKey1[I] = SecretKey1[I - 1] + 1;

    SecretKey2[I] = SecretKey2[I - 1] + 1;

    SecretKey3[I] = SecretKey3[I - 1] + 1;

  }

  CWnd::UpdateData(this, 1);

  memset(GetWindowTextString2_1, 0, 1024);

  memset(GetWindowTextString1, 0, 1024);

  ms_exc.registration.Next = (struct _EH3_EXCEPTION_REGISTRATION *)1024;

  ms_exc.exc_ptr = (EXCEPTION_POINTERS *)GetWindowTextString2_1;

  DlgItem = CWnd::GetDlgItem(this, 1000);

  CWnd::GetWindowTextA(DlgItem, (LPSTR)ms_exc.exc_ptr, (int)ms_exc.registration.Next);

  ms_exc.registration.Next = (struct _EH3_EXCEPTION_REGISTRATION *)1024;

  ms_exc.exc_ptr = (EXCEPTION_POINTERS *)GetWindowTextString1;

  v2 = CWnd::GetDlgItem(this, 1001);

  result = CWnd::GetWindowTextA(v2, (LPSTR)ms_exc.exc_ptr, (int)ms_exc.registration.Next);

  if ( GetWindowTextString2_1[7] )

  {

    result = GetWindowTextString2_1[8];

    if ( !GetWindowTextString2_1[8] && GetWindowTextString1[23] && !GetWindowTextString1[24] )

    {

      v24 = 16;

      v19 = 32;

      for ( J = 0; J < 8; ++J )

      {

        GetWindowTextString2_1[J] ^= J;

        GetWindowTextString2_1[J] ^= *(_BYTE *)(J + v24);

        GetWindowTextString2_1[J] ^= *(_BYTE *)(J + v19);

      }

      memset(FinalKey_1, 0, sizeof(FinalKey_1));

      for ( K = 0; K < 8; ++K )

      {

        Var10_1 = (unsigned __int8)(GetWindowTextString2_1[K] & 0xE0) / 32;

        Var8_1 = (GetWindowTextString2_1[K] & 0x1C) / 4;

        Var9_1 = GetWindowTextString2_1[K] & 3;

        if ( K % 3 == 2 )

        {

          FinalKey_1[3 * K] = SecretKey1[Var9_1];

          FinalKey_1[3 * K + 1] = SecretKey2[Var10_1 + 8];

          FinalKey_1[3 * K + 2] = SecretKey3[Var8_1 + 16];

        }

        if ( K % 3 == 1 )

        {

          FinalKey_1[3 * K] = SecretKey2[Var10_1 + 16];

          FinalKey_1[3 * K + 1] = SecretKey3[Var8_1 + 8];

          FinalKey_1[3 * K + 2] = SecretKey1[Var9_1];

        }

        if ( !(K % 3) )

        {

          FinalKey_1[3 * K] = SecretKey2[Var8_1 + 16];

          FinalKey_1[3 * K + 1] = SecretKey3[Var9_1 + 8];

          FinalKey_1[3 * K + 2] = SecretKey1[Var10_1];

        }

      }

      sub_401790();

      Unknown3_1 = sub_402D90();

      unknown1 = sub_402C60(&dword_42FA04, Unknown3_1);

      sub_4028A0(unknown1);

      Var24_1 = 24;

      pGetWindowTextString1_1 = GetWindowTextString1;

      pFinalKey_1 = FinalKey_1;

      while ( Var24_1 >= 4 )

      {

        result = (int)pGetWindowTextString1_1;

        if ( *(_DWORD *)pFinalKey_1 != *(_DWORD *)pGetWindowTextString1_1 )

          return result;

        Var24_1 -= 4;

        pGetWindowTextString1_1 += 4;

        pFinalKey_1 += 4;

      }

      return CWnd::MessageBoxA(this, &Text, 0, 0);

    }

  }

  return result;

}

我们可以看到上面的代码中还是有两个变量的值是错误的 一个是V24 一个是V19 为什么是错误的呢?

我们可以结合下面的循环代码,下面代码中用到V24 是*(BYTE*)(J+V24);    用到V19 是*(BYTE*)(J+V19);

这很明显是一个数组 大小是8个字节

看下面代码中 V19和V24是来源于AbnormalVariable这个变量的值 + 16和+32的位置的

这也就是下面代码中V19和V24数组的值的来源

最终的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

int main()

{

    char SecretKey1[28];

    char SecretKey2[28];

    char SecretKey3[28];

    memset(SecretKey1,0,sizeof(SecretKey1));

    memset(SecretKey2,0,sizeof(SecretKey2));

    memset(SecretKey3,0,sizeof(SecretKey3));

    SecretKey1[0] = 48;

    SecretKey2[0] = 66;

    SecretKey3[0] = 98;

    for (int I = 1; I < 26; ++I)

    {

        SecretKey1[I] = SecretKey1[I - 1] + 1;

        SecretKey2[I] = SecretKey2[I - 1] + 1;

        SecretKey3[I] = SecretKey3[I - 1] + 1;

    }

    char GetWindowTextString1[1024];

    char GetWindowTextString2_1[1024];

    memset(GetWindowTextString1,0,1024);

    memset(GetWindowTextString2_1, 0, 1024);

    strcpy(GetWindowTextString2_1,"12345678");

    char v24[24] = { 0x00,0x00,0x88,0x85,0xBB,0xF7,0xFF,0xFF,0x0F,0xB6,0x8D,0xBB,0xF7,0xFF,0xFF,0xB8,0x04,0xFA,0x42,0x00,0xE8,0xAD };

    char v19[24] = { 0xB8,0x04,0xFA,0x42,0x00,0xE8,0xAD,0x13,0x00,0x00,0x89,0x85,0x5C,0xF7,0xFF,0xFF,0x8B,0x95,0x5C,0xF7,0xFF,0xFF };

    for (int J = 0; J < 8; ++J)

    {

        GetWindowTextString2_1[J] ^= J;

        GetWindowTextString2_1[J] ^= v24[J];

        GetWindowTextString2_1[J] ^= v19[J];

    }

    char FinalKey_1[26];

    memset(FinalKey_1,0,sizeof(FinalKey_1));

    for (int K = 0; K < 8; ++K)

    {

        char Var10_1 = (unsigned __int8)(GetWindowTextString2_1[K] & 0xE0) / 32;

        char Var8_1 = (GetWindowTextString2_1[K] & 0x1C) / 4;

        char Var9_1 = GetWindowTextString2_1[K] & 3;

        if (K % 3 == 2)

        {

            FinalKey_1[3 * K] = SecretKey1[Var9_1];

            FinalKey_1[3 * K + 1] = SecretKey2[Var10_1 + 8];

            FinalKey_1[3 * K + 2] = SecretKey3[Var8_1 + 16];

        }

        if (K % 3 == 1)

        {

            FinalKey_1[3 * K] = SecretKey2[Var10_1 + 16];

            FinalKey_1[3 * K + 1] = SecretKey3[Var8_1 + 8];

            FinalKey_1[3 * K + 2] = SecretKey1[Var9_1];

        }

        if (!(K % 3))

        {

            FinalKey_1[3 * K] = SecretKey2[Var8_1 + 16];

            FinalKey_1[3 * K + 1] = SecretKey3[Var9_1 + 8];

            FinalKey_1[3 * K + 2] = SecretKey1[Var10_1];

        }

    }

    //FinalKey_1 = 0x00aff3f8 "Tk4So33LrVj7Vl20KuRm3Xn3"

    system("pause");

    return 0;

}

1

2

用户名:12345678

注册码:Tk4So33LrVj7Vl20KuRm3Xn3

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1315096.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Spark RDD、DataFrame、DataSet比较

Spark RDD、DataFrame、DataSet比较

在Spark的学习当中&#xff0c;RDD、DataFrame、DataSet可以说都是需要着重理解的专业名词概念。尤其是在涉及到数据结构的部分&#xff0c;理解清楚这三者的共性与区别&#xff0c;非常有必要。 RDD&#xff0c;作为Spark的核心数据抽象&#xff0c;是Spark当中不可或缺的存在…
阅读更多...
【华为数据之道学习笔记】5-4 数据入湖方式

【华为数据之道学习笔记】5-4 数据入湖方式

数据入湖遵循华为信息架构&#xff0c;以逻辑数据实体为粒度入湖&#xff0c;逻辑数据实体在首次入湖时应该考虑信息的完整性。原则上&#xff0c;一个逻辑数据实体的所有属性应该一次性进湖&#xff0c;避免一个逻辑实体多次入湖&#xff0c;增加入湖工作量。 数据入湖的方式…
阅读更多...
Codeforces Round 914 (Div. 2) A~E

Codeforces Round 914 (Div. 2) A~E

A.Forked!&#xff08;思维&#xff09; 题意&#xff1a; 给出骑士的跳跃能力 ( x , y ) (x, y) (x,y) 以及国王和皇后的位置&#xff0c;问有多少个位置可以让骑士可以直接攻击到国王和皇后。 分析&#xff1a; 棋盘非常大 ( 1 0 8 1 0 8 ) (10^{8} \times 10^{8}) (1…
阅读更多...
基于ssm物流管理系统论文

基于ssm物流管理系统论文

摘 要 本物流管理系统设计目标是实现物流的信息化管理&#xff0c;提高管理效率&#xff0c;使得物流管理作规范化、科学化、高效化。 本文重点阐述了物流管理系统的开发过程&#xff0c;以实际运用为开发背景&#xff0c;基于SSM框架&#xff0c;运用了Java编程语言和MYSQL数…
阅读更多...
C++：命名空间

C++：命名空间

从今天正式开始对C的学习&#xff0c;这里只学习C对C的拓展&#xff0c;和C相同的部分在C语言专栏中都可以找到&#xff0c;我们先看一段C代码 #include<iostream> using namespace std; int main() {cout<<"hello world<<endl;return 0; } 同样也是打…
阅读更多...
【Proteus仿真】【51单片机】电子门铃设计

【Proteus仿真】【51单片机】电子门铃设计

文章目录 一、功能简介二、软件设计三、实验现象联系作者 一、功能简介 本项目使用Proteus8仿真51单片机控制器&#xff0c;使共阴数码管&#xff0c;按键、无源蜂鸣器等。 主要功能&#xff1a; 系统运行后&#xff0c;数码管默认显示第一种门铃音调&#xff0c;可通过K1键切…
阅读更多...
力扣第一题-两数之和[简单]

力扣第一题-两数之和[简单]

题目描述 给定一个整数数组 nums 和一个整数目标值 target&#xff0c;请你在该数组中找出 和为目标值 target 的那 两个 整数&#xff0c;并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是&#xff0c;数组中同一个元素在答案里不能重复出现。 你可以按任…
阅读更多...
陈年葡萄酒里面有什么奥秘？

陈年葡萄酒里面有什么奥秘？

自古希腊和古罗马以来&#xff0c;陈年葡萄酒就令美食家着迷。很自然&#xff0c;许多人会认为酒越陈越香。只有一个问题:这不是真的。世界上绝大多数的葡萄酒一旦你购买了它们就会在一两年之内被品尝掉。葡萄酒是一种活的食物&#xff0c;当你打开软木塞或拧开金属螺旋盖时&am…
阅读更多...
2023年底总结丨5大好用的局域网监控软件

2023年底总结丨5大好用的局域网监控软件

不知不觉间2023年又到结尾了&#xff0c;今年我们服务过很多想要电脑监控软件的客服&#xff0c;也服务了很多想要加密软件的客户。 这一年&#xff0c;我们走得不疾不徐&#xff0c;走得稳而坚定&#xff1b;这一年&#xff0c;我们累积服务超过万计客户&#xff1b;这一年&a…
阅读更多...
什么是质量工程?

什么是质量工程?

质量工程是在精益、敏捷、DevOps等实践基础上进一步发展出的系统化赋能软件开发流程、构建既快又好的开发框架的实践。原文: What is Quality Engineering 我们基于古法语"definer"的定义&#xff0c;通过澄清边界、要素和相互作用的方式来构建某个概念&#xff0c;本…
阅读更多...
二维差分详解

二维差分详解

前言 上一期我们分享了一维差分的使用方法&#xff0c;这一期我们将接着上期的内容带大家了解二位差分的使用方法&#xff0c;话不多说&#xff0c;LET’S GO!&#xff08;上一期链接&#xff09; 二维差分 二维差分我们可以用于对矩阵区间进行多次操作的题。 二维差分我们还…
阅读更多...
关于“Python”的核心知识点整理大全23

关于“Python”的核心知识点整理大全23

目录 ​编辑 第&#xff11;0 章 文件和异常 10.1 从文件中读取数据 10.1.1 读取整个文件 pi_digits.txt file_reader.py 10.1.2 文件路径 10.1.3 逐行读取 file_reader.py 10.1.4 创建一个包含文件各行内容的列表 10.1.5 使用文件的内容 pi_string.py 往期快速传…
阅读更多...
【从零开始学习--设计模式--装饰者模式】

【从零开始学习--设计模式--装饰者模式】

返回首页 前言 感谢各位同学的关注与支持&#xff0c;我会一直更新此专题&#xff0c;竭尽所能整理出更为详细的内容分享给大家&#xff0c;但碍于时间及精力有限&#xff0c;代码分享较少&#xff0c;后续会把所有代码示例整理到github&#xff0c;敬请期待。 此章节介绍装…
阅读更多...
关于“Python”的核心知识点整理大全14

关于“Python”的核心知识点整理大全14

目录 ​编辑 7.2.2 让用户选择何时退出 parrot.py 7.2.3 使用标志 7.2.4 使用 break 退出循环 cities.py 7.2.5 在循环中使用 continue counting.py 7.2.6 避免无限循环 counting.py 7.3 使用 while 循环来处理列表和字典 7.3.1 在列表之间移动元素 confirmed_user…
阅读更多...
虚拟网络管理解决方案

虚拟网络管理解决方案

随着业务规模的扩大&#xff0c;其网络的规模和复杂性也成比例地扩大&#xff0c;企业级组织和中小型企业需要大规模网络来满足不断增长的业务需求&#xff0c;然而&#xff0c;大规模网络需要大量的物理组件、定期维护和配置&#xff0c;所有这些都是有代价的&#xff0c;因此…
阅读更多...
无mac在线申请hbuilderx打包ios证书的方法

无mac在线申请hbuilderx打包ios证书的方法

hbuilderx是一个跨平台的开发工具&#xff0c;可以开发android和ios的app应用。打包hbuilderx应用需要hbuilderx打包证书。但是很多使用hbuilderx开发的程序员&#xff0c;并没有mac电脑&#xff0c;而申请ios的证书&#xff0c;hbuilderx官网的教程却是需要mac电脑的&#xff…
阅读更多...
竞赛保研 opencv 图像识别 指纹识别 - python

竞赛保研 opencv 图像识别 指纹识别 - python

0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 基于机器视觉的指纹识别系统 &#x1f947;学长这里给一个题目综合评分(每项满分5分) 难度系数&#xff1a;3分工作量&#xff1a;3分创新点&#xff1a;4分 该项目较为新颖&#xff0c;适…
阅读更多...
C++面向对象编程（OOP）-浅拷贝与深拷贝

C++面向对象编程（OOP）-浅拷贝与深拷贝

本文主要使用详细的代码比较说明深拷贝和浅拷贝的区别&#xff0c;延伸讲到构造函数。并提供深拷贝和浅拷贝的对比代码。 目录 1 深拷贝和浅拷贝引入原因 2 深拷贝个浅拷贝基本介绍 3 浅拷贝的弊端 4 拷贝构造函数 5 类中有指针的浅拷贝 6 类中有指针的深拷贝 1 深拷贝和浅…
阅读更多...
Zabbix监控系统部署与管理

Zabbix监控系统部署与管理

zabbix介绍 zabbix是⼀个基于 Web 界面的提供分布式系统监视以及网络监视功能的企业级的免费开源解决⽅案。zabbix能监视各种⽹络参数&#xff0c;保证服务器系统的安全运营&#xff1b;并提供灵活的通知机制以让系统管理员快速定位/解决存在的各种问题。 zabbix构成 zabbix由…
阅读更多...
从纸笔到屏幕：我的CS笔记记录体验分享

从纸笔到屏幕：我的CS笔记记录体验分享

前言 三年大学生活里&#xff0c;我花了很多时间在记录笔记上&#xff0c;也因为现有种类繁多的各种学习方式&#xff0c;和朋友一起走了很多弯路。纸笔&#xff0c;OneNote&#xff0c;Typora…… 想总结分享一下自己大学期间的学习笔记记录方式&#xff08;主要针对计算机学…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023