Validadores de posprocesamiento

El validador de certificados de comando externo permite validar la emisión en función de otros valores de certificado después de que el certificado (o eventual precertificado) se haya generado pero no emitido, almacenado ni publicado.

Tipos de validadores

Validador de certificados de comando externo

El Validador de Certificados de Comandos Externos permite llamar a un script externo para el certificado generado. El código de salida de la llamada externa determina si la validación ha fallado. Esto puede usarse no solo para validar los criterios del certificado, sino también para llamar a otros comandos o scripts externos. El usuario que ejecuta el servidor de aplicaciones EJBCA requiere los permisos del sistema de archivos del sistema operativo para hacerlo.

Para poder ver y editar el Validador de scripts externos, se debe habilitar el acceso a scripts externos activando Habilitar acceso a scripts externos en Configuración del sistema → Scripts externos .

El primer token del campo Comando externo debe ser el comando o script externo llamado, seguido de sus argumentos, separados por espacios. El certificado se almacena como un archivo temporal en el servidor EJBCA y su ruta completa se utiliza como primer argumento. Todos los argumentos posteriores se desplazan a la derecha. Si se utiliza el marcador de posición %cert% como argumento en cualquier posición, el certificado no se almacena en el sistema de archivos del servidor EJBCA. En su lugar, se elimina el marcador de posición y el certificado codificado en PEM se envía al comando o script externo mediante STDIN.

La plataforma para MS Windows y Unix/Linux se detecta automáticamente y se configuran el comando de shell y las opciones de shell predeterminados:

  • MS Windows: cmd.exe /C

  • Unix/Linux: /bin/sh -c

A continuación se muestran ejemplos de comandos externos para plataformas Unix/Linux:

$ /usr/local/opt/script .sh -param1 -param2
$ /usr/local/opt/script .sh -param1 -param2 %cert%
$ openssl x509 -text -noout - in %cert%

Listado de permisos de script

Un administrador puede restringir la ejecución de scripts por razones de seguridad configurando una lista de permitidos en la pestaña "Scripts externos" de la configuración del sistema. Esta lista debe contener las rutas de todos los scripts que el Validador de Certificados de Comandos Externos puede ejecutar. Si un administrador habilita la lista de permitidos, EJBCA impedirá la ejecución de scripts que no estén explícitamente incluidos en ella.

Si un administrador habilitó la Lista de permitidos de scripts externos y un validador intenta ejecutar un comando que no está en la lista de permitidos, se lleva a cabo la acción "El validador no era aplicable".

La lista de permitidos tiene el siguiente formato: cada línea contiene la ruta completa del script permitido. Las líneas que empiezan por el carácter # se consideran comentarios. La lista de permitidos puede contener cualquier número de scripts. Una lista de permitidos vacía (habilitada) bloqueará la ejecución de todos los scripts externos.

A continuación se muestra un ejemplo de una lista de permitidos sintácticamente válida:

 # ----------------------------------------------------------------------- # This is an example, this configuration does not necessarily make sense # ----------------------------------------------------------------------- /bin/echo # X.509 Certificate Linter by Amazon # https://github.com/awslabs/certlint /opt/certlint/certlint /opt/certlint/cablint # X.509 Certificate Linter based on CA/B Forum Baseline Requirements and RFC 5280 # https://github.com/zmap/zlint /opt/scripts/zLint.sh #/opt/scripts/IAmDisabled.sh

Esta lista de permitidos permite la ejecución de los scripts /opt/certlint/certlint , /opt/certlint/cablint y /opt/scripts/zLint.sh . No hay restricciones sobre los parámetros que se pueden introducir en estos scripts. La validación de la entrada debe realizarse en el propio script.

Ejemplo de certificado Lint

Puede utilizar el Validador de certificados de comando externo para ejecutar una verificación de pelusa en los certificados emitidos y cancelar la emisión si los certificados no pasan las pruebas.

Preparativos:

  1. Primero, para habilitar scripts externos, seleccione CA UI → Configuración del sistema → Scripts externos :

    • Para habilitar el acceso a scripts externos, seleccione Activar

    • En la lista de permitidos de Configurar scripts, seleccione " Usar la lista de permitidos a continuación" y especifique una ruta completa. Por ejemplo, /opt/bin/zlint.sh .

  2. Para agregar un Validador de Certificado de Comando Externo, vaya a Navegadores :

    • En Tipo de validador, seleccione Validador de certificado de comando externo .

    • En "Ruta completa del script" , agregue la ruta completa del script, terminada en %cert% . Por ejemplo, /opt/bin/zlint.sh %cert%.

    • Asegúrese de que al menos las opciones Error en código de error de script y Error de cierre de sesión estén seleccionadas.

  3. Para habilitar el validador para la CA, vaya a Autoridades de certificación, haga clic en Editar y seleccione el Validador para la CA.

Emita un certificado usando un perfil de certificado de servidor. Puede ver la activación del validador en el archivo server.log. Para comprobar si hay fallos, configure el uso de clave en "Inicio de sesión de certificado de clave" en el perfil de certificado utilizado para emitir el certificado de entidad final. Esta opción no está permitida en los requisitos básicos del foro CAB. Para obtener más información, consulte "Uso de clave en los campos del perfil de certificado" .

ZLint

ZLint es un depurador de certificados X.509 que se puede descargar y crear desde la página de inicio de ZLint .

Debe envolver zlint en un script zlint.sh para permitir que el script devuelva un código de salida 0 en caso de éxito y 1 como código de salida en caso de error.

Coloque el script zlint.sh en la misma ubicación que ZLint:

#!/bin/sh
mydir= "$(dirname " $(realpath "$0" ) ")"
OUTPUT=`$mydir/zlint -pretty <& 0 |grep - 1 '"error"' `
#echo Output:\"$OUTPUT\"
if [ -z "$OUTPUT" ]; then
echo "No error in zlint"
exit 0
else
echo "Error in zlint"
echo $OUTPUT >& 2
exit 1
fi

Pruebe emitiendo un certificado con y sin la opción Uso de clave establecida en Firma de certificado de clave y vea la salida del registro en server.log y en el registro de auditoría de seguridad.

X509Pelusa

X509Lint es un depurador de certificados escrito en C, disponible para descargar en GitHub .

X509Lint espera que la ruta a un certificado codificado en PEM se pase como primer argumento. Dado que EJBCA escribe un certificado codificado en DER en el disco, es necesario analizar el certificado en PEM antes de invocar el linter. También es necesario analizar la salida para garantizar que EJBCA no pueda emitirlo si se produce un error. El siguiente script de contenedor utiliza OpenSSL para convertir el certificado en PEM y redirige los mensajes de error a la salida de error estándar.

Script de envoltura para x509lint
#!/bin/sh
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# x509lint wrapper script for EJBCA.
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# INSTRUCTIONS: Put this script (x509lint.sh) together
# with the x509lint binary in the directory ${BIN} and
# create a new External Command Certificate Validator
# in EJBCA with the following settings:
# Full pathname of script: ${BIN}/x509lint.sh
# Fail on script error code: true
# Fail on output to error out: true
# Issuance phase should be "Pre-certificate Validation"
# if CT is being used, and "Certificate Validation"
# otherwise.
mydir=$( dirname "$(realpath " $0 ")" )
pem= "/dev/shm/OpenSSL-$(date +%s%N).pem"
openssl x509 - in "$1" -inform DER -out "$pem" -outform PEM
if ! output=`$mydir /x509lint "$pem" `; then
rm -f "$pem"
exit 1
fi
rm -f "$pem"
fatals=$( echo "$output" | grep 'F: ' )
errors=$( echo "$output" | grep 'E: ' )
warnings=$( echo "$output" | grep 'W: ' )
notices=$( echo "$output" | grep 'N: ' )
infos=$( echo "$output" | grep 'I: ' )
bugs=$( echo "$output" | grep 'B: ' )
if [ ! -z "$fatals" ]; then
>&2 echo "$fatals"
fi
if [ ! -z "$errors" ]; then
>&2 echo "$errors"
fi
if [ ! -z "$warnings" ]; then
echo "$warnings"
fi
if [ ! -z "$notices" ]; then
echo "$notices"
fi
if [ ! -z "$infos" ]; then
echo "$infos"
fi
if [ ! -z "$bugs" ]; then
echo "$bugs"
fi

Comprobaciones de claves débiles de Debian

Debido a un problema ( CVE-2008-0166 ) de 2006 en OpenSSL, donde una versión vulnerable de la biblioteca solo usaba el PID como semilla al generar claves RSA o DSA, un atacante puede encontrar la clave privada a partir de la clave pública correspondiente sin mayor esfuerzo. La versión defectuosa de OpenSSL se distribuyó en dos paquetes Debian entre el 17 de septiembre de 2006 y el 13 de mayo de 2008.

El proyecto Debian creó listas de bloqueo, que se pueden descargar desde:

Puede comprobar los certificados con estas listas de bloqueo antes de su emisión extrayendo todas las listas de bloqueo y utilizando un script simple para verificar la presencia de la clave en una de ellas.

Para comprobar los certificados con las listas de bloqueo, haga lo siguiente:

  1. Extraiga las listas de bloqueo de huellas dactilares en un solo directorio y cambie el nombre de los archivos de los paquetes para mantenerlos todos en un solo directorio en el servidor CA (el directorio /opt/weak-keys en el siguiente script de ejemplo):

    blacklist-openssh.DSA- 1024
    blacklist-openssh.DSA- 2048
    blacklist-openssh.RSA- 1024
    blacklist-openssh.RSA- 2048
    blacklist-openssh.RSA- 4096
    blacklist-openssl.RSA- 512
    blacklist-openssl.RSA- 1024
    blacklist-openssl.RSA- 2048
    blacklist-openssl.RSA- 4096
    blacklist-openvpn.RSA- 2048

  2. Agregue el siguiente script al directorio como /opt/weak-keys/weak-key-check.sh (el nombre y el parche se pueden cambiar editando el script para adaptarlo a su entorno).

    #!/bin/sh
    #echo $ 1
    OUTPUT=`grep $(openssl x509 -noout -pubkey -inform DER -in $ 1 \
    | openssl rsa -pubin -noout -modulus \
    | sha1sum | cut -d ' ' -f 1 | cut -c 21 -) \
    /opt/weak-keys/all-lists/blacklist*`
    if [ -z "$OUTPUT" ]; then
    echo "Key is not in block list"
    exit 0
    else
    echo "Key is in block list"
    echo $OUTPUT >& 2
    exit 1
    fi

  3. En el Validador de comandos externos, especifique lo siguiente:

    1. Ruta completa del script : /opt/weak-keys/weak-key-check.sh.

    2. Error en el código de error de script : verdadero.

    3. Error en la salida de error : verdadero.

    4. La fase de emisión debe ser una validación del certificado previa a la firma para garantizar que se realicen comprobaciones antes de utilizar la clave privada de la CA.

    5. Guardar el validador.

  4. No es fácil encontrar ejemplos de claves débiles sin generarlas usted mismo. Puede probar el script editando de nuevo el validador, cargando el siguiente certificado descargado de https://crt.sh/?id=2531502044 en la ruta de prueba del certificado y haciendo clic en "Probar comando" .

    -----BEGIN CERTIFICATE-----
    MIIFzDCCA7SgAwIBAgIQB66bp3FYMWG3OiIbZKgNPzANBgkqhkiG9w0BAQsFADBp
    MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hvdXN0b24x
    GDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjEeMBwGA1UEAwwVU1NMLmNvbSBSU0Eg
    U1NMIHN1YkNBMB4XDTIwMDMwNDAwMjczNVoXDTIwMDYwMjAwMjczNVowFzEVMBMG
    A1UEAwwMbGViZXJnZXIuYml6MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
    AQEA+TYH57WzTTfARNmo/Vx8/TGHD774iWbQoglRH+RGeFjgjoDGongoYr9jDwwX
    c1QxK36fojJ5zmDxIsvn/CsIRBj1aWCWvJons4LGfvEEmnZWuyhWleLKxmTvgbFb
    VMyLe+3fsuKjrktntuhpK75GXkpcErKS/3aGFY3UbMDp5qmGTZfZbXUAOTBq6Uvj
    6SyyeGrxrR+xRFAYCrB80ilLL2XlZ9hjqXge7qhhSxP5JYcVG4Fr8BvwhzoQ9zV1
    tdEuU6E+nZlvA6m4Qm4pQByCMMRH2BoqBL4n1aR1fNu+WdWHMC3uVmq2P5WZNsYK
    gdccVMmlHGVfRbhC1wuCty4QUwIDAQABo4IBwDCCAbwwHwYDVR0jBBgwFoAUJhR+
    4NzXpvfi1AQn32HxwuznMsowfAYIKwYBBQUHAQEEcDBuMEoGCCsGAQUFBzAChj5o
    dHRwOi8vd3d3LnNzbC5jb20vcmVwb3NpdG9yeS9TU0xjb20tU3ViQ0EtU1NMLVJT
    QS00MDk2LVIxLmNydDAgBggrBgEFBQcwAYYUaHR0cDovL29jc3BzLnNzbC5jb20w
    KQYDVR0RBCIwIIIMbGViZXJnZXIuYml6ghB3d3cubGViZXJnZXIuYml6MFEGA1Ud
    IARKMEgwCAYGZ4EMAQIBMDwGDCsGAQQBgqkwAQMBATAsMCoGCCsGAQUFBwIBFh5o
    dHRwczovL3d3dy5zc2wuY29tL3JlcG9zaXRvcnkwHQYDVR0lBBYwFAYIKwYBBQUH
    AwIGCCsGAQUFBwMBMDoGA1UdHwQzMDEwL6AtoCuGKWh0dHA6Ly9jcmxzLnNzbC5j
    b20vU1NMY29tUlNBU1NMc3ViQ0EuY3JsMB0GA1UdDgQWBBTCxWii5RK9474UxOJB
    wLerjO2QbTAOBgNVHQ8BAf8EBAMCBaAwEwYKKwYBBAHWeQIEAwEB/wQCBQAwDQYJ
    KoZIhvcNAQELBQADggIBAA+2tsRNgQIQMs93Q+NNCQgzj+9avNUbT8s1hZHBkoyf
    3zGgMRJgZkJ/xSEG/www/0SXKhhg8Bnp6r4PfpGn5t+T1XkZz8PhMvQlCT/zPBqC
    8W7voCSMdG0klWqz2hBJ3lNzEmHLKrkp63SM17xE8rGDd0oMfjKwxZKwb7z40jrA
    isEUWNq6FzSPiNllNJq7IbOffEuR0/oz21a3vruPJGB0opWYPBqQcLzemnEXDPEZ
    R2NzfSZB5UzZfAtGLbjxYoMXK+7JLoQjsPpQWlJqGjVaHd9K+Lthg1THwYtdMekK
    Flobw8WirkmuKBZEmo8x6nobfFh2VaBOjA8AXRr6jEO3EjwKvCHDm32td9SkDXe7
    tP4IO/gJma4dxWKV1Hyu/ 1 /6qPUVn55XCCAiuyZcDo3A0t0nSIR8iGbyBtQb0OJH
    SzOyGFJ2SLM8lmyl3eJzXc5YLcJso4S2ZVgZQ9KVApitjvlBvgL7BPskNZxI/c0T
    ISPlOeYtD0O/rxQuQakWOqal9hk+l4Rrd7O+UguXijB92h/40AfLsaLUCRxBZgXA
    tSMLQNleqFMpxIwA93Ybm+iT3FmBqqDNZ2cJ77NTVL3sKeF77b0Xdppn+93Rz51z
    K9UmDRX973f9qi9p/1PbofcOBKZnMaFp7O7kXfdBRaXzslhSLDE2/X+Kx7SVe0GV
    -----END CERTIFICATE-----

  5. El resultado debería indicar " Probar salida : Código de salida: 1STDOUT: La clave está en la lista de bloqueos. ERROUT:(nombre de la lista de bloqueos y huella digital coincidente)". Al cargar otro certificado que no esté en la lista de bloqueos, el código de salida debería ser 0.
    A continuación se muestra un ejemplo de configuración.

imágenes/descargar/archivos adjuntos/100276028/claves-débiles.png
Validador de comandos externo para comprobar claves débiles