[PHP] Mime-type

[Wolf3D]

Op een door mij ontwikkelde grote marktplaats-achtige website heb ik een upload-formulier waarmee gebruikers afbeeldingen kunnen uploaden. De geuploadde afbeeldingen controleer ik vervolgens op extensie en mime-type en grootte. Volgens mij een waterdicht systeem, en dat was het ook bij mijn laatste tests van maanden geleden.
Inmiddels is de site naar een andere server verhuist .. en .. je raadt het al .. het werkt niet meer. Tenminste.. half!
Als ik een word document upload, dan krijg ik een foutmelding te zien. Goed dus. Ik krijg ook het juiste mime-type te zien. Maar als ik een php-script pak, de extensie verander naar .jpg, en deze upload, dan piept PHP niet. Als ik vervolgens het mime-type van dit bestand echo, krijg ik "image/jpeg" terug. Hoe kan dit?? Waar gaat het mis?

[Sendy]

En wat is voor je computer het verschil tussen twee bestanden met extensie .jpg waarin de ene geen echte jpeg data bevat?!? Oftewel, wat gaat er mis?

[NS_5]

post je PHP foutje ff
dan kunnen we je beter helpen
Oja en je script ook A.u.b...

[ Voor 22% gewijzigd door NS_5 op 08-12-2005 17:34 ]

[Wolf3D]

Het probleem is dat het systeem inmiddels lekker geintegreerd zit met het systeem. De testfase van dit stukje was allang afgerond.

Maargoed, hieronder het controleer script:

PHP:

function check_foto($name, $type, $size)
{
  if ($name)
    {
        if ((!(eregi("(.*\.jpg$|.*\.gif$)", $name))) || (($type !== 'image/pjpeg') && ($type !== 'image/gif') && ($type !== 'image/jpeg')))
        {
            $err = "Het geselecteerde bestand '$name' is geen afbeelding! Selecteer uw afbeeldingen opnieuw...";
        }
        elseif  ($size > 2048000)
        {
            $err = "De bestandsgrootte mag maximaal 2MB zijn! Selecteer uw afbeeldingen opnieuw...";
        }
    }
    return $err;
}

Een foutmelding krijg ik dus niet.... wat wel zou moeten.

[ Voor 8% gewijzigd door Wolf3D op 08-12-2005 17:56 ]

[NMe]

NS_5 schreef op donderdag 08 december 2005 @ 17:33:
post je PHP foutje ff
dan kunnen we je beter helpen

Hij krijgt geen fout, het bestand wordt gewoon doorgelaten.

Oja en je script ook A.u.b...

Nee hoor, het hele script is niet nodig. Alleen het relevante deel is meer dan genoeg.

Heb je ook wat informatie over beide servers en welke versies van welke software ze draaien?

[Verwijderd]

Wolf3D schreef op donderdag 08 december 2005 @ 17:13:
De geuploadde afbeeldingen controleer ik vervolgens op extensie en mime-type en grootte. Volgens mij een waterdicht systeem, en dat was het ook bij mijn laatste tests van maanden geleden.
Inmiddels is de site naar een andere server verhuist .. en .. je raadt het al .. het werkt niet meer. Tenminste.. half!
Als ik een word document upload, dan krijg ik een foutmelding te zien. Goed dus. Ik krijg ook het juiste mime-type te zien. Maar als ik een php-script pak, de extensie verander naar .jpg, en deze upload, dan piept PHP niet. Als ik vervolgens het mime-type van dit bestand echo, krijg ik "image/jpeg" terug. Hoe kan dit?? Waar gaat het mis?

Als je alleen op extensie en mime-type controleert dan moet dit ook op de originele webserver kunnen!

Tenzij je e.o.a. extensie had draaien die keek of de inhoud van het bestand daadwerkelijk klopt.
Om welke webserver praten we?

Edit:
Ik denk het betrouwbaarder is als je controleert op extensie en een .gif/.jpg-header.

[ Voor 6% gewijzigd door Verwijderd op 08-12-2005 17:41 ]

[Wolf3D]

We praten over Apache en PHP versie: 4.4.1. Op de oude server draaide PHP 4.3.11, maar de verhuizing is inmiddels 3 weken geleden. Zou kunnen dat ze inmiddels geupgrade hebben.

Verwijderd schreef op donderdag 08 december 2005 @ 17:39:
[...]
Edit:
Ik denk het betrouwbaarder is als je controleert op extensie en een .gif/.jpg-header.

Is dat niet wat ik nu doe? Dacht ik tenminste ...

[T-MOB]

Om het te beveiligen kun je met behulp van getimagesize() bepalen wat voor een plaatje het is. Die kijkt naar de inhoud van het bestand, en niet naar de extensie. Als je ook andere bestandstypen wil toestaan is het niet zo handig, maar voor plaatjes toch redelijk waterdicht

[NMe]

Wolf3D schreef op donderdag 08 december 2005 @ 17:47:
We praten over Apache en PHP versie: 4.4.1. Op de oude server draaide PHP 4.3.11, maar de verhuizing is inmiddels 3 weken geleden. Zou kunnen dat ze inmiddels geupgrade hebben.

De PHP-versie is hier weinig interessant, de Apache versie boeit me wat meer. Daarnaast is het handig om te weten wat de settings omtrent MIME-types zijn in httpd.conf.

[Sendy]

Volgens mij is hier sprake van een spraakverwarring...

Bij het uploaden wordt er een mimetype meegestuurd. Deze is veelal direct een vertaling van de extensie. Als je dus een bestand renamed weet de server niet wat voor bestand het werkelijk is. Als je dat wel wil moet je op de server kijken wat voor bestand het is. Je kan bijvoorbeeld de tip van T-MOB gebruiken, of het programma "file" op een *nix machine.

Versienummer hebben hiermee weinig te maken; er is namelijk geen bug of vreemde instelling. Ik kan de TS aanraden nog eens goed te kijken naar het "probleem".

[DizzyWeb]

http://nl2.php.net/getimagesize

Gebruik dat anders om de mime-type te bepalen, die kijkt daadwerkelijk in het plaatje.

[edit]
Okay, dat was dus net gezegd, *iets* verder lezen

[ Voor 21% gewijzigd door DizzyWeb op 08-12-2005 22:54 ]

[eamelink]

Sendy schreef op donderdag 08 december 2005 @ 22:49:
Volgens mij is hier sprake van een spraakverwarring...

Bij het uploaden wordt er een mimetype meegestuurd. Deze is veelal direct een vertaling van de extensie. Als je dus een bestand renamed weet de server niet wat voor bestand het werkelijk is. Als je dat wel wil moet je op de server kijken wat voor bestand het is. Je kan bijvoorbeeld de tip van T-MOB gebruiken, of het programma "file" op een *nix machine.

Versienummer hebben hiermee weinig te maken; er is namelijk geen bug of vreemde instelling. Ik kan de TS aanraden nog eens goed te kijken naar het "probleem".

Dat lijkt mij ook.

Hoe weet je dat het vroeger wel werkte Wolf3D? Heb je toen precies dezelfde browser gebruikt? Want als deze versie van de browser die je nu gebruikt voor het mimetype naar de filename kijkt en de vorige niet, dan kan daar een verschil ontstaan .

[edit]

Ik heb het even getest, en een txt filetje die ik rename naar .png wordt zo verstuurd door firefox :

code:

...
Content-Type: multipart/form-data; boundary=---------------------------6897610042718893931024792060
Content-Length: 580
-----------------------------6897610042718893931024792060
Content-Disposition: form-data; name="userfile"; filename="apps.png"
Content-Type: image/png
...

Dus je zult inderdaad GD's mogelijkheden in php moeten gebruiken met getimagesize() voor een betrouwbaar resultaat .

Een andere mogelijkheid is misschien om het 'file' commando te gebruiken als je op een linux bak werkt.

'file' op een échte png geeft :

code:

 PNG image data, 256 x 192, 8-bit/color RGB, non-interlaced

'file' op een nep png geeft :

code:

ASCII text

[ Voor 32% gewijzigd door eamelink op 08-12-2005 23:05 ]

[Wolf3D]

Oké dan! Hartstikke bedankt voor al jullie hulp!

Zoals Sendy hierboven al zei, er was idd sprake van spraakverwarring. Ik las overal dat je niet alleen op extensie moest controleren maar ook op mimetype. Wat ik nergens las was dat het mimetype dat meegestuurd wordt via $_FILES gewoon een directe vertaling was van de extensie en dus niet betrouwbaar is.

getimagesize() heeft het probleem idd verholpen. Wat ik dan niet snap is hoe alles wel heeft kunnen werken op de vorige server!? Of .. hoe het iig leek dat het werkte.

Anyway, het script zoals ie nu is:

PHP:

function check_foto($name, $name_tmp, $type, $size)
{
  if ($name !== "")
  {
    if ((!(eregi("(.*\.jpg$|.*\.gif$)", $name))) || (($type !== 'image/pjpeg') && ($type !== 'image/gif') && ($type !== 'image/jpeg')))
    {
      $err = "Het geselecteerde bestand '$name' is geen afbeelding! Selecteer uw afbeeldingen opnieuw...";
    }
    elseif($size > 2048000)
    {
      $err = "De bestandsgrootte mag maximaal 2MB zijn! Selecteer uw afbeeldingen opnieuw...";
    }
    else
    {
      $image_info = getimagesize($name_tmp);

      switch ($image_info['mime'])
      {
        case 'image/gif':
        {
          // GIF-bestand: Prima dus!
        }
        break;

        case 'image/jpeg':
        {
          // JPG-bestand: Prima dus!
        }
        break;

        default:
        {
          $err = "Het geselecteerde bestand '$name' is geen afbeelding! Selecteer uw afbeeldingen opnieuw...";
        }
      }     
    }
  }
return $err;
}

Ik heb het eerste stuk waarin gekeken wordt naar het mimetype die $_FILES meegeeft laten staan. Hierdoor hoeft imagefilesize() alleen aan het werk indien mensen met bestanden hebben zitten rommelen, zoals gevaarlijke code in afbeeldingen. Bestanden met hele andere mimetypes zoals word-documenten worden al door de eerste IF eruit gehaald.

Indien nog iemand commentaar heeft op bovenstaand script, of als ik toch nog iets over het hoofd heb gezien hoor ik het graag! iig bedankt voor uwen hulp!

[ Voor 6% gewijzigd door Wolf3D op 09-12-2005 10:45 ]

[Wolf3D]

Okee, als jullie er niet op gaan schieten dan zal ik dat zelf maar doen!

Testen is echt een vak, dat blijkt wel! Want bij het uploaden van een afbeelding groter dan 2MB krijg ik wel een foutmelding te zien, maar .. de verkeerde : "Het geselecteerde bestand '$name' is geen afbeelding! Selecteer uw afbeeldingen opnieuw..."

Ik heb inmiddels uitgevonden dat deze melding uit de eerste loop komt, maar snap niet waarom dit gebeurt!? Iemand anders wel?

[AtleX]

De standaard max_upload_size van PHP is 2MB, na die 2MB wordt je upload afgekapt waardoor je een corrupt bestand overhoudt.

[Wolf3D]

Sorry, had er nog bij moeten vermelden dat het volgende staat ingesteld:

upload_max_filesize 16M

Dit verteld phpinfo() mij tenminste...

Wel heb ik bij het uploadform zelf <input type="hidden" name="MAX_FILE_SIZE" value="2048000"> erbij gezet.

[dexonic]

ik gebruik dit om te kijken of er een error opgetreden is tijdens het uploaden..
als $file['error'] == 2 dan is de MAX_FILE_SIZE uit je form overschreden..
nadeel van php blijft dat hij eerst gaat uploaden tot je max upload.. 16M dus meestal...
en drna pas gaat kijken of het je MAX_FILE_SIZE uit je form of je max_upload setting oid overschreden heeft..

mja..

mijn code:

code:

<?php

  $file = $_FILES['bestand'];

  if(error::in($check = $this->checkForUploadError($file)))
  {
    return $check; //error
  }

  function checkForUploadError($file)
  {
    #
    # $file['error'] == 2 MAX_FILE_SIZE uit formulier is overschreden
    #

    if($file['error']==2)
      return new error("Het bestand heeft de limiet overschreden.");

    if($file['error']!=0)
      return new error("Er is een fout opgetreden bij het uploaden.");

    if((int)$file['size']==0)
      return new error("Er is een fout opgetreden bij het uploaden.");

    if(!is_uploaded_file($file['tmp_name']))
      return new error("Het bestand is niet correct geupload");

  }

?>

hopelijk heb je dr wat aan..

[Sendy]

Wel netjes dextronic. Ik zou alleen de error code (file['error']) ook afdrukken in je foutmelding. Dan kan je de fout nog eens opzoeken. In hetzelfde straatje pas natuurlijk de $file['size']==0 error. Schrijf gewoon terug: "Er is een fout opgestreden bij het uploaden: file size is 0".

[OkkE]

Heb je met een bepaalde reden de png-files uitgesloten? Of heb je dat stukje voor het gemak weggelaten?

Owh, en bij je laatste script, zou ik bij jpg-files de volgende case gebruiken:

code:

case 'image/jpeg':
case 'image/pjpeg':

Bij mij worden tenminste soms jpg-files als pjpeg geupload..

[frickY]

Dit heeft te maken met de MIME-lib welke PHP tot zijn beschikking heeft.
Dit is een verzameling van headers waarmee het type bestand kan worden bepaald, door naar de eerste aantal bytes te kijken.

Zie hiervoor http://nl2.php.net/mime_magic
Vergelijk in phpinfo() eens de 3de rij - Configure Command - van beide servers met elkaar. Ik vermoed dat het stukje --with-mime-magic bij je nieuwe server ontbreekt
Het kan ook zijn dat de mime-magic-files gewoon van elkaar verschillen. Deze even kopieëren zou het dan moeten oplossen (zie mime_magic.magicfile in je php.ini).

[ Voor 44% gewijzigd door frickY op 14-12-2005 16:40 ]

[dexonic]

maak anders gewoon array met de verschillende mime-types erin...

kijk of je $file['type'] voorkomt dat array...
ook simpel om uit te breiden als je je array vanuit db opbouwt oid..

code:

<?
if(!in_array($file['type'],array( 'image/jpeg',
                                         'image/pjpeg',
                                         'image/png',
                                         'image/gif')))
{
 // staat niet op de kaart... 
}
else
{
  // ga door...
}
?>

@ sendy
ja je kan het natuurlijk net zo uitgebreid maken als je wilt...
je kan de error gewoon loggen voor jezelf ofzo..

ik vind het beter om het voor de gebruiker niet te moeilijk te maken..
sommigen zijn al blij dat ze ergens kunnen komen op internet laat staan een plaatje uploaden wat op zich dus fout kan gaan..
simpel houden aan de voorkant

[Sendy]

Aan de voorkant ja: "Er is een fout opgetreden bij het uploaden. Error code $file['error']" dus.

Kleine moeite, zeer groot plezier.

[ Voor 27% gewijzigd door Sendy op 14-12-2005 22:59 ]

[Wolf3D]

Het duurde ff, maar dan heb je ook iets!

Het stukje code van dexonic was idd erg handig.
Ik geef nu de waarde van $file['error'] mee aan $error in de functie en controleer of deze gelijk is aan 2. Deze werkte eerst nog niet, maar .. het was gewoon een kwestie van de juiste volgorde gebruiken.
Aangezien de upload idd na 2MB afgekapt wordt is $type dat in de functie gebruikt wordt dus ook leeg. Daarom kreeg ik altijd de bovenste foutmelding. Nu controleer ik gewoon eerst op de file['error] == 2, en daarna check ik pas of het bestand van het juiste formaat is.

PHP:

function check_foto($name, $name_tmp, $type, $size, $error)
{
  if ($name)
    {
      if (!(eregi("(.*\.jpg$|.*\.gif$)", $name)))
      {
        $err = "Het geselecteerde bestand '$name' is geen afbeelding. Selecteer uw afbeeldingen opnieuw...";
      }
      elseif($error == 2)
      {
        $err = "De bestandsgrootte mag maximaal 2MB zijn. Selecteer uw afbeeldingen opnieuw...";
      }
      elseif(($type !== 'image/pjpeg') && ($type !== 'image/gif') && ($type !== 'image/jpeg'))
      {
        $err = "Het geselecteerde bestand '$name' is geen afbeelding. Selecteer uw afbeeldingen opnieuw...";
      }
      elseif($size > 2048000)
      {
        $err = "De bestandsgrootte mag maximaal 2MB zijn. Selecteer uw afbeeldingen opnieuw...";
      }
      else
      {
        $image_info = getimagesize($name_tmp);
        switch ($image_info['mime'])
        {
          case 'image/gif'  :   break;// GIF-bestand: Prima dus!
          case 'image/jpeg' :   break;// JPEG-bestand: Prima dus!
          case 'image/pjpeg':   break;// PJPEG-bestand: Prima dus!
          default: $err = "Het geselecteerde bestand '$name' is geen afbeelding. Selecteer uw afbeeldingen opnieuw...";
        }       
      }
    }
  return $err;
}

Volgens mij controleer ik inmiddels wel dingen dubbelop, maar goed, beter teveel controle dan te weinig....

[ Voor 7% gewijzigd door Wolf3D op 20-12-2005 14:30 ]

[Verwijderd]

Wolf3D schreef op dinsdag 20 december 2005 @ 14:29:
Het duurde ff, maar dan heb je ook iets!

Dan heb je iets waar heel veel aan verbeterd kan worden
Schrijf ten eerste eens logische functies voor al je checks. Dus bijvoorbeeld "isSupportedMimetype", "isSupportedExtension" en "isFileSizeAllowed". En return errors gewoon direct.
Dat wordt dan iets als (pseudo):

code:

if(!isSupportedMimetype($mimetype) || !isSupportedExtension($filename)) {
   return "unsupported file"
}
if(!isFileSizeAllowed($error, $filesize)) {
   return "filesize error"
}
...

[ Voor 6% gewijzigd door Verwijderd op 20-12-2005 14:47 ]

[OkkE]

Ik zou persoonlijk de check op extentie weg laten; Het is niet nodig en mensen met Linux of Mac hebben nog wel eens een afbeelding zonder extentie.

Verder vraag ik mij af waarom je geen PNG files toelaat? Ik gebruik dat persoonlijk op mijn Linux redelijk vaak.

[Wolf3D]

Verwijderd schreef op dinsdag 20 december 2005 @ 14:47:
[...]

Dan heb je iets waar heel veel aan verbeterd kan worden
Schrijf ten eerste eens logische functies voor al je checks. Dus bijvoorbeeld "isSupportedMimetype", "isSupportedExtension" en "isFileSizeAllowed". En return errors gewoon direct.
Dat wordt dan iets als (pseudo):

code:

if(!isSupportedMimetype($mimetype) || !isSupportedExtension($filename)) {
   return "unsupported file"
}
if(!isFileSizeAllowed($error, $filesize)) {
   return "filesize error"
}
...

Is het nuttig om een kleine functie zoals deze op jouw manier te programmeren?
Ik vraag me af of het dan niet heel onoverzichtelijk wordt. Bij grotere functies waarbij stukken code vaker gebruikt gaan worden is het nuttiger, toch? Correct me if i'm wrong!
Het direct returnen van de errors is idd een slimme! Ik neem aan dat de reden is, dat de functie dan meteen stopt, toch?

OkkE schreef op dinsdag 20 december 2005 @ 14:59:
Ik zou persoonlijk de check op extentie weg laten; Het is niet nodig en mensen met Linux of Mac hebben nog wel eens een afbeelding zonder extentie.

Verder vraag ik mij af waarom je geen PNG files toelaat? Ik gebruik dat persoonlijk op mijn Linux redelijk vaak.

Ik ben bang voor Linux en Mac! Verder laat ik geen PNG-files toe, omdat na deze functie de GD-library met de afbeeldingen aan de slag gaat. Van de afbeeldingen wordt een thumbnail gemaakt. Van de jpg een verkleinde jpg en van de gif en kleine gif dus.
Aangezien ik het maken van thumbnails met PNG nog niet getest heb laat ik dit type nog ff niet toe. Maar in de toekomst ga ik er wel naar kijken...

[Verwijderd]

Wolf3D schreef op dinsdag 20 december 2005 @ 15:50:
Is het nuttig om een kleine functie zoals deze op jouw manier te programmeren?
Ik vraag me af of het dan niet heel onoverzichtelijk wordt. Bij grotere functies waarbij stukken code vaker gebruikt gaan worden is het nuttiger, toch? Correct me if i'm wrong!
Het direct returnen van de errors is idd een slimme! Ik neem aan dat de reden is, dat de functie dan meteen stopt, toch?

Het direct returnen is onder andere om van die eindeloze ifelse statements af te komen. Maar het hoofddoel is om in 1 oogopslag duidelijk te maken wat een methode doet. Als je kijkt naar je code is dat niet in een keer duidelijk want er gebeurd vrij veel. Een manier om het overzichtelijk te maken zijn duidelijke functies. Ongeacht of deze vaker worden gebruikt, dat mag het criterium eigenlijk niet zijn.

Als je een leek zou uitleggen wat je methode "check_image" (overigens geen duidelijke naam) doet zou je toch ook zeggen:
- ik controleer of ik het mimetype en de extentie ondersteun
- ik controleer of het bestand niet te groot (of te klein) is.

[T-MOB]

Om nog wat toe te voegen aan wat Mark Platvoet hierboven zegt. Je geeft zelf al aan dat je in de toekomst allicht PNG gaat ondersteunen. Dit heeft niets te maken met de maximale bestandsgrootte. Het zou vanuit die optiek dus al logisch zijn dat je het type plaatje en de grootte daarvan in een andere functie onderbrengt.
Een check op mimetype en daadwerkelijke bestandsformaat zou ik persoonlijk echter wel onderbrengen in dezelfde functie (danwel klasse) omdat ze samenhangen: een plaatje dat een geldig mimetype heeft en een geldige extensie zou ik alleen willen hebben als ze overeenkomen. Als er aan de clientkant mee gerommeld is dan betekent het immers ook vaak gerommel op de server...