写在前面
很多时候我们碰到的问题看似很困难，甚至觉得无从下手，但当我们真的尝试去做的时候，就会发现其实世上无难事，只怕有心人。
前段时间学习给安排了一次课程设计，但我一直忙着做其他事情，这两天终于闲了一些，有空来敲敲代码了，我的内心是快(ju)乐(jue)的。看到了小灰灰早早的敲完然后还开源到了CSDN，那我也就来凑个热闹，第一篇博客就如此吧。今天早上终于把七篇都完成了，也算是顺带复习了Python的基础语法，面向对象和网络编程，好了那么话不多说，进入今天的主题吧。
题目一：暴力破解密码
要求：
1、设计一个信息系统，该系统可为学籍管理系统、订餐系统、票务管理系统不限， 系统必须通过客户端录入账号口令远程登录；
2、系统内至少包含三个以上账号，密码为 6 位以上数字组成；
3、设计程序在该系统所在服务器端进行暴力密码破解，破解后将账号密码通过套接字发送 出去；
4、在客户端用破解得到的账号口令进行登录，验证破解成功
# 服务端server
import socketserver
import socket
import json
# 服务器用户信息数据库
user_db = {'xiaohuihui':'666666','jige':'888888','cxp':'777777'}
print('等待主机连接......')
# 定义TargetServer类，允许tcp的并发连接，也就是多个客户端同时访问
class TargetServer(socketserver.BaseRequestHandler):
# 定义父类的句柄方法
def handle(self):
# 以下代码实现自定义的逻辑
print('IP为{}的客户端已连接，端口为{}'.format(self.client_address[0],self.client_address[1]))
server_info = ('''
-------- 欢迎来到112信息管理系统 --------
''')
# 发送上述消息
self.request.send(server_info.encode())
while True:
# 接收用户名和密码并打印
client_res = self.Server_Recv()
self.Client_Info(client_res)
# 执行验证程序，向客户端发送登录结果
if self.Login(client_res) == 'pass':
self.request.send('pass'.encode())
# 验证通过，则可以与服务端进行socket通信
self.Talk()
break
# 用户名或密码错误则断开连接
else:
self.request.send('fall'.encode())
print('账户密码不匹配，已断开连接！')
# 客户端断开连接
print('等待新主机连接中......')
# 服务器接收用户名和密码的方法
def Server_Recv(self):
user_info = self.request.recv(1460)
str_user_info = user_info.decode()
# 将字典序列化成字符串并返回
return json.loads(str_user_info)
# 服务端内打印用户名和密码的方法
def Client_Info(self,client_res):
print('客户端登陆成功：')
for i in client_res:
print(i + ':' + client_res[i])
# 登录验证的方法
def Login(self,client_res):
for j in user_db:
if (j == client_res['username']) and (user_db[j] == client_res['password']):
return 'pass'
# 客户端与服务端通信函数方法
def Talk(self):
while True:
# 接收客户端的消息
clinet_message = self.request.recv(1460)
if clinet_message == (b'q'):
print('已与客户端断开连接！')
return
# 客户端若未发送消息直接断开连接，则服务端终止停止通信
if len(clinet_message) == 0:
print('客户端已经断开！')
return
print(clinet_message.decode())
# 服务端发消息
server_message = input('----->')
self.request.send(server_message.encode())
if server_message == 'q':
print('已与客户端断开连接！')
return
# 实例化socketserver对象server_socket
server_socket = socketserver.ThreadingTCPServer(('127.0.0.1',10310),TargetServer)
# 循环调用，实现并发
server_socket.serve_forever()
# 爆破端burst
import socket
import json
import time
import os
# 实例化套接字对象
burst_socket = socket.socket()
print('----------->等待连接target......')
# 与服务器建立连接
burst_socket.connect(('127.0.0.1', 10310))
print(burst_socket.recv(1460).decode())
print('----------->已连接上target！')
user = input('请输入要burst的用户：').strip()
start_pwd = input('请选择burst的开始值：').strip()
end_pwd = input('请选择burst的结束值：').strip()
flag = True
while flag:
pwd = start_pwd
while True:
# 将用户名和密码构成字典
burst_dict = {'username':user,'password':pwd}
# # 发送前先将用户信息字典序列化为字符串
str_burst_dict = json.dumps(burst_dict)
burst_socket.send(str_burst_dict.encode())
res = burst_socket.recv(1460).decode()
print('正在burst用户:' + burst_dict['username'] + ' 尝试密码:' + burst_dict['password'])
if res == 'pass':
print('-----------burst成功！' + '目标密码为:' + burst_dict['password'] + '-----------')
burst_socket.close()
print('已经与服务器断开连接')
# 改变flag并退出循环
flag = False
break
else:
print('burst失败...' + '尝试密码为:' + burst_dict['password'])
# 到达设定边界，爆破失败！
if pwd == end_pwd:
burst_socket.close()
break
pwd = int(pwd) + 1
pwd = str(pwd)
# 如果爆破成功，跳出循环
if flag == False:
break
# 否则终止程序！
else:
print('-----------burst失败！请重新运行本程序选择其他范围！-----------')
os._exit(0)
# 实例化套接字对象，向client发送burst后的密码
burst_server_socket = socket.socket()
burst_server_socket.bind(('127.0.0.1',10140))
# 设置端口重用
burst_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
burst_server_socket.listen()
print('--------等待getpwd--------')
# 等待客户端上线
conn,addr = burst_server_socket.accept()
print(addr[0] + '主机以上线')
# 发送被爆破成功的用户名
conn.send(burst_dict['username'].encode())
print('用户名已发送！')
# 防止tcp的黏包，设置缓冲时间
time.sleep(0.5)
# 发送被爆破成功的密码
conn.send(burst_dict['password'].encode())
print('密码已发送！')
# 四次挥手
conn.close()
# 关闭套接字
burst_server_socket.close()
# 客户端client
import socket
import json
# 实例化套接字对象
get_pwd = socket.socket()
# 与burst服务器建立连接
get_pwd.connect(('127.0.0.1',10140))
print('等待burst发送password......')
# 接收burst程序发来的账号和密码
username = get_pwd.recv(1460).decode()
password = get_pwd.recv(1460).decode()
print('用户名:' + username + '密码:' + password)
# 关闭与burst服务器的连接
get_pwd.close()
# 实例化socket对象
client_socket = socket.socket()
# 与服务器建立连接
client_socket.connect(('127.0.0.1',10310))
# 客户端登录函数
def SingIn():
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
# 将用户名和密码构成字典
user_dict = {'username' : username, 'password' : password}
# 发送前先将用户信息字典序列化为字符串
str_user_dict = json.dumps(user_dict)
client_socket.send(str_user_dict.encode())
# 客户端与服务端通信函数
def Talk():
while True:
client_message = input('----->')
client_socket.send(client_message.encode())
if client_message == 'q':
print('已与服务端断开连接！')
return
server_message = client_socket.recv(1460)
if server_message == b'q':
client_socket.close()
print('已与服务端断开连接！')
return
print(server_message.decode())
# 先打印客户端发送的信息
print(client_socket.recv(1460).decode())
while True:
# 执行登录函数
SingIn()
# 查看登录的结果
res = client_socket.recv(1460).decode()
if res == 'pass':
print('登陆成功！')
Talk()
break
else:
print('账号或密码错误！请重新输入！')
# 关闭套接字
client_socket.close()
演示：
题目二：字典破解密码
要求：
1、设计一个信息系统，该系统可为学籍管理系统、订餐系统、票务管理系统不限， 系统必须通过客户端录入账号口令远程登录；
2、系统内至少包含三个以上账号，密码为 6 位以上任意字符组成；
3、设计程序设计程序在该系统所在服务器端进行字典密码破解，破解后将账号密码通过套 接字发送出去；
# 服务端server
import socketserver
import socket
import json
# 服务器用户信息数据库
user_db = {'xiaohuihui':'666666','jige':'888888','xiaopengpeng':'777777'}
print('等待主机连接......')
# 定义TargetServer类，允许tcp的并发连接
class TargetServer(socketserver.BaseRequestHandler):
# 定义父类的句柄方法
def handle(self):
# 实现自定义的逻辑
print('IP为{}的客户端已连接，端口为{}'.format(self.client_address[0],self.client_address[1]))
server_info = ('''
-------- 欢迎来到112信息管理系统 --------
''')
# 发送上述消息
self.request.send(server_info.encode())
while True:
# 接收用户名和密码并打印
client_res = self.Server_Recv()
self.Client_Info(client_res)
# 执行验证程序，向客户端发送登录结果
if self.Login(client_res) == 'pass':
self.request.send('pass'.encode())
# 验证通过，可以与服务端进行socket通信
self.Talk()
break
# 用户名或密码错误则断开连接
else:
self.request.send('fall'.encode())
print('账户密码不匹配，已断开连接！')
print('等待新主机连接中......')
# 服务器接收用户名和密码的函数
def Server_Recv(self):
user_info = self.request.recv(1460)
str_user_info = user_info.decode()
return json.loads(str_user_info)
# 服务端内打印用户名和密码的函数
def Client_Info(self,client_res):
print('客户端登陆成功：')
for i in client_res:
print(i + ':' +client_res[i])
# 登录验证的函数
def Login(self,client_res):
for j in user_db:
if (j == client_res['username']) and (user_db[j] == client_res['password']):
return 'pass'
# 客户端与服务端通信函数
def Talk(self):
while True:
# 接收客户端的消息
clinet_message = self.request.recv(1460)
if clinet_message == (b'q'):
print('已与客户端断开连接！')
return
# 客户端若未发送消息直接断开连接，则服务端终止停止通信
if len(clinet_message) == 0:
print('客户端已经断开！')
return
print(clinet_message.decode())
# 服务端发消息
server_message = input('----->')
self.request.send(server_message.encode())
if server_message == 'q':
print('已与客户端断开连接！')
return
# 实例化socketserver对象server_socket
server_socket = socketserver.ThreadingTCPServer(('127.0.0.1',10310),TargetServer)
# 循环调用
server_socket.serve_forever()
# 字典爆破端dict_pwd
import socket
import json
import time
import os
# 实例化套接字对象
burst_socket = socket.socket()
print('----------->等待连接target......')
burst_socket.connect(('127.0.0.1', 10310))
print(burst_socket.recv(1460).decode())
print('----------->已连接上target！')
file_path = input('请输入使用的dict路径：')
username = input('请输入目标用户名：')
list_pwd = []
with open(file_path, mode="r", encoding="utf-8") as fp:
# 先读文件，把密码存到res里
res = fp.readline().strip()
while res:
# 将res字符串追加到列表中
list_pwd.append(res)
res = fp.readline().strip()
# 大循环：判断字典的可用性
flag = True
while flag:
# 遍历列表
for i in list_pwd:
# 将用户名和遍历列表后的结果组成字典序列化后发往服务端
dict_pwd = {'username':username,'password':i}
str_dict_pwd = json.dumps(dict_pwd)
burst_socket.send(str_dict_pwd.encode())
res = burst_socket.recv(1460).decode()
print('正在burst用户:' + dict_pwd['username'] + ' 尝试密码:' + dict_pwd['password'])
print()
if res == 'pass':
print('爆破成功！' + dict_pwd['username'] + dict_pwd['password'])
burst_socket.close()
flag = False
break
else:
print('burst失败...' + '尝试密码为:' + dict_pwd['password'])
# 如果字典可用，跳出循环
if flag == False:
break
# 否则终止程序！
else:
print('未能使用此字典进行破解，请重新选择字典！')
burst_socket.close()
os._exit(0)
# 向client发送burst后的密码
burst_server_socket = socket.socket()
burst_server_socket.bind(('127.0.0.1',10140))
# 设置端口重用
burst_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
burst_server_socket.listen()
print('--------等待getpwd--------')
conn,addr = burst_server_socket.accept()
print(addr[0] + '主机以上线')
conn.send(dict_pwd['username'].encode())
print('用户名已发送！')
time.sleep(0.5)
# 防止tcp的黏包，设置缓冲时间
conn.send(dict_pwd['password'].encode())
print('密码已发送！')
conn.close()
burst_server_socket.close()
# 客户端client
import socket
import json
get_pwd = socket.socket()
get_pwd.connect(('127.0.0.1',10140))
print('等待burst发送password......')
username = get_pwd.recv(1460).decode()
password = get_pwd.recv(1460).decode()
print('用户名:' + username + '密码:' + password)
get_pwd.close()
# 实例化socket对象
client_socket = socket.socket()
# 与服务器建立连接
client_socket.connect(('127.0.0.1',10310))
# 客户端登录函数
def SingIn():
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
# 将用户名和密码构成字典并发送到服务端
user_dict = {'username' : username, 'password' : password}
# 发送前先将用户信息字典序列化为字符串
str_user_dict = json.dumps(user_dict)
client_socket.send(str_user_dict.encode())
# 客户端与服务端通信函数
def Talk():
while True:
client_message = input('----->')
client_socket.send(client_message.encode())
if client_message == 'q':
print('已与服务端断开连接！')
return
server_message = client_socket.recv(1460)
if server_message == b'q':
client_socket.close()
print('已与服务端断开连接！')
return
print(server_message.decode())
# 先打印客户端发送的信息
print(client_socket.recv(1460).decode())
while True:
# 执行登录函数
SingIn()
# 查看登录的结果
res = client_socket.recv(1460).decode()
if res == 'pass':
print('登陆成功！')
Talk()
break
else:
print('账号或密码错误！请重新输入！')
client_socket.close()
演示：
tip：由于是字典破解，所以需要自定义一个字典文件，里面存入事先定义好的密码字符串。
题目三：认证审计系统
1、 设计一个信息系统，系统必须通过客户端录入账号口令远程登录；
2、 系统内至少包含三个以上账号；
3、 某账号登录后服务器端可实时显示该账号登录的时间及 IP 信息；
4、 服务器端可查询账号的历史登录信息。
# 服务端server
import socketserver
import socket
import json
import time
# 服务器用户信息数据库
user_db = {'xiaohuihui':'666666','jige':'888888','xiaopengpeng':'777777'}
print('等待主机连接......')
# 定义TargetServer类，允许tcp的并发连接
class TargetServer(socketserver.BaseRequestHandler):
# 定义父类的句柄方法
def handle(self):
# 实现自定义的逻辑
print('IP为{}的客户端已连接，端口为{}'.format(self.client_address[0],self.client_address[1]))
server_info = ('''
-------- 欢迎来到112信息管理系统 --------
''')
# 发送上述消息
self.request.send(server_info.encode())
while True:
# 接收用户名和密码并打印
client_res = self.Server_Recv()
self.Client_Info(client_res)
# 执行验证程序，向客户端发送登录结果
if self.Login(client_res) == 'pass':
self.request.send('pass'.encode())
# 验证通过，打印当前时间
print(time.ctime())
# 将成功登录的用户信息写入日志文件
with open(r'F:\代码\课程设计\3、认证审计系统\login_log.txt',mode='a+',encoding='utf-8') as fp:
fp.write('登录IP:' + self.client_address[0] + ' 登录端口：' + str(self.client_address[1]) +
' 登录时间：' + time.ctime() + ' 用户名：' + client_res['username'] + '\n')
# 验证通过，可以与服务端进行socket通信
self.Talk()
break
# 用户名或密码错误则断开连接
else:
self.request.send('fall'.encode())
print('账户密码不匹配，已断开连接！')
print('等待新主机连接中......')
# 服务器接收用户名和密码的函数
def Server_Recv(self):
user_info = self.request.recv(1460)
str_user_info = user_info.decode()
return json.loads(str_user_info)
# 服务端内打印用户名和密码的函数
def Client_Info(self,client_res):
print('客户端登陆成功：')
for i in client_res:
print(i + ':' +client_res[i])
# 登录验证的函数
def Login(self,client_res):
for j in user_db:
if (j == client_res['username']) and (user_db[j] == client_res['password']):
return 'pass'
# 客户端与服务端通信函数
def Talk(self):
while True:
# 接收客户端的消息
clinet_message = self.request.recv(1460)
if clinet_message == (b'q'):
print('已与客户端断开连接！')
return
# 客户端若未发送消息直接断开连接，则服务端终止停止通信
if len(clinet_message) == 0:
print('客户端已经断开！')
return
print(clinet_message.decode())
# 服务端发消息
server_message = input('----->')
self.request.send(server_message.encode())
if server_message == 'q':
print('已与客户端断开连接！')
return
# 实例化socketserver对象server_socket
server_socket = socketserver.ThreadingTCPServer(('127.0.0.1',10310),TargetServer)
# 循环调用
server_socket.serve_forever()
# 客户端client
import socket
import json
# 实例化socket对象
client_socket = socket.socket()
# 与服务器建立连接
client_socket.connect(('127.0.0.1',10310))
# 客户端登录函数
def SingIn():
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
# 将用户名和密码构成字典并发送到服务端
user_dict = {'username' : username, 'password' : password}
# 发送前先将用户信息字典序列化为字符串
str_user_dict = json.dumps(user_dict)
client_socket.send(str_user_dict.encode())
# 客户端与服务端通信函数
def Talk():
while True:
client_message = input('----->')
client_socket.send(client_message.encode())
if client_message == 'q':
print('已与服务端断开连接！')
return
server_message = client_socket.recv(1460)
if server_message == b'q':
client_socket.close()
print('已与服务端断开连接！')
return
print(server_message.decode())
# 先打印客户端发送的信息
print(client_socket.recv(1460).decode())
while True:
# 执行登录函数
SingIn()
# 查看登录的结果
res = client_socket.recv(1460).decode()
if res == 'pass':
print('登陆成功！')
Talk()
break
else:
print('账号或密码错误！请重新输入！')
client_socket.close()
演示：
tip：操作文件函数时，注意要将path写为绝对路径，写相对路径偶尔会出问题。
题目四：数据嗅探系统
1、 设计一个信息系统，系统必须通过客户端录入账号口令远程登录；
2、 登录后客户端可通过键盘输入向服务器发送数据；
3、 服务器端设置嗅探关键字，如果客户端发送的数据包含该关键字，即将该数据显示出来。
#
import socketserver
import socket
import json
# 服务器用户信息数据库
user_db = {'xiaohuihui':'666666','jige':'888888','xiaopengpeng':'777777'}
print('等待主机连接......')
# 定义TargetServer类，允许tcp的并发连接
class TargetServer(socketserver.BaseRequestHandler):
# 定义父类的句柄方法
def handle(self):
# 实现自定义的逻辑
print('IP为{}的客户端已连接，端口为{}'.format(self.client_address[0],self.client_address[1]))
server_info = ('''
-------- 欢迎来到112信息管理系统 --------
''')
# 发送上述消息
self.request.send(server_info.encode())
while True:
# 接收用户名和密码并打印
client_res = self.Server_Recv()
# 执行验证程序，向客户端发送登录结果
if self.Login(client_res) == 'pass':
self.request.send('pass'.encode())
print('客户端已成功登录！')
# 验证通过，可以与服务端进行socket通信
self.Talk()
break
# 用户名或密码错误则断开连接
else:
self.request.send('fall'.encode())
print('账户密码不匹配，已断开连接！')
print('等待新主机连接中......')
# 服务器接收用户名和密码的函数
def Server_Recv(self):
user_info = self.request.recv(1460)
str_user_info = user_info.decode()
return json.loads(str_user_info)
# 登录验证的函数
def Login(self,client_res):
for j in user_db:
if (j == client_res['username']) and (user_db[j] == client_res['password']):
return 'pass'
# 客户端与服务端通信函数
def Talk(self):
while True:
# 接收客户端的消息
clinet_message = self.request.recv(1460)
if clinet_message == (b'q'):
print('已与客户端断开连接！')
return
# 客户端若未发送消息直接断开连接，则服务端终止停止通信
if len(clinet_message) == 0:
print('客户端已经断开！')
return
# 对客户端发送的敏感关键词进行捕获并打印
if "密码" in clinet_message.decode():
print('成功捕获嗅探到关键词：密码！')
print(clinet_message.decode())
# 实例化socketserver对象server_socket
server_socket = socketserver.ThreadingTCPServer(('127.0.0.1',10310),TargetServer)
# 循环调用
server_socket.serve_forever()
# client 客户端
import socket
import json
# 实例化socket对象
client_socket = socket.socket()
# 与服务器建立连接
client_socket.connect(('127.0.0.1',10310))
# 客户端登录函数
def SingIn():
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
# 将用户名和密码构成字典并发送到服务端
user_dict = {'username' : username, 'password' : password}
# 发送前先将用户信息字典序列化为字符串
str_user_dict = json.dumps(user_dict)
client_socket.send(str_user_dict.encode())
# 客户端与服务端通信函数
def Talk():
while True:
client_message = input('----->')
client_socket.send(client_message.encode())
if client_message == 'q':
print('已与服务端断开连接！')
return
# 先打印客户端发送的信息
print(client_socket.recv(1460).decode())
while True:
# 执行登录函数
SingIn()
# 查看登录的结果
res = client_socket.recv(1460).decode()
if res == 'pass':
print('登陆成功！')
Talk()
break
else:
print('账号或密码错误！请重新输入！')
client_socket.close()
演示：
题目五：防火墙系统
1、 设计一个信息系统，系统必须通过客户端录入账号口令远程登录；
2、 系统内至少包含三个以上账号；
3、 系统服务器端可设定禁止登录的 IP 地址和账号信息；
4、 如果客户端从禁止的 IP 地址登录或使用禁止的账号登录则显示不允许登录，并断开连接。
# 服务端server
import socketserver
import socket
import json
# 服务器用户信息数据库
user_db = {'xiaohuihui':'666666','jige':'888888','xiaopengpeng':'777777'}
print('等待主机连接......')
# 定义TargetServer类，允许tcp的并发连接
class TargetServer(socketserver.BaseRequestHandler):
# 定义父类的句柄方法
def handle(self):
# 实现自定义的逻辑
print('IP为{}的客户端已连接，端口为{}'.format(self.client_address[0],self.client_address[1]))
server_info = ('''
-------- 欢迎来到112信息管理系统 --------
''')
# 发送上述消息
self.request.send(server_info.encode())
while True:
# 接收用户名和密码并打印
client_res = self.Server_Recv()
self.Client_Info(client_res)
# 执行验证程序，向客户端发送登录结果
if self.Login(client_res) == 'pass':
self.request.send('pass'.encode())
# 验证通过，可以与服务端进行socket通信
self.Talk()
break
# 如果用户符合防火墙策略，那么返回404
elif self.Login(client_res) == '404':
self.request.send('404'.encode())
print('客户端IP或登录用户名为防火墙黑名单！')
# 用户名或密码错误则断开连接
else:
self.request.send('fall'.encode())
print('账户密码不匹配，已断开连接！')
print('等待新主机连接中......')
# 服务器接收用户名和密码的函数
def Server_Recv(self):
user_info = self.request.recv(1460)
str_user_info = user_info.decode()
return json.loads(str_user_info)
# 服务端内打印用户名和密码的函数
def Client_Info(self,client_res):
print('客户端登陆成功：')
for i in client_res:
print(i + ':' +client_res[i])
# 登录验证的函数
def Login(self,client_res):
# 设定被拒绝的ACL字典
deny_user = {'IP': '127.0.0.1', 'user': 'xiaohuihui'}
# 满足ACL，则返回错误代码，拒绝登录！
if (self.client_address[0] == deny_user['IP']) and (client_res['username'] == deny_user['user']):
return '404'
for j in user_db:
if (j == client_res['username']) and (user_db[j] == client_res['password']):
return 'pass'
# 客户端与服务端通信函数
def Talk(self):
while True:
# 接收客户端的消息
clinet_message = self.request.recv(1460)
if clinet_message == (b'q'):
print('已与客户端断开连接！')
return
# 客户端若未发送消息直接断开连接，则服务端终止停止通信
if len(clinet_message) == 0:
print('客户端已经断开！')
return
print(clinet_message.decode())
# 服务端发消息
server_message = input('----->')
self.request.send(server_message.encode())
if server_message == 'q':
print('已与客户端断开连接！')
return
# 实例化socketserver对象server_socket
server_socket = socketserver.ThreadingTCPServer(('127.0.0.1',10310),TargetServer)
# 循环调用
server_socket.serve_forever()
# 客户端client
import socket
import json
# 实例化socket对象
client_socket = socket.socket()
# 与服务器建立连接
client_socket.connect(('127.0.0.1',10310))
# 客户端登录函数
def SingIn():
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
# 将用户名和密码构成字典并发送到服务端
user_dict = {'username' : username, 'password' : password}
# 发送前先将用户信息字典序列化为字符串
str_user_dict = json.dumps(user_dict)
client_socket.send(str_user_dict.encode())
# 客户端与服务端通信函数
def Talk():
while True:
client_message = input('----->')
client_socket.send(client_message.encode())
if client_message == 'q':
print('已与服务端断开连接！')
return
server_message = client_socket.recv(1460)
if server_message == b'q':
client_socket.close()
print('已与服务端断开连接！')
return
print(server_message.decode())
# 先打印客户端发送的信息
print(client_socket.recv(1460).decode())
while True:
# 执行登录函数
SingIn()
# 查看登录的结果
res = client_socket.recv(1460).decode()
if res == 'pass':
print('登陆成功！')
Talk()
break
# 如果客户端接收到错误代码，那么重新执行循环，即重新登录
if res == '404':
print('服务器拒绝您的连接！')
print('请重新选择账户或者IP登录！')
continue
else:
print('账号或密码错误！请重新输入！')
client_socket.close()
演示：
题目六：加密传输系统
1、 设计客户端程序向服务器端发送数据；
2、 客户端从键盘输入的数据在发送之前进行加密，加密方法可选择仿射、移位密码；
3、 服务器端接收到数据后进行显示，然后在解密后再次显示。
# 服务端server
import socketserver
import socket
import json
# 服务器用户信息数据库
user_db = {'xiaohuihui':'666666','jige':'888888','xiaopengpeng':'777777'}
print('等待主机连接......')
# 定义TargetServer类，允许tcp的并发连接
class TargetServer(socketserver.BaseRequestHandler):
# 定义父类的句柄方法
def handle(self):
# 实现自定义的逻辑
print('IP为{}的客户端已连接，端口为{}'.format(self.client_address[0],self.client_address[1]))
server_info = ('''
-------- 欢迎来到112信息管理系统 --------
''')
# 发送上述消息
self.request.send(server_info.encode())
while True:
# 接收用户名和密码并打印
client_res = self.Server_Recv()
self.Client_Info(client_res)
# 执行验证程序，向客户端发送登录结果
if self.Login(client_res) == 'pass':
self.request.send('pass'.encode())
# 验证通过，可以与服务端进行socket通信
self.Talk()
break
# 用户名或密码错误则断开连接
else:
self.request.send('fall'.encode())
print('账户密码不匹配，已断开连接！')
print('等待新主机连接中......')
# 服务器接收用户名和密码的函数
def Server_Recv(self):
user_info = self.request.recv(1460)
str_user_info = user_info.decode()
return json.loads(str_user_info)
# 服务端内打印用户名和密码的函数
def Client_Info(self,client_res):
print('客户端登陆成功：')
# 解密过程
print('username' + ':' + client_res['username'][-1::-1])
print('password' + ':' + client_res['password'][:-4])
# 登录验证的函数
def Login(self,client_res):
for j in user_db:
# 比对经过加密后的数据进行身份验证
if (j[-1::-1] == client_res['username']) and (user_db[j] + '1014' == client_res['password']):
return 'pass'
# 客户端与服务端通信函数
def Talk(self):
while True:
# 接收客户端的消息
clinet_message = self.request.recv(1460)
if clinet_message == (b'q'):
print('已与客户端断开连接！')
return
if len(clinet_message) == 0:
print('客户端已经断开！')
return
# 反转打印客户端发来的消息
print(clinet_message.decode()[-1::-1])
# 将输入的信息反转后发送
server_message = input('----->')[-1::-1]
self.request.send(server_message.encode())
if server_message == 'q':
print('已与客户端断开连接！')
return
# 实例化socketserver对象server_socket
server_socket = socketserver.ThreadingTCPServer(('127.0.0.1',10310),TargetServer)
# 循环调用
server_socket.serve_forever()
# 客户端client
import socket
import json
# 实例化socket对象
client_socket = socket.socket()
# 与服务器建立连接
client_socket.connect(('127.0.0.1',10310))
# 客户端登录函数
def SingIn():
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
# 将用户名和密码构成字典并发送到服务端
user_dict = {'username' : username, 'password' : password}
# 将客户端输入的用户名反转，密码加1014然后发送
user_dict['username'] = username[-1::-1]
user_dict['password'] = password + '1014'
# 发送前先将用户信息字典序列化为字符串
str_user_dict = json.dumps(user_dict)
client_socket.send(str_user_dict.encode())
# 客户端与服务端通信函数
def Talk():
while True:
# 将输入的信息反转后发送
client_message = input('----->')[-1::-1]
client_socket.send(client_message.encode())
if client_message == 'pass':
print('已与服务端断开连接！')
return
server_message = client_socket.recv(1460)
if server_message == b'q':
client_socket.close()
print('已与服务端断开连接！')
return
# 反转打印服务端发来的消息
print(server_message.decode()[-1::-1])
# 先打印客户端发送的信息
print(client_socket.recv(1460).decode())
while True:
# 执行登录函数
SingIn()
# 查看登录的结果
res = client_socket.recv(1460).decode()
if res == 'pass':
print('登陆成功！')
Talk()
break
else:
print('账号或密码错误！请重新输入！')
client_socket.close()
演示：
题目七：图形验证模拟
要求：
1、开发一个手机锁屏的图形验证程序，以字符命令行形式来实现要求完成的功能有如下：
2、 登录时输入用户名；
3、 输入 4*4 坐标下的图形点位置，用字符方式输入；
4、 输入完成后实现在服务器端对图形进行验证；
5、 至少有三个以上的用户验证。
# 服务端server
import socket
import time
# 服务器用户信息数据库
user_db = {'xiaohuihui':'12342234','jige':'11223344','cxp':'44444444'}
# 将数据库字典的键取出来，构成一个可迭代对象
user_key = user_db.keys()
user_list = []
# 将字典的键迭代存入用户名列表
for i in user_key:
user_list.append(i)
# 实例化socket对象
server_socket = socket.socket()
# 设置端口重用
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(('127.0.0.1',10310))
server_socket.listen()
conn,addr = server_socket.accept()
print('已成功连接客户端！')
# 接收用户名
user = conn.recv(1460).decode()
# 设定验证结果为空
res = ''
flag = True
while True:
# 如果验证结果为字符串pass，则直接退出循环
if res == 'pass':
print('客户端验证通过！')
break
else:
# 接收密码
pwd = conn.recv(1460).decode()
# 比对数据库信息
for i in user_list:
if (user == i) and (pwd == user_db[i]):
res = 'pass'
conn.send(res.encode())
break
else:
conn.send('fall'.encode())
print('客户端验证失败！')
# 标记flag为False
flag = False
break
# 如果flag等于False，那么重新开始循环，等待接收用户的输入
if flag == False:
continue
# 四次挥手
conn.close()
# 关闭套接字
server_socket.close()
# 客户端client
import socket
import time
# 实例化socket对象
client_server = socket.socket()
client_server.connect_ex(('127.0.0.1',10310))
print('已成功连接服务端！')
# 初始化图形字符串
init_str = '0000000000000000'
# 强转为列表，便于操作
init_list = list(init_str)
# 设定密码初值为空字符串，用于拼接输入的密码
password = ''
user = input('请输入用户名：')
client_server.send(user.encode())
time.sleep(0.5)
print('请输入验证图形')
# 打印初始化的图形
for i in range(16):
print(init_list[i] + '\t', end='')
if i % 4 == 3:
print()
while True:
print('''
请选择输入密码还是直接输入verify验证：
tip:使用逗号分隔开密码
''')
auth = input()
# 如果输入verify，则将密码发送至服务端进行验证
if auth == 'verify':
client_server.send(password.encode())
res = client_server.recv(1460).decode()
# 如果通过，则退出循环
if res == 'pass':
print('验证成功！')
break
# 如果不通过，初始化图形，并重新进入循环等待用户输入
else:
password = ''
init_str = '0000000000000000'
init_list = list(init_str)
print('账号或密码错误，请重新登录！')
continue
# 如果输入密码
else:
# 将输入的逗号去除掉，返回一个元素为字符串的列表
pwd_section = auth.split(',')
# 将列表中的字符串元素拼接为一个完整的字符串，赋值给password
password += ''.join(pwd_section)
# num_1为行数算法
num_1 = (int(pwd_section[0]) - 1) * 4
# num_2为列数算法
num_2 = int(pwd_section[1]) + num_1
# 将输入的点坐标改为x
init_list[num_2 - 1] = 'x'
# 打印输出修改后的图形
for i in range(16):
print(init_list[i] + '\t', end='')
if i % 4 == 3:
print()
client_server.close()
演示：
写在最后
第一次尝试写博客，希望自己以后能爱上这里，多和大家分享学习心得。另外，以上代码各位在用来学习或者用来填写实验报告时，可以加入自己的逻辑并修改和完善它，尽管我完善代码的时间远大于写出实现要求代码的时间，但我知道这里面还是有很多瑕疵和值得改进的地方，对代码哪里有疑问，或者有建议的朋友，欢迎讨论区见。
3040
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
