README

trueseeing es un escáner de vulnerabilidades rápido, preciso y resistente para aplicaciones iOS/Android. Operamos en el nivel de la máquina virtual Dalvik para Android, es decir -- no nos importa si la aplicación objetivo está ofuscada o no.

Capacidad

Actualmente podemos:

• Escanear automáticamente la aplicación en busca de vulnerabilidades, reportando en formato HTML/JSON/texto (ver más abajo)
• Manipular la aplicación para un análisis más fácil: p. ej., habilitar el bit de depuración, habilitar la copia de seguridad completa, deshabilitar el pinning TLS, manipular el nivel de API objetivo, inyectar frida-gadget, etc.
• Examinar la aplicación para obtener información general
• Copiar datos de entrada/salida de la aplicación a través de la interfaz de depuración
• Buscar ciertas llamadas/constantes/sput/iput
• Deducir constantes/conjuntos de tipos para argumentos de operaciones
• Escanear llamadas API/privadas en busca de códigos nativos (NB: necesitas ts2-disasm-ghidra)
• Escanear aplicaciones iOS en busca de vulnerabilidades básicas (NB: necesitas ts2-disasm-ghidra)
• Adjuntar scripts de frida
• Proporcionar sesión interactiva de frida
• Rastrear llamadas
• etc.

Instalación

Contenedores

NOTA:

• A partir de la versión 2.1.9, estamos en ghcr.io. (Docker Hub está algo obsoleto)
• Requiere adbd en el host para controlar dispositivos.

Proporcionamos contenedores para que puedas usarlos de inmediato de la siguiente manera; ahora esta también es la forma recomendada, y la única si estás en Windows, para ejecutar:

$ docker run --rm -v $(pwd):/out -v ts2:/cache ghcr.io/alterakey/trueseeing

Si quieres ejecutarlo sin estado, omite montar el volumen en /cache (aunque no se recomienda para uso diario; ver también #254):

$ docker run --rm -v $(pwd):/out ghcr.io/alterakey/trueseeing

Instalar con uv

Alternativamente, puedes instalar nuestro paquete con uv de la siguiente manera. Especialmente la forma de instalación uv tool install puede ser útil para extensiones (ver más abajo), ya que les otorga la mayor libertad. Solo recuerda que necesitas un JRE y el SDK de Android (opcionalmente; para manipular dispositivos):

$ uvx trueseeing

$ uv tool install trueseeing
$ trueseeing

Instalar con pip (obsoleto)

Por supuesto, siempre puedes usar el viejo pip si es necesario:

$ pip install trueseeing

Uso

Modo interactivo

Puedes escanear/analizar/parchear/etc. aplicaciones de forma interactiva, lo que lo convierte en la opción ideal para el análisis manual:

$ trueseeing target.apk
[+] trueseeing x.y.z
ts[target.apk]> ?
...
ts[target.apk]> i                      # show generic information
...
ts[target.apk]> pf AndroidManifest.xml # show manifest file
...
ts[target.apk]> a                      # analyze resources too
...
ts[target.apk]> /s something           # search text
...
ts[target.apk]> as                     # scan
...
[+] done, found 6403 issues (174.94 sec.)
ts[target.apk]> gh report.html

Modo por lotes

Aceptamos un comando en línea (-c) o un archivo de script (-i) para ejecutar antes de darte el prompt, así como salir inmediatamente en lugar de esperar input (-q; ¡no requerimos una tty en este modo!).

Puedes usar estas características para realizar un escaneo por lotes, como por ejemplo para volcar los hallazgos directamente en stderr:

$ trueseeing -eqc 'as' target.apk

Para generar un archivo de informe en formato HTML:

$ trueseeing -eqc 'as;gh report.html' target.apk

Para generar un archivo de informe en formato JSON:

$ trueseeing -eqc 'as;gj report.json' target.apk

Para que el informe se genere en stdout, omite el nombre de archivo del comando g* final:

$ trueseeing -eqc 'as;gh' target.apk > report.html
$ trueseeing -eqc 'as;gj' target.apk > report.json

Modo de escaneo no interactivo (obsoleto)

Tradicionalmente, puedes escanear aplicaciones con la siguiente línea de comandos para obtener hallazgos listados en stderr:

$ trueseeing --scan target.apk

Para generar un informe en formato HTML:

$ trueseeing --scan --scan-output report.html target.apk
$ trueseeing --scan --scan-report=html --scan-output report.html target.apk

Para generar un informe en formato JSON:

$ trueseeing --scan --scan-report=json --scan-output report.json target.apk

Para que el informe se genere en stdout, especifica '-' como nombre de archivo:

$ trueseeing --scan --scan-output - target.apk > report.html
$ trueseeing --scan --scan-report=html --scan-output - target.apk > report.html
$ trueseeing --scan --scan-report=json --scan-output - target.apk > report.json

Usos avanzados

Extensiones

Puedes escribir tus propios comandos y firmas como extensiones. Las extensiones se colocan en /ext (contenedores) o ~/.trueseeing2/extensions/ (uv/pip). Alternativamente, puedes distribuir tus extensiones como wheels. Proporcionamos información de tipos para que no solo puedas verificar los tipos de tus extensiones con zuban sino también obtener una asistencia decente de los IDE. Consulta la sección de detalles para más información.

Construcción

Puedes construirlo de la siguiente manera:

$ docker build -t trueseeing https://github.com/alterakey/trueseeing.git#main

Para construir wheels puedes hacerlo con flit, de la siguiente manera:

$ flit build

Para modificarlo, necesitas crear un entorno de compilación adecuado. Con uv simplemente puedes hacer:

$ git clone https://github.com/alterakey/trueseeing.git wc
$ uv sync --locked --dev
$ (... hack ...)
$ uv run trueseeing ...                                    # to run
$ uv run zuban check trueseeing && uv run ruff trueseeing  # to validate
Success: no issues found in XX source files
$ uv run flit build                                        # to build (wheel)
$ docker build -t trueseeing .                             # to build (container)

Con pip, para crear uno, primero configura un venv, instala flit y las cadenas de herramientas de validación (zuban y ruff) allí, y haz que flit obtenga las dependencias. En resumen, haz algo como esto:

$ git clone https://github.com/alterakey/trueseeing.git wc
$ python3 -m venv wc/.venv
$ source wc/.venv/bin/activate
(.venv) $ pip install flit zuban ruff
(.venv) $ flit install --deps=develop -s
(.venv) $ (... hack ...)
(.venv) $ trueseeing ...                                   # to run
(.venv) $ zuban check trueseeing && ruff check trueseeing  # to validate
Success: no issues found in XX source files
(.venv) $ flit build                                       # to build (wheel)
(.venv) $ docker build -t trueseeing .                     # to build (container)

Detalles

Clases de Vulnerabilidades

Actualmente podemos detectar las siguientes clases de vulnerabilidades, en gran medida las cubiertas en OWASP Mobile Top 10 - 2016:

• Uso Inadecuado de la Plataforma (M1)

  • Depurable
  • Publicación inadvertida de Activities, Services, ContentProviders, BroadcastReceivers

• Datos Inseguros (M2)

  • Con copia de seguridad habilitada (es decir, susceptible al ataque de copia de seguridad)
  • Permisos de archivo inseguros
  • Registro (logging)

• Comunicaciones Inseguras (M3)

  • Falta de pinning (es decir, susceptible al ataque de intercepción TLS)
  • Uso de HTTP en texto claro
  • WebViews manipulables

• Criptografía Insuficiente (M5)

  • Frases de contraseña/claves secretas codificadas
  • Cifrados Vernam con claves estáticas
  • Uso del modo ECB

• Problemas de Calidad del Código del Cliente (M7)

  • WebViews reflectantes (es decir, los XSS en dichas vistas deberían ser escalables a ejecuciones de código remoto mediante reflexión JS)
  • Uso de política insegura en contenidos mixtos

• Manipulación del Código (M8)

  • Certificados codificados

• Ingeniería Inversa (M9)

  • Falta de ofuscación

API de Extensiones

Nuestra API de extensiones se encuentra en el paquete trueseeing.api. Como proporcionamos información de tipos con ella, tu IDE te ayudará al escribir tus extensiones. Solo asegúrate de que su PYTHONPATH (o el de su servidor de lenguaje) cubra el venv donde está nuestro paquete; consulta uv tool list --show-paths si lo instalaste con uv tool install. Si lo instalaste con uvx, considera reinstalarlo con uvx install. Si lo instalaste con pip, ya sabes dónde está.

Comandos

Para definir nuevos comandos, implementa trueseeing.api.Command y anúncialos.

La siguiente clase proporcionará un comando de ejemplo como t, por ejemplo:

from typing import TYPE_CHECKING
from trueseeing.api import Command
from trueseeing.core.ui import ui
if TYPE_CHECKING:
  from trueseeing.api import CommandMap, CommandPatternMap, ModifierMap, OptionMap, ConfigMap

class MyCommand(Command):
  @staticmethod
  def create() -> Command:
    return MyCommand()

  def get_commands(self) -> CommandMap:
    return {'t':dict(e=self._test, n='t', d='sample command')}

  def get_command_patterns(self) -> CommandPatternMap:
    return dict()

  def get_modifiers(self) -> ModifierMap:
     return dict()

  def get_options(self) -> OptionMap:
    return dict()

  def get_configs(self) -> ConfigMap:
    return dict()

  async def _test(self) -> None:
    ui.info('hello world')

Firmas

Para definir nuevas firmas, implementa trueseeing.api.Signature y anúncialas.

La siguiente clase proporcionará un detector de ejemplo como my-sig, por ejemplo:

from typing import TYPE_CHECKING
from trueseeing.api import Signature
if TYPE_CHECKING:
  from trueseeing.api import SignatureMap, ConfigMap

class MySignature(Signature):
  @staticmethod
  def create() -> Signature:
    return MySignature()

  def get_sigs(self) -> SignatureMap:
    return {'my-sig':dict(e=self._detect, d='sample signature')}

  def get_configs(self) -> ConfigMap:
    return dict()

  async def _detect(self) -> None:
    self._helper.raise_issue(
      self._helper.build_issue(
        sigid='my-sig',
        title='hello world',
        cvss='CVSS:3.0/AV:P/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:N/',
      )
    )

Formatos de Archivo

Para definir nuevos formatos de archivo, primero implementa Contexts (ABC) para tus formatos, luego implementa trueseeing.api.FileFormatHandler para crear y devolver sus instancias, y anúncialos.

La siguiente clase proporcionará soporte de archivos APK bajo el tipo llamado apk2, por ejemplo:

from typing import TYPE_CHECKING
from trueseeing.api import FileFormatHandler
from trueseeing.core.android.context import APKContext

if TYPE_CHECKING:
  from typing import Optional, Set
  from trueseeing.api import FormatMap, ConfigMap
  from trueseeing.core.context import Context, ContextType

class MyAPKContext(APKContext):
  # Use a different context type
  def _get_type(self) -> Set[ContextType]:
    return {'apk2'}

class APKFileFormatHandler(FileFormatHandler):
  @staticmethod
  def create() -> FileFormatHandler:
    return APKFileFormatHandler()

  def get_formats(self) -> FormatMap:
    return {'apk2':dict(e=self._handle, r=r'\.apk$', d='sample file format', t=None)}  # if this handler can suggest device context type, advertise at t

  def get_configs(self) -> ConfigMap:
    return dict()

  def _handle(self, path: str) -> Optional[Context]:
    return MyAPKContext(path)

Luego asegúrate de verificar el tipo de contexto en tus firmas, haciendo que se ignoren en contextos no soportados:

context = self._helper.get_context().require_type('apk2')

Tras una verificación exitosa, require_type(...) intentará hacer downcast de ellos a los tipos apropiados para tu conveniencia.

Pero por diseño solo funciona para tipos conocidos (actualmente, apk). Así que si estás definiendo alguna interfaz detallada en tus nuevas clases de contexto como hacemos para el tipo apk, necesitas hacer un downcast aquí, es decir:

context: MyAPKContext = self._helper.get_context().require_type('apk2')  # type:ignore[assignment]

Es posible definir múltiples formatos que coincidan con el mismo patrón. Evaluamos los patrones en orden del más estricto (es decir, largo) al menos. Usas el interruptor -F para forzar el uso de algún formato con el archivo objetivo, por ejemplo:

$ trueseeing -F apk2 target.apk

Requisitos del paquete

Las extensiones pueden ser: a) cualquier paquete colocado en /ext (contenedor) o ~/.trueseeing2/extensions (pip), o b) cualquier módulo instalado con el prefijo trueseeing_ext0_.

¿Origen del nombre del proyecto?

El hechizo de D&D, True Seeing.