Crypteur / décrypteur de texte avec clé de cryptage

Télécharger le projet
Commenter

Description

Donc voilà ma deuxième source :
C'est un crypteur / décrypteur de mot de passe (je dit "crypteur"... mais c'est un grand mot quand même :))
Il utilise une clé de cryptage choisi par l'utilisateur pour crypter le texte voulut.
On peut choisir d'avoir le résultats sour forme de chiffres ou sous forme de caractères (c'est pour le fun :p mais sous formes de caractères le résultat est beaucoup plus court donc plus pratique, surtout que le temps de cryptage / décryptage est proportionnel à la taille du texte entré (car le code analyse le texte caractère par caractère).

Le principe n'est pourtant pas très compliqué (mais très éfficace :)) :
On entre dans un tableau les valeurs ASCII de chaques caractères de la clé, on analyse le texte entré et on récupère chaque code ASCII du texte, enfin on ajoute tour a tour un une valeur ASCII de la clé à une valeur du texte ! Voila c'est "crypté" !
Pour renforcer la sécurité, entre chaque caractère du texte crypté on ajoute un caractère aléatoir qui n'apparaitra pas lors du décryptage :)

Tous est expliqué dans le code, je me suis éfforcer de le commenter au maximum !

Source / Exemple : 


///////////////////////////////////////////////////////////////////////////////////
/////////////                                                         /////////////
/////////////      Crypteur / Décrypteur de texte by DarkGoovyX       /////////////
/////////////                                                         /////////////
///////////////////////////////////////////////////////////////////////////////////
//
//
//
//Focntion qui permet de crypter le texte sous forme de chiffres :
crypte = function (txt, cle) {
	result.text = "";
	// On créé un nouveau tableu qui contiendra les code ASCII de la cle :
	lesCle = new Array();
	// On complète le tableau :
	for (i=0; i<cle.length; i++) {
		lettreCle = cle.substr(i, 1);
		algoASCII = ord(lettreCle);
		lesCle.push(algoASCII);
	}
	j = 0;
	for (i=0; i<txt.length; i++) {
		// On définit une lettre au hasard placer entre chaque lettre sous forme crypté : (renforce le cryoptage :))
		lettreFactice = string.fromCharCode(random(256));
		// On selectionne la lettre a analyser :
		lettre = txt.substr(i, 1);
		// On la converti en code ASCII :
		codeASCII = ord(lettre);
		// On crypte cette lettre en ajoutan a son code ASCII, celui d'une des lettres de la cle :
		codeCrypter = Number(codeASCII)+Number(lesCle[j]);
		// On passe au code ASCII de la cle suivant :
		j++;
		// Si on à passer toutes les lettres de la cle en vu, on recommence :
		if (j == (lesCle.length-1)) {
			j = 0;
		}
		// On s'arange pour que quelque soit le code ASCII, il comporte 3 chiffre au final :
		if (codeCrypter<10) {
			codeASCIIEncode = "00"+codeCrypter;
		} else if (codeCrypter<100) {
			codeASCIIEncode = "0"+codeCrypter;
		} else {
			codeASCIIEncode = codeCrypter;
		}
		// On ajoute le code modifier ainsi que la lettre factice au resultat :
		result.text += codeASCIIEncode;
		result.text += lettreFactice;
	}
};
//
//
//Fonction qui permet de décrypter un texte crypter avec un cryotage type lettre :
decrypte = function (txt, cle) {
	result.text = "";
	// Pareil que précédement :
	lesCle = new Array();
	// On complète le tableau :
	for (i=0; i<cle.length; i++) {
		lettreCle = cle.substr(i, 1);
		algoASCII = ord(lettreCle);
		lesCle.push(algoASCII);
	}
	// On récupère un à un les code ASCII du texte encrypté :
	j = 0;
	// Le i += 4 permet de paC de série de 3 en série de troi tout en sautant le caractère factice :
	for (i=0; i<(txt.length); i += 4) {
		codeCrypter = txt.substr(i, 3);
		// On converti le code rencontré en caractère :
		lettreCrypter = string.fromCharCode(codeCrypter);
		// On transforme le code du caractère cryopter en code décrypter :
		codeLettreDecrypter = Number(codeCrypter)-Number(lesCle[j]);
		lettreDecrypter = string.fromCharCode(codeLettreDecrypter);
		// On l'ajoute à la liste :
		result.text += lettreDecrypter;
		j++;
		if (j == (lesCle.length-1)) {
			j = 0;
		}
	}
};
//Pour les deux fonctionsuivantes, le principe est le même que pour les précédentes, je ne recommente donc pas tout :)
crypteurLettre = function (txt, cle) {
	result.text = "";
	// On créé un nouveau tableu qui contiendra les code ASCII de la cle :
	lesCle = new Array();
	// On complète le tableau :
	for (i=0; i<cle.length; i++) {
		lettreCle = cle.substr(i, 1);
		algoASCII = ord(lettreCle);
		lesCle.push(algoASCII);
	}
	j = 0;
	for (i=0; i<txt.length; i++) {
		lettreFactice = string.fromCharCode(random(256));
		// On selectionne la lettre a analyser :
		lettre = txt.substr(i, 1);
		// On la converti en code ASCII :
		codeASCII = ord(lettre);
		// On crypte cette lettre en ajoutan a son code ASCII, celui d'une des lettres de la cle :
		codeCrypter = Number(codeASCII)+Number(lesCle[j]);
		// On passe au code ASCII de la cle suivant :
		j++;
		// Si on à passer toutes les lettres de la cle en vu, on recommence :
		if (j == (lesCle.length-1)) {
			j = 0;
		}
		lettreCrypter = string.fromCharCode(codeCrypter);
		// trace(codeASCIIEncode);
		result.text += lettreCrypter;
		result.text += lettreFactice;
	}
};
//
decrypteurLettre = function (txt, cle) {
	result.text = "";
	lesCle = new Array();
	// On complète le tableau :
	for (i=0; i<cle.length; i++) {
		lettreCle = cle.substr(i, 1);
		algoASCII = ord(lettreCle);
		lesCle.push(algoASCII);
	}
	// On récupère un à un les code ASCII du texte encrypté :
	j = 0;
	for (i=0; i<(txt.length); i += 2) {
		codeCrypter = txt.substr(i, 1);
		lettreCrypter = ord(codeCrypter);
		codeLettreDecrypter = Number(lettreCrypter)-Number(lesCle[j]);
		lettreDecrypter = string.fromCharCode(codeLettreDecrypter);
		result.text += lettreDecrypter;
		j++;
		if (j == (lesCle.length-1)) {
			j = 0;
		}
	}
};
//
//Actio nsur le bouton "traiter" :
//
bt_valide.onRelease = function() {
	//Si la clé est définis :
	if (_root.cle !== "" and _root.cle !== undefined) {
		//Si cryptageLettre est coché :
		if (cryptageLettre.getState() == true) {
			//Si une des deux "action" est coché :
			if (crypt.getState() == true) {
				crypteurLettre(_root.texte_a_traiter, _root.cle);
			} else if (decrypt.getState() == true) {
				decrypteurLettre(_root.texte_a_traiter, _root.cle);
			} else {
				result.text = "";
				result.text = "Il faut choisir une action à effectuer";
			}
			//Si cryptageChifreest coché :
		} else if (cryptageChiffres.getState() == true) {
			//Si une des deux "action" est coché :
			if (crypt.getState() == true) {
				crypte(_root.texte_a_traiter, _root.cle);
			} else if (decrypt.getState() == true) {
				decrypte(_root.texte_a_traiter, _root.cle);
			} else {
				result.text = "";
				result.text = "Il faut choisir une action à effectuer";
			}
		} else {
			result.text = "";
			result.text = "Il faut choisir un type de cryptage";
		}
	} else {
		result.text = "";
		result.text = "Il manque la clé de cryptage";
	}
};

Conclusion :


J'ai conscience que le code est un peu long mais deux fonctions sont facultatives, à vous d'en faire ce que vous voulez :)
Sans la clé il est impossible de décrypter quoi que se soit.
Attention au trop long texte, le cryptage risque de prendre un peu de temps lol

PS : désolé pour l'emplois un peu abusif du mot "cryptage" lol ;)
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (goovy)