小程序 之使用HMACSHA1算法加密报文

狂风中的少年 提交于 2020-02-23 15:18:29

首先说说我们前端常用的加密技术,

我们常用的加密技术有:如MD5加密,base64加密

今天要说的是HMACSHA1加密技术

先介绍下什么是SHA1算法,

安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准 (Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产生一个160位的消息摘要。当接收到消息的时候,这个消息摘要可以用来验证数据的完整性。在传输的过程中,数据很可能会发生变化,那么这时候就会产生不同的消息摘要。 SHA1有如下特性:不可以从消息摘要中复原信息;两个不同的消息不会产生同样的消息摘要,(但会有1x10 ^ 48分之一的机率出现相同的消息摘要,一般使用时忽略)。

  SHA-1是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。

  单向散列函数的安全性在于其产生散列值的操作过程具有较强的单向性。如果在输入序列中嵌入密码,那么任何人在不知道密码的情况下都不能产生正确的散列值,从而保证了其安全性。SHA将输入流按照每块512位(64个字节)进行分块,并产生20个字节的被称为信息认证代码或信息摘要的输出。

  该算法输入报文的长度不限,产生的输出是一个160位的报文摘要。输入是按512 位的分组进行处理的。SHA-1是不可逆的、防冲突,并具有良好的雪崩效应。 通过散列算法可实现数字签名实现,数字签名的原理是将要传送的明文通过一种函数运算(Hash)转换成报文摘要(不同的明文对应不同的报文摘要),报文摘要加密后与明文一起传送给接受方,接受方将接受的明文产生新的报文摘要与发送方的发来报文摘要解密比较,比较结果一致表示明文未被改动,如果不一致表示明文已被篡改。

 

 

再介绍下什么是HMACSHA1算法

HMACSHA1 是从 SHA1 哈希函数构造的一种键控哈希算法,被用作 HMAC(基于哈希的消息验证代码)。 此 HMAC 进程将密钥与消息数据混合,使用哈希函数对混合结果进行哈希计算,将所得哈希值与该密钥混合,然后再次应用哈希函数。 输出的哈希值长度为 160 位。
在发送方和接收方共享机密密钥的前提下,HMAC 可用于确定通过不安全信道发送的消息是否已被篡改。 发送方计算原始数据的哈希值,并将原始数据和哈希值放在一个消息中同时传送。 接收方重新计算所接收消息的哈希值,并检查计算所得的 HMAC 是否与传送的 HMAC 匹配。
因为更改消息和重新生成正确的哈希值需要密钥,所以对数据或哈希值的任何更改都会导致不匹配。 因此,如果原始的哈希值与计算得出的哈希值相匹配,则消息通过身份验证。
SHA-1(安全哈希算法,也称为 SHS、安全哈希标准)是由美国政府发布的一种加密哈希算法。 它将从任意长度的字符串生成 28位长的字符串。

所以简单理解 就是HMACSHA1算法是一种含密钥的SHA1算法

前后端使用统一规定的密钥,则可以实现对报文的加密和解密,能使加密数据 更加安全

先说下小程序与js中使用HMACSHA1算法的区别,

首先,两者都是基于js,

其次,引用方法是略有不同,小程序中需要添加module.exports = CryptoJS暴露方法才能引用

最后,小程序中使用HMACSHA1算法加密出来是init类型,需要使用.toString()方法对结果进行转换

 

一,下载sha1.js文件,并放入小程序 的公用文件目录,如utils,并在sha1.js文件尾部添加小程序的module.exports = CryptoJS暴露方法

二,在要使用的加密的文件中引用sha1.js文件,并调用CryptoJS方法

var val = 'helloword'
console.log('明文:', val);
var key = "f7205fffe445408a84wqesadasdasdf" //密钥
var sha1 = require('../../utils/js/sha1.js');
var sha1Pw = sha1.HmacSHA1(val,key);
console.log('sha1加密:', sha1Pw.toString());

 

附:sha1.js文件

 

  1 /*
  2  * [js-sha1]
  3  *
  4  * @version 0.6.0
  5  * @author H, J-C [hjc_code@126.com]
  6  * @copyright H, J-C 2018-9-28
  7  * @license MIT
  8  */
  9 
 10 var CryptoJS = CryptoJS || function (g, l) {
 11   var e = {}, d = e.lib = {}, m = function () { }, k = d.Base = {
 12     extend: function (a) {
 13       m.prototype = this;
 14       var c = new m;
 15       a && c.mixIn(a);
 16       c.hasOwnProperty("init") || (c.init = function () {
 17         c.$super.init.apply(this, arguments)
 18       });
 19       c.init.prototype = c;
 20       c.$super = this;
 21       return c
 22     },
 23     create: function () {
 24       var a = this.extend();
 25       a.init.apply(a, arguments);
 26       return a
 27     },
 28     init: function () { },
 29     mixIn: function (a) {
 30       for (var c in a) a.hasOwnProperty(c) && (this[c] = a[c]);
 31       a.hasOwnProperty("toString") && (this.toString = a.toString)
 32     },
 33     clone: function () {
 34       return this.init.prototype.extend(this)
 35     }
 36   },
 37     p = d.WordArray = k.extend({
 38       init: function (a, c) {
 39         a = this.words = a || [];
 40         this.sigBytes = c != l ? c : 4 * a.length
 41       },
 42       toString: function (a) {
 43         return (a || n).stringify(this)
 44       },
 45       concat: function (a) {
 46         var c = this.words,
 47           q = a.words,
 48           f = this.sigBytes;
 49         a = a.sigBytes;
 50         this.clamp();
 51         if (f % 4)
 52           for (var b = 0; b < a; b++) c[f + b >>> 2] |= (q[b >>> 2] >>> 24 - 8 * (b % 4) & 255) << 24 - 8 * ((f + b) % 4);
 53         else if (65535 < q.length)
 54           for (b = 0; b < a; b += 4) c[f + b >>> 2] = q[b >>> 2];
 55         else c.push.apply(c, q);
 56         this.sigBytes += a;
 57         return this
 58       },
 59       clamp: function () {
 60         var a = this.words,
 61           c = this.sigBytes;
 62         a[c >>> 2] &= 4294967295 << 32 - 8 * (c % 4);
 63         a.length = g.ceil(c / 4)
 64       },
 65       clone: function () {
 66         var a = k.clone.call(this);
 67         a.words = this.words.slice(0);
 68         return a
 69       },
 70       random: function (a) {
 71         for (var c = [], b = 0; b < a; b += 4) c.push(4294967296 * g.random() | 0);
 72         return new p.init(c, a)
 73       }
 74     }),
 75     b = e.enc = {}, n = b.Hex = {
 76       stringify: function (a) {
 77         var c = a.words;
 78         a = a.sigBytes;
 79         for (var b = [], f = 0; f < a; f++) {
 80           var d = c[f >>> 2] >>> 24 - 8 * (f % 4) & 255;
 81           b.push((d >>> 4).toString(16));
 82           b.push((d & 15).toString(16))
 83         }
 84         return b.join("")
 85       },
 86       parse: function (a) {
 87         for (var c = a.length, b = [], f = 0; f < c; f += 2) b[f >>> 3] |= parseInt(a.substr(f, 2), 16) << 24 - 4 * (f % 8);
 88         return new p.init(b, c / 2)
 89       }
 90     }, j = b.Latin1 = {
 91       stringify: function (a) {
 92         var c = a.words;
 93         a = a.sigBytes;
 94         for (var b = [], f = 0; f < a; f++) b.push(String.fromCharCode(c[f >>> 2] >>> 24 - 8 * (f % 4) & 255));
 95         return b.join("")
 96       },
 97       parse: function (a) {
 98         for (var c = a.length, b = [], f = 0; f < c; f++) b[f >>> 2] |= (a.charCodeAt(f) & 255) << 24 - 8 * (f % 4);
 99         return new p.init(b, c)
100       }
101     }, h = b.Utf8 = {
102       stringify: function (a) {
103         try {
104           return decodeURIComponent(escape(j.stringify(a)))
105         } catch (c) {
106           throw Error("Malformed UTF-8 data");
107         }
108       },
109       parse: function (a) {
110         return j.parse(unescape(encodeURIComponent(a)))
111       }
112     },
113     r = d.BufferedBlockAlgorithm = k.extend({
114       reset: function () {
115         this._data = new p.init;
116         this._nDataBytes = 0
117       },
118       _append: function (a) {
119         "string" == typeof a && (a = h.parse(a));
120         this._data.concat(a);
121         this._nDataBytes += a.sigBytes
122       },
123       _process: function (a) {
124         var c = this._data,
125           b = c.words,
126           f = c.sigBytes,
127           d = this.blockSize,
128           e = f / (4 * d),
129           e = a ? g.ceil(e) : g.max((e | 0) - this._minBufferSize, 0);
130         a = e * d;
131         f = g.min(4 * a, f);
132         if (a) {
133           for (var k = 0; k < a; k += d) this._doProcessBlock(b, k);
134           k = b.splice(0, a);
135           c.sigBytes -= f
136         }
137         return new p.init(k, f)
138       },
139       clone: function () {
140         var a = k.clone.call(this);
141         a._data = this._data.clone();
142         return a
143       },
144       _minBufferSize: 0
145     });
146   d.Hasher = r.extend({
147     cfg: k.extend(),
148     init: function (a) {
149       this.cfg = this.cfg.extend(a);
150       this.reset()
151     },
152     reset: function () {
153       r.reset.call(this);
154       this._doReset()
155     },
156     update: function (a) {
157       this._append(a);
158       this._process();
159       return this
160     },
161     finalize: function (a) {
162       a && this._append(a);
163       return this._doFinalize()
164     },
165     blockSize: 16,
166     _createHelper: function (a) {
167       return function (b, d) {
168         return (new a.init(d)).finalize(b)
169       }
170     },
171     _createHmacHelper: function (a) {
172       return function (b, d) {
173         return (new s.HMAC.init(a, d)).finalize(b)
174       }
175     }
176   });
177   var s = e.algo = {};
178   return e
179 }(Math);
180 (function () {
181   var g = CryptoJS,
182     l = g.lib,
183     e = l.WordArray,
184     d = l.Hasher,
185     m = [],
186     l = g.algo.SHA1 = d.extend({
187       _doReset: function () {
188         this._hash = new e.init([1732584193, 4023233417, 2562383102, 271733878, 3285377520])
189       },
190       _doProcessBlock: function (d, e) {
191         for (var b = this._hash.words, n = b[0], j = b[1], h = b[2], g = b[3], l = b[4], a = 0; 80 > a; a++) {
192           if (16 > a) m[a] = d[e + a] | 0;
193           else {
194             var c = m[a - 3] ^ m[a - 8] ^ m[a - 14] ^ m[a - 16];
195             m[a] = c << 1 | c >>> 31
196           }
197           c = (n << 5 | n >>> 27) + l + m[a];
198           c = 20 > a ? c + ((j & h | ~j & g) + 1518500249) : 40 > a ? c + ((j ^ h ^ g) + 1859775393) : 60 > a ? c + ((j & h | j & g | h & g) - 1894007588) : c + ((j ^ h ^ g) - 899497514);
199           l = g;
200           g = h;
201           h = j << 30 | j >>> 2;
202           j = n;
203           n = c
204         }
205         b[0] = b[0] + n | 0;
206         b[1] = b[1] + j | 0;
207         b[2] = b[2] + h | 0;
208         b[3] = b[3] + g | 0;
209         b[4] = b[4] + l | 0
210       },
211       _doFinalize: function () {
212         var d = this._data,
213           e = d.words,
214           b = 8 * this._nDataBytes,
215           g = 8 * d.sigBytes;
216         e[g >>> 5] |= 128 << 24 - g % 32;
217         e[(g + 64 >>> 9 << 4) + 14] = Math.floor(b / 4294967296);
218         e[(g + 64 >>> 9 << 4) + 15] = b;
219         d.sigBytes = 4 * e.length;
220         this._process();
221         return this._hash
222       },
223       clone: function () {
224         var e = d.clone.call(this);
225         e._hash = this._hash.clone();
226         return e
227       }
228     });
229   g.SHA1 = d._createHelper(l);
230   g.HmacSHA1 = d._createHmacHelper(l)
231 })();
232 (function () {
233   var g = CryptoJS,
234     l = g.enc.Utf8;
235   g.algo.HMAC = g.lib.Base.extend({
236     init: function (e, d) {
237       e = this._hasher = new e.init;
238       "string" == typeof d && (d = l.parse(d));
239       var g = e.blockSize,
240         k = 4 * g;
241       d.sigBytes > k && (d = e.finalize(d));
242       d.clamp();
243       for (var p = this._oKey = d.clone(), b = this._iKey = d.clone(), n = p.words, j = b.words, h = 0; h < g; h++) n[h] ^= 1549556828, j[h] ^= 909522486;
244       p.sigBytes = b.sigBytes = k;
245       this.reset()
246     },
247     reset: function () {
248       var e = this._hasher;
249       e.reset();
250       e.update(this._iKey)
251     },
252     update: function (e) {
253       this._hasher.update(e);
254       return this
255     },
256     finalize: function (e) {
257       var d = this._hasher;
258       e = d.finalize(e);
259       d.reset();
260       return d.finalize(this._oKey.clone().concat(e))
261     }
262   })
263 })();
264 
265 //使用算法
266 // var key = "f7205fffe445421fdssdfsdfdsfs"
267 // var sha1_result = CryptoJS.HmacSHA1("helloword", key)
268 // console.log('-------',sha1_result.toString())
269 
270 
271 module.exports = CryptoJS;
View Code

 

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!