디지털 서명과 암호화

// 키 쌍 생성 예제 (Ed25519 사용)
import { generateKeyPairSync } from 'crypto';

// Ed25519 키 쌍 생성
const { publicKey, privateKey } = generateKeyPairSync('ed25519', {
    publicKeyEncoding: {
        type: 'spki',
        format: 'pem'
    },
    privateKeyEncoding: {
        type: 'pkcs8',
        format: 'pem'
    }
});

console.log('공개 키:', publicKey);
console.log('개인 키:', privateKey);

// 다양한 해시 알고리즘으로 콘텐츠 해싱
import { createHash } from 'crypto';
import { readFileSync } from 'fs';

// 이미지 파일 읽기
const imageBuffer = readFileSync('photo.jpg');

// SHA-256 해시 계산
const sha256Hash = createHash('sha256')
    .update(imageBuffer)
    .digest('hex');

// SHA-512 해시 계산
const sha512Hash = createHash('sha512')
    .update(imageBuffer)
    .digest('hex');

// SHA-3 해시 계산
const sha3Hash = createHash('sha3-256')
    .update(imageBuffer)
    .digest('hex');

console.log('SHA-256:', sha256Hash);
console.log('SHA-512:', sha512Hash);
console.log('SHA-3:', sha3Hash);

// RSA 서명 생성 및 검증
import { createSign, createVerify } from 'crypto';

// 콘텐츠 해시 계산
const content = readFileSync('document.pdf');
const hash = createHash('sha256').update(content).digest();

// RSA 서명 생성
const sign = createSign('RSA-SHA256');
sign.update(hash);
const signature = sign.sign(privateKey, 'hex');

// 서명 검증
const verify = createVerify('RSA-SHA256');
verify.update(hash);
const isValid = verify.verify(publicKey, signature, 'hex');

console.log('서명 유효성:', isValid);

// ECDSA 서명 (P-256 곡선 사용)
import { generateKeyPairSync, createSign, createVerify } from 'crypto';

// P-256 곡선으로 ECDSA 키 쌍 생성
const { publicKey, privateKey } = generateKeyPairSync('ec', {
    namedCurve: 'P-256',
    publicKeyEncoding: { type: 'spki', format: 'pem' },
    privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
});

// 콘텐츠에 서명
const content = '인증할 중요한 콘텐츠';
const sign = createSign('SHA256');
sign.update(content);
const signature = sign.sign(privateKey, 'base64');

// 서명 검증
const verify = createVerify('SHA256');
verify.update(content);
const isValid = verify.verify(publicKey, signature, 'base64');

console.log('ECDSA 서명 검증:', isValid);

// Ed25519 서명 - 권장 접근 방식
import { generateKeyPairSync, sign, verify } from 'crypto';

// Ed25519 키 쌍 생성
const { publicKey, privateKey } = generateKeyPairSync('ed25519');

// 콘텐츠 준비
const content = Buffer.from('인증할 이미지 데이터');

// 서명 생성 (해싱이 내부적으로 처리됨)
const signature = sign(null, content, privateKey);

// 서명 검증
const isValid = verify(null, content, publicKey, signature);

console.log('Ed25519 서명 검증:', isValid);
console.log('서명 크기:', signature.length, '바이트');

// WIA-AI-017 서명 매니페스트 구조
interface SignatureManifest {
    // 서명 식별
    signatureId: string;              // 고유 서명 ID (UUID)
    version: string;                  // 매니페스트 버전 (예: "1.0")

    // 콘텐츠 참조
    contentHash: string;              // SHA-256 콘텐츠 해시
    contentType: string;              // MIME 타입 (image/jpeg 등)
    contentSize: number;              // 바이트 단위 크기

    // 암호화 정보
    algorithm: string;                // 서명 알고리즘 (Ed25519, ECDSA, RSA)
    hashAlgorithm: string;            // 해시 알고리즘 (SHA-256, SHA-512)
    signature: string;                // Base64 인코딩된 서명
    publicKey: string;                // Base64 인코딩된 공개 키

    // 서명자 정보
    signer: {
        name: string;                 // 서명자 이름/조직
        email?: string;               // 연락 이메일
        did?: string;                 // 분산 식별자 (선택)
    };

    // 타임스탬프
    signedAt: string;                 // ISO 8601 타임스탬프
    expiresAt?: string;               // 서명 만료 (선택)

    // 추가 컨텍스트
    purpose?: string;                 // 서명 목적
    chain?: SignatureManifest[];      // 이전 서명 체인
}

// 완전한 서명 매니페스트 생성
import { v4 as uuidv4 } from 'uuid';
import { generateKeyPairSync, sign, createHash } from 'crypto';
import { readFileSync } from 'fs';

class ContentSigner {
    private privateKey: Buffer;
    private publicKey: Buffer;

    constructor() {
        // 키 쌍 생성
        const keys = generateKeyPairSync('ed25519');
        this.privateKey = keys.privateKey;
        this.publicKey = keys.publicKey;
    }

    signContent(filePath: string, signerName: string): SignatureManifest {
        // 콘텐츠 읽기
        const content = readFileSync(filePath);

        // 콘텐츠 해시 계산
        const contentHash = createHash('sha256')
            .update(content)
            .digest('base64');

        // 서명 생성
        const signature = sign(null, content, this.privateKey);

        // 매니페스트 구성
        const manifest: SignatureManifest = {
            signatureId: uuidv4(),
            version: '1.0',
            contentHash: contentHash,
            contentType: 'image/jpeg',
            contentSize: content.length,
            algorithm: 'Ed25519',
            hashAlgorithm: 'SHA-256',
            signature: signature.toString('base64'),
            publicKey: this.publicKey.toString('base64'),
            signer: {
                name: signerName,
                email: 'signer@example.com'
            },
            signedAt: new Date().toISOString(),
            purpose: 'AI 콘텐츠 인증'
        };

        return manifest;
    }
}

// 사용 예제
const signer = new ContentSigner();
const manifest = signer.signContent('photo.jpg', 'WIA 콘텐츠 연구소');
console.log('서명 매니페스트:', JSON.stringify(manifest, null, 2));

// 서명 검증 구현
import { verify, createHash } from 'crypto';
import { readFileSync } from 'fs';

class SignatureVerifier {
    verifyContent(filePath: string, manifest: SignatureManifest): boolean {
        try {
            // 1. 콘텐츠 읽기
            const content = readFileSync(filePath);

            // 2. 콘텐츠 해시 재계산
            const calculatedHash = createHash('sha256')
                .update(content)
                .digest('base64');

            // 3. 해시 무결성 검사
            if (calculatedHash !== manifest.contentHash) {
                console.error('❌ 콘텐츠 해시 불일치');
                return false;
            }

            // 4. 만료 시간 검사
            if (manifest.expiresAt) {
                const expiry = new Date(manifest.expiresAt);
                if (expiry < new Date()) {
                    console.error('❌ 서명 만료됨');
                    return false;
                }
            }

            // 5. 공개 키 및 서명 디코딩
            const publicKey = Buffer.from(manifest.publicKey, 'base64');
            const signature = Buffer.from(manifest.signature, 'base64');

            // 6. 암호화 서명 검증
            const isValid = verify(null, content, publicKey, signature);

            if (isValid) {
                console.log('✅ 서명 검증 성공');
                console.log('서명자:', manifest.signer.name);
                console.log('서명 시각:', manifest.signedAt);
            }

            return isValid;

        } catch (error) {
            console.error('❌ 검증 오류:', error.message);
            return false;
        }
    }
}

// 사용 예제
const verifier = new SignatureVerifier();
const manifest = JSON.parse(readFileSync('signature.json', 'utf-8'));
const isValid = verifier.verifyContent('photo.jpg', manifest);

// RFC 3161 타임스탬프 요청
import axios from 'axios';
import { createHash } from 'crypto';

async function requestTimestamp(content: Buffer): Promise {
    // 콘텐츠 해시 생성
    const hash = createHash('sha256').update(content).digest();

    // TSA 엔드포인트
    const tsaUrl = 'https://freetsa.org/tsr';

    // TSR (타임스탬프 요청) 생성
    const tsrRequest = {
        version: 1,
        messageImprint: {
            hashAlgorithm: 'SHA-256',
            hashedMessage: hash.toString('base64')
        },
        nonce: Math.floor(Math.random() * 1000000),
        certReq: true
    };

    // TSA에 요청 전송
    const response = await axios.post(tsaUrl, tsrRequest, {
        headers: { 'Content-Type': 'application/timestamp-query' },
        responseType: 'arraybuffer'
    });

    // TST (타임스탬프 토큰) 반환
    return Buffer.from(response.data).toString('base64');
}

// 사용 예제
const content = readFileSync('document.pdf');
const timestamp = await requestTimestamp(content);
console.log('타임스탬프 토큰:', timestamp);

// 키 순환 시스템
class KeyRotationManager {
    private keyStore: Map = new Map();
    private currentKeyId: string;

    // 새 키 생성 및 활성화
    rotateKeys(): string {
        const newKeyId = `key-${Date.now()}`;
        const { publicKey, privateKey } = generateKeyPairSync('ed25519');

        // 새 키 저장
        this.keyStore.set(newKeyId, { publicKey, privateKey });

        // 이전 키는 검증용으로만 유지
        const oldKeyId = this.currentKeyId;
        if (oldKeyId) {
            const oldKey = this.keyStore.get(oldKeyId);
            // 이전 개인 키는 안전하게 보관만 (서명에는 사용 안함)
            console.log(`이전 키 ${oldKeyId}는 검증 전용`);
        }

        // 현재 키 업데이트
        this.currentKeyId = newKeyId;

        console.log(`✅ 새 키 활성화: ${newKeyId}`);
        return newKeyId;
    }

    // 서명에 현재 키 사용
    sign(content: Buffer): { signature: string; keyId: string } {
        const key = this.keyStore.get(this.currentKeyId);
        const signature = sign(null, content, key.privateKey);

        return {
            signature: signature.toString('base64'),
            keyId: this.currentKeyId
        };
    }

    // 모든 키로 검증 (이전 서명 지원)
    verify(content: Buffer, signature: string, keyId: string): boolean {
        const key = this.keyStore.get(keyId);
        if (!key) {
            console.error('키를 찾을 수 없음:', keyId);
            return false;
        }

        const sig = Buffer.from(signature, 'base64');
        return verify(null, content, key.publicKey, sig);
    }
}

// DID 기반 서명자 정보
{
    "signer": {
        "did": "did:wia:0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
        "didDocument": {
            "@context": "https://www.w3.org/ns/did/v1",
            "id": "did:wia:0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
            "publicKey": [{
                "id": "did:wia:...#key-1",
                "type": "Ed25519VerificationKey2020",
                "controller": "did:wia:0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
                "publicKeyBase58": "H3C2AVvLMv6gmMNam3uVAjZpfkcJCwDwnZn6z3wXmqPV"
            }]
        }
    }
}