Cette fonction PDO est-elle sûre de l'injection sql?

Question

J'ai la fonction d'insertion suivante. Est-il sûr d'une injection de sql. Si ce n'est pas le cas, comment puis-je le rendre sûr?

public function insert($postValues, $table){ 

    $dbh = $this->connect(); 

    try { 
     $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); 

     $fields = implode(array_keys($postValues), ','); 
     $values = "'".implode(array_values($postValues), "','")."'"; 
     $insertQuery = 'INSERT INTO '.$table.' ('.$fields.') VALUES (:'.$fields.')'; 

     $stmt = $dbh->prepare($insertQuery); 

     foreach($postValues as $vals) { 
      $stmt->execute($vals); 
     } 

     $message = $sucessMessage; 
    } 
    catch(PDOException $e){ 
     $message = $e->getMessage(); 
    } 

    $dbh = null; 

    return $message; 
} 

Merci à l'avance

Answer 1

Si chaque type de colonne est un PDO::PARAM_STR, il est assez simple de lier vos paramètres marqueurs unamed de paramter utilisant PDOStatement::execute. Toutefois, si les types de colonne varient, vous devez spécifier le type de colonne pour chaque colonne lorsque vous liez avec PDOStatement::bindParam. Accepter les noms de table et de colonne à partir de ce qui semble être une entrée utilisateur n'est pas une bonne idée. La requête échouera si les noms de table ou de colonne sont incorrects, mais vous devez être très prudent pour vous assurer que les noms de table et de colonne sont sûrs à utiliser. L'exemple suivant vérifie la table et les noms de colonnes contre une liste blanche, avant d'exécuter une SQL:

function insert($postValues, $table) { 
    $dbh = $this->connect(); 

    // Create a simple whitelist of table and column names. 
    $whitelist = array('my_table' => array('col1', 'col2', 'col3')); 

    // Check if the table name exists in the whitelist. 
    if(!array_key_exists($table, $whitelist)) { 
     exit("$table is not a valid table name.\n"); 
    } 

    // Count the number of columns that are found in the whitelist. 
    $cols = count(
     array_intersect(
      $whitelist[$table], 
      array_keys($postValues))); 

    if($cols !== count($postValues)) { 
     exit("One or more invalid column names have been supplied.\n"); 
    } 

    // Create a comma separated list of column names. 
    $columns = implode(', ', array_keys($postValues)); 
    // Create a comma separated list of unnamed placeholders. 
    $params = implode(', ', array_fill(0, count($postValues), '?')); 
    // Create a SQL statement. 
    $sql = "INSERT INTO $table ($columns) VALUES ($params)"; 

    // Prepare the SQL statement. 
    $stmt = $dbh->prepare($sql); 
    // Bind the values to the statement, and execute it. 
    return $stmt->execute(array_values($postValues)); 
} 

echo insert(
    array(
     'col1' => 'value1', 
     'col2' => 'value2', 
     'col3' => 'value3'), 
    'my_table'); 

// 1 

echo insert(
    array(
     'col1' => 'value1', 
     'col2' => 'value2', 
     'col3' => 'value3'), 
    'unsafe_table'); 

// unsafe_table is not a valid table name. 

echo insert(
    array(
     'col1' => 'value1', 
     'col2' => 'value2', 
     'unsafe_col' => 'value3'), 
    'my_table'); 

// One or more invalid column names have been supplied. 

Answer 2

Non, parce que vous êtes juste exécution d'une requête SQL brute avec l'extension PDO. Je fais quelque chose de semblable au suivant:

$fields = array(); 
$values = array(); 

foreach ($_POST as $field => $value) { 
    $fields[] = $field; 
    $values[] = $this->pdo->quote($value); 
} 

$fields = implode(',', $fields); 
$values = implode(',', $values); 

$sql = "INSERT INTO $table ($fields) VALUES ($values)"; 
$res = $this->pdo->query($sql); 

Je suis sûr que vous pouvez modifier ce qui précède pour s'adapter à votre configuration.

Answer 3

Soit dit en passant: en demandant si PDO est plus sûr de l'injection sql que d'une autre bibliothèque de connexion PHP MySQL, la réponse est NON quand on parle de PDO_MYSQL (ne sais pas si ce qui suit est vrai pour d'autres bases de données).

On pourrait même soutenir l'inverse, AOP est moins sûr et plus dangereux que toute autre bibliothèque de connexion PHP MySQL (ext/mysql et ext/mysqli) car PDO_MYSQL permet de multiples requêtes dans une instruction SQL lors ext/mysql arrêts multi-requêtes complètement et ext/mysqli a une fonction de sparate mysqli_multi_query().

Je viens d'essayer de trouver des sources pour étayer cette affirmation, mais les seules choses que j'ai sont:

• Protection against SQL Injection using PDO and Zend Framework

  PDO_MySQL est une application plus dangereux que tout autre traditionnel Applications MySQL. MySQL traditionnel ne permet qu'une seule requête SQL. Dans PDO_MySQL il n'y a pas une telle limitation, mais vous risquez d'être injecté avec plusieurs requêtes.

• Zend Webcast "Secure Application Development with the Zend Framework" par Stefan Esser (diapositive 18)

Answer 4

La seule façon saine consiste à utiliser PDO::prepare avec des paramètres (voir exemple dans le manuel). De plus, les noms de champs doivent provenir d'une source fiable, c'est-à-dire ne pas être un utilisateur. De cette façon, vous construisez votre chaîne de requête à partir de composants de confiance:

function insert ($table, $fields, $data) 
{ 
    $field_names = implode (", ", $fields);      # "a, b" 
    $values = ":" . implode (", :", $fields);     # ":a, :b" 
    $query = "INSERT INTO $table($field_names) VALUES($values)"; 
    $sth = $pdo->prepare ($query); 

    foreach ($data as $row) { 
     # Here you can even remove "bad" keys from $row 
     $sth->execute ($row); 
    } 
} 

$fields = array ('a', 'b'); # those are hard-coded in application 
$data = array (   # those come from user 
    array ('a'=>'Apple', 'b'=>'Bean'), 
    array ('a'=>'Avocado', 'b'=>'Blueberry', '); DELETE FROM fruits; -- '=>'evil'), 
); 
insert ('fruits', $fields, $data);