Monitor - Guía de Integración de Monitor

Android (Java/Kotlin) & iOS (Swift/Objective-C)

Tabla de Contenidos

Introducción

Monitor es una solución RASP (Runtime Application Self-Protection) que protege aplicaciones en tiempo de ejecución contra amenazas, tampering y entornos maliciosos.

Esta guía de integración está dirigida específicamente a aplicaciones móviles Android e iOS. Monitor detecta amenazas en dispositivos y entornos como debuggers, máquinas virtuales, emuladores, jailbreak/root, manipulación del reloj y volcados de memoria.

Nota: ByteHide Monitor también dispone de una versión web que actúa como WAF (Web Application Firewall) integrado en la aplicación para interceptar ataques web como SQL Injection, XSS, NoSQL Injection, entre otros. Esta guía no cubre la versión web, está enfocada exclusivamente en protecciones para aplicaciones móviles.

Esta guía está dirigida a desarrolladores y organizaciones que desean integrar la protección de Monitor en sus aplicaciones móviles. Monitor es un producto comercial disponible a través de ByteHide.

Integración Android (Java/Kotlin)

Instalación

Paso 1: Añadir el Repositorio Maven de ByteHide

Añade el repositorio de Monitor a tu settings.gradle.kts:

Kotlin
pluginManagement {
    repositories {
        maven {
            url = uri("https://maven.bytehide.com/releases")
        }
        google()
        mavenCentral()
    }
}

dependencyResolutionManagement {
    repositories {
        maven {
            url = uri("https://maven.bytehide.com/releases")
        }
        google()
        mavenCentral()
    }
}

Paso 2: Añadir la Dependencia de Monitor

Añade Monitor a tu build.gradle.kts del módulo app:

Kotlin
dependencies {
    implementation("com.bytehide:monitor-integration:2.0.0")
}

Configuración

Monitor ofrece 3 opciones de configuración según tus necesidades:

Opción A: Configuración desde la Nube (Zero-Config) - Recomendada

La forma más simple. Solo añade el paquete y Monitor obtiene la configuración automáticamente desde tu dashboard de ByteHide.

Ventajas:

  • Sin archivos de configuración
  • Sin código adicional
  • Actualización de protecciones en tiempo real desde el dashboard
  • Cambios instantáneos sin necesidad de rebuild

¿Qué sucede?

  1. Durante el build, el plugin Gradle embebe tu token en el APK
  2. En runtime, Monitor se conecta a la API de ByteHide
  3. Descarga la configuración activa desde tu dashboard
  4. Aplica las protecciones configuradas remotamente
  5. Sincroniza cambios periódicamente (actualizaciones en caliente)

Setup:

Configura tu token como variable de entorno:

Bash
# Windows (PowerShell)
$env:BYTEHIDE_TOKEN = "tu-token-aqui"

# Windows (CMD)
set BYTEHIDE_TOKEN=tu-token-aqui

# Linux/macOS
export BYTEHIDE_TOKEN="tu-token-aqui"

Build tu proyecto - ¡y listo! Monitor se inicializará automáticamente con la configuración de tu dashboard.

Opción B: Configuración con Archivo JSON - Para Control Local

Define las protecciones localmente en un archivo JSON. Ideal si necesitas configuración offline o control total sobre las protecciones.

Ventajas:

  • Configuración versionada en tu repositorio
  • Funciona completamente offline
  • Control total sobre protecciones y acciones
  • Fácil de auditar y revisar

Crea monitor-config.json en src/main/assets/:

JSON
{
  "projectToken": "tu-token-aqui",
  "logging": {
    "level": "info",
    "console": true,
    "file": {
      "enabled": true,
      "path": "logs/monitor.log"
    }
  },
  "protections": [
    {
      "type": "DEBUGGER_DETECTION",
      "enabled": true,
      "action": "CLOSE",
    },
    {
      "type": "JAILBREAK_DETECTION",
      "enabled": true,
      "action": "CLOSE",
    },
    {
      "type": "EMULATOR_DETECTION",
      "enabled": true,
      "action": "LOG",
    },
    {
      "type": "CLOCK_TAMPERING",
      "enabled": true,
      "action": "LOG",
    },
    {
      "type": "MEMORY_DUMP_DETECTION",
      "enabled": true,
      "action": "CLOSE",
    },
    {
      "type": "VIRTUAL_MACHINE_DETECTION",
      "enabled": true,
      "action": "CLOSE",
    }
  ]
}

Monitor cargará automáticamente este archivo sin código adicional.

Opción C: Configuración Programática - Para Máximo Control

Configura Monitor directamente en código. Ideal para lógica de protección dinámica, acciones personalizadas y debugging avanzado.

Ventajas:

  • Control total mediante código
  • Acciones personalizadas (custom handlers)
  • Configuración dinámica según condiciones
  • Integración con tu lógica de negocio
Kotlin
import android.app.Application
import com.bytehide.monitor.Monitor
import com.bytehide.monitor.core.action.ActionType
import com.bytehide.monitor.core.protection.ProtectionModuleType
import android.util.Log

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        // Configurar Monitor programáticamente
        Monitor.configure { config ->
            // Token (opcional si ya está embebido)
            config.useToken("bh_TuTokenAqui")

            // Registrar acción personalizada
            config.registerCustomAction("notificar") { threat ->
                Log.w("ByteHideMonitor", "🚨 ALERTA: ${threat.description}")
                // Enviar notificación al usuario
                // Registrar en analytics
                // Enviar a sistema de alertas
            }

            // Configurar logging
            config.configureLogging { logging ->
                logging.enableConsole()
                logging.enableFileLogging("monitor.log")
                logging.setMinimumLevel(LogLevel.INFO)
            }

            // Habilitar todas las protecciones con acción personalizada
            config.enableAllProtections(ActionType.CUSTOM, 60000)

            // O configurar protecciones individuales
            config.addProtection(
                ProtectionModuleType.DEBUGGER_DETECTION,
                ActionType.CLOSE,
                60000
            )

            config.addProtection(
                ProtectionModuleType.JAILBREAK_DETECTION,
                "notificar",  // Usar acción personalizada
                60000
            )
        }
    }

    override fun onTerminate() {
        super.onTerminate()
        Monitor.shutdown()
    }
}

No olvides registrar tu Application en el AndroidManifest.xml:

XML

Tipos de Acciones Disponibles

Monitor ofrece diferentes acciones que se ejecutan cuando se detecta una amenaza:

TipoDescripciónUso Recomendado
NONESolo detecta, no toma acciónTesting, análisis inicial
LOGRegistra el incidente en logsProducción con monitoreo
CLOSECierra la aplicación inmediatamenteMáxima seguridad
ERASEBorra datos sensibles y cierraDatos críticos (finanzas, salud)
CUSTOMEjecuta tu handler personalizadoLógica de negocio específica

Ejemplo de Acción Personalizada:

Kotlin
config.registerCustomAction("miAccion") { threat ->
    // 1. Registrar el incidente
    analytics.trackSecurityThreat(threat.type, threat.description)

    // 2. Notificar al usuario
    showSecurityWarning(threat.description)

    // 3. Enviar alerta al backend
    securityApi.reportThreat(threat)

    // 4. Tomar medida según severidad
    when (threat.confidence) {
        in 0.8..1.0 -> {
            // Alta confianza: cerrar app
            exitProcess(1)
        }
        in 0.5..0.8 -> {
            // Media confianza: limitar funcionalidad
            disableSensitiveFeatures()
        }
        else -> {
            // Baja confianza: solo log
            Log.i("Security", "Posible amenaza: ${threat.description}")
        }
    }
}

Configuración Híbrida (Recomendada para Producción)

Puedes combinar las opciones para máxima flexibilidad:

Kotlin
Monitor.configure { config ->
    // Cargar configuración base desde Cloud/JSON
    // (Monitor ya cargó automáticamente desde cloud o monitor-config.json)

    // Sobrescribir solo lo que necesitas
    config.registerCustomAction("alertaCritica") { threat ->
        // Tu lógica personalizada para amenazas críticas
        sendPushNotification("Alerta de Seguridad", threat.description)
        exitProcess(1)
    }

    // Añadir protección adicional con acción custom
    config.addProtection(
        ProtectionModuleType.MEMORY_DUMP_DETECTION,
        "alertaCritica",
        60000
    )
}

Flujo de carga de configuración:

  1. Monitor intenta cargar desde monitor-config.json embebido
  2. Si no existe, obtiene configuración desde la nube (dashboard)
  3. Aplica configuración programática (si usas Monitor.configure)
  4. La configuración programática sobrescribe la automática

Integración iOS (Swift/Objective-C)

Instalación

Monitor para iOS soporta CocoaPods y Swift Package Manager.

Opción 1: CocoaPods (Recomendada - Configuración Cero)

Añade Monitor a tu Podfile:

Ruby
platform :ios, '12.0'

target 'TuApp' do
  use_frameworks!

  pod 'ByteHideMonitor', '~> 1.0.0'
end

Instala:

Bash
pod install

¡Listo! La validación en build-time se ejecuta automáticamente.

Opción 2: Swift Package Manager

Paso 1: Añadir el Paquete

  1. Xcode → File → Add Package Dependencies...
  2. URL: https://github.com/bytehide/bytehide-monitor
  3. Versión: 1.0.0+
  4. Añadir a tu target

Paso 2: Ejecutar Script de Setup (Una sola vez)

Bash
# Instalar xcodeproj gem (si no está instalado)
gem install xcodeproj

# Ejecutar setup desde el directorio de tu proyecto
cd TuProyecto
ruby Packages/ByteHideMonitor/setup-spm.rb

¡Listo! Después de este setup único, los builds funcionan automáticamente como con CocoaPods.

Configuración

Paso 1: Obtener tu Project Token

Obtén tu ByteHide Project Token desde cloud.bytehide.com

Paso 2: Configurar el Token

Tienes 3 opciones para configurar tu token (elige una):

Opción A: Variable de Entorno (Recomendada)

Configura BYTEHIDE_TOKEN en tu esquema de Xcode:

  1. Edit Scheme → Run → Arguments → Environment Variables
  2. Añade: BYTEHIDE_TOKEN = tu-project-token
Opción B: Info.plist

Añade a tu Info.plist:

XML
ByteHideMonitor

    APIToken
    ${BYTEHIDE_TOKEN}

Luego configura la variable de entorno BYTEHIDE_TOKEN (igual que Opción A).

Opción C: Archivo de Configuración JSON

Crea monitor-config.json en la raíz de tu proyecto:

JSON
{
  "apiToken": "${BYTEHIDE_TOKEN}",
  "logLevel": "info",
  "protections": [
    {
      "type": "DebuggerDetection",
      "action": "close",
    },
    {
      "type": "JailbreakDetection",
      "action": "close",
    }
  ]
}

Configura la variable de entorno BYTEHIDE_TOKEN (igual que Opción A).

Configuración de Protecciones

Monitor ofrece 3 opciones de configuración según tus necesidades:

Opción A: Configuración desde la Nube (Zero-Config) - Recomendada

La forma más simple. Monitor obtiene la configuración automáticamente desde tu dashboard de ByteHide.

Ventajas:

  • Sin archivos de configuración
  • Sin código adicional
  • Actualización de protecciones en tiempo real desde el dashboard
  • Cambios instantáneos sin necesidad de rebuild

Setup:

Simplemente configura tu token (como se explicó arriba) y compila tu app. Durante el build, se valida el token y se embebe la configuración. En runtime, Monitor se auto-inicializa usando +load() (antes de main()) y aplica las protecciones configuradas en tu dashboard.

Bash
# Compilar en Xcode: Product → Build (⌘B)
# O vía línea de comandos:
xcodebuild -workspace TuApp.xcworkspace -scheme TuApp -configuration Release

¡No se requiere código! Todo es automático.

Opción B: Configuración con Archivo JSON - Para Control Local

Define las protecciones localmente en un archivo JSON. Ideal si necesitas configuración offline o control total.

Ventajas:

  • Configuración versionada en tu repositorio
  • Funciona completamente offline
  • Control total sobre protecciones y acciones
  • Fácil de auditar y revisar

Crea monitor-config.json en la raíz de tu proyecto:

JSON
{
  "projectToken": "bh_TuToken",
  "logging": {
    "level": "info",
    "console": true
  },
  "protections": [
    {
      "type": "DebuggerDetection",
      "enabled": true,
      "action": "close",
    },
    {
      "type": "JailbreakDetection",
      "enabled": true,
      "action": "close",
    },
    {
      "type": "EmulatorDetection",
      "enabled": true,
      "action": "log",
    },
    {
      "type": "ClockTampering",
      "enabled": true,
      "action": "log",
    },
    {
      "type": "MemoryDumpDetection",
      "enabled": true,
      "action": "close",
    },
    {
      "type": "VirtualMachineDetection",
      "enabled": true,
      "action": "close",
    }
  ]
}

Monitor cargará automáticamente este archivo sin código adicional.

Opción C: Configuración Programática - Para Máximo Control

Configura Monitor directamente en código Swift/Objective-C. Ideal para lógica de protección dinámica y acciones personalizadas.

Ventajas:

  • Control total mediante código
  • Acciones personalizadas (custom handlers)
  • Configuración dinámica según condiciones
  • Integración con tu lógica de negocio

Swift:

Swift
import ByteHideMonitor

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

        // Configurar Monitor programáticamente
        Monitor.configure { config in
            // Token (opcional si ya está embebido)
            config.useToken("bh_TuToken")

            // Registrar acción personalizada
            config.registerCustomAction("notificar") { threat in
                print("🚨 ALERTA: \(threat.description)")
                // Enviar notificación al usuario
                // Registrar en analytics
                // Enviar a sistema de alertas
            }

            // Configurar logging
            config.configureLogging { logging in
                logging.enableConsole()
                logging.setMinimumLevel(.info)
            }

            // Habilitar todas las protecciones con acción personalizada
            config.enableAllProtections(.log)

            // O configurar protecciones individuales
            config.addProtection(.debuggerDetection, action: .close)
            config.addProtection(.jailbreakDetection, customAction: "notificar")
        }

        return true
    }

    func applicationWillTerminate(_ application: UIApplication) {
        Monitor.shutdown()
    }
}

Objective-C:

OBJC
#import <ByteHideMonitor/ByteHideMonitor.h>

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application
    didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    // Configurar Monitor programáticamente
    [Monitor configure:^(MonitorConfiguration *config) {
        // Token
        [config useToken:@"bh_TuToken"];

        // Registrar acción personalizada
        [config registerCustomAction:@"notificar" handler:^(Threat *threat) {
            NSLog(@"🚨 ALERTA: %@", threat.description);
        }];

        // Habilitar todas las protecciones
        [config enableAllProtections:ActionTypeCustom];

        // O protecciones individuales
        [config addProtection:ProtectionTypeDebuggerDetection
                       action:ActionTypeClose
                   intervalMs:60000];
    }];

    return YES;
}

- (void)applicationWillTerminate:(UIApplication *)application {
    [Monitor shutdown];
}

@end

Tipos de Acciones Disponibles

Monitor ofrece diferentes acciones que se ejecutan cuando se detecta una amenaza:

TipoDescripciónUso Recomendado
noneSolo detecta, no toma acciónTesting, análisis inicial
logRegistra el incidente en logsProducción con monitoreo
closeCierra la aplicación inmediatamenteMáxima seguridad
eraseBorra datos sensibles y cierraDatos críticos (finanzas, salud)
customEjecuta tu handler personalizadoLógica de negocio específica

Configuración Híbrida (Recomendada para Producción)

Puedes combinar las opciones para máxima flexibilidad:

Swift
Monitor.configure { config in
    // Cargar configuración base desde Cloud/JSON
    // (Monitor ya cargó automáticamente desde cloud o monitor-config.json)

    // Sobrescribir solo lo que necesitas
    config.registerCustomAction("alertaCritica") { threat in
        // Tu lógica personalizada para amenazas críticas
        sendPushNotification("Alerta de Seguridad", threat.description)
        exit(1)
    }

    // Añadir protección adicional con acción custom
    config.addProtection(.memoryDumpDetection,
                        customAction: "alertaCritica"
                        )
}

Flujo de carga de configuración:

  1. Monitor intenta cargar desde monitor-config.json embebido
  2. Si no existe, obtiene configuración desde la nube (dashboard)
  3. Aplica configuración programática (si usas Monitor.configure)
  4. La configuración programática sobrescribe la automática

Auto-inicialización

Monitor para iOS se auto-inicializa automáticamente usando el método +load() de Objective-C, que se ejecuta antes de main().

¿Cómo funciona?

  • Durante el build: Se valida el token y se embebe la configuración necesaria en el bundle de la app
  • Durante la ejecución: Monitor se inicializa automáticamente antes de que tu código se ejecute, validando la firma y activando las protecciones configuradas

¡No se requiere código adicional! A menos que uses la Opción C (configuración programática)

Integración CI/CD

Android - GitHub Actions

YAML
name: Build Android App

on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Set up JDK 11
        uses: actions/setup-java@v3
        with:
          java-version: '11'
          distribution: 'temurin'

      - name: Build con Monitor
        env:
          BYTEHIDE_TOKEN: ${{ secrets.BYTEHIDE_TOKEN }}
        run: |
          ./gradlew assembleRelease

      - name: Subir APK
        uses: actions/upload-artifact@v3
        with:
          name: app-release
          path: app/build/outputs/apk/release/app-release.apk

iOS - GitHub Actions

YAML
name: Build iOS App

on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: macos-latest

    steps:
      - uses: actions/checkout@v3

      - name: Instalar CocoaPods
        run: |
          gem install cocoapods
          pod install

      - name: Compilar IPA
        env:
          BYTEHIDE_TOKEN: ${{ secrets.BYTEHIDE_TOKEN }}
        run: |
          xcodebuild archive \
            -workspace TuApp.xcworkspace \
            -scheme TuApp \
            -configuration Release \
            -archivePath TuApp.xcarchive

          xcodebuild -exportArchive \
            -archivePath TuApp.xcarchive \
            -exportPath . \
            -exportOptionsPlist ExportOptions.plist

      - name: Subir IPA
        uses: actions/upload-artifact@v3
        with:
          name: app-protected
          path: TuApp.ipa

GitLab CI

Android:

YAML
build_android:
  stage: build
  image: gradle:7.6-jdk11
  script:
    - export BYTEHIDE_TOKEN=$BYTEHIDE_TOKEN
    - ./gradlew assembleRelease
  artifacts:
    paths:
      - app/build/outputs/apk/release/app-release.apk

iOS:

YAML
build_ios:
  stage: build
  image: macos-12-xcode-14
  script:
    - export BYTEHIDE_TOKEN=$BYTEHIDE_TOKEN
    - pod install
    - xcodebuild archive ...
  artifacts:
    paths:
      - TuApp.ipa

Protecciones Disponibles

Monitor ofrece 13 protecciones de seguridad en tiempo de ejecución para aplicaciones móviles y de escritorio:

1. Debugger Detection

Detecta y bloquea debuggers adjuntos a tu aplicación en tiempo de ejecución.

Qué protege: Previene el análisis dinámico con herramientas como LLDB, GDB, Android Studio Debugger, Frida, y otros debuggers que permiten a atacantes analizar el comportamiento de tu aplicación.

Técnicas de detección:

  • Detección de procesos debugger adjuntos
  • Verificación de flags de debugging del sistema
  • Detección de breakpoints y hooks
  • Detección de herramientas de instrumentación

2. Jailbreak/Root Detection

Detecta dispositivos con jailbreak (iOS) o root (Android) que tienen privilegios elevados.

Qué protege: Evita que tu app se ejecute en dispositivos comprometidos donde existen herramientas avanzadas de hacking como Magisk, Xposed Framework, Cydia, Sileo, checkra1n, unc0ver.

Verificaciones incluidas:

  • Detección de archivos y rutas de jailbreak/root
  • Verificación de permisos del sistema de archivos
  • Detección de modificaciones del sistema
  • Identificación de hooks y frameworks de modificación
  • Detección de binarios sospechosos (su, busybox)

3. Clock Tampering Detection

Detecta manipulación del reloj del sistema.

Qué protege: Previene bypass de funcionalidades basadas en tiempo como trials, licencias temporales, ofertas limitadas, y validaciones de certificados.

Técnicas de detección:

  • Comparación de tiempo local vs tiempo de red
  • Detección de saltos temporales anormales
  • Verificación de sincronización NTP
  • Detección de cambios en zona horaria sospechosos

4. Virtual Machine Detection

Identifica si tu aplicación se está ejecutando en un entorno de máquina virtual.

Qué protege: Detecta entornos virtualizados como VMware, VirtualBox, Hyper-V, Parallels, QEMU, KVM donde los atacantes suelen realizar análisis de malware y reversing.

Verificaciones incluidas:

  • Detección de hardware virtualizado (CPU, chipset)
  • Identificación de drivers de VM
  • Verificación de características específicas de hypervisors
  • Detección de MAC addresses de VM
  • Análisis de BIOS/UEFI

5. Emulator Detection

Detecta si tu aplicación se ejecuta en un emulador en lugar de un dispositivo físico.

Qué protege: Previene la ejecución en emuladores como Android Emulator, Genymotion, iOS Simulator, BlueStacks, donde los atacantes pueden tener control total del entorno.

Verificaciones incluidas:

  • Detección de características de emulador (sensores, hardware)
  • Identificación de archivos y propiedades de sistema de emuladores
  • Análisis de comportamiento de dispositivo
  • Detección de build properties de emulador
  • Verificación de hardware falso

6. Memory Dump Detection

Detecta intentos de volcar la memoria de la aplicación.

Qué protege: Previene la extracción de datos sensibles de la memoria como tokens, claves de API, credenciales, secretos, y datos de sesión almacenados temporalmente.

Detecciones incluidas:

  • Herramientas de memory dumping (GameGuardian, Cheat Engine)
  • Procesos sospechosos accediendo a memoria
  • Intentos de lectura no autorizada
  • Detección de memory scanning tools

7. Tampering Detection

Detecta modificaciones no autorizadas en los archivos de la aplicación.

Qué protege: Identifica si el código, recursos, o configuración de tu aplicación han sido modificados, lo que podría indicar repacking, patching, o distribución no autorizada.

Verificaciones incluidas:

  • Validación de firma digital de la aplicación
  • Verificación de checksums de archivos críticos
  • Detección de modificaciones en el APK/IPA
  • Detección de instaladores no oficiales
  • Validación de integridad del código

8. Process Injection Detection

Detecta intentos de inyección de código en el proceso de tu aplicación.

Qué protege: Previene ataques donde código malicioso es inyectado en tu proceso para robar datos, modificar comportamiento, o bypassear protecciones.

Técnicas de detección:

  • Detección de DLL/library injection
  • Identificación de code injection
  • Detección de hooks maliciosos
  • Monitoreo de módulos cargados
  • Detección de ptrace attachments

9. Network Tampering Detection

Detecta manipulación de tráfico de red.

Qué protege: Identifica ataques Man-in-the-Middle (MITM), uso de proxies maliciosos, y manipulación de peticiones/respuestas HTTP/HTTPS.

Verificaciones incluidas:

  • Detección de certificados SSL/TLS no confiables
  • Identificación de proxies (Charles, Burp Suite, Fiddler)
  • Detección de VPNs sospechosas
  • Validación de certificate pinning
  • Detección de network interception tools

10. License Binding Detection

Valida que la licencia esté correctamente vinculada al dispositivo.

Qué protege: Previene que una licencia legítima sea usada en dispositivos no autorizados, evitando piratería y uso compartido de cuentas.

Validaciones incluidas:

  • Binding a hardware único (device fingerprint)
  • Validación de machine ID
  • Verificación de licencia en servidor
  • Detección de clonación de dispositivos
  • Límites de activaciones por licencia

11. Container Detection

Detecta si la aplicación se ejecuta dentro de un contenedor.

Qué protege: Identifica entornos containerizados como Docker, LXC, Kubernetes donde los atacantes pueden tener control avanzado del entorno de ejecución.

Técnicas de detección:

  • Detección de control groups (cgroups)
  • Identificación de namespaces de contenedor
  • Verificación de filesystem containers
  • Detección de Docker/containerd
  • Análisis de procesos init del contenedor

12. Remote Desktop Detection

Detecta conexiones de escritorio remoto activas.

Qué protege: Identifica si alguien está controlando el dispositivo remotamente, lo que podría indicar acceso no autorizado o análisis remoto.

Detecciones incluidas:

  • RDP (Remote Desktop Protocol)
  • VNC (Virtual Network Computing)
  • TeamViewer y AnyDesk
  • Apple Remote Desktop
  • Chrome Remote Desktop
  • Otras soluciones de acceso remoto

13. Cloud Metadata Detection

Detecta si la aplicación se ejecuta en infraestructura cloud.

Qué protege: Identifica ejecución en servicios cloud (AWS, Azure, GCP) donde los atacantes pueden usar recursos temporales para análisis sin dejar rastro.

Verificaciones incluidas:

  • Detección de metadata endpoints de AWS
  • Identificación de Azure Instance Metadata Service
  • Detección de Google Cloud metadata
  • Verificación de IPs cloud conocidas
  • Detección de hostnames cloud característicos

Protecciones Web Adicionales

Nota: ByteHide Monitor también incluye 9 protecciones adicionales para aplicaciones web que actúan como WAF (Web Application Firewall) integrado:

  • SQL Injection
  • Cross-Site Scripting (XSS)
  • Path Traversal
  • Command Injection
  • Server-Side Request Forgery (SSRF)
  • LDAP Injection
  • XML External Entity (XXE)
  • NoSQL Injection
  • LLM Prompt Injection

Estas protecciones web no están cubiertas en esta guía móvil. Consulta la documentación de Monitor Web para más detalles.

Monitor es un producto comercial de ByteHide. Visita https://bytehide.com para más información.