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中解釋