mirror of
https://github.com/bacher09/pwgen-for-bios.git
synced 2024-09-19 23:38:56 -04:00
1042 lines
31 KiB
JavaScript
1042 lines
31 KiB
JavaScript
/* May be need add 51,52 and 53 symbol */
|
|
var keyboardDict = { 2: '1', 3: '2', 4: '3', 5: '4', 6: '5', 7: '6', 8: '7', 9: '8', 10: '9', 11: '0',
|
|
16: 'q', 17: 'w', 18: 'e', 19: 'r', 20: 't', 21: 'y', 22: 'u', 23: 'i', 24: 'o', 25: 'p',
|
|
30: 'a', 31: 's', 32: 'd', 33: 'f', 34: 'g', 35: 'h', 36: 'j', 37: 'k', 38: 'l',
|
|
44: 'z', 45: 'x', 46: 'c', 47: 'v', 48: 'b', 49: 'n', 50: 'm' };
|
|
|
|
var SONY = 'sony';
|
|
var SAMSUNG = 'samsung';
|
|
var PHOENIX = 'phoenix';
|
|
var HP_COMPAQ = 'hp_compaq_phoenix';
|
|
var FSI_PHOENIX = 'fsi_phoenix';
|
|
var FSI_L_PHOENIX = 'fsi_l_phoenix';
|
|
var FSI_P_PHOENIX = 'fsi_p_phoenix';
|
|
var FSI_S_PHOENIX = 'fsi_s_phoenix';
|
|
var FSI_X_PHOENIX = 'fsi_x_phoenix';
|
|
var INSYDE = 'insyde';
|
|
var HP_MINI = 'hp_mini';
|
|
var FSI_20_DEC_NEW = 'fsi_20_dec_new';
|
|
var FSI_20_DEC_OLD = 'fsi_20_dec_old';
|
|
var FSI_HEX = 'fsi_hex';
|
|
var DELL_TAG = 'dell_tag';
|
|
var DELL_HDD_NEW = 'dell_hdd_new';
|
|
var DELL_HDD_OLD = 'dell_hdd_old';
|
|
|
|
|
|
var DELL_SERIES_PREFIX = ['595B','D35B','2A7B','A95B'];
|
|
|
|
|
|
var encscans = [0x05,0x10,0x13,0x09,0x32,0x03,0x25,0x11,0x1F,0x17,0x06,
|
|
0x15,0x30,0x19,0x26,0x22,0x0A,0x02,0x2C,0x2F,0x16,0x14,0x07,
|
|
0x18,0x24,0x23,0x31,0x20,0x1E,0x08,0x2D,0x21,0x04,0x0B,0x12,
|
|
0x2E];
|
|
|
|
|
|
|
|
var scancods = "\00\0331234567890-=\010\011qwertyuiop[]\015\377asdfghjkl;'`\377\\zxcvbnm,./";
|
|
|
|
var encData = [ 0x67452301 | 0, // For bit alignment
|
|
0xEFCDAB89 | 0,
|
|
0x98BADCFE | 0,
|
|
0x10325476 | 0];
|
|
|
|
var MD5magic_o = [
|
|
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
|
|
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
|
|
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
|
|
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
|
|
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
|
|
0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
|
|
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
|
|
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
|
|
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
|
|
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
|
|
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
|
|
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
|
|
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
|
|
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
|
|
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
|
|
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
|
|
];
|
|
|
|
function CorectBits(arr){
|
|
if(typeof(arr) == 'object'){
|
|
for(var i = 0;i<arr.length;i++){
|
|
arr[i] = arr[i] | 0;
|
|
}
|
|
return arr;
|
|
} else {
|
|
return arr | 0;
|
|
}
|
|
}
|
|
|
|
var MD5magic = CorectBits(MD5magic_o);
|
|
/* Convert signed int to unsined like in C */
|
|
function SignedToUnsigned(num){
|
|
return num >>> 0;
|
|
}
|
|
|
|
/* Keys function for hashArray for compability
|
|
* with browsers witch does't have keys function */
|
|
if(typeof(Object.keys) == 'undefined'){
|
|
Object.keys = function (hash){
|
|
var mkeys = [];
|
|
for(var i in hash) if (hash.hasOwnProperty(i)){
|
|
mkeys.push(i);
|
|
}
|
|
return mkeys;
|
|
};
|
|
}
|
|
var keys = Object.keys;
|
|
|
|
/* values function for hashArray for compability
|
|
* with browsers witch does't have values function */
|
|
if(typeof(values) == 'undefined'){
|
|
values = function (hash){
|
|
var mvalues = [];
|
|
for(var i in hash) if (hash.hasOwnProperty(i)){
|
|
mvalues.push(hash[i]);
|
|
}
|
|
return mvalues;
|
|
};
|
|
}
|
|
|
|
Array.prototype.swap = function (x,y) {
|
|
var b = this[x];
|
|
this[x] = this[y];
|
|
this[y] = b;
|
|
return this;
|
|
}
|
|
|
|
if(typeof(String.prototype.trim) === "undefined"){
|
|
String.prototype.trim = function() {
|
|
return String(this).replace(/^\s+|\s+$/g, '');
|
|
};
|
|
}
|
|
|
|
function min(x, y){
|
|
if (x < y){
|
|
return x;
|
|
}
|
|
return y;
|
|
}
|
|
|
|
function CreateHashTable2(mkeys, mvalues){
|
|
var k = min(mkeys.length, mvalues.length);
|
|
var hash = new Object();
|
|
for(var i=0;i<k;i++){
|
|
hash[mkeys[i]] = mvalues[i];
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
function CreateHashTable3(arr){
|
|
var hash = new Object();
|
|
for(var i=0;i<arr.length;i++){
|
|
hash[arr[i][0]] = arr[i][1];
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
function CreateHashTable(a, b){
|
|
return (typeof(b) =="undefined") ? CreateHashTable3(a)
|
|
: CreateHashTable2(a,b);
|
|
}
|
|
|
|
function ord(str){
|
|
return str.charCodeAt(0);
|
|
}
|
|
function chr(ascii_code){
|
|
return String.fromCharCode(ascii_code);
|
|
}
|
|
|
|
|
|
/* Integer divide */
|
|
function div(a, b){
|
|
return a / b - a % b / b;
|
|
}
|
|
|
|
|
|
function copy_array(ar){
|
|
var temp_arr = [];
|
|
for(var i=0;i<ar.length;i++){
|
|
temp_arr[i] = ar[i];
|
|
}
|
|
return temp_arr;
|
|
}
|
|
|
|
function StrintToArray(str){
|
|
var arr = [];
|
|
if(typeof(str)=="object"){
|
|
return str;
|
|
}
|
|
for(var i=0;i<str.length;i++){
|
|
arr[i] = str.charCodeAt(i);
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
function toByte(arr){
|
|
for(var i=0;i<arr.length;i++){
|
|
arr[i] = arr[i] & 0xFF;
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
|
|
function ByteArrToIntArr(b_arr){
|
|
var k = b_arr.length >> 2;
|
|
var ret_arr = [];
|
|
for(var i=0;i<=k;i++){
|
|
ret_arr[i] = b_arr[i*4] | (b_arr[i*4+1] << 8) |
|
|
(b_arr[i*4+2] << 16) |
|
|
(b_arr[i*4+3] << 24);
|
|
}
|
|
return ret_arr;
|
|
}
|
|
|
|
function StringToIntArr(str){
|
|
return (typeof(str)=="object") ? ByteArrToIntArr(str) :
|
|
ByteArrToIntArr(StrintToArray(str));
|
|
}
|
|
|
|
function IntToByteArr(num){
|
|
var ret_arr = [];
|
|
ret_arr[0] = (num & 0xFF );
|
|
ret_arr[1] = ((num >> 8) & 0xFF );
|
|
ret_arr[2] = ((num >> 16) & 0xFF );
|
|
ret_arr[3] = ((num >> 24) & 0xFF );
|
|
return ret_arr
|
|
}
|
|
|
|
function IntArrToByteArr(int_arr){
|
|
var ret_arr = [];
|
|
for(var i=0;i<int_arr.length;i++){
|
|
ret_arr = ret_arr.concat(IntToByteArr(int_arr[i]));
|
|
}
|
|
return ret_arr;
|
|
}
|
|
|
|
function fill_zero(arr, from, to){
|
|
for(var i=from;i<to;i++){
|
|
arr[i] = 0;
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
/* Without zero */
|
|
var keyboardDictDigits = CreateHashTable(keys(keyboardDict).slice(0,9),
|
|
values(keyboardDict).slice(0,9));
|
|
|
|
var keyboardDictChars = CreateHashTable(keys(keyboardDict).slice(10,36),
|
|
values(keyboardDict).slice(10,36));
|
|
|
|
|
|
/* Decode Keyboard code to Ascii symbol */
|
|
function keyboardEncToAscii(inKey){
|
|
var out= "";
|
|
for(var i=0;i<inKey.length;i++){
|
|
if (inKey[i] == 0) return out;
|
|
if (inKey[i] in keyboardDict){
|
|
out += keyboardDict[inKey[i]];
|
|
} else {
|
|
return ""
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
|
|
|
|
/* The phoenix implementation of the CRC-16 contains a rather severe bug
|
|
* quartering the image space of the function: both the first and second MSB
|
|
* are always zero regardless of the input.
|
|
* For a working implementation, you'd have to change the polynom from 0x2001
|
|
* to e.g. 0xA001.*/
|
|
function badCRC16(pwd, salt){
|
|
salt = (typeof(salt) == 'undefined') ? 0 : salt;
|
|
var hash = salt;
|
|
var c = 0;
|
|
for(var c=0;c < pwd.length;c++){
|
|
hash ^= pwd[c] ;
|
|
for(var i=8;i--;){
|
|
if(hash & 1){
|
|
hash = (hash >> 1) ^ 0x2001;
|
|
} else {
|
|
hash = (hash >> 1)
|
|
}
|
|
}
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
function bruteForce(hash, salt, digitsOnly, charsOnly, minLen, maxLen){
|
|
|
|
salt = (typeof(salt) == 'undefined') ? 0 : salt;
|
|
digitsOnly = (typeof(digitsOnly) == 'undefined') ? false: digitsOnly;
|
|
charsOnly = (typeof(charsOnly) == 'undefined') ? true : charsOnly;
|
|
minLen = (typeof(minLen) == 'undefined') ? 3 : minLen;
|
|
maxLen = (typeof(maxLen) == 'undefined') ? 7 : maxLen;
|
|
|
|
var encodedPwd = [0,0,0,0,0,0,0];
|
|
|
|
if(hash > 0x3FFF){
|
|
return "Bad hash";
|
|
}
|
|
var kk = 0;
|
|
if(charsOnly==true){
|
|
var my_keyboard_dict = keyboardDictChars;
|
|
} else if(digitsOnly==true){
|
|
var my_keyboard_dict = keyboardDictDigits;
|
|
} else {
|
|
var my_keyboard_dict = keyboardDict;
|
|
}
|
|
var my_keyboard_dict_keys = keys(my_keyboard_dict);
|
|
var my_keyboard_dict_len = my_keyboard_dict_keys.length;
|
|
|
|
while(true){
|
|
var rndVal = Math.random()*my_keyboard_dict_len;
|
|
for(var i=0; i<7; i++){
|
|
var value = Math.floor(rndVal % my_keyboard_dict_len);
|
|
encodedPwd[i]= my_keyboard_dict_keys[value];
|
|
rndVal *= 7;
|
|
}
|
|
kk++;
|
|
if(kk > 50000){
|
|
return "No";
|
|
}
|
|
for(var i=minLen;i<=maxLen; i++){
|
|
if( badCRC16(encodedPwd.slice(0,i),salt) == hash){
|
|
encodedPwd = encodedPwd.slice(0,i);
|
|
return keyboardEncToAscii(encodedPwd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
function calc_in(l_arr){
|
|
return [ (l_arr[1] >> 1),
|
|
((l_arr[1] >> 6) | (l_arr[0] << 2)),
|
|
(l_arr[0] >> 3) ];
|
|
}
|
|
|
|
function begin_calc(serial, s_arr){
|
|
var ret_arr = [];
|
|
if(typeof(serial)=="string"){
|
|
serial = StrintToArray(serial);
|
|
}
|
|
|
|
ret_arr[0] = serial[ s_arr[3] ];
|
|
ret_arr[1] = ( serial[ s_arr[3] ] >> 5) |
|
|
(( (serial[ s_arr[2] ] >> 5) | (serial[ s_arr[2] ] << 3))
|
|
& 0xF1);
|
|
ret_arr[2] = (serial[ s_arr[2] ] >> 2);
|
|
ret_arr[3] = (serial[ s_arr[2] ] >> 7) | (serial[ s_arr[1] ] << 1);
|
|
ret_arr[4] = (serial[ s_arr[1] ] >> 4) | (serial[ s_arr[0] ] << 4);
|
|
|
|
ret_arr = ret_arr.concat(calc_in(serial));
|
|
|
|
return toByte(ret_arr);
|
|
}
|
|
|
|
function end_calc(serial, calced_arr, s_arr){
|
|
var r = 0;
|
|
var ret_arr = [];
|
|
for (var i=0;i<8;i++) {
|
|
r = 0xAA;
|
|
(calced_arr[i] & 1) && (r ^= serial[ s_arr[0] ]);
|
|
(calced_arr[i] & 2) && (r ^= serial[ s_arr[1] ]);
|
|
(calced_arr[i] & 4) && ( r ^= serial[ s_arr[2] ]);
|
|
(calced_arr[i] & 8) && (r ^= serial[1]);
|
|
(calced_arr[i] & 16) && (r ^= serial[0]);
|
|
|
|
ret_arr[i] = encscans[r % encscans.length];
|
|
}
|
|
return ret_arr;
|
|
}
|
|
|
|
function calc_suffix_shortcut(serial, s_arr1, s_arr2){
|
|
var serial_arr = StrintToArray(serial);
|
|
var ret_arr = begin_calc(serial_arr,s_arr1);
|
|
return end_calc(serial_arr, ret_arr, s_arr2);
|
|
}
|
|
|
|
function calc_suffix_tag(serial){
|
|
return calc_suffix_shortcut(serial, [1,2,3,4],[4,3,2]);
|
|
}
|
|
|
|
function calc_suffix_hdd_new(serial){
|
|
return calc_suffix_shortcut(serial, [1,10,9,8], [8,9,10]);
|
|
}
|
|
|
|
/* Depends only in first two chars */
|
|
function calc_suffix_hdd_old(serial){
|
|
// encscans[26], enscans[0xAA % enscans.length]
|
|
var ret_arr = [49,49,49,49,49];
|
|
var serial_arr = StrintToArray(serial);
|
|
ret_arr = ret_arr.concat(calc_in(serial_arr));
|
|
// lower bits then 5 are never change
|
|
for(var i=5;i<8;i++){
|
|
var r = 0xAA;
|
|
(ret_arr[i] & 8) && (r ^= serial[1]);
|
|
(ret_arr[i] & 16) && (r ^= serial[0]);
|
|
ret_arr[i] = encscans[ r % encscans.length];
|
|
}
|
|
return ret_arr;
|
|
}
|
|
|
|
|
|
function blockEncode(encBlock,f1, f2, f3, f4 ,f5){
|
|
var A = encData[0] | 0; // For bit alignment
|
|
var B = encData[1] | 0;
|
|
var C = encData[2] | 0;
|
|
var D = encData[3] | 0;
|
|
|
|
function rol(t, bitsrot, num){
|
|
var k = bitsrot[num >> 4][i & 3];
|
|
return (SignedToUnsigned(t)/ Math.pow(2,32 - k)) |
|
|
((SignedToUnsigned(t) << k) | 0 );
|
|
}
|
|
|
|
function f_shortcut(func, key, num){
|
|
return (A + f1(func, B, C , D, MD5magic[num] + encBlock[ key ])) | 0;
|
|
}
|
|
|
|
var S = [ [ 7, 12, 17, 22 ],
|
|
[ 5, 9, 14, 20 ],
|
|
[ 4, 11, 16, 23 ],
|
|
[ 6, 10, 15, 21 ]
|
|
];
|
|
var t;
|
|
for(i=0;i<64;i++){
|
|
switch(i >> 4){
|
|
case 0:
|
|
t = f_shortcut(f2, i & 15, i); // Use half byte
|
|
break;
|
|
case 1:
|
|
t = f_shortcut(f3, (i*5 + 1) & 15, i);
|
|
break;
|
|
case 2:
|
|
t = f_shortcut(f4, (i*3 + 5) & 15, i);
|
|
break;
|
|
case 3:
|
|
t = f_shortcut(f5, (i*7) & 15, i);
|
|
break;
|
|
}
|
|
A = D, D = C, C = B, B = (rol(t,S,i) + B) | 0;
|
|
}
|
|
|
|
return CorectBits([ A + encData[0],
|
|
B + encData[1],
|
|
C + encData[2],
|
|
D + encData[3]]);
|
|
|
|
}
|
|
|
|
function choseEncode(encBlock, serial){
|
|
|
|
function encF2(num1, num2, num3) {
|
|
return ((( num3 ^ num2) & num1) ^ num3);
|
|
}
|
|
|
|
function encF3 (num1, num2, num3) {
|
|
return ((( num1 ^ num2) & num3) ^ num2);
|
|
}
|
|
|
|
function encF4(num1, num2, num3) {return (( num2 ^ num1) ^ num3); }
|
|
|
|
function encF5(num1, num2, num3) {return (( num1 | ~num3) ^ num2); }
|
|
|
|
function encF1(func, num1,num2, num3, key){
|
|
return (func(num1,num2,num3) + key) | 0; // For bit alignment
|
|
}
|
|
|
|
// Negative functions
|
|
function encF1N(func, num1, num2, num3, key) {
|
|
return encF1(func,num1,num2, num3, -key);
|
|
}
|
|
function encF2N(num1, num2, num3){ return encF2(num1, num2, ~num3); }
|
|
function encF4N(num1, num2, num3){ return encF4(num1, ~num2, num3); }
|
|
function encF5N(num1, num2, num3){ return encF5(~num1, num2, num3); }
|
|
|
|
/* Main part */
|
|
var type = serial.substr(serial.length - 4, serial.length);
|
|
if(type == 'D35B'){
|
|
return blockEncode(encBlock, encF1, encF2, encF3, encF4, encF5);
|
|
} else {
|
|
return blockEncode(encBlock, encF1N, encF2N, encF3, encF4N, encF5N);
|
|
}
|
|
}
|
|
|
|
function answerToString(b_arr){
|
|
var r = b_arr[0] % 9;
|
|
var ret_str = "";
|
|
for(var i = 0;i<16;i++){
|
|
if( ( r <= i) && (ret_str.length < 8) ){
|
|
ret_str += scancods.charAt(encscans[b_arr[i] % encscans.length]);
|
|
}
|
|
}
|
|
return ret_str;
|
|
}
|
|
|
|
function dell_encode(in_str, cnt, serial){
|
|
in_str[cnt] = 0x80;
|
|
var encBlock = StringToIntArr(in_str);
|
|
encBlock = fill_zero(encBlock,6,16);
|
|
encBlock[14] = (cnt << 3);
|
|
|
|
return IntArrToByteArr(choseEncode(encBlock, serial));
|
|
|
|
}
|
|
|
|
/* 7 symbols + 4 symbols ( 595B, D35B, 2A7B, A95B ) */
|
|
function getBiosPwdForDellTag(serial){
|
|
var serial_arr = StrintToArray(serial);
|
|
serial_arr = serial_arr.concat(calc_suffix_tag(serial_arr));
|
|
return answerToString(dell_encode(serial_arr,23, serial));
|
|
}
|
|
|
|
/* 12 symbols + 4 symbols ( 595B, D35B, 2A7B, A95B ) */
|
|
function getBiosPwdForDellHddNew(serial){
|
|
var serial_arr = StrintToArray(serial);
|
|
serial_arr = serial_arr.concat(calc_suffix_hdd_new(serial_arr));
|
|
return answerToString(dell_encode(serial_arr,23, serial));
|
|
}
|
|
|
|
/* Depends only in first two chars
|
|
* 12 symbols */
|
|
function getBiosPwdForDellHddOld(serial){
|
|
var t_arr = calc_suffix_hdd_old(serial);
|
|
var ret_str = "";
|
|
for(var i=0;i<t_arr.length;i++){
|
|
ret_str += scancods.charAt( t_arr[i]);
|
|
}
|
|
return ret_str;
|
|
}
|
|
|
|
/* Return password for old sony laptops
|
|
* password 7 digit number like 1234567 */
|
|
function getBiosPwdForSony(serial){
|
|
if(serial.length != 7){
|
|
return ""
|
|
}
|
|
var table = "0987654321876543210976543210982109876543109876543221098765436543210987";
|
|
var pos = 0;
|
|
var code= "";
|
|
for(var i=0;i<serial.length;i++){
|
|
code += table.charAt(parseInt(serial.charAt(i))+10*pos);
|
|
pos++;
|
|
}
|
|
return code;
|
|
}
|
|
|
|
/* Return password for samsung laptops
|
|
* 12 or 18 hexhecimal digits like 07088120410C0000 */
|
|
function getBiosPwdForSamsung(serial){
|
|
|
|
var rotationMatrix1 = [7, 1, 5, 3, 0, 6, 2, 5, 2, 3, 0, 6, 1, 7, 6, 1, 5, 2, 7, 1, 0, 3, 7, 6, 1, 0, 5, 2, 1, 5, 7, 3, 2, 0, 6];
|
|
|
|
var rotationMatrix2 = [1, 6, 2, 5, 7, 3, 0, 7, 1, 6, 2, 5, 0, 3, 0, 6, 5, 1, 1, 7, 2, 5, 2, 3, 7, 6, 2, 1, 3, 7, 6, 5, 0, 1, 7];
|
|
|
|
|
|
function decryptHash(hash, key, rotationMatrix){
|
|
var outhash = [];
|
|
for(var i=0;i<hash.length;i++){
|
|
outhash.push(((hash[i] << (rotationMatrix[7*key+i])) & 0xFF) | (hash[i] >> (8-rotationMatrix[7*key+i])));
|
|
}
|
|
return outhash;
|
|
}
|
|
|
|
var hash = [];
|
|
|
|
for(var i=1;i<div(serial.length,2);i++){
|
|
hash.push(parseInt(serial.charAt(2*i)+serial.charAt(2*i+1),16))
|
|
}
|
|
var key = parseInt(serial.substring(0,2), 16) % 5
|
|
|
|
var password = keyboardEncToAscii(decryptHash(hash, key, rotationMatrix1))
|
|
if(password == ""){
|
|
password = keyboardEncToAscii(decryptHash(hash, key, rotationMatrix2))
|
|
}
|
|
|
|
return password
|
|
}
|
|
|
|
/* Compute password for phoenix bios. 5 digits */
|
|
function getBiosPwdForGenericPhoenix(serial){
|
|
return bruteForce(parseInt(serial));
|
|
}
|
|
|
|
/* Compute password for phoenix bios HP/Compaq.5 digits */
|
|
function getBiosPwdForHPCompaqPhoenix(serial){
|
|
return bruteForce(parseInt(serial),17232);
|
|
}
|
|
|
|
/* Compute password for FSI phoenix bios. 5 digits */
|
|
function getBiosPwdForFsiPhoenix(serial){
|
|
return bruteForce(parseInt(serial),65,true,false,3,7);
|
|
}
|
|
|
|
/* Compute password for FSI (L model) phoenix bios. 5 digits */
|
|
function getBiosPwdForFsiLPhoenix(serial){
|
|
return bruteForce(parseInt(serial)+1,ord('L'),true,false,3,7);
|
|
}
|
|
|
|
/* Compute password for FSI (P model) phoenix bios. 5 digits */
|
|
function getBiosPwdForFsiPPhoenix(serial){
|
|
return bruteForce(parseInt(serial)+1,ord('P'),true,false,3,7);
|
|
}
|
|
|
|
/* Compute password for FSI (S model) phoenix bios. 5 digits */
|
|
function getBiosPwdForFsiSPhoenix(serial){
|
|
return bruteForce(parseInt(serial)+1,ord('S'),true,false,3,7);
|
|
}
|
|
|
|
/* Compute password for FSI (X model) phoenix bios. 5 digits */
|
|
function getBiosPwdForFsiXPhoenix(serial){
|
|
return bruteForce(parseInt(serial)+1,ord('X'),true,false,3,7);
|
|
}
|
|
|
|
/* Maybe need fixing for browsers where numbers is 32-bits */
|
|
/* Some Acer, HP laptops. 8 digit */
|
|
function getBiosPwdForInsyde(serial){
|
|
var salt = 'Iou|hj&Z';
|
|
var password = '';
|
|
var b = 0;
|
|
var a =0;
|
|
for(var i=0;i<8;i++){
|
|
b = ord(salt.charAt(i)) ^ ord(serial.charAt(i));
|
|
a = b;
|
|
//a = (a * 0x66666667) >> 32;
|
|
a = (a * 0x66666667);
|
|
a = Math.floor(a / Math.pow(2,32));
|
|
a = (a >> 2) | (a & 0xC0);
|
|
if ( a & 0x80000000 ){
|
|
a++;
|
|
}
|
|
a *= 10;
|
|
password += (b-a).toString();
|
|
}
|
|
return password
|
|
}
|
|
/* For HP/Compaq Netbooks. 10 chars */
|
|
function getBiosPwdForHpmini(serial){
|
|
var table1 = {'1': '3', '0': '1', '3': 'F', '2': '7', '5': 'Q', '4': 'V',
|
|
'7': 'X', '6': 'G', '9': 'O', '8': 'U', 'a': 'C', 'c': 'E',
|
|
'b': 'P', 'e': 'M', 'd': 'T', 'g': 'H', 'f': '8', 'i': 'Y',
|
|
'h': 'Z', 'k': 'S', 'j': 'W', 'm': '4', 'l': 'K', 'o': 'J',
|
|
'n': '9', 'q': '5', 'p': '2', 's': 'N', 'r': 'B', 'u': 'L',
|
|
't': 'A', 'w': 'D', 'v': '6', 'y': 'I', 'x': '4', 'z': '0'
|
|
};
|
|
|
|
var table2 = {'1': '3', '0': '1', '3': 'F', '2': '7', '5': 'Q', '4': 'V',
|
|
'7': 'X', '6': 'G', '9': 'O', '8': 'U', 'a': 'C', 'c': 'E',
|
|
'b': 'P', 'e': 'M', 'd': 'T', 'g': 'H', 'f': '8', 'i': 'Y',
|
|
'h': 'Z', 'k': 'S', 'j': 'W', 'm': '4', 'l': 'K', 'o': 'J',
|
|
'n': '9', 'q': '5', 'p': '2', 's': 'N', 'r': 'B', 'u': 'L',
|
|
't': 'A', 'w': 'D', 'v': '6', 'y': 'I', 'x': 'R', 'z': '0'
|
|
};
|
|
|
|
var password1 = "";
|
|
var password2 = "";
|
|
serial = serial.toLowerCase();
|
|
for(var i=0;i<serial.length;i++){
|
|
password1 += table1[serial.charAt(i)]
|
|
password2 += table2[serial.charAt(i)]
|
|
}
|
|
if(password1 == password2){
|
|
return password1.toLowerCase();
|
|
} else {
|
|
return [password1.toLowerCase(), password2.toLowerCase()];
|
|
}
|
|
}
|
|
|
|
/* For Fujinsu-Siemens. 5x4 dicimal digits */
|
|
function getBiosPwdForFsi20dec_old(serial){
|
|
|
|
function byteToChar(symbol_byte){
|
|
if(symbol_byte > 9 ){
|
|
return chr(ord('a') + symbol_byte - 10);
|
|
} else {
|
|
return chr(ord('0') + symbol_byte);
|
|
}
|
|
}
|
|
|
|
function bytesToString(bytes){
|
|
var str= "";
|
|
for(var i=0;i<bytes.length;i++){
|
|
str += byteToChar(bytes[i]);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
function codeToBytes(code){
|
|
var numbers = [parseInt(code.slice(0,5)),
|
|
parseInt(code.slice(5,10)),
|
|
parseInt(code.slice(10,15)),
|
|
parseInt(code.slice(15,20))
|
|
];
|
|
var bytes = [];
|
|
for(var i=0;i<numbers.length;i++){
|
|
bytes.push(numbers[i] % 256);
|
|
bytes.push(Math.floor(numbers[i] / 256));
|
|
}
|
|
return bytes;
|
|
}
|
|
|
|
/* op_arr - array with that operations do, ar1,ar2 - numbers */
|
|
function interleave(op_arr,ar1, ar2 ){
|
|
var arr = copy_array(op_arr);
|
|
arr[ ar1[0]] = ((op_arr[ar2[0]] >> 4) | (op_arr[ar2[3]] << 4)) & 0xFF;
|
|
arr[ ar1[1]] = ((op_arr[ar2[0]] & 0x0F) | (op_arr[ar2[3]] & 0xF0));
|
|
arr[ ar1[2]] = ((op_arr[ar2[1]] >> 4) | (op_arr[ar2[2]] << 4) & 0xFF);
|
|
arr[ ar1[3]] = (op_arr[ar2[1]] & 0x0F) | (op_arr[ar2[2]] & 0xF0);
|
|
return arr;
|
|
}
|
|
|
|
function convert_to_remainder(arr){
|
|
var temp_arr = [];
|
|
for(var i=0;i<arr.length;i++){
|
|
temp_arr[i] = arr[i] % 36;
|
|
}
|
|
return temp_arr;
|
|
}
|
|
|
|
function decryptCode_old(bytes){
|
|
var XORkey = ":3-v@e4i";
|
|
// apply XOR key
|
|
for(var i=0;i<bytes.length;i++){
|
|
bytes[i] = bytes[i] ^ ord(XORkey.charAt(i));
|
|
}
|
|
|
|
// swap two bytes
|
|
bytes.swap(2,6);
|
|
bytes.swap(3,7);
|
|
|
|
bytes = interleave(bytes, [0,1,2,3],[0,1,2,3]);
|
|
bytes = interleave(bytes, [4,5,6,7],[6,7,4,5]);
|
|
|
|
// final rotations
|
|
bytes[0] = ((bytes[0] << 3) & 0xFF) | (bytes[0] >> 5);
|
|
bytes[1] = ((bytes[1] << 5) & 0xFF) | (bytes[1] >> 3);
|
|
bytes[2] = ((bytes[2] << 7) & 0xFF) | (bytes[2] >> 1);
|
|
bytes[3] = ((bytes[3] << 4) & 0xFF) | (bytes[3] >> 4);
|
|
bytes[5] = ((bytes[5] << 6) & 0xFF) | (bytes[5] >> 2);
|
|
bytes[6] = ((bytes[6] << 1) & 0xFF) | (bytes[6] >> 7);
|
|
bytes[7] = ((bytes[7] << 2) & 0xFF) | (bytes[7] >> 6);
|
|
|
|
// len(solution space) = 10 + 26
|
|
bytes = convert_to_remainder(bytes);
|
|
|
|
return bytesToString(bytes);
|
|
}
|
|
|
|
return decryptCode_old(codeToBytes(serial));
|
|
}
|
|
|
|
/* For Fujinsu-Siemens. 5x4 dicimal digits. new */
|
|
function getBiosPwdForFSI20dec_new(serial){
|
|
var f_keys = ["4798156302", "7201593846", "5412367098", "6587249310",
|
|
"9137605284", "3974018625", "8052974163"];
|
|
|
|
var pwdHash = serial.charAt(0) + serial.charAt(2) + serial.charAt(5) +
|
|
serial.charAt(11) + serial.charAt(13) + serial.charAt(15) +
|
|
serial.charAt(16);
|
|
|
|
var masterPwd = "";
|
|
var i = 0;
|
|
for(var j=0;j<pwdHash.length;j++){
|
|
masterPwd += f_keys[i].charAt(parseInt(pwdHash.charAt(j)));
|
|
i++;
|
|
}
|
|
return masterPwd
|
|
}
|
|
|
|
/* For Fujinsu-Siemens. 5x4 dicimal digits. */
|
|
function getBiosPwdForFSI20dec(serial){
|
|
|
|
return CreateHashTable([FSI_20_DEC_NEW,FSI_20_DEC_OLD],
|
|
[getBiosPwdForFSI20dec_new(serial),getBiosPwdForFsi20dec_old(serial)]);
|
|
|
|
}
|
|
|
|
/* For Fujinsu-Siemens. 8 or 5x4 hexadecimal digits. */
|
|
function getBiosPwdForFSIhex(serial){
|
|
|
|
function generateCRC16Table(){
|
|
var table = [];
|
|
var crc = 0;
|
|
for(var i=0;i<256;i++){
|
|
crc = (i << 8);
|
|
for(var j=0;j<8;j++){
|
|
// Maybe so are batter
|
|
crc = (crc << 1);
|
|
if(crc & 0x10000){
|
|
crc = crc ^ 0x1021;
|
|
}
|
|
}
|
|
table.push(crc & 0xFFFF);
|
|
}
|
|
return table;
|
|
}
|
|
|
|
function hashToChar(hash,code, num){
|
|
return chr(code + ((hash >> num) % 16) % 10);
|
|
}
|
|
|
|
function hashToString(hash){
|
|
var a = ord('0')
|
|
return (hashToChar(hash, a, 12) +
|
|
hashToChar(hash, a, 8) +
|
|
hashToChar(hash, a, 4) +
|
|
hashToChar(hash, a, 0) );
|
|
}
|
|
|
|
function calculateHash(word, table){
|
|
var hash = 0;
|
|
var d =0;
|
|
for(var i=0;i<word.length;i++){
|
|
d = table[ (ord(word.charAt(i)) ^ (hash >> 8)) % 256 ];
|
|
hash = ((hash << 8) ^ d) & 0xFFFF ;
|
|
}
|
|
return hash
|
|
}
|
|
|
|
function decryptCode(code){
|
|
var table = generateCRC16Table();
|
|
return (hashToString(calculateHash(code.slice(0,4), table)) +
|
|
hashToString(calculateHash(code.slice(4,8), table)));
|
|
|
|
}
|
|
if (serial.length == 20){
|
|
serial = serial.slice(12,20);
|
|
}
|
|
return decryptCode(serial);
|
|
}
|
|
|
|
function has_element(element, arr){
|
|
for(var i=0;i<arr.length;i++){
|
|
if(arr[i] == element){
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* Return true of false (valid format and not) */
|
|
function numberChecker(serial, len_arr, decimal, hexdecimal){
|
|
decimal = (typeof(decimal) == 'undefined') ? true : decimal;
|
|
hexdecimal = (typeof(decimal) == 'undefined') ? false : hexdecimal;
|
|
var i =0;
|
|
if(decimal){
|
|
var code = parseInt(serial,10);
|
|
var code_len = code.toString(10).length;
|
|
} else if (hexdecimal){
|
|
var code = parseInt(serial,16);
|
|
var code_len = code.toString(16).length;
|
|
} else {
|
|
return false;
|
|
}
|
|
while(serial.charAt(i++)=='0'){
|
|
code_len++;
|
|
}
|
|
|
|
if((code != NaN) && has_element(code_len, len_arr)){
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function dellChecker(serial, len_arr, series_arr){
|
|
series_arr = (typeof(series_arr) == 'undefine') ? false : series_arr;
|
|
if(has_element(serial.length, len_arr)){
|
|
if(!series_arr) {
|
|
return true;
|
|
}
|
|
|
|
var ls = serial.length;
|
|
for(var i=0;i<series_arr.length;i++){
|
|
var l = series_arr[i].length;
|
|
if(serial.substr(ls-l,ls).toUpperCase() == series_arr[i]){
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
/* Just shortcut */
|
|
function autoCheckAndRun(serial, run_func, len_arr, decimal, hexdecimal){
|
|
if(numberChecker(serial, len_arr,decimal,hexdecimal)){
|
|
return run_func(serial);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/* Just shortcut */
|
|
function autoCheckAndRunWithKey(serial, run_func,
|
|
key, len_arr,
|
|
decimal, hexdecimal){
|
|
|
|
var res = autoCheckAndRun(serial, run_func, len_arr, decimal, hexdecimal);
|
|
if(res != false){
|
|
var r_ob = new Object();
|
|
r_ob[key]= res;
|
|
return r_ob;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function dell_serial_normalize(serial){
|
|
var l = serial.length;
|
|
var bs = l - 4;
|
|
return serial.substr(0, bs) + serial.substr(bs,l).toUpperCase();
|
|
}
|
|
|
|
/* Just shortcut */
|
|
function dellCheckAndRunWithKey(serial, run_func, key, len_arr, series){
|
|
if(dellChecker(serial, len_arr, series)){
|
|
var r_ob = new Object();
|
|
r_ob[key] = run_func(dell_serial_normalize(serial));
|
|
return r_ob;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/* Auto function return password if serial is valid,
|
|
* or false if it is bad */
|
|
function autoGetBiosPwdForSony(serial){
|
|
return autoCheckAndRunWithKey(serial, getBiosPwdForSony,SONY,
|
|
[7], true,false);
|
|
}
|
|
|
|
|
|
function autoGetBiosPwdForSamsung(serial){
|
|
return autoCheckAndRunWithKey(serial, getBiosPwdForSamsung,SAMSUNG,
|
|
[12,16,18],false,true);
|
|
}
|
|
|
|
/* Maybe create one function for Phoenix */
|
|
function autoGetBiosPwdForAllPhoenix(serial){
|
|
if(numberChecker(serial,[5],true)){
|
|
return CreateHashTable( [PHOENIX, HP_COMPAQ, FSI_PHOENIX,
|
|
FSI_L_PHOENIX,FSI_P_PHOENIX,FSI_S_PHOENIX,
|
|
FSI_X_PHOENIX
|
|
],
|
|
[getBiosPwdForGenericPhoenix(serial),
|
|
getBiosPwdForHPCompaqPhoenix(serial),
|
|
getBiosPwdForFsiPhoenix(serial),
|
|
getBiosPwdForFsiLPhoenix(serial),
|
|
getBiosPwdForFsiPPhoenix(serial),
|
|
getBiosPwdForFsiSPhoenix(serial),
|
|
getBiosPwdForFsiXPhoenix(serial)
|
|
]);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function autoGetBiosPwdForInsyde(serial){
|
|
return autoCheckAndRunWithKey(serial, getBiosPwdForInsyde,INSYDE,
|
|
[8], true);
|
|
}
|
|
|
|
function autoGetBiosPwdForHpmini(serial){
|
|
if(serial.length == 10){
|
|
return CreateHashTable([HP_MINI], [getBiosPwdForHpmini(serial)]);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function autoGetBiosPwdForFSI20dec(serial){
|
|
return autoCheckAndRun(serial, getBiosPwdForFSI20dec, [20], true);
|
|
}
|
|
|
|
function autoGetBiosPwdForFSIhex(serial){
|
|
return autoCheckAndRunWithKey(serial, getBiosPwdForFSIhex, FSI_HEX,
|
|
[8,20], false, true);
|
|
}
|
|
|
|
function autoGetBiosPwdForDellHddOld(serial){
|
|
return dellCheckAndRunWithKey(serial, getBiosPwdForDellHddOld,
|
|
DELL_HDD_OLD, [11], false);
|
|
}
|
|
|
|
/* 7 symbols + 4 symbols ( 595B, D35B, 2A7B, A95B ) */
|
|
function autoGetBiosPwdForDellTag(serial){
|
|
return dellCheckAndRunWithKey(serial, getBiosPwdForDellTag,
|
|
DELL_TAG, [11],DELL_SERIES_PREFIX);
|
|
}
|
|
|
|
|
|
function metaDellManyTag(serial, len, key, func){
|
|
if(serial.length == len){
|
|
var answ_arr = [];
|
|
for(var i=0;i<DELL_SERIES_PREFIX.length;i++){
|
|
answ_arr[i] = func(serial + DELL_SERIES_PREFIX[i]);
|
|
}
|
|
if(answ_arr.length == 0){
|
|
return false;
|
|
}
|
|
var r_ob = new Object();
|
|
r_ob[key] = answ_arr;
|
|
return r_ob;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/* 11 symbols + 4 symbols ( 595B, D35B, 2A7B, A95B ) */
|
|
function autoGetBiosPwdForDellHddNew(serial){
|
|
return dellCheckAndRunWithKey(serial, getBiosPwdForDellHddNew,
|
|
DELL_HDD_NEW, [15],DELL_SERIES_PREFIX);
|
|
}
|
|
|
|
// 7 symbols
|
|
function autoGetBiosPwdForDellTagAll(serial){
|
|
return metaDellManyTag(serial, 7, DELL_TAG, getBiosPwdForDellTag);
|
|
}
|
|
|
|
// 11 symbols
|
|
function autoGetBiosPwdForDellHddNewAll(serial){
|
|
return metaDellManyTag(serial,11,DELL_HDD_NEW,getBiosPwdForDellHddNew);
|
|
}
|
|
|
|
var arr_of_bios_pwgen_fun = [autoGetBiosPwdForSony,
|
|
autoGetBiosPwdForSamsung,
|
|
autoGetBiosPwdForAllPhoenix,
|
|
autoGetBiosPwdForInsyde,
|
|
autoGetBiosPwdForHpmini,
|
|
autoGetBiosPwdForFSI20dec,
|
|
autoGetBiosPwdForFSIhex,
|
|
autoGetBiosPwdForDellHddOld,
|
|
autoGetBiosPwdForDellTag,
|
|
autoGetBiosPwdForDellHddNew,
|
|
autoGetBiosPwdForDellTagAll,
|
|
autoGetBiosPwdForDellHddNewAll
|
|
];
|
|
|
|
function autoGetBiosPwd(serial){
|
|
var temp = "";
|
|
var ret_arr = new Object();
|
|
serial = serial.trim().replace(/-/gi,'');
|
|
for(var i=0;i< arr_of_bios_pwgen_fun.length; i++){
|
|
temp = arr_of_bios_pwgen_fun[i](serial);
|
|
if(temp != false){
|
|
for(var c in temp){
|
|
ret_arr[c] = temp[c];
|
|
}
|
|
}
|
|
}
|
|
return ret_arr;
|
|
}
|