MINISTERUL EDUCAŢIEI, CULTURII ȘI CERCETĂRII

Universitatea Tehnică a Moldovei

Facultatea Calculatoare Informatică şi Microelectronică
Departamentul Ingineria Software și Automatică

Raport
Disciplina: Securitatea informațională

Tema: “Algoritmul DSA”

Student: _____________ Mereuță Ana, TI-192

Coordonator: _____________ Răducanu Octavian, asist. univ.

Chişinău 2022
Explicațiile algoritmului
Obiectivul semnăturilor digitale este autentificarea și verificarea documentelor și datelor. Acest lucru este
necesar pentru a evita manipularea și modificarea digitală sau falsificarea în timpul transmiterii
documentelor oficiale. Cu o singură excepție, aceștia lucrează pe arhitectura criptografică cu cheie publică.
De obicei, un sistem de cheie asimetrică criptează folosind o cheie publică și decriptează cu o cheie privată.
Pentru semnăturile digitale, însă, este adevărat invers. Semnătura este criptată folosind cheia privată și
decriptată cu cheia publică. Deoarece cheile sunt legate, decodificarea acesteia cu cheia publică verifică
dacă cheia privată adecvată a fost utilizată pentru a semna documentul, verificând astfel proveniența
semnăturii.

Figura 1 – Reprezentarea procesului de procesare a datelor a algoritmului DSA

Imaginea de mai sus arată întreaga procedură a algoritmului DSA. Se va folosi aici două funcții diferite, o
funcție de semnare și o funcție de verificare. Diferența dintre imaginea unui proces tipic de verificare a
semnăturii digitale este partea de criptare și decriptare. Au parametri diferiți.

Algoritmul DSA oferă trei beneficii, care sunt următoarele:

- Autentificare mesaj: Puteți verifica originea expeditorului folosind combinația de taste potrivită;
- Verificarea integrității: nu puteți modifica mesajul, deoarece va împiedica decriptarea completă a
pachetului;
- Nerepudierea: expeditorul nu poate pretinde că nu a trimis niciodată mesajul dacă verifică
semnătura.
Avantajele algoritmului DSA
- Pe lângă faptul că are niveluri puternice de rezistență, lungimea semnăturii este mai mică în
comparație cu alte standarde de semnătură digitală;
- Viteza de calcul a semnăturii este mai mică;
- DSA necesită mai puțin spațiu de stocare pentru a funcționa în comparație cu alte standarde digitale;
Dezavantajele algoritmului DSA
- Este nevoie de mult timp pentru a se autentifica, deoarece procesul de verificare include operatori
rămași complicati. Este nevoie de mult timp pentru calcul.
- Datele din DSA nu sunt criptate. Putem autentifica datele doar în acest sens.
- Algoritmul de semnătură digitală calculează mai întâi cu hash SHA1 și îl semnează. Orice
dezavantaje în securitatea criptografică a SHA1 sunt reflectate în DSA, deoarece implicit DSA
depinde de acesta.
- Cu aplicații atât în comunicații secrete, cât și non-secrete, DSA este conform standardului național
al SUA.

Funcționarea algoritmului DSA

Prima parte a algoritmului DSA este generarea cheii publice și private, care pot fi descrise astfel:
Se alege un număr prim q, care se numește divizor prim.
Se alege un alt număr de primer p, astfel încât p-1 mod q = 0. p se numește modul prim.
Se alege un număr întreg g, astfel încât 1 < g < p, g**q mod p = 1 și g = h**((p–1)/q) mod p. q se mai
numește și ordinul multiplicativ al lui g modulo p.
Se alege un număr întreg, astfel încât 0 < x < q.
Se calculează y ca g**x mod p.
Se împachetează cheia publică ca {p,q,g,y}.
Se împachetează cheia privată ca {p,q,g,x}.

A doua parte a algoritmului DSA este generarea și verificarea semnăturii, care pot fi descrise astfel:
Pentru a genera o semnătură de mesaj, expeditorul poate urma acești pași:
Se generează rezumatul mesajului h, folosind un algoritm hash precum SHA1.
Se generează un număr aleator k, astfel încât 0 < k < q.
Se calculează r ca (g**k mod p) mod q. Dacă r = 0, selectați un k diferit.
Se calculează i, astfel încât k*i mod q = 1. i se numește inversul multiplicativ modular al lui k modulo q.
Se calculează s = i*(h+r*x) mod q. Dacă s = 0, selectați un k diferit.
Se împachetează semnătura digitală ca {r,s}.

Pentru a verifica semnătura unui mesaj, destinatarul mesajului și semnătura digitală pot urma acești pași:
Se generează rezumatul mesajului h, folosind același algoritm hash.
Se calculează w, astfel încât s*w mod q = 1. w se numește inversul multiplicativ modular al lui s modulo
q.
Se calculează u1 = h*w mod q.
Se calculează u2 = r*w mod q.
Se calculează v = (((g**u1)*(y**u2)) mod p) mod q.
Dacă v == r, semnătura digitală este validă.

Implementarea DSA
from random import randrange
from hashlib import sha1
from gmpy2 import xmpz, to_binary, invert, powmod, is_prime

def generate_p_q(L, N):

g = N # g >= 160
n = (L - 1) // g
b = (L - 1) % g
while True:

while True:
s = xmpz(randrange(1, 2 ** (g)))
a = sha1(to_binary(s)).hexdigest()
zz = xmpz((s + 1) % (2 ** g))
z = sha1(to_binary(zz)).hexdigest()
U = int(a, 16) ^ int(z, 16)
mask = 2 ** (N - 1) + 1
q = U | mask
if is_prime(q, 20):
break

i = 0
j = 2
while i < 4096:
V = []
for k in range(n + 1):
arg = xmpz((s + j + k) % (2 ** g))
zzv = sha1(to_binary(arg)).hexdigest()
V.append(int(zzv, 16))
W = 0
for qq in range(0, n):
W += V[qq] * 2 ** (160 * qq)
W += (V[n] % 2 ** b) * 2 ** (160 * n)
X = W + 2 ** (L - 1)
c = X % (2 * q)
 p = X - c + 1
if p >= 2 ** (L - 1):
if is_prime(p, 10):
return p, q
i += 1
j += n + 1

def generate_g(p, q):

while True:
h = randrange(2, p - 1)
exp = xmpz((p - 1) // q)
g = powmod(h, exp, p)
if g > 1:
break
return g

def generate_keys(g, p, q):

x = randrange(2, q) # x < q
y = powmod(g, x, p)
return x, y

def generate_params(L, N):

p, q = generate_p_q(L, N)
g = generate_g(p, q)
return p, q, g

def sign(M, p, q, g, x):

if not validate_params(p, q, g):
raise Exception("Invalid params")
while True:
k = randrange(2, q)
r = powmod(g, k, p) % q
m = int(sha1(M).hexdigest(), 16)
try:
s = (invert(k, q) * (m + x * r)) % q
return r, s
except ZeroDivisionError:
pass

def verify(M, r, s, p, q, g, y):

if not validate_params(p, q, g):
raise Exception("Invalid params")
if not validate_sign(r, s, q):
return False
try:
w = invert(s, q)
except ZeroDivisionError:
return False
m = int(sha1(M).hexdigest(), 16)
u1 = (m * w) % q
u2 = (r * w) % q
v = (powmod(g, u1, p) * powmod(y, u2, p)) % p % q # v = ((g ** u1 * y ** u2) % p) % q
if v == r:
return True
return False

def validate_params(p, q, g):

if is_prime(p) and is_prime(q):
return True
if powmod(g, q, p) == 1 and g > 1 and (p - 1) % q:
return True
return False

def validate_sign(r, s, q):

if r < 0 and r > q:
return False
if s < 0 and s > q:
return False
return True
if __name__ == "__main__":
N = 160
L = 1024
p, q, g = generate_params(L, N)
x, y = generate_keys(g, p, q)

text = "Finally, this is the end of the semester"

M = str.encode(text, "ascii")
r, s = sign(M, p, q, g, x)
if verify(M, r, s, p, q, g, y):
print('Proceesed')
print(M, r, s, p, q, g, y, x, sep='\n')

Rezultatul programului: