恰好我有。能運行的，C語言的。
#include <string.h>
#include "aes.h"
#include "commonage.h"
#define byte unsigned char
#define BPOLY 0x1b //!< Lower 8 bits of (x^8+x^4+x^3+x+1), ie. (x^4+x^3+x+1).
#define BLOCKSIZE 16 //!< Block size in number of bytes.
#define KEYBITS 128 //!< Use AES128.
#define ROUNDS 10 //!< Number of rounds.
#define KEYLENGTH 16 //!< Key length in number of bytes.
byte xdata block1[ 256 ]; //!< Workspace 1.
byte xdata block2[ 256 ]; //!< Worksapce 2.
byte xdata * powTbl; //!< Final location of exponentiation lookup table.
byte xdata * logTbl; //!< Final location of logarithm lookup table.
byte xdata * sBox; //!< Final location of s-box.
byte xdata * sBoxInv; //!< Final location of inverse s-box.
byte xdata * expandedKey; //!< Final location of expanded key.
void CalcPowLog( byte * powTbl, byte * logTbl )
{
byte xdata i = 0;
byte xdata t = 1;
do {
// Use 0x03 as root for exponentiation and logarithms.
powTbl[i] = t;
logTbl[t] = i;
i++;
// Muliply t by 3 in GF(2^8).
t ^= (t << 1) ^ (t & 0x80 ? BPOLY : 0);
} while( t != 1 ); // Cyclic properties ensure that i < 255.
powTbl[255] = powTbl[0]; // 255 = '-0', 254 = -1, etc.
}
void CalcSBox( byte * sBox )
{
byte xdata i, rot;
byte xdata temp;
byte xdata result;
// Fill all entries of sBox[].
i = 0;
do {
// Inverse in GF(2^8).
if( i > 0 ) {
temp = powTbl[ 255 - logTbl[i] ];
} else {
temp = 0;
}
// Affine transformation in GF(2).
result = temp ^ 0x63; // Start with adding a vector in GF(2).
for( rot = 0; rot < 4; rot++ ) {
// Rotate left.
temp = (temp<<1) | (temp>>7);
// Add rotated byte in GF(2).
result ^= temp;
}
// Put result in table.
sBox[i] = result;
} while( ++i != 0 );
}
void CalcSBoxInv( byte * sBox, byte * sBoxInv )
{
byte xdata i = 0;
byte xdata j = 0;
// Iterate through all elements in sBoxInv using i.
do {
// Search through sBox using j.
cleardog();
do {
// Check if current j is the inverse of current i.
if( sBox[ j ] == i ) {
// If so, set sBoxInc and indicate search finished.
sBoxInv[ i ] = j;
j = 255;
}
} while( ++j != 0 );
} while( ++i != 0 );
}
void CycleLeft( byte * row )
{
// Cycle 4 bytes in an array left once.
byte xdata temp = row[0];
row[0] = row[1];
row[1] = row[2];
row[2] = row[3];
row[3] = temp;
}
void InvMixColumn( byte * column )
{
byte xdata r0, r1, r2, r3;
r0 = column[1] ^ column[2] ^ column[3];
r1 = column[0] ^ column[2] ^ column[3];
r2 = column[0] ^ column[1] ^ column[3];
r3 = column[0] ^ column[1] ^ column[2];
column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);
column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);
column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);
column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);
r0 ^= column[0] ^ column[1];
r1 ^= column[1] ^ column[2];
r2 ^= column[2] ^ column[3];
r3 ^= column[0] ^ column[3];
column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);
column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);
column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);
column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);
r0 ^= column[0] ^ column[2];
r1 ^= column[1] ^ column[3];
r2 ^= column[0] ^ column[2];
r3 ^= column[1] ^ column[3];
column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);
column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);
column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);
column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);
column[0] ^= column[1] ^ column[2] ^ column[3];
r0 ^= column[0];
r1 ^= column[0];
r2 ^= column[0];
r3 ^= column[0];
column[0] = r0;
column[1] = r1;
column[2] = r2;
column[3] = r3;
}
byte Multiply( unsigned char num, unsigned char factor )
{
byte mask = 1;
byte result = 0;
while( mask != 0 ) {
// Check bit of factor given by mask.
if( mask & factor ) {
// Add current multiple of num in GF(2).
result ^= num;
}
// Shift mask to indicate next bit.
mask <<= 1;
// Double num.
num = (num << 1) ^ (num & 0x80 ? BPOLY : 0);
}
return result;
}
byte DotProct( unsigned char * vector1, unsigned char * vector2 )
{
byte result = 0;
result ^= Multiply( *vector1++, *vector2++ );
result ^= Multiply( *vector1++, *vector2++ );
result ^= Multiply( *vector1++, *vector2++ );
result ^= Multiply( *vector1 , *vector2 );
return result;
}
void MixColumn( byte * column )
{
byte xdata row[8] = {
0x02, 0x03, 0x01, 0x01,
0x02, 0x03, 0x01, 0x01
}; // Prepare first row of matrix twice, to eliminate need for cycling.
byte xdata result[4];
// Take dot procts of each matrix row and the column vector.
result[0] = DotProct( row+0, column );
result[1] = DotProct( row+3, column );
result[2] = DotProct( row+2, column );
result[3] = DotProct( row+1, column );
// Copy temporary result to original column.
column[0] = result[0];
column[1] = result[1];
column[2] = result[2];
column[3] = result[3];
}
void SubBytes( byte * bytes, byte count )
{
do {
*bytes = sBox[ *bytes ]; // Substitute every byte in state.
bytes++;
} while( --count );
}
void InvSubBytesAndXOR( byte * bytes, byte * key, byte count )
{
do {
// *bytes = sBoxInv[ *bytes ] ^ *key; // Inverse substitute every byte in state and add key.
*bytes = block2[ *bytes ] ^ *key; // Use block2 directly. Increases speed.
bytes++;
key++;
} while( --count );
}
void InvShiftRows( byte * state )
{
byte temp;
// Note: State is arranged column by column.
// Cycle second row right one time.
temp = state[ 1 + 3*4 ];
state[ 1 + 3*4 ] = state[ 1 + 2*4 ];
state[ 1 + 2*4 ] = state[ 1 + 1*4 ];
state[ 1 + 1*4 ] = state[ 1 + 0*4 ];
state[ 1 + 0*4 ] = temp;
// Cycle third row right two times.
temp = state[ 2 + 0*4 ];
state[ 2 + 0*4 ] = state[ 2 + 2*4 ];
state[ 2 + 2*4 ] = temp;
temp = state[ 2 + 1*4 ];
state[ 2 + 1*4 ] = state[ 2 + 3*4 ];
state[ 2 + 3*4 ] = temp;
// Cycle fourth row right three times, ie. left once.
temp = state[ 3 + 0*4 ];
state[ 3 + 0*4 ] = state[ 3 + 1*4 ];
state[ 3 + 1*4 ] = state[ 3 + 2*4 ];
state[ 3 + 2*4 ] = state[ 3 + 3*4 ];
state[ 3 + 3*4 ] = temp;
}
void ShiftRows( byte * state )
{
byte temp;
// Note: State is arranged column by column.
// Cycle second row left one time.
temp = state[ 1 + 0*4 ];
state[ 1 + 0*4 ] = state[ 1 + 1*4 ];
state[ 1 + 1*4 ] = state[ 1 + 2*4 ];
state[ 1 + 2*4 ] = state[ 1 + 3*4 ];
state[ 1 + 3*4 ] = temp;
// Cycle third row left two times.
temp = state[ 2 + 0*4 ];
state[ 2 + 0*4 ] = state[ 2 + 2*4 ];
state[ 2 + 2*4 ] = temp;
temp = state[ 2 + 1*4 ];
state[ 2 + 1*4 ] = state[ 2 + 3*4 ];
state[ 2 + 3*4 ] = temp;
// Cycle fourth row left three times, ie. right once.
temp = state[ 3 + 3*4 ];
state[ 3 + 3*4 ] = state[ 3 + 2*4 ];
state[ 3 + 2*4 ] = state[ 3 + 1*4 ];
state[ 3 + 1*4 ] = state[ 3 + 0*4 ];
state[ 3 + 0*4 ] = temp;
}
void InvMixColumns( byte * state )
{
InvMixColumn( state + 0*4 );
InvMixColumn( state + 1*4 );
InvMixColumn( state + 2*4 );
InvMixColumn( state + 3*4 );
}
void MixColumns( byte * state )
{
MixColumn( state + 0*4 );
MixColumn( state + 1*4 );
MixColumn( state + 2*4 );
MixColumn( state + 3*4 );
}
void XORBytes( byte * bytes1, byte * bytes2, byte count )
{
do {
*bytes1 ^= *bytes2; // Add in GF(2), ie. XOR.
bytes1++;
bytes2++;
} while( --count );
}
void CopyBytes( byte * to, byte * from, byte count )
{
do {
*to = *from;
to++;
from++;
} while( --count );
}
void KeyExpansion( byte * expandedKey )
{
byte xdata temp[4];
byte i;
byte xdata Rcon[4] = { 0x01, 0x00, 0x00, 0x00 }; // Round constant.
unsigned char xdata *key;
unsigned char xdata a[16];
key=a;
//以下為加解密密碼，共16位元組。可以選擇任意值
key[0]=0x30;
key[1]=0x30;
key[2]=0x30;
key[3]=0x30;
key[4]=0x30;
key[5]=0x30;
key[6]=0x30;
key[7]=0x30;
key[8]=0x30;
key[9]=0x30;
key[10]=0x30;
key[11]=0x30;
key[12]=0x30;
key[13]=0x30;
key[14]=0x30;
key[15]=0x30;
////////////////////////////////////////////
// Copy key to start of expanded key.
i = KEYLENGTH;
do {
*expandedKey = *key;
expandedKey++;
key++;
} while( --i );
// Prepare last 4 bytes of key in temp.
expandedKey -= 4;
temp[0] = *(expandedKey++);
temp[1] = *(expandedKey++);
temp[2] = *(expandedKey++);
temp[3] = *(expandedKey++);
// Expand key.
i = KEYLENGTH;
while( i < BLOCKSIZE*(ROUNDS+1) ) {
// Are we at the start of a multiple of the key size?
if( (i % KEYLENGTH) == 0 ) {
CycleLeft( temp ); // Cycle left once.
SubBytes( temp, 4 ); // Substitute each byte.
XORBytes( temp, Rcon, 4 ); // Add constant in GF(2).
*Rcon = (*Rcon << 1) ^ (*Rcon & 0x80 ? BPOLY : 0);
}
// Keysize larger than 24 bytes, ie. larger that 192 bits?
#if KEYLENGTH > 24
// Are we right past a block size?
else if( (i % KEYLENGTH) == BLOCKSIZE ) {
SubBytes( temp, 4 ); // Substitute each byte.
}
#endif
// Add bytes in GF(2) one KEYLENGTH away.
XORBytes( temp, expandedKey - KEYLENGTH, 4 );
// Copy result to current 4 bytes.
*(expandedKey++) = temp[ 0 ];
*(expandedKey++) = temp[ 1 ];
*(expandedKey++) = temp[ 2 ];
*(expandedKey++) = temp[ 3 ];
i += 4; // Next 4 bytes.
}
}
void InvCipher( byte * block, byte * expandedKey )
{
byte round = ROUNDS-1;
expandedKey += BLOCKSIZE * ROUNDS;
XORBytes( block, expandedKey, 16 );
expandedKey -= BLOCKSIZE;
do {
InvShiftRows( block );
InvSubBytesAndXOR( block, expandedKey, 16 );
expandedKey -= BLOCKSIZE;
InvMixColumns( block );
} while( --round );
InvShiftRows( block );
InvSubBytesAndXOR( block, expandedKey, 16 );
}
void Cipher( byte * block, byte * expandedKey ) //完成一個塊(16位元組，128bit)的加密
{
byte round = ROUNDS-1;
XORBytes( block, expandedKey, 16 );
expandedKey += BLOCKSIZE;
do {
SubBytes( block, 16 );
ShiftRows( block );
MixColumns( block );
XORBytes( block, expandedKey, 16 );
expandedKey += BLOCKSIZE;
} while( --round );
SubBytes( block, 16 );
ShiftRows( block );
XORBytes( block, expandedKey, 16 );
}
void aesInit( unsigned char * tempbuf )
{
powTbl = block1;
logTbl = block2;
CalcPowLog( powTbl, logTbl );
sBox = tempbuf;
CalcSBox( sBox );
expandedKey = block1; //至此block1用來存貯密碼表
KeyExpansion( expandedKey );
sBoxInv = block2; // Must be block2. block2至此開始只用來存貯SBOXINV
CalcSBoxInv( sBox, sBoxInv );
}
//對一個16位元組塊解密,參數buffer是解密密緩存，chainBlock是要解密的塊
void aesDecrypt( unsigned char * buffer, unsigned char * chainBlock )
{
//byte xdata temp[ BLOCKSIZE ];
//CopyBytes( temp, buffer, BLOCKSIZE );
CopyBytes(buffer,chainBlock,BLOCKSIZE);
InvCipher( buffer, expandedKey );
//XORBytes( buffer, chainBlock, BLOCKSIZE );
CopyBytes( chainBlock, buffer, BLOCKSIZE );
}
//對一個16位元組塊完成加密，參數buffer是加密緩存，chainBlock是要加密的塊
void aesEncrypt( unsigned char * buffer, unsigned char * chainBlock )
{
CopyBytes( buffer, chainBlock, BLOCKSIZE );
//XORBytes( buffer, chainBlock, BLOCKSIZE );
Cipher( buffer, expandedKey );
CopyBytes( chainBlock, buffer, BLOCKSIZE );
}
//加解密函數，參數為加解密標志，要加解密的數據緩存起始指針，要加解密的數據長度（如果解密運算，必須是16的整數倍。）
unsigned char aesBlockDecrypt(bit Direct,unsigned char *ChiperDataBuf,unsigned char DataLen)
{
unsigned char xdata i;
unsigned char xdata Blocks;
unsigned char xdata sBoxbuf[256];
unsigned char xdata tempbuf[16];
unsigned long int xdata OrignLen=0; //未加密數據的原始長度
if(Direct==0)
{
*((unsigned char *)&OrignLen+3)=ChiperDataBuf[0];
*((unsigned char *)&OrignLen+2)=ChiperDataBuf[1];
*((unsigned char *)&OrignLen+1)=ChiperDataBuf[2];
*((unsigned char *)&OrignLen)=ChiperDataBuf[3];
DataLen=DataLen-4;
}
else
{
memmove(ChiperDataBuf+4,ChiperDataBuf,DataLen);
OrignLen=DataLen;
ChiperDataBuf[0]=OrignLen;
ChiperDataBuf[1]=OrignLen>>8;
ChiperDataBuf[2]=OrignLen>>16;
ChiperDataBuf[3]=OrignLen>>24;
}
cleardog();
aesInit(sBoxbuf); //初始化
if(Direct==0) //解密
{
Blocks=DataLen/16;
for(i=0;i<Blocks;i++)
{
cleardog();
aesDecrypt(tempbuf,ChiperDataBuf+4+16*i);
}
memmove(ChiperDataBuf,ChiperDataBuf+4,OrignLen);
cleardog();
return(OrignLen);
}
else //加密
{
if(DataLen%16!=0)
{
Blocks=DataLen/16+1;
//memset(ChiperDataBuf+4+Blocks*16-(DataLen%16),0x00,DataLen%16); //不足16位元組的塊補零處理
}
else
{
Blocks=DataLen/16;
}
for(i=0;i<Blocks;i++)
{
cleardog();
aesEncrypt(tempbuf,ChiperDataBuf+4+16*i);
}
cleardog();
return(Blocks*16+4);
}
}
//#endif
以上是C文件。以下是頭文件
#ifndef AES_H
#define AES_H
extern void aesInit( unsigned char * tempbuf );
extern void aesDecrypt(unsigned char *buffer, unsigned char *chainBlock);
extern void aesEncrypt( unsigned char * buffer, unsigned char * chainBlock );
extern void aesInit( unsigned char * tempbuf );
extern void aesDecrypt( unsigned char * buffer, unsigned char * chainBlock );
extern void aesEncrypt( unsigned char * buffer, unsigned char * chainBlock );
extern unsigned char aesBlockDecrypt(bit Direct,unsigned char *ChiperDataBuf,unsigned char DataLen);
#endif // AES_H
這是我根據網上程序改寫的。只支持128位加解密。沒有使用占內存很多的查表法。故運算速度會稍慢。
⑵ URL內 參數加密解密
javascript對URL中的參數進行簡單加密處理
javascript的api本來就支持Base64，因此我笑笑們可以很方便的來進行編碼和解碼。
var encodeData = window.btoa("name=xiaoming&age=10")//衡升敗編碼
var decodeData = window.atob(encodeData)//解碼。
下面來個具體的例子來說明如何對url中參數進行轉碼，並取得解碼後的參數
假如要跳轉的url = "stu_info.html?name=xiaoming&age=10"
轉碼：url = "stu_info.html?"+window.btoa("name=xiaoming&age=10");
跳轉：window.open(url)或者window.locaton.href = url;
解碼：解碼時我們首先要從url中獲得參數列表，
我們可以通過var paramsString = window.location.search來獲取url中?號開始的內容（url的咐顫查詢部分）即"?name=xiaoming&age=10"；
然後去掉?號 paramsString = paramsString.substring(1) //"name=xiaoming&age=10"
去掉& paramsString = paramsString.split("&");//["name=xiaoming","age=10"]
需要指出的是 window.btoa這中編碼方式不能直接作用於Unicode字元串。只能將ascci字元串或二進制數據轉換成Base64編碼過的字元串。如果要對Unicode字元進行編碼可以將做如下轉換。
var encodeData = window.btoa(window.encodeURIComponent("name=小明&age=10"))//編碼
var decodeData = window.decodeURIComponent(window.atob(encodeData))//解碼。
獲取url參數
//獲取url參數
function getQueryString(name) {
var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i");
var params = window.location.search.substr(1);
params = window.decodeURIComponent(window.atob(params));
var r = params.match(reg);
if (r != null) {
return decodeURI(r[2]);
}
return null;
}
⑶ 虛擬貨幣和什麼演算法有關
Litecoin
Litecoin（LTC）發布於2011年10月7日,是目前市值最高的山寨幣，約為 BTC 市值的2%。目前單價為2.31美元，總幣值 3800 萬美元。
這同樣是一種分布式（去中心化）的數字貨幣。不同於比特幣使用的 SHA256 挖礦演算法，LTC 採用 scrypt 演算法。獨特的演算法也是從山寨幣中脫穎而出的關鍵，scrypt 演算法使用 SHA256 作為其子程序，而 scrypt 自身需要大量的內存，每個散列作為輸入的種子使用的，然後與需要大量的內存存儲另一種子偽隨機序列，共同生成序列的偽隨機點而輸出哈希值。在 BTC（Bitcoin）的開采依靠單純的顯卡挖礦已經力不從心（利用一般配置顯卡挖到一個 BTC 大概需要十幾到數十天），各種價格不菲挖礦機的出現提高了普通人通過挖礦獲得 BTC 的門檻，而 LTC 在使用 PC 顯卡挖礦上具有一定優勢。（本段來源於知乎。）
Litecoin 對比 BTC 在技術上做了一點的改進，如果現在 BTC 是金，那 LTC 暫時是銀。
Litecoin 的最大優點是能更快確認真偽，該虛擬貨幣由 Charles Lee 設計和維護。比特幣的交易需要驗證，驗證的時間平均在10分鍾以上，大多數交易網站驗證需要1個小時。Litecoin 交易確認平均為2.5分鍾，開發者聲稱縮短驗證增加了虛擬貨幣的實用性。定製機器和 AMD GPU 的比特幣采礦效率最高，令使用 CPU 采礦的礦工幾乎無利可圖。Litecoin 的采礦排除了 GPU 和定製處理器，因此不過於依賴少量專業礦工。
PPCoin
PPCoin（PPC） 發布於2012年8月19，在 BTC 原有技術上有所提升。使用 proof-of-stake，並加入 coin age 概念。
PPCoin 是 Bitcoin 的分叉項目，目標是實現能源效率，並盡可能保持原 Bitcoin 的最好性能。PPCoin 單價0.22美元，總幣值 400 萬美元。
PPCoin 沒有一個固定的貨幣供應量上限，但這並不意味著 PPCoin 比 Bitcoin 有明顯通脹。可以將 Bitcoin 比做黃金，黃金每年的通脹是1-3％左右，雖然黃金並沒有已知的貨幣供應量上限，但我們仍知道它是可靠的稀缺品。
PPCoin 的鑄造有兩種類型，工作證明及股權證明。工作證明的鑄幣率受摩爾定律影響，這取決於我們的工作證明能力的成倍增長。而大家都知道的是摩爾定律最終會結束，到那時通脹的 PPCoin 可能已經接近黃金的水平。而股權證明鑄造每年最多通脹 1％。與此同時，PPCoin 的交易費用被銷毀以抗衡通脹。所以整體來說， PPCoin 的鑄幣設計仍是未來一個非常低的通脹設計，可以達到和 Bitcoin 相媲美的程度。
PPCoin 的獎勵方式類似彩票，會根據礦工持有的 PPCoin 數量決定獲勝幾率，創始人之一的 Sunny King 說，他們的設計是基於長期能量效率的新概念。
Terracoin
Terracoin（TRC）發布於2012年10月26，總幣量 4200 萬。每塊速度為2分鍾，比 LTC 稍快一些。技術上沒有太多特別之處，類似 BTC 每4年產量減半。
不過運營團隊似乎有較強商業背景，可能會在流通上優於其他比特幣。虛擬貨幣現在的發展越來越得到重視，現在一些有商業背景的團隊進入，會加速虛擬貨幣的發展。
Namecoin
Namecoin 是一個基於比特幣技術的分布式域名系統，其原理和 Bitcoin 一樣， 這個開源軟體首次發布的日期是2011年4月18日。
Namecoin 產生於一個不同於 Bitcoin 主交易區塊的起源塊， 使用一個新的區塊鏈（blockchain），獨立於 Bitcoin 的區塊鏈之外，因為是基於 Bitcoin，域名的安全性， 分布性， 魯棒性， 加密性， 遷移都有數學保證。可以用挖 Bitcoin 的方式，同時挖 Namecoin。
⑷ 前後端分類，數據傳輸問題
目前我所知道的項目開發中，基本上都是前後端分離的。這就出現了數據傳輸的問題，前端傳給伺服器 或者 伺服器傳給前端的數據都是容易被別人竊取的。這里就要對傳輸的數據進行加解密，以保證數據安全。
下面介紹兩種前後端數據傳輸的方式
前後端約定一個key,將請求參數按照字母排序拼接成一個字元串（通常都是ASCll排序），然後拼接上key,最後用MD5或者SHA進行加密，得到一個加密的簽名sign，再把sign作為最後一個參數傳到服務端。
服務端拿到前端傳過來的結果之後，也將參數(排除sign)按照順序拼接成一個字元串，再拼接上key，再用MD5或者SHA進行加密，也得到了一個新的sign，服務端比較這兩個sign，如果相同就說明傳回來的數據沒有問題，如果不相同，說明數據被串改了。
例如：
傳遞的參數是
id=5&age=10
現在通過加簽 應該傳遞的參數為
id=5&age=10&sign=MD5(age=10&id=5)
服務端拿到的就是
id=5&age=10&sign=MD5(age=10&id=5)
服務端經過篩選參數，得到 id=5&age=10 ，然後進行排序得到 age=10&id=5 ,再MD5得到sign，頌敏兩個sign進行比較
目前我知道的根據秘鑰的使用方法，可以將密碼分為兩種
在對稱密碼中，加密、解密時使用的是同一個密鑰，我們常用的AES演算法就是對稱密碼演算法。具體AES演算法大家自己網路就好了
但是通常使用對稱密碼時，就會有秘鑰配送問題。
例：發送者A將使用對稱密碼加密過得信息發送給接收者B，只有將秘鑰發送給接收者B，B才能進行解密，這里A發送秘鑰給B的過程中，就容易被別人竊取秘鑰，別人拿著秘鑰也能進行解密。
如何解決秘鑰配送問題
我知道的幾種解決方法
公鑰密碼
公鑰密碼中，密鑰分為加密密鑰、解密密鑰2種，它們並不是同一個密鑰。
目前使用最廣泛的公鑰密碼演算法是RSA
加密密鑰，一般是公開的，因此該密鑰稱為公鑰（public key）
解密密鑰，由消息接收者自己保管的，不能公開，因此也稱為私鑰（private key）
公鑰和私鑰是一 一對應的，是不能單獨生成的，一對公鑰和密鑰統稱為密鑰對（key pair）
由公鑰加密的密文，必須使用與該公鑰對應的私鑰才能解密
由私鑰加密的密文，必野或枝須使用與該私鑰對應的公鑰才能解密
1.由消息的接收者，生成一對公鑰、私鑰
2.將公鑰發給消息的發送者
3.消息的發送者使用公鑰加密消息
混合密碼系統
不能很好地解決密鑰配送問題
加密解密速度比較慢
混合密碼系統，是將對稱密碼和公鑰密碼的優勢相團銀結合的方法，解決了公鑰密碼速度慢的問題，並通過公鑰密碼解決了對稱密碼的密鑰配送問題
會話密鑰（session key）為本次通信隨機生成的臨時密鑰，作為對稱密碼的密鑰，用於加密信息，提高速度
發送出去的內容包括
前端A >>>>> 伺服器端B
發送過程，加密過程
接收過程，解密過程
文章參考了 猿天地的再談前後端API簽名安全？ 和李明傑的底層原理iOS簽名機制