Visualisation de la connexion entre le malware et le serveur de rappel

c'est

Cet article traite de la visualisation de la connexion entre les logiciels malveillants et le serveur de rappel pour la pratique de networkx.

environnement

Kali Linux python 2.2.17

Flux de mise en œuvre approximatif

Réglage de l'argument
Organiser le suffixe
Fonction d'acquisition de nom d'hôte
Analyser le répertoire cible
Création de réseau

Chargez la bibliothèque requise

import pefile
import sys
import argparse
import os
import pprint
import networkx
import re
from networkx.drawing.nx_agraph import write_dot
import collections
from networkx.algorithms import bipartite

Définition des arguments de ligne de commande

args = argparse.ArgumentParser()
args.add_argument("target")
args.add_argument("filename")
args.add_argument("malware_pro")
args.add_argument("hostname_pro")
args = args.parse_args()
network = networkx.Graph()

Organiser le suffixe

suffixes = map(lambda string: string.strip(), open("suffixes.txt"))
suffixes = set(suffixes)

Organisez le suffixe dans suffixes.txt en utilisant une carte et une expression lambda dans les deux dernières lignes. Vous pouvez créer vous-même suffixes.txt, mais c'est ennuyeux. Cette fois, je vais emprunter à Malware Data Science. En outre, l'échantillon de logiciel malveillant transmis à l'argument cible est également emprunté. Tout d'abord, strip () car le code de saut de ligne dans suffixes.txt est un obstacle. Notez que dans python3, la valeur de retour de la fonction map sera l'objet de la fonction map.

def get_hostnames(string):
    tmp = re.findall(r'(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-]{,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,6}',string)
    hostnames = filter(lambda hostname: hostname.split(".")[-1].lower() in suffixes, tmp)
    return hostnames

Spécifiez le domaine avec une expression régulière et séparez-le par ".". Rendre le dernier élément plus bas et utiliser des expressions de filtre et lambda pour vérifier s'il correspond aux suffixes. C'est aussi python3 ...

for root,dirs,files in os.walk(args.target):
    for file in files:
    try:
         pe = pefile.PE(os.path.join(root, file))
    except pefile.PEFormatError:
        continue
        f_path = os.path.join(root, file)
        contents = os.popen("strings '{0}'".format(f_path)).read()
        hostnames = get_hostnames(contents)
        if len(hostnames):
            network.add_node(file,label=file ,color='blue', penwidth=3,bipartite=0)
        for hostname in hostnames:
            network.add_node(hostname,label=hostname,color='purple', penwidth=10,bipartite=1)
            network.add_edge(hostname, file ,penwidth=2)
    if hostnames:
        print "Extracted hostname from:", file
        pprint.pprint(hostname)

Parcourez le répertoire cible, récupérez le répertoire racine, le sous-répertoire et le chemin du fichier avec l'instruction for et vérifiez la mobilisation des fichiers avec try. Sinon, passez à la boucle suivante. Stockez le chemin complet du fichier pe dans f_path et transmettez la chaîne de caractères imprimables comme argument à la fonction get_hostnames. Une fois que vous avez obtenu le nom d'hôte, créez un salware de contenu et un réseau d'hôtes respectivement. Ensuite, si le nom d'hôte est trouvé, enregistrez le chemin d'accès au fichier dans l'un des réseaux en deux parties et enregistrez tous les noms d'hôte eux-mêmes dans l'autre du réseau en deux parties. Dans la dernière instruction if, le chemin du fichier où le nom d'hôte a été obtenu est affiché sur la ligne de commande au moment de l'exécution

write_dot(network, args.filename)
codes= set(n for n,d in network.nodes(data=True) if d['bipartite']==0)
hostname = set(network)-codes

Ecrivez le réseau dans le nom de fichier sur la première ligne. Stockez le côté malware avec bipartite = 0 dans le code. En définissant network.nodes (data = True), un taple composé d'un nom de nœud et d'un dictionnaire des attributs du nœud sera renvoyé. De même, entrez le nom d'hôte dans hostname.

codes = bipartite.projected_graph(network, codes)
hostname = bipartite.projected_graph(network, hostname)

Créez des projections pour chaque malware et hôte. La projection est ici une simplification du réseau en deux parties. Par exemple, dans le cas d'un malware (codes), un malware avec un nom d'hôte commun est connecté.

write_dot(codes ,args.malware_pro)
write_dot(hostname ,args.hostname_pro)

Ecrivez chaque projection créée dans un fichier.

Visualisation avec fdp

fdp filename.dot -T png -o filename.png -Goverlap=false
fdp malware_pro.dot -T png -o malwre_pro.png -Goverlap=false
fdp hostname_pro.dot -T png -o hostname_pro.png -Goverlap=false

fdp est un outil qui visualise le réseau en fonction de l'orientation de la force. Il existe d'autres outils tels que sfdp, mais je les omettrai cette fois. Essayez de l'exécuter.

filename.png
malware_pro.pnf
hostname_pro.png

Vous pouvez le faire avec un fichier image appelé .

eog filename.png

Lorsque je l'ouvre,

Terminé ^^

Au fait, qu'est-ce que l'orientation du pouvoir?

La longueur des bords est un problème lors de la mise en place d'un réseau. Si les poids des nœuds sont les mêmes, les longueurs des arêtes doivent être identiques. Cependant, lorsque le nombre de nœuds est de 4 ou plus, il est absolument impossible de rendre tous les nœuds de la même longueur, non? Par conséquent, nous essaierons de minimiser cette distorsion. C'est là qu'intervient l'algorithme orienté force. Lorsque vous simulez une arête en tant que ressort, l'arête essaie automatiquement de rendre la distance entre les nœuds aussi uniforme que possible. Le printemps est génial. Puis.

[PYTHON] Visualisation de la connexion entre le malware et le serveur de rappel