Rust | Repository

Rust ARCHIVE .ZIP

SysMonitor

Scripts pour monitorer votre CPU et mémoire. Attention aux dépendances.

use sysinfo::{System, SystemExt, CpuExt};
use std::{thread, time};
use std::io::{self, Write};

fn main() {
    let mut sys = System::new_all();

println!("=== Wouam SysMonitor v1.1 ===");
    println!("Système : {} {}", sys.name().unwrap_or("?".to_string()), sys.os_version().unwrap_or("?".to_string()));
    println!("Hôte    : {}", sys.host_name().unwrap_or("?".to_string()));
    println!("-----------------------------");

loop {
        sys.refresh_all();

// Affichage CPU
        print!("\rCPU: {:.2}%  ", sys.global_cpu_info().cpu_usage());

// Affichage RAM (CORRECTION ICI : On divise 3 fois par 1024 pour passer des Octets aux Go)
        // Octets -> Ko -> Mo -> Go
        let used_mem = sys.used_memory() as f64 / 1024.0 / 1024.0 / 1024.0;
        let total_mem = sys.total_memory() as f64 / 1024.0 / 1024.0 / 1024.0;
        
        print!("| RAM: {:.2} GB / {:.2} GB    ", used_mem, total_mem);

// Rafraîchissement console
        io::stdout().flush().unwrap();
        thread::sleep(time::Duration::from_secs(2));
    }
}
-------------------------------------------------------------
use std::net::{TcpStream, ToSocketAddrs};
use std::sync::mpsc::{channel, Sender};
use std::thread;
use std::time::Duration;
use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        println!("Usage: cargo run <IP_ADDRESS>");
        return;
    }
    let target_ip = &args[1];
    println!("Scanning {} (Ports 1-1024)...", target_ip);

let (sender, receiver) = channel();
    let mut children = Vec::new();

// On scanne les 1024 premiers ports
    for port in 1..=1024 {
        let target = target_ip.clone();
        let sender = sender.clone();

let child = thread::spawn(move || {
            if scan_port(&target, port) {
                sender.send(port).unwrap();
            }
        });
        children.push(child);
    }

// On ferme le canal d'envoi principal
    drop(sender);

// Réception des résultats
    let mut open_ports = Vec::new();
    for p in receiver {
        open_ports.push(p);
    }
    open_ports.sort();

println!("\nRésultats pour {} :", target_ip);
    for port in open_ports {
        println!("Port {} est [OUVERT]", port);
    }
}

fn scan_port(ip: &str, port: u16) -> bool {
    let addr = format!("{}:{}", ip, port);
    // Timeout très court (1 sec) pour aller vite
    match addr.to_socket_addrs() {
        Ok(mut addrs) => {
            if let Some(socket_addr) = addrs.next() {
                if TcpStream::connect_timeout(&socket_addr, Duration::from_secs(1)).is_ok() {
                    return true;
                }
            }
        }
        Err(_) => {}
    }
    false
}
-------------------------------------------------
use sha2::{Sha256, Digest};
use std::env;
use std::fs::File;
use std::io::{self, Read};

fn main() -> io::Result<()> {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        println!("Usage: cargo run <chemin_du_fichier>");
        return Ok(());
    }

let path = &args[1];
    println!("Calcul du hash SHA-256 pour : {}", path);

let mut file = File::open(path)?;
    let mut hasher = Sha256::new();
    let mut buffer = [0; 1024];

loop {
        let count = file.read(&mut buffer)?;
        if count == 0 {
            break;
        }
        hasher.update(&buffer[..count]);
    }

let result = hasher.finalize();
    println!("----------------------------------------------------------------");
    println!("HASH: {}", hex::encode(result));
    println!("----------------------------------------------------------------");

Ok(())
}

TÉLÉCHARGER

# Scripts Rust

Nouveau sur Rust ?

SysMonitor

Ce laboratoire est gratuit. Mon métier, c'est de créer des sites.

Viewer