Saltar al contenido
Nuevo

DeepSeek V4.1 Flash gratis por 7 días: 10M tokens al día tras una recarga de $10 o más. Hasta el 30/11.

Cómo funciona
aeondave/fridaMóvil, firmware y hardware

frida

⁨Auth/lab ref: Dynamic instrumentation toolkit for hooking functions, tracing APIs, and manipulating running processes across Windows, Linux, macOS, Android, and iOS.⁩

v2026.11.13-21cd5683 instalaciones+3 en 7 días39 EstrellasMITsincronizado hace 10 horas

Instalar

¿Aún no tienes la CLI de NotHoly? Instálala primero.

$ curl -fsSL https://notholy.com/install.sh | sh
$ notholy skills install aeondave/frida

Escribe en ⁦~/.notholy/skills⁩ después de comprobar la firma y el SHA-256.

FirmaFirmado, ed25519
BCh1Q6G3sr…ZxZy5CBA==La CLI comprueba el SHA-256 y la firma antes de escribir cualquier archivo.
Paqueted27689a8…43a39929
d27689a8fcc2…6d0743a399292 archivos · ⁦8.3 KB⁩
EscaneoBajo1 hallazgo
  • Enlaces a dominios externos
Ver el escaneo completo
Fuentegithub.com/AeonDave/malskill/tree/main/offensive-tools/rev/frida@21cd568

Esta entrada todavía no está escrita en tu idioma, así que aparece en English.

Frida 17+ API: Resolve exports via module instances (Process.getModuleByName(name).getExportByName(sym)) or Module.getGlobalExportByName(sym); use NativePointer methods (ptr.readByteArray(), ptr.writeByteArray()).

Dynamic instrumentation — inject JavaScript into running processes to hook, trace, and modify behavior at runtime.

Installation

bash
# CLI tools
pip install frida-tools

# Python bindings
pip install frida

# For Android: push frida-server to device
# Download from https://github.com/frida/frida/releases (match arch)
adb push frida-server /data/local/tmp/
adb shell chmod 755 /data/local/tmp/frida-server
adb shell /data/local/tmp/frida-server &

Quick Start

bash
# List running processes
frida-ps                        # Local
frida-ps -U                     # USB (Android/iOS)

# Attach to process
frida -p PID
frida -n process_name

# Spawn and attach
frida -f /path/to/binary

# Run a script
frida -p PID -l hook.js

# Trace functions matching pattern
frida-trace -i "recv*" -p PID
frida-trace -i "open*" -f ./binary

Core JavaScript API

Interceptor — Hook Functions

javascript
// Hook a native function
Interceptor.attach(Module.getGlobalExportByName('connect'), {
    onEnter(args) {
        const sockaddr = args[1];
        const family = sockaddr.readU16();
        if (family === 2) { // AF_INET
            const port = (sockaddr.add(2).readU8() << 8) | sockaddr.add(3).readU8();
            const ip = [
                sockaddr.add(4).readU8(), sockaddr.add(5).readU8(),
                sockaddr.add(6).readU8(), sockaddr.add(7).readU8()
            ].join('.');
            console.log(`[connect] ${ip}:${port}`);
        }
    },
    onLeave(retval) {
        console.log(`[connect] returned ${retval}`);
    }
});

Replace Function Return

javascript
// Force IsDebuggerPresent to return 0 (Windows anti-debug bypass)
Interceptor.attach(Process.getModuleByName('kernel32.dll').getExportByName('IsDebuggerPresent'), {
    onLeave(retval) {
        retval.replace(ptr(0));
    }
});

Module and Memory

javascript
// List loaded modules
Process.enumerateModules().forEach(m => {
    console.log(`${m.name} @ ${m.base} size=${m.size}`);
});

// Find export
const addr = Process.getModuleByName('libc.so').getExportByName('open');

// Read/write memory
const buf = ptr(0x401000).readByteArray(64);
ptr(0x401000).writeByteArray([0x90, 0x90, 0x90]);

// Scan memory for pattern
Memory.scan(module.base, module.size, 'MZ', {
    onMatch(address, size) { console.log(`Found MZ at ${address}`); },
    onComplete() { console.log('Scan done'); }
});

Stalker — Instruction Tracing

javascript
Stalker.follow(Process.getCurrentThreadId(), {
    events: { call: true, ret: true },
    onCallSummary(summary) {
        for (const [addr, count] of Object.entries(summary)) {
            const mod = Process.findModuleByAddress(ptr(addr));
            if (mod) console.log(`${mod.name}+${ptr(addr).sub(mod.base)}: ${count} calls`);
        }
    }
});

Common Workflows

Malware — trace network calls (Linux)

javascript
['connect', 'send', 'sendto', 'recv', 'recvfrom'].forEach(fn => {
    const p = Module.findGlobalExportByName(fn);
    if (p) {
        Interceptor.attach(p, {
            onEnter(args) {
                console.log(`[${fn}] fd=${args[0]}, buf=${args[1]}, len=${args[2]}`);
                if (fn.startsWith('send')) {
                    console.log(hexdump(args[1], { length: Math.min(args[2].toInt32(), 128) }));
                }
            }
        });
    }
});

Malware — intercept crypto (Windows)

javascript
Interceptor.attach(Process.getModuleByName('bcrypt.dll').getExportByName('BCryptEncrypt'), {
    onEnter(args) {
        this.plaintext = args[1];
        this.len = args[2].toInt32();
        console.log(`[BCryptEncrypt] plaintext (${this.len} bytes):`);
        console.log(hexdump(this.plaintext, { length: Math.min(this.len, 256) }));
    }
});

Android — bypass SSL pinning

javascript
Java.perform(() => {
    const TrustManager = Java.registerClass({
        name: 'com.frida.TrustManager',
        implements: [Java.use('javax.net.ssl.X509TrustManager')],
        methods: {
            checkClientTrusted(chain, authType) {},
            checkServerTrusted(chain, authType) {},
            getAcceptedIssuers() { return []; }
        }
    });
    const SSLContext = Java.use('javax.net.ssl.SSLContext');
    const ctx = SSLContext.getInstance('TLS');
    ctx.init(null, [TrustManager.$new()], null);
    SSLContext.getInstance.overload('java.lang.String').implementation = function(protocol) {
        return ctx;
    };
    console.log('[bypass] SSL pinning disabled');
});

Android — hook Java methods

javascript
Java.perform(() => {
    const clazz = Java.use('com.example.app.LoginActivity');
    clazz.validatePassword.implementation = function(password) {
        console.log(`[hook] validatePassword("${password}")`);
        const result = this.validatePassword(password);
        console.log(`[hook] returned ${result}`);
        return result;
    };
});

Windows — trace injection APIs

javascript
const apis = ['VirtualAlloc', 'VirtualProtect', 'CreateRemoteThread',
              'WriteProcessMemory', 'CreateProcessW'];
apis.forEach(api => {
    const p = Process.getModuleByName('kernel32.dll').getExportByName(api);
    if (p) {
        Interceptor.attach(p, {
            onEnter(args) {
                console.log(`[${api}] called from ${this.returnAddress}`);
                console.log(`  args: ${args[0]}, ${args[1]}, ${args[2]}, ${args[3]}`);
            },
            onLeave(retval) {
                console.log(`[${api}] returned ${retval}`);
            }
        });
    }
});

frida-trace

bash
# Trace all open* calls
frida-trace -i "open*" -f ./binary

# Trace specific library functions
frida-trace -i "SSL_*" -f ./binary

# Trace ObjC methods (iOS/macOS)
frida-trace -m "-[NSURLSession *]" -p PID

# Trace Java methods (Android)
frida-trace -j "com.example.app.LoginActivity!*" -U -f com.example.app

Python API

python
import frida

def on_message(message, data):
    if message['type'] == 'send':
        print(f"[*] {message['payload']}")

device = frida.get_local_device()
session = device.attach("target_process")
script = session.create_script("""
    Interceptor.attach(Module.getGlobalExportByName('connect'), {
        onEnter(args) { send('connect called'); }
    });
""")
script.on('message', on_message)
script.load()
input("Press Enter to detach...")
session.detach()

Resources

File When to load
references/android-ios.md Mobile-specific instrumentation: SSL bypass, root bypass, Gadget embedding, JNI/native hooking, anti-Frida evasion

See Also

  • mobile-technique — full mobile pentest methodology; routes here for dynamic instrumentation
  • smali-dex-patching — static APK patching alternative; load smali-dex-patching/references/hooking-vs-patching.md to decide which approach
  • android-jni-ndk — JNI mechanics, NDK debugging, Rust-on-Android; needed when reversing native .so loaded via Frida hooks
  • smali-dex-patching/references/dynamic-dex-and-native-loaders.md — hybrid loader patterns (DexClassLoader + native bootstrap + second-stage recovery)
  • reversing-technique — when Frida tracing leads to a native binary requiring static RE (Ghidra/IDA/r2)

Archivos de esta versión

Permisos

PermisoDeclaradoHallado en el escaneo
Lee archivosNoNo
Escribe archivosSíSí
Ejecuta comandos de shellSíSí
Usa la redSíSí
Usa conectoresNoNo
Controla un navegadorNoNo

Hallazgos del escaneo

Revisado el 13 nov 2026

  1. InfoEnlace · Enlaces a dominios externos

Un escaneo limpio baja el riesgo, pero no prueba que el paquete sea seguro. Lee lo que instalas.

VersiónPublicadaCommitSHA-256FirmaCambio de permisos
v2026.11.13-21cd56813 nov 202621cd568d27689a8Firmada–

Pregunta todo lo que tu alcance permite.

Crea la cuenta, añade créditos y haz la primera pregunta en el chat o en la terminal.

  1. 1/3

    Crea la cuenta

    Individual o empresa. Puedes pasar a empresa después sin perder saldo ni claves.

    IndividualEmpresa
  2. 2/3

    Añade créditos

    Con tarjeta. Pagas por token, sin suscripción.

    $5.00recarga mínima
  3. 3/3

    Pregunta

    En el chat, o instala el CLI y ejecuta notholy login en tu terminal.

    $ notholy login