Wouam | Repository SysAdmin & DevOps

Bienvenue sur le dépôt /root

Centralisation d'outils SysAdmin, scripts d'automatisation et veille DevOps.
Open Source & Free to use.

Tip

$ ctrl + r Recherche historique

#PowerShell #Python #Rust 👾 Arcade

./ Derniers Ajouts

Rust .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(())
}

Python PY

Scanner de Ports TCP

Un script essentiel pour vérifier rapidement si un serveur est accessible ou si un pare-feu bloque une connexion.

#!/usr/bin/env python3
"""
NetProbe - Simple TCP Port Scanner
Auteur: Wouam
Usage: python NetProbe.py <hostname/IP>
"""

import socket
import sys
from datetime import datetime

# Configuration
target = input("Entrez l'IP ou le domaine à scanner : ")
ports_to_scan = [21, 22, 25, 53, 80, 110, 143, 443, 3306, 3389, 8080]

# Couleurs
GREEN = '\033[92m'
RED = '\033[91m'
RESET = '\033[0m'

print("-" * 50)
print(f"Scanning Target: {target}")
print(f"Time started: {datetime.now()}")
print("-" * 50)

try:
    for port in ports_to_scan:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(0.5) # Timeout rapide
        result = sock.connect_ex((target, port))
        
        service_name = socket.getservbyport(port, "tcp") if port < 1024 else "Custom"
        
        if result == 0:
            print(f"Port {port:<5} [{service_name:<10}]: {GREEN}OPEN{RESET}")
        else:
            print(f"Port {port:<5} [{service_name:<10}]: {RED}CLOSED{RESET}")
        sock.close()

except KeyboardInterrupt:
    print("\nScan annulé par l'utilisateur.")
except socket.gaierror:
    print("\nHostname non résolu.")
except socket.error:
    print("\nImpossible de se connecter au serveur.")

print("-" * 50)
print("Scan terminé.")
input("Appuyez sur Entrée pour quitter...")

Python PY

CertGuardian

Rien de pire qu'un certificat SSL qui expire le week-end. Ce script vérifie la date d'expiration d'un site HTTPS.

#!/usr/bin/env python3
"""
CertGuardian - SSL Expiry Checker
Auteur: Wouam
"""

import ssl
import socket
import datetime

def get_ssl_expiry_date(hostname):
    context = ssl.create_default_context()
    conn = context.wrap_socket(
        socket.socket(socket.AF_INET),
        server_hostname=hostname,
    )
    # Connexion (Timeout 3s)
    conn.settimeout(3.0)
    
    try:
        conn.connect((hostname, 443))
        ssl_info = conn.getpeercert()
        # Format de date SSL: 'Sep 18 23:59:59 2024 GMT'
        expire_str = ssl_info['notAfter']
        expire_date = datetime.datetime.strptime(expire_str, '%b %d %H:%M:%S %Y %Z')
        return expire_date
    except Exception as e:
        return None
    finally:
        conn.close()

# Interface
print("--- SSL CERTIFICATE CHECKER ---")
domain = input("Domaine à vérifier (ex: google.com) : ")

expiry = get_ssl_expiry_date(domain)

if expiry:
    days_left = (expiry - datetime.datetime.now()).days
    print(f"\nDomaine : {domain}")
    print(f"Expire le : {expiry}")
    
    if days_left < 15:
        print(f"\033[91mALERTE CRITIQUE : Expire dans {days_left} jours !\033[0m")
    elif days_left < 30:
        print(f"\033[93mATTENTION : Expire dans {days_left} jours.\033[0m")
    else:
        print(f"\033[92mOK : Valide pour encore {days_left} jours.\033[0m")
else:
    print("\033[91mErreur : Impossible de récupérer le certificat (Site down ou pas de HTTPS).\033[0m")

input("\nAppuyez sur Entrée pour quitter...")

Python PY

DiskCleaner

Un script de maintenance pour supprimer les fichiers temporaires ou les vieux logs qui encombrent un dossier.

#!/usr/bin/env python3
"""
LogPurge - Suppression automatique de vieux fichiers
Auteur: Wouam
Attention : Ce script supprime réellement des fichiers.
"""

import os
import time
import sys

def cleanup_files(folder, days_limit):
    if not os.path.exists(folder):
        print(f"Erreur : Le dossier {folder} n'existe pas.")
        return

now = time.time()
    cutoff = now - (days_limit * 86400) # 86400 sec = 1 jour
    deleted_count = 0
    deleted_size = 0

print(f"Analyse de : {folder}")
    print(f"Critère : Fichiers plus vieux que {days_limit} jours...")
    print("-" * 40)

for root, dirs, files in os.walk(folder):
        for file in files:
            file_path = os.path.join(root, file)
            try:
                # Vérification date modification
                file_mtime = os.path.getmtime(file_path)
                if file_mtime < cutoff:
                    size = os.path.getsize(file_path)
                    os.remove(file_path) # ACTION DE SUPPRESSION
                    
                    print(f"[DEL] {file} ({round(size/1024, 2)} KB)")
                    deleted_count += 1
                    deleted_size += size
            except Exception as e:
                print(f"[ERR] Impossible de supprimer {file} : {e}")

print("-" * 40)
    print(f"Terminé. {deleted_count} fichiers supprimés.")
    print(f"Espace libéré : {round(deleted_size/1024/1024, 2)} MB")

# Interface
target_folder = input("Chemin du dossier logs (ex: C:/Temp ou /var/log/app) : ")
try:
    days = int(input("Supprimer fichiers plus vieux que (jours) : "))
    confirm = input("Confirmer la suppression ? (y/n) : ")
    
    if confirm.lower() == 'y':
        cleanup_files(target_folder, days)
    else:
        print("Annulé.")
except ValueError:
    print("Erreur : Veuillez entrer un nombre de jours valide.")

input("\nAppuyez sur Entrée pour quitter...")

Jeux PY

Le Morpion

Un jeu à deux joueurs (X et O) qui se joue directement dans le terminal. Pas besoin de bibliothèque graphique, ça tourne partout.

import os

# Initialisation du plateau
board = [' ' for _ in range(9)]

def print_board():
    os.system('cls' if os.name == 'nt' else 'clear')
    print("\n  TIC-TAC-TOE - Wouam Games\n")
    print(f"  {board[0]} | {board[1]} | {board[2]}")
    print(" ---+---+---")
    print(f"  {board[3]} | {board[4]} | {board[5]}")
    print(" ---+---+---")
    print(f"  {board[6]} | {board[7]} | {board[8]}\n")

def check_win(player):
    # Combinaisons gagnantes
    win_conditions = [
        (0, 1, 2), (3, 4, 5), (6, 7, 8), # Lignes
        (0, 3, 6), (1, 4, 7), (2, 5, 8), # Colonnes
        (0, 4, 8), (2, 4, 6)             # Diagonales
    ]
    for a, b, c in win_conditions:
        if board[a] == board[b] == board[c] == player:
            return True
    return False

def play_game():
    current_player = 'X'
    
    for turn in range(9):
        print_board()
        try:
            move = int(input(f"Joueur {current_player}, choisissez une case (1-9) : ")) - 1
            if 0 <= move <= 8 and board[move] == ' ':
                board[move] = current_player
                if check_win(current_player):
                    print_board()
                    print(f"BRAVO ! Le joueur {current_player} a gagné !")
                    return
                current_player = 'O' if current_player == 'X' else 'X'
            else:
                input("Case invalide ou occupée. Appuyez sur Entrée...")
        except ValueError:
            pass
            
    print_board()
    print("Match nul !")

if __name__ == "__main__":
    play_game()
    input("\nAppuyez sur Entrée pour quitter...")

Jeux PS1

GuessNumber.ps1

Un classique absolu pour apprendre les boucles. L'ordinateur choisit un nombre entre 1 et 100, et le joueur doit le deviner.

<#
.SYNOPSIS
    Jeu du Juste Prix en PowerShell.
.DESCRIPTION
    L'ordinateur choisit un nombre aléatoire entre 1 et 100.
    Vous devez le deviner avec des indices (Plus grand / Plus petit).
.NOTES
    Auteur: Wouam
    Version: 1.0
#>

Clear-Host
Write-Host "==================================" -ForegroundColor Cyan
Write-Host "      GUESS THE NUMBER v1.0       " -ForegroundColor Yellow
Write-Host "==================================" -ForegroundColor Cyan
Write-Host ""

$target = Get-Random -Minimum 1 -Maximum 101
$guess = 0
$attempts = 0

Write-Host "Je pense à un nombre entre 1 et 100..." -ForegroundColor White

do {
    try {
        $inputUser = Read-Host "Votre proposition "
        $guess = [int]$inputUser
        $attempts++

if ($guess -lt $target) {
            Write-Host "C'est PLUS !" -ForegroundColor Green
        }
        elseif ($guess -gt $target) {
            Write-Host "C'est MOINS !" -ForegroundColor Red
        }
    }
    catch {
        Write-Host "Erreur : Entrez un nombre valide." -ForegroundColor DarkGray
    }

} until ($guess -eq $target)

Write-Host ""
Write-Host "**********************************" -ForegroundColor Yellow
Write-Host "BRAVO ! Trouvé en $attempts essais." -ForegroundColor Cyan
Write-Host "Le nombre était bien $target."
Write-Host "**********************************" -ForegroundColor Yellow
Write-Host ""
Pause

Veille IA (Siècle Digital)

Mistral AI rattrapé par des soupçons de pillage massif 24/02

L’IA peut-elle épuiser nos ressources ? La réponse très contestée de Sam Altman 24/02

IA : les États-Unis refusent toute règle mondiale et créent la polémique 24/02

On sait désormais à quoi va ressembler le premier appareil d’OpenAI 23/02

DevOps & Linux

Liens intéressants Journal du hacker semaine #8 23/02

ISOMan : un outil open source pour centraliser vos images ISO 23/02

Nouvelles de Haiku - Hiver 2025-26 22/02

Optimisation webperf : AVIF et pré-compression pour le blog 21/02

Bienvenue sur le dépôt /root

./ Derniers Ajouts

SysMonitor

Scanner de Ports TCP

CertGuardian

DiskCleaner

Le Morpion

GuessNumber.ps1

Veille IA (Siècle Digital)

DevOps & Linux

Viewer