Ministerul Educaie al Republicii Moldova

Universitatea Tehnic a Moldovei

Facultatea Calculatoare Informatic i Microelectronic
Catedra Automatica i Tehnologii Informaionale

S.I.P.C
Lucrare de laborator 7
Tema : Algoritmul pentru semnturi digitale - DSA

a efectuat :
st.gr. TI-071 Chian O.
a verificat : l.s. Potaru A.

Chiinu 2010

Cuprins
Cuprins..................................................................................................................................................3
1 Algoritm pentru semnaturi digitale...................................................................................................4
Generarea cheii.................................................................................................................................4
Semnare............................................................................................................................................4
Verificarea .......................................................................................................................................4
Corectitudine.....................................................................................................................................5
Securitate..........................................................................................................................................5
Implementarea algorimului DSA.........................................................................................................6
Concluzie..............................................................................................................................................8
Bibliografie...........................................................................................................................................9
Anexa A codul surs...........................................................................................................................10

1 Algoritm pentru semnaturi digitale

Algoritmul pentru semnturi digitale (englez: "Digital Signature Algorithm"), cunoscut i sub
acronimul DSA, este un standard al guvernului Statelor Unite ale Americii pentru semnturile digitale. A
fost propus de National Institute of Standards and Technology (NIST) n august 1991 pentru utilizare n
cadrul standardului Digital Signature Standard (DSS), adoptat n 1993. O revizie minor a fost emis n
1996 sub numele de FIPS 186-1 , iar standardul a fost extins n 2000 sub numele FIPS 186-2 .
Algoritmul este format din trei proceduri: generarea cheii, semnarea, verificarea semnturii.

Generarea cheii
1. Se alege q, astfel nct el este prim i are o dimensiune de 160 de bii (2159 < q < 2160).
2. Se alege p, astfel nct el este prim i p = 2qz+1 (2512 < p < 21024).
a. Ultimele reglementri specific faptul c p ar trebui s fie pe fix 1024 de bii, ceea
ce nseamn c z trebuie s fie pe 864 de bii.
3. Se alege

, unde h este o rdcin primitiv n

4.
5. Se alege arbitrar

, unde

6. Se calculeaz

7. Cheia public este

8. Cheia privat este .

Semnare
1. Se alege arbitrar
.
2. Se calculeaz x=SHA-1(mesaj), cu x pe 160 de bii; SHA-1 este funcia de hash, care
realizeaz rezumatul mesajului (returneaz un numr n funcie de coninutul mesajului).
3. Se calculeaz

4. Se calculeaz
.
a. Dac vreuna dintre cele dou valori ( sau ) este egal cu zero, atunci se reia
calculul cu generarea unui alt k.
5. Cheia de semnare este

Verificarea
1. Se calculeaz
2. Se calculeaz

.
.
4

3. Se calculeaz

4. Se calculeaz
5. Semntura este valid dac i numai dac

.
.

Algoritmul Semnturii Digitale este similar Schemei de semntur ElGamal.

Corectitudine
Algoritmul este corect n sensul c destinatarul va accepta ntotdeauna doar semnturi originale.
Acest lucru poate fi demonstrat dup cum urmeaz:
Din

rezult

Deoarece

din Teorema lui Fermat.

i q este prim, are ordinul q.

Expeditorul calculeaz

Deci

Deoarece are ordinul q

n sfrit, corectitudinea algoritmului vine din

Securitate
Acest algoritm este considerat imposibil de spart, datorit siguranei mari asigurate de cteva
puncte, cum ar fi generarea aleatoare a lui p, q, a i k. Pentru a se afla k, de exemplu, ar trebui rezolvat o
problem de tipul logaritmilor discrei, care este o problem "dificil", n sensul c ajungerea la o soluie
poate dura cteva luni.

Implementarea algorimului DSA

Scopul realizrii lucrrii date de laborator este elaborarea unei aplicaii care ar verifica validitatea
mesajelor utiliznd algorimul de semnare DSA. Astfel interfaa aplicaiei va fi constituit din trei seciuni:
generarea cheilor, semanarea mesajului i verificarea mesajului semnat. Astfel utilizatorul pentru nceput
tasteaz butonul Generate Key n urma cruia se vor genera cheia public, privat i parametrii q, p, n.
Avnd la dispoziie aceti parametri putem semna mesajul prin tastarea butonului Sign. Validitatea
mesajului poate fi verificate prin tastarea butonului Validate, n caz c mesajul este validat se va afia un
mesaj de genul: The message is valid n caz contrar The message is invalid. Mai jos este prezentat prototiul
aplicaiei.

Figura 1 Prototipul aplicaiei de semnare a mesajelor.

n baza analizei algorimului DSA am realizat urmtoarele funcii necesare aplicrii algoritmului:
generarea cheilor, semnarea, validarea semnturii. Pentru etapa I am determinat o funcie de verificare a
numrului dac este numr prim conform teoremei lui Fermat-Little care spune c p este un numr prim
dac pentru un oarecare a se realizeaz relaia .Ca rezultat al acestei metode este semntura respectiv.
Cea de-a treia funcie realizeaz validarea semnturii utiliznd datele de la etapa precedent.
reprezentare a celor expuse mai sus poate fi diagrama din figura 2.

TForm1
(f rom C++ Rev erse Engineered)

MessageBoxSignMemo : TMemo *
MessageBoxVerifyMemo : TMemo *
PublicKeyMemo : TMemo *
PrivateKeyMemo : TMemo *
GenKeyBtn : TButton *
qpnParamMemo : TMemo *
SignatureMemo : TMemo *
SendBtn : TButton *
SignBtn : TButton *
ValidateBtn : TButton *
HashSignMemo : TMemo *
HashVerifyMemo : TMemo *

+p_com

<<struct>>
p_parameters
int p
int q
int n

+semn

GenKeyBtnClick()
SignBtnClick()
ValidateBtnClick()
SendBtnClick()
putere()
putere1()
Hash()
TForm1()

<<struct>>
Signature
int r
int s

Figura 2 Diagrama de clas a aplicaiei de semnare i validare a mesajelor

Mai jos este prezentat rularea programului, generarea cheilor, semnarea mesajului i validarea lui.

Figura 3 Rularea aplicaiei de semnare i validare a mesajelor

Concluzie
n urma efecturii lucrrii de laborator am studiat algoritmul de semnare digital a mesajelor DSA. Am studiat cele trei faze prin care trece algoritmul i am realizat aplicaia care implementeaz
algorimul dat. Pot spune c spargerea acestui algorim ar duce la rezolvarea unei probleme de tipul
logaritmilor discrei care este foarte dificil.

Bibliografie
1. Algoritm pentru Semnturi Digitale - http://ro.wikipedia.org/wiki/DSA
2. Jeffrey Walton - Cryptographic Interoperability: Digital Signatures http://www.codeproject.com/KB/security/CryptoInteropSign.aspx

Anexa A codul surs

//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//--------------------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
#define rand 500
#define size 500
int kpub,kpriv;
struct p_parameters{
int p;
int q;
int g;
}p_com;
struct Signature{
int r;
int s;
}semn;
TForm1 *Form1;
//--------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//--------------------------------------------------------------------------#include <stdio.h>
#include <string.h>
//--------------------------------------------------------------------------int TForm1::putere(m,d,n)
{
int toByte[16],i,j,z;
long tabrez[16];
for(i=0;i<16;i++) toByte[i]=0;
i=0;
if(d>=32000) return -1;
while(d!=0){
toByte[i++]=d%2;
d=d/2;
}
j=0;long temp;
for(i=15;i>=0;i--)
if(toByte[i]==1){
temp=m;
for(z=0;z<i;z++){temp=temp*temp;temp=temp%n;}
tabrez[j++]=temp;
}
for(i=j-1;i>=1;i--)
tabrez[i-1]=(tabrez[i]*tabrez[i-1])%n;
return (int)tabrez[0];
}

10

//--------------------------------------------------------------------------bool TForm1::Prim(int num)

{
bool temp;
temp=false;
for (int j=(num/2);j>=2;j--)
if (num%j==0){
temp=true;
break ;
}
if(num==0) temp=true;
return !temp;
}
/***************************Semnatura***************/
void __fastcall TForm1::GenKeyBtnClick(TObject *Sender)
{
int q,z,p,h,g,x,y;
Randomize();
while(!Prim(q=random(size))||(q==0));
do{ a:
z=random(size);
if(z==0) goto a;
p=2*q*z+1;
}while(!Prim(p)||(p>=32000));
//alegem h si determinam g
b:
h=random(p-1);
if(h<=1) goto b;
g=putere(h,z,p);
if(g<=1) goto b;
//alegem x si determinam y
c:
x=random(q);
if(x==0) goto c;
y=putere(g,x,p);
kpub=y;
kpriv=x;
p_com.p=p;
p_com.q=q;
p_com.g=g;
qpnParamMemo->Text="(q,p,g)=(";
qpnParamMemo->Text=qpnParamMemo->Text+p_com.q+",";
qpnParamMemo->Text=qpnParamMemo->Text+p_com.p+",";
qpnParamMemo->Text=qpnParamMemo->Text+p_com.g+")";
PrivateKeyMemo->Text=kpriv;
PublicKeyMemo->Text=kpub;

}
//--------------------------------------------------------------------------int TForm1::putere1(m,d,n){
int i;
if(d==-1){
for(i=1;i<=n;i++)
if((i*m)%n==1) return i;
}
return -1;
}
//--------------------------------------------------------------------------void __fastcall TForm1::SignBtnClick(TObject *Sender)
{
int k,r,s,k1;
int h,c,i;
h=1;
for(i=1;i<=MessageBoxSignMemo->Text.Length();i++)

11

c=MessageBoxSignMemo->Text.operator [](i);
h=Hash(c,h);

}
HashSignMemo->Text=h;
a:
k=random(p_com.q);
if(k==0) goto a;
r=putere(p_com.g,k,p_com.p)%p_com.q;
k1=putere1(k,-1,p_com.q);
if(k1==-1) ShowMessage("In algoritm sunt baguri!");
s=((h+kpriv*r)*k1)%p_com.q;
if((r==0)||(s==0)) goto a;
semn.r=r;
semn.s=s;
SignatureMemo->Text="(r,s)=(";
SignatureMemo->Text=SignatureMemo->Text+semn.r+",";
SignatureMemo->Text=SignatureMemo->Text+semn.s+")";
}
//--------------------------------------------------------------------------void __fastcall TForm1::ValidateBtnClick(TObject *Sender)
{
int w,u1,u2,v;
int h,c,i;
h=1;
for(i=1;i<=MessageBoxVerifyMemo->Text.Length();i++)
{
c=MessageBoxVerifyMemo->Text.operator [](i);
h=Hash(c,h);
}
HashVerifyMemo->Text=h;
w=putere1(semn.s,-1,p_com.q)%p_com.q;
u1=(h*w)%p_com.q;
u2=(w*semn.r)%p_com.q;
v=((putere(p_com.g,u1,p_com.p)*putere(kpub,u2,p_com.p))%p_com.p)%p_com.q;
if(v==semn.r)
{
Label10->Caption="The message is valid";
Label10->Font->Color=clBlue;
}
else
{
Label10->Caption="The message is invalid" ;
Label10->Font->Color=clRed;
}
}
//--------------------------------------------------------------------------int TForm1::Hash(int c,int h)
{
return putere(c,h,30711);
}
void __fastcall TForm1::SendBtnClick(TObject *Sender)
{
int i;
MessageBoxVerifyMemo->Clear();
for(i=1;i<=MessageBoxSignMemo->Text.Length();i++)
MessageBoxVerifyMemo->Text=MessageBoxVerifyMemo->Text+MessageBoxSignMemo>Text.operator [](i);
}
//---------------------------------------------------------------------------

12