js逆向中常见加密/解密算法特征及其实现

常见加密、解密算法特征及实现

  • base64

    • 逆向特征

      • 字符串的长度为4的整数倍
      • 字符串的符号取值只能在 A-Z、a-z、0-9、+、/、= 共计65个字符中，且 = 如果出现，就必须在末尾
      • 索引表：ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

    • js（原生实现）

      // btoa、atob方法实现
!function(){
    // private property
    _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

    // public method for encoding
    this.btoa = function (input) {
        var output = "";
        var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
        var i = 0;
        input = _utf8_encode(input);
        while (i < input.length) {
            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);
        }
        return output;
    }

    // public method for decoding
    this.atob = function (input) {
        var output = "";
        var chr1, chr2, chr3;
        var enc1, enc2, enc3, enc4;
        var i = 0;
        input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
        while (i < input.length) {
            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 = output + String.fromCharCode(chr2);
            }
            if (enc4 != 64) {
                output = output + String.fromCharCode(chr3);
            }
        }
        output = _utf8_decode(output);
        return output;
    }

    // private method for UTF-8 encoding
    _utf8_encode = function (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;
    }

    // private method for UTF-8 decoding
    _utf8_decode = function (utftext) {
        var string = "";
        var i = 0;
        var c, c1, c2, c3;
        c = c1 = c2 = 0;
        while (i < utftext.length) {
            c = utftext.charCodeAt(i);
            if (c < 128) {
                string += String.fromCharCode(c);
                i++;
            } else if ((c > 191) && (c < 224)) {
                c2 = utftext.charCodeAt(i + 1);
                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                i += 2;
            } else {
                c2 = utftext.charCodeAt(i + 1);
                c3 = utftext.charCodeAt(i + 2);
                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                i += 3;
            }
        }
        return string;
    }
}()
      View Code

      加载上述代码后，正常使用btoa和atob方法

    • Nodejs(使用外部库)

      // 加密
let pwd = '密码'
let b64_pwd = Buffer.from(pwd).toString('base64')
console.log(b64_pwd) // 5a+G56CB

// 解密
console.log(Buffer.from(b64_pwd, 'base64').toString()) // 密码
      View Code

    • python

      import base64

# 加密
pwd = '密码'
b64_pwd = base64.b64encode(pwd.encode('utf-8'))
print(b64_pwd)

# 解密
print(base64.b64decode(b64_pwd).decode('utf-8'))
      View Code

  • MD5/SHA1

    • MD5逆向特征

      • 16位或32位十六进制数
      • 搜索关键词：
        • 关键字：md5、MD5
        • 默认的 key 值：0123456789abcdef、0123456789ABCDEF
        • 原始MD5的魔法值（16进制）：0x67452301、0xefcdab89、0x98badcfe、0x10325476
        • 原始MD5的魔法值（10进制）：1732584193、271733879、1732584194、271733878
      • 123456 计算结果值：
        • 16位结果49开头：49ba59abbe56e057（小写）、49BA59ABBE56E057（大写）
        • 32位结果e10或E10开头：e10adc3949ba59abbe56e057f20f883e（小写）、E10ADC3949BA59ABBE56E057F20F883E（大写）

    • SHA系列逆向特征

      • 十六进制数
      • 位数为 40、64、96、128 等，位数均是 8 的倍数
      • 123456计算结果值：
        • SHA1：7c4a8d09ca3762af61e59520943dc26494f8941b（40位）
        • SHA256：8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92（64 位）

    • js原生实现MD5

      // MD5方法实现
function MD5_Encrypt(instring) {
    var hexcase = 0;   /* hex output format. 0 - lowercase; 1 - uppercase        */
    var b64pad = "";  /* base-64 pad character. "=" for strict RFC compliance   */

    /*
     * These are the functions you'll usually want to call
     * They take string arguments and return either hex or base-64 encoded strings
     */
    function hex_md5(s) {
        return rstr2hex(rstr_md5(str2rstr_utf8(s)));
    }

    function b64_md5(s) {
        return rstr2b64(rstr_md5(str2rstr_utf8(s)));
    }

    function any_md5(s, e) {
        return rstr2any(rstr_md5(str2rstr_utf8(s)), e);
    }

    function hex_hmac_md5(k, d) {
        return rstr2hex(rstr_hmac_md5(str2rstr_utf8(k), str2rstr_utf8(d)));
    }

    function b64_hmac_md5(k, d) {
        return rstr2b64(rstr_hmac_md5(str2rstr_utf8(k), str2rstr_utf8(d)));
    }

    function any_hmac_md5(k, d, e) {
        return rstr2any(rstr_hmac_md5(str2rstr_utf8(k), str2rstr_utf8(d)), e);
    }

    /*
     * Perform a simple self-test to see if the VM is working
     */
    function md5_vm_test() {
        return hex_md5("abc").toLowerCase() == "900150983cd24fb0d6963f7d28e17f72";
    }

    /*
     * Calculate the MD5 of a raw string
     */
    function rstr_md5(s) {
        return binl2rstr(binl_md5(rstr2binl(s), s.length * 8));
    }

    /*
     * Calculate the HMAC-MD5, of a key and some data (raw strings)
     */
    function rstr_hmac_md5(key, data) {
        var bkey = rstr2binl(key);
        if (bkey.length > 16) bkey = binl_md5(bkey, key.length * 8);

        var ipad = Array(16), opad = Array(16);
        for (var i = 0; i < 16; i++) {
            ipad[i] = bkey[i] ^ 0x36363636;
            opad[i] = bkey[i] ^ 0x5C5C5C5C;
        }

        var hash = binl_md5(ipad.concat(rstr2binl(data)), 512 + data.length * 8);
        return binl2rstr(binl_md5(opad.concat(hash), 512 + 128));
    }

    /*
     * Convert a raw string to a hex string
     */
    function rstr2hex(input) {
        try {
            hexcase
        } catch (e) {
            hexcase = 0;
        }
        var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
        var output = "";
        var x;
        for (var i = 0; i < input.length; i++) {
            x = input.charCodeAt(i);
            output += hex_tab.charAt((x >>> 4) & 0x0F)
                + hex_tab.charAt(x & 0x0F);
        }
        return output;
    }

    /*
     * Convert a raw string to a base-64 string
     */
    function rstr2b64(input) {
        try {
            b64pad
        } catch (e) {
            b64pad = '';
        }
        var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        var output = "";
        var len = input.length;
        for (var i = 0; i < len; i += 3) {
            var triplet = (input.charCodeAt(i) << 16)
                | (i + 1 < len ? input.charCodeAt(i + 1) << 8 : 0)
                | (i + 2 < len ? input.charCodeAt(i + 2) : 0);
            for (var j = 0; j < 4; j++) {
                if (i * 8 + j * 6 > input.length * 8) output += b64pad;
                else output += tab.charAt((triplet >>> 6 * (3 - j)) & 0x3F);
            }
        }
        return output;
    }

    /*
     * Convert a raw string to an arbitrary string encoding
     */
    function rstr2any(input, encoding) {
        var divisor = encoding.length;
        var i, j, q, x, quotient;

        /* Convert to an array of 16-bit big-endian values, forming the dividend */
        var dividend = Array(Math.ceil(input.length / 2));
        for (i = 0; i < dividend.length; i++) {
            dividend[i] = (input.charCodeAt(i * 2) << 8) | input.charCodeAt(i * 2 + 1);
        }

        /*
         * Repeatedly perform a long division. The binary array forms the dividend,
         * the length of the encoding is the divisor. Once computed, the quotient
         * forms the dividend for the next step. All remainders are stored for later
         * use.
         */
        var full_length = Math.ceil(input.length * 8 /
            (Math.log(encoding.length) / Math.log(2)));
        var remainders = Array(full_length);
        for (j = 0; j < full_length; j++) {
            quotient = Array();
            x = 0;
            for (i = 0; i < dividend.length; i++) {
                x = (x << 16) + dividend[i];
                q = Math.floor(x / divisor);
                x -= q * divisor;
                if (quotient.length > 0 || q > 0)
                    quotient[quotient.length] = q;
            }
            remainders[j] = x;
            dividend = quotient;
        }

        /* Convert the remainders to the output string */
        var output = "";
        for (i = remainders.length - 1; i >= 0; i--)
            output += encoding.charAt(remainders[i]);

        return output;
    }

    /*
     * Encode a string as utf-8.
     * For efficiency, this assumes the input is valid utf-16.
     */
    function str2rstr_utf8(input) {
        var output = "";
        var i = -1;
        var x, y;

        while (++i < input.length) {
            /* Decode utf-16 surrogate pairs */
            x = input.charCodeAt(i);
            y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;
            if (0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF) {
                x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF);
                i++;
            }

            /* Encode output as utf-8 */
            if (x <= 0x7F)
                output += String.fromCharCode(x);
            else if (x <= 0x7FF)
                output += String.fromCharCode(0xC0 | ((x >>> 6) & 0x1F),
                    0x80 | (x & 0x3F));
            else if (x <= 0xFFFF)
                output += String.fromCharCode(0xE0 | ((x >>> 12) & 0x0F),
                    0x80 | ((x >>> 6) & 0x3F),
                    0x80 | (x & 0x3F));
            else if (x <= 0x1FFFFF)
                output += String.fromCharCode(0xF0 | ((x >>> 18) & 0x07),
                    0x80 | ((x >>> 12) & 0x3F),
                    0x80 | ((x >>> 6) & 0x3F),
                    0x80 | (x & 0x3F));
        }
        return output;
    }

    /*
     * Encode a string as utf-16
     */
    function str2rstr_utf16le(input) {
        var output = "";
        for (var i = 0; i < input.length; i++)
            output += String.fromCharCode(input.charCodeAt(i) & 0xFF,
                (input.charCodeAt(i) >>> 8) & 0xFF);
        return output;
    }

    function str2rstr_utf16be(input) {
        var output = "";
        for (var i = 0; i < input.length; i++)
            output += String.fromCharCode((input.charCodeAt(i) >>> 8) & 0xFF,
                input.charCodeAt(i) & 0xFF);
        return output;
    }

    /*
     * Convert a raw string to an array of little-endian words
     * Characters >255 have their high-byte silently ignored.
     */
    function rstr2binl(input) {
        var output = Array(input.length >> 2);
        for (var i = 0; i < output.length; i++)
            output[i] = 0;
        for (var i = 0; i < input.length * 8; i += 8)
            output[i >> 5] |= (input.charCodeAt(i / 8) & 0xFF) << (i % 32);
        return output;
    }

    /*
     * Convert an array of little-endian words to a string
     */
    function binl2rstr(input) {
        var output = "";
        for (var i = 0; i < input.length * 32; i += 8)
            output += String.fromCharCode((input[i >> 5] >>> (i % 32)) & 0xFF);
        return output;
    }

    /*
     * Calculate the MD5 of an array of little-endian words, and a bit length.
     */
    function binl_md5(x, len) {
        /* append padding */
        x[len >> 5] |= 0x80 << ((len) % 32);
        x[(((len + 64) >>> 9) << 4) + 14] = len;

        var a = 1732584193;
        var b = -271733879;
        var c = -1732584194;
        var d = 271733878;

        for (var i = 0; i < x.length; i += 16) {
            var olda = a;
            var oldb = b;
            var oldc = c;
            var oldd = d;

            a = md5_ff(a, b, c, d, x[i + 0], 7, -680876936);
            d = md5_ff(d, a, b, c, x[i + 1], 12, -389564586);
            c = md5_ff(c, d, a, b, x[i + 2], 17, 606105819);
            b = md5_ff(b, c, d, a, x[i + 3], 22, -1044525330);
            a = md5_ff(a, b, c, d, x[i + 4], 7, -176418897);
            d = md5_ff(d, a, b, c, x[i + 5], 12, 1200080426);
            c = md5_ff(c, d, a, b, x[i + 6], 17, -1473231341);
            b = md5_ff(b, c, d, a, x[i + 7], 22, -45705983);
            a = md5_ff(a, b, c, d, x[i + 8], 7, 1770035416);
            d = md5_ff(d, a, b, c, x[i + 9], 12, -1958414417);
            c = md5_ff(c, d, a, b, x[i + 10], 17, -42063);
            b = md5_ff(b, c, d, a, x[i + 11], 22, -1990404162);
            a = md5_ff(a, b, c, d, x[i + 12], 7, 1804603682);
            d = md5_ff(d, a, b, c, x[i + 13], 12, -40341101);
            c = md5_ff(c, d, a, b, x[i + 14], 17, -1502002290);
            b = md5_ff(b, c, d, a, x[i + 15], 22, 1236535329);

            a = md5_gg(a, b, c, d, x[i + 1], 5, -165796510);
            d = md5_gg(d, a, b, c, x[i + 6], 9, -1069501632);
            c = md5_gg(c, d, a, b, x[i + 11], 14, 643717713);
            b = md5_gg(b, c, d, a, x[i + 0], 20, -373897302);
            a = md5_gg(a, b, c, d, x[i + 5], 5, -701558691);
            d = md5_gg(d, a, b, c, x[i + 10], 9, 38016083);
            c = md5_gg(c, d, a, b, x[i + 15], 14, -660478335);
            b = md5_gg(b, c, d, a, x[i + 4], 20, -405537848);
            a = md5_gg(a, b, c, d, x[i + 9], 5, 568446438);
            d = md5_gg(d, a, b, c, x[i + 14], 9, -1019803690);
            c = md5_gg(c, d, a, b, x[i + 3], 14, -187363961);
            b = md5_gg(b, c, d, a, x[i + 8], 20, 1163531501);
            a = md5_gg(a, b, c, d, x[i + 13], 5, -1444681467);
            d = md5_gg(d, a, b, c, x[i + 2], 9, -51403784);
            c = md5_gg(c, d, a, b, x[i + 7], 14, 1735328473);
            b = md5_gg(b, c, d, a, x[i + 12], 20, -1926607734);

            a = md5_hh(a, b, c, d, x[i + 5], 4, -378558);
            d = md5_hh(d, a, b, c, x[i + 8], 11, -2022574463);
            c = md5_hh(c, d, a, b, x[i + 11], 16, 1839030562);
            b = md5_hh(b, c, d, a, x[i + 14], 23, -35309556);
            a = md5_hh(a, b, c, d, x[i + 1], 4, -1530992060);
            d = md5_hh(d, a, b, c, x[i + 4], 11, 1272893353);
            c = md5_hh(c, d, a, b, x[i + 7], 16, -155497632);
            b = md5_hh(b, c, d, a, x[i + 10], 23, -1094730640);
            a = md5_hh(a, b, c, d, x[i + 13], 4, 681279174);
            d = md5_hh(d, a, b, c, x[i + 0], 11, -358537222);
            c = md5_hh(c, d, a, b, x[i + 3], 16, -722521979);
            b = md5_hh(b, c, d, a, x[i + 6], 23, 76029189);
            a = md5_hh(a, b, c, d, x[i + 9], 4, -640364487);
            d = md5_hh(d, a, b, c, x[i + 12], 11, -421815835);
            c = md5_hh(c, d, a, b, x[i + 15], 16, 530742520);
            b = md5_hh(b, c, d, a, x[i + 2], 23, -995338651);

            a = md5_ii(a, b, c, d, x[i + 0], 6, -198630844);
            d = md5_ii(d, a, b, c, x[i + 7], 10, 1126891415);
            c = md5_ii(c, d, a, b, x[i + 14], 15, -1416354905);
            b = md5_ii(b, c, d, a, x[i + 5], 21, -57434055);
            a = md5_ii(a, b, c, d, x[i + 12], 6, 1700485571);
            d = md5_ii(d, a, b, c, x[i + 3], 10, -1894986606);
            c = md5_ii(c, d, a, b, x[i + 10], 15, -1051523);
            b = md5_ii(b, c, d, a, x[i + 1], 21, -2054922799);
            a = md5_ii(a, b, c, d, x[i + 8], 6, 1873313359);
            d = md5_ii(d, a, b, c, x[i + 15], 10, -30611744);
            c = md5_ii(c, d, a, b, x[i + 6], 15, -1560198380);
            b = md5_ii(b, c, d, a, x[i + 13], 21, 1309151649);
            a = md5_ii(a, b, c, d, x[i + 4], 6, -145523070);
            d = md5_ii(d, a, b, c, x[i + 11], 10, -1120210379);
            c = md5_ii(c, d, a, b, x[i + 2], 15, 718787259);
            b = md5_ii(b, c, d, a, x[i + 9], 21, -343485551);

            a = safe_add(a, olda);
            b = safe_add(b, oldb);
            c = safe_add(c, oldc);
            d = safe_add(d, oldd);
        }
        return Array(a, b, c, d);
    }

    /*
     * These functions implement the four basic operations the algorithm uses.
     */
    function md5_cmn(q, a, b, x, s, t) {
        return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b);
    }

    function md5_ff(a, b, c, d, x, s, t) {
        return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
    }

    function md5_gg(a, b, c, d, x, s, t) {
        return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
    }

    function md5_hh(a, b, c, d, x, s, t) {
        return md5_cmn(b ^ c ^ d, a, b, x, s, t);
    }

    function md5_ii(a, b, c, d, x, s, t) {
        return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
    }

    /*
     * Add integers, wrapping at 2^32. This uses 16-bit operations internally
     * to work around bugs in some JS interpreters.
     */
    function safe_add(x, y) {
        var lsw = (x & 0xFFFF) + (y & 0xFFFF);
        var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
        return (msw << 16) | (lsw & 0xFFFF);
    }

    /*
     * Bitwise rotate a 32-bit number to the left.
     */
    function bit_rol(num, cnt) {
        return (num << cnt) | (num >>> (32 - cnt));
    }

    return hex_md5(instring);
}
      View Code

      加载上述代码后，直接使用：MD5_Encrypt('待加密字符串')

    • Nodejs（使用外部库）

      const CryptoJS = require('crypto-js')

let pwd = '密码'

// md5加密
let md5_enc_pwd = CryptoJS.MD5(pwd).toString()

// sha1加密
let sha1_enc_pwd = CryptoJS.SHA1(pwd).toString()

console.log(md5_enc_pwd) // a8105204604a0b11e916f3879aae3b0b
console.log(sha1_enc_pwd) // c839a8ff17885af0b098662ccc3ac5e3111b3b3b
      View Code

    • python

      from hashlib import md5, sha1

# 加密
pwd = '密码'
print(md5(pwd.encode('utf-8')).hexdigest())
print(sha1(pwd.encode('utf-8')).hexdigest())
      View Code

  • HMAC

    • Nodejs

      const CryptoJS = require('crypto-js')

let key = 'key' // 密钥
let pwd = '密码'

// hmac中的sha256加密
let hash = CryptoJS.HmacSHA256(pwd, key)
let hmac_sha256_pwd = CryptoJS.enc.Hex.stringify(hash)
console.log(hmac_sha256_pwd) // 2c3a5556c71f76f1270ca87db60e1e91c69d812d748767468459a46912feed9c
      View Code

    • python

      import hashlib
import hmac

# 加密
key = 'key'
pwd = '密码'
enc_pwd = hmac.new(key.encode('utf-8'), pwd.encode('utf-8'), hashlib.sha256).hexdigest()
print(enc_pwd)
      View Code

  • DES

    • 逆向特征

      • 搜索关键词：cryptojs.des.encrypt、DES、mode、padding等

    • js原生实现

      function des(key, message, encrypt, mode, iv){
  //declaring this locally speeds things up a bit
  var spfunction1 = new Array(0x1010400,0,0x10000,0x1010404,0x1010004,0x10404,0x4,0x10000,0x400,0x1010400,0x1010404,0x400,0x1000404,0x1010004,0x1000000,0x4,0x404,0x1000400,0x1000400,0x10400,0x10400,0x1010000,0x1010000,0x1000404,0x10004,0x1000004,0x1000004,0x10004,0,0x404,0x10404,0x1000000,0x10000,0x1010404,0x4,0x1010000,0x1010400,0x1000000,0x1000000,0x400,0x1010004,0x10000,0x10400,0x1000004,0x400,0x4,0x1000404,0x10404,0x1010404,0x10004,0x1010000,0x1000404,0x1000004,0x404,0x10404,0x1010400,0x404,0x1000400,0x1000400,0,0x10004,0x10400,0,0x1010004);
  var spfunction2 = new Array(-0x7fef7fe0,-0x7fff8000,0x8000,0x108020,0x100000,0x20,-0x7fefffe0,-0x7fff7fe0,-0x7fffffe0,-0x7fef7fe0,-0x7fef8000,-0x80000000,-0x7fff8000,0x100000,0x20,-0x7fefffe0,0x108000,0x100020,-0x7fff7fe0,0,-0x80000000,0x8000,0x108020,-0x7ff00000,0x100020,-0x7fffffe0,0,0x108000,0x8020,-0x7fef8000,-0x7ff00000,0x8020,0,0x108020,-0x7fefffe0,0x100000,-0x7fff7fe0,-0x7ff00000,-0x7fef8000,0x8000,-0x7ff00000,-0x7fff8000,0x20,-0x7fef7fe0,0x108020,0x20,0x8000,-0x80000000,0x8020,-0x7fef8000,0x100000,-0x7fffffe0,0x100020,-0x7fff7fe0,-0x7fffffe0,0x100020,0x108000,0,-0x7fff8000,0x8020,-0x80000000,-0x7fefffe0,-0x7fef7fe0,0x108000);
  var spfunction3 = new Array(0x208,0x8020200,0,0x8020008,0x8000200,0,0x20208,0x8000200,0x20008,0x8000008,0x8000008,0x20000,0x8020208,0x20008,0x8020000,0x208,0x8000000,0x8,0x8020200,0x200,0x20200,0x8020000,0x8020008,0x20208,0x8000208,0x20200,0x20000,0x8000208,0x8,0x8020208,0x200,0x8000000,0x8020200,0x8000000,0x20008,0x208,0x20000,0x8020200,0x8000200,0,0x200,0x20008,0x8020208,0x8000200,0x8000008,0x200,0,0x8020008,0x8000208,0x20000,0x8000000,0x8020208,0x8,0x20208,0x20200,0x8000008,0x8020000,0x8000208,0x208,0x8020000,0x20208,0x8,0x8020008,0x20200);
  var spfunction4 = new Array(0x802001,0x2081,0x2081,0x80,0x802080,0x800081,0x800001,0x2001,0,0x802000,0x802000,0x802081,0x81,0,0x800080,0x800001,0x1,0x2000,0x800000,0x802001,0x80,0x800000,0x2001,0x2080,0x800081,0x1,0x2080,0x800080,0x2000,0x802080,0x802081,0x81,0x800080,0x800001,0x802000,0x802081,0x81,0,0,0x802000,0x2080,0x800080,0x800081,0x1,0x802001,0x2081,0x2081,0x80,0x802081,0x81,0x1,0x2000,0x800001,0x2001,0x802080,0x800081,0x2001,0x2080,0x800000,0x802001,0x80,0x800000,0x2000,0x802080);
  var spfunction5 = new Array(0x100,0x2080100,0x2080000,0x42000100,0x80000,0x100,0x40000000,0x2080000,0x40080100,0x80000,0x2000100,0x40080100,0x42000100,0x42080000,0x80100,0x40000000,0x2000000,0x40080000,0x40080000,0,0x40000100,0x42080100,0x42080100,0x2000100,0x42080000,0x40000100,0,0x42000000,0x2080100,0x2000000,0x42000000,0x80100,0x80000,0x42000100,0x100,0x2000000,0x40000000,0x2080000,0x42000100,0x40080100,0x2000100,0x40000000,0x42080000,0x2080100,0x40080100,0x100,0x2000000,0x42080000,0x42080100,0x80100,0x42000000,0x42080100,0x2080000,0,0x40080000,0x42000000,0x80100,0x2000100,0x40000100,0x80000,0,0x40080000,0x2080100,0x40000100);
  var spfunction6 = new Array(0x20000010,0x20400000,0x4000,0x20404010,0x20400000,0x10,0x20404010,0x400000,0x20004000,0x404010,0x400000,0x20000010,0x400010,0x20004000,0x20000000,0x4010,0,0x400010,0x20004010,0x4000,0x404000,0x20004010,0x10,0x20400010,0x20400010,0,0x404010,0x20404000,0x4010,0x404000,0x20404000,0x20000000,0x20004000,0x10,0x20400010,0x404000,0x20404010,0x400000,0x4010,0x20000010,0x400000,0x20004000,0x20000000,0x4010,0x20000010,0x20404010,0x404000,0x20400000,0x404010,0x20404000,0,0x20400010,0x10,0x4000,0x20400000,0x404010,0x4000,0x400010,0x20004010,0,0x20404000,0x20000000,0x400010,0x20004010);
  var spfunction7 = new Array(0x200000,0x4200002,0x4000802,0,0x800,0x4000802,0x200802,0x4200800,0x4200802,0x200000,0,0x4000002,0x2,0x4000000,0x4200002,0x802,0x4000800,0x200802,0x200002,0x4000800,0x4000002,0x4200000,0x4200800,0x200002,0x4200000,0x800,0x802,0x4200802,0x200800,0x2,0x4000000,0x200800,0x4000000,0x200800,0x200000,0x4000802,0x4000802,0x4200002,0x4200002,0x2,0x200002,0x4000000,0x4000800,0x200000,0x4200800,0x802,0x200802,0x4200800,0x802,0x4000002,0x4200802,0x4200000,0x200800,0,0x2,0x4200802,0,0x200802,0x4200000,0x800,0x4000002,0x4000800,0x800,0x200002);
  var spfunction8 = new Array(0x10001040,0x1000,0x40000,0x10041040,0x10000000,0x10001040,0x40,0x10000000,0x40040,0x10040000,0x10041040,0x41000,0x10041000,0x41040,0x1000,0x40,0x10040000,0x10000040,0x10001000,0x1040,0x41000,0x40040,0x10040040,0x10041000,0x1040,0,0,0x10040040,0x10000040,0x10001000,0x41040,0x40000,0x41040,0x40000,0x10041000,0x1000,0x40,0x10040040,0x1000,0x41040,0x10001000,0x40,0x10000040,0x10040000,0x10040040,0x10000000,0x40000,0x10001040,0,0x10041040,0x40040,0x10000040,0x10040000,0x10001000,0x10001040,0,0x10041040,0x41000,0x41000,0x1040,0x1040,0x40040,0x10000000,0x10041000);
 
  //create the 16 or 48 subkeys we will need
  var keys = des_createKeys(key);
  var m=0, i, j, temp, temp2, right1, right2, left, right, looping;
  var cbcleft, cbcleft2, cbcright, cbcright2
  var endloop, loopinc;
  var len = message.length;
  var chunk = 0;
  //set up the loops for single and triple des
  var iterations = keys.length == 32 ? 3 : 9; //single or triple des
  if (iterations == 3){looping = encrypt ? new Array(0, 32, 2) : new Array(30, -2, -2);}
  else {looping = encrypt ? new Array(0, 32, 2, 62, 30, -2, 64, 96, 2) : new Array(94, 62, -2, 32, 64, 2, 30, -2, -2);}
 
  message += "\0\0\0\0\0\0\0\0"; //pad the message out with null bytes
  //store the result here
  result = "";
  tempresult = "";
 
  if (mode == 1){//CBC mode
    cbcleft = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);
    cbcright = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);
    m=0;
  }
 
  //loop through each 64 bit chunk of the message
  while (m < len){
    left = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);
    right = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);
 
    //for Cipher Block Chaining mode, xor the message with the previous result
    if (mode == 1){if(encrypt){left ^= cbcleft; right ^= cbcright;}else{cbcleft2 = cbcleft; cbcright2 = cbcright; cbcleft = left; cbcright = right;}}
 
    //first each 64 but chunk of the message must be permuted according to IP
    temp = ((left >>> 4) ^ right) & 0x0f0f0f0f; right ^= temp; left ^= (temp << 4);
    temp = ((left >>> 16) ^ right) & 0x0000ffff; right ^= temp; left ^= (temp << 16);
    temp = ((right >>> 2) ^ left) & 0x33333333; left ^= temp; right ^= (temp << 2);
    temp = ((right >>> 8) ^ left) & 0x00ff00ff; left ^= temp; right ^= (temp << 8);
    temp = ((left >>> 1) ^ right) & 0x55555555; right ^= temp; left ^= (temp << 1);
 
    left = ((left << 1) | (left >>> 31));
    right = ((right << 1) | (right >>> 31));
 
    //do this either 1 or 3 times for each chunk of the message
    for (j=0; j<iterations; j+=3){
      endloop = looping[j+1];
      loopinc = looping[j+2];
      //now go through and perform the encryption or decryption 
      for (i=looping[j]; i!=endloop; i+=loopinc){//for efficiency
        right1 = right ^ keys[i];
        right2 = ((right >>> 4) | (right << 28)) ^ keys[i+1];
        //the result is attained by passing these bytes through the S selection functions
        temp = left;
        left = right;
        right = temp ^ (spfunction2[(right1 >>> 24) & 0x3f] | spfunction4[(right1 >>> 16) & 0x3f]
              | spfunction6[(right1 >>>  8) & 0x3f] | spfunction8[right1 & 0x3f]
              | spfunction1[(right2 >>> 24) & 0x3f] | spfunction3[(right2 >>> 16) & 0x3f]
              | spfunction5[(right2 >>>  8) & 0x3f] | spfunction7[right2 & 0x3f]);
      }
      temp = left; left = right; right = temp; //unreverse left and right
    } //for either 1 or 3 iterations
 
    //move then each one bit to the right
    left = ((left >>> 1) | (left << 31));
    right = ((right >>> 1) | (right << 31));
 
    //now perform IP-1, which is IP in the opposite direction
    temp = ((left >>> 1) ^ right) & 0x55555555; right ^= temp; left ^= (temp << 1);
    temp = ((right >>> 8) ^ left) & 0x00ff00ff; left ^= temp; right ^= (temp << 8);
    temp = ((right >>> 2) ^ left) & 0x33333333; left ^= temp; right ^= (temp << 2);
    temp = ((left >>> 16) ^ right) & 0x0000ffff; right ^= temp; left ^= (temp << 16);
    temp = ((left >>> 4) ^ right) & 0x0f0f0f0f; right ^= temp; left ^= (temp << 4);
 
    //for Cipher Block Chaining mode, xor the message with the previous result
    if (mode == 1){if(encrypt){cbcleft = left; cbcright = right;}else{left ^= cbcleft2; right ^= cbcright2;}}
    tempresult += String.fromCharCode ((left>>>24), ((left>>>16) & 0xff), ((left>>>8) & 0xff), (left & 0xff), (right>>>24), ((right>>>16) & 0xff), ((right>>>8) & 0xff), (right & 0xff));
 
    chunk += 8;
    if (chunk == 512){result += tempresult; tempresult = ""; chunk = 0;}
  } //for every 8 characters, or 64 bits in the message
 
  //return the result as an array
  return stringToHex(result + tempresult).slice(2);
} //end of des
 
 
 
//des_createKeys
//this takes as input a 64 bit key (even though only 56 bits are used)
//as an array of 2 integers, and returns 16 48 bit keys
function des_createKeys(key){
  //declaring this locally speeds things up a bit
  pc2bytes0  = new Array(0,0x4,0x20000000,0x20000004,0x10000,0x10004,0x20010000,0x20010004,0x200,0x204,0x20000200,0x20000204,0x10200,0x10204,0x20010200,0x20010204);
  pc2bytes1  = new Array(0,0x1,0x100000,0x100001,0x4000000,0x4000001,0x4100000,0x4100001,0x100,0x101,0x100100,0x100101,0x4000100,0x4000101,0x4100100,0x4100101);
  pc2bytes2  = new Array(0,0x8,0x800,0x808,0x1000000,0x1000008,0x1000800,0x1000808,0,0x8,0x800,0x808,0x1000000,0x1000008,0x1000800,0x1000808);
  pc2bytes3  = new Array(0,0x200000,0x8000000,0x8200000,0x2000,0x202000,0x8002000,0x8202000,0x20000,0x220000,0x8020000,0x8220000,0x22000,0x222000,0x8022000,0x8222000);
  pc2bytes4  = new Array(0,0x40000,0x10,0x40010,0,0x40000,0x10,0x40010,0x1000,0x41000,0x1010,0x41010,0x1000,0x41000,0x1010,0x41010);
  pc2bytes5  = new Array(0,0x400,0x20,0x420,0,0x400,0x20,0x420,0x2000000,0x2000400,0x2000020,0x2000420,0x2000000,0x2000400,0x2000020,0x2000420);
  pc2bytes6  = new Array(0,0x10000000,0x80000,0x10080000,0x2,0x10000002,0x80002,0x10080002,0,0x10000000,0x80000,0x10080000,0x2,0x10000002,0x80002,0x10080002);
  pc2bytes7  = new Array(0,0x10000,0x800,0x10800,0x20000000,0x20010000,0x20000800,0x20010800,0x20000,0x30000,0x20800,0x30800,0x20020000,0x20030000,0x20020800,0x20030800);
  pc2bytes8  = new Array(0,0x40000,0,0x40000,0x2,0x40002,0x2,0x40002,0x2000000,0x2040000,0x2000000,0x2040000,0x2000002,0x2040002,0x2000002,0x2040002);
  pc2bytes9  = new Array(0,0x10000000,0x8,0x10000008,0,0x10000000,0x8,0x10000008,0x400,0x10000400,0x408,0x10000408,0x400,0x10000400,0x408,0x10000408);
  pc2bytes10 = new Array(0,0x20,0,0x20,0x100000,0x100020,0x100000,0x100020,0x2000,0x2020,0x2000,0x2020,0x102000,0x102020,0x102000,0x102020);
  pc2bytes11 = new Array(0,0x1000000,0x200,0x1000200,0x200000,0x1200000,0x200200,0x1200200,0x4000000,0x5000000,0x4000200,0x5000200,0x4200000,0x5200000,0x4200200,0x5200200);
  pc2bytes12 = new Array(0,0x1000,0x8000000,0x8001000,0x80000,0x81000,0x8080000,0x8081000,0x10,0x1010,0x8000010,0x8001010,0x80010,0x81010,0x8080010,0x8081010);
  pc2bytes13 = new Array(0,0x4,0x100,0x104,0,0x4,0x100,0x104,0x1,0x5,0x101,0x105,0x1,0x5,0x101,0x105);
 
  //how many iterations (1 for des, 3 for triple des)
  var iterations = key.length >= 24 ? 3 : 1;
  //stores the return keys
  var keys = new Array(32 * iterations);
  //now define the left shifts which need to be done
  var shifts = new Array(0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);
  //other variables
  var lefttemp, righttemp, m=0, n=0, temp;
 
  for (var j=0; j<iterations; j++){//either 1 or 3 iterations
    left = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
    right = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
 
    temp = ((left >>> 4) ^ right) & 0x0f0f0f0f; right ^= temp; left ^= (temp << 4);
    temp = ((right >>> -16) ^ left) & 0x0000ffff; left ^= temp; right ^= (temp << -16);
    temp = ((left >>> 2) ^ right) & 0x33333333; right ^= temp; left ^= (temp << 2);
    temp = ((right >>> -16) ^ left) & 0x0000ffff; left ^= temp; right ^= (temp << -16);
    temp = ((left >>> 1) ^ right) & 0x55555555; right ^= temp; left ^= (temp << 1);
    temp = ((right >>> 8) ^ left) & 0x00ff00ff; left ^= temp; right ^= (temp << 8);
    temp = ((left >>> 1) ^ right) & 0x55555555; right ^= temp; left ^= (temp << 1);
 
    //the right side needs to be shifted and to get the last four bits of the left side
    temp = (left << 8) | ((right >>> 20) & 0x000000f0);
    //left needs to be put upside down
    left = (right << 24) | ((right << 8) & 0xff0000) | ((right >>> 8) & 0xff00) | ((right >>> 24) & 0xf0);
    right = temp;
 
    //now go through and perform these shifts on the left and right keys
    for (i=0; i < shifts.length; i++){
      //shift the keys either one or two bits to the left
      if (shifts[i]){left = (left << 2) | (left >>> 26); right = (right << 2) | (right >>> 26);}
      else {left = (left << 1) | (left >>> 27); right = (right << 1) | (right >>> 27);}
      left &= -0xf; right &= -0xf;
 
      //now apply PC-2, in such a way that E is easier when encrypting or decrypting
      //this conversion will look like PC-2 except only the last 6 bits of each byte are used
      //rather than 48 consecutive bits and the order of lines will be according to
      //how the S selection functions will be applied: S2, S4, S6, S8, S1, S3, S5, S7
      lefttemp = pc2bytes0[left >>> 28] | pc2bytes1[(left >>> 24) & 0xf]
              | pc2bytes2[(left >>> 20) & 0xf] | pc2bytes3[(left >>> 16) & 0xf]
              | pc2bytes4[(left >>> 12) & 0xf] | pc2bytes5[(left >>> 8) & 0xf]
              | pc2bytes6[(left >>> 4) & 0xf];
      righttemp = pc2bytes7[right >>> 28] | pc2bytes8[(right >>> 24) & 0xf]
                | pc2bytes9[(right >>> 20) & 0xf] | pc2bytes10[(right >>> 16) & 0xf]
                | pc2bytes11[(right >>> 12) & 0xf] | pc2bytes12[(right >>> 8) & 0xf]
                | pc2bytes13[(right >>> 4) & 0xf];
      temp = ((righttemp >>> 16) ^ lefttemp) & 0x0000ffff;
      keys[n++] = lefttemp ^ temp; keys[n++] = righttemp ^ (temp << 16);
    }
  } //for each iterations
  //return the keys we've created
  return keys;
} //end of des_createKeys

function stringToHex(s){
  var r = "0x";
  var hexes = new Array("0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f");
  for (var i=0; i<s.length; i++){r += hexes[s.charCodeAt(i) >> 4] + hexes[s.charCodeAt(i) & 0xf];}
  return r;
}

// var key = "12345678";
// var message = "hello world";
// console.log(des(key, message, 1, 0));
      View Code

    • Nodejs

      const CryptoJS = require('crypto-js')

let key = '12345678' // 密钥
let pwd = '密码'

let new_key = CryptoJS.enc.Utf8.parse(key)
let new_pwd = CryptoJS.enc.Utf8.parse(pwd)

let config = {
    mode: CryptoJS.mode.ECB,
    padding: CryptoJS.pad.Pkcs7
}

// 加密
let enc_pwd = CryptoJS.DES.encrypt(new_pwd, new_key, config).toString()
console.log(enc_pwd) // 80lOPdkA6f4=

// 解密
let dec_pwd = CryptoJS.DES.decrypt(enc_pwd, new_key, config).toString(CryptoJS.enc.Utf8)
console.log(dec_pwd)
      View Code

    • python

      # coding:utf-8
import base64
from Crypto.Cipher import DES
from Crypto.Util.Padding import pad, unpad


class DESCrypt:
    def __init__(self):
        self.key = b'12345678'  # 密钥
        self.mode = DES.MODE_CBC  # 模式
        self.iv = b'87654321'  # 初始化向量

    def encrpyt(self, text):
        '''加密'''
        text_pad = pad(text.encode('utf-8'), DES.block_size)  # 填充后的字节串
        crpytor = DES.new(self.key, self.mode, self.iv)  # 生成算法对象
        encrypt_data = crpytor.encrypt(text_pad)  # 对数据进行加密
        return base64.b64encode(encrypt_data).decode()

    def decrypt(self, text):
        '''解密'''
        data = base64.b64decode(text.encode())
        crpytor = DES.new(self.key, self.mode, self.iv)
        decrypt_data = crpytor.decrypt(data)  # 对数据进行解密
        res = unpad(decrypt_data, DES.block_size).decode()  # 去除多余字符
        return res


if __name__ == '__main__':
    des = DESCrypt()
    data = '123456'
    encrypt_data = des.encrpyt(data)
    print(f'【{data}】加密-->【{encrypt_data}】')
    decrypt_data = des.decrypt(encrypt_data)
    print(f'【{encrypt_data}】解密-->【{decrypt_data}】')
      View Code

      ECB模式没有使用初始化向量（IV），其它模式有初始化向量时，Nodejs中只需要在cfg中添加属性'iv'即可配置

  • 3DES

    • python

      import base64
from Crypto.Cipher import DES3
from Crypto.Util.Padding import pad, unpad

class Des3:
    def __init__(self):
        self.key = b'123456789012345678901234'  # 密钥：16或24字节
        self.mode = DES3.MODE_CBC  # 模式
        self.iv = b'12345678'  # 初始化向量

    def encrpyt(self, text):
        '''加密'''
        text_pad = pad(text.encode('utf-8'), DES3.block_size,style='pkcs7')  # 填充后的字节串
        crpytor = DES3.new(self.key, self.mode, self.iv)  # 生成算法对象
        encrypt_data = crpytor.encrypt(text_pad)  # 对数据进行加密
        return base64.b64encode(encrypt_data).decode()

    def decrypt(self, text):
        '''解密'''
        data = base64.b64decode(text.encode())
        crpytor = DES3.new(self.key, self.mode, self.iv)
        decrypt_data = crpytor.decrypt(data)  # 对数据进行解密
        res = unpad(decrypt_data, DES3.block_size).decode()  # 去除多余字符
        return res
      View Code

      注意key是16个字节或者24字节

  • AES

    • 逆向特征

      • 加密结果一般是8 的整数倍。

      • 搜索关键词：cryptojs.aes、encryptedString、010001、AES、mode、padding等

    • Nodejs

      const CryptoJS = require('crypto-js')

let pwd = "密码";
let key = "1234567890abcdef"

let new_key = CryptoJS.enc.Utf8.parse(key)
let new_pwd = CryptoJS.enc.Utf8.parse(pwd)

let cfg = {
    mode: CryptoJS.mode.ECB,
    padding: CryptoJS.pad.Pkcs7
}

// AES加密
let enc_pwd = CryptoJS.AES.encrypt(new_pwd, new_key, cfg).toString()
console.log(enc_pwd) // cdT+fh971Dgn3ji5v3+0AQ==

// AES解密
let dec_pwd = CryptoJS.AES.decrypt(enc_pwd, new_key, cfg).toString(CryptoJS.enc.Utf8) // 指定解码方式
console.log(dec_pwd)  // 密码
      View Code

    • python

      # coding:utf-8
import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad


class AESCrypt:
    def __init__(self):
        self.key = b'0123456789abcdef'  # 密钥 16、24或32字节
        self.mode = AES.MODE_CBC  # 模式
        self.iv = b'0123456789abcdef'  # 初始化向量 16字节

    def encrpyt(self, text):
        '''加密'''
        text_pad = pad(text.encode('utf-8'), AES.block_size)  # 填充后的字节串
        crpytor = AES.new(self.key, self.mode, self.iv)  # 生成算法对象
        encrypt_data = crpytor.encrypt(text_pad)  # 对数据进行加密
        return base64.b64encode(encrypt_data).decode()

    def decrypt(self, text):
        '''解密'''
        data = base64.b64decode(text.encode())
        crpytor = AES.new(self.key, self.mode, self.iv)
        decrypt_data = crpytor.decrypt(data)  # 对数据进行解密
        res = unpad(decrypt_data, AES.block_size).decode()  # 去除多余字符
        return res


if __name__ == '__main__':
    aes = AESCrypt()
    data = '123456'
    encrypt_data = aes.encrpyt(data)
    print(f'【{data}】加密-->【{encrypt_data}】')
    decrypt_data = aes.decrypt(encrypt_data)
    print(f'【{encrypt_data}】解密-->【{decrypt_data}】')
      View Code

  • RSA

    • 逆向特征

      • 同一个明文可以生成不同的密文
      • 加密后的数据长度不可能是 8 的倍数
      • 搜索关键词：new JSEncrypt、setpublickey、ABCDEFG、abcdefg。

    • Nodejs

      window = global;
const JSEncrypt = require('jsencrypt'); // npm install jsencrypt@3.2.1
publickey = `
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCdRivxDSsUknPXJ4iGLwmezwgc
1mue6d+Xyf67NWeHc6vC5vq2BfSmGgOz42dQ1JOwzWM+1TG6gocJbfSSsW1dFy3G
sMLUblq1iIQ9/NZLjGRgF7+MUxCxTp+okPyhhUCeeg7u44B9F3OdDXIc3peAs4hV
QI241AHnQqKJJVrEIwIDAQAB
-----END PUBLIC KEY-----
`;

// 加密
let jse = new JSEncrypt();
jse.setPublicKey(publickey);
var enc_pwd = jse.encrypt('密码');
console.log(enc_pwd) // dYxPVvIG/O2rHq0M6IG1H2yB0euqgL3pJ8jS+oFyGg7ZNHsWtLH/T6sYFRmVeMQwPJ4+c0ReEr/8wdzPcDg8NA==

// 解密
privatekey = `
-----BEGIN RSA PRIVATE KEY-----
MIICWwIBAAKBgQCdRivxDSsUknPXJ4iGLwmezwgc1mue6d+Xyf67NWeHc6vC5vq2
BfSmGgOz42dQ1JOwzWM+1TG6gocJbfSSsW1dFy3GsMLUblq1iIQ9/NZLjGRgF7+M
UxCxTp+okPyhhUCeeg7u44B9F3OdDXIc3peAs4hVQI241AHnQqKJJVrEIwIDAQAB
AoGAPW7dGDYUF1+Tlz3ugreZ8uoc2aLZ/AOP3ss80OSt8Yd51tKBqRtPcphjzN8t
irHWlO/Nbgw59ggpdkH4kFp1BJRyqTIxNibZaBK4vrvP6nnta6Us3zsdmYvql6v8
zpa7mIiXkchftj2M2bZEsJib3Xor9idzg805H2pyYWSsd2ECQQDAG/7tIHJ5hsAa
dyqjbHDpFoVa1t6JpNVlttj+NLIuQKi8Atd5xXF5SPGFwVjeYfyvFbPp0rAoFje1
ldfUNB5DAkEA0ZRWIOHOMV+h2NMx5PCRnPClmx450I2bqdOo14CnG6gmipw15Oh5
oeLGqM1XsNKobDclU8YbR5B/YRxaw8eUoQJAEnYeR3doyNj0ORbemBnht+ScKCCh
/iRDBaVOsQ8rWFqKXJcBUghxYTBrVWlBOw27lK/HPF8s4o1QCTk/JntjtQJAQKk/
mY2RjHIxATDH6BbBFma48Y71z36hVFhVc4fiBwpuOb3Qcvu261eIa3RPZeLYy+qH
vb0VlZLjehbBej4NgQJAF9RKBmh7VtqrzhBU53KzVzpwSUdpiuNGnb563xNt4FtS
Ybwh5wrMDHf6y8GNUgI2ICKZA+0LCWDs/PxekA8URg==
-----END RSA PRIVATE KEY-----
`
jse.setPrivateKey(privatekey);
var dec_pwd = jse.decrypt(enc_pwd);
console.log(dec_pwd) // 加密
      View Code

      每次加密的结果都会不同，密钥对可通过在线工具生成

    • python

      import base64
from Crypto.Cipher import PKCS1_v1_5
from Crypto.PublicKey import RSA


# ------------------------生成密钥对------------------------
def gen_rsa_pair():
    rsaKey = RSA.generate(1024)
    public_key = rsaKey.publickey().exportKey()  # 生成公钥
    private_key = rsaKey.exportKey()  # 生成私钥
    return public_key, private_key


# ------------------------加密------------------------
def rsa_encrypt(data: str, public_key: bytes):
    # 构建公钥对象，并通过它生成rsa算法对象
    rsa = PKCS1_v1_5.new(RSA.importKey(public_key))
    # 加密（bytes）
    encrypt_data = rsa.encrypt(data.encode('utf-8'))
    # base64编码后的rsa加密结果
    return base64.b64encode(encrypt_data).decode()


# ------------------------解密------------------------
def rsa_decrypt(b64_encrypt_data: str, private_key: bytes):
    # 构建私钥对象，并通过它生成rsa算法对象
    rsa = PKCS1_v1_5.new(RSA.importKey(private_key))
    # 解密（bytes）
    decrypt_data = rsa.decrypt(base64.b64decode(b64_encrypt_data), None)
    return decrypt_data.decode('utf-8')


if __name__ == '__main__':
    # 生成密钥对
    public_key, private_key = gen_rsa_pair()
    # 加密
    data = '123456'
    encrypt_data = rsa_encrypt(data, public_key)
    print(f'【{data}】加密-->【{encrypt_data}】')

    # 解密
    decrpyt_data = rsa_decrypt(encrypt_data, private_key)
    print(f'【{encrypt_data}】解密-->【{decrpyt_data}】')
      View Code
posted @ 2023-02-16 14:17  eliwang  阅读(1136)  评论(0)  编辑  收藏  举报