网络编程ssh,粘包

1.什么是socket?

TCP,可靠地,面向连接协议,有阻塞rect

udp,不可靠的,无线连接的服务 这里因为不需要阻塞,所以速度会很快,但安全性不高

2.关于客户端退出而服务器未退出的解决办法

 1 import socket
 2 sock=socket.socket() # TCP协议
 3 IP_PORT=("127.0.0.1",8899)
 4 sock.bind(IP_PORT)
 5 sock.listen(5)
 6 while 1:
 7     conn,addr=sock.accept()
 8     while 1:
 9         try:#这里是因为如果当客户端完成登陆后,由于客户端的退出,而
10             #服务端只是刚刚退出第一层循环,还在等着接收客户端传来的信息,所以
11             #会报错 只需要加一个异常处理,如果客户端离开则不会等待客户传来信息
12             #会处于待命状态,等待下一次传入
13             data=conn.recv(1024).decode("utf8")
14             print("接收信息:",data)
15             print("接收信息:",type(data))
16             print("-----",data.split("|"))
17             user,pwd=data.strip().split("|")
18             # 文件操作
19             flag=False
20             with open("account","r") as f:
21
22                 for line in f:
23                     print("===",line.strip().split(":"))
24                     username,password=line.strip().split(":")
25                     if username==user and password==pwd:
26                         flag=True
27                         break
28             if flag:
29                 conn.send(b"success")
30             else:
31                 conn.send(b"fail")
32         except Exception as e:
33             break

客户端

 1 import socket
 2
 3 sock=socket.socket() # TCP
 4 sock.connect(("127.0.0.1",8899))
 5
 6 while 1:
 7     user=input("用户名>>>>")
 8     pwd=input("密码>>>>")
 9     val=("%s|%s"%(user,pwd)).encode("utf8")
10     sock.send(val)
11     response=sock.recv(1024)
12     print(response.decode("utf8"))
13     if response.decode("utf8")=="success":
14         break
15     else:
16         print("用户名或者密码错误!")
17         continue

3.模拟ssh

 1 import struct
 2
 3 #打包
 4 res=struct.pack("i","")#这里可以放数字
 5
 6 print(res)#最终显示的是4个字节
 7 print(len(res))#始终四个字节.长度为4
 8
 9 obj=struct.unpack("i",res)#用于解包,最后显示元祖,后面一逗号结尾
10 print(obj[0])#获取解包后的数字
11 #struct模块主要用于当发生粘包时.由于向客户端/服务端发送两个
12 #字节时,计算机无法判断前后位置,所以又来区分因为打包后固定长度为4
13 #所以取前四段
14 b‘xxx/xxx/xxx/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb‘
15 #就可以区分了
16 #当然也可以用时间(睡眠)来区分
1 import subprocess#可以使cmd之间的程序在python中显示
2
3 res=subprocess.Popen("dir",#进行命令
4                      shell=True,
5                      stderr=subprocess.PIPE,#终端错误输出stderr
6                      stdout=subprocess.PIPE)# 终端输出stdout
7
8 print(res.stdout.read().decode("gbk"))##返回的字节所以用gbk
9 #可以实现将cmd中的命令显示在python
 1 import socket
 2 import subprocess
 3 server = socket.socket()
 4 server.bind((‘127.0.0.1‘,8008))
 5 server.listen(5)
 6 while True:
 7     print("server is working.....")
 8     conn,addr = server.accept()
 9     # 字节类型
10     while True:
11         # 针对window系统
12         try:
13             cmd = conn.recv(1024).decode("utf8") # 阻塞#客户端传入的命令需要解码显示成字符串的形式
14
15             if cmd == b‘exit‘:
16                 break
17             # res=subprocess.Popen(cmd,#subprocess模块
18             #                  shell=True,
19             #                  stderr=subprocess.PIPE,
20             #                  stdout=subprocess.PIPE,
21             #                  )
22             # print("stdout",res.stdout.read())
23             # print("stderr",res.stderr.read().decode("gbk"))
24             out=res.stdout.read()#终端输出 显示的是使用命令的正确
25             err=res.stderr.read()#终端错误 显示的是不是系统命令的报错提示
26
27             print("out响应长度",len(out))#知道长度才可以使他们逐一实现
28             print("err响应长度",len(err))
29             if err:
30                  import struct
31                  header_pack = struct.pack("i", len(err))#首先一定要给出长度,客户端才会跟据长度
32                  #来显示
33                  conn.send(header_pack)
34                  conn.send(err)
35             else:#没阻塞一次就发过去了
36                  #构建报头
37                  import struct#构建
38                  header_pack=struct.pack("i",len(out))#数字的长度压缩完成报头
39                  print("header_pack",header_pack)
40                  # # 发送报头#将报文连在一起发送
41                  conn.send(str(len(out)).encode("utf8"))#把数字转换成字符串,再转化成字节才可以发过去
42                  # 发送数据
43                  conn.send(out)#整体的数据
44
45         except Exception as e:
46             break
47     conn.close()

客户端

 1 sk.connect((‘127.0.0.1‘,8008))
 2
 3 while 1:
 4     cmd = input("请输入命令:")
 5     sk.send(cmd.encode(‘utf-8‘)) # 字节
 6     if cmd=="":
 7         continue
 8     if cmd == ‘exit‘:
 9         break
10
11     header_pack=sk.recv(4)#取前四个字节
12     data_length=struct.unpack("i",header_pack)[0]#解包
13     print("data_length",data_length)
14     ‘‘‘
15     b‘xxx/xxx/xxx/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb‘
16
17
18     ‘‘‘
19     data_length=int(sk.recv(1024).de- code("utf8"))
20     print("data_length",data_length)
21     recv_data_length=0#判断是否小于接收到的字节
22     recv_data=b""
23     while recv_data_length<data_length:
24         data=sk.recv(1024)
25         recv_data_length+=len(data)#接收多少就是这个
26         #实现的前提需要总长度,
27         recv_data+=data
28     print(recv_data.decode("gbk"))
29 sk.close()

3.关于粘包

粘包:发送长度和数据但是计算机不知道怎么去区分 两个send计算机不知道怎么区分
我们丢的东西没有丢
1.间隔短 2.文件不大3.
sleep 不让粘包

关于加密

 1 import hashlib
 2
 3 # md5=hashlib.md5()
 4 # md5.update(b"hello")#当分别输入hello 和 yaun时 结果与helloyuan
 5 #一样,但是这样的好处是可以分开存储节省内存,要是一次写入那么多
 6 #会疯的
 7 # md5.update(b"yuan")
 8 #
 9 # print(md5.hexdigest())
10 # print(len(md5.hexdigest()))
11
12 #helloyuan:   d843cc930aa76f7799bba1780f578439
13 #             d843cc930aa76f7799bba1780f578439
14
15 #############################################
16 md5=hashlib.md5()
17
18 with open("ssh_client.py","rb") as f:
19     for line in f:
20         md5.update(line)
21
22 print(md5.hexdigest()) # f.read() 16位字节

原文地址:https://www.cnblogs.com/zhangqing979797/p/9589590.html

时间: 2024-10-08 20:34:37

网络编程ssh,粘包的相关文章

网络编程中粘包的处理方法

写在前面的话:因为自己是才解除网络编程,在工作中第一次遇到粘包问题,我还不知道它是叫粘包问题,所以被整的晕头转向,百思不得其解,自己的代码到底哪里出了问题,最后只能单步调试程序才发现接收方接收到的数据并不一定是按自己设想那样,一次接收整个数据包,当时就想到用文件长度来判断是否接收完文件,之后读了UNP才知道是粘包问题.记录以下当时自己的处理方法. 面对网络编程中的发送文件时的粘包问题,我的处理方法是在要发送文件前,首先发送文件的长度,获取的文件长度是UlongLong类型的整数,发送 时需要转换

Learning-Python【29】:网络编程之粘包

粘包问题 上一篇博客遗留了一个问题,在接收的最大字节数设置为 1024 时,当接收的结果大于1024,再执行下一条命令时还是会返回上一条命令未执行完成的结果.这就是粘包问题. 因为TCP协议又叫流式协议,每次发送给客户端的数据实际上是发送到客户端所在操作系统的缓存上,客户端就是一个应用程序,需要通过操作系统才能调到缓存内的数据,而缓存的空间是一个队列,有 “先进先出” 的思想,当第一次的 tasklist 数据未接收完,第二次又来一个 dir 的数据时,只能等第一次先全部接收完成才会接收后面的.

网络编程基础粘包现象

粘包 tcp是流式传输,字节流,数据与数据之间是没有边界的 流式传输优点: 不限定长度 可靠传输 缺点: 慢 和一个人的通信连接conn会一直占用我们的通信资源 udp协议,面向数据包的传输 数据包优点 快 由于不需要建立连接,所以谁发的消息我都能接受到 缺点 不能传输过长的数据 不可靠 粘包现象 由于流式传输的特点,产生了数据连续发送的粘包现象. 在一个conn建立起来的连接上传输的多条数据是没有边界的 数据的发送和接收实际上不是在执行send/recv的时候就立刻被发送和接收,而是需要经过操

网络编程-之------粘包现象

一.什么是粘包 须知:只有TCP有粘包现象,UDP永远不会粘包 粘包不一定会发生 如果发生了:1.可能是在客户端已经粘了 2.客户端没有粘,可能是在服务端粘了 首先需要掌握一个socket收发消息的原理 应用程序所看到的数据是一个整体,或说是一个流(stream),一条消息有多少字节对应用程序是不可见的,因此TCP协议是面向流的协议,这也是容易出现粘包问题的原因.(因为TCP是流式协议,不知道啥时候开始,啥时候结束).而UDP是面向消息的协议,每个UDP段都是一条消息,应用程序必须以消息为单位提

网络编程 之粘包问题、使用socketserver实现并发

一.粘包问题 注意:粘包问题只有tcp协议并且udp协议永远不会粘包 粘包问题的产生: 简述:粘包问题的产生主要是由于tcp协议传输数据(其内置的nagle算法来进行的)会将数据较小的且发送时间较短的合并成一个包从发送端发送出去,接收端不知道该怎么去想要的数据拿出来这样造成了粘包问题,另一方面是由于时间太短接收端没有及时拿干净 传来的数据造成数据混乱(这是因为tcp协议又叫流氏协议指的是其就像水流一样传输数据)才产生的粘包问题. 1.发送端由于时间太短造成多个包合在一起发送产生粘包问题的实例如下

网络编程之粘包

粘包: 传输层协议有tcp和udp两种 tcp:Transmission Control Protocol 传输控制协议,基于数据流,收发的消息不能为空,需要在客户端和服务端都添加空消息的处理机制 tcp是可靠性协议,数据的收发都需要确认信息,这就降低了传输效率,故为了减少确认次数,tcp采用了nagle算法 将多次间隔短且数据小的数据合成一个数据流,然后发送,tcp的数据没有明确的界限,无法区分数据的开始和结束, 这就导致了可能将多个信息并为一条信息,也就是粘包 还有一种粘包情况是当一个数据包

解决网络编程的粘包问题

# 服务端 import socketimport subprocessimport structimport json servers = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)servers.bind(('127.0.0.1', 7777))servers.listen(10)print('start settings') while True:    """连接循环""

python/socket编程之粘包

python/socket编程之粘包 粘包: 只有TCP有尿包现象,UDP永远不会粘包. 首先需要掌握一个socket收发消息的原理 发送端可以是1k,1k的发送数据而接受端的应用程序可以2k,2k的提取数据,当然也有可能是3k或者多k提取数据,也就是说,应用程序是不可见的,因此TCP协议是面来那个流的协议,这也是容易出现粘包的原因而UDP是面向笑死的协议,每个UDP段都是一条消息,应用程序必须以消息为单位提取数据,不能一次提取任一字节的数据,这一点和TCP是很同的.怎样定义消息呢?认为对方一次

Socket编程--TCP粘包问题

TCP是个流协议,它存在粘包问题 产生粘包的原因是: TCP所传输的报文段有MSS的限制,如果套接字缓冲区的大小大于MSS,也会导致消息的分割发送. 由于链路层最大发送单元MTU,在IP层会进行数据的分片. 应用层调用write方法,将应用层的缓冲区中的数据拷贝到套接字的发送缓冲区.而发送缓冲区有一个SO_SNDBUF的限制,如果应用层的缓冲区数据大小大于套接字发送缓冲区的大小,则数据需要进行多次的发送. 粘包问题的解决 ①:发送定长包 这里需要封装两个函数: ssize_t readn(int