PCI DSS

// PCI DSS 준수 토큰화 서비스 - Node.js
const crypto = require('crypto');
const { v4: uuidv4 } = require('uuid');

/**
 * PCI DSS 요구사항 3 준수를 위한 토큰화 서비스
 * 실제 PAN을 토큰으로 대체하여 CDE 범위 최소화
 */
class TokenizationService {
    constructor() {
        // 토큰-PAN 매핑 저장소 (실제로는 HSM + 암호화된 DB)
        this.tokenVault = new Map();
        this.encryptionKey = crypto.randomBytes(32);
        this.algorithm = 'aes-256-gcm';
    }

    /**
     * PAN을 토큰으로 변환
     * @param {string} pan - 카드번호
     * @returns {object} - 토큰 및 마스킹된 PAN
     */
    tokenize(pan) {
        const cleanPan = pan.replace(/\D/g, '');

        // Luhn 검증
        if (!this.luhnCheck(cleanPan)) {
            throw new Error('Invalid PAN: Luhn check failed');
        }

        // 기존 토큰 확인 (중복 방지)
        for (const [token, encrypted] of this.tokenVault) {
            const decrypted = this.decrypt(encrypted);
            if (decrypted === cleanPan) {
                return {
                    token,
                    maskedPan: this.maskPan(cleanPan),
                    last4: cleanPan.slice(-4)
                };
            }
        }

        // 새 토큰 생성 (포맷 보존 옵션)
        const token = this.generateToken(cleanPan);

        // PAN 암호화 후 저장
        const encrypted = this.encrypt(cleanPan);
        this.tokenVault.set(token, encrypted);

        console.log(`[AUDIT] PAN tokenized: last4=${cleanPan.slice(-4)}, token=${token.slice(0, 8)}...`);

        return {
            token,
            maskedPan: this.maskPan(cleanPan),
            last4: cleanPan.slice(-4)
        };
    }

    /**
     * 토큰을 PAN으로 복원 (권한 있는 시스템만)
     * @param {string} token - 토큰
     * @param {string} purpose - 복원 목적 (감사용)
     * @returns {string} - 원본 PAN
     */
    detokenize(token, purpose) {
        const encrypted = this.tokenVault.get(token);
        if (!encrypted) {
            throw new Error('Token not found');
        }

        const pan = this.decrypt(encrypted);

        console.log(`[AUDIT] PAN detokenized: token=${token.slice(0, 8)}..., purpose=${purpose}`);

        return pan;
    }

    /**
     * 포맷 보존 토큰 생성 (FPE 스타일)
     * 실제로는 BIN(처음 6자리) + 마지막 4자리 유지 가능
     */
    generateToken(pan) {
        // 옵션 1: UUID 기반 (완전 랜덤)
        // return uuidv4().replace(/-/g, '').slice(0, 16);

        // 옵션 2: 포맷 보존 (BIN + 랜덤 + last4)
        const bin = pan.slice(0, 6);
        const last4 = pan.slice(-4);
        const middle = crypto.randomBytes(3).toString('hex').slice(0, 6);
        return `${bin}${middle}${last4}`;
    }

    /**
     * AES-256-GCM 암호화
     */
    encrypt(plaintext) {
        const iv = crypto.randomBytes(16);
        const cipher = crypto.createCipheriv(this.algorithm, this.encryptionKey, iv);

        let encrypted = cipher.update(plaintext, 'utf8', 'hex');
        encrypted += cipher.final('hex');
        const authTag = cipher.getAuthTag();

        return JSON.stringify({
            iv: iv.toString('hex'),
            authTag: authTag.toString('hex'),
            data: encrypted
        });
    }

    /**
     * AES-256-GCM 복호화
     */
    decrypt(encryptedJson) {
        const { iv, authTag, data } = JSON.parse(encryptedJson);

        const decipher = crypto.createDecipheriv(
            this.algorithm,
            this.encryptionKey,
            Buffer.from(iv, 'hex')
        );
        decipher.setAuthTag(Buffer.from(authTag, 'hex'));

        let decrypted = decipher.update(data, 'hex', 'utf8');
        decrypted += decipher.final('utf8');

        return decrypted;
    }

    /**
     * PAN 마스킹 (요구사항 3.4)
     */
    maskPan(pan) {
        return `${pan.slice(0, 6)}${'*'.repeat(pan.length - 10)}${pan.slice(-4)}`;
    }

    /**
     * Luhn 알고리즘 검증
     */
    luhnCheck(pan) {
        let sum = 0;
        let isEven = false;

        for (let i = pan.length - 1; i >= 0; i--) {
            let digit = parseInt(pan[i], 10);

            if (isEven) {
                digit *= 2;
                if (digit > 9) digit -= 9;
            }

            sum += digit;
            isEven = !isEven;
        }

        return sum % 10 === 0;
    }
}

/**
 * PCI DSS 요구사항 4: 전송 중 암호화 검증 미들웨어
 */
function requireTLS(req, res, next) {
    // X-Forwarded-Proto 헤더 또는 직접 연결 확인
    const isSecure = req.secure ||
        req.headers['x-forwarded-proto'] === 'https' ||
        req.connection.encrypted;

    if (!isSecure && process.env.NODE_ENV === 'production') {
        console.log(`[AUDIT] INSECURE_CONNECTION_BLOCKED: ip=${req.ip}`);
        return res.status(403).json({
            error: 'PCI DSS Requirement 4: TLS required for cardholder data transmission'
        });
    }

    // TLS 버전 확인 (1.2 이상 필수)
    const tlsVersion = req.connection.getPeerCertificate?.()?.version;
    if (tlsVersion && parseFloat(tlsVersion) < 1.2) {
        return res.status(403).json({
            error: 'PCI DSS: TLS 1.2 or higher required'
        });
    }

    next();
}

// 사용 예시
const tokenService = new TokenizationService();

// 토큰화
const result = tokenService.tokenize('4111111111111111');
console.log('토큰화 결과:', result);

// 디토큰화 (결제 처리 시에만)
const pan = tokenService.detokenize(result.token, 'payment_processing');
console.log('복원된 PAN:', tokenService.maskPan(pan));

module.exports = { TokenizationService, requireTLS };

-- PCI DSS 준수를 위한 SQL 데이터 보호 기법

-- =====================================================
-- 요구사항 3: 저장된 카드홀더 데이터 보호
-- =====================================================

-- 1. 카드 데이터 테이블 구조 (올바른 설계)
CREATE TABLE payment_tokens (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    token VARCHAR(32) NOT NULL UNIQUE,          -- 토큰 (PAN 대체)
    pan_hash VARCHAR(64) NOT NULL,              -- SHA-256 해시 (검색용)
    pan_last4 CHAR(4) NOT NULL,                 -- 마지막 4자리 (표시용)
    bin CHAR(6),                                -- BIN (처음 6자리, 선택적)
    card_brand VARCHAR(20),                     -- Visa, Mastercard 등
    expiry_month SMALLINT,                      -- 만료 월 (암호화 가능)
    expiry_year SMALLINT,                       -- 만료 년
    cardholder_name_encrypted BYTEA,            -- 암호화된 카드소유자명
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

    -- CVV/CVC는 절대 저장하지 않음! (SAD)
    -- PIN도 절대 저장하지 않음! (SAD)

    CONSTRAINT valid_expiry_month CHECK (expiry_month BETWEEN 1 AND 12),
    CONSTRAINT valid_last4 CHECK (pan_last4 ~ '^[0-9]{4}$')
);

-- 2. 암호화된 PAN 저장소 (별도 보안 DB/HSM 권장)
CREATE TABLE pan_vault (
    token VARCHAR(32) PRIMARY KEY REFERENCES payment_tokens(token),
    encrypted_pan BYTEA NOT NULL,               -- AES-256 암호화된 PAN
    key_id VARCHAR(36) NOT NULL,                -- 암호화 키 식별자
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

    -- 접근 감사용 컬럼
    last_accessed_at TIMESTAMP,
    access_count INTEGER DEFAULT 0
);

-- 3. PAN 마스킹 함수
CREATE OR REPLACE FUNCTION mask_pan(pan TEXT)
RETURNS TEXT AS $$
BEGIN
    -- 처음 6자리 + 마스크 + 마지막 4자리
    RETURN SUBSTRING(pan, 1, 6) ||
           REPEAT('*', LENGTH(pan) - 10) ||
           SUBSTRING(pan, LENGTH(pan) - 3);
END;
$$ LANGUAGE plpgsql IMMUTABLE;

-- 예시: SELECT mask_pan('4111111111111111');
-- 결과: 411111******1111

-- 4. PAN 해싱 함수 (검색용)
CREATE OR REPLACE FUNCTION hash_pan(pan TEXT, salt TEXT DEFAULT 'PCI_SALT')
RETURNS TEXT AS $$
BEGIN
    RETURN encode(sha256((salt || pan)::bytea), 'hex');
END;
$$ LANGUAGE plpgsql IMMUTABLE;


-- =====================================================
-- 요구사항 7: 카드홀더 데이터 접근 제한
-- =====================================================

-- 1. 역할 기반 접근 제어 (RBAC)
CREATE ROLE pci_readonly;
CREATE ROLE pci_payment_processor;
CREATE ROLE pci_admin;

-- 읽기 전용 역할: 마스킹된 데이터만 조회 가능
GRANT SELECT (id, token, pan_last4, card_brand, expiry_month, expiry_year)
ON payment_tokens TO pci_readonly;

-- 결제 처리 역할: PAN vault 접근 가능
GRANT SELECT ON pan_vault TO pci_payment_processor;
GRANT EXECUTE ON FUNCTION mask_pan TO pci_payment_processor;

-- 관리자: 전체 접근 (감사 추적 필수)
GRANT ALL ON payment_tokens TO pci_admin;
GRANT ALL ON pan_vault TO pci_admin;


-- =====================================================
-- 요구사항 10: 네트워크 리소스 및 CHD 접근 추적
-- =====================================================

-- 1. 감사 로그 테이블
CREATE TABLE pci_audit_log (
    id BIGSERIAL PRIMARY KEY,
    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    user_name VARCHAR(100) NOT NULL,
    client_ip INET,
    action VARCHAR(50) NOT NULL,            -- SELECT, INSERT, UPDATE, DELETE
    table_name VARCHAR(100) NOT NULL,
    record_id UUID,
    column_accessed TEXT[],                 -- 접근한 컬럼 목록
    query_text TEXT,                        -- 실행된 쿼리 (마스킹된)
    success BOOLEAN NOT NULL,
    error_message TEXT
);

-- 2. 자동 감사 로그 트리거
CREATE OR REPLACE FUNCTION log_pan_access()
RETURNS TRIGGER AS $$
BEGIN
    INSERT INTO pci_audit_log (
        user_name, client_ip, action, table_name, record_id, success
    ) VALUES (
        current_user,
        inet_client_addr(),
        TG_OP,
        TG_TABLE_NAME,
        COALESCE(NEW.id, OLD.id),
        TRUE
    );
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER audit_pan_vault_access
AFTER SELECT OR INSERT OR UPDATE OR DELETE ON pan_vault
FOR EACH ROW EXECUTE FUNCTION log_pan_access();

-- 3. 민감 데이터 접근 시 알림
CREATE OR REPLACE FUNCTION alert_on_bulk_access()
RETURNS TRIGGER AS $$
DECLARE
    access_count INTEGER;
BEGIN
    -- 지난 1분간 동일 사용자의 접근 횟수 확인
    SELECT COUNT(*) INTO access_count
    FROM pci_audit_log
    WHERE user_name = current_user
    AND timestamp > NOW() - INTERVAL '1 minute'
    AND table_name = 'pan_vault';

    -- 임계값 초과 시 경고 (대량 데이터 추출 시도 탐지)
    IF access_count > 100 THEN
        RAISE WARNING 'PCI ALERT: Unusual bulk access detected for user %', current_user;
        -- 실제로는 SIEM으로 알림 전송
    END IF;

    RETURN NEW;
END;
$$ LANGUAGE plpgsql;


-- =====================================================
-- 요구사항 3.2: SAD 저장 방지 제약조건
-- =====================================================

-- SAD 컬럼이 추가되는 것을 방지하는 체크
-- (실제로는 DDL 트리거로 구현)

-- 금지된 컬럼명 목록
CREATE TABLE forbidden_columns (
    column_name VARCHAR(50) PRIMARY KEY
);

INSERT INTO forbidden_columns VALUES
    ('cvv'), ('cvc'), ('cvv2'), ('cvc2'), ('cid'),
    ('pin'), ('pin_block'),
    ('track1'), ('track2'), ('magnetic_stripe'),
    ('full_track_data');

-- DDL 이벤트 트리거 (PostgreSQL 9.3+)
CREATE OR REPLACE FUNCTION prevent_sad_columns()
RETURNS event_trigger AS $$
DECLARE
    obj record;
BEGIN
    FOR obj IN SELECT * FROM pg_event_trigger_ddl_commands()
    LOOP
        IF obj.command_tag IN ('CREATE TABLE', 'ALTER TABLE') THEN
            -- 금지된 컬럼명 체크 로직
            RAISE NOTICE 'DDL command detected: %', obj.command_tag;
        END IF;
    END LOOP;
END;
$$ LANGUAGE plpgsql;

-- CREATE EVENT TRIGGER check_sad_columns
-- ON ddl_command_end
-- EXECUTE FUNCTION prevent_sad_columns();