CHAPTER 06

Deepfake Detection Methods

Deploy machine learning models and forensic analysis to detect synthetic media

The Deepfake Challenge

Deepfakes use generative AI to create synthetic media that is increasingly difficult to distinguish from authentic content. Detection requires sophisticated analysis across multiple modalities and scales.

Types of Synthetic Media

Face Swapping: Replacing one person's face with another's
Face Reenactment: Manipulating facial expressions and movements
Voice Cloning: Synthesizing speech in someone's voice
Full Synthesis: Generating entirely fictional people or scenes
Lip Syncing: Modifying mouth movements to match audio

CNN-Based Detection

Convolutional Neural Networks learn to identify subtle artifacts in synthetic images:

// Example: CNN Deepfake Detector with TensorFlow.js
import * as tf from '@tensorflow/tfjs-node';

class CNNDeepfakeDetector {
    constructor() {
        this.model = this.buildModel();
    }

    buildModel() {
        const model = tf.sequential();

        // Feature extraction layers
        model.add(tf.layers.conv2d({
            inputShape: [224, 224, 3],
            filters: 32,
            kernelSize: 3,
            activation: 'relu'
        }));
        model.add(tf.layers.maxPooling2d({ poolSize: 2 }));
        model.add(tf.layers.dropout({ rate: 0.25 }));

        model.add(tf.layers.conv2d({ filters: 64, kernelSize: 3, activation: 'relu' }));
        model.add(tf.layers.maxPooling2d({ poolSize: 2 }));
        model.add(tf.layers.dropout({ rate: 0.25 }));

        model.add(tf.layers.conv2d({ filters: 128, kernelSize: 3, activation: 'relu' }));
        model.add(tf.layers.maxPooling2d({ poolSize: 2 }));
        model.add(tf.layers.dropout({ rate: 0.25 }));

        // Dense layers
        model.add(tf.layers.flatten());
        model.add(tf.layers.dense({ units: 256, activation: 'relu' }));
        model.add(tf.layers.dropout({ rate: 0.5 }));

        // Output layer (binary classification)
        model.add(tf.layers.dense({
            units: 1,
            activation: 'sigmoid'
        }));

        model.compile({
            optimizer: 'adam',
            loss: 'binaryCrossentropy',
            metrics: ['accuracy']
        });

        return model;
    }

    async detect(imageTensor) {
        // Preprocess image
        const normalized = imageTensor.div(255.0);
        const resized = tf.image.resizeBilinear(normalized, [224, 224]);
        const batched = resized.expandDims(0);

        // Get prediction
        const prediction = this.model.predict(batched);
        const score = await prediction.data();

        const result = {
            is_deepfake: score[0] > 0.5,
            confidence: Math.abs(score[0] - 0.5) * 2, // 0 to 1
            score: score[0],
            method: 'CNN Binary Classifier'
        };

        // Cleanup tensors
        batched.dispose();
        resized.dispose();
        normalized.dispose();
        prediction.dispose();

        return result;
    }

    async analyzeAttentionMap(imageTensor) {
        // Generate attention map showing suspicious regions
        const features = this.extractFeatures(imageTensor);
        const attention = this.computeGradCAM(features);

        return attention;
    }

    extractFeatures(imageTensor) {
        // Extract intermediate layer activations
        const featureModel = tf.model({
            inputs: this.model.input,
            outputs: this.model.getLayer('conv2d_2').output
        });

        return featureModel.predict(imageTensor);
    }
}

// Usage
const detector = new CNNDeepfakeDetector();
const result = await detector.detect(imageTensor);

console.log('Deepfake detected:', result.is_deepfake);
console.log('Confidence:', (result.confidence * 100).toFixed(1) + '%');

Transformer-Based Detection

Vision Transformers excel at capturing long-range dependencies and global inconsistencies:

// Example: Vision Transformer for Deepfake Detection
class ViTDeepfakeDetector {
    constructor(patchSize = 16, numLayers = 12) {
        this.patchSize = patchSize;
        this.numLayers = numLayers;
        this.model = this.buildTransformer();
    }

    buildTransformer() {
        // Simplified ViT architecture
        const input = tf.input({ shape: [224, 224, 3] });

        // Patch embedding
        const patches = this.patchify(input);
        const embedded = tf.layers.dense({
            units: 768,
            name: 'patch_embedding'
        }).apply(patches);

        // Positional encoding
        const positioned = this.addPositionalEncoding(embedded);

        // Transformer encoder blocks
        let x = positioned;
        for (let i = 0; i < this.numLayers; i++) {
            x = this.transformerBlock(x, i);
        }

        // Classification head
        const pooled = tf.layers.globalAveragePooling1d().apply(x);
        const output = tf.layers.dense({
            units: 1,
            activation: 'sigmoid',
            name: 'classification'
        }).apply(pooled);

        return tf.model({ inputs: input, outputs: output });
    }

    transformerBlock(x, blockId) {
        // Multi-head self-attention
        const attention = tf.layers.multiHeadAttention({
            numHeads: 12,
            keyDim: 64,
            name: `attention_${blockId}`
        }).apply(x, x);

        // Add & Norm
        const normed1 = tf.layers.layerNormalization({
            name: `norm1_${blockId}`
        }).apply(tf.layers.add().apply([x, attention]));

        // Feed-forward network
        const ff1 = tf.layers.dense({
            units: 3072,
            activation: 'gelu',
            name: `ff1_${blockId}`
        }).apply(normed1);

        const ff2 = tf.layers.dense({
            units: 768,
            name: `ff2_${blockId}`
        }).apply(ff1);

        // Add & Norm
        const output = tf.layers.layerNormalization({
            name: `norm2_${blockId}`
        }).apply(tf.layers.add().apply([normed1, ff2]));

        return output;
    }

    async detectWithExplanation(imageTensor) {
        const prediction = await this.model.predict(imageTensor);
        const score = await prediction.data();

        // Extract attention maps for explanation
        const attentionMaps = await this.extractAttentionMaps(imageTensor);

        return {
            is_deepfake: score[0] > 0.5,
            confidence: Math.abs(score[0] - 0.5) * 2,
            attention_maps: attentionMaps,
            suspicious_patches: this.identifySuspiciousPatches(attentionMaps)
        };
    }
}

Forensic Analysis

Traditional forensic techniques detect inconsistencies that betray manipulation:

Error Level Analysis (ELA)

// Example: Error Level Analysis
async function errorLevelAnalysis(imagePath) {
    const original = await Jimp.read(imagePath);

    // Save at specific JPEG quality
    const tempPath = '/tmp/ela_temp.jpg';
    await original.quality(95).writeAsync(tempPath);

    // Reload compressed version
    const compressed = await Jimp.read(tempPath);

    // Compute pixel-wise difference
    const ela = new Jimp(original.bitmap.width, original.bitmap.height);

    original.scan(0, 0, original.bitmap.width, original.bitmap.height, (x, y, idx) => {
        const origR = original.bitmap.data[idx];
        const compR = compressed.bitmap.data[idx];

        const diff = Math.abs(origR - compR);
        const amplified = Math.min(255, diff * 10); // Amplify differences

        ela.bitmap.data[idx] = amplified;
        ela.bitmap.data[idx + 1] = amplified;
        ela.bitmap.data[idx + 2] = amplified;
        ela.bitmap.data[idx + 3] = 255;
    });

    return {
        ela_image: ela,
        anomaly_score: computeAnomalyScore(ela),
        suspicious_regions: detectSuspiciousRegions(ela)
    };
}

function computeAnomalyScore(elaImage) {
    let totalDiff = 0;
    let pixelCount = 0;

    elaImage.scan(0, 0, elaImage.bitmap.width, elaImage.bitmap.height, (x, y, idx) => {
        totalDiff += elaImage.bitmap.data[idx];
        pixelCount++;
    });

    return totalDiff / pixelCount / 255;
}

Noise Analysis

Different cameras produce different noise patterns. Inconsistent noise suggests manipulation:

// Example: Camera Noise Pattern Analysis
class NoiseAnalyzer {
    async analyzeNoise(imagePath) {
        const image = await Jimp.read(imagePath);

        // Extract noise using wavelet denoising
        const noise = await this.extractNoise(image);

        // Compute noise characteristics
        const stats = this.computeNoiseStatistics(noise);

        // Check for inconsistencies
        const inconsistencies = this.detectInconsistencies(noise, stats);

        return {
            noise_level: stats.stdDev,
            noise_pattern: stats.pattern,
            inconsistent_regions: inconsistencies,
            tampering_likelihood: inconsistencies.length > 0 ? 'HIGH' : 'LOW'
        };
    }

    async extractNoise(image) {
        // Apply median filter to estimate image without noise
        const denoised = this.medianFilter(image, 3);

        // Subtract to get noise
        const noise = new Jimp(image.bitmap.width, image.bitmap.height);

        image.scan(0, 0, image.bitmap.width, image.bitmap.height, (x, y, idx) => {
            const diff = image.bitmap.data[idx] - denoised.bitmap.data[idx];
            noise.bitmap.data[idx] = 128 + diff; // Center around 128
            noise.bitmap.data[idx + 3] = 255;
        });

        return noise;
    }

    detectInconsistencies(noise, globalStats) {
        const blockSize = 32;
        const inconsistencies = [];

        // Divide into blocks and check local statistics
        for (let y = 0; y < noise.bitmap.height; y += blockSize) {
            for (let x = 0; x < noise.bitmap.width; x += blockSize) {
                const blockStats = this.computeBlockStatistics(noise, x, y, blockSize);

                // Check if block statistics deviate significantly
                if (Math.abs(blockStats.stdDev - globalStats.stdDev) / globalStats.stdDev > 0.3) {
                    inconsistencies.push({
                        x, y,
                        width: blockSize,
                        height: blockSize,
                        deviation: Math.abs(blockStats.stdDev - globalStats.stdDev)
                    });
                }
            }
        }

        return inconsistencies;
    }
}

Multi-Modal Detection

Analyzing multiple modalities improves detection accuracy:

// Example: Multi-Modal Deepfake Detector
class MultiModalDetector {
    constructor() {
        this.visualDetector = new CNNDeepfakeDetector();
        this.audioDetector = new AudioDeepfakeDetector();
        this.syncDetector = new LipSyncDetector();
    }

    async analyzeVideo(videoPath) {
        // Extract frames and audio
        const frames = await extractFrames(videoPath);
        const audio = await extractAudio(videoPath);

        // Visual analysis
        const visualResults = [];
        for (const frame of frames.slice(0, 10)) { // Sample frames
            const result = await this.visualDetector.detect(frame);
            visualResults.push(result.score);
        }
        const visualScore = average(visualResults);

        // Audio analysis
        const audioResult = await this.audioDetector.analyze(audio);
        const audioScore = audioResult.synthetic_probability;

        // Lip sync analysis
        const syncResult = await this.syncDetector.analyze(videoPath);
        const syncScore = syncResult.mismatch_score;

        // Combine scores
        const finalScore = (visualScore * 0.4 +
                           audioScore * 0.3 +
                           syncScore * 0.3);

        return {
            is_deepfake: finalScore > 0.5,
            confidence: Math.abs(finalScore - 0.5) * 2,
            breakdown: {
                visual: visualScore,
                audio: audioScore,
                lip_sync: syncScore
            },
            suspicious_frames: this.identifySuspiciousFrames(visualResults)
        };
    }
}

class LipSyncDetector {
    async analyze(videoPath) {
        // Extract facial landmarks and audio features
        const landmarks = await extractLandmarks(videoPath);
        const audioFeatures = await extractMFCC(videoPath);

        // Check synchronization
        let totalMismatch = 0;
        const syncWindow = 3; // frames

        for (let i = 0; i < landmarks.length; i++) {
            const mouthMovement = this.computeMouthMovement(
                landmarks.slice(i, i + syncWindow)
            );

            const audioEnergy = this.computeAudioEnergy(
                audioFeatures.slice(i, i + syncWindow)
            );

            // Correlation should be high for natural speech
            const correlation = this.correlate(mouthMovement, audioEnergy);

            if (correlation < 0.6) {
                totalMismatch += (0.6 - correlation);
            }
        }

        return {
            mismatch_score: totalMismatch / landmarks.length,
            synchronized: totalMismatch < landmarks.length * 0.1
        };
    }
}

GAN Fingerprinting

Different GAN architectures leave unique fingerprints in generated images:

// Example: GAN Attribution
class GANAttributor {
    constructor() {
        this.knownModels = [
            'StyleGAN2',
            'StyleGAN3',
            'DALL-E',
            'Midjourney',
            'Stable Diffusion'
        ];
        this.classifier = this.loadAttributionModel();
    }

    async attributeModel(imageTensor) {
        // Extract GAN-specific artifacts
        const features = await this.extractGANFeatures(imageTensor);

        // Classify to specific model
        const predictions = await this.classifier.predict(features);
        const probabilities = await predictions.data();

        const results = this.knownModels.map((model, idx) => ({
            model: model,
            probability: probabilities[idx]
        })).sort((a, b) => b.probability - a.probability);

        return {
            most_likely: results[0].model,
            confidence: results[0].probability,
            all_probabilities: results
        };
    }

    async extractGANFeatures(imageTensor) {
        // Frequency domain analysis
        const fft = await this.computeFFT(imageTensor);

        // Specific artifact patterns
        const artifacts = {
            checkerboard: this.detectCheckerboard(fft),
            spectral_peaks: this.detectSpectralPeaks(fft),
            color_correlation: this.analyzeColorCorrelation(imageTensor)
        };

        return tf.tensor([
            artifacts.checkerboard,
            artifacts.spectral_peaks,
            artifacts.color_correlation
        ]);
    }
}

Biological Signal Analysis

Deepfakes often fail to replicate subtle biological signals:

Blinking: Natural blink rate is 15-20 per minute
Pulse: Visible in face via photoplethysmography
Micro-expressions: Involuntary facial movements
Eye movements: Saccades and tracking patterns

Ensemble Detection

Combining multiple detectors improves robustness:

// Example: Ensemble Detector
class EnsembleDeepfakeDetector {
    constructor() {
        this.detectors = [
            new CNNDeepfakeDetector(),
            new ViTDeepfakeDetector(),
            new ForensicAnalyzer(),
            new GANAttributor(),
            new BiologicalSignalDetector()
        ];
    }

    async detect(media) {
        const results = [];

        // Run all detectors
        for (const detector of this.detectors) {
            try {
                const result = await detector.detect(media);
                results.push({
                    detector: detector.constructor.name,
                    score: result.is_deepfake ? result.confidence : (1 - result.confidence),
                    details: result
                });
            } catch (error) {
                console.error(`Detector ${detector.constructor.name} failed:`, error);
            }
        }

        // Weighted voting
        const weights = [0.3, 0.25, 0.2, 0.15, 0.1]; // Adjust based on detector reliability
        let weightedScore = 0;
        let totalWeight = 0;

        results.forEach((result, idx) => {
            weightedScore += result.score * weights[idx];
            totalWeight += weights[idx];
        });

        const finalScore = weightedScore / totalWeight;

        return {
            is_deepfake: finalScore > 0.5,
            confidence: Math.abs(finalScore - 0.5) * 2,
            ensemble_score: finalScore,
            individual_results: results,
            consensus: results.filter(r => r.score > 0.5).length / results.length
        };
    }
}

📌 Key Takeaways

CNN and Transformer models excel at learning deepfake artifacts
Forensic analysis detects inconsistencies in compression and noise
Multi-modal detection analyzes video, audio, and synchronization
GAN fingerprinting can attribute synthetic content to specific models
Biological signals provide additional verification dimensions
Ensemble methods combine strengths of multiple detectors
Detection is an ongoing arms race requiring continuous model updates

📝 Review Questions

What are the main types of deepfake manipulation techniques?
How do CNNs detect deepfakes compared to traditional forensic methods?
What advantages do Vision Transformers offer for deepfake detection?
Explain Error Level Analysis and what it reveals about image manipulation.
Why is multi-modal analysis more effective than single-modality detection?
How can GAN fingerprinting attribute synthetic content to specific models?
What biological signals are difficult for deepfakes to replicate?
Why is ensemble detection more robust than individual detectors?

弘益人間 (홍익인간) · Benefit All Humanity

Korea Digital Transformation Detailed Mapping

Korea operates digital transformation through a comprehensive governance system. Digital Government: Digital Platform Government Committee (established September 2022, under the President)·Ministry of the Interior and Safety Digital Government Bureau·e-Government Support Center·Gov.kr·National Citizen Service·KDIS (Korea Digital Information Society)·NIA (National Information Society Agency)·MOIS (Ministry of the Interior and Safety). K-DNS Infrastructure: Korea Internet & Security Agency (KISA) Korea Internet Center·KISA DNS Root Server·KRNIC (Korea Network Information Center)·BGP Korea·National Cyber Security Center (NCSC)·KCC (Korea Communications Commission)·MSIT (Ministry of Science and ICT)·NIA·NIPA. Korean Cloud Infrastructure: KT Cloud·NAVER Cloud (NCloud)·Samsung SDS Cloud·LG U+ Cloud·NHN Cloud·Kakao Enterprise Cloud·SK Telecom Cloud·KISA Cloud Security Assurance Program (CSAP)·KCMVP-validated cloud·ISMS-P (Information Security & Personal Information Management System). Korean Security Certifications: KISA ISMS-P certification·KCMVP (Korean Cryptographic Module Validation Program)·NIS (National Intelligence Service) "National Cryptographic Technology Operation Standards"·NCSC "National Cyber Security Strategy 2024-2028"·CC (Common Criteria) Korean evaluation bodies·EAL4·EAL5·KS X ISO/IEC 15408·19790·24759 Korean Profile. Korean Data Standards: NIA AI Hub·National Data Standardization Committee·Statistics Korea (KOSTAT)·MyData 4 Designated Combination Specialists (Samsung SDS, KICI, KOSTAT, KFTC)·National Institute of Korean Language·National Law Information Center·National Spatial Information Platform·National Spatial Data Center·Korean Spatial Information Standards. Finance and Fintech Standards: FSC (Financial Services Commission)·FSS (Financial Supervisory Service)·FIU (Financial Intelligence Unit)·BOK (Bank of Korea)·FSEC (Financial Security Institute)·KFTC (Korea Financial Telecommunications)·KSD (Korea Securities Depository)·KRX (Korea Exchange) 8-agency cooperation. 5G/6G Communications Infrastructure: 5G subscribers 35 million (2024)·5G base stations 350,000·6G commercialization target 2028·5G dedicated networks 16 operators·6G Acceleration Council (MSIT, 2024). K-Content: KOCCA (Korea Creative Content Agency)·MCST (Ministry of Culture, Sports and Tourism)·KCA (Korea Communications Agency)·Korea Culture Information Service Agency·Korean Film Archive·Korea Publishing Industry Promotion Agency. Data 3 Acts (Personal Information Protection Act·Credit Information Act·Telecommunications Network Act, 2020 enforcement)·Data Industry Act (2021)·Public Data Act (2013)·AI Framework Act (2026)·Digital Platform Government Framework Act (2024 proposed) — Korea digital transformation core legislation.

Korea Industrial, Research, Education Infrastructure Mapping

Korea operates its industrial ecosystem and standardization system through the following core infrastructure. Korea Top 5 Groups: Samsung, Hyundai Motor, LG, SK, Lotte. Each group operates standardization committees and ISO/IEC TC Korean secretariats. Samsung Electronics (semiconductors, displays, home appliances, telecom)·Hyundai Motor (automobiles, mobility)·LG Electronics (home appliances, displays, OLED)·SK hynix (memory)·LG Energy Solution·Samsung SDI (batteries)·POSCO Future M (materials)·Hyundai Mobis (parts). Korean IT Big Tech: NAVER (search, cloud, AI HyperCLOVA)·Kakao (messenger, payment, mobility, banking)·Coupang (e-commerce, logistics)·Karrot Market·Toss·Woowa Brothers. Korea Telcos: SK Telecom·KT·LG U+. 5G·5G dedicated networks·B2B cloud·AI businesses operating. Korea Top 7 Research Universities: Seoul National University·KAIST·POSTECH·Yonsei University·Korea University·UNIST·DGIST·GIST. All serve as standardization R&D bases and ISO/IEC/IEEE Korean chairs. Korea Government-affiliated National Research Institutes (26): KIST, KAERI, KIMM, KIER, KFRI, KRICT, KRIBB, KARI, KASI, KIGAM, KICT, KISTI, KETI, ETRI, NIMS, KIMS, KISDI, KOTRA, STEPI, KOEN, KICCE, KIET, KIPF, KIHASA, KICJ, KLRI. Korea Industrial Complexes / Tech Valleys: Pangyo Techno Valley·Dongtan·Gwanggyo·Songdo IBD·Yeouido·Gangnam·Sihwa·Banwol·Gumi·Ulsan·Changwon·Geoje·Yeosu·Onsan·Cheongju·Iksan·Gwangyang·POSCO Gwangyang Steel Mill·Asan Bay·Seosan·Songdo·Incheon Airport·Sejong·Cheongna·Geomdan. Korea Trade and Finance Infrastructure: Korea International Trade Association (KITA)·Korea Trade-Investment Promotion Agency (KOTRA)·Export-Import Bank of Korea (KEXIM)·Bank of Korea·Kookmin Bank·Shinhan·Hana·Woori·NH Nonghyup·IBK Industrial Bank·SC First Bank·Citi Bank Korea·HSBC Korea·DBS Korea — 14 Korean major banks and foreign banks. Korea K-POP / K-Content: HYBE·SM·YG·JYP 4 major entertainment companies·CJ ENM·tvN·MBC·KBS·SBS·EBS·YTN·Yonhap News TV·JTBC Korean broadcasting·NETFLIX Korea·Disney Plus·TVING·Wavve·Watcha·Coupang Play. Korea Gaming Industry: Nexon·NCsoft·Krafton·Netmarble·Kakao Games·Pearl Abyss·Com2uS·Gamevil·NHN·Smilegate·Webzen. Korea Automotive / Battery: Hyundai Motor·Kia·Genesis·LG Energy Solution·Samsung SDI·SK On·POSCO Future M·EcoPro·L&F battery cathode material suppliers. Korea Semiconductor: Samsung Electronics (HBM3E·HBM4)·SK hynix (HBM3E 12-Hi)·DB HiTek·SK siltron·SK Enpulse·Dongjin Semichem·Seoul Semiconductor·Simmtech·Samsung Display·LG Display.

Korea Standardization Infrastructure Mapping

Korea operates a comprehensive standards governance system through inter-ministerial cooperation. National Standards Council (under Prime Minister's Office, per Framework Act on National Standards Article 5) coordinates KATS (Korean Agency for Technology and Standards), MFDS (Ministry of Food and Drug Safety), MOTIE (Ministry of Trade, Industry and Energy), MSIT (Ministry of Science and ICT), MOIS (Ministry of the Interior and Safety), MOE (Ministry of Environment), MOHW (Ministry of Health and Welfare), MND (Ministry of National Defense), MCST (Ministry of Culture, Sports and Tourism), MOFA (Ministry of Foreign Affairs), MOJ (Ministry of Justice), and FSC (Financial Services Commission). Accreditation and Testing: KOLAS (Korea Laboratory Accreditation Scheme) accredits 800+ testing laboratories. KAS (Korea Accreditation System) accredits 50+ certification bodies. KTC (Korea Testing Certification), KTR (Korea Testing & Research Institute), KTL (Korea Testing Laboratory), and KCL (Korea Conformity Laboratories) provide conformance testing. Telecom and Cyber: KCC (Korea Communications Commission), KCA (Korea Communications Agency), TTA (Telecommunications Technology Association), IITP (Institute for Information & Communications Technology Planning & Evaluation), NIPA (National IT Industry Promotion Agency), KISA (Korea Internet & Security Agency), KCMVP (Korea Cryptographic Module Validation Program), NIS (National Intelligence Service), NSR (National Security Research Institute), and NCSC (National Cyber Security Center). National R&D Centers: KIST, ETRI, KAIST, Seoul National University, Yonsei University, Korea University, POSTECH, UNIST, GIST, DGIST, KISTI, KIER, KIMM, KRICT, KFRI, KRIBB. International Standards Cooperation: ISO TC/SC Korean secretariats, IEC TC/SC Korean secretariats, ITU-T Study Group Korean chairs, 3GPP RAN/SA Korean chairs, IEEE 802 Korean chairs, W3C Korea office, OASIS Korea office, IETF Korea cooperation, OECD CSTP, UN ESCAP, APEC SCSC Korean cooperation. Korean Industrial Standards (KS) Catalog: KS X (Information) 25,000+, KS A (Basic) 15,000+, KS B (Machinery) 25,000+, KS C (Electrical) 18,000+, KS D (Metallurgy) 12,000+, KS E (Mining) 5,000+, KS F (Construction) 18,000+, KS H (Food) 8,000+, KS I (Environment) 5,000+, KS J (Biology) 3,000+, KS K (Textile) 15,000+, KS L (Ceramics) 7,000+, KS M (Chemistry) 12,000+, KS P (Medical) 5,000+, KS Q (Quality Mgmt) 4,000+, KS R (Transport) 12,000+, KS S (Service) 3,000+, KS T (Packaging) 4,000+, KS V (Shipbuilding) 5,000+, KS W (Aerospace) 3,000+ — totaling 220,000+ Korean Industrial Standards. Key Acts: Personal Information Protection Act (Act 19234, effective Sept 15, 2024), Electronic Government Act, Electronic Signature Act, Act on Promotion of Information and Communications Network Utilization and Information Protection, Information and Communications Infrastructure Protection Act, Data Industry Act, Public Data Act, AI Framework Act (Act 20212, effective July 2026), Industrial Technology Innovation Promotion Act, Framework Act on Science and Technology — 70+ Korean standardization-related laws.