Chiffrement

César, affine, Hill, RSA

Hajar Laamache(S137082583)
package Cezar;

public class CesarCrypt {

public static void main(String[] args) {

String message = "safae";

int clef = 3; // nombre de positions à décaler

String messageChiffre = chiffrementCesar(message, clef);

System.out.println("Message chiffré: " + messageChiffre);

String messageDechiffre = dechiffrementCesar(messageChiffre, clef);

System.out.println("Message déchiffré: " + messageDechiffre);

// Fonction de chiffrement de César

public static String chiffrementCesar(String message, int clef) {

String messageChiffre = "";

for (int i = 0; i < message.length(); i++) {

char c = (char)(message.charAt(i) + clef);

if (c > 'z') {

messageChiffre += (char)(message.charAt(i) - (26 - clef));

} else {

messageChiffre += c;

}
 return messageChiffre;

// Fonction de déchiffrement de César

public static String dechiffrementCesar(String messageChiffre, int clef) {

String messageDechiffre = "";

for (int i = 0; i < messageChiffre.length(); i++) {

char c = (char)(messageChiffre.charAt(i) - clef);

if (c < 'a') {

messageDechiffre += (char)(messageChiffre.charAt(i) + (26 - clef));

} else {

messageDechiffre += c;

return messageDechiffre;

}
package Hill;

import java.util.Scanner;

public class HillCipher {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

// Demander à l'utilisateur de saisir la clé de chiffrement sous forme de matrice 2x2

int[][] key = new int[2][2];

System.out.println("Entrez la cle de chiffrement sous forme de matrice 2x2 :");

for (int i = 0; i < 2; i++) {

for (int j = 0; j < 2; j++) {

key[i][j] = scanner.nextInt();

// Demander à l'utilisateur de saisir le texte à chiffrer

System.out.println("Entrez le texte a chiffrer :");

scanner.nextLine();

String plaintext = scanner.nextLine().toUpperCase();

// Ajouter des lettres fictives pour que la longueur du texte soit un multiple de 2

while (plaintext.length() % 2 != 0) {

plaintext += "X";

// Chiffrer le texte par blocs de deux lettres

String ciphertext = "";

for (int i = 0; i < plaintext.length(); i += 2) {

 int[] block = {plaintext.charAt(i) - 'A', plaintext.charAt(i+1) - 'A'};

int[] encryptedBlock = multiplyMatrix(key, block);

ciphertext += (char) (encryptedBlock[0] + 'A');

ciphertext += (char) (encryptedBlock[1] + 'A');

// Afficher le texte chiffré

System.out.println("Texte chiffre : " + ciphertext);

// Fonction pour multiplier une matrice 2x2 avec un vecteur 2x1

public static int[] multiplyMatrix(int[][] matrix, int[] vector) {

int[] result = new int[2];

result[0] = (matrix[0][0] * vector[0] + matrix[0][1] * vector[1]) % 26;

result[1] = (matrix[1][0] * vector[0] + matrix[1][1] * vector[1]) % 26;

return result;

}
package Affine;

import java.util.Scanner;

public class AffineCipher {

private static final int a = 5; // coefficient a

private static final int b = 7; // coefficient b

private static final int m = 26; // taille de l'alphabet

// Fonction pour calculer l'inverse modulaire de a

private static int modInverse(int a, int m) {

a = a % m;

for (int x = 1; x < m; x++) {

if ((a * x) % m == 1) {

return x;

return -1;

// Fonction pour encrypter un message

public static String encrypt(String message) {

StringBuilder result = new StringBuilder();

for (int i = 0; i < message.length(); i++) {

char c = message.charAt(i);

if (Character.isLetter(c)) {

int charIndex = c - 'a';

int encryptedIndex = (a * charIndex + b) % m;

char encryptedChar = (char) (encryptedIndex + 'a');

result.append(encryptedChar);
 } else {

result.append(c);

return result.toString();

// Fonction pour décrypter un message

public static String decrypt(String message) {

StringBuilder result = new StringBuilder();

int aInverse = modInverse(a, m);

for (int i = 0; i < message.length(); i++) {

char c = message.charAt(i);

if (Character.isLetter(c)) {

int charIndex = c - 'a';

int decryptedIndex = (aInverse * (charIndex - b + m)) % m;

char decryptedChar = (char) (decryptedIndex + 'a');

result.append(decryptedChar);

} else {

result.append(c);

return result.toString();

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.print("Entrez le message à chiffrer : ");

String message = sc.nextLine();

String encryptedMessage = encrypt(message);

System.out.println("Message chiffré : " + encryptedMessage);

 String decryptedMessage = decrypt(encryptedMessage);

System.out.println("Message déchiffré : " + decryptedMessage);

sc.close();

}
import java.math.*;

public class RSA {

/* Les parametres secrets */

private long p, q, d;

private long phiN;

/* Les parametres publiques */

long N, e;

/* Genere les parametres RSA etant donnes deux nombres premiers p

* et q */

public RSA(long p, long q) {

N=p*q;

phiN=(p-1)*(q-1);

do {

d=(long)(Math.random() * phiN-3)+2;

e=invmod(d,phiN);}

while (e==0);

if (e<0) e=e+phiN;

/* Chiffre le message m avec l'exposant publique */

public long chiffre(long m) {

return (modpow(m,e,N));

/* Dechiffre le message c avec l'exposant secret */

public long dechiffre(long m) {

return (modpow(m,d,N));

/* Calcule l'inverse de x modulo n */

public static long invmod(long x, long n) {

if (x==0) return(0);

long u=1;

long v=0;

long y;

long q;

while (n !=0) {

y=n;

q=x/n;

n=x %n;

x=y;

y=v;

v=u-q*v;

u=y;

if (x==1) return (u);

else return(0);

/* Calcule x à la puissance exp modulo mod */

public static long modpow(long x, long exp, long mod) {

if (exp==0) return (1);

else {

long xx=1;

if (exp %2==1) xx=x %mod;

return (modpow(x*x %mod,exp/2,mod)*xx %mod);

/* Le main prend en arguments deux nombres premiers */

public static void main(String[] args) {

 long p = Long.parseLong(args[0]);

long q = Long.parseLong(args[1]);

RSA rsa = new RSA(p, q);

System.out.println("Module publique: N = " + rsa.N);

System.out.println("Clef publique: e = " + rsa.e);

System.out.println("Indicatrice d'Euler: phi(N) = " + rsa.phiN);

System.out.println("Clef privée: d = " + rsa.d);

System.out.println(" e * d mod phi(N) = " + (rsa.e * rsa.d % rsa.phiN));

System.out.println();

long msg = (int)(Math.random() * rsa.N);

System.out.println("Message: " + msg);

System.out.println("Chiffre: " + rsa.chiffre(msg));

System.out.println("Dechiffre " + rsa.dechiffre(rsa.chiffre(msg)));