近来天天看论文看的头疼,想着敲敲代码缓解下,顺便练练python,于是写了下面这个程序
主要功能:1.多C端与S端多线程通信
2.C端之间互相通信(通过S端转发)
3.对C端通信加入了敏感词过滤(DFA算法(中文敏感词过滤)+贝叶斯(英文敏感词过滤))
计划加入功能:1.RSA加密算法
2.在服务器端假设防火墙,可以对数据包做操作(libnids那一套)
3.加入群聊功能
4.图形界面
C端代码
import threading,time
import socket
import random
from Fillter import DFA#过滤言语模块
from Fillter import fillter_machine
sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.connect(('127.0.0.1',8082))
ip=input("请输入要连接的IP:")
port=input("请输入要使用的端口:")
string=ip+','+port
sock.send(string.encode('utf-8'))
def send(sock):
while 1:
string=input()
if DFA.judge(root,string)==1 or fillter_machine.run(string)==1:
string='***'
string=string.encode('utf-8')
print('请文明用语!')
else:
string=string.encode('utf-8')
sock.send(string)
def recv(sock):
while 1:
msg=sock.recv(1024)
if msg:
print(msg.decode())
#申请线程
def Create_Thread_Recv(sock):
t1=threading.Thread(target=recv,args=(sock,))
t1.start()
def Create_Thread_Send(sock):
t1 =threading.Thread(target=send,args=(sock,))
t1.start()
return t1
if __name__=='__main__':
root=DFA.init()
Create_Thread_Recv(sock)
Create_Thread_Send(sock)
另一个C端测试代码
import socket
import threading
import multiprocessing,time
import os,sys
def Create():
host = 'localhost'
port = 8083
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑本地
server.bind((host, port))
server.listen(10)
return server
def recv(sock):
while 1:
msg=sock.recv(1024)
print(msg.decode())
def send(sock):
while 1:
sock.send(input().encode('utf-8'))
def Create_Thread_Recv_S2B(sock_B):
t1=threading.Thread(target=recv,args=(sock_B,))
t1.start()
def Create_Thread_Send_S2B(sock_B):
t1 =threading.Thread(target=send,args=(sock_B,))
t1.start()
if __name__=='__main__':
server=Create()
client, address = server.accept()
print(address)
Create_Thread_Recv_S2B(client)
Create_Thread_Send_S2B(client)
S端代码
import socket
import threading
import multiprocessing,time
import os,sys
from scapy.all import *
#创建本地socket
def Create():
host = ''
port = 8082
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑本地
server.bind((host, port))
server.listen(10)
return server
#用来存请求的ip和port
class Client():
def __init__(self,ip,port):
self.ip=ip
self.port=port
#去请求要连接的客户端
def Get_Connection(a,client):
sock_con = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_con.connect((a.ip,int(a.port)))
client.send('连接成功'.encode('utf-8'))
return sock_con
def send(sock_B,sock_A,string):
while 1:
msg=sock_A.recv(1024)
if msg:
sock_B.send(msg)
print('A-->B:'+msg.decode())
else:
print('No message')
time.sleep(2)
def recv(sock_B,sock_A,string_accept):
while 1:
msg=sock_B.recv(1024)
time.sleep(1)
string_accept=msg.decode()
print('B-->A:'+msg.decode())
sock_A.send(string_accept.encode('utf-8'))
#申请线程S->C
def Create_Thread_Recv_S2B(sock_B,sock_A,string_accept):
t1=threading.Thread(target=recv,args=(sock_B,sock_A,string_accept))
t1.start()
def Create_Thread_Send_S2B(sock_B,sock_A,string_send):
t1 =threading.Thread(target=send,args=(sock_B,sock_A,string_send))
t1.start()
#拦截查包处理
def pcap(ip,port):
pack=sniff(count=0)
print(pack)
def Create_Thread_pcapcheck(ip,port):
t1=threading.Thread(target=pcap,args=(ip,port))
t1.start()
if __name__=='__main__':
global string_accept
global string_send
string_accept='accept'
string_send=''
server=Create()
client,address=server.accept()
#先接收对方要连接的IP和端口
msg=client.recv(1024).decode().split(',')
a=Client(msg[0],msg[1])
print(a.ip,a.port)
client.send("收到IP和端口,请等待连接...".encode('utf-8'))
s_c = Get_Connection(a,client)
#创建拦截线程
Create_Thread_pcapcheck(a.ip,a.port)
#创建接收和发送线程
Create_Thread_Recv_S2B(client,s_c,string_accept)
Create_Thread_Send_S2B(client,s_c,string_send)
DFA模块代码
import jieba
class Node():
def __init__(self):
self.children=None
self.badword=None
def Add(root,word):
node=root
for i in range(len(word)):
if node.children==None:
node.children={}
node.children[word[i]]=Node()
elif word[i] not in node.children:
node.children[word[i]] = Node()
node=node.children[word[i]]
node.badword=word
def init():
node=Node()
path='/Users/macbook/Desktop/Python/SOCKET/Fillter/处理后的中文词库/其他词库.txt'
f=open(path,'r')
for i in f.readlines():
Add(node,i.split('\n')[0])
return node
def Search(root,word):
for i in range(len(word)):
p=root
j=i
while(j<len(word) and p.children!=None and word[j] in p.children):
p=p.children[word[j]]
j+=1
if p.badword==word[i:j]:
return 1
return 0
def judge(root,string):
s = jieba.cut(string, cut_all=False)
s='/'.join(s)
t=s.split('/')
for i in range(len(t)):
if Search(root,t[i])==1:
return 1
else:
continue
return 0
if __name__=='__main__':
root=init()
print(judge(root,'第一夫人'))
贝叶斯代码
from numpy import *
import sys,os
import jieba
mark=[',','.','/','`','!','@','~','#','$','%','^','&','*','(',')','-','_','=','+','|','|',';',':','"','\'','.','/','?']
#拆分语句
def Detach_sentence(data):
l=[]
list=[]
s=jieba.cut(data,cut_all=False)
string='/'.join(s)
l=string.split('/')
for i in range(0,l.__len__()):
if l[i] not in mark:
list.append(l[i])
return list
def loadDataSet_Chinese():
path='/Users/macbook/Desktop/Python/SOCKET/Fillter/中文词库/test.txt'
f=open(path,'r')
postingList = []
classVed = []
for i in f.readlines():
t = []
classVed.append(1)
postingList.append(i.split('\n')[0])
print(postingList)
return postingList, classVed
#词条字典构建
def createVocaList_Chinese(dataSet):
vocabSet=set([])#set会自动滤掉重复的数据
for document in dataSet:
#'|'操作可以获取两个列表的并集
vocabSet=vocabSet|set(dataSet)
return list(vocabSet)
def loadDataSet_English():
path='/Users/macbook/Desktop/Python/SOCKET/Fillter/英文敏感词库.txt'
f=open(path,'r')
postingList=[]
classVed=[]
for i in f.readlines():
tmp=i.split(';')[0]
t=[]
classVed.append(int((i.split(';')[1]).split('\n')[0]))
t=tmp.split(' ')
postingList.append(t)
return postingList,classVed
#词条字典构建
def createVocaList_English(dataSet):
vocabSet=set([])#set会自动滤掉重复的数据
for document in dataSet:
#'|'操作可以获取两个列表的并集
vocabSet=vocabSet|set(document)
return list(vocabSet)
#词条向量构建:传入词条字典和待测试的对应文本词条集合,得到词条向量
def setofWord2Vec(vocabList,inputSet):
#初始化词条向量全为'0'
returnVec=[0]*len(vocabList)
for word in inputSet:
if word in vocabList:
#如果词条集合中词条出现在字典库中,则标记对应位置的元素为'1'
returnVec[vocabList.index(word)]=1
else:
#print("%s 不在字典中"%word)
continue
return returnVec
#trainMatrix:多个词条向量组成的集合矩阵
#trainCategory:分类标签集合
def trainNBO(trainMatrix,trainCategory):
#记录词条向量个数
numTrainDocs=len(trainMatrix)
#单个词条向量的长度
numWords=len(trainMatrix[0])
#计算所有词条中,侮辱性的概率
pAbusive=sum(trainCategory)/float(numTrainDocs)
# 初始化 侮辱性/非侮辱性 言论中 词条分布总和向量
# 引入numpy后,zeros(numWords)方法用来得到一个和numWords等长的0矩阵
p0Num = zeros(numWords)
p1Num = zeros(numWords)
#初始化 侮辱性/非侮辱性 言论中 词条总个数
p0Denom=1.0
p1Denom=1.0
for i in range(numTrainDocs):
if trainCategory[i] == 1:
# 如果为侮辱性言论,记录所有侮辱性词条向量累加之后的总向量
p1Num += trainMatrix[i]
# 记录所有侮辱性言论中,总的词条个数
p1Denom += sum(trainMatrix[i])
else:
# 如果为非侮辱性言论,记录所有非侮辱性词条向量累加之后的总向量
p0Num += trainMatrix[i]
# 记录所有非侮辱性言论中,总的词条个数
p0Denom += sum(trainMatrix[i])
# 计算出一个标示每个词可能是侮辱性词汇概率的向量
p1Vect = p1Num / p1Denom
# 计算出一个标示每个词可能是非侮辱性词汇概率的向量
p0Vect = p0Num / p0Denom
return p0Vect, p1Vect, pAbusive
# vec2Classify:待测试数据的词条向量
# pClass1:所有词条向量中是侮辱性词条向量的概率
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
# sum(vec2Classify * p1Vec)当前词条向量中,每个词条可能是侮辱性词条的概率之积p(w:c1)
# pClass1 : p(c1)
p1 = sum(vec2Classify * p1Vec) + log(pClass1)
p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
if p1 > p0:
return 1
else:
return 0
def init(inputstring):
#加载中文词库
'''postingList, classVec = loadDataSet_Chinese()
vocabList = createVocaList_Chinese(postingList)'''
#加载英文词库
trainMat = []
postingList, classVec = loadDataSet_English()
vocabList = createVocaList_English(postingList)
for posting in postingList:
word2Vec = setofWord2Vec(vocabList, posting)
trainMat.append(word2Vec)
p0V, p1V, pAb = trainNBO(trainMat, classVec)
teststring=inputstring
thisDoc = array(setofWord2Vec(vocabList, teststring))
return classifyNB(thisDoc,p0V, p1V, pAb)
def run(inputstring):
while 1:
return init(Detach_sentence(inputstring))
if __name__=='__main__':
while 1:
data=input()
print(run(data))
敏感词库是从网上扒的,这里就不给链接了