day8-套接字sock 实现SSH远程执行命令功能

Posted 2020-10-14

复习

#面向对象编程
#类：
#对象
#实例化 ：从一个类到产生一个对象的过程
    #对象 = 类名()   #__init__初始化方法，是为了给一个具体的对象放一些初识的属性
#在类中：
    # 静态属性 直接定义在类中的属性，使用静态属性：类名、对象名都可以调用
    # 动态属性 就是方法 就是定义在类中的函数 默认传一个self
# class Person:
#     money = 100
# sister = Person()
# father = Person()
# Person.money += 200
# Person.money += 500
# print(Person.money)
#组合:是什么有什么的关系。
    #一个类的对象作为两外一个类的属性来使用
#继承
    #子类
    #父类、基类、超类
    #单继承和多继承
    #子类中出现 ： 派生 父类中没有的子类中有了
        #派生方法
        #派生属性
    #经典类和新式类在多继承上有什么特点
        #新式类广度优先和经典类深度优先

# python2 ： 经典类 指名道姓去使用父类的方法

class A:
    def func(self):print(‘A‘)

class B(A):
    def func(self):
        super().func()
        # super(B,self).func()
        print(‘B‘)

b = B()
b.func()
super(B,b).func() #不常用

 

多态

#初识面向对象
#继承和组合
#面向对象的进阶
#多态
#封装
#面向对象：反射
#类中的内部的 双下方法

#__init__
#__dict__

#多态：python自带多态

# def func(int a):
#     print(a)

# func(2)
# func(‘ashkgask‘)

class Animal:
    pass

class Dog(Animal):pass
class Cat(Animal):pass

wangcai = Dog()
kitty = Cat()
def eat(obj):
    print(obj.name,‘在吃‘)

eat(1)
eat(‘hello‘)

#多态：在其他语言里：类的继承
      #在Python中

#有相同特点的类：鸭子类型
    #list 和 tuple  鸭子类型
    #1+2   ‘a‘+‘b‘

 

封装

#封装就是把方法和属性 扔到一个容器里装起来
#私有的:只能在类的内部使用，不能直接在类的外部使用
# class Supermarket:
#     __DISCONT = 0.8  #加了双下划线就被定义成了一个私有的
#     def __init__(self,org_price):
#         self.price = org_price * Supermarket.__DISCONT
# A.__COUNTRY
# a = A()
# a.func()
# print(A.__dict__)
# print(A._A__COUNTRY)   #不合法

# class Goods:
#     __DISCONT = 0.8  #加了双下划线就被定义成了一个私有的
#     def __init__(self,org_price):
#         self.price = org_price * Goods.__DISCONT
#
# apple = Goods(10)
# print(apple.price)

# class A:
#     def __func(self):
#         self.__name = ‘alex‘
#
# a = A()
# a._A__func()

#私有的  __名字
#定义私有静态属性
#定义私有的方法
#定义私有的对象属性
#只要是私有的：类内正常使用，类外不能直接使用。如果一定要用_类名__名字
#私有的东西可以子类中使用么？不能

#用到私有变量
    #1.当我们想要隐藏一个变量不被外调用的时候
    #2.当我们写在父类中且不希望子类继承的时候
class A:
    __B = ‘hahaha‘

class B(A):pass

print(A.__dict__)
print(B.__dict__)

 

几个类中的装饰器

#property
#classmethod
#staticmethod
# class Circle:
#     def __init__(self,r):
#         self.r = r
#
#     @property
#     def area(self):
#         return self.r *self.r *3.14
#
# c1 = Circle(5)
# print(c1.area)

class A:
    def __init__(self,name):
        self.__name = name
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self,new_name):
        if type(new_name) is str:
            self.__name = new_name

# a = A(‘alex‘)
# print(a.name)
# #希望不从外部被修改 所以设置一个私有的属性
# #但是又希望能从外部查看 所以使用一个property
# a.name = ‘alex_sb‘
# print(a.name)

#classmethod
class A:
    country = ‘China‘
    def func(self):
        self.name= ‘alex‘

    @classmethod    #类方法：就是不需要传具体的对象
                    #但是可以使用类的属性、静态属性
    def c_method(cls):
        print(‘in class method‘)
        print(cls.country)

    @staticmethod   #静态方法
    def s_method():print(‘in static method‘)

A.c_method()
A.s_method()

#完全的面向对象编程
#所有的方法代码都必须写类里
#只能把原来的函数写进类里
#而原本又只是函数 所以就加上一个staticmethod装饰器

 

反射

#issubclass(子类，父类)
# class A:pass
# class B(A):pass
# print(issubclass(B,A))
# isinstance(对象，类名)
#判断一个对象是不是这个类的实例
# b = B()
# print(isinstance(b,B))
# print(isinstance(b,A))

#什么叫反射
#使用字符串的形式去获取变量
# a = 1
# b = 2
# name = input(‘变量名 :‘)
# if name == ‘a‘:
#     print(a)

class Person:
    role = ‘Person‘
    country = ‘China‘
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def func(self):
        print(‘%s in func‘%self.name)
alex = Person(‘alex‘,80)
# name = input(‘属性名 ：‘)
# Person.role
# alex.name  alex.age
# if hasattr(alex,‘func‘):
#     func = getattr(alex,‘func‘)
#     func()


def func2(self):
    print(‘%s in func2‘ % self.name)

#setattr
# alex.sex = None
# setattr(alex,‘sex‘,‘不详‘)
# print(alex.sex)
# setattr(alex,‘func2‘,func2)  #setattr绑定方法是一个假的
# # print(alex.func)          # 在使用的时候必须要手动传self对象
# alex.func2(alex)
#delattr
# delattr(alex,‘name‘)  #del alex.name
# alex.name
#使用反射来调用类中的方法和属性，对象的属性


# import demo1
# print(demo1.a)
# print(getattr(demo1,‘a‘))
# demo1.qqxing()
# getattr(demo1,‘qqxing‘)()

a = ‘aaaaa‘
import sys
this_module = sys.modules[__name__]
print(getattr(this_module,‘a‘))


#反射：a.b --> getattr(a,‘b‘)
#hasattr getattr setattr delattr
#类，静态属性、类方法
#对象，方法、属性
#模块，函数，变量
#本模块，函数，变量

 

类中的内置方法

# class A:
#     def __call__(self, *args, **kwargs):
#         print(‘aaaaaaaa‘)

# a = A()()

#__new__
class A:
    def __init__(self):     #初始化方法
        self.x = 1
        print(‘in init function‘)
    def __new__(cls, *args, **kwargs):  #构造方法
        print(‘in new function‘)
        return object.__new__(A, *args, **kwargs)
a = A()   #先构造一个对象 再初始化属性
#单例模式
#从头到尾只有一个实例
class Singleton:
    # def __new__(cls, *args, **kw):
    #     if not hasattr(cls, ‘_instance‘):
    #         cls._instance = object.__new__(A, *args, **kw)
    #     return cls._instance
    # def __str__(self):
    #     return ‘singleton 的 实例‘

    def __repr__(self):
        return ‘singleton repr‘
one = Singleton()
two = Singleton()
# print(‘%s‘%one)
# two.a = 3
# print(one.a)
# print(id(one))
# print(id(two))
# print(one == two)
# print(one is two)

#面试的时候
#单例模式是一种设计模式
#设计模式早期只在java里使用

# l = list()
# l.append(123)
# print(l)

# print(‘%r is somebody‘%‘alex‘)
# print(‘%s is somebody‘%‘alex‘)

#这个类有100个对象，只要name和sex相同，我就认为是相同的对象
#要求对100个对象进行去重
class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __hash__(self):
        return hash(self.name+self.sex)

    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:return True


p_lst = []
for i in range(84):
    p_lst.append(Person(‘egon‘,i,‘male‘))

print(p_lst)
print(set(p_lst))

 

基于TCP协议的简单套接字通信

客户端：

import socket

#买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议

#发起电话链接
phone.connect((‘127.0.0.1‘,8080))


#发消息
phone.send(‘hello‘.encode(‘utf-8‘))

#收消息
data=phone.recv(1024)
print(data)

#关机
phone.close()

服务端

import socket

#买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议

#绑定手机卡
phone.bind((‘127.0.0.1‘,8080))

#开机
phone.listen(5)

#等电话链接
print(‘starting...‘)
conn,client_addr=phone.accept() #(套接字链接,客户端的ip和port)
print(conn)
# print(client_addr)

#收消息
data=conn.recv(1024) # 1024最大的限制
print(‘客户端数据: ‘,data)

#发消息
conn.send(data.upper())

#挂电话
conn.close()

#关机
phone.close()

 

加上通信循环和链接循环

服务端：

import socket

#买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议
# phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加

#绑定手机卡
phone.bind((‘127.0.0.1‘,8080))

#开机
phone.listen(5)

#等电话链接
print(‘starting...‘)
while True:
    conn,client_addr=phone.accept() #(套接字链接,客户端的ip和port)
    print(client_addr)

    while True: #通信循环
        #收消息
        try:
            data=conn.recv(1024) # 1024最大的限制
            print(‘客户端数据: ‘,data)
            if not data:break #针对linux系统
            #发消息
            conn.send(data.upper())
        except ConnectionResetError:
            break

    #挂电话
    conn.close()

#关机
phone.close()

客户端0：

import socket

#买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议

#发起电话链接
phone.connect((‘127.0.0.1‘,8080))


while True:
    #发消息
    msg=input(‘>>: ‘).strip()
    if not msg:continue
    phone.send(msg.encode(‘utf-8‘))
    print(‘has send====>‘)
    #收消息
    data=phone.recv(1024)
    print(‘has recv=====>‘)
    print(data.decode(‘utf-8‘))

#关机
phone.close()

客户端1

import socket

#买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议

#发起电话链接
phone.connect((‘127.0.0.1‘,8080))


while True:
    #发消息
    msg=input(‘>>: ‘).strip()
    if not msg:continue
    phone.send(msg.encode(‘utf-8‘))
    print(‘has send====>‘)
    #收消息
    data=phone.recv(1024)
    print(‘has recv=====>‘)
    print(data.decode(‘utf-8‘))

#关机
phone.close()

 

客户端2

import socket

#买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议

#发起电话链接
phone.connect((‘127.0.0.1‘,8080))


while True:
    #发消息
    msg=input(‘>>: ‘).strip()
    if not msg:continue
    phone.send(msg.encode(‘utf-8‘))
    print(‘has send====>‘)
    #收消息
    data=phone.recv(1024)
    print(‘has recv=====>‘)
    print(data.decode(‘utf-8‘))

#关机
phone.close()

 

 

实现ssh远程执行命令的功能（low版）

服务端：

import socket
import subprocess
import struct

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议
phone.bind((‘127.0.0.1‘,8080))
phone.listen(5)

while True:
    conn,client_addr=phone.accept() #(套接字链接,客户端的ip和port)
    print(client_addr)

    while True: #通信循环
        #收消息
        try:
            cmd=conn.recv(1024) # 1024最大的限制
            if not cmd:break #针对linux系统

            #执行，拿到执行结果
            obj = subprocess.Popen(cmd.decode(‘gbk‘), shell=True,
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)

            stdout_res=obj.stdout.read()
            stderr_res=obj.stderr.read()
            #先发报头
            total_size=len(stderr_res)+len(stdout_res)
            conn.send(struct.pack(‘i‘,total_size))

            #再发真是的数据
            # conn.send(stdout_res+stderr_res)
            conn.send(stdout_res)
            conn.send(stderr_res)
        except ConnectionResetError:
            break

    #挂电话
    conn.close()

#关机
phone.close()

客户端：

import socket
import struct

#买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议

#发起电话链接
phone.connect((‘127.0.0.1‘,8080))


while True:
    #发消息
    cmd=input(‘>>: ‘).strip()
    if not cmd:continue
    phone.send(cmd.encode(‘gbk‘))

    #先收报头
    header_struct=phone.recv(4)
    total_size=struct.unpack(‘i‘,header_struct)[0]

    #再收消息
    cmd_res=b‘‘
    recv_size=0
    while recv_size < total_size:
        recv_data=phone.recv(1024)
        cmd_res+=recv_data
        recv_size+=len(recv_data)

    print(cmd_res.decode(‘gbk‘))

#关机
phone.close()

 

粘包

服务端1：

from socket import *


server=socket(AF_INET,SOCK_STREAM)
server.bind((‘127.0.0.1‘,8080))
server.listen()

conn,addr=server.accept()

data1=conn.recv(5)
print(‘data1:‘,data1)
data2=conn.recv(5)
print(‘data2:‘,data2)

 

客户端1：

from socket import *


client=socket(AF_INET,SOCK_STREAM)
client.connect((‘127.0.0.1‘,8080))


client.send(‘hello‘.encode(‘utf-8‘))
# import time
# time.sleep(10)
client.send(‘world‘.encode(‘utf-8‘))

服务端2：

from socket import *


server=socket(AF_INET,SOCK_STREAM)
server.bind((‘127.0.0.1‘,8080))
server.listen()

conn,addr=server.accept()

data1=conn.recv(1)
print(‘data1:‘,data1)
import time
time.sleep(5)
data2=conn.recv(1024)
print(‘data2:‘,data2)

 

客户端2：

from socket import *


client=socket(AF_INET,SOCK_STREAM)
client.connect((‘127.0.0.1‘,8080))


client.send(‘hello‘.encode(‘utf-8‘))
import time
time.sleep(3)
client.send(‘world‘.encode(‘utf-8‘))

 

实现ssh远程执行命令的功能（最终版）

服务端：

import socket
import subprocess
import struct
import json

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议
phone.bind((‘127.0.0.1‘,8080))
phone.listen(5)

while True:
    conn,client_addr=phone.accept() #(套接字链接,客户端的ip和port)
    print(client_addr)

    while True: #通信循环
        #收消息
        try:
            cmd=conn.recv(1024) # 1024最大的限制
            if not cmd:break #针对linux系统

            #执行，拿到执行结果
            obj = subprocess.Popen(cmd.decode(‘gbk‘), shell=True,
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)

            stdout_res=obj.stdout.read()
            stderr_res=obj.stderr.read()

            # 制作报头
            header_dic = {
                ‘filename‘: ‘a.txt‘,
                ‘total_size‘: len(stdout_res)+len(stderr_res),
                ‘md5‘: ‘xxxxxxxxx‘
            }
            head_json = json.dumps(header_dic)
            head_bytes = head_json.encode(‘utf-8‘)




            #先发报头长度
            conn.send(struct.pack(‘i‘,len(head_bytes)))

            #先发报头
            conn.send(head_bytes)

            #再发真是的数据
            # conn.send(stdout_res+stderr_res)
            conn.send(stdout_res)
            conn.send(stderr_res)
        except ConnectionResetError:
            break

    #挂电话
    conn.close()

#关机
phone.close()

 

客户端：

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             import socket
import struct
import json

#买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议

#发起电话链接
phone.connect((‘127.0.0.1‘,8080))


while True:
    #发消息
    cmd=input(‘>>: ‘).strip()
    if not cmd:continue
    phone.send(cmd.encode(‘gbk‘))

    #先收报头长度
    struct_res=phone.recv(4)
    header_size=struct.unpack(‘i‘,struct_res)[0]

    #再收报头
    head_bytes=phone.recv(header_size)
    head_json=head_bytes.decode(‘utf-8‘)
    head_dic=json.loads(head_json)
    print(head_dic)

    #最收消息
    cmd_res=b‘‘
    recv_size=0
    total_size=head_dic[‘total_size‘]
    while recv_size < total_size:
        recv_data=phone.recv(1024)
        cmd_res+=recv_data
        recv_size+=len(recv_data)

    print(cmd_res.decode(‘gbk‘))

#关机
phone.close()

 

异常处理try

print(‘====>1‘)
print(‘====>2‘)
print(‘====>3‘)
# l=[]
# l[1000000000000000000000000000000000000000000]
# d={}
# d[‘k‘]

age=input(‘>>: ‘).strip()
if age.isdigit():
    int(age)

print(‘====>4‘)
print(‘====>5‘)




print(‘====>6‘)

 

执行系统命令的模块

# import os
#
# res=os.system(‘dir‘)
# print(‘命令的结果‘,res)


# import subprocess
#
# obj=subprocess.Popen(‘dir‘,shell=True,
#                      stdout=subprocess.PIPE,
#                      stderr=subprocess.PIPE)
#
#
#
# stdout_res1=obj.stdout.read()
# print(stdout_res1.decode(‘gbk‘))

# stdout_res2=obj.stdout.read() #在第一次读时，管道就空了
# print(‘========>‘,stdout_res2.decode(‘gbk‘))




# import subprocess
#
# obj=subprocess.Popen(‘diasdfasdfasr‘,shell=True,
#                      stdout=subprocess.PIPE,
#                      stderr=subprocess.PIPE)



# stdout_res1=obj.stdout.read() #命令执行错误会把结果送到stderr管道
# print(stdout_res1.decode(‘gbk‘))

# stdout_res2=obj.stderr.read() #命令执行错误会把结果送到stderr管道
# print(stdout_res2.decode(‘gbk‘))





#ls ; pwasdfasdfd; echo 123
#ls && pwd && echo 123





#执行命令
# import subprocess
#
# obj=subprocess.Popen(‘tasklist | findstr pycharm‘,shell=True,
#                      stdout=subprocess.PIPE,
#                      stderr=subprocess.PIPE)
#
# print(obj.stdout.read().decode(‘gbk‘))



import subprocess
obj1=subprocess.Popen(‘tasklist‘,shell=True,
                 stdout=subprocess.PIPE,)

obj2=subprocess.Popen(‘findstr pycharm‘,shell=True,
                     stdin=obj1.stdout,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE)

print(obj2.stdout.read().decode(‘gbk‘))