Public-Key Cryptography Standards #3

Principe utilisé par Up ! Security Manager

Les algorithmes Public-Key Cryptography Standards #3 (PKCS#3) du laboratoire Rsa permettent à deux tiers de se constituer une clé secrète sans qu'ils aient communiqué par ailleurs et sans échanger directement cette clé secrète.

Voici le principe de cette méthode trouvée par Diffie et Hellman :

Génération d'une clé partielle.
Cette étape est réalisée par chaque tiers. Le champ Cle.Y est envoyé à l'autre tiers.
Construction de la clé secrète..
Cette étape est réalisée par chaque tiers à partir de ce qu'il est préalablement généré et du champ Cle.Y reçu de l'autre tiers.

Algorithmes utilisés par Up ! Security Manager

Contexte

Les algorithmes utilisent un contexte composé du type global suivant :

Type ClePki Defaut /****************/


	NbBits : Entier;

	L : Entier;

	P : Nul Ou Decimal;

	G : Nul Ou Decimal;

	X : Nul Ou Decimal;

	Y : Nul Ou Decimal;

	SK : Nul Ou Decimal;

	Constructeur();


Fin Type

Phase 1 de la génération d'une clé secrète

La phase 1 de la génération de la clé secrète nécessite les paramètres suivants :

NbBits pour la taille des nombres premiers échangés en nombre de bits.
L pour la taille de la clé secrète en nombre de bits. Elle doit être inférieure à NbBits.

/******************************************************************/ Fonction GenererClePkiKsa1(NbBits : Entier, L : Entier) Retourner Nul Ou ClePki /* Objet : Genere une cle de Pki pour Ksa. */ /******************************************************************/ Variable /******/


	Cle : Nul Ou ClePki;

	NbBits2 : Entier;




Debut

/* Fabrique la cle de Pki. */

Cle=ClePki();

ClePki->NbBits=NbBits;

ClePki->L=L;

/* Tire aleatoirement P. */

Cle.P=Aleatoire(NbBits,Vrai);

/* Tire aleatoirement G. */

TantQue Vrai Faire

   NbBits2=Aleatoire();

	Si NbBits2>NbBits Alors
	
      NbBits2%=NbBits;
   
	Fin Si

	Si NbBits2==0 Alors
	
		Continuer;
   
	Fin Si

	Cle.G=Aleatoire(NbBits,Vrai);

	Arreter;


Fin TantQue

/* Tire aleatoirement X tel que 2^(L-1) < X < 2^L. */

Cle.X=Aleatoire(L-1,0);

/* Calcul de Y=G^X mod P. */

Cle.Y=ExponentiationModulaire(Cle.G,Cle.X,Cle.P);

Retourner Cle;

Fin Fonction

Phase 2 de la génération d'une clé secrète

La phase 2 de la génération de la clé secrète nécessite les paramètres suivants :

Cle qui a été généré à la phase précédente.
Y qui a été communiqué par l'autre tiers.

/******************************************************************/ Procedure GenererClePkiKsa2(Cle : Nul Ou ClePki, Y : Nul Ou Decimal) /* Objet : Genere une cle de Pki pour Ksa. */ /******************************************************************/ Debut /* Calcul de SK=Y^X mod P. */ Cle.SK=ExponentiationModulaire(Y,Cle.X,Cle.P); Fin Procedure

Format utilisé par Up ! Security Manager

Le format Public-Key Cryptography Standards #3 (PKCS#3) du laboratoire Rsa spécifie le format d'échange des clés publiques ou privées.

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-3 OBJECT IDENTIFIER ::= { iso(1) member-body(2) US(840) rsadsi(113549) pkcs(1) 3 } dhKeyAgreement OBJECT IDENTIFIER ::= { pkcs-3 1 } DHParameter ::= SEQUENCE


	{

	prime INTEGER, -- p

	base INTEGER, -- g

	privateValueLength INTEGER OPTIONAL -- l
 
	}