DSA (Digital Signature Algorithm) este un algoritm criptografic care asigură autenticitatea, integritatea și ne-repudierea mesajelor prin semnături digitale. Algoritmul se bazează pe teoria numerelor și utilizarea hash-urilor criptografice pentru semnarea și verificarea mesajelor. DSA este standardizat și utilizat pe scară largă în aplicatii de securitate digitală, inclusiv protocoale precum SSL/TLS și în domeniul blockchain.

1. Algoritmul Criptografic
DSA
(Digital Signature Algorithm)

2. Ce este DSA?
•DSA (Digital Signature Algorithm) este un algoritm criptografic
utilizat pentru a crea semnături digitale.
•Asigură autenticitatea, integritatea i ne-repudierea
ș unui mesaj sau
document.
•Folosit pentru a verifica că un mesaj provine de la o sursă autentică i
ș
nu a fost modificat.

3. Scopul DSA
•Autenticitate: Mesajul provine de la o sursă de încredere.
•Integritate: Mesajul nu a fost modificat după semnare.
•Ne-repudiere: Semnatarul nu poate nega semnătura.

4. Cum func ionează DSA?
ț
Se bazează pe teoria numerelor i problema logaritmilor discre i
ș ț ,
care presupune că este extrem de dificil să se găsească exponentul x
într-o ecua ie de forma:
ț
g^x≡y (mod p), unde:
•p este un număr prim mare,
•g este un generator al unui grup ciclic,
•x este cheia privată,
•y este cheia publică.

5. Semnarea digitală
•Se calculează hash-ul mesajului utilizând o func ie de hash
ț
criptografică (ex. SHA-256).
•Se alege un număr aleatoriu secret k.
•Se generează o pereche de valori (r, s), care reprezintă semnătura.

6. Verificarea semnăturii
•Se recalculează hash-ul mesajului primit.
•Se verifică semnătura folosind cheia publică a semnatarului.
•Dacă rezultatul este corect, semnătura este validă i mesajul nu a fost
ș
modificat.

7. Avantajele DSA
1. Securitate ridicată
•Se bazează pe logaritmul discret, o problemă matematică dificil de rezolvat în timp util.
2.Standardizare i conformitate
ș
•Face parte din FIPS 186-4 (Federal Information Processing Standard), fiind adoptat de
guverne i institu ii de securitate.
ș ț
3.Utilizare eficientă a resurselor
•Semnătura digitală este eficientă pentru dispozitive cu resurse limitate (ex. smart cards,
dispozitive IoT).
4.Protec ie împotriva falsificării
ț
•Fiecare semnătură DSA folose te un
ș număr aleatoriu unic k, ceea ce face imposibilă
reutilizarea semnăturii pentru atacuri de tip replay.

8. Limitările DSA
•Securitate mai slabă comparativ cu RSA (Rivest-Shamir-Adleman).
•Dependen ă de k
ț - un număr aleatoriu slab ales poate compromite
semnătura sau reduce eficien a
ț .
•Unele tehnici DSA sunt eficiente doar pentru seturi mici de date.
Pe masura ce volumul de date creste, este posibil sa fie nevoie de
optimizari suplimentare sau de algoritmi complet diferiti.

9. Utilizarea DSA
•Semnătura digitală a mesajelor (e-mailuri, documente electronice).
•Sisteme de autentificare.
•Certificate digitale.
•Autentificarea serverului i
ș asigurarea integrită ii
ț i confiden ialit
ș ț ă ii
ț
datelor transmise între client i server
ș (HTTPS, SSL/TLS).
•În blockchain, DSA poate fi folosit pentru a semna tranzac iile sau
ț
pentru a valida blocurile de tranzac ii
ț . (actual se folose te
ș ECDSA -
Elliptic Curve DSA)

10. Aplica ie
ț
import os
from cryptography.hazmat.primitives.asymmetric import
dsa
from cryptography.hazmat.primitives import hashes,
serialization
# --- Key Management ---
def generate_dsa_keys():
"""Generate or load a DSA key pair."""
if os.path.exists("private_key.pem"):
print("🔑 Private key found. Using existing keys.")
return load_keys()
private_key = dsa.generate_private_key(key_size=2048)
public_key = private_key.public_key()
# Save private key
with open("private_key.pem", "wb") as f:
f.write(private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption()
))
print("✅ New DSA keys generated and saved!")
return private_key, public_key
generate_dsa_keys()
 Dacă există deja o cheie privată (fi ierul
ș
private_key.pem), func ia încarcă acea cheie.
ț
 Dacă nu există cheie privată, func ia generează
ț
o cheie DSA de 2048 de bi i (prin
ț
dsa.generate_private_key()) i derivă
ș cheia
publică din aceasta.
 Cheia privată este salvată în fi ierul
ș
private_key.pem.
 Cheia publică este derivată din cheia privată i
ș
va fi folosită pentru verificarea semnăturii.
 Cheia privată este salvată în format PEM (un
format de fi ier folosit pentru criptografie).
ș
 Cheia publică este derivată automat din cheia
privată.

11. sign_and_store_message()
Această func ie semnează mesajul cu
ț
cheia privată i salvează:
ș
 Cheia publică (pentru a putea verifica
semnătura mai târziu)
 Mesajul semnat (pentru verificare)
 Semnătura (pentru verificare)
Totul este salvat într-un singur fi ier:
ș
signed_data.dat.
# --- Signing & Storing Data ---
def sign_and_store_message(private_key, message):
"""Sign a message and store it along with the signature
and public key in one file."""
signature = private_key.sign(message,
hashes.SHA256())
public_key = private_key.public_key()
# Serialize the public key
public_pem = public_key.public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo
)
# Store everything in one file
with open("signed_data.dat", "wb") as f:
f.write(public_pem + b"n-----MESSAGE-----n" +
message + b"n-----SIGNATURE-----n" + signature)
print("✅ Message, signature, and public key saved to
'signed_data.dat'.")

12. verify_from_file()
Această func ie cite te fi ierul
ț ș ș
signed_data.dat, extrage:
 Cheia publică
 Mesajul semnat
 Semnătura
Apoi, folose te
ș cheia publică
pentru a verifica dacă semnătura
se potrive te cu mesajul.
ș
def verify_from_file():
"""Load and verify a message from 'signed_data.dat'."""
if not os.path.exists("signed_data.dat"):
print("❌ No signed data file found!")
return
with open("signed_data.dat", "rb") as f:
data = f.read()
# Extract components from the stored file
try:
public_key_data, message_signature_data =
data.split(b"n-----MESSAGE-----n", 1)
message_data, signature_data =
message_signature_data.split(b"n-----SIGNATURE-----n", 1)
except ValueError:
print("❌ Invalid file format!")
return
# Load public key
public_key =
serialization.load_pem_public_key(public_key_data)
# Verify signature
try:
public_key.verify(signature_data, message_data,
hashes.SHA256())
print("n✅ Signature is valid! The message has not
been altered.")
print(f"n📩 Stored Message: {message_data.decode()}")
except Exception:
print("n❌ Signature verification failed!")

13. La rularea scriptului, utilizatorul
are două op iuni:
ț
1. Semnează i stochează un
ș
mesaj
2. Verifică semnătura unui
mesaj
În func ie de alegere, scriptul va
ț
solicita un mesaj de semnat sau va
verifica un mesaj deja semnat.
if __name__ == "__main__":
private_key, public_key = generate_dsa_keys()
print("nChoose an option:")
print("1 ️
1️⃣Sign and store a message")
print("2️⃣Verify message from file")
choice = input("nEnter your choice (1/2): ")
if choice == "1":
user_message = input("nEnter a message to
sign: ").encode('utf-8')
sign_and_store_message(private_key,
user_message)
elif choice == "2":
verify_from_file()
else:
print("❌ Invalid choice! Please enter 1 or 2.")

14. Concluzie
•DSA este un algoritm sigur i standardizat pentru semnături digitale.
ș
•Garantează autenticitatea, integritatea i ne-repudierea
ș mesajelor.
•Utilizat în protocoale precum SSL/TLS, PGP i aplica ii de
ș ț
securitate digitală.