CSIE ID Anul I

CREAREA PAROLELOR PSEUDO-ALEATOARE

Parolele pseudo-aleatoare au la baza algoritmul generarii numerelor aleatoare.
Dupa cum sugereaza si numele, numere pseudo-aleatoare nu sunt cu adevarat aleatorii
ci, mai
degraba, ele sunt generate cu o formula matematica. In prezent, in logistica celor mai
multe organizatii se impune folosirea unui anumit numar de caractere pentru parole, cu
o anumita complexitate si reguli pentru schimbarea ei.
Pentru administratorii de sistem, generarea unei parole este un element
important pentru
ment inerea unui mediu sigur. Administratorul de sistem trebuie sa se asigure ca fiecare
cont are o
parola care este cunoscut doar pentru utilizatori si nu este usor de ghicit de catre alti
utilizatori. Se
pleaca de la prezumtia ca o parol mai lunga de 7 caractere alfanumerice este mai greu
de spart
decat una mai scurta.
S-a ajuns la implementarea acestor parole pseudo-aleatoare deoarece s-a constatat ca
in
general, utilizatorul, foloseste drept parola caractere logice usor de retinut precum: data
nasterii, numele sotului, al animalului preferat, al echipei favorite, iar de regula pentru a
satisface
cerintele de complexitate adauga la sfarsit o cifra ,de aici rezultand o parola usor de
ghicit.
Crearea acetor tipuri de parole are la baza alegerea unui numar/vector utilizat
pentru
initializarea unui generator de numere pseudo-aleatoare, aceast alegere este crucial
pentru
securitate .Acest numar este folosit pentru crearea urmatoarelor secvente de numere
aleatoare .
Aaa cum este de asteptat, daca intotdeauna se va alege acelasi numar initial, se va
obtine aceiasi
secventa de numere aleatoare. Pentru ca numarul initial sa varieze de fiecare data se
foloseste un
identificator de proces unic al shell-ului activ numit PID. In majoritatea problemelor se
foloseste initializarea RANDOM=$$ unde RANDOM contine la fiecare accesare un numar
aleator intre 0 i 32767 , iar $$ reprezinta identificatorul de process (PID). Acest numar
poate
fi usor generat si afisat prin comanda echo $RANDOM .
Exista mai multe tipuri de generare a parolelor pseudo-aleatoare de tip intreg .Se
poate
stabili ca numarul sa fie cuprins intre 1 si o limita maxima. De asemenea se poate
genera o
valoare aleatoare dupa o limita inferioara sau se pot stabili numere pseudo aleatoare
de o
dimensiune fixata prin adaugarea de zero-uri in fata numarului pentru a mentine
dimensiunea
stabilita (algoritmul exemplificat in exemplul 1 criteriul 4 in Korn Shell).
Generatoarele de numere pseudo-aleatoare produc numere prin calcul (prin

urmare
numerele generate sunt deterministe ), dar algoritmul de generare amesteca suficient
de bine numerele pentru ca sirul de numere sa par aleator. In fiecare moment
generatorul are asociat o
stare intern .Starea intern este o valoare dintr-o multime arbitrar suficient de mare.
Acest
numar este obtinut prin aplicarea unui algoritm care modifica starea interna pentru ca
urmatorul
numar sa nu aiba aceeasi valoare. Daca acest algoritm amesteca destul de bine bitii,
sirul pseudo
-aleator are proprietatea de a fi un numar cu adevarat aleator, desi multimea stariilor
interne este
finit si la un moment dat numerele se vor repeta datorita periodicitatii.
Este foarte dificil sa creezi cu adevarat un numar aleator intr-un sistem
computerizat.
Problema este repetabilitatea si predictibilitatea numarului. O metoda foarte populara
de
generare automata a parolelor pseudo aleaatoare, este utilizand o sursa reala de date
aleatoare.
Multe sisteme UNIX ofera un modul de kernel, / dev / random care utilizeaza sistemele
de
evenimente (intrerupe traficul in retea, etc), ca o sursa de entropie pentru a produce
date reale
aleatoare. De asemenea in exemplul de mai jos pentru generarea unui numar pseudoaleator s-a
folosit /dev/urandom. Intre cele doua dispozitive de generare aleatoare /dev/random si
/dev/urandom exista o diferenta constand in faptul ca /dev/random genereaza numere
pseudoaleatoare de inalta calitate generand biti aleatori pana la o limita stabilita, si ea
aleatoare, pe
cand /dev/urandom nu are aceast limitare.

Exemplu:
echo `</dev/urandom tr -dc A-Za-z0-9 | head -c8`

head -c8 alege primele 8 caractere aleatoare pentru formarea unei parole
pseudoaleatoare
/dev Director pentru dispozitive speciale
Exemplul 1: Crearea unei parole pseudo-aleatoare de tip intreg in functie de criteriile
din meniu (prin utilizarea functiei RANDOM):
#!/bin/bash
echo Va rugam sa selectati o criterie de generare a parolei pseudo-aleatoare de tip
numeric
echo 1) Un numar pseudo-aleator intre 1 si o limita superioar aleasa
echo 2) Un numar pseudo-aleator mai mare decat o valoare aleasa
echo 3) Un numar pseudo-aleator compus din suma a 10 numere pseudo-aleatoare

echo 4) Un numar de dimensiune fixa intre 1 si o limita superioara

read criteriu
case $criteriu in
# algoritm realizat in Korn Shell
1)RANDOM=$$
echo Introduceti limita superioara
read UPPER_LIMIT
RANDOM_PASS=$(($RANDOM % $UPPER_LIMIT + 1))
echo Parola dumneavostra este $RANDOM_PASS;;
#
2)echo Introduceti limita inferioara
read MIN
number=0
RANDOM=$$
while [ $number -le $MIN ]
do
number=$RANDOM
done
echo Parola pseudo-aleatoare este $number;;
3)MAXCOUNT=10
RANDOM=$$
PASS=0
count=1
while [ $count -le $MAXCOUNT ]
do
number=$RANDOM
PASS=`expr $PASS + $number `
count=`expr $count + 1`
done
echo parola este $PASS;;

# algoritm realizat in Korn Shell

4)UPPER_LIMIT=9999
PASSWORD=$((RANDOM % $UPPER_LIMIT + 1))
RP_LENGTH= ${#PASSWORD}
UL_LENGTH=${#UPPER_LIMIT}
((LENGTH_DIFF= UL_LENGTH RP_LENGTH))
case $LENGTH_DIFF in
0) echo $PASSWORD;;
1) echo 0$PASSWORD;;
2) echo 00$PASSWORD;;
3) echo 000$PASSWORD;;
4) echo 0000$PASSWORD;;
5) echo 00000$PASSWORD;;
*)echo $PASSWORD;;
Esac
#

*) echo optiune invalida

esac

MAXCOUNT reprezinta valoarea numerelor pseudo-aleatoare

RP_LENGTH= ${#PASSWORD} retine dimensiunea parolei pseudo-aleatoare
numerice
generate
UL_LENGTH=${#UPPER_LIMIT} retine dimensiune limitei superioare
((LENGTH_DIFF= UL_LENGTH - RP_LENGTH))
LENGTH_DIFF retine diferenta dintre dimensiunea limitei si dimensiune parolei
pentru a putea stii cate zerouri sa adauge la parola pseudo-aleatoare creata
pentru a mentine o dimenisiune fixa a parolelor la fiecare rulare a programului
(( )) face operatii aritmetice si atribuie variabilei rezultatul obtinut specific Korn
Shell
Exemplul 2 :Generare a unei parole pseudo-aleatoare de minim 8 caractere (cu
ajutorul
crearii unei matrici ce contine numere si litere ):
#!/bin/bash
MATRIX="0123456789ABCDEFGHIJKLMNOPRSTUVWXYZabcdefghijklmnoprstuvwxyz"
echo Introduceti numarul de caractere al parolei
read LENGTH
if [ $LENGTH -lt 8 ]
then
echo parola trebuie sa aiba minim 8 caractere
echo introduceti numar carctere
read LENGTH
fi
if [ $LENGTH -ge 8 ]
then
while [ ${n:=1} -le $LENGTH ]
do
PAROLA=$PAROLA${MATRIX:$(($RANDOM%${#MATRIX})):1}
let n+=1
done
fi
echo parola este $PAROLA
n:=1 initializeaza variabila n cu 1 in cazul in care nu a fost initializata in prealabil
%${#MATRIX} returneaza dimensiunea matricei
$RANDOM%${#MATRIX} returneaza un numar aleator intre 1 si dimensiunea
matricei -1
let n+=1 incrementeaz variabila n pentru pasul urmator al ciclarii
De asemea o alta metoda de generare a parolelor pseudo aleatoare este cu ajutorul
makepasswd care se instaleaz prin linia de comanda: $ sudo apt-get install makepasswd
iar
apoi poate fi apelat n program. Este o metoda usoara si eficienta pentru generarea
parolei de
dimensiunea dorita.

Exemplul 3: Generarea unei parole pseudo-aleatoare de 10 caractere prin makepasswd

#!/bin/bash
RPASS=$(makepasswd --char=10)
echo parola generata este $RPASS

makepasswd genereaz o parola pseudo-aleatoare

--char=10 stabileste numarul de caractere ca fiind =10

Exemplul 4: Generarea unei parole pseudo-aleatoare din fisierul creat. (unde fisierul
contine pe fiecare linie in parte numere, litere si caractere ).
Exemplu continut fisier : 1 2 3 4 5 6 7 8 9 0 a b c d e f g h I j l m n o p r s # $ % ^
&*(^~|/
Algoritmul consta in alegerea aleatoare a unei linii din fisier deci implicit al unui
caracter, de un numar de pasi egal cu lungimea parolei dorite de utilizator.
Este de preferat stergerea liniilor nule din fisier inainte de generarea parolei
#!/bin/bash
#fisierul creat se numeste tmp.txt si contine pe fiecare linie cate un caracter
FILE=tmp.txt
# stergerea liniilor nule
sed '/^$/d' $FILE > tt
mv tt $FILE
password= #intializarea variabilei password cu valoarea nula
echo dimensiunea parolei dorite
read dim
i=1
while [ $i le $dim ]
do
random_line=$(cat $FILE | sort --random-sort | head -n 1)
password=$password$random_line
i=`expr $i + 1` #incrementarea contorului i
done
echo $password

verificarea liniilor nule se face prin expresia ^$ n care ^=inceputul liniei i

$=sfarsitul liniei, cu niciun caracter intre
noul fisier este redirectionat spre un alt fisier tt prin comanda $FILE > tt iar
apoi mutat n
fisierul initial pornind comanda mv tt $FILE
cat $FILE | sort --random-sort | head -n 1 alege aleator una din liniile din fisier
head reprezinta partea de sus a paginii
Exemplul 5: Generare parol pseudo-aleatoare de 12 caractere cu ajutorul elementelor
unei
multimi:

#!/bin/bash
MAXSIZE=12 #reprezinta dimensiunea parolei, dimensiune ce poate fi oricand

modificata
RANDOM=$$
array=(
qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASD
F G H J K L Z X C V B N M 1 2 3 4 5 6 7 8 9 0 \! \@ \# \$ \% \^ \& \* \( \)
\! \@ \# \$ \% \^ \& \* \( \) \! \@ \# \$ \% \^ \& \* \( \) \! \@ \# \$ \%
)
# MODNUM este folosit pentru a pastra numerele aleatoare in dimensiunea multimii
MODNUM=${#array[*]}
i=0 # un contor ce pastreaza numarul de caractere generat in parola
while [ $i -lt $MAXSIZE ]
do
index=$(($RANDOM%$MODNUM))
password=${password}${array[$index]}
let i+=1 #incrementare contor
done
echo Parola este $password

blackslash-ul se foloseste pentru ca acele caractere din array ce indeplinesc

anumite functii
sa isi piard semnificatia (ele devin semne si nu mai sunt comenzi)
Mediul de test: Ubuntu