PHP tiene 2 estrechamente relacionadas con las funciones, escapeshellarg() y escapeshellcmd(). Ambos parecen hacer cosas similares, a saber, ayudar a hacer una cadena más seguro para su uso en system()/exec()/etc.

Cuál debo usar? Yo sólo quiero ser capaz de tomar algunos de usuario de entrada y ejecutar un comando en él, y no tienen todo lo de volar. Si PHP había un exec tipo de función que tomó una matriz de cadenas (como argv), lo que evita la concha, yo uso la que. Similar a Python subproceso.llame al() función.

InformationsquelleAutor Rory | 2009-12-10

4 Comentarios

  1. 4

    De http://ie2.php.net/manual/en/function.escapeshellarg.php

    escapeshellarg() agrega comillas simples
    alrededor de una cadena de citas y/escapa de cualquier
    existente entre comillas simples permitiendo
    pasar una cadena directamente a una consola de
    función y que sea tratado como un
    único seguro argumento.

    escapeshellarg, como su nombre lo indica, se utiliza como pasar shell argumento(s). Por ejemplo, usted desea de la lista de directorio actual,

    $dir = ".";
    system('ls '.escapeshellarg($dir));
    escapeshellcmd('ls $dir');

    Tanto hacer cosas similares y simplemente depende de cómo usted maneja su lógica, hacer asegúrese de que su normalizar y validar tu entrada antes de pasar directamente a estos métodos para mejorar la seguridad.

    • Esta no es una respuesta. La pregunta era ¿cuáles son las diferencias.
    • La verdadera pregunta es «Cual debo usar?». Creo que Jay respondió a esa pregunta.
    • Yo no diría que ellos hacen «cosas parecidas», de verificación de Adán respuesta para la diferencia real.
  2. 94

    Por lo general, usted querrá usar escapeshellarg, un único argumento de un comando de la shell seguro. He aquí por qué:

    Supongamos que usted necesita para obtener una lista de archivos en un directorio. Usted viene para arriba con el siguiente:

    $path  = 'path/to/directory'; //From user input
    
    $files = shell_exec('ls '.$path);
    //Executes `ls path/to/directory`

    (Esta es una mala manera de hacer esto, pero para ilustración del oso conmigo)

    Esto funciona «gran» por este camino, pero supongamos que el camino era algo más peligroso:

    $path  = 'path; rm -rf /';
    
    $files = shell_exec('ls '.$path);
    //Executes `ls path`, then `rm -rf /`;

    Porque el camino era utilizado unsanitised, cualquier comando puede ser potencialmente ejecutar. Podemos utilizar el escapeshell* métodos para tratar de evitar esto.

    Primer lugar, el uso de escapeshellcmd:

    $path = 'path; rm -rf /';
    
    $files = shell_exec(escapeshellcmd('ls '.$path));
    //Executes `ls path\; rm -rf /`;

    Este método sólo se escapa de los personajes que podría conducir a la ejecución de varios comandos, así que mientras que las paradas de los principales riesgos de seguridad, puede conducir a múltiples parámetros que se pasan en.

    Ahora, el uso de escapeshellarg:

    $path = 'path; rm -rf /';
    
    $files = shell_exec('ls '.escapeshellarg($path));
    //Executes `ls 'path; rm -rf /'`;

    Que nos da el resultado que queremos. Te darás cuenta de que el citado todo el argumento, de manera individual, espacios, etc, no necesitan ser escapado. Si el argumento fuera a tener citas en sí, que sería citado.

    Para resumir, escapeshellcmd se asegura que una cadena es sólo uno de los comandos, mientras que escapeshellarg hace una cadena de seguro para usar como único argumento para un comando.

    • Esto debe ser aceptado respuesta.
  3. 4

    El PHP docs explicar la diferencia:

    escapeshellcmd:

    Siguientes caracteres son precedidos por una barra diagonal inversa: #&;`|*?~<>^()[]{}$\,
    \x0A y \xFF. » y » se escapó sólo si ellos no están emparejados. En
    De Windows, todos estos caracteres más % se sustituye por un espacio en su lugar.

    escapeshellarg:

    agrega comillas simples alrededor de una cadena de citas y/escapa de cualquier existentes
    las comillas simples que permite pasar una cadena directamente a una consola de
    función y que sea tratado como una sola caja fuerte argumento.

    Fuente:

    http://www.php.net/manual/en/function.escapeshellcmd.php
    http://www.php.net/manual/en/function.escapeshellarg.php

  4. 4

    Una solución simple para determinar la diferencia entre dos de sonido similar funciones de PHP es escribir un rápido la línea de comandos de script en PHP que genera todo posible espacio de búsqueda y sólo muestran diferencias (en este caso, la comparación de 256 valores):

    <?php
        for ($x = 0; $x < 256; $x++)
        {
            if (chr($x) !== escapeshellcmd(chr($x)))  echo $x . " - cmd:  " . chr($x) . " != " . escapeshellcmd(chr($x)) . "\n";
        }
    
        echo "\n\n";
    
        for ($x = 0; $x < 256; $x++)
        {
            if (chr($x) !== substr(escapeshellarg(chr($x)), 1, -1))  echo $x . " - arg:  " . chr($x) . " != " . substr(escapeshellarg(chr($x)), 1, -1) . "\n";
        }
    ?>

    Ejecutando el anterior bajo PHP 5.6 en el Símbolo del sistema de Windows salidas:

    0 - cmd:    !=
    10 - cmd:
    != ^
    33 - cmd:  ! != ^!
    34 - cmd:  " != ^"
    35 - cmd:  # != ^#
    36 - cmd:  $ != ^$
    37 - cmd:  % != ^%
    38 - cmd:  & != ^&
    39 - cmd:  ' != ^'
    40 - cmd:  ( != ^(
    41 - cmd:  ) != ^)
    42 - cmd:  * != ^*
    59 - cmd:  ; != ^;
    60 - cmd:  < != ^<
    62 - cmd:  > != ^>
    63 - cmd:  ? != ^?
    91 - cmd:  [ != ^[
    92 - cmd:  \ != ^\
    93 - cmd:  ] != ^]
    94 - cmd:  ^ != ^^
    96 - cmd:  ` != ^`
    123 - cmd:  { != ^{
    124 - cmd:  | != ^|
    125 - cmd:  } != ^}
    126 - cmd:  ~ != ^~
    255 - cmd:    != ^ 
    0 - arg:    !=
    33 - arg:  ! !=
    34 - arg:  " !=
    37 - arg:  % !=
    92 - arg:  \ != \\

    Ejecutando el mismo script en PHP 5.5 para Linux salidas:

    0 - cmd:   !=
    10 - cmd:
    != \
    34 - cmd:  " != \"
    35 - cmd:  # != \#
    36 - cmd:  $ != \$
    38 - cmd:  & != \&
    39 - cmd:  ' != \'
    40 - cmd:  ( != \(
    41 - cmd:  ) != \)
    42 - cmd:  * != \*
    59 - cmd:  ; != \;
    60 - cmd:  < != \<
    62 - cmd:  > != \>
    63 - cmd:  ? != \?
    91 - cmd:  [ != \[
    92 - cmd:  \ != \\
    93 - cmd:  ] != \]
    94 - cmd:  ^ != \^
    96 - cmd:  ` != \`
    123 - cmd:  { != \{
    124 - cmd:  | != \|
    125 - cmd:  } != \}
    126 - cmd:  ~ != \~
    128 - cmd:   !=
    ...
    255 - cmd:  ÿ !=
    0 - arg:   !=
    39 - arg:  ' != '\''
    128 - arg:   !=
    ...
    255 - arg:  ÿ !=

    La principal diferencia es que PHP escapeshellcmd() en Windows prefijos de caracteres con un acento circunflejo ^ en lugar de una barra invertida \. Las rarezas bajo Linux desde chr(128) a través de la chr(255) para ambos escapeshellcmd() y escapeshellarg() puede ser explicado por el uso de UTF-8 no válida puntos de código que se cayó, trunca, o mal interpretado.

    También de la nota es que escapeshellarg() se escapa mucho menos caracteres y todavía hace el trabajo.

    En términos de conjunto del sistema y de la aplicación de la seguridad y la seguridad, es mejor que el uso de escapeshellarg() y de forma individual escapar de cada argumento que consta de entrada del usuario.

    Un último ejemplo:

    echo escapeshellarg("something here") . "\n";
    echo escapeshellarg("'something here'") . "\n";
    echo escapeshellarg("\"something here\"") . "\n";

    Windows salidas:

    "something here"
    "'something here'"
    " something here "

    Linux salidas:

    'something here'
    ''\''something here'\'''
    '"something here"'

    PHP escapeshellarg() en Windows rodea la cadena con comillas dobles «de carácter mientras que Linux utiliza una comilla simple’ carácter. PHP en Windows reemplaza completamente a la interna de la doble cita con espacios (que podría ser un problema en algunos casos). PHP en Linux va un poco fuera de su camino para escapar de una sola comillas y barras \ se escapó \\ en Windows. PHP escapeshellarg (en Windows) sustituye también ! y % de caracteres con espacios. Todas las plataformas reemplazar \0 con espacios.

    Nota que el comportamiento no es necesariamente coherentes entre las versiones de PHP y la documentación de PHP no siempre reflejan la realidad. La escritura de una rápida secuencia de comandos o la lectura del código fuente de PHP, son dos maneras de averiguar lo que está pasando detrás de las escenas.

Dejar respuesta

Please enter your comment!
Please enter your name here