1. Subida de archivo
Para que el usuario del cliente cargue archivos, debemos proporcionar un formulario en la interfaz de usuario para enviar solicitudes para cargar archivos. Dado que el archivo cargado son datos especiales, a diferencia de otros datos de publicación, debemos establecer una codificación especial para el formulario:
Copie el código de la siguiente manera: <Form Action = "upload.php" método = "post" enctype = "multipart/form-data"> </form>
Es posible que no esté familiarizado con los atributos de cifrado anteriores, porque esto a menudo se ignora. Sin embargo, si la solicitud de publicación HTTP contiene datos regulares y datos similares a archivos, se debe agregar este atributo, lo que puede mejorar la compatibilidad para varios navegadores.
A continuación, tenemos que agregar un campo al formulario para cargar el archivo:
Copie el código de la siguiente manera: <input type = "file" name = "adjunto">
Los campos de archivo anteriores pueden comportarse de manera diferente en varios navegadores. Para la mayoría de los navegadores, los campos anteriores se representan en un cuadro de texto con un botón de navegación. De esta manera, el usuario puede ingresar la ruta del archivo en el cuadro de texto por sí mismo, o seleccionar el archivo que se cargará desde el disco duro local a través del botón de navegación. Sin embargo, en el safari de Apple, parece que solo se puede usar navegación. Por supuesto, también puede personalizar el estilo de este cuadro de carga para que se vea más elegante que el estilo predeterminado.
A continuación, para explicar mejor cómo manejar las cargas de archivos, dar un ejemplo completo. Por ejemplo, el siguiente formulario permite a los usuarios cargar archivos adjuntos a mi servidor local:
Copie el código de la siguiente manera: <p> Por favor, cargue su archivo adjunto: </p>
<Form Action = "upload.php" método = "post" enctype = "multipart/formy-data">
<input type = "file" name = "adjunto">
<input type = "enviar" valor = "adjunto de carga">
</form>
Consejo: puede establecer el valor máximo que permite cargar archivos a través de upload_max_filesize en php.ini. Además, también hay un post_max_size que se puede usar para establecer los datos de formulario máximo que se permite cargar. estableciendo este campo. Sin embargo, tenga en cuenta que el valor de este último debe ser mayor que el primero, porque el primero pertenece a una parte de los datos de formulario de los últimos.
Figura 1. Formulario de carga que se muestra en Firefox
Cuando se envíe este formulario, la solicitud HTTP se enviará a fload.php. Para mostrar qué información específica se puede utilizar en upload.php, la imprimí en upload.php:
La copia del código es la siguiente:
Header ('Content-Type: Text/Plain');
print_r ($ _ archivos);
Hagamos un experimento.
Copie el código de la siguiente manera: Array
(
[adjunto] => matriz
(
[nombre] => boy.jpg
[type] => Image/jpeg
[tmp_name] => d: /xampp/tmp/php1168.tmp
[error] => 0
[tamaño] => 11490
)
)
Lo anterior es toda la información sobre el archivo cargado actualmente en la matriz global después de cargar el archivo. Sin embargo, ¿podemos asegurarnos de que esta información sea segura, ¿qué pasa si el nombre u otra información ha sido manipulada? ¡Siempre debemos estar atentos a la información de los clientes!
Cada parte de la solicitud HTTP específica
Para comprender mejor la carga de archivos, debemos verificar qué información específica está contenida en la solicitud HTTP enviada por el cliente. El archivo adjunto que subí antes fue el logotipo de este blog, porque es una imagen, no es adecuado para nosotros hacer los experimentos anteriores. Entonces, subí un archivo de texto Test.Text nuevamente, que contiene el siguiente contenido:
La copia del código es la siguiente:
360W
360 días
Vida de un chico web
Bueno. Ahora cargue este archivo de texto y lo emitiré en upload.php:
La copia del código es la siguiente:
Formación
(
[adjunto] => matriz
(
[nombre] => test.txt
[type] => texto/simple
[tmp_name] => d: /xAMPP/TMP/PHP51C0.TMP
[error] => 0
[tamaño] => 40
)
)
Echemos un vistazo a la solicitud de publicación HTTP enviada por el navegador correspondiente (omití algunos encabezados opcionales):
La copia del código es la siguiente:
Post /upload.php http /1.1
Anfitrión: www.360weboy.me
Referente: http://www.360weboy.me/
multipart/formularios de forma; -------------------------------------------------- -------------------------
Contenido-longitud: 234
--------------------------------------- 24464570528145
Contenido-Disposición: Forma-Data;
Tipo de contenido: texto/simple
360weboy
360 días
Vida de un chico web
------------------------------------ 24464570528145-
Hay varios campos en el formato de solicitud anterior, el nombre, el nombre de archivo y el tipo de contenido. test.txt, y el texto de formato de archivo cargado/simple (representa el archivo de texto). Luego, vemos que la siguiente línea es el contenido específico en el archivo cargado.
2. Fortalecimiento de la seguridad
Para mejorar la seguridad en la carga de archivos, necesitamos verificar el tmp_name y el tamaño en la matriz global de $ _files. Para garantizar que el archivo apuntado por tmp_name sea el archivo cargado por el usuario en el cliente, en lugar de señalar algo como /etc /passwd, puede usar la función is_uploaded_file () en PHP para hacer el siguiente juicio :
La copia del código es la siguiente:
$ filename = $ _files ['adjunto'] ['tmp_name'];
if (is_uploaded_file ($ filename)) {
/ * es un archivo cargado.
}
En algunos casos, después de que el usuario carga el archivo, el contenido del archivo cargado con éxito se puede mostrar al usuario para su visualización, por lo que la verificación del código anterior es particularmente importante.
Otra cosa para verificar es el tipo MIME del archivo de carga, que es el campo Tipo de la matriz de salida en la carga anterior.php. Lo que cargué en el primer ejemplo es una imagen, por lo que el valor de $ _files ['adjunto'] ['type'] es 'Image/jpeg'. Si planea aceptar solo imágenes de tipo MIME como Image/PNG, Image/JPEG, Image/GIF, Image/X-PNG e Image/P-JPEG en el lado del servidor, puede usar un código similar al siguiente para verificar (solo dale un vistazo) los ejemplos, los códigos específicos, como los errores, deben seguir los mecanismos de su sistema):
La copia del código es la siguiente:
$ dign_mimes = array (
'Imagen/png',
'Imagen/X-PNG',
'Imagen/GIF',
'Imagen/jpeg',
'Imagen/PJPEG'
);
$ image = $ _files ['adjunto'];
if (! in_array ($ image ['type'], $ tlow_mimes)) {
morir ('Lo siento, el formato de archivo que cargó es inexacto; solo aceptamos archivos de imagen');
}
// Continuar procesando archivos de imagen cargados
Como puede ver, hemos asegurado que el tipo MIME del archivo cumpla con los requisitos del lado del servidor. Sin embargo, no es suficiente para evitar que los usuarios maliciosos carguen otros archivos dañinos, porque los usuarios maliciosos pueden fingir que se disfrazan de este tipo de mime. Por ejemplo, el usuario hizo una imagen JPG, escribió algún código PHP malicioso en los metadatos de la imagen y lo guardó como un archivo con el sufijo llamado PHP. Cuando se cargue este archivo malicioso, el lado del servidor lo verificará con éxito para el tipo MIME, que se considera una imagen, y se ejecutará el código PHP peligroso en el interior. Los metadatos de la imagen específica son similares a los siguientes:
La copia del código es la siguiente:
Nombre del archivo: Image.jpg
Tamaño del archivo: 182007 bytes
Fecha del archivo: 2012: 11: 27 7:45:10
Resolución: 1197 x 478
Comentario: passthru ($ _ post ['cmd']);
Podemos ver que el código PHP se agrega al campo de comentarios de los metadatos de la imagen. Por lo tanto, es obvio que para evitar situaciones peligrosas similares, también se debe realizar una verificación necesaria de la extensión del archivo cargado. El siguiente código mejora el código anterior para verificar el tipo MIME:
La copia del código es la siguiente:
$ dign_mimes = array (
'Image/png' => '.png',
'Image/x-png' => '.png',
'Image/gif' => '.gif',
'Image/jpeg' => '.jpg',
'Image/Pjpeg' => '.jpg'
);
$ image = $ _files ['adjunto'];
if (! Array_key_exists ($ image ['type'], $ dign_mimes)) {
morir ('Lo siento, el formato de archivo que cargó es inexacto; solo aceptamos archivos de imagen');
}
// Obtenga el nombre del archivo con el nombre de sufijo omitido:
$ filename = substr ($ image ['name'], 0, strpos ($ image ['name'], '.');
// Agregar un nombre de sufijo
$ FileName. = $ Dign_mimes [$ image ['type']];
// Continuar procesando archivos cargados
A través del código anterior, nos aseguramos de que incluso si la imagen de imagen cargada contiene el código PHP, el archivo de imagen se cambiará a llamarse como un archivo con el nombre de sufijo y el formato de imagen, por lo que el código PHP en él no se ejecutará. El código anterior no tendrá ningún impacto negativo en las imágenes cargadas normales.
Después de realizar los anteriores varios pasos para mejorar las verificaciones de seguridad, si solo desea guardar el archivo cargado en un directorio especificado, puede usar la función predeterminada Move_UPLOADED_FILE de PHP para implementarlo:
La copia del código es la siguiente:
$ tmp_filename = $ _files ['adjunto'] ['tmp_name'];
$ filename = '/path/to/attachment.txt';
if (mude_uploaded_file (tmp_filename, $ filename)) {
/ * $ TEMP_FILENAME El archivo de carga guardado en el directorio temporal y luego guárdelo con éxito en el archivo adjunto.txt en el directorio correspondiente.
}
También es posible que deba limitar el tamaño del archivo cargado, para que pueda usar la función de tamaño de archivo para obtener el tamaño del archivo cargado, hacer juicios y hacer un procesamiento adicional.
Bien, escribamos esto por ahora sobre la carga de archivos. Espero que este artículo introductorio sea útil para usted.