App安全

发表于 2022/04/26 更新于 2025/02/02

作者 Hacket Zeng

22 分钟阅读

App安全

禁止 APP 录屏和截屏

Android 有些 APP 会为了安全，禁止录屏和截屏，例如：金融、银行相关的。禁止录屏和截屏并不难，只需要在 Activity 的 onCreate() 方法中添加一行代码即可：

  
getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);

添加这行代码后，当截屏的时候，系统会弹出一个 Toast 提示 “ 禁止屏幕抓取 “；当录屏的时候，看似能够正常录制，但是保存后的视频，都是一片黑色，并没有 APP 的相关界面。
https://www.cnblogs.com/qixingchao/p/11652392.html

Android KeyStore 非对称 + 对称加密

KeyStore

Android KeyStore 系统允许你存储加密密钥。如果是 AndroidKeyStore 这种类型的话，keystore 难以从设备中导出，并且可以指明 key 的使用规则，例如只有用户验证后，才可以使用 key 等；但如果是 bks 这种的话，就比较容易导出。

Key material never enters the application process.
Key material may be bound to the secure hardware(e.g., Trusted Execution Environment(TEE), Secure Element(SE)) of the Android device.

可以通过以下代码获取你的 KeyStore：

  
try {
    KeyStore mKeyStore = KeyStore.getInstance(“类型");
} catch (KeyStoreException e) {
    return;
}

KeyStore.getInstance(参数) 中的参数可以传以下内容：

AndroidKeyStore：这里要先区分下 AndroidKeyStore 和 Android KeyStore，虽然这两个一样，但是后者中间多了个空格，意义是不一样的，前者是子集，后者是父集，后者包含前者。而 AndroidKeyStore 主要是用来存储一些密钥 key 的，存进该处的 key 可以为其设置 KeyProtection，例如只能通过用户验证才能取出 key 使用等。这些 key 是存在系统里的，不是在 app 的目录下，并且每个 app 不能访问其他 app 的 key，如果 app1 创建了 key1，并且存储的时候命名为 temp，app2 去通过 temp 去访问 key，是获取不到的！！
KeyStore.getDefaultType()：该函数返回的是一个字符串，在 java 下，返回的是 JKS，在 Android 下，返回的是 BKS。(注：android 系统中使用的证书要求以 BKS 的库文件结构保存，通常情况下，我们使用 java 的 keytool 只能生成 jks 的证书库。读取 key 可以通过 psw 来读取)。当你使用这个 keystore 的时候，其文件存放在 data（沙盒中）

签名和 Keystore 关系

签名的话其实是对一个 app 加上开发者的签名，证明这个 app 和开发者的关系。通过签名可以证明这个是正版的 app，如果是假冒伪劣的 app，那么是不允许安装的。这怎么说呢？其实就是用了签名 keystore 文件，在该文件中有一对 非对称密钥，签名的时候使用 私钥 对 apk 中所有的文件内容进行加密，并且签名后的 apk 携带 keystore 文件中的公钥，当安装在手机系统上的时候系统会取出公钥，对 apk 进行验证，查看是不是使用正确私钥加密的 apk，或者 apk 是否被人篡改过。如果篡改过，那么公钥验证不通过。

使用

  
/**
 * AndroidKeyStore加密存储
 *
 * 1. 使用KeyStore随机生成RSA Key
 *
 * 2. 产生AES Key，并用RSA Public Key加密后保存到sp
 *
 * 3. 从SP取出AES Key，并用RSA Private Key解密，用这把AES Key来加解密数据
 */
public final class AndroidKeyStoreUtils {

    private static final String KEYSTORE_PROVIDER = "AndroidKeyStore";
    private static final String KEYSTORE_ALIAS = "KEYSTORE_DEMO";

    private static final String AES_MODE = "AES/GCM/NoPadding";
    private static final String RSA_MODE = "RSA/ECB/PKCS1Padding";

    private static KeyStore sMKeyStore;

    public static void init() {
        try {
            initKeyStore();
            generateKey();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static KeyStore initKeyStore() throws Exception {
        if (sMKeyStore == null) {
            log("1. 初始化AndroidKeyStore");
            sMKeyStore = KeyStore.getInstance(KEYSTORE_PROVIDER);
            sMKeyStore.load(null);
        }
        return sMKeyStore;
    }

    private static void generateKey() {
        try {
            if (getAESKey() == null || getAESIV() == null) {
                genKeyStoreKey(GlobalContext.getAppContext());
                genAESKey();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 1、KeyStore生成RSA Key
     */
    private static void genKeyStoreKey(Context context) throws Exception {
        log("2. AndroidKeyStore生成RSA Key");
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            generateRSAKey_AboveApi23();
        } else {
            generateRSAKey_BelowApi23(context);
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.M)
    private static void generateRSAKey_AboveApi23() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator
                .getInstance(KeyProperties.KEY_ALGORITHM_RSA, KEYSTORE_PROVIDER);

        KeyGenParameterSpec keyGenParameterSpec = new KeyGenParameterSpec
                .Builder(KEYSTORE_ALIAS, KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
                .setDigests(KeyProperties.DIGEST_SHA256, KeyProperties.DIGEST_SHA512)
                .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_RSA_PKCS1)
                .build();

        keyPairGenerator.initialize(keyGenParameterSpec);
        keyPairGenerator.generateKeyPair();
    }

    private static void generateRSAKey_BelowApi23(Context context) throws NoSuchAlgorithmException,
            NoSuchProviderException, InvalidAlgorithmParameterException {
        Calendar start = Calendar.getInstance();
        Calendar end = Calendar.getInstance();
        end.add(Calendar.YEAR, 30);

        KeyPairGeneratorSpec spec = new KeyPairGeneratorSpec.Builder(context)
                .setAlias(KEYSTORE_ALIAS)
                .setSubject(new X500Principal("CN=" + KEYSTORE_ALIAS))
                .setSerialNumber(BigInteger.TEN)
                .setStartDate(start.getTime())
                .setEndDate(end.getTime())
                .build();

        KeyPairGenerator keyPairGenerator = KeyPairGenerator
                .getInstance(KeyProperties.KEY_ALGORITHM_RSA, KEYSTORE_PROVIDER);

        keyPairGenerator.initialize(spec);
        keyPairGenerator.generateKeyPair();
    }

    /**
     * 生成AES Key和IV，用RSA Public Key加密AES Key保存到SP
     */
    private static void genAESKey() throws Exception {
        // Generate AES-Key
        byte[] aesKey = new byte[16];
        SecureRandom secureRandom = new SecureRandom();
        secureRandom.nextBytes(aesKey);

        // Generate 12 bytes iv then save to SharedPrefs
        byte[] generated = secureRandom.generateSeed(12);
        String iv = Base64.encodeToString(generated, Base64.DEFAULT);
        log("【genAESKey】初始化一个iv并进行Base64编码保存：" + iv);
        SPUtils.put("aes_iv", iv);

        // Encrypt AES-Key with RSA Public Key then save to SharedPrefs
        String encryptAESKey = encryptRSA(aesKey);
        SPUtils.put("aes_key", encryptAESKey);
        log("【genAESKey】初始化一个AES Key并通过RSA公钥进行加密保存：" + encryptAESKey);

        log("3. 生成AES Key和IV，用RSA Public Key加密AES Key保存到SP，IV base64：" + iv + "，encryptAESKeyByRSAPublicKey：" + encryptAESKey);
    }

    /**
     * RSA公钥加密
     *
     * 使用RSA Public Key 加密 AES Key，存入缓存中
     */
    private static String encryptRSA(byte[] plainText) throws Exception {
        PublicKey publicKey = initKeyStore().getCertificate(KEYSTORE_ALIAS).getPublicKey();

        Cipher cipher = Cipher.getInstance(RSA_MODE);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        byte[] encryptedByte = cipher.doFinal(plainText);
        return Base64.encodeToString(encryptedByte, Base64.DEFAULT);
    }

    /**
     * RSA私钥解密
     *
     * 使用RSA Private Key 解密 得到 AES Key
     */
    private static byte[] decryptRSA(String encryptedText) throws Exception {
        PrivateKey privateKey = (PrivateKey) initKeyStore().getKey(KEYSTORE_ALIAS, null);

        Cipher cipher = Cipher.getInstance(RSA_MODE);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        byte[] encryptedBytes = Base64.decode(encryptedText, Base64.DEFAULT);
        byte[] decryptedBytes = cipher.doFinal(encryptedBytes);

        return decryptedBytes;
    }

    private static SecretKeySpec getAESKey() throws Exception {
        String aesKey = (String) SPUtils.get("aes_key", "");
        if (TextUtils.isEmpty(aesKey)) {
            return null;
        }
        byte[] aesKeyBytes = decryptRSA(aesKey);
        return new SecretKeySpec(aesKeyBytes, AES_MODE);
    }

    private static byte[] getAESIV() {
        String aesIV = (String) SPUtils.get("aes_iv", "");
        if (TextUtils.isEmpty(aesIV)) {
            return null;
        }
        byte[] iv = Base64.decode(aesIV, Base64.DEFAULT);
        return iv;
    }

    /**
     * AES Encryption
     *
     * @param plainText: A string which needs to be encrypted.
     * @return A base64's string after encrypting.
     */
    public static String encryptAES(String plainText) throws Exception {
        Cipher cipher = Cipher.getInstance(AES_MODE);
        cipher.init(Cipher.ENCRYPT_MODE, getAESKey(), new IvParameterSpec(getAESIV()));

        // 加密過後的byte
        byte[] encryptedBytes = cipher.doFinal(plainText.getBytes());

        // 將byte轉為base64的string編碼
        String cipherData = Base64.encodeToString(encryptedBytes, Base64.DEFAULT);
        log("AES加密+base64：" + cipherData);
        return cipherData;
    }

    public static String decryptAES(String encryptedText) throws Exception {
        // 將加密過後的Base64編碼格式 解碼成 byte
        byte[] decodedBytes = Base64.decode(encryptedText.getBytes(), Base64.DEFAULT);

        // 將解碼過後的byte 使用AES解密
        Cipher cipher = Cipher.getInstance(AES_MODE);
        cipher.init(Cipher.DECRYPT_MODE, getAESKey(), new IvParameterSpec(getAESIV()));

        String plainTextData = new String(cipher.doFinal(decodedBytes));
        log("Base64+AES解密：" + plainTextData);
        return plainTextData;
    }

    /**
     * 字节数组转16进制
     *
     * @param bytes 需要转换的byte数组
     * @return 转换后的Hex字符串
     */
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(bytes[i] & 0xFF);
            if (hex.length() < 2) {
                sb.append(0);
            }
            sb.append(hex);
        }
        return sb.toString();
    }

    private static void log(String msg) {
        LogUtil.i(msg);
    }

}

Reference

Android Keystore 对称－非对称加密
https://www.cnblogs.com/CharlesGrant/p/8378854.html

App 安全

接口安全

请求合法性校验

身份校验，一般用 token
token 一般要有有效期

参数签名校验

header 或 params 参与计算，进行 hash
加点盐啥的

流程

在 Http 的请求中生成唯一的签名 (signature), 当 Server 接收到请求之后首先对请求中参数进行校验，采用同样签名方式生成签名及其校验，如果服务端生成的签名 (autograph) 和 Http 请求的 Signature 一致，则处理清理，否则，则请求丢弃。其交互流程如下：

以上所示中，网关和前端针对同一个 appKey 采取同样的秘钥，用请求签名的版本号老兼容、过度、演进签名算法，其两侧的签名算法保持一致，此处，由于前端逆向工程及其秘钥储存安全性考虑，前端侧采取无线保镖 (灰度安全图片) 进行秘钥储存，其无线保镖生成规则如下：

在前端运行时从无线保镖 (安全图片) 获取秘钥，该秘钥用于计算生成请求签名，对于请求签名的生成的代码安全。web 侧用严格的 js 混淆、压缩，并将其核心算法注册到 service worker，app 将签名算法用其 C++ 实现，Android、IOS 通过 FFI 方式进行底层调用，并将其接入到 Http 的 SDK 中。

其请求签名的核心算法如下：

网关会根据请求参数，对签名进行验证，签名不合法的请求将会被拒绝。目前暂定支持的签名算法有三种：MD5(sign_method=md5)，HMAC_MD5(sign_method=hmac)，HMAC_SHA256（sign_method=hmac-sha256)，签名大体过程如下：
对所有 API 请求参数（本地仅仅是请求头)，但除去 sign 参数和 byte[] 类型的参数），根据参数名称的 ASCII 码表的顺序排序。如：foo:1, bar:2, foo_bar:3, foobar:4 排序后的顺序是 bar:2, foo:1, foo_bar:3, foobar:4。
将排序好的参数名和参数值拼装在一起，根据上面的示例得到的结果为：bar2foo1foo_bar3foobar4。
把拼装好的字符串采用 utf-8 编码，使用签名算法对编码后的字节流进行摘要。如果使用 MD5 算法，则需要在拼装的字符串前后加上 app 的 secret 后，再进行摘要，如：md5(secret+bar2foo1foo_bar3foobar4+secret)；如果使用 HMAC_MD5 算法，则需要用 app 的 secret 初始化摘要算法后，再进行摘要，如：hmac_md5(bar2foo1foo_bar3foobar4)。
将摘要得到的字节流结果使用十六进制表示，如：hex(“helloworld”.getBytes(“utf-8”)) = “68656C6C6F776F726C64”

说明：MD5 和 HMAC_MD5 都是 128 位长度的摘要算法，用 16 进制表示，一个十六进制的字符能表示 4 个位，所以签名后的字符串长度固定为 32 个十六进制字符。

JAVA 代码签名示例

  
public static String signTopRequest(Map<String, String> params, String secret, String signMethod) throws IOException {
    // 第一步：检查参数是否已经排序
    String[] keys = params.keySet().toArray(new String[0]);
    Arrays.sort(keys);
 
    // 第二步：把所有参数名和参数值串在一起
    StringBuilder query = new StringBuilder();
    if (Constants.SIGN_METHOD_MD5.equals(signMethod)) { //签名的摘要算法，可选值为：hmac，md5，hmac-sha256
        query.append(secret);
    }
    for (String key : keys) {
        String value = params.get(key);
        if (StringUtils.areNotEmpty(key, value)) {
            query.append(key).append(value);
        }
    }
 
    // 第三步：使用MD5/HMAC加密
    byte[] bytes;
    if (Constants.SIGN_METHOD_HMAC.equals(signMethod)) {
        bytes = encryptHMAC(query.toString(), secret);
    } else {
        query.append(secret);
        bytes = encryptMD5(query.toString());
    }
 
    // 第四步：把二进制转化为大写的十六进制(正确签名应该为32大写字符串，此方法需要时使用)
    //return byte2hex(bytes);
}
 
public static byte[] encryptHMAC(String data, String secret) throws IOException {
    byte[] bytes = null;
    try {
        SecretKey secretKey = new SecretKeySpec(secret.getBytes(Constants.CHARSET_UTF8), "HmacMD5");
        Mac mac = Mac.getInstance(secretKey.getAlgorithm());
        mac.init(secretKey);
        bytes = mac.doFinal(data.getBytes(Constants.CHARSET_UTF8));
    } catch (GeneralSecurityException gse) {
        throw new IOException(gse.toString());
    }
    return bytes;
}
 
public static byte[] encryptMD5(String data) throws IOException {
    return encryptMD5(data.getBytes(Constants.CHARSET_UTF8));
}
 
public static String byte2hex(byte[] bytes) {
    StringBuilder sign = new StringBuilder();
    for (int i = 0; i < bytes.length; i++) {
        String hex = Integer.toHexString(bytes[i] & 0xFF);
        if (hex.length() == 1) {
            sign.append("0");
        }
        sign.append(hex.toUpperCase());
    }
    return sign.toString();
}

post 参数多层时的 sign 时候

设计 sign 校验时，如果要校验 body 的参数和值，那么需要考虑是否要校验多层的结构，很多只设计了单层的校验。

第 1 种单层 {key1:value1, key2:value2}，第 2 种多层 {key1:value1,key2:{key3:value3,key4:value4} } 及第 3 种多层数组 {key1:value1, key2:[{key3:value3,key4:value4],} } 传递参数方式，只支持单层；第 2 种和第 3 种 sign 校验要多考虑

案例：

  
{
  "wish": [
        {"gid": 2, // 礼物id
         "cnt": 10, // 目标礼物数量
         "rwd": "奖励xx",
        },
        ...
      ]
}

body 加密

body 体进行对称加密

接口重放攻击

请求重放就是指把请求被原封不动地重复发送，一次，两次…n 次，
在针对 http 的请求方式中，有 post、put 等请求方式是不冪等的。这种情况下，就需要更加注意请求重放啦，从而造成不必要的大量的脏数据。在 pc 上的处理通常处理方式是隐藏域或 token 来解决。而针对 restful api 我们需要用 timestamp+nonce 来解决。

client 端 (HTTP SDK)

timestamp
- 用来表示请求的当前时间戳，这个时间要事先和服务器时间戳校正过。我们预期正常请求带的时间戳会是不同的，如：假设正常人每秒至多会做一个操作。
- 每个请求携带的时间戳不能和当前时间距离很近，即不能超过规定时间，如 60s。这样请求即使被截取了，也只能在有限时间（如：60s）内进行重放，过期就会失效
nonce
- 仅仅提供 timestamp 还是不够的，我们还是提供给攻击者 60s 的可攻击时间了。要避免 60 秒内发生攻击，我们还需要使用一个 nonce 随机数。
- nonce 是由客户端根据随机生成的，比如 md5(timestamp+rand(0, 1000)，正常情况下，在短时间内（比如 60s）连续生成两个相同 nonce 的情况几乎为 0。

server 端 (Gateway)

在分布式缓存 (如: REDIS) 中查找是否有 key 为 nonce:{nonce}的 string
如果没有，则创建这个 key，把这个 key 失效的时间和验证 timestamp 失效的时间设置一致，比如是 60s。
如果有，说明这个 key 在 60s 内已被使用过了，这个请求就可以判断为重放请求。

so 安全

1、三方 app key 存 so

通过简单的算法将 key 生成出来

2、so 防止被盗用

so 校验 app 的签名

App 加固

App 加壳

App 反调试与代码保护的一些基本方案 Proguard

isDebuggerConnected

isDebuggerConnected 函数用于检测此刻是否有调试器挂载到程序上，如果返回值为 true 则表示此刻被调试中。用法很简单，如下：

android:debuggable 属性

在 Android 的 AndroidManifest.xml 清单文件的 application 节点下加入 android:debuggable=”false” 属性，使程序不能被调试。在 Java 程序代码里也可检测该属性的值，如下：

Android app 反调试与代码保护的一些基本方案
https://mp.weixin.qq.com/s/uvrkAvbfWuDYf7SWX_dJBA

Android 密钥、AppSecret 保存到 native 层

保存密钥常用方式

硬编码到 Java 层 or Java 层变相/计算保存
Gradle，通过 BuildConfig 读取
写在 gradle properties 中，再在 build gradle 中读取，同第二种方法

实质都是 Java 代码，Android 代码中很容易让别人通过反编译进行读取；这样就存在很大的安全隐患；

保存到 C/C++ 代码

  
#include <jni.h>
#include <string>

#define LOGINFO(...) ((void)__android_log_print(ANDROID_LOG_INFO, "security", __VA_ARGS__))
#define LOGERROR(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "security", __VA_ARGS__))

extern "C"
JNIEXPORT jstring JNICALL
Java_qsbk_app_voice_common_net_SecurityUtils_getSecretKey(JNIEnv *env, jclass type) {
    std::string hello = "obMImdpSP0mqGKlzIYyJej09HqzOj08G";
    return env->NewStringUTF(hello.c_str());
}

extern "C"
JNIEXPORT jstring JNICALL
Java_qsbk_app_voice_common_net_SecurityUtils_getSault(JNIEnv *env, jclass type) {
    return env->NewStringUTF("sault");
}

extern "C"
JNIEXPORT jstring JNICALL
Java_qsbk_app_voice_common_net_SecurityUtils_getMMKVKey(JNIEnv *env, jclass type) {
    return env->NewStringUTF("hbMImdpSP0mqGKlzIYyJej09HqzOj17G");
}

声明 Java 代码

  
public final class SecurityUtils {
    static {
        System.loadLibrary("qbvoicechatsecurity");
    }

    public static native String getMMKVKey();

    public static native String getSecretKey();

    public static native String getSault();
}

Jni 是通过反射的方式来相互调用，也就是说，我们的 native 方法是不能混淆的，那么就可以反编译拿到.so 库和同名的 native 方法，然后通过二次打包 debug 出这个密钥串。所以我们需要一种预防 debug 的手段，这里我们采取验证 apk 签名的方式来达到目的，当发现 apk 签名和我们自己的签名不一致的时候，调用 so 库直接崩溃即可。

Android进阶, 逆向

安全逆向

本文由作者按照 CC BY 4.0 进行授权