Python基础29_验证用户链接的合法性, socketserver模块实现并发

 一. 验证用户链接的合法性
    1. 服务端:
    from socket import *
    import hmac,os
    secret_key=b'Jedan has a big key!'
    def conn_auth(conn):
        '''
        认证客户端链接
        :param conn:
        :return:
        '''
        print('开始验证新链接的合法性')
        msg=os.urandom(32)#生成一个32字节的随机字符串
        conn.sendall(msg)
        h=hmac.new(secret_key,msg) 
        digest=h.digest()
        respone=conn.recv(len(digest))
        return hmac.compare_digest(respone,digest)
    def data_handler(conn,bufsize=1024):
        if not conn_auth(conn):
            print('该链接不合法,关闭')
            conn.close()
            return
        print('链接合法,开始通信')
        while True:
            data=conn.recv(bufsize)
            if not data:break
            conn.sendall(data.upper())
    def server_handler(ip_port,bufsize,backlog=5):
        '''
        只处理链接
        :param ip_port:
        :return:
        '''
        tcp_socket_server=socket(AF_INET,SOCK_STREAM)
        tcp_socket_server.bind(ip_port)
        tcp_socket_server.listen(backlog)
        while True:
            conn,addr=tcp_socket_server.accept()
            print('新连接[%s:%s]' %(addr[0],addr[1]))
            data_handler(conn,bufsize)
    if __name__ == '__main__':
        ip_port=('127.0.0.1',9999)
        bufsize=1024
        server_handler(ip_port,bufsize)
    2. 客户端:
    from socket import *
    import hmac,os
    secret_key=b'Jedan has a big key！'
    def conn_auth(conn):
        '''
        验证客户端到服务器的链接
        :param conn:
        :return:
        '''
        msg=conn.recv(32)
        h=hmac.new(secret_key,msg)
        digest=h.digest()
        conn.sendall(digest)
    def client_handler(ip_port,bufsize=1024):
        tcp_socket_client=socket(AF_INET,SOCK_STREAM)
        tcp_socket_client.connect(ip_port)
    
        conn_auth(tcp_socket_client)
    
        while True:
            data=input('>>: ').strip()
            if not data:continue
            if data == 'quit':break
    
            tcp_socket_client.sendall(data.encode('utf-8'))
            respone=tcp_socket_client.recv(bufsize)
            print(respone.decode('utf-8'))
        tcp_socket_client.close()
    if __name__ == '__main__':
        ip_port=('127.0.0.1',9999)
        bufsize=1024
        client_handler(ip_port,bufsize)

    3. 介绍代码中使用的两个方法：
　　(1)、 os.urandom(n): 是一种bytes类型的随机生成n个字节字符串的方法，而且每次生成的值都不相同。再加上md5等加密的处理，就能够成内容不同长度相同的字符串了。
    os.urandom(n)函数在python官方文档中做出了这样的解释
    函数定位： Return a string of n random bytes suitable for cryptographic use. 
    意思就是，返回一个有n个byte那么长的一个string，然后很适合用于加密。
    然后这个函数，在文档中，被归结于os这个库的Miscellaneous Functions，意思是不同种类的函数（也可以说是混种函数） 
    原因是： This function returns random bytes from an OS-specific randomness source. （函数返回的随机字节是根据不同的操作系统特定的随机函数资源。即，这个函数是调用OS内部自带的随机函数的。有特异性）
    使用方法：
    import os
    from hashlib import md5
    for i in range(10):
        print md5(os.urandom(24)).hexdigest()
    (2)、 hmac： Python自带的hmac模块实现了标准的Hmac算法，我们首先需要准备待计算的原始消息message，随机key，哈希算法，这里采用MD5，使用hmac的代码如下：
    import hmac
    message = b'Hello world'
    key = b'secret'
    h = hmac.new(key,message,digestmod='MD5')
    print(h.hexdigest())
    比较两个密文是否相同，可以用hmac.compare_digest(密文、密文)，然会True或者False。
    可见使用hmac和普通hash算法非常类似。hmac输出的长度和原始哈希算法的长度一致。需要注意传入的key和message都是bytes类型，str类型需要首先编码为bytes。
    def hmac_md5(key, s):
        return hmac.new(key.encode('utf-8'), s.encode('utf-8'), 'MD5').hexdigest()
    class User(object):
        def __init__(self, username, password):
            self.username = username
            self.key = ''.join([chr(random.randint(48, 122)) for i in range(20)])
            self.password = hmac_md5(self.key, password)
二. socketserver模块实现并发
    我们之前写的tcp协议的socket是不是一次只能和一个客户端通信，如果用socketserver可以实现和多个客户端通信。它是在socket的基础上进行了一层封装，也就是说底层还是调用的socket
    import socketserver                              #1、引入模块
    class MyServer(socketserver.BaseRequestHandler): #2、自己写一个类，类名自己随便定义，然后继承socketserver这个模块里面的BaseRequestHandler这个类
        def handle(self):                            #3、写一个handle方法，必须叫这个名字
            #self.request                            #6、self.request 相当于一个conn
            self.request.recv(1024)                  #7、收消息
            msg = '亲，学会了吗'
            self.request.send(bytes(msg,encoding='utf-8')) #8、发消息
            self.request.close()                     #9、关闭连接
            # 拿到了我们对每个客户端的管道，那么我们自己在这个方法里面的就写我们接收消息发送消息的逻辑就可以了
            pass
    if __name__ == '__mian__':
        #thread 线程，现在只需要简单理解线程，别着急，后面很快就会讲到啦，看下面的图
        server = socketserver.ThreadingTCPServer(('127.0.0.1',8090),MyServer)    #4、使用socketserver的ThreadingTCPServer这个类，将IP和端口的元祖传进去，还需要将上面咱们自己定义的类传进去，得到一个对象，相当于我们通过它进行了bind、listen
        server.serve_forever()   #5、使用我们上面这个类的对象来执行serve_forever()方法，他的作用就是说，我的服务一直开启着, 并且serve_forever()帮我们进行了accept
    一个完整的sockeserver代码示例：
　　1.服务端代码示例：
    import socketserver
    class Myserver(socketserver.BaseRequestHandler):
        def handle(self):
            self.data = self.request.recv(1024).strip()
            print("{} wrote:".format(self.client_address[0]))
            print(self.data)
            self.request.sendall(self.data.upper())
    if __name__ == "__main__":
        HOST, PORT = "127.0.0.1", 9999
        # 设置allow_reuse_address允许服务器重用地址
        socketserver.TCPServer.allow_reuse_address = True
        # 创建一个server, 将服务地址绑定到127.0.0.1:9999
        #server = socketserver.TCPServer((HOST, PORT),Myserver)
        server = socketserver.ThreadingTCPServer((HOST, PORT),Myserver)
        # 让server永远运行下去，除非强制停止程序
        server.serve_forever()
    2. 客户端代码示例：
    import socket
    HOST, PORT = "127.0.0.1", 9999
    data = "hello"
    # 创建一个socket链接，SOCK_STREAM代表使用TCP协议
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        sock.connect((HOST, PORT))          # 链接到客户端
        sock.sendall(bytes(data + "\n", "utf-8")) # 向服务端发送数据
        received = str(sock.recv(1024), "utf-8")# 从服务端接收数据
    print("Sent:     {}".format(data))
    print("Received: {}".format(received))