攻防世界逆向刷题wp Newbie_calculations

最新推荐文章于 2020-11-07 20:43:00 发布
最新推荐文章于 2020-11-07 20:43:00 发布
阅读量368 收藏
点赞数 1
分类专栏： 逆向刷题 攻防世界 文章标签： 信息安全 c++ 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sanqiz/article/details/108952537
版权

Newbie_calculations

做逆向c语言要扎实呀，这里有用到指针的知识点。

用exeinfope分析发现没壳

用ida打开先看main函数

int __cdecl main(int argc, const char **argv, const char **envp)
{
  _DWORD *v3; // eax
  _DWORD *v4; // eax
  _DWORD *v5; // eax
  _DWORD *v6; // eax
  int v7; // eax
  _DWORD *v8; // eax
  _DWORD *v9; // eax
  _DWORD *v10; // eax
  _DWORD *v11; // eax
  _DWORD *v12; // eax
  _DWORD *v13; // eax
  _DWORD *v14; // eax
  _DWORD *v15; // eax
  _DWORD *v16; // eax
  _DWORD *v17; // eax
  _DWORD *v18; // eax
  _DWORD *v19; // eax
  _DWORD *v20; // eax
  _DWORD *v21; // eax
  _DWORD *v22; // eax
  _DWORD *v23; // eax
  _DWORD *v24; // eax
  _DWORD *v25; // eax
  _DWORD *v26; // eax
  _DWORD *v27; // eax
  _DWORD *v28; // eax
  _DWORD *v29; // eax
  _DWORD *v30; // eax
  _DWORD *v31; // eax
  _DWORD *v32; // eax
  _DWORD *v33; // eax
  _DWORD *v34; // eax
  _DWORD *v35; // eax
  _DWORD *v36; // eax
  _DWORD *v37; // eax
  _DWORD *v38; // eax
  _DWORD *v39; // eax
  int v40; // eax
  int v41; // eax
  int v42; // eax
  int v43; // eax
  int v44; // eax
  int v45; // eax
  int v46; // eax
  _DWORD *v47; // eax
  _DWORD *v48; // eax
  _DWORD *v49; // eax
  int v50; // eax
  _DWORD *v51; // eax
  _DWORD *v52; // eax
  _DWORD *v53; // eax
  int v54; // eax
  int v55; // eax
  int v56; // eax
  int v57; // eax
  int v58; // eax
  int v59; // eax
  int v60; // eax
  _DWORD *v61; // eax
  _DWORD *v62; // eax
  _DWORD *v63; // eax
  int v64; // eax
  int v65; // eax
  int v66; // eax
  int v67; // eax
  int v68; // eax
  int v69; // eax
  int v70; // eax
  int v71; // eax
  int v72; // eax
  int v73; // eax
  int v74; // eax
  int v75; // eax
  int v76; // eax
  int v77; // eax
  int v78; // eax
  _DWORD *v79; // eax
  _DWORD *v80; // eax
  _DWORD *v81; // eax
  _DWORD *v82; // eax
  _DWORD *v83; // eax
  _DWORD *v84; // eax
  _DWORD *v85; // eax
  _DWORD *v86; // eax
  _DWORD *v87; // eax
  _DWORD *v88; // eax
  _DWORD *v89; // eax
  _DWORD *v90; // eax
  _DWORD *v91; // eax
  _DWORD *v92; // eax
  _DWORD *v93; // eax
  _DWORD *v94; // eax
  _DWORD *v95; // eax
  _DWORD *v96; // eax
  int v97; // eax
  int v98; // eax
  int v99; // eax
  int v100; // eax
  int v101; // eax
  int v102; // eax
  int v103; // eax
  int v104; // eax
  _DWORD *v105; // eax
  _DWORD *v106; // eax
  _DWORD *v107; // eax
  _DWORD *v108; // eax
  int v109; // ST1C_4
  _DWORD *v110; // eax
  _DWORD *v111; // eax
  int v112; // ST20_4
  _DWORD *v113; // eax
  _DWORD *v114; // eax
  int v115; // ST20_4
  _DWORD *v116; // eax
  signed int i; // [esp+4h] [ebp-90h]
  signed int j; // [esp+8h] [ebp-8Ch]
  int v120[32]; // [esp+Ch] [ebp-88h]
  int v121; // [esp+8Ch] [ebp-8h]

  for ( i = 0; i < 32; ++i )
    v120[i] = 1;
  v121 = 0;
  puts("Your flag is:");
  v3 = sub_401100(v120, 1000000000);
  v4 = sub_401220(v3, 999999950);
  sub_401100(v4, 2);
  v5 = (_DWORD *)sub_401000(&v120[1], 5000000);
  v6 = sub_401220(v5, 6666666);
  v7 = sub_401000(v6, 1666666);
  v8 = (_DWORD *)sub_401000(v7, 45);
  v9 = sub_401100(v8, 2);
  sub_401000(v9, 5);
  v10 = sub_401100(&v120[2], 1000000000);
  v11 = sub_401220(v10, 999999950);
  v12 = sub_401100(v11, 2);
  sub_401000(v12, 2);
  v13 = (_DWORD *)sub_401000(&v120[3], 55);
  v14 = sub_401220(v13, 3);
  v15 = (_DWORD *)sub_401000(v14, 4);
  sub_401220(v15, 1);
  v16 = sub_401100(&v120[4], 100000000);
  v17 = sub_401220(v16, 99999950);
  v18 = sub_401100(v17, 2);
  sub_401000(v18, 2);
  v19 = sub_401220(&v120[5], 1);
  v20 = sub_401100(v19, 1000000000);
  v21 = (_DWORD *)sub_401000(v20, 55);
  sub_401220(v21, 3);
  v22 = sub_401100(&v120[6], 1000000);
  v23 = sub_401220(v22, 999975);
  sub_401100(v23, 4);
  v24 = (_DWORD *)sub_401000(&v120[7], 55);
  v25 = sub_401220(v24, 33);
  v26 = (_DWORD *)sub_401000(v25, 44);
  sub_401220(v26, 11);
  v27 = sub_401100(&v120[8], 10);
  v28 = sub_401220(v27, 5);
  v29 = sub_401100(v28, 8);
  sub_401000(v29, 9);
  v30 = (_DWORD *)sub_401000(&v120[9], 0);
  v31 = sub_401220(v30, 0);
  v32 = (_DWORD *)sub_401000(v31, 11);
  v33 = sub_401220(v32, 11);
  sub_401000(v33, 53);
  v34 = (_DWORD *)sub_401000(&v120[10], 49);
  v35 = sub_401220(v34, 2);
  v36 = (_DWORD *)sub_401000(v35, 4);
  sub_401220(v36, 2);
  v37 = sub_401100(&v120[11], 1000000);
  v38 = sub_401220(v37, 999999);
  v39 = sub_401100(v38, 4);
  sub_401000(v39, 50);
  v40 = sub_401000(&v120[12], 1);
  v41 = sub_401000(v40, 1);
  v42 = sub_401000(v41, 1);
  v43 = sub_401000(v42, 1);
  v44 = sub_401000(v43, 1);
  v45 = sub_401000(v44, 1);
  v46 = sub_401000(v45, 10);
  sub_401000(v46, 32);
  v47 = sub_401100(&v120[13], 10);
  v48 = sub_401220(v47, 5);
  v49 = sub_401100(v48, 8);
  v50 = sub_401000(v49, 9);
  sub_401000(v50, 48);
  v51 = sub_401220(&v120[14], 1);
  v52 = sub_401100(v51, -294967296);
  v53 = (_DWORD *)sub_401000(v52, 55);
  sub_401220(v53, 3);
  v54 = sub_401000(&v120[15], 1);
  v55 = sub_401000(v54, 2);
  v56 = sub_401000(v55, 3);
  v57 = sub_401000(v56, 4);
  v58 = sub_401000(v57, 5);
  v59 = sub_401000(v58, 6);
  v60 = sub_401000(v59, 7);
  sub_401000(v60, 20);
  v61 = sub_401100(&v120[16], 10);
  v62 = sub_401220(v61, 5);
  v63 = sub_401100(v62, 8);
  v64 = sub_401000(v63, 9);
  sub_401000(v64, 48);
  v65 = sub_401000(&v120[17], 7);
  v66 = sub_401000(v65, 6);
  v67 = sub_401000(v66, 5);
  v68 = sub_401000(v67, 4);
  v69 = sub_401000(v68, 3);
  v70 = sub_401000(v69, 2);
  v71 = sub_401000(v70, 1);
  sub_401000(v71, 20);
  v72 = sub_401000(&v120[18], 7);
  v73 = sub_401000(v72, 2);
  v74 = sub_401000(v73, 4);
  v75 = sub_401000(v74, 3);
  v76 = sub_401000(v75, 6);
  v77 = sub_401000(v76, 5);
  v78 = sub_401000(v77, 1);
  sub_401000(v78, 20);
  v79 = sub_401100(&v120[19], 1000000);
  v80 = sub_401220(v79, 999999);
  v81 = sub_401100(v80, 4);
  v82 = (_DWORD *)sub_401000(v81, 50);
  sub_401220(v82, 1);
  v83 = sub_401220(&v120[20], 1);
  v84 = sub_401100(v83, -294967296);
  v85 = (_DWORD *)sub_401000(v84, 49);
  sub_401220(v85, 1);
  v86 = sub_401220(&v120[21], 1);
  v87 = sub_401100(v86, 1000000000);
  v88 = (_DWORD *)sub_401000(v87, 54);
  v89 = sub_401220(v88, 1);
  v90 = (_DWORD *)sub_401000(v89, 1000000000);
  sub_401220(v90, 1000000000);
  v91 = (_DWORD *)sub_401000(&v120[22], 49);
  v92 = sub_401220(v91, 1);
  v93 = (_DWORD *)sub_401000(v92, 2);
  sub_401220(v93, 1);
  v94 = sub_401100(&v120[23], 10);
  v95 = sub_401220(v94, 5);
  v96 = sub_401100(v95, 8);
  v97 = sub_401000(v96, 9);
  sub_401000(v97, 48);
  v98 = sub_401000(&v120[24], 1);
  v99 = sub_401000(v98, 3);
  v100 = sub_401000(v99, 3);
  v101 = sub_401000(v100, 3);
  v102 = sub_401000(v101, 6);
  v103 = sub_401000(v102, 6);
  v104 = sub_401000(v103, 6);
  sub_401000(v104, 20);
  v105 = (_DWORD *)sub_401000(&v120[25], 55);
  v106 = sub_401220(v105, 33);
  v107 = (_DWORD *)sub_401000(v106, 44);
  v108 = sub_401220(v107, 11);
  sub_401000(v108, 42);
  sub_401000(&v120[26], v120[25]);
  sub_401000(&v120[27], v120[12]);
  v109 = v120[27];
  v110 = sub_401220(&v120[28], 1);
  v111 = (_DWORD *)sub_401000(v110, v109);
  sub_401220(v111, 1);
  v112 = v120[23];
  v113 = sub_401220(&v120[29], 1);
  v114 = sub_401100(v113, 1000000);
  sub_401000(v114, v112);
  v115 = v120[27];
  v116 = (_DWORD *)sub_401000(&v120[30], 1);
  sub_401100(v116, v115);
  sub_401000(&v120[31], v120[30]);
  sub_401C7F("CTF{");
  for ( j = 0; j < 32; ++j )
    sub_401C7F("%c", SLOBYTE(v120[j]));
  sub_401C7F("}\n");
  return 0;
}

分析代码，一开始程序将32位数组v120赋值为1

然后调用三类函数改变v120，最后将v120输出

sub_401100
sub_401220
sub_401000

现在来看看这三个函数是用来干什么的

_DWORD *__cdecl sub_401100(_DWORD *a1, int a2) //函数需要一个地址a1和一个数值a2
{
  int v2; // ST20_4
  signed int v4; // [esp+Ch] [ebp-1Ch]
  int v5; // [esp+14h] [ebp-14h]
  int v6; // [esp+18h] [ebp-10h]
  int v7; // [esp+1Ch] [ebp-Ch]
  int v8; // [esp+20h] [ebp-8h]

  v5 = *a1;          		//让v5存储a1地址中的数值
  v6 = a2;					//让v6存储数值a2
  v4 = -1;									
  v8 = 0;
  v7 = a2 * v5;				//让v7等于a2 * a1地址中的数值
  while ( a2 )              //运行a2次
  {
    v2 = v7 * v5;			//v2 = v7 * a1地址中的数值
    sub_401000(&v8, *a1);   //调用了一个函数将v8的值进行了改变，先去看看
    ++v7;					//让v7+1
    --a2;					//让a2-1
    v6 = v2 - 1;			//v6 = v7 * a1地址中的数值 - 1
  }
    				//发现v8数据只有发生到sub_401000函数中发生过变化
  while ( v4 )              //v4 = -1 而里面的判断条件却是--v4。这里我理解为，这是逆过来的，循环里的++就是--，--就是++
  {
    ++v7;           		//相当于--v7
    ++*a1;					//相当于--*a1
    --v4;					//相当于++v4
    --v6;					//相当于--v6
  }				
    				//发现这里循环只做了一次，a1的值只是-1了即*a1 = *a1-1
  ++*a1;					//这里又给加回来了 *a1 = *a1 +1  
  *a1 = v8;					//这里将v8赋值给了*a1，而v8只在上面sub_401000函数中发生过变化，现在去看看sub_401000函数做了什么事
  return a1;				//明白了sub_401000函数其实就是*a1 = *a1+a2时，由while（a2）和--a2;可知v8做了a2次的加法，相当于v8 = *a1 + *a1 ... +*a1,加了a2次，就是v8 = *a1 * a2，然后将v8赋值给了*a1，函数返回a1。这个函数的作用就是*a1 = *a1 * a2
}

int *__cdecl sub_401000(int *a1, int a2)//函数需要一个地址a1和一个数值a2
{
  int v2; // edx
  int v4; // [esp+Ch] [ebp-18h]
  signed int v5; // [esp+10h] [ebp-14h]
  int v6; // [esp+18h] [ebp-Ch]
  signed int v7; // [esp+1Ch] [ebp-8h]

  v5 = -1;
  v4 = -1 - a2 + 1;			//将v4 = -a2
  v7 = 1231;				
  v2 = *a1;
  v6 = a2 + 1231;
  while ( v4 )				//v4 = -a2，这里可以将循环中的运算逆过来，循环里的++就是--，--就是++
  {
    ++v7;					//相当于--v7
    --*a1;					//相当于++*a1
    --v4;					//相当于++v4
    --v6;					//相当于--v6
  }					//这里相当于*a1 = *a1 + 1 + 1 ....+1,加了a2次1，即*a1 = *a1 + a2 
  while ( v5 )              //v5 = -1 这里可以将循环中的运算逆过来，循环里的++就是--，--就是++
  {
    --v6;					//相当于++v6;
    ++*a1;					//相当于--*a1;
    --v5;					//相当于++v5;
  }					//发现这里循环只做了一次，a1的值只是-1了即*a1 = *a1-1
  ++*a1;					//这里又给加回来了 *a1 = *a1 +1
  return a1;				//这个函数的作用就是*a1 = *a1 + a2
}

_DWORD *__cdecl sub_401220(_DWORD *a1, int a2)//函数需要一个地址a1和一个数值a2
{
  int v3; // [esp+8h] [ebp-10h]
  signed int v4; // [esp+Ch] [ebp-Ch]
  signed int v5; // [esp+14h] [ebp-4h]
  int v6; // [esp+14h] [ebp-4h]

  v4 = -1;
  v3 = -1 - a2 + 1;			//将v3 = -a2
  v5 = -1;
  while ( v3 )				//v3 = -a2，这里可以将循环中的运算逆过来，循环里的++就是--，--就是++
  {
    ++*a1;					//相当于--*a1;
    --v3;					//相当于++v3;
    --v5;					//相当于++v5;
  }					//这里相当于*a1 = *a1 - 1 - 1 ....-1,减了a2次1，即*a1 = *a1 - a2 
  v6 = v5 * v5;
  while ( v4 )      		//v4 = -1 这里可以将循环中的运算逆过来，循环里的++就是--，--就是++
  {
    v6 *= 123;
    ++*a1;					//--*a1;
    --v4;					//++v4;
  }
    				//发现这里循环只做了一次，a1的值只是-1了即*a1 = *a1-1
  ++*a1;					//这里又给加回来了 *a1 = *a1 +1
  return a1;				//这个函数的作用就是*a1 = *a1 - a2
}

现在知道了三个函数的作用，就可以写脚本，得到flag了

这里就有一个有趣的地方了，我直接运行时没有结果的，需要我一步一步调试才有输出，我这里不能明白，希望由师傅指点指点

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <stdlib.h>
using namespace std;
int *sub_401100(int *a1, int a2)//a1 * a2
{
    *a1 = *a1 * a2;
    return a1;
}

int *sub_401000(int *a1, int a2)//a1 + a2
{
    *a1 = *a1 + a2;
    return a1;
}

int *sub_401220(int *a1, int a2)//a1 - a2
{
    *a1 = *a1 -a2;
    return a1;
}

int main()
{
  int *v3; // eax
  int *v4; // eax
  int *v5; // eax
  int *v6; // eax
  int *v7; // eax
  int *v8; // eax
  int *v9; // eax
  int *v10; // eax
  int *v11; // eax
  int *v12; // eax
  int *v13; // eax
  int *v14; // eax
  int *v15; // eax
  int *v16; // eax
  int *v17; // eax
  int *v18; // eax
  int *v19; // eax
  int *v20; // eax
  int *v21; // eax
  int *v22; // eax
  int *v23; // eax
  int *v24; // eax
  int *v25; // eax
  int *v26; // eax
  int *v27; // eax
  int *v28; // eax
  int *v29; // eax
  int *v30; // eax
  int *v31; // eax
  int *v32; // eax
  int *v33; // eax
  int *v34; // eax
  int *v35; // eax
  int *v36; // eax
  int *v37; // eax
  int *v38; // eax
  int *v39; // eax
  int *v40; // eax
  int *v41; // eax
  int *v42; // eax
  int *v43; // eax
  int *v44; // eax
  int *v45; // eax
  int *v46; // eax
  int *v47; // eax
  int *v48; // eax
  int *v49; // eax
  int *v50; // eax
  int *v51; // eax
  int *v52; // eax
  int *v53; // eax
  int *v54; // eax
  int *v55; // eax
  int *v56; // eax
  int *v57; // eax
  int *v58; // eax
  int *v59; // eax
  int *v60; // eax
  int *v61; // eax
  int *v62; // eax
  int *v63; // eax
  int *v64; // eax
  int *v65; // eax
  int *v66; // eax
  int *v67; // eax
  int *v68; // eax
  int *v69; // eax
  int *v70; // eax
  int *v71; // eax
  int *v72; // eax
  int *v73; // eax
  int *v74; // eax
  int *v75; // eax
  int *v76; // eax
  int *v77; // eax
  int *v78; // eax
  int *v79; // eax
  int *v80; // eax
  int *v81; // eax
  int *v82; // eax
  int *v83; // eax
  int *v84; // eax
  int *v85; // eax
  int *v86; // eax
  int *v87; // eax
  int *v88; // eax
  int *v89; // eax
  int *v90; // eax
  int *v91; // eax
  int *v92; // eax
  int *v93; // eax
  int *v94; // eax
  int *v95; // eax
  int *v96; // eax
  int *v97; // eax
  int *v98; // eax
  int *v99; // eax
  int *v100; // eax
  int *v101; // eax
  int *v102; // eax
  int *v103; // eax
  int *v104; // eax
  int *v105; // eax
  int *v106; // eax
  int *v107; // eax
  int *v108; // eax
  int *v109; // ST1C_4
  int *v110; // eax
  int *v111; // eax
  int *v112; // ST20_4
  int *v113; // eax
  int *v114; // eax
  int *v115; // ST20_4
  int *v116; // eax
  signed int i; // [esp+4h] [ebp-90h]
  signed int j; // [esp+8h] [ebp-8Ch]
  int v120[33]; // [esp+Ch] [ebp-88h]
  int v121; // [esp+10h] [ebp-84h]
  for ( i = 0; i < 32; ++i )
    v120[i] = 1;
  v121 = 0;
  puts("Your flag is:");
  v3 = sub_401100(&v120[0], 1000000000);
  v4 = sub_401220(v3, 999999950);
  sub_401100(v4, 2);
  v5 =  sub_401000(&v120[1], 5000000);
  v6 = sub_401220(v5, 6666666);
  v7 = sub_401000(v6, 1666666);
  v8 =  sub_401000(v7, 45);
  v9 = sub_401100(v8, 2);
  sub_401000(v9, 5);
  v10 = sub_401100(&v120[2], 1000000000);
  v11 = sub_401220(v10, 999999950);
  v12 = sub_401100(v11, 2);
  sub_401000(v12, 2);
  v13 =  sub_401000(&v120[3], 55);
  v14 = sub_401220(v13, 3);
  v15 =  sub_401000(v14, 4);
  sub_401220(v15, 1);
  v16 = sub_401100(&v120[4], 100000000);
  v17 = sub_401220(v16, 99999950);
  v18 = sub_401100(v17, 2);
  sub_401000(v18, 2);
  v19 = sub_401220(&v120[5], 1);
  v20 = sub_401100(v19, 1000000000);
  v21 =  sub_401000(v20, 55);
  sub_401220(v21, 3);
  v22 = sub_401100(&v120[6], 1000000);
  v23 = sub_401220(v22, 999975);
  sub_401100(v23, 4);
  v24 =  sub_401000(&v120[7], 55);
  v25 = sub_401220(v24, 33);
  v26 =  sub_401000(v25, 44);
  sub_401220(v26, 11);
  v27 = sub_401100(&v120[8], 10);
  v28 = sub_401220(v27, 5);
  v29 = sub_401100(v28, 8);
  sub_401000(v29, 9);
  v30 =  sub_401000(&v120[9], 0);
  v31 = sub_401220(v30, 0);
  v32 =  sub_401000(v31, 11);
  v33 = sub_401220(v32, 11);
  sub_401000(v33, 53);
  v34 =  sub_401000(&v120[10], 49);
  v35 = sub_401220(v34, 2);
  v36 =  sub_401000(v35, 4);
  sub_401220(v36, 2);
  v37 = sub_401100(&v120[11], 1000000);
  v38 = sub_401220(v37, 999999);
  v39 = sub_401100(v38, 4);
  sub_401000(v39, 50);
  v40 = sub_401000(&v120[12], 1);
  v41 = sub_401000(v40, 1);
  v42 = sub_401000(v41, 1);
  v43 = sub_401000(v42, 1);
  v44 = sub_401000(v43, 1);
  v45 = sub_401000(v44, 1);
  v46 = sub_401000(v45, 10);
  sub_401000(v46, 32);
  v47 = sub_401100(&v120[13], 10);
  v48 = sub_401220(v47, 5);
  v49 = sub_401100(v48, 8);
  v50 = sub_401000(v49, 9);
  sub_401000(v50, 48);
  v51 = sub_401220(&v120[14], 1);
  v52 = sub_401100(v51, -294967296);
  v53 =  sub_401000(v52, 55);
  sub_401220(v53, 3);
  v54 = sub_401000(&v120[15], 1);
  v55 = sub_401000(v54, 2);
  v56 = sub_401000(v55, 3);
  v57 = sub_401000(v56, 4);
  v58 = sub_401000(v57, 5);
  v59 = sub_401000(v58, 6);
  v60 = sub_401000(v59, 7);
  sub_401000(v60, 20);
  v61 = sub_401100(&v120[16], 10);
  v62 = sub_401220(v61, 5);
  v63 = sub_401100(v62, 8);
  v64 = sub_401000(v63, 9);
  sub_401000(v64, 48);
  v65 = sub_401000(&v120[17], 7);
  v66 = sub_401000(v65, 6);
  v67 = sub_401000(v66, 5);
  v68 = sub_401000(v67, 4);
  v69 = sub_401000(v68, 3);
  v70 = sub_401000(v69, 2);
  v71 = sub_401000(v70, 1);
  sub_401000(v71, 20);
  v72 = sub_401000(&v120[18], 7);
  v73 = sub_401000(v72, 2);
  v74 = sub_401000(v73, 4);
  v75 = sub_401000(v74, 3);
  v76 = sub_401000(v75, 6);
  v77 = sub_401000(v76, 5);
  v78 = sub_401000(v77, 1);
  sub_401000(v78, 20);
  v79 = sub_401100(&v120[19], 1000000);
  v80 = sub_401220(v79, 999999);
  v81 = sub_401100(v80, 4);
  v82 =  sub_401000(v81, 50);
  sub_401220(v82, 1);
  v83 = sub_401220(&v120[20], 1);
  v84 = sub_401100(v83, -294967296);
  v85 =  sub_401000(v84, 49);
  sub_401220(v85, 1);
  v86 = sub_401220(&v120[21], 1);
  v87 = sub_401100(v86, 1000000000);
  v88 =  sub_401000(v87, 54);
  v89 = sub_401220(v88, 1);
  v90 =  sub_401000(v89, 1000000000);
  sub_401220(v90, 1000000000);
  v91 =  sub_401000(&v120[22], 49);
  v92 = sub_401220(v91, 1);
  v93 =  sub_401000(v92, 2);
  sub_401220(v93, 1);
  v94 = sub_401100(&v120[23], 10);
  v95 = sub_401220(v94, 5);
  v96 = sub_401100(v95, 8);
  v97 = sub_401000(v96, 9);
  sub_401000(v97, 48);
  v98 = sub_401000(&v120[24], 1);
  v99 = sub_401000(v98, 3);
  v100 = sub_401000(v99, 3);
  v101 = sub_401000(v100, 3);
  v102 = sub_401000(v101, 6);
  v103 = sub_401000(v102, 6);
  v104 = sub_401000(v103, 6);
  sub_401000(v104, 20);
  v105 =  sub_401000(&v120[25], 55);
  v106 = sub_401220(v105, 33);
  v107 =  sub_401000(v106, 44);
  v108 = sub_401220(v107, 11);
  sub_401000(v108, 42);
  sub_401000(&v120[26], v120[25]);
  sub_401000(&v120[27], v120[12]);
  *v109 = v120[27];
  v110 = sub_401220(&v120[28], 1);
  v111 =  sub_401000(v110, *v109);
  sub_401220(v111, 1);
  *v112 = v120[23];
  v113 = sub_401220(&v120[29], 1);
  v114 = sub_401100(v113, 1000000);
  sub_401000(v114, v120[23]);
  v116 =  sub_401000(&v120[30], 1);
  sub_401100(v116, v120[27]);
  sub_401000(&v120[31], v120[30]);
  printf("CTF{");
  for ( j = 0; j < 32; ++j )
    printf("%c", v120[j]);
  printf("}\n");
	return 0;
}

0d9Rln.jpg

桑棋宗
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
前端中 let 和 var 的区别
星星点灯的博客
02-16 1929
作用域不同 var是函数作用域，let是块作用域。 在函数中声明了var，整个函数内都是有效的，比如说在for循环内定义的一个var变量，实际上其在for循环以外也是可以访问的 而let由于是块作用域，所以如果在块作用域内定义的变量，比如说在for循环内，在其外面是不可被访问的，所以for循环推荐用let let不能在定义之前访问该变量，但是var可以。 let必须先声明，再使用。而var先使用后声明也行，只不过直接使用但没有定义的时候，其值是undefined。var有一个变量提升的过程，当整个函.
SG-UAP weblet的使用
热门推荐
码农一个
07-29 1万+
SG-UAP的核心框架是MVC3层结构         在目前的开发过程中遇到一些问题是框架的持久层无法解决的，就自己直接写代码调用hibernate 接口完成功能。 前端使用的是Weblet，除了index页面是jsp的其他的都是js代码编写的 Weblet运行在客户端，是包含展现逻辑、多个用户界面、可独立执行的RIA应用程序或运行时库。  Weblet小程序是web应用的最小逻
UAP 从前端到后端 详细教程 (三) WebLet里的代码
胡萧徒的博客
07-29 8361
直接上代码了,这里是 一个比较 简单的 weblet 增删改查的 表单. 项目名为 holiday ,weblet 也叫 holiday. 主要代码在 模块 holiday-basic 里. 我 的数据库 里也有 holiday 这个表. 字段是: MainView 是列表视图(点击新增时触发事件,弹出的对话框),DetailView 是表单视图 提一点,访问 weblet 的 默...
Web 前端开发利器 Jslet 2.5发布了
xiaoqiang_it的专栏
11-04 678
Jslet 2.5发布了，这次发布对代码进行了全面梳理，在安全，性能及简便性方面进行了全面的加强，文档及demo也增加不少，具体改进如下： 增加了安全防护：防止Xss攻击和防止CSRF攻击；增加DBTimePicker控件；字段支持存放3种类型数据：单值，多值及From...To类型值；重构了与Server端的交互，目前精简到3个方法，使用起来更加简单；修改了一些重要的Bug；重写了及增加了
前端面试题：JS中的let和var的区别
陈迹·清欢的博客
03-05 119
最近很多前端的朋友去面试被问到let和var的区别，其实阮一峰老师的ES6中已经很详细介绍了let的用法和var的区别。我简单总结一下，以便各位以后面试中使用。 ES6 新增了let命令，用来声明局部变量。它的用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效，而且有暂时性死区的约束。 先看个var的常见变量提升的面试题目： 题目1： var a = 99; ...
Makro Newbie_makronexia_
10-02
【标题】"Makro Newbie_makronexia_" 指的可能是一个针对新手的Makro Nexia教程或指南，其中“Makro”通常指的是宏，即自动化脚本，而“Nexia”可能是一个特定的软件、工具或者在本例中的花园管理情境中的概念。...
newbie_project:rc
05-15
newbie_project SPARCS프로젝트 _________________________________________________ | Look up Your Daily Horoscope! | | Used API from aztro | | Guest Mode and Register Mode | | Sign in temporaily ...
2021_Newbie_Python:2021年
03-25
【标题】"2021_Newbie_Python:2021年" 暗示这是一个针对初学者的Python编程教程，可能包含了2021年最新的Python学习资源和趋势。这个标题告诉我们，内容可能涉及Python的基础知识，更新至2021年的最新版本和特性。 ...
2015_mobigen_newbie
06-28
标题 "2015_mobigen_newbie" 暗示我们可能在讨论一个与 Java 相关的项目，可能是某个初学者入门教程或者一个简单的应用。"Mobigen" 是一个早期的 Java 开发工具，这个名字可能指的是这个项目是用 Mobigen 进行开发的...
Newbie02_social-proof-section:新手02
03-17
Newbie02_社会证明部分新手02 resolución375 x 667 resolución1440 x 800
前端面试题（二）：ES6中let，const和 var 三者的区别
lizhengxv的博客
06-02 7963
let命令基本用法 在ES6中，新增了let命令，用于声明变量，用来取代ES5中var命令，消除var声明的变量的不合理，不严谨之处。const用于声明常量。 让我们来看看let和var的区别 1.let不存在变量提升 使用let声明的变量，不会像使用var那样存在“变量提升“”的现象。所以使用let声明变量，必须遵循“先声明，后使用”的原则。否则会报错 console.log(a...
前端：let与var的区别
weixin_30654583的博客
09-16 327
详细情况可跳转到下面这个链接阅读： https://www.cnblogs.com/yukixing/p/11523259.html 【收集别人总结好的知识点，也是高效学习的一种方式！】 转载于:https://www.cnblogs.com/jianguo221/p/11526456.html...
es6中let的特点
少油少盐不要辣
01-28 2458
let 1.同一作用域中，声名变量时，不能重复定义。 2.必须先声名，后使用。（暂时性死区） 3.声名的变量不挂载到window对象上。 4.在一对大括号中{}，声名变量时，会产生块级作用域，变量仅在此块级作用域中有效。 比如，for(){}循坏，function(){}，if(){}语句等，都满足。 5.看如下代码 let a = 9; { c...
let,const与var的比较
weixin_33852020的博客
03-17 171
转载自阮一峰老师的ES6入门，稍有修改 1.基本概念MDN var声明了一个变量，并且可以同时初始化该变量。let语句声明一个块级作用域的本地变量，并且可选的赋予初始值。const 声明创建一个只读的常量，作用域与let相同。这不意味着常量指向的值不可变，而是变量标识符的值只能赋值一次。 2.基本用法 var为大家所熟悉，在这里不再赘述...
Js变量：var，let，const三个关键字的区别
web前端开发
11-07 230
来源 |http://www.fly63.com/article/detial/9697?type=2var在ECMAScript的所有版本中都可以使用，而const和let只能在ES...
js中Let和Var的区别
wt1310445488的博客
10-06 2049
写在前面： 本文转载自：https://www.cnblogs.com/fly_dragon/p/8669057.html 作者：FlyDragon 出处：http://www.cnblogs.com/fly_dragon/ 关于作者：专注于微软平台项目架构、管理和企业解决方案。如有问题或建议，请多多赐教！ 本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，如有问题，可以通malun666@126.com 联系我，非常感谢。 正文： ES6 新增了let
前端学习：let 和 const 命令
qq_31445163的博客
04-18 228
let 和 const 命令 let 命令 基本用法： let 命令声明的对象在代码块内有效 var a= []; for(let i= 0; i<10 ;i++){ a[i] =function(){console.log(i);} } a[6](); // 6 for循环还有一个特别之处，就是设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域。 不存在...
ALTER TABLE `inst_newbie_guide_info` MODIFY COLUMN `playerId` bigint(20) NOT NULL FIRST;
最新发布
04-04
This SQL statement modifies the column `playerId` in the table `inst_newbie_guide_info`. It changes the data type of the column to `bigint(20)` and sets the `NOT NULL` constraint which means the ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值