DEV Community

Antonio Jose Socorro Marin
Antonio Jose Socorro Marin

Posted on

Autenticación y verificación de identidad (Captura, contenedor, firma y primer flujo de personalización)

#architecture #cybersecurity #security

Resumen ejecutivo

Este primer módulo define el flujo de enrolamiento y el formato del contenedor inteligente que almacena datos demográficos y biométricos (huellas, rostro, iris), los protege criptográficamente y produce artefactos verificables que pueden: (a) almacenarse en una smart card; (b) firmarse con claves gestionadas por HSM/PKCS#11; y (c) usarse como base para generar identidades derivadas exportables de forma segura. Las decisiones criptográficas y de formato se alinean con los requisitos de los principales estándares internacionales de identidad y biometría.

  1. Requisitos técnicos

Algoritmos y tamaños: para firmas y certificados se recomienda ECDSA P-256 y SHA-256, garantizando compatibilidad y longevidad.

Objetos firmados y OIDs: los datos críticos deben encapsularse y firmarse en CMS, manteniendo trazabilidad y verificabilidad a futuro.

Integración con CMS/IDMS: la cadena de gestión de identidad requiere interacción segura entre el sistema de gestión de identidad (IDMS), el sistema de gestión de tarjetas (CMS) y los módulos criptográficos (HSM).

  1. Datos a capturar

Demográficos:

Nombre completo

Número de identificación único

Nacionalidad

Dirección postal

Teléfono

Biométricos:

Huellas dactilares: al menos dos obligatorias, con opción de captura decadactilar completa

Imagen facial electrónica de acuerdo a normas internacionales

Imagen de iris izquierdo y derecho

Metadatos de captura: dispositivo, operador, calidad, fecha y hora

  1. Modelo lógico del contenedor inteligente

El contenedor de identidad debe estructurarse con secciones bien definidas:

{
"header": {
"uuid": "",
"enrolment_time": "",
"issuer": "",
"version": "1.0"
},
"demographics": { ... },
"biometrics": {
"fingerprints": [ ... ],
"face": { ... },
"iris": [ ... ]
},
"keys_and_certs": { ... },
"pin_policy": { ... },
"audit": [ ... ],
"integrity": {
"hash": "",
"signed_object": ""
}
}

  1. Flujo de enrolamiento

Paso 0 — Preparación: definir políticas, reglas de retención, límites de PIN/PUK y configurar el HSM/CA.
Paso 1 — Verificación de identidad física: recolectar documentos probatorios, registrar y almacenar solo referencias seguras.
Paso 2 — Captura biométrica: obtener huellas, rostro e iris conforme normas ISO, registrar calidad y repetir si no cumple umbral.
Paso 3 — Generación de claves: preferiblemente en HSM o en la tarjeta; emitir certificados X.509 asociados.
Paso 4 — Construcción del contenedor: serializar en formato canónico, calcular hash SHA3-256.
Paso 5 — Firma del contenedor: aplicar firma digital ECDSA-P256 con encapsulado CMS.
Paso 6 — Personalización de tarjeta: escribir objetos mediante canal seguro GlobalPlatform, almacenar certificados y claves.
Paso 7 — Provisioning de PIN/PUK/TOTP: establecer PIN estático verificado en tarjeta, opcional TOTP y política de reintentos.
Paso 8 — Entrega y auditoría: registrar la entrega, guardar hash y firma del contenedor en repositorio seguro.

  1. Diseño criptográfico

Uso de ECDSA P-256 y SHA-256 para firmas de contenedores.

Firmado de objetos críticos como biometría y datos de identidad.

Custodia de claves y secretos en HSM o módulos PKCS#11.

Canal seguro para comunicación IDMS ↔ CMS ↔ tarjeta.

  1. Código: creación del contenedor y firma # create_and_sign_container.py # Autor: Antonio José Socorro Marín © 2025

import json
import base64
from datetime import datetime
import hashlib
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import ec

def canonical_json_bytes(obj):
return json.dumps(obj, sort_keys=True, separators=(',',':'), ensure_ascii=False).encode('utf-8')

def sha3_256_hex(data_bytes):
h = hashlib.sha3_256()
h.update(data_bytes)
return h.hexdigest()

def generate_demo_ecdsa_key():
private_key = ec.generate_private_key(ec.SECP256R1())
public_key = private_key.public_key()
return private_key, public_key

def sign_bytes_ecdsa_sha256(private_key, data_bytes):
signature_der = private_key.sign(data_bytes, ec.ECDSA(hashes.SHA256()))
return base64.b64encode(signature_der).decode('ascii')

def build_container(demo_identity):
header = {
"uuid": demo_identity.get("uuid"),
"enrolment_time": datetime.utcnow().isoformat() + "Z",
"issuer": "Authority CN=IDIssuer",
"version": "1.0"
}
container = {
"header": header,
"demographics": demo_identity.get("demographics"),
"biometrics": demo_identity.get("biometrics"),
"keys_and_certs": demo_identity.get("keys_and_certs", {}),
"pin_policy": demo_identity.get("pin_policy", {}),
"audit": demo_identity.get("audit", [])
}
return container

if name == "main":
demo_identity = {
"uuid": "b7f6a2d6-3f7a-4a8f-ab12-0f4e6b1a9c2d",
"demographics": {
"given_name": "Juan",
"family_name": "Pérez",
"id_number": "ID12345678",
"nationality": "VEN",
"address": "Caracas, Venezuela",
"phone": "+58-412-1234567"
},
"biometrics": {
"fingerprints": [
{ "type":"ISO19794-2", "template":"", "quality":98 },
{ "type":"ISO19794-2", "template":"", "quality":96 }
],
"face": { "format":"ISO19794-5", "image":"", "quality":92 },
"iris": [
{ "format":"ISO19794-6","template":"" },
{ "format":"ISO19794-6","template":"" }
]
},
"pin_policy": {
"static_pin_length": 6,
"otp_enabled": True,
"puk_present": True
},
"audit": []
}

container = build_container(demo_identity)
canonical = canonical_json_bytes(container)
container_hash = sha3_256_hex(canonical)
container["integrity"] = { "hash": container_hash, "hash_alg": "SHA3-256" }

priv, pub = generate_demo_ecdsa_key()
signature_b64 = sign_bytes_ecdsa_sha256(priv, canonical)
container["integrity"]["signed"] = { "alg": "ECDSA-P256-SHA256", "signature_b64": signature_b64, "signer": "CN=IDIssuer" }

print(json.dumps(container, indent=2, ensure_ascii=False))
Enter fullscreen mode Exit fullscreen mode
  1. PIN dinámico y multifactor

El sistema debe contemplar:

PIN estático: verificado en la tarjeta, longitud mínima 6 dígitos, límite de reintentos, bloqueo y PUK.

PIN dinámico (OTP): implementación TOTP de 6 dígitos con ventana temporal de ±30 s.

PIN derivado de biometría: cálculo de un PIN numérico usando HMAC-SHA256 sobre la plantilla biométrica y un nonce, sin exponer datos biométricos en claro.

Código: derivación de PIN biométrico

biometric_derived_pin.py

Autor: Antonio José Socorro Marín © 2025

import hmac, hashlib, binascii

def derive_pin_from_biometric(template_hash_hex, secret_hmac_key, nonce_int, digits=6):
template_bytes = binascii.unhexlify(template_hash_hex)
nonce_bytes = nonce_int.to_bytes(8, 'big')
mac = hmac.new(secret_hmac_key, template_bytes + nonce_bytes, hashlib.sha256).digest()
code_int = int.from_bytes(mac[-4:], 'big') & 0x7FFFFFFF
pin = str(code_int % (10 ** digits)).zfill(digits)
return pin

  1. Auditoría y verificación futura

Cada contenedor debe incluir hash SHA3-256 y firma ECDSA-P256.

Mantener registros de enrolamiento, captura y personalización en repositorios de evidencia sellados.

Implementar trazabilidad completa para futuras verificaciones y auditorías.

  1. Recomendaciones operativas

Ejecutar todas las operaciones críticas (firma, custodia de secretos) en HSM.

Alinear formatos de datos biométricos con estándares ISO/IEC 19794.

Separar roles: enrolamiento, gestión de PKI y personalización deben estar segregados.

Aplicar políticas de privacidad desde el diseño, almacenando solo lo necesario y cifrando datos sensibles.

Definir métricas y realizar pruebas de calidad y verificación periódicas.

  1. Conclusión

Este primer módulo establece la base para la creación de un contenedor de identidad seguro, firmado y verificable, capaz de almacenar datos demográficos y biométricos de acuerdo con estándares internacionales. Sobre este diseño se podrán construir las fases posteriores del sistema, incluyendo la generación de identidades derivadas exportables y verificables de manera segura en cualquier infraestructura compatible

Top comments (0)