Pour plus de précisions sur les conventions concernant la paire de clés privée et publique ((D, N), (E, N)), merci de se référer à la fiche Public-Key Infrastructure (PKI).
Constante
/*******/
CO_DifferencePQ=2;
Type ClePki Defaut
/****************/
VersionCle : Entier;
Fin Type
NbBits : Entier;
N : Nul Ou Decimal;
E : Nul Ou Decimal;
Selon Forme : Entier Faire
Cas Forme1 Pour 1 Faire
Fin Selon
D : Nul Ou Decimal;
Fin Cas
Cas Forme2 Pour 2 Faire
P : Nul Ou Decimal;
Fin Cas
Q : Nul Ou Decimal;
DP : Nul Ou Decimal;
DQ : Nul Ou Decimal;
QInv : Nul Ou Decimal;
Constructeur();
/******************************************************************/
Fonction GenererClePkiRsa(VersionCle : Entier, NbBits : Entier, MessageErreur : Caractere Sortie) Retourner Nul Ou ClePki
/* Objet : Genere une cle de Pki pour Rsa. */
/******************************************************************/
Variable
/******/
Cle : Nul Ou ClePki;
TailleP : Entier;
P : Nul Ou Decimal;
TailleQ : Entier;
Q : Nul Ou Decimal;
U : Nul Ou Decimal;
Phi : Nul Ou Decimal;
Increment : Entier;
Debut
Cle=ClePki();
Cle.VersionCle=VersionCle;
Cle.NbBits=NbBits;
Cle.Forme=1;
/* Calcul des tailles de P et Q. */
TailleP=(NbBits/2)-(CO_DifferencePQ/2);
TailleQ=NbBits-TailleP;
/* Tire aleatoirement P et Q. */
TantQue Vrai Faire
/* Tire aleatoirement P tel que P-1 a un grand facteur premier. P=2*U+1. */
U=Aleatoire(TailleP,Vrai);
P=2*U+1;
TantQue Vrai Faire
Si EstPremier(P) Alors
Arreter;
Fin Si
P+=2*U;
Fin TanQue
/* Tire aleatoirement Q tel que Q-1 a un grand facteur premier. Q=2*U+1. */
U=Aleatoire(TailleQ,Vrai);
Q=2*U+1;
TantQue Vrai Faire
Si EstPremier(Q) Alors
Arreter;
Fin Si
Q+=2*U;
Fin TanQue
/* Calcul de Pgcd(P-1,Q-1). */
Si Pgcd(P-1,Q-1)==Decimal(1) Alors
/* P-1 et Q-1 sont premiers entre eux. */
Arreter;
Fin Si
Fin TantQue
Cle.N=P*Q;
TantQue Vrai Faire
/* Calcule D > Max(P,Q) qui doit etre premier. */
Cle.Forme.Forme1.D=Max(P,Q);
TantQue Vrai Faire
Increment=Aleatoire()&0xFF;
Si Increment&0x1 Faire
Increment++;
Fin Si
Cle.Forme.Forme1.D+=Increment;
Si EstPremier(Cle.Forme.Forme1.D) Alors
Arreter;
Fin Si
Fin TanQue
/* Calcule E. */
Selon VersionCle Faire
Cas Pour 1 Faire
Phi=(P-1)*(Q-1);
Fin Cas
Cas Pour 2 Faire
Phi=Ppcm((P-1)*(Q-1));
Fin Cas
Fin Selon
/* E est tel que Pgcd(Phi,D)=E*Phi+F*D. */
/* Comme Phi<=Ppcm(P-1,Q-1) et que D est premier, Pgcd(Phi,D)==1. */
?=Pgcd(Phi,Cle.Forme.Forme1.D,Cle.E,?);
/* E doit etre superieur a Log2(N) donc superieur a 2*Log(N). */
Si Cle.E>=2*Log(Cle.N) Alors
Arreter;
Fin Si
Fin TantQue
Retourner Cle;
Fin Fonction
NbBits/8 octets.
/****************************************************************/
Procedure CrypterRsaEp(Cle : Nul Ou ClePki, BufferEntree : Binaire, BufferSortie : Binaire Sortie)
/* Objet : Crypte un binaire en Rsa - RSAEP. */
/****************************************************************/
Variable
/******/
M : Nul Ou Decimal;
C : Nul Ou Decimal;
Debut
/* Equivalent de OS2IP. */
M=Decimal(BufferEntree);
/* Calcul de C=M^E % N. */
C=ExponentiationModulaire(M,Cle.E,Cle.N);
/* Equivalent de I2OSP. */
BufferSortie=C.VersBinaire();
Fin Procedure
NbBits/8 octets.
/****************************************************************/
Procedure DecrypterRsaDp(Cle : Nul Ou ClePki, BufferEntree : Binaire, BufferSortie : Binaire Sortie)
/* Objet : Decrypte un binaire en Rsa - RSADP. */
/****************************************************************/
Variable
/******/
M : Nul Ou Decimal;
M1 : Nul Ou Decimal;
M2 : Nul Ou Decimal;
H : Nul Ou Decimal;
C : Nul Ou Decimal;
Debut
/* Equivalent de OS2IP. */
C=Decimal(BufferEntree);
Selon Cle.Forme Faire
Cas Pour 1 Faire
Fin Selon
M=ExponentiationModulaire(C,Cle.Forme.Forme1.D,Cle.N);
Fin Cas
Cas Pour 2 Faire
M1=ExponentiationModulaire(C,Cle.Forme.Forme2.DP,Cle.P);
Fin Cas
M2=ExponentiationModulaire(C,Cle.Forme.Forme2.DQ,Cle.Q);
H=((M1-M2)*QInv)%P;
M=M2+Q*H;
/* Equivalent de I2OSP. */
BufferSortie=M.VersBinaire();
Fin Procedure
NbBits/8 octets.
/****************************************************************/
Procedure SignerRsaSp1(Cle : Nul Ou ClePki, BufferEntree : Binaire, BufferSignature : Binaire Sortie)
/* Objet : Signe un binaire en Rsa - RSSP1. */
/****************************************************************/
Debut
DecrypterRsaDp(Cle,BufferEntree,BufferSignature);
Fin Procedure
NbBits/8 octets.
/****************************************************************/
Fonction VerifierSignatureRsaVp1(Cle : Nul Ou ClePki, BufferEntree : Binaire, BufferSignature : Binaire) Retourner Booleen
/* Objet : Verifie la signature d'un binaire en Rsa - RSVP1. */
/****************************************************************/
Variable
/******/
BufferSignature2 : Nul Ou Binaire;
Debut
CrypterRsaEp(Cle,BufferEntree,BufferSignature2);
Retourner BufferSignature==BufferSignature2;
Fin Fonction
/****************************************************************/
Procedure GenererMasqueMgf1(Graine : Binaire, SousJacent : ModeSignatureFlux, Masque : Binaire Sortie)
/* Objet : Genere un masque en Rsa - MGF1. */
/****************************************************************/
Variable
/******/
TailleSignature : Entier;
I : Entier;
IMax : Entier;
C : Binaire;
Signature : Binaire;
TF : Tableau[2] De Nul Ou IFlux;
F : Nul Ou FluxConcatene;
Debut
/* Calcul de la taille de la signature. */
TailleSignature=CalculerTailleSignature(SousJacent);
/* Ouverture du flux concatene Graine||C. */
TF[0]=IFlux(FluxBinaire(Graine,Vrai));
C=Binaire(0x00,4);
TF[1]=IFlux(FluxBinaire(C,Vrai));
F=FluxConcatene(TF);
/* Calcul de la taille du masque. */
Si TailleMasque%TailleSignature Alors
IMax=(TypUpsMmrLong)((TailleMasque/TailleSignature)+1);
Sinon
IMax=(TypUpsMmrLong)(TailleMasque/TailleSignature);
Masque=Binaire();
Pour I=0 JusquA IMax-1 Faire
/* Calcul de T=H(Graine||C). */
Si I>0 Alors
/* Reinitialise la lecture du flux concatene. */
F.FixerPosition(0);
Fin Si
Signer(SousJacent,IFlux(F),Signature);
/* Calcul T=T||H(Graine||C). */
Masque+=Signature;
/* Passage au suivant. */
Si C[3]==255 Alors
C[3]=0;
Si C[2]==255 Alors
C[2]=0;
Si C[1]==255 Alors
C[1]=0;
C[0]++;
Sinon
C[1]++;
Fin Si
Sinon
C[2]++;
Fin Si
Sinon
C[3]++;
Fin Si
Fin Pour
Fin Procedure
NbBits/8-2*(TailleSignature+1) où TailleSignature est la taille de la signature de l'algorithme sous-jacent.
/****************************************************************/
Procedure CrypterRsaOaep(Cle : Nul Ou ClePki, L : Binaire, SousJacent : ModeSignatureFlux, BufferEntree : Binaire, BufferSortie : Binaire Sortie)
/* Objet : Crypte un binaire en Rsa - RSAES-OAEP-ENCRYPT. */
/****************************************************************/
Variable
/******/
TailleSignature : Entier;
K : Entier;
DB : Binaire;
DBMasque : Binaire;
Graine : Binaire;
GraineMasque : Binaire;
EM : Binaire;
TailleDB : Entier;
TailleDBMasque : Entier;
TaillePS : Entier;
I : Entier;
Debut
K=Cle.NbBits/8;
/* Calcule la signature H(L). */
Signer(SousJacent,L,DB);
TailleSignature=DB.Longueur();
/* Calcule DB=H(L)||PS||0x1||M. */
TaillePS=K-BufferEntree.Longueur()-2*(TailleDB+1);
DB+=Binaire(0x00,TaillePS)+Binaire(0x01,1)+BufferEntree;
TailleDB=DB.Longueur();
/* Genere le contenu Graine de taille TailleSignature. */
Graine=Binaire(0x00,TailleSignature);
Pour I=0 JusquA TailleSignature-1 Faire
Graine[I]=Octet(Aleatoire());
Fin Pour
/* Genere le masque DBMasque. */
TailleDBMasque=K-TailleSignature-1;
GenererMasqueMgf1(Graine,SousJacent,DBMasque);
/* Calcul de DB^=DBMasque. */
Pour I=0 JusquA TailleDBMasque-1 Faire
DB[I]^=DBMasque[I];
Fin Pour
/* Genere le masque GraineMasque. */
GenererMasqueMgf1(DB,SousJacent,GraineMasque);
/* Calcul de Graine^=GraineMasque. */
Pour I=0 JusquA TailleSignature-1 Faire
BufferGraine[I]^=BufferGraineMasque[I];
Fin Pour
/* Calcul de EM=0x00||Graine^GraineMasque||DB^DBMasque. */
EM=Binaire(0x00,1)+Graine+DB;
/* Calcul C=RSAEP(Cle,EM). */
CrypterRsa(Cle,EM,BufferSortie);
Fin Procedure
NbBits/8-2*(TailleSignature+1) où TailleSignature est la taille de la signature de l'algorithme sous-jacent.
/****************************************************************/
Procedure DecrypterRsaOaep(Cle : Nul Ou ClePki, L : Binaire, SousJacent : ModeSignatureFlux, BufferEntree : Binaire, BufferSortie : Binaire Sortie)
/* Objet : Decrypte un binaire en Rsa - RSAES-OAEP-DECRYPT. */
/****************************************************************/
Variable
/******/
TailleSignature : Entier;
K : Entier;
DB : Binaire;
DBMasque : Binaire;
Graine : Binaire;
GraineMasque : Binaire;
EM : Binaire;
TailleDB : Entier;
TailleDBMasque : Entier;
TailleM : Entier;
I : Entier;
Debut
K=Cle.NbBits/8;
/* Calcule la signature H(L). */
Signer(SousJacent,L,DB);
TailleSignature=DB.Longueur();
/* Calcul EM=RSADP(Cle,C). */
DecrypterRsa(Cle,BufferEntree,EM);
/* Separation de EM=0x00||Graine^GraineMasque||DB^DBMasque. */
TailleDBMasque=K-TailleSignature-1;
Graine=EM.Milieu(1,TailleSignature);
DB=EM.Milieu(1+TailleSignature,TailleDBMasque);
/* Genere le masque GraineMasque. */
GenererMasqueMgf1(DB,SousJacent,GraineMasque);
/* Calcul de Graine^=GraineMasque. */
Pour I=0 JusquA TailleSignature-1 Faire
BufferGraine[I]^=BufferGraineMasque[I];
Fin Pour
/* Genere le masque DBMasque. */
TailleBufferDBMasque=K-TailleSignature-1;
GenererMasqueMgf1(Graine,SousJacent,DBMasque);
/* Calcul de DB^=DBMasque. */
Pour I=0 JusquA TailleDBMasque-1 Faire
DB[I]^=DBMasque[I];
Fin Pour
/* Separation de DB=H(L)||PS||0x1||M. */
Pour TailleDB=TailleSignature JusquA TailleDBMasque-1 Faire
Si DB[TailleDB]!=0x00 Alors
Fin Pour
Arreter;
Fin Si
TailleDB++;
TailleM=TailleDBMasque-TailleDB);
BufferSortie=BufferDB.Milieu(TailleDB,TailleM);
Fin Procedure
NbBits/8-11.
/****************************************************************/
Procedure CrypterRsaPkcs1V1_5(Cle : Nul Ou ClePki, L : Binaire, SousJacent : ModeSignatureFlux, BufferEntree : Binaire, BufferSortie : Binaire Sortie)
/* Objet : Crypte un binaire en Rsa - RSAES-PKCS1-v1_5-ENCRYPT. */
/****************************************************************/
Variable
/******/
K : Entier;
EM : Binaire;
TailleEM : Entier;
TaillePS : Entier;
I : Entier;
Debut
K=Cle.NbBits/8;
/* Calcul de EM=0x00||0x02||PS||0x00||Message. */
TaillePS=K-BufferEntree.Longueur()-3;
EM=Binaire(0x00,1)+Binaire(0x02,1)+Binaire(0x00,TaillePS);
Pour I=0 JusquA TaillePS-1 Faire
TantQue Vrai Faire
Fin Pour
EM[I+2]=Octet(Aleatoire());
Fin TantQue
Si EM[I+2]!=0 Alors
Arreter;
Fin Si
EM+=Binaire(0x00,1)+BufferEntree;
/* Calcul C=RSAEP(Cle,EM). */
CrypterRsa(Cle,EM,BufferSortie);
Fin Procedure
NbBits/8-11.
/****************************************************************/
Procedure DecrypterRsaPkcs1V1_5(Cle : Nul Ou ClePki, L : Binaire, SousJacent : ModeSignatureFlux, BufferEntree : Binaire, BufferSortie : Binaire Sortie)
/* Objet : Decrypte un binaire en Rsa - RSAES-PKCS1-v1_5-ENCRYPT. */
/****************************************************************/
Variable
/******/
K : Entier;
EM : Binaire;
PS : Binaire;
TailleEM : Entier;
TaillePS : Entier;
TailleM : Entier;
I : Entier;
Debut
K=Cle.NbBits/8;
/* Calcul EM=RSADP(Cle,C). */
DecrypterRsa(Cle,BufferEntree,EM);
/* Separation de EM=0x00||0x02||PS||0x00||Message. */
Pour TaillePS=0 JusquA EM.LOngueur()-1 Faire
Si EM[2+TaillePS]!=0x00 Alors
Fin Pour
Arreter;
Fin Si
TailleM=TailleEM-(TaillePS+2);
BufferSortie=EM.Milieu(2+TaillePS+1,TailleM);
Fin Procedure
NbBits/8 octets.
/****************************************************************/
Procedure SignerRsaEmsaPss(SousJacent : ModeSignatureFlux, TailleSalt : Entier, NbBits : Entier, BufferEntree : Binaire, TailleSignature : Entier, BufferSignature : Binaire Sortie)
/* Objet : Signe un binaire en Rsa - EMSA-PSS-ENCODE. */
/****************************************************************/
Variable
/******/
Signature : Binaire;
M2 : Binaire;
Salt : Binaire;
DB : Binaire;
MasqueDB : Binaire;
TailleSignature2 : Entier;
TailleDB : Entier;
TaillePS : Entier;
NbBits2 : Entier;
I : Entier;
J : Entier;
K : Entier;
Debut
/* Calcule la signature de M. */
Signer(SousJacent,BufferEntree,Signature);
/* Calcule 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00||H(M)||Salt. */
Salt=Binaire(0x00,8);
Pour I=0 JusquA TailleSalt-1 Faire
Salt[I]=Octet(Aleatoire());
Fin Pour
M2=Binaire(0x00,8)+Signature+Salt;
/* Calcule la signature de M2. */
Signer(SousJacent,M2,Signature);
/* Calcule DB=PS||0x01||Salt. */
TaillePS=TailleSignature-TailleSalt-Signature.Longueur()-2;
DB=Binaire(0x00,TaillePS)+Binaire(0x01,1)+Salt;
/* Calcule MasqueDB=MGF(H,TailleBufferDB). */
GenererMasqueMgf1(Signature,SousJacent,MasqueDB);
/* Calcule DB^=MasqueDB. */
Pour I=0 JusquA DB.Longueur()-1 Faire
DB[I]^=MasqueDB[I];
Fin Pour
/* Blanchit les premiers bits. */
NbBits2=8*TailleSignature-NbBits;
I=NbBits2/8;
J=NbBits2%8;
Pour K=0 JusquA I-1 Faire
DB[K]=0;
Fin Pour
Selon J Faire
Cas Pour 1 Faire
Fin Selon
DB[I]&=0x80;
Fin Cas
Cas Pour 2 Faire
DB[I]&=0xC0;
Fin Cas
Cas Pour 3 Faire
DB[I]&=0xE0;
Fin Cas
Cas Pour 4 Faire
DB[I]&=0xF0;
Fin Cas
Cas Pour 5 Faire
DB[I]&=0xF8;
Fin Cas
Cas Pour 6 Faire
DB[I]&=0xFC;
Fin Cas
Cas Pour 7 Faire
DB[I]&=0xFE;
Fin Cas
/* Calcule EM=MasqueDB||H||0xBC. */
BufferSignature=DB+Signature+Binaire(0xBC,1);
Fin Procedure
NbBits/8 octets.
/****************************************************************/
Fonction VerifierSignatureRsaEmsaPss(SousJacent : ModeSignatureFlux, TailleSalt : Entier, NbBits : Entier, BufferEntree : Binaire, BufferSignature : Binaire) Retourner Booleen
/* Objet : Verifie la signature d'un binaire en Rsa - EMSA-PSS-VERIFY. */
/****************************************************************/
Variable
/******/
Signature : Binaire;
Signature2 : Binaire;
M2 : Binaire;
Salt : Binaire;
DB : Binaire;
MasqueDB : Binaire;
TailleSignature : Entier;
TailleSignature2 : Entier;
TailleDB : Entier;
NbBits2 : Entier;
I : Entier;
J : Entier;
K : Entier;
Debut
TailleSignature=BufferSignature.Longueur();
/* Calcule la signature de M. */
Signer(SousJacent,BufferEntree,Signature);
/* Separation de EM=MasqueDB||H||0xBC. */
TailleSignature2=Signature.Longueur();
TailleDB=BufferSignature.Longueur()-TailleSignature2-1;
DB=BufferSignature.Gauche(TailleDB);
Signature=BufferSignature.Milieu(TailleSignature2,TailleDB,TailleSignature2);
/* Calcule MasqueDB=MGF(H,TailleBufferDB). */
GenererMasqueMgf1(Signature,SousJacent,MasqueDB);
/* Calcule DB^=MasqueDB. */
Pour I=0 JusquA TailleDB-1 Faire
DB[I]^=MasqueDB[I];
Fin Pour
/* Blanchit les premiers bits. */
I=NbBits/8;
J=NbBits%8;
Pour K=0 JusquA I-1 Faire
DB[K]=0;
Fin Pour
Selon J Faire
Cas Pour 1 Faire
Fin Selon
DB[I]&=0x80;
Fin Cas
Cas Pour 2 Faire
DB[I]&=0xC0;
Fin Cas
Cas Pour 3 Faire
DB[I]&=0xE0;
Fin Cas
Cas Pour 4 Faire
DB[I]&=0xF0;
Fin Cas
Cas Pour 5 Faire
DB[I]&=0xF8;
Fin Cas
Cas Pour 6 Faire
DB[I]&=0xFC;
Fin Cas
Cas Pour 7 Faire
DB[I]&=0xFE;
Fin Cas
/* Calcule M2=0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00||H(M)||Salt. */
M2=Binaire(0x00,8)+BufferSignature+DB.Droite(TailleSalt);
/* Calcule la signature de M2. */
Signer(SousJacent,M2,Signature2);
/* Verifie que H(M)==H(M2). */
Retourner Signature==Signature2;
Fin Fonction
NbBits/8 octets.
/****************************************************************/
Procedure SignerRsaEmsaPkcs1V1_5(SousJacent : ModeSignatureFlux, BufferEntree : Binaire, TailleSignature : Entier, BufferSignature : Binaire Sortie)
/* Objet : Signe un binaire en Rsa - EMSA-PKCS1-V1_5-ENCODE. */
/****************************************************************/
Variable
/******/
Signature : Binaire;
T : Binaire;
PS : Binaire;
TailleSignature : Entier;
TailleT : Entier;
TaillePS : Entier;
I : Entier;
Debut
/* Calcule la signature de M. */
CalculerSignature(BufferEntree,SousJacent,Signature);
TailleSignature=Signature.Longueur();
Selon SousJacent Faire
Cas Pour ModeSignatureMd2 Faire
Fin Selon
T={0x30,0x20,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x02,0x05,0x00,0x04,0x10};
Fin Cas
Cas Pour ModeSignatureMd5 Faire
T={0x30,0x20,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x04,0x10};
Fin Cas
Cas Pour ModeSignatureSha1 Faire
T={0x30,0x21,0x30,0x09,0x06,0x05,0x2b,0x0e,0x03,0x02,0x1a,0x05,0x00,0x04;0x14};
Fin Cas
Cas Pour ModeSignatureSha256 Faire
T={0x30,0x31,0x30,0x0d,0x06,0x09,0x60,0x86,0x48,0x01,0x65,0x03,0x04,0x02,0x01,0x05,0x00,0x04,0x20};
Fin Cas
Cas Pour ModeSignatureSha384 Faire
T={0x30,0x41,0x30,0x0d,0x06,0x09,0x60,0x86,0x48,0x01,0x65,0x03,0x04,0x02,0x02,0x05,0x00,0x04,0x30};
Fin Cas
Cas Pour ModeSignatureSha512 Faire
T={0x30,0x51,0x30,0x0d,0x06,0x09,0x60,0x86,0x48,0x01,0x65,0x03,0x04,0x02,0x03,0x05,0x00,0x04,0x40};
Fin Cas
/* Calcule EM=0x00 0x01||PS||0x00||T. */
BufferSignature=Binaire(0x00,1)+Binaire(0x01,1)+Binaire(0xFF,TailleSignature-T.Longueur()-1)+T;
Fin Procedure
NbBits/8 octets.
/****************************************************************/
Fonction VerifierSignatureRsaEmsaPkcs1V1_5(SousJacent : ModeSignatureFlux, BufferEntree : Binaire, BufferSignature : Binaire) Retourner Booleen
/* Objet : Verifie la signature d'un binaire en Rsa - EMSA-PKCS1-V1_5-VERIFY. */
/****************************************************************/
Variable
/******/
BufferSignature2 : Binaire;
Debut
/* Signe le message. */
SignerRsaEmsaPkcs1V1_5(SousJacent,BufferEntree,BufferSignature.Longueur(),BufferSignature2);
/* Verifie que S(M)==S(M2). */
Retourner BufferSignature==BufferSignature2;
Fin Fonction
NbBits/8 octets.
/****************************************************************/
Procedure SignerRsaSsaPss(Cle : Nul Ou ClePki, SousJacent : ModeSignatureFlux, BufferEntree : Binaire, BufferSignature : Binaire Sortie)
/* Objet : Signe un binaire en Rsa - RSASSA-PSS-SIGN. */
/****************************************************************/
Variable
/******/
TailleBuffer : Entier;
Buffer : Binaire;
Debut
/* Calcul la taille du buffer intermediaire. */
Si (Cle.NbBits-1)%8!=0 Alors
TailleBuffer=(Cle.NbBits-1)/8+1;
Sinon
TailleBuffer=(Cle.NbBits-1)/8;
Fin Si
/* Appel de EMSA-PSS-ENCODE. */
SignerRsaEmsaPss(SousJacent,0,Cle.NbBits-1,BufferEntree,TailleBuffer,Buffer);
/* Appel de RSASP1. */
SignerRsaSp1(Cle,Buffer,BufferSignature);
Fin Procedure
NbBits/8 octets.
/****************************************************************/
Fonction VerifierSignatureRsaSsaPss(Cle : Nul Ou ClePki, SousJacent : ModeSignatureFlux, BufferEntree : Binaire, BufferSignature : Binaire) Retourner Booleen
/* Objet : Verifie la signature d'un binaire en Rsa - RSASSA-PSS-VERIFY. */
/****************************************************************/
Variable
/******/
K : Entier;
TailleBuffer : Entier;
Buffer : Binaire;
Debut
K=Cle.NbBits/8;
/* Calcul la taille du buffer intermediaire. */
Si (Cle.NbBits-1)%8!=0 Alors
TailleBuffer=(Cle.NbBits-1)/8+1;
Sinon
TailleBuffer=(Cle.NbBits-1)/8;
Fin Si
/* Appel de RSAVP1. */
Si Non VerifierSignatureRsaVp1(Session,Signature,Buffer) Alors
Retourner Faux;
Fin Si
/* Appel de EMSA-PSS-VERIFY. */
Si Buffer.Longueur!=TailleBuffer Alors
Retourner Faux;
Fin Si
Retourner VerifierSignatureRsaEmsaPss(SousJacent,0,Cle.NbBits-1,BufferEntree,Buffer);
Fin Fonction
NbBits/8 octets.
/****************************************************************/
Procedure SignerRsaSsaPkcs11V1_5(Cle : Nul Ou ClePki, SousJacent : ModeSignatureFlux, BufferEntree : Binaire, BufferSignature : Binaire Sortie)
/* Objet : Signe un binaire en Rsa - RSASSA-PKCS1-V1_5-SIGN. */
/****************************************************************/
Variable
/******/
TailleBuffer : Entier;
Buffer : Binaire;
Debut
/* Calcul la taille du buffer intermediaire. */
TailleBuffer=Cle.NbBits/8;
/* Appel de EMSA-PKCS1-V1_5-ENCODE. */
SignerRsaEmsaPkcs1V15(SousJacent,BufferEntree,TailleBuffer,Buffer);
/* Appel de RSASP1. */
SignerRsaSp1(Cle,Buffer,BufferSignature);
Fin Procedure
NbBits/8 octets.
/****************************************************************/
Fonction VerifierSignatureRsaSsaPkcs11V1_5(Cle : Nul Ou ClePki, SousJacent : ModeSignatureFlux, BufferEntree : Binaire, BufferSignature : Binaire) Retourner Booleen
/* Objet : Verifie la signature d'un binaire en Rsa - RSASSA-PKCS1-V1_5-VERIFY. */
/****************************************************************/
Variable
/******/
K : Entier;
TailleBuffer : Entier;
Buffer : Binaire;
Debut
K=Cle.NbBits/8;
/* Calcul la taille du buffer intermediaire. */
TailleBuffer=Cle.NbBits/8;
/* Appel de RSAVP1. */
Si Non VerifierSignatureRsaVp1(Session,Signature,Buffer) Alors
Retourner Faux;
Fin Si
/* Appel de EMSA-PSS-VERIFY. */
Si Buffer.Longueur()!=TailleBuffer Alors
Retourner Faux;
Fin Si
Retourner VerifierSignatureRsaEmsaPkcs1V15(SousJacent,BufferEntree,Buffer);
Fin Fonction
Les certificats sont conservés dans des fichiers, dans une base de donnees ou dans un annuaire selon l'application.
La norme utilisée utilisée est Abstract Syntax Notation One (ASN.1) de l'International Telecommunication Union (ITU) compilée en Basic Encoding Rules (BER).
PKCS-1 { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-1(1) modules(0) pkcs-1(1) }
-- $ Revision: 2.1r1 $
-- This module has been checked for conformance with the ASN.1
-- standard by the OSS ASN.1 Tools
DEFINITIONS EXPLICIT TAGS ::=
BEGIN
-- EXPORTS ALL
-- All types and values defined in this module are exported for use
-- in other ASN.1 modules.
IMPORTS
id-sha256, id-sha384, id-sha512 FROM NIST-SHA
{ joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) nistalgorithm(4) modules(0) sha2(1) };
-- ============================
-- Basic object identifiers
-- ============================
-- The DER encoding of this in hexadecimal is:
-- (0x)06 08
-- 2A 86 48 86 F7 0D 01 01
--
pkcs-1 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) 1 }
--
-- When rsaEncryption is used in an AlgorithmIdentifier the
-- parameters MUST be present and MUST be NULL.
--
rsaEncryption OBJECT IDENTIFIER ::= { pkcs-1 1 }
--
-- When id-RSAES-OAEP is used in an AlgorithmIdentifier the
-- parameters MUST be present and MUST be RSAES-OAEP-params.
--
id-RSAES-OAEP OBJECT IDENTIFIER ::= { pkcs-1 7 }
--
-- When id-pSpecified is used in an AlgorithmIdentifier the
-- parameters MUST be an OCTET STRING.
--
id-pSpecified OBJECT IDENTIFIER ::= { pkcs-1 9 }
-- When id-RSASSA-PSS is used in an AlgorithmIdentifier the
-- parameters MUST be present and MUST be RSASSA-PSS-params.
--
id-RSASSA-PSS OBJECT IDENTIFIER ::= { pkcs-1 10 }
--
-- When the following OIDs are used in an AlgorithmIdentifier the
-- parameters MUST be present and MUST be NULL.
--
md2WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 2 }
md5WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 4 }
sha1WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 5 }
sha256WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 11 }
sha384WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 12 }
sha512WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 13 }
--
-- This OID really belongs in a module with the secsig OIDs.
--
id-sha1 OBJECT IDENTIFIER ::= { iso(1) identified-organization(3) oiw(14) secsig(3) algorithms(2) 26 }
--
-- OIDs for MD2 and MD5, allowed only in EMSA-PKCS1-v1_5.
--
id-md2 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) digestAlgorithm(2) 2 }
id-md5 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) digestAlgorithm(2) 5 }
--
-- When id-mgf1 is used in an AlgorithmIdentifier the parameters MUST
-- be present and MUST be a HashAlgorithm, for example sha1.
--
id-mgf1 OBJECT IDENTIFIER ::= { pkcs-1 8 }
-- ================
-- Useful types
-- ================
ALGORITHM-IDENTIFIER ::= CLASS
{
WITH SYNTAX { OID &id [PARAMETERS &Type] }
&id OBJECT IDENTIFIER UNIQUE,
&Type OPTIONAL
}
--
-- Note: the parameter InfoObjectSet in the following definitions
-- allows a distinct information object set to be specified for sets
-- of algorithms such as:
-- DigestAlgorithms ALGORITHM-IDENTIFIER ::= {
-- { OID id-md2 PARAMETERS NULL }|
-- { OID id-md5 PARAMETERS NULL }|
-- { OID id-sha1 PARAMETERS NULL }
-- }
--
AlgorithmIdentifier { ALGORITHM-IDENTIFIER:InfoObjectSet } ::= SEQUENCE
{
algorithm ALGORITHM-IDENTIFIER.&id({InfoObjectSet}),
parameters ALGORITHM-IDENTIFIER.&Type({InfoObjectSet}{@.algorithm}) OPTIONAL
}
-- ==============
-- Algorithms
-- ==============
--
-- Allowed EME-OAEP and EMSA-PSS digest algorithms.
--
OAEP-PSSDigestAlgorithms ALGORITHM-IDENTIFIER ::=
{
{ OID id-sha1 PARAMETERS NULL }
| { OID id-sha256 PARAMETERS NULL }
| { OID id-sha384 PARAMETERS NULL }
| { OID id-sha512 PARAMETERS NULL },
... -- Allows for future expansion --
}
--
-- Allowed EMSA-PKCS1-v1_5 digest algorithms.
--
PKCS1-v1-5DigestAlgorithms ALGORITHM-IDENTIFIER ::=
{
{ OID id-md2 PARAMETERS NULL }
| { OID id-md5 PARAMETERS NULL }
| { OID id-sha1 PARAMETERS NULL }
| { OID id-sha256 PARAMETERS NULL }
| { OID id-sha384 PARAMETERS NULL }
| { OID id-sha512 PARAMETERS NULL }
}
-- When id-md2 and id-md5 are used in an AlgorithmIdentifier the
-- parameters MUST be present and MUST be NULL.
-- When id-sha1, id-sha256, id-sha384 and id-sha512 are used in an
-- AlgorithmIdentifier the parameters (which are optional) SHOULD
-- be omitted. However, an implementation MUST also accept
-- AlgorithmIdentifier values where the parameters are NULL.
sha1 HashAlgorithm ::=
{
algorithm id-sha1,
parameters SHA1Parameters : NULL
-- included for compatibility
-- with existing implementations
}
HashAlgorithm ::= AlgorithmIdentifier { {OAEP-PSSDigestAlgorithms} }
SHA1Parameters ::= NULL
--
-- Allowed mask generation function algorithms.
-- If the identifier is id-mgf1, the parameters are a HashAlgorithm.
--
PKCS1MGFAlgorithms ALGORITHM-IDENTIFIER ::=
{
{ OID id-mgf1 PARAMETERS HashAlgorithm },
... -- Allows for future expansion --
}
--
-- Default AlgorithmIdentifier for id-RSAES-OAEP.maskGenAlgorithm and
-- id-RSASSA-PSS.maskGenAlgorithm.
--
mgf1SHA1 MaskGenAlgorithm ::=
{
algorithm id-mgf1,
parameters HashAlgorithm : sha1
}
MaskGenAlgorithm ::= AlgorithmIdentifier { {PKCS1MGFAlgorithms} }
--
-- Allowed algorithms for pSourceAlgorithm.
--
PKCS1PSourceAlgorithms ALGORITHM-IDENTIFIER ::=
{
{ OID id-pSpecified PARAMETERS EncodingParameters },
... -- Allows for future expansion --
}
EncodingParameters ::= OCTET STRING(SIZE(0..MAX))
--
-- This identifier means that the label L is an empty string, so the
-- digest of the empty string appears in the RSA block before
-- masking.
--
pSpecifiedEmpty PSourceAlgorithm ::=
{
algorithm id-pSpecified,
parameters EncodingParameters : emptyString
}
PSourceAlgorithm ::= AlgorithmIdentifier { {PKCS1PSourceAlgorithms} }
emptyString EncodingParameters ::= ''H
--
-- Type identifier definitions for the PKCS #1 OIDs.
--
PKCS1Algorithms ALGORITHM-IDENTIFIER ::=
{
{ OID rsaEncryption PARAMETERS NULL }
| { OID md2WithRSAEncryption PARAMETERS NULL }
| { OID md5WithRSAEncryption PARAMETERS NULL }
| { OID sha1WithRSAEncryption PARAMETERS NULL }
| { OID sha256WithRSAEncryption PARAMETERS NULL }
| { OID sha384WithRSAEncryption PARAMETERS NULL }
| { OID sha512WithRSAEncryption PARAMETERS NULL }
| { OID id-RSAES-OAEP PARAMETERS RSAES-OAEP-params }
| PKCS1PSourceAlgorithms
| { OID id-RSASSA-PSS PARAMETERS RSASSA-PSS-params },
... -- Allows for future expansion --
}
-- ===================
-- Main structures
-- ===================
RSAPublicKey ::= SEQUENCE
{
modulus INTEGER, -- n
publicExponent INTEGER -- e
}
--
-- Representation of RSA private key with information for the CRT
-- algorithm.
--
RSAPrivateKey ::= SEQUENCE
{
version Version,
modulus INTEGER, -- n
publicExponent INTEGER, -- e
privateExponent INTEGER, -- d
prime1 INTEGER, -- p
prime2 INTEGER, -- q
exponent1 INTEGER, -- d mod (p-1)
exponent2 INTEGER, -- d mod (q-1)
coefficient INTEGER, -- (inverse of q) mod p
otherPrimeInfos OtherPrimeInfos OPTIONAL
}
Version ::= INTEGER { two-prime(0), multi(1) }
( CONSTRAINED BY
{
)
-- version must be multi if otherPrimeInfos present --
}
OtherPrimeInfos ::= SEQUENCE SIZE(1..MAX) OF OtherPrimeInfo
OtherPrimeInfo ::= SEQUENCE
{
prime INTEGER, -- ri
exponent INTEGER, -- di
coefficient INTEGER -- ti
}
--
-- AlgorithmIdentifier.parameters for id-RSAES-OAEP.
-- Note that the tags in this Sequence are explicit.
--
RSAES-OAEP-params ::= SEQUENCE
{
hashAlgorithm [0] HashAlgorithm DEFAULT sha1,
maskGenAlgorithm [1] MaskGenAlgorithm DEFAULT mgf1SHA1,
pSourceAlgorithm [2] PSourceAlgorithm DEFAULT pSpecifiedEmpty
}
--
-- Identifier for default RSAES-OAEP algorithm identifier.
-- The DER Encoding of this is in hexadecimal:
-- (0x)30 0D
-- 06 09
-- 2A 86 48 86 F7 0D 01 01 07
-- 30 00
-- Notice that the DER encoding of default values is "empty".
--
rSAES-OAEP-Default-Identifier RSAES-AlgorithmIdentifier ::=
{
algorithm id-RSAES-OAEP,
parameters RSAES-OAEP-params :
{
}
hashAlgorithm sha1,
maskGenAlgorithm mgf1SHA1,
pSourceAlgorithm pSpecifiedEmpty
}
RSAES-AlgorithmIdentifier ::= AlgorithmIdentifier { {PKCS1Algorithms} }
--
-- AlgorithmIdentifier.parameters for id-RSASSA-PSS.
-- Note that the tags in this Sequence are explicit.
--
RSASSA-PSS-params ::= SEQUENCE
{
hashAlgorithm [0] HashAlgorithm DEFAULT sha1,
maskGenAlgorithm [1] MaskGenAlgorithm DEFAULT mgf1SHA1,
saltLength [2] INTEGER DEFAULT 20,
trailerField [3] TrailerField DEFAULT trailerFieldBC
}
TrailerField ::= INTEGER { trailerFieldBC(1) }
--
-- Identifier for default RSASSA-PSS algorithm identifier
-- The DER Encoding of this is in hexadecimal:
-- (0x)30 0D
-- 06 09
-- 2A 86 48 86 F7 0D 01 01 0A
-- 30 00
-- Notice that the DER encoding of default values is "empty".
--
rSASSA-PSS-Default-Identifier RSASSA-AlgorithmIdentifier ::=
{
algorithm id-RSASSA-PSS,
parameters RSASSA-PSS-params :
{
}
hashAlgorithm sha1,
maskGenAlgorithm mgf1SHA1,
saltLength 20,
trailerField trailerFieldBC
}
RSASSA-AlgorithmIdentifier ::= AlgorithmIdentifier { {PKCS1Algorithms} }
--
-- Syntax for the EMSA-PKCS1-v1_5 hash identifier.
--
DigestInfo ::= SEQUENCE
{
digestAlgorithm DigestAlgorithm,
digest OCTET STRING
}
DigestAlgorithm ::= AlgorithmIdentifier { {PKCS1-v1-5DigestAlgorithms} }
END -- PKCS1Definitions