/*
 * .============.
 * // M A K E / \
 * // C++ DEV / \
 * // E A S Y / \/ \
 * ++ ----------. \/\ .
 * \\ \ \ /\ /
 * \\ \ \ /
 * \\ \ \ /
 * -============'
 *
 * Copyright (c) 2018 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include "md5.h"

#include <cstring>
#include <tbox/base/assert.h>

namespace tbox {
namespace crypto {

/**
 * 参考 https://cloud.tencent.com/developer/article/1806329
 * 并进行 C++ 语法化
 */

namespace {

/**
 * 非线性函数
 * (&是与,|是或,~是非,^是异或)
 *
 * 这些函数是这样设计的:
 * 如果X、Y和Z的对应位是独立和均匀的,
 * 那么结果的每一位也应是独立和均匀的。
 *
 * 函数F是按逐位方式操作:如果X,那么Y,否则Z。
 * 函数H是逐位奇偶操作符
 */
#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))


//! 向左环移n个单位
#define ROTATE_LEFT(x, n) ((x << n) | (x >> (32 - n)))

/**
 * 每次操作对a,b,c和d中的其中三个作一次非线性函数运算
 * F(b,c,d) G(b,c,d) H(b,c,d) I(b,c,d)
 *
 * 然后将所得结果加上 第四个变量(a),
 * F(b,c,d)+a
 *
 * 文本的一个子分组(x)
 * F(b,c,d)+a+x
 *
 * 和一个常数(ac)。
 * F(b,c,d)+a+x+ac
 *
 * 再将所得结果向右环移一个不定的数(s),
 * ROTATE_LEFT( F(b,c,d)+a+x+ac , s )
 *
 * 并加上a,b,c或d中之一(b)。
 * ROTATE_LEFT( F(b,c,d)+a+x+ac , s )+b
 *
 * 最后用该结果取代a,b,c或d中之一(a)。
 * a=ROTATE_LEFT( F(b,c,d)+a+x+ac , s )+b
 */

#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; }

//! 第一位1 其后若干个0,用于Final函数时的补足
const uint8_t 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 };

/**
 * \brief 利用位操作,按1->4方式把数字分解成字符
 *
 * \param output 输出的字符的数组
 * \param input 输入数字的数组
 * \param len 输入数字数组的长度(单位:位)
 */
void Encode(uint8_t *output, const uint32_t *input, size_t len)
{
 uint32_t 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;
 }
}

/**
 * \brief 利用位操作,按4->1方式把字符合成数字
 *
 * \param output 输出的数字的数组
 * \param input 输入字符的数组
 * \param len 输入字符的长度 (单位:位)
 */
void Decode(uint32_t *output, const uint8_t *input, size_t len)
{
 uint32_t i = 0, j = 0;
 while (j < len) {
 /**
 * 利用位操作,把四个单位为1字节的字符,合成一个单位为4字节的数字
 * 因为FF GG HH II和非线性函数都只能对数字进行处理
 * 第一个字符占前8位,第二个占8-16位,第三个占16-24位,第四个占24-32位。
 */
 output[i] = (input[j]) | (input[j + 1] << 8) | (input[j + 2] << 16)
 | (input[j + 3] << 24);
 i++;
 j += 4;
 }
}

/**
 * \brief 对512位的block数据进行加密,并把加密结果存入state_数组中
 * 对512位信息(即block字符数组)进行一次处理,每次处理包括四轮
 *
 * \param state_[4] md5结构中的state_[4],用于保存对512bits信息加密的中间结果或者最终结果
 * \param block[64] 欲加密的512bits信息或其中间数据
 */
void Transform(uint32_t state_[4], const uint8_t block[64])
{
 uint32_t a = state_[0];
 uint32_t b = state_[1];
 uint32_t c = state_[2];
 uint32_t d = state_[3];

 uint32_t x[16];

 Decode(x, block, 64);

 //! round 1
 FF(a, b, c, d, x[0], 7, 0xd76aa478);
 FF(d, a, b, c, x[1], 12, 0xe8c7b756);
 FF(c, d, a, b, x[2], 17, 0x242070db);
 FF(b, c, d, a, x[3], 22, 0xc1bdceee);

 FF(a, b, c, d, x[4], 7, 0xf57c0faf);
 FF(d, a, b, c, x[5], 12, 0x4787c62a);
 FF(c, d, a, b, x[6], 17, 0xa8304613);
 FF(b, c, d, a, x[7], 22, 0xfd469501);

 FF(a, b, c, d, x[8], 7, 0x698098d8);
 FF(d, a, b, c, x[9], 12, 0x8b44f7af);
 FF(c, d, a, b, x[10], 17, 0xffff5bb1);
 FF(b, c, d, a, x[11], 22, 0x895cd7be);

 FF(a, b, c, d, x[12], 7, 0x6b901122);
 FF(d, a, b, c, x[13], 12, 0xfd987193);
 FF(c, d, a, b, x[14], 17, 0xa679438e);
 FF(b, c, d, a, x[15], 22, 0x49b40821);

 //! round 2
 GG(a, b, c, d, x[1], 5, 0xf61e2562);
 GG(d, a, b, c, x[6], 9, 0xc040b340);
 GG(c, d, a, b, x[11], 14, 0x265e5a51);
 GG(b, c, d, a, x[0], 20, 0xe9b6c7aa);

 GG(a, b, c, d, x[5], 5, 0xd62f105d);
 GG(d, a, b, c, x[10], 9, 0x2441453);
 GG(c, d, a, b, x[15], 14, 0xd8a1e681);
 GG(b, c, d, a, x[4], 20, 0xe7d3fbc8);

 GG(a, b, c, d, x[9], 5, 0x21e1cde6);
 GG(d, a, b, c, x[14], 9, 0xc33707d6);
 GG(c, d, a, b, x[3], 14, 0xf4d50d87);
 GG(b, c, d, a, x[8], 20, 0x455a14ed);

 GG(a, b, c, d, x[13], 5, 0xa9e3e905);
 GG(d, a, b, c, x[2], 9, 0xfcefa3f8);
 GG(c, d, a, b, x[7], 14, 0x676f02d9);
 GG(b, c, d, a, x[12], 20, 0x8d2a4c8a);

 //! round 3
 HH(a, b, c, d, x[5], 4, 0xfffa3942);
 HH(d, a, b, c, x[8], 11, 0x8771f681);
 HH(c, d, a, b, x[11], 16, 0x6d9d6122);
 HH(b, c, d, a, x[14], 23, 0xfde5380c);

 HH(a, b, c, d, x[1], 4, 0xa4beea44);
 HH(d, a, b, c, x[4], 11, 0x4bdecfa9);
 HH(c, d, a, b, x[7], 16, 0xf6bb4b60);
 HH(b, c, d, a, x[10], 23, 0xbebfbc70);

 HH(a, b, c, d, x[13], 4, 0x289b7ec6);
 HH(d, a, b, c, x[0], 11, 0xeaa127fa);
 HH(c, d, a, b, x[3], 16, 0xd4ef3085);
 HH(b, c, d, a, x[6], 23, 0x4881d05);

 HH(a, b, c, d, x[9], 4, 0xd9d4d039);
 HH(d, a, b, c, x[12], 11, 0xe6db99e5);
 HH(c, d, a, b, x[15], 16, 0x1fa27cf8);
 HH(b, c, d, a, x[2], 23, 0xc4ac5665);

 //! round 4
 II(a, b, c, d, x[0], 6, 0xf4292244);
 II(d, a, b, c, x[7], 10, 0x432aff97);
 II(c, d, a, b, x[14], 15, 0xab9423a7);
 II(b, c, d, a, x[5], 21, 0xfc93a039);

 II(a, b, c, d, x[12], 6, 0x655b59c3);
 II(d, a, b, c, x[3], 10, 0x8f0ccc92);
 II(c, d, a, b, x[10], 15, 0xffeff47d);
 II(b, c, d, a, x[1], 21, 0x85845dd1);

 II(a, b, c, d, x[8], 6, 0x6fa87e4f);
 II(d, a, b, c, x[15], 10, 0xfe2ce6e0);
 II(c, d, a, b, x[6], 15, 0xa3014314);
 II(b, c, d, a, x[13], 21, 0x4e0811a1);

 II(a, b, c, d, x[4], 6, 0xf7537e82);
 II(d, a, b, c, x[11], 10, 0xbd3af235);
 II(c, d, a, b, x[2], 15, 0x2ad7d2bb);
 II(b, c, d, a, x[9], 21, 0xeb86d391);

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

MD5::MD5()
{
 count_[0] = 0;
 count_[1] = 0;

 state_[0] = 0x67452301;
 state_[1] = 0xEFCDAB89;
 state_[2] = 0x98BADCFE;
 state_[3] = 0x10325476;
}

void MD5::update(const void* plain_text_ptr, size_t plain_text_len)
{
 TBOX_ASSERT(plain_text_ptr != nullptr);
 TBOX_ASSERT(!is_finished_);

 //! index:当前状态的位数对64取余,其单位是字节
 uint32_t index = (count_[0] >> 3) & 0x3F;

 uint32_t partlen = 64 - index;

 //! 下面代码是解决一个unsignde int 无法储存极大数据导致溢出的问题
 //! 当前位数加上新添加的位数,由于plain_text_len是以字节为单位,所以其转换为位数
 //! 相当于count_[0] += plain_text_len*8;
 count_[0] += plain_text_len << 3;

 //! 当其出现溢出的情况时,通过以下操作把两个16位的数连在一块,生成一个
 //! 32位的二进制数串,从而扩大其储存范围
 if (count_[0] < (plain_text_len << 3))
 count_[1]++;

 count_[1] += plain_text_len >> 29;

 const uint8_t *plain_text_u8_ptr = static_cast<const uint8_t*>(plain_text_ptr);

 uint32_t i = 0;
 //! 当其输入字节数的大于其可以补足64字节的字节数,进行补足
 if (plain_text_len >= partlen) {
 //! 向buffer_中补足partlen个字节,使其到达64字节
 memcpy(buffer_ + index, plain_text_u8_ptr, partlen);

 //! buffer_达到64字节512位,则把其作为一组进行运算
 Transform(state_, buffer_);

 //! 如果输入的数据还可以组成多个64字节,则把其可以组成
 //! 的作为若干组进行运算
 for (i = partlen; i + 64 <= plain_text_len; i += 64)
 Transform(state_, plain_text_u8_ptr + i);

 //! 恢复0值,照应 下面 把输入 剩余字节(不能组成64字节组) 储存的操作
 index = 0;
 }

 //! 放置剩余数据
 memcpy(buffer_ + index, plain_text_u8_ptr + i, plain_text_len - i);
}

void MD5::finish(uint8_t digest[16])
{
 TBOX_ASSERT(digest != nullptr);

 uint32_t index = (count_[0] >> 3) & 0x3F;
 //! 因为要填充满足使其位长对512求余的结果等于448(56位)
 //! 所以当其所剩余的数小于56字节,则填充56-index字节,
 //! 否则填充120-index字节
 //! 这里padlen代表其所需填充的字节
 uint32_t padlen = (index < 56) ? (56 - index) : (120 - index);

 //! 然后,在这个结果后面附加一个以64位二进制表示的填充前数据长度。
 //! 把填充前数据数据长度转换后放到bit字符数组中
 uint8_t bits[8];
 Encode(bits, count_, 8);

 //! 根据已经存储好的数组PADDING,在信息的后面填充一个1和无数个0,
 //! 直到满足上面的条件时才停止用0对信息的填充
 //! 其填充后进行了一系列的加密操作,其定剩余48个字节
 update(PADDING, padlen);

 //! 在最后添加进8个字节的数据长度信息,最后凑成一组,进行一次加密处理
 update(bits, 8);

 //! 把最终得到的加密信息变成字符输出,共16字节
 Encode(digest, state_, 16);

 is_finished_ = true;
}

}
}