使用鉴权配置控制接口的调用权限

172.16.1.5[0-6]

var login_uid = "test";

var time = new Date().getTime();

var sso_key = "12345678";

var xtoken = crypDES( login_uid + "#" + time, sso_key );

/// o2oa 3DES加密 @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

    }

}

/// 3DES 加密

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

}

let uid = "test"

let timeInterval = Date().timeIntervalSince1970

let time = CLongLong(round(timeInterval*1000))

let code = "(uid)#(time)"

let xtoken = code.o2DESEncode() ?? ""

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");

    }

}

Crypto.java

import java.io.IOException;

import java.net.URLDecoder;

import java.net.URLEncoder;

import java.security.SecureRandom;

import javax.crypto.Cipher;

import javax.crypto.SecretKey;

import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESKeySpec;

import org.apache.commons.codec.binary.Base64;

import org.apache.commons.lang3.StringUtils;

/**

 * encrypt and decrypt utils

 * @author O2OA

 *

 */

public class Crypto {

    private static final String utf8 = "UTF-8";

    private final static String DES = "DES";

    private final static String cipher_init = "DES";

    public static String encrypt(String data, String key) throws Exception {

      byte[] bt = encrypt(data.getBytes(), key.getBytes());

      String str = Base64.encodeBase64URLSafeString(bt);

      return URLEncoder.encode( str, utf8 );

  }

  public static byte[] encrypt(byte[] data, byte[] key) throws Exception {

      // 生成一个可信任的随机数源

      SecureRandom sr = new SecureRandom();

      // 从原始密钥数据创建DESKeySpec对象

      DESKeySpec dks = new DESKeySpec(key);

      // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象

      SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);

      SecretKey securekey = keyFactory.generateSecret(dks);

      // Cipher对象实际完成加密操作

      Cipher cipher = Cipher.getInstance(cipher_init);

      // 用密钥初始化Cipher对象

      cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);

      return cipher.doFinal(data);

  }

  public static String decrypt(String data, String key) throws IOException, Exception {

      if (StringUtils.isEmpty(data)) {

          return null;

      }

      String str = URLDecoder.decode(data, utf8);

      byte[] buf = Base64.decodeBase64(str);

      byte[] bt = decrypt(buf, key.getBytes());

      return new String(bt);

  }

  public static byte[] decrypt(byte[] data, byte[] key) throws Exception {

      // 生成一个可信任的随机数源

      SecureRandom sr = new SecureRandom();

      // 从原始密钥数据创建DESKeySpec对象

      DESKeySpec dks = new DESKeySpec(key);

      // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象

      SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);

      SecretKey securekey = keyFactory.generateSecret(dks);

      // Cipher对象实际完成解密操作

      Cipher cipher = Cipher.getInstance(cipher_init);

      // 用密钥初始化Cipher对象

      cipher.init(Cipher.DECRYPT_MODE, securekey, sr);

      return cipher.doFinal(data);

  }

}

String login_uid = "test";

long time = new Date().getTime();

String sso_key = "12345678";

String xtoken = Crypto.encrypt( login_uid + "#" + time, sso_key );