c语言sint16,2015年AliCrackMe第二题的分析之人肉过反调试

最新推荐文章于 2023-03-28 17:15:37 发布
最新推荐文章于 2023-03-28 17:15:37 发布
阅读量629 收藏
点赞数
文章标签： c语言sint16

#include 

#include 

#include 

#if defined(__GNUC__)

typedef          long long ll;

typedef unsigned long long ull;

#define __int64 long long

#define __int32 int

#define __int16 short

#define __int8  char

#define MAKELL(num) num ## LL

#define FMT_64 "ll"

#elif defined(_MSC_VER)

typedef          __int64 ll;

typedef unsigned __int64 ull;

#define MAKELL(num) num ## i64

#define FMT_64 "I64"

#elif defined (__BORLANDC__)

typedef          __int64 ll;

typedef unsigned __int64 ull;

#define MAKELL(num) num ## i64

#define FMT_64 "L"

#else

#error "unknown compiler"

#endif

typedef unsigned int uint;

typedef unsigned char uchar;

typedef unsigned short ushort;

typedef unsigned long ulong;

typedef          char   int8;

typedef   signed char   sint8;

typedef unsigned char   uint8;

typedef          short  int16;

typedef   signed short  sint16;

typedef unsigned short  uint16;

typedef          int    int32;

typedef   signed int    sint32;

typedef unsigned int    uint32;

typedef ll              int64;

typedef ll              sint64;

typedef ull             uint64;

// Partially defined types:

#define _BYTE  uint8

#define _WORD  uint16

#define _DWORD uint32

#define _QWORD uint64

#if !defined(_MSC_VER)

#define _LONGLONG __int128

#endif

#ifndef _WINDOWS_

typedef int8 BYTE;

typedef int16 WORD;

typedef int32 DWORD;

typedef int32 LONG;

#endif

typedef int64 QWORD;

#ifndef __cplusplus

typedef int bool;       // we want to use bool in our C programs

#endif

// Some convenience macros to make partial accesses nicer

// first unsigned macros:

#define LOBYTE(x)   (*((_BYTE*)&(x)))   // low byte

#define LOWORD(x)   (*((_WORD*)&(x)))   // low word

#define LODWORD(x)  (*((_DWORD*)&(x)))  // low dword

#define HIBYTE(x)   (*((_BYTE*)&(x)+1))

#define HIWORD(x)   (*((_WORD*)&(x)+1))

#define HIDWORD(x)  (*((_DWORD*)&(x)+1))

#define BYTEn(x, n)   (*((_BYTE*)&(x)+n))

#define WORDn(x, n)   (*((_WORD*)&(x)+n))

#define BYTE1(x)   BYTEn(x,  1)         // byte 1 (counting from 0)

#define BYTE2(x)   BYTEn(x,  2)

#define BYTE3(x)   BYTEn(x,  3)

#define BYTE4(x)   BYTEn(x,  4)

#define BYTE5(x)   BYTEn(x,  5)

#define BYTE6(x)   BYTEn(x,  6)

#define BYTE7(x)   BYTEn(x,  7)

#define BYTE8(x)   BYTEn(x,  8)

#define BYTE9(x)   BYTEn(x,  9)

#define BYTE10(x)  BYTEn(x, 10)

#define BYTE11(x)  BYTEn(x, 11)

#define BYTE12(x)  BYTEn(x, 12)

#define BYTE13(x)  BYTEn(x, 13)

#define BYTE14(x)  BYTEn(x, 14)

#define BYTE15(x)  BYTEn(x, 15)

#define WORD1(x)   WORDn(x,  1)

#define WORD2(x)   WORDn(x,  2)         // third word of the object, unsigned

#define WORD3(x)   WORDn(x,  3)

#define WORD4(x)   WORDn(x,  4)

#define WORD5(x)   WORDn(x,  5)

#define WORD6(x)   WORDn(x,  6)

#define WORD7(x)   WORDn(x,  7)

// now signed macros (the same but with sign extension)

#define SLOBYTE(x)   (*((int8*)&(x)))

#define SLOWORD(x)   (*((int16*)&(x)))

#define SLODWORD(x)  (*((int32*)&(x)))

#define SHIBYTE(x)   (*((int8*)&(x)+1))

#define SHIWORD(x)   (*((int16*)&(x)+1))

#define SHIDWORD(x)  (*((int32*)&(x)+1))

#define SBYTEn(x, n)   (*((int8*)&(x)+n))

#define SWORDn(x, n)   (*((int16*)&(x)+n))

#define SBYTE1(x)   SBYTEn(x,  1)

#define SBYTE2(x)   SBYTEn(x,  2)

#define SBYTE3(x)   SBYTEn(x,  3)

#define SBYTE4(x)   SBYTEn(x,  4)

#define SBYTE5(x)   SBYTEn(x,  5)

#define SBYTE6(x)   SBYTEn(x,  6)

#define SBYTE7(x)   SBYTEn(x,  7)

#define SBYTE8(x)   SBYTEn(x,  8)

#define SBYTE9(x)   SBYTEn(x,  9)

#define SBYTE10(x)  SBYTEn(x, 10)

#define SBYTE11(x)  SBYTEn(x, 11)

#define SBYTE12(x)  SBYTEn(x, 12)

#define SBYTE13(x)  SBYTEn(x, 13)

#define SBYTE14(x)  SBYTEn(x, 14)

#define SBYTE15(x)  SBYTEn(x, 15)

#define SWORD1(x)   SWORDn(x,  1)

#define SWORD2(x)   SWORDn(x,  2)

#define SWORD3(x)   SWORDn(x,  3)

#define SWORD4(x)   SWORDn(x,  4)

#define SWORD5(x)   SWORDn(x,  5)

#define SWORD6(x)   SWORDn(x,  6)

#define SWORD7(x)   SWORDn(x,  7)

// Helper functions to represent some assembly instructions.

#ifdef __cplusplus

// Fill memory block with an integer value

inline void memset32(void *ptr, uint32 value, int count)

{

uint32 *p = (uint32 *)ptr;

for ( int i=0; i 

*p++ = value;

}

// Generate a reference to pair of operands

template  int16 __PAIR__( int8  high, T low) { return ((( int16)high) <

template  int32 __PAIR__( int16 high, T low) { return ((( int32)high) <

template  int64 __PAIR__( int32 high, T low) { return ((( int64)high) <

template uint16 __PAIR__(uint8  high, T low) { return (((uint16)high) <

template uint32 __PAIR__(uint16 high, T low) { return (((uint32)high) <

template uint64 __PAIR__(uint32 high, T low) { return (((uint64)high) <

// rotate left

template T __ROL__(T value, uint count)

{

const uint nbits = sizeof(T) * 8;

count %= nbits;

T high = value >> (nbits - count);

value <<= count;

value |= high;

return value;

}

// rotate right

template T __ROR__(T value, uint count)

{

const uint nbits = sizeof(T) * 8;

count %= nbits;

T low = value <

value >>= count;

value |= low;

return value;

}

// carry flag of left shift

template int8 __MKCSHL__(T value, uint count)

{

const uint nbits = sizeof(T) * 8;

count %= nbits;

return (value >> (nbits-count)) & 1;

}

// carry flag of right shift

template int8 __MKCSHR__(T value, uint count)

{

return (value >> (count-1)) & 1;

}

// sign flag

template int8 __SETS__(T x)

{

if ( sizeof(T) == 1 )

return int8(x) 

if ( sizeof(T) == 2 )

return int16(x) 

if ( sizeof(T) == 4 )

return int32(x) 

return int64(x) 

}

// overflow flag of subtraction (x-y)

template int8 __OFSUB__(T x, U y)

{

if ( sizeof(T) 

{

U x2 = x;

int8 sx = __SETS__(x2);

return (sx ^ __SETS__(y)) & (sx ^ __SETS__(x2-y));

}

else

{

T y2 = y;

int8 sx = __SETS__(x);

return (sx ^ __SETS__(y2)) & (sx ^ __SETS__(x-y2));

}

}

// overflow flag of addition (x+y)

template int8 __OFADD__(T x, U y)

{

if ( sizeof(T) 

{

U x2 = x;

int8 sx = __SETS__(x2);

return ((1 ^ sx) ^ __SETS__(y)) & (sx ^ __SETS__(x2+y));

}

else

{

T y2 = y;

int8 sx = __SETS__(x);

return ((1 ^ sx) ^ __SETS__(y2)) & (sx ^ __SETS__(x+y2));

}

}

// carry flag of subtraction (x-y)

template int8 __CFSUB__(T x, U y)

{

int size = sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U);

if ( size == 1 )

return uint8(x) 

if ( size == 2 )

return uint16(x) 

if ( size == 4 )

return uint32(x) 

return uint64(x) 

}

// carry flag of addition (x+y)

template int8 __CFADD__(T x, U y)

{

int size = sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U);

if ( size == 1 )

return uint8(x) > uint8(x+y);

if ( size == 2 )

return uint16(x) > uint16(x+y);

if ( size == 4 )

return uint32(x) > uint32(x+y);

return uint64(x) > uint64(x+y);

}

#else

// The following definition is not quite correct because it always returns

// uint64. The above C++ functions are good, though.

#define __PAIR__(high, low) (((uint64)(high)<

// For C, we just provide macros, they are not quite correct.

#define __ROL__(x, y) __rotl__(x, y)      // Rotate left

#define __ROR__(x, y) __rotr__(x, y)      // Rotate right

#define __CFSHL__(x, y) invalid_operation // Generate carry flag for (x<

#define __CFSHR__(x, y) invalid_operation // Generate carry flag for (x>>y)

#define __CFADD__(x, y) invalid_operation // Generate carry flag for (x+y)

#define __CFSUB__(x, y) invalid_operation // Generate carry flag for (x-y)

#define __OFADD__(x, y) invalid_operation // Generate overflow flag for (x+y)

#define __OFSUB__(x, y) invalid_operation // Generate overflow flag for (x-y)

#endif

// No definition for rcl/rcr because the carry flag is unknown

#define __RCL__(x, y)    invalid_operation // Rotate left thru carry

#define __RCR__(x, y)    invalid_operation // Rotate right thru carry

#define __MKCRCL__(x, y) invalid_operation // Generate carry flag for a RCL

#define __MKCRCR__(x, y) invalid_operation // Generate carry flag for a RCR

#define __SETP__(x, y)   invalid_operation // Generate parity flag for (x-y)

// In the decompilation listing there are some objects declarared as _UNKNOWN

// because we could not determine their types. Since the C compiler does not

// accept void item declarations, we replace them by anything of our choice,

// for example a char:

#define _UNKNOWN char

#ifdef _MSC_VER

#define snprintf _snprintf

#define vsnprintf _vsnprintf

#endif

int __fastcall sub_239C(_BYTE *a1, int a2, char *a3, int a4, unsigned int a5)

{

_BYTE *v5; // r11

char *v6; // r10

int v7; // r5

int v8; // r0

unsigned int v9; // r7

char v10; // r6

int v11; // r8

int result; // r0

int v13; // r1

char v14; // r1

int v15; // r1

int v16; // r0

char v17; // r2

char v18; // t1

char v19[256]; // [sp+8h] [bp-128h]

__int16 v20; // [sp+108h] [bp-28h]

v5 = a1;

v6 = a3;

v7 = a2;

v8 = 0;

do

{

v19[v8] = v8;

++v8;

}

while ( v8 != 256 );

v9 = 0;

v10 = 0;

v20 = 0;

do

{

v11 = (unsigned __int8)v19[v9];

result = *(unsigned __int8 *)(a4 + v9 % a5) + v11;

v13 = (unsigned __int8)(result + v10);

v19[v9] = v19[v13];

v19[v13] = v11;

++v9;

v10 += result;

}

while ( v9 != 256 );

if ( v7 )

{

LOBYTE(result) = HIBYTE(v20);

v14 = v20;

do

{

LOBYTE(v15) = v14 + 1;

--v7;

LOBYTE(v20) = v15;

v15 = (unsigned __int8)v15;

LOBYTE(v16) = result + v19[(unsigned __int8)v15];

HIBYTE(v20) = v16;

v16 = (unsigned __int8)v16;

v17 = v19[(unsigned __int8)v15];

v19[v15] = v19[(unsigned __int8)v16];

v19[v16] = v17;

v14 = v20;

result = HIBYTE(v20);

v18 = *v6++;

*v5++ = v19[(unsigned __int8)(v19[HIBYTE(v20)] + v19[(unsigned __int8)v20])] ^ v18;

}

while ( v7 );

}

return result;

}

int sub_258C(char* result, int a2, char* a3, char* a4, unsigned int a5, int a6)

{

char* v6; // r7

unsigned int v7; // r4

v6 = result;

if ( a2 )

{

v7 = 0;

do

{

result = (*((unsigned char*)a4 + v7 % a5)) ^ (*((unsigned char*)a3 + v7) - a6);

*(char *)(v6 + v7++) = result;

}

while ( a2 != v7 );

}

return result;

}

char* sub_254C(char *result, int a2, unsigned char *a3, char* a4, int a5, char a6)

{

unsigned int v6; // r3

unsigned int v7; // t1

if ( a2 )

{

v6 = a3[a2 - 1];

do

{

v7 = *a3++;

--a2;

*result++ = ((char)v7 <> (8 - a6));

v6 = v7;

}

while ( a2 );

}

return result;

}

int sub_239C(char *a1, int a2, char *a3, char* a4, unsigned int a5)

{

char *v5; // r11

char *v6; // r10

int v7; // r5

int v8; // r0

unsigned int v9; // r7

int v10; // r6

int v11; // r8

int result; // r0

int v13; // r1

char v14; // r1

int v15; // r1

int v16; // r0

char v17; // r2

char v18; // t1

char v19[256]; // [sp+8h] [bp-128h]

short v20; // [sp+108h] [bp-28h]

v5 = a1;

v6 = a3;

v7 = a2;

v8 = 0;

do

{

v19[v8] = v8;

++v8;

}

while ( v8 != 256 );

v9 = 0;

v10 = 0;

v20 = 0;

do

{

v11 = (unsigned char)v19[v9];

result = *(unsigned char *)(a4 + v9 % a5) + v11;

v13 = (unsigned char)(result + v10);

v19[v9] = v19[v13];

v19[v13] = v11;

++v9;

v10 += result;

}

while ( v9 != 256 );

if ( v7 )

{

LOBYTE(result) = HIBYTE(v20);

v14 = v20;

do

{

LOBYTE(v15) = v14 + 1;

--v7;

LOBYTE(v20) = v15;

v15 = (unsigned char)v15;

LOBYTE(v16) = result + v19[(unsigned char)v15];

HIBYTE(v20) = v16;

v16 = (unsigned char)v16;

v17 = v19[(unsigned char)v15];

v19[v15] = v19[(unsigned char)v16];

v19[v16] = v17;

v14 = v20;

result = HIBYTE(v20);

v18 = *v6++;

*v5++ = v19[(unsigned char)(v19[HIBYTE(v20)] + v19[(unsigned char)v20])] ^ v18;

}

while ( v7 );

}

return result;

}

int sub_24F4(char* result, int a2, unsigned char* a3, unsigned char* a4, unsigned int a5, int a6)

{

char* v6; // r7

unsigned int v7; // r4

v6 = result;

if ( a2 )

{

v7 = 0;

do

{

result = (*(unsigned char*)(a3 + v7) ^ a6) - *(unsigned char *)(a4 + v7 % a5);

*(char* *)(v6 + v7++) = result;

}

while ( a2 != v7 );

}

return result;

}

int main()

{

unsigned char unk_44FC[1] = {0x00};

char unk_62D7[128] = {0};

unsigned char unk_4509[7] = {0x58,0x71,0x10,0x7E,0x63,0x8D,0x00};

sub_24F4(unk_62D7, 6, unk_4509, "9HbB", 4u, 197);

printf("v0:%s\n",(char*)unk_62D7);

char unk_62EF[128];

unsigned char unk_448B[8] = {0x01,0x49,0x34,0x72,0x03,0x4E,0xB8,0x00};

unsigned char unk_4488[3] = {0x6D,0x37,0x00};

sub_24F4(unk_62EF, 7, unk_448B, unk_4488, 2u, 213);

printf("dword_6294:%s\n",(char*)unk_62EF);

char unk_630C[128] = {0};

unsigned char unk_44F3[9] = {0xE6,0xCF,0xCF,0x89,0xBB,0x16,0x65,0x71,0x00};

sub_239C(unk_630C, 8, unk_44F3, "LNAt", 4u);

printf("dword_6298:%s\n",(char*)unk_630C);

char unk_62DD[128] ={0};

unsigned char unk_44AC[7] = {0x30,0xB4,0x7D,0x77,0x9C,0xA5,0x00};

sub_239C(unk_62DD, 6, unk_44AC, "cOXt", 4u);

printf("dword_629C:%s\n",(char*)unk_62DD);

char unk_62E3[128];

unsigned char unk_4481[7] = {0xA9,0xB5,0xB8,0xB7,0xC1,0x55,0x00};

sub_24F4(unk_62E3, 6, unk_4481, "BMT", 3u, 1);

printf("dword_62A0 :%s\n",(char*)unk_62E3);

char unk_62F6[128] ={0};

unsigned char unk_44C4[8] = {0x45,0xEB,0x5A,0x11,0x75,0x7E,0x4E,0x00};

unsigned char unk_44C1[3] = {0x47,0x21,0x00};

sub_239C(unk_62F6, 7, unk_44C4, unk_44C1,2u);

printf("dword_62A4:%s\n",(char*)unk_62F6);

char unk_62FD[128];

unsigned char unk_44CC[8] = {0xB9,0xB9,0xB1,0x30,0x37,0x33,0x80,0x00};

sub_254C(unk_62FD, 7, unk_44CC, unk_44FC, 0, 1);

printf("dword_62A8:%s\n",(char*)unk_62FD);

char unk_62CC[128];

unsigned char unk_44A1[6] = {0xB5,0x34,0x36,0x36,0x80,0x00};

sub_254C(unk_62CC, 5, unk_44A1, unk_44FC, 0, 1);

printf("dword_62AC:%s\n",(char*)unk_62CC);

unsigned char unk_44FD[7] = {0x39,0xB6,0xB2,0x32,0x38,0x80,0x00};

char unk_62E9[128];

sub_254C(unk_62E9, 6, unk_44FD, unk_44FC, 0, 1);

printf("dword_62B0:%s\n",(char*)unk_62E9);

char unk_633A[128];

sub_258C(unk_633A, 15, "3:*8(-&\x1B\"@%%7)B", "BMAE", 4u, 1);

printf("dword_62B4:%s\n",(char*)unk_633A);

char unk_631C[128];

unsigned char unk_44E4[10] = {0x23,0x18,0xCA,0x21,0x14,0xDF,0x1D,0x14,0x3C,0x00};

unsigned char unk_44E0[4] = {0x37,0x3F,0x73,0x00};

sub_258C(unk_631C, 9, unk_44E4, unk_44E0, 3u, 201);

printf("dword_62B8:%s\n",(char*)unk_631C);

char unk_632F[128];

unsigned char unk_44D4[12] = {0xB1,0xB0,0x31,0xB4,0x32,0x33,0xB6,0xBA,0x39,0x34,0x80,0x00};

sub_254C(unk_632F, 11, unk_44D4, unk_44FC, 0, 1);

printf("dword_62BC:%s\n",(char*)unk_632F);

char unk_6314[128];

unsigned char unk_44B8[9] = {0xFD,0xFF,0xC1,0xDA,0x05,0xBD,0x1A,0x2C,0x00};

sub_258C(unk_6314, 8, unk_44B8, ".6gq", 4u, 187);

printf("dword_62C0:%s\n",(char*)unk_6314);

return 0;

}

cx不二
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言基础知识 - 笔记（一）
wangyu2010302660001的专栏
08-18 1476
C语言基础知识 - 笔记（一） 数据类型 char—8位—127—255 int—16位—32767—65535 short—16位—32767—65535 long—32位—2147483647—4294967295 在表达式中，P是指针，*P是指向它的内容 函数指针 V.S. 指针函数 函数指针 int （*fun） （）：本质上是一个指针，指向一个函数的地址，用于函数调用 指针函数
c语言sint16,算法篇（PID详解).pdf
weixin_39747568的博客
05-21 2452
前言说明控制的方法远远不止PID这一招，在许多场合也未必是最佳的控制算法 对于学习能力较好的师弟也可以再去寻求一种更优秀的控制算法 PID的分类多如牛毛，例如：模糊PID、数字PID、神经元PID等等 另外，本文档是参考几十个PID相关文档资料整合而成 由于个人能力等原因，从策划、编辑、排版等花了一个多月的时间才完成此次PID算法的整合为了更有针对性和有效性，本文档主要讲解数字PID及其变种 (改...
八大基本数据类型
sinat_36542083的博客
12-18 6480
整型数据: 存整数                 byte(字节)    表示是一个字节                  short(短整型) 表示是两个字节                      int  (整型)   表示四个字节                        long (长整型) 表示八个字节          定义变量的规则：在能够满足要求的情况下
C语言数据类型的范围
weixin_43084908的博客
11-19 3478
/** @brief The standard AUTOSAR type boolean shall be implemented on basis of an eight bits long unsigned integer. @implements boolean_type */ typedef unsigned char boolean; /** @brief Unsigned 8 bit integer with range of 0 …+255 (0x00…0xFF) -
十进制数值字符串转各种位宽的整形数据demo
axushilong的专栏
08-06 396
本demo实现了字符串转各种位宽的函数，代码简单效率高，非常适合单片机嵌入式应用。需要注意的是字符串需要按照严格的输入要求输入才行，比如“-127”，“255”等，除了第一个字符可以是负号‘-’外，其他字符必须是数字，对应位宽的数字字符，必须选择对应的函数。demo如下。 #include <stdio.h> #include <string.h> /* exact-width signed integer types */ typedef signed .
16进制与10进制相互转换，整型，双整型，浮点数等
12-10
主要用于程序读写PLC，单片机等数据时读取的16进制数据转换成10进制的数，解决初学者的疑惑，数据在单片机或PLC中存储时是以bit、字节为单元存储的，不管是整型数还是浮点数，最终都是以二进制位进行存储的，...
确知信号分析.zip
06-20
（1）绘制Sa(t)=sint/t的波形；（2）绘制sinc(t)=sinπt/πt的波形；（3）如图所示周期矩形脉冲，试绘制其幅度谱；如果信号是冲激信号，周期不变，试绘制其幅度谱；如果信号是余弦信号，周期不变，幅度不变，初始...
Sint Nicolaas-开源
04-26
收集有关圣尼古拉（Sint Nicolaas）的动作/益智游戏，他每年12月向烟囱运送礼物和饼干。
论文研究 - 硅/碳纳米管的电子结构和光学性质的第一性原理研究
06-01
建立由碳纳米管（CNT）和硅纳米管（SiNT）形成的纳米管的超级电池。 通过基于密度泛函理论（DFT）和广义梯度近似（GGA）的第一原理方法来实现电子结构和光学特性。 计算结果表明（6，6）-（6，6）硅/碳纳米管（Si / ...
cls_sint.rar_return
09-21
Check return value sint32.
C中的数据类型
weixin_43791071的博客
01-07 1328
前言 根据开发需要，用 char 时，数组每个元素的字长与存储单元是1个byte（16进制2位，2进制8位）。而用int时，数组每个元素的字长与存储单元是4个byte（16进制8位，2进制32位）。现存放16进制2位数，例如 0xFF, 0x0A 之类，用 char 型足够了。若改用 int 型当然也可以，只是浪费了存储空间，因数位多，运算，读写也要多费时间。
IDA常见的宏定义（逆向）
爱党人士
10-08 1864
/* This file contains definitions used by the Hex-Rays decompiler output. It has type definitions and convenience macros to make the output more readable. Copyright © 2007-2011 Hex-Rays */ #if defined...
IDA 使用记录
liuzejie1的博客
03-28 684
U x2 = x;
IDAF5后的宏
谢绝留言与私信
10-16 1846
前言IDAF5结果中，有一些宏是IDA中定义的。宏名含义很清楚，具体怎么干活不清楚。 查了资料，在<IDA dir>\plugins\defs.h中有这些宏的定义. e.g. BYTE3() 记录IDA6.1中的defs.h/* This file contains definitions used by the Hex-Rays decompiler output. It has typ
GACTF2020 WannaUp
lhk124的博客
09-08 317
要点：任何求余的操作都指明了一个点：限制了一个范围，从而限制了用到它的地方的范围 这道题的计算由 某一处的异或爆破+循环移位操作+异或运算 组成。 定位关键代码的几种方法 1.ida查找字符串，发现flag.bin和flag.txt。再使用x查找到了函数sub_402280 2.ida查看import表 发现如CryptDecryptGetWindowTextA 这类API，同样能定位到函数sub_402280 3.运行程序，一个gui界面，动态调试软件下断获取信息的api(r如GetDl..
C语言学习笔记03--预处理相关
zhouyuming_hbxt的博客
02-16 307
宏定义是简单的字符串替换， 是在预处理时完成的；而typedef是在编译时处理的，它不是做简单的替换，而是对类型说明符进行重新的命名，被命名的标识符具有类型定义说明的功能。 #define M_GetByteLL( x ) (INT8U)( (x) & 0xFF ) #define M_GetByteLH( x ) ...
c语言风格注意事项(misra c)
weixin_30918633的博客
04-20 417
最近接触了代码静态检查工具QAC以及PolySpace，在使用过程中积累了一些经验，在此记录。 一、类型问题 可以说是最多的一类问题。 1、常量需要注明类型 uint32 i = 0; /*i是无符号数，与它比较的0要明确申明为无符号数0u*/ if( i > 0u){ func1(); } 　　 　　2、enum（包括其他...
C语言uint8转换为sint8
最新发布
08-26
将一个无符号的8位整数(uint8)转换为有符号的8位整数(sint8)可以使用类型转换操作符。在C语言中，可以使用以下方式进行转换： ```c uint8_t unsignedValue = 200; sint8_t signedValue = (sint8_t)unsignedValue; `...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值