hy 0.18.1

HCLI - Hex-Rays CLI Utility
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

//! `hy ida` command group: install, set-default, accept-eula.

use std::path::PathBuf;

use clap::{Args, Subcommand};

use crate::error::Result;
use crate::util::fmt;

#[derive(Debug, Subcommand)]
pub enum IdaCommands {
    /// Install IDA from a downloaded installer
    Install(IdaInstallArgs),
    /// Set the default IDA installation directory
    SetDefault(IdaSetDefaultArgs),
    /// Accept the IDA EULA for an installation
    AcceptEula(IdaAcceptEulaArgs),
}

#[derive(Debug, Args)]
pub struct IdaInstallArgs {
    /// Path to the installer file
    pub installer: PathBuf,
    /// Installation directory
    #[arg(long)]
    pub prefix: Option<PathBuf>,
    /// Accept the EULA non-interactively
    #[arg(long)]
    pub accept_eula: bool,
}

#[derive(Debug, Args)]
pub struct IdaSetDefaultArgs {
    /// Path to the IDA installation directory
    pub path: PathBuf,
}

#[derive(Debug, Args)]
pub struct IdaAcceptEulaArgs {
    /// Path to the IDA installation directory (uses default if omitted)
    pub path: Option<PathBuf>,
}

pub async fn run(cmd: IdaCommands) -> Result<()> {
    match cmd {
        IdaCommands::Install(args) => run_install(args).await,
        IdaCommands::SetDefault(args) => run_set_default(args).await,
        IdaCommands::AcceptEula(args) => run_accept_eula(args).await,
    }
}

async fn run_install(args: IdaInstallArgs) -> Result<()> {
    let install_dir = args
        .prefix
        .unwrap_or_else(crate::ida::default_install_dir);

    fmt::info(&format!(
        "Installing IDA from {} to {}",
        args.installer.display(),
        install_dir.display()
    ));

    let result = crate::ida::install_ida(&args.installer, &install_dir, args.accept_eula).await?;
    fmt::success(&format!("IDA installed at: {}", result.display()));
    Ok(())
}

async fn run_set_default(args: IdaSetDefaultArgs) -> Result<()> {
    let path = args.path.canonicalize()?;
    if !path.is_dir() {
        fmt::error(&format!("Not a directory: {}", path.display()));
        return Ok(());
    }

    // Write to ida-config.json.
    let config_path = crate::ida::ida_user_dir().join("ida-config.json");
    let mut config: serde_json::Value = if config_path.exists() {
        let text = std::fs::read_to_string(&config_path)?;
        serde_json::from_str(&text).unwrap_or_default()
    } else {
        serde_json::json!({})
    };

    if let Some(paths) = config.get_mut("paths") {
        paths["ida_install_dir"] = serde_json::json!(path.to_string_lossy());
    } else {
        config["paths"] = serde_json::json!({ "ida_install_dir": path.to_string_lossy() });
    }

    if let Some(parent) = config_path.parent() {
        std::fs::create_dir_all(parent)?;
    }
    std::fs::write(&config_path, serde_json::to_string_pretty(&config)?)?;

    fmt::success(&format!("Default IDA set to: {}", path.display()));
    Ok(())
}

async fn run_accept_eula(args: IdaAcceptEulaArgs) -> Result<()> {
    let install_dir = match args.path {
        Some(p) => p,
        None => match crate::ida::current_install_dir() {
            Some(d) => d,
            None => {
                fmt::error("No IDA installation found. Specify a path or set a default.");
                return Ok(());
            }
        },
    };

    if !install_dir.exists() {
        fmt::error(&format!("Directory not found: {}", install_dir.display()));
        return Ok(());
    }

    // Look for idalib / idapyswitch to invoke EULA acceptance.
    let ida_path = if cfg!(target_os = "macos") {
        install_dir.join("Contents").join("MacOS")
    } else {
        install_dir.clone()
    };

    let idalib = if cfg!(target_os = "windows") {
        ida_path.join("idalib.exe")
    } else {
        ida_path.join("idalib")
    };

    if idalib.exists() {
        fmt::info("Accepting EULA via idalib...");
        let status = std::process::Command::new(&idalib)
            .arg("--accept-eula")
            .status();

        match status {
            Ok(s) if s.success() => {
                fmt::success("EULA accepted.");
            }
            Ok(s) => {
                fmt::warning(&format!(
                    "idalib exited with status {}. EULA may not have been accepted.",
                    s.code().unwrap_or(-1)
                ));
            }
            Err(e) => {
                fmt::error(&format!("Failed to run idalib: {e}"));
            }
        }
    } else {
        fmt::warning("idalib not found in the installation directory.");
        fmt::info("EULA acceptance requires IDA Pro or IDA Teams (not IDA Free/Home).");
        fmt::info(&format!("Checked: {}", idalib.display()));
    }

    Ok(())
}