1.添加公钥加密参数。

app/src/main/java/com/quansu/heifengwuliu/config/Config.kt

@@ -54,4 +54,19 @@ class Config : IConfig {
     override fun enterpriseSenderCode(): String {
        return "9db07b886ee3457aa33bf79745591fa21ae24fdc687794431c98668520e5dd18d5"
     }
+
+    override fun publicKey(): String {//公钥
+       return "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCpk3FnPYXzQrydZSgPMIbyqE2W\n" +
+               "TKzw0/lCgx1dKcKapMFUql+z8trMG1xtBqw+7oY9rE6NYMvANYyhI4i6fLv0aIZy\n" +
+               "kvnd+JIeqFwhHZYqCof0K4EuaG5CUsz4OlUUdRDzhdId/yuSfhW6srCJDOcvZfYW\n" +
+               "blXT/Dl1YBEDPE22fwIDAQAB"
+    }
+
+    override fun publicKeyName(): String {
+       return "actk"
+    }
+
+    override fun keyName(): String {
+       return "actime"
+    }
 }

base/src/main/java/com/ysnows/base/base/BRepository.kt

@@ -63,6 +63,7 @@ open class BRepository : IRepository {
         return Observable.create { emitter ->
             val qmuiProgressDialog = arrayOfNulls<QMUIProgressDialog>(1)
 
+
             var subscribe = observable
                     .throttleFirst(VConfig.THROTTLE_TIME.toLong(), TimeUnit.MILLISECONDS)
                     .subscribeOn(Schedulers.io())
@@ -90,6 +91,7 @@ open class BRepository : IRepository {
             subscribe
                     .subscribeOn(AndroidSchedulers.mainThread())
                     .observeOn(AndroidSchedulers.mainThread())
+
                     .subscribe(object : Observer<T> {
                         override fun onSubscribe(d: Disposable) {}
                         override fun onNext(iResponse: T) {

base/src/main/java/com/ysnows/base/config/IConfig.java

@@ -1,6 +1,6 @@
 package com.ysnows.base.config;
 
-public interface IConfig extends ApiConfig,IConfigBugly, IConfigOss,IConfigUmeng,IConfigLocation {
+public interface IConfig extends ApiConfig,IConfigBugly, IConfigOss,IConfigUmeng,IConfigLocation,IConfigPublicKey {
 
 
 

base/src/main/java/com/ysnows/base/config/IConfigPublicKey.java

@@ -0,0 +1,15 @@
+package com.ysnows.base.config;
+
+/**
+ * Created by shihuiyun
+ * on 2020/11/9
+ */
+public interface IConfigPublicKey {
+
+    String publicKey();
+
+    String publicKeyName();
+
+    String keyName();
+
+}

base/src/main/java/com/ysnows/base/net/BOkhttpClient.kt

@@ -16,6 +16,7 @@ object BOkhttpClient {
                     .writeTimeout(156760, TimeUnit.MILLISECONDS)
                     .connectTimeout(15676, TimeUnit.MILLISECONDS)
                     .retryOnConnectionFailure(true)
+                    .addInterceptor(CommonInterceptor())//设置公共参数
                     .addInterceptor(ChuckInterceptor(BApp.instance()?.applicationContext))
                     .cookieJar(BCookieJar())
                     .addInterceptor(BHeaderInterceptor())

base/src/main/java/com/ysnows/base/net/CommonInterceptor.kt

@@ -0,0 +1,94 @@
+package com.ysnows.base.net
+
+import android.util.Log
+import com.ysnows.base.base.BApp
+import com.ysnows.base.utils.Base64Util
+import okhttp3.HttpUrl
+import okhttp3.Interceptor
+import okhttp3.Request
+import okhttp3.Response
+import java.security.KeyFactory
+import java.security.NoSuchAlgorithmException
+import java.security.PublicKey
+import java.security.spec.X509EncodedKeySpec
+
+import javax.crypto.Cipher
+
+
+/**
+ *Created by shihuiyun
+ *on 2020/11/9
+ */
+class CommonInterceptor() : Interceptor {
+
+
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val oldRequest: Request = chain.request()
+
+        var time=( System.currentTimeMillis()/1000).toString()
+
+        Log.e("-shy-", "time=: $time")
+
+        var keyTime=encryptByPublic(time!!, BApp.instance()!!.config()!!.publicKey())
+
+        Log.e("-shy-", "keyTime=: $keyTime")
+
+
+        // 添加新的参数
+        val authorizedUrlBuilder: HttpUrl.Builder = oldRequest.url()
+                .newBuilder()
+                .scheme(oldRequest.url().scheme())
+                .host(oldRequest.url().host())
+                .addQueryParameter(BApp.instance()!!.config()!!.publicKeyName(), keyTime)
+                .addQueryParameter(BApp.instance()!!.config()!!.keyName(), time)
+
+        // 新的请求
+
+        // 新的请求
+        val newRequest: Request = oldRequest.newBuilder()
+                .method(oldRequest.method(), oldRequest.body())
+                .url(authorizedUrlBuilder.build())
+                .build()
+
+        return chain.proceed(newRequest)
+    }
+
+
+    /**
+     * 得到公钥
+     *
+     * @param bysKey
+     * @return
+     */
+    @Throws(NoSuchAlgorithmException::class, java.lang.Exception::class)
+    private fun getPublicKeyFromX509(bysKey: String): PublicKey? {
+        val decodedKey: ByteArray = Base64Util.decode(bysKey)
+        val x509 = X509EncodedKeySpec(decodedKey)
+        val keyFactory: KeyFactory = KeyFactory.getInstance("RSA")
+        return keyFactory.generatePublic(x509)
+    }
+
+    /**
+     * 使用公钥加密
+     *
+     * @param content 密文
+     * @param pub_key 公钥
+     * @return
+     */
+    fun encryptByPublic(content: String, pub_key: String?): String? {
+        return try {
+            val pubkey = getPublicKeyFromX509(pub_key!!)
+            val cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding")
+            cipher.init(Cipher.ENCRYPT_MODE, pubkey)
+            val plaintext = content.toByteArray(charset("UTF-8"))
+            val output = cipher.doFinal(plaintext)
+            (Base64Util.encode(output)).toString()
+        } catch (e: java.lang.Exception) {
+            null
+        }
+    }
+
+
+
+}

base/src/main/java/com/ysnows/base/utils/Base64Util.java

@@ -0,0 +1,276 @@
+package com.ysnows.base.utils;
+
+/**
+ * Created by shihuiyun
+ * on 2020/11/9
+ */
+public class Base64Util {
+    static private final int     BASELENGTH           = 128;
+    static private final int     LOOKUPLENGTH         = 64;
+    static private final int     TWENTYFOURBITGROUP   = 24;
+    static private final int     EIGHTBIT             = 8;
+    static private final int     SIXTEENBIT           = 16;
+    static private final int     FOURBYTE             = 4;
+    static private final int     SIGN                 = -128;
+    static private final char    PAD                  = '=';
+    static private final boolean fDebug               = false;
+    static final private byte[]  base64Alphabet       = new byte[BASELENGTH];
+    static final private char[]  lookUpBase64Alphabet = new char[LOOKUPLENGTH];
+
+    static {
+        for (int i = 0; i < BASELENGTH; ++i) {
+            base64Alphabet[i] = -1;
+        }
+        for (int i = 'Z'; i >= 'A'; i--) {
+            base64Alphabet[i] = (byte) (i - 'A');
+        }
+        for (int i = 'z'; i >= 'a'; i--) {
+            base64Alphabet[i] = (byte) (i - 'a' + 26);
+        }
+
+        for (int i = '9'; i >= '0'; i--) {
+            base64Alphabet[i] = (byte) (i - '0' + 52);
+        }
+
+        base64Alphabet['+'] = 62;
+        base64Alphabet['/'] = 63;
+
+        for (int i = 0; i <= 25; i++) {
+            lookUpBase64Alphabet[i] = (char) ('A' + i);
+        }
+
+        for (int i = 26, j = 0; i <= 51; i++, j++) {
+            lookUpBase64Alphabet[i] = (char) ('a' + j);
+        }
+
+        for (int i = 52, j = 0; i <= 61; i++, j++) {
+            lookUpBase64Alphabet[i] = (char) ('0' + j);
+        }
+        lookUpBase64Alphabet[62] = (char) '+';
+        lookUpBase64Alphabet[63] = (char) '/';
+
+    }
+
+    private static boolean isWhiteSpace(char octect) {
+        return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
+    }
+
+    private static boolean isPad(char octect) {
+        return (octect == PAD);
+    }
+
+    private static boolean isData(char octect) {
+        return (octect < BASELENGTH && base64Alphabet[octect] != -1);
+    }
+
+    /**
+     * Encodes hex octects into Base64
+     *
+     * @param binaryData Array containing binaryData
+     * @return Encoded Base64 array
+     */
+    public static String encode(byte[] binaryData) {
+
+        if (binaryData == null) {
+            return null;
+        }
+
+        int lengthDataBits = binaryData.length * EIGHTBIT;
+        if (lengthDataBits == 0) {
+            return "";
+        }
+
+        int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
+        int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
+        int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;
+        char encodedData[] = null;
+
+        encodedData = new char[numberQuartet * 4];
+
+        byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
+
+        int encodedIndex = 0;
+        int dataIndex = 0;
+        if (fDebug) {
+            System.out.println("number of triplets = " + numberTriplets);
+        }
+
+        for (int i = 0; i < numberTriplets; i++) {
+            b1 = binaryData[dataIndex++];
+            b2 = binaryData[dataIndex++];
+            b3 = binaryData[dataIndex++];
+
+            if (fDebug) {
+                System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);
+            }
+
+            l = (byte) (b2 & 0x0f);
+            k = (byte) (b1 & 0x03);
+
+            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
+            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
+            byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);
+
+            if (fDebug) {
+                System.out.println("val2 = " + val2);
+                System.out.println("k4   = " + (k << 4));
+                System.out.println("vak  = " + (val2 | (k << 4)));
+            }
+
+            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
+            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
+            encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
+            encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
+        }
+
+        // form integral number of 6-bit groups
+        if (fewerThan24bits == EIGHTBIT) {
+            b1 = binaryData[dataIndex];
+            k = (byte) (b1 & 0x03);
+            if (fDebug) {
+                System.out.println("b1=" + b1);
+                System.out.println("b1<<2 = " + (b1 >> 2));
+            }
+            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
+            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
+            encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
+            encodedData[encodedIndex++] = PAD;
+            encodedData[encodedIndex++] = PAD;
+        } else if (fewerThan24bits == SIXTEENBIT) {
+            b1 = binaryData[dataIndex];
+            b2 = binaryData[dataIndex + 1];
+            l = (byte) (b2 & 0x0f);
+            k = (byte) (b1 & 0x03);
+
+            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
+            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
+
+            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
+            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
+            encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
+            encodedData[encodedIndex++] = PAD;
+        }
+
+        return new String(encodedData);
+    }
+
+    /**
+     * Decodes Base64 data into octects
+     *
+     * @param encoded string containing Base64 data
+     * @return Array containind decoded data.
+     */
+    public static byte[] decode(String encoded) {
+
+        if (encoded == null) {
+            return null;
+        }
+
+        char[] base64Data = encoded.toCharArray();
+        // remove white spaces
+        int len = removeWhiteSpace(base64Data);
+
+        if (len % FOURBYTE != 0) {
+            return null;//should be divisible by four
+        }
+
+        int numberQuadruple = (len / FOURBYTE);
+
+        if (numberQuadruple == 0) {
+            return new byte[0];
+        }
+
+        byte decodedData[] = null;
+        byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
+        char d1 = 0, d2 = 0, d3 = 0, d4 = 0;
+
+        int i = 0;
+        int encodedIndex = 0;
+        int dataIndex = 0;
+        decodedData = new byte[(numberQuadruple) * 3];
+
+        for (; i < numberQuadruple - 1; i++) {
+
+            if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
+                    || !isData((d3 = base64Data[dataIndex++]))
+                    || !isData((d4 = base64Data[dataIndex++]))) {
+                return null;
+            }//if found "no data" just return null
+
+            b1 = base64Alphabet[d1];
+            b2 = base64Alphabet[d2];
+            b3 = base64Alphabet[d3];
+            b4 = base64Alphabet[d4];
+
+            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
+            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
+            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
+        }
+
+        if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
+            return null;//if found "no data" just return null
+        }
+
+        b1 = base64Alphabet[d1];
+        b2 = base64Alphabet[d2];
+
+        d3 = base64Data[dataIndex++];
+        d4 = base64Data[dataIndex++];
+        if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters
+            if (isPad(d3) && isPad(d4)) {
+                if ((b2 & 0xf) != 0)//last 4 bits should be zero
+                {
+                    return null;
+                }
+                byte[] tmp = new byte[i * 3 + 1];
+                System.arraycopy(decodedData, 0, tmp, 0, i * 3);
+                tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
+                return tmp;
+            } else if (!isPad(d3) && isPad(d4)) {
+                b3 = base64Alphabet[d3];
+                if ((b3 & 0x3) != 0)//last 2 bits should be zero
+                {
+                    return null;
+                }
+                byte[] tmp = new byte[i * 3 + 2];
+                System.arraycopy(decodedData, 0, tmp, 0, i * 3);
+                tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
+                tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
+                return tmp;
+            } else {
+                return null;
+            }
+        } else { //No PAD e.g 3cQl
+            b3 = base64Alphabet[d3];
+            b4 = base64Alphabet[d4];
+            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
+            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
+            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
+
+        }
+
+        return decodedData;
+    }
+
+    /**
+     * remove WhiteSpace from MIME containing encoded Base64 data.
+     *
+     * @param data  the byte array of base64 data (with WS)
+     * @return      the new length
+     */
+    private static int removeWhiteSpace(char[] data) {
+        if (data == null) {
+            return 0;
+        }
+
+        // count characters that's not whitespace
+        int newSize = 0;
+        int len = data.length;
+        for (int i = 0; i < len; i++) {
+            if (!isWhiteSpace(data[i])) {
+                data[newSize++] = data[i];
+            }
+        }
+        return newSize;
+    }
+}