base64随机字符混淆加密、解密-美拍视频地址解密(兼容ie、中文)

最新推荐文章于 2024-07-02 08:00:19 发布
最新推荐文章于 2024-07-02 08:00:19 发布
阅读量1.2k 收藏
点赞数
分类专栏： Web安全 web前端
原文链接：https://www.cnblogs.com/xitianzhou/p/7495867.html
版权

用火车头测试采集美拍的数据时无意中发现美拍的视频地址是一段加了混淆字符串的base64代码。如下图:

于是好奇之下研究下解密算法。具体过程省略800字。发现美拍的视频解密是通过js完成，于是找到了具体的解密代码，如下:

;function(a) {
    var b = "substring",
    c = "split",
    d = "replace",
    e = "substr",
    f = {
        getHex: function(a) {
            return {
                str: a[b](4),
                hex: a[b](0, 4)[c]("").reverse().join("")
            }
        },
        getDec: function(a) {
            var d = parseInt(a, 16).toString();
            return {
                pre: d[b](0, 2)[c](""),
                tail: d[b](2)[c]("")
            }
        },
        substr: function(a, c) {
            var f = a[b](0, c[0]),
            g = a[e](c[0], c[1]);
            return f + a[b](c[0])[d](g, "")
        },
        getPos: function(a, b) {
            return b[0] = a.length - b[0] - b[1],
            b
        },
        decode: function(a) {
            var b = this.getHex(a),
            c = this.getDec(b.hex),
            d = this[e](b.str, c.pre);
            return window.atob(this[e](d, this.getPos(d, c.tail)))
        }
    };
    a.decodeMp4 = f,
    window.MP = a
} (window.MP || {}))

通过解密代码可以发现视频地址字符串是base64加密的，只不过在其中插入了一些混淆字符。只要清除混淆字符即可通过base64解密得到视频地址。

js怎样对字符进行base64加密、解密?如下:

window.atob(str); //解密
window.btoa(str); //加密
//但后来发现这样是不兼容中文的，于是有了下面的兼容中文的方法
decodeURIComponent(escape(window.atob(d))); //解密
window.btoa(unescape(encodeURIComponent(str))); //加密

由于ie兼容问题，所以另外找了一个封装好的:

base64={
    atob: function(src) { //解密
        //用一个数组来存放解码后的字符。
        var str = new Array();
        var ch1, ch2, ch3, ch4;
        var pos=0;
        //过滤非法字符，并去掉'='。
        src=src.replace(/[^A-Za-z0-9\+\/]/g, '');
        //decode the source string in partition of per four characters.
        while (pos + 4 <= src.length) {
            ch1 = this.deKey[src.charCodeAt(pos++)];
            ch2 = this.deKey[src.charCodeAt(pos++)];
            ch3 = this.deKey[src.charCodeAt(pos++)];
            ch4 = this.deKey[src.charCodeAt(pos++)];
            str.push(String.fromCharCode(
                (ch1<<2&0xff) + (ch2>>4), (ch2<<4&0xff) + (ch3>>2), (ch3<<6&0xff)+ch4));
        }
        //给剩下的字符进行解码
        if (pos+1<src.length) {
            ch1 = this.deKey[src.charCodeAt(pos++)];
            ch2 = this.deKey[src.charCodeAt(pos++)];
            if (pos < src.length) {
                ch3 = this.deKey[src.charCodeAt(pos)];
                str.push(String.fromCharCode((ch1<<2&0xff)+(ch2>>4), (ch2<<4&0xff)+(ch3>>2)));
            } else {
                str.push(String.fromCharCode((ch1<<2&0xff)+(ch2>>4)));
            }
        }
        //组合各解码后的字符，连成一个字符串。
        return str.join('');
    },
    btoa: function(src) {//加密
        //用一个数组来存放编码后的字符，效率比用字符串相加高很多。
        var str=new Array();
        var ch1, ch2, ch3;
        var pos = 0;
        //每三个字符进行编码
        while (pos+3 <= src.length) {
            ch1 = src.charCodeAt(pos++);
            ch2 = src.charCodeAt(pos++);
            ch3 = src.charCodeAt(pos++);
            str.push(this.enKey.charAt(ch1>>2), this.enKey.charAt(((ch1<<4)+(ch2>>4))&0x3f));
            str.push(this.enKey.charAt(((ch2<<2) + (ch3>>6))&0x3f), this.enKey.charAt(ch3&0x3f));
        }
        //给剩下的字符进行编码。
        if (pos < src.length) {
            ch1 = src.charCodeAt(pos++);
            str.push(this.enKey.charAt(ch1>>2));
            if (pos < src.length) {
                ch2 = src.charCodeAt(pos);
                str.push(this.enKey.charAt(((ch1<<4) +(ch2>>4)) & 0x3f));
                str.push(this.enKey.charAt(ch2<<2&0x3f), '=');
            } else {
                str.push(this.enKey.charAt(ch1<<4&0x3f), '==');
            }
        }
        //组合各编码后的字符，连成一个字符串。
        return str.join('');
    },
    enKey:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
    deKey: new Array(
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
         52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
         -1, 0, 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, -1, -1, -1, -1, -1,
         -1, 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, -1, -1, -1, -1, -1
     ),
}

解密算法已经找到，但我想要的是加密算法，所以只能通过解密算法反推加密算法，于是展开了一系列烧脑操作。终于发现了加密的原理(大概可能是)。

首先说说加密的原理：

1、先用base64对视频地址进行加密。

2、在视频地址前面加上一个4位字符串，字符串要满足以下条件:

  a.必须是四位16进制的字符串。

  b.字符串的10进制必须也是一个四位整数。(这个四位整数很重要，用来确定随机字符串的插入位置和个数的)

  c.插入加密地址前的是四位16进制的字符串的倒序。

3.通过开头加上的4位字符串确定随机字符串以及插入的位置(前后相应位置都加上一段随机字符串)

看着原理是不是一头大？不用急，现在慢慢来解析一下：

现在用第一张图上的字符串来说明一下解密的过程，然后就能反推加密原理：

base64混淆加密后的地址：b901aHR0TDcDovL212dmlkZW8xLm1laXR1ZGF0YS5jb20vNTlhZmU3MDRmMTBiOTQ3ODIubXA0P2s9NDNiNzhkYjZmYmE1ZjNlZWM4NjY3NTM2MTkxNjI3ZGUmdD01OWIzNjdejNA==

①首先前面4位16进制的字符串为b901,因为是倒序添加的，所以实际上为109b。

②109b对应的10进制为4251。

③通过4251推算,前面添加的随机字符串位置为第4个字符开始，添加2个随机字符串;后台添加的随机字符串位置为倒数第5个添加1个随机字符串。

得出上面的混淆加密的随机字符为(用*号替代)：

aHR0**cDovL212dmlkZW8xLm1laXR1ZGF0YS5jb20vNTlhZmU3MDRmMTBiOTQ3ODIubXA0P2s9NDNiNzhkYjZmYmE1ZjNlZWM4NjY3NTM2MTkxNjI3ZGUmdD01OWIzNjd*jNA==

去掉*号的内容即为真实的base64加密地址：

aHR0cDovL212dmlkZW8xLm1laXR1ZGF0YS5jb20vNTlhZmU3MDRmMTBiOTQ3ODIubXA0P2s9NDNiNzhkYjZmYmE1ZjNlZWM4NjY3NTM2MTkxNjI3ZGUmdD01OWIzNjdjNA==

然后就可以通过普通的base64解密方法来解密视频地址了。

1 decodeURIComponent(escape(window.atob('aHR0cDovL212dmlkZW8xLm1laXR1ZGF0YS5jb20vNTlhZmU3MDRmMTBiOTQ3ODIubXA0P2s9NDNiNzhkYjZmYmE1ZjNlZWM4NjY3NTM2MTkxNjI3ZGUmdD01OWIzNjdjNA==')));
2 //得出内容为：http://mvvideo1.meitudata.com/59afe704f10b94782.mp4?k=43b78db6fba5f3eec8667536191627de&t=59b367c4

知道了加密原理，那么推算出加密算法就只是时间问题了。

。。。又经过一系列的测试整理，终于出版了js版的base64随机字符混淆加密、解密方法，如下：

;function(base64){
    var substring = 'substring',
        split = 'split',
        reverse = 'reverse',
        join = 'join',
        toString = 'toString',
        substr = 'substr',
        replace = 'replace',
        fn = {
        getHex: function (str) {//获取前4位标记数字
            return {
                str: str[substring](4), //排除前4位字符串
                hex: str[substring](0, 4)[split]("")[reverse]()[join]("") //前4位倒序
            }
        },
        getDec: function (str) { //获取混淆字符位置坐标
            str = parseInt(str, 16)[toString](); //前4位倒序的16进制
            //str[substring](0, 2)[split]("");
            return {
                pre: str[substring](0, 2)[split](""), //前面坐标
                tail: str[substring](2)[split]("") //后面坐标
            }
        },
        delStr: function(str, pos) { //混淆的字符抽取
            var s = str[substring](0, pos[0]),
                del = str[substr](pos[0], pos[1]); //需替换的字符
            return s + str[substring](pos[0])[replace](del, ""); //返回替换完成后的base64字符串
        },
        getPos: function(str, pos) {
            return [str.length - pos[0] - pos[1], pos[1]];
        },
        decode: function(str) { //解密
            var sh = this.getHex(str), //获取前4位标记数字
                pos = this.getDec(sh.hex), //获取混淆位置坐标
                d = this.delStr(sh.str, pos.pre); //前面混淆的字符抽取
                d = this.delStr(d, this.getPos(d, pos.tail));
            return decodeURIComponent(escape(this.atob(d))); //base64转成utf-8(兼容中文) atob
        },
        encode: function(str) {//加密
            var base64 = this.btoa(unescape(encodeURIComponent(str))), //转换成baes64格式
                random = this.getRanNum(base64), //获取16进制是4位数的随机字符
                pos = this.getDec(random); //获取混淆位置坐标
            base64 = this.addStr(base64, pos); //插入混淆坐标
            //console.log(random, pos)
            return random[toString]()[split]("")[reverse]()[join]("")+base64;
        },
        addStr: function(str, pos) { //混淆的字符插入
            var r1 = this.getRanStr(pos.pre[1]), //获取随机字符串(前)
                r2 = this.getRanStr(pos.tail[1]), //获取随机字符串(后)
                pre = this.insertStr(str, r1, pos.pre[0]), //插入随机字符串(前)
                tail = pre.length - pos.tail[0];
            str = this.insertStr(pre, r2, tail); //插入随机字符串(后)
            return str;
        },
        atob:function(src) {//解密
            //用一个数组来存放解码后的字符。
            var str=new Array();
            var ch1, ch2, ch3, ch4;
            var pos=0;
            //过滤非法字符，并去掉'='。
            src = src.replace(/[^A-Za-z0-9\+\/]/g, '');
            //decode the source string in partition of per four characters.
            while (pos + 4 <= src.length) {
                ch1 = this.deKey[src.charCodeAt(pos++)];
                ch2 = this.deKey[src.charCodeAt(pos++)];
                ch3 = this.deKey[src.charCodeAt(pos++)];
                ch4 = this.deKey[src.charCodeAt(pos++)];
                str.push(String.fromCharCode(
                    (ch1<<2&0xff)+(ch2>>4), (ch2<<4&0xff)+(ch3>>2), (ch3<<6&0xff)+ch4));
            }
            //给剩下的字符进行解码。
            if (pos+1<src.length) {
                ch1 = this.deKey[src.charCodeAt(pos++)];
                ch2 = this.deKey[src.charCodeAt(pos++)];
                if (pos < src.length) {
                    ch3 = this.deKey[src.charCodeAt(pos)];
                    str.push(String.fromCharCode((ch1 << 2& 0xff) + (ch2>>4), (ch2<<4 & 0xff) + (ch3>>2)));
                } else {
                    str.push(String.fromCharCode((ch1<<2&0xff) + (ch2>>4)));
                }
            }
            //组合各解码后的字符，连成一个字符串。
            return str.join('');
        },
        btoa: function(src) { //加密
            //用一个数组来存放编码后的字符，效率比用字符串相加高很多。
            var str = new Array();
            var ch1, ch2, ch3;
            var pos = 0;
            //每三个字符进行编码
            while (pos+3 <= src.length) {
                ch1 = src.charCodeAt(pos++);
                ch2 = src.charCodeAt(pos++);
                ch3 = src.charCodeAt(pos++);
                str.push(this.enKey.charAt(ch1>>2), this.enKey.charAt(((ch1<<4)+(ch2>>4))&0x3f));
                str.push(this.enKey.charAt(((ch2<<2)+(ch3>>6))&0x3f), this.enKey.charAt(ch3&0x3f));
             }
             //给剩下的字符进行编码。
             if(pos<src.length){
               ch1=src.charCodeAt(pos++);
               str.push(this.enKey.charAt(ch1>>2));
               if(pos<src.length){
                 ch2=src.charCodeAt(pos);
                 str.push(this.enKey.charAt(((ch1<<4)+(ch2>>4))&0x3f));
                 str.push(this.enKey.charAt(ch2<<2&0x3f), '=');
               }else{
                 str.push(this.enKey.charAt(ch1<<4&0x3f), '==');
               }
            }
            //组合各编码后的字符，连成一个字符串。
            return str.join('');
        },
        insertStr: function(str, addstr, pos) { //往指定位置插入字符串
            return str[substring](0, pos) + addstr + str[substring](pos);
        },
        getRanNum: function(str) { //获取16进制是4位数的4位随机字符
            var ranArr = [];
            ;(function() {
                var n = '',
                    length = src.length;
                /** 4101开始16进制是4位数**/
                for (var i=4101; i<=9999; i++) { //找到所有符合要求的16进制4位数
                    n = i[toString](16); //10转成16
                    if (length  >= 8 && !(Math.floor(i/100) % 10 === 0 || i%10 === 0) && n.length === 4) {
                        //正常的base64编码长度大于8才前后加混淆字符
                        //console.log(i, n);
                        if (Math.floor(i/1000)<= length/2&&Math.floor(i%100/10) <= length/2) { //混淆位置不能大于长度一半
                            ranArr.push(n);
                        }
                    } else if (i%100 === 0 && n.length === 4) { //只在前面插入混淆字符
                        if (Math.floor(i/1000) <= length) { //混淆位置不能大于长度
                            ranArr.push(n);
                        }
                    }
                }
            }());
            var length = ranArr.length,
                ran = Math.round(Math.random()*(length - 1));
            return ranArr[ran];
        },
        enKey:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
        deKey: new Array(
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
            52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
            -1, 0, 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, -1, -1, -1, -1, -1,
            -1, 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, -1, -1, -1, -1, -1
        ),
        getRanStr:function(num){//获取指定个数随机字符串
            var key=this.enKey.split("");
                length=key.length,
                res = "";
            for (; num-- ;) {
                var id = Math.round(Math.random() * (length - 1));
                res += key[id];
            }
            return res;
        }
    }
    base64.tranCode=fn;
    window.base64 = base64;
}(window.base64||{}));

以上代码已经带有一些注释，就不详细说明了。不明白或有指教的请留言吧！

另附上php版的加密算法：

class base64{
    public function encode($str) { //加密
        if ($str != '') {
            $base64 = base64_encode($str);
            $random = $this->getRanNum($base64); //获取16进制是4位数的随机字符
            $pos = $this->getDec($random); //获取混淆位置坐标
            $base64 = $this->addStr($base64, $pos); //插入混淆字符
            return join('', array_reverse(str_split($random))).$base64;
        }
        return null;
    }
    private function getRanNum($str) {
        $length = strlen($str);
        $ranArr = array();
        /** 4101开始16进制是4位数 **/
        for ($i=4101; $i <= 9999; $i++) { //找出所有符合要求的16进制的4位数
            $n = dechex($i); //10转成16
            if ($length >= 8 && !(floor($i/100)%10 == 0 || $i%10 === 0) && strlen($n) === 4) {
                //正常的base64编码长度大于8才前后加混淆字符
                if (floor($i/1000) <= $length/2 && floor($i%100/10) <= $length/2) {//混淆位置不能大于长度一半
                    array_push($ranArr, $n);
                }
            } else if ($i%100 === 0 && strlen($n) === 4) { //只在前面插入混淆字符
                if (floor($i/1000) <= $length) { //混淆位置不能大于长度
                    array_push($ranArr, $n);
                }
            }
        }
        $ran = rand(0, count($ranArr) - 1);
        return $ranArr[$ran];
    }
    private function getDec($str) {
        $str = hexdec($str); //前4位倒序的16进制
        return [
            "pre" => str_split(substr($str, 0, 2)), //前面坐标
            "tail" => str_split(substr($str, 2) //后面坐标
        ];
    }
    private function addStr($str, $pos) {
        $r1 = $this->getRanStr($pos["pre"][1]); //获取随机字符串(前)
        $r2 = $this->getRanStr($pos["tail"][1]); //获取随机字符串(后)
        $pre = $this->insertStr($str, $r1, $pos["pre"][0]); //插入随机字符串(前)
        $tail = strlen($pre) - $pos["tail"][0];
        $str = this->insertStr($pre, $r2, $tail); //插入随机字符串(后)
        return $str;
    }
    private function getRanStr($num) { //获取指定个数随机字符串
        $enKey="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        $str = str_split($enKey);
        $length = count($str);
        $res = "";
        for (; $num--; ) {
            $id = rand(0, $length - 1);
            $res .= $str[$id];
        }
        return $res;
    }
    private function insertStr($str, $addstr, $pos) {
        return substr($str, 0, $pos).$addstr.substr($str, $pos);
    }
}

算法兼容对美拍视频地址的解密！同时兼容其他内容的加密，同时兼容中文的加密、解密。

反推加密算法的过程是烧脑的，但也是有意思的，在成功的那一瞬间还是有点小兴奋的。

写了一个demo，有兴趣的可以下载看看，如图。下载地址为：https://github.com/zhouxitian/base64

欢迎指教！！！

以上代码只为研究学习使用。

zhangge3663
关注
专栏目录
php文件加密网站源码（基于base64和混淆加密）
憨豆婆的博客
06-25 1732
保护源代码：PHP 是一种脚本语言，源代码是以明文形式存储在服务器上的。通过对 PHP 代码进行加密，可以增加源代码的保密性，使其更难以被未经授权的人员获取和理解。这对于一些商业应用程序或具有商业价值的软件来说尤为重要，以防止他人盗取您的代码。防止篡改：通过对 PHP 代码进行加密，可以提高代码的完整性和安全性。加密后的代码更难以被篡改，减少了潜在的恶意攻击和漏洞利用的可能性。保护敏感信息：如果您的 PHP 代码中包含敏感信息，例如数据库连接凭证、API 密钥等，加密代码可以增加这些敏感信息的保护。
Python实现base64加解密，轻松爬取网页数据
热门推荐
景天科技苑
02-05 1万+
Base64是一种用64个字符来表示任意二进制数据的方法。base64是一种编码方式而不是加密算法。只是看上去像是加密而已。 比如A用10编码 *用c来编码。 Base64使用A--Z，a--z，0--9，+，/ 这64个字符实现对数据进行加密。 用这64个符号来描述出不同的字节。
Base64 混淆加密+迭代次数，Base64前后端加解密不一致、Base64 js加解密结果与java加解密结果不一致，Base64中文加密乱码
qq_32352777的博客
01-14 5625
Table of Contents 概述 一、js加密，java解密 1、js加密 1、中文字符串加密 2、英文等字符串加密 3、中文字符串混淆、迭代加密 4、英文等字符串混淆、迭代加密 5、JSON数据混淆、迭代加密 2、Java解密 二、java加密，js解密 1、Java加密 1、中文字符串加密 2、英文等字符串加密 3、中文字符串混淆、迭代加密 4、英文等字符...
压缩和混淆
最新发布
dafan0的博客
07-02 510
*代码压缩：**在对用户体验造成影响的因素中，最重要的是“网页打开速度”，即资源加载速度和页面渲染速度。**代码加密：**将JavaScript代码转成人无法阅读或解析的代码，如借用WebAssembly技术，可以直接将JavaScript代码用C/C++实现，JavaScript调用其编译后形成的文件来执行相应的功能。代码编码之AAEncode与JJEncode：AAEncode能将JavaScript代码转换为颜文字，而JJEncode则将代码转换为“$”、“_”、“+”组成的字符。
MD5加密和Base64混淆
weixin_55914700的博客
06-09 213
utlis类 implementation 'com.alibaba:fastjson:1.2.72'//fastjson依赖 package com.example.commom; import android.util.Base64; import android.util.Log; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.Compar
利用os和base64生成随机字符串
weixin_34240520的博客
12-20 146
import osimport base64a = os.urandom(46)b = base64.b64encode(a)print(b) # b'yn5VoGp1+LNzG8NqjMCFfAzqWrqwj+mR1u2tCKJDaqKPnMGCHMFruazlQAG4Hg=='print(b.decode('utf-8')) # yn5VoGp1+LNzG8NqjMCFfAzqWrqwj+mR...
Base64混合加解密破解
Leon~博客
05-12 3824
目录 方法一：反向暴力破解，已知：{密文，加密算法}， 未知：{加密顺序，即密钥} 方法二：正向暴力破解，已知：{密文，加密算法，部分明文}，未知：{加密顺序} 方法三：异常处理，根据解密时产生的错误异常处理来破解密文 方法四：编码识别 根据base64，base32和base16的编码方式不同来破解密文 方法一：反向暴力破解，已知：{密文，加密算法}， 未知：{加密顺序，即密钥} # 算法逆向破解 # 加密函数，flag是某个字符串 import random import base64
base64 + AES 前端加密解密代码实现
ParisT_T的博客
11-04 1671
需要两个自己定义的值。一个是密钥key，一个是偏移量iv。 1.页面引入js <script type="text/javascript" src="js/crypto-js.js"></script> 2.加密函数 var key= '' ; var iv= '' ; var test= '' ; //test是明文 encrypt: function (text) { var key = CryptoJS.enc.Utf8.parse(key),
Java中的Base64加/解密
09-10
Demo中使用base64对数据进行加/解密，包括前台页面js和后台数据处理，使用此方法，可以保证用户输入的数据具有安全性，另外有一种方式具有不可逆解密，保证了数据的不可见性。希望下载的伙伴，有所收获，谢谢！！！
【Java进阶开发实战】用Java中的Base64数据加密与解密处理
Gorden的博客
11-24 1557
base64
php加密解密字符串示例
12-18
值得注意的是，此示例中使用了Base64编码来处理加密后的结果，这是为了应对可能出现的特殊字符问题，确保加密后的字符串在传输和存储时不会出现问题。 在实际应用中，PHP还提供了许多内置的加密库和函数，例如： 1....
maskBase64：使用base64进行数据混淆
02-20
maskBase64 使用压缩和base64进行数据混淆 该过程采用消息字符串（STR1）和用户字符串（STR2）并分别压缩CSTR1和CSTR2。 然后，对压缩的字符串进行Base64编码，并去除压缩标头，页脚和Base64填充。 然后将修改后的字符串以CSTR1 [1] CSTR2 [1] CSTR1 [2] CSTR2 [2] ..... CSTR1 [n] CSTR2 [n]的形式混合在一起，其中n = CSTR1的长度。 STR1 =这是一个测试 STR2 =填充空格的短语 CSTR1 = yvJyCxWAKJEhZLU4hIA6uceDQ4 CSTR2 = 0tUKMgoSixOVSjJV0jLzMlRKMlIVSguSExOBQA1utowGg 混淆文字= y0vtJUyKCMxgWoASKiJxEOhVZSLjUJ4Vh0IjAL6zuMcleRDKQM4l
python3利用base64编码生成随机文件
三水有余的博客
06-15 619
python3利用base64编码生成随机文件 在测试某些功能的时候，我们可能需要用一些文件来作为测试的对象，利用python生成这些随机文件是不错的选择。虽然tempfile库已经有类似的功能了，但我还是想自己造一个轮子。 使用的库 base64 random 思路 无论是生成文件还是生成文件名，我们需要的都是一个合法的字符串（此处合法指不违背用途要求），而字符串可以看成一系列的二进制字节编码而成的对象，因此，我们需要一个大随机数以生成这个随机的字符串。 问题来了，这个大随机数应该怎么确定位长
vue中base64加密以及base64在ie浏览器中导致页面空白的问题
only_zing的博客
08-03 443
vue中base64加密以及base64在ie中导致页面空白问题
base64算法加密 、解密
小灰的博客
09-23 704
public class Base64Utils { // 加密 public static String getBase64(String str) { byte[] b = null; String s = null; try { b = str.getBytes("utf-8");
【Python爬虫】之西瓜视频地址解密20210822
qq_33516409的博客
08-22 5785
目录 前言 代码 前言 最近找工作需要看一些面试看，无意间看到有个题说是要获取一个链接里面的视频地址。链接：https://www.ixigua.com/i6704446868685849092 兴趣来了，抵挡不住这股冲动，点进去链接一看，= =！居然是小猪佩奇！！ 罢了，小猪佩奇就小猪佩奇吧，整就完事了。先右键检查元素看一眼 http://v9-xg-web-s.ixigua.com/1b92afae1bebac684f789947b67997f7/612222...
java 文件压缩 base64加解密 生成指定随机数 时间换算 获取系统 获取mac等小结
qq_23625847的博客
10-09 696
平常开发中会遇到一些小而有用的程序，可以拿过来就用的，现整理如下 首先，是比较杂乱的小方法 import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutpu
Go语言实现Base64与Base58加密解密原理详解
本文主要介绍了Base64和Base58两种二进制编码方法的原理，以及如何在Go语言中实现它们的加密解密过程。 Base64是一种常见的二进制到文本的编码方式，主要用于在ASCII环境中传输二进制数据，如电子邮件中的附件。它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值