OCR识别：身份证信息加密传输

AES加密

使用AES加密来请求本身份证识别接口，支持对身份证图片及识别结果进行加密后传输，示意图如下

1. 在百度云控制台「文字识别-应用列表-管理」中获取您的AES Key
2. 使用AES Key对将要识别的图片进行加密
3. 将加密后的图片传入接口，请求参数AESEncry设置为true
4. 接口返回加密后的识别结果，使用AES Key进行解密，得到明文识别结果

使用AES加密不影响身份证识别接口支持的质量检测、风险检测等其他能力，也不影响识别效果。

package AES;

import com.alibaba.fastjson.JSONObject;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.net.URLEncoder;
import java.util.Base64;

public class Idcard {

    /**
     * 重要提示代码中所需工具类
     * FileUtil,HttpUtil请从
     * https://ai.baidu.com/file/658A35ABAB2D404FBF903F64D47C1F72
     * https://ai.baidu.com/file/544D677F5D4E4F17B4122FBD60DB82B3
     * 下载
     */

    // 请求url
    static String url = "https://aip.baidubce.com/rest/2.0/ocr/v1/idcard";

    // aes key 从console控制台获取
    static String aesKey = "[16位 aeskey]";

    static byte[] originAesKey = null;

    public static String idcard() {
        try {
            // 本地文件路径
            String filePath = "[本地文件路径]";
            byte[] imgData = FileUtil.readFileByBytes(filePath);

            String imgStr = encryptImg(aesKey, imgData);

            String imgParam = URLEncoder.encode(imgStr, "UTF-8");

            String param = "id_card_side=" + "front" +
                    "&image=" + imgParam +
                    "&AESEncry=" + true ;

            String accessToken = "[access token]";

            String encryptResult = HttpUtil.post(url, accessToken, param);

            String decryptResult = parseResult(encryptResult);

            return decryptResult;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 加密图片
     *
     * @param aesKey
     * @param imgData
     * @return
     * @throws Exception
     */
    private static String encryptImg(String aesKey, byte[] imgData) throws Exception {
        originAesKey = AesKeyUtil.parseAesKey(aesKey);
        byte[] encImgBytes = AesUtil.encrypt(imgData, originAesKey);
        String imgStr = Base64Util.encodeBase64(encImgBytes);
        return imgStr;
    }

    /**
     * 解密结果
     *
     * @param encryptResult
     * @return
     * @throws Exception
     */
    private static String parseResult(String encryptResult) throws Exception {
        JSONObject obj = JSONObject.parseObject(encryptResult);
        String result = obj.getString("result");
        byte[] arr = Base64Util.decodeBase64(result);
        String decryptResult = new String(AesUtil.decrypt(arr, originAesKey));
        return decryptResult;
    }

    public static void main(String[] args) {
        Idcard.idcard();
    }


    static class AesKeyUtil {
        private static final String HEX = "0123456789abcdef";

        /**
         * 获得原生的128位的aeskey
         * 因为一个byte位8位最后生成的byte数组长度为16
         * <p>
         * 16 * 8 = 128
         *
         * @param hex
         * @return
         */
        public static byte[] parseAesKey(String hex) throws Exception {
            char[] data = hex.toCharArray();
            if (data.length != 16) {
                throw new Exception(" ase key illegal ");
            }
            return decode(hex.toCharArray());
        }

        private static byte[] decode(char[] data) throws IllegalArgumentException {
            int len = data.length;

            byte[] out = new byte[len];

            for (int i = 0; i < len; i++) {
                int f = toDigit(data[i]);
                out[i] = (byte) (f);
            }
            return out;
        }

        private static int toDigit(char ch) {
            return HEX.indexOf(ch);
        }
    }

    static class AesUtil {

        private static final String ALGORITHM = "AES";

        private static final String ALGORITHM_STR = "AES/ECB/PKCS5Padding";

        /**
         * aes 加密
         */
        private static byte[] encrypt(byte[] src, byte[] aesKey) throws Exception {
            Cipher cipher = getCipher(aesKey, Cipher.ENCRYPT_MODE);
            byte[] ret = cipher.doFinal(src);
            return ret;
        }

        /**
         * aes 解密
         */
        public static byte[] decrypt(byte[] src, byte[] aesKey) throws Exception {
            Cipher cipher = getCipher(aesKey, Cipher.DECRYPT_MODE);
            byte[] original = cipher.doFinal(src);
            return original;
        }

        private static Cipher getCipher(byte[] aesKey, int mode) throws Exception {
            SecretKeySpec secretKeySpec = new SecretKeySpec(aesKey, ALGORITHM);
            Cipher cipher = Cipher.getInstance(ALGORITHM_STR);
            cipher.init(mode, secretKeySpec);
            return cipher;
        }
    }

    static class Base64Util {

        private static Base64.Encoder ENCODER = Base64.getEncoder();

        // base64 加密
        private static Base64.Decoder DECODER = Base64.getDecoder();

        /**
         * base64加密
         *
         * @param arr
         * @return
         */
        private static String encodeBase64(byte[] arr) {
            String base64 = null;
            try {
                base64 = ENCODER.encodeToString(arr);
            } catch (Exception e) {
            }
            return base64;
        }

        /**
         * base64解密
         *
         * @param str
         * @return
         */
        public static byte[] decodeBase64(String str) {
            byte[] encodeBase64 = new byte[0];
            try {
                encodeBase64 = DECODER.decode(str);
            } catch (Exception e) {
            }
            return encodeBase64;
        }
    }
}

 对result密文进行base64解码后得到byte流，再进行AES解密，得到识别结果的明文。