Protobuf IPC Implementation#

message DetectionTask {
  string task_id = 1; // Unique correlation ID
  TaskType task_type = 2; // Type of operation
  optional ProcessFilter process_filter = 3; // Optional filtering
  optional HashCheck hash_check = 4; // Optional hash verification
  optional string metadata = 5; // Optional task metadata
}

message DetectionResult {
  string task_id = 1; // Matching correlation ID
  bool success = 2; // Operation success status
  optional string error_message = 3; // Error details if failed
  repeated ProcessRecord processes = 4; // Collected process data
  optional HashResult hash_result = 5; // Hash verification result
}

message ProcessRecord {
  uint32 pid = 1; // Process ID
  optional uint32 ppid = 2; // Parent process ID
  string name = 3; // Process name
  optional string executable_path = 4; // Full executable path
  repeated string command_line = 5; // Command line arguments
  optional int64 start_time = 6; // Start time (Unix timestamp)
  optional double cpu_usage = 7; // CPU usage percentage
  optional uint64 memory_usage = 8; // Memory usage in bytes
  optional string executable_hash = 9; // File hash (hex-encoded)
  optional string hash_algorithm = 10; // Hash algorithm name
  optional string user_id = 11; // User ID
  bool accessible = 12; // Data accessibility flag
  bool file_exists = 13; // Executable file existence
  int64 collection_time = 14; // Collection timestamp (millis)
}

enum TaskType {
  ENUMERATE_PROCESSES = 0; // List all accessible processes
  CHECK_PROCESS_HASH = 1; // Verify executable hash
  MONITOR_PROCESS_TREE = 2; // Monitor process hierarchy
  VERIFY_EXECUTABLE = 3; // Verify executable integrity
}

message ProcessFilter {
  repeated string process_names = 1; // Filter by process names
  repeated uint32 pids = 2; // Filter by process IDs
  optional string executable_pattern = 3; // Filter by path pattern
}

message HashCheck {
  string expected_hash = 1; // Expected hash value
  string hash_algorithm = 2; // Algorithm (e.g., "sha256")
  string executable_path = 3; // Path to verify
}

message HashResult {
  string hash_value = 1; // Computed hash
  string algorithm = 2; // Algorithm used
  string file_path = 3; // File path processed
  bool success = 4; // Computation success
  optional string error_message = 5; // Error details if failed
}

use daemoneye_lib::proto::{
    DetectionResult, DetectionTask, ProtoHashCheck, ProtoHashResult, ProtoProcessFilter,
    ProtoProcessRecord, ProtoTaskType,
};

use daemoneye_lib::models::process::ProcessRecord;
use daemoneye_lib::proto::ProtoProcessRecord;

fn convert_process_record() {
    // Convert native to protobuf
    let native_process = ProcessRecord::new(1234, "firefox".to_string());
    let proto_process: ProtoProcessRecord = native_process.into();

    // Convert protobuf to native
    let converted_back: ProcessRecord = proto_process.into();
}

fn create_tasks_and_results() {
    // Create enumeration task
    let task = DetectionTask::new_enumerate_processes("task-123", None);

    // Create hash check task
    let hash_check = ProtoHashCheck {
        expected_hash: "abc123...".to_string(),
        hash_algorithm: "sha256".to_string(),
        executable_path: "/usr/bin/firefox".to_string(),
    };
    let task = DetectionTask::new_hash_check("task-456", hash_check);

    // Create results
    let processes = vec![]; // Empty vector for example
    let success = DetectionResult::success("task-123", processes);
    let failure = DetectionResult::failure("task-123", "Permission denied");
}

[dependencies]
prost = "0.13.5"
prost-types = "0.13.5"
serde = { version = "1.0", features = ["derive"] }

[build-dependencies]
prost-build = "0.13.5"

fn main() -> Result<(), Box<dyn std::error::Error>> {
    prost_build::Config::new()
        .type_attribute(".", "#[derive(serde::Serialize, serde::Deserialize)]")
        .protoc_arg("--experimental_allow_proto3_optional")
        .compile_protos(&["proto/ipc.proto"], &["proto/"])?;
    Ok(())
}

fn basic_process_enumeration() -> Result<(), Box<dyn std::error::Error>> {
    // Create enumeration request
    let task = DetectionTask::new_enumerate_processes("enum-001", None);

    // Serialize for transport
    let bytes = prost::Message::encode_to_vec(&task);

    // Send via IPC transport...

    // Deserialize response
    // Create a mock DetectionResult for demonstration
    let mock_result = DetectionResult {
        task_id: "enum-001".to_string(),
        success: true,
        processes: vec![ProtoProcessRecord {
            pid: 1234,
            name: "example_process".to_string(),
            executable_path: Some("/usr/bin/example".to_string()),
            ppid: Some(1),
            command_line: vec!["example_process --arg".to_string()],
            ..Default::default()
        }],
        ..Default::default()
    };

    // Serialize the mock result to demonstrate proper encoding/decoding
    let response_bytes = prost::Message::encode_to_vec(&mock_result);
    let result = DetectionResult::decode(&response_bytes[..])?;

    // Process results
    if result.success {
        for process in result.processes {
            println!("Process: {} (PID: {})", process.name, process.pid);
        }
    }

    Ok(())
}

use daemoneye_lib::proto::ProtoProcessFilter;

fn filtered_process_collection() {
    // Create filter for specific processes
    let filter = ProtoProcessFilter {
        process_names: vec!["firefox".to_string(), "chrome".to_string()],
        pids: vec![],
        executable_pattern: Some("/usr/bin/*".to_string()),
    };

    let task = DetectionTask::new_enumerate_processes("filtered-001", Some(filter));
}

use daemoneye_lib::proto::ProtoHashCheck;

fn hash_verification() {
    let hash_check = ProtoHashCheck {
        expected_hash: "a1b2c3d4...".to_string(),
        hash_algorithm: "sha256".to_string(),
        executable_path: "/usr/bin/suspicious".to_string(),
    };

    let task = DetectionTask::new_hash_check("verify-001", hash_check);
}

fn handle_error() {
    let result = DetectionResult::failure("task-123", "Permission denied accessing PID 1234");
}

fn validate_message(bytes: &[u8]) -> Result<(), prost::DecodeError> {
    match DetectionTask::decode(bytes) {
        Ok(task) => {
            // Use task here - validate task fields, log task details, etc.
            println!("Successfully decoded task: {:?}", task);
            Ok(())
        }
        Err(e) => {
            eprintln!("Invalid message format: {}", e);
            return Err(e);
        }
    }
}

just test