# 緊急時の一括削除（全 EXIF 除去）
exiftool -all= *.jpg
# または ImageMagick
magick mogrify -strip *.jpg

// Node.js + sharp による選択的処理
import sharp from 'sharp'

export async function safeMetadataClean(inputPath, outputPath) {
  const metadata = await sharp(inputPath).metadata()
  
  // 危険な EXIF フィールドの除去
  await sharp(inputPath)
    .rotate() // Orientation を適用して正立化
    .withMetadata({
      // 最小限の安全な情報のみ保持
      icc: 'sRGB', // カラープロファイルは sRGB に統一
      // 著作権情報は業務要件に応じて保持/削除を判断
    })
    .jpeg({ quality: 90 }) // 適切な品質で再圧縮
    .toFile(outputPath)
}

#!/bin/bash
# 監視フォルダベースの自動処理スクリプト

WATCH_DIR="/path/to/incoming"
OUTPUT_DIR="/path/to/cleaned"
BACKUP_DIR="/path/to/backup"

# inotify で新規ファイルを監視
inotifywait -m -e create --format '%w%f' "$WATCH_DIR" | while read FILE
do
  if [[ "$FILE" =~ \.(jpg|jpeg|png|tiff)$ ]]; then
    echo "Processing: $FILE"
    
    # 1. バックアップ作成
    cp "$FILE" "$BACKUP_DIR/"
    
    # 2. EXIF 除去 + 自動回転
    exiftool -all= -tagsFromFile @ -ColorSpace -Orientation "$FILE"
    
    # 3. sRGB 正規化 + リサイズ
    magick "$FILE" -colorspace sRGB -auto-orient -resize 1920x1920\> \
           -quality 85 "$OUTPUT_DIR/$(basename "$FILE")"
    
    echo "Cleaned: $(basename "$FILE")"
  fi
done

# GitHub Actions での EXIF チェック例
name: Image Metadata Security Check

on: [pull_request]

jobs:
  metadata-audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Install ExifTool
        run: sudo apt-get install -y libimage-exiftool-perl
      
      - name: Scan for sensitive metadata
        run: |
          # GPS 情報の検査
          if exiftool -r -GPS* . | grep -q "GPS"; then
            echo "::error::GPS metadata found in images"
            exit 1
          fi
          
          # デバイス固有情報の検査
          if exiftool -r -SerialNumber -CameraOwnerName . | grep -v "ExifTool" | grep -q ":"; then
            echo "::error::Device-specific metadata found"
            exit 1
          fi
          
          echo "Metadata security check passed"

// 業務要件での例外処理例
const ALLOWED_METADATA_FIELDS = [
  'ImageWidth',
  'ImageHeight', 
  'BitsPerSample',
  'Copyright' // 企業著作権表示は保持
]

async function businessMetadataPolicy(imagePath, businessContext) {
  const metadata = await extractMetadata(imagePath)
  
  if (businessContext.type === 'marketing') {
    // マーケティング素材は著作権情報を保持
    return cleanMetadata(metadata, [...ALLOWED_METADATA_FIELDS, 'Artist'])
  } else if (businessContext.type === 'user_generated') {
    // ユーザー投稿は最小限のみ
    return cleanMetadata(metadata, ALLOWED_METADATA_FIELDS.slice(0, 3))
  }
  
  // デフォルトは最も厳格な除去
  return stripAllMetadata(metadata)
}

// 並列処理による高速化
import pLimit from 'p-limit'

const limit = pLimit(4) // 同時処理数制限

async function batchCleanMetadata(imagePaths) {
  const promises = imagePaths.map(path => 
    limit(() => safeMetadataClean(path, `cleaned_${path}`))
  )
  
  const results = await Promise.allSettled(promises)
  
  // エラーハンドリング
  results.forEach((result, index) => {
    if (result.status === 'rejected') {
      console.error(`Failed to process ${imagePaths[index]}:`, result.reason)
    }
  })
}

// AWS Lambda での自動処理例
export const handler = async (event: S3Event) => {
  for (const record of event.Records) {
    const bucket = record.s3.bucket.name
    const key = record.s3.object.key
    
    if (!isImageFile(key)) continue
    
    try {
      // S3 から画像取得
      const imageBuffer = await s3.getObject({ Bucket: bucket, Key: key }).promise()
      
      // メタデータクリーニング
      const cleanedBuffer = await cleanImageMetadata(imageBuffer.Body)
      
      // クリーニング済み画像を別バケットに保存
      await s3.putObject({
        Bucket: `${bucket}-cleaned`,
        Key: key,
        Body: cleanedBuffer,
        ContentType: 'image/jpeg'
      }).promise()
      
    } catch (error) {
      console.error(`Processing failed for ${key}:`, error)
    }
  }
}

// 処理ログの記録例
async function auditableMetadataProcessing(imagePath, policy) {
  const startTime = Date.now()
  const originalMetadata = await extractMetadata(imagePath)
  
  try {
    const cleanedMetadata = await applyPolicy(originalMetadata, policy)
    
    // 監査ログ記録
    await logMetadataOperation({
      timestamp: new Date().toISOString(),
      filePath: imagePath,
      operation: 'metadata_cleaning',
      policy: policy.name,
      fieldsRemoved: Object.keys(originalMetadata).filter(
        key => !(key in cleanedMetadata)
      ),
      processingTimeMs: Date.now() - startTime,
      status: 'success'
    })
    
    return cleanedMetadata
  } catch (error) {
    await logMetadataOperation({
      timestamp: new Date().toISOString(),
      filePath: imagePath,
      operation: 'metadata_cleaning',
      status: 'failed',
      error: error.message
    })
    throw error
  }
}