Biometría y Face Morphing: La Nueva Frontera del Fraude

Publicado el 29 de mayo de 2025 - Equipo de Investigación DeepForgery

El morphing facial representa hoy una de las amenazas más sofisticadas contra los sistemas biométricos. Esta técnica, que consiste en fusionar sutilmente las características faciales de dos individuos, elude eficazmente los controles de identidad tradicionales y plantea desafíos inéditos a las tecnologías de seguridad. Análisis profundo de un fenómeno en plena expansión.

1. Comprender el Face Morphing

1.1. Definición y Principio Técnico

El face morphing o morphing facial es una técnica de manipulación de imagen que fusiona las características faciales de dos o más personas para crear una imagen compuesta. A diferencia de los deepfakes, el morphing produce una imagen que puede ser autenticada por los sistemas biométricos de varios individuos simultáneamente.

Proceso Técnico del Morphing

Paso 1: Detección de landmarks faciales (68-128 puntos)
Paso 2: Alineación geométrica de rostros
Paso 3: Fusión ponderada de texturas
Paso 4: Armonización de colores y luminosidad
Paso 5: Post-procesamiento para eliminar artefactos

1.2. Tipos de Morphing Facial

Morphing Lineal Simple

• Método: Interpolación directa entre dos rostros
• Complejidad: Baja
• Detectabilidad: Alta con herramientas apropiadas
• Uso: Ataques básicos en sistemas poco sofisticados

Morphing por Deep Learning

• Método: Redes neuronales generativas (GANs, VAEs)
• Complejidad: Muy alta
• Detectabilidad: Muy baja
• Uso: Elusión de sistemas biométricos avanzados

Morphing Diferencial

• Método: Optimización para engañar detectores específicos
• Complejidad: Extrema
• Detectabilidad: Casi imposible sin IA especializada
• Uso: Ataques dirigidos estado-nación

1.3. Casos de Uso Maliciosos

Fraude Documental

• Pasaportes: 67% de aumento de intentos en 2024
• Cédulas de identidad: Vulnerabilidad de sistemas nacionales
• Licencias de conducir: Elusión de controles viales

Suplantación de Identidad Digital

• Apertura de cuentas bancarias: Bypass de procesos KYC
• Acceso a servicios gubernamentales: Fraude en prestaciones

2. Análisis Técnico del Morphing

2.1. Algoritmos de Generación

Implementación con OpenCV

import cv2
import numpy as np
import dlib

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">class FaceMorpher:
    def init(self):
        self.detector = dlib.getfrontalfacedetector()
        self.predictor = dlib.shapepredictor("shapepredictor68facelandmarks.dat")</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def extractlandmarks(self, image):
        """Extrae landmarks faciales de una imagen"""
        gray = cv2.cvtColor(image, cv2.COLORBGR2GRAY)
        faces = self.detector(gray)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">if len(faces) == 0:
            return None</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">landmarks = self.predictor(gray, faces[0])
        points = []</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">for n in range(68):
            x = landmarks.part(n).x
            y = landmarks.part(n).y
            points.append([x, y])</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">return np.array(points, dtype=np.float32)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def morphfaces(self, img1, img2, alpha=0.5):
        """Realiza morphing entre dos rostros"""
        # Extracción de landmarks
        landmarks1 = self.extractlandmarks(img1)
        landmarks2 = self.extractlandmarks(img2)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">if landmarks1 is None or landmarks2 is None:
            return None</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Interpolación de landmarks
        morphedlandmarks = (1 - alpha)  landmarks1 + alpha  landmarks2</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Triangulación de Delaunay
        triangles = self.calculatedelaunaytriangles(morphedlandmarks)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Warping y blending
        morphedimage = self.warpandblend(
            img1, img2, landmarks1, landmarks2,
            morphedlandmarks, triangles, alpha
        )</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">return morphedimage</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def calculatedelaunaytriangles(self, landmarks):
        """Calcula triangulación de Delaunay para landmarks"""
        rect = cv2.boundingRect(landmarks)
        subdiv = cv2.Subdiv2D(rect)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">for point in landmarks:
            subdiv.insert(tuple(point))</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">triangles = subdiv.getTriangleList()
        return triangles

Morphing Avanzado con GANs

import torch
import torch.nn as nn
import torchvision.transforms as transforms

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">class StyleGANMorpher(nn.Module):
    def init(self, latentdim=512):
        super().init()
        self.generator = self.loadpretrainedstylegan()
        self.encoder = self.buildencoder()
        self.latentdim = latentdim</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def encodeface(self, faceimage):
        """Codifica un rostro en el espacio latente"""
        transform = transforms.Compose([
            transforms.Resize((256, 256)),
            transforms.ToTensor(),
            transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
        ])</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">facetensor = transform(faceimage).unsqueeze(0)
        latentcode = self.encoder(facetensor)
        return latentcode</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def morphinlatentspace(self, face1, face2, interpolationfactor=0.5):
        """Realiza morphing en el espacio latente de StyleGAN"""
        # Codificación de rostros
        latent1 = self.encodeface(face1)
        latent2 = self.encodeface(face2)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Interpolación en espacio latente
        morphedlatent = (1 - interpolationfactor)  latent1 + \
                        interpolationfactor  latent2</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Generación de imagen morpheada
        with torch.nograd():
            morphedimage = self.generator(morphedlatent)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">return morphedimage</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def adaptivemorphing(self, face1, face2, targetsystem):
        """Morphing adaptativo optimizado para sistema biométrico específico"""
        # Análisis del sistema objetivo
        systemvulnerabilities = self.analyzetargetsystem(targetsystem)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Optimización de parámetros de morphing
        optimalalpha = self.optimizemorphingparameters(
            face1, face2, systemvulnerabilities
        )</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Generación de imagen optimizada
        morphedimage = self.morphinlatentspace(face1, face2, optimalalpha)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">return morphedimage, optimalalpha

class MorphingDetector:
    def init(self):
        self.landmarkdetector = dlib.shapepredictor("shapepredictor68facelandmarks.dat")
        self.morphingclassifier = self.loadtrainedmodel()

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def detectmorphingartifacts(self, image):
        """Detecta artefactos de morphing en imagen"""
        landmarks = self.extractlandmarks(image)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Análisis de simetría facial
        symmetryscore = self.calculatefacialsymmetry(landmarks)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Análisis de proporciones faciales
        proportionanomalies = self.detectproportionanomalies(landmarks)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Análisis de texturas
        textureinconsistencies = self.analyzetextureconsistency(image, landmarks)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Puntuación final
        morphingprobability = self.calculatemorphingprobability(
            symmetryscore, proportionanomalies, textureinconsistencies
        )</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">return {
            'ismorphed': morphingprobability > 0.7,
            'confidence': morphingprobability,
            'artifacts': {
                'symmetry': symmetryscore,
                'proportions': proportionanomalies,
                'texture': textureinconsistencies
            }
        }</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def calculatefacialsymmetry(self, landmarks):
        """Calcula score de simetría facial"""
        # Puntos del lado izquierdo y derecho
        leftpoints = landmarks[0:17]  # Contorno izquierdo
        rightpoints = landmarks[17:27]  # Contorno derecho</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Cálculo de simetría
        centerx = np.mean(landmarks[:, 0])</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">leftdistances = []
        rightdistances = []</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">for i, leftpoint in enumerate(leftpoints):
            mirrorx = 2  centerx - leftpoint[0]</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Encuentra punto más cercano en lado derecho
            distances = np.sqrt(np.sum((rightpoints - [mirrorx, leftpoint[1]])2, axis=1))
            mindistance = np.min(distances)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">leftdistances.append(mindistance)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">symmetryscore = 1.0 - (np.mean(leftdistances) / 100.0)
        return max(0, min(1, symmetryscore))

class DeepMorphingDetector(nn.Module):
    def init(self):
        super().init()
        # Red convolucional para extracción de características
        self.featureextractor = nn.Sequential(
            nn.Conv2d(3, 64, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">nn.Conv2d(64, 128, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">nn.Conv2d(128, 256, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">nn.Conv2d(256, 512, 3, padding=1),
            nn.ReLU(),
            nn.AdaptiveAvgPool2d((1, 1))
        )</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Clasificador
        self.classifier = nn.Sequential(
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 1),
            nn.Sigmoid()
        )</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def forward(self, x):
        features = self.featureextractor(x)
        features = features.view(features.size(0), -1)
        output = self.classifier(features)
        return output

class BiometricSystemAnalyzer:
    def init(self):
        self.testmorphs = self.loadmorpheddataset()
        self.apis = {
            'amazonrekognition': AmazonRekognition(),
            'microsoftface': MicrosoftFaceAPI(),
            'googlevision': GoogleVisionAPI(),
            'faceplusplus': FacePlusPlusAPI()
        }</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def evaluateapivulnerability(self, apiname):
        """Evalúa vulnerabilidad de API específica"""
        api = self.apis[apiname]
        results = {
            'totaltests': len(self.testmorphs),
            'successfulattacks': 0,
            'falseacceptancerate': 0,
            'detailedresults': []
        }</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">for morphdata in self.testmorphs:
            original1 = morphdata['identity1']
            original2 = morphdata['identity2']
            morphedimage = morphdata['morphed']</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Test de reconnaissance avec identité 1
            match1 = api.comparefaces(morphedimage, original1)
            # Test de reconnaissance avec identité 2
            match2 = api.comparefaces(morphedimage, original2)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">if match1['ismatch'] and match2['ismatch']:
                results['successfulattacks'] += 1
                results['detailedresults'].append({
                    'morphid': morphdata['id'],
                    'confidence1': match1['confidence'],
                    'confidence2': match2['confidence'],
                    'attacksuccessful': True
                })</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">results['falseacceptancerate'] = \
            results['successfulattacks'] / results['totaltests']</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">return results

class DeepForgeryMorphDetector:
    def init(self):
        self.detectors = {
            'landmarkanalyzer': LandmarkAnalyzer(),
            'textureanalyzer': TextureConsistencyAnalyzer(),
            'deepdetector': DeepMorphingDetector(),
            'frequencyanalyzer': FrequencyDomainAnalyzer()
        }
        self.ensembleclassifier = EnsembleClassifier()

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def analyzeimage(self, imagepath):
        """Analyse complète d'une image pour détection morphing"""
        image = cv2.imread(imagepath)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">results = {}</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Analyse par tous les détecteurs
        for name, detector in self.detectors.items():
            result = detector.analyze(image)
            results[name] = result</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Fusion des résultats
        finaldecision = self.ensembleclassifier.predict(results)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">return {
            'ismorphed': finaldecision['ismorphed'],
            'confidence': finaldecision['confidence'],
            'individualscores': results,
            'risklevel': self.calculaterisklevel(finaldecision['confidence'])
        }</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def calculaterisklevel(self, confidence):
        """Calcule niveau de risque basé sur confidence"""
        if confidence > 0.9:
            return 'TRÈS ÉLEVÉ'
        elif confidence > 0.7:
            return 'ÉLEVÉ'
        elif confidence > 0.5:
            return 'MODÉRÉ'
        else:
            return 'FAIBLE'

import hashlib
from cryptography.fernet import Fernet

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">class SecureImageProcessor:
    def init(self):
        self.key = Fernet.generatekey()
        self.cipher = Fernet(self.key)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def createimagefingerprint(self, image):
        """Crée empreinte cryptographique de l'image"""
        # Extraction de caractéristiques robustes
        features = self.extractrobustfeatures(image)</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Hash cryptographique
        fingerprint = hashlib.sha256(features.tobytes()).hexdigest()</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">return fingerprint</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def verifyimageintegrity(self, image, storedfingerprint):
        """Vérifie intégrité de l'image"""
        currentfingerprint = self.createimagefingerprint(image)
        return currentfingerprint == storedfingerprint

Secteur bancaire : 2.8 milliards USD
Sécurité publique : 890 millions USD
Assurance : 1.2 milliards USD
E-commerce : 760 millions USD
Total estimé : 5.65 milliards USD

class DeepForgeryPlatform:
    def init(self):
        self.modules = {
            'morphingdetector': MorphingDetectionModule(),
            'livenesschecker': LivenessDetectionModule(),
            'qualityassessor': ImageQualityModule(),
            'blockchainverifier': BlockchainVerificationModule()
        }</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">def comprehensiveanalysis(self, biometricdata):
        """Analyse complète de données biométriques"""
        results = {}</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Détection morphing
        morphingresult = self.modules['morphingdetector'].analyze(
            biometricdata['image']
        )</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Vérification liveness
        livenessresult = self.modules['livenesschecker'].verify(
            biometricdata['videosequence']
        )</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Assessment qualité
        qualityresult = self.modules['qualityassessor'].evaluate(
            biometricdata['image']
        )</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed"># Vérification blockchain
        blockchainresult = self.modules['blockchainverifier'].validate(
            biometricdata['identityhash']
        )</p>

<p class="mb-4 text-gray-700 dark:text-gray-300 leading-relaxed">return {
            'overallscore': self.calculatetrustscore(
                morphingresult, livenessresult,
                qualityresult, blockchainresult
            ),
            'detailedanalysis': {
                'morphing': morphingresult,
                'liveness': livenessresult,
                'quality': qualityresult,
                'blockchain': blockchainresult
            }
        }

--- Tags:* biométrie, morphing facial, sécurité, fraude, reconnaissance faciale, intelligence artificielle