1. Upload de arquivo
Para que o usuário do cliente faça upload de arquivos, devemos fornecer um formulário na interface do usuário para enviar solicitações para fazer upload de arquivos. Como o arquivo carregado é um dados especial, diferentemente de outros dados de postagem, devemos definir uma codificação especial para o formulário:
Copie o código da seguinte
Você pode não estar familiarizado com os atributos do Enctype acima, porque isso é frequentemente ignorado. No entanto, se a solicitação de postagem HTTP contiver dados regulares e dados semelhantes a arquivos, esse atributo deve ser adicionado, o que pode melhorar a compatibilidade para vários navegadores.
Em seguida, temos que adicionar um campo ao formulário para fazer upload do arquivo:
Copie o código da seguinte
Os campos de arquivo acima podem se comportar de maneira diferente em vários navegadores. Para a maioria dos navegadores, os campos acima são renderizados em uma caixa de texto com um botão de navegação. Dessa forma, o usuário pode inserir o caminho do arquivo na caixa de texto sozinho ou selecionar o arquivo a ser carregado no disco rígido local através do botão de navegação. No entanto, no Safari da Apple, parece que apenas a navegação pode ser usada. Obviamente, você também pode personalizar o estilo desta caixa de upload para parecer mais elegante que o estilo padrão.
Abaixo, para explicar melhor como lidar com uploads de arquivo, dê um exemplo completo. Por exemplo, o formulário a seguir permite que os usuários enviem anexos ao meu servidor local:
Copie o código da seguinte forma: <p> Envie seu anexo: </p>
<form action = "upload.php" method = "post" rtype = "multipart/form-data">
<input type = "file" name = "anexamento">
<input type = "submit" value = "upload anexamento">
</morm>
Dica: você pode definir o valor máximo que permite o upload de arquivos através do upload_max_filesize em php.ini. Além disso, há também um post_max_size que pode ser usado para definir os dados máximos de formulário que podem ser carregados. Definindo este campo. No entanto, observe que o valor deste último deve ser maior que o primeiro, porque o primeiro pertence a uma parte dos dados do formulário deste último.
Figura 1. Formulário de upload mostrado no Firefox
Quando este formulário for enviado, a solicitação HTTP será enviada para upload.php. Para mostrar quais informações específicas podem ser usadas no upload.php, imprimi -as no upload.php:
A cópia do código é a seguinte:
cabeçalho ('Tipo de conteúdo: texto/simples');
print_r ($ _ arquivos);
Vamos fazer um experimento.
Copie o código da seguinte maneira: Array
(
[Anexo] => Array
(
[nome] => boy.jpg
[tipo] => Image/jpeg
[tmp_name] => d: /xampp/tmp/php1168.tmp
[erro] => 0
[tamanho] => 11490
)
)
O exposto acima está todas as informações sobre o arquivo atualmente enviado na matriz global após o upload do arquivo. No entanto, podemos garantir que essas informações sejam seguras, e se o nome ou outras informações tenham sido adulteradas? Sempre precisamos estar vigilantes com as informações dos clientes!
Cada parte da solicitação HTTP específica
Para entender melhor o upload de arquivos, devemos verificar quais informações específicas estão contidas na solicitação HTTP enviada pelo cliente. O anexo que enviei antes foi o logotipo deste blog, porque é uma imagem, não é adequado para nós fazermos os experimentos acima. Então, eu enviei um arquivo de texto test.text novamente, que contém o seguinte conteúdo:
A cópia do código é a seguinte:
360W
360 dias
Vida de um garoto da web
OK. Agora eu carrego este arquivo de texto e o utilizo no upload.php:
A cópia do código é a seguinte:
Variedade
(
[Anexo] => Array
(
[nome] => test.txt
[TYPE] => Texto/Plano
[tmp_name] => d: /xampp/tmp/php51c0.tmp
[erro] => 0
[tamanho] => 40
)
)
Vamos dar uma olhada na solicitação de postagem HTTP enviada pelo navegador relevante (omiti alguns cabeçalhos opcionais):
A cópia do código é a seguinte:
Post /upload.php http /1.1
Host: www.360weboy.me
Referente: http://www.360weboy.me/
Multipart/Form-Data; -------------------------------------------------------- ---------------------------
Comprimento de conteúdo: 234
----------------------------------------- 24464570528145
Disposição de conteúdo: formulário-dados;
Tipo de conteúdo: texto/simples
360WoBoy
360 dias
Vida de um garoto da web
------------------------------------ 24464570528145-
Existem vários campos no formato de solicitação acima, nome, nome do arquivo e tipo de conteúdo test.txt e o arquivo de arquivo de arquivo carregado Texto/simples (representa o arquivo de texto). Em seguida, vemos que a linha a seguir é o conteúdo específico no arquivo carregado.
2. Fortalecimento da segurança
Para aprimorar a segurança no upload de arquivos, precisamos verificar o TMP_NAME e o tamanho da matriz Global $ _Files. Para garantir que o arquivo apontado por tmp_name seja de fato o arquivo enviado pelo usuário no cliente, em vez de apontar para algo como /etc /passwd, você pode usar a função is_uploaded_file () no PHP para fazer o seguinte julgamento :
A cópia do código é a seguinte:
$ filename = $ _files ['anexo'] ['tmp_name'];
if (is_uploaded_file ($ filename)) {
/ * é um arquivo carregado.
}
Em alguns casos, depois que o usuário carrega o arquivo, o conteúdo do arquivo carregado com sucesso pode ser exibido ao usuário para visualização, portanto a verificação do código acima é particularmente importante.
Outra coisa a verificar é o tipo MIME do arquivo de upload, que é o campo de tipo da matriz de saída no upload.php acima. O que eu carreguei no primeiro exemplo é uma imagem; portanto, o valor de $ _files ['anexo'] ['tipo'] é 'imagem/jpeg'. Se você planeja aceitar apenas imagens do tipo MIME, como imagem/png, imagem/jpeg, imagem/gif, imagem/x-png e imagem/p-jpeg no lado do servidor, você pode usar o código semelhante ao seguinte para verificar (Basta dar uma olhada nele) Exemplos, códigos específicos, como erros, devem seguir os mecanismos do seu sistema):
A cópia do código é a seguinte:
$ allow_mimes = Array (
'imagem/png',
'imagem/x-png',
'imagem/gif',
'imagem/jpeg',
'imagem/pjpeg'
);
$ imagem = $ _files ['anexo'];
if (! in_array ($ image ['type'], $ allow_mimes)) {
Die ('Desculpe, o formato de arquivo que você carregou é impreciso; aceitamos apenas arquivos de imagem.');
}
// Continue a processar arquivos de imagem carregados
Como você pode ver, garantimos que o tipo MIME do arquivo atenda aos requisitos do lado do servidor. No entanto, não basta impedir que usuários maliciosos enviem outros arquivos nocivos, porque usuários maliciosos podem fingir que estão disfarçados por esse tipo MIME. Por exemplo, o usuário fez uma imagem JPG, escreveu algum código PHP malicioso nos metadados da imagem e salvou -o como um arquivo com o sufixo chamado PHP. Quando esse arquivo malicioso for enviado, ele será verificado com sucesso pelo lado do servidor para o tipo MIME, que é considerado uma imagem, e o código PHP perigoso dentro será executado. Os metadados da imagem específica são semelhantes aos seguintes:
A cópia do código é a seguinte:
Nome do arquivo: image.jpg
Tamanho do arquivo: 182007 bytes
Data do arquivo: 2012: 11: 27 7:45:10
Resolução: 1197 x 478
Comentário: passthru ($ _ post ['cmd']);
Podemos ver que o código PHP é adicionado ao campo de comentários dos metadados da imagem. Portanto, é óbvio que, para evitar situações perigosas semelhantes, também deve ser realizada uma verificação necessária da extensão do arquivo carregado. O código a seguir aprimora o código anterior para verificar o tipo MIME:
A cópia do código é a seguinte:
$ allow_mimes = Array (
'imagem/png' => '.png',
'imagem/x-png' => '.png',
'imagem/gif' => '.gif',
'imagem/jpeg' => '.jpg',
'imagem/pjpeg' => '.jpg'
);
$ imagem = $ _files ['anexo'];
if (! Array_key_exists ($ image ['type'], $ allow_mimes)) {
Die ('Desculpe, o formato de arquivo que você carregou é impreciso; aceitamos apenas arquivos de imagem.');
}
// Obtenha o nome do arquivo com o nome do sufixo omitido:
$ filename = substr ($ imagem ['nome'], 0, strpos ($ imagem ['nome'], '.'));
// Adicione um nome de sufixo
$ nome do arquivo. = $ allow_mimes [$ image ['type']];
// continua a processar arquivos carregados
Através do código acima, garantimos que, mesmo que o metafile de imagem carregado contenha o código PHP, o arquivo de imagem será renomeado como um arquivo com o nome do sufixo e o formato da imagem, para que o código PHP não será executado. O código acima não terá nenhum impacto negativo nas imagens carregadas normais.
Depois de executar as várias etapas acima para melhorar as verificações de segurança, se você deseja apenas salvar o arquivo carregado em um diretório especificado, poderá usar a função padrão move_uploaded_file de php para implementá -lo:
A cópia do código é a seguinte:
$ tmp_filename = $ _files ['anexo'] ['tmp_name'];
$ filename = '/path/to/attachment.txt';
if (move_uploaded_file (tmp_filename, $ filename)) {
/ * $ temp_filename O arquivo de upload salva no diretório temporário e, em seguida, salve -o no arquivo APCHment.txt no diretório correspondente.
}
Você também pode ser necessário limitar o tamanho do arquivo carregado, para que você possa usar a função FileSear para obter o tamanho do arquivo carregado, fazer julgamentos e fazer um processamento adicional.
Ok, vamos escrever isso agora sobre o upload de arquivos. Espero que este artigo introdutório seja útil para você.