Java判斷文件類型

1. 通過後綴名，如exe,jpg,bmp,rar,zip等等。

2. 通過讀取文件，獲取文件的Content-type來判斷。

3. 通過讀取文件流，根據文件流中特定的一些字節標識來區分不同類型的文件。

4. 若是圖片，則通過縮放來判斷，可以縮放的為圖片，不可以的則不是。

然而，在安全性較高的業務場景中，1，2兩種方法的校驗會被輕易繞過。

1. 偽造後綴名，如圖片的，非常容易修改。

2. 偽造文件的Content-type，這個稍微復雜點，為了直觀，截圖如下： 

3.較安全，但是要讀取文件，並有16進制轉換等操作，性能稍差，但能滿足一定條件下對安全的要求，所以建議使用。

  但是文件頭的信息也可以偽造，截圖如下，對於圖片可以采用圖片縮放或者獲取圖片寬高的方法避免偽造頭信息漏洞。

                              被偽裝成gif的惡意圖片文件

對應的Java代碼如下：

1. package apistudy;    
2.     
3. import java.awt.image.BufferedImage;  
4. import java.io.File;  
5. import java.io.FileInputStream;  
6. import java.io.FileNotFoundException;  
7. import java.io.IOException;  
8. import java.io.InputStream;  
9. import java.util.HashMap;  
10. import java.util.Iterator;  
11. import java.util.Map;  
12. import java.util.Map.Entry;  
13. import javax.imageio.ImageIO;  
14. import javax.imageio.ImageReader;  
15. import javax.imageio.stream.ImageInputStream;  
16.     
17. public class FileTypeTest    
18. {    
19.     public final static Map<String, String> FILE_TYPE_MAP = new HashMap<String, String>();    
20.         
21.     private FileTypeTest(){}    
22.     static{    
23.         getAllFileType();  //初始化文件類型信息     
24.     }    
25.         
26.     /**  
27.      * Created on 2010-7-1   
28.      * <p>Discription:[getAllFileType,常見文件頭信息]</p>  
29.      * @author:[[email protected]]  
30.      */    
31.     private static void getAllFileType()    
32.     {    
33.         FILE_TYPE_MAP.put("jpg", "FFD8FF"); //JPEG (jpg)     
34.         FILE_TYPE_MAP.put("png", "89504E47");  //PNG (png)     
35.         FILE_TYPE_MAP.put("gif", "47494638");  //GIF (gif)     
36.         FILE_TYPE_MAP.put("tif", "49492A00");  //TIFF (tif)     
37.         FILE_TYPE_MAP.put("bmp", "424D"); //Windows Bitmap (bmp)     
38.         FILE_TYPE_MAP.put("dwg", "41433130"); //CAD (dwg)     
39.         FILE_TYPE_MAP.put("html", "68746D6C3E");  //HTML (html)     
40.         FILE_TYPE_MAP.put("rtf", "7B5C727466");  //Rich Text Format (rtf)     
41.         FILE_TYPE_MAP.put("xml", "3C3F786D6C");    
42.         FILE_TYPE_MAP.put("zip", "504B0304");    
43.         FILE_TYPE_MAP.put("rar", "52617221");    
44.         FILE_TYPE_MAP.put("psd", "38425053");  //Photoshop (psd)     
45.         FILE_TYPE_MAP.put("eml", "44656C69766572792D646174653A");  //Email [thorough only] (eml)     
46.         FILE_TYPE_MAP.put("dbx", "CFAD12FEC5FD746F");  //Outlook Express (dbx)     
47.         FILE_TYPE_MAP.put("pst", "2142444E");  //Outlook (pst)     
48.         FILE_TYPE_MAP.put("xls", "D0CF11E0");  //MS Word     
49.         FILE_TYPE_MAP.put("doc", "D0CF11E0");  //MS Excel 注意：word 和 excel的文件頭一樣     
50.         FILE_TYPE_MAP.put("mdb", "5374616E64617264204A");  //MS Access (mdb)     
51.         FILE_TYPE_MAP.put("wpd", "FF575043"); //WordPerfect (wpd)      
52.         FILE_TYPE_MAP.put("eps", "252150532D41646F6265");    
53.         FILE_TYPE_MAP.put("ps", "252150532D41646F6265");    
54.         FILE_TYPE_MAP.put("pdf", "255044462D312E");  //Adobe Acrobat (pdf)     
55.         FILE_TYPE_MAP.put("qdf", "AC9EBD8F");  //Quicken (qdf)     
56.         FILE_TYPE_MAP.put("pwl", "E3828596");  //Windows Password (pwl)     
57.         FILE_TYPE_MAP.put("wav", "57415645");  //Wave (wav)     
58.         FILE_TYPE_MAP.put("avi", "41564920");    
59.         FILE_TYPE_MAP.put("ram", "2E7261FD");  //Real Audio (ram)     
60.         FILE_TYPE_MAP.put("rm", "2E524D46");  //Real Media (rm)     
61.         FILE_TYPE_MAP.put("mpg", "000001BA");  //     
62.         FILE_TYPE_MAP.put("mov", "6D6F6F76");  //Quicktime (mov)     
63.         FILE_TYPE_MAP.put("asf", "3026B2758E66CF11"); //Windows Media (asf)     
64.         FILE_TYPE_MAP.put("mid", "4D546864");  //MIDI (mid)     
65.     }    
66.     
67.     public static void main(String[] args) throws Exception    
68.     {    
69.         File f = new File("c://aaa.gif");    
70.         if (f.exists())    
71.         {    
72.             String filetype1 = getImageFileType(f);    
73.             System.out.println(filetype1);    
74.             String filetype2 = getFileByFile(f);    
75.             System.out.println(filetype2);    
76.         }    
77.     }    
78.     
79.     /**  
80.      * Created on 2010-7-1   
81.      * <p>Discription:[getImageFileType,獲取圖片文件實際類型,若不是圖片則返回null]</p>  
82.      * @param File  
83.      * @return fileType  
84.      * @author:[[email protected]]  
85.      */    
86.     public final static String getImageFileType(File f)    
87.     {    
88.         if (isImage(f))  
89.         {  
90.             try  
91.             {  
92.                 ImageInputStream iis = ImageIO.createImageInputStream(f);  
93.                 Iterator<ImageReader> iter = ImageIO.getImageReaders(iis);  
94.                 if (!iter.hasNext())  
95.                 {  
96.                     return null;  
97.                 }  
98.                 ImageReader reader = iter.next();  
99.                 iis.close();  
100.                 return reader.getFormatName();  
101.             }  
102.             catch (IOException e)  
103.             {  
104.                 return null;  
105.             }  
106.             catch (Exception e)  
107.             {  
108.                 return null;  
109.             }  
110.         }  
111.         return null;  
112.     }    
113.     
114.     /**  
115.      * Created on 2010-7-1   
116.      * <p>Discription:[getFileByFile,獲取文件類型,包括圖片,若格式不是已配置的,則返回null]</p>  
117.      * @param file  
118.      * @return fileType  
119.      * @author:[[email protected]]  
120.      */    
121.     public final static String getFileByFile(File file)    
122.     {    
123.         String filetype = null;    
124.         byte[] b = new byte[50];    
125.         try    
126.         {    
127.             InputStream is = new FileInputStream(file);    
128.             is.read(b);    
129.             filetype = getFileTypeByStream(b);    
130.             is.close();    
131.         }    
132.         catch (FileNotFoundException e)    
133.         {    
134.             e.printStackTrace();    
135.         }    
136.         catch (IOException e)    
137.         {    
138.             e.printStackTrace();    
139.         }    
140.         return filetype;    
141.     }    
142.         
143.     /**  
144.      * Created on 2010-7-1   
145.      * <p>Discription:[getFileTypeByStream]</p>  
146.      * @param b  
147.      * @return fileType  
148.      * @author:[[email protected]]  
149.      */    
150.     public final static String getFileTypeByStream(byte[] b)    
151.     {    
152.         String filetypeHex = String.valueOf(getFileHexString(b));    
153.         Iterator<Entry<String, String>> entryiterator = FILE_TYPE_MAP.entrySet().iterator();    
154.         while (entryiterator.hasNext()) {    
155.             Entry<String,String> entry =  entryiterator.next();    
156.             String fileTypeHexValue = entry.getValue();    
157.             if (filetypeHex.toUpperCase().startsWith(fileTypeHexValue)) {    
158.                 return entry.getKey();    
159.             }    
160.         }    
161.         return null;    
162.     }    
163.         
164.     /** 
165.      * Created on 2010-7-2  
166.      * <p>Discription:[isImage,判斷文件是否為圖片]</p> 
167.      * @param file 
168.      * @return true 是 | false 否 
169.      * @author:[[email protected]] 
170.      */  
171.     public static final boolean isImage(File file){  
172.         boolean flag = false;  
173.         try  
174.         {  
175.             BufferedImage bufreader = ImageIO.read(file);  
176.             int width = bufreader.getWidth();  
177.             int height = bufreader.getHeight();  
178.             if(width==0 || height==0){  
179.                 flag = false;  
180.             }else {  
181.                 flag = true;  
182.             }  
183.         }  
184.         catch (IOException e)  
185.         {  
186.             flag = false;  
187.         }catch (Exception e) {  
188.             flag = false;  
189.         }  
190.         return flag;  
191.     }  
192.       
193.     /**  
194.      * Created on 2010-7-1   
195.      * <p>Discription:[getFileHexString]</p>  
196.      * @param b  
197.      * @return fileTypeHex  
198.      * @author:[[email protected]]  
199.      */    
200.     public final static String getFileHexString(byte[] b)    
201.     {    
202.         StringBuilder stringBuilder = new StringBuilder();    
203.         if (b == null || b.length <= 0)    
204.         {    
205.             return null;    
206.         }    
207.         for (int i = 0; i < b.length; i++)    
208.         {    
209.             int v = b[i] & 0xFF;    
210.             String hv = Integer.toHexString(v);    
211.             if (hv.length() < 2)    
212.             {    
213.                 stringBuilder.append(0);    
214.             }    
215.             stringBuilder.append(hv);    
216.         }    
217.         return stringBuilder.toString();    
218.     }    
219. }  

這樣，不管是傳入的文件有後綴名，還是無後綴名，或者修改了後綴名，真正獲取到的才是該文件的實際類型，這樣避免了一些想通過修改後綴名或者Content-type信息來攻擊的因素。但是性能與安全永遠是無法同時完美的，安全的同時付出了讀取文件的代價。本人建議可采用後綴名與讀取文件的方式結合校驗，畢竟攻擊是少數，後綴名的校驗能排除大多數用戶，在後綴名獲取不到時再通過獲取文件真實類型校驗，這樣來適當提高性能。