--- a/ipu-show-server/pom.xml
+++ b/ipu-show-server/pom.xml
@ -70,10 +70,10 @@
 
														            <artifactId>junit</artifactId>
													
 
														            <scope>test</scope>
													
 
														        </dependency>
													
 
														<!--        <dependency>-->
													
 
														<!--            <groupId>org.springframework.boot</groupId>-->
													
 
														<!--            <artifactId>spring-boot-starter-log4j2</artifactId>-->
													
 
														<!--        </dependency>-->
													
 
														        <!--        <dependency>-->
													
 
														        <!--            <groupId>org.springframework.boot</groupId>-->
													
 
														        <!--            <artifactId>spring-boot-starter-log4j2</artifactId>-->
													
 
														        <!--        </dependency>-->
													
 
														        <!--通用http接口-->
													
 
														        <dependency>
													
 
														            <groupId>cn.hutool</groupId>
													
@ -97,6 +97,12 @@
 
														            <artifactId>ipu-file-system</artifactId>
													
 
														            <version>3.0</version>
													
 
														        </dependency>
													
 
														        <!--加密依赖包-->
													
 
														        <dependency>
													
 
														            <groupId>org.bouncycastle</groupId>
													
 
														            <artifactId>bcprov-jdk16</artifactId>
													
 
														            <version>1.43</version>
													
 
														        </dependency>
													
 
														    </dependencies>
													
 
														
													
 
														
													
@ -110,6 +116,19 @@
 
														                <groupId>org.codehaus.mojo</groupId>
													
 
														                <artifactId>exec-maven-plugin</artifactId>
													
 
														            </plugin>
													
 
														            <!--引用本地jdk，主要是加解密组件需要用到-->
													
 
														            <plugin>
													
 
														                <artifactId>maven-compiler-plugin</artifactId>
													
 
														                <configuration>
													
 
														                    <source>1.8</source>
													
 
														                    <target>1.8</target>
													
 
														                    <encoding>UTF-8</encoding>
													
 
														                    <compilerArguments>
													
 
														                        <bootclasspath>${JAVA_HOME}/jre/lib/rt.jar:${JAVA_HOME}/jre/lib/jce.jar</bootclasspath>
													
 
														                        <extdirs>${project.basedir}/libs</extdirs>
													
 
														                    </compilerArguments>
													
 
														                </configuration>
													
 
														            </plugin>
													
 
														        </plugins>
													
 
														        <finalName>ipu-show-server</finalName>
													
 
														    </build>
													
--- a/ipu-show-server/src/main/java/com/ai/ipu/show/bean/CommonBean.java
+++ b/ipu-show-server/src/main/java/com/ai/ipu/show/bean/CommonBean.java
@ -3,21 +3,25 @@ package com.ai.ipu.show.bean;
 
														import cn.hutool.http.HttpRequest;
													
 
														import com.ai.ipu.basic.log.ILogger;
													
 
														import com.ai.ipu.basic.log.IpuLoggerFactory;
													
 
														import com.ai.ipu.server.frame.bean.AbstractBean;
													
 
														import com.ai.ipu.server.config.MobileConfig;
													
 
														import com.ai.ipu.show.core.bean.IpuAppBean;
													
 
														import com.ai.ipu.show.util.AesUtils;
													
 
														import com.ailk.common.data.IData;
													
 
														import com.ailk.common.data.impl.DataMap;
													
 
														import com.alibaba.fastjson.JSON;
													
 
														import com.ai.ipu.show.util.Constant;
													
 
														import com.ai.ipu.show.util.SpringContextUtils;
													
 
														import org.springframework.core.env.Environment;
													
 
														import org.springframework.util.StringUtils;
													
 
														
													
 
														import java.util.HashMap;
													
 
														import java.util.Map;
													
 
														
													
 
														/**
													
 
														 * @author
													
 
														 * @desc
													
 
														 */
													
 
														public class CommonBean extends AbstractBean {
													
 
														public class CommonBean extends IpuAppBean {
													
 
														
													
 
														    /**
													
 
														     * 环境参数工具
													
@ -98,5 +102,167 @@ public class CommonBean extends AbstractBean {
 
														        sb.setLength(sb.length() - 1);
													
 
														        return sb.toString();
													
 
														    }
													
 
														
													
 
														
													
 
														    /**
													
 
														     * 通用公用接口请求方法
													
 
														     *
													
 
														     * @param requestParams
													
 
														     * @return
													
 
														     * @throws Exception
													
 
														     */
													
 
														    public IData commonInterfaceHandler(IData requestParams) throws Exception {
													
 
														        //定义返回参数
													
 
														        IData result = null;
													
 
														        //先检查是否加密
													
 
														        String encryptFlag = MobileConfig.getValue(Constant.COMMON_INTERFACE_KEY_ENCRYPTFLAG, Constant.COMMON_INTERFACE_DEFAULT_VALUE);
													
 
														        String signFlag = MobileConfig.getValue(Constant.COMMON_INTERFACE_KEY_SIGNFLAG, Constant.COMMON_INTERFACE_DEFAULT_VALUE);
													
 
														        //初始化正式参数，默认直接取上传的参数作为真实参数
													
 
														        IData realReqParams = requestParams;
													
 
														        if (Constant.COMMON_INTERFACE_TRUE_VALUE.equals(encryptFlag)) {
													
 
														            //需要解密
													
 
														            realReqParams = decryptReqData(requestParams);
													
 
														        }
													
 
														        if (Constant.COMMON_INTERFACE_TRUE_VALUE.equals(signFlag)) {
													
 
														            //需要验签
													
 
														            if (checkReqSign(realReqParams)) {
													
 
														                result = createErrorMsg(realReqParams, "签名错误，请检查接口签名");
													
 
														                return result;
													
 
														            }
													
 
														        }
													
 
														        //请求类型(post/get)
													
 
														        String requestType = realReqParams.getString(Constant.COMMON_INTERFACE_KEY_REQTYPE);
													
 
														        //接口名称
													
 
														        String interfaceName = realReqParams.getString(Constant.COMMON_INTERFACE_KEY_INTFNAME);
													
 
														        if (StringUtils.isEmpty(requestType) || StringUtils.isEmpty(interfaceName)) {
													
 
														            result = createErrorMsg(realReqParams, "请指定接口名称和请求方式");
													
 
														            return result;
													
 
														        }
													
 
														
													
 
														        //重新组装业务请求参数
													
 
														        //请求头内容
													
 
														        Map<String, Object> headParamMap = new HashMap<>();
													
 
														        IData headerDatas = realReqParams.getData(Constant.COMMON_INTERFACE_KEY_HEAD);
													
 
														        for (String key : headerDatas.keySet()) {
													
 
														            headParamMap.put(key, headerDatas.get(key));
													
 
														        }
													
 
														        //处理
													
 
														        Map<String, Object> bodyParamMap = new HashMap<>();
													
 
														        IData bodyDatas = realReqParams.getData(Constant.COMMON_INTERFACE_KEY_DATA);
													
 
														        //请求body内容
													
 
														        for (String key : requestParams.keySet()) {
													
 
														            bodyParamMap.put(key, requestParams.get(key));
													
 
														        }
													
 
														
													
 
														        //获取json作为body
													
 
														        String jsonParams = JSON.toJSONString(bodyParamMap);
													
 
														        log.debug("获取到的json字符：jsonParams:" + jsonParams);
													
 
														
													
 
														//        //接口加签名参数拼装
													
 
														//        String appId = environment.getProperty(Constant.ENV_INTERFACE_APPID);
													
 
														//        String timestamp = DateUtil.format(DateUtil.date(), "yyyyMMddHHmmss");
													
 
														//        Map<String, String> signParam = new HashMap<String, String>();
													
 
														//        signParam.put("appId", appId);
													
 
														//        signParam.put("timestamp", timestamp);
													
 
														//        // 如果业务参数需要加密，则这里需是加密后的值
													
 
														//        signParam.put("content", jsonParams);
													
 
														//        // 应用密钥
													
 
														//        String key = environment.getProperty(Constant.ENV_INTERFACE_APPKEY);
													
 
														//        //签名参数
													
 
														//        String signValue = "";
													
 
														//        try {
													
 
														//            log.debug("接口签名加密参数：signParam:" + signParam.toString() + ",key:" + key);
													
 
														//            signValue = SignUtil.sign(signParam, "HmacSHA256", key);
													
 
														//            log.debug("接口签名加密结果：signValue:" + signValue);
													
 
														//        } catch (Exception e) {
													
 
														//            log.error("接口签名发生加密异常：" + e.getMessage());
													
 
														//        }
													
 
														
													
 
														        //外部接口返回的参数
													
 
														        String reqResult = null;
													
 
														        //请求url拼接
													
 
														        String url = environment.getProperty(Constant.ENV_URL_BASEPATH) + interfaceName;
													
 
														
													
 
														        //请求代理
													
 
														        if (Boolean.parseBoolean(environment.getProperty(Constant.ENV_PROXY_FLAG))) {
													
 
														            System.setProperty("http.proxySet", "true");
													
 
														            System.setProperty("http.proxyHost", environment.getProperty(Constant.ENV_PROXY_SERVER));
													
 
														            System.setProperty("http.proxyPort", environment.getProperty(Constant.ENV_PROXY_PORT));
													
 
														        }
													
 
														        //发送请求
													
 
														        if (Constant.COMMON_INTERFACE_VALUE_POST.equalsIgnoreCase(requestType)) {
													
 
														            log.debug("调用远端Post接口，接口请求地址:" + url + "，参数:" + jsonParams);
													
 
														            HttpRequest httpRequest = HttpRequest.post(url);
													
 
														            //添加header
													
 
														            for (String headerKey : headParamMap.keySet()) {
													
 
														                httpRequest.header(headerKey, headParamMap.get(headerKey).toString());
													
 
														            }
													
 
														            reqResult = httpRequest.contentType("application/json")
													
 
														                    .body(jsonParams)
													
 
														                    //超时，毫秒
													
 
														                    .timeout(30000)
													
 
														                    .execute().body();
													
 
														            log.debug("调用远端Post接口，接口请求地址:" + url + "，返回:" + result);
													
 
														        } else {
													
 
														            //get请求，先要把参数转换到url里面
													
 
														            String filterStrs = "requestType,interfaceName,token";
													
 
														            String urlStr = idata2Url(requestParams, filterStrs);
													
 
														            String reqUrl = url + urlStr;
													
 
														            log.debug("调用远端get接口，接口请求地址:" + reqUrl);
													
 
														            HttpRequest httpRequest = HttpRequest.get(reqUrl);
													
 
														            //添加header
													
 
														            for (String headerKey : headParamMap.keySet()) {
													
 
														                httpRequest.header(headerKey, headParamMap.get(headerKey).toString());
													
 
														            }
													
 
														            reqResult = httpRequest
													
 
														                    .contentType("x-www-form-urlencoded")
													
 
														                    //超时，毫秒
													
 
														                    .timeout(30000)
													
 
														                    .execute().body();
													
 
														            log.debug("调用远端get接口，接口请求地址:" + reqUrl + "，返回:" + reqResult);
													
 
														        }
													
 
														        IData retMap = createReturnData();
													
 
														        if (Constant.COMMON_INTERFACE_TRUE_VALUE.equals(encryptFlag) && reqResult != null) {
													
 
														            //需要加密
													
 
														            String resultEncrypt = AesUtils.aes256ECBPkcs7PaddingHexEncrypt(reqResult, Constant.AES_KEY);
													
 
														            retMap.put(Constant.COMMON_INTERFACE_KEY_DATA, resultEncrypt);
													
 
														        } else {
													
 
														            retMap.put(Constant.COMMON_INTERFACE_KEY_DATA, reqResult);
													
 
														        }
													
 
														        return retMap;
													
 
														    }
													
 
														
													
 
														    /**
													
 
														     * 解密入参
													
 
														     *
													
 
														     * @param reqData
													
 
														     * @return
													
 
														     */
													
 
														    public static IData decryptReqData(IData reqData) throws Exception {
													
 
														        IData retIdata = new DataMap();
													
 
														        //处理接口请求参数加解密
													
 
														        String dataSrcStr = reqData.getString(Constant.COMMON_INTERFACE_KEY_DATA);
													
 
														        log.debug("接口参数密文:" + dataSrcStr);
													
 
														        if (dataSrcStr != null && dataSrcStr.length() > 0) {
													
 
														            String dataJson = AesUtils.aes256ECBPkcs7PaddingHexDecrypt(dataSrcStr, Constant.AES_KEY);
													
 
														            log.debug("接口参数解密后明文:" + dataJson);
													
 
														            //把接口参数再次构造成DataMap赋值给参数对象
													
 
														            retIdata = new DataMap(dataJson);
													
 
														
													
 
														        }
													
 
														        return retIdata;
													
 
														    }
													
 
														
													
 
														    /**
													
 
														     * 签名验证方法
													
 
														     *
													
 
														     * @param reqData
													
 
														     * @return
													
 
														     * @throws Exception
													
 
														     */
													
 
														    public static boolean checkReqSign(IData reqData) throws Exception {
													
 
														        //TODO Junjie.Lai 方法实现
													
 
														        return true;
													
 
														    }
													
 
														}
													
 
														
													
--- a/ipu-show-server/src/main/java/com/ai/ipu/show/util/AesUtils.java
+++ b/ipu-show-server/src/main/java/com/ai/ipu/show/util/AesUtils.java
@ -0,0 +1,112 @@
 
														package com.ai.ipu.show.util;
													
 
														
													
 
														import org.bouncycastle.jce.provider.BouncyCastleProvider;
													
 
														
													
 
														import javax.crypto.Cipher;
													
 
														import javax.crypto.spec.SecretKeySpec;
													
 
														import java.nio.charset.StandardCharsets;
													
 
														import java.security.Security;
													
 
														import java.util.Base64;
													
 
														
													
 
														/**
													
 
														 * AES加密工具类
													
 
														 */
													
 
														public class AesUtils {
													
 
														    private static final String SECRET = "AES";
													
 
														    private static final String CIPHER_ALGORITHM = "AES/ECB/PKCS7Padding";
													
 
														
													
 
														    static {
													
 
														        Security.addProvider(new BouncyCastleProvider());
													
 
														    }
													
 
														
													
 
														    /**
													
 
														     * AES加密ECB模式PKCS7Padding填充方式（Base64编码）
													
 
														     * @param str 字符串
													
 
														     * @param key 密钥
													
 
														     * @return 加密字符串
													
 
														     * @throws Exception 异常信息
													
 
														     */
													
 
														    public static String aes256ECBPkcs7PaddingEncrypt(String str, String key) throws Exception {
													
 
														        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
													
 
														        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
													
 
														        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(keyBytes, SECRET));
													
 
														        byte[] doFinal = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));
													
 
														        return new String(Base64.getEncoder().encode(doFinal));
													
 
														    }
													
 
														
													
 
														    public static String encodeHexString(byte[] data) {
													
 
														        StringBuilder sb = new StringBuilder();
													
 
														        for (byte b : data) {
													
 
														            sb.append(String.format("%02x", b));
													
 
														        }
													
 
														        return sb.toString();
													
 
														    }
													
 
														
													
 
														    public static String aes256ECBPkcs7PaddingHexEncrypt(String str, String key) throws Exception {
													
 
														        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
													
 
														        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
													
 
														        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(keyBytes, SECRET));
													
 
														        byte[] doFinal = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));
													
 
														        return new String(encodeHexString(doFinal));
													
 
														    }
													
 
														
													
 
														
													
 
														
													
 
														    /**
													
 
														     * AES解密ECB模式PKCS7Padding填充方式（Base64编码）
													
 
														     * @param str 字符串
													
 
														     * @param key 密钥
													
 
														     * @return 解密字符串
													
 
														     * @throws Exception 异常信息
													
 
														     */
													
 
														    public static String aes256ECBPkcs7PaddingDecrypt(String str, String key) throws Exception {
													
 
														        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
													
 
														        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
													
 
														        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(keyBytes, SECRET));
													
 
														        byte[] doFinal = cipher.doFinal(Base64.getDecoder().decode(str));
													
 
														        return new String(doFinal);
													
 
														    }
													
 
														
													
 
														
													
 
														    public static byte[] hexStringToByteArray(String hexString) {
													
 
														        hexString = hexString.replaceAll(" ", "");
													
 
														        int len = hexString.length();
													
 
														        byte[] bytes = new byte[len / 2];
													
 
														        for (int i = 0; i < len; i += 2) {
													
 
														            // 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个字节
													
 
														            bytes[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character
													
 
														                    .digit(hexString.charAt(i+1), 16));
													
 
														        }
													
 
														        return bytes;
													
 
														    }
													
 
														    /**
													
 
														     * AES解密ECB模式PKCS7Padding填充方式（Hex编码）
													
 
														     * @param str 字符串
													
 
														     * @param key 密钥
													
 
														     * @return 解密字符串
													
 
														     * @throws Exception 异常信息
													
 
														     */
													
 
														    public static String aes256ECBPkcs7PaddingHexDecrypt(String str, String key) throws Exception {
													
 
														        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
													
 
														        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
													
 
														        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(keyBytes, SECRET));
													
 
														        byte[] doFinal = cipher.doFinal(hexStringToByteArray(str));
													
 
														        return new String(doFinal);
													
 
														    }
													
 
														
													
 
														    public static void main(String[] args) throws Exception {
													
 
														        String str = "fjadmin";
													
 
														        System.out.println("字符串：" + str);
													
 
														        String encryptStr = AesUtils.aes256ECBPkcs7PaddingEncrypt(str, "abcdefXXABCDEFxx");
													
 
														        System.out.println("Base64编码，加密后字符串：" + encryptStr);
													
 
														
													
 
														        String decryptStr = AesUtils.aes256ECBPkcs7PaddingDecrypt(encryptStr, "abcdefXXABCDEFxx");
													
 
														        System.out.println("Base64编码，解密后字符串：" + decryptStr);
													
 
														
													
 
														        String hexEncryptStr = AesUtils.aes256ECBPkcs7PaddingHexEncrypt(str, "abcdefXXABCDEFxx");
													
 
														        System.out.println("Hex编码，加密后字符串：" + hexEncryptStr);
													
 
														
													
 
														        String hexDecryptStr = AesUtils.aes256ECBPkcs7PaddingHexDecrypt(hexEncryptStr, "abcdefXXABCDEFxx");
													
 
														        System.out.println("Hex编码，解密后字符串：" + hexDecryptStr);
													
 
														    }
													
 
														}
													
--- a/ipu-show-server/src/main/java/com/ai/ipu/show/util/Constant.java
+++ b/ipu-show-server/src/main/java/com/ai/ipu/show/util/Constant.java
@ -89,4 +89,55 @@ public class Constant {
 
														     */
													
 
														    public static final String FILE_SAVE_PATH = "appserver.file.savepath";
													
 
														
													
 
														    /**通用接口固定参数*/
													
 
														    /**
													
 
														     * 请求数据加密标识
													
 
														     */
													
 
														    public static final String COMMON_INTERFACE_KEY_ENCRYPTFLAG = "commInterfaceEncrypt";
													
 
														
													
 
														    /**
													
 
														     * 请求数据签名标识
													
 
														     */
													
 
														    public static final String COMMON_INTERFACE_KEY_SIGNFLAG = "commInterfaceSign";
													
 
														
													
 
														    /**
													
 
														     * AES加解密的KEY
													
 
														     */
													
 
														    public static final String AES_KEY = "onLineTradeTKAMC";
													
 
														
													
 
														    /**
													
 
														     * 参数标识，默认false
													
 
														     */
													
 
														    public static final String COMMON_INTERFACE_DEFAULT_VALUE = "false";
													
 
														
													
 
														    /**
													
 
														     * 参数标识，true
													
 
														     */
													
 
														    public static final String COMMON_INTERFACE_TRUE_VALUE = "true";
													
 
														    /**
													
 
														     * 接口请求类型
													
 
														     */
													
 
														    public static final String COMMON_INTERFACE_KEY_REQTYPE = "requestType";
													
 
														
													
 
														    /**
													
 
														     * 接口请求值
													
 
														     */
													
 
														    public static final String COMMON_INTERFACE_VALUE_POST = "POST";
													
 
														    public static final String COMMON_INTERFACE_VALUE_GET = "GET";
													
 
														
													
 
														    /**
													
 
														     * 接口名称
													
 
														     */
													
 
														    public static final String COMMON_INTERFACE_KEY_INTFNAME = "interfaceName";
													
 
														
													
 
														    /**
													
 
														     * 发送到后端的请求head
													
 
														     */
													
 
														    public static final String COMMON_INTERFACE_KEY_HEAD = "head";
													
 
														
													
 
														    /**
													
 
														     * 发送到后端的请求data
													
 
														     */
													
 
														    public static final String COMMON_INTERFACE_KEY_DATA = "data";
													
 
														
													
 
														}
													
--- a/ipu-show-server/src/main/resources/server-config.xml
+++ b/ipu-show-server/src/main/resources/server-config.xml
@ -21,6 +21,10 @@
 
														    <config name="indexPage" value="Index"/>
													
 
														    <!-- 文件是否加密 -->
													
 
														    <config name="fileEncrypt" value="true"/>
													
 
														    <!--通用接口是否加密-->
													
 
														    <config name="commInterfaceEncrypt" value="false"/>
													
 
														    <!--通用接口是否签名-->
													
 
														    <config name="commInterfaceSign" value="false"/>
													
 
														    <!-- 自定义异常管理器 -->
													
 
														    <config name="exceptionHandler" value="com.ai.ipu.show.core.handler.IpuExceptionHandler"/>
													
 
														    <!-- 自定义Session管理器 -->
													
--- a/ipu-show-server/src/main/resources/server-data.xml
+++ b/ipu-show-server/src/main/resources/server-data.xml
@ -5,7 +5,6 @@
 
														    <!-- 模拟发送验证码 -->
													
 
														    <action name="LoginBean.sendVerificationCode" class="com.ai.ipu.show.bean.LoginBean" method="sendVerificationCode" verify="false"></action>
													
 
														
													
 
														    as>
													
 
														    <!-- 上传下载 -->
													
 
														    <action name="UploadDownloadBean.download" 	class="com.ai.ipu.show.bean.UploadDownloadBean" method="download" verify="false"></action>
													
 
														    <action name="UploadDownloadBean.upload" 	class="com.ai.ipu.show.bean.UploadDownloadBean" method="upload" 	verify="false"></action>
													
@ -61,4 +60,8 @@
 
														
													
 
														    <!-- 通用转发接口 -->
													
 
														    <action name="CommonBean.interfaceHandler" class="com.ai.ipu.show.bean.CommonBean" method="interfaceHandler" verify="false"></action>
													
 
														
													
 
														    <!-- 通用转发功能接口，参数已经过优化处理，支持加密和验签 -->
													
 
														    <action name="CommonBean.commonInterfaceHandler" class="com.ai.ipu.show.bean.CommonBean" method="commonInterfaceHandler" verify="false"></action>
													
 
														
													
 
														</datas>
liuyf23 4b2cbbef0e @修复：冲突处理		2 年之前
..
src	efbfeabe37 @新增：mobile-action.xml中增加插件对应的权限，避免权限问题导致插件用不了（比如自定义相机等）	2 年之前
build.gradle	4b2cbbef0e @修复：冲突处理	2 年之前
proguard-rules.pro	fba78db9f2 超级客户端使用IPU框架4.0	3 年之前
showshow.keystore	fba78db9f2 超级客户端使用IPU框架4.0	3 年之前