ciscn2023-ezbyte

最新推荐文章于 2024-06-10 18:20:56 发布
最新推荐文章于 2024-06-10 18:20:56 发布
阅读量309 收藏
点赞数
文章标签： rust 网络安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41853048/article/details/130939115
版权

啊，做了一天牢，师傅们都出了，就我只能等wp😭

文件类型

64位elf文件

反编译

很奇怪，看不到主加密函数，只能跟到flag{…6813}就断了，后面的代码完全看不懂了，看wp所使用到了栈回溯，中间有地方抛出了异常，在回溯过程中用到了Dwarf expression对寄存器进行了更改也就是R12寄存器
在这里插入图片描述
xor r13 r13
cmp r12 r13
只有当r12为0时才会跳入yes模块
在此之前，由于x64没有采用传统的方法记录堆栈信息，而是通过.eh_frame段保存了栈寄存器等信息，我们需要读取这个段的信息进行还原栈回溯时对R12的操作

读取段信息

readelf -Wwf ezbyte >a.txt #W表示每行以特定字符输出，wf按CFA语法输出.eh_frame内容
在这里插入图片描述

  • FDE代表某个函数的记录
  • CIE代表一个文件，CIE下有多个FDE
  • PS函数的起点和终点
    分析函数，加密验证区域出现在flag{…381}这个地方
    在这里插入图片描述
    也就是这里不过我们直接利用rust字节码脚本还原用不到这个，本来用的python的方法，结果没找到解析器源码
rust和Cargo安装

curl --proto ‘=https’ --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env #应用环境变量
rustc --version #验证
sudo apt install cargo
给cargo换源:
vi ~/.cargo/config
[source.crates-io] registry = "https://github.com/rust-lang/crates.io-index" replace-with = 'ustc' [source.ustc] registry = "git://mirrors.ustc.edu.cn/crates.io-index"
安装完成

反编译

建立Cargo.toml文件与解析器analysis.rs

[package]
name = "analysis"
version = "0.1.0"
edition = "2021"

[dependencies]
gimli = "0.26.1"
object = "0.29.0"

[[bin]]
name = "analysis"
path = "analysis.rs"

// [dependencies]
// gimli = "0.26.1"
// object = "0.29.0"

use std::{collections::HashMap, fs, fmt::Display, io::Write};
use std::process::Command;

use gimli::UnwindSection;
use object::{Object, ObjectSection};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut arg = std::env::args();
    if arg.len() != 2 {
        panic!("Argument Error!")
    }
    let bin_data = fs::read(arg.nth(1).unwrap())?;
    let obj_file = object::File::parse(&*bin_data)?;
    let data = obj_file.section_by_name(".eh_frame").unwrap();
    let eh_frame = gimli::read::EhFrame::new(data.data()?, gimli::LittleEndian);
    let bases = gimli::BaseAddresses::default().set_eh_frame(data.address());
    let mut entries = eh_frame.entries(&bases);

    let mut file = fs::OpenOptions::new().append(false).truncate(true).write(true).create(true).open("./output.c")?;
    writeln!(file, "#include <stdint.h>")?;


    let mut cies = HashMap::new();
    while let Some(entry) = entries.next()? {
        if let gimli::CieOrFde::Fde(partial) = entry {
            let fde = partial.parse(|_, bases, o| {
                cies.entry(o)
                    .or_insert_with(|| eh_frame.cie_from_offset(bases, o))
                    .clone()
            })?;
            // 通过长度过滤出我们想要的
            if fde.entry_len() < 100 {
                continue;
            }
            let mut instructions = fde.instructions(&eh_frame, &bases);
            use gimli::CallFrameInstruction::*;
            loop {
                match instructions.next() {
                    Err(e) => {
                        println!("Failed to decode CFI instruction: {}", e);
                        break;
                    }
                    Ok(Some(ValExpression {
                                register,
                                expression,
                            })) => {
                        println!(
                            "DW_CFA_val_expression ({}, ...)",
                            gimli::X86_64::register_name(register).unwrap_or("{unknown}")
                        );
                        display_val_expression(register, expression, &mut file)?;
                    }
                    Ok(None) => {
                        break;
                    }

                    _ => {}
                }
            }
        }
    }
    file.flush()?;

    Command::new("gcc")
        .arg("-O3")
        .arg("./output.c")
        .arg("-c")
        .spawn()?;

    Ok(())
}

#[derive(Clone, Copy)]
struct Val {
    id: u64,
}

impl Val {
    fn new(id: u64) -> Self {
        Val { id }
    }
}

struct ValGenerator {
    id: u64,
}

impl ValGenerator {
    fn new() -> Self {
        Self { id: 0 }
    }
    fn next(&mut self) -> Val {
        self.id += 1;
        Val::new(self.id - 1)
    }
}

impl Display for Val {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "v{}", self.id)
    }
}

fn display_val_expression<R>(target_reg: gimli::Register, exp: gimli::Expression<R>, w: &mut dyn Write) -> Result<(), Box<dyn std::error::Error>>
    where
        R: gimli::Reader,
{
    let mut val_generator = ValGenerator::new();
    let mut ops = exp.operations(gimli::Encoding { address_size: 8, format: gimli::Format::Dwarf64, version: 5 });
    let mut stack: Vec<Val> = Vec::new();
    writeln!(w, "uint64_t cal_{}(uint64_t r12, uint64_t r13, uint64_t r14, uint64_t r15){{", gimli::X86_64::register_name(target_reg).unwrap())?;
    writeln!(w, "    uint64_t rax=0,rbx=0;")?;
    loop {
        if let Ok(Some(op)) = ops.next() {
            match op {
                gimli::Operation::Drop => {
                    stack.pop();
                }
                gimli::Operation::Pick { index } => {
                    let val1 = stack.get(stack.len() - 1 - index as usize).unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={};", new_val, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Swap => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    stack.push(val1);
                    stack.push(val2);
                }
                gimli::Operation::Rot => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let val3 = stack.pop().unwrap();
                    stack.push(val1);
                    stack.push(val3);
                    stack.push(val2);
                }
                gimli::Operation::And => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}&{};", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Minus => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}-{};", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Neg => {
                    let val = stack.get(stack.len() - 1).unwrap();
                    writeln!(w, "    {}=-{};", val, val)?;
                }
                gimli::Operation::Not => {
                    let val = stack.get(stack.len() - 1).unwrap();
                    writeln!(w, "    {}=~{};", val, val)?;
                }
                gimli::Operation::Or => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}|{};", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Plus => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}+{};", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::PlusConstant { value } => {
                    let val = stack.get(stack.len() - 1).unwrap();
                    writeln!(w, "    {}+={}ull;", val, value)?;
                }
                gimli::Operation::Shl => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}<<{};", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Shr => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}>>{};", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Shra => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}=(uint64_t)((int64_t){}>>(int64_t){});", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Xor => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}^{};", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Eq => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}= {}=={}?1:0;", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Ge => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}>={}?1:0;", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Gt => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}>{}?1:0;", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Le => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}<={}?1:0;", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Lt => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}<{}?1:0;", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::Ne => {
                    let val1 = stack.pop().unwrap();
                    let val2 = stack.pop().unwrap();
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}!={}?1:0;", new_val, val2, val1)?;
                    stack.push(new_val);
                }
                gimli::Operation::UnsignedConstant { value } => {
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={}ull;", new_val, value)?;
                    stack.push(new_val);
                }
                gimli::Operation::SignedConstant { value } => {
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}=(uint64_t){}ll;", new_val, value)?;
                    stack.push(new_val);
                }
               gimli::Operation::RegisterOffset { register, offset, base_type} => {
                    let new_val = val_generator.next();
                    writeln!(w, "    uint64_t {}={};", new_val, gimli::X86_64::register_name(register).unwrap_or("{error}"))?;
                    stack.push(new_val);
                }
   
                _ => todo!("{:?}", op)
                
            }
        } else {
            break;
        }
    }
    assert_eq!(stack.len(), 1);
    writeln!(w, "    return {};", stack.pop().unwrap())?;
    writeln!(w, "}}\n")?;
    Ok(())
}
  • cargo build
  • cargo run – ./ezbyte_patch
    可以得到以下文件，函数保留在output.o文件下
    在这里插入图片描述

wp

#include"stdio.h"
//#define a1{a5,a2,a3,a4}
int main(){
	long long a[4];
    a[0] =0x35626665394D17E8LL -1892739;
	a[1] =0x65342D6530C04912LL -8971237;
	a[2] =0x2D393663614447B1LL -1512312;
	a[3] =0x6336396431BE9AD9LL -9123704;
	for(int i=0;i<4;i++){
		for(int j=0;j<8;j++){
		     putchar((a[i]>>j*8)&0xff);
		}
	}

	return 0;
}
//e609efb5-e70e-4e94-ac69-ac31d96c
__int64 __fastcall cal_r12(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
  return (a1 + 1892739) ^ 0x35626665394D17E8LL | (a2 + 8971237) ^ 0x65342D6530C04912LL | (a4 + 9123704) ^ 0x6336396431BE9AD9LL | (a3 + 1512312) ^ 0x2D393663614447B1LL;
}

flag{e609efb5-e70e-4e94-ac69-ac31d96c}

参考链接：
https://mdnice.com/writing/dae27f3c9b584d34b156fbf1a392ad85
https://blog.csdn.net/zhuliliang/article/details/114976890

WowOnWall
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2023全国大学生信息安全竞赛(ciscn)初赛题解
返璞归真的博客
05-28 1万+
2023全国大学生信息安全竞赛(ciscn)部分题解
cisco xrv-k9-6.6.3
04-14
cisco xrv-k9-6.6.3 加载到EVE可使用。亲测有效，用户名/密码：admin/admin 加载方法参考：https://blog.csdn.net/qq_33681684/article/details/118671946 路由协议，mpls，SR等功能都可以支持。
2023 CTF国赛初赛（CISCN） re- ez_byte
qq_54894802的博客
05-30 1466
我们跳到数据区，发现这个100%下面的，yes并没有在string窗口出现，我们按下x查询交叉引用，在执行yes之前，有个jmp指令，也就是说，按照程序执行是永远不好去到yes的地方的，也就是说，一定有什么操作，然后再跳到yes中去。在前面，我们分析了，对r12的操作，并没有直接出现在代码上，操作代码被隐藏了。为此，我们可以大致猜测就是运行程序，触发一个异常，然后通过此条转到想要操作的地方，进行操作，通过题目描述，应该就是嵌入了一堆字节码。我们查看判断跳入，yes的汇编，我们可以发现，
[CISCN 2023 初赛]ezbyte
于高山之巅，方见大河奔涌；于群峰之上，更觉长风浩荡。
11-18 634
实际着这个关键的操作r12的加密逻辑，是藏在异常处理机制的栈展开过程中的dwarf字节码。xor r13，r13说明r13是0，但是找不到r12的操作代码。看上面的代码，要想跳转到含有yes这一块，需要r13等于r12。从字符串找到%100s，发现下面有个yes。使用这个命令得到ELF文件的信息。找到这段dwarf字节码。yes之前有个jmp。结合官方文档理解意思。
CISCN2023 初赛部分复现
最新发布
Pisces50002的博客
06-10 1002
不知道怎么看出来的，这里使用了DWARF Expression将代码隐藏在栈展开过程中，在异常处理中恢复隐藏代码。然后有两种分析方法，一种就是根据DWARF的语法手撕字节码，另一种就是借助rust编写的解释器（来自。输入错误的flag就会返回相同的内容，然后卡在一个循环里等待输入，再次输错就退出了。可以直接看见伪代码方程，可以z3爆，或者跟上面一样算，脚本都差不多。不知道是不是我的问题，这个爆破非常慢（比hook慢多了），不太推荐。参考的这一篇wp的方法，hook脚本很复杂，我也不太懂。
2023ciscn初赛 -- BackendService
qq_44640313的博客
06-03 891
CVE-2022-22947的漏洞和nacos存在鉴权漏洞
2023CISCN—华中赛区—pwn wp
m0_63437215的博客
07-13 1209
ciscn2023华中赛区pwn
CISCN2023国赛复现
wwwwyyyrre的博客
07-19 252
下载附件打开 他的题目叫modbus modbus是一种协议在这些流量里都找不到有用信息，但是发现了有tcp的追踪流 打开看看发现两个一组的这几行数字组合像是base编码放到base家族解一下密最后在base32解出flag NSSCTF{c1f_fi1g_1000}
Getting-started-with-Cisco-SD-WAN-REST-APIs:思科SD-WAN REST API入门
05-03
思科SD-WAN REST API入门 思科SD-WAN解决方案（又名Viptela）是一种云交付的覆盖WAN架构，可促进企业的数字和云转换。 它大大降低了WAN成本和部署新服务的时间。 思科SD-WAN建立了强大的安全架构，这对于混合网络至...
cisco sr-te policy pcep
04-17
cisco sr-te policy pcep 思科 sr-te policy pcep方式建立动态路径。 配置说明： https://blog.csdn.net/qq_33681684/article/details/124229457
Cisco AIR-SAP1602i设置手册
12-19
Cisco AIR-SAP1602i设置手册，可以帮助了解Cisco AIR-SAP1602i 无线AP及其设置相关问题
cisco sr-te policy explicit
04-14
cisco sr-te policy explicit 思科 sr-te policy 显性路径配置。 配置说明：https://blog.csdn.net/qq_33681684/article/details/123934431
【CTF】2023Ciscn WEB方向题解
Sapphire037的博客
05-29 2388
比赛体验一般，一黑灯基本上题都烂掉。
ciscn2023-web 总结与思考
m0_64348326的博客
05-29 479
1.一开始本以为是一个简单的dump界面的命令注入，因为猜测源语句可能是先执行命令读取创建日志信息，然后file_get_contents写入/log/目录中。所以一开始就在读取的table_2_dump参数中进行fuzz，发现很多能用来执行命令的符号，例如反引号、$、|、;均被过滤了，不过尝试换行符成功了，于是尝试执行env成功在环境变量中找到了flag。2.赛后才知道这是非预期解，预期是。官方文档中说明了这是一个备份程序，在shell中可以执行备份操作，安装的mysqldump就是链接到该程序中的。
2023 ciscn国赛pwn lojin wp
cainiao78777的博客
05-29 2384
第一次参加国赛，被队友带飞了，pwn只做出来了四个，1381分，第16名，总体来说还可以在所有题目中，也是拿到了pwn题login的一血话说回来，来详细说一下，这个pwn题的解法首先就是能看到这是个没附件的pwn题说明只能通过交互去得到信息，再寻找方向，连接之后应该就是这四个选项。
2023CISCN初赛
这个人很懒，什么都懒得写
06-04 970
随便写写
CISCN 2023 初赛 pwn——Shellwego 题解
CoLin的pwn小屋
05-28 1860
CISCN 2023 初赛 pwn Shellwego题解
CISCN2023 badkey1&badkey2
qq_41626232的博客
05-29 877
这里只有n,e,d，没有p,q所以会跳到下面的else。再对生成的q，依次每个素数进行二次剩余判断是否等于上述由p生成的结果。后面使用while循环生成q的同时爆破a，对于a爆破（0,e)就好。p是给定的，使用可以先计算15个素数在模p的二次剩余和二次非剩余。查看当前生成的碰撞字典长度为10的个数，这里有2万个就足够了。即对每个数，有1/2的可能满足，所有2到50一共15个素数。源码分解取的g是2到100间的偶数。生成3000个也有大概10%的概率找到一个q。这样写肯定是不行的，可以先本地生成。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值