MemoryScope: dashboard web para análisis forense de memoria con Volatility 3 | Operating systems, scripting, PowerShell and security

PowerShell

El análisis forense de memoria permite obtener información que puede no estar disponible en el almacenamiento permanente de un equipo. Procesos activos, conexiones de red, comandos ejecutados, DLL cargadas o determinadas regiones de memoria pueden aportar evidencias relevantes durante la investigación de un incidente de ciberseguridad.

Para facilitar este trabajo he desarrollado MemoryScope, un pequeño dashboard web que utiliza Volatility 3 como motor de análisis y presenta sus resultados mediante una interfaz gráfica accesible desde el navegador.

La idea es sencilla: colocar la imagen de memoria y el dashboard en una misma carpeta, ejecutar un único script y acceder desde el navegador a localhost.

¿Qué es MemoryScope?

MemoryScope es una interfaz web local diseñada para facilitar el análisis de imágenes de memoria con Volatility 3.

En lugar de ejecutar individualmente numerosos comandos desde la terminal y revisar grandes cantidades de texto, el dashboard organiza los resultados en diferentes secciones.

La aplicación detecta automáticamente una imagen de memoria con extensiones como:

memoria.raw
memoria.mem
memoria.dmp
memory.raw
memory.mem
memory.dmp

También busca automáticamente vol.py y utiliza el mismo intérprete de Python con el que se ejecuta el dashboard.

Arquitectura

El funcionamiento es:

                    ┌─────────────────────┐
                    │     memoria.raw     │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │     Volatility 3    │
                    └──────────┬──────────┘
                               │
       ┌───────────────────────┼───────────────────────┐
       │                       │                       │
       ▼                       ▼                       ▼
    Procesos                 Red                  Memoria
       │                       │                       │
       └───────────────────────┼───────────────────────┘
                               ▼
                    ┌─────────────────────┐
                    │     MemoryScope     │
                    │    Web Dashboard    │
                    └──────────┬──────────┘
                               │
                               ▼
                    http://127.0.0.1:8787

La aplicación funciona completamente en local.

Plugins de Volatility utilizados

MemoryScope ejecuta varios de los plugins más interesantes de Volatility 3:

Plugin	Función
`windows.info`	Información sobre el sistema y la imagen
`windows.pslist`	Procesos identificados
`windows.psscan`	Búsqueda de estructuras de procesos
`windows.pstree`	Relación entre procesos
`windows.cmdline`	Argumentos de línea de comandos
`windows.netscan`	Conexiones y sockets de red
`windows.dlllist`	DLL asociadas a procesos
`windows.filescan`	Estructuras de archivos encontradas
`windows.malfind`	Regiones de memoria potencialmente sospechosas

Esto permite obtener una primera visión bastante amplia de una imagen de memoria.

Dashboard de procesos

Una de las vistas principales es la correspondiente a los procesos.

El dashboard muestra los resultados de windows.pslist en una tabla y permite realizar búsquedas sobre los resultados.

Esto facilita localizar rápidamente procesos concretos como:

explorer.exe
powershell.exe
cmd.exe
svchost.exe
lsass.exe

La información puede utilizarse posteriormente para profundizar en procesos concretos.

Árbol de procesos

MemoryScope también muestra la salida de:

windows.pstree

Esta información es especialmente útil para estudiar las relaciones entre procesos.

Por ejemplo:

explorer.exe
 ├── cmd.exe
 │    └── powershell.exe
 └── chrome.exe

Una relación de procesos inesperada puede convertirse en un indicador que merezca una investigación adicional.

Análisis de conexiones de red

El plugin:

windows.netscan

permite localizar estructuras relacionadas con conexiones de red presentes en la memoria.

El dashboard presenta estos resultados para facilitar la identificación de:

direcciones IP;
puertos;
procesos asociados;
conexiones establecidas;
conexiones pendientes;
actividad de red potencialmente sospechosa.

La correlación entre un proceso y una conexión de red puede aportar información especialmente útil durante el análisis de un incidente.

Análisis de comandos

Otra sección importante utiliza:

windows.cmdline

El objetivo es identificar los argumentos utilizados por los procesos.

Por ejemplo, durante una investigación puede resultar interesante localizar procesos asociados con:

cmd.exe
powershell.exe

y revisar los argumentos que aparecen asociados a ellos.

DLL cargadas

Con:

windows.dlllist

es posible revisar las DLL asociadas a los procesos identificados.

Esta información puede utilizarse junto con otros artefactos para investigar comportamientos anómalos.

Filescan

MemoryScope también incorpora:

windows.filescan

que permite visualizar estructuras relacionadas con archivos encontradas durante el análisis de memoria.

La información puede utilizarse como punto de partida para investigaciones posteriores.

Malfind

Una de las secciones más interesantes es:

windows.malfind

Este plugin busca regiones de memoria de procesos que presentan características que pueden ser compatibles con determinadas técnicas de inyección o ejecución de código.

Es importante interpretar estos resultados correctamente.

Un resultado de malfind no significa automáticamente que exista malware.

Debe correlacionarse con otros elementos como:

proceso;
PID;
permisos de memoria;
DLL;
conexiones de red;
comandos;
árbol de procesos;
otros artefactos disponibles.

La herramienta está pensada para facilitar esa correlación.

Instalación

El proyecto requiere Python y Volatility 3.

Una vez instalado Volatility, se puede instalar Flask:

python3 -m pip install flask

En Windows:

python -m pip install flask

La estructura recomendada es:

analisis-forense/
│
├── memory_dashboard.py
├── memoria.raw
├── vol.py
└── volatility3/

Código de memory_dashboard.py

 renderRaw();

 document.getElementById("treeOutput").textContent =
   DATA.pstree?.stdout || "Sin datos.";

 document.getElementById("malfindOutput").textContent =
   DATA.malfind?.stdout || DATA.malfind?.stderr || "Sin datos.";

 const tbody=document.querySelector("#statusTable tbody");
 tbody.innerHTML=Object.entries(DATA).map(([key,d])=>`
  <tr>
   <td>${esc(d.plugin||key)}</td>
   <td><span class="badge ${d.ok?"":"bad"}">${d.ok?"OK":"ERROR"}</span></td>
   <td>${d.lines||0}</td>
   <td>${d.seconds||0}s</td>
  </tr>`).join("");
}

function renderTabs(){
 const names={
  info:"Sistema",pslist:"Procesos",psscan:"Process Scan",
  pstree:"Árbol",cmdline:"Comandos",netscan:"Red",
  dlllist:"DLL",filescan:"Archivos",malfind:"Malfind"
 };
 document.getElementById("tabs").innerHTML=Object.keys(DATA).map(k=>
   `<button class="tab ${k===ACTIVE?"active":""}" onclick="selectTab('${k}')">${names[k]||k}</button>`
 ).join("");
}

function selectTab(k){
 ACTIVE=k;
 renderTabs();
 renderRaw();
}

function renderRaw(){
 const d=DATA[ACTIVE];
 if(!d){
   document.getElementById("rawOutput").textContent="Sin datos.";
   return;
 }
 let text=d.stdout||"";
 if(!d.ok && d.stderr) text+="\n\n--- STDERR ---\n"+d.stderr;
 document.getElementById("rawOutput").textContent=text||"Sin salida.";
 document.getElementById("rawSearch").value="";
}

function filterRaw(){
 const q=document.getElementById("rawSearch").value.toLowerCase();
 const d=DATA[ACTIVE];
 if(!d)return;

 let text=(d.stdout||"");
 if(d.stderr)text+="\n\n--- STDERR ---\n"+d.stderr;

 if(!q){
   document.getElementById("rawOutput").textContent=text;
   return;
 }

 const lines=text.split("\n").filter(x=>x.toLowerCase().includes(q));
 document.getElementById("rawOutput").textContent=
   lines.length?lines.join("\n"):"No se encontraron coincidencias.";
}

function filterTable(id,q){
 q=q.toLowerCase();
 document.querySelectorAll("#"+id+" tbody tr").forEach(tr=>{
   tr.style.display=tr.textContent.toLowerCase().includes(q)?"":"none";
 });
}

async function startAnalysis(){
 const btn=document.getElementById("runBtn");
 btn.disabled=true;
 btn.textContent="⏳ Iniciando...";

 try{
   const r=await fetch("/api/run",{method:"POST"});
   const data=await r.json();

   if(!r.ok)throw new Error(data.message||"No se pudo iniciar.");

   showAlert("Análisis iniciado. El panel se actualizará automáticamente.",true);

   if(poller)clearInterval(poller);
   poller=setInterval(refresh,800);

   await refresh();

 }catch(e){
   showAlert(e.message,false);
 }finally{
   btn.disabled=false;
   btn.textContent="▶ Ejecutar análisis";
 }
}

refresh();
setInterval(()=>{
 const btn=document.getElementById("runBtn");
 fetch("/api/status").then(r=>r.json()).then(s=>{
   if(s.state.running){
     btn.disabled=true;
     btn.textContent="⏳ Analizando...";
   }else{
     btn.disabled=false;
     btn.textContent="▶ Ejecutar análisis";
   }
 }).catch(()=>{});
},1000);
</script>

</body>
</html>
"""


if __name__ == "__main__":
    print()
    print("=" * 72)
    print(" MemoryScope Pro · Volatility 3")
    print("=" * 72)
    print()
    mem = memory_info()
    vol = vol_info()
    print("Memoria :", mem["path"] if mem else "NO ENCONTRADA")
    print("Volatility:", vol if vol else "NO ENCONTRADO")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

renderRaw();

document.getElementById("treeOutput").textContent =

DATA.pstree?.stdout || "Sin datos.";

document.getElementById("malfindOutput").textContent =

DATA.malfind?.stdout || DATA.malfind?.stderr || "Sin datos.";

const tbody=document.querySelector("#statusTable tbody");

tbody.innerHTML=Object.entries(DATA).map(([key,d])=>`

<tr>

<td>${esc(d.plugin||key)}</td>

<td><span class="badge ${d.ok?"":"bad"}">${d.ok?"OK":"ERROR"}</span></td>

<td>${d.lines||0}</td>

<td>${d.seconds||0}s</td>

</tr>`).join("");

}

function renderTabs(){

const names={

info:"Sistema",pslist:"Procesos",psscan:"Process Scan",

pstree:"Árbol",cmdline:"Comandos",netscan:"Red",

dlllist:"DLL",filescan:"Archivos",malfind:"Malfind"

};

document.getElementById("tabs").innerHTML=Object.keys(DATA).map(k=>

`<button class="tab ${k===ACTIVE?"active":""}" onclick="selectTab('${k}')">${names[k]||k}</button>`

).join("");

}

function selectTab(k){

ACTIVE=k;

renderTabs();

renderRaw();

}

function renderRaw(){

const d=DATA[ACTIVE];

if(!d){

document.getElementById("rawOutput").textContent="Sin datos.";

return;

}

let text=d.stdout||"";

if(!d.ok && d.stderr) text+="\n\n--- STDERR ---\n"+d.stderr;

document.getElementById("rawOutput").textContent=text||"Sin salida.";

document.getElementById("rawSearch").value="";

}

function filterRaw(){

const q=document.getElementById("rawSearch").value.toLowerCase();

const d=DATA[ACTIVE];

if(!d)return;

let text=(d.stdout||"");

if(d.stderr)text+="\n\n--- STDERR ---\n"+d.stderr;

if(!q){

document.getElementById("rawOutput").textContent=text;

return;

}

const lines=text.split("\n").filter(x=>x.toLowerCase().includes(q));

document.getElementById("rawOutput").textContent=

lines.length?lines.join("\n"):"No se encontraron coincidencias.";

}

function filterTable(id,q){

q=q.toLowerCase();

document.querySelectorAll("#"+id+" tbody tr").forEach(tr=>{

tr.style.display=tr.textContent.toLowerCase().includes(q)?"":"none";

});

}

async function startAnalysis(){

const btn=document.getElementById("runBtn");

btn.disabled=true;

btn.textContent="⏳ Iniciando...";

try{

const r=await fetch("/api/run",{method:"POST"});

const data=await r.json();

if(!r.ok)throw new Error(data.message||"No se pudo iniciar.");

showAlert("Análisis iniciado. El panel se actualizará automáticamente.",true);

if(poller)clearInterval(poller);

poller=setInterval(refresh,800);

await refresh();

}catch(e){

showAlert(e.message,false);

}finally{

btn.disabled=false;

btn.textContent="▶ Ejecutar análisis";

}

refresh();

setInterval(()=>{

const btn=document.getElementById("runBtn");

fetch("/api/status").then(r=>r.json()).then(s=>{

if(s.state.running){

btn.disabled=true;

btn.textContent="⏳ Analizando...";

}else{

btn.disabled=false;

btn.textContent="▶ Ejecutar análisis";

}

}).catch(()=>{});

},1000);

</script>

</body>

</html>

"""

if __name__ == "__main__":

print()

print("=" * 72)

print(" MemoryScope Pro · Volatility 3")

print("=" * 72)

print()

mem = memory_info()

vol = vol_info()

print("Memoria :", mem["path"] if mem else "NO ENCONTRADA")

print("Volatility:", vol if vol else "NO ENCONTRADO")

Después se ejecuta:

python3 memory_dashboard.py

En Windows:

python memory_dashboard.py

El servidor se inicia en:

http://127.0.0.1:8787

Al acceder desde el navegador aparece el dashboard.

Ejecutar el análisis

Una vez abierta la aplicación simplemente hay que pulsar:

▶ Ejecutar análisis

MemoryScope ejecutará los plugins configurados y actualizará las diferentes secciones del dashboard.

El tiempo necesario dependerá principalmente del tamaño de la imagen de memoria y de los plugins ejecutados.

Ventaja de utilizar un dashboard

Volatility es una herramienta extremadamente potente, pero gran parte de su funcionamiento se basa en la línea de comandos.

Por ejemplo, un análisis tradicional puede implicar ejecutar:

python vol.py -f memoria.raw windows.pslist

después:

python vol.py -f memoria.raw windows.pstree

y posteriormente:

python vol.py -f memoria.raw windows.netscan

python vol.py -f memoria.raw windows.malfind

MemoryScope permite centralizar estos resultados en una única interfaz.

La terminal continúa siendo importante para el análisis forense avanzado, pero el dashboard proporciona una primera capa visual para explorar rápidamente la evidencia.

Laboratorio de análisis forense

Una práctica interesante consiste en crear una máquina Windows de laboratorio, generar actividad controlada y posteriormente capturar la memoria RAM.

El escenario podría ser:

1. Preparar Windows de laboratorio
              ↓
2. Generar actividad controlada
              ↓
3. Capturar la RAM
              ↓
4. Obtener memoria.raw
              ↓
5. Ejecutar MemoryScope
              ↓
6. Analizar procesos
              ↓
7. Analizar conexiones
              ↓
8. Analizar comandos
              ↓
9. Revisar DLL y archivos
              ↓
10. Investigar resultados de malfind

Este procedimiento permite trabajar conceptos de análisis forense de una manera mucho más práctica.

Evidencia y cadena de custodia

En un escenario académico o profesional es importante diferenciar entre una práctica de laboratorio y una investigación real.

La imagen de memoria debe tratarse como evidencia y conservarse de forma adecuada. Es recomendable calcular un hash antes del análisis, por ejemplo:

Windows

Get-FileHash memoria.raw -Algorithm SHA256

Linux/macOS

sha256sum memoria.raw

De esta forma se puede comprobar posteriormente que la imagen analizada no ha cambiado.

También es recomendable trabajar sobre una copia cuando el procedimiento de adquisición y preservación de evidencia así lo requiera.

Una interfaz para aprender análisis de memoria

El objetivo de MemoryScope no es sustituir Volatility 3.

Su finalidad es proporcionar una capa visual sobre Volatility que facilite la exploración inicial de una imagen de memoria.

La combinación de:

Captura RAM
     +
Volatility 3
     +
MemoryScope

permite construir un laboratorio bastante completo para estudiar análisis forense de memoria.

El proyecto también puede ampliarse con nuevas funcionalidades como generación automática de informes, gráficas de procesos, análisis temporal, clasificación de indicadores, correlación entre procesos y conexiones de red o un sistema de puntuación de riesgo.

Nota: el análisis debe realizarse únicamente sobre equipos, imágenes de memoria y evidencias para los que se disponga de autorización. Los resultados de herramientas como malfind deben interpretarse junto con otras evidencias y no como una confirmación automática de malware.

MemoryScope: dashboard web para análisis forense de memoria con Volatility 3 (PowerShell)