python安全工具开发基础

最新推荐文章于 2024-05-24 09:16:22 发布
最新推荐文章于 2024-05-24 09:16:22 发布
阅读量337 收藏 3
点赞数 1
分类专栏： # python # web安全 文章标签： python 安全 windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63701832/article/details/133657136
版权

文章目录

拷贝、with

==、is

a = [11, 22, 33]
b = [11, 22, 33]
c=a
print(id(a))
print(id(b))
print(id(c))

print(a == b)
print(a == c)
print(a is b)
print(a is c)

1655503254336
1655503220608
1655503254336
True
True
False
True

深拷贝、浅拷贝

  • 浅拷贝：对于一个对象的顶层拷贝
  • 深拷贝：对于一个对象所有层次的拷贝(递归)
import copy
_list=['a',4]
a=[1,2,3,_list]
b=a
c=a.copy()
d=copy.deepcopy(a)

a.append(9)
a[3].append(8)

print(a)
print(b)
print(c)
print(d)

[1, 2, 3, [‘a’, 4, 8], 9]
[1, 2, 3, [‘a’, 4, 8], 9]
[1, 2, 3, [‘a’, 4, 8]]
[1, 2, 3, [‘a’, 4]]

注意：copy.copy对于可变类型会进行浅拷贝，对于不可变类型（例如元组）不会拷贝，仅仅是指向

with

上下文管理器

任何实现了 __enter__() 和 __exit__() 方法的对象都可称之为上下文管理器，上下文管理器对象可以使用 with 关键字。

class File():
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        print("entering")
        self.f = open(self.filename, self.mode)
        return self.f

    def __exit__(self, *args):
        print("will exit")
        self.f.close()

with File('test', 'w') as f:
    print("coleak")
    f.write('hello, python')

entering
coleak
will exit

contextmanager 的装饰器

通过 yield 将函数分割成两部分，yield 之前的语句在__enter__方法中执行，yield 之后的语句在 __exit__ 方法中执行。紧跟在 yield 后面的值是函数的返回值。

from contextlib import contextmanager

@contextmanager
def my_open(path, mode):
    f = open(path, mode)
    yield f
    f.close()


with my_open('test', 'w') as m:
    m.write("hello , the simplest context manager")

三器一闭

迭代器

  • 只要是可以通过for…in…的形式进行遍历的，那么这个数据类型就是可以迭代的
  • 只要是通过isinstance来判断出是Iterable类的实例，即isinstance的结果是True那么就表示，这个数据类型是可以迭代的数据类型
  • 迭代器是一个可以记住遍历的位置的对象。迭代器对象从第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
  • list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据
  • 只要在类中，定义__iter__方法，那么这个类创建出来的对象一定是可迭代对象
  • 凡是可作用于for 循环的对象都是 Iterable 类型；
  • 凡是可作用于 next() 函数的对象都是 Iterator 类型
  • 集合数据类型如 list 、dict、str等是 Iterable 但不是Iterator，不过可以通过 iter() 函数获得一个 Iterator 对象

Iterable, Iterator

from collections.abc import Iterator
nums = [11, 22, 33, 44]
nums_iter = iter(nums)
print("nums", isinstance(nums, Iterator))
print("nums_iter", isinstance(nums_iter, Iterator))
num1 = next(nums_iter)
print(num1)
num2 = next(nums_iter)
print(num2)
num3 = next(nums_iter)
print(num3)
num4 = next(nums_iter)
print(num4)

# nums False
# nums_iter True
# 11
# 22
# 33
# 44

next,iter

from collections.abc import Iterator

class MyList(object):
    """自定义的一个可迭代对象"""
    def __init__(self):
        self.items = []
        self.current = 0


    def add(self, val):
        self.items.append(val)

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < len(self.items):
            item = self.items[self.current]
            self.current += 1
            return item
        else:
        	self.current = 0
            raise StopIteration

if __name__ == '__main__':
    mylist = MyList()
    mylist.add(1)
    mylist.add(2)
    mylist.add(3)
    mylist.add(4)
    mylist.add(5)
    for num in mylist:
        print(num)
    print("mylist是否是迭代器", isinstance(mylist, Iterator))
    print(next(mylist))
    print(next(mylist))
    print(next(mylist))
    print(next(mylist))
    print(next(mylist))


# 1
# 2
# 3
# 4
# 5
# mylist是否是迭代器 True
# 1
# 2
# 3
# 4
# 5

生成器

  • 生成器是一种特殊的迭代器
  • 在def函数中有yield关键字的 就称为 生成器

yield

def fib_generator():
    num1 = 1
    num2 = 1
    while True:
        temp_num = num1
        num1, num2 = num2, num1+num2
        # return temp_num
        yield temp_num

fib = fib_generator()
print(next(fib))
print(next(fib))
print(next(fib))
print(next(fib))

def generator_test():
    while True:
        print("--1--")
        num = yield 100
        print("--2--", "num=", num)


g = generator_test()
print(g.send(None))
print(g.send(11))

# --1--
# 100
# --2-- num= 11
# --1--
# 100

闭包

  • 闭包定义是在函数内再嵌套函数
  • 闭包是可以访问另一个函数局部作用域中变量的函数
  • 闭包可以读取另外一个函数内部的变量
  • 闭包可以让参数和变量不会被垃圾回收机制回收，始终保持在内存中（而普通的函数调用结束后 会被Python解释器自动释放局部变量）
def who(name):
    def talk(content):
        print("(%s):%s" % (name, content))
    return talk

zhangsan = who("张三")
lisi = who("李四")

zhangsan("zsan")
lisi("lsi")

def make_filter(keep):  
    def the_filter(file_name):  
        file = open(file_name)  
        lines = file.readlines()  
        file.close()  
        filter_doc = [i for i in lines if keep in i]  
        return filter_doc  
    return the_filter  

filter = make_filter("163.com")  
filter_result = filter("result.txt")

装饰器

  • 引入日志
  • 函数执行时间统计
  • 执行函数前预备处理
  • 执行函数后清理功能
  • 权限校验等场景
  • 缓存

简单装饰器

import time
def out_hello(fn):
    def inner_hello():
        before = time.time()
        fn()
        after = time.time()
        print("函数所用时间是：", after-before)
    return inner_hello
@out_hello
def print_hello():
    for i in range(10000):
        print("hello:%d" % i)
ph = print_hello()

执行顺序

def timefun(func):
    print("----开始装饰----")
    def wrapped_func():
        print("----开始调用原函数----")
        func()
        print("----结束调用原函数----")

    print("----完成装饰----")
    return wrapped_func

@timefun
def helloworld():
    print("helloworld")

helloworld()

带参数

from time import ctime, sleep

def timefun(func):
    def wrapped_func(a, b):
        print("%s called at %s" % (func.__name__, ctime()))
        print(a, b)
        func(a, b)
    return wrapped_func

@timefun
def foo(a, b):
    print(a+b)

foo(3,5)
sleep(2)
foo(2,4)

带return的函数

from time import ctime, sleep
def timefun(func):
    def wrapped_func():
        print("%s called at %s" % (func.__name__, ctime()))
        return func()
    return wrapped_func

@timefun
def foo():
    print("I am foo")

@timefun
def get_info():
    return '----hahah---'

foo()
sleep(2)
foo()
print(get_info())  # 可以看到这里并没有 get_info这个函数 返回的数据，因此这里有不完善的地方

类对函数进行装饰

class Test(object):
    def __init__(self, func):
        print("---初始化---")
        print("func name is %s" % func.__name__)
        self.__func = func
    def __call__(self):
        print("---装饰器中的功能---")
        self.__func()

@Test
def test():
    print("----test---")

test()  # 如果把这句话注释，重新运行程序，依然会看到"--初始化--"

动态绑定

import types

class Person():
    num = 0
    def __init__(self, name = None, age = None):
        self.name = name
        self.age = age
    def eat(self):
        print("---默认的实例方法---")

# 定义一个实例方法
def run(self, speed):
    print("----实例方法--1--")
    print("%s在移动, 速度是 %d km/h"%(self.name, speed))
    print("----实例方法--2--")

# 定义一个类方法
@classmethod
def test_class(cls):
    print("----类方法--1--")
    print("num=%d" % cls.num)
    cls.num = 100
    print("num=%d" % cls.num)
    print("----类方法--2--")

# 定义一个静态方法
@staticmethod
def test_static():
    print("----静态方法--1--")
    print("---static method----")
    print("----静态方法--2--")

# 创建一个实例对象
p = Person("老王", 24)
# 调用在class中的方法
p.eat()

# 给这个对象添加实例方法
p.run = types.MethodType(run,p)
# 调用实例方法
p.run(180)

# 给Person类绑定类方法
Person.test_class = test_class

# 调用类方法
Person.test_class()

# 给Person类绑定静态方法
Person.test_static = test_static
# 调用静态方法
Person.test_static()

slots

__slots__ = ("name", "age")

限制实例的属性，只允许对Person实例添加name和age属性

垃圾回收

  • python采用的是引用计数机制为主，标记-清除和**分代收集（隔代回收）**两种机制为辅的策略。
  • [-5, 256] 这些整数对象是提前建立好的，不会被垃圾回收
  • 大整数不共用内存，引用计数为0，销毁
  • 单个单词，不可修改，默认开启intern机制，共用对象，引用计数为0，则销毁
  • 字符串（含有空格），不可修改，没开启intern机制，不共用对象，引用计数为0，销毁

引用计数机制的优点

  • 简单
  • 实时性：一旦没有引用，内存就直接释放了。不用像其他机制等到特定时机。实时性还带来一个好处：处理回收内存的时间分摊到了平时

引用计数机制的缺点

  • 维护引用计数消耗资源
  • 循环引用

GC系统

  • 为新生成的对象分配内存
  • 识别哪些是垃圾对象
  • 回收垃圾对象占用的内存

导致引用计数+1的情况

  • 对象被创建，例如a=23
  • 对象被引用，例如b=a
  • 对象被作为参数，传入到一个函数中，例如func(a)
  • 对象作为一个元素，存储在容器中，例如list1=[a,a]

导致引用计数-1的情况

  • 对象的别名被显式销毁，例如del a
  • 对象的别名被赋予新的对象，例如a=24
  • 一个对象离开它的作用域，例如f函数执行完毕时，func函数中的局部变量（全局变量不会）
  • 对象所在的容器被销毁，或从容器中删除对象

分代回收

  • 分代回收是一种以空间换时间的操作方式，Python将内存根据对象的存活时间划分为不同的集合，每个集合称为一个代，Python将内存分为了3“代”，分别为年轻代（第0代）、中年代（第1代）、老年代（第2代），他们对应的是3个链表，它们的垃圾收集频率随着对象存活时间的增大而减小。
  • 新创建的对象都会分配在年轻代，年轻代链表的总数达到上限时，Python垃圾收集机制就会被触发，把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代去，依此类推，老年代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内。
  • 同时，分代回收是建立在标记清除技术基础之上。分代回收同样作为Python的辅助垃圾收集技术处理那些容器对象

gc模块

  • gc.get_count()：获取当前自动执行垃圾回收的计数器，返回一个长度为3的列表
  • gc.get_threshold()：获取gc模块中自动执行垃圾回收的频率,默认是(700, 10, 10)
  • gc.set_threshold(threshold0[,threshold1,threshold2])：设置自动执行垃圾回收的频率
  • gc.disable()：python3默认开启gc机制，可以使用该方法手动关闭gc机制
  • gc.collect()：手动调用垃圾回收机制回收垃圾

查看引用计数

import sys
a = "hello world"
sys.getrefcount(a)

查看阈值

import gc

print(gc.get_threshold())
#(700, 10, 10)
# 700：表示当分配对象的个数达到700时，进行一次0代回收
# 10：当进行10次0代回收以后触发一次1代回收
# 10：当进行10次1代回收以后触发一次2代回收

内存泄漏

import gc

class ClassA():
    def __init__(self):
        print('object born,id:%s'%str(id(self)))

def f2():
    while True:
        c1 = ClassA()
        c2 = ClassA()
        c1.t = c2
        c2.t = c1
        del c1
        del c2
        #gc.collect() 手动调用垃圾回收功能，这样在自动垃圾回收被关闭的情况下，也会进行回收

#python默认是开启垃圾回收的，可以通过下面代码来将其关闭
gc.disable()
f2()

有三种情况会触发垃圾回收

当gc模块的计数器达到阈值的时候，自动回收垃圾
调用gc.collect()，手动回收垃圾
程序退出的时候，python解释器来回收垃圾

import gc
class ClassA():
    pass

print(gc.get_count())
a = ClassA()
print(gc.get_count())
del a
print(gc.get_count())

网络编程

函数 socket.socket 创建一个套接字，该函数带有两个参数：

  • Address Family：可以选择 AF_INET（用于 Internet 进程间通信） 或者 AF_UNIX（用于同一台机器进程间通信）,实际工作中常用AF_INET
  • Type：套接字类型，可以是 SOCK_STREAM（流式套接字，主要用于 TCP 协议）或者 SOCK_DGRAM（数据报套接字，主要用于 UDP 协议）

Udp

数据传输

from socket import *


def send_msg(udp_socket):
    """获取键盘数据，并将其发送给对方"""
    # 1. 从键盘输入数据
    msg = input("\n请输入要发送的数据:")
    # 2. 输入对方的ip地址
    dest_ip = input("\n请输入对方的ip地址:")
    # 3. 输入对方的port
    dest_port = int(input("\n请输入对方的Aport:"))
    # 4. 发送数据
    udp_socket.sendto(msg.encode("utf-8"), (dest_ip, dest_port))


def recv_msg(udp_socket):
    """接收数据并显示"""
    # 1. 接收数据
    recv_msg = udp_socket.recvfrom(1024)
    # 2. 解码
    recv_ip = recv_msg[1]
    recv_msg = recv_msg[0].decode("utf-8")
    # 3. 显示接收到的数据
    print(">>>%s:%s" % (str(recv_ip), recv_msg))


def main():
    # 1. 创建套接字
    udp_socket = socket(AF_INET,SOCK_DGRAM)
    # 2. 绑定本地信息
    udp_socket.bind(("", 7890))
    while True:
        # 3. 选择功能
        print("="*30)
        print("1:发送消息")
        print("2:接收消息")
        print("="*30)
        op_num = input("请输入要操作的功能序号:")

        # 4. 根据选择调用相应的函数
        if op_num == "1":
            send_msg(udp_socket)
        elif op_num == "2":
            recv_msg(udp_socket)
        else:
            print("输入有误，请重新输入...")

if __name__ == "__main__":
    main()

广播

import socket

# 1. 创建UDP套接字
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 2. 设置UDP套接字允许其广播(注意如果udp套接字需要广播，则一定要添加此语句)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

# 选做 绑定本地信息
# s.bind(("", 8080))

# 4. 向本局域网中发送广播数据
# 此时只要是本局域网中的电脑上有 用1060端口的udp程序 它就会收到此数据
dest_info = ("<broadcast>", 1060)  # <broadcast>会自动改为本局域网的广播ip
s.sendto('hello world !'.encode('utf-8'), dest_info)

# 5. 关闭套接字
s.close()

Tcp

数据传输

import socket

# 1. 创建TCP套接字
server_s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 2. 绑定本地信息
server_s.bind(("", 8082))

# 3. 设置为被动的
server_s.listen(128)

# 4. 等待客户端链接
new_s,client_info = server_s.accept()

# 5. 用新的套接字为已经连接好的客户端服务器
while True:
    recv_content = new_s.recv(1024)
    print(f"{str(client_info)},{recv_content.decode('utf-8')}")

    if not recv_content:
        # 当客户端调用了close后，recv返回值为空，此时服务套接字就可以close了
        # 6. 关闭服务套接字
        new_s.close()
        break

# 7. 关闭监听套接字
server_s.close()

from socket import *

# 1. 创建socket
tcp_client_socket = socket(AF_INET, SOCK_STREAM)

# 2. 链接服务器
tcp_client_socket.connect(("127.0.0.1", 8082))

# 3. 向服务器发送数据
while True:
    ch=int (input("选择1则发送信息"))
    if ch==1:
        send_data = input("请输入要发送的数据：")
        tcp_client_socket.send(send_data.encode("utf-8"))
    else:
        break

tcp_client_socket.close()

文件下载功能

from socket import *
import sys


def get_file_content(file_name):
    """获取文件的内容"""
    try:
        with open(file_name, "rb") as f:
            content = f.read()
        return content
    except:
        print("没有下载的文件:%s" % file_name)


def main():
    port = int(input("开启的端口"))
    # 创建socket
    tcp_server_socket = socket(AF_INET, SOCK_STREAM)
    # 本地信息
    address = ('', port)
    # 绑定本地信息
    tcp_server_socket.bind(address)
    # 将主动套接字变为被动套接字
    tcp_server_socket.listen(128)

    # 等待客户端的链接，即为这个客户端发送文件
    client_socket, clientAddr = tcp_server_socket.accept()
    # 接收对方发送过来的数据
    recv_data = client_socket.recv(1024)  # 接收1024个字节
    file_name = recv_data.decode("utf-8")
    print("对方请求下载的文件名为:%s" % file_name)
    file_content = get_file_content(file_name)
    # 发送文件的数据给客户端
    # 因为获取打开文件时是以rb方式打开，所以file_content中的数据已经是二进制的格式，因此不需要encode编码
    if file_content:
        client_socket.send(file_content)
    # 关闭这个套接字
    client_socket.close()
    # 关闭监听套接字
    tcp_server_socket.close()

if __name__ == "__main__":
    main()

import time
from socket import *

def main():

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

    # 目的信息
    server_ip = input("请输入服务器ip:")
    server_port = int(input("请输入服务器port:"))

    # 链接服务器
    tcp_client_socket.connect((server_ip, server_port))

    # 输入需要下载的文件名
    file_name = input("请输入要下载的文件名：")

    # 发送文件下载请求
    tcp_client_socket.send(file_name.encode("utf-8"))

    # 接收对方发送过来的数据，最大接收1024个字节（1K）
    recv_data = tcp_client_socket.recv(1024)
    # print('接收到的数据为:', recv_data.decode('utf-8'))
    # 如果接收到数据再创建文件，否则不创建
    if recv_data:
        with open(f"new_{time.time()}", "wb") as f:
            f.write(recv_data)
        print('下载完毕')

    # 关闭套接字
    tcp_client_socket.close()


if __name__ == "__main__":
    main()

协程

yield

import time

def work1():
    while True:
        print("----work1---")
        yield
        time.sleep(0.5)

def work2():
    while True:
        print("----work2---")
        yield
        time.sleep(0.5)

def main():
    w1 = work1()
    w2 = work2()
    while True:
        next(w1)
        next(w2)

if __name__ == "__main__":
    main()

greenlet

from greenlet import greenlet
import time

def test1():
    while True:
        print("---A1--")
        gr2.switch()
        time.sleep(0.5)
        print("---A2--")


def test2():
    while True:
        print("---B1--")
        gr1.switch()
        time.sleep(0.5)
        print("---B2--")


gr1 = greenlet(test1)
gr2 = greenlet(test2)

#切换到gr1中运行
gr1.switch()

gevent

import gevent
import time
from gevent import monkey


monkey.patch_all()


def f1(n):
    for i in range(n):
        print("-----f1-----", i)
        # gevent.sleep(1)
        time.sleep(1)


def f2(n):
    for i in range(n):
        print("-----f2-----", i)
        # gevent.sleep(1)
        time.sleep(1)

def f3(n):
    for i in range(n):
        print("-----f3-----", i)
        # gevent.sleep(1)
        time.sleep(1)


g1 = gevent.spawn(f1, 5)
g2 = gevent.spawn(f2, 5)
g3 = gevent.spawn(f3, 5)
g1.join()  # join会等待g1标识的那个任务执行完毕之后 对其进行清理工作，其实这就是一个 耗时操作
g2.join()
g3.join()

通过添加monkey.patch_all()能够让程序中看上去的time.sleep也具备了自动切换任务的功能，实际上它会悄悄的修改程序中time.sleep为gevent.sleep从而实现功能

import gevent
import random
import time
from gevent import monkey

monkey.patch_all()

def coroutine_work(coroutine_name):
    for i in range(10):
        print(coroutine_name, i)
        time.sleep(random.random())


def coroutine_work2(coroutine_name):
    for i in range(10):
        print(coroutine_name, i)
        time.sleep(random.random())


gevent.joinall([
        gevent.spawn(coroutine_work, "work1"),
        gevent.spawn(coroutine_work2, "work2")
])

gevent.joinall，只要将得到的协程对象放到里面即可

mysql

设置远程权限

mysql -uroot -proot
use mysql;
select user,host from user;
update user set host = '%'  where user ='root';
grant all privileges on *.* to 'root'@'%' identified by 'root' with grant option;
flush privileges;

grant all privileges on . to ‘用户名’@‘%’ identified by ‘密码’ with grant option;
注释： 第一个 * ，表示被授权访问的库
第二个 *， 表示库下的所有表
‘用户名’@‘%’ 用户名 表示授权用户，%表示任意的ip地址
【identified by ‘密码’】 访问mysql的密码
整句命令的意思就是，允许在任何IP地址上用这个用户名和密码来访问这个mysql

查看版本

import pymysql
conn=pymysql.Connection(
    host='192.168.10.133',
    port=3306,
    user='root',
    password='root'
)
# mysql数据库服务器的版本
# 使用cursor()方法获取操作游标
cursor = conn.cursor()

# 使用execute方法执行SQL语句
cursor.execute("SELECT VERSION();")

# 使用 fetchone() 方法获取一条数据
data = cursor.fetchone()

print(data)

# 关闭数据库连接
conn.close()

创建表

import pymysql

db = pymysql.connect(
    host='192.168.10.133',
    port=3306,
    user='root',
    password='root',
    autocommit=True
    )

# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()
db.select_db('test')
# 使用 execute() 方法执行 SQL，如果表存在则删除
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE;")

# 使用预处理语句创建表
sql = """CREATE TABLE EMPLOYEE (
         FIRST_NAME  CHAR(20) NOT NULL,
         LAST_NAME  CHAR(20),
         AGE INT,  
         SEX CHAR(1),
         INCOME FLOAT )"""

cursor.execute(sql)

# 关闭数据库连接
db.close()

插入数据

# SQL 插入语句
sql = "INSERT INTO EMPLOYEE(FIRST_NAME,LAST_NAME, AGE, SEX, INCOME)VALUES ('%s', '%s',  %s,  '%s',  %s)" %('Mac', 'Mohan', 21, 'M', 2000)
try:
    # 执行sql语句
    cursor.execute(sql)
except:
    # 如果发生错误则回滚
    db.rollback()

# 关闭数据库连接
db.close()

查询操作

# SQL 插入语句
sql = "SELECT * FROM EMPLOYEE \
       WHERE INCOME > %s" % (1000)
try:
    # 执行SQL语句
    cursor.execute(sql)
    # 获取所有记录列表
    results = cursor.fetchall()
    # result=cursor.fetchone()
    # print(result)
    print(results)
    for row in results:
        fname = row[0]
        lname = row[1]
        age = row[2]
        sex = row[3]
        income = row[4]
        # 打印结果
        print("fname=%s,lname=%s,age=%s,sex=%s,income=%s" % \
              (fname, lname, age, sex, income))
except:
    print("Error: unable to fetch data")

# 关闭数据库连接
db.close()

更新操作

# SQL 更新语句
sql = "UPDATE EMPLOYEE SET AGE = AGE + 10 WHERE SEX = '%c'" % ('M')
try:
    # 执行SQL语句
    cursor.execute(sql)
except:
    # 发生错误时回滚
    db.rollback()

删除操作

# SQL 删除语句
sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20)
try:
    # 执行SQL语句
    cursor.execute(sql)
    # 提交修改
    db.commit()
except:
    # 发生错误时回滚
    db.rollback()

# 关闭连接
db.close()

预处理防止注入

开启日志

set global general_log_file='/tmp/general_log';
set global general_log=on;
show global variables like '%general%';

普通查询操作

cursor = db.cursor()
db.select_db('test')
fn='Mac2'
# SQL 插入语句
sql = f"SELECT * FROM EMPLOYEE WHERE FIRST_NAME = '{fn}';"
print(sql)
try:
    # 执行SQL语句
    cursor.execute(sql)

日志记录

85 Connect  root@192.168.10.1 on  using TCP/IP
85 Init DB  test
85 Query    SELECT * FROM EMPLOYEE WHERE FIRST_NAME = 'Mac2'
85 Quit

修改fn为

fn=f"1' or 1=1 #"
即SELECT * FROM EMPLOYEE WHERE FIRST_NAME = '1' or 1=1 #';

日志记录

88 Connect  root@192.168.10.1 on  using TCP/IP
88 Init DB  test
88 Query    SELECT * FROM EMPLOYEE WHERE FIRST_NAME = '1' or 1=1 --+ '
88 Quit

此时存在sql注入，返回所有数据

预处理

fn=f"1' or 1=1 #"
# SQL 插入语句
sql = "select * from EMPLOYEE where FIRST_NAME = %s"
print(sql)
try:
    # 执行SQL语句
    cursor.execute(sql,fn)
    # 获取所有记录列表
    results = cursor.fetchall()

日志记录

93 Connect  root@192.168.10.1 on  using TCP/IP
93 Init DB  test
93 Query    select * from EMPLOYEE where FIRST_NAME = '1\' or 1=1 #'
93 Quit

发现此时单引号已经被转义

mysql原预编译语法为

 prepare emp from 'select * from EMPLOYEE where FIRST_NAME = ?';
 set @FIRST_NAME='Mac';
 execute emp using @FIRST_NAME;

redis

未授权/弱密码

import socket
import sys
def check(ip, port, file,timeout):
    passfile=open(file,'r')
    PASSWORD_DIC=passfile.read().splitlines()
    socket.setdefaulttimeout(timeout)
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((ip, int(port)))
    s.send("INFO\r\n".encode("utf-8"))
    result = s.recv(1024).decode()
    if "redis_version" in result:
        return "未授权访问"
    elif "Authentication" in result:
        for pass_ in PASSWORD_DIC:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.connect((ip, int(port)))
            s.send(f"AUTH {pass_}\r\n".encode("utf-8"))
            result = s.recv(1024).decode()
            if 'OK' in result:
                return "存在弱口令，密码：%s" % (pass_)
if __name__ == '__main__':
    ip=sys.argv[1]
    port=sys.argv[2]
    file=sys.argv[3]
    print(check(ip, port,file, timeout=10))

python redis.py 127.0.0.1 6379 pass.txt
coleak
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python基础知识点总结
学Python的小白！
08-25 7万+
本文包括python基本知识：简单数据结构，数据结构类型（可变：列表，字典，集合，不可变：数值类型，字符串，元组），分支循环和控制流程，类和函数，文件处理和异常等等。
python开发的Web爬虫.zip
12-28
教程详尽：配套的Python爬虫教程，从基础到进阶，让您逐步掌握爬虫的核心技术。 合法合规：严格遵守法律法规和网站使用协议，确保采集行为合法，尊重网站权益。 实战项目：结合实际案例，让您在实践中掌握Python爬虫...
python web开发基础
野猫炫的博客
05-09 1万+
Web 开发：构建、创建和维护网站。Web 开发涉及前端，即与客户端交互的所有内容，以及包含业务逻辑并与数据库交互的后端。 网站是存储在服务器上的文件，服务器是托管网站的计算机。这些服务器连接到一个称为 Internet 的网络。访问这些网站的计算机称为“客户端”。 要访问网站需要知道其IP地址，IP 地址是一串唯一的数字。每个设备都有一个 IP 地址。可以在控制台cmd输入命令ipconfig获取自己的ip。也可以使用其 IP 地址访问网站，但大多数使用域名或通过搜索引擎访问网站。 超文本传输​​协
Python学习工具TOP10
Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！
11-07 9172
大家好，我是是Dream呀，在我们平时的开发和生活中，天都在使用、寻找、贡献、创作各类开发者工具，包括开源服务、付费软件、API等。好的工具可以极大帮助我们提升效率，服务业务。作为一名资深的Python博主， **很多人都会问我平时使用什么工具，亦或者说有什么比较好的推荐工具呢？** 实话实说，在这些年来的学习生活中，确实有一些很好用的工具，那今天我就来和大家一起分享一下我的开发工具！希望大家可以耐心看完，如果对你也有帮助的话就赶紧收藏起来吧
《Python基础教程》内容总览篇
热门推荐
weixin_43178406的博客
08-26 11万+
大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的知识进行总结与归纳，不仅形成深入且独到的理解，而且能够帮助新手快速入门。个人精心开设的《Python基础课程》专栏订阅量接近900，帮助不少同学解决了Bug。
Python基础手册
爱测乐园
11-05 4309
python基础
Python最基础语法
lydms的博客
06-30 1万+
3.7.3。
5个Python开发实用工具
m0_59162248的博客
10-25 1054
Python 虽好，可总是会遇到各种包管理和 Python 版本问题，特别是 Windows 平台很多包无法正常安装，为了解决这些问题，Anoconda 出现了，Anoconda 包含了一个包管理工具和一个Python管理环境，同时附带了一大批常用数据科学包，也是数据分析的标配。它是数据分析、机器学习的必备工具。Python shell 了，IPython 支持变量自动补全，自动缩进，支持 bash shell 命令，内置了许多实用功能和函数，同时它也是科学计算和交互可视化的最佳平台。
python测试开发工具库汇总
猫咪控丶的博客
05-21 3166
https://github.com/china-testing/python-api-tesing/blob/master/books.md有相关书籍下载！ Web UI测试自动化 splinter - web UI测试工具，基于selnium封装。 selenium - web UI自动化测试。 mechanize- Python中有状态的程序化Web浏览链接 selene -...
Python基础知识总结
zxzxin的博客~
10-31 2万+
Python基础知识总结 基础中的基础 列表、元组(tuple)、字典、字符串 变量和引用 函数 面向对象 基础中的基础 解释型语言和编译型语言差距； Python概述 解释器执行原理 which python3可以查看python3的位置(linux下)； 交互式环境中使用exit()或者ctrl+D退出； 9 // 2表示取结果的整数，乘方使用**； 乘法可以用在 字符串中 也就...
用Python写了个工具，完美破解了MySQL！！（建议收藏）
冰河的专栏
07-01 4万+
再也不怕忘记MySQL的用户名和密码了，用这个工具可以秒破MySQL，冰河强烈建议收藏！！
Python爬虫基础知识
03-03
Python爬虫是利用Python...在爬虫开发中，也应注意保护个人隐私和信息安全，避免对网站造成不必要的负担或恶意攻击。 总之，Python爬虫是一项强大而灵活的技术，能够帮助开发者快速获取和整理大量数据。通过掌握爬虫基
Python网络安全项目开发实战_扫描漏洞_编程案例解析实例详解课程教程.pdf
04-27
某个时期，有很多完全不...做个脚本小子并不难，只需要一点点的英语基础（认识基本的计算机单词即可，毕竟很多软件都是英文版的），熟练地使用黑客工具，再熟悉几个简单的命令，就可以对网络上的计算机造成很大的破坏。
python scrapy 企业级分布式爬虫开发架构模板.zip
12-28
教程详尽：配套的Python爬虫教程，从基础到进阶，让您逐步掌握爬虫的核心技术。 合法合规：严格遵守法律法规和网站使用协议，确保采集行为合法，尊重网站权益。 实战项目：结合实际案例，让您在实践中掌握Python爬虫...
Python实用教程：Python基础，Python高级特性，面向对象编程，多线程，数据库，数据科学，Flask，爬虫开发教程
12-28
教程详尽：配套的Python爬虫教程，从基础到进阶，让您逐步掌握爬虫的核心技术。 合法合规：严格遵守法律法规和网站使用协议，确保采集行为合法，尊重网站权益。 实战项目：结合实际案例，让您在实践中掌握Python爬虫...
【hackmyvm】Slowman靶机
woshicainiao666的博客
05-20 906
发现/secretLOGIN/login.html为登录地址，根据账号密码登录发现一个zip，但是需要密码。在FTP中得到的账号，爆破一下SSH。上传linpeas.sh文件，报一下。SSH爆破无果，试试mysql。得到用户名和加密的密码。
python中用“*”运算符复制列表时子列表实际上引用的是同一个列表，列表和嵌套列表的坑
ThreeS_tones的博客
05-21 433
当你修改了一个子列表的元素时，所有的子列表都会随之改变。因为他们实际上都是同一个子列表的引用。输出如下，可以看到每个子列表中的第5个元素相同，并没有实现从0.8-1.2分布。先看一个例子，我想改变load的子列表中第五个元素，从0.8-1.2分布。的时候，Python实际上。
【Python爬虫】案例_github模拟登录
qq_45951891的博客
05-21 357
【代码】【Python爬虫】案例_github模拟登录。
python 异常处理 try
最新发布
qq_64993426的博客
05-24 324
异常处理，主动抛出异常，断言
python安全工具开发书籍
05-09
以下是几本值得推荐的Python安全工具开发书籍： 1.《Python网络数据采集》- Ryan Mitchell 这本书主要介绍了如何使用Python进行网络数据采集，对于网络安全工程师来说非常有用。书中详细介绍了如何使用Python来编写网络爬虫、模拟登录、数据处理等。 2.《Python黑帽子：黑客与渗透测试编程之道》- Justin Seitz 这是一本非常实用的Python安全工具开发书籍，主要介绍了如何使用Python来编写黑客工具和渗透测试工具。书中涵盖了很多Python的基础知识和网络安全的基础知识。 3.《Python密码学编程》- Sam Bowne 这本书主要介绍了如何使用Python进行密码学编程，包括加密、解密、哈希等。对于想要深入了解密码学的安全工程师来说非常有用。 4.《Python渗透测试实战》- 刘沧龙 这是一本非常实用的Python安全工具开发书籍，主要介绍了如何使用Python进行渗透测试，包括信息搜集、漏洞扫描、漏洞利用等。书中详细介绍了如何使用Python编写渗透测试工具。 以上是一些值得推荐的Python安全工具开发书籍，希望对你有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

coleak

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值