# Inspector de Certificados

> Una página de jmrp.io, publicada como markdown. Índice: https://jmrp.io/llms.txt

Canonical: https://jmrp.io/es/tools/cert-inspector/
Language: es
Alternate: https://jmrp.io/tools/cert-inspector/index.md
Updated: 2026-09-03
License: https://jmrp.io/es/license/
Category: security
Tags: ssl, tls, certificados, x509, pem, seguridad

Decodifica certificados SSL/TLS en formato PEM o descárgalos desde una URL en el navegador. Inspecciona sujeto, emisor, validez, SANs y seguridad.
Build-Date: 2026-09-06

Características:
- Decodifica PEM o descarga certificados por URL
- Inspecciona sujeto, emisor, validez y SANs
- Muestra clave, uso y extensiones
- Calcula la huella SHA-256 en el navegador
- Evaluación de seguridad de claves y algoritmos

Preguntas que responde:

**¿Se sube mi certificado a un servidor?**

No. Todo el análisis ASN.1/DER, el cálculo de la huella SHA-256 y la evaluación de seguridad se ejecutan completamente en tu navegador. Los datos PEM pegados nunca salen de tu dispositivo.

**¿Puedo inspeccionar un certificado privado o interno?**

Sí. Pega los datos codificados en PEM directamente en lugar de obtenerlos por URL. La obtención por URL depende de APIs públicas de logs de Certificate Transparency (certspotter, crt.sh) y solo funciona con certificados registrados públicamente.

**¿Qué comprueba la evaluación de seguridad?**

Evalúa la fortaleza de la clave, el algoritmo de firma, la duración de la validez y el cumplimiento de Certificate Transparency (SCT), señalando claves débiles, algoritmos obsoletos y periodos de validez demasiado largos.

**¿Qué es un Subject Alternative Name (SAN)?**

Un SAN enumera todos los nombres de host, IPs, correos o URIs para los que el certificado es válido. Los navegadores modernos ignoran el Common Name y comparan el host solicitado con las entradas SAN, por lo que un SAN ausente provoca errores de confianza.

**¿Cómo inspecciono un certificado sin esta herramienta?**

Usa OpenSSL desde la terminal, por ejemplo "openssl s_client -connect host:443" canalizado a "openssl x509 -noout -text". La referencia de comandos Linux de arriba incluye fragmentos listos para usar.


---

**Herramienta interactiva** — esta página contiene la aplicación en funcionamiento, no una descripción de ella.

## Acerca de esta herramienta

Inspecciona certificados SSL/TLS descargándolos desde una URL o pegando
datos codificados en PEM. La herramienta decodifica la estructura ASN.1 DER
completamente en tu navegador y proporciona un análisis exhaustivo que
incluye una evaluación de seguridad.

### ¿Qué información muestra?

- **Estado de validez** — válido, próximo a expirar o expirado, con días restantes
- **Sujeto y emisor** — nombres distinguidos con desglose de CN, O, C
- **Nombres Alternativos del Sujeto** (SAN) — todos los nombres DNS, IPs, correos, URIs
- **Clave pública** — algoritmo (RSA/EC/Ed25519), tamaño de clave, curva, algoritmo de firma
- **Uso de Clave y Uso Extendido de Clave** (Key Usage / EKU) — firma digital, autenticación de servidor/cliente
- **Acceso a Información de Autoridad** (AIA) — URLs de OCSP y CA Issuer
- **Certificate Transparency** — comprobación de presencia de SCT
- **Huella SHA-256** — calculada en el navegador mediante Web Crypto
- **Evaluación de seguridad** — fortaleza de clave, algoritmo de firma, duración de validez, cumplimiento de CT

### ¿Cómo se usa?

1. Introduce una URL y haz clic en **Obtener** para descargar el certificado, o pega datos PEM directamente
2. Haz clic en **Inspeccionar certificado** para decodificar y analizar
3. Revisa todos los detalles del certificado y los hallazgos de seguridad

### Privacidad

Todo el análisis y la decodificación del certificado ocurren completamente en tu navegador. Al obtener por URL, se utilizan APIs públicas de logs CT (certspotter, crt.sh) — sin proxy del lado del servidor. Para certificados privados o internos, usa la opción de pegar PEM o los comandos `openssl` que se muestran a continuación.

### Referencia de comandos Linux

Puedes inspeccionar certificados desde la terminal usando `openssl`:

#### Descargar y guardar certificado

```bash
echo | openssl s_client -connect jmrp.io:443 -servername jmrp.io 2>/dev/null | openssl x509 > cert.pem
```

**Salida — Guardado en cert.pem**

```text
(certificado guardado en cert.pem)
```

#### Resumen rápido del certificado

```bash
echo | openssl s_client -connect jmrp.io:443 -servername jmrp.io 2>/dev/null | openssl x509 -noout -subject -issuer -dates -fingerprint -sha256
```

**Salida — Resumen del certificado**

```text
subject=CN=jmrp.io
issuer=C=US, O=Let's Encrypt, CN=E7
notBefore=Jan 3 14:02:05 2026 GMT
notAfter=Apr 3 14:02:04 2026 GMT
sha256 Fingerprint=31:B2:A8:53:45:F8:CE:34:AE:20:FE:83:31:07:9C:5D:66:56:DB:29:...
```

#### Ver Subject Alternative Names

```bash
echo | openssl s_client -connect jmrp.io:443 -servername jmrp.io 2>/dev/null | openssl x509 -noout -ext subjectAltName
```

**Salida — SANs**

```text
X509v3 Subject Alternative Name:
    DNS:*.jmrp.io, DNS:jmrp.io
```

#### Detalles completos del certificado

```bash
echo | openssl s_client -connect jmrp.io:443 -servername jmrp.io 2>/dev/null | openssl x509 -noout -text | head -25
```

**Salida — Texto del certificado**

```text
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number:
            05:fc:45:dd:04:c9:dc:90:3a:35:bd:76:be:e2:1b:f7:e6:b6
    Signature Algorithm: ecdsa-with-SHA384
    Issuer: C=US, O=Let's Encrypt, CN=E7
    Validity
        Not Before: Jan 3 14:02:05 2026 GMT
        Not After : Apr 3 14:02:04 2026 GMT
    Subject: CN=jmrp.io
    Subject Public Key Info:
        Public Key Algorithm: id-ecPublicKey
            Public-Key: (256 bit)
            ASN1 OID: prime256v1
            NIST CURVE: P-256
```

#### Comprobar expiración (30 días)

```bash
# Comprobar si el certificado expira en 30 días (2592000 segundos)
echo | openssl s_client -connect jmrp.io:443 -servername jmrp.io 2>/dev/null | openssl x509 -noout -checkend 2592000

# Código de salida 0 = OK, 1 = expira pronto
```

**Salida — Comprobación de expiración**

```text
Certificate will not expire
```

#### Handshake TLS y cadena

```bash
echo | openssl s_client -connect jmrp.io:443 -servername jmrp.io 2>&1 | grep -E "Protocol|Cipher|Verify|depth"
```

**Salida — Detalles TLS**

```text
depth=2 C=US, O=Internet Security Research Group, CN=ISRG Root X1
depth=1 C=US, O=Let's Encrypt, CN=E7
depth=0 CN=jmrp.io
New, TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384
Protocol: TLSv1.3
Verify return code: 0 (ok)
```

#### Verificar cadena de certificados

```bash
# Verificar un certificado contra el paquete de CA del sistema
openssl verify cert.pem

# Verificar con cadena CA explícita
openssl verify -CAfile chain.pem cert.pem
```

**Salida — Verificación**

```text
cert.pem: OK
```

#### Monitorizar expiración (script cron)

```bash
# Añadir al crontab: comprobar diariamente, alertar si expira en 14 días
for domain in jmrp.io example.com; do
if ! echo | openssl s_client -connect "$domain:443" \
    -servername "$domain" 2>/dev/null | \
    openssl x509 -noout -checkend 1209600 2>/dev/null; then
    echo "AVISO: el certificado de $domain expira en 14 días"
fi
done
```

**Salida — Monitor de expiración**

```text
(sin salida = todos los certificados OK)
```

### Relacionado

Consulta [Asegurar Nginx con certificados de cliente](https://jmrp.io/es/blog/001-secure-nginx-client-certificates/) para una guía sobre autenticación TLS mutua.