Tauri のセキュリティ対策ベストプラクティス

2025年8月7日

Tauri

近年、デスクトップアプリケーション開発において注目を集めているTauriですが、セキュリティ対策は開発者にとって避けて通れない重要な課題となっています。

Webベースのフロントエンドとネイティブなバックエンドを組み合わせるTauriアプリケーションでは、従来のWebアプリケーションやネイティブアプリケーションとは異なる特有のセキュリティリスクが存在します。適切なセキュリティ対策を講じることで、ユーザーの大切なデータを守り、信頼性の高いアプリケーションを提供できるでしょう。

本記事では、Tauriアプリケーションを安全に開発・運用するために必要なセキュリティ対策について、基本的な設定から実装例まで詳しく解説いたします。

Tauriにおけるセキュリティの重要性

Tauriアプリが直面する脅威

Tauriアプリケーションは、WebViewを使用してHTMLとJavaScriptでUIを構築し、Rustで書かれたバックエンドと通信を行うハイブリッドな構造を持っています。この特徴により、以下のような複数のセキュリティ脅威に晒される可能性があります。

脅威の種類	説明	影響範囲
1	コード注入攻撃	フロントエンド側での悪意あるスクリプト実行
2	権限昇格攻撃	不正なシステムリソースへのアクセス
3	データ漏洩	機密情報の不正な外部送信
4	ファイルシステムへの不正アクセス	ローカルファイルの改ざん・削除

セキュリティ対策の必要性

従来のWebアプリケーションではブラウザのサンドボックス機能によってある程度の保護が提供されますが、Tauriアプリケーションではネイティブシステムへの直接アクセスが可能なため、より厳格なセキュリティ対策が求められます。

適切なセキュリティ対策を講じないと、以下のような深刻な問題が発生する恐れがあります。

ユーザーの個人情報や機密データの漏洩
システムファイルの破壊やマルウェアの感染
企業の信頼性やブランド価値の失墜
法的責任や賠償問題の発生

基本的なセキュリティ設定

tauri.conf.jsonの設定

Tauriアプリケーションのセキュリティの根幹となるのがtauri.conf.jsonファイルの設定です。このファイルで適切なセキュリティポリシーを定義することで、アプリケーション全体のセキュリティレベルを向上させることができます。

まず、基本的なセキュリティ設定を見てみましょう。

json{
  "build": {
    "beforeBuildCommand": "",
    "beforeDevCommand": "",
    "devPath": "../dist",
    "distDir": "../dist"
  },
  "package": {
    "productName": "secure-app",
    "version": "0.1.0"
  },
  "tauri": {
    "security": {
      "csp": "default-src 'self'; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline';"
    }
  }
}

上記の設定では、Content Security Policy（CSP）を定義しています。default-src 'self'により、リソースの読み込みを同一オリジンに制限し、外部からの不正なコンテンツ読み込みを防止します。

次に、より詳細なセキュリティ設定を追加していきます。

json{
  "tauri": {
    "security": {
      "csp": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; connect-src 'self' https:",
      "dangerousDisableAssetCspModification": false,
      "freezePrototype": true,
      "pattern": {
        "use": "brownfield"
      }
    },
    "allowlist": {
      "all": false,
      "shell": {
        "all": false,
        "execute": false,
        "open": false
      },
      "fs": {
        "all": false,
        "readFile": false,
        "writeFile": false,
        "createDir": false,
        "removeDir": false,
        "removeFile": false
      }
    }
  }
}

この設定により、すべてのAPI機能を明示的に無効化し、必要な機能のみを個別に有効化する「最小権限の原則」を実現できます。

権限管理（permissions）

Tauriでは、アプリケーションが使用できる機能を細かく制御する権限システムを提供しています。適切な権限設定により、不要な機能へのアクセスを制限し、攻撃対象を最小化できます。

権限の設定は、先ほどのallowlistセクションで行います。以下は、ファイル読み書き機能を安全に有効化する例です。

json{
  "tauri": {
    "allowlist": {
      "fs": {
        "all": false,
        "readFile": true,
        "writeFile": true,
        "scope": [
          "$APPDATA/myapp/*",
          "$DOCUMENT/*"
        ]
      }
    }
  }
}

この設定では、ファイルの読み書きを特定のディレクトリ（アプリケーションデータフォルダとドキュメントフォルダ）に制限しています。scopeパラメータを使用することで、アクセス可能なパスを明確に定義できます。

HTTP通信を行う場合の権限設定も見てみましょう。

json{
  "tauri": {
    "allowlist": {
      "http": {
        "all": false,
        "request": true,
        "scope": [
          "https://api.myapp.com/*",
          "https://*.trusted-domain.com/*"
        ]
      }
    }
  }
}

この設定により、HTTPリクエストを信頼できるドメインのみに制限し、不正な外部通信を防止できます。

CSPの設定

Content Security Policy（CSP）は、XSS攻撃やデータ注入攻撃を防ぐための重要なセキュリティ機能です。Tauriでは、WebViewで表示されるコンテンツに対してCSPを適用できます。

基本的なCSPの設定から見ていきましょう。

json{
  "tauri": {
    "security": {
      "csp": "default-src 'self'"
    }
  }
}

これは最も厳格な設定で、すべてのリソースを同一オリジンからの読み込みに制限します。実際のアプリケーションでは、必要に応じてより柔軟な設定が必要になる場合があります。

より実用的なCSPの設定例をご紹介します。

json{
  "tauri": {
    "security": {
      "csp": "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; connect-src 'self' wss: https:; font-src 'self' data:;"
    }
  }
}

この設定の各ディレクティブの意味は以下の通りです。

ディレクティブ	設定値	説明
1	`default-src 'self'`	デフォルトですべてのリソースを同一オリジンに制限
2	`script-src 'self' 'wasm-unsafe-eval'`	スクリプトとWebAssemblyの実行を許可
3	`style-src 'self' 'unsafe-inline'`	インラインCSSの使用を許可
4	`img-src 'self' data: https:`	画像をローカル、データURL、HTTPSから読み込み許可
5	`connect-src 'self' wss: https:`	WebSocket とHTTPS通信を許可

フロントエンド側のセキュリティ対策

XSS防止

クロスサイトスクリプティング（XSS）攻撃は、Webベースのフロントエンドを持つTauriアプリケーションでも重要な脅威となります。適切な対策を講じることで、悪意あるスクリプトの実行を防止できます。

まず、ユーザー入力を表示する際のサニタイゼーション処理を実装しましょう。

typescript// XSS防止のためのサニタイゼーション関数
function sanitizeHTML(input: string): string {
  const div = document.createElement('div');
  div.textContent = input;
  return div.innerHTML;
}

// 使用例
function displayUserInput(userInput: string) {
  const sanitized = sanitizeHTML(userInput);
  document.getElementById('output').innerHTML = sanitized;
}

この関数は、HTMLタグや特殊文字を安全な形式にエスケープし、スクリプトの実行を防止します。

さらに、DOMPurifyライブラリを使用したより堅牢なサニタイゼーション方法もご紹介します。

typescriptimport DOMPurify from 'dompurify';

// DOMPurifyを使用した高度なサニタイゼーション
function secureSanitize(input: string): string {
  return DOMPurify.sanitize(input, {
    ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'p', 'br'],
    ALLOWED_ATTR: []
  });
}

// リッチテキストコンテンツの安全な表示
function displayRichContent(content: string) {
  const cleanContent = secureSanitize(content);
  document.getElementById('content').innerHTML = cleanContent;
}

DOMPurifyを使用することで、許可するHTMLタグや属性を細かく制御し、より安全なコンテンツ表示が可能になります。

入力値検証

ユーザーからの入力値は常に検証し、予期しない値や悪意ある値の処理を防ぐ必要があります。フロントエンド側での入力値検証は、ユーザビリティの向上とセキュリティの両方に寄与します。

基本的な入力値検証の実装例を見てみましょう。

typescript// 入力値検証のためのバリデーター
class InputValidator {
  // 文字列の長さチェック
  static validateLength(input: string, min: number, max: number): boolean {
    return input.length >= min && input.length <= max;
  }

  // 英数字のみかチェック
  static validateAlphaNumeric(input: string): boolean {
    const regex = /^[a-zA-Z0-9]+$/;
    return regex.test(input);
  }

  // メールアドレスの形式チェック
  static validateEmail(email: string): boolean {
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return regex.test(email);
  }
}

これらのバリデーター関数を使用して、フォーム入力の検証を実装します。

typescript// フォーム送信時の検証処理
function handleFormSubmit(event: Event) {
  event.preventDefault();
  
  const formData = new FormData(event.target as HTMLFormElement);
  const username = formData.get('username') as string;
  const email = formData.get('email') as string;

  // 入力値の検証
  if (!InputValidator.validateLength(username, 3, 20)) {
    showError('ユーザー名は3文字以上20文字以下で入力してください。');
    return;
  }

  if (!InputValidator.validateAlphaNumeric(username)) {
    showError('ユーザー名は英数字のみ使用可能です。');
    return;
  }

  if (!InputValidator.validateEmail(email)) {
    showError('有効なメールアドレスを入力してください。');
    return;
  }

  // 検証をパスした場合の処理
  submitToBackend({ username, email });
}

この実装により、不正な入力値がバックエンドに送信されることを防げます。

バックエンド（Rust）側のセキュリティ対策

コマンド実行時の検証

Tauriのバックエンドでは、フロントエンドからのコマンド呼び出しを処理する際に、適切な検証とセキュリティチェックを実装する必要があります。すべての入力値を信頼せず、厳格な検証を行うことが重要です。

まず、基本的なコマンドハンドラーの安全な実装例をご紹介します。

rustuse tauri::State;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Deserialize)]
struct UserInput {
    username: String,
    email: String,
}

#[derive(Debug, Serialize)]
struct ValidationError {
    field: String,
    message: String,
}

入力値の検証を行うバリデーター関数を実装します。

rust// 入力値検証のための関数群
fn validate_username(username: &str) -> Result<(), String> {
    if username.len() < 3 || username.len() > 20 {
        return Err("ユーザー名は3文字以上20文字以下である必要があります".to_string());
    }

    if !username.chars().all(|c| c.is_alphanumeric()) {
        return Err("ユーザー名は英数字のみ使用可能です".to_string());
    }

    Ok(())
}

fn validate_email(email: &str) -> Result<(), String> {
    // 簡単なメールアドレス検証（実際にはより厳密な検証が推奨されます）
    if !email.contains('@') || !email.contains('.') {
        return Err("有効なメールアドレスを入力してください".to_string());
    }

    if email.len() > 254 {
        return Err("メールアドレスが長すぎます".to_string());
    }

    Ok(())
}

これらの検証関数を使用したセキュアなコマンドハンドラーを実装します。

rust#[tauri::command]
async fn create_user(input: UserInput) -> Result<String, String> {
    // 入力値の検証
    if let Err(error) = validate_username(&input.username) {
        return Err(error);
    }

    if let Err(error) = validate_email(&input.email) {
        return Err(error);
    }

    // SQLインジェクション対策のためのパラメータ化クエリの使用
    // ここでは擬似的な実装を示します
    match save_user_to_database(&input.username, &input.email).await {
        Ok(_) => Ok("ユーザーが正常に作成されました".to_string()),
        Err(e) => Err(format!("データベースエラー: {}", e))
    }
}

// データベース保存の擬似実装
async fn save_user_to_database(username: &str, email: &str) -> Result<(), String> {
    // 実際の実装では、パラメータ化クエリを使用してSQLインジェクションを防ぎます
    // 例: sqlx や diesel を使用した安全な実装
    Ok(())
}

ファイルアクセス制御

ファイルシステムへのアクセスは、セキュリティ上特に注意が必要な領域です。適切なパス検証とアクセス制御を実装することで、不正なファイルアクセスを防止できます。

まず、安全なファイルパス検証の実装を見てみましょう。

rustuse std::path::{Path, PathBuf};
use tauri::api::path;

// 許可されたディレクトリのリスト
const ALLOWED_DIRECTORIES: &[&str] = &[
    "documents",
    "appdata",
    "temp"
];

fn validate_file_path(file_path: &str) -> Result<PathBuf, String> {
    // パストラバーサル攻撃の防止
    if file_path.contains("..") || file_path.contains("~") {
        return Err("不正なファイルパスが検出されました".to_string());
    }

    let path = Path::new(file_path);
    
    // 絶対パスの拒否
    if path.is_absolute() {
        return Err("絶対パスは許可されていません".to_string());
    }

    // 許可されたディレクトリかチェック
    let first_component = path.components()
        .next()
        .and_then(|c| c.as_os_str().to_str())
        .ok_or("無効なパスです".to_string())?;

    if !ALLOWED_DIRECTORIES.contains(&first_component) {
        return Err("アクセス権限のないディレクトリです".to_string());
    }

    Ok(path.to_path_buf())
}

セキュアなファイル読み込み機能を実装します。

rustuse tokio::fs;

#[tauri::command]
async fn read_secure_file(file_path: String) -> Result<String, String> {
    // ファイルパスの検証
    let validated_path = validate_file_path(&file_path)?;

    // アプリケーションデータディレクトリとの結合
    let app_data_dir = path::app_data_dir(&tauri::Config::default())
        .ok_or("アプリケーションデータディレクトリが見つかりません")?;
    
    let full_path = app_data_dir.join(validated_path);

    // ファイルサイズの制限チェック
    match fs::metadata(&full_path).await {
        Ok(metadata) => {
            if metadata.len() > 1024 * 1024 { // 1MBの制限
                return Err("ファイルサイズが大きすぎます".to_string());
            }
        },
        Err(_) => return Err("ファイルが見つかりません".to_string()),
    }

    // ファイル内容の読み込み
    match fs::read_to_string(&full_path).await {
        Ok(contents) => Ok(contents),
        Err(e) => Err(format!("ファイル読み込みエラー: {}", e))
    }
}

セキュアなファイル書き込み機能も実装しましょう。

rust#[tauri::command]
async fn write_secure_file(file_path: String, content: String) -> Result<String, String> {
    // ファイルパスの検証
    let validated_path = validate_file_path(&file_path)?;

    // コンテンツサイズの制限
    if content.len() > 1024 * 1024 { // 1MBの制限
        return Err("書き込みデータが大きすぎます".to_string());
    }

    // 危険な文字列のチェック
    if content.contains('\0') {
        return Err("無効な文字が含まれています".to_string());
    }

    let app_data_dir = path::app_data_dir(&tauri::Config::default())
        .ok_or("アプリケーションデータディレクトリが見つかりません")?;
    
    let full_path = app_data_dir.join(validated_path);

    // 親ディレクトリの存在確認と作成
    if let Some(parent) = full_path.parent() {
        fs::create_dir_all(parent).await
            .map_err(|e| format!("ディレクトリ作成エラー: {}", e))?;
    }

    // ファイル書き込み
    match fs::write(&full_path, content).await {
        Ok(_) => Ok("ファイルが正常に保存されました".to_string()),
        Err(e) => Err(format!("ファイル書き込みエラー: {}", e))
    }
}

実装例とコードサンプル

セキュアな認証システムの実装

実際のアプリケーションで使用できるセキュアな認証システムの実装例をご紹介します。このサンプルでは、JWT（JSON Web Token）を使用した認証機能を安全に実装する方法を示します。

まず、必要な依存関係をCargo.tomlに追加します。

toml[dependencies]
tauri = { version = "1.0", features = ["api-all"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
jsonwebtoken = "8.1"
sha2 = "0.10"
hex = "0.4"
tokio = { version = "1.0", features = ["full"] }
uuid = { version = "1.0", features = ["v4"] }

認証に必要なデータ構造を定義します。

rustuse serde::{Deserialize, Serialize};
use jsonwebtoken::{encode, decode, Header, Algorithm, Validation, EncodingKey, DecodingKey};
use sha2::{Sha256, Digest};
use std::time::{SystemTime, UNIX_EPOCH};

#[derive(Debug, Serialize, Deserialize)]
struct Claims {
    sub: String,    // ユーザーID
    exp: usize,     // 有効期限
    iat: usize,     // 発行時刻
    jti: String,    // JWT ID
}

#[derive(Debug, Deserialize)]
struct LoginRequest {
    username: String,
    password: String,
}

#[derive(Debug, Serialize)]
struct LoginResponse {
    token: String,
    expires_in: usize,
}

パスワードのハッシュ化と検証機能を実装します。

rustfn hash_password(password: &str, salt: &str) -> String {
    let mut hasher = Sha256::new();
    hasher.update(password.as_bytes());
    hasher.update(salt.as_bytes());
    hex::encode(hasher.finalize())
}

fn verify_password(password: &str, salt: &str, hash: &str) -> bool {
    let computed_hash = hash_password(password, salt);
    // 時間攻撃を防ぐため、常に同じ時間をかけて比較
    subtle::ConstantTimeEq::ct_eq(computed_hash.as_bytes(), hash.as_bytes()).into()
}

JWT トークンの生成と検証機能を実装します。

rustconst JWT_SECRET: &[u8] = b"your-secret-key-change-this-in-production";
const TOKEN_EXPIRY_HOURS: u64 = 24;

fn generate_jwt(user_id: &str) -> Result<String, String> {
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map_err(|_| "時刻の取得に失敗しました")?
        .as_secs() as usize;

    let claims = Claims {
        sub: user_id.to_string(),
        exp: now + (TOKEN_EXPIRY_HOURS * 3600) as usize,
        iat: now,
        jti: uuid::Uuid::new_v4().to_string(),
    };

    encode(&Header::default(), &claims, &EncodingKey::from_secret(JWT_SECRET))
        .map_err(|e| format!("JWT生成エラー: {}", e))
}

fn verify_jwt(token: &str) -> Result<Claims, String> {
    decode::<Claims>(
        token,
        &DecodingKey::from_secret(JWT_SECRET),
        &Validation::new(Algorithm::HS256),
    )
    .map(|data| data.claims)
    .map_err(|e| format!("JWT検証エラー: {}", e))
}

セキュアなデータ通信の実装

次に、フロントエンドとバックエンド間でのセキュアなデータ通信を実装します。

typescript// フロントエンド側のセキュアAPI通信クラス
class SecureApiClient {
  private token: string | null = null;

  async login(username: string, password: string): Promise<boolean> {
    try {
      const response = await invoke('login', {
        username: username.trim(),
        password: password
      });

      if (response.token) {
        this.token = response.token;
        // セキュアストレージにトークンを保存
        localStorage.setItem('auth_token', response.token);
        return true;
      }
    } catch (error) {
      console.error('ログインエラー:', error);
    }
    return false;
  }

  async makeAuthenticatedRequest(command: string, params: any): Promise<any> {
    if (!this.token) {
      throw new Error('認証が必要です');
    }

    try {
      return await invoke(command, {
        ...params,
        auth_token: this.token
      });
    } catch (error) {
      if (error.includes('認証エラー')) {
        // トークンが無効な場合、ログイン画面にリダイレクト
        this.logout();
        throw new Error('認証の有効期限が切れました');
      }
      throw error;
    }
  }

  logout(): void {
    this.token = null;
    localStorage.removeItem('auth_token');
  }
}

バックエンドでの認証機能付きコマンドハンドラーを実装します。

rust#[tauri::command]
async fn login(username: String, password: String) -> Result<LoginResponse, String> {
    // 入力値の検証
    if username.trim().is_empty() || password.is_empty() {
        return Err("ユーザー名とパスワードを入力してください".to_string());
    }

    if username.len() > 50 || password.len() > 128 {
        return Err("入力値が長すぎます".to_string());
    }

    // データベースからユーザー情報を取得（擬似実装）
    let user_data = get_user_from_database(&username).await?;
    
    // パスワード検証
    if !verify_password(&password, &user_data.salt, &user_data.password_hash) {
        return Err("認証に失敗しました".to_string());
    }

    // JWT生成
    let token = generate_jwt(&user_data.id)?;
    let expires_in = TOKEN_EXPIRY_HOURS * 3600;

    Ok(LoginResponse {
        token,
        expires_in: expires_in as usize,
    })
}

#[tauri::command]
async fn get_user_data(auth_token: String) -> Result<UserData, String> {
    // JWT検証
    let claims = verify_jwt(&auth_token)?;
    
    // ユーザーデータの取得
    let user_data = get_user_from_database(&claims.sub).await?;
    
    Ok(user_data)
}

セキュリティテストの実施方法

自動化されたセキュリティテスト

セキュリティテストは、アプリケーションの安全性を確保するために不可欠です。Tauriアプリケーションでは、フロントエンドとバックエンドの両方に対してテストを実施する必要があります。

まず、Rustのテスト機能を使用したバックエンドのセキュリティテストを実装します。

rust#[cfg(test)]
mod security_tests {
    use super::*;

    #[tokio::test]
    async fn test_input_validation_prevents_injection() {
        // SQLインジェクション攻撃のテスト
        let malicious_input = "'; DROP TABLE users; --";
        let result = validate_username(malicious_input);
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_path_traversal_prevention() {
        // パストラバーサル攻撃のテスト
        let malicious_path = "../../../etc/passwd";
        let result = validate_file_path(malicious_path);
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_file_size_limits() {
        // ファイルサイズ制限のテスト
        let large_content = "x".repeat(2 * 1024 * 1024); // 2MB
        let result = write_secure_file("test.txt".to_string(), large_content).await;
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_jwt_expiry() {
        // JWT有効期限のテスト
        let expired_token = generate_expired_jwt("test_user");
        let result = verify_jwt(&expired_token);
        assert!(result.is_err());
    }
}

次に、フロントエンド側のセキュリティテストをJestを使用して実装します。

javascript// セキュリティテスト用のテストファイル
import { InputValidator } from '../src/utils/validation';
import { SecureApiClient } from '../src/api/client';

describe('セキュリティテスト', () => {
  describe('入力値検証', () => {
    test('XSS攻撃を防ぐ', () => {
      const maliciousInput = '<script>alert("XSS")</script>';
      const result = InputValidator.validateAlphaNumeric(maliciousInput);
      expect(result).toBe(false);
    });

    test('SQLインジェクション文字列を拒否', () => {
      const sqlInjection = "admin'; DROP TABLE users; --";
      const result = InputValidator.validateUsername(sqlInjection);
      expect(result).toBe(false);
    });

    test('長すぎる入力を拒否', () => {
      const tooLongInput = 'x'.repeat(1000);
      const result = InputValidator.validateLength(tooLongInput, 1, 100);
      expect(result).toBe(false);
    });
  });

  describe('認証システム', () => {
    let apiClient;

    beforeEach(() => {
      apiClient = new SecureApiClient();
    });

    test('無効なトークンでのAPI呼び出しを拒否', async () => {
      apiClient.token = 'invalid-token';
      
      await expect(
        apiClient.makeAuthenticatedRequest('get_user_data', {})
      ).rejects.toThrow('認証エラー');
    });

    test('空のパスワードでのログインを拒否', async () => {
      const result = await apiClient.login('testuser', '');
      expect(result).toBe(false);
    });
  });
});

脆弱性スキャンの実装

Rustのセキュリティ監査ツールcargo auditを使用して、依存関係の脆弱性をチェックできます。

bash# cargo-auditのインストール
cargo install cargo-audit

# 脆弱性スキャンの実行
cargo audit

package.jsonにセキュリティチェックのスクリプトを追加します。

json{
  "scripts": {
    "security-audit": "npm audit && cargo audit",
    "test-security": "jest --testPathPattern=security",
    "lint-security": "eslint --config .eslintrc.security.js src/"
  }
}

継続的インテグレーション（CI）でのセキュリティテストを設定します。

yaml# .github/workflows/security.yml
name: Security Tests

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  security-tests:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
        
    - name: Setup Rust
      uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        
    - name: Install dependencies
      run: |
        npm install
        cargo install cargo-audit
        
    - name: Run security audit
      run: |
        npm audit
        cargo audit
        
    - name: Run security tests
      run: |
        npm run test-security
        cargo test security_tests