钉钉企业应用网关接入(保姆级教程)

深藏阁楼爱情的钟 2024-04-07 10:18 104阅读 0赞

## 背景 ##

> 在对接钉钉开放平台时, 会出现需要钉钉开放平台回调我们项目的情况. 而一般项目都被部署在公司内网.  
> 因此, 我们需要进行内网穿透. 常用内网穿透工具对比如下表. 可以看到钉钉是在对接钉钉开放平台时, 最优的选择…  
> 本文将**详细介绍自己和钉钉企业应用网关对接和搭建的整体流程**

**常用内网穿工具透比较**

![在这里插入图片描述][a78932fc24bd4394b5c7adbb61b7acf1.png]

## 企业应用网关 ##

> 其实在之前, 钉钉还提供一种内网穿透. 但因为**因安全合规、服务资源和维护成本等**原因，钉钉于2022年7月21日起，不再提供内网穿透的工具服务，若需要在本地或开发测试环境调试中有内网穿透的需求，请参考文档自行搭建的[frp内网穿透服务][frp]. 因此, 如果企业有这方面需求, 本着安全性, 稳定性, 简易性来说, 钉钉企业应用网关也是一个不错的选择. 而且可以联系商务搭建试用版平台. [点击进入官网地址][Link 1]

### 是什么 ###

> **企业应用网关, 又称为钉钉零信任网关**, 作用是为企业提供了内网应用在外网安全访问的能力，可以替代传统的VPN方案，基于阿里云的网络加速能力提升应用访问速度. 该产品以零信任为理念，提供持续动态的访问准入校验，最大程度上保障企业数字信息安全

**用户痛点**

> 企业通常会将核心应用系统放入企业内网或DMZ区，通过防火墙建立网络边界隔离.  
> 如果企业员工在互联网侧通过移动设备或PC设备访问企业内网应用时，通过使用2种方式：VPN拨号和端口映射.  
> 但是由于VPN存在设备漏洞或端口映射到外网IP或URL，黑客可以直接访问或攻击企业应用，导致企业核心数据泄露

![在这里插入图片描述][c43eb59c1ab4485b9349af693e5a4db0.png]

企业原有内网应用访问方式，如下图所示

![在这里插入图片描述][1207766512024da88100acedbb50a5d4.png]

钉钉企业应用网关总体架构，如下图所示  
![在这里插入图片描述][7b6178d94c5d4459bbb62fe3020d51d5.png]  
企业用户内网应用访问推荐以下五种解决方案  
![在这里插入图片描述][c8eef706907146539a2652744c364d04.png]

### 怎么用 ###

> 如果习惯看官网做的话, 可以参照[企业应用网关配置流程][Link 2] 进行搭建.

## 搭建和踩坑过程 ##

### 搭建过程 ###

#### 准备工作 ####

1.  已开通企业应用网关。如果未开通，需要使用移动端钉钉扫描下方二维码或[进入此页面扫码二维码][Link 2]，  
    并安装钉钉企业应用网关应用  
    ![在这里插入图片描述][832a5744260547aea53f55b3fec8cd4d.png]
2.  扫描后会出现下图页面  
    **如果企业开通该功能, 需要该账户级别为管理员(子管理员也不行)**  
    ![在这里插入图片描述][d8933d385c344348b02ccf620ff30214.png]

#### 查看企业网关应用 ####

1.  当与客户侧沟通成功扫描上方二维码后，客户侧可以通过下图获取到开通成功的提示信息：  
    ![在这里插入图片描述][d545b08745a14ec6b7c762a2ba5659c2.png]
2.  在钉钉的管理后台 -> 工作台 -> 三方应用里面看到钉钉安全网关的入口，点击即可进入安全网关后台  
    ![在这里插入图片描述][171a7a7c05f746d1a04ba4ff6e7bf0de.png]  
    进入企业网关首页  
    ![在这里插入图片描述][674eeae0b2f240faa468d3e698ef22b1.png]  
    企业网关首页  
    ![在这里插入图片描述][97bf4347eaa343b2a2f55ae47382b0e3.png]

#### 配置连通器 ####

1.  前提准备  
    需要注意, 如果需要部署在linux服务器, 则需要满足下面条件(Windows也需保证满足如下条件)  
    ![在这里插入图片描述][2991b0871cd34c52b559b5d5dde14af0.png]
2.  创建连通器  
    选择新建连通器, 选择部署类型之后, 点击继续, 生成以下命令, 然后复制下面linux命令  
    ![在这里插入图片描述][e04600966f81413d85b2cf046f9896c0.png]
3.  在linux服务器上进行执行复制的命令后, 可以看到连通器已经启动成功  
    ![在这里插入图片描述][b34399bb8bd64b88a5a11283c7f292ce.png]
4.  新建连通器组  
    将新建的连通器加入连通器组, 连通器组的作用: 批量管理连通器, 在后面应用管理时使用  
    ![在这里插入图片描述][156aad1eabf644a0b1a0a84ac33d59de.png]

##### 补充——连通器自启动配置 #####

**2022.12.12补充, 公司在进行网络调整时, 由于网络断开过导致连通器断开, 为了图方便进行了服务器重启. 但是由于重启后连通器也未进行重启. 所以带来了一系列的问题. 需要配置重启后自启动**. 当前服务器为ubuntu, 因此需要在`/etc/rc.local` 下面配置自启动项.

# 进入rc.local
    vim  /etc/rc.local
    # 配置启动名称 
    ## cd 后面跟的是连通器脚本所在目录, 就是执行第2步创建连通器是所在创建的目录
    ## ;(分号)后面执行的命令就是图2圈出来的参数!!!
    cd /home/dingding-getway/connector ;./start.sh -a endpoint.ztna-dingtalk.com:8021 -k 6cc96011442d42149bdfbf95a1c61343 -s 42e4d95397dd4a75bf8b51e1ac655026df1786927f77f4a788e951b9d79fc55b &

图1  
![在这里插入图片描述][57c93a342f3144b1b237f732fad21aec.png]  
图2  
![在这里插入图片描述][92280c0286b841e78fd74f37a583c4cb.png]

#### 配置应用管理 ####

##### 准备前提 #####

1.  新建应用  
    方式一: [在管理后台-工作台][-]新建第三方应用  
    ![在这里插入图片描述][88fe9e5594ef435ca8b0cec18b02a481.png]
    
    方式二: 在[钉钉开放平台][Link 3]根据使用场景去创建应用  
    ![在这里插入图片描述][29d16e7ac60f4cfc8736a6cb42062720.png]
2.  根据需要填写应用信息  
    ![在这里插入图片描述][f7ff407be29b4ee2882185f16542ba73.png]
3.  配置成功后, 自动生成**AgentId, AppKey, AppSecret, 用于接口对接时使用**  
    ![在这里插入图片描述][4f417ae629164a5ba934441b074e4ba5.png]
4.  发布应用(开发程序完成后使用)  
    应用发布后, 才能被其他用户看到(**这里指在自己的工作台上看到, 而不是管理后台的工作台上看到**). 体验版本发布属于灰度发布.[点击][Link 4]查看应用发布介绍  
    ![在这里插入图片描述][a97a629fdde74b4384687cf51c7df785.png]

##### 配置应用 #####

1.  创建好应用之后, 在应用管理里面配置测试应用, 点击未配置的应用，进行相关配置  
    ![在这里插入图片描述][e65732ef70bd4a9688606ad99c61630b.png]
2.  应用管理 - 基础配置  
    点击连通器选项的“+”，选择部署的连通器（或连通器组），与测试应用建立连接.  
    选择域名进行配置, 这里的域名值得是内网地址+端口(可以配置多条映射). **配置好保存之后即可实现内网穿透!!!**  
    ![在这里插入图片描述][ce7c5c896f264909a434ee1fabd4e5b3.png]
3.  需要说明的是, 这里的主域名配置就是你在**钉钉开放平台->具体应用->开发管理**的应用首页地址. **如果后面配置规则之后访问出现`unexpected EOF`, 则说明配置的url在连通器上面访问不通, 一般情况就是在开发配置中, 配置的是https但实际上内网走的是http**  
    ![在这里插入图片描述][910d9d2d1b7445adb135ad758e5b9059.png] ![在这里插入图片描述][444e6b3470624077a80ef29bb612f7e6.png]  
    例如我上图配置的内网域名是https, 但是实际上`curl https://ip:port`则会出错. 说明该服务在内网本身是通过http访问的, 但是在网关域名中我误写成https导致网关穿透失败(**因为该域名本身在内网都访问不通!!!**)  
    ![在这里插入图片描述][1128ebdd5849470da0d5e7f942401a17.png]  
      
    因此在**钉钉开放平台->具体应用->开发管理**的应用首页地址之后访问不通时, 一定要验证该url在钉钉连通器所在服务器是否可以访问!

##### 高级配置 #####

**注意:**

*  下面介绍下高级配置. 如**无特殊需求可以不进行高级配置(直接进行下一步).**
 *  这里配置需的前提是 要我们在下一步**访问策略配置**并获**取外网访问域名**后 再进行配置

> 因为背景介绍的原因, 需要钉钉开放平台在创建的应用中进行事件回调(在公司组织架构进行变动时调用该接口),  
> 然而在我们配置好访问策略时, 钉钉回调接口时仍出现: `url 地址访问异常, 不允许3xxx跳转`  
> 故需要我们管理平台-应用管理中进行高级配置. 没有配置前, 填入url后报错, 内容如下图所示

![在这里插入图片描述][cfeff07b1dc549dcad29d7d207c3ba9f.png]

1.  高级配置  
    添加允许匿名访问url: 格式为 `https://生成的外网访问域名/事件回调sdk接口地址.*`  
    ![在这里插入图片描述][5d6b7d581cb549a7a3b9c746370b162a.png]
2.  配置成功后, 进行测试  
    需要先将事件回调sdk部署在内网服务器上才能够进行测试  
    ![在这里插入图片描述][edb06759824946bfa73f33aebec7e156.png]

#### 配置访问策略 ####

> 策略管理由企业管理员操作，包括注册策略、修改策略、删除策略、停用策略、启用策略、优先级排序等

1.  然后点击“创建策略”按钮，进入创建策略界面  
    ![在这里插入图片描述][54288b20ede741b8b9032a22af35d955.png]
2.  在策略页面，填写策略信息，配置项如下表  
    ![在这里插入图片描述][d4f4c6466d6242fb939fc3bb5e359626.png]  
    ![在这里插入图片描述][0f3f38c6100944fab77d6b9af06862a2.png]
3.  点击完成，创建策略  
    ![在这里插入图片描述][9cf13ff6e6ff42c1bcee57c8f00bf968.png]

#### 获取外网访问域名(踩坑) ####

1.  在配置好访问策略后, 可以**通过应用管理里面获取新域名**, 而不是通过连通器显示的公网ip进行访问  
    ![在这里插入图片描述][48580e6c3712491386f5b10629a4a809.png]
2.  可以看到我们**每次配置的内网ip+端口都被映射成外网对应可以访问的唯一域名**, 根据需要复制新域名即可  
    ![在这里插入图片描述][0c7223204115474386c9680dd372f84c.png]
3.  测试企业网关内网穿透效果  
    内网访问  
    ![在这里插入图片描述][f94d110ebcad4c39b610ff87d4831966.png]  
    公网访问  
    ![在这里插入图片描述][f21d4c10c9d04c9db0b178fdc9ba9c0f.png]

## 附: 钉钉事件回调sdk ##

> 事件回调介绍地址: https://open.dingtalk.com/document/org/configure-event-subcription

1.  钉钉开放平台加解密方法
    
        import java.io.ByteArrayOutputStream;
        import java.nio.charset.Charset;
        import java.security.MessageDigest;
        import java.security.Permission;
        import java.security.PermissionCollection;
        import java.util.Arrays;
        import java.util.HashMap;
        import java.util.Map;
        import java.util.Random;
        import java.security.Security;
        import java.lang.reflect.Field;
        
        import javax.crypto.Cipher;
        import javax.crypto.spec.IvParameterSpec;
        import javax.crypto.spec.SecretKeySpec;
        
        import com.alibaba.fastjson.JSON;
        
        import org.apache.commons.codec.binary.Base64;
        
        /**
         * 钉钉开放平台加解密方法
         * 在ORACLE官方网站下载JCE无限制权限策略文件
         * JDK6的下载地址：http://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html
         * JDK7的下载地址： http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html
         * JDK8的下载地址 https://www.oracle.com/java/technologies/javase-jce8-downloads.html
         * @Author caoHaiYang
         * @Date 2022/8/18 10:15
         */
        public class DingCallbackCrypto {
              
        
            private static final Charset CHARSET = Charset.forName("utf-8");
            private static final Base64 base64 = new Base64();
            private byte[] aesKey;
            private String token;
            private String corpId;
            /**
             * ask getPaddingBytes key固定长度
             **/
            private static final Integer AES_ENCODE_KEY_LENGTH = 43;
            /**
             * 加密随机字符串字节长度
             **/
            private static final Integer RANDOM_LENGTH = 16;
        
            /**
             * 构造函数
             *
             * @param token          钉钉开放平台上，开发者设置的token
             * @param encodingAesKey 钉钉开放台上，开发者设置的EncodingAESKey
             * @param corpId         企业自建应用-事件订阅, 使用appKey
             *                       企业自建应用-注册回调地址, 使用corpId
             *                       第三方企业应用, 使用suiteKey
             *
             * @throws DingTalkEncryptException 执行失败，请查看该异常的错误码和具体的错误信息
             */
            public DingCallbackCrypto(String token, String encodingAesKey, String corpId) throws DingTalkEncryptException {
              
                if (null == encodingAesKey || encodingAesKey.length() != AES_ENCODE_KEY_LENGTH) {
              
                    throw new DingTalkEncryptException(DingTalkEncryptException.AES_KEY_ILLEGAL);
                }
                this.token = token;
                this.corpId = corpId;
                aesKey = Base64.decodeBase64(encodingAesKey + "=");
            }
        
            public Map<String, String> getEncryptedMap(String plaintext) throws DingTalkEncryptException {
              
                return getEncryptedMap(plaintext, System.currentTimeMillis(), Utils.getRandomStr(16));
            }
        
            /**
             * 将和钉钉开放平台同步的消息体加密,返回加密Map
             *
             * @param plaintext 传递的消息体明文
             * @param timeStamp 时间戳
             * @param nonce     随机字符串
             * @return
             * @throws DingTalkEncryptException
             */
            public Map<String, String> getEncryptedMap(String plaintext, Long timeStamp, String nonce)
                    throws DingTalkEncryptException {
              
                if (null == plaintext) {
              
                    throw new DingTalkEncryptException(DingTalkEncryptException.ENCRYPTION_PLAINTEXT_ILLEGAL);
                }
                if (null == timeStamp) {
              
                    throw new DingTalkEncryptException(DingTalkEncryptException.ENCRYPTION_TIMESTAMP_ILLEGAL);
                }
                if (null == nonce) {
              
                    throw new DingTalkEncryptException(DingTalkEncryptException.ENCRYPTION_NONCE_ILLEGAL);
                }
                // 加密
                String encrypt = encrypt(Utils.getRandomStr(RANDOM_LENGTH), plaintext);
                String signature = getSignature(token, String.valueOf(timeStamp), nonce, encrypt);
                Map<String, String> resultMap = new HashMap<String, String>();
                resultMap.put("msg_signature", signature);
                resultMap.put("encrypt", encrypt);
                resultMap.put("timeStamp", String.valueOf(timeStamp));
                resultMap.put("nonce", nonce);
                return resultMap;
            }
        
            /**
             * 密文解密
             *
             * @param msgSignature 签名串
             * @param timeStamp    时间戳
             * @param nonce        随机串
             * @param encryptMsg   密文
             * @return 解密后的原文
             * @throws DingTalkEncryptException
             */
            public String getDecryptMsg(String msgSignature, String timeStamp, String nonce, String encryptMsg)
                    throws DingTalkEncryptException {
              
                //校验签名
                String signature = getSignature(token, timeStamp, nonce, encryptMsg);
                if (!signature.equals(msgSignature)) {
              
                    throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_SIGNATURE_ERROR);
                }
                // 解密
                String result = decrypt(encryptMsg);
                return result;
            }
        
            /*
             * 对明文加密.
             * @param text 需要加密的明文
             * @return 加密后base64编码的字符串
             */
            private String encrypt(String random, String plaintext) throws DingTalkEncryptException {
              
                try {
              
                    byte[] randomBytes = random.getBytes(CHARSET);
                    byte[] plainTextBytes = plaintext.getBytes(CHARSET);
                    byte[] lengthByte = Utils.int2Bytes(plainTextBytes.length);
                    byte[] corpidBytes = corpId.getBytes(CHARSET);
                    ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
                    byteStream.write(randomBytes);
                    byteStream.write(lengthByte);
                    byteStream.write(plainTextBytes);
                    byteStream.write(corpidBytes);
                    byte[] padBytes = PKCS7Padding.getPaddingBytes(byteStream.size());
                    byteStream.write(padBytes);
                    byte[] unencrypted = byteStream.toByteArray();
                    byteStream.close();
                    Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
                    SecretKeySpec keySpec = new SecretKeySpec(aesKey, "AES");
                    IvParameterSpec iv = new IvParameterSpec(aesKey, 0, 16);
                    cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);
                    byte[] encrypted = cipher.doFinal(unencrypted);
                    String result = base64.encodeToString(encrypted);
                    return result;
                } catch (Exception e) {
              
                    throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_ENCRYPT_TEXT_ERROR);
                }
            }
        
            /*
             * 对密文进行解密.
             * @param text 需要解密的密文
             * @return 解密得到的明文
             */
            private String decrypt(String text) throws DingTalkEncryptException {
              
                byte[] originalArr;
                try {
              
                    // 设置解密模式为AES的CBC模式
                    Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
                    SecretKeySpec keySpec = new SecretKeySpec(aesKey, "AES");
                    IvParameterSpec iv = new IvParameterSpec(Arrays.copyOfRange(aesKey, 0, 16));
                    cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);
                    // 使用BASE64对密文进行解码
                    byte[] encrypted = Base64.decodeBase64(text);
                    // 解密
                    originalArr = cipher.doFinal(encrypted);
                } catch (Exception e) {
              
                    throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_DECRYPT_TEXT_ERROR);
                }
        
                String plainText;
                String fromCorpid;
                try {
              
                    // 去除补位字符
                    byte[] bytes = PKCS7Padding.removePaddingBytes(originalArr);
                    // 分离16位随机字符串,网络字节序和corpId
                    byte[] networkOrder = Arrays.copyOfRange(bytes, 16, 20);
                    int plainTextLegth = Utils.bytes2int(networkOrder);
                    plainText = new String(Arrays.copyOfRange(bytes, 20, 20 + plainTextLegth), CHARSET);
                    fromCorpid = new String(Arrays.copyOfRange(bytes, 20 + plainTextLegth, bytes.length), CHARSET);
                } catch (Exception e) {
              
                    throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_DECRYPT_TEXT_LENGTH_ERROR);
                }
        
                // corpid不相同的情况
                if (!fromCorpid.equals(corpId)) {
              
                    throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_DECRYPT_TEXT_CORPID_ERROR);
                }
                return plainText;
            }
        
            /**
             * 数字签名
             *
             * @param token     isv token
             * @param timestamp 时间戳
             * @param nonce     随机串
             * @param encrypt   加密文本
             * @return
             * @throws DingTalkEncryptException
             */
            public String getSignature(String token, String timestamp, String nonce, String encrypt)
                    throws DingTalkEncryptException {
              
                try {
              
                    String[] array = new String[] {
              token, timestamp, nonce, encrypt};
                    Arrays.sort(array);
                    //System.out.println(JSON.toJSONString(array));
                    StringBuffer sb = new StringBuffer();
                    for (int i = 0; i < 4; i++) {
              
                        sb.append(array[i]);
                    }
                    String str = sb.toString();
                    System.out.println(str);
                    MessageDigest md = MessageDigest.getInstance("SHA-1");
                    md.update(str.getBytes());
                    byte[] digest = md.digest();
        
                    StringBuffer hexstr = new StringBuffer();
                    String shaHex = "";
                    for (int i = 0; i < digest.length; i++) {
              
                        shaHex = Integer.toHexString(digest[i] & 0xFF);
                        if (shaHex.length() < 2) {
              
                            hexstr.append(0);
                        }
                        hexstr.append(shaHex);
                    }
                    return hexstr.toString();
                } catch (Exception e) {
              
                    throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_SIGNATURE_ERROR);
                }
            }
        
            public static class Utils {
              
                public Utils() {
              
                }
        
                public static String getRandomStr(int count) {
              
                    String base = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
                    Random random = new Random();
                    StringBuffer sb = new StringBuffer();
        
                    for (int i = 0; i < count; ++i) {
              
                        int number = random.nextInt(base.length());
                        sb.append(base.charAt(number));
                    }
        
                    return sb.toString();
                }
        
                public static byte[] int2Bytes(int count) {
              
                    byte[] byteArr = new byte[] {
              (byte)(count >> 24 & 255), (byte)(count >> 16 & 255), (byte)(count >> 8 & 255),
                            (byte)(count & 255)};
                    return byteArr;
                }
        
                public static int bytes2int(byte[] byteArr) {
              
                    int count = 0;
        
                    for (int i = 0; i < 4; ++i) {
              
                        count <<= 8;
                        count |= byteArr[i] & 255;
                    }
        
                    return count;
                }
            }
        
            public static class PKCS7Padding {
              
                private static final Charset CHARSET = Charset.forName("utf-8");
                private static final int BLOCK_SIZE = 32;
        
                public PKCS7Padding() {
              
                }
        
                public static byte[] getPaddingBytes(int count) {
              
                    int amountToPad = 32 - count % 32;
                    if (amountToPad == 0) {
              
                        amountToPad = 32;
                    }
        
                    char padChr = chr(amountToPad);
                    String tmp = new String();
        
                    for (int index = 0; index < amountToPad; ++index) {
              
                        tmp = tmp + padChr;
                    }
        
                    return tmp.getBytes(CHARSET);
                }
        
                public static byte[] removePaddingBytes(byte[] decrypted) {
              
                    int pad = decrypted[decrypted.length - 1];
                    if (pad < 1 || pad > 32) {
              
                        pad = 0;
                    }
        
                    return Arrays.copyOfRange(decrypted, 0, decrypted.length - pad);
                }
        
                private static char chr(int a) {
              
                    byte target = (byte)(a & 255);
                    return (char)target;
                }
            }
        
            public static class DingTalkEncryptException extends Exception {
              
                public static final int SUCCESS = 0;
                public static final int ENCRYPTION_PLAINTEXT_ILLEGAL = 900001;
                public static final int ENCRYPTION_TIMESTAMP_ILLEGAL = 900002;
                public static final int ENCRYPTION_NONCE_ILLEGAL = 900003;
                public static final int AES_KEY_ILLEGAL = 900004;
                public static final int SIGNATURE_NOT_MATCH = 900005;
                public static final int COMPUTE_SIGNATURE_ERROR = 900006;
                public static final int COMPUTE_ENCRYPT_TEXT_ERROR = 900007;
                public static final int COMPUTE_DECRYPT_TEXT_ERROR = 900008;
                public static final int COMPUTE_DECRYPT_TEXT_LENGTH_ERROR = 900009;
                public static final int COMPUTE_DECRYPT_TEXT_CORPID_ERROR = 900010;
                private static Map<Integer, String> msgMap = new HashMap();
                private Integer code;
        
                static {
              
                    msgMap.put(0, "成功");
                    msgMap.put(900001, "加密明文文本非法");
                    msgMap.put(900002, "加密时间戳参数非法");
                    msgMap.put(900003, "加密随机字符串参数非法");
                    msgMap.put(900005, "签名不匹配");
                    msgMap.put(900006, "签名计算失败");
                    msgMap.put(900004, "不合法的aes key");
                    msgMap.put(900007, "计算加密文字错误");
                    msgMap.put(900008, "计算解密文字错误");
                    msgMap.put(900009, "计算解密文字长度不匹配");
                    msgMap.put(900010, "计算解密文字corpid不匹配");
                }
        
                public Integer getCode() {
              
                    return this.code;
                }
        
                public DingTalkEncryptException(Integer exceptionCode) {
              
                    super((String)msgMap.get(exceptionCode));
                    this.code = exceptionCode;
                }
            }
            static {
              
                try {
              
                    Security.setProperty("crypto.policy", "limited");
                    RemoveCryptographyRestrictions();
                } catch (Exception var1) {
              
                }
        
            }
            private static void RemoveCryptographyRestrictions() throws Exception {
              
                Class<?> jceSecurity = getClazz("javax.crypto.JceSecurity");
                Class<?> cryptoPermissions = getClazz("javax.crypto.CryptoPermissions");
                Class<?> cryptoAllPermission = getClazz("javax.crypto.CryptoAllPermission");
                if (jceSecurity != null) {
              
                    setFinalStaticValue(jceSecurity, "isRestricted", false);
                    PermissionCollection defaultPolicy = (PermissionCollection)getFieldValue(jceSecurity, "defaultPolicy", (Object)null, PermissionCollection.class);
                    if (cryptoPermissions != null) {
              
                        Map<?, ?> map = (Map)getFieldValue(cryptoPermissions, "perms", defaultPolicy, Map.class);
                        map.clear();
                    }
        
                    if (cryptoAllPermission != null) {
              
                        Permission permission = (Permission)getFieldValue(cryptoAllPermission, "INSTANCE", (Object)null, Permission.class);
                        defaultPolicy.add(permission);
                    }
                }
        
            }
            private static Class<?> getClazz(String className) {
              
                Class clazz = null;
        
                try {
              
                    clazz = Class.forName(className);
                } catch (Exception var3) {
              
                }
        
                return clazz;
            }
            private static void setFinalStaticValue(Class<?> srcClazz, String fieldName, Object newValue) throws Exception {
              
                Field field = srcClazz.getDeclaredField(fieldName);
                field.setAccessible(true);
                Field modifiersField = Field.class.getDeclaredField("modifiers");
                modifiersField.setAccessible(true);
                modifiersField.setInt(field, field.getModifiers() & -17);
                field.set((Object)null, newValue);
            }
            private static <T> T getFieldValue(Class<?> srcClazz, String fieldName, Object owner, Class<T> dstClazz) throws Exception {
              
                Field field = srcClazz.getDeclaredField(fieldName);
                field.setAccessible(true);
                return dstClazz.cast(field.get(owner));
            }
        
        }
2.  Controller层接口
    
        /**
             * 事件回调方法
             *
             * @param msg_signature
             * @param timeStamp
             * @param nonce
             * @param json
             * @return
             */
            @RequestMapping("/callback")
            public Map<String, String> callBack(
                    @RequestParam(value = "msg_signature", required = false) String msg_signature,
                    @RequestParam(value = "timestamp", required = false) String timeStamp,
                    @RequestParam(value = "nonce", required = false) String nonce,
                    @RequestBody(required = false) JSONObject json) {
              
                try {
              
                    // 1. 从http请求中获取加解密参数
                    // 2. 使用加解密类型
                    // Constant.OWNER_KEY 说明：
                    // 1、开发者后台配置的订阅事件为应用级事件推送，此时OWNER_KEY为应用的APP_KEY。
                    // 2、调用订阅事件接口订阅的事件为企业级事件推送，
                    //      此时OWNER_KEY为：企业的appkey（企业内部应用）或SUITE_KEY（三方应用）
                    DingCallbackCrypto callbackCrypto = new DingCallbackCrypto(dingTalkConfig.getToken(), dingTalkConfig.getAesKey(), dingTalkConfig.getAppkey());
                    String encryptMsg = json.getString("encrypt");
                    String decryptMsg = callbackCrypto.getDecryptMsg(msg_signature, timeStamp, nonce, encryptMsg);
                    // 3. 反序列化回调事件json数据
                    JSONObject eventJson = JSON.parseObject(decryptMsg);
                    log.info("反序列化回调事件json数据:" + eventJson);
                    String eventType = eventJson.getString("EventType");
                    // 4. 根据EventType分类处理
                    if ("check_url".equals(eventType)) {
              
                        // 测试回调url的正确性
                        log.info("测试回调url的正确性");
                    } else if ("user_add_org".equals(eventType)) {
              
                        // 处理通讯录用户增加事件
                        log.info("发生了：" + eventType + "事件");
                    } else {
              
                        // 添加其他已注册的
                        log.info("发生了：" + eventType + "事件");
                    }
        
                    // 5. 返回success的加密数据
                    Map<String, String> successMap = callbackCrypto.getEncryptedMap("success");
                    return successMap;
        
                } catch (DingCallbackCrypto.DingTalkEncryptException e) {
              
                    e.printStackTrace();
                }
                return null;
            }
3.  钉钉提供的事件回调列表  
    其他类型请点击[此蓝色链接][Link 5]获取  
    ![在这里插入图片描述][7b303ec20a7a4dcfb20fd39360ba4553.png]  
    ![在这里插入图片描述][faac27227ff944b1891596e4ef389a0f.png]

### 补充: 前端联调时, 需要为前端配置步骤 ###

> 在复用钉钉登录功能之后, 前端进行本地调试时, 会进行网关内网穿透, 以便外网可测试访问.  
> 当然也可以直接构造内网的二维码登录url, 但这里我们着重讨论第一种情况. 探究其解决方法

1.  在[钉钉企业应用网关平台][Link 6], 配置对应应用的内网ip+端口到外网的映射  
    ![在这里插入图片描述][4f65daff504344419de44d133c4f3449.png]
2.  找到并复制映射好的外网映射  
    ![在这里插入图片描述][d4a0e06f0b5641aba0609e1c07cc9e4a.png]
3.  在钉钉开放平台的企业应用开发中, 选择自己的应用. 配置登录回调  
    这里直接配置内网地址, 或者上一步映射好的外网地址均可  
    ![在这里插入图片描述][e9f4ba35ca5f4100a2e0c3f2c642400a.png]  
    **如果本步骤没有进行配置, 前端在访问该页面则会出现下面问题**  
    ![在这里插入图片描述][d8592000396540b38c4d658f1a6f13a4.jpeg]

--------------------

2023-01-03

### 补充: 如何配置网关连通器开机自启动 ###

#### ubuntu ####

> 整体思路是按照这个大佬的博客走 [Ubuntu设置自启动软件][Ubuntu] 本人使用的服务器是ubuntu 18.04

1.  第一步：检查系统目录/lib/systemd/system/rc-local.service，如果没有自己新建，文件内容为（如果文件存在本身是没有\[Install\]项的，需要自己添加进去）
    
        #  SPDX-License-Identifier: LGPL-2.1+
        #
        #  This file is part of systemd.
        #
        #  systemd is free software; you can redistribute it and/or modify it
        #  under the terms of the GNU Lesser General Public License as published by
        #  the Free Software Foundation; either version 2.1 of the License, or
        #  (at your option) any later version.
         
        # This unit gets pulled automatically into multi-user.target by
        # systemd-rc-local-generator if /etc/rc.local is executable.
        [Unit]
        Description=/etc/rc.local Compatibility
        Documentation=man:systemd-rc-local-generator(8)
        ConditionFileIsExecutable=/etc/rc.local
        After=network.target
         
        [Service]
        Type=forking
        ExecStart=/etc/rc.local start
        TimeoutSec=0
        RemainAfterExit=yes
        GuessMainPID=no
         
        [Install]
        WantedBy=multi-user.target
        Alias=rc-local.service
    
    ![在这里插入图片描述][509a2c8514624708bcf280d6c0fceb86.png]
2.  etc目录下的文件也需要进行如上修改，检查/etc/systemd/system/rc-local.service，如果没有该文件则新增该文件
    
        #  SPDX-License-Identifier: LGPL-2.1+
        	#
        	#  This file is part of systemd.
        	#
        	#  systemd is free software; you can redistribute it and/or modify it
        	#  under the terms of the GNU Lesser General Public License as published by
        	#  the Free Software Foundation; either version 2.1 of the License, or
        	#  (at your option) any later version.
        	 
        	# This unit gets pulled automatically into multi-user.target by
        	# systemd-rc-local-generator if /etc/rc.local is executable.
        	[Unit]
        	Description=/etc/rc.local Compatibility
        	Documentation=man:systemd-rc-local-generator(8)
        	ConditionFileIsExecutable=/etc/rc.local
        	After=network.target
        	 
        	[Service]
        	Type=forking
        	ExecStart=/etc/rc.local start
        	TimeoutSec=0
        	RemainAfterExit=yes
        	GuessMainPID=no
        	 
        	[Install]
        	WantedBy=multi-user.target
        	Alias=rc-local.service
        	```
3.  创建/etc/rc.local脚本文件，并写入想要运行的脚本命令
    
        vim /etc/rc.local
    
    ![在这里插入图片描述][d47b943dfe5f4810a4a9990a52e75690.png]
4.  给rc.local执行的权限
    
        sudo chmod +x /etc/rc.local
5.  启用服务
    
        sudo systemctl enable rc-local
        sudo systemctl start rc-local.service
        sudo systemctl status rc-local.service
    
    ![在这里插入图片描述][f79db9d6813a47769492579f591d4817.png]
6.  重启电脑看效果  
    通过重启后查看脚本启动的应用是否能够正常运行  
    ![在这里插入图片描述][4f78556965ce4fb8bb7f3b8c0c42783a.png]

#### centos操作系统 ####

> 参考 [Linux设置开机自启动的三种方法][Linux]

1.  根据系统文件配置, 找到对应启动脚本, 系统文件所在位置 `/lib/systemd/system/rc-local.service`  
    ![在这里插入图片描述][b4b3707fdab344a1983cf543e896f501.png]
2.  编辑启动脚本 `vim /etc/rc.d/rc.local`  
    ![在这里插入图片描述][493fca84fcb144ea984b7ee7fadfd140.png]
3.  授予脚本可执行权限 chmod +x /etc/rc.d/rc.local
4.  重启后测试软件是否启动  
    ![在这里插入图片描述][62111b60259940f18cd87eda49a99230.png]

[a78932fc24bd4394b5c7adbb61b7acf1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/9cb45b1c39eb470c9524376c338ae3be.png
[frp]: https://developer.aliyun.com/article/853534?spm=ding_open_doc.document.0.0.14bc722fcPatbM
[Link 1]: https://open.dingtalk.com/document/resourcedownload/dingtalk-on-the-security-of-intranet-applications
[c43eb59c1ab4485b9349af693e5a4db0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/ccf9ee8dab9e46e5a7f1af79904917ff.png
[1207766512024da88100acedbb50a5d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/6ce7de1125ab4b41b13b7d4c9b5f31ee.png
[7b6178d94c5d4459bbb62fe3020d51d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/529c224dfd62430fb65abc3b98e8407c.png
[c8eef706907146539a2652744c364d04.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/3dfd62c7172941298be732cbf79aa21d.png
[Link 2]: https://open.dingtalk.com/document/resourcedownload/configure-the-enterprise-application-gateway
[832a5744260547aea53f55b3fec8cd4d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/644a900ad700438a916454ca3bef1d1e.png
[d8933d385c344348b02ccf620ff30214.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/bc5df6e387604e13a18333c51944bde8.png
[d545b08745a14ec6b7c762a2ba5659c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/ee674e8e1a5d4e30ac458cbe04df42d5.png
[171a7a7c05f746d1a04ba4ff6e7bf0de.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/eadba082bab042758c7c434e9550a786.png
[674eeae0b2f240faa468d3e698ef22b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/305e8178875647ffad06399ce22656ff.png
[97bf4347eaa343b2a2f55ae47382b0e3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/d27bbd8b667f45bd8bceeb3fd4e8d2bc.png
[2991b0871cd34c52b559b5d5dde14af0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/c49325ac01244bcd832c19716db51fc2.png
[e04600966f81413d85b2cf046f9896c0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/1102cf1c259f4664a888342f25b85a64.png
[b34399bb8bd64b88a5a11283c7f292ce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/1bc5a14d499b4e2f9a8bb37d55815250.png
[156aad1eabf644a0b1a0a84ac33d59de.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/4113a1f15915404ba1d0e5f63f97ea0c.png
[57c93a342f3144b1b237f732fad21aec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/d917c2f0a1c242d0b9ce23bd31eef1ef.png
[92280c0286b841e78fd74f37a583c4cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/54e7e21bb6c947ea804d8baf67625288.png
[-]: https://oa.dingtalk.com/index.htm#/microApp/microAppList
[88fe9e5594ef435ca8b0cec18b02a481.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/839080e304d448fcaa3040c15c338ed7.png
[Link 3]: https://open-dev.dingtalk.com/#/
[29d16e7ac60f4cfc8736a6cb42062720.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/50174fe0202c4f05abf1d4b23ee7df7e.png
[f7ff407be29b4ee2882185f16542ba73.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/844b8a21719b4432bfe763703a396445.png
[4f417ae629164a5ba934441b074e4ba5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/d2f94c93030c48e3b81908d03fdf7a1f.png
[Link 4]: https://open.dingtalk.com/document/org/publish-orgapp
[a97a629fdde74b4384687cf51c7df785.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/3c25005b9497422084c373eec0a7cef9.png
[e65732ef70bd4a9688606ad99c61630b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/dfc729ccbe1a485ea97132848de25456.png
[ce7c5c896f264909a434ee1fabd4e5b3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/ca0a18c1f434493190455381130304ea.png
[910d9d2d1b7445adb135ad758e5b9059.png]: https://img-blog.csdnimg.cn/910d9d2d1b7445adb135ad758e5b9059.png
[444e6b3470624077a80ef29bb612f7e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/bc05ca3b1036483eb01007ff8acdd438.png
[1128ebdd5849470da0d5e7f942401a17.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/05e6ea69a497488198bf5fcb7b614e79.png
[cfeff07b1dc549dcad29d7d207c3ba9f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/51445e52bb3543b29fa2b1b9c4bf28ae.png
[5d6b7d581cb549a7a3b9c746370b162a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/28870c95fcee4594aeafc670e7394318.png
[edb06759824946bfa73f33aebec7e156.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/a4cb6f16e4544b8a89329a4188d9f55e.png
[54288b20ede741b8b9032a22af35d955.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/03fb396b608940a5b820bc47532936b8.png
[d4f4c6466d6242fb939fc3bb5e359626.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/bcf2920b25c741549b296b31ac4386cd.png
[0f3f38c6100944fab77d6b9af06862a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/72a8d4b85a5d40da9a10e194ed98226e.png
[9cf13ff6e6ff42c1bcee57c8f00bf968.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/c08c6e177df34ce29ddd734a6f44d3f9.png
[48580e6c3712491386f5b10629a4a809.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/fc1050ac4c5347cfbf05ebd6f308657c.png
[0c7223204115474386c9680dd372f84c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/88bb860d0a2a48f2bc969a8001b1e169.png
[f94d110ebcad4c39b610ff87d4831966.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/fc7dc0e3e01f435381490f13c7de00c1.png
[f21d4c10c9d04c9db0b178fdc9ba9c0f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/9424258c675d4d8c964b8857feec0031.png
[Link 5]: https://open.dingtalk.com/document/org/event-list-1
[7b303ec20a7a4dcfb20fd39360ba4553.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/e722c50582694810ba95e01009c785be.png
[faac27227ff944b1891596e4ef389a0f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/bcbb718212ac4dd981e9d89e98afd608.png
[Link 6]: https://ztna-console.dingtalk.com/#/app
[4f65daff504344419de44d133c4f3449.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/eafed6d994c74249b92e7950bfb017df.png
[d4a0e06f0b5641aba0609e1c07cc9e4a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/ceb16c2b1d9f44dbb096fb7429f7c27d.png
[e9f4ba35ca5f4100a2e0c3f2c642400a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/3b3d62444cdd4bbc9e139611853303f4.png
[d8592000396540b38c4d658f1a6f13a4.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/cb9e227dba5e4148b849b04575cab0e1.jpeg
[Ubuntu]: https://blog.csdn.net/u011473714/article/details/122554757
[509a2c8514624708bcf280d6c0fceb86.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/f923be87ea124987bdfbc175abbf8777.png
[d47b943dfe5f4810a4a9990a52e75690.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/824284f6a91c4a938ea399ff1efdc9e8.png
[f79db9d6813a47769492579f591d4817.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/cca6226350db4c39818d6058f2a527d1.png
[4f78556965ce4fb8bb7f3b8c0c42783a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/c412200c058a4ed18420a9fe9f405c3d.png
[Linux]: https://www.cnblogs.com/Alwayslearn/p/16816093.html
[b4b3707fdab344a1983cf543e896f501.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/869fa6c285dd47658f46e75915e96b3b.png
[493fca84fcb144ea984b7ee7fadfd140.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/e0893b150d5e4e97a906191920e04609.png
[62111b60259940f18cd87eda49a99230.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/d9daa842025e4bbe837bf58260181354.png