[dragonsector](Reverse)Starblind

---

简介 :

题目地址 : https://s3.eu-central-1.amazonaws.com/dragonsector2-ctf-prod/starblind_96bbc884beb953bee0f120d0994d30d6073c53afd582f456586d7effa184dc25/starblind.html

---

分析 :

查看源码发现有一段 base64 编码的 js 代码

Paste_Image.png

直接点开浏览器会自动解码 :

Paste_Image.png

可以找到 , 这里是主要的密码验证的地方 , 会将用户输入的密码使用 CalcSha4() 这个函数计算哈希
然后再比较得到的哈希是否和已存在的哈希相同

Paste_Image.png

再来看 CalcSha4() 这个函数 :

var CalcSHA4 = function(block) {
  let r = new Uint8Array(64);

  for (let i = 0; i < block.length; i++) {
    r[i] = block.charCodeAt(i); // 将用户输入复制到新的长度 64 的数组中
  }

  for (let i = 32; i < 64; i++) {
    r[i] = i * 48271;  // 后 32 字节填充
  }

  // 定义异或函数
  let xor = function (imm) {
    for (let i = 0; i < 64; i++) {
      r[i] ^= imm[i];
    }
  };
  
  // 定义 perm 函数
  let perm = function (imm) {
    let n = new Uint8Array(64);  
    for (let i = 0; i < 512; i++) {
      const dst_bit = i%8;
      const dst_byte = i/8|0;
      const sign = Math.sgn(imm[i]);
      const idx = sign ? -imm[i] : imm[i];
      const src_bit = idx%8;
      const src_byte = idx/8|0;
      let b = (r[src_byte] >> src_bit) & 1;
      if (sign) { b ^= 1; }      
      n[dst_byte] |= b << dst_bit;
    }
    r = n;
  };

/*
 * 这里省略了 xor 函数 和 perm 函数
 */

  // 将数组转换成 16 进制字符串
  hexdigest = "";
  for (let i = 0; i < 64; i++) {
    let n = r[i].toString(16);        
    if (n.length < 2) {
      n = "0" + n;
    }
    hexdigest += n;
  }

  return hexdigest;
}

这里需要我们重点关注的函数是 perm 函数 , 单独拿出来分析 :

  let perm = function (imm) {
    let n = new Uint8Array(64);  
    for (let i = 0; i < 512; i++) { // 64字节 -> 512 位 , 也就是遍历 64 个字符的每一个位
      const dst_bit = i%8;
      const dst_byte = i/8|0;
      const sign = Math.sgn(imm[i]); // Math.sgn 返回这个数是否为负数
      // Math.sgn = function(a) { return 1/a<0; }; 
      const idx = sign ? -imm[i] : imm[i]; // 求出 imm 数组元素的绝对值
      const src_bit = idx%8;
      const src_byte = idx/8|0;
      let b = (r[src_byte] >> src_bit) & 1; // 取出 r 的第 idx/8 个元素的第 idx%8 个 bit
      if (sign) { b ^= 1; } // 如果这里 imm 元素是负数 , 将这个 bit 与 1 异或
      n[dst_byte] |= b << dst_bit; // 将异或后的 b 放置在 n 这个数组的第 i/8 个元素的第 i%8 个 bit
    }
    r = n;
  };

这里加密算法的流程是这样 :

1. 加密之前保证明文长度为 27 字节
2. 定义一个 64 字节的数组 , 初始值为 0 
3. 将明文按照顺序复制到这个数组中
4. 由于明文不足 64 字节 , 因此从 32 位开始 , 对明文进行填充 , 具体填充的做法请见上面的代码
5. 不断地使用 xor 和 perm 函数对函数中定义的数组进行处理 (大约总共五百多次)
5.1. xor() : xor 的话在异或一次就可以得到明文
5.2. perm() : 将明文 r(64个字节(元素)) 和加密向量 imm(512个元素) 进行运算得到密文 n
  5.2.1. 循环计数器 i , 除以 8 得到目标字节的索引
  5.2.2. 循环计数器 i , 求余 8 得到目标字节的 bit 的索引
  5.2.3. imm的元素 , 判断是否小于 0 , 小于 0 , 则本次循环中取得的 bit 要与 1 异或 , 大于则不进行异或处理
  5.2.4. imm的元素 , 将其除以 8 得到 src_byte , 源字节
  5.2.5. imm的元素 , 将其求余 8 得到单个字节的 bit 数
  5.2.6. 最后将 r 的 sct_byte 的 src_bit 移动到 n 的 dst_byte 的 dst_bit 位置
  5.2.7. 循环 512 次直到所有 bit 都被移动
6. 处理结束 , 然后将这个数组转换成 16 进制字符串 , 并返回 , 得到明文的哈希

那么我们现在可以知道的是最终的哈希 , 以及最后一次 perm 函数中使用到的加密向量 imm
那我们就可以反推出最后一次 perm 函数执行前明文 r 的值
然后就可以一直反推回去 , 就可以得到最终的明文 , 也就是 r 的前 27 字节
将 js 代码进行简单修改即可
这里有一个需要注意的技巧就是 , 这里有大量的 xor 函数和 perm 函数需要逆序执行
这里给出两种方法 :

1. 神马大哥的方法 : 使用 sublime : Edit->Permute Lines->Reverse
2. linux下使用 tac 命令

最终的 js 代码如下 :

  let r = [
0x98, 0x3b, 0xb3, 0x5e, 0xd0, 0xa8, 0x00, 0xfc, 
0xc8, 0x5d, 0x12, 0x80, 0x6d, 0xf9, 0x22, 0x53, 
0x64, 0x71, 0x3b, 0xe5, 0x78, 0xba, 0x67, 0xf6, 
0x5b, 0xc5, 0x08, 0xb7, 0x7f, 0x0c, 0x54, 0x87, 
0x8e, 0xda, 0x18, 0xa5, 0xee, 0xd5, 0x0b, 0xac, 
0x70, 0x5b, 0xdc, 0x7d, 0xb2, 0x05, 0x62, 0x32, 
0x21, 0xe8, 0xff, 0xe3, 0x30, 0x48, 0x39, 0x55, 
0xa2, 0x22, 0x16, 0x96, 0x07, 0x54, 0xa1, 0x22
];

  // 定义 Math.sgn 函数
Math.sgn = function(a) { return 1/a<0; }; 

  // 定义 xor 函数
  let xor = function (imm) {
    for (let i = 0; i < 64; i++) {
      r[i] ^= imm[i];
    }
  };

  // 定义 perm 函数
  let perm = function (imm) {
    let n = new Uint8Array(64);  
    for (let i = 0; i < 512; i++) {
      const dst_bit = i%8;
      const dst_byte = i/8|0;
      const sign = Math.sgn(imm[i]);
      const idx = sign ? -imm[i] : imm[i];
      const src_bit = idx%8;
      const src_byte = idx/8|0;
      let b = (r[dst_byte] >> dst_bi) & 1; // 调换 dst 和 src
      if (sign) { b ^= 1; }      
      n[src_byte] |= b << src_bitt;
    }
    r = n;
  };

/*
 * 这里是已经逆向排序的 xor 和 perm 函数
 */

  // 输出 r
  for(let i = 0; i < 64; i++){
    console.log(r[i]);
  }