Ministerul Educaiei al Republicii Moldova

Universitatea Tehnic a Moldovei

Catedra: Automatic i Tehnologii Informaionale

RAPORT
Lucrare de laborator Nr.1
la disciplina Metode Criptografice de Protecie a Informaiei
Tema: Dezvoltarea unui algoritm de criptare simetrica

A efectuat: st. gr. SI-131

Ciornii Nicolae

A verificat: lect. univ.

I. Antohi

Chiinu 2016
 Scopul lucrrii: Elaborarea unui algoritm de criptare simetrica

Sarcina lucrrii:
Implementarea unui program de criptare/decriptare folosind aceeasi cheie.

Mersul lucrrii:
Tehnica de criptare Vigenere este o tehnic polialfabetic, n sensul c, prin criptare, dou sau mai
multe caractere diferite ale textului iniial pot fi codificate folosind acelasi caracter n textul
criptat. Pentru a cripta un text folosind aceast metod se alege mai nti un alfabet, astfel nct toate
caracterele coninute n textul iniial s se afle printre caracterele alfabetului si apoi o parol format
din caractere ale alfabetului. Nu este necesar ca alfabetul ales s conin numai caracterele textului
iniial.
Funciile fi de substituie se definesc astfel:
(a) = (a+ )(mod n) unde n este lungimea alfabetului, este litera cheii k= 1 2 , iar a este
litera din mesajul clar.
n figura 1 este reprezentat rezultatul cifrrii unui text clar utiliznd algortimul Vigenere:

Figura 1 Cifrarea textului clar

n figura 2 este prezentat rezultatul decifrrii mesajului utiliznd metoda brute forcing, n
cazul n care avem doar mesajul criptat ns nu se cunoate cheia i textul clar. Pentru aceasta, se
determin toate cheile posibile, se decripteaz mesajul, iar cuvintele mesajului au fost comparate
cu cuvintele dintr-un dicionar.

Figura 2 Decifrarea mesajului

Codul surs:
Clasa VigenereAlgorithm:
Aceast clas conine paii algoritmului Vigenere, att pentru criptarea textului, ct i pentru
decriptare.
public class VigenereAlgorithm {

private String alphabetM;

private int alphabetSizeN;

public VigenereAlgorithm(String alphabetM)

{
this.alphabetM = alphabetM;
this.alphabetSizeN = alphabetM.length();
}

public String getAlphabetK() {

return alphabetM;
}
 public void setAlphabetK(String alphabetM) {
this.alphabetM = alphabetM;
}

private int getMi(char character) throws IOException

{
int result = this.alphabetM.indexOf(String.valueOf(character));

if(result == -1){
throw new IOException("Not character '"+character+"' for text in alphabet.");
}

return result;
}

private int getKj(int position, String passphraseK) throws IOException

{
char character = passphraseK.charAt(position%passphraseK.length());
int result = this.alphabetM.indexOf(character);

if(result == -1){
throw new IOException("Not character '"+character+"' for key in alphabet.");
}

return result;
}

public String cipher(String plainText, String passphraseK) throws IOException

{
int plainTextSize = plainText.length();

char[] Ci = new char[plainTextSize];

int Mi, Kj; /* for i = position from char in plainText and j = i mod passphrase length
*/
for(int i = 0; i < plainTextSize; i++)
{

/* get position from char i of plainText on alphabetM */

Mi = getMi(plainText.charAt(i));

/* get position from i mod d (passphraseK length) */

Kj = getKj(i, passphraseK);

/* get char from Mi+Kj mod N (alphabetM length) */

Ci[i] = this.alphabetM.charAt((Mi + Kj) % this.alphabetSizeN);
}

return new String(Ci);

}

public String decipher(String cipherText, String passphraseK) throws IOException

{
int cipherTextSize = cipherText.length();

int inverseModule;
char[] Mi = new char[cipherTextSize];
int Ci, Kj; /* for i = position from char in plainText and j = i mod passphrase length
*/
for(int i = 0; i < cipherTextSize; i++)
{

/* get position from char i of plainText on alphabetM */

Ci = getMi(cipherText.charAt(i));
//this.alphabetM.indexOf(String.valueOf(plainText.charAt(i)));

/* get position from i mod d (passphraseK length) */

Kj = getKj(i, passphraseK);

/* get char from Mi+Kj mod N (alphabetM length) */

 inverseModule = (Ci - Kj) % this.alphabetSizeN;

/* Java doesn't resolve negative modules!! */

inverseModule = inverseModule>=0 ? inverseModule :
inverseModule+this.alphabetSizeN;

Mi[i] = this.alphabetM.charAt(inverseModule);
}

return new String(Mi);

}
}

Encrypter.java:
Aceast clas se refer la execuia criptrii textului clar. Aici se indic alfabetul initial utilizat n criptare.

public class Encrypter {

public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String M; //Textul pentru cifrare

String K; //Cheia

String command; //comanda in consola

String result;

// Alfabetul initial
String defaultM = "abcdefghijklmnopqrstuvwxyz ";

System.out.println("Enter comand (-c for crypting and -d for decrypting):");

command = br.readLine();

System.out.println("Enter message for crypting:");

M = br.readLine();

System.out.println("Enter the key for crypting:");

K = br.readLine();

System.out.println("Text: "+ M);

System.out.println("M: "+ M);
System.out.println("K: "+ K);

/* Creaza un obiect viginere */

VigenereAlgorithm vigenere = new VigenereAlgorithm(defaultM);

/* Primirea textului difrat sau descifrat */

if(command.equals("-d") || command.equals("--decipher"))
{
result = vigenere.decipher(M, K);
System.out.println("Decipher text: " + result);
}else if(command.equals("-c") || command.equals("--cipher"))
{
result = vigenere.cipher(M, K);
System.out.println("Cipher text: " + result);

}else{
throw new IllegalArgumentException("Not a valid argument: "+args[0]);
}

}
}

BruteForce.java
n aceast clas sunt implementai paii de bruteforcing pentru determinarea textului clar.
 Metoda checkPossibleKey() genereaz toate cuvintele posibile formate la descifrarea textului cu
cheia generat de metoda permutation()
private static ArrayList<Object> ckeckPossibleKey(String key) {
VigenereAlgorithm vigenere = new VigenereAlgorithm(defaultM);

String result = null;

try {
result = vigenere.decipher(cipherText, key);
} catch (IOException e) {
e.printStackTrace();
}

if (result.contains(" ")) {
parts = result.split(" ");
int i = 0;
while (i < parts.length) {
possibleResults.add(parts[i]);
i++;
}
}
// System.out.println("Possible results" + possibleResults);
return possibleResults;

}
Metoda permutation() genereaz toate cheile posibile, care sunt utilizate ca argumentul metodei
checkPossibleKey(String key). n metoda permutation() de asemenea se determin identicitatea
cuvintelor obinute cu cele din dicionar, astfel gsindu-se mesajul clar.
Concluzie:
n lucrarea data am folosit principiul criptrii simetrice.Mi-am fcut cunotin cu
implementarea cifrului polialfabetic Vigenere. Am analizat metode de determinare a
textului clar dintr-un text cifrat (n cazul n care nu cunoatem cheia) , i anume brute-
forceing-ul.