​

O2OA應用開發平臺是蘭德縱橫網路技術股份有限公司精心打造的一款開源辦公產品，是使用JavaEE技術棧，分散式架構設計的真正全程式碼開源的企業應用定製化開發平臺，平臺既可以支援小企業的OA協同辦公系統快速搭建，也能支援複雜的集團化大型協同門戶及業務平臺建設，以最低成本，搭建一個OA辦公系統。

本文介紹O2OA服務管理中，介面的許可權設定和呼叫方式。

適用版本：5.4及以上版本

建立介面

具有服務管理設計許可權的使用者（具有ServiceManager角色或Manager角色）開啟“服務管理平臺”，進入介面配置檢視，點選左上角的新建按鈕，可建立一個新的介面。

​

新建介面後，在右側屬性欄中有兩個配置和呼叫許可權有關，一個是“允許訪問的地址表示式”，一個收是“啟用鑑權”。

​

允許訪問的地址表示式

此處允許輸入一個正則表示式，用來匹配呼叫介面的客戶端的Remote_Addr，只有匹配通過，接口才允許執行。例如只允許172.16.1.50到172.16.1.56地址呼叫介面，可以在此處輸入：

172\.16\.1\.5[0-6]

啟用鑑權

此處選擇“是”的話，就需要在呼叫介面時傳入client名稱和一個加密後的token。所以我們先需要一組鑑權配置。

具有管理員許可權的使用者（具有Manager角色），開啟“系統設定”-“系統SSO配置”，找到“鑑權配置”。

​

點選“新增鑑權配置”：

​

此處需要配置一個名稱和金鑰。

名稱：可隨意填寫，就是我們在呼叫介面或進行SSO時要傳入的client引數。

金鑰：可隨意填寫，用於後續加密，最少8位。

此處我們假設名稱填寫：oa；金鑰填寫：platform

填寫完成後確定。

​

然後我們就可以使用此鑑權配置來呼叫介面了。

介面呼叫

介面呼叫的的地址在介面屬性欄中有顯示：

​

當啟用鑑權後的介面呼叫地址為：

http://develop.o2oa.net:20030/x_program_center/jaxrs/invoke/{name}/client/{client}/token/{token}/execute

請求方法為：POST

地址中的{name}為介面的名稱或別名；

地址中的{client}為鑑權的名稱；

地址中的{token}為：使用者名稱#1970年毫秒數 使用鑑權金鑰經過3DES加密後的值。

javascript加密程式碼樣例

我們使用CryptoJS進行DES加密。（GitHub： GitHub - brix/crypto-js: JavaScript library of crypto standards.）

function crypDES (value, key) {
    var keyHex = CryptoJS.enc.Utf8.parse(key);
    var xtoken = CryptoJS.DES.encrypt(value, keyHex, {
      mode: CryptoJS.mode.ECB,
      padding: CryptoJS.pad.Pkcs7
    });
    var str = xtoken.ciphertext.toString(CryptoJS.enc.Base64);
    str = str.replace(/=/g, "");
    str = str.replace(/\+/g, "-");
    str = str.replace(/\//g, "_");
    return str;
},

IOS加密程式碼樣例

/// o2oa DES加密 @param publicKey 加密公鑰
func o2DESEncode(code: String, publicKey: String) -> String? {
    if let encode = desEncrypt(code: code, key: publicKey, iv: "12345678", options: (kCCOptionECBMode + kCCOptionPKCS7Padding)) {
        let first = encode.replacingOccurrences(of: "+", with: "-")
        let second = first.replacingOccurrences(of: "/", with: "_")
        let token = second.replacingOccurrences(of: "=", with: "")
        return token
    }else {
        print("加密錯誤")
        return nil
    }
}
/// DES 加密
func desEncrypt(code: String, key:String, iv:String, options:Int = kCCOptionPKCS7Padding) -> String? {
    if let keyData = key.data(using: String.Encoding.utf8),
        let data = code.data(using: String.Encoding.utf8),
        let cryptData    = NSMutableData(length: Int((data.count)) + kCCBlockSizeDES) {

        let keyLength              = size_t(kCCKeySizeDES)
        let operation: CCOperation = UInt32(kCCEncrypt)
        let algoritm:  CCAlgorithm = UInt32(kCCAlgorithmDES)
        let options:   CCOptions   = UInt32(options)

        var numBytesEncrypted :size_t = 0

        let cryptStatus = CCCrypt(operation,
                                  algoritm,
                                  options,
                                  (keyData as NSData).bytes, keyLength,
                                  iv,
                                  (data as NSData).bytes, data.count,
                                  cryptData.mutableBytes, cryptData.length,
                                  &numBytesEncrypted)

        if UInt32(cryptStatus) == UInt32(kCCSuccess) {
            cryptData.length = Int(numBytesEncrypted)
            let base64cryptString = cryptData.base64EncodedString()
            return base64cryptString
        }
        else {
            return nil
        }
    }
    return nil
}

Android加密程式碼樣例

fun o2DESEncode(code: String, publicKey: String): String {
    val sutil = CryptDES.getInstance(publicKey)
    var encode = ""
    try {
        encode = sutil.encryptBase64(code)
        Log.d(LOG_TAG,"加密後code:$encode")
        encode = encode.replace("+", "-")
        encode = encode.replace("/", "_")
        encode = encode.replace("=", "")
        Log.d(LOG_TAG,"替換特殊字元後的code:$encode")
    }catch (e: Exception) {
        Log.e(LOG_TAG,"加密失敗", e)
    }
    return encode
}

public class CryptDES {
    private Cipher encryptCipher = null;
    private Cipher decryptCipher = null;
    private static CryptDES des = null;
    public static CryptDES getInstance(String des_key) {
        try {
            DESKeySpec key = new DESKeySpec(des_key.getBytes());
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            des = new CryptDES(keyFactory.generateSecret(key));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return des;
    }
    private CryptDES(SecretKey key) throws Exception {
        encryptCipher = Cipher.getInstance("DES");
        decryptCipher = Cipher.getInstance("DES");
        encryptCipher.init(Cipher.ENCRYPT_MODE, key);
        decryptCipher.init(Cipher.DECRYPT_MODE, key);
    }    
    public String encryptBase64 (String unencryptedString) throws Exception {
        // Encode the string into bytes using utf-8
        byte[] unencryptedByteArray = unencryptedString.getBytes("UTF8");
        // Encrypt
        byte[] encryptedBytes = encryptCipher.doFinal(unencryptedByteArray);
        // Encode bytes to base64 to get a string
        byte [] encodedBytes = Base64.encode(encryptedBytes, Base64.DEFAULT);
        return new String(encodedBytes);
    }
    public String decryptBase64 (String encryptedString) throws Exception {
        // Encode bytes to base64 to get a string
        byte [] decodedBytes = Base64.encode(encryptedString.getBytes(), Base64.DEFAULT);
        // Decrypt
        byte[] unencryptedByteArray = decryptCipher.doFinal(decodedBytes);
        // Decode using utf-8
        return new String(unencryptedByteArray, "UTF8");
    }  
}

（轉自公眾號：浙江蘭德網路）

​