Sono ben cinque le vulnerabilità sfruttate dal developer e hacker TheFlow e che una volta concatenate permetterebbero ad un malintenzionato di acquisire capacità JIT ed eseguire payload arbitrari.

Questo almeno quanto evidenziato su HackerOne, il payload fornito andrebbe ad attivare un buffer overflow che provocherebbe un kernel panic.

L’exploit permetterebbe ad un certo punto di eseguire giochi piratati masterizzati su dischi Blu-Ray, basta dunque caricare la catena di exploit da un’immagine .iso (vulnerabilità 1~4) ed iniettare il payload .bin che andrebbe ad attivare la vulnerabilità 5.

Una piccola premessa, e che purtroppo chi ha scelto di acquistare una console PlayStation 5 Digital Edition non avrà modo di attivare l’exploit.

Vulnerabilità

Vulnerabilità 1 [MEDIA][PS4] [PS5]

La classe com.sony.gemstack.org.dvb.user.UserPreferenceManagerImpl deserializza il file userprefs in un contesto privilegiato utilizzando readObject() che non è sicuro:

 private void initPreferences() {
      try {
          UserPreferenceManagerImpl.preferences = AccessController.doPrivileged((PrivilegedExceptionAction<String[][]>)new ReadPreferenceAction());
      }
      catch (PrivilegedActionException ex) {}
      if (UserPreferenceManagerImpl.preferences == null) {
          UserPreferenceManagerImpl.preferences = new String[UserPreferenceManagerImpl.PREFERENCES.length][];
      }
      if (UserPreferenceManagerImpl.preferences[3] == null) {
          UserPreferenceManagerImpl.preferences[3] = new String[] { "26" };
          this.savePreferences();
      }
  }

  private static class ReadPreferenceAction implements PrivilegedExceptionAction
  {
      public Object run() throws Exception {
          String[][] array = null;
          ObjectInputStream objectInputStream = null;
          try {
              objectInputStream = new ObjectInputStream(new BufferedInputStream(new FileInputStream(RootCertManager.getOriginalPersistentRoot() + "/userprefs")));
              array = (String[][])objectInputStream.readObject();
          }
          finally {
              if (objectInputStream != null) {
                  objectInputStream.close();
              }
          }
          return array;
      }
  }

Un utente malintenzionato potrebbe andare a sostituire il file userprefs con un oggetto serializzato dannoso per creare un’istanza di classi in un contesto privilegiato.

Su firmware meno recenti come 5.05, dove il commit https://github.com/openjdk/jdk/commit/020204a972d9be8a3b2b9e75c2e8abea36d787e9#diff-2c19943dd71743c3de69aa065025e753ca2e1f3b7ebc798e0d954de75d995de5 non è presente, lo sfruttamento di questa vulnerabilità è facile:

Un utente malintenzionato potrebbe creare un’istanza di una sottoclasse ClassLoader per chiamare defineClass con tutte le autorizzazioni e infine bypassare il gestore della sicurezza.

Vulnerabilità 2 [MEDIA][PS4]

La classe com.oracle.security.Service contiene un metodo newInstance che chiama Class.forName su un nome di classe arbitrario. Ciò consente di istanziare classi arbitrarie, anche ristrette (ad esempio in sun.).

Funziona per tutte le classi con costruttori pubblici che hanno argomenti singoli. Il check-in newInstance può essere ignorato chiamando com.oracle.ProviderAdapter.setProviderAccessor su un’implementazione ProviderAccessor personalizzata.

   if (!this.registered) {
       if (ProviderAdapter.getService(this.provider, this.type, this.algorithm) != this) {
           throw new NoSuchAlgorithmException("Service not registered with Provider " + this.provider.getName() + ": " + this);
       }
       this.registered = true;
    }

Vulnerabilità 3 [MEDIA] [PS4] [PS5]

La classe com.sony.gemstack.org.dvb.io.ixc.IxcProxy contiene il metodo protetto invokeMethod che può chiamare metodi in un contesto privilegiato. I controlli di autorizzazione nei metodi possono essere ignorati se sono soddisfatte le seguenti condizioni:

• Il metodo è pubblico e non statico.
• La classe del metodo è pubblica, non finale e può essere istanziata.

In uno scenario del genere, un utente malintenzionato potrebbe scrivere una sottoclasse della classe target che implementa un’interfaccia in cui il metodo desiderato genera RemoteException.

Ad esempio, ci sono controlli di autorizzazione in File.list(). Un attaccante potrebbe aggirarli con le seguenti classi:

class FileImpl extends File implements FileInterface {
   FileImpl(String pathname) {
     super(pathname);
   }
}

interface FileInterface extends Remote {
  public String[] list() throws RemoteException;
}

Questa vulnerabilità può essere utilizzata per perdere la struttura del file system e per eseguire il dump di file (ad esempio da /app0/).

Vulnerabilità 4 [ALTA][PS4] 

Il “thread del ricevitore del compilatore” riceve una struttura di dimensioni 0x58 byte dal processo di runtime:

typedef struct {
  uint8_t cmd; // 0x00
  uint64_t arg0; // 0x08
  uint64_t arg1; // 0x10
  uint64_t arg2; // 0x18
  uint64_t arg3; // 0x20
  uint64_t arg4; // 0x28
  uintptr_t runtime_data; // 0x30
  uintptr_t compiler_data; // 0x38
  uint64_t data1; // 0x40
  uint64_t data2; // 0x48
  uint64_t unk; // 0x50
} CompilerAgentRequest; // 0x58

CompilerAgentRequest req;
while (CompilerAgent::readn(s, &req, sizeof(req)) > 0) {
  uint8_t ack = 0xAA;
  CompilerAgent::writen(s, &ack, sizeof(ack));
  if (req.compiler_data != 0) {
    memcpy(req.compiler_data + 0x28, &req, sizeof(req));
    ...
  }
  ...
}

Questa struttura contiene un puntatore all’offset 0x38 (lo chiamiamo compiler_data) dal processo del compilatore che viene utilizzato per eseguire un backup della struttura della richiesta.

Un utente malintenzionato può semplicemente inviare un puntatore non attendibile e il thread del ricevitore del compilatore copierà i dati dalla richiesta nella sua memoria.

In altre parole, abbiamo una primitiva write-what-where. Un utente malintenzionato può sfruttare questa vulnerabilità fornendo un puntatore alla memoria JIT e archiviando il contenuto da scrivere nella richiesta.

Il compilatore scriverà questi dati nella memoria JIT e quindi ci darà l’opportunità di eseguire payload arbitrari. Ciò ha gravi implicazioni:

• È possibile scrivere un caricatore ELF per caricare ed eseguire giochi piratati.
• Lo sfruttamento del kernel diventa banale in quanto non esiste SMEP e si può semplicemente passare all’utente con un puntatore a funzione danneggiato.

Vulnerabilità 5 [ALTA] [PS4] [PS5]

Il driver UDF https://github.com/williamdevries/UDF viene utilizzato su PS4 e PS5 che contiene un buffer overflow.

Un utente malintenzionato potrebbe aumentare la dimensione inf_len di sector_size (il presupposto dell’allocazione interna è che i dati siano inferiori alla dimensione del settore) e causare un overflow con memcpy().

int
udf_read_internal(struct udf_node *node, uint8_t *blob)
{
	struct file_entry *fe = node->fe;
	struct extfile_entry *efe = node->efe;
	struct udf_mount *ump;
	uint64_t inflen;
	int addr_type, icbflags;
	uint32_t sector_size;
	uint8_t *pos;

	/* get extent and do some paranoia checks */
	ump = node->ump;
	sector_size = ump->sector_size;

	if (fe != NULL) {
		inflen = le64toh(fe->inf_len);
		pos = &fe->data[0] + le32toh(fe->l_ea);
		icbflags = le16toh(fe->icbtag.flags);
	} else {
		inflen = le64toh(efe->inf_len);
		pos = &efe->data[0] + le32toh(efe->l_ea);
		icbflags = le16toh(efe->icbtag.flags);
	}
	addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;

	/* copy out info */
	memset(blob, 0, sector_size);
	memcpy(blob, pos, inflen);

	return (0);
}

Verifica teorica

In allegato è la catena di exploit bd-jb come file .iso che dimostra lo sfruttamento delle vulnerabilità 1-4 con la capacità di eseguire payload arbitrari.

Masterizzare l’immagine ISO con il file system UDF 2.5. Puoi inviare il payload utilizzando il comando nc $PS4IP 1337 < payload.bin.

Il payload fornito provoca un kernel panic attivando la vulnerabilità 5 (il file /PWN/0 è stato modificato per utilizzare l’allocazione interna e ha una dimensione di 4 MB riempita con A). Testato sull’ultimo firmware 9.00.

Impatto

Con queste vulnerabilità, è possibile spedire giochi piratati su dischi Bluray. Ciò è possibile anche senza un exploit del kernel poiché abbiamo capacità JIT.

Fonte: hackerone.com