Python_Day35_Socket模块3和hmac模块详解编程语言

例1:简单的服务端如下 
#!/usr/bin/env python 
# _*_ coding: utf-8 _*_ 
import os 
import socket 
import hmac 
secret_key = '老衲洗头用飘柔'.encode('utf-8') 
server = socket.socket() 
server.bind(('127.0.0.1', 9527)) 
server.listen() 
while True: 
try: 
conn, addr = server.accept() 
random_bytes = os.urandom(32) 
conn.send(random_bytes) 
hmac_obj = hmac.new(key=secret_key, msg=random_bytes) 
ret = hmac_obj.hexdigest() 
print(hmac_obj.hexdigest()) 
msg = conn.recv(1024).decode('utf-8') 
if msg == ret: 
print('是合法的客户端') 
else: 
print('不是合法的客户端') 
conn.close() 
finally: 
server.close() 
break 
客户端如下： 
#!/usr/bin/env python 
# _*_ coding: utf-8 _*_ 
import socket 
import hmac 
secret_key = '老衲洗头用飘柔'.encode('utf-8') 
client = socket.socket() 
client.connect(('127.0.0.1', 9527)) 
urandom = client.recv(1024) 
hmac_obj = hmac.new(key=secret_key, msg=urandom) 
client.send(hmac_obj.hexdigest().encode('utf-8')) 
print('--------') 
client.close() 
效果如下： 
33e40f5f66b2e9b2867a7862d02fba9d 
是合法的客户端。 
例2:TCP时间戳服务器验证 
#!/usr/bin/env python 
# _*_ coding: utf-8 _*_ 
import os 
import hmac 
from socket import * 
from time import ctime 
''' 
socket tcp时间戳服务端，利用hmac模块加盐验证客户端连接的合法性 
''' 
# 加盐 
secret_key = '芝麻开门'.encode('utf-8') 
def conn_auth(conn): 
''' 
    认证客户端链接 
    :param conn: 客户端链接 
    :return: True or False 
    ''' 
print('开始验证新链接的合法性') 
# os模块生成随机32位字符串，用于发送给客户端验证 
ustr = os.urandom(32) 
conn.sendall(ustr) 
# 生成密钥 hmac加盐+32位随机字符串 
cipher = hmac.new(secret_key, ustr).digest() 
#　接收客户端发送过来的密钥，长度和这边生成的应当一致 
result = conn.recv(len(cipher)) 
# compare 两相比较，一致返回true，否则为false 
return hmac.compare_digest(result, cipher) 
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 
data = '[%s] %s' % (ctime(), data.decode('utf-8')) 
conn.sendall(data.encode('utf-8')) 
conn.close() 
def server_handler(host,port,bufsize=1024,num=5): 
''' 
    socket tcp服务端设置 
    :param host: 主机名或ip地址 
    :param port: 端口号 
    :param bufsize: 缓冲区大小，默认1024 
    :param num: 侦听最大客户端，默认5位 
    :return:  
    ''' 
tcpss = socket(AF_INET, SOCK_STREAM) 
tcpss.bind((host,port)) 
tcpss.listen(num) 
while True: 
conn, addr = tcpss.accept() 
print('新连接[%s:%s]' % (addr[0], addr[1])) 
data_handler(conn,bufsize) 
if __name__ == '__main__': 
host = 'localhost' 
port = 9527 
server_handler(host, port) 
TCP时间戳客户端： 
#!/usr/bin/env python 
# _*_ coding: utf-8 _*_ 
''' 
socket tcp时间戳客户端，利用hmac模块加盐验证客户端连接的合法性 
''' 
import os 
import hmac 
from socket import * 
secret_key = '芝麻开门'.encode('utf-8') 
def conn_auth(conn): 
''' 
    验证客户端到服务器的链接 
    :param conn: 链接 
    :return: True or False 
    ''' 
# 客户端接收32位随机字节 
ustr = conn.recv(32) 
# hmac加盐加密文得出最终密钥并发送回服务端 
cipher = hmac.new(secret_key, ustr).digest() 
conn.sendall(cipher) 
def client_handler(host,port,bufsize=1024): 
tcpsc = socket(AF_INET, SOCK_STREAM) 
tcpsc.connect((host, port)) 
conn_auth(tcpsc) 
while True: 
data = input('>>>').strip() 
if not data:continue 
if data == 'quit':break 
tcpsc.sendall(data.encode('utf-8')) 
result = tcpsc.recv(bufsize) 
print(result.decode('utf-8')) 
tcpsc.close() 
if __name__ == '__main__': 
host = 'localhost' 
port = 9527 
bufsize = 1024 
client_handler(host, port, bufsize) 
效果： 
服务端： 
D:/PortableSoft/Python35/python.exe E:/Python/重要的代码/socket_hmac验证合法连接/tcpss.py 
新连接[127.0.0.1:57600] 
开始验证新链接的合法性 
链接已通过验证，开始通信 
客户端： 
D:/PortableSoft/Python35/python.exe E:/Python/重要的代码/socket_hmac验证合法连接/tcpsc.py 
>>>time 
[Thu May 10 22:00:19 2018] time 
>>>也许猪的身体不优美，长鼻短尾，但是别人不可天空里高飞 
[Thu May 10 22:01:10 2018] 也许猪的身体不优美，长鼻短尾，但是别人不可天空里高飞 
>>>

#!/usr/bin/env python 
# _*_ coding: utf-8 _*_ 
''' 
通过使用socketserver类、TCPServer和StreamRequesthandler，该脚本创建了一个时间戳TCP服务器。 
''' 
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH) 
from time import ctime 
HOST = '127.0.0.1' 
PORT = 9527 
ADDR = (HOST, PORT) 
class MyRequestHandler(SRH): 
# 重写handle方法，该方法在基类Request中默认情况下没有任何行为（pass） 
# 但当接收到一个客户端的消息时，它就会调用handle()方法，因此得重写进行处理。 
def handle(self): 
print('...connected from:', self.client_address) 
# StreamRequsetHandler将输入和输出套接字看作类似文件的对象 
# 因此可以使用readline()获取客户端消息，当然此时客户端要约定消息附带/n换行符 
data = '[%s] %s' % (ctime(), self.rfile.readline().decode('utf-8')) 
# 同理，视作文件对象，使用write（）将字符串发送回客户端 
self.wfile.write(data.encode('utf-8')) 
tcpServ = TCP(ADDR, MyRequestHandler) 
print('waiting for connection...') 
# 注：是serve，而不是server；forever为无限循环地等待并服务于客户端请求。 
tcpServ.serve_forever() 
创建SocketServer TCP客户端 
#!/usr/bin/env python 
# _*_ coding: utf-8 _*_ 
from socket  import * 
HOST = 'localhost' 
PORT = 9527 
BUFSIZ = 1024 
ADDR = (HOST, PORT) 
while True: 
''' 
    和之前socker普通的tcp客户端从输入才开始循环不同， 
    sockerserver请求处理程序的默认行为是接受连接、获取请求，然后关闭连接。 
    由于这个原因,我们不能在应用程序整个执行过程中都保持连接，因此每次向服务器发送消息时， 
    都需要创建一个新的套接字。 
    ''' 
tcpCliSock = socket(AF_INET, SOCK_STREAM) 
tcpCliSock.connect(ADDR) 
data = input('>>>') 
if not data: 
break 
''' 
    这里使用的处理程序对待套接字通信就像是文件一样，所以必須发送行终止符（回车和换行符）。 
    而服务器只是保留并重用这里发送的终止符。 
    ''' 
data = '%s/r/n' % data 
tcpCliSock.send(data.encode('utf-8')) 
resu = tcpCliSock.recv(BUFSIZ) 
if not resu: 
break 
# 加strip()处理掉换行符 
print(resu.decode('utf-8').strip()) 
tcpCliSock.close() 
运行服务端和客户端后效果如下： 
client端： 
>>>百变星君 
[Wed May  9 20:44:11 2018] 百变星君 
>>>大圣娶亲 
[Wed May  9 20:44:22 2018] 大圣娶亲 
>>> 
server端： 
---------------------------------------- 
Exception happened during processing of request from ('127.0.0.1', 53286) 
---------------------------------------- 
...connected from: ('127.0.0.1', 53397) 
...connected from: ('127.0.0.1', 53398) 
...connected from: ('127.0.0.1', 53399) 
另一种不看成文件操作的支持并发连接的TCP时间戳服务器和客户端如下： 
socketserver TCP时间戳服务器 
#!/usr/bin/env python 
# _*_ coding: utf-8 _*_ 
import socketserver 
from time import ctime 
# 并发编程 
class MyServer(socketserver.BaseRequestHandler): 
def handle(self): 
print('...连接来自：', self.client_address) 
msg = self.request.recv(1024) 
msg = '[%s] %s' % (ctime(), msg.decode('utf-8')) 
print(msg) 
self.request.send(msg.encode('utf-8')) 
if __name__ == '__main__': 
# 支持重用端口和Ip 
socketserver.TCPServer.allow_reuse_address = True 
# ThreadingTCPServer 支持线程功能 
server = socketserver.ThreadingTCPServer(('127.0.0.1', 9527), MyServer) 
print('等待连接...') 
server.serve_forever() 
socketserver TCP时间戳客户端 
#!/usr/bin/env python 
# _*_ coding: utf-8 _*_ 
import socket 
while True: 
client = socket.socket() 
client.connect(('127.0.0.1', 9527)) 
data = input('>>>') 
if not data: 
break 
client.send(data.encode('utf-8')) 
resu = client.recv(1024) 
if not resu: 
break 
print(resu.decode('utf-8')) 
client.close() 
运行效果如下： 
第一个client端： 
>>>哆啦A梦 
[Wed May  9 20:59:14 2018] 哆啦A梦 
>>>蜡笔小新 
[Wed May  9 20:59:27 2018] 蜡笔小新 
>>>超人迪加 
[Wed May  9 21:00:13 2018] 超人迪加 
>>> 
第二个client端： 
>>>银河唯一的秘密 
[Wed May  9 20:59:50 2018] 银河唯一的秘密 
>>>护卫人类，挽救地球，看守这宇宙 
[Wed May  9 21:00:35 2018] 护卫人类，挽救地球，看守这宇宙 
>>> 
socketserver服务端： 
等待连接... 
...连接来自： ('127.0.0.1', 53505) 
[Wed May  9 20:59:14 2018] 哆啦A梦 
...连接来自： ('127.0.0.1', 53506) 
[Wed May  9 20:59:27 2018] 蜡笔小新 
...连接来自： ('127.0.0.1', 53507) 
...连接来自： ('127.0.0.1', 53508) 
[Wed May  9 20:59:50 2018] 银河唯一的秘密 
...连接来自： ('127.0.0.1', 53509) 
[Wed May  9 21:00:13 2018] 超人迪加 
...连接来自： ('127.0.0.1', 53510) 
[Wed May  9 21:00:35 2018] 护卫人类，挽救地球，看守这宇宙 
...连接来自： ('127.0.0.1', 53514)