Public-Key Cryptography Standards #5

La norme Public-Key Cryptography Standards #5 (PKCS#5) présente les algorithmes de cryptage, décryptage, signature et de vérification d'une signature d'un message à partir d'une clé privée ou publique et d'un mot de passe complémentaire.

Par souci de sécurité forte :

Le mot de passe est prolongé par l'emploi d'un élément perturbateur calculé aléatoirement. Ce dernier est appelée Salt.
Le mot de passe sert à générer une clé, appelée clé dérivée, de taille variable. Il existe donc des algorithmes de génération de clé dérivée.

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).

Algorithmes utilisés par Up ! Security Manager

Contexte

Les algorithmes utilisent un contexte composé de la constante et du type global suivant :

Constante /*******/


	CO_DifferencePQ=2;




Type ClePki Defaut

/****************/


	VersionCle : Entier;

	NbBits : Entier;

	N : Nul Ou Decimal;

	E : Nul Ou Decimal;

	Selon Forme : Entier Faire
	
		Cas Forme1 Pour 1 Faire
		
			D : Nul Ou Decimal;

		
		Fin Cas

		

		Cas Forme2 Pour 2 Faire
		
			P : Nul Ou Decimal;

			Q : Nul Ou Decimal;

			DP : Nul Ou Decimal;

			DQ : Nul Ou Decimal;

			QInv : Nul Ou Decimal;

		
		Fin Cas

	
	Fin Selon

	Constructeur();


Fin Type

Générateur PBKDF1

Les paramètres du générateur de clé dérivée PBKDF1 sont les suivants :

MotDePasse est le mot de passe.
Salt est l'élement perturbateur.
NbIterations est le nombre d'itérations du générateur.
SousJacent est le code de l'algorithme de signature sous-jacent.

/****************************************************************/ Procedure GenererCleDeriveeRsa1(MotDePasse : Binaire, Salt : Binaire, NbIterations : Entier, SousJacent : ModeSignatureFlux, TailleCleDerivee : Entier, CleDerivee : Binaire Sortie) /* Objet : Genere la cle derivee - PBKDF1. */ /****************************************************************/ Variable /******/


	I : Entier;

	F : Nul Ou FluxConcatene;

	T : Nul Ou Tableau[2] De Nul Ou IFlux;

	Signature : Binaire;

	Signature2 : Binaire;




Debut

/* Ouverture du flux concatene MotDePasse||Salt. */

T[0]=IFlux(FluxBinaire(MotDePasse,1));

T[1]=IFlux(FluxBinaire(Salt,1));

F=FluxConcatene(T);

/* Calcul de T(1)=H(MotDePasse||Salt). */

CalculerSignature(SousJacent,IFlux(F),Signature);

Pour I=1 JusquA NbIterations-1 Faire

	/* Calcul de T(n+1)=H(T(n)). */

	CalculerSignature(SousJacent,Signature,Signature2);

	Signature=Signature2;


Fin Pour

/* Recupere la cle derivee. */

CleDerivee=Signature.Gauche(TailleCleDerivee);

Fin Procedure

Générateur PBKDF2

Les paramètres du générateur de clé dérivée PBKDF2 sont les suivants :

MotDePasse est le mot de passe.
Salt est l'élement perturbateur.
NbIterations est le nombre d'itérations du générateur.
SousJacent est le code de l'algorithme de signature sous-jacent.

/****************************************************************/ Procedure GenererCleDeriveeRsa2(MotDePasse : Binaire, Salt : Binaire, NbIterations : Entier, SousJacent : ModeSignatureFlux, TailleCleDerivee : Entier, CleDerivee : Binaire Sortie) /* Objet : Genere la cle derivee - PBKDF2. */ /****************************************************************/ Variable /******/


	TailleSignature : Entier;

	TailleSignature2 : Entier;

	I : Entier;

	J : Entier;

	K : Entier;

	L : Entier;

	R : Entier;

	TailleBloc : Entier;

	Bloc : Binaire;

	Signature : Binaire;

	Signature2 : Binaire;




Debut

/* Calcul de la taille de la signature. */

TailleSignature=CalculerTailleSignature(SousJacent);

/* Calcul de L et R. */

R=TailleCleDerivee%TailleSignature;

Si R!=0 Alors

   L=(TailleCleDerivee/TailleSignature)+1;

Sinon

   L=TailleCleDerivee/TailleSignature;

Fin Si

CleDerivee=Binaire();

Pour I=1 JusquA L Faire

	Si I<L Faire
	
      TailleBloc=TailleSignature;
   
	Sinon
	
      TailleBloc=R;
	
	Fin Si

	/* Calcul de U(1)=PRF(MotDePasse,Salt||Binaire(i)). */

	Signature=Salt+Binaire((I>>24)&0xFF)+Binaire((I>>16)&0xFF)+Binaire((I>>8)&0xFF)+Binaire(I&0xFF);

	SignerHmac(MotDePasse,SousJacent,Signature,Salt.Longueur()+4,Signature2);

	/* Calcul partiel de T(i)=F(MotDePasse,Salt,NbIterations,i). */

	Bloc=Signature2;

	/* Passage au suivant. */

   Signature=Signature2;

	Pour J=1 JusquA NbIterations-1 Faire
	
		/* Calcul de U(j+1)=PRF(MotDePasse,U(j)). */

		CalculerSignatureHmac(MotDePasse,SousJacent,Signature,TailleSignature,Signature2);

		/* Calcul partiel de T(i)=F(MotDePasse,Salt,NbIterations,I). */

		Pour K=0 JusquA TailleBloc-1 Faire
		
         Bloc[K]^=Signature2[K];
		
		Fin Pour

		/* Passage au suivant. */

      Signature=Signature2;

	
	Fin Pour

	CleDerivee+=Bloc;


Fin Pour

Fin Procedure

Cryptage PBES1

Les paramètres du cryptage PBES1 sont les suivants :

MotDePasse est le mot de passe.
Salt est l'élement perturbateur.
NbIterations est le nombre d'itérations du générateur.
CryptageSousJacent est le code de l'algorithme de cryptage sous-jacent.
SignatureSousJacent est le code de l'algorithme de signature sous-jacent.

/****************************************************************/ Procedure CrypterRsaPbes1(MotDePasse : Binaire, Salt : Binaire, NbIterations : Entier, CryptageSousJacent : ModeCryptageFlux, SignatureSousJacent : ModeSignatureFlux, BufferEntree : Binaire, BufferSortie : Binaire Sortie) /* Objet : Crypte un binaire en Rsa - PBES1. */ /****************************************************************/ Variable /******/


	CleDerivee : Binaire;

	Cle : Binaire;

	VecteurInitialisation : Binaire;

	F : Nul Ou FluxConcatene;

	T : Nul Ou Tableau[2] De Nul Ou IFlux;




Debut

/* Calcul de DK=PBKDF1(MotDePasse,Salt,NbIterations,16). */

GenererCleDeriveeRsa1(MotDePasse,Salt,NbIterations,SignatureSousJacent,16,CleDerivee);

/* Extraction de K et IV tel que DK=K||IV. */

Cle=CleDerivee.Gauche(8);

VecteurInitialisation=CleDerivee.Droite(8);

/* Calcul de PS. */

TailleRemplissage=BufferEntree.Longueur()%8;

Si TailleRemplissage==0 Alors

   TailleRemplissage=8;

Fin Si

Remplissage=Binaire(TailleRemplissage,TailleRemplissage);

/* Ouverture du flux concatene M||PS. */

T[0]=IFlux(FluxBinaire(BufferEntree,1));

T[1]=IFlux(FluxBinaire(Remplissage,1));

F=FluxConcatene(T);

/* Calcul de C=Crypter(M||PS). */

Selon CryptageSousJacent Faire

	Cas Pour ModeCryptageAes Faire
	
		CrypterAes(Cle,128,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageDes Faire
	
		CrypterDes(Cle,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc2 Faire
	
		CrypterRc2(Cle,64,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc4 Faire
	
		CrypterRc4(Cle,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc5 Faire
	
		CrypterRc5(Cle,NbIterations,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc6 Faire
	
		CrypterRc6(Cle,NbIterations,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageTdea Faire
	
		CrypterTdea(Cle,IFlux(F),BufferSortie);
	
	Fin Cas


Fin Selon

Fin Procedure

Décryptage PBES1

Les paramètres du décryptage PBES1 sont les suivants :

MotDePasse est le mot de passe.
Salt est l'élement perturbateur.
NbIterations est le nombre d'itérations du générateur.
CryptageSousJacent est le code de l'algorithme de cryptage sous-jacent.
SignatureSousJacent est le code de l'algorithme de signature sous-jacent.

/****************************************************************/ Procedure DecrypterRsaPbes1(MotDePasse : Binaire, Salt : Binaire, NbIterations : Entier, CryptageSousJacent : ModeCryptageFlux, SignatureSousJacent : ModeSignatureFlux, BufferEntree : Binaire, BufferSortie : Binaire Sortie) /* Objet : Décrypte un binaire en Rsa - PBES1. */ /****************************************************************/ Variable /******/


	CleDerivee : Binaire;

	Cle : Binaire;

	VecteurInitialisation : Binaire;

	EM : Binaire;

	TailleEM : Entier;




Debut

/* Calcul de DK=PBKDF1(MotDePasse,Salt,NbIterations,16). */

GenererCleDeriveeRsa1(MotDePasse,Salt,NbIterations,SignatureSousJacent,16,CleDerivee);

/* Extraction de K et IV tel que DK=K||IV. */

Cle=CleDerivee.Gauche(8);

VecteurInitialisation=CleDerivee.Droite(8);

/* Calcul de EM=Decrypter(C). */

Selon CryptageSousJacent Faire

	Cas Pour ModeCryptageAes Faire
	
		DecrypterAes(Cle,128,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageDes Faire
	
		DecrypterDes(Cle,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc2 Faire
	
		DecrypterRc2(Cle,64,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc4 Faire
	
		DecrypterRc4(Cle,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc5 Faire
	
		DecrypterRc5(Cle,NbIterations,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc6 Faire
	
		DecrypterRc6(Cle,NbIterations,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageTdea Faire
	
		DecrypterTdea(Cle,BufferEntree,EM);
	
	Fin Cas


Fin Selon

/* Recuperation du message. */

TailleEM=EM.Longueur();

BufferSortie=EM.Gauche(TailleEM-EM[TailleEM-1]);

Fin Procedure

Cryptage PBES2

Les paramètres du cryptage PBES2 sont les suivants :

MotDePasse est le mot de passe.
Salt est l'élement perturbateur.
NbIterations est le nombre d'itérations du générateur.
CryptageSousJacent est le code de l'algorithme de cryptage sous-jacent.
SignatureSousJacent est le code de l'algorithme de signature sous-jacent.
TailleCle est la taille de la clé.

/****************************************************************/ Procedure CrypterRsaPbes2(MotDePasse : Binaire, Salt : Binaire, NbIterations : Entier, CryptageSousJacent : ModeCryptageFlux, SignatureSousJacent : ModeSignatureFlux, TailleCle : Entier, BufferEntree : Binaire, BufferSortie : Binaire Sortie) /* Objet : Crypte un binaire en Rsa - PBES2. */ /****************************************************************/ Variable /******/


	I : Entier;

	CleDerivee : Binaire;

	Cle : Binaire;

	Taille : Entier;

	VecteurInitialisation : Binaire;

	TailleVecteurInitialisation : Entier;

	TailleCleDerivee : Entier;

	Remplissage : Binaire;

	F : Nul Ou FluxConcatene;

	T : Nul Ou Tableau[2] De Nul Ou IFlux;




Debut

Selon CryptageSousJacent Faire

	Cas Pour ModeCryptageAes Faire
	
      TailleVecteurInitialisation=16;

	
	Fin Cas

	

	Cas Pour ModeCryptageDes Faire
	
      TailleCle=8;

      TailleVecteurInitialisation=8;

	
	Fin Cas

	

	Cas Pour ModeCryptageRc2 Faire
	
      TailleVecteurInitialisation=8;

	
	Fin Cas

	

	Cas Pour ModeCryptageRc4 Faire
	
      TailleVecteurInitialisation=0;

	
	Fin Cas

	

	Cas Pour ModeCryptageRc5 Faire
	
      TailleVecteurInitialisation=8;

	
	Fin Cas

	

	Cas Pour ModeCryptageRc6 Faire
	
      TailleVecteurInitialisation=8;

	
	Fin Cas

	

	Cas Pour ModeCryptageTdea Faire
	
      TailleVecteurInitialisation=8;

	
	Fin Cas


Fin Selon

TailleCleDerivee=TailleCle+TailleVecteurInitialisation;

/* Calcul de DK=PBKDF2(MotDePasse,Salt,NbIterations,TailleCleDerivee). */

GenererCleDeriveeRsa2(MotDePasse,Salt,NbIterations,SignatureSousJacent,TailleCleDerivee,CleDerivee);

/* Extraction de K et IV tel que DK=K||IV. */

Cle=CleDerivee.Gauche(TailleCle);

Si TailleVecteurInitialisation!=0 Alors

   VecteurInitialisation=CleDerivee.Droite(TailleVecteurInitialisation);

Sinon

   VecteurInitialisation=Nul;

Fin Si

/* Calcul de PS. */

TailleRemplissage=TailleBufferEntree%8;

Si TailleRemplissage!=0 Alors

   TailleRemplissage=8;

Fin Si

Remplissage=Binaire(TailleRemplissage,TailleRemplissage);

/* Ouverture du flux concatene M||PS. */

T[0]=IFlux(FluxBinaire(BufferEntree));

T[1]=IFlux(FluxBinaire(Remplissage));

F=FluxConcatene(T);

/* Calcul de C=Crypter(M||PS). */

Selon CryptageSousJacent Faire

	Cas Pour ModeCryptageAes Faire
	
		CrypterAes(Cle,TailleCle,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageDes Faire
	
		CrypterDes(Cle,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc2 Faire
	
		CrypterRc2(Cle,TailleCle,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc4 Faire
	
		CrypterRc4(Cle,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc5 Faire
	
		CrypterRc5(Cle,NbIterations,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc6 Faire
	
		CrypterRc6(Cle,NbIterations,IFlux(F),BufferSortie);
	
	Fin Cas

	

	Cas Pour ModeCryptageTdea Faire
	
		CrypterTdea(Cle,IFlux(F),BufferSortie);
	
	Fin Cas


Fin Selon

Fin Procedure

Décryptage PBES2

Les paramètres du décryptage PBES2 sont les suivants :

MotDePasse est le mot de passe.
Salt est l'élement perturbateur.
NbIterations est le nombre d'itérations du générateur.
CryptageSousJacent est le code de l'algorithme de cryptage sous-jacent.
SignatureSousJacent est le code de l'algorithme de signature sous-jacent.

/****************************************************************/ Procedure DecrypterRsaPbes2(MotDePasse : Binaire, Salt : Binaire, NbIterations : Entier, CryptageSousJacent : ModeCryptageFlux, SignatureSousJacent : ModeSignatureFlux, TailleCle : Entier, BufferEntree : Binaire, BufferSortie : Binaire Sortie) /* Objet : Décrypte un binaire en Rsa - PBES2. */ /****************************************************************/ Variable /******/


	I : Entier;

	CleDerivee : Binaire;

	Cle : Binaire;

	Taille : Entier;

	VecteurInitialisation : Binaire;

	TailleVecteurInitialisation : Entier;

	TailleCleDerivee : Entier;

	EM : Binaire;

	TailleEM : Entier;




Debut

Selon CryptageSousJacent Faire

	Cas Pour ModeCryptageAes Faire
	
      TailleVecteurInitialisation=16;

	
	Fin Cas

	

	Cas Pour ModeCryptageDes Faire
	
      TailleCle=8;

      TailleVecteurInitialisation=8;

	
	Fin Cas

	

	Cas Pour ModeCryptageRc2 Faire
	
      TailleVecteurInitialisation=8;

	
	Fin Cas

	

	Cas Pour ModeCryptageRc4 Faire
	
      TailleVecteurInitialisation=0;

	
	Fin Cas

	

	Cas Pour ModeCryptageRc5 Faire
	
      TailleVecteurInitialisation=8;

	
	Fin Cas

	

	Cas Pour ModeCryptageRc6 Faire
	
      TailleVecteurInitialisation=8;

	
	Fin Cas

	

	Cas Pour ModeCryptageTdea Faire
	
      TailleVecteurInitialisation=8;

	
	Fin Cas


Fin Selon

TailleCleDerivee=TailleCle+TailleVecteurInitialisation;

/* Calcul de DK=PBKDF2(MotDePasse,Salt,NbIterations,TailleCleDerivee). */

GenererCleDeriveeRsa2(MotDePasse,Salt,NbIterations,SignatureSousJacent,TailleCleDerivee,CleDerivee);

/* Extraction de K et IV tel que DK=K||IV. */

Cle=CleDerivee.Gauche(TailleCle);

Si TailleVecteurInitialisation!=0 Alors

   VecteurInitialisation=CleDerivee.Droite(TailleVecteurInitialisation);

Sinon

   VecteurInitialisation=Nul;

Fin Si

/* Calcul de EM=Decrypter(C). */

Selon CryptageSousJacent Faire

	Cas Pour ModeCryptageAes Faire
	
		DecrypterAes(Cle,TailleCle,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageDes Faire
	
		DecrypterDes(Cle,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc2 Faire
	
		DecrypterRc2(Cle,TailleCle,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc4 Faire
	
		DecrypterRc4(Cle,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc5 Faire
	
		DecrypterRc5(Cle,NbIterations,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageRc6 Faire
	
		DecrypterRc6(Cle,NbIterations,BufferEntree,EM);
	
	Fin Cas

	

	Cas Pour ModeCryptageTdea Faire
	
		DecrypterTdea(Cle,BufferEntree,EM);
	
	Fin Cas


Fin Selon

/* Recuperation du message. */

TailleEM=EM.Longueur();

BufferSortie=EM.Gauche(TailleEM-EM[TailleEM-1]);

Fin Procedure

Signature PBMAC1

Les paramètres de la signature PBMAC1 sont les suivants :

MotDePasse est le mot de passe.
Salt est l'élement perturbateur.
NbIterations est le nombre d'itérations du générateur.
SousJacent est le code de l'algorithme de signature sous-jacent.
TailleCle est la taille clé.

/****************************************************************/ Procedure SignerRsaPbmac1(MotDePasse : Binaire, Salt : Binaire, NbIterations : Entier, SousJacent : ModeSignatureFlux, TailleCle : Entier, BufferEntree : Binaire, BufferSignature : Binaire Sortie) /* Objet : Signe un binaire en Rsa - PBMAC1. */ /****************************************************************/ Variable /******/


	Cle : Binaire;




Debut

/* Calcul de DK=PBKDF2(MotDePasse,Salt,NbIterations,TailleCleDerivee). */

GenererCleDeriveeRsa2(MotDePasse,Salt,NbIterations,SousJacent,TailleCle,Cle);

/* Appel de HMAC. */

SignerHmac(SousJacent,Cle,BufferEntree,BufferSignature);

Fin Procedure

Vérification de la signature PBMAC1

Pour cette vérification de signature de base, la taille du message est limitée à NbBits/8 octets.

/****************************************************************/ Fonction SignerRsaPbmac1(MotDePasse : Binaire, Salt : Binaire, NbIterations : Entier, SousJacent : ModeSignatureFlux, TailleCle : Entier, BufferEntree : Binaire, BufferSignature : Binaire Sortie) Retourner Booleen /* Objet : Verifie la signature d'un binaire en Rsa - PBMAC1. */ /****************************************************************/ Variable /******/


	BufferSignature2 : Nul Ou Binaire;




Debut

SignerRsaPbmac1(MotDePasse,Salt,NbIterations,SousJacent,TailleCle,BufferEntree,BufferSignature2);

Retourner BufferSignature==BufferSignature2;

Fin Fonction

Format utilisé par Up ! Security Manager

Le format Public-Key Cryptography Standards #5 (PKCS#5) 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 #5 v2.0 ASN.1 Module -- Revised March 25, 1999 -- This module has been checked for conformance with the -- ASN.1 standard by the OSS ASN.1 Tools PKCS5v2-0 {iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-5(5) modules(16) pkcs5v2-0(1)} DEFINITIONS ::= BEGIN -- Basic object identifiers rsadsi OBJECT IDENTIFIER ::= {iso(1) member-body(2) us(840) 113549} pkcs OBJECT IDENTIFIER ::= {rsadsi 1} pkcs-5 OBJECT IDENTIFIER ::= {pkcs 5} -- Basic types and classes AlgorithmIdentifier { ALGORITHM-IDENTIFIER:InfoObjectSet } ::= SEQUENCE


	{

   algorithm ALGORITHM-IDENTIFIER.&id({InfoObjectSet}),

   parameters ALGORITHM-IDENTIFIER.&Type({InfoObjectSet}

   {@algorithm}) OPTIONAL

   }




ALGORITHM-IDENTIFIER ::= TYPE-IDENTIFIER



-- PBKDF2



PBKDF2Algorithms ALGORITHM-IDENTIFIER ::= { {PBKDF2-params IDENTIFIED BY id-PBKDF2}, ...}



id-PBKDF2 OBJECT IDENTIFIER ::= {pkcs-5 12}



algid-hmacWithSHA1 AlgorithmIdentifier {{PBKDF2-PRFs}} ::= {algorithm id-hmacWithSHA1, parameters NULL : NULL}



PBKDF2-params ::= SEQUENCE

	{

   salt CHOICE 
	
		{

      specified OCTET STRING,

      otherSource AlgorithmIdentifier {{PBKDF2-SaltSources}}

      },
   
	iterationCount INTEGER (1..MAX),

   keyLength INTEGER (1..MAX) OPTIONAL,

   prf AlgorithmIdentifier {{PBKDF2-PRFs}} DEFAULT algid-hmacWithSHA1

   }




PBKDF2-SaltSources ALGORITHM-IDENTIFIER ::= { ... }



PBKDF2-PRFs ALGORITHM-IDENTIFIER ::= { {NULL IDENTIFIED BY id-hmacWithSHA1}, ... }



-- PBES1



PBES1Algorithms ALGORITHM-IDENTIFIER ::= 

	{

   {PBEParameter IDENTIFIED BY pbeWithMD2AndDES-CBC}

	| {PBEParameter IDENTIFIED BY pbeWithMD2AndRC2-CBC}

	| {PBEParameter IDENTIFIED BY pbeWithMD5AndDES-CBC}

	| {PBEParameter IDENTIFIED BY pbeWithMD5AndRC2-CBC}

	| {PBEParameter IDENTIFIED BY pbeWithSHA1AndDES-CBC}

	| {PBEParameter IDENTIFIED BY pbeWithSHA1AndRC2-CBC},

   ...

   }



pbeWithMD2AndDES-CBC OBJECT IDENTIFIER ::= {pkcs-5 1}

pbeWithMD2AndRC2-CBC OBJECT IDENTIFIER ::= {pkcs-5 4}

pbeWithMD5AndDES-CBC OBJECT IDENTIFIER ::= {pkcs-5 3}

pbeWithMD5AndRC2-CBC OBJECT IDENTIFIER ::= {pkcs-5 6}

pbeWithSHA1AndDES-CBC OBJECT IDENTIFIER ::= {pkcs-5 10}

pbeWithSHA1AndRC2-CBC OBJECT IDENTIFIER ::= {pkcs-5 11}



PBEParameter ::= SEQUENCE

   {

   salt OCTET STRING (SIZE(8)),

   iterationCount INTEGER

   }



-- PBES2



PBES2Algorithms ALGORITHM-IDENTIFIER ::= { {PBES2-params IDENTIFIED BY id-PBES2}, ...}



id-PBES2 OBJECT IDENTIFIER ::= {pkcs-5 13}



PBES2-params ::= SEQUENCE

   {

   keyDerivationFunc AlgorithmIdentifier {{PBES2-KDFs}},

   encryptionScheme AlgorithmIdentifier {{PBES2-Encs}}

   }




PBES2-KDFs ALGORITHM-IDENTIFIER ::= { {PBKDF2-params IDENTIFIED BY id-PBKDF2}, ... }



PBES2-Encs ALGORITHM-IDENTIFIER ::= { ... }



-- PBMAC1



PBMAC1Algorithms ALGORITHM-IDENTIFIER ::= { {PBMAC1-params IDENTIFIED BY id-PBMAC1}, ...}



id-PBMAC1 OBJECT IDENTIFIER ::= {pkcs-5 14}



PBMAC1-params ::= SEQUENCE

	{

   keyDerivationFunc AlgorithmIdentifier {{PBMAC1-KDFs}},

   messageAuthScheme AlgorithmIdentifier {{PBMAC1-MACs}}

   }



PBMAC1-KDFs ALGORITHM-IDENTIFIER ::= { {PBKDF2-params IDENTIFIED BY id-PBKDF2}, ... }



PBMAC1-MACs ALGORITHM-IDENTIFIER ::= { ... }



-- Supporting techniques



digestAlgorithm OBJECT IDENTIFIER ::= {rsadsi 2}

encryptionAlgorithm OBJECT IDENTIFIER ::= {rsadsi 3}



SupportingAlgorithms ALGORITHM-IDENTIFIER ::= 

	{

	{NULL IDENTIFIED BY id-hmacWithSHA1}

	| {OCTET STRING (SIZE(8)) IDENTIFIED BY desCBC}

	| {OCTET STRING (SIZE(8)) IDENTIFIED BY des-EDE3-CBC}

	| {RC2-CBC-Parameter IDENTIFIED BY rc2CBC}

	| {RC5-CBC-Parameters IDENTIFIED BY rc5-CBC-PAD},

	...

   }



id-hmacWithSHA1 OBJECT IDENTIFIER ::= {digestAlgorithm 7}



desCBC OBJECT IDENTIFIER ::= {iso(1) identified-organization(3) oiw(14) secsig(3) algorithms(2) 7} -- from OIW



des-EDE3-CBC OBJECT IDENTIFIER ::= {encryptionAlgorithm 7}



rc2CBC OBJECT IDENTIFIER ::= {encryptionAlgorithm 2}



RC2-CBC-Parameter ::= SEQUENCE

	{

   rc2ParameterVersion INTEGER OPTIONAL,

   iv OCTET STRING (SIZE(8))

   }



rc5-CBC-PAD OBJECT IDENTIFIER ::= {encryptionAlgorithm 9}

RC5-CBC-Parameters ::= SEQUENCE 

	{

   version INTEGER {v1-0(16)} (v1-0),

   rounds INTEGER (8..127),

   blockSizeInBits INTEGER (64 | 128),

   iv OCTET STRING OPTIONAL

   }



END