L'array injection è una vulnerabilità e qual è il termine corretto per questo?

4

Quando eseguo i test di penetrazione, a volte noto un comportamento indesiderato di uno script PHP quando inietto un array singolo o multidimensionale utilizzando i parametri HTTP GET.

Rischio di disponibilità possibile

Ciò può causare un rischio di disponibilità, specialmente nel caso di un'iniezione di array multidimensionale quando uno script PHP ricorre in modo ricorsivo attraverso una matrice (profonda) multidimensionale e non vi è alcuno o un limite elevato al tempo di esecuzione. Perché questo può causare esaurimento delle risorse. In pratica questo può essere il caso in cui l'intera matrice $_GET viene sottoposta a looping per applicare qualche tipo di filtro o convalida.

Domande su questo comportamento

  1. Quale sarebbe il termine appropriato per una tale vulnerabilità? "Iniezione di array"?
  2. In quale categoria di vulnerabilità appartiene (ad esempio nell'elenco OWASP Top 10 o CWE)?
  3. È questo, oltre al rischio di disponibilità, considerato una vulnerabilità?
  4. Qual è un buon scenario in cui questo può essere sfruttato?

Esempio di comportamento

Input: (si aspetti stringa come parametro)

/search.php?query=test

Risultato: (in $_GET di PHP)

[query] => test

Input: (array iniettato)

/search.php?query[]=test

Risultato: (in $_GET di PHP)

[query] => Array
(
    [0] => test
)

Input: (array multidimensionale iniettato)

/search.php?query[][][][]=test

Risultato: (in $_GET di PHP)

[query] => Array
(
    [0] => Array
        (
            [0] => Array
                (
                    [0] => Array
                        (
                            [0] => test
                        )
                )
        )
)
    
posta Bob Ortiz 22.06.2016 - 12:19
fonte

4 risposte

3

What would be the proper term for such a vulnerability? "Array injection"?

In what vulnerability category does this belong (for example in the OWASP Top > 10 or CWE list)?

Questo è chiamato " parametro di manomissione " ed è stato chiamato come tale da PHP developers , OWASP, e rientra in diversi numeri CWE con il genitore di essere CWE-371 , ad es. quando il paremeter coinvolge l'istruzione SQL di injection, diventa SQL Injection. Tutto quello che stai facendo è manipolare (manomettere) con l'input nel tentativo di produrre un effetto negativo.

Is this, other than the availability risk, considered to be a vulnerability?

La vulnerabilità è che il server non riesce a input disinfettante

What is a good scenario wherein this can be exploited?

Dipende dall'applicazione stessa. Dovresti continuare a manipolare gli input per vedere cosa potrebbe / potrebbe accadere in circostanze diverse. Ad esempio, hai provato a inserire comandi annidati all'interno della manomissione? Per esempio:.

/search.php?query[() { example;};echo \"Content-type: text/plain\"; echo; echo; /bin/cat /etc/shadow"]=test

Senza comprendere l'applicazione sottostante, è difficile determinare cosa sia vulnerabile. Il fatto che l'input non sia stato convalidato, dovresti essere in grado di testare ogni sorta di cose da iniettare per cercare di ottenere che il server risponda ai tuoi dati manomessi. È possibile inserire grandi quantità di dati per vedere se è possibile attivare un overflow stack / buffer / heap. Ci sono alcune cose che potresti provare, ma ancora una volta, senza conoscere la funzione dell'applicazione iniziale, questo diventa un gioco di ipotesi

    
risposta data 28.06.2016 - 21:03
fonte
6

Penso che il termine inquinamento dei parametri HTTP sarebbe la soluzione migliore. Questo tipo di inquinamento di solito invia lo stesso parametro più volte con valori diversi nella stessa richiesta. Ciò comporta che il parametro viene trattato come una matrice di valori con il nome del parametro come nome della matrice, come descritto in questo articolo . Il modo in cui il server web e il linguaggio di programmazione gestiscono questi array rispetto al singolo valore è ciò che sfrutta questa classe di bug.

I tuoi esempi provocano allo stesso modo un array con lo stesso nome, sebbene attraverso un metodo diverso per la ripetizione del parametro, ma sembra un adattamento migliore rispetto ad altri termini come fault injection o type confusion .

Mentre questo tipo di inquinamento di solito sfrutta un comportamento indefinito, gli esempi che hai fornito non lo sarebbero. Avrebbero causato un comportamento definito per la gestione di un array. Ciò potrebbe comunque attivare eccezioni che potrebbero essere utilizzate per modificare il flusso di un'applicazione, ad esempio errori prima che un controllo di autorizzazione abbia modificato la sessione con conseguente escalation di privilegi.

    
risposta data 22.06.2016 - 13:51
fonte
4

Essere in grado di utilizzare le matrici in $_GET in questo modo non rappresenta di per sé una vulnerabilità di sicurezza. Il vettore DoS mi sembra trascurabile, sebbene possa essere amplificato dal codice che lo utilizza.

Tuttavia , gli esempi forniti mancavano della parte più importante di questa funzione (dal punto di vista di un attaccante): non solo è possibile passare array regolari in GET e POST parametri in questo modo, ma anche array associativi . In effetti, PHP non distingue tra i due:

PHP arrays can contain integer and string keys at the same time as PHP does not distinguish between indexed and associative arrays. – PHP: Arrays - Manual

Questo significa che se un cliente fornisce POST parametri come questo:

<input type="text" name="pass[pass1]" value="Password 1">
<input type="text" name="pass[pass2]" value="Password 2">

$_POST / $_GET sarà simile a questo:

$_POST = array(
    ...
    'pass' => array(
        'pass1' => 'Password 1',
        'pass2' => 'Password 2', 
    ),
    ...
);

Ma se il server si aspettava che fosse un array normale anziché uno associativo, potrebbe portare a una vulnerabilità di sicurezza:

//Simplified example, bug is possible with parameterized queries as well
//Expects ?pass[]=password1&pass[]=password2
$query = 'INSERT INTO users (index, password) ';
$parts = array();

foreach($_GET['user'] AS $index=>$value){
  parts[]=" VALUES ({$index}, ".$pdo->real_escape_string($value).')';
}

$query .= implode(", ", $parts);
$pdo->exec($query);//

$query con l'input previsto:

INSERT INTO USERS (index, password) VALUES(0, 'password1'), VALUES(1, 'password2')

$query con ?pass[0,'');DROP DATABASE DATABASE();--]=foo :

INSERT INTO USERS (index, password) VALUES(0,'');DROP DATABASE DATABASE();--, 'foo')

Ineffetti,questoèesattamentelostessoerrorechehaportatoaldifettodisicurezzachiamato"Drupalgeddon" - e ha ricevuto quel nome per una buona ragione.

A vulnerability in this API allows an attacker to send specially crafted requests resulting in arbitrary SQL execution. Depending on the content of the requests this can lead to privilege escalation, arbitrary PHP execution, or other attacks. – SA-CORE-2014-005 - Drupal core - SQL injection

Automated attacks began compromising Drupal 7 websites that were not patched or updated to Drupal 7.32 within hours of the announcement of SA-CORE-2014-005 - Drupal core - SQL injection. You should proceed under the assumption that every Drupal 7 website was compromised unless updated or patched before Oct 15th, 11pm UTC, that is 7 hours after the announcement. – Drupal Core - Highly Critical - Public Service announcement - PSA-2014-003

Era anche la vulnerabilità che molto probabilmente ha portato alla divulgazione del Panama Papers (probabilmente dovrebbe aver installato quegli aggiornamenti di sicurezza ...).

La vulnerabilità di Drupal è stata risolta aggiornando il codice per passare l'array ricevuto a array_values() , che restituisce un array indicizzato contenente solo valori dell'array ricevuto, eliminando quindi eventuali chiavi dannose.

Il codice di esempio potrebbe essere corretto allo stesso modo:

Prima:

foreach($_GET['user'] AS $index=>$value){

Dopo

foreach(array_values($_GET['user']) AS $index=>$value){

Ulteriori informazioni su Drupalgeddon, incluso un exploit di lavoro: Drupal 7: Drupalgeddon Exploit

Tieni presente che questa roba funziona allo stesso modo, indipendentemente dal fatto che tu stia lavorando con $_GET o $_POST . Non sono sicuro di $_REQUEST e $_COOKIE .

    
risposta data 24.06.2016 - 14:52
fonte
0

Esiste un altro possibile attacco, ad esempio con MongoDB .

If you are passing $_GET (or $_POST) parameters to your queries, make sure that they are cast to strings first. Users can insert associative arrays in GET and POST requests, which could then become unwanted $-queries.

A fairly innocuous example: suppose you are looking up a user's information with the request http://www.example.com?username=bob. Your application does the query $collection->find(array("username" => $_GET['username'])).

Someone could subvert this by getting http://www.example.com?username[$ne]=foo, which PHP will magically turn into an associative array, turning your query into $collection->find(array("username" => array('$ne' => "foo"))), which will return all users not named "foo" (all of your users, probably).

link

    
risposta data 28.07.2016 - 13:21
fonte