模拟ssh、黏包、hashlib模块

时间 2019-12-08

标签模拟 ssh hashlib 模块繁體版

原文原文链接

1、模拟sshpython

一、subprocess模块　　　　　　　　ipconfig -all　　dirlinux

　　subprocess模块是python从2.4版本开始引入的模块。主要用来取代一些旧的模块方法，如os.system、os.spawn*、os.popen*、commands.*等。subprocess模块可用于产生进程，并链接到进程的输入/输出/错误输出管道，并获取进程的返回值。算法

    import subprocess   　　　　　　　　　　#subprocess(色破儿赛斯)

    res = subprocess.Popen("dir",　　　　　　　　　　#popen(跑pen)
                            shell=True,　　　　　　　　#shell(烧奥)
                            stderr=subprocess.PIPE,　　　　std爱热儿 
                            stdout=subprocess.PIPE)　　　　std奥特
    # PIPE表示的是管道
    # stdin,stdout,stderr：分别表示程序的标准输入、标准输出、标准错误。
    print(res.stdout.read().decode("gbk"))        　　　　#read(蕊的)
    # 结果的编码是以当前所在的系统为准的，若是是windows，
    # 那么res.stdout.read()读出的就是GBK编码的，在接收端须要用GBK解码

二、写一个模拟ssh的简单程序，即实现客户端向服务端发送一条终端命令，服务端执行这条命令后将执行结果返回给客户端，以下示例：shell

    import socket
    import subprocess

    server = socket.socket()
    server.bind(('127.0.0.1',8008))
    server.listen(5)
    conn,addr = server.accept()
    while 1:
        data = conn.recv(1024).decode('utf8')

        res = subprocess.Popen(data,
                           shell = True,
                           stderr=subprocess.PIPE,
                           stdout=subprocess.PIPE
        )
        out_result = res.stdout.read()  # 发生错误后结果
        err_result = res.stderr.read()  # 命令正确的结果
        if out_result:
            conn.send(out_result)
            print('已发送给客户端','字节数是',len(out_result))
        elif err_result:
            conn.send(err_result)
            print('发生错误','字节数是',len(err_result))

服务端

    import socket

    client = socket.socket()
    client.connect(('127.0.0.1',8008))

    while 1:
        comm = input('请输入命令>>>').encode('utf8')
        client.send(comm)
        data = client.recv(1024)
        print(data.decode('gbk'))

客户端

　　分析：试运行上面示例，分析有没有问题？数据库

2、黏包windows

一、黏包现象：同时执行多条命令以后，获得的结果极可能只有一部分，在执行其余命令的时候又接收到以前执行的另一部分结果，这种现象就是黏包。上述模拟ssh示例中最后一个服务器端代码就可能会出现黏包现象，由于服务端代码中连续写了两个send（一个send长度，一个send数据内容），send不会发生阻塞，因此形成两个send会造成一个包发送过去，接收方没法分辨哪些数据是哪一个send发送的，也就没法获取到长度和内容。那么怎么解决黏包现象？缓存

二、黏包成因安全

　　a、TCP协议中的数据传递服务器

　　　　tcp协议的拆包机制：当发送端缓冲区的长度大于网卡的MTU时，tcp会将此次发送的数据拆成几个数据包发送出去。MTU（Maximum Transmission Unit）的意思是网络上传送的最大数据包。MTU的单位是字节。大部分网络设备的MTU都是1500，若是本机的MTU比网关的MTU大，大的数据包就会被拆开来传送，这样会产生不少数据包碎片，增长丢包率，下降网络速度。网络

　　　　面向流的通讯特色和Nagle算法：TCP（transport control protocol，传输控制协议）是面向链接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，所以，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将屡次间隔较小且数据量小的数据，合并成一个大的数据块，而后进行封包。这样，接收端就难于分辨出来了，必须提供科学的拆包机制。即面向流的通讯是无消息保护边界的。对于空消息：tcp是基于数据流的，因而收发的消息不能为空，这就须要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即使是你输入空内容（直接回车），也能够被发送，udp协议会帮你封装上消息头发送过去。可靠黏包的tcp协议：tcp的协议数据不会丢，没有收完包，下次接收时，会继续上次继续接收，一端老是在收到ack时才会清楚缓冲区内容。数据是可靠的，可是会黏包。

　　　　基于tcp协议特色的黏包现象成因：

：

    发送端能够是一K一K地发送数据，而接收端的应用程序能够两K两K地提走数据，固然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据。
也就是说，应用程序所看到的数据是一个总体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，所以TCP协议是面向流的协议，这也是容易出现粘包问题的缘由。
    而UDP是面向消息的协议，每一个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不一样的。
    怎样定义消息呢？能够认为对方一次性write/send的数据为一个消息，须要明白的是当对方send一条信息的时候，不管底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈如今内核缓冲区。

黏包现象成因

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看来，根本不知道该文件的字节流从何处开始，在何处结束；

　　　　此外，发送方引发的黏包是由TCP协议自己形成的，TCP为提升传输效率，发送方每每要收集到足够多的数据后才发送一个TCP段。若连续几回须要send的数据都不多，一般TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了黏包数据。

　　b、udp不会发生黏包

　　　　UDP（user datagram protocol，用户数据报协议）是无链接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 因为UDP支持的是一对多的模式，因此接收端的skbuff(套接字缓冲区）采用了链式结构来记录每个到达的UDP包，在每一个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来讲，就容易进行区分处理了。即面向消息的通讯是有消息保护边界的。

　　　　对于空消息：tcp是基于数据流的，因而收发的消息不能为空，这就须要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即使是你输入的是空内容（直接回车），也能够被发送，udp协议会帮你封装上消息头发送过去。

　　　　不可靠不黏包的udp协议：udp的recvfrom是阻塞的，一个recvfrom(x)必须对惟一一个sendinto(y),收完了x个字节的数据就算完成,如果y;x数据就丢失，这意味着udp根本不会粘包，可是会丢数据，不可靠。

总结：黏包现象只发生在tcp协议中：

　　1) 从表面上看，黏包问题主要是由于发送方和接收方的缓存机制、tcp协议面向流通讯的特色；

　　2) 实际上，主要仍是因接收方不知道消息之间的界限，不知道一次性提取多少字节的数据形成的；

三、struct模块

　　这个模块能够把要发送的数据长度转换成固定长度的bytes(字节)，以下示例：

    import struct

    res1 = struct.pack("i",23767)
    print(res1)  # b'\xd7\\\x00\x00'
    print(len(res1))  # 4       固定长度是4个字节
    obj1 = struct.unpack("i",res1)
    print(obj1 , obj1[0])  # (23767,) 23767

四、黏包的解决方案

　　咱们能够借助struct模块，这个模块能够把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息以前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就中止，就能恰好很少很多的接收完整的数据了。

发送时

接收时

先发送struct转换好的数据长度4字节

先接受4个字节使用struct转换成数字来获取要接收的数据长度

再发送数据

再按照长度接收数据

因此上述模拟ssh示例最终能够改成以下代码：

服务端

　　 import socket
    import subprocess
    import struct

    server = socket.socket()
    server.bind(('127.0.0.1',8008))
    server.listen(5)
    conn,addr = server.accept()
    while 1:
        data = conn.recv(1024).decode('utf8')

        res = subprocess.Popen(data,
                           shell = True,
                           stderr=subprocess.PIPE,
                           stdout=subprocess.PIPE
        )
        out_result = res.stdout.read()  
        err_result = res.stderr.read()  

        if out_result:
            conn.send(struct.pack('i',len(out_result))) # 构建报头
            conn.send(out_result)  # 发送报文
            print('已发送给客户端','字节数是',len(out_result))
        elif err_result:
            conn.send(struct.pack('i',len(err_result)))  # 构建报头
            conn.send(err_result)  # 发送报文
            print('发生错误','字节数是',len(err_result))

客户端

　　 import socket
    import struct

    client = socket.socket()
    client.connect(('127.0.0.1',8008))

    while 1:
        comm = input('请输入命令>>>').encode('utf8')
        client.send(comm)
        data_len = struct.unpack('i',client.recv(4))[0]
        data_all = b''
        while len(data_all) < data_len:
            data = client.recv(1024)
            data_all += data
        print(data_all.decode('gbk'))

　黏包subprocess模块　　　　　　模拟cmd

黏包现象一

import socket
import subprocess

server = socket.socket()
ip_port = ('192.168.15.65',8001)
server.bind(ip_port)

server.listen()

conn,addr = server.accept()

while 1:#循环
    zhiling = conn.recv(1024).decode('utf-8')         #来自客户端的指令

    sub_obj = subprocess.Popen(
            zhiling,                            #客户端的指令
            shell=True,
            stdout=subprocess.PIPE,             #正确的
            stderr=subprocess.PIPE              #错误的
    )
    sub_obj_dui = sub_obj.stdout.read()         #标准输出读

    sub_obj_len = str(len(sub_obj_dui))         #拿到全部的长度
    conn.send(sub_obj_len.encode('gbk'))        #吧长度编码GBK,发送给客户端,客户端在解码

    jie_ok = conn.recv(1024).decode('utf-8')    #接收客户端发来的消息,看看客户端是否有我将要发送数据的大小

    if jie_ok =='ok':       #看看是否==ok
        conn.send(sub_obj_dui)#等于就把数据发送到客户端
    else:
        continue

服务端,结合了subprocess模块

import socket
client = socket.socket()
server_ip_port = ('192.168.15.65',8001)
client.connect(server_ip_port)

while 1:
    shuru = input('请输入:')
    client.send(shuru.encode('utf-8'))          #发送系统指令请求

    daxiao = int(client.recv(1024).decode('gbk'))   #把系统发送过来的长度转换成gbk和int类型
    print('接收的大小是----->%s'%daxiao)     #查看接收的大小

    client.send('ok'.encode('utf-8'))           #发送一条指令,表示我有了你的文件大小,能够防止黏包

    s = client.recv(daxiao).decode('gbk')       #接收服务端发来的信息解码成gbk的
    print(s)

客户端

黏包现象二

import socket
import subprocess
import struct

server = socket.socket()
ip_port = ('192.168.15.62',8001)
server.bind(ip_port)
server.listen()
conn,addr = server.accept()
while 1:
    #来自客户端的指令
    print('等待接受信息。。。')
    from_client_cmd = conn.recv(1024).decode('utf-8')
    print(from_client_cmd)
    #经过subprocess模块执行服务端的系统指令,而且拿到指令执行结果
    sub_obj = subprocess.Popen(
        from_client_cmd, #客户端的指令
        shell=True,
        stdout=subprocess.PIPE, #标准输出:正确指令的执行结果在这里
        stderr=subprocess.PIPE, #标准错误输出:错误指令的执行结果在这里
    )
    #接受到的返回信息是bytes类型的，而且windows系统的默认编码为gbk
    server_cmd_msg = sub_obj.stdout.read()
    #首先计算出你将要发送的数据的长度
    cmd_msg_len = len(server_cmd_msg)
    #先对数据长度进行打包,打包成4个字节的数据,目的是为了和你将要发送的数据拼在一块儿,就好咱们自定制了一个消息头
    msg_len_stru = struct.pack('i',cmd_msg_len)
    conn.send(msg_len_stru) #首先发送打包成功后的那4个字节的数据
    conn.sendall(server_cmd_msg) #循环send数据,直到数据所有发送成功

服务端

import socket
import struct
client = socket.socket()
server_ip_port = ('192.168.15.62',8001)
client.connect(server_ip_port)
while 1:
    msg = input('请输入要执行的指令>>>')
    client.send(msg.encode('utf-8'))
    #先接收服务端要发送给个人信息的长度,前4个字节,固定的
    from_server_msglen = client.recv(4)
    unpack_len_msg = struct.unpack('i',from_server_msglen)[0]
    #接收数据长度统计,和服务端发给个人数据长度做比较,来肯定跳出循环的条件
    recv_msg_len = 0
    #统计拼接接收到的数据,注意:这个不是统计长度
    all_msg = b''
    while recv_msg_len < unpack_len_msg:
        every_recv_data = client.recv(1024)
        #将每次接收的数据进行拼接和统计
        all_msg += every_recv_data
        #对每次接收到的数据的长度进行累加
        recv_msg_len += len(every_recv_data)

    print(all_msg.decode('gbk'))

客户端

3、hashlib模块

一、算法介绍

　　python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。

什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它经过一个函数，把任意长度的数据转换为一个长度固定的数据串（一般用16进制的字符串表示）。

　　摘要算法就是经过只要函数f1()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。

　　摘要算法之因此能指出数据是否被篡改过，就是由于摘要函数是一个单向函数，计算(data)很容易，但经过digest反推data却很是困难，并且，对原始数据作一个bit的修改，都会致使计算出的摘要彻底不一样。

　　咱们以前学过一个简单用MD5加密的示例，以下：

import hashlib

    md5 = hashlib.md5()
    md5.update(b'how to use md5 in python hashlib?')
    print(md5.hexdigest())  # d26a53750bc40b38b65a520292f69306

　若是数据量很大，能够分屡次调用update()，最后计算的结果是同样的，以下示例：　

    import hashlib

    md5 = hashlib.md5()
    md5.update(b'how to use md5 in ')
    md5.update(b'python hashlib?')
    print(md5.hexdigest())  # d26a53750bc40b38b65a520292f69306

　MD5是最多见的摘要算法，速度很快，生成结果是固定的128bit字节，一般用一个32位的16进制字符串表示。另外一种常见的只要算法是SHA1，调用SHA1和调用MD5彻底相似，以下示例：　

    import hashlib

    sha1 = hashlib.sha1()
    sha1.update(b'how to use sha1 in ')
    sha1.update(b'python hashlib?')
    print(sha1.hexdigest())  #     2c76b57293ce30acef38d98f6046927161b46a44

　　SHA1的结果是160 bit字节，一般用一个40位的16进制字符串表示。比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法越慢，并且摘要长度更长。

二、算法应用

　　任何容许用户登陆的网站都会存储用户登陆的用户名和口令。如何存储用户名和口令呢？方法是存到数据库表中：

    name    | password
    --------+----------
    michael | 123456
    bob     | abc999
    alice   | alice2008

　　若是以明文保存用户口令，若是数据库泄露，全部用户的口令就落入黑客的手里。此外，网站运维人员是能够访问数据库的，也就是能获取到全部用户的口令。正确的保存口令的方式是不存储用户的明文口令，而是存储用户口令的摘要，好比MD5：　　

    username | password
    ---------+---------------------------------
    michael  | e10adc3949ba59abbe56e057f20f883e
    bob      | 878ef96e86145580c38c87f0410ad153
    alice    | 99b1c2188db85afee403b1536010c2c9

　考虑这么个状况，不少用户喜欢用123456，888888，password这些简单的口令，因而，黑客能够事先计算出这些经常使用口令的MD5值，获得一个反推表：　

    'e10adc3949ba59abbe56e057f20f883e': '123456'
    '21218cca77804d2ba1922c33e0151105': '888888'
    '5f4dcc3b5aa765d61d8327deb882cf99': 'password'

　　这样，无需破解，只须要对比数据库的MD5，黑客就得到了使用经常使用口令的用户帐号。

　　对于用户来说，固然不要使用过于简单的口令。可是，咱们可否在程序设计上对简单口令增强保护呢？

　　因为经常使用口令的MD5值很容易被计算出来，因此，要确保存储的用户口令不是那些已经被计算出来的经常使用口令的MD5，这一方法经过对原始口令加一个复杂字符串来实现，俗称“加盐”：

    hashlib.md5("salt".encode("utf-8"))

通过Salt处理的MD5口令，只要Salt不被黑客知道，即便用户输入简单口令，也很难经过MD5反推明文口令。

　　可是若是有两个用户都使用了相同的简单口令好比123456，在数据库中，将存储两条相同的MD5值，这说明这两个用户的口令是同样的。有没有办法让使用相同口令的用户存储不一样的MD5呢？

　　若是假定用户没法修改登陆名，就能够经过把登陆名做为Salt的一部分来计算MD5，从而实现相同口令的用户也存储不一样的MD5。

　　摘要算法在不少地方都有普遍的应用。要注意摘要算法不是加密算法，不能用于加密（由于没法经过摘要反推明文），只能用于防篡改，可是它的单向计算特性决定了能够在不存储明文口令的状况下验证用户口令。

4、补充知识

　　data = conn.recv(1024) # 阻塞

监听的套接字对象conn断开链接：

　　　　针对windows：异常报错。

　　　　针对linux：接收一个空的data。