3. Dans VS Code : Fichier -> **Ouvrir un espace de travail à partir d'un fichier...** `vscode-codeql-starter.code-workspace`
4. Continuez avec [Sélection d'une base de données CodeQL](#select-codeql-database)
5. Ensuite [Testez votre installation](#test-your-installation)

### Option B : GitHub Codespace

Utilisez un Codespace GitHub à distance pour travailler sur les exercices de l'atelier.

#### Prérequis

* Compte GitHub ([inscription gratuite](https://github.com/)) 
* Navigateur (vous pouvez suivre tout l'atelier dans un navigateur - c'est la configuration la plus rapide) ou [Visual Studio Code](https://code.visualstudio.com/download) (VS Code) avec l'extension [GitHub Codespaces](https://marketplace.visualstudio.com/items?itemName=GitHub.codespaces) installée sur votre machine locale.

Remarque : Les 120 premières heures par cœur d'utilisation de Codespace sont gratuites par mois. Nous utilisons un Codespace avec 4 cœurs pour cet atelier car 4 cœurs est le maximum actuel pour les comptes gratuits. (Si vous avez un compte Pro, nous vous recommandons de passer à une machine à 8 cœurs.)

#### Instructions

1. Connectez-vous à votre compte [GitHub](https://github.com/login)
2. Allez sur le dépôt https://github.com/sylwia-budzynska/codeql-workshop
3. Cliquez sur Code -> Codespaces
4. Cliquez sur le signe plus (+) pour créer un nouveau Codespace.

<img src="https://assets.kitploit.com/production/public/readmes/33098/c86e537f9e7891fb6bdb5da727cae5b6ad0b2c9ac94f67854d48296f2dad89cb.png"  width="439" alt="Capture d'écran : Créez un Codespace, cliquez sur plus">

VS Code démarrera dans votre navigateur et un Codespace distant sera construit. Cela peut prendre quelques minutes.
Si on vous demande d'ouvrir l'espace de travail `vscode-codeql-starter.code-workspace`, cliquez sur « Ouvrir l'espace de travail ».

5. Si vous souhaitez utiliser VS Code localement, appuyez sur le bouton à trois lignes dans le coin supérieur gauche et sélectionnez « Ouvrir VS Code Desktop ». L'option peut prendre jusqu'à quelques minutes pour apparaître.

<img src="https://assets.kitploit.com/production/public/readmes/33098/f2c8c2fe6da80142344b17c208da31a23c3fa68a3917a124f0e2f7871b6a20f7.png" width="300" alt="Capture d'écran : Appuyez sur le bouton à trois lignes et Ouvrir dans VS Code Desktop">

6. Continuez avec [Sélection d'une base de données CodeQL](#select-codeql-database)
7. Ensuite [Testez votre installation](#test-your-installation)

Vous pouvez voir vos Codespaces sur [github.com/codespaces](https://github.com/codespaces). Le Codespace s'éteindra automatiquement après quelques heures d'inactivité, mais pour vous assurer de ne pas utiliser d'heures supplémentaires des 120h gratuites, n'oubliez pas d'aller sur [github.com/codespaces](https://github.com/codespaces) > trois points > « Arrêter le Codespace » après l'atelier.

#### Dépannage de l'installation

Si vous voyez des erreurs telles que :
* `Failed to run query: Could not resolve library path for [..]`
* `Could not resolve module [..]`
* `Could not resolve type [..]`

Il est très probable que vous ayez oublié de cloner les sous-modules git (notamment le dépôt ql). Pour résoudre ce problème, exécutez `git submodule init && git submodule update --recursive`.

### Sélectionner une base de données CodeQL

1. Assurez-vous d'avoir l'espace de travail `vscode-codeql-starter.code-workspace` ouvert dans VS Code.
2. Cliquez sur l'icône « QL » dans le volet des onglets de gauche pour accéder à la vue CodeQL.
3. Cliquez sur « Choisir une base de données à partir d'une archive » et sélectionnez le fichier `test-app-db.zip` à la racine du dépôt.
   Remarque : À ce stade, vous pouvez rencontrer une erreur dans VSCode avec un message contextuel demandant d'installer le CLI CodeQL. Accepter cette installation devrait résoudre le problème. Une fois l'installation du CLI terminée, vous devriez pouvoir terminer la sélection de la base de données ci-dessus.
   <img src="https://assets.kitploit.com/production/public/readmes/33098/65cc5790b8b49113623bc9a9b34a1be61575b05bea2428c46f83115e2271148b.png"  alt="Capture d'écran : Message d'erreur VSCode concernant CodeQL">
   <img src="https://assets.kitploit.com/production/public/readmes/33098/c3bf9c304d9c1f6199f591c9bcbf6e446ee4f5388ab209e30887326698129f84.png"  alt="Capture d'écran : Installation du CLI CodeQL par VSCode">

### Testez votre installation

#### Prérequis

Assurez-vous que la base de données CodeQL précédemment choisie est sélectionnée dans la vue CodeQL. (Cliquez sur « Sélectionner » si ce n'est pas le cas)

Lorsque la base de données est sélectionnée, elle devrait ressembler à ceci (notez la coche) :

<img src="https://assets.kitploit.com/production/public/readmes/33098/fee6e47c0d9b0754c7ac9e29e2f0b3a721093aa5ce882615b3839a99f4862506.png"  alt="Capture d'écran : Base de données CodeQL sélectionnée">

#### Instructions

1. Dans VS Code : allez dans le dossier de l'espace de travail : `codeql-custom-queries-python`
2. Créez un nouveau fichier `test.ql`
3. ajoutez le contenu suivant : `select "Hello World!"`
4. Enregistrez le fichier, faites un clic droit dans la zone du fichier et choisissez « CodeQL : Exécuter la requête sur la base de données sélectionnée »
5. Vous devriez voir un nouvel onglet s'ouvrir avec le résultat « Hello World! »

## :books: Ressources

- [Tutoriels QL](https://codeql.github.com/docs/writing-codeql-queries/ql-tutorials/)
- [Guide du langage CodeQL pour Python](https://codeql.github.com/docs/codeql-language-guides/codeql-for-python/)
- [Documentation CodeQL](https://codeql.github.com/docs/)
- [Référence du langage QL](https://codeql.github.com/docs/ql-language-reference/)
- [Bibliothèque CodeQL pour Python](https://codeql.github.com/codeql-standard-libraries/python/)
- [Requête de base pour le code Python](https://codeql.github.com/docs/codeql-language-guides/basic-query-for-python-code/)
- [Classes QL](https://codeql.github.com/docs/ql-language-reference/types/#classes)
- [CodeQL de zéro à héros partie 1 : les fondamentaux de l'analyse statique pour la recherche de vulnérabilités](https://github.blog/2023-03-31-codeql-zero-to-hero-part-1-the-fundamentals-of-static-analysis-for-vulnerability-research/)
- [CodeQL de zéro à héros partie 2 : démarrer avec CodeQL](https://github.blog/2023-06-15-codeql-zero-to-hero-part-2-getting-started-with-codeql/)
- [CodeQL de zéro à héros partie 3 : recherche en sécurité](https://github.blog/2024-04-29-codeql-zero-to-hero-part-3-security-research-with-codeql/)
- [CodeQL de zéro à héros partie 4 : étude de cas Gradio](https://github.blog/security/vulnerability-research/codeql-zero-to-hero-part-4-gradio-framework-case-study/)
- [CodeQL de zéro à héros partie 5 : débogage de requêtes](https://github.blog/security/vulnerability-research/codeql-zero-to-hero-part-5-debugging-queries/)

## Atelier

Bienvenue à l'atelier « Trouver des vulnérabilités avec CodeQL » !

Cette session présentera les fondamentaux de la recherche en sécurité et de l'analyse statique utilisés lors de la recherche de vulnérabilités dans les logiciels. Nous utiliserons un exemple de vulnérabilité simple, passerons en revue comment CodeQL pourrait la détecter, et fournirons des exemples sur la façon dont le public pourrait utiliser CodeQL pour trouver lui-même des vulnérabilités.

Avant de commencer, il est important que tous les prérequis soient remplis afin que vous puissiez participer à l'atelier.

L'atelier est divisé en plusieurs sections et chaque section se compose d'exercices qui mènent à la requête finale.

Pour chaque section, nous fournissons des *directives* qui vous aident à terminer l'exercice en vous donnant des références aux classes QL et aux prédicats membres que vous pouvez utiliser.

### Aperçu

Dans cet atelier, nous rechercherons des *vulnérabilités d'injection de commandes* connues dans [kohya_ss](https://securitylab.github.com/advisories/GHSL-2024-019_GHSL-2024-024_kohya_ss/). De telles vulnérabilités peuvent se produire lorsque des informations contrôlées par un utilisateur parviennent à un code d'application qui construit et exécute une commande de manière non sécurisée. La commande construite de manière non sécurisée à partir d'une entrée utilisateur peut être réécrite pour effectuer des actions non intentionnelles telles que l'exécution de commandes arbitraires ou la divulgation d'informations sensibles.

Les injections de commandes discutées dans cet atelier sont [CVE-2024-32022, CVE-2024-32026, CVE-2024-32025, CVE-2024-32027](https://securitylab.github.com/advisories/GHSL-2024-019_GHSL-2024-024_kohya_ss/).

## Théorie

### Sources et puits

Pensez à l'une des vulnérabilités les plus connues : l'injection de commandes. Cela se produit si une entrée utilisateur est utilisée dans des fonctions qui permettent d'exécuter des commandes dans un shell directement sur le serveur. Cela permet à un attaquant d'exécuter des commandes du système d'exploitation (OS) sur le serveur qui exécute une application, et généralement de compromettre totalement l'application et ses données.

La principale cause des vulnérabilités d'injection est l'utilisation d'entrées non fiables contrôlées par l'utilisateur dans des fonctions sensibles ou dangereuses du programme. Pour représenter cela en analyse statique, nous utilisons des termes tels que flux de données, sources et puits.

L'entrée utilisateur provient généralement des points d'entrée d'une application—l'origine des données. Cela inclut les paramètres dans les méthodes HTTP, telles que GET et POST, ou les arguments de ligne de commande d'un programme. Ceux-ci sont appelés « **sources** ».

En continuant avec notre injection de commandes, un exemple d'une fonction dangereuse qui ne devrait pas être appelée avec des données non fiables non assainies pourrait être `os.system`. Ces fonctions dangereuses sont appelées « **puits** ». Notez que ce n'est pas parce qu'une fonction est potentiellement dangereuse qu'elle constitue immédiatement une vulnérabilité exploitable et qu'elle doit être supprimée. De nombreux puits ont des moyens de les utiliser en toute sécurité. D'autres exemples de puits, qui ne devraient pas être utilisés avec des entrées utilisateur, sont MySQLCursor.execute() de la bibliothèque MySQLdb en Python (provoquant une injection SQL) ou la fonction intégrée eval() de Python qui évalue des expressions arbitraires (provoquant une injection de code).

Pour qu'une vulnérabilité soit présente, l'entrée non sécurisée contrôlée par l'utilisateur doit être utilisée sans désinfection ou validation appropriée dans une fonction dangereuse. En d'autres termes, il doit y avoir un chemin de code entre la source et le puits, auquel cas nous disons que les données circulent d'une source vers un puits—il y a un « **flux de données** » de la source au puits.

<img src="https://assets.kitploit.com/production/public/readmes/33098/ff60a1649737805a71bd27710209dba66203a77159cc72ae435c165353e56491.png">

### Aide-mémoire CodeQL
La structure de requête de base```codeql
import python

from <type> <name> 		//variables used in the query

where <conditions for variables>

select <output>			//results, referring to the variables

Trouver les références aux appels à `os.system()`, cette fois avec un prédicat```codeql
predicate isOsSystemSink(API::CallNode call) {
	call = API::moduleImport("os")
	.getMember("system").getACall()
  }


from API::CallNode call
where isOsSystemSink(call)
select call, "Call to os.system"

Rechercher les références aux appels `os.system()`, cette fois avec une classe.
Spécifiez que le type avec lequel nous commençons est `OsSystemSink````codeql
class OsSystemSink extends API::CallNode {
  OsSystemSink() {
    this = API::moduleImport("os")
    .getMember("system").getACall()
	}
}


from OsSystemSink s
select s, "Call to os.system"

btn = gr.Button("Run")
btn.click(fn=execute_cmd, inputs=[folder]) #2

Vous remarquerez également un autre exemple d'injection de commande dans l'atelier, dans une application créée à l'aide du framework `Flask`. Dans ce cas, l'entrée utilisateur provient d'un paramètre GET d'une requête Flask (framework web populaire en Python), qui est stocké dans la variable `files` (voir #1). `files` est ensuite passé à l'appel `os.system` et concaténé avec `ls`, ce qui entraîne une injection de commande (voir #2).```python
import os
from flask import Flask, request

app = Flask(__name__)

@app.route("/command1")
def command_injection1():
    files = request.args.get('files', '')   #1
    os.system("ls " + files)                #2

Faites un clic droit dans la zone de fichiers et choisissez "CodeQL: Run Query on Selected Database" pour exécuter la requête.

<details>
<summary>Directives</summary>

- Dans la clause `from`, commencez par `API::` et appuyez sur `Ctrl + Espace` pour voir les types disponibles dans le module API Graphs.
- Un appel est représenté par le type `API::CallNode`. Créez une variable avec ce type et le nom `call`.
- Pour limiter les résultats uniquement aux appels dans le dossier racine de l'application (appelée `test-app`), ajoutez une clause ` where` avec la condition `where call.getLocation().getFile().getRelativePath().regexpMatch("test-app/.*")`.

</details>
<details>
<summary>Solution</summary>```codeql
import python
import semmle.python.ApiGraphs

from API::CallNode call
where call.getLocation().getFile().getRelativePath().regexpMatch("test-app/.*")
select call, "A call"

</details>
<details>
<summary>Solution</summary>```codeql
/**
 * @name Command injection in os.system sink
 * @kind path-problem
 * @id codeql-ws/dataflow-query
 */

import python
import semmle.python.dataflow.new.DataFlow
import semmle.python.dataflow.new.TaintTracking
import semmle.python.ApiGraphs
import semmle.python.dataflow.new.RemoteFlowSources
import MyFlow::PathGraph

class OsSystemSink extends API::CallNode {
	OsSystemSink() {
		this = API::moduleImport("os").getMember("system").getACall()
	}
}

private module MyConfig implements DataFlow::ConfigSig {
predicate isSource(DataFlow::Node source) {
	source instanceof RemoteFlowSource
}

predicate isSink(DataFlow::Node sink) {
	exists(OsSystemSink call |
	sink = call.getArg(0)
	)
}
}

module MyFlow = TaintTracking::Global<MyConfig>;

from MyFlow::PathNode source, MyFlow::PathNode sink
where MyFlow::flowPath(source, sink)
select sink.getNode(), source, sink, "Command injection"