root后打开小黄鸟登录不了

Posted 2023-04-15

root后打开小黄鸟登录不了
root 账号不能登录的解决方法

默认 系统 root 登录 图形界面，出现 登录失败。解决方法如下：

1，登录普通用户, 打开终端执行命令, 使用su root或sudo -i切换到root用户(必须)

su root
1
1
按照提示输入密码即可切换用户。

若root账户密码忘记，使用如下命令重设后再切换。

sudo passwd root
1
1
2，在终端中输入如下命令，打开文件

gedit /etc/pam.d/gdm-autologin
1
1
将打开的文件中第三行前加#，如下注释掉语句 “auth required pam_succeed_if.so user != root

quiet_success”

#%PAM-1.0
auth requisite pam_nologin.so
#auth required pam_succeed_if.so user != root quiet_success
auth optional pam_gdm.so
auth optional pam_gnome_keyring.so
auth required pam_permit.so
@include common-account

#SELinux needs to be the first session rule. This ensures that any

#lingering context has been cleared. Without this it is possible

#that a module could execute code in the wrong domain.

session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so close
session required pam_loginuid.so

#SELinux needs to intervene at login time to ensure that the process

#starts in the proper default security context. Only sessions which are

#intended to run in the user's context should be run after this.

session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so open
session optional pam_keyinit.so force revoke
session required pam_limits.so
session required pam_env.so readenv=1
session required pam_env.so readenv=1 user_readenv=1 envfile=/etc/default/locale
@include common-session
session optional pam_gnome_keyring.so auto_start
@include common-password
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
3，保存并退出,继续在终端执行

gedit /etc/pam.d/gdm-password
1
1
将打开的文件中第三行语句加#注释掉，如下

#%PAM-1.0
auth requisite pam_nologin.so
#auth required pam_succeed_if.so user != root quiet_success
@include common-auth
auth optional pam_gnome_keyring.so
@include common-account

#SELinux needs to be the first session rule. This ensures that any

#lingering context has been cleared. Without this it is possible

#that a module could execute code in the wrong domain.

session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so close
session required pam_loginuid.so

#SELinux needs to intervene at login time to ensure that the process

#starts in the proper default security context. Only sessions which are

#intended to run in the user's context should be run after this.

#pam_selinux.so changes the SELinux context of the used TTY and configures

#SELinux in order to transition to the user context with the next execve()

#call.

session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so open
session optional pam_keyinit.so force revoke
session required pam_limits.so
session required pam_env.so readenv=1
session required pam_env.so readenv=1 user_readenv=1 envfile=/etc/default/locale
@include common-session
session optional pam_gnome_keyring.so auto_start
@include common-password
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
4，保存并退出。在终端继续执行

gedit /root/.profile
1
1
将打开的文件中“mesg n 2> /dev/null || true” 改为

tty -s&&mesg n 2> /dev/null || true
1
1
5，保存并退出。

6，重启电脑，即可以root用户登录 参考技术A 默认 系统 root 登录 图形界面，出现 登录失败。解决方法如下：
1，登录普通用户, 打开终端执行命令, 使用su root或sudo -i切换到root用户(必须)
su root
按照提示输入密码即可切换用户。
若root账户密码忘记，使用如下命令重设后再切换。
sudo passwd root
2，在终端中输入如下命令，打开文件
gedit /etc/pam.d/gdm-autologin
将打开的文件中第三行前加#，如下注释掉语句 “auth required pam_succeed_if.so user != root
quiet_success”
#%PAM-1.0
auth requisite pam_nologin.so
#auth required pam_succeed_if.so user != root quiet_success
auth optional pam_gdm.so
auth optional pam_gnome_keyring.so
auth required pam_permit.so
@include common-account
#SELinux needs to be the first session rule. This ensures that any
#lingering context has been cleared. Without this it is possible
#that a module could execute code in the wrong domain.
session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so close
session required pam_loginuid.so
#SELinux needs to intervene at login time to ensure that the process
#starts in the proper default security context. Only sessions which are
#intended to run in the user's context should be run after this.
session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so open
session optional pam_keyinit.so force revoke
session required pam_limits.so
session required pam_env.so readenv=1
session required pam_env.so readenv=1 user_readenv=1 envfile=/etc/default/locale
@include common-session
session optional pam_gnome_keyring.so auto_start
@include common-password
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
3，保存并退出,继续在终端执行
gedit /etc/pam.d/gdm-password
1
1
将打开的文件中第三行语句加#注释掉，如下
#%PAM-1.0
auth requisite pam_nologin.so
#auth required pam_succeed_if.so user != root quiet_success
@include common-auth
auth optional pam_gnome_keyring.so
@include common-account
#SELinux needs to be the first session rule. This ensures that any
#lingering context has been cleared. Without this it is possible
#that a module could execute code in the wrong domain.
session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so close
session required pam_loginuid.so
#SELinux needs to intervene at login time to ensure that the process
#starts in the proper default security context. Only sessions which are
#intended to run in the user's context should be run after this.
#pam_selinux.so changes the SELinux context of the used TTY and configures
#SELinux in order to transition to the user context with the next execve()
#call.
session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so open
session optional pam_keyinit.so force revoke
session required pam_limits.so
session required pam_env.so readenv=1
session required pam_env.so readenv=1 user_readenv=1 envfile=/etc/default/locale
@include common-session
session optional pam_gnome_keyring.so auto_start
@include common-password
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
4，保存并退出。在终端继续执行
gedit /root/.profile

将打开的文件中“mesg n 2> /dev/null || true” 改为
tty -s&&mesg n 2> /dev/null || true
5，保存并退出。
6，重启电脑，即可以root用户登录 参考技术B 步骤：
本机需安装MT管理器，小黄鸟HttpCanay和安卓虚拟机vmos；
打开SSL证书设置选择导出根证书，类型System Trusted (.0)；
导出的证书储存路径为：内部储存/HttpCanary/cert/
打开虚拟机VMOS，选择文件中转站—我要导入：MT管理器+目标APP+证书；
打开并赋予MT管理器root权限，刚刚导入的证书在VMOSfiletransferstatio目录下，将其复制到VMOS系统内：/system/etc/security/cacerts/目录下即可。无法挂载可尝试re管理器挂载读写。
返回本机启动小黄鸟，目标应用-设置VMOS-开启抓包
返回虚拟机-启动目标APP 即可. 参考技术C 步骤：
本机需安装MT管理器，小黄鸟HttpCanay和安卓虚拟机vmos；
打开SSL证书设置选择导出根证书，类型System Trusted (.0)；
导出的证书储存路径为：内部储存/HttpCanary/cert/
打开虚拟机VMOS，选择文件中转站—我要导入：MT管理器+目标APP+证书；
打开并赋予MT管理器root权限，刚刚导入的证书在VMOSfiletransferstatio目录下，将其复制到VMOS系统内：/system/etc/security/cacerts/目录下即可。无法挂载可尝试re管理器挂载读写。
返回本机启动小黄鸟，目标应用-设置VMOS-开启抓包
返回虚拟机-启动目标APP 即可. 参考技术D 本机需安装MT管理器，小黄鸟HttpCanay和安卓虚拟机vmos；
打开SSL证书设置选择导出根证书，类型System Trusted (.0)；
导出的证书储存路径为：内部储存/HttpCanary/cert/
打开虚拟机VMOS，选择文件中转站—我要导入：MT管理器+目标APP+证书；
打开并赋予MT管理器root权限，刚刚导入的证书在VMOSfiletransferstatio目录下，将其复制到VMOS系统内：/system/etc/security/cacerts/目录下即可。无法挂载可尝试re管理器挂载读写。
返回本机启动小黄鸟，目标应用-设置VMOS-开启抓包
返回虚拟机-启动目标APP 即可

微信小程序快递鸟快递查询接口对接

微信小程序快递查询接口对接指南

1、登录快递鸟官网注册页面注册快递鸟账号

网址：http://www.kdniao.com/reg

2、登录快递鸟用户管理后台

网址：http://www.kdniao.com/login

注：登录快递鸟用户管理后台后获得用户ID和APIKey，此用于保证应用来源的可靠性，避免应用伪造，被不法使用。

3、进入“我的会员中心”进行实名认证

注：

3.1、认证类型、应用类型根据用户实际情况选择即可，接口返回数据与选择结果无关；

3.2、标记为*的为必填，要求上传清晰、jpg格式且小于2M的证件图片；

3.3、技术对接人信息为用户方对接工程师的信息；

3.4、如有其他疑问可进入官网加入商务合作群进行咨询。

4、认证成功后，进入“产品服务管理”，开通相关会员服务

注：

4.1、物流查询（免费版）会员套餐为免费版，有效期1年结束后，如在近3个月内有数据交互系统会自动免费续期；

4.2、如有其他疑问可进入官网加入商务合作群进行咨询。

5、开发对接

5.1、即时查询（RequestType：1002/8001）

5.1.1、请求接口之前需要先实名认证，开通相关会员服务，否则会请求失败并返回提示“未申请开通接口”；

5.1.2、接口开发可以下载“快递鸟接口技术文档”进行参考；即时查询，参考技术文档中的4.1或5.1.1部分；

5.1.3、接口开发可以下载“即时查询demo”进行参考（仅提供了.NET、Java、PHP三种语言demo）；

5.1.4、查看快递公司对应快递鸟的编码可以下载“2019快递鸟接口支持快递公司编码列表.xlsx”。

5.1.5、接入过程中如有疑问请先参考快递鸟官网常见问题进行解决（http://www.kdniao.com/help），也可以进入快递鸟官网加入技术对接群进行咨询。

注：快递鸟官网-帮助与文档地址（http://www.kdniao.com/documents）

 

开发步骤

1.  微信小程序相关

     首先要申请一个微信小程序公众号，注意不是微信公众号，然后仔细阅读小程序的框架和功能介绍。有些JS的功能小程序里是不能用的。我之前也没有做过JS，但上起手来感觉还是很快的，几乎没有太多阻碍。网上有很多教程，我就不多说了。

    网址： 微信小程序开发文档

打开微信开发者工具（下载地址附上：https://developers.weixin.qq.com/miniprogram/dev/devtools/download.html），先用微信登录，然后点小程序项目

然后我们新建一个项目，选好目录，AppID点使用测试号（自己如果注册过，用自己的也OK）

 

2. 快递查询的API接口

     注意寻找合适的API接口时，要选用支持https的访问接口，微信小程序目前仅支持https的访问。快递鸟快递API接口是支持https，你需要自己注册，获取自己的API key和商户ID。

//查物流
//快递公司和，快递单号
var logistics = ["YD","1111111111"]
//数据内容
var RequestData = "‘OrderCode‘:‘‘,‘ShipperCode‘:‘" + logistics[0] + "‘,‘LogisticCode‘:‘" + logistics[1] + "‘"
//utf-8编码的数据内容
console.log(RequestData)
var RequestDatautf = encodeURI(RequestData)
console.log("RequestDatautf:" + RequestDatautf)
//签名
console.log(RequestData + ‘apikey‘)
var DataSign = encodeURI(util.Base64((util.md5(RequestData + ‘apikey‘))))
console.log("DataSign:" + DataSign)
if (logistics != null)
wx.request(
url: ‘https://api.kdniao.com/Ebusiness/EbusinessOrderHandle.aspx‘,
data:
//数据内容(进行过url编码)
‘RequestData‘: RequestDatautf,
//电商ID
‘EBusinessID‘: ‘商户id‘,
//请求指令类型：1002
‘RequestType‘: ‘1002‘,
//数据内容签名把（请求内容（未编码）+ApiKey）进行MD5加密，然后Base64编码，最后进行URL（utf-8）编码
‘DataSign‘: DataSign,
//请求、返回数据类型： 2-json；
‘DataType‘: ‘2‘,
,
header:
‘content-type‘: ‘application/json‘
,
success: function (res)
console.log(res)
that.setData( data: res.data.Traces )

)

在util.js里加入
function Base64(input)
var output = "";
var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
var chr1, chr2, chr3 = "";
var enc1, enc2, enc3, enc4 = "";
var i = 0;
do
chr1 = input.charCodeAt(i++);
chr2 = input.charCodeAt(i++);
chr3 = input.charCodeAt(i++);
enc1 = chr1 >> 2;
enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
enc4 = chr3 & 63;
if (isNaN(chr2))
enc3 = enc4 = 64;
else if (isNaN(chr3))
enc4 = 64;

output = output + keyStr.charAt(enc1) + keyStr.charAt(enc2)
+ keyStr.charAt(enc3) + keyStr.charAt(enc4);
chr1 = chr2 = chr3 = "";
enc1 = enc2 = enc3 = enc4 = "";
while (i < input.length);
return output;

//将Base64编码字符串转换成Ansi编码的字符串
function decode64(input)
var output = "";
var chr1, chr2, chr3 = "";
var enc1, enc2, enc3, enc4 = "";
var i = 0;

if (input.length % 4 != 0)
return "";

var base64test = /[^A-Za-z0-9\+\/\=]/g;
if (base64test.exec(input))
return "";

do
enc1 = keyStr.indexOf(input.charAt(i++));
enc2 = keyStr.indexOf(input.charAt(i++));
enc3 = keyStr.indexOf(input.charAt(i++));
enc4 = keyStr.indexOf(input.charAt(i++));
chr1 = (enc1 << 2) | (enc2 >> 4);
chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
chr3 = ((enc3 & 3) << 6) | enc4;

output = output + String.fromCharCode(chr1);
if (enc3 != 64)
output += String.fromCharCode(chr2);

if (enc4 != 64)
output += String.fromCharCode(chr3);

chr1 = chr2 = chr3 = "";
enc1 = enc2 = enc3 = enc4 = "";
while (i < input.length);
return output;

function utf16to8(str)
var out, i, len, c;
out = "";
len = str.length;
for (i = 0; i < len; i++)
c = str.charCodeAt(i);
if ((c >= 0x0001) && (c <= 0x007F))
out += str.charAt(i);
else if (c > 0x07FF)
out += String.fromCharCode(0xE0 | ((c >> 12) & 0x0F));
out += String.fromCharCode(0x80 | ((c >> 6) & 0x3F));
out += String.fromCharCode(0x80 | ((c >> 0) & 0x3F));
else
out += String.fromCharCode(0xC0 | ((c >> 6) & 0x1F));
out += String.fromCharCode(0x80 | ((c >> 0) & 0x3F));


return out;

function utf8to16(str)
var out, i, len, c;
var char2, char3;

out = "";
len = str.length;
i = 0;
while (i < len)
c = str.charCodeAt(i++);
switch (c >> 4)
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
// 0xxxxxxx
out += str.charAt(i - 1);
break;
case 12: case 13:
// 110x xxxx 10xx xxxx
char2 = str.charCodeAt(i++);
out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
break;
case 14:
// 1110 xxxx 10xx xxxx 10xx xxxx
char2 = str.charCodeAt(i++);
char3 = str.charCodeAt(i++);
out += String.fromCharCode(((c & 0x0F) << 12) |
((char2 & 0x3F) << 6) |
((char3 & 0x3F) << 0));
break;


return out;

module.exports.Base64 = Base64
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
在util.js里加入
function md5(string)
function md5_RotateLeft(lValue, iShiftBits)
return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));

function md5_AddUnsigned(lX, lY)
var lX4, lY4, lX8, lY8, lResult;
lX8 = (lX & 0x80000000);
lY8 = (lY & 0x80000000);
lX4 = (lX & 0x40000000);
lY4 = (lY & 0x40000000);
lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
if (lX4 & lY4)
return (lResult ^ 0x80000000 ^ lX8 ^ lY8);

if (lX4 | lY4)
if (lResult & 0x40000000)
return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
else
return (lResult ^ 0x40000000 ^ lX8 ^ lY8);

else
return (lResult ^ lX8 ^ lY8);


function md5_F(x, y, z)
return (x & y) | ((~x) & z);

function md5_G(x, y, z)
return (x & z) | (y & (~z));

function md5_H(x, y, z)
return (x ^ y ^ z);

function md5_I(x, y, z)
return (y ^ (x | (~z)));

function md5_FF(a, b, c, d, x, s, ac)
a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_F(b, c, d), x), ac));
return md5_AddUnsigned(md5_RotateLeft(a, s), b);
;
function md5_GG(a, b, c, d, x, s, ac)
a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_G(b, c, d), x), ac));
return md5_AddUnsigned(md5_RotateLeft(a, s), b);
;
function md5_HH(a, b, c, d, x, s, ac)
a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_H(b, c, d), x), ac));
return md5_AddUnsigned(md5_RotateLeft(a, s), b);
;
function md5_II(a, b, c, d, x, s, ac)
a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_I(b, c, d), x), ac));
return md5_AddUnsigned(md5_RotateLeft(a, s), b);
;
function md5_ConvertToWordArray(string)
var lWordCount;
var lMessageLength = string.length;
var lNumberOfWords_temp1 = lMessageLength + 8;
var lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
var lWordArray = Array(lNumberOfWords - 1);
var lBytePosition = 0;
var lByteCount = 0;
while (lByteCount < lMessageLength)
lWordCount = (lByteCount - (lByteCount % 4)) / 4;
lBytePosition = (lByteCount % 4) * 8;
lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount) << lBytePosition));
lByteCount++;

lWordCount = (lByteCount - (lByteCount % 4)) / 4;
lBytePosition = (lByteCount % 4) * 8;
lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
return lWordArray;
;
function md5_WordToHex(lValue)
var WordToHexValue = "",
WordToHexValue_temp = "",
lByte, lCount;
for (lCount = 0; lCount <= 3; lCount++)
lByte = (lValue >>> (lCount * 8)) & 255;
WordToHexValue_temp = "0" + lByte.toString(16);
WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length - 2, 2);

return WordToHexValue;
;
function md5_Utf8Encode(string)
string = string.replace(/\r\n/g, "\n");
var utftext = "";
for (var n = 0; n < string.length; n++)
var c = string.charCodeAt(n);
if (c < 128)
utftext += String.fromCharCode(c);
else if ((c > 127) && (c < 2048))
utftext += String.fromCharCode((c >> 6) | 192);
utftext += String.fromCharCode((c & 63) | 128);
else
utftext += String.fromCharCode((c >> 12) | 224);
utftext += String.fromCharCode(((c >> 6) & 63) | 128);
utftext += String.fromCharCode((c & 63) | 128);


return utftext;
;
var x = Array();
var k, AA, BB, CC, DD, a, b, c, d;
var S11 = 7,
S12 = 12,
S13 = 17,
S14 = 22;
var S21 = 5,
S22 = 9,
S23 = 14,
S24 = 20;
var S31 = 4,
S32 = 11,
S33 = 16,
S34 = 23;
var S41 = 6,
S42 = 10,
S43 = 15,
S44 = 21;
string = md5_Utf8Encode(string);
x = md5_ConvertToWordArray(string);
a = 0x67452301;
b = 0xEFCDAB89;
c = 0x98BADCFE;
d = 0x10325476;
for (k = 0; k < x.length; k += 16)
AA = a;
BB = b;
CC = c;
DD = d;
a = md5_FF(a, b, c, d, x[k + 0], S11, 0xD76AA478);
d = md5_FF(d, a, b, c, x[k + 1], S12, 0xE8C7B756);
c = md5_FF(c, d, a, b, x[k + 2], S13, 0x242070DB);
b = md5_FF(b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
a = md5_FF(a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
d = md5_FF(d, a, b, c, x[k + 5], S12, 0x4787C62A);
c = md5_FF(c, d, a, b, x[k + 6], S13, 0xA8304613);
b = md5_FF(b, c, d, a, x[k + 7], S14, 0xFD469501);
a = md5_FF(a, b, c, d, x[k + 8], S11, 0x698098D8);
d = md5_FF(d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
c = md5_FF(c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
b = md5_FF(b, c, d, a, x[k + 11], S14, 0x895CD7BE);
a = md5_FF(a, b, c, d, x[k + 12], S11, 0x6B901122);
d = md5_FF(d, a, b, c, x[k + 13], S12, 0xFD987193);
c = md5_FF(c, d, a, b, x[k + 14], S13, 0xA679438E);
b = md5_FF(b, c, d, a, x[k + 15], S14, 0x49B40821);
a = md5_GG(a, b, c, d, x[k + 1], S21, 0xF61E2562);
d = md5_GG(d, a, b, c, x[k + 6], S22, 0xC040B340);
c = md5_GG(c, d, a, b, x[k + 11], S23, 0x265E5A51);
b = md5_GG(b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
a = md5_GG(a, b, c, d, x[k + 5], S21, 0xD62F105D);
d = md5_GG(d, a, b, c, x[k + 10], S22, 0x2441453);
c = md5_GG(c, d, a, b, x[k + 15], S23, 0xD8A1E681);
b = md5_GG(b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
a = md5_GG(a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
d = md5_GG(d, a, b, c, x[k + 14], S22, 0xC33707D6);
c = md5_GG(c, d, a, b, x[k + 3], S23, 0xF4D50D87);
b = md5_GG(b, c, d, a, x[k + 8], S24, 0x455A14ED);
a = md5_GG(a, b, c, d, x[k + 13], S21, 0xA9E3E905);
d = md5_GG(d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
c = md5_GG(c, d, a, b, x[k + 7], S23, 0x676F02D9);
b = md5_GG(b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
a = md5_HH(a, b, c, d, x[k + 5], S31, 0xFFFA3942);
d = md5_HH(d, a, b, c, x[k + 8], S32, 0x8771F681);
c = md5_HH(c, d, a, b, x[k + 11], S33, 0x6D9D6122);
b = md5_HH(b, c, d, a, x[k + 14], S34, 0xFDE5380C);
a = md5_HH(a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
d = md5_HH(d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
c = md5_HH(c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
b = md5_HH(b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
a = md5_HH(a, b, c, d, x[k + 13], S31, 0x289B7EC6);
d = md5_HH(d, a, b, c, x[k + 0], S32, 0xEAA127FA);
c = md5_HH(c, d, a, b, x[k + 3], S33, 0xD4EF3085);
b = md5_HH(b, c, d, a, x[k + 6], S34, 0x4881D05);
a = md5_HH(a, b, c, d, x[k + 9], S31, 0xD9D4D039);
d = md5_HH(d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
c = md5_HH(c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
b = md5_HH(b, c, d, a, x[k + 2], S34, 0xC4AC5665);
a = md5_II(a, b, c, d, x[k + 0], S41, 0xF4292244);
d = md5_II(d, a, b, c, x[k + 7], S42, 0x432AFF97);
c = md5_II(c, d, a, b, x[k + 14], S43, 0xAB9423A7);
b = md5_II(b, c, d, a, x[k + 5], S44, 0xFC93A039);
a = md5_II(a, b, c, d, x[k + 12], S41, 0x655B59C3);
d = md5_II(d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
c = md5_II(c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
b = md5_II(b, c, d, a, x[k + 1], S44, 0x85845DD1);
a = md5_II(a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
d = md5_II(d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
c = md5_II(c, d, a, b, x[k + 6], S43, 0xA3014314);
b = md5_II(b, c, d, a, x[k + 13], S44, 0x4E0811A1);
a = md5_II(a, b, c, d, x[k + 4], S41, 0xF7537E82);
d = md5_II(d, a, b, c, x[k + 11], S42, 0xBD3AF235);
c = md5_II(c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
b = md5_II(b, c, d, a, x[k + 9], S44, 0xEB86D391);
a = md5_AddUnsigned(a, AA);
b = md5_AddUnsigned(b, BB);
c = md5_AddUnsigned(c, CC);
d = md5_AddUnsigned(d, DD);

return (md5_WordToHex(a) + md5_WordToHex(b) + md5_WordToHex(c) + md5_WordToHex(d)).toLowerCase();

module.exports.md5 = md5