前言:

在伟大的计算机科学家研究下,发明了许多的加密算法,以下做个简答的描述:

一、分类

加密算法分为两种:单向加密、双向加密。

单向加密,不可逆的加密算法,只能加密不能解密;

双向加密,由对称性加密算法和非对称性加密算法;

对称性加密:约定好的密钥和统一的加密算法,双发对数据进行加密、解密;

// 加密解密用的是同样的“钥匙”

张无忌将一个加了锁的盒子寄给了赵敏,

赵敏收到盒子后用相同的钥匙打开,然后同样的方式寄回给张无忌;

非对称性加密:公钥和私钥组成,公钥加密私钥解密;

// 加密解密用的是不同的“钥匙”

张无忌和赵敏各有自己的盒子。赵敏要跟张无忌秘密通信,她先让张无忌把盒子打开通过邮局发给她。

赵敏拿到盒子后放入信息锁上,然后发给张无忌。张无忌就可以用他自己的钥匙打开了。回复的话就用同样的方式。

二、SSL(HTTPS 协议)加密原理

SSL 就是典型的非对称性加密方式,结合上面的描述,简单描述一下 SSL 原理:

1、当你的浏览器向服务器请求一个安全的网页(通常是 https://);

2、服务器就把它的证书和(非对称性加密的)公钥发回来;

3、浏览器检查证书是不是由可以信赖的机构颁发的,确认证书有效和此证书是此网站的;

4、浏览器使用服务器给的公钥加密了一个随机对称密钥 (浏览器随机生成一个对称性密钥,采用服务器的公钥进行加密),

包括加密的URL一起发送到服务器

5、服务器用自己的私钥解密了浏览器发送的密钥,然后用这个对称性加密的密钥解密浏览器的请求信息;

6、服务器用你发的对称钥匙给你请求的网页加密。你也有相同的钥匙就可以解密发回来的网页了;

// 非对称算法在加密和解密时用的是不同的钥匙。

信息接受者有两把钥匙:一把“公匙”,一把“私匙”。

公匙是给信息发送者用来加密的,私匙是自己用来解密的这样最大的好处是:

不必通过不安全的渠道发送私密的东西。公匙本来就是给别人用的,不用藏好。

你的私匙在你产生私匙的电脑里保存着。

// 如果还是没能完全理解,把非对称性加密中的 "张无忌、赵敏" 分别换成客户端(浏览器)与服务器(Web)

三、常用的算法

对称性加密算法:AES、DES、3DES

非对称性加密算法:RSA、DSA、ECC

线性散列算法(不是加密算法):MD5、SHA1、HMAC

四、AES 加密算法

AES 又称“矩阵加密算法”其原理采用字节矩阵上进行“或与非”的操作(置换和替代),

达到数据被重新排列、或者替换成为另一个完全不相同的数据;

从而达到可以采用相同的密钥进行“回转”;

AES 加密的区块长度固定为 128、192、256 位(bit);

(附破图一张)

AES 加密过程涉及到 4 种操作:

字节替代(SubBytes)

行移位(ShiftRows)

列混淆(MixColumns)

轮密钥加(AddRoundKey)

解密过程分别为对应的逆操作,

由于每一步操作都是可逆的,按照相反的顺序进行解密即可恢复明文。

字节替代(SubBytes)

字节代替的主要功能是通过一个固定的“矩阵”(想象成 Excel 表格上的数据)

完成一个字节到另外一个字节的映射。

行移位(ShiftRows)

行移位的功能是实现一个 4x4 矩阵内部字节之间的置换。

其实应该就是高级编程不常用的“或与非 ^ & | ”操作;

采用正向行移位和逆向行移位到达预期结果;

 列混淆(MixColumns)

利用GF(28)域上算术特性的一个代替。

具体没有深究,有点小复杂,总之一句话代替就是 TM 在矩阵上根据数学公式搞来搞去;

 /*
* Advanced Encryption Standard
* @author Dani Huertas
* @email huertas.dani@gmail.com
*
* Based on the document FIPS PUB 197
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h> /*
* Addition in GF(2^8)
* http://en.wikipedia.org/wiki/Finite_field_arithmetic
*/
uint8_t gadd(uint8_t a, uint8_t b) {
return a^b;
} /*
* Subtraction in GF(2^8)
* http://en.wikipedia.org/wiki/Finite_field_arithmetic
*/
uint8_t gsub(uint8_t a, uint8_t b) {
return a^b;
} /*
* Multiplication in GF(2^8)
* http://en.wikipedia.org/wiki/Finite_field_arithmetic
* Irreducible polynomial m(x) = x8 + x4 + x3 + x + 1
*/
uint8_t gmult(uint8_t a, uint8_t b) { uint8_t p = , i = , hbs = ; for (i = ; i < ; i++) {
if (b & ) {
p ^= a;
} hbs = a & 0x80;
a <<= ;
if (hbs) a ^= 0x1b; // 0000 0001 0001 1011
b >>= ;
} return (uint8_t)p;
} /*
* Addition of 4 byte words
* m(x) = x4+1
*/
void coef_add(uint8_t a[], uint8_t b[], uint8_t d[]) { d[] = a[]^b[];
d[] = a[]^b[];
d[] = a[]^b[];
d[] = a[]^b[];
} /*
* Multiplication of 4 byte words
* m(x) = x4+1
*/
void coef_mult(uint8_t *a, uint8_t *b, uint8_t *d) { d[] = gmult(a[],b[])^gmult(a[],b[])^gmult(a[],b[])^gmult(a[],b[]);
d[] = gmult(a[],b[])^gmult(a[],b[])^gmult(a[],b[])^gmult(a[],b[]);
d[] = gmult(a[],b[])^gmult(a[],b[])^gmult(a[],b[])^gmult(a[],b[]);
d[] = gmult(a[],b[])^gmult(a[],b[])^gmult(a[],b[])^gmult(a[],b[]);
} /*
* The cipher Key.
*/
int K; /*
* Number of columns (32-bit words) comprising the State. For this
* standard, Nb = 4.
*/
int Nb = ; /*
* Number of 32-bit words comprising the Cipher Key. For this
* standard, Nk = 4, 6, or 8.
*/
int Nk; /*
* Number of rounds, which is a function of Nk and Nb (which is
* fixed). For this standard, Nr = 10, 12, or 14.
*/
int Nr; /*
* S-box transformation table
*/
static uint8_t s_box[] = {
// 0 1 2 3 4 5 6 7 8 9 a b c d e f
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, //
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, //
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, //
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, //
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, //
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, //
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, //
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, //
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, //
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, //
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, // a
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, // b
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, // c
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, // d
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, // e
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16};// f /*
* Inverse S-box transformation table
*/
static uint8_t inv_s_box[] = {
// 0 1 2 3 4 5 6 7 8 9 a b c d e f
0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, //
0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, //
0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, //
0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, //
0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, //
0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, //
0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, //
0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, //
0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, //
0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, //
0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, // a
0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, // b
0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, // c
0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, // d
0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, // e
0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d};// f /*
* Generates the round constant Rcon[i]
*/
uint8_t R[] = {0x02, 0x00, 0x00, 0x00}; uint8_t * Rcon(uint8_t i) { if (i == ) {
R[] = 0x01; // x^(1-1) = x^0 = 1
} else if (i > ) {
R[] = 0x02;
i--;
while (i- > ) {
R[] = gmult(R[], 0x02);
i--;
}
} return R;
} /*
* Transformation in the Cipher and Inverse Cipher in which a Round
* Key is added to the State using an XOR operation. The length of a
* Round Key equals the size of the State (i.e., for Nb = 4, the Round
* Key length equals 128 bits/16 bytes).
*/
void add_round_key(uint8_t *state, uint8_t *w, uint8_t r) { uint8_t c; for (c = ; c < Nb; c++) {
state[Nb*+c] = state[Nb*+c]^w[*Nb*r+*c+]; //debug, so it works for Nb !=4
state[Nb*+c] = state[Nb*+c]^w[*Nb*r+*c+];
state[Nb*+c] = state[Nb*+c]^w[*Nb*r+*c+];
state[Nb*+c] = state[Nb*+c]^w[*Nb*r+*c+];
}
} /*
* Transformation in the Cipher that takes all of the columns of the
* State and mixes their data (independently of one another) to
* produce new columns.
*/
void mix_columns(uint8_t *state) { uint8_t a[] = {0x02, 0x01, 0x01, 0x03}; // a(x) = {02} + {01}x + {01}x2 + {03}x3
uint8_t i, j, col[], res[]; for (j = ; j < Nb; j++) {
for (i = ; i < ; i++) {
col[i] = state[Nb*i+j];
} coef_mult(a, col, res); for (i = ; i < ; i++) {
state[Nb*i+j] = res[i];
}
}
} /*
* Transformation in the Inverse Cipher that is the inverse of
* MixColumns().
*/
void inv_mix_columns(uint8_t *state) { uint8_t a[] = {0x0e, 0x09, 0x0d, 0x0b}; // a(x) = {0e} + {09}x + {0d}x2 + {0b}x3
uint8_t i, j, col[], res[]; for (j = ; j < Nb; j++) {
for (i = ; i < ; i++) {
col[i] = state[Nb*i+j];
} coef_mult(a, col, res); for (i = ; i < ; i++) {
state[Nb*i+j] = res[i];
}
}
} /*
* Transformation in the Cipher that processes the State by cyclically
* shifting the last three rows of the State by different offsets.
*/
void shift_rows(uint8_t *state) { uint8_t i, k, s, tmp; for (i = ; i < ; i++) {
// shift(1,4)=1; shift(2,4)=2; shift(3,4)=3
// shift(r, 4) = r;
s = ;
while (s < i) {
tmp = state[Nb*i+]; for (k = ; k < Nb; k++) {
state[Nb*i+k-] = state[Nb*i+k];
} state[Nb*i+Nb-] = tmp;
s++;
}
}
} /*
* Transformation in the Inverse Cipher that is the inverse of
* ShiftRows().
*/
void inv_shift_rows(uint8_t *state) { uint8_t i, k, s, tmp; for (i = ; i < ; i++) {
s = ;
while (s < i) {
tmp = state[Nb*i+Nb-]; for (k = Nb-; k > ; k--) {
state[Nb*i+k] = state[Nb*i+k-];
} state[Nb*i+] = tmp;
s++;
}
}
} /*
* Transformation in the Cipher that processes the State using a non­
* linear byte substitution table (S-box) that operates on each of the
* State bytes independently.
*/
void sub_bytes(uint8_t *state) { uint8_t i, j;
uint8_t row, col; for (i = ; i < ; i++) {
for (j = ; j < Nb; j++) {
row = (state[Nb*i+j] & 0xf0) >> ;
col = state[Nb*i+j] & 0x0f;
state[Nb*i+j] = s_box[*row+col];
}
}
} /*
* Transformation in the Inverse Cipher that is the inverse of
* SubBytes().
*/
void inv_sub_bytes(uint8_t *state) { uint8_t i, j;
uint8_t row, col; for (i = ; i < ; i++) {
for (j = ; j < Nb; j++) {
row = (state[Nb*i+j] & 0xf0) >> ;
col = state[Nb*i+j] & 0x0f;
state[Nb*i+j] = inv_s_box[*row+col];
}
}
} /*
* Function used in the Key Expansion routine that takes a four-byte
* input word and applies an S-box to each of the four bytes to
* produce an output word.
*/
void sub_word(uint8_t *w) { uint8_t i; for (i = ; i < ; i++) {
w[i] = s_box[*((w[i] & 0xf0) >> ) + (w[i] & 0x0f)];
}
} /*
* Function used in the Key Expansion routine that takes a four-byte
* word and performs a cyclic permutation.
*/
void rot_word(uint8_t *w) { uint8_t tmp;
uint8_t i; tmp = w[]; for (i = ; i < ; i++) {
w[i] = w[i+];
} w[] = tmp;
} /*
* Key Expansion
*/
void key_expansion(uint8_t *key, uint8_t *w) { uint8_t tmp[];
uint8_t i, j;
uint8_t len = Nb*(Nr+); for (i = ; i < Nk; i++) {
w[*i+] = key[*i+];
w[*i+] = key[*i+];
w[*i+] = key[*i+];
w[*i+] = key[*i+];
} for (i = Nk; i < len; i++) {
tmp[] = w[*(i-)+];
tmp[] = w[*(i-)+];
tmp[] = w[*(i-)+];
tmp[] = w[*(i-)+]; if (i%Nk == ) { rot_word(tmp);
sub_word(tmp);
coef_add(tmp, Rcon(i/Nk), tmp); } else if (Nk > && i%Nk == ) { sub_word(tmp); } w[*i+] = w[*(i-Nk)+]^tmp[];
w[*i+] = w[*(i-Nk)+]^tmp[];
w[*i+] = w[*(i-Nk)+]^tmp[];
w[*i+] = w[*(i-Nk)+]^tmp[];
}
} void cipher(uint8_t *in, uint8_t *out, uint8_t *w) { uint8_t state[*Nb];
uint8_t r, i, j; for (i = ; i < ; i++) {
for (j = ; j < Nb; j++) {
state[Nb*i+j] = in[i+*j];
}
} add_round_key(state, w, ); for (r = ; r < Nr; r++) {
sub_bytes(state);
shift_rows(state);
mix_columns(state);
add_round_key(state, w, r);
} sub_bytes(state);
shift_rows(state);
add_round_key(state, w, Nr); for (i = ; i < ; i++) {
for (j = ; j < Nb; j++) {
out[i+*j] = state[Nb*i+j];
}
}
} void inv_cipher(uint8_t *in, uint8_t *out, uint8_t *w) { uint8_t state[*Nb];
uint8_t r, i, j; for (i = ; i < ; i++) {
for (j = ; j < Nb; j++) {
state[Nb*i+j] = in[i+*j];
}
} add_round_key(state, w, Nr); for (r = Nr-; r >= ; r--) {
inv_shift_rows(state);
inv_sub_bytes(state);
add_round_key(state, w, r);
inv_mix_columns(state);
} inv_shift_rows(state);
inv_sub_bytes(state);
add_round_key(state, w, ); for (i = ; i < ; i++) {
for (j = ; j < Nb; j++) {
out[i+*j] = state[Nb*i+j];
}
}
} int main(int argc, char *argv[]) { uint8_t i; /*
* Appendix A - Key Expansion Examples
*/ /* 128 bits */
/* uint8_t key[] = {
0x2b, 0x7e, 0x15, 0x16,
0x28, 0xae, 0xd2, 0xa6,
0xab, 0xf7, 0x15, 0x88,
0x09, 0xcf, 0x4f, 0x3c}; */ /* 192 bits */
/* uint8_t key[] = {
0x8e, 0x73, 0xb0, 0xf7,
0xda, 0x0e, 0x64, 0x52,
0xc8, 0x10, 0xf3, 0x2b,
0x80, 0x90, 0x79, 0xe5,
0x62, 0xf8, 0xea, 0xd2,
0x52, 0x2c, 0x6b, 0x7b}; */ /* 256 bits */
/* uint8_t key[] = {
0x60, 0x3d, 0xeb, 0x10,
0x15, 0xca, 0x71, 0xbe,
0x2b, 0x73, 0xae, 0xf0,
0x85, 0x7d, 0x77, 0x81,
0x1f, 0x35, 0x2c, 0x07,
0x3b, 0x61, 0x08, 0xd7,
0x2d, 0x98, 0x10, 0xa3,
0x09, 0x14, 0xdf, 0xf4};
*/ /* uint8_t in[] = {
0x32, 0x43, 0xf6, 0xa8,
0x88, 0x5a, 0x30, 0x8d,
0x31, 0x31, 0x98, 0xa2,
0xe0, 0x37, 0x07, 0x34}; // 128
*/ /*
* Appendix C - Example Vectors
*/ /* 128 bit key */
/* uint8_t key[] = {
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f}; */ /* 192 bit key */
/* uint8_t key[] = {
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13,
0x14, 0x15, 0x16, 0x17}; */ /* 256 bit key */
uint8_t key[] = {
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13,
0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b,
0x1c, 0x1d, 0x1e, 0x1f}; uint8_t in[] = {
0x00, 0x11, 0x22, 0x33,
0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xaa, 0xbb,
0xcc, 0xdd, 0xee, 0xff}; uint8_t out[]; // uint8_t *w; // expanded key switch (sizeof(key)) {
default:
case : Nk = ; Nr = ; break;
case : Nk = ; Nr = ; break;
case : Nk = ; Nr = ; break;
} w = malloc(Nb*(Nr+)*); key_expansion(key, w); cipher(in /* in */, out /* out */, w /* expanded key */); printf("out:\n"); for (i = ; i < ; i++) {
printf("%x %x %x %x ", out[*i+], out[*i+], out[*i+], out[*i+]);
} printf("\n"); inv_cipher(out, in, w); printf("msg:\n");
for (i = ; i < ; i++) {
printf("%x %x %x %x ", in[*i+], in[*i+], in[*i+], in[*i+]);
} printf("\n"); exit(); }

https://github.com/dhuertas/AES/blob/master/aes.c

参考自:

http://blog.csdn.net/qq_26420489/article/details/53395472

http://www.mamicode.com/info-detail-514466.html

[非原创] 常用加密算法整理 AES/SSL(一)的更多相关文章

  1. CSS样式命名整理(非原创)

    非原创,具体出自哪里忘了,如果侵害您的利益,请联系我. CSS样式命名整理 页面结构 容器: container/wrap 整体宽度:wrapper 页头:header 内容:content 页面主体 ...

  2. Java MD5和SHA256等常用加密算法

    前言 我们在做java项目开发的时候,在前后端接口分离模式下,接口信息需要加密处理,做签名认证,还有在用户登录信息密码等也都需要数据加密.信息加密是现在几乎所有项目都需要用到的技术,身份认证.单点登陆 ...

  3. 常用加密算法的Java实现总结

    常用加密算法的Java实现(一) ——单向加密算法MD5和SHA 1.Java的安全体系架构 1.1           Java的安全体系架构介绍 Java中为安全框架提供类和接口.JDK 安全 A ...

  4. 常用加密算法的Java实现总结(二)

    常用加密算法的Java实现总结(二) ——对称加密算法DES.3DES和AES 摘自:http://www.blogjava.net/amigoxie/archive/2014/07/06/41550 ...

  5. NiosII常用函数整理

    NiosII常用函数整理 IO操作函数函数原型:IORD(BASE, REGNUM) 输入参数:BASE为寄存器的基地址,REGNUM为寄存器的偏移量函数说明:从基地址为BASE的设备中读取寄存器中偏 ...

  6. Atitit.加密算法ati Aes的框架设计v2.2

    Atitit.加密算法ati Aes的框架设计v2.2 版本进化1 V2.2   add def decode key api1 v1版本1 Aes的历史2 Atitit.加密算法 des  aes  ...

  7. 【linux】---常用命令整理

    linux常用命令整理 一.ls命令 就是list的缩写,通过ls 命令不仅可以查看linux文件夹包含的文件,而且可以查看文件权限(包括目录.文件夹.文件权限)查看目录信息等等 常用参数搭配: l ...

  8. Tomcat性能优化及常用命令整理

    1汤姆猫性能优化 1.1连接参数 1.1.1默认连接配置 默认连接器采用阻塞式 IO,默认最大线程数为200,配置如下: <Connector port="8080" pro ...

  9. sqlmap常用技巧整理

    言 通过在乌云网上出现的很多SQL注入漏洞,因此来总结一下,大致使用SQLMAP所遇到的参数. 基本结构 基本SQLMAP的使用方式就如下所示,使用参数式的方式,按需求添加. 12 sqlmap.py ...

随机推荐

  1. python并发编程&多线程(一)

    本篇理论居多,实际操作见:  python并发编程&多线程(二) 一 什么是线程 在传统操作系统中,每个进程有一个地址空间,而且默认就有一个控制线程 线程顾名思义,就是一条流水线工作的过程,一 ...

  2. android studio 和gradle版本问题解决

    打开android studio 开始导入一个 covrdova项目 结果弹出一个这样的对话框意思是  "尚未配置此项目的 gradle" "是否希望项目使用gradle ...

  3. 关于SIM800C MINI V4.0 V4版本 5v供电模块重启问题

    现象描述 模块不停重启,发送AT时候能看到,不停的回复Call Ready 或者SIM卡确认没问题,但是NET指示灯一直不能进入3秒闪烁的状态. 1.内核要求 SIM800C内核要求需要电源有瞬间有2 ...

  4. junit在idea中的使用(2)--实践篇

    目录:(1)普通java项目(2)在web项目中 (1)普通java项目 直接在代码中写上 @Before @Test即可,想执行main方法,直接右击main,选择run as import org ...

  5. IDEA中文出现乱码解决

    转自:http://lcl088005.iteye.com/blog/2284696 我是个idea的忠实用户,新公司的项目都是用eclipse做的,通过svn拉下代码后发现,注释的内容里,中文内容都 ...

  6. Loadrunder脚本篇——webservice接口测试(二)

    1.选择协议--Web Service,如下图 2.导入服务 入口1:点击Manage Services ->弹出窗中选择“Import” ->弹出窗中选择“URL”,填写wsdl地址,导 ...

  7. Loadrunder脚本篇——文件下载

    下载简介 对 HTTP协议来说,无论是下载文件或者请求页面,对客户端来说,都只是发出一个GET请求,并不会记录点击后的“保存”.“另存为操作”. 如下,点击页面中tar.gz压缩包,用工具可以清楚的看 ...

  8. 【Head First Servlets and JSP】笔记17:JSP所生成的servlet相关问题

    1.容器根据你所写的JSP生成一个类, /* * Generated by the Jasper component of Apache Tomcat * Version: Apache Tomcat ...

  9. package.json字段简要解析

    name 必填 应用名称 version 必填 应用版本 description 选填 应用描述,多用于搜索,在npm search 时可以用到 keywords 选填 应用关键字,也多用于搜索 sc ...

  10. iis和apache共享80端口

    Windows server 2003服务器上安装有默认 IIS 6和Apache两个服务器,IIS运行的一个.net程序,apache运行php程序,现在想让它们同时都能通过80端口访问,设置起来还 ...