Python Forensics - Memoria y Forense

En este capítulo, nos centraremos en investigar la memoria volátil con la ayuda de Volatility, un marco forense basado en Python aplicable en las siguientes plataformas: Android y Linux.

Memoria volatil

La memoria volátil es un tipo de almacenamiento en el que el contenido se borra cuando se apaga o interrumpe la alimentación del sistema. La RAM es el mejor ejemplo de memoria volátil. Significa que si estaba trabajando en un documento que no se ha guardado en una memoria no volátil, como un disco duro, y la computadora perdió energía, entonces todos los datos se perderán.

En general, los análisis forenses de memoria volátil siguen el mismo patrón que otras investigaciones forenses:

  • Seleccionar el objetivo de la investigación
  • Adquirir datos forenses
  • Análisis forense

Lo básico volatility plugins que se utilizan para recopilaciones de Android RAM dumppara analizar. Una vez que se recopila el volcado de RAM para su análisis, es importante comenzar a buscar malware en la RAM.

Reglas YARA

YARA es una herramienta popular que proporciona un lenguaje robusto, es compatible con Expresiones regulares basadas en Perl y se utiliza para examinar los archivos / directorios sospechosos y buscar cadenas.

En esta sección, usaremos YARA basados ​​en la implementación de coincidencia de patrones y los combinaremos con energía de la red. El proceso completo será beneficioso para el análisis forense.

Ejemplo

Considere el siguiente código. Este código ayuda a extraer el código.

import operator
import os
import sys

sys.path.insert(0, os.getcwd())
import plyara.interp as interp

# Plyara is a script that lexes and parses a file consisting of one more Yara
# rules into a python dictionary representation.
if __name__ == '__main__': 
   file_to_analyze = sys.argv[1] 
   rulesDict = interp.parseString(open(file_to_analyze).read()) 
   authors = {} 
   imps = {} 
   meta_keys = {} 
   max_strings = [] 
   max_string_len = 0 
   tags = {} 
   rule_count = 0  

   for rule in rulesDict: 
      rule_count += 1  
   
   # Imports 
   if 'imports' in rule: 
      for imp in rule['imports']: 
         imp = imp.replace('"','') 
         
         if imp in imps: 
            imps[imp] += 1 
         else: 
            imps[imp] = 1  
   # Tags 
   if 'tags' in rule: 
      for tag in rule['tags']: 
         if tag in tags: 
            tags[tag] += 1 
         else: 
            tags[tag] = 1
            
   # Metadata 
   if 'metadata' in rule: 
      for key in rule['metadata']: 
         if key in meta_keys: 
            meta_keys[key] += 1
         else: 
            meta_keys[key] = 1 
         
         if key in ['Author', 'author']: 
            if rule['metadata'][key] in authors: 
               authors[rule['metadata'][key]] += 1 
            else: 
               authors[rule['metadata'][key]] = 1  

   #Strings 
   if 'strings' in rule: 
      for strr in rule['strings']: 
         if len(strr['value']) > max_string_len: 
            max_string_len = len(strr['value']) 
            max_strings = [(rule['rule_name'], strr['name'], strr['value'])] 
         elif len(strr['value']) == max_string_len: 
            max_strings.append((rule['rule_name'], strr['key'], strr['value']))  
   
   print("\nThe number of rules implemented" + str(rule_count))
   ordered_meta_keys = sorted(meta_keys.items(), key = operator.itemgetter(1),
      reverse = True)
   ordered_authors = sorted(authors.items(), key = operator.itemgetter(1), 
      reverse = True)
   ordered_imps = sorted(imps.items(), key = operator.itemgetter(1), reverse = True)
   ordered_tags = sorted(tags.items(), key = operator.itemgetter(1), reverse = True)

El código anterior producirá el siguiente resultado.

El número de reglas YARA implementadas ayuda a dar una mejor imagen de los archivos sospechosos. De manera indirecta, la lista de archivos sospechosos ayuda a recopilar la información adecuada para el análisis forense.

A continuación se muestra el código fuente en github: https://github.com/radhikascs/Python_yara