node ~ zip压缩 && 文件加密

咱们知道zip压缩,文件加密都是基于http的,下面我用用node实现着几个功能

zip压缩/解压

let zlib = require('zlib'); // 核心
let path = require('path');
let fs = require('fs');

// 压缩流 将1.txt压缩成1.txt.gz
function gzip(source){ //source文件目录
    let gzip = zlib.createGzip(); // 转化流 可读可写
    fs.createReadStream(source).pipe(gzip).pipe(fs.createWriteStream(source+'.gz')); //读=>压缩=>写新的
}
//gzip(path.join(__dirname, '1.txt'));
//解压
function ungzip(source) {
    let ungz = zlib.createGunzip();
    fs.createReadStream(source).pipe(ungz).pipe(fs.createWriteStream(path.join(__dirname,path.basename(source,'.gz'))));
}
ungzip(path.join(__dirname, '1.txt.gz'))
复制代码

发送请求的时候会有字段Accept-Encoding: gzip, deflate, br 支持哪一种压缩方式, 在写服务器的时候,浏览器会有个字段,响应头有Content-Encoding: gzip,浏览器会自动以这种方式解压,下面咱们来实现下压缩功能

let http = require('http');
let url=  require('url');
let path = require('path');
let fs = require('fs');
let zlib = require('zlib');
let server = http.createServer(function (req,res) {
    let {pathname} = url.parse(req.url,true);
    if(pathname === '/' || pathname === '\\') pathname = '\index.html';
    let p = path.join(__dirname,pathname);
    fs.stat(p,function (err,stat) {
        if(!err){
            let encoding = req.headers['accept-encoding'];
            if (encoding.match(/\bgzip\b/)){   //:,都叫边界
                res.setHeader('Content-Encoding','gzip');
                let gzip = zlib.createGzip();
                fs.createReadStream(p).pipe(gzip).pipe(res);
            } else if (encoding.match(/\bdeflate\b/)){
                res.setHeader('Content-Encoding', 'bdeflate');
                let deflate = zlib.createDeflate();
                fs.createReadStream(p).pipe(deflate).pipe(res);
            }else{
                fs.createReadStream(p).pipe(res);//不支持就原封不动的返还给客户端
            }
        }else{
          res.end();
        }
    })
})
server.listen(3000);
复制代码

文件加密

加密的过程是可逆的,可是MD5是不可逆的,加密有不少算法,例如对称加密,非对称加密(https),签名等,这种算法通常都是node内置的(crypto),这里咱们只说用法

crypto crypto是node.js中实现加密和解密的模块 在node.js中，使用OpenSSL类库做为内部实现加密解密的手段 OpenSSL是一个通过严格测试的可靠的加密与解密算法的实现工具

散列(哈希)算法 加盐算法

散列算法也叫哈希算法，用来把任意长度的输入变换成固定长度的输出,常见的有md5,sha1等

let crypto = require('crypto'); // 常见的加密模块
// console.log(crypto.getHashes());
//1)md5 其实不叫加密 ,叫摘要算法, 特色不可逆,输出结果长度相等,内容不一样输出的结果就不一样,反之相同

let md5 = crypto.createHash('md5') // 建立一个算法,常常用这种方式传文件
md5.update('123456'); // update加密 把哪段文字加密
let result1 = md5.digest('hex');//base64/hex16进制
let md52 = crypto.createHash('md5') // 建立一个算法,常常用这种方式传文件
md52.update('1234567'); // update加密 把哪段文字加密
let result = md52.digest('base64');//base64/hex16进制
// 若是存的是密码 屡次加密。 拖库
复制代码

//缺点 加密文件,会把文件读取到内存中,在文件很大的时候通常分段读,
let fs = require('fs');
let str = fs.readFileSync(__dirname+'/index.html','utf8');
let md53 = crypto.createHash('md5');
md53.update(str);
let result2 = md53.digest('hex');
console.log(result2);

//客户端第二次请求文件,服务器会先判断加密是否一致,若是一致会返回304从缓存中读取,
let md54 = crypto.createHash('md5');
let rs = fs.createReadStream(__dirname + '/index.html',{highWaterMark:3});
rs.on('data',function (data) {
      md54.update(data); // update能够调用屡次 data是buffer
});
rs.on('end', function (data) {
    console.log(md54.digest('hex'));
})
复制代码

HMAC算法

可用的摘要算法，例如 sha一、md五、sha256

// ------------ 加盐算法
let crypto = require('crypto');
let hmac = crypto.createHmac('sha1', 'zdl'); //加zdl的味道zdl为一个字符串，用于指定一个PEM格式的密钥,PEM不一样生成的秘钥也不一样
hmac.update('123456');
let result = hmac.digest('hex');
console.log(result);
复制代码

可是以上客户端发送给乙方的时候仍是会不安全,在发送的过程当中有可能被劫持,咱们能够用openssl genrsa -out rsa_private.key 1024 生成1024字节的秘钥,字节越多越安全

// PEM是OpenSSL的标准格式，OpenSSL使用PEM文件格式存储证书和密钥，是基于Base64编码的证书。
let fs = require('fs');
let pem  = fs.readFileSync(__dirname+'/rsa_private.key');
let key = pem.toString('ascii');
let hmac = crypto.createHmac('sha1', key);
hmac.update('zdl');
let result = hmac.digest('hex');
console.log(result);
复制代码

对称加密

blowfish算法是一种对称的加密算法,对称的意思就是加密和解密使用的是同一个密钥。

缺点:对,名字有限制,最多接受14个字符

let crypto = require('crypto');
let fs = require('fs');
let key = fs.readFileSync(__dirname + '/rsa_private.key')
let cipher = crypto.createCipher('blowfish', key);
cipher.update('zdl');
let result = cipher.final('hex');
console.log(result);

//解密
let deciper = crypto.createDecipher('blowfish', key);
// 告诉他刚才加密的是hex
deciper.update(result,'hex');
let r = deciper.final('utf8');
console.log(r);
复制代码

非对称加密

公钥加密私钥解密

算公钥 openssl rsa -in rsa_private.key -pubout -out rsa_public.key

// 非对称加密
let crypto = require('crypto');
let fs = require('fs');
let public = fs.readFileSync(__dirname+'/rsa_public.key','utf8');
let private = fs.readFileSync(__dirname +'/rsa_private.key','utf8');
let result = crypto.publicEncrypt(public, Buffer.from('hello'));
let r = crypto.privateDecrypt(private, result);
console.log(r.toString());
复制代码

相对安全,若是客户端给服务端加个凭证,这种状况须要加密后发送,,以前可能写个算法,把当前字符串前几个后几个取出来中间作排序,而后拼回去,每段时间换一次~~~

签名会在cookie中解释