暴力破解密码算法-JS

最新推荐文章于 2025-10-01 16:00:01 发布
原创 最新推荐文章于 2025-10-01 16:00:01 发布 · 5.8k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

本文详细解析了JavaScript中用于密码保护的MD5加密算法，并探讨了针对此类加密的破解策略，帮助读者理解其工作原理及安全性。
  1. md5加密算法
var getMd5 = function (string) {

    function RotateLeft(lValue, iShiftBits) {
        return (lValue << iShiftBits) | (lValue >>> (32-iShiftBits));
    }

    function 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 F(x,y,z) { return (x & y) | ((~x) & z); }
    function G(x,y,z) { return (x & z) | (y & (~z)); }
    function H(x,y,z) { return (x ^ y ^ z); }
    function I(x,y,z) { return (y ^ (x | (~z))); }

    function FF(a,b,c,d,x,s,ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    };

    function GG(a,b,c,d,x,s,ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    };

    function HH(a,b,c,d,x,s,ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    };

    function II(a,b,c,d,x,s,ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    };

    function 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 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 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 = Utf8Encode(string);

    x = 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=FF(a,b,c,d,x[k+0], S11,0xD76AA478);
        d=FF(d,a,b,c,x[k+1], S12,0xE8C7B756);
        c=FF(c,d,a,b,x[k+2], S13,0x242070DB);
        b=FF(b,c,d,a,x[k+3], S14,0xC1BDCEEE);
        a=FF(a,b,c,d,x[k+4], S11,0xF57C0FAF);
        d=FF(d,a,b,c,x[k+5], S12,0x4787C62A);
        c=FF(c,d,a,b,x[k+6], S13,0xA8304613);
        b=FF(b,c,d,a,x[k+7], S14,0xFD469501);
        a=FF(a,b,c,d,x[k+8], S11,0x698098D8);
        d=FF(d,a,b,c,x[k+9], S12,0x8B44F7AF);
        c=FF(c,d,a,b,x[k+10],S13,0xFFFF5BB1);
        b=FF(b,c,d,a,x[k+11],S14,0x895CD7BE);
        a=FF(a,b,c,d,x[k+12],S11,0x6B901122);
        d=FF(d,a,b,c,x[k+13],S12,0xFD987193);
        c=FF(c,d,a,b,x[k+14],S13,0xA679438E);
        b=FF(b,c,d,a,x[k+15],S14,0x49B40821);
        a=GG(a,b,c,d,x[k+1], S21,0xF61E2562);
        d=GG(d,a,b,c,x[k+6], S22,0xC040B340);
        c=GG(c,d,a,b,x[k+11],S23,0x265E5A51);
        b=GG(b,c,d,a,x[k+0], S24,0xE9B6C7AA);
        a=GG(a,b,c,d,x[k+5], S21,0xD62F105D);
        d=GG(d,a,b,c,x[k+10],S22,0x2441453);
        c=GG(c,d,a,b,x[k+15],S23,0xD8A1E681);
        b=GG(b,c,d,a,x[k+4], S24,0xE7D3FBC8);
        a=GG(a,b,c,d,x[k+9], S21,0x21E1CDE6);
        d=GG(d,a,b,c,x[k+14],S22,0xC33707D6);
        c=GG(c,d,a,b,x[k+3], S23,0xF4D50D87);
        b=GG(b,c,d,a,x[k+8], S24,0x455A14ED);
        a=GG(a,b,c,d,x[k+13],S21,0xA9E3E905);
        d=GG(d,a,b,c,x[k+2], S22,0xFCEFA3F8);
        c=GG(c,d,a,b,x[k+7], S23,0x676F02D9);
        b=GG(b,c,d,a,x[k+12],S24,0x8D2A4C8A);
        a=HH(a,b,c,d,x[k+5], S31,0xFFFA3942);
        d=HH(d,a,b,c,x[k+8], S32,0x8771F681);
        c=HH(c,d,a,b,x[k+11],S33,0x6D9D6122);
        b=HH(b,c,d,a,x[k+14],S34,0xFDE5380C);
        a=HH(a,b,c,d,x[k+1], S31,0xA4BEEA44);
        d=HH(d,a,b,c,x[k+4], S32,0x4BDECFA9);
        c=HH(c,d,a,b,x[k+7], S33,0xF6BB4B60);
        b=HH(b,c,d,a,x[k+10],S34,0xBEBFBC70);
        a=HH(a,b,c,d,x[k+13],S31,0x289B7EC6);
        d=HH(d,a,b,c,x[k+0], S32,0xEAA127FA);
        c=HH(c,d,a,b,x[k+3], S33,0xD4EF3085);
        b=HH(b,c,d,a,x[k+6], S34,0x4881D05);
        a=HH(a,b,c,d,x[k+9], S31,0xD9D4D039);
        d=HH(d,a,b,c,x[k+12],S32,0xE6DB99E5);
        c=HH(c,d,a,b,x[k+15],S33,0x1FA27CF8);
        b=HH(b,c,d,a,x[k+2], S34,0xC4AC5665);
        a=II(a,b,c,d,x[k+0], S41,0xF4292244);
        d=II(d,a,b,c,x[k+7], S42,0x432AFF97);
        c=II(c,d,a,b,x[k+14],S43,0xAB9423A7);
        b=II(b,c,d,a,x[k+5], S44,0xFC93A039);
        a=II(a,b,c,d,x[k+12],S41,0x655B59C3);
        d=II(d,a,b,c,x[k+3], S42,0x8F0CCC92);
        c=II(c,d,a,b,x[k+10],S43,0xFFEFF47D);
        b=II(b,c,d,a,x[k+1], S44,0x85845DD1);
        a=II(a,b,c,d,x[k+8], S41,0x6FA87E4F);
        d=II(d,a,b,c,x[k+15],S42,0xFE2CE6E0);
        c=II(c,d,a,b,x[k+6], S43,0xA3014314);
        b=II(b,c,d,a,x[k+13],S44,0x4E0811A1);
        a=II(a,b,c,d,x[k+4], S41,0xF7537E82);
        d=II(d,a,b,c,x[k+11],S42,0xBD3AF235);
        c=II(c,d,a,b,x[k+2], S43,0x2AD7D2BB);
        b=II(b,c,d,a,x[k+9], S44,0xEB86D391);
        a=AddUnsigned(a,AA);
        b=AddUnsigned(b,BB);
        c=AddUnsigned(c,CC);
        d=AddUnsigned(d,DD);
    }

    var temp = WordToHex(a)+WordToHex(b)+WordToHex(c)+WordToHex(d);

    return temp.toLowerCase();
}
  1. 破解算法
 var lowerCaseC = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n"];
var upperCaseC = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"];
var numN = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];

var sourceSeq = null;
var md5Seq = "0659c7992e268962384eb17fafe88364";
var useC = [];
var findFlag = false;
useC.push.apply(useC, lowerCaseC);
useC.push.apply(useC, upperCaseC);
useC.push.apply(useC, numN); 

var indexArr = [];
var testStr = null;
var j = 0;
var calculateCount = 0;
console.log("start time: " + new Date());
for(var pwdLength = 6; pwdLength <= 6; pwdLength++) {
    indexArr = [];
    for(var i=0; i < pwdLength; i++) { //初始化索引
        indexArr[i] = 0;
    }

    //console.log("start-" + indexArr[0] + ", " + indexArr[1] + ", " + indexArr[2] + ", " +indexArr[3] + ", " + indexArr[4] + ", " + indexArr[5]);
    while(indexArr[0] < useC.length - 10) {
        testStr = "";
        for(var i=0; i<pwdLength; i++) { //构建字符串
            testStr += useC[indexArr[i]];
        }
        console.log(testStr);

        /*if(getMd5(testStr) == md5Seq) {
            findFlag = true;
            console.log("find password: " + testStr);
            break;
        }*/
        calculateCount++;
        //$("body div").html("calculate count: " + calculateCount);

        j = pwdLength -1;
        if(indexArr[j] >= useC.length - 1) {
            indexArr[j] = 0;
                indexArr[j-1]++;
            while(--j >= 0) {
                if(indexArr[j] > useC.length - 1) {
                    if(j > 0) {
                        indexArr[j] = 0;
                        indexArr[j-1]++;
                    }
                } else {
                    break;
                }
            }
        } else {
            indexArr[j]++;
        }

        console.log("count:[" + calculateCount + "] " + indexArr[0] + ", " + indexArr[1] + ", " + indexArr[2] + ", " +indexArr[3] + ", " + indexArr[4] + ", " + indexArr[5]);
    }

    if(findFlag) {
        break;
    }
}
console.log("end time: " + new Date());
jsEncrypter--一次js前端加密的暴力破解
n0d_xy的博客
04-28 2049
疑似存在用户名枚举，但网站用户名使用前端js加密，然后再传输。枚举payload遇到加密问题。 一番针扎后以后遇到这种事只需第9、第7、第10步骤即可 1、下载 jsEncrypter： https://github.com/c0ny1/jsEncrypter phantomJS ：http://phantomjs.org/download.html 2、使用idea导入jsEncry...
暴力破解算法
weixin_30929195的博客
01-23 576
暴力破解是一种基础算法，一半只涉及循环及基本运算。 3层for循环寻找1000内可构成的平方数 #include<stdio.h> int main() { int i,a,b; for(i=1;i<10;i++) { for(b=1;b<...
DVWA靶场之一：暴力破解（Brute Force）
最新发布
YoungLime的博客
10-01 301
user$pass$user$avatar首先帐号和密码是通过GET方式传递给服务器的，其次可以看到存在SQL注入问题，输入没有经过过滤，但是回显仅仅显示$user，成功除了一张图片及其地址，你是看不到查询结果的，说明是盲注。然后用test’ --测一下，即没有报错，说明存在SQL注入问题。
javascript leetcode第四题的暴力破解
qq_44845332的博客
02-26 501
4. 寻找两个正序数组的中位数 给定两个大小分别为m和n的正序（从小到大）数组nums1和nums2。请你找出并返回这两个正序数组的中位数。 算法的时间复杂度应该为O(log (m+n))。 ...
（一）算法之暴力破解法
啊哈程序
05-07 3990
1.暴力破解 public class Baolipojie {      /**       * 鸡兔同笼       * 设鸡为x 兔为y       */      @Test      public void test1() {            int HEAD = 50;            int FOOT = 120;            for (
精选资源
scrypt-js:基于scrypt密码的密钥派生功能的纯JavaScript实现
05-02
密码的密钥派生函数（pbkdf）是一种旨在防止暴力破解的算法，该算法将人类可读的密码转换为固定长度的字节数组，然后可以将其用作对称分组密码，私钥等的密钥。等等 特征： 非阻塞-为事件循环中的其他事件提供运行...
pikachu练习---暴力破解-验证码
ptxybird的博客
06-15 2697
pikachu-暴力破解-验证码绕过及token练习
暴力破解方式
weixin_60757883的博客
04-07 2917
暴力破解漏洞介绍 暴力破解的产生是由于服务器端没有做限制，导致攻击者可以通过暴力的手段暴力破解的产生是由于破解所需信息，如用户名、密码、验证码等。暴力破解需要一个庞大的字典，如 4 位数字的验证码，那么暴力破解的范围就是 0000~9999，暴力破解的关键在于字典的大小 二．暴力破解靶场实战 漏洞描述： 由于没有对登录页面进行相关的人机验证机制，如无验证码、有验证码但可重复利用以及无登录错误次数登录账号和密码。限制等，导致攻击者可通过暴力破解获取用户 修复建议 1、如果用户登录次数超过
基于彩虹表碰撞法破解SHA/MD5等hash加密——半非暴力破解哈希逆运算
ctbinzi的专栏
12-26 4363
网上查了一下彩虹表攻击相关资料，发现大部分文章说得都不太清楚，于是扒了Philippe Oechslin最初的paper《Making a Faster Cryptanalytic Time-Memory Trade-Of》，再结合开源项目RainbowCrack-NG（），把整个彩虹表攻击原理及其实现方法做了梳理，方便大家理解。
pikachu-暴力破解
weixin_50342860的博客
07-11 1696
pikachu-暴力破解基于表单的暴力破解暴力破解概述暴力破解测试防暴力破解的措施总结验证码绕过（on sever）验证码绕过（on sever）测试验证码绕过（on client）验证码绕过（on client）测试token防爆破token防爆破概述token防爆破测试 基于表单的暴力破解 暴力破解概述 攻击者在不知道目标系统的账号密码的情况下，通过自动化工具和一个强大的字典进行连续性尝试的登录，碰撞出一些有效的账号密码 暴力破解测试 一、打开pikachu靶场 输入用户名和密码----Login（
4位数字解密.vi
09-06
破解Labview程序四位数字保护密码程序，感兴趣可自行开发多位密码，穷举法，密码位数越多，解密时间越长！
24游戏 js 暴力破解
u013276512的博客
04-25 718
最近地铁上没啥事，玩了玩 24 游戏。游戏定义很简单，四个100以内整数，通过三次四则运算，结果等于24。 忙中偷闲用 js 开发写了一个暴力破解的方法。代码贴一下。 <html> <body> <script> function calculation(a, b, c, d){ //符号整理 var charsAll = []; var ch...
移动零 Javascript 暴力解法（源码）
小助手爱编程
08-19 218
/** * @param {number[]} nums * @return {void} Do not return anything, modify nums in-place instead. */ var moveZeroes = function (nums) { var i = 0; var j = 0; while (i < nums.length) { if (nums[i] != 0) { [n...
暴力破解练习（四）排列组合模板一
Lawrence_121
03-12 765
问题 1.已知不同字母构成的串，求它的全排列#include&lt;iostream&gt; #include&lt;string&gt; using namespace std; void f(char *a, int k) { if (k == strlen(a) - 1) { //将字符数组转换为字符串 string b; b = a; cout &lt;&lt; ...
Web暴力破解--前端JS表单加密进行爆破
weixin_33688840的博客
06-09 215
0x01 前言 　　常见的js实现加密的方式有：md5、base64、shal，写了一个简单的demo作为测试。 0x02 代码 login.html <!DOCTYPE HTML> <html> <head> <meta charset="utf-8"> <title>用户...
JS逆向案例：破解登录密码
算法channel
06-21 3568
本人不是专业IT人员，但是对python爬虫这块非常感兴趣，在抖音上看了zhen老师的python全栈直播课程，果断选择加入zhen老师的VIP大家庭，给zhen老师投稿发文章还能挣钱，50元。废话不多说，进入主题。最近在学习JS逆向方面的知识，由于之前做过12306的自动抢票软件，因此对12306情有独钟????，接下来就给大家介绍一下12306用户登录密码的参数破解办法。首...
【js逆向】md5加密参数破解
philosophy
06-29 6311
md5:消息摘要算法（英文：MD5 Message-Digest Algorithm ），一种被广泛使用的密码散列函数，可以产生一个128位（16字节）的散列值。加密算法不可逆，通过暴力穷举法破解，以及网站接口实现解密。 js逆向中，可以通过搜索MD5关键字查找加密位置。 python实现MD5加密: 方法一： 方法二： 输出结果都为：进入登录窗口，打开开发者工具，输入账号密码，点击登录进行抓包： 网站地址：https://www.zhaoxi.net/ 在开发者工具中Network面板可以看到登录提交..
JavaScript实现MD5、AES-CBC加密解密
小龙在线
07-13 1529
CryptoJS是用JavaScript编写的加解密包，支持生成哈希、AES加密解密、多种编码方式。
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值