在web开发中,我们经常遇到一些上传文件的功能, 我们在对文件进行校验时,除了对文件大小进行校验外,还需要对文件的格式进行校验. 在对格式校验的时候要考虑到用户或者攻击者对文件后缀进行的改变,导致上传的文件并不是我们需要的类型,从而对系统造成影响.

我们可以对常用的文件进行校验,如图片格式, 压缩格式,office word,Excel格式,以及其他文件的格式进行校验.
代码如下:

import java.io.*;
import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName FileFormatVerify
 * @Description  图片 pdf/wored/excel和各种压缩格式的校验
 **/
public class FileFormatVerify {

    private static  Map<String, Object> fileFormat = null;

    /**
     * @Description  将常用需要校验的格式和区别其他格式的前几个字节写入map
     * @Param []
     * @return
     **/
   public  FileFormatVerify (){
       //if(fileFormat == null ){
           fileFormat = new HashMap<String, Object>();

           //JPEG
           fileFormat.put("jpg","FFD8FFE0");
           //PNG
           fileFormat.put("png","89504E47");
           fileFormat.put("zip","504B0304");
           fileFormat.put("rar","52617221");
           //office类型，包括doc、xls和ppt
//           fileFormat.put("office","D0CF11E0");
           /**
            * docx ,xlsx和zip   相同  doc 和 xls 相同
            */
           fileFormat.put("docx","504b0304");
           fileFormat.put("doc","d0cf11e0");

           fileFormat.put("xls","d0cf11e0");
           fileFormat.put("xlsx","504b0304");
           //fileFormat.put("pdf","255044462D312E");
           fileFormat.put("pdf","255044462");
      // }
   }

    /**
     * @Description 根据传入的文件获得后缀,获得指定文件格式byte[]数组中的前8位字符
     *              将传入文件转化为byte[]数组,取前8位.判断传入文件的前8位和我们指定好的文件byte[]的前8位是否相同,
     *              如果相同则文件格式没有被篡改,反之,文件后缀格式被篡改
     * @Param [file]
     * @return boolean 返回true 表示文件格式验证通过, 返回false 文件格式验证失败
     **/
    public boolean suffixVerify(File file){
        String fileType = "";
        String name = file.getName();
        int i = name.lastIndexOf(".");
        // 获取文件的后缀
        if(i > 0){
             fileType = name.substring(i + 1);
        }
        //根据文件的后缀获取,获取文件的byte[]的前8位
        if(fileFormat.containsKey(fileType.toLowerCase())){
            String fileByte8 = String.valueOf(fileFormat.get(fileType.toLowerCase()));
            //获取传入文件的byte[]的前8位
            byte[] bytes = inputStream2ByteArray(file);
            String compareByte = bytesToHexString(bytes);
            //如果传入文件的byte[]的前8位和我们定义好的byte[]的前8位相同,验证通过.
            if (compareByte.startsWith(fileByte8)){
                //如果格式校验成功
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }


    /**
     * @Description  将file文件转化为byte[]
     * @Param [file]
     * @return byte[]
     **/   
    public  byte[] inputStream2ByteArray(File file){
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        FileInputStream fis = null;
        byte[] buffer = null;

        try {
            fis = new FileInputStream(file);


            //不用读取全部文件,只读文件前面的部分
            byte[] b = new byte[1024];
            fis.read(b);
            bos.write(b, 0, 1024);


            /**
            byte[] b = new byte[4];
            int n;
            while ((n = fis.read(b)) != -1){
               bos.write(b, 0, n);
            }
            */
            buffer = bos.toByteArray();
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e1){
            e1.printStackTrace();
        }finally {
            try {
                if(fis !=null){
                    fis.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
            try {
                if(bos !=null){
                    bos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        return buffer;
    }


    /**
     * @Description  取byte[]前8位的为字符串
     * @Param [src]
     * @return java.lang.String
     **/
    public  String bytesToHexString(byte[] src) {
        StringBuilder stringBuilder = new StringBuilder();
        if (src == null || src.length <= 0) {
            return null;
        }
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        //return stringBuilder.toString().substring(0, 8);
        return stringBuilder.toString();
    }


}

写一个测试类,测试是否有效.

import org.junit.Test;
import java.io.File;

/**
 * @ClassName TestFileFormatVerify
 * @Description 测试FileFormatVerify类
 * @Author sun
 * Date 2019/5/8 14:57
 * @Version 1.0
 **/
public class TestFileFormatVerify {

    /**
     * @Description 测试传入参数后缀是否有篡改
     * @Param []
     * @return void
     **/
    @Test
    public void TestSuffixReg(){
        FileFormatVerify reg = new FileFormatVerify();
        File file = new File("E:\\ideaFile\\RegEx\\src\\1.xlsx");

        if (file.isFile() && file.exists()){

            boolean b = reg.suffixVerify(file);
            System.out.println(b);

        }

    }

    /**
 
     * @Description 查看传入文件格式的前几位字符
     * @Param []
     * @return void
     **/
     @Test
    public void CheckFileByte8(){
        FileFormatVerify reg = new FileFormatVerify();
        File file = new File("E:\\ideaFile\\RegEx\\src\\1.xlsx");

        byte[] bytes = reg.inputStream2ByteArray(file);
        String s = reg.bytesToHexString(bytes);
        System.out.println(s);
    }
}

注意:txt文件是一个纯文本文件,它的头文件字符是不固定的.
可以用测试类中的CheckFileByte8()方法. 对一个txt文件,改变其内容来查看它的头文件字符.

我们仅仅通过对文件后缀格式的校验,并不能保证上传文件是安全的.
本篇文章也是参考 太阳守护者Sunner.
这篇文章有有关图片的更加安全的校验方式. 可以参考帮助我们加强对上传文件的安全控制.

1、创建测试类（FileUtils.java）

package com.jeff.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileUtils {

	public static final String TYPE_JPG = "jpg";
	public static final String TYPE_GIF = "gif";
	public static final String TYPE_PNG = "png";
	public static final String TYPE_BMP = "bmp";
	public static final String TYPE_UNKNOWN = "unknown";

	/**
	 * 
	 * @description: 根据文件流判断图片类型
	 * @author: Jeff
	 * @date: 2019年12月7日
	 * @param fis 文件输入流
	 * @return
	 */
	public static String getPicType(FileInputStream fis) {
		// 读取文件的前几个字节来判断图片格式
		byte[] b = new byte[4];
		try {
			fis.read(b, 0, b.length);
			String type = bytesToHexString(b).toUpperCase();
			if (type.contains("FFD8FF")) {
				return TYPE_JPG;
			} else if (type.contains("89504E47")) {
				return TYPE_PNG;
			} else if (type.contains("47494638")) {
				return TYPE_GIF;
			} else if (type.contains("424D")) {
				return TYPE_BMP;
			} else {
				return TYPE_UNKNOWN;
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return null;
	}

	/**
	 * 
	 * @description: byte数组转换成16进制字符串
	 * @author: Jeff
	 * @date: 2019年12月7日
	 * @param src
	 * @return
	 */
	public static String bytesToHexString(byte[] src) {
		StringBuilder stringBuilder = new StringBuilder();
		if (src == null || src.length <= 0) {
			return null;
		}
		for (int i = 0; i < src.length; i++) {
			int v = src[i] & 0xFF;
			String hv = Integer.toHexString(v);
			if (hv.length() < 2) {
				stringBuilder.append(0);
			}
			stringBuilder.append(hv);
		}
		return stringBuilder.toString();
	}

	public static void main(String[] args) {
		try {
			System.out.println("图片1格式： " + getPicType(new FileInputStream(new File("F:\\Jeff\\images\\jie.jpg"))));
			System.out.println("图片2格式： " + getPicType(new FileInputStream(new File("F:\\Jeff\\images\\1.png"))));
			System.out.println("图片3格式： " + getPicType(new FileInputStream(new File("F:\\Jeff\\images\\2.gif"))));
			System.out.println("图片4格式： " + getPicType(new FileInputStream(new File("F:\\Jeff\\images\\3.bmp"))));
			System.out.println("图片5格式： " + getPicType(new FileInputStream(new File("F:\\Jeff\\images\\jie.png"))));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
	}

}

2、控制台输出结果