best way to determine if a URL is an image in PHP

Php Problem Overview

Using PHP, given a URL, how can I determine whether it is an image?

There is no context for the URL - it is just in the middle of a plain text file, or maybe just a string on its own.

I don't want high overhead (e.g. reading the content of the URL) as this could be called for many URLs on a page. Given this restriction, it isn't essential that all images are identified, but I would like a fairly good guess.

At the moment I am just looking at the file extension, but it feels like there should be a better way than this.

Here is what I currently have:

  function isImage( $url )
  {
    $pos = strrpos( $url, ".");
	if ($pos === false)
	  return false;
	$ext = strtolower(trim(substr( $url, $pos)));
	$imgExts = array(".gif", ".jpg", ".jpeg", ".png", ".tiff", ".tif"); // this is far from complete but that's always going to be the case...
	if ( in_array($ext, $imgExts) )
	  return true;
    return false;
  }

Edit: In case it's useful to anybody else here is the final function using the technique from Emil H's answer:

  function isImage($url)
  {
     $params = array('http' => array(
                  'method' => 'HEAD'
               ));
     $ctx = stream_context_create($params);
     $fp = @fopen($url, 'rb', false, $ctx);
     if (!$fp) 
        return false;  // Problem with url

    $meta = stream_get_meta_data($fp);
    if ($meta === false)
    {
        fclose($fp);
        return false;  // Problem reading data from url
    }
     
    $wrapper_data = $meta["wrapper_data"];
    if(is_array($wrapper_data)){
      foreach(array_keys($wrapper_data) as $hh){
          if (substr($wrapper_data[$hh], 0, 19) == "Content-Type: image") // strlen("Content-Type: image") == 19 
          {
            fclose($fp);
            return true;
          }
      }
    }
    
    fclose($fp);
    return false;
  }

Php Solutions

Solution 1 - Php

You could use an HTTP HEAD request and check the content-type. This might be a good compromise. It can be done using PHP Streams. Wez Furlong has an article that shows how to use this approach to send post requests, but it can be easily adapted to send HEAD requests instead. You can retrieve the headers from an http response using stream_get_meta_data().

Of course this isn't really 100%. Some servers send incorrect headers. It will however handle cases where images are delivered through a script and the correct file extension isn't available. The only way to be really certain is to actually retrieve the image - either all of it, or the first few bytes, as suggested by thomasrutter.

Solution 2 - Php

if(is_array(getimagesize($urlImg)))
	echo 'Yes it is an image!';

Solution 3 - Php

There are a few different approaches.

Sniff the content by looking for a magic number at the start of the file. For example, GIF uses GIF87 or GIF89 as the first five bytes of the file (in ascii). Unfortunately this can't tell you if there's an error in the image or if the image contains malicious content. Here are some magic numbers for various types of image files (feel free to use these):

"\xff\xd8\xff" => 'image/jpeg',
"\x89PNG\x0d\x0a\x1a\x0a" => 'image/png',
"II*\x00" => 'image/tiff',
"MM\x00*" => 'image/tiff',
"\x00\x00\x01\x00" => 'image/ico',
"\x00\x00\x02\x00" => 'image/ico',
"GIF89a" => 'image/gif',
"GIF87a" => 'image/gif',
"BM" => 'image/bmp',

Sniffing the content like this is probably going to fit your requirements best; you'll only have to read and therefore download the first few bytes of the file (past the header).

Load the image using the GD library to see if it loads without error. This can tell you if the image is valid, without error or not. Unfortunately this probably doesn't fit your requirements because it requires downloading the complete image.
If you really don't want to make an HTTP request for the image at all, then this rules out both sniffing and getting HTTP headers. You can, however, try to determine whether something is an image by the context in which it is linked. Something linked using a src attribute in an <img element is almost certainly an image (or an attempt at XSS, but that's another story). This will tell you if something is intended as an image. It won't tell you whether the image is actually available, or valid; you'll have to fetch at least the first small part (header or magic number) of the image URL to find that.

Unfortunately, it is possible for a file to be both a valid image as well as a ZIP file containing harmful content which could be executed as Java by a harmful site - see the GIFAR exploit. You can almost certainly prevent this vulnerability by loading the image in a library like GD and performing some non-trivial filter on it, like softening or sharpening it a tiny amount (ie using a convolution filter) and saving it to a fresh file without transferring any metadata across.

Trying to determine if something is an image by its content-type alone is quite unreliable, almost as unreliable as checking the file extension. When loading an image using an <img element, browsers sniff for a magic string.

Solution 4 - Php

In addition to Emil H's answer:

Using get_headers() to check the content type of an url without downloading the entire file with getimagesize()

	$url_headers=get_headers($url, 1);
	
	if(isset($url_headers['Content-Type'])){
		
		$type=strtolower($url_headers['Content-Type']);
		
		$valid_image_type=array();
		$valid_image_type['image/png']='';
		$valid_image_type['image/jpg']='';
		$valid_image_type['image/jpeg']='';
		$valid_image_type['image/jpe']='';
		$valid_image_type['image/gif']='';
		$valid_image_type['image/tif']='';
		$valid_image_type['image/tiff']='';
		$valid_image_type['image/svg']='';
		$valid_image_type['image/ico']='';
		$valid_image_type['image/icon']='';
		$valid_image_type['image/x-icon']='';
		
		if(isset($valid_image_type[$type])){

			//do something

		}
	}

Solution 5 - Php

Edit: For static images with popular image extension.

<?php
$imgExts = array("gif", "jpg", "jpeg", "png", "tiff", "tif");
$url ='path/to/image.png';
$urlExt = pathinfo($url, PATHINFO_EXTENSION);
if (in_array($urlExt, $imgExts)) {
    echo 'Yes, '.$url.' is an Image';
}

?>

Solution 6 - Php

Similar to some given answer but with a slightly different logic.

$headers = @get_headers($url, 1); // @ to suppress errors. Remove when debugging.
if (isset($headers['Content-Type'])) {
  if (strpos($headers['Content-Type'], 'image/') === FALSE) {
    // Not a regular image (including a 404).
  }
  else {
    // It's an image!
  }
}
else {
  // No 'Content-Type' returned.
}

@ is an error control operator.

Note we used the "strict" operator === FALSE in the condition because strpos($headers['Content-Type'], 'image/') does return 0 in our use case if the needle is found in the haystack. With type casting using == that would erroneously be interpreted as FALSE.

Solution 7 - Php

we can use exif_imagetype to check the image type, so it's not allow to any other content types. It only allow images and we can restrict them to few image types, following sample code show how to allow GIF image type.

if (exif_imagetype('image.gif') != IMAGETYPE_GIF) {
    echo 'The picture is not a gif';
}

You can use following image types,

 IMAGETYPE_GIF
 IMAGETYPE_JPEG
 IMAGETYPE_PNG
 IMAGETYPE_SWF
 IMAGETYPE_PSD
 IMAGETYPE_BMP
 IMAGETYPE_TIFF_II (intel byte order)
 IMAGETYPE_TIFF_MM (motorola byte order)
 IMAGETYPE_JPC
 IMAGETYPE_JP2
 IMAGETYPE_JPX
 IMAGETYPE_JB2
 IMAGETYPE_SWC
 IMAGETYPE_IFF
 IMAGETYPE_WBMP
 IMAGETYPE_XBM
 IMAGETYPE_ICO

more details : link

Solution 8 - Php

Fast Solution for broken or not found images link
i recommend you that don't use getimagesize() because it will 1st download image then it will check images size+if this will not image then it will throw exception so use below code

if(checkRemoteFile($imgurl))
{
//found url, its mean
echo "this is image";
}

function checkRemoteFile($url)
{
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL,$url);
    // don't download content
    curl_setopt($ch, CURLOPT_NOBODY, 1);
    curl_setopt($ch, CURLOPT_FAILONERROR, 1);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    if(curl_exec($ch)!==FALSE)
    {
        return true;
    }
    else
    {
        return false;
    }
}

Note: this current code help you to identify broken or not found url image this will not help you to identify image type or headers

Content Type	Original Author	Original Content on Stackoverflow
Question	danio	View Question on Stackoverflow
Solution 1 - Php	Emil H	View Answer on Stackoverflow
Solution 2 - Php	Pedro Soares	View Answer on Stackoverflow
Solution 3 - Php	thomasrutter	View Answer on Stackoverflow
Solution 4 - Php	RafaSashi	View Answer on Stackoverflow
Solution 5 - Php	TheMonkeyKing	View Answer on Stackoverflow
Solution 6 - Php	Martin Postma	View Answer on Stackoverflow
Solution 7 - Php	Janith Chinthana	View Answer on Stackoverflow
Solution 8 - Php	Hassan Saeed	View Answer on Stackoverflow