의료 웹사이트 보안과 개인정보보호 구현 가이드

'use client';
import { useState } from 'react';

interface ConsentFormProps {
  onConsent: (consents: ConsentData) => void;
}

interface ConsentData {
  personalInfo: boolean;
  sensitiveInfo: boolean;
  marketing: boolean;
  thirdParty: boolean;
  timestamp: string;
  ipAddress: string;
}

export function ConsentForm({ onConsent }: ConsentFormProps) {
  const [consents, setConsents] = useState({
    personalInfo: false,
    sensitiveInfo: false,
    marketing: false,
    thirdParty: false,
  });

  const requiredConsents = consents.personalInfo && consents.sensitiveInfo;

  return (
    <div className="space-y-4 p-6 bg-gray-50 rounded-xl">
      <h3 className="font-semibold">개인정보 수집 및 이용 동의</h3>

      {/* 필수 동의: 개인정보 수집 */}
      <label className="flex items-start gap-3 p-4 bg-white rounded-lg border cursor-pointer">
        <input
          type="checkbox"
          checked={consents.personalInfo}
          onChange={(e) => setConsents(prev => ({ ...prev, personalInfo: e.target.checked }))}
          className="mt-1"
        />
        <div>
          <span className="font-medium">[필수] 개인정보 수집 및 이용 동의</span>
          <p className="text-sm text-gray-500 mt-1">
            수집 항목: 성명, 연락처, 이메일<br />
            수집 목적: 진료 상담 예약 및 안내<br />
            보유 기간: 예약일로부터 1년 (관련 법령에 따라 연장 가능)
          </p>
          <button className="text-xs text-accent underline mt-1">전문 보기</button>
        </div>
      </label>

      {/* 필수 동의: 민감정보 수집 */}
      <label className="flex items-start gap-3 p-4 bg-white rounded-lg border cursor-pointer">
        <input
          type="checkbox"
          checked={consents.sensitiveInfo}
          onChange={(e) => setConsents(prev => ({ ...prev, sensitiveInfo: e.target.checked }))}
          className="mt-1"
        />
        <div>
          <span className="font-medium">[필수] 민감정보(건강정보) 수집 동의</span>
          <p className="text-sm text-gray-500 mt-1">
            수집 항목: 관심 시술, 현재 건강상태, 알레르기 정보<br />
            수집 목적: 맞춤 시술 상담 제공<br />
            보유 기간: 진료기록 보관 의무에 따름 (의료법 제22조)
          </p>
        </div>
      </label>

      {/* 선택 동의: 마케팅 */}
      <label className="flex items-start gap-3 p-4 bg-white rounded-lg border cursor-pointer">
        <input
          type="checkbox"
          checked={consents.marketing}
          onChange={(e) => setConsents(prev => ({ ...prev, marketing: e.target.checked }))}
          className="mt-1"
        />
        <div>
          <span className="font-medium">[선택] 마케팅 정보 수신 동의</span>
          <p className="text-sm text-gray-500 mt-1">
            이벤트, 할인 정보, 시술 안내 등의 마케팅 정보를 받으실 수 있습니다.
          </p>
        </div>
      </label>

      <button
        onClick={() => onConsent({
          ...consents,
          timestamp: new Date().toISOString(),
          ipAddress: '', // 서버에서 수집
        })}
        disabled={!requiredConsents}
        className="w-full py-3 bg-accent text-white rounded-lg font-medium disabled:bg-gray-300 disabled:cursor-not-allowed"
      >
        동의하고 상담 신청하기
      </button>
    </div>
  );
}

// next.config.ts
const securityHeaders = [
  {
    key: 'Strict-Transport-Security',
    value: 'max-age=63072000; includeSubDomains; preload',
  },
  {
    key: 'Content-Security-Policy',
    value: [
      "default-src 'self'",
      "script-src 'self' 'unsafe-eval' 'unsafe-inline' https://t1.kakaocdn.net",
      "style-src 'self' 'unsafe-inline'",
      "img-src 'self' data: blob: https:",
      "font-src 'self' https://fonts.gstatic.com",
      "connect-src 'self' https://kapi.kakao.com",
      "frame-ancestors 'none'",
    ].join('; '),
  },
  {
    key: 'X-Content-Type-Options',
    value: 'nosniff',
  },
  {
    key: 'X-Frame-Options',
    value: 'DENY',
  },
  {
    key: 'Referrer-Policy',
    value: 'strict-origin-when-cross-origin',
  },
  {
    key: 'Permissions-Policy',
    value: 'camera=(), microphone=(), geolocation=(self)',
  },
];

const nextConfig = {
  async headers() {
    return [
      {
        source: '/(.*)',
        headers: securityHeaders,
      },
    ];
  },
};

export default nextConfig;

// lib/crypto.ts
import crypto from 'crypto';

const ALGORITHM = 'aes-256-gcm';

export class FieldEncryption {
  private key: Buffer;

  constructor() {
    const keyHex = process.env.ENCRYPTION_KEY;
    if (!keyHex || keyHex.length !== 64) {
      throw new Error('ENCRYPTION_KEY must be 32 bytes (64 hex chars)');
    }
    this.key = Buffer.from(keyHex, 'hex');
  }

  encrypt(plaintext: string): string {
    const iv = crypto.randomBytes(12); // GCM 권장 12바이트
    const cipher = crypto.createCipheriv(ALGORITHM, this.key, iv);
    const encrypted = Buffer.concat([
      cipher.update(plaintext, 'utf8'),
      cipher.final(),
    ]);
    const authTag = cipher.getAuthTag();
    // iv:authTag:ciphertext (모두 base64)
    return [
      iv.toString('base64'),
      authTag.toString('base64'),
      encrypted.toString('base64'),
    ].join('.');
  }

  decrypt(ciphertext: string): string {
    const [ivB64, tagB64, dataB64] = ciphertext.split('.');
    const iv = Buffer.from(ivB64, 'base64');
    const authTag = Buffer.from(tagB64, 'base64');
    const data = Buffer.from(dataB64, 'base64');

    const decipher = crypto.createDecipheriv(ALGORITHM, this.key, iv);
    decipher.setAuthTag(authTag);
    return Buffer.concat([
      decipher.update(data),
      decipher.final(),
    ]).toString('utf8');
  }
}

// 사용 예시
const enc = new FieldEncryption();
const encrypted = enc.encrypt('010-1234-5678');
const decrypted = enc.decrypt(encrypted); // '010-1234-5678'

// middleware.ts
import { NextRequest, NextResponse } from 'next/server';
import { verifyToken } from '@/lib/auth';

const PROTECTED_PATHS = ['/admin', '/api/admin'];
const PUBLIC_PATHS = ['/login', '/api/auth'];

export async function middleware(request: NextRequest) {
  const { pathname } = request.nextUrl;

  // 공개 경로는 통과
  if (PUBLIC_PATHS.some(p => pathname.startsWith(p))) {
    return NextResponse.next();
  }

  // 보호 경로 접근 시 토큰 검증
  if (PROTECTED_PATHS.some(p => pathname.startsWith(p))) {
    const token = request.cookies.get('auth-token')?.value;

    if (!token) {
      return NextResponse.redirect(new URL('/login', request.url));
    }

    try {
      const payload = await verifyToken(token);

      // RBAC: 관리자 경로는 admin/doctor 역할만
      if (pathname.startsWith('/admin') && !['admin', 'doctor'].includes(payload.role)) {
        return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
      }

      // 요청 헤더에 사용자 정보 추가
      const headers = new Headers(request.headers);
      headers.set('x-user-id', payload.userId);
      headers.set('x-user-role', payload.role);

      return NextResponse.next({ headers });
    } catch {
      return NextResponse.redirect(new URL('/login', request.url));
    }
  }

  return NextResponse.next();
}

// Prisma ORM 사용 시 자동 방어 (파라미터 바인딩)
const patient = await prisma.patient.findFirst({
  where: { phone: userInput }, // 안전: Prisma가 자동 이스케이프
});

// 주의: Raw Query 사용 시 반드시 파라미터 바인딩
const result = await prisma.$queryRaw`
  SELECT * FROM patients WHERE phone = ${userInput}
`;
// 절대 하지 말 것: prisma.$queryRawUnsafe(`SELECT * FROM patients WHERE phone = '${userInput}'`)

// React는 기본적으로 JSX 내 값을 이스케이프
// 하지만 dangerouslySetInnerHTML 사용 시 주의
import DOMPurify from 'dompurify';

function SafeHTML({ content }: { content: string }) {
  const sanitized = DOMPurify.sanitize(content, {
    ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'p', 'br'],
    ALLOWED_ATTR: [],
  });

  return <div dangerouslySetInnerHTML={{ __html: sanitized }} />;
}

// Next.js Server Actions는 CSRF 토큰 자동 처리
// API Routes 사용 시 수동 구현 필요

import crypto from 'crypto';

export function generateCSRFToken(): string {
  return crypto.randomBytes(32).toString('hex');
}

export function validateCSRFToken(token: string, sessionToken: string): boolean {
  return crypto.timingSafeEqual(
    Buffer.from(token),
    Buffer.from(sessionToken)
  );
}

// lib/audit-log.ts
interface AuditEntry {
  userId: string;
  action: 'VIEW' | 'CREATE' | 'UPDATE' | 'DELETE' | 'EXPORT';
  resource: string;
  resourceId: string;
  details?: string;
  ipAddress: string;
  timestamp: Date;
}

export async function logAccess(entry: AuditEntry) {
  await prisma.auditLog.create({
    data: {
      ...entry,
      timestamp: new Date(),
    },
  });
}

// 사용 예시: 환자 정보 조회 시
const patient = await prisma.patient.findUnique({ where: { id: patientId } });
await logAccess({
  userId: currentUser.id,
  action: 'VIEW',
  resource: 'patient',
  resourceId: patientId,
  ipAddress: request.headers.get('x-forwarded-for') || 'unknown',
  timestamp: new Date(),
});