#include <string.h>
#include "MD5.h"

/* MD5转换用到的常量，是算法本身规定的 */
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21

/* MD5算法本身规定的基本函数 */
#define F(x, y, z) ((x & y) | (~x & z))
#define G(x, y, z) ((x & z) | (y & ~z))
#define H(x, y, z) (x ^ y ^ z)
#define I(x, y, z) (y ^ (x | ~z))

/* 实现将x循环左移n位
 */
#define ROTATE_LEFT(x, n) ((x << n) | (x >> (32 - n)))

/** MD5算法本身规定的 4 轮变换 
 * Rotation is separate from addition to prevent recomputation. 
**/
#define FF(a, b, c, d, x, s, ac) \
{                                \
    a += F(b, c, d) + x + ac;    \
    a = ROTATE_LEFT(a, s);       \
    a += b;                      \
}
#define GG(a, b, c, d, x, s, ac) \
{                                \
    a += G(b, c, d) + x + ac;    \
    a = ROTATE_LEFT(a, s);       \
    a += b;                      \
}
#define HH(a, b, c, d, x, s, ac) \
{                                \
    a += H(b, c, d) + x + ac;    \
    a = ROTATE_LEFT(a, s);       \
    a += b;                      \
}
#define II(a, b, c, d, x, s, ac) \
{                                \
    a += I(b, c, d) + x + ac;    \
    a = ROTATE_LEFT(a, s);       \
    a += b;                      \
}


unsigned char PADDING[] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

static void MD5Transform(unsigned int state[4], unsigned char block[64]);
static void MD5Encode(unsigned char *output, unsigned int *input, unsigned int len);
static void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len);

/* MD5 initialization. Begins an MD5 operation, writing a new context. */  
/* 初始化md5的结构 */
void MD5Init(MD5_CTX *context)
{
    /* 将当前的有效信息的长度设成 0 */
    context->count[0] = 0;
    context->count[1] = 0;
    /* Load magic initialization constants.*/
    /* 初始化链接变量 */
    context->state[0] = 0x67452301;
    context->state[1] = 0xEFCDAB89;
    context->state[2] = 0x98BADCFE;
    context->state[3] = 0x10325476;
}


void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen)
{
    unsigned int i = 0, index = 0, partlen = 0;

    /* 计算已有信息的bits长度的字节数的模64（64bytes = 512bits）。 用于判断已有信息加上当前传过来的信息的总长度能不能达到 512bits， 如果能够达到则对凑够的512bits进行一次处理 */
    index = (context->count[0] >> 3) & 0x3F;    /* (context->count[0] >> 3) = context->count[0]/8 ,即：算字节数； 后面的 & 3F 就是 Mod 64 */
    partlen = 64 - index;                       /* 计算已有的字节数长度还差多少字节可以凑成 64Bytes（512bits） */
    /* 保存输入信息的比特位数 */
    context->count[0] += inputlen << 3;
    if (context->count[0] < (inputlen << 3))
    {
        context->count[1]++;
    }
    context->count[1] += inputlen >> 29;

    /* 如果当前输入的字节数 大于 已有字节数长度补足64字节整倍数所差的字节数 */
    if (inputlen >= partlen)
    {
        /* 用当前输入的内容把 context->buffer 的内容补足 512bits */
        memcpy(&context->buffer[index], input, partlen);
        /* 用基本函数对填充满的512bits（已经保存到context->buffer中） 做一次转换，转换结果保存到context->state中 */
        MD5Transform(context->state, context->buffer);
        /* 对当前输入的剩余字节做转换（如果剩余的字节大于512bits的话 ）， 转换结果保存到context->state中 */
        for (i = partlen; i + 64 <= inputlen; i += 64)
        {
            MD5Transform(context->state, &input[i]);
        }
        index = 0;
    }
    else
    {
        i = 0;
    }
    /*将输入缓冲区中的不足填充满512bits的剩余内容填充到context->buffer中，留待以后再作处理*/
    memcpy(&context->buffer[index], &input[i], inputlen - i);
}


void MD5Final(MD5_CTX *context, unsigned char digest[16])
{
    unsigned int index = 0, padlen = 0;
    unsigned char bits[8];

    /* 计算已有信息的bits长度的字节数的模64（64bytes = 512bits）。 */ 
    index = (context->count[0] >> 3) & 0x3F;
    /* 计算需要填充的字节数，padLen的取值范围在1-64之间 */
    padlen = (index < 56) ? (56 - index) : (120 - index);

    /* 将要被转换的信息(所有的)的bits长度拷贝到bits中 */
    MD5Encode(bits, context->count, 8);
    /*  */
    MD5Update(context, PADDING, padlen);

    /* 补上原始信息的bits长度（bits长度固定的用64bits表示），这一次能够恰巧凑够512bits */
    MD5Update(context, bits, 8);

    /* 将最终的结果保存到digest中 */
    MD5Encode(digest, context->state, 16);
}

static void MD5Encode(unsigned char *output, unsigned int *input, unsigned int len)
{
    unsigned int i = 0, j = 0;
    while (j < len)
    {
        output[j] = input[i] & 0xFF;
        output[j + 1] = (input[i] >> 8) & 0xFF;
        output[j + 2] = (input[i] >> 16) & 0xFF;
        output[j + 3] = (input[i] >> 24) & 0xFF;
        i++;
        j += 4;
    }
}

static void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len)
{
    unsigned int i = 0, j = 0;
    while (j < len)
    {
        output[i] = (input[j]) |
                    (input[j + 1] << 8) |
                    (input[j + 2] << 16) |
                    (input[j + 3] << 24);
        i++;
        j += 4;
    }
}


static void MD5Transform(unsigned int state[4], unsigned char block[64])
{
    unsigned int a = state[0];
    unsigned int b = state[1];
    unsigned int c = state[2];
    unsigned int d = state[3];
    unsigned int x[64];

    MD5Decode(x, block, 64);

    /* Round 1 */
    FF(a, b, c, d, x[0], S11, 0xd76aa478);  /* 1 */
    FF(d, a, b, c, x[1], S12, 0xe8c7b756);  /* 2 */
    FF(c, d, a, b, x[2], S13, 0x242070db);  /* 3 */
    FF(b, c, d, a, x[3], S14, 0xc1bdceee);  /* 4 */
    FF(a, b, c, d, x[4], S11, 0xf57c0faf);  /* 5 */
    FF(d, a, b, c, x[5], S12, 0x4787c62a);  /* 6 */
    FF(c, d, a, b, x[6], S13, 0xa8304613);  /* 7 */
    FF(b, c, d, a, x[7], S14, 0xfd469501);  /* 8 */
    FF(a, b, c, d, x[8], S11, 0x698098d8);  /* 9 */
    FF(d, a, b, c, x[9], S12, 0x8b44f7af);  /* 10 */
    FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
    FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
    FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
    FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
    FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
    FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */

    /* Round 2 */
    GG(a, b, c, d, x[1], S21, 0xf61e2562);  /* 17 */
    GG(d, a, b, c, x[6], S22, 0xc040b340);  /* 18 */
    GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
    GG(b, c, d, a, x[0], S24, 0xe9b6c7aa);  /* 20 */
    GG(a, b, c, d, x[5], S21, 0xd62f105d);  /* 21 */
    GG(d, a, b, c, x[10], S22, 0x2441453);  /* 22 */
    GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
    GG(b, c, d, a, x[4], S24, 0xe7d3fbc8);  /* 24 */
    GG(a, b, c, d, x[9], S21, 0x21e1cde6);  /* 25 */
    GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
    GG(c, d, a, b, x[3], S23, 0xf4d50d87);  /* 27 */
    GG(b, c, d, a, x[8], S24, 0x455a14ed);  /* 28 */
    GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
    GG(d, a, b, c, x[2], S22, 0xfcefa3f8);  /* 30 */
    GG(c, d, a, b, x[7], S23, 0x676f02d9);  /* 31 */
    GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

    /* Round 3 */
    HH(a, b, c, d, x[5], S31, 0xfffa3942);  /* 33 */
    HH(d, a, b, c, x[8], S32, 0x8771f681);  /* 34 */
    HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
    HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
    HH(a, b, c, d, x[1], S31, 0xa4beea44);  /* 37 */
    HH(d, a, b, c, x[4], S32, 0x4bdecfa9);  /* 38 */
    HH(c, d, a, b, x[7], S33, 0xf6bb4b60);  /* 39 */
    HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
    HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
    HH(d, a, b, c, x[0], S32, 0xeaa127fa);  /* 42 */
    HH(c, d, a, b, x[3], S33, 0xd4ef3085);  /* 43 */
    HH(b, c, d, a, x[6], S34, 0x4881d05);   /* 44 */
    HH(a, b, c, d, x[9], S31, 0xd9d4d039);  /* 45 */
    HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
    HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
    HH(b, c, d, a, x[2], S34, 0xc4ac5665);  /* 48 */

    /* Round 4 */
    II(a, b, c, d, x[0], S41, 0xf4292244);  /* 49 */
    II(d, a, b, c, x[7], S42, 0x432aff97);  /* 50 */
    II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
    II(b, c, d, a, x[5], S44, 0xfc93a039);  /* 52 */
    II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
    II(d, a, b, c, x[3], S42, 0x8f0ccc92);  /* 54 */
    II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
    II(b, c, d, a, x[1], S44, 0x85845dd1);  /* 56 */
    II(a, b, c, d, x[8], S41, 0x6fa87e4f);  /* 57 */
    II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
    II(c, d, a, b, x[6], S43, 0xa3014314);  /* 59 */
    II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
    II(a, b, c, d, x[4], S41, 0xf7537e82);  /* 61 */
    II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
    II(c, d, a, b, x[2], S43, 0x2ad7d2bb);  /* 63 */
    II(b, c, d, a, x[9], S44, 0xeb86d391);  /* 64 */

    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;
}

import hashlib
i = hashlib.md5(b'abc')
print(i.digest().hex())

import itertools as its
import md5

#暴力破解
def uncipher(maxlenth,salt,ciphertext_s,str_letter):
  ciphertext_s=ciphertext_s
  salt = salt
  maxlenth=int(maxlenth)
  str_letter=str_letter
  ciphertext=''
  for i in range(1, maxlenth+1):
    # 迭代生成明文(例如abc,repeat=2  结果为（a,a)(a,b)(a,c)(b,b)(b,a)(b,c)(c,c)(c,a)(c,b)
    r = its.product(str_letter, repeat=i)
    for j in r:
      plaintext = "".join(j) #连接成字符串
      plaintext = "%s%s" % (plaintext, salt)  #把盐加到明文的后面 每次生成的最终明文
      #print plaintext   #打印明文
      # 开始解密，方法是，每个明文进来，加密成密文，然后密文与密文做对比
      md501 = md5.new()
      md501.update(plaintext)
      ciphertext = md501.hexdigest()
      # 对比密文确认明文
      if ciphertext == ciphertext_s:  #如果密文一致 退出2层循环
        break
    if ciphertext == ciphertext_s:    #如果密文一致，退出1层循环，打印结果
      print "task finished(plain,cipher)"
      print "%s:%s" % (plaintext, ciphertext) #打印结果
      break

#开始执行主函数

str_letter="abcdefghijklmnopqrstuvwxyz"   #明文的字符范围
maxlenth=6   #明文的最大长度,一般不会超过6位，否则短时间很难暴力破解
salt=''  #加盐 #如果不加盐，为空就是正常的md5解密
ciphertext_s='900150983cd24fb0d6963f7d28e17f72'     #密文
uncipher(maxlenth,salt,ciphertext_s,str_letter)     #开始解密

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v3; // eax
  char *v4; // edi
  int v5; // esi
  int i; // eax
  int v7; // eax
  char v9; // [esp+0h] [ebp-E0h]
  int v10[22]; // [esp+10h] [ebp-D0h] BYREF
  char v11[12]; // [esp+68h] [ebp-78h] BYREF
  char Destination[12]; // [esp+74h] [ebp-6Ch] BYREF
  char v13[12]; // [esp+80h] [ebp-60h] BYREF
  char Source[6]; // [esp+8Ch] [ebp-54h] BYREF
  char v15[8]; // [esp+92h] [ebp-4Eh] BYREF
  char v16[14]; // [esp+9Ah] [ebp-46h] BYREF
  char Buffer[36]; // [esp+A8h] [ebp-38h] BYREF
  char v18[16]; // [esp+CCh] [ebp-14h] BYREF

  scanf("%s", Source);
  v16[7] = 0;
  Destination[6] = 0;
  strncpy(Destination, Source, 6u);
  v3 = strcmp(Destination, "SUCTF{");
  if ( v3 )
    v3 = v3 < 0 ? -1 : 1;
  if ( v3 || v16[6] != '}' )
    goto LABEL_4;
  v11[8] = 0;
  strncpy(v11, v15, 8u);
  v10[0] = 0;
  v10[1] = 0;
  v10[2] = 0x67452301;
  v10[3] = 0xEFCDAB89;
  v10[4] = 0x98BADCFE;
  v10[5] = 0x10325476;
  sub_4010E0(strlen(v11));
  sub_4011A0(v10, v18);
  Buffer[32] = 0;
  v4 = Buffer;
  v5 = 0;
  do
  {
    sub_4010A0(v4, "%02x", v18[v5++]);
    v4 += 2;
  }
  while ( v5 < 16 );
  for ( i = 0; i < 32; ++i )
  {
    if ( (i & 1) == 0 )
      Buffer[i] ^= 1u;
  }
  v7 = strcmp(Buffer, "bf772f6ed89838b9gb9f7abf3cc09413");
  if ( v7 )
    v7 = v7 < 0 ? -1 : 1;
  if ( v7 || (v13[6] = 0, strncpy(v13, v16, 6u), (unsigned __int8)sub_401A90(v13)) )
LABEL_4:
    sub_401020("wrong!", v9);
  else
    sub_401020("Bingo!", v9);
  return 0;
}

bool __thiscall sub_401A90(const char *this)
{
  signed int v2; // esi
  signed int i; // ebx
  const char *v4; // ecx
  char v5; // al

  v2 = strlen(this);
  for ( i = 0; i < v2; *v4 += v5 + 1 )
  {
    v4 = &this[i];
    v5 = 2 * i++;
  }
  return strcmp(this, "`ut9t;") != 0;
}

aaa = 'bf772f6ed89838b9gb9f7abf3cc09413'
num = 0
flag = ''
for i in aaa:
    if num%2 == 0:
        flag+=chr(ord(i)^1)
    else :
        flag += i
    num+=1
print(flag)
#cf673f7ee88828c9fb8f6acf2cb08403
#cf673f7ee88828c9fb8f6acf2cb08403 = md5(birthday)

s='`ut9t;'
flag=''
for i in range(len(s)):
    flag+=chr(ord(s[i])-2*i-1)

print(flag)   
#_ro2k0

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char *v3; // rdx
  int v4; // ecx
  unsigned int v5; // eax
  char *v6; // rsi
  char *v7; // rbx
  __int64 v8; // r8
  char *v9; // rcx
  __int64 i; // r9
  __int64 v11; // rax
  int v12; // edx
  char v14[16]; // [rsp+20h] [rbp-218h] BYREF
  char v15[16]; // [rsp+30h] [rbp-208h] BYREF
  char Str2[32]; // [rsp+40h] [rbp-1F8h] BYREF
  char Str[32]; // [rsp+60h] [rbp-1D8h] BYREF
  char Buffer[32]; // [rsp+80h] [rbp-1B8h] BYREF
  __int64 v19; // [rsp+A0h] [rbp-198h] BYREF
  int v20[24]; // [rsp+B0h] [rbp-188h] BYREF
  _DWORD v21[32]; // [rsp+110h] [rbp-128h] BYREF
  int v22[42]; // [rsp+190h] [rbp-A8h]

  _main();
  qmemcpy(Str2, "32cbe93f1dd4f2f3be1c85983d6994c1", sizeof(Str2));
  v20[0] = 0;
  v20[1] = 0;
  v20[2] = 1732584193;
  v20[3] = -271733879;
  v20[4] = -1732584194;
  v20[5] = 271733878;
  puts("please input your key:");
  scanf("%s", v14);
  v3 = v14;
  do
  {
    v4 = *(_DWORD *)v3;
    v3 += 4;
    v5 = ~v4 & (v4 - 16843009) & 0x80808080;
  }
  while ( !v5 );
  if ( (~v4 & (v4 - 16843009) & 0x8080) == 0 )
    v5 >>= 16;
  if ( (~v4 & (v4 - 16843009) & 0x8080) == 0 )
    v3 += 2;
  if ( &v3[-__CFADD__((_BYTE)v5, (_BYTE)v5) - 3] - v14 != 6 )
  {
    printf("err0r!");
    exit(0);
  }
  v6 = v15;
  MD5Update(v20, v14, 6i64);
  v7 = Buffer;
  MD5Final(v20, v15);
  do
  {
    v8 = (unsigned __int8)*v6;
    v9 = v7;
    v7 += 2;
    ++v6;
    sprintf(v9, "%02x", v8);
  }
  while ( v7 != (char *)&v19 );
  if ( !strcmp(Buffer, Str2) )
  {
    printf("key error");
    exit(0);
  }
  puts("oh yeah~");
  puts(&byte_405040);
  puts("please inut your flag:");
  scanf("%s", Str);
  memset(v21, 0, sizeof(v21));
  do_something(Str);
  for ( i = 0i64; i != 31; ++i )
    v21[i] ^= (i + 18) ^ ((v21[i] + 12) % 24) ^ v21[i + 1];
  v22[0] = 29;
  v22[1] = 70;
  v11 = 0i64;
  v22[2] = 92;
  v22[3] = 84;
  v12 = 29;
  v22[4] = 87;
  v22[5] = 19;
  v22[6] = 61;
  v22[7] = 43;
  v22[8] = 62;
  v22[9] = 60;
  v22[10] = 29;
  v22[11] = 9;
  v22[12] = 18;
  v22[13] = 63;
  v22[14] = 6;
  v22[15] = 6;
  v22[16] = 42;
  v22[17] = 14;
  v22[18] = 124;
  v22[19] = 110;
  v22[20] = 109;
  v22[21] = 60;
  v22[22] = 105;
  v22[23] = 160;
  v22[24] = 184;
  v22[25] = 135;
  v22[26] = 62;
  v22[27] = 128;
  v22[28] = 92;
  v22[29] = 61;
  v22[30] = 220;
  v22[31] = 176;
  while ( 1 )
  {
    if ( v21[v11] != v12 )
    {
      printf("error");
      exit(0);
    }
    if ( ++v11 == 32 )
      break;
    v12 = v22[v11];
  }
  puts("Right!!!!!");
  printf("flag is NSSCTF{%s}", Str);
  return 0;
}

__int64 __fastcall do_something(char *Str, __int64 a2, __int64 a3)
{
  size_t v6; // rax
  int v7; // r13d
  int v8; // edi
  unsigned int v9; // r12d
  __int64 i; // rax
  __int64 v11; // r11
  __int64 v12; // r10
  unsigned int v13; // ecx
  int v14; // kr00_4
  _BYTE *v15; // r9
  __int64 result; // rax
  _DWORD v17[22]; // [rsp+20h] [rbp-58h]

  v6 = strlen(Str);
  v7 = v6;
  if ( (v6 & 3) != 0 )
  {
    v8 = 0;
    v9 = ((unsigned int)((int)v6 >> 31) >> 30) - ((((unsigned int)((int)v6 >> 31) >> 30) + (_BYTE)v6) & 3) + 4;
    while ( 1 )
    {
      ++v8;
      *(_WORD *)&Str[v6] = 'Q';
      if ( v8 == v9 )
        break;
      v6 = strlen(Str);
    }
  }
  for ( i = 0i64; v7 / 4 > (int)i; ++i )
    v17[i] = *(_DWORD *)&Str[4 * i];
  v11 = a2;
  v12 = 0i64;
  do
  {
    v13 = v17[v12];
    v14 = v12++;
    v11 += 16i64;
    v15 = (_BYTE *)(a3 + v14 % 6);
    *(_DWORD *)(v11 - 16) = (unsigned __int8)*v15 ^ BYTE1(v13);
    *(_DWORD *)(v11 - 12) = (unsigned __int8)*v15 ^ HIBYTE(v13);
    result = (unsigned __int8)*v15 ^ (unsigned int)((int)(v13 & 0xFF0000) >> 16);
    *(_DWORD *)(v11 - 8) = result;
    *(_DWORD *)(v11 - 4) = (unsigned __int8)(*v15 ^ v13);
  }
  while ( v12 != 8 );
  return result;
}

for ( i = 0i64; i != 31; ++i )
    v21[i] ^= (i + 18) ^ ((v21[i] + 12) % 24) ^ v21[i + 1];
    ....
    while ( 1 )
  {
    if ( v21[v11] != v12 )
    {
      printf("error");
      exit(0);
    }
    if ( ++v11 == 32 )
      break;
    v12 = v22[v11];
  }
  puts("Right!!!!!");

mid=[32,59,121,60,125,45,32,17,38,0,43,45,48,48,28,42,11,20,49,100,63,119,103,53,173,46,136,158,49,78,78,176]
enc=[29,70,92,84,87,19,61,43,62,60,29,9,18,63,6,6,42,14,124,110,109,60,105,191,7,162,64,104,92,61,223,179]
flag=[0]*32
flag[31]=179
flag[30]=223
print(flag)
#th1s_3ncryt_is_s0_e@sy!1
key = [ord(i) for i in "HN_CTF"]
def decrypt(arr):
    for i in range(0,len(arr)//4):
        tmp = arr[4*i:4*i+4]
        st = ""
        st+=chr(tmp[3]^key[i%6])
        st+=chr(tmp[0]^key[i%6])
        st+=chr(tmp[2]^key[i%6])
        st+=chr(tmp[1]^key[i%6])
        print(st,end='')
    print()   
    pass
def dfs(deep):
    global flag
    if(deep==0):
        decrypt(flag)
    else:
        for i in range(0,0xff):
            if( enc[deep-1] == (0x12+deep-1)^ ((i+12)%24 )^ i ^ flag[deep]):
                flag[deep-1] = i
                dfs(deep-1)
dfs(31)
#th1s_3ncryt_is_s0_e@sy!1

unsigned int f(int B, int C, int D, int t)
{
    return 
    (t >= 0 && t <= 19) ? ((B&C) | (~B&D)) : 
    ((t >= 20 && t <= 39) ? (B ^ C ^ D) : 
    ((t >= 40 && t <= 59) ? ((B&C) | (B&D) | (C&D)) :
    ((t >= 60 && t <= 79) ? B ^ C ^ D : 0)));
}

void GetW(unsigned int w[])
{
    /*
    for (int i = 16; i < 80; i++)
        w[i] = ((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]) << 1) | ((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]) >> 31);
    */
    for (int i = 16; i < 80; w[i++] = ((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]) << 1) | ((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]) >> 31));
}

void StepFunction(unsigned int w[], int t)
{
    unsigned int temp = ((A << 5) | (A >> 27)) + f(B, C, D, t) + E + w[t] + GetK(t);
    E = D, D = C, C = ((B << 30) | (B >> 2)), B = A, A = temp;
}

void GetCipher(unsigned int * cipher)
{
    cipher[0] = A0 + A;
    cipher[1] = B0 + B;
    cipher[2] = C0 + C;
    cipher[3] = D0 + D;
    cipher[4] = E0 + E;
}

u32 Ch(u32 x, u32 y, u32 z)
{
    return (x & y) ^ (~x & z);
}

u32 Ma(u32 x, u32 y, u32 z)
{
    return (x & y) ^ (x & z)^ (y & z);
}

u32 cycle_rshift(u32 x,u32 n)
{
    return  ((x & (((u32)1 << n) - 1)) << (32 - n))|(x >> n);
}
u32 Sum0(u32 x)
{
    return cycle_rshift(x, 2) ^ cycle_rshift(x, 13) ^ cycle_rshift(x, 22);
}

u32 Sum1(u32 x)
{
    return cycle_rshift(x, 6) ^ cycle_rshift(x, 11) ^ cycle_rshift(x, 25);
}

u32 Sigma0(u32 x)
{
    return cycle_rshift(x, 7) ^ cycle_rshift(x, 18) ^ (x>>3);
}

u32 Sigma1(u32 x)
{
    return cycle_rshift(x, 17) ^ cycle_rshift(x, 19) ^ (x >> 10);
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#pragma warning(disable:4996)

//初始化链接变量
unsigned int A = 0x67452301, B = 0xEFCDAB89, C = 0x98BADCFE, D = 0x10325476, E = 0xC3D2E1F0;        //第一次迭代的链接变量

unsigned int K[4] = { 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6 };                              //循环中用到的常量
unsigned int A0 = 0x67452301, B0 = 0xEFCDAB89, C0 = 0x98BADCFE, D0 = 0x10325476, E0 = 0xC3D2E1F0;

// 字节转换，将四个字节转换为一个整型
int CharToWord(unsigned char *context, int i)
{
    return (((int)context[i] & 0x000000ff) << 24) | (((int)context[i + 1] & 0x000000ff) << 16) | (((int)context[i + 2] & 0x000000ff) << 8) | ((int)context[i + 3] & 0x000000ff);
}

// 填充补位获得原始明文
void SHA1_fill(unsigned char *plaintext, unsigned int *group, int length)
{
    printf("补位后获得的明文：\n");

    int temp = length / 32, len = length;
    while (len > 0)
    {
        if (len = len / 32)
        {
            for (int j = 0; j < temp; j++)
            {
                group[j] = CharToWord(plaintext, 4 * j);
                printf("%08X\n", group[j]);
            }
        }
        else
        {
            plaintext[length / 8] = 0x80;
            group[temp] = CharToWord(plaintext, temp * 4);
            printf("%08X\n", group[temp]);
            break;
        }
    }
    group[15] = length;
    for (int i = temp + 1; i < 16; i++)
        printf("%08X\n", group[i]);

}
// f函数
unsigned int f(int B, int C, int D, int t)
{
    return (t >= 0 && t <= 19) ? ((B&C) | (~B&D)) : ((t >= 20 && t <= 39) ? (B ^ C ^ D) : ((t >= 40 && t <= 59) ? ((B&C) | (B&D) | (C&D)) : ((t >= 60 && t <= 79) ? B ^ C ^ D : 0)));
}
//获得Kr
unsigned int GetK(int r)
{
    /*
    if (r >= 0&& r <= 19)
    {
        return K[0];
    }else if (r >= 20 && r <= 39)
    {
        return K[1];
    }else if (r >= 40 && r <= 59)
    {
        return K[2];
    }else if (r >= 60 && r <= 79)
    {
        return K[3];
    }
    */
    return (r >= 0 && r <= 19) ? K[0] : ((r >= 20 && r <= 39) ? K[1] : ((r >= 40 && r <= 59) ? K[2] : ((r >= 60 && r <= 79) ? K[3] : 0)));
}

//获得 Wt
void GetW(unsigned int w[])
{
    /*
    for (int i = 16; i < 80; i++)
        w[i] = ((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]) << 1) | ((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]) >> 31);
    */
    for (int i = 16; i < 80; w[i++] = ((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]) << 1) | ((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]) >> 31));
}
// 步函数
void StepFunction(unsigned int w[], int t)
{
    unsigned int temp = ((A << 5) | (A >> 27)) + f(B, C, D, t) + E + w[t] + GetK(t);
    E = D, D = C, C = ((B << 30) | (B >> 2)), B = A, A = temp;
}
// 获得密文
void GetCipher(unsigned int * cipher)
{
    cipher[0] = A0 + A;
    cipher[1] = B0 + B;
    cipher[2] = C0 + C;
    cipher[3] = D0 + D;
    cipher[4] = E0 + E;
}

void SHA1(unsigned char *context,unsigned int * cipher)
{
    int len = strlen((char*)context) * 8;
    unsigned int group[80] = { 0 };

    SHA1_fill(context, group, len);
    GetW(group);
    for (int t = 0; t < 80; t++)
    {
        StepFunction(group, t);
    }


    GetCipher(cipher);

}
int main()
{
    unsigned char m[56];
    unsigned int c[5] = { 0 };
    printf("请输入长度小于56且不包含空格的明文：");
    scanf("%s", m);
    SHA1(m,c);
    /*密文输出*/
    printf("密文为：");
    for (int j = 0; j <= 4; j++) printf("%08X", c[j]);
    printf("\n");
    system("pause");
    return 0;
}

#include<stdio.h>
#include<windows.h>
typedef unsigned int u32;
typedef unsigned char u8;
typedef unsigned long long u64;
#define H0  0x6a09e667
#define H1  0xbb67ae85
#define H2  0x3c6ef372
#define H3  0xa54ff53a
#define H4  0x510e527f
#define H5  0x9b05688c
#define H6  0x1f83d9ab
#define H7  0x5be0cd19
u32 Wt[64];
u32 Kt[64] = { 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
                0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
                0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
                0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
                0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
                0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
                0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
                0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
                0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
                0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
                0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
                0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
                0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
                0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
                0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
                0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
u32 Ch(u32 x, u32 y, u32 z)
{
    return (x & y) ^ (~x & z);
}
u32 cycle_rshift(u32 x,u32 n)
{
    return  ((x & (((u32)1 << n) - 1)) << (32 - n))|(x >> n);
}
u32 Sum0(u32 x)
{
    return cycle_rshift(x, 2) ^ cycle_rshift(x, 13) ^ cycle_rshift(x, 22);
}
u32 Sum1(u32 x)
{
    return cycle_rshift(x, 6) ^ cycle_rshift(x, 11) ^ cycle_rshift(x, 25);
}
u32 Sigma0(u32 x)
{
    return cycle_rshift(x, 7) ^ cycle_rshift(x, 18) ^ (x>>3);
}
u32 Sigma1(u32 x)
{
    return cycle_rshift(x, 17) ^ cycle_rshift(x, 19) ^ (x >> 10);
}
u32 Ma(u32 x, u32 y, u32 z)
{
    return (x & y) ^ (x & z)^ (y & z);
}
struct sha256
{
    u32 block[16];  //加密的measage
    u32 hash[8];    //hash的结果
    u64 hash_length;//总共hash的byte数
    u8  offset;     //一个update未对齐Word(4字节)的字节数
    u8  index;      //当前已经写到block的位置
};
void sha_init(struct sha256 *s)
{
    s->hash[0] = H0;
    s->hash[1] = H1;
    s->hash[2] = H2;
    s->hash[3] = H3;
    s->hash[4] = H4;
    s->hash[5] = H5;
    s->hash[6] = H6;
    s->hash[7] = H7;
    s->hash_length = 0;
    s->index  = 0;
    s->offset = 0;
}
void sha_caculator(struct sha256* s)//先补齐 Wt,然后循环64次加密
{
    u8 i = 0;
    u32 m0, s0, s1,c1,t1;

    u32 temp[8];
    for(i=0;i<8;i++)
        temp[i]=s->hash[i];

    for (i = 0; i < 16; i++)
        Wt[i] = s->block[i];

    for (i = 16; i < 64; i++)
        Wt[i] = Sigma1(Wt[i-2])+ Wt[i-7]+Sigma0(Wt[i - 15])+ Wt[i - 16];

    for (i = 0; i < 64; i++)
    {
        s0 = Sum0(temp[0]);

        s1 = Sum1(temp[4]);

        m0 = Ma(temp[0], temp[1], temp[2]);

        c1 = Ch(temp[4], temp[5], temp[6]);

        t1 = s1+c1+temp[7]+Wt[i] + Kt[i];

        temp[7] = temp[6];
        temp[6] = temp[5];
        temp[5] = temp[4];
        temp[4] = temp[3]+ t1;
        temp[3] = temp[2];
        temp[2] = temp[1];
        temp[1] = temp[0];
        temp[0] = t1+m0+s0;

    }

    for (i = 0; i < 8; i++)
        s->hash[i]+=temp[i];
}
void sha_updata(struct sha256* s,unsigned char *str,u64 len)
{
    u64 i = 0;
    u64 count;
    s->hash_length += len;
    if (s->offset!=0)//说明没有4字节对齐
    {
        if (s->offset + len < 4)
        {
            for (i = s->offset; i < s->offset+len; i++)
            {
                s->block[s->index]  |= (((u32)(*str)) << (8 * (3 - i)));
                str++;
            }
            s->offset += len;
            return;
        }
        else
        {
            len = len + s->offset - 4;
            for (i = s->offset; i < 4; i++)
            {
                s->block[s->index]  |= (((u32)(*str)) << (8 * (3 - i)));
                str++;
            }
            s->index++;
            if (s->index == 16)
            {
                sha_caculator(s);//满足512bit 16Word加密一次
                s->index = 0;
            }
        }
    }
    count = (len >> 2);//计算这次加密有多少个Word
    s->offset = len % 4;//对齐Word剩余的byte


    for(i=0;i<count;i++)
    {

        s->block[s->index] = (((u32)(*str))     << 24) |
                                ((*(str +   1))     << 16) |
                                ((*(str + 2))   << 8) |
                                (*(str + 3));
        s->index++;

        str += 4;

        if (s->index == 16)
        {
            sha_caculator(s);//满足512bit 16Word加密一次
            s->index = 0;
        }
    }


    s->block[s->index] = 0;//对齐Word剩余的byte写在 s->index 位置上，供下一次update使用

    for (i = 0; i < s->offset; i++)
    {
        s->block[s->index] |= (((u32)(*str)) << (8 * (3 - i)));
        str++;
    }

}
void sha_final(struct sha256* s)
{
    u8 temp=s->hash_length % 64;//计算需要填充多少byte
    u8 fill[4] = { 0x80,0x0,0x0,0x0 };
    u32 i;
    if (temp == 56)//则需要填充一个512bit
    {
        //补齐前一次的512bit
        if (s->offset != 0)
        {
            for (i = 0; i < 4-s->offset; i++)
            s->block[s->index]  |= (fill[i]<< (8 * (3 - i-s->offset)));

            s->index++;
        }
        else
        {
            s->block[s->index] = 0x80000000;
            s->index++;
        }
        for (i = s->index; i < 16; i++)
            s->block[i] = 0;

        sha_caculator(s);


        for(i=0;i<14;i++)
        s->block[i] = 0;

        s->block[14] = s->hash_length >> 29;
        s->block[15] = s->hash_length << 3 & 0xffffffff;
        sha_caculator(s);

    }
    else
    {
        if (s->offset != 0)
        {
            for (i = 0; i < 4-s->offset; i++)
                s->block[s->index]  |= (fill[i] << (8 * ( 3 - i - s->offset)));

            s->index++;
        }
        else
        {
            s->block[s->index] = 0x80000000;
            s->index++;
        }
        for (i = s->index; i < 14; i++)
            s->block[i] = 0;
        s->block[14] = s->hash_length>> 29;
        s->block[15] = s->hash_length<<3 & 0xffffffff;
        sha_caculator(s);
    }
}
int main()
{


    int i = 0;
    struct sha256 testsha;

    sha_init(&testsha);
    sha_updata(&testsha, "abc", 3);
    sha_updata(&testsha, "defg", 4);
    sha_updata(&testsha, "hi", 2);
    sha_updata(&testsha, "jklmn", 5);
    sha_final(&testsha);

    for (i = 0; i < 8; i++)
        printf("%08x", testsha.hash[i]);

    system("pause");

}

import hashlib

sha256 = hashlib.sha256()
sha256.update(b"Hello, World!")
hash_value = sha256.digest()
hex_value = hash_value.hex()

print(hex_value)

#b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

import  hashlib
from tqdm import tqdm

m1="8c36e4"
m2="c1d294"
m3="df5bb7a9b"
m4="b8bd2d2"
m5="f22c1f"
m6="9"


str1="i"
str2="Bgt"
str3="_Ld"
str4="s"
str5="6c9"
cc=[]

def getdigest(content):
    return  hashlib.sha1(str(content).encode('utf-8')).hexdigest()
alphabet1="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
alphabet2="0123456789abcdef"

for a1 in tqdm(range(32,127)):
    for a2 in range(32,127):
        for a3 in range(32,127):
            for a4 in range(32,127):
                string = str1 + chr(a1) + str2+ chr(a2) + str3 + chr(a3) + str4+ chr(a4) + str5
                cip=getdigest(string)
                #print(cip)
                cc.append(cip)

uu=0
print(len(cc))
#print(cc)

for i in tqdm(cc):
    if m1 in i and  m2 in i and m3 in i and m4 in i and m5 in i and m6 in i :
        print(i)
        uu+=1
print(uu)