Web Crypto API는 window.crypto 객체를 통해 접근할 수 있어요:

// Web Crypto API 사용 가능 여부 확인하기
if (window.crypto && window.crypto.subtle) {
  console.log("야호! Web Crypto API 사용 가능! 🎉");
} else {
  console.log("앗... 이 브라우저는 Web Crypto API를 지원하지 않네요 😢");
}

// 1. 암호화 키 생성하기
async function generateAESKey() {
  const key = await window.crypto.subtle.generateKey(
    {
      name: "AES-GCM",
      length: 256  // 키 길이 (128, 192, 256 비트 중 선택)
    },
    true,  // 내보내기 가능 여부
    ["encrypt", "decrypt"]  // 이 키로 수행할 수 있는 작업
  );
  
  return key;
}

// 2. 텍스트 암호화하기
async function encryptData(text, key) {
  // 문자열을 Uint8Array로 변환
  const encoder = new TextEncoder();
  const data = encoder.encode(text);
  
  // 초기화 벡터(IV) 생성 - 매번 새로운 IV를 사용해야 해요!
  const iv = window.crypto.getRandomValues(new Uint8Array(12));
  
  // 암호화 수행
  const encryptedData = await window.crypto.subtle.encrypt(
    {
      name: "AES-GCM",
      iv: iv,
      tagLength: 128  // 인증 태그 길이
    },
    key,
    data
  );
  
  // 암호화된 데이터와 IV 반환 (둘 다 필요해요!)
  return {
    encryptedData: encryptedData,
    iv: iv
  };
}

// 3. 텍스트 복호화하기
async function decryptData(encryptedData, iv, key) {
  // 복호화 수행
  const decryptedData = await window.crypto.subtle.decrypt(
    {
      name: "AES-GCM",
      iv: iv,
      tagLength: 128
    },
    key,
    encryptedData
  );
  
  // Uint8Array를 다시 문자열로 변환
  const decoder = new TextDecoder();
  return decoder.decode(decryptedData);
}

// 실제 사용 예시
async function testAESEncryption() {
  try {
    // 암호화할 메시지
    const message = "안녕하세요! 이것은 비밀 메시지입니다. 🤫";
    console.log("원본 메시지:", message);
    
    // 키 생성
    const key = await generateAESKey();
    
    // 암호화
    const encrypted = await encryptData(message, key);
    console.log("암호화 완료!", encrypted);
    
    // 복호화
    const decrypted = await decryptData(encrypted.encryptedData, encrypted.iv, key);
    console.log("복호화된 메시지:", decrypted);
    
    // 결과 확인
    if (message === decrypted) {
      console.log("야호! 암호화/복호화 성공! 🎉");
    } else {
      console.log("앗, 뭔가 잘못됐어요... 😢");
    }
  } catch (error) {
    console.error("에러 발생:", error);
  }
}

// 함수 실행
testAESEncryption();

// 키 내보내기 (바이너리 형태로)
async function exportKey(key) {
  const exportedKey = await window.crypto.subtle.exportKey(
    "raw",  // 대칭키는 보통 "raw" 형식으로 내보내요
    key
  );
  
  // ArrayBuffer를 Base64 문자열로 변환 (저장하기 쉽게)
  return arrayBufferToBase64(exportedKey);
}

// 키 가져오기
async function importKey(keyData) {
  // Base64 문자열을 ArrayBuffer로 변환
  const keyBuffer = base64ToArrayBuffer(keyData);
  
  // 키 가져오기
  const key = await window.crypto.subtle.importKey(
    "raw",
    keyBuffer,
    {
      name: "AES-GCM",
      length: 256
    },
    true,
    ["encrypt", "decrypt"]
  );
  
  return key;
}

// ArrayBuffer를 Base64로 변환하는 헬퍼 함수
function arrayBufferToBase64(buffer) {
  const bytes = new Uint8Array(buffer);
  let binary = '';
  for (let i = 0; i < bytes.byteLength; i++) {
    binary += String.fromCharCode(bytes[i]);
  }
  return btoa(binary);
}

// Base64를 ArrayBuffer로 변환하는 헬퍼 함수
function base64ToArrayBuffer(base64) {
  const binaryString = atob(base64);
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }
  return bytes.buffer;
}

// RSA 키 쌍 생성하기
async function generateRSAKeyPair() {
  const keyPair = await window.crypto.subtle.generateKey(
    {
      name: "RSA-OAEP",
      modulusLength: 2048,  // 키 길이 (2048 또는 4096 비트 권장)
      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),  // 65537
      hash: "SHA-256"  // 해시 알고리즘
    },
    true,  // 내보내기 가능 여부
    ["encrypt", "decrypt"]  // 이 키로 수행할 수 있는 작업
  );
  
  return keyPair;  // { publicKey, privateKey } 객체 반환
}

// RSA로 데이터 암호화하기 (공개키 사용)
async function encryptWithRSA(data, publicKey) {
  // 문자열을 Uint8Array로 변환
  const encoder = new TextEncoder();
  const encodedData = encoder.encode(data);
  
  // 공개키로 암호화
  const encryptedData = await window.crypto.subtle.encrypt(
    {
      name: "RSA-OAEP"
    },
    publicKey,
    encodedData
  );
  
  return encryptedData;
}

// RSA로 데이터 복호화하기 (개인키 사용)
async function decryptWithRSA(encryptedData, privateKey) {
  // 개인키로 복호화
  const decryptedData = await window.crypto.subtle.decrypt(
    {
      name: "RSA-OAEP"
    },
    privateKey,
    encryptedData
  );
  
  // Uint8Array를 다시 문자열로 변환
  const decoder = new TextDecoder();
  return decoder.decode(decryptedData);
}

// RSA 암호화 테스트
async function testRSAEncryption() {
  try {
    // 암호화할 메시지
    const message = "이 메시지는 RSA로 암호화됩니다! 🔒";
    console.log("원본 메시지:", message);
    
    // RSA 키 쌍 생성
    const keyPair = await generateRSAKeyPair();
    console.log("RSA 키 쌍 생성 완료!", keyPair);
    
    // 공개키로 암호화
    const encryptedData = await encryptWithRSA(message, keyPair.publicKey);
    console.log("암호화 완료!", encryptedData);
    
    // 개인키로 복호화
    const decryptedMessage = await decryptWithRSA(encryptedData, keyPair.privateKey);
    console.log("복호화된 메시지:", decryptedMessage);
    
    // 결과 확인
    if (message === decryptedMessage) {
      console.log("야호! RSA 암호화/복호화 성공! 🎉");
    } else {
      console.log("앗, 뭔가 잘못됐어요... 😢");
    }
  } catch (error) {
    console.error("에러 발생:", error);
  }
}

// 함수 실행
testRSAEncryption();

// 하이브리드 암호화 구현하기
async function hybridEncrypt(data, publicKey) {
  // 1. 임시 AES 키 생성
  const aesKey = await generateAESKey();
  
  // 2. AES로 데이터 암호화
  const encryptedData = await encryptData(data, aesKey);
  
  // 3. AES 키를 RSA 공개키로 암호화
  const exportedAesKey = await window.crypto.subtle.exportKey("raw", aesKey);
  const encryptedAesKey = await encryptWithRSA(
    new Uint8Array(exportedAesKey), 
    publicKey
  );
  
  // 4. 암호화된 데이터와 암호화된 AES 키 반환
  return {
    encryptedData: encryptedData.encryptedData,
    iv: encryptedData.iv,
    encryptedAesKey: encryptedAesKey
  };
}

// 하이브리드 복호화 구현하기
async function hybridDecrypt(encryptedPackage, privateKey) {
  // 1. RSA 개인키로 AES 키 복호화
  const decryptedAesKeyBuffer = await decryptWithRSA(
    encryptedPackage.encryptedAesKey, 
    privateKey
  );
  
  // 2. 복호화된 AES 키 가져오기
  const aesKey = await window.crypto.subtle.importKey(
    "raw",
    decryptedAesKeyBuffer,
    { name: "AES-GCM", length: 256 },
    false,
    ["decrypt"]
  );
  
  // 3. AES 키로 데이터 복호화
  const decryptedData = await decryptData(
    encryptedPackage.encryptedData,
    encryptedPackage.iv,
    aesKey
  );
  
  return decryptedData;
}

// 데이터의 해시 생성하기
async function createHash(data, algorithm = 'SHA-256') {
  // 문자열을 Uint8Array로 변환
  const encoder = new TextEncoder();
  const encodedData = encoder.encode(data);
  
  // 해시 생성
  const hashBuffer = await window.crypto.subtle.digest(
    algorithm,  // 'SHA-1', 'SHA-256', 'SHA-384', 'SHA-512' 중 선택
    encodedData
  );
  
  // ArrayBuffer를 16진수 문자열로 변환
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
  
  return hashHex;
}

// 해시 함수 테스트
async function testHashFunctions() {
  const data = "안녕하세요! 이것은 해시 함수 테스트입니다.";
  
  console.log("원본 데이터:", data);
  
  // 다양한 해시 알고리즘으로 해시 생성
  const sha1Hash = await createHash(data, 'SHA-1');
  const sha256Hash = await createHash(data, 'SHA-256');
  const sha384Hash = await createHash(data, 'SHA-384');
  const sha512Hash = await createHash(data, 'SHA-512');
  
  console.log("SHA-1 해시:", sha1Hash);
  console.log("SHA-256 해시:", sha256Hash);
  console.log("SHA-384 해시:", sha384Hash);
  console.log("SHA-512 해시:", sha512Hash);
  
  // 데이터가 조금만 바뀌어도 해시가 완전히 달라지는지 테스트
  const modifiedData = "안녕하세요! 이것은 해시 함수 테스트입니다!"; // 마지막에 느낌표 추가
  const modifiedHash = await createHash(modifiedData);
  
  console.log("수정된 데이터:", modifiedData);
  console.log("수정된 데이터의 SHA-256 해시:", modifiedHash);
}

// 함수 실행
testHashFunctions();

// 파일의 해시 계산하기
async function calculateFileHash(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    
    reader.onload = async (event) => {
      try {
        const hashHex = await createHash(new Uint8Array(event.target.result));
        resolve(hashHex);
      } catch (error) {
        reject(error);
      }
    };
    
    reader.onerror = () => reject(reader.error);
    
    reader.readAsArrayBuffer(file);
  });
}

// 파일 무결성 검증 예시
async function verifyFileIntegrity(file, expectedHash) {
  try {
    const actualHash = await calculateFileHash(file);
    
    if (actualHash === expectedHash) {
      console.log("파일 무결성 검증 성공! 파일이 변경되지 않았어요. ✅");
      return true;
    } else {
      console.log("파일 무결성 검증 실패! 파일이 변경되었거나 손상되었어요. ❌");
      return false;
    }
  } catch (error) {
    console.error("파일 해시 계산 중 오류 발생:", error);
    return false;
  }
}

// 디지털 서명용 키 쌍 생성하기
async function generateSigningKeyPair() {
  const keyPair = await window.crypto.subtle.generateKey(
    {
      name: "ECDSA",  // 타원곡선 디지털 서명 알고리즘
      namedCurve: "P-256"  // 타원곡선 종류
    },
    true,  // 내보내기 가능 여부
    ["sign", "verify"]  // 이 키로 수행할 수 있는 작업
  );
  
  return keyPair;  // { publicKey, privateKey } 객체 반환
}

// 메시지에 서명하기
async function signMessage(message, privateKey) {
  // 문자열을 Uint8Array로 변환
  const encoder = new TextEncoder();
  const encodedMessage = encoder.encode(message);
  
  // 개인키로 서명 생성
  const signature = await window.crypto.subtle.sign(
    {
      name: "ECDSA",
      hash: {name: "SHA-256"}  // 서명에 사용할 해시 알고리즘
    },
    privateKey,
    encodedMessage
  );
  
  return signature;
}

// 서명 검증하기
async function verifySignature(message, signature, publicKey) {
  // 문자열을 Uint8Array로 변환
  const encoder = new TextEncoder();
  const encodedMessage = encoder.encode(message);
  
  // 공개키로 서명 검증
  const isValid = await window.crypto.subtle.verify(
    {
      name: "ECDSA",
      hash: {name: "SHA-256"}
    },
    publicKey,
    signature,
    encodedMessage
  );
  
  return isValid;  // true 또는 false 반환
}

// 디지털 서명 테스트
async function testDigitalSignature() {
  try {
    // 서명할 메시지
    const message = "이 메시지는 디지털 서명으로 보호됩니다! 👍";
    console.log("원본 메시지:", message);
    
    // 서명용 키 쌍 생성
    const keyPair = await generateSigningKeyPair();
    console.log("서명용 키 쌍 생성 완료!", keyPair);
    
    // 메시지에 서명
    const signature = await signMessage(message, keyPair.privateKey);
    console.log("서명 생성 완료!", signature);
    
    // 서명 검증 (원본 메시지)
    const isValidOriginal = await verifySignature(message, signature, keyPair.publicKey);
    console.log("원본 메시지 서명 검증 결과:", isValidOriginal);
    
    // 서명 검증 (변경된 메시지)
    const alteredMessage = "이 메시지는 변경되었습니다! 😈";
    const isValidAltered = await verifySignature(alteredMessage, signature, keyPair.publicKey);
    console.log("변경된 메시지 서명 검증 결과:", isValidAltered);
    
  } catch (error) {
    console.error("에러 발생:", error);
  }
}

// 함수 실행
testDigitalSignature();

// 문서 서명 시스템
class DocumentSigningSystem {
  constructor() {
    this.keyPair = null;
  }
  
  // 사용자 키 쌍 초기화
  async initializeUser() {
    this.keyPair = await generateSigningKeyPair();
    console.log("사용자 키 쌍이 생성되었습니다!");
    return this.keyPair;
  }
  
  // 문서 서명하기
  async signDocument(document) {
    if (!this.keyPair) {
      throw new Error("키 쌍이 초기화되지 않았습니다. initializeUser()를 먼저 호출하세요.");
    }
    
    // 문서 내용을 JSON 문자열로 변환
    const documentString = JSON.stringify(document);
    
    // 서명 생성
    const signature = await signMessage(documentString, this.keyPair.privateKey);
    
    // 서명된 문서 패키지 생성
    return {
      document: document,
      signature: new Uint8Array(signature),
      timestamp: new Date().toISOString(),
      publicKey: this.keyPair.publicKey  // 실제로는 내보낸 공개키를 저장해야 해요
    };
  }
  
  // 서명된 문서 검증하기
  async verifySignedDocument(signedPackage) {
    // 문서 내용을 JSON 문자열로 변환
    const documentString = JSON.stringify(signedPackage.document);
    
    // 서명 검증
    const isValid = await verifySignature(
      documentString,
      signedPackage.signature,
      signedPackage.publicKey
    );
    
    return {
      isValid: isValid,
      document: signedPackage.document,
      timestamp: signedPackage.timestamp
    };
  }
}

// 비밀번호 기반 키 도출 함수 (PBKDF2)
async function deriveKeyFromPassword(password, salt, iterations = 100000) {
  // 비밀번호를 Uint8Array로 변환
  const encoder = new TextEncoder();
  const passwordBuffer = encoder.encode(password);
  
  // 솔트가 없으면 새로 생성
  if (!salt) {
    salt = window.crypto.getRandomValues(new Uint8Array(16));
  }
  
  // 비밀번호에서 키 재료 도출
  const keyMaterial = await window.crypto.subtle.importKey(
    "raw",
    passwordBuffer,
    { name: "PBKDF2" },
    false,
    ["deriveBits", "deriveKey"]
  );
  
  // PBKDF2로 AES 키 도출
  const derivedKey = await window.crypto.subtle.deriveKey(
    {
      name: "PBKDF2",
      salt: salt,
      iterations: iterations,
      hash: "SHA-256"
    },
    keyMaterial,
    { name: "AES-GCM", length: 256 },
    true,
    ["encrypt", "decrypt"]
  );
  
  return {
    key: derivedKey,
    salt: salt
  };
}

// 키 교체 관리자 클래스
class KeyRotationManager {
  constructor(storageProvider) {
    this.storage = storageProvider;
    this.currentKeyId = null;
  }
  
  // 새 키 생성 및 저장
  async generateNewKey() {
    // 새 AES 키 생성
    const key = await generateAESKey();
    
    // 키 ID 생성 (타임스탬프 + 랜덤값)
    const keyId = `key-${Date.now()}-${Math.random().toString(36).substring(2, 10)}`;
    
    // 키 내보내기
    const exportedKey = await window.crypto.subtle.exportKey("raw", key);
    const keyBase64 = arrayBufferToBase64(exportedKey);
    
    // 키 메타데이터 생성
    const keyData = {
      id: keyId,
      key: keyBase64,
      created: new Date().toISOString(),
      expires: new Date(Date.now() + (90 * 24 * 60 * 60 * 1000)).toISOString(), // 90일 후 만료
      active: true
    };
    
    // 이전 키 비활성화
    if (this.currentKeyId) {
      const oldKeyData = await this.storage.getKey(this.currentKeyId);
      if (oldKeyData) {
        oldKeyData.active = false;
        await this.storage.saveKey(oldKeyData);
      }
    }
    
    // 새 키 저장
    await this.storage.saveKey(keyData);
    this.currentKeyId = keyId;
    
    return {
      keyId: keyId,
      key: key
    };
  }
  
  // 현재 활성 키 가져오기
  async getCurrentKey() {
    if (!this.currentKeyId) {
      // 저장소에서 활성 키 찾기
      const activeKey = await this.storage.findActiveKey();
      
      if (!activeKey) {
        // 활성 키가 없으면 새로 생성
        return this.generateNewKey();
      }
      
      this.currentKeyId = activeKey.id;
      
      // 키 만료 확인
      if (new Date(activeKey.expires) < new Date()) {
        // 만료된 경우 새 키 생성
        return this.generateNewKey();
      }
      
      // 키 가져오기
      const keyBuffer = base64ToArrayBuffer(activeKey.key);
      const key = await window.crypto.subtle.importKey(
        "raw",
        keyBuffer,
        { name: "AES-GCM", length: 256 },
        true,
        ["encrypt", "decrypt"]
      );
      
      return {
        keyId: activeKey.id,
        key: key
      };
    } else {
      // 현재 키 ID가 있으면 해당 키 가져오기
      const keyData = await this.storage.getKey(this.currentKeyId);
      
      // 키 만료 확인
      if (new Date(keyData.expires) < new Date()) {
        // 만료된 경우 새 키 생성
        return this.generateNewKey();
      }
      
      // 키 가져오기
      const keyBuffer = base64ToArrayBuffer(keyData.key);
      const key = await window.crypto.subtle.importKey(
        "raw",
        keyBuffer,
        { name: "AES-GCM", length: 256 },
        true,
        ["encrypt", "decrypt"]
      );
      
      return {
        keyId: keyData.id,
        key: key
      };
    }
  }
}

// 안전한 채팅 애플리케이션 클래스
class SecureChatApp {
  constructor() {
    this.keyPair = null;
    this.sessionKeys = new Map(); // 다른 사용자와의 세션 키 저장
  }
  
  // 사용자 초기화 (키 쌍 생성)
  async initUser() {
    // RSA 키 쌍 생성
    this.keyPair = await generateRSAKeyPair();
    
    // 공개키 내보내기 (서버에 등록하기 위해)
    const exportedPublicKey = await window.crypto.subtle.exportKey(
      "spki",
      this.keyPair.publicKey
    );
    
    // Base64로 변환
    const publicKeyBase64 = arrayBufferToBase64(exportedPublicKey);
    
    return publicKeyBase64;
  }
  
  // 다른 사용자와 세션 키 설정
  async establishSessionWith(userId, theirPublicKeyBase64) {
    // 상대방 공개키 가져오기
    const theirPublicKeyBuffer = base64ToArrayBuffer(theirPublicKeyBase64);
    const theirPublicKey = await window.crypto.subtle.importKey(
      "spki",
      theirPublicKeyBuffer,
      {
        name: "RSA-OAEP",
        hash: "SHA-256"
      },
      true,
      ["encrypt"]
    );
    
    // 새 AES 세션 키 생성
    const sessionKey = await generateAESKey();
    
    // 세션 키 내보내기
    const exportedSessionKey = await window.crypto.subtle.exportKey(
      "raw",
      sessionKey
    );
    
    // 세션 키를 상대방 공개키로 암호화
    const encryptedSessionKey = await encryptWithRSA(
      new Uint8Array(exportedSessionKey),
      theirPublicKey
    );
    
    // 세션 키 저장
    this.sessionKeys.set(userId, sessionKey);
    
    // 암호화된 세션 키 반환 (상대방에게 전송)
    return arrayBufferToBase64(encryptedSessionKey);
  }
  
  // 상대방이 보낸 암호화된 세션 키 처리
  async receiveEncryptedSessionKey(userId, encryptedSessionKeyBase64) {
    // Base64 디코딩
    const encryptedSessionKeyBuffer = base64ToArrayBuffer(encryptedSessionKeyBase64);
    
    // 개인키로 세션 키 복호화
    const sessionKeyBuffer = await decryptWithRSA(
      encryptedSessionKeyBuffer,
      this.keyPair.privateKey
    );
    
    // 세션 키 가져오기
    const sessionKey = await window.crypto.subtle.importKey(
      "raw",
      sessionKeyBuffer,
      {
        name: "AES-GCM",
        length: 256
      },
      true,
      ["encrypt", "decrypt"]
    );
    
    // 세션 키 저장
    this.sessionKeys.set(userId, sessionKey);
    
    return true;
  }
  
  // 메시지 암호화
  async encryptMessage(userId, message) {
    const sessionKey = this.sessionKeys.get(userId);
    if (!sessionKey) {
      throw new Error(`${userId}와의 세션 키가 설정되지 않았습니다.`);
    }
    
    // AES-GCM으로 메시지 암호화
    const encrypted = await encryptData(message, sessionKey);
    
    // 암호화된 메시지와 IV를 Base64로 변환
    return {
      encryptedMessage: arrayBufferToBase64(encrypted.encryptedData),
      iv: arrayBufferToBase64(encrypted.iv)
    };
  }
  
  // 메시지 복호화
  async decryptMessage(userId, encryptedMessageBase64, ivBase64) {
    const sessionKey = this.sessionKeys.get(userId);
    if (!sessionKey) {
      throw new Error(`${userId}와의 세션 키가 설정되지 않았습니다.`);
    }
    
    // Base64 디코딩
    const encryptedMessageBuffer = base64ToArrayBuffer(encryptedMessageBase64);
    const ivBuffer = base64ToArrayBuffer(ivBase64);
    
    // AES-GCM으로 메시지 복호화
    const decryptedMessage = await decryptData(
      encryptedMessageBuffer,
      ivBuffer,
      sessionKey
    );
    
    return decryptedMessage;
  }
}

// 안전한 파일 공유 시스템
class SecureFileSharing {
  constructor() {
    this.keyManager = new KeyRotationManager(/* 스토리지 제공자 */);
  }
  
  // 파일 암호화
  async encryptFile(file) {
    // 현재 활성 키 가져오기
    const { keyId, key } = await this.keyManager.getCurrentKey();
    
    return new Promise((resolve, reject) => {
      const reader = new FileReader();
      
      reader.onload = async (event) => {
        try {
          // 파일 데이터를 Uint8Array로 변환
          const fileData = new Uint8Array(event.target.result);
          
          // AES-GCM으로 파일 암호화
          const iv = window.crypto.getRandomValues(new Uint8Array(12));
          const encryptedData = await window.crypto.subtle.encrypt(
            {
              name: "AES-GCM",
              iv: iv,
              tagLength: 128
            },
            key,
            fileData
          );
          
          // 암호화된 파일 메타데이터 생성
          const encryptedFile = {
            name: file.name,
            type: file.type,
            size: file.size,
            keyId: keyId,
            iv: arrayBufferToBase64(iv),
            encryptedData: encryptedData, // ArrayBuffer 형태
            timestamp: new Date().toISOString()
          };
          
          resolve(encryptedFile);
        } catch (error) {
          reject(error);
        }
      };
      
      reader.onerror = () => reject(reader.error);
      
      reader.readAsArrayBuffer(file);
    });
  }
  
  // 파일 복호화
  async decryptFile(encryptedFile) {
    // 키 ID로 키 가져오기
    const keyData = await this.storage.getKey(encryptedFile.keyId);
    if (!keyData) {
      throw new Error(`키 ID ${encryptedFile.keyId}를 찾을 수 없습니다.`);
    }
    
    // 키 가져오기
    const keyBuffer = base64ToArrayBuffer(keyData.key);
    const key = await window.crypto.subtle.importKey(
      "raw",
      keyBuffer,
      { name: "AES-GCM", length: 256 },
      false,
      ["decrypt"]
    );
    
    // IV 가져오기
    const iv = base64ToArrayBuffer(encryptedFile.iv);
    
    // 파일 복호화
    const decryptedData = await window.crypto.subtle.decrypt(
      {
        name: "AES-GCM",
        iv: iv,
        tagLength: 128
      },
      key,
      encryptedFile.encryptedData
    );
    
    // 복호화된 파일 생성
    const decryptedFile = new File(
      [decryptedData],
      encryptedFile.name,
      { type: encryptedFile.type }
    );
    
    return decryptedFile;
  }
  
  // 파일 공유 링크 생성
  async generateShareLink(encryptedFile, recipients) {
    // 파일 암호화에 사용된 키 가져오기
    const keyData = await this.storage.getKey(encryptedFile.keyId);
    
    // 각 수신자별로 처리
    const recipientData = await Promise.all(recipients.map(async (recipient) => {
      // 수신자의 공개키 가져오기
      const recipientPublicKey = await fetchRecipientPublicKey(recipient.id);
      
      // 파일 키를 수신자의 공개키로 암호화
      const encryptedKey = await encryptWithRSA(
        base64ToArrayBuffer(keyData.key),
        recipientPublicKey
      );
      
      return {
        recipientId: recipient.id,
        encryptedKey: arrayBufferToBase64(encryptedKey)
      };
    }));
    
    // 공유 정보 생성
    const shareInfo = {
      fileId: generateUniqueId(),
      encryptedFile: {
        name: encryptedFile.name,
        type: encryptedFile.type,
        size: encryptedFile.size,
        iv: encryptedFile.iv,
        // 실제 구현에서는 encryptedData를 서버에 업로드하고 URL만 저장
      },
      recipients: recipientData,
      expires: new Date(Date.now() + (7 * 24 * 60 * 60 * 1000)).toISOString() // 7일 후 만료
    };
    
    // 공유 정보 저장 및 링크 생성
    const shareId = await saveShareInfo(shareInfo);
    return `https://example.com/share/${shareId}`;
  }
}

// 비밀번호 관리자 클래스
class PasswordManager {
  constructor() {
    this.masterKey = null;
    this.passwords = [];
  }
  
  // 마스터 비밀번호로 키 생성
  async setMasterPassword(password) {
    // 솔트 생성
    const salt = window.crypto.getRandomValues(new Uint8Array(16));
    
    // PBKDF2로 마스터 키 도출
    const keyData = await deriveKeyFromPassword(password, salt, 200000);
    this.masterKey = keyData.key;
    
    // 솔트 저장 (안전한 저장소에)
    localStorage.setItem('pm_salt', arrayBufferToBase64(salt));
    
    return true;
  }
  
  // 마스터 비밀번호 확인 및 키 복원
  async unlockWithMasterPassword(password) {
    // 저장된 솔트 가져오기
    const saltBase64 = localStorage.getItem('pm_salt');
    if (!saltBase64) {
      throw new Error('저장된 솔트를 찾을 수 없습니다. 마스터 비밀번호를 설정했나요?');
    }
    
    const salt = base64ToArrayBuffer(saltBase64);
    
    // 마스터 키 도출
    const keyData = await deriveKeyFromPassword(password, salt, 200000);
    this.masterKey = keyData.key;
    
    // 저장된 비밀번호 불러오기 및 복호화
    await this.loadPasswords();
    
    return true;
  }
  
  // 비밀번호 추가
  async addPassword(site, username, password) {
    if (!this.masterKey) {
      throw new Error('마스터 키가 설정되지 않았습니다. 먼저 마스터 비밀번호를 입력하세요.');
    }
    
    // 비밀번호 암호화
    const encryptedPassword = await encryptData(password, this.masterKey);
    
    // 비밀번호 항목 생성
    const passwordEntry = {
      id: generateUniqueId(),
      site: site,
      username: username,
      encryptedPassword: arrayBufferToBase64(encryptedPassword.encryptedData),
      iv: arrayBufferToBase64(encryptedPassword.iv),
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString()
    };
    
    // 비밀번호 목록에 추가
    this.passwords.push(passwordEntry);
    
    // 변경사항 저장
    await this.savePasswords();
    
    return passwordEntry.id;
  }
  
  // 비밀번호 가져오기
  async getPassword(id) {
    if (!this.masterKey) {
      throw new Error('마스터 키가 설정되지 않았습니다. 먼저 마스터 비밀번호를 입력하세요.');
    }
    
    // ID로 비밀번호 항목 찾기
    const passwordEntry = this.passwords.find(entry => entry.id === id);
    if (!passwordEntry) {
      throw new Error(`ID ${id}에 해당하는 비밀번호를 찾을 수 없습니다.`);
    }
    
    // 비밀번호 복호화
    const encryptedPasswordBuffer = base64ToArrayBuffer(passwordEntry.encryptedPassword);
    const ivBuffer = base64ToArrayBuffer(passwordEntry.iv);
    
    const decryptedPassword = await decryptData(
      encryptedPasswordBuffer,
      ivBuffer,
      this.masterKey
    );
    
    return {
      site: passwordEntry.site,
      username: passwordEntry.username,
      password: decryptedPassword
    };
  }
  
  // 비밀번호 목록 저장
  async savePasswords() {
    if (!this.masterKey) {
      throw new Error('마스터 키가 설정되지 않았습니다.');
    }
    
    // 비밀번호 목록 암호화
    const passwordsString = JSON.stringify(this.passwords);
    const encryptedPasswords = await encryptData(passwordsString, this.masterKey);
    
    // 암호화된 비밀번호 목록 저장
    localStorage.setItem('pm_passwords', arrayBufferToBase64(encryptedPasswords.encryptedData));
    localStorage.setItem('pm_passwords_iv', arrayBufferToBase64(encryptedPasswords.iv));
  }
  
  // 비밀번호 목록 불러오기
  async loadPasswords() {
    if (!this.masterKey) {
      throw new Error('마스터 키가 설정되지 않았습니다.');
    }
    
    // 암호화된 비밀번호 목록 가져오기
    const encryptedPasswordsBase64 = localStorage.getItem('pm_passwords');
    const ivBase64 = localStorage.getItem('pm_passwords_iv');
    
    if (!encryptedPasswordsBase64 || !ivBase64) {
      // 저장된 비밀번호가 없으면 빈 배열로 초기화
      this.passwords = [];
      return;
    }
    
    // 비밀번호 목록 복호화
    const encryptedPasswordsBuffer = base64ToArrayBuffer(encryptedPasswordsBase64);
    const ivBuffer = base64ToArrayBuffer(ivBase64);
    
    const decryptedPasswordsString = await decryptData(
      encryptedPasswordsBuffer,
      ivBuffer,
      this.masterKey
    );
    
    // JSON 파싱
    this.passwords = JSON.parse(decryptedPasswordsString);
  }
}