鼠标_锁定() 完善 及 增加 校验_取HmacSHA256() 的方法

xuezhq

鼠标_锁定()


.版本 2

鼠标锁定状态 ＝ 状态
UnhookWindowsHookEx (鼠标锁定钩子句柄)  ' 锁定鼠标前，卸载上次的锁定钩子
鼠标锁定钩子句柄 ＝ SetWindowsHookExA (14, &鼠标钩子处理, GetModuleHandleA1 (0), 0)  ' 载入鼠标钩子


当重复多次调用“鼠标_锁定()”后，使用“鼠标_解锁()”将无法解除，建议在锁定时先调用解锁以后再进行锁定，防止多次调用锁定而不解锁的问题！
====================================================================================

建议增加：校验_取HmacSHA256() 的方法
可用于腾讯等验签使用
代码如下：

.版本 2

.子程序 校验_取HmacSHA256, 文本型, 公开
.参数 加密文本, 文本型
.参数 密钥, 文本型
.局部变量 脚本对象, 对象
.局部变量 局部文本, 文本型

CoInitialize (0)
脚本对象.创建 (“ScriptControl”, )
脚本对象.写属性 (“Language”, “JScript”)
脚本对象.数值方法 (“ExecuteStatement”, #SHA256脚本)
局部文本 ＝ 脚本对象.文本方法 (“Run”, “HMAC”, 加密文本, 密钥)
CoUninitialize ()  ' 返回之前使用 必须释放掉对象才可用
返回 (局部文本)


===========================================================
#SHA256脚本  '新长文本常量内容如下：
var CryptoJS = CryptoJS ||
function(h, i) {
        var e = {},
        f = e.lib = {},
        l = f.Base = function() {
                function a() {}
                return {
                        extend: function(j) {
                                a.prototype = this;
                                var d = new a;
                                j && d.mixIn(j);
                                d.$super = this;
                                return d
                        },
                        create: function() {
                                var a = this.extend();
                                a.init.apply(a, arguments);
                                return a
                        },
                        init: function() {},
                        mixIn: function(a) {
                                for (var d in a) a.hasOwnProperty(d) && (this[d] = a[d]);
                                a.hasOwnProperty("toString") && (this.toString = a.toString)
                        },
                        clone: function() {
                                return this.$super.extend(this)
                        }
                }
        } (),
        k = f.WordArray = l.extend({
                init: function(a, j) {
                        a = this.words = a || [];
                        this.sigBytes = j != i ? j: 4 * a.length
                },
                toString: function(a) {
                        return (a || m).stringify(this)
                },
                concat: function(a) {
                        var j = this.words,
                        d = a.words,
                        c = this.sigBytes,
                        a = a.sigBytes;
                        this.clamp();
                        if (c % 4) for (var b = 0; b < a; b++) j[c + b >>> 2] |= (d[b >>> 2] >>> 24 - 8 * (b % 4) & 255) << 24 - 8 * ((c + b) % 4);
                        else if (65535 < d.length) for (b = 0; b < a; b += 4) j[c + b >>> 2] = d[b >>> 2];
                        else j.push.apply(j, d);
                        this.sigBytes += a;
                        return this
                },
                clamp: function() {
                        var a = this.words,
                        b = this.sigBytes;
                        a[b >>> 2] &= 4294967295 << 32 - 8 * (b % 4);
                        a.length = h.ceil(b / 4)
                },
                clone: function() {
                        var a = l.clone.call(this);
                        a.words = this.words.slice(0);
                        return a
                },
                random: function(a) {
                        for (var b = [], d = 0; d < a; d += 4) b.push(4294967296 * h.random() | 0);
                        return k.create(b, a)
                }
        }),
        o = e.enc = {},
        m = o.Hex = {
                stringify: function(a) {
                        for (var b = a.words, a = a.sigBytes, d = [], c = 0; c < a; c++) {
                                var e = b[c >>> 2] >>> 24 - 8 * (c % 4) & 255;
                                d.push((e >>> 4).toString(16));
                                d.push((e & 15).toString(16))
                        }
                        return d.join("")
                },
                parse: function(a) {
                        for (var b = a.length, d = [], c = 0; c < b; c += 2) d[c >>> 3] |= parseInt(a.substr(c, 2), 16) << 24 - 4 * (c % 8);
                        return k.create(d, b / 2)
                }
        },
        q = o.Latin1 = {
                stringify: function(a) {
                        for (var b = a.words, a = a.sigBytes, d = [], c = 0; c < a; c++) d.push(String.fromCharCode(b[c >>> 2] >>> 24 - 8 * (c % 4) & 255));
                        return d.join("")
                },
                parse: function(a) {
                        for (var b = a.length, d = [], c = 0; c < b; c++) d[c >>> 2] |= (a.charCodeAt(c) & 255) << 24 - 8 * (c % 4);
                        return k.create(d, b)
                }
        },
        r = o.Utf8 = {
                stringify: function(a) {
                        try {
                                return decodeURIComponent(escape(q.stringify(a)))
                        } catch(b) {
                                throw Error("Malformed UTF-8 data");
                        }
                },
                parse: function(a) {
                        return q.parse(unescape(encodeURIComponent(a)))
                }
        },
        b = f.BufferedBlockAlgorithm = l.extend({
                reset: function() {
                        this._data = k.create();
                        this._nDataBytes = 0
                },
                _append: function(a) {
                        "string" == typeof a && (a = r.parse(a));
                        this._data.concat(a);
                        this._nDataBytes += a.sigBytes
                },
                _process: function(a) {
                        var b = this._data,
                        d = b.words,
                        c = b.sigBytes,
                        e = this.blockSize,
                        g = c / (4 * e),
                        g = a ? h.ceil(g) : h.max((g | 0) - this._minBufferSize, 0),
                        a = g * e,
                        c = h.min(4 * a, c);
                        if (a) {
                                for (var f = 0; f < a; f += e) this._doProcessBlock(d, f);
                                f = d.splice(0, a);
                                b.sigBytes -= c
                        }
                        return k.create(f, c)
                },
                clone: function() {
                        var a = l.clone.call(this);
                        a._data = this._data.clone();
                        return a
                },
                _minBufferSize: 0
        });
        f.Hasher = b.extend({
                init: function() {
                        this.reset()
                },
                reset: function() {
                        b.reset.call(this);
                        this._doReset()
                },
                update: function(a) {
                        this._append(a);
                        this._process();
                        return this
                },
                finalize: function(a) {
                        a && this._append(a);
                        this._doFinalize();
                        return this._hash
                },
                clone: function() {
                        var a = b.clone.call(this);
                        a._hash = this._hash.clone();
                        return a
                },
                blockSize: 16,
                _createHelper: function(a) {
                        return function(b, d) {
                                return a.create(d).finalize(b)
                        }
                },
                _createHmacHelper: function(a) {
                        return function(b, d) {
                                return g.HMAC.create(a, d).finalize(b)
                        }
                }
        });
        var g = e.algo = {};
        return e
} (Math); (function(h) {
        var i = CryptoJS,
        e = i.lib,
        f = e.WordArray,
        e = e.Hasher,
        l = i.algo,
        k = [],
        o = []; (function() {
                function e(a) {
                        for (var b = h.sqrt(a), d = 2; d <= b; d++) if (! (a % d)) return ! 1;
                        return ! 0
                }
                function f(a) {
                        return 4294967296 * (a - (a | 0)) | 0
                }
                for (var b = 2, g = 0; 64 > g;) e(b) && (8 > g && (k[g] = f(h.pow(b, 0.5))), o[g] = f(h.pow(b, 1 / 3)), g++),
                b++
        })();
        var m = [],
        l = l.SHA256 = e.extend({
                _doReset: function() {
                        this._hash = f.create(k.slice(0))
                },
                _doProcessBlock: function(e, f) {
                        for (var b = this._hash.words, g = b[0], a = b[1], j = b[2], d = b[3], c = b[4], h = b[5], l = b[6], k = b[7], n = 0; 64 > n; n++) {
                                if (16 > n) m[n] = e[f + n] | 0;
                                else {
                                        var i = m[n - 15],
                                        p = m[n - 2];
                                        m[n] = ((i << 25 | i >>> 7) ^ (i << 14 | i >>> 18) ^ i >>> 3) + m[n - 7] + ((p << 15 | p >>> 17) ^ (p << 13 | p >>> 19) ^ p >>> 10) + m[n - 16]
                                }
                                i = k + ((c << 26 | c >>> 6) ^ (c << 21 | c >>> 11) ^ (c << 7 | c >>> 25)) + (c & h ^ ~c & l) + o[n] + m[n];
                                p = ((g << 30 | g >>> 2) ^ (g << 19 | g >>> 13) ^ (g << 10 | g >>> 22)) + (g & a ^ g & j ^ a & j);
                                k = l;
                                l = h;
                                h = c;
                                c = d + i | 0;
                                d = j;
                                j = a;
                                a = g;
                                g = i + p | 0
                        }
                        b[0] = b[0] + g | 0;
                        b[1] = b[1] + a | 0;
                        b[2] = b[2] + j | 0;
                        b[3] = b[3] + d | 0;
                        b[4] = b[4] + c | 0;
                        b[5] = b[5] + h | 0;
                        b[6] = b[6] + l | 0;
                        b[7] = b[7] + k | 0
                },
                _doFinalize: function() {
                        var e = this._data,
                        f = e.words,
                        b = 8 * this._nDataBytes,
                        g = 8 * e.sigBytes;
                        f[g >>> 5] |= 128 << 24 - g % 32;
                        f[(g + 64 >>> 9 << 4) + 15] = b;
                        e.sigBytes = 4 * f.length;
                        this._process()
                }
        });
        i.SHA256 = e._createHelper(l);
        i.HmacSHA256 = e._createHmacHelper(l)
})(Math); (function() {
        var h = CryptoJS,
        i = h.enc.Utf8;
        h.algo.HMAC = h.lib.Base.extend({
                init: function(e, f) {
                        e = this._hasher = e.create();
                        "string" == typeof f && (f = i.parse(f));
                        var h = e.blockSize,
                        k = 4 * h;
                        f.sigBytes > k && (f = e.finalize(f));
                        for (var o = this._oKey = f.clone(), m = this._iKey = f.clone(), q = o.words, r = m.words, b = 0; b < h; b++) q ^= 1549556828,
                        r ^= 909522486;
                        o.sigBytes = m.sigBytes = k;
                        this.reset()
                },
                reset: function() {
                        var e = this._hasher;
                        e.reset();
                        e.update(this._iKey)
                },
                update: function(e) {
                        this._hasher.update(e);
                        return this
                },
                finalize: function(e) {
                        var f = this._hasher,
                        e = f.finalize(e);
                        f.reset();
                        return f.finalize(this._oKey.clone().concat(e))
                }
        })
})();

function HMAC(test, hmacKey)
{
var anEncryptedKey = CryptoJS.HmacSHA256(test, hmacKey);
        return anEncryptedKey;
}

zhanshenbsq

不懂也评论

不苦小和尚

校验_取HmacSHA256() 的方法好像没加啊

xuezhq

是否调整，请回复一下！