Séparateur et lecture aléatoire de code JavaScript
Divisez et mélangez votre code JavaScript en plusieurs morceaux indépendants avec une dénomination aléatoire et une génération automatique de code de réassemblage. Choisissez le nombre de blocs de sortie (2 à 10), sélectionnez votre style de dénomination préféré (lettres courtes, hex _0x ou aléatoire) et générez instantanément du code obscurci qui se réassemble au moment de l'exécution. Parfait pour protéger la logique JS côté client, les bibliothèques et les algorithmes propriétaires.
Split your JavaScript code into shuffled chunks with randomized naming and automatic reassembly code generation. Paste your code below, configure the split options, and click Split & Shuffle Code.
var _0x01a=function(){// Sample JavaScript
function greet(name) {
return "Hello, " + name + "!";
}
function processUsers(userList) {
return userList.map(function(user) {
return greet(user).toUpperCase();
});
}},
var _0x02b=function(){const results = processUsers(users);
const users = ["Alice", "Bob", "Charlie"];},
var _0x03c=function(){console.log(results);
class Calculator {
add(a, b) {
return a + b;
}
multiply(a, b) {
return a * b;
}
}};
var _0xloader=[_0x01a,_0x02b,_0x03c];
for(var _0xi=0;_0xi<_0xloader.length;_0xi++){_0xloader[_0xi]();}// Sample JavaScript
function greet(name) {
return "Hello, " + name + "!";
}
function processUsers(userList) {
return userList.map(function(user) {
return greet(user).toUpperCase();
});
}const results = processUsers(users);
const users = ["Alice", "Bob", "Charlie"];console.log(results);
class Calculator {
add(a, b) {
return a + b;
}
multiply(a, b) {
return a * b;
}
}| # | Chunk | Statement Preview |
|---|---|---|
| 1 | _0x01a | // Sample JavaScript function greet(name) { return "Hello, " + name + "!"; } |
| 2 | _0x01a | function processUsers(userList) { return userList.map(function(user) { ret... |
| 3 | _0x02b | const results = processUsers(users); |
| 4 | _0x02b | const users = ["Alice", "Bob", "Charlie"]; |
| 5 | _0x03c | console.log(results); |
| 6 | _0x03c | class Calculator { add(a, b) { return a + b; } multiply(a, b) { ... |
Code splitting makes static analysis harder but is not encryption. Always test obfuscated code thoroughly in your target environment before deployment. Keep your original source code in version control - obfuscated code is difficult to maintain and debug directly. This tool processes all code locally in your browser with no server-side data transfer.
Pourquoi utiliser notre séparateur de code JavaScript ?
- Fractionnement et brassage instantanés du code : divisez votre code JavaScript en morceaux mélangés et distribués indépendamment en quelques secondes. Choisissez le nombre de blocs de sortie (2 à 10) et le style de dénomination, et générez instantanément du code obscurci qui se réassemble au moment de l'exécution. Aucun traitement côté serveur n'est nécessaire : tout se passe localement dans votre navigateur.
- Obfuscation de code sécurisée et privée : votre code source JavaScript ne quitte jamais votre appareil. Toute génération de code de fractionnement, de brassage et de réassemblage se produit localement dans votre navigateur en utilisant du JavaScript pur. Pas de téléchargement, pas de suivi, pas de stockage côté serveur : confidentialité totale de votre propriété intellectuelle.
- JavaScript Obfuscator en ligne - Aucune installation : utilisez le séparateur de code JavaScript directement dans n'importe quel navigateur moderne sans téléchargements, applications ou plugins requis. Fonctionne hors ligne après le premier chargement et gère n'importe quelle taille d'entrée JavaScript. 100 % gratuit pour toujours, sans inscription requise.
- Distribution de fragments configurable : affinez la façon dont votre code est réparti en fragments. Choisissez entre 2 et 10 blocs de sortie avec une dénomination aléatoire (lettres courtes, style hexadécimal _0x ou étiquettes descriptives). Chaque morceau obtient son propre identifiant unique et le code de réassemblage est automatiquement généré afin que votre code s'exécute correctement au moment de l'exécution.
Cas d'utilisation courants du séparateur de code JavaScript
- Protection de la source des applications Web : les développeurs Web utilisent le séparateur de code JavaScript pour protéger la logique des applications côté client en divisant les algorithmes de base en plusieurs morceaux mélangés. En répartissant les calculs critiques sur des blocs de code distincts qui se réassemblent au moment de l'exécution, vous compliquez considérablement la tâche des concurrents ou des acteurs malveillants lors de la rétro-ingénierie de votre logique métier.
- Bibliothèque JavaScript et distribution de plugins : les auteurs de bibliothèques et de plugins utilisent le séparateur de code pour masquer les packages JavaScript distribués. Le fractionnement du code source en morceaux mélangés avec une dénomination aléatoire des morceaux rend difficile pour les utilisateurs de copier, modifier ou redistribuer le code sans licence appropriée, tandis que le réassemblage automatique garantit le bon fonctionnement de la bibliothèque.
- Protection des scripts de paiement pour le commerce électronique : les plateformes de commerce électronique utilisent le séparateur de code JavaScript pour protéger les scripts liés au paiement et la logique d'intégration des paiements. En divisant le code de traitement de paiement sensible en morceaux mélangés, ils ajoutent une couche de protection supplémentaire contre le scraping de script et la copie non autorisée de la logique de flux de paiement propriétaire.
- Démonstrations d'obfuscation de code pédagogique : les enseignants et les instructeurs en cybersécurité utilisent le séparateur de code JavaScript pour démontrer les techniques d'obfuscation de code en classe. L'outil fournit un exemple visuel clair du fonctionnement du fractionnement du code, de la façon dont les morceaux peuvent être mélangés et réassemblés, ainsi que des compromis entre la force d'obscurcissement et la surcharge de taille du code.
- Protection du code client API et SDK : les fournisseurs d'API et les développeurs de SDK utilisent le séparateur de code JavaScript pour protéger le code d'intégration côté client distribué aux développeurs tiers. Les morceaux de code mélangés avec une dénomination aléatoire rendent plus difficile pour les utilisateurs non autorisés de modifier ou d'utiliser à mauvais escient la logique d'intégration du SDK tout en conservant le comportement fonctionnel intact.
- Propriété intellectuelle et protection des algorithmes : les entreprises protégeant les algorithmes JavaScript propriétaires utilisent le séparateur de code dans le cadre d'une stratégie de défense à plusieurs niveaux. Le fractionnement du code ajoute une couche d'obscurcissement basée sur la distribution qui complète le renommage des variables, le codage de chaînes et d'autres techniques d'obscurcissement. Cette approche à plusieurs niveaux augmente considérablement les efforts requis pour la rétro-ingénierie.
Qu'est-ce que le fractionnement et la brassage de code JavaScript ?
Le fractionnement et la brassage du code JavaScript sont une technique d'obscurcissement du code qui divise votre source JavaScript en plusieurs morceaux (ou blocs) indépendants, puis mélange leur ordre et attribue à chaque morceau un nom aléatoire. Un petit stub de chargeur est généré qui exécute les morceaux dans le bon ordre au moment de l'exécution, garantissant que le code s'exécute exactement comme il a été écrit à l'origine.
Contrairement à la minification traditionnelle (qui supprime uniquement les espaces et renomme les variables), la division du code distribue votre logique entre des morceaux distincts nommés indépendamment. Cela rend l'analyse statique beaucoup plus difficile, car un attaquant doit d'abord identifier tous les morceaux, comprendre l'ordre de réassemblage, puis reconstruire la source d'origine avant de pouvoir analyser la logique. Notre séparateur de code JavaScript gère tout cela automatiquement, en traitant entièrement votre code dans votre navigateur.
Comment fonctionne notre séparateur de code JavaScript
- 1. Analyser et segmenter : l'outil analyse votre entrée JavaScript et identifie toutes les instructions de niveau supérieur : déclarations de fonction, déclarations de classe, déclarations de variables (const/let/var), instructions d'expression, instructions d'importation/exportation, etc. Chaque instruction de niveau supérieur devient candidate à la distribution entre fragments. Les commentaires et les lignes vides sont regroupés avec leurs instructions adjacentes.
- 2. Distribuer et mélanger : en fonction du nombre de morceaux et du style de dénomination que vous avez choisis, l'outil distribue les instructions sur N blocs de sortie en utilisant un modèle de distribution circulaire. Chaque morceau se voit attribuer un identifiant aléatoire (par exemple, _0x1a , _0x2b ou des codes de lettres courtes). Le contenu des morceaux est ensuite mélangé de sorte que même si quelqu'un inspecte des morceaux individuels, l'ordre original du code est obscurci.
- 3. Générer du code de réassemblage : l'outil génère automatiquement une fonction de chargeur compact qui exécute les morceaux dans le bon ordre au moment de l'exécution. Le chargeur est inclus comme sortie finale, rendant le code obscurci entièrement fonctionnel. Remplacez simplement votre script d'origine par la sortie générée - aucune configuration ni dépendance supplémentaire n'est nécessaire.
Ce qui est transformé lors du fractionnement du code
- Distribution des instructions : les déclarations de fonctions de niveau supérieur, les déclarations de classes, les déclarations de variables et les instructions d'expression sont distribuées sur N morceaux mélangés. Chaque morceau contient un sous-ensemble des instructions originales dans un ordre mélangé.
- Nommage des morceaux : chaque morceau reçoit un identifiant aléatoire en fonction du style de dénomination que vous avez choisi. Le style de lettre courte utilise des identifiants à une ou deux lettres (a, b, c...). Le style hexadécimal utilise des codes hexadécimaux préfixés par _0x. Chaque nom de bloc est unique dans la sortie.
- Chargeur de réassemblage : un chargeur d'exécution compact est généré et exécute tous les morceaux dans le bon ordre. Le chargeur est une fonction autonome qui parcourt les morceaux enregistrés et garantit une séquence d'exécution appropriée.
- Suivi des frais généraux de taille : l'outil affiche l'augmentation exacte de la taille due au fractionnement, y compris les frais généraux du chargeur de réassemblage. Généralement, augmentation de la taille de 15 à 40 % en fonction du nombre de morceaux et de la taille du code d'origine.
Limites importantes
Le fractionnement du code est une transformation au niveau du code, pas un cryptage. Bien que diviser votre code en morceaux mélangés rende l'analyse statique beaucoup plus difficile, des attaquants déterminés disposant de suffisamment de temps et d'outils peuvent toujours reconstruire la logique d'origine. Le fractionnement du code est plus efficace dans le cadre d’une stratégie d’obscurcissement en couches qui comprend le renommage des variables, le codage des chaînes et l’obscurcissement du flux de contrôle.
Toutes les constructions JavaScript ne sont pas réparties de manière égale. L'outil utilise une segmentation basée sur des expressions régulières pour identifier les instructions de niveau supérieur. Un code extrêmement complexe ou construit dynamiquement peut ne pas être divisé proprement. Testez toujours minutieusement la sortie masquée avant le déploiement. L'outil traite tout le code localement dans votre navigateur sans aucune donnée envoyée à des serveurs externes.
Foire aux questions
Un séparateur et mélangeur de code JavaScript est un outil d'obfuscation de code qui divise votre code source JavaScript en plusieurs morceaux indépendants, mélange leur ordre, attribue à chaque morceau un identifiant aléatoire et génère un chargeur de réassemblage qui exécute tous les morceaux dans le bon ordre au moment de l'exécution. Cela rend beaucoup plus difficile pour les attaquants l’analyse statique ou la rétro-ingénierie de votre code.
Non. Notre séparateur de code JavaScript préserve l'ordre d'exécution d'origine en générant un chargeur de réassemblage qui exécute tous les morceaux dans le bon ordre. Le fractionnement est purement structurel : il modifie la façon dont le code est organisé dans les fichiers, et non la façon dont il s'exécute. Cependant, nous recommandons toujours de tester la sortie masquée dans votre environnement cible avant le déploiement.
Absolument. Votre code source JavaScript est entièrement sécurisé avec notre outil. Toute la génération de code de fractionnement, de brassage et de réassemblage de code se produit entièrement dans votre navigateur en utilisant du JavaScript pur. Aucune donnée n'est jamais téléchargée sur un serveur. Votre propriété intellectuelle, vos algorithmes propriétaires et votre logique métier ne quittent jamais votre appareil.
Le nombre optimal de morceaux dépend de la taille de votre code et de vos besoins d’obscurcissement. 3 à 5 morceaux offrent un bon équilibre entre la force d’obscurcissement et la taille de sortie. Un nombre de fragments plus élevé (8 à 10) fournit une obscurcissement plus fort mais augmente la taille de sortie. Pour les petits scripts, 2 à 4 morceaux suffisent généralement. Notre outil affiche la taille exacte des frais généraux afin que vous puissiez faire un compromis éclairé.
L'outil propose trois styles de dénomination : lettres courtes (a, b, c, aa, ab...), style hexadécimal (_0x1a, _0x2b, _0x3c...) et mots aléatoires (en utilisant des combinaisons telles que xk, qp, zt). Chaque morceau reçoit un identifiant unique qui est utilisé à la fois comme nom de variable de morceau et dans le chargeur de réassemblage. Le style de dénomination affecte l'esthétique de la sortie, mais tous les styles fournissent une obscurcissement équivalent.
Oui. Le séparateur de code JavaScript gère les instructions d'importation et d'exportation au niveau supérieur. Ces instructions sont conservées et distribuées entre des morceaux avec d'autres déclarations. Le chargeur de réassemblage garantit que les dépendances des modules restent intactes. Les appels CommonJS require() et les importations dynamiques sont également conservés dans leur forme originale.
Non. Le fractionnement du code est une technique d’obscurcissement et non de chiffrement. Le code chiffré ne peut pas s'exécuter sans déchiffrement, tandis que le code fractionné s'exécute normalement dans n'importe quel environnement JavaScript. Le fractionnement rend l'analyse statique plus difficile en répartissant la logique sur plusieurs morceaux, mais les attaquants déterminés disposant d'outils de débogage peuvent toujours suivre l'exécution au moment de l'exécution. Utilisez le fractionnement du code dans le cadre d’une stratégie de défense à plusieurs niveaux.
L'augmentation de la taille dépend de la taille de votre code d'origine et du nombre de morceaux. En règle générale, le fractionnement ajoute 15 à 40 % de surcharge, principalement à cause des déclarations de variables de bloc et du chargeur de réassemblage. Le pourcentage de surcharge est plus élevé pour les petits scripts et inférieur pour les bases de code plus volumineuses. Notre outil affiche la taille exacte de l'original, la taille de sortie et le pourcentage de modification afin que vous puissiez comparer les options.
Oui, notre séparateur de code JavaScript est 100 % gratuit, sans coûts cachés ni limitations. Aucune inscription n'est requise, aucun niveau premium, aucune limite d'utilisation, aucune restriction de taille de fichier et aucune publicité. Utilisez-le un nombre illimité de fois pour tout projet personnel ou commercial. Tout le traitement s'effectue localement dans votre navigateur.