Sunteți pe pagina 1din 14

Ministerul Educaiei al Republicii Moldova

Universitatea Tehnic a Moldovei


Facultatea Calculatoare, Informatic i Microelectronic
Catedra Automatic i Tehnologii Informaionale

RAPORT
Disciplina: Securitatea informaional

Lucrare de laborator Nr.1


Tema: Algoritmi simetrici de criptare. Algoritmul S-DES.

A efectuat:

st.gr TI-121 Cobla Adrian

A verificat:

lector universitar Cozma Nicolae

Chiinu 2015

1. Scopul lucrrii
n aceast lucrare de laborator se vor studia i analiza metodologii i algoritmi decriptare.
2. Sarcina lucrrii
De studiat i de implimentat algoritmii de criptare: Caesar, Polybius, Trimetrius i S-DES.
3. Noiuni teoretice
Criptografia clasic este criptografia dinaintea calculatorului, de unde i denumirea de criptografie
precomputaional. n criptografia clasic, algoritmii erau bazai pe caracter i constau dintr-o serie de
transformri elementare (substituii, transpoziii) ale caracterelor textului n clar. Unii algoritmi aplicau
aceste transformri n mod repetat, mbuntind n acest mod securitatea algoritmului. n criptografia
modern bazat pe calculator (criptografie computaional), lucrurile s-au complicat, dar multe dintre ideile
criptografiei clasice au rmas nemodificate.Criptografia clasic se ncadreaz n clasa criptografiei cu chei
simetrice.
Cifruri de substituie
Cifrul de substituie (substitution cipher) este cifrul bloc la care fiecare caracter sau grup de caractere ale
textului n clar (M) este substituit cu un alt caracter sau grup de caractere n textul cifrat (C), descifrarea
fcndu-se prin aplicarea substituiei inverse asupra textului cifrat.
n criptografia clasic exist patru tipuri de cifruri de substituie:
Cifruri de substituie monoalfabetic (monoalphabetic ciphers) sunt cifrurile n care fiecare caracter al
textului n clar (M) este nlocuit cu un caracter corespondent n textul cifrat (C). Cteva dintre cifrurile de
substituie cele mai cunoscute:
Cifrul lui Caesar este un cifru cu substituie monoalfabetic n care fiecare liter a textului n clar este
nlocuit cu o nou liter obinut printr-o deplasare alfabetic. Cheia este aceeai la criptare i la decriptare
i const n numrul ce indic deplasarea alfabetic C = aM + b (mod N) unde a se numete factor de
amplificare, iar b coeficient de deplasare.
Expemplu:
C(ni) = (ni + 3)(mod 26)
Text
Clar
Text
Cifrat

Tabelul 1 Substituie monoalfabetic pentru algoritmul Caesar.


Celebrul VENI VIDI VICI , devine prin criptare : YHQL YLGL YLFL.
Cifrul lui Polybius

Este un cifru substituie. Literele alfabetului latin sunt aezate ntr-un ptrat bidimensiune 5x5. Literele I
i J sunt combinate pentru a forma un singur caracter, deoarecealegerea final (ntre I i J) poate fi uor
decis din contextul mesajului. Rezult astfel 25 decaractere aezate ntr-un ptrat 5x5. Cifrarea oricrui
caracter se face alegnd perecheapotrivit de numere (intersecia liniei i coloanei) corespunztoare
dispunerii caracterului nptrat. Codul poate fi schimbat prin rearanjarea literelor n ptratul 5x5.

1
2
3
4
5

1
A
F
L
Q
V

2
B
G
M
R
W

3
C
H
N
S
X

4
D
IJ
O
T
Y

5
E
K
P
U
Z

Tabelul 2 Matricea poziionrii literelor pentru algoritmul Polybius.


Mesajul : A SOSIT TIMPUL , se cifreaz : 11 3443344244 444223535413.
Cifrul lui Trithemius
Este un cifru polialfabetic. Alfabetul este dispus pe 26 de linii numerotate de la 0 la 25, unde numrul de
ordine al liniei indic numrul de caractere cu care se deplaseaz ciclic alfabetul spre dreapta. Linia
numerotat cu 0 constituie tocmai alfabetul n ordinea iniial. Acest cifru poate fi utilizat astfel: primul
caracter se cifreaz selectndu-l din linia 1, al doilea din linia a 2-a i aa mai departe.

Figura 1 Matricea lui Trithemius


Mesajul: A SOSIT TIMPUlse cifreaz: B URWNZ AQVZFX

Tehnica de criptare DES (Data Encryption Standard) a aprut n anii '70 n Statele Unite ale Americii.
Standardul de criptare a fost realizat de Biroul Naional de Standardizare (National Bureau of Standards) cu
ajutorul Ageniei Naionale de Securitate (National Security Agency). Aceast tehnic de criptare este una
dintre cele mai utilizate. Scopul acestei tehnici este acela de a asigura o metod standard pentru protejarea
datelor comerciale neclasificate. IBM a creat n anul 1976 o prim implementare a algoritmului sub numele
de Lucifer.Acest algoritm utilizeaz reprezentarea binara a codurilor numerice ale caracterlor folosite pentru
reprezentarea datelor care urmeaz a fi criptate. Algoritmul de baz DES folosete blocuri de 64 de bii de
date i aplic doar dou operaii asupra intrrii: deplasare i substituie de bii. Cheia de criptare controleaz
procesul de codificare a datelor. Prin aplicarea celor dou operaii n mod repetat i neliniar, se obine un
rezultat care, practic, nu poate fi decriptat dect dac se cunoate cheia de criptare.Asupra fiecrui bloc de
date, algoritmul se aplic de pn la 16 ori (DES standard aplic algoritmul de criptare de 16 ori).Datorit
complexitii ridicate a algoritmului DES standard, n continuare v prezentm varianta simplificat a
algoritmului DES, Simple-DES, care folosete blocuri de 8 bii de date.
Algoritmul DES simplificat poate fi exprimat ca o compunere de cinci funcii:
o permutare iniial IP, care permut biii blocului de intrare;
o funcie f, care depinde de o subcheie k1 a unei chei de criptare K; funcia estefoarte complex i
acioneaz asupra jumtii stngi a blocului de date rezultatla pasul anterior;
o permutare SW, care interschimb cele dou jumti ale blocului de date rezultat la pasul anterior.
Dac blocul de date este 1 2 3 4 5 6 7 8 d d d d d d d d atunci acesta devine 5 6 7 8 1 2 3 4 d d d d d
1d d d ,unde i d reprezint al i-lea bit din blocul d;
aceeai funcie f, care folosete o alt subcheie ( 2 k ) a cheii de criptare K;
inversa permutrii IP,IP ^ -1 .
4. Sarcina practic
Algoritmul Caesar utilizeaz o substituie monoalfabetic n care fiecare liter a textului n clar este
nlocuit cu o nou liter obinut printr-o deplasare alfabetic. Implementarea algoritmului este prezent n
anexa A. n figura 2 este reprezentat rezultatul execuiei programului cu deplasarea 3.

Figura 2 Algoritmul Caesar


Algoritmul Polybius folosete o matrice care are ca elemente literele alfabetului. n depende de ce liter
se cripteaz se alege linia i coloana din acea matrice. Implementarea algoritmului este n anexa B.

n figura 3 este reprezentat rezultatul execuiei programului pentru algoritmul Polybius. Fiecare liter se
nlocuiete cu coordonatele din matricea cu dimensiunea 5x5.

Figura 3 Algoritmul Polybius


Algoritmul Trithemius folosete o matrice 25x25 cu deplasari polialfabetice. n acest algoritm mport
ordinea literelor textului pentru criptare. n figura 4 este reprezentat rezultatul execuiei programului pentru
acest algoritm. Implementarea algoritmului o gsim n anexa C.

Figura 4 Algoritmul Trithemius


Algoritmul S-DES utilizeaz o cheie pe 10 bii pentru criptarea unui mesaj pe 8 bii i returneaz
deasemenea un mesaj n binar pe 8 bii. n figura 5 este reprezentat rezultatul execuiei
programului.Implementarea o putem gsi n anexa D.

Figura 5 Algoritmul S-DES

Concluzie
n aceast lucrare de laborator am studiat algoritmii de criptare al datelor care folosesc metode de
substituie. Am creat aplicaii care implementeaz algoritmii de criptare studiai n aceasta lucrare. Sunt nite
metode de criptare destul de simple i uor de implementat, de aceea acestea se utilizeaz mai des n scopuri
educaionale , n prezent se utilizeaz astfel de algoritmi precum DES, RSA,AES, DSA i altele.

Bibliografie
1. Crypto Tool Project, accesat 07.11.2015, [Resursa electronica]. Regim de acces:
http://www.cryptool-online.org/index.php?option=com_content&view=article&id=70&Itemid=80&
lang=en
2. Polybius
square
accesat
08.11.2015,
[Resursa
electronica].
Regim
de
acces:
https://en.wikipedia.org/wiki/Polybius_square

Anexa A
Algoritmul Caesar
public class CaesarCipher {
public String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
public String encrypt(String plainText, int shiftKey) {
plainText = plainText.toLowerCase();
plainText = plainText.replaceAll("\\s","");
String cipherText = "";
for (int i = 0; i < plainText.length(); i++) {
int charPosition = ALPHABET.indexOf(plainText.charAt(i));
int keyVal = (shiftKey + charPosition) % 26;
char replaceVal = ALPHABET.charAt(keyVal);
cipherText += replaceVal;
}
return cipherText;
}
public String decrypt(String cipherText, int shiftKey) {
cipherText = cipherText.toLowerCase();
cipherText = cipherText.replaceAll("\\s","");
String plainText = "";
for (int i = 0; i < cipherText.length(); i++) {
int charPosition = ALPHABET.indexOf(cipherText.charAt(i));
int keyVal = (charPosition - shiftKey) % 26;
if (keyVal < 0) {
keyVal = ALPHABET.length() + keyVal;
}
char replaceVal = ALPHABET.charAt(keyVal);
plainText += replaceVal;
}
return plainText;
}
}

Anexa B
Algoritmul Polybius
public class PolybiusCipher {
private static char[][] matrix = { {'a','b','c','d','e'},
{'f','g','h','i','k'},
{'l','m','n','o','p'},
{'q','r','s','t','u'},
{'v','w','x','y','z'}};
private String characterPosition(char character)
{
for(int i=0;i<5;i++)
{
for(int j=0;j<5;j++)
{
if(character == 'j')
return ((2)+""+(4)+" ");
if(character==matrix[i][j])
return ((i+1)+""+(j+1)+" ");
}
}
return null;
}
public String encrypt(String plainText){
plainText = plainText.toLowerCase();
plainText = plainText.replaceAll("\\s","");
String cipherText = "";
for (int i = 0; i < plainText.length(); i++) {
cipherText += characterPosition(plainText.charAt(i));
}
return cipherText;
}
}

Anexa C
Algoritmul Trithemius
public class TritemiusCipher {
private char characterEncoding(char character,int numberRotation)
{
int characterPosition = 0;
if (numberRotation == 26) {
numberRotation = 1;
}
for (int i = 0; i < 25; i++) {
if (matrix[i][0] == character) {
characterPosition = i;
break;
}
}
return matrix[(characterPosition+1)][numberRotation];
}
public String encrypt(String plainText){
plainText = plainText.toLowerCase();
plainText = plainText.replaceAll("\\s","");
String cipherText = "";
for (int i = 0; i < plainText.length(); i++) {
cipherText += characterEncoding(plainText.charAt(i), i);
}
return cipherText;
}
}

Anexa D
Algoritmul S-DES
public class SDES {
// subkeys
//
public int K1, K2;
// permutations
//
public static final int P10[] = { 3, 5, 2, 7, 4, 10, 1, 9, 8, 6};
public static final int P10max = 10;
public static final int P8[] = { 6, 3, 7, 4, 8, 5, 10, 9};
public static final int P8max = 10;
public static final int P4[] = { 2, 4, 3, 1};
public static final int P4max = 4;
public static final int IP[] = { 2, 6, 3, 1, 4, 8, 5, 7};
public static final int IPmax = 8;
public static final int IPI[] = { 4, 1, 3, 5, 7, 2, 8, 6};
public static final int IPImax = 8;
public static final int EP[] = { 4, 1, 2, 3, 2, 3, 4, 1};
public static final int EPmax = 4;
public static final int S0[][] = {
{ 1, 0, 3, 2},
{ 3, 2, 1, 0},
{ 0, 2, 1, 3},
{ 3, 1, 3, 2}
};
public static final int S1[][] = {
{ 0, 1, 2, 3},
{ 2, 0, 1, 3},
{ 3, 0, 1, 0},
{ 2, 1, 0, 3}
};
// permute bits
//
public static int permute( int x, int p[], int pmax)
{
int y = 0;
for( int i = 0; i < p.length; ++i) {
y <<= 1;
y |= (x >> (pmax - p[i])) & 1;
}
return y;
}
// F function
//
public static int F( int R, int K)
{
int t = permute( R, EP, EPmax) ^ K;
int t0 = (t >> 4) & 0xF;
int t1 = t & 0xF;
t0 = S0[ ((t0 & 0x8) >> 2) | (t0 & 1) ][ (t0 >> 1) & 0x3 ];

t1 = S1[ ((t1 & 0x8) >> 2) | (t1 & 1) ][ (t1 >> 1) & 0x3 ];
t = permute( (t0 << 2) | t1, P4, P4max);
return t;
}
// fK function
//
public static int fK( int m, int K)
{
int L = (m >> 4) & 0xF;
int R = m & 0xF;
return ((L ^ F(R,K)) << 4) | R;
}
// switch function
//
public static int SW( int x)
{
return ((x & 0xF) << 4) | ((x >> 4) & 0xF);
}
// encrypt one byte
//
public byte encrypt( int m)
{
m = permute( m, IP, IPmax);
m = fK( m, K1);
m = SW( m);
m = fK( m, K2);
m = permute( m, IPI, IPImax);
return (byte) m;
}
// decrypt one byte
//
public byte decrypt( int m)
{
m = permute( m, IP, IPmax);
m = fK( m, K2);
m = SW( m);
m = fK( m, K1);
m = permute( m, IPI, IPImax);
return (byte) m;
}
// print n bits in binary
//
public static String printb(int x, int n)
{
int mask = 1 << (n-1);
String output = "";
while( mask > 0) {
output += ((x & mask) == 0) ? '0' : '1';
mask >>= 1;
}
return output;
}
// constructor - initializes K1 and K2
//
public SDES( int K)

{
K = permute( K, P10, P10max);
// 5-bit parts of K
//
int t1 = (K >> 5) & 0x1F;
int t2 = K & 0x1F;
// LS-1
//
t1 = ((t1 & 0xF) << 1) | ((t1 & 0x10) >> 4);
t2 = ((t2 & 0xF) << 1) | ((t2 & 0x10) >> 4);
K1 = permute( (t1 << 5) | t2, P8, P8max);
// LS-2
//
t1 = ((t1 & 0x7) << 2) | ((t1 & 0x18) >> 3);
t2 = ((t2 & 0x7) << 2) | ((t2 & 0x18) >> 3);
K2 = permute( (t1 << 5) | t2, P8, P8max);
}
}