Aggregator

A vulnerability classified as problematic has been found in Genivia gSOAP up to 2.8.132. Affected is an unknown function of the component XML Parser. The manipulation leads to excessive iteration. This vulnerability is traded as CVE-2024-4227. It is possible to launch the attack remotely. There is no exploit available.

In the last part of this Windows kernel exploitation series, we succe

​The U.S. Department of Justice announced today that the FBI has deleted Chinese PlugX malwa

Пламя этических споров вспыхнуло после выхода нового исследования.

阅读： 3一、漏洞概述近日，绿盟科技CERT监测到Fortinet发布安全通告，修复了FortiOS和FortiProxy中的身份认证绕过漏洞(CVE-2024-

Задержки в диагностике и лечении привели к осложнениям.

中国信通院ICT第二期《数字安全技术能力全景图》发布，海云安上榜27大细分赛道，拳头产品荣膺“磐安” 优秀案例 日期：2025年01月15日

近日，2025中国信通院ICT深度观察报告会—数字生态治理分论坛（以下简称“论坛”）于12月24日下午在北京国 […]

海云安开发者安全智能助手D10荣膺 “ AI标杆产品 ” 称号，首席科学家齐大伟博士入选2024年度 “ 十大杰出青年 ” 日期：2025年01月

2024年12月27日，粤港澳大湾区AI领袖峰会在深圳成功举办，大会表彰了在人工智能技术创新、应用实践和产业发 […]

海云安 “ 开发者智能助手D10 ” 荣登 2024 人工智能应用标杆 TOP100 榜单！ 日期：2025年01月15日 阅：75

近日，由中关村智用人工智能研究院和新智引擎主办，以“智能驱动，生产力重塑”为主题的第二届人工智能产业应用大会（ […]

Эксперты предупреждают о критическом риске для корпоративной безопасности.

Routers play an essential role in networking and are one of the key components that allow users to

探讨2024年医疗保健行业网络安全的主要发现及趋势

本文内容来源于Help Net Security对2024年医疗保健行业网络安全的主要发现及趋势进行了深入探讨，揭示出当前这一领域所面临的诸多状况。 构建医疗网络安全响应计划 在构建医疗保健网络安全响

A vulnerability was found in NEC WG2600HS, WF1200CR, WG1200CR, GB1200PE, WG2600HP4, WG2600HM4, WG2600HS2, WX3000HP and WX4200D5. It has been rated as critical. This issue affects some unknown processing. The manipulation leads to missing authentication. The identification of this vulnerability is CVE-2025-0355. The attack may be initiated remotely. There is no exploit available.

国际赛IrisCTF在前几天举办，遇到了一道有意思的题目，特来总结。

题目

附件如下：babyrevjohnson.tar

解题过程

关键main函数分析如下：

int __fastcall main(int argc, const char **argv, const char
 **envp)
 {
 int v4; // [rsp+4h] [rbp-7Ch]
 int v5; // [rsp+4h] [rbp-7Ch]
 int v6; // [rsp+8h] [rbp-78h]
 int v7; // [rsp+Ch] [rbp-74h]
 char input[104]; // [rsp+10h] [rbp-70h] BYREF
 unsigned __int64 v9; // [rsp+78h] [rbp-8h]
 v9 = __readfsqword(0x28u);
 puts("Welcome to the Johnson's family!");
 puts("You have gotten to know each person decently well, so let's see
 if you remember all of the facts.");
 puts("(Remember that each of the members like different things from
 each other.)");
 v4 = 0;
 while ( v4 <= 3 ) // 在提供的颜色中，选择4种
 {
 printf("Please choose %s's favorite color: ", (&names)[v4]);//
 4个人
 __isoc99_scanf("%99s", input);
 if ( !strcmp(input, colors) )
 {
 v6 = 1; // red
 goto LABEL_11;
 }
 if ( !strcmp(input, s2) )
 {
 v6 = 2; // blue
 goto LABEL_11;
 }
 if ( !strcmp(input, off_4050) )
 {
 v6 = 3; // green
 goto LABEL_11;
 }
 if ( !strcmp(input, off_4058) )
 {
 v6 = 4; // yellow
 LABEL_11:
 if ( v6 == chosenColors[0] || v6 == dword_4094 || v6 ==
 dword_4098 || v6 == dword_409C )// 选择4个颜色，然后顺序不能一样
 puts("That option was already chosen!");
 else
 chosenColors[v4++] = v6; // 存储选择的颜色（已经转换成了数字）
 }
 else
 {
 puts("Invalid color!");
 }
 }
 v5 = 0;
 while ( v5 <= 3 )
 {
 printf("Please choose %s's favorite food: ", (&names)[v5]);//
 4个人最喜欢的食物
 __isoc99_scanf("%99s", input);
 if ( !strcmp(input, foods) )
 {
 v7 = 1; // pizza
 goto LABEL_28;
 }
 if ( !strcmp(input, off_4068) )
 {
 v7 = 2; // pasta
 goto LABEL_28;
 }
 if ( !strcmp(input, off_4070) )
 {
 v7 = 3; // steak
 goto LABEL_28;
 }
 if ( !strcmp(input, off_4078) )
 {
 v7 = 4; // chicken
 LABEL_28:
 if ( v7 == chosenFoods[0] || v7 == dword_40A4 || v7 == dword_40A8
 || v7 == dword_40AC )
 puts("That option was already chosen!");
 else
 chosenFoods[v5++] = v7;
 }
 else
 {
 puts("Invalid food!");
 }
 }
 check(); // 开始check，检测我们输入的颜色和食物是否正确
 return 0;

 }
 -----------------------------------------------------------------------

将check提取出来，我们方便分析

其实到这里已经可以得到结果了，国外的题目确实很讲究趣味性，用颜色和食物作为导向，引导一步一步分析

笔者使用静态分析的方法，一步一步跟踪

C++

int check()
 {
 bool v0; // dl
 _BOOL4 v1; // eax
 _BOOL4 v2; // edx
 v0 = dword_40A8 != 2 && dword_40AC != 2;
 
 v1 = v0 && dword_4094 != 1;
 v2 = chosenColors[0] != 3 && dword_4094 != 3;
 if ( !v2 || !v1 || chosenFoods[0] != 4 || dword_40AC == 3 ||
 dword_4098 == 4 || dword_409C != 2 )
 return puts("Incorrect.");
 puts("Correct!");
 return system("cat flag.txt"); // 执行cat flag的命令

 }
 -----------------------------------------------------------------------

对应的输入值地址如下：

我们将颜色color数组用x系列表示，将食物用food数组y系列表示

化简如下：

C++
 v0 = y3 != 2 && y4 != 2;
 
 v1 = v0 && x2 != 1;
 v2 = x1 != 3 && x2 != 3;
 if ( !v2 || !v1 || y1 != 4 || y4 == 3 || x3 == 4 || x4 != 2
 )
 {
 //错误
 }
 else
 {
 //成功

 }
 -----------------------------------------------------------------------

思路1:简单粗暴的爆破，但不是学习的目的，因此并不采用

思路2:锻炼写脚本能力，使用z3解题可以锻炼写脚本的能力，因此采用

Python

 from z3 import *
 
 # 创建变量
 x1, x2, x3, x4 = Ints('x1 x2 x3 x4')
 y1, y2, y3, y4 = Ints('y1 y2 y3 y4')
 
 # 创建约束条件
 v0 = And(y3 != 2, y4 != 2)
 v1 = And(v0, x2 != 1)
 v2 = And(x1 != 3, x2 != 3)
 
 # 创建条件语句
 cond = Or(Not(v2), Not(v1), y1 != 4, y4 == 3, x3 == 4, x4 != 2)
 cond1 = Not(cond)
 #正常来说，cond的值要为false的，但是z3的add添加的条件必须为1才行，因此要进行取反操作
 # 创建求解器
 solver = Solver()
 
 # 添加约束条件和条件语句到求解器
 solver.add(cond1)#这里添加的条件必须为true，所以最后使用了 not 进行取反操作
 
 # 求解
 if solver.check() == sat:
 # 如果有解，则获取解
 model = solver.model()
 
 # 打印解
 print("成功:")
 print("x1 =", model[x1])
 print("x2 =", model[x2])
 print("x3 =", model[x3])
 print("x4 =", model[x4])
 print("y1 =", model[y1])
 print("y2 =", model[y2])
 print("y3 =", model[y3])
 print("y4 =", model[y4])
 else:

 print("无解")
 ---------------------------------------------------------------------------------------

得到结果

Python

 成功:
 x1 = 4
 x2 = 0
 x3 = 5
 x4 = 2
 y1 = 4
 y2 = None
 y3 = 3

 y4 = 0
 -----------------------------------------------------------------------

其实有经验的师傅发现了，这是有多解的，因为没有为约束变量添加范围约束

改进之后的代码如下：

Python

 from z3 import *
 
 # 创建变量
 x1, x2, x3, x4 = Ints('x1 x2 x3 x4')
 y1, y2, y3, y4 = Ints('y1 y2 y3 y4')
 
 # 创建约束条件
 v0 = And(y3 != 2, y4 != 2)
 v1 = And(v0, x2 != 1)
 v2 = And(x1 != 3, x2 != 3)
 range_constraint = And(x1 >= 1, x1 <= 4, x2 >= 1, x2 <= 4, x3 >= 1, x3 <= 4, x4
 >= 1, x4 <= 4,
 y1 >= 1, y1 <= 4, y2 >= 1, y2 <= 4, y3 >= 1, y3 <= 4, y4 >= 1, y4 <= 4)
 # 创建条件语句
 cond = Or(Not(v2), Not(v1), y1 != 4, y4 == 3, x3 == 4, x4 != 2)
 cond1 = Not(cond)
 #正常来说，cond的值要为false的，但是z3的add添加的条件必须为1才行，因此要进行取反操作
 # 创建求解器
 solver = Solver()
 
 # 添加约束条件和条件语句到求解器
 solver.add(cond1)#这里添加的条件必须为true，所以最后使用了 not 进行取反操作
 solver.add(range_constraint)
 # 求解
 if solver.check() == sat:
 # 如果有解，则获取解
 model = solver.model()
 
 # 打印解
 print("成功:")
 print("x1 =", model[x1])
 print("x2 =", model[x2])
 print("x3 =", model[x3])
 print("x4 =", model[x4])
 print("y1 =", model[y1])
 print("y2 =", model[y2])
 print("y3 =", model[y3])
 print("y4 =", model[y4])
 else:

 print("无解")
 ---------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------

得到结果：

-----------------------------------------------------------------------

 Python
 成功:
 x1 = 1
 x2 = 4
 x3 = 1
 x4 = 2
 y1 = 4
 y2 = 1
 y3 = 3

 y4 = 4
 -----------------------------------------------------------------------

发现x1和x3重复了，因此还要添加值不重复约束

Python
 from z3 import *
 
 # 创建变量
 x1, x2, x3, x4 = Ints('x1 x2 x3 x4')
 y1, y2, y3, y4 = Ints('y1 y2 y3 y4')
 
 # 创建约束条件
 v0 = And(y3 != 2, y4 != 2)
 v1 = And(v0, x2 != 1)
 v2 = And(x1 != 3, x2 != 3)
 #值范围约束
 range_constraint = And(x1 >= 1, x1 <= 4, x2 >= 1, x2 <= 4, x3 >= 1, x3 <= 4, x4
 >= 1, x4 <= 4,
 y1 >= 1, y1 <= 4, y2 >= 1, y2 <= 4, y3 >= 1, y3 <= 4, y4 >= 1, y4 <= 4)
 #非重复值约束
 distinct_x=Distinct(x1,x2,x3,x4)
 distinct_y=Distinct(y1,y2,y3,y4)
 
 # 创建条件语句
 cond = Or(Not(v2), Not(v1), y1 != 4, y4 == 3, x3 == 4, x4 != 2)
 cond1 = Not(cond)
 #正常来说，cond的值要为false的，但是z3的add添加的条件必须为1才行，因此要进行取反操作
 # 创建求解器
 solver = Solver()
 
 # 添加约束条件和条件语句到求解器
 solver.add(cond1)#这里添加的条件必须为true，所以最后使用了 not 进行取反操作
 solver.add(range_constraint)
 solver.add(distinct_y)
 solver.add(distinct_x)
 # 求解
 if solver.check() == sat:
 # 如果有解，则获取解
 model = solver.model()
 
 # 打印解
 print("成功:")
 print("x1 =", model[x1])
 print("x2 =", model[x2])
 print("x3 =", model[x3])
 print("x4 =", model[x4])
 print("y1 =", model[y1])
 print("y2 =", model[y2])
 print("y3 =", model[y3])
 print("y4 =", model[y4])
 else:

 print("无解")
 ---------------------------------------------------------------------------------------

最终得到正确的结果

Python 成功: x1 = 1 x2 = 4 x3 = 3 x4 = 2 y1 = 4 y2 = 2 y3 = 3

y4 = 1

x1-x4= 1 4 3 2

y1-y4= 4 2 3 1

按照这样的顺序输入即可：

得到了flag

irisctf{m0r3_th4n_0n3_l0g1c_puzzl3_h3r3}

总结

题目并不是很难，没有复杂的ollvm混淆也没有复杂的加密。但是却一步一步引导我们去学习和总结。z3解题的过程中，会有很多误解，然后经过自己的思考总结，发现了漏掉的东西，再进行补充，最终写出正确的脚本。

国外的题还是很值得学习的，不单单为了出题而出题。这就是逻辑运算在z3的运用以及如何增加约束，让z3求解出我们需要的key。

  

国际赛IrisCTF在前几天举办，遇到了一道有意思的题目，特来总结。题目附件如下：babyrevjohnson.tar解题过程关键main函数分析如下：int __fast

前言

热补丁的钩取方式是为了解决内联钩取在多线程情况下会出错的情况，使用热补丁的钩取可以避免重复读写指令造成问题。

内联钩取潜在问题

正常情况下，在每次跳转到自定义函数时需要将原始的指令（mov edi，edi）写回CreateProcessW函数内，为了后续正确调用CreateProcesW函数，在调用完毕之后，又需要进行挂钩的处理，即将mov指令修改为jmp指令。

但是在多线程的情况下就可能会出现下列问题，在进行mov指令篡改时可能会发生线程的切换，因为篡改指令的操作不是原子操作。那么在线程2时可能调用了CreateProcessW函数时可能跳转指令还没写完成，例如下图的jmp 0x12xx，而不是原本的jmp 0x1234就导致了执行出错。

为了解决此问题采用了热补丁钩取。

热补丁钩取

热补丁是指在不中断系统运行进行应用。即不中断程序运行也能够修改系统库或程序中的执行逻辑。

这里以CreateProcessW为例子

在windbg中使用以下指令在CreateProcessW函数中打下断点

.reload /f
bp CreateProcessW

可以看到CreateProcessW函数入口点是mov edi，edi指令，而在该指令上方有一段没用用到的空间，在windbg中使用int 3指令填充了。

而mov edi，edi指令本身没有实际意义，这就是微软在系统库预留的空间，用于打上热补丁。因为这个指令无论被修改成什么都不会影响程序的执行。

接着可以发现这跳指令的长度为2字节，因此可以使用任意的2字节长的指令替换mov edi，edi。

那么这里就需要寻找可以完成跳转的指令，并且仅占用2字节完成对mov指令的替换。

在汇编中存在着短跳转指令可以完成跳转并且仅占用2字节，用以下例子来观察一下短跳转的指令。

int main()
{
   // 使用标签作为跳转目标
   __asm {
       jmp short label;
   };

   // 标签处定义跳转目标
label:
   // 这里是跳转目标后的代码
   return 0;
}

可以看到在跳转到标签label上时，采用的跳转指令机器码是EB开头的，而不是E9，并且指令长度也只有2字节。

那么00是跳转的偏移值，根据该例子分析一下跳转偏移的计算

跳转偏移 = 目标地址 - 当前地址 - 当前指令的长度
00      = 00731005 - 00731003 - 2

可以看到计算偏移的公式与jmp指令一致，只是跳转的指令的长度为5字节，而短跳转的指令长度为2字节，因此jmp指令也被称之为长跳转。

那么怎么配合短跳转进行一个钩取操作，如下图。我们可以借助短跳转使得指令执行到上述填充的区域，然后再使用jmp指令完成钩取的操作。这里需要注意的是空闲区域的空间大小需要大于5个字节，不然无法容纳jmp指令。

最终修改后钩取的效果如下图，在自定义函数中不在需要钩取与脱钩的操作，因为我们修改的指令不会影响正常的CreateProcessW函数执行。那么在既然不存在写操作，那么在多线程中也不会因为条件竞争导致还没写完就切换线程的情况。

那么代码实现部分如下，这里需要注意长跳转的指令0xE9，短跳转的指令为0xEB，这里先把偏移计算好了0xF9，因此写好了，但是这个偏移值不是唯一值，只要找到的地址存在大于5字节的空闲区域都是可以的。紧接着就是修改函数内部的指令，将初始的指令修改为短跳转，然后再空闲区中填充长跳转即可。

...
   //长跳转指令
   BYTE pBuf[5] = { 0xE9, 0 };
   //短跳转指令 + 偏移值
   BYTE pShortJmp[2] = { 0xEB, 0xF9};
   //获取模块地址
   HMODULE hModule = GetModuleHandleA(szDllName);
   //获取函数地址
   FARPROC pfnOld = GetProcAddress(hModule, szFuncName);
   //选中长跳转指令填充的地址，这里选择恰好能容纳jmp指令的位置
   DWORD target = (DWORD)pfnOld - 5;
   //计算跳转的偏移
   DWORD dwAddress =  (DWORD)pfnNew - target - 5;
   //修改区域的权限
   VirtualProtect((LPVOID)target, 7, PAGE_EXECUTE_READWRITE, &dwOldProtect);
   //将偏移填充到指令中
   memcpy(&pBuf[1], &dwAddress, 4);
   //将长跳转指令填充
   memcpy((LPVOID)target, pBuf, 5);
   //保存原始的两个字节
   memcpy(pOldBytes, pfnOld, 2);
   //将短跳转指令填充
   memcpy(pfnOld, pShortJmp, 2);
   VirtualProtect((LPVOID)target, 7, dwOldProtect, &dwOldProtect);
...

在自定义函数中，只需要直接调用CreatePorcessW + 2的指令就可以完成原始CreateProcessW函数，不再需要挂钩脱钩的处理。

...
   //调用CreateProcessW + 2
   BOOL ret = ((LPFN_CreateProcessW)((DWORD)pfnOld + 2))(
       applicationName,
       lpCommandLine,
       lpProcessAttributes,
       lpThreadAttributes,
       bInheritHandles,
       dwCreationFlags,
       lpEnvironment,
       lpCurrentDirectory,
       lpStartupInfo,
       lpProcessInformation
       );
...

完整代码：

https://github.com/h0pe-ay/HookTechnology/tree/main/Hook-HotPatch

总结

优点：避免多线程出错

缺点：不一定有热补丁的条件，就是不一定存在有垃圾指令

如64位程序的CreateProcessW函数的第一条指令是mov r11，rsp，但是后续的指令都需要用到r11寄存器的值，因此该指令不是无用指令。就不能上述热补丁的方法。