1. Toy模板网首页
  2. > Toy博客

如何解决APP抓包问题【网络安全】

6月前 作者：瓦罗兰特顶级C位 分类：Toy博客 阅读(42) 违法举报

这篇具有很好参考价值的文章主要介绍了如何解决APP抓包问题【网络安全】。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1.前言

在日常渗透过程中我们经常会遇到瓶颈无处下手，这个时候如果攻击者从APP进行突破，往往会有很多惊喜。但是目前市场上的APP都会为防止别人恶意盗取和恶意篡改进行一些保护措施，比如模拟器检测、root检测、APK加固、代码混淆、代码反调试、反脱壳、签名校验等等对抗机制。

而测试人员对APP进行渗透的首步操作通常就是上burp或者Charles这类抓包工具进行抓包，查看请求记录里的域名及链接地址是否可以进一步利用，但是如果遇到一些APP出现证书报错或者抓不到包的情况该怎么办，读过本篇文章之后，相信你会拥有一些新的解决方案和思考。

2.数字证书

我们都知道http协议传输的是明文信息，是可以直接捕获的，从而造成了数据泄露。为了防止中间人的拦截，出现了HTTPS加密机制。在HTTPS中，使用了证书+数字签名解决了这个问题。

此篇的重点在于如何应对APP的抓包对抗。

总结的HTTPS加密机制如下：

  • 数字签名是发送方的明文经历了两次加密得到的两个东西组成，一个是hash ，一个是经过私钥加密。
  • 数字证书就是明文+数字签名。但是数字证书中的内容远不止这俩，还包括了权威机构的信息，服务器的域名，最重要的是有签名的计算方法，不然用公钥进行解密之后的hash，如何与加密明文进行对比呢，还有证书中还包括公钥，公钥用于发放给请求证书的客户端。
  • HTTPS就是使用SSL/TLS协议进行加密传输，让客户端拿到服务器的公钥，然后客户端随机生成一个对称加密的秘钥，使用公钥加密，传输给服务端，后续的所有信息都通过该对称秘钥进行加密解密，完成整个HTTPS的流程。

3.https抓包

导入用户证书

在第一次使用burp时，都会有这么一步，将burp的证书导出，添加进浏览器 【受信任的根证书颁发机构】中去，这样就会信任burp发来的请求包，也就可以请求数据进行修改。我们对APP抓包，也同样要将burp证书安装到系统证书中去，一般从【SD卡安装】的证书会存放在用户信任的凭据下 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

但是，在Android 7.0以前，应用默认会信任系统证书和用户证书，Android 7.0开始，默认只信任系统证书。

所以如果你的手机是处于Android7.0以上版本的话，并且在没有绑定SSL证书的情况下，也会抓不到包，从安卓开发的角度可以很清楚的看到这一点。

下图是我将burp证书安装到Android7.1.2的用户证书下，使用okhttp对https://ttt.com进行请求的结果。由于ttt.com的SSL证书是自签名证书，而自签名证书是不被系统默认信任的，所以需要先将ttt.com的自签名证书添加到系统证书中才可以访问。 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

自签名证书的生成如下图所示： app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

  • 系统证书路径：/system/etc/security/cacerts/
  • 用户证书路径：/data/misc/user/0/cacerts-added/

移动到系统根证书路径的方法：

1、导出burp.der

2、使用openssl更改证书格式,先将burp证书的der格式转成pem,再获取证书的hash

openssl x509 -inform DER -in burp.der -out burp.pem
openssl x509 -inform PEM -subject_hash_old -in burp.pem 

复制代码

app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

3.移动到系统根证书目录路径下

Android根证书目录都是以pem证书的hash值+.0格式，所以要将刚才生成的pem改名为xxxx.0

mv burp.pem a5ba575.0

复制代码

由于系统读写权限问题，不一定能直接上传到system目录

adb push 9a5ba575.0 /sdcard

adb shell 
mount -o remount,rw /system
cp /sdcard/9a5ba575.0 /system/etc/security/cacerts/
chmod 644 /system/etc/security/cacerts/9a5ba575.0

复制代码

移动完成之后，再打开【设置】-【安全】-【信任的凭据】验证一下 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

这时可以在Android7.0以上版本正常访问https://ttt.com了，其他抓包工具同理即可。

证书有效期过长

还有一种情况是，导入到系统证书仍抓不到包，并且浏览器会报NET::ERR_CERT_VALIDITY_TOO_LONG错误。

原因是chrome从2018年开始只信任有效期少于825天（27个月）的证书，而burp证书有效期过长。

解决方案是自己做一个低于27个月的root证书导入burp，再通过burp重新导出证书并放入到系统证书路径下。

openssl genrsa -out key.pem 3072 -nodes
openssl req -new -x509 -key key.pem -sha256 -config openssl.cnf -out cert.pem -days 730 -subj "/C=JP/ST=/L=/O=m4bln/CN=MY CA"
openssl pkcs12 -export -inkey key.pem -in cert.pem -out cert_and_key.pfx
把cert_and_key.pfx导入burp

复制代码

目前还没遇到过这种情况，但是如果遇到了这种问题要知道怎么解决。

以上两种方法都是仅依靠了系统校验证书的方式进行抓包，APP在整个请求HTTPS的请求过程时还并未进行证书校验，和在普通的浏览器中访问并无区别，只是要将想要被信任的证书放入系统证书路径内。

4.SSLPinning

对于像ttt.com这种自签名的免费证书，不需要CA权威认证的证书，大多数APP开发商都会使用。那么如果在安卓开发的过程中，将证书的验证逻辑放在APP内部，与系统和浏览器毫无相关，这时再想将burp证书导入系统受信任路径下也于事无补了。

APP自己校验证书，分为两种，一种是将验证逻辑也在代码中，一种是写在安卓7.0之后才有的network-security-config中。

验证是方式也有两种，一种是验证证书公钥的hash值，一种是直接验证证书的公钥文件。

这种通过APP自身的验证方式就叫做证书绑定(也叫Certificate Pinning或SSL Pinning)。

那么如何去判断一个APP是否使用了证书绑定呢？首先拿到apk文件，用apktool工具进行反编译，查看敏感文件

apktool d -s <file.apk> -o <outdir>

复制代码

开发人员经常会将网络配置的相关文件保存到指定位置，如下图就指定在了xml目录下。 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

所以在反编译后的res/xml目录下会有一个network_security_config.xml文件，打开看到标签，说明使用了证书绑定机制。

app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

在配置文件中检验的两种方法

<network-security-config xmlns:tools="http://schemas.android.com/tools">
    <!--允许http访问-->
    <base-config cleartextTrafficPermitted="true"
        tools:ignore="InsecureBaseConfiguration" />

    <!--证书校验-->
    <domain-config>
        <domain includeSubdomains="true">www.ttt.com</domain>
        <trust-anchors>
            <certificates src="@raw/ttt"/>
        </trust-anchors>
    </domain-config>

    <!--公钥校验-->
    <domain-config cleartextTrafficPermitted="true">
        <domain includeSubdomains="true">ttt.com</domain>
        <!--利用xml校验证书公钥的hash值-->
        <pin-set expiration="2099-01-01"
            tools:ignore="MissingBackupPin">
            <pin digest="SHA-256">7VMdvZE3PGbxb0Pgf1PlCp+MI8KZ2ZC5psM8TIylNDA=</pin>
        </pin-set>
        <!--利用xml校验证书的公钥文件-->
        <trust-anchors>
            <certificates src="@raw/ttt"/>
        </trust-anchors>
    </domain-config>

</network-security-config>

复制代码

这两种校验机制出现一种即可，从代码中可以看出，ttt.com就是安卓自己要校验绑定的域名。

如果只是在这个文件进行校验，有两种解决方案：一是直接将文件中校验的部分或注释掉，再重新打包和签名即可，但是这过程又有些麻烦，并不是上上策，如果遇到了不能重打包的apk就尴尬了。。。二是最常用的也是最好用的frida来hook关键函数进行绕过，后面会讲解。当然有些人会直接在真机或者模拟器上安装xposed模块，但是我个人觉得每次使用都要软重启，可能还会造成卡机，所以感觉还是使用frida最方便。

在代码中检验的两种方法

1.利用代码校验证书的公钥hash

String hostname = "www.ttt.com";
CertificatePinner certificatePinner = new CertificatePinner.Builder()
    .add(hostname, "sha256/7VMdvZE3PGbxb0Pgf1PlCp+MI8KZ2ZC5psM8TIylNDA=")
    .build();
OkHttpClient client = new OkHttpClient.Builder()
    .certificatePinner(certificatePinner)
    .hostnameVerifier(new HostnameVerifier() {
        @Override
        public boolean verify(String hostname, SSLSession session) {
            return true;
        }
    }).build();

复制代码

2.利用代码校验证书的公钥证书文件

// 获取证书输入流
InputStream openRawResource = getApplicationContext().getResources().openRawResource(R.raw.ttt); 
Certificate ca = CertificateFactory.getInstance("X.509").generateCertificate(openRawResource);
// 创建 Keystore 包含我们的证书
KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
keyStore.load(null, null);
keyStore.setCertificateEntry("ca", ca);
// 创建一个 TrustManager 仅把 Keystore 中的证书 作为信任的锚点
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); // 建议不要使用自己实现的X509TrustManager，而是使用默认的X509TrustManager
trustManagerFactory.init(keyStore);
// 用 TrustManager 初始化一个 SSLContext
sslContext = SSLContext.getInstance("TLS");  //定义：public static SSLContext sslContext = null;
sslContext.init(null, trustManagerFactory.getTrustManagers(), new SecureRandom());

OkHttpClient client = new OkHttpClient.Builder()
    .sslSocketFactory(sslContext.getSocketFactory(),
                      (X509TrustManager) trustManagerFactory.getTrustManagers()[0] )
    .hostnameVerifier(new HostnameVerifier() {
        @Override
        public boolean verify(String hostname, SSLSession session) {
            return true;
        }
    }).build();

复制代码

通过frida进行hook，这种绕过的脚本也很多，比较熟悉的有JustTrustMe和DroidSSLUnpinning，他们的底层原理都是一样的，通过hook关键的验证函数，进行逻辑绕过。

frida的安装过程就不详细讲解了，网上很多教程。这里我使用的是frida 12.8.0 + frida-tools=5.3.0

这里我使用的hook.js的脚本如下：

/*  Android ssl certificate pinning bypass script for various methods
by Maurizio Siddu modify by Ch3nYe

Run with:
frida -U -f [APP_ID] -l frida_multiple_unpinning.js --no-pause
*/
setTimeout(function() {
Java.perform(function () {
console.log('');
console.log('======');
console.log('[#] Android Bypass for various Certificate Pinning methods [#]');
console.log('======');

var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
var SSLContext = Java.use('javax.net.ssl.SSLContext');

// TrustManager (Android < 7) //

var TrustManager = Java.registerClass({
// Implement a custom TrustManager
name: 'dev.asd.test.TrustManager',
implements: [X509TrustManager],
methods: {
checkClientTrusted: function (chain, authType) {},
checkServerTrusted: function (chain, authType) {},
getAcceptedIssuers: function () {return []; }
}
});
// Prepare the TrustManager array to pass to SSLContext.init()
var TrustManagers = [TrustManager.$new()];
// Get a handle on the init() on the SSLContext class
var SSLContext_init = SSLContext.init.overload(
'[Ljavax.net.ssl.KeyManager;', '[Ljavax.net.ssl.TrustManager;', 'java.security.SecureRandom');
try {
// Override the init method, specifying the custom TrustManager
SSLContext_init.implementation = function(keyManager, trustManager, secureRandom) {
console.log('[+] Bypassing Trustmanager (Android < 7) request');
SSLContext_init.call(this, keyManager, TrustManagers, secureRandom);
};
} catch (err) {
console.log('[-] TrustManager (Android < 7) pinner not found');
//console.log(err);
}

// OkHTTPv3 (quadruple bypass) //
/
try {
// Bypass OkHTTPv3 {1}
var okhttp3_Activity_1 = Java.use('okhttp3.CertificatePinner');
okhttp3_Activity_1.check.overload('java.lang.String', 'java.util.List').implementation = function (a, b) {
console.log('[+] Bypassing OkHTTPv3 {1}: ' + a);
return true;
};
} catch (err) {
console.log('[-] OkHTTPv3 {1} pinner not found');
//console.log(err);
}
try {
// Bypass OkHTTPv3 {2}
// This method of CertificatePinner.check could be found in some old Android app
var okhttp3_Activity_2 = Java.use('okhttp3.CertificatePinner');
okhttp3_Activity_2.check.overload('java.lang.String', 'java.security.cert.Certificate').implementation = function (a, b) {
console.log('[+] Bypassing OkHTTPv3 {2}: ' + a);
return true;
};
} catch (err) {
console.log('[-] OkHTTPv3 {2} pinner not found');
//console.log(err);
}
try {
// Bypass OkHTTPv3 {3}
var okhttp3_Activity_3 = Java.use('okhttp3.CertificatePinner');
okhttp3_Activity_3.check.overload('java.lang.String', '[Ljava.security.cert.Certificate;').implementation = function (a, b) {
console.log('[+] Bypassing OkHTTPv3 {3}: ' + a);
return true;
};
} catch(err) {
console.log('[-] OkHTTPv3 {3} pinner not found');
//console.log(err);
}
try {
// Bypass OkHTTPv3 {4}
var okhttp3_Activity_4 = Java.use('okhttp3.CertificatePinner');
okhttp3_Activity_4[''].implementation = function (a, b) {
console.log('[+] Bypassing OkHTTPv3 {4}: ' + a);
};
} catch(err) {
console.log('[-] OkHTTPv3 {4} pinner not found');
//console.log(err);
}

// Trustkit (triple bypass) //
//
try {
// Bypass Trustkit {1}
var trustkit_Activity_1 = Java.use('com.datatheorem.android.trustkit.pinning.OkHostnameVerifier');
trustkit_Activity_1.verify.overload('java.lang.String', 'javax.net.ssl.SSLSession').implementation = function (a, b) {
console.log('[+] Bypassing Trustkit {1}: ' + a);
return true;
};
} catch (err) {
console.log('[-] Trustkit {1} pinner not found');
//console.log(err);
}
try {
// Bypass Trustkit {2}
var trustkit_Activity_2 = Java.use('com.datatheorem.android.trustkit.pinning.OkHostnameVerifier');
trustkit_Activity_2.verify.overload('java.lang.String', 'java.security.cert.X509Certificate').implementation = function (a, b) {
console.log('[+] Bypassing Trustkit {2}: ' + a);
return true;
};
} catch (err) {
console.log('[-] Trustkit {2} pinner not found');
//console.log(err);
}
try {
// Bypass Trustkit {3}
var trustkit_PinningTrustManager = Java.use('com.datatheorem.android.trustkit.pinning.PinningTrustManager');
trustkit_PinningTrustManager.checkServerTrusted.implementation = function () {
console.log('[+] Bypassing Trustkit {3}');
};
} catch (err) {
console.log('[-] Trustkit {3} pinner not found');
//console.log(err);
}

// TrustManagerImpl (Android > 7) //

try {
var TrustManagerImpl = Java.use('com.android.org.conscrypt.TrustManagerImpl');
TrustManagerImpl.verifyChain.implementation = function (untrustedChain, trustAnchorChain, host, clientAuth, ocspData, tlsSctData) {
console.log('[+] Bypassing TrustManagerImpl (Android > 7): ' + host);
return untrustedChain;
};
} catch (err) {
console.log('[-] TrustManagerImpl (Android > 7) pinner not found');
//console.log(err);
}

// Appcelerator Titanium //
///
try {
var appcelerator_PinningTrustManager = Java.use('appcelerator.https.PinningTrustManager');
appcelerator_PinningTrustManager.checkServerTrusted.implementation = function () {
console.log('[+] Bypassing Appcelerator PinningTrustManager');
};
} catch (err) {
console.log('[-] Appcelerator PinningTrustManager pinner not found');
//console.log(err);
}

// OpenSSLSocketImpl Conscrypt //
/
try {
var OpenSSLSocketImpl = Java.use('com.android.org.conscrypt.OpenSSLSocketImpl');
OpenSSLSocketImpl.verifyCertificateChain.implementation = function (certRefs, JavaObject, authMethod) {
console.log('[+] Bypassing OpenSSLSocketImpl Conscrypt');
};
} catch (err) {
console.log('[-] OpenSSLSocketImpl Conscrypt pinner not found');
//console.log(err);
}

// OpenSSLEngineSocketImpl Conscrypt //
///
try {
var OpenSSLEngineSocketImpl_Activity = Java.use('com.android.org.conscrypt.OpenSSLEngineSocketImpl');
OpenSSLSocketImpl_Activity.verifyCertificateChain.overload('[Ljava.lang.Long;', 'java.lang.String').implementation = function (a, b) {
console.log('[+] Bypassing OpenSSLEngineSocketImpl Conscrypt: ' + b);
};
} catch (err) {
console.log('[-] OpenSSLEngineSocketImpl Conscrypt pinner not found');
//console.log(err);
}

// OpenSSLSocketImpl Apache Harmony //
//
try {
var OpenSSLSocketImpl_Harmony = Java.use('org.apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl');
OpenSSLSocketImpl_Harmony.verifyCertificateChain.implementation = function (asn1DerEncodedCertificateChain, authMethod) {
console.log('[+] Bypassing OpenSSLSocketImpl Apache Harmony');
};
} catch (err) {
console.log('[-] OpenSSLSocketImpl Apache Harmony pinner not found');
//console.log(err);
}

// PhoneGap sslCertificateChecker (https://github.com/EddyVerbruggen/SSLCertificateChecker-PhoneGap-Plugin) //
//
try {
var phonegap_Activity = Java.use('nl.xservices.plugins.sslCertificateChecker');
phonegap_Activity.execute.overload('java.lang.String', 'org.json.JSONArray', 'org.apache.cordova.CallbackContext').implementation = function (a, b, c) {
console.log('[+] Bypassing PhoneGap sslCertificateChecker: ' + a);
return true;
};
} catch (err) {
console.log('[-] PhoneGap sslCertificateChecker pinner not found');
//console.log(err);
}

// IBM MobileFirst pinTrustedCertificatePublicKey (double bypass) //

try {
// Bypass IBM MobileFirst {1}
var WLClient_Activity_1 = Java.use('com.worklight.wlclient.api.WLClient');
WLClient_Activity_1.getInstance().pinTrustedCertificatePublicKey.overload('java.lang.String').implementation = function (cert) {
console.log('[+] Bypassing IBM MobileFirst pinTrustedCertificatePublicKey {1}: ' + cert);
return;
};
} catch (err) {
console.log('[-] IBM MobileFirst pinTrustedCertificatePublicKey {1} pinner not found');
//console.log(err);
}
try {
// Bypass IBM MobileFirst {2}
var WLClient_Activity_2 = Java.use('com.worklight.wlclient.api.WLClient');
WLClient_Activity_2.getInstance().pinTrustedCertificatePublicKey.overload('[Ljava.lang.String;').implementation = function (cert) {
console.log('[+] Bypassing IBM MobileFirst pinTrustedCertificatePublicKey {2}: ' + cert);
return;
};
} catch (err) {
console.log('[-] IBM MobileFirst pinTrustedCertificatePublicKey {2} pinner not found');
//console.log(err);
}

// IBM WorkLight (ancestor of MobileFirst) HostNameVerifierWithCertificatePinning (quadruple bypass) //
///
try {
// Bypass IBM WorkLight {1}
var worklight_Activity_1 = Java.use('com.worklight.wlclient.certificatepinning.HostNameVerifierWithCertificatePinning');
worklight_Activity_1.verify.overload('java.lang.String', 'javax.net.ssl.SSLSocket').implementation = function (a, b) {
console.log('[+] Bypassing IBM WorkLight HostNameVerifierWithCertificatePinning {1}: ' + a);
return;
};
} catch (err) {
console.log('[-] IBM WorkLight HostNameVerifierWithCertificatePinning {1} pinner not found');
//console.log(err);
}
try {
// Bypass IBM WorkLight {2}
var worklight_Activity_2 = Java.use('com.worklight.wlclient.certificatepinning.HostNameVerifierWithCertificatePinning');
worklight_Activity_2.verify.overload('java.lang.String', 'java.security.cert.X509Certificate').implementation = function (a, b) {
console.log('[+] Bypassing IBM WorkLight HostNameVerifierWithCertificatePinning {2}: ' + a);
return;
};
} catch (err) {
console.log('[-] IBM WorkLight HostNameVerifierWithCertificatePinning {2} pinner not found');
//console.log(err);
}
try {
// Bypass IBM WorkLight {3}
var worklight_Activity_3 = Java.use('com.worklight.wlclient.certificatepinning.HostNameVerifierWithCertificatePinning');
worklight_Activity_3.verify.overload('java.lang.String', '[Ljava.lang.String;', '[Ljava.lang.String;').implementation = function (a, b) {
console.log('[+] Bypassing IBM WorkLight HostNameVerifierWithCertificatePinning {3}: ' + a);
return;
};
} catch (err) {
console.log('[-] IBM WorkLight HostNameVerifierWithCertificatePinning {3} pinner not found');
//console.log(err);
}
try {
// Bypass IBM WorkLight {4}
var worklight_Activity_4 = Java.use('com.worklight.wlclient.certificatepinning.HostNameVerifierWithCertificatePinning');
worklight_Activity_4.verify.overload('java.lang.String', 'javax.net.ssl.SSLSession').implementation = function (a, b) {
console.log('[+] Bypassing IBM WorkLight HostNameVerifierWithCertificatePinning {4}: ' + a);
return true;
};
} catch (err) {
console.log('[-] IBM WorkLight HostNameVerifierWithCertificatePinning {4} pinner not found');
//console.log(err);
}

// Conscrypt CertPinManager //
//
try {
var conscrypt_CertPinManager_Activity = Java.use('com.android.org.conscrypt.CertPinManager');
conscrypt_CertPinManager_Activity.isChainValid.overload('java.lang.String', 'java.util.List').implementation = function (a, b) {
console.log('[+] Bypassing Conscrypt CertPinManager: ' + a);
return true;
};
} catch (err) {
console.log('[-] Conscrypt CertPinManager pinner not found');
//console.log(err);
}

// CWAC-Netsecurity (unofficial back-port pinner for Android<4.2) CertPinManager //
///
try {
var cwac_CertPinManager_Activity = Java.use('com.commonsware.cwac.netsecurity.conscrypt.CertPinManager');
cwac_CertPinManager_Activity.isChainValid.overload('java.lang.String', 'java.util.List').implementation = function (a, b) {
console.log('[+] Bypassing CWAC-Netsecurity CertPinManager: ' + a);
return true;
};
} catch (err) {
console.log('[-] CWAC-Netsecurity CertPinManager pinner not found');
//console.log(err);
}

// Worklight Androidgap WLCertificatePinningPlugin //
/
try {
var androidgap_WLCertificatePinningPlugin_Activity = Java.use('com.worklight.androidgap.plugin.WLCertificatePinningPlugin');
androidgap_WLCertificatePinningPlugin_Activity.execute.overload('java.lang.String', 'org.json.JSONArray', 'org.apache.cordova.CallbackContext').implementation = function (a, b, c) {
console.log('[+] Bypassing Worklight Androidgap WLCertificatePinningPlugin: ' + a);
return true;
};
} catch (err) {
console.log('[-] Worklight Androidgap WLCertificatePinningPlugin pinner not found');
//console.log(err);
}

// Netty FingerprintTrustManagerFactory //
//
try {
var netty_FingerprintTrustManagerFactory = Java.use('io.netty.handler.ssl.util.FingerprintTrustManagerFactory');
//NOTE: sometimes this below implementation could be useful
//var netty_FingerprintTrustManagerFactory = Java.use('org.jboss.netty.handler.ssl.util.FingerprintTrustManagerFactory');
netty_FingerprintTrustManagerFactory.checkTrusted.implementation = function (type, chain) {
console.log('[+] Bypassing Netty FingerprintTrustManagerFactory');
};
} catch (err) {
console.log('[-] Netty FingerprintTrustManagerFactory pinner not found');
//console.log(err);
}

// Squareup CertificatePinner [OkHTTP<v3] (double bypass) //

try {
// Bypass Squareup CertificatePinner  {1}
var Squareup_CertificatePinner_Activity_1 = Java.use('com.squareup.okhttp.CertificatePinner');
Squareup_CertificatePinner_Activity_1.check.overload('java.lang.String', 'java.security.cert.Certificate').implementation = function (a, b) {
console.log('[+] Bypassing Squareup CertificatePinner {1}: ' + a);
return;
};
} catch (err) {
console.log('[-] Squareup CertificatePinner {1} pinner not found');
//console.log(err);
}
try {
// Bypass Squareup CertificatePinner {2}
var Squareup_CertificatePinner_Activity_2 = Java.use('com.squareup.okhttp.CertificatePinner');
Squareup_CertificatePinner_Activity_2.check.overload('java.lang.String', 'java.util.List').implementation = function (a, b) {
console.log('[+] Bypassing Squareup CertificatePinner {2}: ' + a);
return;
};
} catch (err) {
console.log('[-] Squareup CertificatePinner {2} pinner not found');
//console.log(err);
}

// Squareup OkHostnameVerifier [OkHTTP v3] (double bypass) //
/
try {
// Bypass Squareup OkHostnameVerifier {1}
var Squareup_OkHostnameVerifier_Activity_1 = Java.use('com.squareup.okhttp.internal.tls.OkHostnameVerifier');
Squareup_OkHostnameVerifier_Activity_1.verify.overload('java.lang.String', 'java.security.cert.X509Certificate').implementation = function (a, b) {
console.log('[+] Bypassing Squareup OkHostnameVerifier {1}: ' + a);
return true;
};
} catch (err) {
console.log('[-] Squareup OkHostnameVerifier pinner not found');
//console.log(err);
}
try {
// Bypass Squareup OkHostnameVerifier {2}
var Squareup_OkHostnameVerifier_Activity_2 = Java.use('com.squareup.okhttp.internal.tls.OkHostnameVerifier');
Squareup_OkHostnameVerifier_Activity_2.verify.overload('java.lang.String', 'javax.net.ssl.SSLSession').implementation = function (a, b) {
console.log('[+] Bypassing Squareup OkHostnameVerifier {2}: ' + a);
return true;
};
} catch (err) {
console.log('[-] Squareup OkHostnameVerifier pinner not found');
//console.log(err);
}

// Android WebViewClient (double bypass) //
///
try {
// Bypass WebViewClient {1} (deprecated from Android 6)
var AndroidWebViewClient_Activity_1 = Java.use('android.webkit.WebViewClient');
AndroidWebViewClient_Activity_1.onReceivedSslError.overload('android.webkit.WebView', 'android.webkit.SslErrorHandler', 'android.net.http.SslError').implementation = function (obj1, obj2, obj3) {
console.log('[+] Bypassing Android WebViewClient {1}');
};
} catch (err) {
console.log('[-] Android WebViewClient {1} pinner not found');
//console.log(err)
}
try {
// Bypass WebViewClient {2}
var AndroidWebViewClient_Activity_2 = Java.use('android.webkit.WebViewClient');
AndroidWebViewClient_Activity_2.onReceivedSslError.overload('android.webkit.WebView', 'android.webkit.WebResourceRequest', 'android.webkit.WebResourceError').implementation = function (obj1, obj2, obj3) {
console.log('[+] Bypassing Android WebViewClient {2}');
};
} catch (err) {
console.log('[-] Android WebViewClient {2} pinner not found');
//console.log(err)
}

// Apache Cordova WebViewClient //
//
try {
var CordovaWebViewClient_Activity = Java.use('org.apache.cordova.CordovaWebViewClient');
CordovaWebViewClient_Activity.onReceivedSslError.overload('android.webkit.WebView', 'android.webkit.SslErrorHandler', 'android.net.http.SslError').implementation = function (obj1, obj2, obj3) {
console.log('[+] Bypassing Apache Cordova WebViewClient');
obj3.proceed();
};
} catch (err) {
console.log('[-] Apache Cordova WebViewClient pinner not found');
//console.log(err);
}

// Boye AbstractVerifier //
///
try {
var boye_AbstractVerifier = Java.use('ch.boye.httpclientandroidlib.conn.ssl.AbstractVerifier');
boye_AbstractVerifier.verify.implementation = function (host, ssl) {
console.log('[+] Bypassing Boye AbstractVerifier: ' + host);
};
} catch (err) {
console.log('[-] Boye AbstractVerifier pinner not found');
//console.log(err);
}

});

}, 0);

复制代码

启动frida进行hook指定APP的包名

frida -U -f com.example.safehttps -l hook.js --no-pause

复制代码

app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

可以看到开启burp抓包成功。

5.开启双向校验

双向校验顾名思义也就是服务器也要对客户端进行证书校验，在刚才客户端校验服务端的基础上添加一直被校验的逻辑在里面。

首先ttt.com所在的nginx服务器要开启双向认证 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

开启客户端的校验后，在浏览器进行访问，会发现返回400，没有被请求的SSL证书发送，是因为浏览器正常请求不会携带证书信息去请求ttt.com app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

那么如何携带客户端的证书，就要利用burp来操作，将ttt.com的证书添加到TLS客户证书 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

这时再访问 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

在APP中进行绑定客户端的证书文件，一般是p12格式文件，会放在assets目录下或者raw目录下，client.p12会有一个密钥内置在代码中，需要找到才能添加进burp中。 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

这个在反编译后的目录下也能找到，通常在assets或者res/raw目录下查找，但是再导入burp这一步是需要证书密码的，比如上图能明显看到密码是123456，但是找不到证书密码怎么办，可以看一下目录下是否存在lib文件夹，如果存在的话极大可能是将密码写进so层了，这就需要你会IDA反汇编获取证书密钥了，这部分在此不详细阐述，感兴趣的朋友可以先去研究一下。 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

APP双向校验验证

服务器校验客户端的证书ClientSSLSocketFactory，服务端将客户端的证书进行绑定。

TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustManagerFactory.init((KeyStore) null);
TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
if (trustManagers.length != 1 || !(trustManagers[0] instanceof X509TrustManager)) {
    throw new IllegalStateException("Unexpected default trust managers:" + Arrays.toString(trustManagers));
}
trustManager = (X509TrustManager) trustManagers[0];

OkHttpClient client = new OkHttpClient.Builder()
        .sslSocketFactory(Objects.requireNonNull(ClientSSLSocketFactory.getSocketFactory(getApplicationContext())), Objects.requireNonNull(trustManager))
        .hostnameVerifier(new HostnameVerifier() {
            @Override
            public boolean verify(String hostname, SSLSession session) {
                //强行返回true 即验证成功
                return true;
            }
}).build();

复制代码

public class ClientSSLSocketFactory  {
    private static final String KEY_STORE_PASSWORD = "123456"; // 证书密码
    private static InputStream client_input;

    public static SSLSocketFactory getSocketFactory(Context context) {
        try {
            //客户端证书
            client_input = context.getResources().getAssets().open("client.p12");
            SSLContext sslContext = SSLContext.getInstance("TLS");
            KeyStore keyStore = KeyStore.getInstance("PKCS12");
            keyStore.load(client_input, KEY_STORE_PASSWORD.toCharArray());
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(keyStore, KEY_STORE_PASSWORD.toCharArray());
            sslContext.init(keyManagerFactory.getKeyManagers(), null, new SecureRandom());
            return sslContext.getSocketFactory();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                client_input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

复制代码

双向校验时，要将SSLPinning与服务器校验客户端证书的模块同时开启。

对其就行绕过，需要先启动Frida进行hook，然后勾选上客户端证书，才可以请求成功。如下图所示： app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

没勾选就会请求失败，出现400 Bad Request，和浏览器无代理时请求的结果一样，如下图： app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

此时burp代理日志显示如下，SSL请求失败 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

WebView证书校验

webview也是一种请求方式，相当于页面的跳转或嵌入，请求的结果会显示在主屏幕上。

对于webview证书校验，有些可以找到的脚本不一定有绕过，所以在使用的过程中要查看是否含有webview的关键信息

这里我使用的是DroidSSLUnpinning

使用效果如下： app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

此时的APP绑定场景为：OKhttp请求为双向校验，webview为SSLPinning校验。所以在图中的上面一行是okhttp的请求结果，下面的是webview的请求结果，此脚本双向校验仍然可以绕过。

如果说webview再添加了客户端校验，那么在反编译apk后，需要找到webview访问域名的证书密钥，再安装进burp中即可。

6.ssl_logger通杀

至此，我们可以绕过证书绑定，抓APP发出的https包了，然而上述的证书解绑hook工具仅仅是通过hook了几种绑定证书的API，不适用于新出现或者非主流的证书绑定技术。这时，就需要神器ssl_logger

ssl_logger是用来解密SSL流量的工具，也是一款基于frida的hook工具，通过hook libssl库中的SSL_read、SSL_write等函数来实现流量解密，由于底层的实现会调用这几个函数来封装，所以可以直接解出流量数据。 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

r0capture是r0ysue大佬在其基础上进行改进的一款工具。 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

由于ssl_logger是适用于MAC和linux操作系统，所以我选择在kali上进行hook实现双向校验的app app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

打开抓到的1.pcap包 app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

从图中可以看出成功的获取到了信息，是不是感觉这个工具特别神，但是看pcap的包总归不如看burp的一目了然，这个工具就这一点不太友好。所以用哪个看你心情

7.eBPF hook 免CA证书

ecapture：eBPF HOOK uprobe实现的各种用户态进程的数据捕获，无需改动原程序。这个工具也是通过hook了libssl库中SSL_write、SSL_read这两个关键的SSL加密函数的返回值，拿到明文信息，通过ebpf map传递给用户进程。在APP中，如果遇到场景是burp抓包时出现证书报错，我觉得可以尝试一下用这个工具直接curl访问进行抓包。eBPF hook也是最近才发现的hook方法，值得我们去深入探索。

我这里用的是作者v0.1.3版本发布的工具，使用效果如下： app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

8.总结

在依靠系统或默认浏览器校验证书的情况下，导入burp证书为用户证书是可以抓https包的

当app支持的最小API为24（Android 7.0）或以上时，默认情况下app只信任系统级别的证书，需要把burp变为系统证书

自签名证书作为系统证书时，有效期最长不超过825天，用户证书则没有限制

开启证书校验的APP在使用burp抓包时会报certtificate_unknown等错误

使用frida hook绕过双向证书校验时，必须要将客户端的p12文件导入burp中

一些脚本仍绕不过可以使用ssl_logger或者逆向代码进行分析验证逻辑，再有针对性的绕过

p12文件的密钥如果在so层，需要会用IDA进行静态分析lib下的so文件获取关键密钥

看完本篇文章之后，相信你再面对抓不到包的APP或者是https请求也不会手足无措了。

​最后

为了帮助大家更好的学习网络安全，小编给大家准备了一份网络安全入门/进阶学习资料，里面的内容都是适合零基础小白的笔记和资料，不懂编程也能听懂、看懂，所有资料共282G，朋友们如果有需要全套网络安全入门+进阶学习资源包，可以点击免费领取（如遇扫码问题，可以在评论区留言领取哦）~

😝有需要的小伙伴，可以点击下方链接免费领取或者V扫描下方二维码免费领取🆓

👉CSDN大礼包🎁：全网最全《网络安全入门&进阶学习资源包》免费分享（安全链接，放心点击）👈

​app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维文章来源地址https://www.toymoban.com/news/detail-715533.html

网络安全源码合集+工具包
​​app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维
网络安全面试题
最后就是大家最关心的网络安全面试题板块
app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维
app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

所有资料共282G，朋友们如果有需要全套网络安全入门+进阶学习资源包！

​视频配套资料&国内外网安书籍、文档
app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

😝有需要的小伙伴，可以点击下方链接免费领取或者V扫描下方二维码免费领取🆓

👉CSDN大礼包🎁：全网最全《网络安全入门&进阶学习资源包》免费分享（安全链接，放心点击）👈

​app 防止抓包,网络安全,转行,黑客,web安全,ssl,https,网络安全,运维

到了这里，关于如何解决APP抓包问题【网络安全】的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 某购票平台APP的抓包问题(解决过程)

    某购票平台APP的抓包问题(解决过程)

    某购票平台App的抓包问题(解决实现) 软件地址: aHR0cHM6Ly93d3cud2FuZG91amlhLmNvbS9hcHBzLzY2MjI2MjgvaGlzdG9yeV92MjAyMzAxMTE=(BASE64) App版本: 5.2.1 手机: Google Son (Pixel 4)  系统: Android 11 本文利用工具: HttpCanary Frida Objection JADX 一 、先判断问题 利用Charles抓包不出包，为了方便我用的是httpCanary,指定该

    2024年02月08日
    浏览(43)

  • 游戏盾SDK为小程序APP提供安全的网络保障！

    随着小程序APP在移动应用市场中的普及，安全问题也备受关注。为了保护小程序APP的网络通信安全，提供安全加密和防护措施，游戏盾SDK成为一种有效的网络保障工具。游戏盾SDK能够为小程序APP提供安全的网络保障，确保数据传输安全、防范恶意攻击，保护用户隐私信息。接

    2024年04月11日
    浏览(32)

  • 探索ProtonVPN Android App：安全、自由与隐私的网络新选择

    项目地址:https://gitcode.com/ProtonVPN/android-app ProtonVPN Android App 是一个开源的虚拟私人网络（VPNs）应用，致力于提供强大的加密、极致的安全性和无日志政策，以保护你的在线活动和数据。这款应用不仅适用于普通用户，也适合那些重视隐私和安全的专业人士。 ProtonVPN Android Ap

    2024年04月13日
    浏览(32)
  • Web逆向、软件逆向、安卓逆向、APP逆向，关于网络安全这些你必须懂

    Web逆向、软件逆向、安卓逆向、APP逆向，关于网络安全这些你必须懂

    逆向工程是网络安全行业里面一项很重要的技术。 逆向是一个相对正向而言的解释，相对正向来说，对一个程序来讲，正向就是开发的过程，从0到1。 就是在一个软件诞生的整个生命周期中的一个过程， 也就是按照需求通过编码把需求实现，产生一个程序，当然这个程序可

    2024年02月07日
    浏览(39)
  • 自学网络安全解决问题方法

    自学网络安全解决问题方法

     自学网络安全很容易学着学着就迷茫了，找到源头问题，解决它就可以了，所以首先咱们聊聊，学习网络安全方向通常会有哪些问题，看到后面有惊喜哦 1、打基础时间太长 学基础花费很长时间，光语言都有几门，有些人会倒在学习 linux 系统及命令的路上，更多的人会倒在

    2024年02月08日
    浏览(45)
  • 网络安全——防止被抓包

    网络安全——防止被抓包

    安全套接字层 (Secure Socket Layer, SSL) 是用来实现互联网安全通信的最普遍的标准。Web 应用程序使用 HTTPS（基于 SSL 的 HTTP），HTTPS 使用数字证书来确保在服务器和客户端之间进行安全、加密的通信。在 SSL 连接中，客户机和服务器在发送数据之前都要对数据进行加密，然后由接

    2024年02月08日
    浏览(46)
  • 网络安全工具——Wireshark抓包工具

    网络安全工具——Wireshark抓包工具

    Wireshark是一个网络封包分析软件。网络封包分析软件的功能是撷取网络封包，并尽可能显示出最为详细的网络封包资料。Wireshark使用WinPCAP作为接口，直接与网卡进行数据报文交换。 网络管理员使用Wireshark 来检测网络问题， 网络安全工程师使用Wireshark来检查资讯安全相关问题

    2024年02月13日
    浏览(36)
  • 云原生环境该怎样解决网络安全问题

    云原生环境该怎样解决网络安全问题

    随着云计算逐渐迈向成熟阶段，云原生技术以其“生在云上、长在云上”的核心理念，被普遍认为是云计算未来十年发展的关键方向。该技术不仅能够有效破解传统云实践中所面临的应用升级缓慢、架构臃肿、迭代效率低下等难题，更为业务创新注入了强大的动力。 云原生技

    2024年04月27日
    浏览(34)
  • 网络信息通信的安全问题以及解决方法

    网络信息通信的安全问题以及解决方法

    网络通信笔记 窃听指A，B两者通信时被第三方窃听。例如：美国如何窃听海底光缆这类事件 这种情况也很好解决， 信息加密 就行 假冒是指第三方,冒充A(发送者)或B(接受者)，与另外一方进行消息通信。类似盗号的操作 这种情况一般用，数据签名，和消息认证的方式解决 篡改

    2024年02月16日
    浏览(39)
  • 自学网络安全遇到问题怎么解决？路线是什么

    自学网络安全遇到问题怎么解决？路线是什么

    自学网络安全很容易学着学着就迷茫了，找到源头问题，解决它就可以了，所以首先咱们聊聊，学习网络安全方向通常会有哪些问题，看到后面有惊喜哦 1、打基础时间太长 学基础花费很长时间，光语言都有几门，有些人会倒在学习 linux 系统及命令的路上，更多的人会倒在学

    2024年02月06日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包