c64加密

㈠ C語言編譯加密問題

不可能的，二進制文件中只存在機器碼，不存在源代碼。

㈡ c語言編寫加密程序

#include <stdio.h>
#include <string.h>
#include "global.h"
#include "md5.h"

#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21

static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char
[64]));
static void Encode PROTO_LIST
((unsigned char *, UINT4 *, unsigned int));
static void Decode PROTO_LIST
((UINT4 *, unsigned char *, unsigned int));
static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned
int));
static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int));

static unsigned char PADDING[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))

#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

#define FF(a, b, c, d, x, s, ac) { (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b);}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}

void MD5Init (context)
MD5_CTX *context;
{
context->count[0] = context->count[1] = 0;
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
}

void MD5Update (context, input, inputLen)
MD5_CTX *context;
unsigned char *input;
unsigned int inputLen;
{
unsigned int i, index, partLen;
index = (unsigned int)((context->count[0] >> 3) & 0x3F);
if ((context->count[0] += ((UINT4)inputLen << 3))< ((UINT4)inputLen << 3))
context->count[1]++;
context->count[1] += ((UINT4)inputLen >> 29);
partLen = 64 - index;
if (inputLen >= partLen)
{
MD5_memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
MD5Transform (context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64)
MD5Transform (context->state, &input[i]);
index = 0;
}
else
i = 0;
MD5_memcpy((POINTER)&context->buffer[index], (POINTER)&input[i],inputLen-i);
}

void MD5Final (digest, context)
unsigned char digest[16];
MD5_CTX *context;
{
unsigned char bits[8];
unsigned int index, padLen;
Encode (bits, context->count, 8);
index = (unsigned int)((context->count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
MD5Update (context, PADDING, padLen);
MD5Update (context, bits, 8);
Encode (digest, context->state, 16);
MD5_memset ((POINTER)context, 0, sizeof (*context));
}

static void MD5Transform (UINT4 state[4], unsigned char block[64])
{
UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
Decode (x, block, 64);
FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */

/* Round 2 */
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */

GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

/* Round 3 */
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */

/* Round 4 */
II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */

state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
MD5_memset ((POINTER)x, 0, sizeof (x));
}

static void Encode (output, input, len)
unsigned char *output;
UINT4 *input;
unsigned int len;
{
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
{
output[j] = (unsigned char)(input[i] & 0xff);
output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
}
}

static void Decode (output, input, len)
UINT4 *output;
unsigned char *input;
unsigned int len;
{
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |(((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
}

static void MD5_memcpy (output, input, len)
POINTER output;
POINTER input;
unsigned int len;
{
unsigned int i;
for (i = 0; i < len; i++)
output[i] = input[i];
}

static void MD5_memset (output, value, len)
POINTER output;
int value;
unsigned int len;
{
unsigned int i;
for (i = 0; i < len; i++)
((char *)output)[i] = (char)value;
}
#ifndef MD
#define MD 5
#endif

#define TEST_BLOCK_LEN 1000
#define TEST_BLOCK_COUNT 1000

static void MDString PROTO_LIST ((char *));
static void MDPrint PROTO_LIST ((unsigned char [16]));

#define MD_CTX MD5_CTX
#define MDInit MD5Init
#define MDUpdate MD5Update
#define MDFinal MD5Final

int main (int argc, char *argv[])
{
int i;
if (argc > 1)
{ MDString(argv[1]);
return (0);
}
}

static void MDString (char *string)
{
MD_CTX context;
unsigned char digest[16];
unsigned int len = strlen (string);

MDInit (&context);
MDUpdate (&context, string, len);
MDFinal (digest, &context);

printf ("MD%d (\"%s\") = ", MD, string);
MDPrint (digest);
printf ("\n");
}

static void MDPrint (unsigned char digest[16])
{
unsigned int i;
for (i = 0; i < 16; i++)
printf ("%02x", digest[i]);

}

㈢ C語言編程：編寫一個函數base64加密

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

constchar*chlist="+/";

intencode_string(char*str,unsignedintlength,char*stat){
	chars[103];
	inti,j;
	unsignedtemp;
	if(length<=0)return1;
	if(length>100)return2;
	str[length]='';
	strcpy(s,str);
	while(strlen(s)%3)strcat(s,"=");
	for(i=0,j=0;s[i];i+=3,j+=4){
		temp=s[i];
		temp=(temp<<8)+s[i+1];
		temp=(temp<<8)+s[i+2];
		stat[j+3]=chlist[temp&0X3F];
		temp>>=6;
		stat[j+2]=chlist[temp&0X3F];
		temp>>=6;
		stat[j+1]=chlist[temp&0X3F];
		temp>>=6;
		stat[j+0]=chlist[temp&0X3F];
	}
	stat[j]='';
	return0;
}

intIndex(charch){
	inti;
	for(i=0;chlist[i];++i){
		if(chlist[i]==ch)
			returni;
	}
	return-1;
}

voiddecode_string(char*s,char*t){
	unsignedtemp;
	inti,j,k,len=strlen(s);
	if(len%4){
		printf("無效數據。
");
		exit(2);
	}
	for(i=0,j=0;i<=len;i+=4,j+=3){
		temp=0;
		for(k=0;k<4;++k)
			temp=(temp<<6)+Index(s[i+k]);
		for(k=2;k>=0;--k){
			t[j+k]=temp&0XFF;
			temp>>=8;
		}
	}
	t[j+k]='';
}

intmain(){
	chars[100]="1a2a3s4dff5fj6u7M8B9P0O1U2";
	chart[150],u[100];
	printf("s=%s
",s);
	encode_string(s,strlen(s),t);
	printf("t=%s
",t);
	decode_string(t,u);
	printf("u=%s
",u);
	return0;
}

㈣ C語言英文文本加密

#include "stdio.h"

#include <stdlib.h>

int main(int argc,char *argv[]){

FILE *fp,*fq;

int k,t;

fp=fopen("AAA12345678901.txt","w+");

if(!fp || (fq=fopen("tmp.txt","w"))==NULL){

printf("Failed to open the file and exit... ");

return 0;

}

printf("Please enter a short passage(letters+space+punctuation,'Enter' end)... ");

while((t=getchar())!=' ')//為文件輸入內容

fputc(t,fp);

printf("Please enter the encryption key(int >0)... k=");

while(scanf("%d",&k)!=1 || k<1){//輸入加密密鑰並判斷是否正確

printf("Input error, redo: ");

fflush(stdin);

}

rewind(fp);

while(t=fgetc(fp),!feof(fp))//加密

if(t>='A' && t<='Z')

fputc(((t-'A')+k)%26+'A',fq);

else if(t>='a' && t<='z')

fputc(((t-'a')+k)%26+'a',fq);

else

fputc(t,fq);

fclose(fp);//關閉原文件

fclose(fq);//關閉加密後的文件

remove("AAA12345678901.txt");//刪除原文件

rename("tmp.txt","AAA12345678901.txt");//將加密後的文件更換為原文件名

printf(" ");

if(fp=fopen("AAA12345678901.txt","r")){

while((t=fgetc(fp))!=EOF)

printf("%c",t);

printf(" Encryption success! ");

}

else

printf(" Failed to open the encrypted file... ");

fclose(fp);

return 0;

}

代碼格式和運行樣例圖片：

㈤ 數據加密的方法有哪些如題

1. 數據加密標准 傳統加密方法有兩種,替換和置換.上面的例子採用的就是替換的方法：使用密鑰將明文中的每一個字元轉換為密 文中的一個字元.而置換僅將明文的字元按不同的順序重新排列.單獨使用這兩種方法的任意一種都是不夠安全的,但 是將這兩種方法結合起來就能提供相當高的安全程度.數據加密標准（Data Encryption Standard,簡稱DES）就採用了 這種結合演算法,它由IBM制定,並在1977年成為美國官方加密標准. DES的工作原理為：將明文分割成許多64位大小的塊,每個塊用64位密鑰進行加密,實際上,密鑰由56位數據位和8 位奇偶校驗位組成,因此只有256個可能的密碼而不是264個.每塊先用初始置換方法進行加密,再連續進行16次復雜的 替換,最後再對其施用初始置換的逆.第i步的替換並不是直接利用原始的密鑰K,而是由K與i計算出的密鑰Ki. DES具有這樣的特性,其解密演算法與加密演算法相同,除了密鑰Ki的施加順序相反以外. 2. 公開密鑰加密 多年來,許多人都認為DES並不是真的很安全.事實上,即使不採用智能的方法,隨著快速、高度並行的處理器的出 現,強制破解DES也是可能的.公開密鑰加密方法使得DES以及類似的傳統加密技術過時了.公開密鑰加密方法中,加密 演算法和加密密鑰都是公開的,任何人都可將明文轉換成密文.但是相應的解密密鑰是保密的（公開密鑰方法包括兩個密鑰, 分別用於加密和解密）,而且無法從加密密鑰推導出,因此,即使是加密者若未被授權也無法執行相應的解密. 公開密鑰加密思想最初是由Diffie和Hellman提出的,最著名的是Rivest、Shamir以及Adleman提出的,現在通常稱為 RSA（以三個發明者的首位字母命名）的方法,該方法基於下面的兩個事實： 1) 已有確定一個數是不是質數的快速演算法； 2) 尚未找到確定一個合數的質因子的快速演算法. RSA方法的工作原理如下： 1) 任意選取兩個不同的大質數p和q,計算乘積r=p*q； 2) 任意選取一個大整數e,e與(p-1)*(q-1)互質,整數e用做加密密鑰.注意：e的選取是很容易的,例如,所有大 於p和q的質數都可用. 3) 確定解密密鑰d： d * e = 1 molo（p - 1）*（q - 1） 根據e、p和q可以容易地計算出d. 4) 公開整數r和e,但是不公開d； 5) 將明文P (假設P是一個小於r的整數)加密為密文C,計算方法為： C = Pe molo r 6) 將密文C解密為明文P,計算方法為： P = Cd molo r 然而只根據r和e（不是p和q）要計算出d是不可能的.因此,任何人都可對明文進行加密,但只有授權用戶（知道d） 才可對密文解密.

㈥ 加密技術

對稱加密就是指，加密和解密使用同一個密鑰的加密方式。需要用到的有加密演算法和加密秘鑰。例如加密演算法可以類似這樣的加密規則(a ->b，b->w，c->a)

發送方使用密鑰將明文數據加密成密文，然後發送出去，接收方收到密文後，使用同一個密鑰將密文解密成明文讀取。

優點：加密計算量小、速度快，效率高，適合對大量數據進行加密的場景。
缺點：（1）密鑰不適合在網上傳輸（容易被截取），（2）密鑰維護麻煩

DES 、3DES、Blowfish、IDEA、RC4、RC5、RC6和AES。

數據加密標准DES屬於常規密鑰密碼體制，是一種分組密碼。加密前，先對整個明文進行分組，每一組長為64位，然後對每一個64位二進制數據進行加密處理，產生一組64位密文數據。最後將各組密文串接起來，即得出整個的密文。使用的密鑰為64位（實際密鑰長度為56位，有8位用於奇偶檢驗）

DES的保密性取決於密鑰的保密，而演算法是公開的。盡管人們在破譯DES方面取得了許多進展，但至今仍未能找到比窮舉搜索密鑰更有效的方法。DES是世界上第一個公認的實用密碼演算法標准，它曾對密碼學的發展做出了重大貢獻。目前較為嚴重的問題是DES的密鑰長度，現在已經設計出搜索DES密鑰的專用晶元。

DES演算法安全性取決於密鑰長度，56位密鑰破解需要3.5到21分鍾，128位密鑰破解需要5.4 * 10^18次方年

注意的是：這里是沒有密鑰的情況下，直接窮舉密鑰嘗試破解。如果密鑰在傳送過程中被人截取了，就相當於直接知道加密規則了，根本不需要破解，因此密鑰在網路中傳送還是不安全。

與對稱加密演算法不同，非對稱加密演算法需要密鑰對，即兩個密鑰：公開密鑰（公鑰）和私有密鑰（私鑰）。

公開密鑰與私有密鑰是一對，如果用公開密鑰對數據進行加密，只有用對應的私有密鑰才能解密；如果用私有密鑰對數據進行加密，那麼只有用對應的公開密鑰才能解密。因為加密和解密使用的是兩個不同的密鑰，所以這種演算法叫作非對稱加密演算法。

公鑰和私鑰是怎麼來的？
操作系統隨機生成一個隨機數，將這個隨機數通過某個函數進行運算，分成兩部分，公鑰和私鑰

優點：安全性高
缺點：加密與解密速度慢。

RSA、ECC（移動設備用）、Diffie-Hellman、El Gamal、DSA（數字簽名用）。

答案是不能
鑒於非對稱加密的機制，我們可能會有這種思路：伺服器先把公鑰直接明文傳輸給瀏覽器，之後瀏覽器向伺服器傳數據前都先用這個公鑰加密好再傳，這條數據的安全似乎可以保障了！ 因為只有伺服器有相應的私鑰能解開這條數據 。
然而 由伺服器到瀏覽器的這條路怎麼保障安全？ 如果伺服器用它的的私鑰加密數據傳給瀏覽器，那麼瀏覽器用公鑰可以解密它，而這個公鑰是一開始通過明文傳輸給瀏覽器的，這個公鑰被誰劫持到的話，他也能用該公鑰解密伺服器傳來的信息了。所以 目前似乎只能保證由瀏覽器向伺服器傳輸數據時的安全性 （其實仍有漏洞，下文會說）。

1、先通過非對稱加密技術，把對稱加密的密鑰X傳給對方，使得這個對稱加密的密鑰X是安全的
2、後面再通過對稱加密技術進行數據傳輸

詳細流程
（1）伺服器端擁有用於非對稱加密的 公鑰A 、 私鑰A』 。
（2）客戶端向網站伺服器請求，伺服器先把 公鑰A 明文給傳輸瀏客戶端
（3）客戶端隨機生成一個用於對稱加密的 密鑰X ，用 公鑰A 加密後傳給伺服器端。
（4）伺服器端拿到後用 私鑰A』 解密得到 密鑰X 。
（5）這樣雙方就都擁有 密鑰X 了，且別人無法知道它。之後雙方所有數據都用 密鑰X 加密解密。

數字簽名是基於公鑰密碼體制（非對稱密鑰密碼體制）的。

數字簽名必須保證以下三點：

上圖位用戶A使用數字簽名向用戶B傳輸一份文件的過程：

什麼時候使用這種不對文件加密，而對文件的摘要加密（對文件進行簽名）的技術呢？

注意： 這里強調的是只有「A公鑰」 上有認證機構CA的數字簽名，意思是CA用它的私鑰對「A公鑰」的內容進行單向散列函數得到的 加密摘要（數字簽名） ，該簽名放在「A公鑰」中（左上角那個），對於B用戶來說，它從可靠的路徑拿到CA的公鑰，使用CA的公鑰解密「A公鑰」的內容得到的128位的摘要 和 「A公鑰」的內容通過單向散列函數計算出來的是否一致，如果是表示認可這個「A公鑰」

當用戶A遺失或泄露了CA頒發的證書後，為了避免他人使用該證書冒充用戶A，用戶A向認證機構CA "掛失" 該證書。於是認證機構CA把該證書放入該認證機構的證書吊銷列表（CRL）中，並在網上公示。

用戶B在收到用戶A的公鑰時，除了要驗證該公鑰是否位認證機構頒發的，還要登錄認證機構的網站查看該公鑰是否已被認證機構吊銷變為無效證書。

認證機構CA的作用：

1、http連接很簡單，是無狀態的，明文傳輸。https協議 = http協議 + SSL，可以進行加密傳輸，身份認證
2、http連接的是80埠，https連接的是443埠
3、https協議需要伺服器端到CA申請SSL證書，即客戶端請求的時候，伺服器端發送SSL證書給客戶端，SSL證書內容包括公鑰、CA機構的數字簽名。驗證了伺服器端的身份以及公鑰的可靠性。 （注意：混合加密那裡「將公鑰A給客戶端」，嚴格的來說是把SSL證書給客戶端）

SSL提供以下三個功能
1、 SSL伺服器鑒別。允許用戶證實伺服器的身份。 具有SSL功能的瀏覽器維持一個表，上面有一些可信賴的認證中心CA和它們的公鑰
2、 SSL客戶鑒別。允許伺服器證實客戶的身份。
3、 加密的SSL會話，通過混合加密實現的 。客戶和伺服器交互的所有數據都是發送方加密，接受方解密

SSL的位置

（1）方法：get，post，head，put，delete，option，trace，connect
（2）URL欄位
（3）HTTP協議版本

User-Agent：產生請求的瀏覽器類型
Aceept：客戶端可識別的內容類型列表
Host：主機地址

200：請求被成功處理
301：永久性重定向
302：臨時性重定向
403：沒有訪問許可權
404：沒有對應資源
500：伺服器錯誤
503：伺服器停機

HTTP協議的底層使用TCP協議，所以HTTP協議的長連接和短連接在本質上是TCP層的長連接和短連接。由於TCP建立連接、維護連接、釋放連接都是要消耗一定的資源，浪費一定的時間。所對於伺服器來說，頻繁的請求釋放連接會浪費大量的時間，長時間維護太多的連接的話又需要消耗資源。所以長連接和短連接並不存在優劣之分，只是適用的場合不同而已。長連接和短連接分別有如下優點和缺點：

注意： 從HTTP/1.1版本起，默認使用長連接用以保持連接特性。 使用長連接的HTTP協議，會在響應消息報文段加入: Connection: keep-alive。TCP中也有keep alive，但是TCP中的keep alive只是探測TCP連接是否活著，而HTTP中的keep-alive是讓一個TCP連接獲得更久一點。