文件上传加密
在很多应用场景中，出于安全考虑，我们不得不实行上传文件时对文件进行加密，
存入服务器的文件就会变成二进制文件，当别人直接冲服务器拿到文件时，也无法查看，这就保证了安全性。
但是我们需要在页面上查看自己上传的文件，这时候就需要再次请求服务器文件的解密接口，
通过解密代码，获得原来的图片，这样对于一些银行等相关业务可有效的保证安全性。
首先导入文件加密解密工具类
public class AES {
/**
* 块大小固定为8字节
*/
private final static String AES_CBC_PKCS5PADDING = "AES/ECB/PKCS5Padding";
/**
* KeyGenerator Init params
*/
private final static int KGEN_256 = 256;
private final static String SHA_256 = "SHA-256";
private final static String S_KEY = "9538172738539384";
private final static String SHA1PRNG = "SHA1PRNG";
// private static AlgorithmParameters params = null;
/**
* 字符串加密
* @param content
* @return
*/
public static String encrypt(String content) {
if (StringUtils.isNotBlank(content)) {
try {
byte[] byteContent = content.getBytes(Constant.ConfigConsts.ENCODE_UTF_8);
byte[] cryptograph = getCipher(Cipher.ENCRYPT_MODE, S_KEY).doFinal(byteContent);
return new Base64().encodeToString(cryptograph);
} catch (Exception e) {
e.printStackTrace();
}
}
return "";
}
/**
* 字符串解密
* @param content
* @return
*/
public static String decrypt(String content) {
if (StringUtils.isNotBlank(content)) {
try {
byte[] byteContent = new Base64().decode(content);
byte[] result = getCipher(Cipher.DECRYPT_MODE, S_KEY).doFinal(byteContent);
return new String(result);
} catch (Exception e) {
e.printStackTrace();
}
}
return "";
}
/**
* 通过Skey得到秘钥算法对象
* @param sKey
* @return
*/
private static SecretKeySpec getSecretKeySpec (String sKey) {
SecretKeySpec key = null;
try {
//"AES"：请求的密钥算法的标准名称
KeyGenerator kgen = KeyGenerator.getInstance(Constant.ConfigConsts.SECRET_AES);
//256：密钥生成参数；securerandom：密钥生成器的随机源
SecureRandom securerandom = SecureRandom.getInstance(SHA1PRNG);
securerandom.setSeed(sKey.getBytes());
kgen.init(KGEN_256, securerandom);
//生成秘密（对称）密钥
SecretKey secretKey = kgen.generateKey();
//返回基本编码格式的密钥
byte[] enCodeFormat = secretKey.getEncoded();
//根据给定的字节数组构造一个密钥。enCodeFormat：密钥内容；"AES"：与给定的密钥内容相关联的密钥算法的名称
key = new SecretKeySpec(enCodeFormat, Constant.ConfigConsts.SECRET_AES);
//将提供程序添加到下一个可用位置
Security.addProvider(new BouncyCastleProvider());
} catch (Exception e) {
e.printStackTrace();
}
return key;
}
/**
* get Cipher
* @param mode
* @param sKey
* @return
*/
private static Cipher getCipher(int mode, String sKey) {
byte[] IV = new byte[16];
SecureRandom random = new SecureRandom();
random.nextBytes(IV);
Cipher cipher = null;
try {
// params = AlgorithmParameters.getInstance("IV", "LunaProvider");
// params.init(new IvParameterSpec(IV));
cipher = Cipher.getInstance(AES_CBC_PKCS5PADDING);
cipher.init(mode, getSecretKeySpec(sKey));
} catch(Exception e) {
e.printStackTrace();
}
return cipher;
}
/**
* 上传文件加密(传入文件流，输出流对象后直接处理即加密文件流后存储文件)
* @param inputStream
* @param outputStream
* @return
*/
public static boolean encryptFile(InputStream inputStream, OutputStream outputStream) {
try {
CipherInputStream cipherInputStream = new CipherInputStream(
inputStream, getCipher(Cipher.ENCRYPT_MODE, S_KEY));
byte[] cache = new byte[1024];
int nRead = 0;
while ((nRead = cipherInputStream.read(cache)) != -1) {
outputStream.write(cache, 0, nRead);
outputStream.flush();
}
cipherInputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
return true;
}
/**
* **上传文件加密(传入字节，加密后返回字节)**
* @param plainFile
* @return
* @throws Exception
*/
public static byte[] encryptFile(byte[] plainFile) throws Exception {
byte[] cipherText = getCipher(Cipher.ENCRYPT_MODE, S_KEY).doFinal(plainFile);
return cipherText;
}
/**
* 下载文件解密(传入文件流，输出流对象后直接处理即解密文件流后输出文件)
* @param inputStream
* @param outputStream
* @return
*/
public static boolean decryptFile(InputStream inputStream, OutputStream outputStream) {
try {
CipherOutputStream cipherOutputStream = new CipherOutputStream(
outputStream, getCipher(Cipher.DECRYPT_MODE, S_KEY));
byte[] buffer = new byte[1024];
int r;
while ((r = inputStream.read(buffer)) >= 0) {
cipherOutputStream.write(buffer, 0, r);
}
cipherOutputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
return true;
}
/**
* 下载文件解密(传入字节，解密后返回字节)
* @param cipherFile
* @return
* @throws Exception
*/
public static byte[] decryptFile(byte[] cipherFile) throws Exception {
byte[] cipherText = getCipher(Cipher.DECRYPT_MODE, S_KEY).doFinal(cipherFile);
return cipherText;
}
/**
* 获得指定文件的byte数组
*/
private static byte[] getBytes(String filePath){
byte[] buffer = null;
try {
File file = new File(filePath);
FileInputStream fis = new FileInputStream(file);
ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
byte[] b = new byte[1000];
int n;
while ((n = fis.read(b)) != -1) {
bos.write(b, 0, n);
}
fis.close();
bos.close();
buffer = bos.toByteArray();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return buffer;
}
/**
* 根据byte数组，生成文件
*/
public static void getFile(byte[] bfile, String filePath,String fileName) {
BufferedOutputStream bos = null;
FileOutputStream fos = null;
File file = null;
try {
File dir = new File(filePath);
if(!dir.exists()&&dir.isDirectory()){ //判断文件目录是否存在
dir.mkdirs();
}
file = new File(filePath+"\\"+fileName);
fos = new FileOutputStream(file);
bos = new BufferedOutputStream(fos);
bos.write(bfile);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (bos != null) {
try {
bos.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
}
在这个工具方法中，我们使用 encryptFile(InputStream inputStream, OutputStream outputStream)对文件加密，在这个方法中需要把文件转成流的形式，并以byte【】的形式输出到指定位置。其中用到了类CipherInputStream，CipherInputStream由InputStream和Cipher组成，它允许我们自定义一个key，同时把key的信息揉进文件流中。解密的时候再次输入key，才能完成解密。
文件上传加密代码
@RequestMapping(value = "/upload", method = RequestMethod.POST)
public RtnResult springUpload(HttpServletRequest request) throws IllegalStateException, IOException {
RtnResult result = new RtnResult(RtnResultCode.SUCCESS);
Map<String, String> map = new HashMap<>();
// 将request变成多部分request
MultipartHttpServletRequest multiRequest = (MultipartHttpServletRequest) request;
// 获取multiRequest 中所有的文件名
Iterator iter = multiRequest.getFileNames();
while (iter.hasNext()) {
//一次遍历所有文件
MultipartFile file = multiRequest.getFile(iter.next().toString());
if (file != null) {
// 取得当前上传文件的文件名称
String originalFileName = file.getOriginalFilename().replace(",", ";");
// 文件名前缀
int lastIndexOf = originalFileName.lastIndexOf(".");
String name = originalFileName;
String extension = "";
if (lastIndexOf != -1) {
name = originalFileName.substring(0, originalFileName.lastIndexOf("."));
extension = originalFileName.substring(originalFileName.lastIndexOf(".") + 1);
}
if (!extension.equalsIgnoreCase("png") && !extension.equalsIgnoreCase("jpg")
&& !extension.equalsIgnoreCase("jpeg") && !extension.equalsIgnoreCase("gif")
&& !extension.equalsIgnoreCase("pdf") && !extension.equalsIgnoreCase("xlsx")
&& !extension.equalsIgnoreCase("lsx") && !extension.equalsIgnoreCase("docx")
&& !extension.equalsIgnoreCase("doc")) {
return RtnResult.Fail(RtnResultCode.FILE_TYPE_ERROR);
}
// 时间戳
long timeStr = (new Date()).getTime();
// 4位随机数
int random = new Random().nextInt(10000);
// 文件后缀名
String fileName =timeStr + random + "." + extension;
//上传
String dateStr = DateUtils.getDateTime("yyyyMMdd");
//上传 ,替代掉常量类中的数据
String path = PathConstants.DIRECTORY_UPLOAD_TEMP_SUB
.replace("{yyyyMMdd}", dateStr)
.replace("{fileName}", fileName);
File temp = new File(configProperties.getFileLocation() + PathConstants.DIRECTORY_UPLOAD_TEMP + path);
if (!temp.getParentFile().exists()) {
temp.getParentFile().mkdirs();
}
//上传文件加密
OutputStream enOutputStream = new FileOutputStream(temp);
boolean b = AES.encryptFile(file.getInputStream(), enOutputStream);
if (!b){
return RtnResult.Fail("文件上传失败！");
}
logger.info("文件上传成功！------------------");
// file.transferTo(temp);
map.put("fileName", file.getOriginalFilename());
map.put("filePath", path);
String dowUrl = PathConstants.URL_FILE_TEMP_ORIGIN.replace("{date}", dateStr).replace("{fileName}", fileName);
map.put("downUrl", dowUrl);
}
}
result.setData(map);
return result;
}
下载文件解密
传入文件名，根据配置文件拼装出文件地址，通过new file(path) ，得到真实文件。通过HttpServletResponse.getOutputStream以及相关设置可以向页面输出文件内容，再调用机密方法即可
@RequestMapping(value = "/download/temp", method = RequestMethod.GET)
@ResponseBody
public void downloadTemp(@RequestParam("date") String date,@RequestParam("fileName") String fileName,HttpServletResponse response) throws IOException {
logger.info("FileController.downloadTemp=========>start");
if (StringUtils.isNotBlank(fileName) && StringUtils.isNotBlank(date)) {
String path =
configProperties.getFileLocation()+PathConstants.DIRECTORY_UPLOAD_TEMP +
PathConstants.DIRECTORY_UPLOAD_TEMP_SUB.replace("{yyyyMMdd}", date)
.replace("{fileName}", fileName);
//通过路径得到文件
File file = new File(path);
logger.info("FileController.downloadTemp=========File:{},exits:{}",path,file.exists());
if (file.exists()) {
//浏览器接受图片设置
String contentType = Files.probeContentType(Paths.get(path));
contentType = StringUtils.isBlank(contentType) ? MediaType.ALL_VALUE : contentType;
response.setContentType(contentType);
response.setHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(file.getName()));
response.setCharacterEncoding("UTF-8");
OutputStream outputStream = response.getOutputStream();
FileInputStream fis = FileUtils.openInputStream(file);
//文件解密
boolean b = AES.decryptFile(fis, outputStream);
if (b){
logger.info("文件解密成功-----------------------");
}else {
logger.info("文件解密失败！----------------------");
}
//IOUtils.copy(fis, outputStream);
outputStream.flush();
outputStream.close();
IOUtils.closeQuietly(fis);
}
}
}
