Testing de Certificate Pinning en Aplicaciones Móviles: Validación SSL/TLS, Protección MITM y Rotación de Pins

Testing de Certificate Pinning en Aplicaciones Móviles: Validación SSL/TLS, Protección MITM y Rotación de Pins es una disciplina crítica en el aseguramiento de calidad de software moderno. According to IBM’s Cost of a Data Breach Report 2024, the global average cost of a data breach reached $4.88 million (IBM Cost of a Data Breach 2024). According to OWASP, injection vulnerabilities and broken authentication remain in the top 10 web application security risks (OWASP Top 10). Esta guía cubre enfoques prácticos que los equipos de QA pueden aplicar de inmediato: desde conceptos básicos y herramientas hasta patrones de implementación del mundo real. Ya sea que estés desarrollando habilidades en esta área o mejorando un proceso existente, encontrarás técnicas accionables respaldadas por experiencia de la industria. El objetivo no es solo la comprensión teórica, sino un framework funcional que puedas adaptar al contexto de tu equipo, stack tecnológico y objetivos de calidad.

TL;DR

• El testing de seguridad pertenece al sprint, no al final del ciclo de release
• Usa SAST para detección temprana y DAST para descubrimiento de vulnerabilidades en tiempo de ejecución
• El OWASP Top 10 cubre los riesgos más críticos que cada equipo de aplicaciones web debe abordar

Ideal para: Equipos construyendo aplicaciones orientadas al cliente o que manejan datos Omitir si: Herramientas puramente internas sin datos sensibles ni acceso externo

Android Certificate Pinning #

OkHttp CertificatePinner #

import okhttp3.CertificatePinner

val certificatePinner = CertificatePinner.Builder()
    .add("api.example.com", "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=")
    .add("api.example.com", "sha256/BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB=") // Backup pin
    .build()

val client = OkHttpClient.Builder()
    .certificatePinner(certificatePinner)
    .build()

Generando Pins de Certificados #

# Extraer certificado del servidor
openssl s_client -connect api.example.com:443 -servername api.example.com < /dev/null \
    | openssl x509 -outform DER > cert.der

# Generar hash SHA-256
openssl x509 -in cert.der -inform DER -pubkey -noout \
    | openssl pkey -pubin -outform DER \
    | openssl dgst -sha256 -binary \
    | base64

Testing Certificate Pinning #

class CertificatePinningTest {

    @Test
    fun testValidCertificate() = runTest {
        val client = createClientWithPinning()

        val response = client.newCall(
            Request.Builder()
                .url("https://api.example.com/users")
                .build()
        ).execute()

        assertTrue(response.isSuccessful)
    }

    @Test
    fun testInvalidCertificate() = runTest {
        val client = createClientWithPinning()

        assertThrows<SSLPeerUnverifiedException> {
            client.newCall(
                Request.Builder()
                    .url("https://evil.example.com/users")
                    .build()
            ).execute()
        }
    }

    @Test
    fun testMITMAttempt() = runTest {
        val proxyClient = OkHttpClient.Builder()
            .proxy(Proxy(Proxy.Type.HTTP, InetSocketAddress("localhost", 8888)))
            .certificatePinner(certificatePinner)
            .build()

        assertThrows<SSLHandshakeException> {
            proxyClient.newCall(
                Request.Builder()
                    .url("https://api.example.com/users")
                    .build()
            ).execute()
        }
    }
}

«El testing de seguridad pertenece al sprint, no al final del ciclo de release. Una vulnerabilidad encontrada por tu equipo durante el desarrollo cuesta 10 veces menos de corregir que una encontrada por un pentester antes del lanzamiento.» — Yuri Kan, Senior QA Lead

Public Key Pinning #

class PublicKeyPinning : CertificatePinner {
    private val pinnedPublicKeys = setOf(
        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
        "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB="
    )

    override fun check(hostname: String, peerCertificates: List<Certificate>) {
        val publicKeyHashes = peerCertificates.map { cert ->
            sha256(cert.publicKey.encoded).base64()
        }

        if (publicKeyHashes.none { it in pinnedPublicKeys }) {
            throw SSLPeerUnverifiedException("Certificate pinning failure!")
        }
    }
}

Estrategia de Rotación de Pins #

Pins de Respaldo #

val certificatePinner = CertificatePinner.Builder()
    .add("api.example.com",
        "sha256/PRIMARY_PIN_HASH")
    .add("api.example.com",
        "sha256/BACKUP_PIN_HASH_1")
    .add("api.example.com",
        "sha256/BACKUP_PIN_HASH_2")
    .build()

Configuración Remota de Pins #

class DynamicPinningManager(
    private val configService: ConfigService,
    private val secureStorage: SecureStorage
) {
    suspend fun updatePins() {
        val newPins = configService.getCertificatePins()

        if (validatePins(newPins)) {
            secureStorage.savePins(newPins)
        }
    }
}

@Test
fun testPinRotation() = runTest {
    val manager = DynamicPinningManager(mockConfigService, storage)

    mockConfigService.respondWith(mapOf(
        "api.example.com" to setOf("OLD_PIN", "NEW_PIN")
    ))

    manager.updatePins()

    val client = manager.createClient()
    assertTrue(client.certificatePinner.pins.size == 2)
}

Testing de Detección MITM #

La detección MITM es crítica para la seguridad móvil. Aprende técnicas avanzadas de testing de seguridad en nuestra guía de Fundamentos de Penetration Testing.

Detección de Bypass #

class SecurityChecker {
    fun detectRootAndBypassTools(): SecurityStatus {
        val issues = mutableListOf<String>()

        if (isDeviceRooted()) {
            issues.add("Dispositivo rooteado")
        }

        if (isFridaRunning()) {
            issues.add("Frida detectado")
        }

        return if (issues.isEmpty()) {
            SecurityStatus.Secure
        } else {
            SecurityStatus.Compromised(issues)
        }
    }
}

Mejores Prácticas #

1. Siempre usa pins de respaldo - Incluye 2-3 pins para rotación
2. Pin a claves públicas, no certificados - Más flexible para rotación
3. Monitorea expiración de pins - Configura alertas antes de que expiren
4. Prueba pinning en CI/CD - Detecta mala configuración temprano
5. Implementa actualizaciones remotas - Para rotación de emergencia
6. Combina con otras medidas de seguridad - Detección root, validación SSL

El certificate pinning funciona mejor cuando se combina con testing de OAuth 2.0 y JWT para seguridad completa de autenticación. Para ingenieros QA que buscan expandir conocimientos de seguridad, consulta Testing de Seguridad para QA.

Conclusión #

El testing de certificate pinning asegura:

• Prevención de ataques MITM
• Validación apropiada SSL/TLS
• Rotación graceful de pins
• Detección de intentos de bypass

El certificate pinning correctamente implementado y probado mejora significativamente la seguridad de apps móviles.

Ver También #

• Testing de Seguridad Móvil - Fundamentos completos de seguridad para aplicaciones iOS y Android
• Testing de Seguridad de APIs - Técnicas de testing para APIs REST y GraphQL con enfoque en seguridad
• Documentación de Pruebas de Seguridad - Mejores prácticas para documentar hallazgos de seguridad
• Testing Continuo en DevOps - Automatización de pruebas de seguridad en pipelines CI/CD
• Jenkins Pipeline para Automatización de Pruebas - Configuración de pipelines para testing automatizado

Recursos Oficiales #

• REST API Tutorial
• HTTP Specification
• OWASP Testing Guide

FAQ #

¿Cuál es la diferencia entre SAST y DAST? SAST (Análisis Estático) escanea el código fuente sin ejecutarlo, encontrando problemas temprano. DAST (Análisis Dinámico) prueba aplicaciones en ejecución, encontrando vulnerabilidades en tiempo de ejecución.

¿Cuándo debe realizarse el testing de seguridad? El testing de seguridad debe comenzar en la fase de diseño con modelado de amenazas, continuar con SAST durante el desarrollo y concluir con DAST y penetration testing antes de cada release.

¿Cuáles son las vulnerabilidades más comunes en aplicaciones web? El OWASP Top 10 cubre los riesgos más críticos: inyección, autenticación rota, exposición de datos sensibles, configuración incorrecta de seguridad, XSS y deserialización insegura.

¿Cómo se prueba la inyección SQL? Usa escáneres automáticos para el descubrimiento inicial, luego verifica manualmente condiciones límite, caracteres especiales y patrones de inyección ciega basada en tiempo en todos los campos de entrada.