/*
CryptoJS v3.1.2
code.google.com/p/crypto-js
(c) 2009-2013 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
加密算法
*/
var CryptoJS = CryptoJS || function(g, l) {
var e = {}, d = e.lib = {}, m = function() {}, k = d.Base = {
extend: function(a) {
m.prototype = this;
var c = new m;
a && c.mixIn(a);
c.hasOwnProperty("init") || (c.init = function() {
c.$super.init.apply(this, arguments)
});
c.init.prototype = c;
c.$super = this;
return c
},
create: function() {
var a = this.extend();
a.init.apply(a, arguments);
return a
},
init: function() {},
mixIn: function(a) {
for (var c in a) a.hasOwnProperty(c) && (this[c] = a[c]);
a.hasOwnProperty("toString") && (this.toString = a.toString)
},
clone: function() {
return this.init.prototype.extend(this)
}
},
p = d.WordArray = k.extend({
init: function(a, c) {
a = this.words = a || [];
this.sigBytes = c != l ? c : 4 * a.length
},
toString: function(a) {
return (a || n).stringify(this)
},
concat: function(a) {
var c = this.words,
q = a.words,
f = this.sigBytes;
a = a.sigBytes;
this.clamp();
if (f % 4)
for (var b = 0; b < a; b++) c[f + b >>> 2] |= (q[b >>> 2] >>> 24 - 8 * (b % 4) & 255) << 24 - 8 * ((f + b) % 4);
else if (65535 < q.length)
for (b = 0; b < a; b += 4) c[f + b >>> 2] = q[b >>> 2];
else c.push.apply(c, q);
this.sigBytes += a;
return this
},
clamp: function() {
var a = this.words,
c = this.sigBytes;
a[c >>> 2] &= 4294967295 << 32 - 8 * (c % 4);
a.length = g.ceil(c / 4)
},
clone: function() {
var a = k.clone.call(this);
a.words = this.words.slice(0);
return a
},
random: function(a) {
for (var c = [], b = 0; b < a; b += 4) c.push(4294967296 * g.random() | 0);
return new p.init(c, a)
}
}),
b = e.enc = {}, n = b.Hex = {
stringify: function(a) {
var c = a.words;
a = a.sigBytes;
for (var b = [], f = 0; f < a; f++) {
var d = c[f >>> 2] >>> 24 - 8 * (f % 4) & 255;
b.push((d >>> 4).toString(16));
b.push((d & 15).toString(16))
}
return b.join("")
},
parse: function(a) {
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);
return new p.init(b, c / 2)
}
}, j = b.Latin1 = {
stringify: function(a) {
var c = a.words;
a = a.sigBytes;
for (var b = [], f = 0; f < a; f++) b.push(String.fromCharCode(c[f >>> 2] >>> 24 - 8 * (f % 4) & 255));
return b.join("")
},
parse: function(a) {
for (var c = a.length, b = [], f = 0; f < c; f++) b[f >>> 2] |= (a.charCodeAt(f) & 255) << 24 - 8 * (f % 4);
return new p.init(b, c)
}
}, h = b.Utf8 = {
stringify: function(a) {
try {
return decodeURIComponent(escape(j.stringify(a)))
} catch (c) {
throw Error("Malformed UTF-8 data");
}
},
parse: function(a) {
return j.parse(unescape(encodeURIComponent(a)))
}
},
r = d.BufferedBlockAlgorithm = k.extend({
reset: function() {
this._data = new p.init;
this._nDataBytes = 0
},
_append: function(a) {
"string" == typeof a && (a = h.parse(a));
this._data.concat(a);
this._nDataBytes += a.sigBytes
},
_process: function(a) {
var c = this._data,
b = c.words,
f = c.sigBytes,
d = this.blockSize,
e = f / (4 * d),
e = a ? g.ceil(e) : g.max((e | 0) - this._minBufferSize, 0);
a = e * d;
f = g.min(4 * a, f);
if (a) {
for (var k = 0; k < a; k += d) this._doProcessBlock(b, k);
k = b.splice(0, a);
c.sigBytes -= f
}
return new p.init(k, f)
},
clone: function() {
var a = k.clone.call(this);
a._data = this._data.clone();
return a
},
_minBufferSize: 0
});
d.Hasher = r.extend({
cfg: k.extend(),
init: function(a) {
this.cfg = this.cfg.extend(a);
this.reset()
},
reset: function() {
r.reset.call(this);
this._doReset()
},
update: function(a) {
this._append(a);
this._process();
return this
},
finalize: function(a) {
a && this._append(a);
return this._doFinalize()
},
blockSize: 16,
_createHelper: function(a) {
return function(b, d) {
return (new a.init(d)).finalize(b)
}
},
_createHmacHelper: function(a) {
return function(b, d) {
return (new s.HMAC.init(a, d)).finalize(b)
}
}
});
var s = e.algo = {};
return e
}(Math);
(function() {
var g = CryptoJS,
l = g.lib,
e = l.WordArray,
d = l.Hasher,
m = [],
l = g.algo.SHA1 = d.extend({
_doReset: function() {
this._hash = new e.init([1732584193, 4023233417, 2562383102, 271733878, 3285377520])
},
_doProcessBlock: function(d, e) {
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++) {
if (16 > a) m[a] = d[e + a] | 0;
else {
var c = m[a - 3] ^ m[a - 8] ^ m[a - 14] ^ m[a - 16];
m[a] = c << 1 | c >>> 31
}
c = (n << 5 | n >>> 27) + l + m[a];
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);
l = g;
g = h;
h = j << 30 | j >>> 2;
j = n;
n = c
}
b[0] = b[0] + n | 0;
b[1] = b[1] + j | 0;
b[2] = b[2] + h | 0;
b[3] = b[3] + g | 0;
b[4] = b[4] + l | 0
},
_doFinalize: function() {
var d = this._data,
e = d.words,
b = 8 * this._nDataBytes,
g = 8 * d.sigBytes;
e[g >>> 5] |= 128 << 24 - g % 32;
e[(g + 64 >>> 9 << 4) + 14] = Math.floor(b / 4294967296);
e[(g + 64 >>> 9 << 4) + 15] = b;
d.sigBytes = 4 * e.length;
this._process();
return this._hash
},
clone: function() {
var e = d.clone.call(this);
e._hash = this._hash.clone();
return e
}
});
g.SHA1 = d._createHelper(l);
g.HmacSHA1 = d._createHmacHelper(l)
})();
(function() {
var g = CryptoJS,
l = g.enc.Utf8;
g.algo.HMAC = g.lib.Base.extend({
init: function(e, d) {
e = this._hasher = new e.init;
"string" == typeof d && (d = l.parse(d));
var g = e.blockSize,
k = 4 * g;
d.sigBytes > k && (d = e.finalize(d));
d.clamp();
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;
p.sigBytes = b.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 d = this._hasher;
e = d.finalize(e);
d.reset();
return d.finalize(this._oKey.clone().concat(e))
}
})
})();
//使用算法
var timestamp = Date.parse(new Date());
var real_time = new Date(timestamp) /1000;
var value="android"+real_time ;
var key="UGGHFTKKH545JGFGYF"
var sha1_result=CryptoJS.HmacSHA1(value,key);//第一个参数为加密字符串，第二个参数为公共秘钥
Kinect开发学习笔记之（一）Kinect介绍和应用[email protected]://blog.csdn.net/zouxy09 一、Kinect简介 Kinectfor Xbox 360，简称 Kinect，是由微软开发，应用于Xbox 360 主机的周边设备。它让玩家不需要手持或踩踏控制器，而是使用语音指令或手势来操作 Xbox360
`netstat` 这个命令一直以为是 net status 的缩写，今天一查发现并没有找到官方的这种说法，然后参考了 man 手册，发现这个词更像是 net statistics 的缩写，命令的作用是显示网络连接、路由表、接口连接、无效连接和多播成员关系的...
主题主题是一种定制Blockly外观和感觉的方法。目前我们支持在块和类别上自定义某些样式。我们创建主题的主要目标是授权开发人员创建更容易访问的块体验。然而，伴随着强大的力量而来的是巨大的责任。如果不需要控制块的所有三种样式值（块颜色、边框颜色和阴影块颜色），我们强烈建议用户坚持使用块颜色。很难找到协调一致的颜色，所以最简单的方法仍然是使用色调定义颜色，并允许Blockly计算边框和阴影块的...
目录第10章 文本聚类10.1 概述10.2 文档的特征提取10.3 k均值算法10.4 重复二分聚类算法10.5 标准化评测10.6 总结第10章 文本聚类上一章我们在字符、词语和句子的层级上应用了一些无监督学习方法。这些方法可以自动发现字符与字符、词语与词语、乃至句子与句子之间的联系，而不需要标注语料。同样，在文档层级上，无监督方法也可以在缺乏标注数据的条件下自动找出文档与文档之间的关联。正所谓物以类聚，人以群分。人类获取并积累信息时常常需要整理数据，将相..
Level of detailThis is asmart resource. Use a QR readeror theAurasmaapp to access additional content.https://goo.gl/ofoTXCLevel of detail is a met
apt-get使用本地安装源进行安装我们都喜欢使用apt-get，因为它实在是让我们大大的省心。但是，有时候我们会为网速慢，安装源不好而烦恼，所以我们可能会将一些常用软件包的 deb文件保存在本地以备不时之需。当然了使用dpkg也可以直接来安装保存在本地的deb软件包，问题是它并不能处理软件包之间的依赖 (dependence)关系，那么如何使用apt-get来安装保存在本地的软件包和源代码呢
模电知识整理（一）知识点零输入相应： 电容自然放电，电容器两端电压按照指数规律下降。零状态相应： 初始状态为0，开启开关，进行充电；电容器两端电压指数规律上升。零状态+零输入=全相应用方波作为输入波形（激励信号）： 上升沿作为0状态响应，下降沿作为0输入响应。相当于开关断和闭合状态。 条件：波形周期/2需要远远大于时间常数。微分电路： 输出信号是输入信号的微分。时间常数远小于T/2。...
Python 编程语言是一种高级、解释和通用的动态编程语言，专注于代码可读性。与Java或C ++相比，Python中的语法有助于程序员以更少的步骤进行编码。开发人员Guido Van Rossum于1991年创立的语言使编程变得轻松有趣。由于其多种编程范例，Python在大型组织中被广泛使用。它们通常涉及命令式和面向对象的函数式编程。它有一个全面的大型标准库，具有自动内存管理和动态特性。为什么公...
**P75（多态）：**一、什么是多态变量它有两个类型，一个是它的声明类型，一个是它的动态类型，它的声明类型永远是 Item，而它的动态类型是这次拿到是什么就是什么，可能是 CD 可能是 DVD当通过点运算符说 item 所管理的对象去做 print（）的动作的时候，它会让它所实际管理对象的那个类型去做 print（）的动作，这样子的一件事情叫做多态二、多态的技术基础是什么？绑定对于 Java 来说，所有的绑定都是动态绑定最后一点也是动态绑定，所有的成员函数的调用都应该是看作一种
redhat开源项目 RDO， 利用puppet 管理openstack使用RDO项目中的工具packstack 安装openstack：一种是 allinone 方式 ： 把openstack的各个组件全部安装到一台机器上去，安装的时候很多都是不可以定制，allinone只适合做测试环境，体验一下openstack同时，会预下载一个镜像cirros及配置模拟环境，从互联网上下载，其下载地址是国外...
1.APM2.APM启动
题目描述求A^B的最后三位数表示的整数（1<=A,B<=1000）输入第一行输入一个整数n，表示有n个测试实例，接着有n行，每行一个实例，给出两个正整数A,B输出针对每个测试实例，输出A^B的最后三位（没有前导0） ，单独占一行。#include <stdio.h>#include <math.h>int main(){ int n,a,b...