python tcp socket中实现SSL/TLS认证

已于 2024-01-11 18:54:14 修改
阅读量2.7k 收藏 25
点赞数 29
分类专栏： # python基础 文章标签： python tcp/ip ssl
于 2024-01-11 18:50:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/python_9k/article/details/135536597
版权

SSL/TLS介绍

官话说SSL是安全套接层(secure sockets layer)，TLS是SSL的继任者，叫传输层安全(transport layer security)。

说白点，就是在明文的上层和TCP层之间加上一层加密，这样就保证上层信息传输的安全。如HTTP协议是明文传输，加上SSL层之后，就有了雅称HTTPS。它存在的唯一目的就是保证上层通讯安全的一套机制。

传统的 TLS 握手过程:

单向认证和双向认证

SSL认证分为单向认证和双向认证，是在安全通信中使用的两种不同的身份验证方式，它们之间的主要区别在于身份验证的方向和安全性。

  1. 单向认证（One-Way Authentication）：

    • 客户端认证服务器：

      • 无需客户端拥有客户端证书，只需服务端拥有服务器证书。
      • 例如：浏览器通常会内置一组根证书，这些根证书由浏览器厂商或操作系统供应商预先安装在浏览器中。这组内置的根证书是被广泛信任的证书颁发机构（Certificate Authorities，CAs）签发的根证书，用于验证网站和服务的数字证书的可信性。
      • 当您访问一个使用HTTPS协议的网站时，您的浏览器会使用其内置的根证书来验证该网站的数字证书是否由受信任的CA签发。如果验证通过，浏览器将显示一个锁定图标或其他安全标志，表示连接是安全的。如果验证未通过，浏览器通常会发出警告，提醒您可能存在安全风险。
      • 因此，根证书在浏览器中起到了关键的作用，它们构成了安全通信的基础。浏览器定期更新其内置的根证书，以反映新的CA或吊销的证书，以确保持续的安全性和可信性。

    • 适用场景：单向认证适用于大多数Web浏览和服务器通信场景，一般情况下，在打开页面的时候没有提示数据加密插件的，属于单向认证，即浏览器只持有公钥。

  1. 双向认证（Two-Way Authentication）：

    • 服务器验证客户端和客户端验证服务器：双向认证中，服务器验证客户端的身份，同时客户端也验证服务器的身份。这意味着客户端和服务器都需要提供有效的证书以进行相互验证。

    • 更高的安全性：双向认证提供更高的安全性，因为它确保了通信的两端都是合法的，并且双方都可以互相验证。

    • 适用场景：双向认证通常在需要更高级别的安全性的场景中使用，例如金融交易、医疗保健、政府通信等，其中双方都需要互相验证以确保身份。类似于支付宝、银行的U顿支付之类的，会要求用户安装插件或驱动，属于双向验证。

总之，单向认证用于服务器验证客户端的情况，而双向认证要求双方都进行身份验证，提供更高级别的安全性。选择哪种认证方式取决于您的应用程序的特定需求和安全性要求。

生成自签名证书文件

数字证书一般由数字证书认证机构签发，证书包含了：

  • 公钥。
  • 证书拥有者身份信息。
  • 数字证书认证机构（发行者）信息。
  • 发行者对这份文件的数字签名及使用的算法。
  • 有效期。

生成 CA 根证书、服务器证书和客户端证书的步骤如下：

步骤 1：创建 CA 根密钥和证书

首先，您需要生成一个 CA 根密钥（私钥）和一个 CA 根证书。以下是一些基本的步骤：

  1. 创建 CA 根密钥 (ca-key.pem)。这是用于签署服务器和客户端证书请求的私钥。请确保保护好这个私钥文件，因为它是证书链的根。
openssl genpkey -algorithm RSA -out ca-key.pem
  1. 使用 CA 根密钥创建自签名的 CA 根证书 (ca-cert.pem)。
openssl req -new -x509 -key ca-key.pem -out ca-cert.pem -days 3650

在此过程中，您需要提供一些 CA 根证书的信息，如组织、单位、常用名等。

步骤 2：创建服务器证书请求和证书

接下来，您需要为服务器创建证书请求并签署服务器证书。

  1. 创建服务器密钥 (server-key.pem)。
openssl genpkey -algorithm RSA -out server-key.pem
  1. 使用服务器密钥创建证书请求 (server-csr.pem)。在这一步中，您需要提供服务器的信息，如主机名（通常是服务器的域名）。
openssl req -new -key server-key.pem -out server-csr.pem


(py3.8) root@localhost:/opt/lianhaifeng/test2# openssl req -new -key server-key.pem -out server-csr.pem
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:CN
State or Province Name (full name) [Some-State]:fujian
Locality Name (eg, city) []:xiamen
Organization Name (eg, company) [Internet Widgits Pty Ltd]:
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:
Email Address []:

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:
  1. 使用 CA 根证书和私钥签署服务器证书请求，生成服务器证书 (server-cert.pem)。
openssl x509 -req -in server-csr.pem -CA ca-cert.pem -CAkey ca-key.pem -out server-cert.pem -CAcreateserial -days 3650

(py3.8) root@localhost:/opt/lianhaifeng/test2# openssl x509 -req -in server-csr.pem -CA ca-cert.pem -CAkey ca-key.pem -out server-cert.pem -CAcreateserial -days 3650
Signature ok
subject=C = CN, ST = fujian, L = xiamen, O = Internet Widgits Pty Ltd
Getting CA Private Key
  1. 验证生成的服务器证书，如果验证成功，它将不会输出任何错误消息。
openssl verify -CAfile ca-cert.pem client-cert.pem  # 验证证书链完整性
openssl x509 -text -noout -in server-cert.pem  # 验证证书属性


(py3.8) root@localhost:/opt/lianhaifeng/test2# openssl verify -CAfile ca-cert.pem server-cert.pem
server-cert.pem: OK

步骤 3：创建客户端证书请求和证书（可选）

如果您需要客户端证书以进行双向认证，则可以执行以下步骤：

  1. 创建客户端密钥 (client-key.pem)。
openssl genpkey -algorithm RSA -out client-key.pem


(py3.8) root@localhost:/opt/lianhaifeng/test2# openssl genpkey -algorithm RSA -out client-key.pem
....................................................................................................................................................................+++++
........+++++
  1. 使用客户端密钥创建证书请求 (client-csr.pem)。
openssl req -new -key client-key.pem -out client-csr.pem


(py3.8) root@localhost:/opt/lianhaifeng/test2# openssl req -new -key client-key.pem -out client-csr.pem
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:CN
State or Province Name (full name) [Some-State]:fujian
Locality Name (eg, city) []:qz
Organization Name (eg, company) [Internet Widgits Pty Ltd]:
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:
Email Address []:

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:
  1. 使用 CA 根证书和私钥签署客户端证书请求，生成客户端证书 (client-cert.pem)。
openssl x509 -req -in client-csr.pem -CA ca-cert.pem -CAkey ca-key.pem -out client-cert.pem -CAcreateserial -days 3650

注意： 在实际生产环境中，需要更多的安全性和细化控制。此示例仅提供了基本步骤和示例命令，具体的配置可能因您的环境和需求而有所不同。同时，请确保适当地保护和存储您的密钥和证书文件。

  1. 验证生成的服务器证书，如果验证成功，它将不会输出任何错误消息。
openssl verify -CAfile ca-cert.pem client-cert.pem  # 验证证书链完整性
openssl x509 -text -noout -in server-cert.pem  # 验证证书属性

python实现SSL单向认证

通过上面的介绍，我们已经了解了单向认证的一般概念及流程。

下面是一个简单的Python示例代码，演示了如何在客户端认证服务端证书：

ssl_server.py

import socket
import ssl
import threading

class server_ssl:
    def build_listen(self):
        # CA_FILE = "ca-cert.pem"
        KEY_FILE = "server-key.pem"
        CERT_FILE = "server-cert.pem"
        context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
        context.load_cert_chain(certfile=CERT_FILE, keyfile=KEY_FILE)  # 加载服务端证书和私钥
        # context.load_verify_locations(CA_FILE)  # 加载根证书
        context.verify_mode = ssl.CERT_NONE  # 不需要客户端提供证书

        # 监听端口
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
            # 将socket打包成SSL socket
            with context.wrap_socket(sock, server_side=True) as ssock:
                ssock.bind(('127.0.0.1', 10036))
                ssock.listen(5)
                print("Server is listening for connections...")

                while True:
                    # 接收客户端连接
                    client_socket, addr = ssock.accept()
                    print(f"Accepted connection from {addr}")

                    # 创建新线程来处理客户端请求
                    client_thread = threading.Thread(target=self.handle_client, args=(client_socket, addr))
                    client_thread.start()

    def handle_client(self, client_socket, addr):
        try:
            while True:
                # 接收客户端信息
                msg = client_socket.recv(1024).decode("utf-8")
                if not msg:
                    break  # 客户端断开连接

                print(f"Received message from client {addr}: {msg}")

                # 向客户端发送信息
                response = f"Received: {msg}".encode("utf-8")
                client_socket.send(response)
        except Exception as e:
            print(f"Error: {str(e)}")
        finally:
            client_socket.close()
            print("Connection closed")

if __name__ == "__main__":
    server = server_ssl()
    server.build_listen()

运行server端代码：

(py3.8) root@localhost:/opt/lianhaifeng# python ssl_server.py
Server is listening for connections...
Accepted connection from ('127.0.0.1', 49814)
Received message from client ('127.0.0.1', 49814): hello
Received message from client ('127.0.0.1', 49814): world

ssl_client.py

import socket
import ssl

class client_ssl:
    def send_hello(self):
        CA_FILE = "ca-cert.pem"
        # CLIENT_KEY_FILE = "client-key.pem"
        # CLIENT_CERT_FILE = "client-cert.pem"

        # 创建SSL上下文对象
        context = ssl.SSLContext(ssl.PROTOCOL_TLS)
        context.check_hostname = False
        # context.load_cert_chain(certfile=CLIENT_CERT_FILE, keyfile=CLIENT_KEY_FILE)  # 服务器不需要认证客户端证书，故不需要
        context.load_verify_locations(CA_FILE)   # 使用根证书认证服务端证书
        context.verify_mode = ssl.CERT_REQUIRED

        # 与服务端建立socket连接
        with socket.socket() as sock:
            # 将socket打包成SSL socket
            with context.wrap_socket(sock, server_side=False) as ssock:
                ssock.connect(('127.0.0.1', 10036))

                while True:
                    # 输入要发送的消息
                    msg = input("Enter a message to send (or 'quit' to exit): ")
                    if msg.lower() == 'quit':
                        break

                    # 向服务端发送消息
                    ssock.send(msg.encode("utf-8"))

                    # 接收并打印服务端返回的消息
                    response = ssock.recv(1024).decode("utf-8")
                    print(f"Received message from the server: {response}")

if __name__ == "__main__":
    client = client_ssl()
    client.send_hello()

运行客户端代码：

(py3.8) root@localhost:/opt/lianhaifeng# python ssl_client.py
Enter a message to send (or 'quit' to exit): hello
Received message from the server: Received: hello
Enter a message to send (or 'quit' to exit): world
Received message from the server: Received: world
Enter a message to send (or 'quit' to exit):

python实现SSL双向认证

下面是一个简单的Python示例代码，演示了如何在服务器和客户端之间进行双向认证：

服务器端代码 server.py：

import socket
import ssl
import threading

class server_ssl:
    def build_listen(self):
        CA_FILE = "ca-cert.pem"
        KEY_FILE = "server-key.pem"
        CERT_FILE = "server-cert.pem"
        context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
        context.load_cert_chain(certfile=CERT_FILE, keyfile=KEY_FILE)
        context.load_verify_locations(CA_FILE)
        context.verify_mode = ssl.CERT_REQUIRED  # 如果服务器不验证客户端证书：ssl.CERT_NONE 
        context.check_hostname = False

        # 监听端口
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
            # 将socket打包成SSL socket
            with context.wrap_socket(sock, server_side=True) as ssock:
                ssock.bind(('127.0.0.1', 10028))
                ssock.listen(5)
                print("Server is listening for connections...")

                while True:
                    # 接收客户端连接
                    client_socket, addr = ssock.accept()
                    print(f"Accepted connection from {addr}")

                    # 创建新线程来处理客户端请求
                    client_thread = threading.Thread(target=self.handle_client, args=(client_socket, addr))
                    client_thread.start()

    def handle_client(self, client_socket, addr):
        try:
            while True:
                # 接收客户端信息
                msg = client_socket.recv(1024).decode("utf-8")
                if not msg:
                    break  # 客户端断开连接

                print(f"Received message from client {addr}: {msg}")

                # 向客户端发送信息
                response = f"Received: {msg}".encode("utf-8")
                client_socket.send(response)
        except Exception as e:
            print(f"Error: {str(e)}")
        finally:
            client_socket.close()
            print("Connection closed")

if __name__ == "__main__":
    server = server_ssl()
    server.build_listen()



(py3.8) root@localhost:/opt/lianhaifeng/test2# python server.py
Server is listening for connections...
Accepted connection from ('127.0.0.1', 55364)
Received message from client ('127.0.0.1', 55364): hello
Received message from client ('127.0.0.1', 55364): haige1
Accepted connection from ('127.0.0.1', 55366)
Received message from client ('127.0.0.1', 55366): hello
Received message from client ('127.0.0.1', 55366): haige2

客户端代码 client.py：

import socket
import ssl

class client_ssl:
    def send_hello(self):
        CA_FILE = "ca-cert.pem"
        SERVER_CERT_FILE = "server-cert.pem"  # 服务器证书文件路径
        CLIENT_KEY_FILE = "client-key.pem"
        CLIENT_CERT_FILE = "client-cert.pem"

        # 创建SSL上下文对象
        context = ssl.SSLContext(ssl.PROTOCOL_TLS)
        context.check_hostname = False
        context.load_cert_chain(certfile=CLIENT_CERT_FILE, keyfile=CLIENT_KEY_FILE)
        context.load_verify_locations(CA_FILE)
        context.verify_mode = ssl.CERT_REQUIRED
        context.load_verify_locations(cafile=CA_FILE)  # 设置根证书

        # 与服务端建立socket连接
        with socket.socket() as sock:
            # 将socket打包成SSL socket
            with context.wrap_socket(sock, server_side=False) as ssock:
                ssock.connect(('127.0.0.1', 10026))

                while True:
                    # 输入要发送的消息
                    msg = input("Enter a message to send (or 'quit' to exit): ")
                    if msg.lower() == 'quit':
                        break

                    # 向服务端发送消息
                    ssock.send(msg.encode("utf-8"))

                    # 接收并打印服务端返回的消息
                    response = ssock.recv(1024).decode("utf-8")
                    print(f"Received message from the server: {response}")

if __name__ == "__main__":
    client = client_ssl()
    client.send_hello()

客户端1

(py3.8) root@localhost:/opt/lianhaifeng/test2# python client.py
Enter a message to send (or 'quit' to exit): hello
Received message from the server: Received: hello
Enter a message to send (or 'quit' to exit): haige1
Received message from the server: Received: haige1
Enter a message to send (or 'quit' to exit):

客户端2

(py3.8) root@localhost:/opt/lianhaifeng/test2# python client.py
Enter a message to send (or 'quit' to exit): hello
Received message from the server: Received: hello
Enter a message to send (or 'quit' to exit): haige2
Received message from the server: Received: haige2
Enter a message to send (or 'quit' to exit):

若是服务端要求验证客户端证书，但是客户端没有携带证书，则会引发一个常见的网络错误：ConnectionResetError: [Errno 104] Connection reset by peer，此时在服务器端也会有详细信息：ssl.SSLError: [SSL: PEER_DID_NOT_RETURN_A_CERTIFICATE] peer did not return a certificate (_ssl.c:1131)

如果本篇文章对你所有帮助，欢迎转发、点赞、收藏、在看，非常感谢。

参考

https://www.jianshu.com/p/ffcf1b765d76
https://blog.csdn.net/wuliganggang/article/details/78428866
https://blog.csdn.net/zhangtaoym/article/details/55259889
https://cloud.tencent.com/document/product/214/54254

海哥python
关注
专栏目录
【Python】深入理解TLS协议（附Python实现）
qq_20623849的博客
02-21 3306
深入理解TLS协议
python关于SSL/TLS认证的实现
热门推荐
vip97yigang的专栏
12-02 6万+
最近有个客户端的需求是和服务端建立安全的链路，需要用ssl双向认证的方式实现。刚开始的时候被各种证书认证搞得晕乎乎-_-，花了好长时间才理清思路实现需求，所以写下这篇文章记录分享。接下来先介绍下啥是SSL。 参考 https://blog.csdn.net/wuliganggang/article/details/78428866 https://blog.csdn.net/duanbokan/a...
Python-TLS-Client 使用指南
最新发布
gitblog_01085的博客
08-09 986
Python-TLS-Client 使用指南 Python-Tls-ClientAdvanced HTTP Library项目地址:https://gitcode.com/gh_mirrors/py/Python-Tls-Client 项目介绍 Python-TLS-Client 是一个基于 requests 和自定义 tls-client 的高级HTTP库，专为Python开发者设计。它提供...
python网络编程——TLS/SSL
qq_40909772的博客
03-29 5236
1.TLS简介。        TLS的前身是 安全套接层 ，是传输层安全协议。TLS能保护的信息包括： 与请求URL之间的HTTPS连接以及返回内容。 密码或cookies等可能在套接字双向传递的任意认证信息。        但TLS并不是万能的它也有不...
python socket中实现SSL/TLS认证
weixin_68789096的博客
09-13 1857
官话说SSL是安全套接层(secure sockets layer)，TLS是SSL的继任者，叫传输层安全(transport layer security)。说白点，就是在明文的上层和TCP层之间加上一层加密，这样就保证上层信息传输的安全。如HTTP协议是明文传输，加上SSL层之后，就有了雅称HTTPS。它存在的唯一目的就是保证上层通讯安全的一套机制。
python实现ssl通信
qq_56426046的博客
11-09 3877
SSL通信的本质就是客户端拿着认证机关的证书去认证对方网站到底是不是你要访问的。客户端以后每次访问一个重要的网站时就要拿着发证机关CA（Cerficate Authority）的证书和对方连接的时候验证一下。客户端连接的时候服务端也有证书，这个证书也是CA发给他们的，里面的内容进行了加密，只要拿CA发给客户的那个证书对接一些就知道对面网站的那个证书是不是真的。这就是SSL的基本逻辑。同时通信的过程也是加密了的，这样就不太容易被窃听的人看明白（即中间人攻击）。所以SSL等于解决了两个问题：流量劫持中间人攻击。
python socket ssl编程
Nicholas的专栏
09-22 4389
http://blog.csdn.net/hongqun/article/details/6833412 首先，使用如下命令生成证书和key: openssl req -new -x509 -days 365 -nodes -out cert.pem -keyout key.pem 接下来实现服务器： [python] view plain copy
python3 在线加密_Python3+ssl实现加密通信
weixin_39759890的博客
11-28 433
一、说明1. python标准库ssl可实现加密通信2. ssl库底层使用openssl，做了面向对像化改造和简化，但还是可以明显看出openssl的痕迹3. 本文先给出python实现的socket通信，在此基础上再给出ssl通信以便读者更方便地看到socket和ssl在python编程中的区别4. 说到ssl很多人都会想到https，但本质而言ssl是在传输层和应用层之间新插入的一个层，根据不...
SSL自签署证书生成脚本
00's Blog
11-09 1619
view plainprint? #!/bin/sh   #      # ssl 证书输出的根目录。   sslOutputRoot="/etc/apache_ssl"   if [ $# -eq 1 ]; then       sslOutputRoot=$1   fi   if [ ! -d ${sslOutputRoot} ]; then       mkd
c语言 tls单向认证 验证证书,使用wireshark观察SSL/TLS握手过程--双向认证/单向认证...
weixin_29187895的博客
05-24 1143
SSL/TLS握手过程可以分成两种类型：1)SSL/TLS 双向认证，就是双方都会互相认证，也就是两者之间将会交换证书。2)SSL/TLS 单向认证，客户端会认证服务器端身份，而服务器端不会去对客户端身份进行验证。我们知道，握手过程实际上就是通信双方协商交换一个用于对称加密的密钥的过程，而且握手过程是明文的。这个过程实际上产生三个随机数:client random, server random, ...
Python SSL
12-22
Python SSL
TLS/SSL Socket 实现
05-25
NULL 博文链接：https://sariel.iteye.com/blog/469035
ssl python
01-21
SSL——安全套接字层（Secure Sockers Layer）协议由著名的Netscape公司开发。为了保证通信双方建立安全可靠的传输隧道，SSL使用PKI中的数字证书技术对通信双方进行身份认证；使用对称加密来保证数据保密性；使用消息认证码（MAC）来保证数据完整性
python ssl_Python网络编程中的TLS/SSL。
weixin_39616477的博客
11-29 1466
传输层安全协议（TLS）算是如今互联网上应用最广泛的加密方法。TLS的前身是安全套接层（SSL），现代互联网的许多协议基础协议都是使用TLS来验证服务器身份，并保护传输过程中的数据。TLS能保护的信息包括：与请求URL之间的HTTPS链接以及以及返回内容、密码或cookie等可能在套接字双向传递的认证信息。下面的信息无法使用TLS保护：本机与远程主机都是可见的，地址信息在每个数据包的IP头信息中以...
python之ssl socket客户端代码示例
我不是萧海哇的博客
05-27 110
【代码】python之ssl socket客户端代码示例。
python3 socket ssl_Python中的SSLSocket密码/密码
weixin_39790102的博客
12-08 366
I've been looking into making an iOS push notification service for one of my apps lately. It has a Python 2.7 backend so I wanted to do it in Python rather than PHP (or anything else).I've got code th...
python之tcp ssl编程（亲测可用）
我不是萧海哇的博客
05-19 238
【代码】python之tcp ssl编程（亲测可用）
SSL 认证 python
tortelee的博客
10-20 181
https://www.cnblogs.com/liuhaidon/p/11752734.html
python tls client端socket代码
04-22
实现TLS客户端的Python代码如下： ```python import socket import ssl # 客户端证书和私钥文件路径 CERTFILE = '/path/to/client/cert.pem' KEYFILE = '/path/to/client/key.pem' # 服务器地址和端口号 HOSTNAME = 'example.com' PORT = 443 # 创建 TCP socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 连接远程服务器 sock.connect((HOSTNAME, PORT)) # 对 socket 进行 SSL 包装 context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile='/path/to/ca/cert.pem') context.load_cert_chain(certfile=CERTFILE, keyfile=KEYFILE) ssl_sock = context.wrap_socket(sock, server_hostname=HOSTNAME) # 向服务器发送请求 ssl_sock.sendall(b'GET / HTTP/1.0\r\nHost: example.com\r\n\r\n') # 从服务器接收响应 data = b'' while True: chunk = ssl_sock.recv(1024) if not chunk: break data += chunk print(data) # 关闭 SSL socket ssl_sock.close() ``` 请注意，这个示例代码假设您已经拥有证书和私钥文件。此外，还需要替换HOSTNAME，PORT和CA证书文件的路径，以适应您的实际情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

海哥python

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值