HTTPS

最新推荐文章于 2024-09-22 10:32:31 发布

长安0511

最新推荐文章于 2024-09-22 10:32:31 发布

阅读量348

点赞数

分类专栏：网络文章标签： https 网络 http

本文链接：https://blog.csdn.net/sun_0228/article/details/130448924

版权

网络专栏收录该内容

3 篇文章

订阅专栏

HTTPS通过在HTTP基础上引入SSL/TLS实现安全通信，结合对称加密和非对称加密确保数据的保密性。非对称加密使用公钥和私钥，对称加密则速度快但密钥分发困难。中间人攻击是安全隐患，数字证书和CA认证解决了这一问题，确保了服务器身份的真实性，防止数据被篡改。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

HTTPS是什么：

HTTPS （全称：Hypertext Transfer Protocol Secure ），是以安全为目标的 HTTP 通道，在HTTP的基础上通过传输加密和身份认证保证了传输过程的安全性。HTTPS 在HTTP 的基础下加入SSL，HTTPS 的安全基础是 SSL，因此加密的详细内容就需要 SSL。 HTTPS 存在不同于 HTTP 的默认端口及一个加密/身份验证层（在 HTTP与 TCP 之间）。这个系统提供了身份验证与加密通讯方法。它被广泛用于万维网上安全敏感的通讯，例如交易支付等方面。

以上解释来自百度百科，简单来讲：

1.HTTPS是一个应用层协议，是在HTTP协议基础上的引入了一个加密层。

2.HTTP协议内容都是按照文本的方式明文传输的，这会使其在传输过程中出现被篡改的情况。

那么什么又是加密呢？

加密就是把明文（需要传输的信息）进行一系列变换，生成密文。

解密就是把密文再进行一系列变换，还原成明文。

在这个过程中,通常需要一个或多个中间数据，辅助进行这个过程，这样的数据我们称之为密钥。

这里以儿时爱看的解密书为例，完美诠释了密文、密钥及明文。

为什么要加密？

因为http的内容是明文传输的，明文数据会经过路由器，WiFi热点，通信服务运营商，代理服务器等多个物理节点，如果信息在传输过程中被劫持，传输的内容则会被完全暴露或被更改，且不被双方察觉，这就是中间人攻击，所以我们需要对信息进行加密。

所以我们出现了HTTPS在HTTP的基础上进行加密，进一步保证用户信息安全。

常⻅的加密⽅式

对称加密

• 采⽤单钥密码系统的加密⽅法，同⼀个密钥可以同时⽤作信息的加密和解密，这种加密⽅法称为对称加密，也称为单密钥加密，特征：加密和解密所⽤的密钥是相同的

• 常⻅对称加密算法(了解)：DES、3DES、AES、TDEA、Blowfish、RC2等

• 特点：算法公开、计算量⼩、加密速度快、加密效率高，对称加密其实就是通过同⼀个 "密钥" , 把明⽂加密成密⽂, 并且也能把密⽂解密成明⽂.

⼀个简单的对称加密, 按位异或

假设明⽂ a = 1234, 密钥 key = 8888

则加密 a ^ key 得到的密⽂ b 为 9834.

然后针对密⽂ 9834 再次进⾏运算 b ^ key, 得到的就是原来的明⽂ 1234. (对于字符串的对称加密也是同理, 每⼀个字符都可以表⽰成⼀个数字) 当然, 按位异或只是最简单的对称加密. HTTPS 中并不是使⽤按位异或.

⾮对称加密

• 需要两个密钥来进⾏加密和解密，这两个密钥是公开密钥（public key，简称公钥）和私有密钥（private key，简称私钥）。

• 常⻅⾮对称加密算法(了解)：RSA，DSA，ECDSA

• 特点：算法强度复杂、安全性依赖于算法与密钥但是由于其算法复杂，⽽使得加密解密速度没有对称加密解密的速度快。

⾮对称加密要⽤到两个密钥, ⼀个叫做 "公钥", ⼀个叫做 "私钥".

公钥和私钥是配对的. 最⼤的缺点就是运算速度⾮常慢，⽐对称加密要慢很多.

• 通过公钥对明⽂加密, 变成密⽂

• 通过私钥对密⽂解密, 变成明⽂

也可以反着⽤

• 通过私钥对明⽂加密, 变成密⽂

• 通过公钥对密⽂解密, 变成明⽂

⾮对称加密的数学原理⽐较复杂, 涉及到⼀些数论相关的知识. 这⾥举⼀个简单的⽣活上的例⼦.

A 要给 B ⼀些重要的⽂件, 但是 B 可能不在. 于是 A 和 B 提前做出约定:

B 说: 我桌⼦上有个盒⼦, 然后我给你⼀把锁, 你把⽂件放盒⼦⾥⽤锁锁上, 然后我回头拿着钥匙来开锁

取⽂件.

在这个场景中, 这把锁就相当于公钥, 钥匙就是私钥. 公钥给谁都⾏(不怕泄露), 但是私钥只有 B ⾃⼰持有. 持有私钥的⼈才能解密.

HTTPS工作过程探究：

如果双方都共同持有一个秘钥X，没有别人知道，则通信安全可以保证，那么我们怎么让客户端和服务器都拿到此秘钥呢？

加密方案一：

都采用对称加密：

这个方法看似万无一失，客户端加密，服务器解密，就算被截获也没有密钥进行破解，但是这也会带来一个致命的错误——我们怎么保证双方第一次就都有相同的密钥呢？

如果我们在第一次传输时约定，岂不也是直接将密钥公开，相当于黑客也拿到了密钥，这不等于在互联网上裸奔嘛！！！这显然是一个无解的问题，所以此方案行不通！

加密方案二：

使用非对称加密：

1. 服务端拥有公钥b*与对应的私钥b，客⼾端拥有公钥a*与对应的私钥a

2. 客⼾和服务端交换公钥

3. 客⼾端给服务端发信息：先⽤b*对数据加密，再发送，只能由服务器解密，因为只有服务器有私钥 b

4. 服务端给客⼾端发信息：先⽤a*对数据加密，在发送，只能由客⼾端解密，因为只有客⼾端有私钥 a

这样看似两端都可以进行数据加密，中间人好像截取不到什么数据，但是真的安全吗？并且此方法效率对比对称加密是不是太低效了呢?

加密方案三：

对称加密+非对称加密：

有了以上两种方方法的经验，我们结合试着取长补短，结合一下——第一次使用非对称加密将我们共同商定的密钥888888进行加密使服务器和客户端都得到密钥888888（密钥协商阶段）

然后后期就可以拿着密钥进行对称加密的方式进行交互数据。

最后两种方案看似安全，真的吗？

Man-in-the-MiddleAttack，简称“MITM攻击”

确实，在⽅案2/3中，客⼾端获取到公钥S之后，对客⼾端形成的对称秘钥X⽤服务端给客⼾端的公钥 S进⾏加密，中间⼈即使窃取到了数据，此时中间⼈确实⽆法解出客⼾端形成的密钥X，因为只有服务器有私钥S'

但是中间⼈的攻击，如果在最开始握⼿协商的时候就进⾏了，那就不⼀定了，假设hacker已经成功成为中间⼈

1. 服务器具有⾮对称加密算法的公钥S，私钥S'

2. 中间⼈具有⾮对称加密算法的公钥M，私钥M'

3. 客⼾端向服务器发起请求，服务器明⽂传送公钥S给客⼾端

4. 中间⼈劫持数据报⽂，提取公钥S并保存好，然后将被劫持报⽂中的公钥S替换成为⾃⼰的公钥M，并将伪造报⽂发给客⼾端

5. 客⼾端收到报⽂，提取公钥M(⾃⼰当然不知道公钥被更换过了)，⾃⼰形成对称秘钥X，⽤公钥M加密X，形成报⽂发送给服务器

6. 中间⼈劫持后，直接⽤⾃⼰的私钥M'进⾏解密，得到通信秘钥X，再⽤曾经保存的服务端公钥S加密后，将报⽂推送给服务器

7. 服务器拿到报⽂，⽤⾃⼰的私钥S'解密，得到通信秘钥X

8. 双⽅开始采⽤X进⾏对称加密，进⾏通信。但是⼀切都在中间⼈的掌握中，劫持数据，进⾏窃听甚⾄修改，都是可以的

上⾯的攻击⽅案，同样适⽤于⽅案2，⽅案3

问题本质出在哪⾥了呢？客⼾端⽆法确定收到的含有公钥的数据报⽂，就是⽬标服务器发送过来的！

如果中间人从一开始就截取并修改，那么这也是不安全的！

数据指纹和数字签名：

数据摘要&&数据指纹：

• 数字指纹(数据摘要),其基本原理是利⽤单向散列函数(Hash函数)对信息进⾏运算,⽣成⼀串固定⻓度的数字摘要。数字指纹并不是⼀种加密机制,但可以⽤来判断数据有没有被窜改。

• 摘要常⻅算法：有MD5 、SHA1、SHA256、SHA512等，算法把⽆限的映射成有限，因此可能会有碰撞（两个不同的信息，算出的摘要相同，但是概率⾮常低）

• 摘要特征：和加密算法的区别是，摘要严格意义不是加密，因为没有解密，只不过从摘要很难反推原信息，通常⽤来进⾏数据对⽐

以MD5算法为例，相似的字符串，我们来看看差距有多大

可以看到因为 "," 与 " " 的不同，造就了行成字符串差距很大。

我们可以通过百度百科所给的算法进行尝试——

#include<iostream>
#include<string>
using namespace std;
#define shift(x, n) (((x) << (n)) | ((x) >> (32-(n))))//右移的时候，高位一定要补零，而不是补充符号位
#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 A 0x67452301
#define B 0xefcdab89
#define C 0x98badcfe
#define D 0x10325476
//strBaye的长度
unsigned int strlength;
//A,B,C,D的临时变量
unsigned int atemp;
unsigned int btemp;
unsigned int ctemp;
unsigned int dtemp;
//常量ti unsigned int(abs(sin(i+1))*(2pow32))
const unsigned int k[] = {
        0xd76aa478,0xe8c7b756,0x242070db,0xc1bdceee,
        0xf57c0faf,0x4787c62a,0xa8304613,0xfd469501,0x698098d8,
        0x8b44f7af,0xffff5bb1,0x895cd7be,0x6b901122,0xfd987193,
        0xa679438e,0x49b40821,0xf61e2562,0xc040b340,0x265e5a51,
        0xe9b6c7aa,0xd62f105d,0x02441453,0xd8a1e681,0xe7d3fbc8,
        0x21e1cde6,0xc33707d6,0xf4d50d87,0x455a14ed,0xa9e3e905,
        0xfcefa3f8,0x676f02d9,0x8d2a4c8a,0xfffa3942,0x8771f681,
        0x6d9d6122,0xfde5380c,0xa4beea44,0x4bdecfa9,0xf6bb4b60,
        0xbebfbc70,0x289b7ec6,0xeaa127fa,0xd4ef3085,0x04881d05,
        0xd9d4d039,0xe6db99e5,0x1fa27cf8,0xc4ac5665,0xf4292244,
        0x432aff97,0xab9423a7,0xfc93a039,0x655b59c3,0x8f0ccc92,
        0xffeff47d,0x85845dd1,0x6fa87e4f,0xfe2ce6e0,0xa3014314,
        0x4e0811a1,0xf7537e82,0xbd3af235,0x2ad7d2bb,0xeb86d391 };
//向左位移数
const unsigned int s[] = { 7,12,17,22,7,12,17,22,7,12,17,22,7,
        12,17,22,5,9,14,20,5,9,14,20,5,9,14,20,5,9,14,20,
        4,11,16,23,4,11,16,23,4,11,16,23,4,11,16,23,6,10,
        15,21,6,10,15,21,6,10,15,21,6,10,15,21 };
const char str16[] = "0123456789abcdef";
void mainLoop(unsigned int M[])
{
    unsigned int f, g;
    unsigned int a = atemp;
    unsigned int b = btemp;
    unsigned int c = ctemp;
    unsigned int d = dtemp;
    for (unsigned int i = 0; i < 64; i++)
    {
        if (i < 16) {
            f = F(b, c, d);
            g = i;
        }
        else if (i < 32)
        {
            f = G(b, c, d);
            g = (5 * i + 1) % 16;
        }
        else if (i < 48) {
            f = H(b, c, d);
            g = (3 * i + 5) % 16;
        }
        else {
            f = I(b, c, d);
            g = (7 * i) % 16;
        }
        unsigned int tmp = d;
        d = c;
        c = b;
        b = b + shift((a + f + k[i] + M[g]), s[i]);
        a = tmp;
    }
    atemp = a + atemp;
    btemp = b + btemp;
    ctemp = c + ctemp;
    dtemp = d + dtemp;
}
/*
*填充函数
*处理后应满足bits≡448(mod512),字节就是bytes≡56（mode64)
*填充方式为先加一个1,其它位补零
*最后加上64位的原来长度
*/
unsigned int* add(string str)
{
    unsigned int num = ((str.length() + 8) / 64) + 1;//以512位,64个字节为一组
    unsigned int* strByte = new unsigned int[num * 16];    //64/4=16,所以有16个整数
    strlength = num * 16;
    for (unsigned int i = 0; i < num * 16; i++)
        strByte[i] = 0;
    for (unsigned int i = 0; i < str.length(); i++)
    {
        strByte[i >> 2] |= (str[i]) << ((i % 4) * 8);//一个整数存储四个字节，i>>2表示i/4 一个unsigned int对应4个字节，保存4个字符信息
    }
    strByte[str.length() >> 2] |= 0x80 << (((str.length() % 4)) * 8);//尾部添加1 一个unsigned int保存4个字符信息,所以用128左移
    /*
    *添加原长度，长度指位的长度，所以要乘8，然后是小端序，所以放在倒数第二个,这里长度只用了32位
    */
    strByte[num * 16 - 2] = str.length() * 8;
    return strByte;
}
string changeHex(int a)
{
    int b;
    string str1;
    string str = "";
    for (int i = 0; i < 4; i++)
    {
        str1 = "";
        b = ((a >> i * 8) % (1 << 8)) & 0xff;   //逆序处理每个字节
        for (int j = 0; j < 2; j++)
        {
            str1.insert(0, 1, str16[b % 16]);
            b = b / 16;
        }
        str += str1;
    }
    return str;
}
string getMD5(string source)
{
    atemp = A;    //初始化
    btemp = B;
    ctemp = C;
    dtemp = D;
    unsigned int* strByte = add(source);
    for (unsigned int i = 0; i < strlength / 16; i++)
    {
        unsigned int num[16];
        for (unsigned int j = 0; j < 16; j++)
            num[j] = strByte[i * 16 + j];
        mainLoop(num);
    }
    return changeHex(atemp).append(changeHex(btemp)).append(changeHex(ctemp)).append(changeHex(dtemp));
}
unsigned int main()
{
    string ss;
    //    cin>>ss;
    string s1 = getMD5("hello sun");
    string s2 = getMD5("hello,sun");
    cout << s1 << endl;
    cout << s2 << endl;
    return 0;
}

缺点：这个算法虽然能得到一个唯一的字符串标识，但是通过此加密算法所得的字符串却是不可逆的，也就是只能得到唯一串，但是不能从唯一串推算回加密内容。