Public-Key Cryptography Standards #15

Format utilisé par Up ! Security Manager

Le format Public-Key Cryptography Standards #15 (PKCS#15) du laboratoire Rsa spécifie l'interface avec un périphérique renfermant les clés 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).

Le principe de cette Application Program Interface (API) est le suivant :

La carte comporte un système de fichiers formaté en Elementary Files EFs.
Le point de montage de ce système de fichiers est Master File (MF).

Le Master File (MF) comporte les éléments suivants :

Répertoire EF(DIR).
Il y a un fichier pour chaque application pouvant exploiter la carte. Les applications sont identifiées de manière unique.
Répertoire DF(PKCS#15).
Il contient les élements suivants :
- Private Key Directory File (PrKDF).
  Ce répertoire contient une ou plusieurs clés privées.
  La séquence des objets PrivateKeyType est encodée en Distinguished Encoding Rules (DER) sans l'étiquette ni la longueur.
- Public Key Directory File (PuKDF).
  Ce répertoire contient zéro, une ou plusieurs clés publiques.
  La séquence des objets PublicKeyType est encodée en Distinguished Encoding Rules (DER) sans l'étiquette ni la longueur.
- Secret Key Directory File (SKDF).
  Ce répertoire contient une ou plusieurs mots de passe i.e. clés secrètes.
  La séquence des objets SecretKeyType est encodée en Distinguished Encoding Rules (DER) sans l'étiquette ni la longueur.
- Certificate Directory File (CDF).
  Ce répertoire contient un ou plusieurs certificats. Ils référencient alors les clés privées et publiques correspondantes.
  La séquence des objets CertificateType est encodée en Distinguished Encoding Rules (DER) sans l'étiquette ni la longueur.
- Data Object Directory File (DODF).
  Ce répertoire contient zéron, un ou plusieurs fichiers qui sont autres que des clés ou des certificats.
  La séquence des objets DataType est encodée en Distinguished Encoding Rules (DER) sans l'étiquette ni la longueur.
- Authentication Object Directory File (AODF).
  Ce répertoire contient zéron, un ou plusieurs fichiers utilisés pour l'identification - mot de passe, code Personal Information Number (PIN), etc. Ils sont utilisés pour confirmer l'accès aux autres fichiers cités précédemment.
  La séquence des objets AuthenticationType est encodée en Distinguished Encoding Rules (DER) sans l'étiquette ni la longueur.
- TokenInfo.
  Ce fichier regroupe des informations décrivant le périphérique - Numéro de série, capacité, algorithmes implémentés par la carte, etc.
- UnusedSpace.
  Ce fichier regroupe tout l'espace libre restant.

PKCS-15 {iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-15(15) modules(1) pkcs-15(1)} DEFINITIONS IMPLICIT TAGS ::= BEGIN IMPORTS


	informationFramework, authenticationFramework, certificateExtensions FROM UsefulDefinitions 
	
		{joint-iso-itu-t(2) ds(5) module(1) usefulDefinitions(0) 3}
	
	Name, Attribute FROM InformationFramework informationFramework

	Certificate, AttributeCertificate, CertificateSerialNumber, SubjectPublicKeyInfo FROM AuthenticationFramework authenticationFramework

	GeneralNames, KeyUsage FROM CertificateExtensions certificateExtensions

	RecipientInfos, RecipientInfo, OriginatorInfo, sha-1, id-alg-CMS3DESwrap, id-alg-CMSRC2wrap, hMAC-SHA1, des-ede3-cbc FROM CryptographicMessageSyntax 
	
		{iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1)	pkcs-9(9) smime(16) modules(0) cms(1)}
	
	RSAPublicKey FROM PKCS-1 
	
		{iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-1(1) modules(0) pkcs-1(1)}
	
	AlgorithmIdentifier, SupportingAlgorithms, PBKDF2Algorithms, ALGORITHM-IDENTIFIER, id-hmacWithSHA1 FROM PKCS-5 
	
		{iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-5(5) modules(16) pkcs-5(1)}
	
	ECPoint, Parameters FROM ANSI-X9-62 
	
		{iso(1) member-body(2) us(840) ansi-x962(10045) module(4) 1}
	
	DiffieHellmanPublicNumber, DomainParameters FROM ANSI-X9-42 
	
		{iso(1) member-body(2) us(840) ansi-x942(10046) module(5) 1}
	
	OOBCertHash FROM PKIXCMP 
	
		{iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5)
	
	pkix(7) id-mod(0) id-mod-cmp(9)};




-- Constants

pkcs15-ub-identifier INTEGER ::= 255

pkcs15-ub-reference INTEGER ::= 255

pkcs15-ub-index INTEGER ::= 65535

pkcs15-ub-label INTEGER ::= pkcs15-ub-identifier

pkcs15-lb-minPinLength INTEGER ::= 4

pkcs15-ub-minPinLength INTEGER ::= 8

pkcs15-ub-storedPinLength INTEGER ::= 64

pkcs15-ub-recordLength INTEGER ::= 16383

pkcs15-ub-userConsent INTEGER ::= 15

pkcs15-ub-securityConditions INTEGER ::= 255

pkcs15-ub-seInfo INTEGER ::= 255



-- Object Identifiers

pkcs15 OBJECT IDENTIFIER ::= {iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-15(15)}

pkcs15-mo OBJECT IDENTIFIER ::= {pkcs15 1} -- Modules branch

pkcs15-at OBJECT IDENTIFIER ::= {pkcs15 2} -- Attribute branch

pkcs15-ct OBJECT IDENTIFIER ::= {pkcs15 3} -- Content type branch



-- Content Types

pkcs15-ct-PKCS15Token OBJECT IDENTIFIER ::= {pkcs15-ct 1}



-- Basic types

Identifier ::= OCTET STRING (SIZE (0..pkcs15-ub-identifier))

-- Pour l'identifiant interne de la carte.

Reference ::= INTEGER (0..pkcs15-ub-reference)

Label ::= UTF8String (SIZE(0..pkcs15-ub-label))



-- Credential Identifiers

KEY-IDENTIFIER ::= CLASS 

	{

	&id INTEGER UNIQUE,

	&Value

	}

WITH SYNTAX

	{

	SYNTAX &Value IDENTIFIED BY &id

	}



CredentialIdentifier {KEY-IDENTIFIER : IdentifierSet} ::= SEQUENCE

-- Pour identifier une cle privee ou un certificat.


	{

	idType KEY-IDENTIFIER.&id ({IdentifierSet}),

	idValue KEY-IDENTIFIER.&Value ({IdentifierSet}{@idType})

	}



KeyIdentifiers KEY-IDENTIFIER ::= 

	{

	issuerAndSerialNumber

	-- Identification par le Distinguished Name (DN) de l'emetteur et le numero de serie du certificat.

	| issuerAndSerialNumberHash

	-- Identification par le Distinguished Name (DN) de l'emetteur et le numero de serie du certificat + SHA-1.

	| subjectKeyId

	-- Identification par la paire de cles privee et publique comme dans CertificateExtension.subjectKeyIdentifier.

	| subjectKeyHash

	-- Identification par la cle publique + SHA-1.

	| issuerKeyHash

	-- Identification par la cle publique + SHA-1 comme dans CertificateExtension.authorityKeyIdentifier.

	| issuerNameHash

	-- Hachage du nom de l'emetteur comme cela apparait dans le certificat.

	| subjectNameHash,

	-- Hachage du nom du sujet comme cela apparait dans le certificat.

	...

	}



issuerAndSerialNumber KEY-IDENTIFIER::= {SYNTAX PKCS15-OPAQUE.&Type IDENTIFIED BY 1}

-- As defined in RFC 2630



subjectKeyId KEY-IDENTIFIER ::= { SYNTAX OCTET STRING IDENTIFIED BY 2}

-- From x509v3 certificate extension



issuerAndSerialNumberHash KEY-IDENTIFIER ::= { SYNTAX OCTET STRING IDENTIFIED BY 3}

-- Assumes SHA-1 hash of DER encoding of IssuerAndSerialNumber



subjectKeyHash KEY-IDENTIFIER ::= { SYNTAX OCTET STRING IDENTIFIED BY 4}



issuerKeyHash KEY-IDENTIFIER ::= { SYNTAX OCTET STRING IDENTIFIED BY 5}



issuerNameHash KEY-IDENTIFIER ::= { SYNTAX OCTET STRING IDENTIFIED BY 6}

-- SHA-1 hash of DER-encoded issuer name



subjectNameHash KEY-IDENTIFIER ::= { SYNTAX OCTET STRING IDENTIFIED BY 7}

-- SHA-1 hash of DER-encoded subject name



ReferencedValue {Type} ::= CHOICE
-- Reference externe.


	{

	path Path,

	-- Chemin d'acces au fichier dans le peripherique ou numéro d'identification sur deux octets.

	url URL

	-- URL d'acces au fichier externe.

	}

(CONSTRAINED BY

	{-- 'path' or 'url' shall point to an object of type -- Type})



URL ::= CHOICE

	{

	url PrintableString,

	urlWithDigest [3] SEQUENCE
	
		{

		url IA5String,

		digest DigestInfoWithDefault

		}
	
	}



alg-id-sha1 AlgorithmIdentifier {{DigestAlgorithms}} ::= 

	{

	algorithm sha-1,

	parameters SHA1Parameters : NULL

	}



SHA1Parameters ::= NULL



DigestInfoWithDefault ::= SEQUENCE

	{

	digestAlg AlgorithmIdentifier {{DigestAlgorithms}} DEFAULT alg-id-sha1,

	digest OCTET STRING (SIZE(8..128))

	}



Path ::= SEQUENCE 

	{
	path OCTET STRING,

	index INTEGER (0..pkcs15-ub-index) OPTIONAL,

	length [0] INTEGER (0..pkcs15-ub-index) OPTIONAL

	}

( WITH COMPONENTS

	 {..., index PRESENT, length PRESENT}

| WITH COMPONENTS 

	{..., index ABSENT, length ABSENT})



ObjectValue { Type } ::= CHOICE

-- Choix du mode d'acces a une cle ou un certificat.


	{

	indirect ReferencedValue {Type},

	-- La cle ou le certificat est indirectement pointe par l'entree du repertoire. Pas de protection.

	direct [0] Type,

	-- La cle ou le certificat est directement pointe par l'entree du repertoire. Pas de protection.

	indirect-protected [1] ReferencedValue {EnvelopedData {Type}},

	-- La cle ou le certificat est indirectement pointe par l'entree du repertoire. Acces protege.

	direct-protected [2] EnvelopedData {Type}

	-- La cle ou le certificat est directement pointe par l'entree du repertoire. Acces protege.

	}

(CONSTRAINED BY 

	{-- if indirection is being used, then it is expected that the reference

	-- points either to a (possibly enveloped) object of type -- Type -- or (key case) to a card-

	-- specific key file --

	})



PathOrObjects {ObjectType} ::= CHOICE

-- Soit un acces ou directement une cle ou un certificat.


	{

	path Path,

	-- Pour un acces direct si le peripherique sait proteger l'acces aux fichiers, fichier contenant SEQUENCE OF ObjectType.

	objects [0] SEQUENCE OF ObjectType,

	...,

	indirect-protected [1] ReferencedValue {EnvelopedData {SEQUENCE OF ObjectType}},

	-- Pour un acces indirect si le peripherique ne sait pas proteger l'acces aux fichiers.

	direct-protected [2] EnvelopedData {SEQUENCE OF ObjectType}

	-- Pour un acces direct si le peripherique ne sait pas proteger l'acces aux fichiers.

	}



CommonObjectAttributes ::= SEQUENCE

-- Description des attributs pour tous les objets - cle ou certificat.


	{

	label Label OPTIONAL,

	-- Libelle de l'objet comprehensible par l'utilisateur.

	flags CommonObjectFlags OPTIONAL,

	-- Droits d'acces a l'objet.

	authId Identifier OPTIONAL,

	-- Reference vers la protection de l'objet.

	...,

	userConsent INTEGER (1..pkcs15-ub-userConsent) OPTIONAL,

	-- Periode re-authentification. 1 est decompte a chaque usage de l'objet.

	accessControlRules SEQUENCE SIZE (1..MAX) OF AccessControlRule OPTIONAL

	-- Regles de controle d'acces.

	}

(CONSTRAINED BY 

	{

	-- authId should be present in the IC card case if flags.private is set.

	-- It must equal an authID in one AuthRecord in the AODF --
 
	})



CommonObjectFlags ::= BIT STRING 

	{

	private (0),

	modifiable (1)

	}



AccessControlRule ::= SEQUENCE

	{

	accessMode AccessMode,

	securityCondition SecurityCondition,

	... -- For future extensions

	}



AccessMode ::= BIT STRING

	{

	read (0),

	update (1),

	execute (2)

	}



SecurityCondition ::= CHOICE 

	{

	authId Identifier,

	not[0] SecurityCondition,

	and [1] SEQUENCE SIZE (2..pkcs15-ub-securityConditions) OF SecurityCondition,

	or [2] SEQUENCE SIZE (2..pkcs15-ub-securityConditions) OF SecurityCondition,

	... -- For future extensions

	}



CommonKeyAttributes ::= SEQUENCE

-- Description des attributs pour les cles publiques ou privees.


	{

	iD Identifier,

	-- Identification unique d'une cle privee, d'une cle publique ou d'une paire de cles prives et publiques.

	usage KeyUsageFlags,

	-- Ce pour quoi la cle est utilisee. Confere PKCS#11.

	native BOOLEAN DEFAULT TRUE,

	-- Si Vrai, les algorithmes du peripherique savent utiliser une telle cle.

	accessFlags KeyAccessFlags OPTIONAL,

	-- Confere Pkcs#11.

	keyReference Reference OPTIONAL,

	startDate GeneralizedTime OPTIONAL,

	-- Date de debut d'usage de la cle.

	endDate [0] GeneralizedTime OPTIONAL,

	-- Date de fin d'usage de la cle.

	... -- For future extensions

	}



KeyUsageFlags ::= BIT STRING

	{

	encrypt (0),

	decrypt (1),

	sign (2),

	signRecover (3),

	wrap (4),

	unwrap (5),

	verify (6),

	verifyRecover (7),

	derive (8),

	nonRepudiation (9)

	}



KeyAccessFlags ::= BIT STRING

	{

	sensitive (0),

	extractable (1),

	alwaysSensitive (2),

	neverExtractable (3),

	local (4)

	}

CommonPrivateKeyAttributes ::= SEQUENCE

-- Description des attributs pour les cles privees.


	{

	subjectName Name OPTIONAL,

	-- Distinguished Name (DN) du proprietaire de la cle privee.

	keyIdentifiers [0] SEQUENCE OF CredentialIdentifier {{KeyIdentifiers}} OPTIONAL,

	-- Pour savoir quelle cle privee du peripherique employer pour decrypter l'enveloppe d'une cle publique transferee.

	... -- For future extensions

	}



CommonPublicKeyAttributes ::= SEQUENCE

-- Description des attributs pour les cles publiques.


	{

	subjectName Name OPTIONAL,

	-- Distinguished Name (DN) du proprietaire de la cle publique.

	...,

	trustedUsage [0] Usage OPTIONAL

	-- Indicateur sur la confiance envers la cle publique attribuee par l'utilisateur.

	}



CommonSecretKeyAttributes ::= SEQUENCE

-- Description des attributs pour les cles secretes.


	{
	keyLen INTEGER OPTIONAL, -- keylength (in bits)

	... -- For future extensions

	}



KeyInfo {ParameterType, OperationsType} ::= CHOICE

-- Information sur une cle.


	{

	reference Reference,

	-- Reference des informations de la cle dans le fichier MF/PKCS#15/TokenInfo.

	paramsAndOps SEQUENCE 
	-- Informations directes.

	
		{

		parameters ParameterType,

		supportedOperations OperationsType OPTIONAL

		-- Operations directement supportees par le peripherique.

		}
	
	}



CommonCertificateAttributes ::= SEQUENCE
 
-- Description des attributs pour les certificats.


	{

	iD Identifier,

	-- Uniquement pour les certificats a la norme X.509.

	authority BOOLEAN DEFAULT FALSE,

	-- Si Vrai, certificat pour une autorite i.e. Certificate Authority (CA).

	identifier CredentialIdentifier {{KeyIdentifiers}} OPTIONAL,

	-- Obsolete.

	certHash [0] OOBCertHash OPTIONAL,

	-- Utile quand le certificat est conserve en externe i.e. pas dans le peripherique.

	...,

	trustedUsage [1] Usage OPTIONAL,

	-- Si Vrai, l'utilisateur du peripherique a confiance en le certificat.

	identifiers [2] SEQUENCE OF CredentialIdentifier{{KeyIdentifiers}} OPTIONAL,

	-- Identifiant de la cle.

	implicitTrust [3] BOOLEAN DEFAULT FALSE

	-- Si vrai, le reste de la chaine des certifiats menant au CA n'a pas a etre valide.

	}



Usage ::= SEQUENCE

	{

	keyUsage KeyUsage OPTIONAL,

	extKeyUsage SEQUENCE SIZE (1..MAX) OF OBJECT IDENTIFIER OPTIONAL

	}

(WITH COMPONENTS 

	{..., keyUsage PRESENT}

| WITH COMPONENTS 

	{..., extKeyUsage PRESENT})



CommonDataObjectAttributes ::= SEQUENCE

-- Attributs communs aux objets.


	{

	applicationName Label OPTIONAL,

	-- Nom de l'application.

	applicationOID OBJECT IDENTIFIER OPTIONAL,

	-- Identifiant de l'application.

	... -- For future extensions

	}

(WITH COMPONENTS 

	{..., applicationName PRESENT}

| WITH COMPONENTS

	{..., applicationOID PRESENT})



CommonAuthenticationObjectAttributes ::= SEQUENCE

	{

	authId Identifier,

	... -- For future extensions

	}



PKCS15Object {ClassAttributes, SubClassAttributes, TypeAttributes} ::= SEQUENCE

-- Proprietes communes a tous les objets PKCS#15.


	{

	commonObjectAttributes CommonObjectAttributes,

	classAttributes ClassAttributes,

	subClassAttributes [0] SubClassAttributes OPTIONAL,

	typeAttributes [1] TypeAttributes

	}



PKCS15Objects ::= CHOICE

-- Choix d'un objet PKCS#15.


	{

	privateKeys [0] PrivateKeys,

	-- Cles privees.

	publicKeys [1] PublicKeys,

	-- Pour les peripheriques pour lesquels la modification des cles publiques en acces direct n'est pas possible.

	trustedPublicKeys [2] PublicKeys,

	-- Pour les peripheriques pour lesquels la modification des cles publiques en acces direct est possible.

	secretKeys [3] SecretKeys,

	-- Cles secretes.

	certificates [4] Certificates,

	-- Pour les peripheriques pour lesquels la modification des certificats en acces direct n'est pas possible.

	trustedCertificates [5] Certificates,

	-- Pour les peripheriques pour lesquels la modification des certificats en acces direct est possible.

	usefulCertificates [6] Certificates,

	-- Pour les peripheriques pour lesquels la modification des certificats en acces direct est possible, certificats faisant partie de la chaine de validation et qui ont ete valides.

	dataObjects [7] DataObjects,

	authObjects [8] AuthObjects,

	... -- For future extensions

	}



PrivateKeys ::= PathOrObjects {PrivateKeyType}

SecretKeys ::= PathOrObjects {SecretKeyType}

PublicKeys ::= PathOrObjects {PublicKeyType}

Certificates ::= PathOrObjects {CertificateType}

DataObjects ::= PathOrObjects {DataType}

AuthObjects ::= PathOrObjects {AuthenticationType}



PrivateKeyType ::= CHOICE

-- Choix d'un type de cle privee.


	{

	privateRSAKeyPrivateKeyObject {PrivateRSAKeyAttributes},

	privateECKey [0] PrivateKeyObject {PrivateECKeyAttributes},

	privateDHKey [1] PrivateKeyObject {PrivateDHKeyAttributes},

	privateDSAKey[2] PrivateKeyObject {PrivateDSAKeyAttributes},

	privateKEAKey[3] PrivateKeyObject {PrivateKEAKeyAttributes},

	... -- For future extensions

	}



PrivateKeyObject {KeyAttributes} ::= PKCS15Object 

	{

	CommonKeyAttributes, CommonPrivateKeyAttributes, KeyAttributes}

	PrivateRSAKeyAttributes ::= SEQUENCE 
	
		{

		value ObjectValue {RSAPrivateKeyObject},

		-- Contient soit :

		-- 1) Un objet RSAPrivateKeyObject si les algorithmes du peripheriques ne sont pas utilises.

		-- 2) Un cle privee RSA au format attendu par le peripherique.

		-- 3) ''H si pas d'utilite.

		modulusLength INTEGER, -- modulus length in bits, e.g. 1024

		keyInfo KeyInfo {NULL, PublicKeyOperations} OPTIONAL,

		-- Parametres pour les algorithmes sur la cle.

		... -- For future extensions

		}
	
	}



RSAPrivateKeyObject ::= SEQUENCE

	{

	modulus [0] INTEGER OPTIONAL, -- n

	publicExponent [1] INTEGER OPTIONAL, -- e

	privateExponent [2] INTEGER OPTIONAL, -- d

	prime1 [3] INTEGER OPTIONAL, -- p

	prime2 [4] INTEGER OPTIONAL, -- q

	exponent1 [5] INTEGER OPTIONAL, -- d mod (p-1)

	exponent2 [6] INTEGER OPTIONAL, -- d mod (q-1)

	coefficient [7] INTEGER OPTIONAL -- inv(q) mod p

	}

(CONSTRAINED BY

	{

	-- must be possible to reconstruct modulus and privateExponent from

	-- selected fields --
	})



PrivateECKeyAttributes ::= SEQUENCE

	{

	value ObjectValue {ECPrivateKey},

	-- Contient soit :

	-- 1) Un objet ECPrivateKey si les algorithmes du peripheriques ne sont pas utilises.

	-- 2) Un cle privee EC au format attendu par le peripherique.

	-- 3) ''H si pas d'utilite.

	keyInfo KeyInfo {Parameters, PublicKeyOperations} OPTIONAL,

	-- Parametres pour les algorithmes sur la cle.

	... -- For future extensions

	}



ECPrivateKey ::= INTEGER



PrivateDHKeyAttributes ::= SEQUENCE

	{

	value ObjectValue {DHPrivateKey},

	-- Contient soit :

	-- 1) Un objet DHPrivateKey si les algorithmes du peripheriques ne sont pas utilises.

	-- 2) Un cle privee DH au format attendu par le peripherique.

	-- 3) ''H si pas d'utilite.

	keyInfo KeyInfo {DomainParameters, PublicKeyOperations} OPTIONAL,

	-- Parametres pour les algorithmes sur la cle.

	... -- For future extensions

	}



DHPrivateKey ::= INTEGER -- Diffie-Hellman exponent



PrivateDSAKeyAttributes ::= SEQUENCE

	{

	value ObjectValue {DSAPrivateKey},

	-- Contient soit :

	-- 1) Un objet DSAPrivateKey si les algorithmes du peripheriques ne sont pas utilises.

	-- 2) Un cle privee DSA au format attendu par le peripherique.

	-- 3) ''H si pas d'utilite.

	keyInfo KeyInfo {DomainParameters, PublicKeyOperations} OPTIONAL,

	-- Parametres pour les algorithmes sur la cle.

	... -- For future extensions

	}



DSAPrivateKey ::= INTEGER



PrivateKEAKeyAttributes ::= SEQUENCE

	{

	value ObjectValue {KEAPrivateKey},

	-- Contient soit :

	-- 1) Un objet KEAPrivateKey si les algorithmes du peripheriques ne sont pas utilises.

	-- 2) Un cle privee KEA au format attendu par le peripherique.

	-- 3) ''H si pas d'utilite.

	keyInfo KeyInfo {DomainParameters, PublicKeyOperations} OPTIONAL,

	-- Parametres pour les algorithmes sur la cle.

	... -- For future extensions

	}



KEAPrivateKey ::= INTEGER



PublicKeyType ::= CHOICE

-- Choix d'un type de cle publique.


	{

	publicRSAKey PublicKeyObject {PublicRSAKeyAttributes},

	publicECKey [0] PublicKeyObject {PublicECKeyAttributes},

	publicDHKey [1] PublicKeyObject {PublicDHKeyAttributes},

	publicDSAKey [2] PublicKeyObject {PublicDSAKeyAttributes},

	publicKEAKey [3] PublicKeyObject {PublicKEAKeyAttributes},

	... -- For future extensions

	}



PublicKeyObject {KeyAttributes} ::= PKCS15Object {CommonKeyAttributes, CommonPublicKeyAttributes, KeyAttributes}



PublicRSAKeyAttributes ::= SEQUENCE

	{

	value ObjectValue {RSAPublicKeyChoice},

	-- Contient soit :

	-- 1) Un objet RSAPublicKey ou SubjectPublicKeyInfo si les algorithmes du peripheriques ne sont pas utilises.

	-- 2) Un cle privee RSA au format attendu par le peripherique.

	modulusLength INTEGER, -- modulus length in bits, e.g. 1024

	keyInfo KeyInfo {NULL, PublicKeyOperations} OPTIONAL,

	-- Parametres pour les algorithmes sur la cle.

	... -- For future extensions

	}



RSAPublicKeyChoice ::= CHOICE

	{

	raw RSAPublicKey,

	spki [1] SubjectPublicKeyInfo, -- See X.509. Must contain a public RSA key

	...

	}



PublicECKeyAttributes ::= SEQUENCE

	{

	value ObjectValue {ECPublicKeyChoice},

	-- Contient soit :

	-- 1) Un objet ECPublicKey, ou SubjectPublicKeyInfo si les algorithmes du peripheriques ne sont pas utilises.

	-- 2) Un cle privee EC au format attendu par le peripherique.

	keyInfo KeyInfo {Parameters, PublicKeyOperations} OPTIONAL,

	-- Parametres pour les algorithmes sur la cle.

	... -- For future extensions

	}



ECPublicKeyChoice ::= CHOICE

	{

	raw ECPoint,

	spki SubjectPublicKeyInfo, -- See X.509. Must contain a public EC key

	...

	}



PublicDHKeyAttributes ::= SEQUENCE

	{

	value ObjectValue {DHPublicKeyChoice},

	-- Contient soit :

	-- 1) Un objet DHPublicKey, ou SubjectPublicKeyInfo si les algorithmes du peripheriques ne sont pas utilises.

	-- 2) Un cle privee DH au format attendu par le peripherique.

	keyInfo KeyInfo {DomainParameters, PublicKeyOperations} OPTIONAL,

	-- Parametres pour les algorithmes sur la cle.

	... -- For future extensions

	}



DHPublicKeyChoice ::= CHOICE

	{

	raw DiffieHellmanPublicNumber,

	spki SubjectPublicKeyInfo, -- See X.509. Must contain a public D-H key

	...

	}



PublicDSAKeyAttributes ::= SEQUENCE

	{

	value ObjectValue {DSAPublicKeyChoice},

	-- Contient soit :

	-- 1) Un objet DSAPublicKey, ou SubjectPublicKeyInfo si les algorithmes du peripheriques ne sont pas utilises.

	-- 2) Un cle privee DSA au format attendu par le peripherique.

	keyInfo KeyInfo {DomainParameters, PublicKeyOperations} OPTIONAL,

	-- Parametres pour les algorithmes sur la cle.

	... -- For future extensions

	}



DSAPublicKeyChoice ::= CHOICE

	{

	raw INTEGER,

	spki SubjectPublicKeyInfo, -- See X.509. Must contain a public DSA key.

	...

	}



PublicKEAKeyAttributes ::= SEQUENCE

	{

	value ObjectValue {KEAPublicKeyChoice},

	-- Contient soit :

	-- 1) Un objet KEAPublicKey, ou SubjectPublicKeyInfo si les algorithmes du peripheriques ne sont pas utilises.

	-- 2) Un cle privee KEA au format attendu par le peripherique.

	keyInfo KeyInfo {DomainParameters, PublicKeyOperations} OPTIONAL,

	... -- For future extensions

	}



KEAPublicKeyChoice ::= CHOICE

	{

	raw INTEGER,

	spki SubjectPublicKeyInfo, -- See X.509. Must contain a public KEA key

	...

	}



SecretKeyType ::= CHOICE

-- Choix d'un type de cle secrete.


	{

	genericSecretKey SecretKeyObject {GenericSecretKeyAttributes},

	rc2key [0] SecretKeyObject {GenericSecretKeyAttributes},

	rc4key [1] SecretKeyObject {GenericSecretKeyAttributes},

	desKey [2] SecretKeyObject {GenericSecretKeyAttributes},

	des2Key [3] SecretKeyObject {GenericSecretKeyAttributes},

	des3Key [4] SecretKeyObject {GenericSecretKeyAttributes},

	castKey [5] SecretKeyObject {GenericSecretKeyAttributes},

	cast3Key [6] SecretKeyObject {GenericSecretKeyAttributes},

	cast128Key [7] SecretKeyObject {GenericSecretKeyAttributes},

	rc5Key [8] SecretKeyObject {GenericSecretKeyAttributes},

	ideaKey [9] SecretKeyObject {GenericSecretKeyAttributes},

	skipjackKey [10] SecretKeyObject {GenericSecretKeyAttributes},

	batonKey [11] SecretKeyObject {GenericSecretKeyAttributes},

	juniperKey [12] SecretKeyObject {GenericSecretKeyAttributes},

	rc6Key [13] SecretKeyObject {GenericSecretKeyAttributes},

	otherKey [14] OtherKey,

	... -- For future extensions

	}



SecretKeyObject {KeyAttributes} ::= PKCS15Object {CommonKeyAttributes, CommonSecretKeyAttributes, KeyAttributes}



OtherKey ::= SEQUENCE

	{

	keyType OBJECT IDENTIFIER,

	keyAttr SecretKeyObject {GenericSecretKeyAttributes}

	}



GenericSecretKeyAttributes ::= SEQUENCE

	{

	value ObjectValue { OCTET STRING },

	-- Au format attendu par le peripherique.

	... -- For future extensions

	}



CertificateType ::= CHOICE

-- Choix d'un type de certificat.


	{

	x509Certificate CertificateObject { X509CertificateAttributes},

	x509AttributeCertificate [0] CertificateObject {X509AttributeCertificateAttributes},

	spkiCertificate [1] CertificateObject {SPKICertificateAttributes},

	pgpCertificate [2] CertificateObject {PGPCertificateAttributes},

	wtlsCertificate [3] CertificateObject {WTLSCertificateAttributes},

	x9-68Certificate [4] CertificateObject {X9-68CertificateAttributes},

	...,

	cvCertificate [5] CertificateObject {CVCertificateAttributes}

	}



CertificateObject {CertAttributes} ::= PKCS15Object { CommonCertificateAttributes, NULL, CertAttributes}



X509CertificateAttributes ::= SEQUENCE

	{

	value ObjectValue { Certificate },

	-- Contient soit :

	-- 1) Un objet ReferencedValue contenant le certificat X.509 encode en DER.

	-- 2) Une URL pointant le certificat.

	subject Name OPTIONAL,

	-- Sujet du certificat. Cf PKCS#11.

	issuer [0] Name OPTIONAL,

	-- Emetteur du certificat. Cf PKCS#11.

	serialNumber CertificateSerialNumber OPTIONAL,

	-- Numero de serie du certificat. Cf PKCS#11.

	... -- For future extensions

	}



X509AttributeCertificateAttributes ::= SEQUENCE

	{

	value ObjectValue { AttributeCertificate },

	issuer GeneralNames OPTIONAL,

	serialNumber CertificateSerialNumber OPTIONAL,

	attrTypes [0] SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,

	... -- For future extensions

	}



SPKICertificateAttributes ::= SEQUENCE

	{

	value ObjectValue { PKCS15-OPAQUE.&Type },

	-- Contient soit :

	-- 1) Un objet ReferencedValue contenant le certificat SPKI encode en DER.

	-- 2) Une URL pointant le certificat.

	... -- For future extensions

	}



PGPCertificateAttributes ::= SEQUENCE 

	{

	value ObjectValue { PKCS15-OPAQUE.&Type },

	-- Contient soit :

	-- 1) Un objet ReferencedValue contenant le certificat PGP encode en DER.

	-- 2) Une URL pointant le certificat.

	... -- For future extensions

	}



WTLSCertificateAttributes ::= SEQUENCE

	{

	value ObjectValue { PKCS15-OPAQUE.&Type },

	-- Contient soit :

	-- 1) Un objet ReferencedValue contenant le certificat WTLS.

	-- 2) Une URL pointant le certificat.

	... -- For future extensions

	}



X9-68CertificateAttributes ::= SEQUENCE

	{

	value ObjectValue { PKCS15-OPAQUE.&Type },

	-- Contient soit :

	-- 1) Un objet ReferencedValue contenant le certificat X9-68 encode en DER ou PER.

	-- 2) Une URL pointant le certificat.

	... -- For future extensions

	}



CVCertificateAttributes ::= SEQUENCE

	{

	value ObjectValue { PKCS15-OPAQUE.&Type},

	-- Contient soit :

	-- 1) Un objet ReferencedValue contenant le certificat CV.

	-- 2) Une URL pointant le certificat.

	... -- For future extensions

	}



DataType ::= CHOICE

-- Choix d'un type de donnees.


	{

	opaqueDO DataObject {Opaque},

	externalIDO [0] DataObject {ExternalIDO},

	oidDO [1] DataObject {OidDO},

	... -- For future extensions

	}



DataObject {DataObjectAttributes} ::= PKCS15Object 

	{

	CommonDataObjectAttributes, NULL, DataObjectAttributes}

	Opaque ::= ObjectValue {PKCS15-OPAQUE.&Type}

	ExternalIDO ::= ObjectValue {PKCS15-OPAQUE.&Type

	}

(CONSTRAINED BY

	{

	-- All data objects must be defined in

	-- accordance with ISO/IEC 7816-6 --

	})



OidDO ::= SEQUENCE

	{

	id OBJECT IDENTIFIER,

	value ObjectValue {PKCS15-OPAQUE.&Type}

	}



AuthenticationType ::= CHOICE

-- Choix d'un type d'authentification.


	{

	pin AuthenticationObject { PinAttributes },

	...,

	biometricTemplate [0] AuthenticationObject {BiometricAttributes},

	authKey [1] AuthenticationObject {AuthKeyAttributes},

	external [2] AuthenticationObject {ExternalAuthObjectAttributes}

	}



AuthenticationObject {AuthObjectAttributes} ::= PKCS15Object { CommonAuthenticationObjectAttributes, NULL, AuthObjectAttributes}



PinAttributes ::= SEQUENCE

	{

	pinFlags PinFlags,

	pinType PinType,

	-- Bcd, Ascii numerique, Utf8, Half-nibble Bcd ou Iso9564-1.

	minLength INTEGER (pkcs15-lb-minPinLength..pkcs15-ub-minPinLength),

	-- Taille minimale code Pin.

	storedLength INTEGER (0..pkcs15-ub-storedPinLength),

	-- Taille du code Pin dans le peripherique.

	maxLength INTEGER OPTIONAL,

	-- Taille maximale code Pin.

	pinReference [0] Reference DEFAULT 0,

	-- Pour la commande VERIFY.

	padChar OCTET STRING (SIZE(1)) OPTIONAL,

	-- Octet de remplissage pour que le code Pin atteigne la taille storedLength.

	lastPinChange GeneralizedTime OPTIONAL,

	-- Date et heure du dernier changement du code Pin.

	path Path OPTIONAL,

	-- Chemin du fichier dans lequel le code Pin est conserve.

	... -- For future extensions

	}



PinFlags ::= BIT STRING 

	{

	case-sensitive (0),

	-- La casse est importante.

	local (1),

	-- Si local, l'authentification doit etre refaite a chaque usage.

	change-disabled (2),

	-- Si Vrai, impossible de changer le code Pin.

	unblock-disabled (3),

	-- Si Vrai, impossible de debloquer le code Pin.

	initialized (4),

	-- Si Vrai, le code Pin a ete initialise.

	needs-padding (5),

	unblockingPin (6),

	soPin (7),

	-- Si Vrai, le code Pin est en fait un Security Officer Pin. Confere Pkcs#11.

	disable-allowed (8),

	-- Si Vrai, le code Pin peut etre desactive.

	integrity-protected (9),

	-- Si Vrai, le code Pin doit etre saisi avant signature.

	confidentiality-protected (10),

	-- Si Vrai, le code Pin doit etre saisi avant cryptage.

	exchangeRefData (11)

	-- Si Vrai, pour changer le code Pin, il faut saisir l'ancien puis le nouveau. Sinon, le nouveau uniquement.

	} 

(CONSTRAINED BY

	{

	-- 'unblockingPin' and 'soPIN' cannot both be set --

	})



PinType ::= ENUMERATED {bcd, ascii-numeric, utf8, ..., half-nibble-bcd, iso9564-1}



BiometricAttributes ::= SEQUENCE

	{

	bioFlags BiometricFlags,

	templateId OBJECT IDENTIFIER,

	bioType BiometricType,

	bioReference Reference DEFAULT 0,

	lastChange GeneralizedTime OPTIONAL,

	path Path OPTIONAL,

	... -- For future extensions

	}



BiometricFlags ::= BIT STRING

	{

	local (1),

	-- Si local, l'authentification doit etre refaite a chaque usage.

	change-disabled (2),

	-- Si Vrai, impossible de changer le code Pin.

	unblock-disabled (3),

	-- Si Vrai, impossible de debloquer le code Pin.

	initialized (4),

	-- Si Vrai, le code Pin a ete initialise.

	disable-allowed (8),

	-- Si Vrai, le code Pin peut etre desactive.

	integrity-protected (9),

	-- Si Vrai, le code Pin doit etre saisi avant signature.

	confidentiality-protected (10)

	-- Si Vrai, le code Pin doit etre saisi avant cryptage.

	} 

-- Note: bits 0, 5, 6, and 7 are reserved for future use



BiometricType ::= CHOICE

	{

	fingerPrint FingerPrint,

	irisScan [0] IrisScan,

	-- Possible extensions:

	-- voiceScan VoiceScan,

	-- faceScan FaceScan,

	-- retinaScan Retinascan,

	-- handGeometry HandGeometry,

	-- writeDynamics WriteDynamics,

	-- keyStrokeDynamicsKeyStrokeDynamics,

	-- lipDynamics LipDynamics,

	... -- For future extensions

	}



FingerPrint ::= SEQUENCE

	{

	hand ENUMERATED {left, right},

	finger ENUMERATED {thumb, pointerFinger, middleFinger, ringFinger, littleFinger},

	...

	}



IrisScan ::= SEQUENCE

	{

	eye ENUMERATED {left, right},

	...

	}



ExternalAuthObjectAttributes ::= CHOICE

	{

	authKeyAttributes AuthKeyAttributes,

	certBasedAttributes [0] CertBasedAuthenticationAttributes,

	... -- For future extensions

	}



AuthKeyAttributes ::= SEQUENCE

	{

	derivedKey BOOLEAN DEFAULT TRUE,

	-- Si Vrai, il s'agit d'une cle derivee, d'une cle de goupe ou une cle maitresse.

	authKeyId Identifier,

	-- Identifiant de la cle.

	... -- For future extensions

	}



CertBasedAuthenticationAttributes ::= SEQUENCE

	{

	cha OCTET STRING,

	...

	}



TokenInfo ::= SEQUENCE

-- Information generation sur l'application.


	{

	version INTEGER {v1(0)} (v1,...),

	-- Toujours 0.

	serialNumber OCTET STRING,

	-- Numero de serie du peripherique.

	manufacturerID Label OPTIONAL,

	-- Identifiant du fabriquant du peripherique.

	label [0] Label OPTIONAL,

	-- Libelle de l'application.

	tokenflags TokenFlags,

	-- Propriete de l'application : lecture seule, authentification, generation de nombre aleatoire, etc.

	seInfo SEQUENCE OF SecurityEnvironmentInfo OPTIONAL,

	recordInfo [1] RecordInfo OPTIONAL,

	-- Propriete du système de fichiers : fichiers lineaires ou non, taille fixe de la place allouee pour chaque fichier, etc.

	supportedAlgorithms[2] SEQUENCE OF AlgorithmInfo OPTIONAL,

	-- Algorithme supporte par le peripherique.

	...,

	issuerId [3] Label OPTIONAL,

	-- Identifiant du producteur du peripherique.

	holderId [4] Label OPTIONAL,

	-- Identifiant du proprietaire du peripherique.

	lastUpdate [5] LastUpdate OPTIONAL,

	-- Date de derniere mise a jour des informations de l'application.

	preferredLanguage PrintableString OPTIONAL -- In accordance with IETF RFC 1766

	-- Langue de l'utilisateur.

	}

(CONSTRAINED BY

	{

	-- Each AlgorithmInfo.reference value must be unique --

	})



TokenFlags ::= BIT STRING

	{

	readonly (0),

	loginRequired (1),

	prnGeneration (2),

	eidCompliant (3)

	}



SecurityEnvironmentInfo ::= SEQUENCE 

	{

	se INTEGER (0..pkcs15-ub-seInfo),

	owner OBJECT IDENTIFIER,

	... -- For future extensions

	}



RecordInfo ::= SEQUENCE

	{

	oDFRecordLength [0] INTEGER (0..pkcs15-ub-recordLength) OPTIONAL,

	prKDFRecordLength [1] INTEGER (0..pkcs15-ub-recordLength) OPTIONAL,

	puKDFRecordLength [2] INTEGER (0..pkcs15-ub-recordLength) OPTIONAL,

	sKDFRecordLength [3] INTEGER (0..pkcs15-ub-recordLength) OPTIONAL,

	cDFRecordLength [4] INTEGER (0..pkcs15-ub-recordLength) OPTIONAL,

	dODFRecordLength [5] INTEGER (0..pkcs15-ub-recordLength) OPTIONAL,

	aODFRecordLength [6] INTEGER (0..pkcs15-ub-recordLength) OPTIONAL

	}



AlgorithmInfo ::= SEQUENCE

	{

	reference Reference,

	algorithm PKCS15-ALGORITHM.&id({AlgorithmSet}),

	parameters PKCS15-ALGORITHM.&Parameters({AlgorithmSet}{@algorithm}),

	supportedOperations PKCS15-ALGORITHM.&Operations({AlgorithmSet}{@algorithm}),

	algId PKCS15-ALGORITHM.&objectIdentifier({AlgorithmSet}{@algorithm}) OPTIONAL,

	algRef Reference OPTIONAL

	}



PKCS15-ALGORITHM ::= CLASS

	{

	&id INTEGER UNIQUE,

	&Parameters,

	&Operations Operations,

	&objectIdentifier OBJECT IDENTIFIER OPTIONAL

	} 

WITH SYNTAX

	{

	PARAMETERS &Parameters OPERATIONS &Operations ID &id [OID &objectIdentifier]

	}



PKCS15-OPAQUE ::= TYPE-IDENTIFIER

PublicKeyOperations ::= Operations

Operations ::= BIT STRING

	{

	compute-checksum (0), -- H/W computation of checksum

	compute-signature (1), -- H/W computation of signature

	verify-checksum (2), -- H/W verification of checksum

	verify-signature (3), -- H/W verification of signature

	encipher (4), -- H/W encryption of data

	decipher (5), -- H/W decryption of data

	hash (6), -- H/W hashing

	generate-key (7) -- H/W key generation

	}



pkcs15-alg-null PKCS15-ALGORITHM ::= {PARAMETERS NULL OPERATIONS {{generate-key}} ID -1}



AlgorithmSet PKCS15-ALGORITHM ::= 

	{

	pkcs15-alg-null,

	... -- See PKCS #11 for values for the &id field (and parameters)

	}



LastUpdate ::= CHOICE

	{

	generalizedTime GeneralizedTime,

	referencedTime ReferencedValue {GeneralizedTime},
	
	...

	}



-- Soft token related types and objects

EnvelopedData {Type} ::= SEQUENCE

-- Pour un emulateur logiciel de peripherique.


	{

	version INTEGER{v0(0),v1(1),v2(2),v3(3),v4(4)}(v0|v1|v2,...),

	-- Toujours 0.

	originatorInfo [0] OriginatorInfo OPTIONAL,

	recipientInfos RecipientInfos,

	encryptedContentInfo EncryptedContentInfo{Type},

	unprotectedAttrs [1] SET SIZE (1..MAX) OF Attribute OPTIONAL

	}



EncryptedContentInfo {Type} ::= SEQUENCE

	{

	contentType OBJECT IDENTIFIER,

	-- Doit etre id-data.

	contentEncryptionAlgorithm AlgorithmIdentifier{{ContentEncryptionAlgorithms}},

	encryptedContent [0] OCTET STRING OPTIONAL

	}

(CONSTRAINED BY 

	{

	-- 'encryptedContent' shall be the result of encrypting DER-encoded

	-- value of type -- Type


})



PKCS15Token ::= SEQUENCE

	{

	version INTEGER {v1(0)} (v1,...),

	keyManagementInfo [0] KeyManagementInfo OPTIONAL,

	pkcs15Objects SEQUENCE OF PKCS15Objects

	}



KeyManagementInfo ::= SEQUENCE OF SEQUENCE

	{

	keyId Identifier,

	keyInfo CHOICE
	
		{

		recipientInfo RecipientInfo,

		passwordInfo [0] PasswordInfo

		}
	
	} 

(CONSTRAINED BY 

	{

	-- Each keyID must be unique --
	})



PasswordInfo ::= SEQUENCE

	{

	hint Label OPTIONAL,

	algId AlgorithmIdentifier {{KeyDerivationAlgorithms}},

	...

	}

(CONSTRAINED BY

	{

	--keyID shall point to a KEKRecipientInfo--
	})



KeyDerivationAlgorithms ALGORITHM-IDENTIFIER ::= 

	{

	PBKDF2Algorithms,

	... -- For future extensions

	}



KeyEncryptionAlgorithms ALGORITHM-IDENTIFIER ::= 

	{

	{NULL IDENTIFIED BY id-alg-CMS3DESwrap}

	| {INTEGER IDENTIFIED BY id-alg-CMSRC2wrap},

	... -- For future extensions

	}



ContentEncryptionAlgorithms ALGORITHM-IDENTIFIER ::= 
	{

	SupportingAlgorithms EXCEPT {NULL IDENTIFIED BY id-hmacWithSHA1},

	-- SupportingAlgorithms are defined in PKCS #5 v2

	... -- For future extensions

	}



MACAlgorithms ALGORITHM-IDENTIFIER ::= 
	{

	{NULL IDENTIFIED BY hMAC-SHA1},

	... -- For future extensions

	}



DigestAlgorithms ALGORITHM-IDENTIFIER ::= 
	{

	{NULL IDENTIFIED BY sha-1},

	... -- For future extensions

	}



-- Misc

DDO ::= SEQUENCE

Discretionary ASN.1 Data Objects (DDO) i.e. repertoire des fichiers normalises.


	{

	oid OBJECT IDENTIFIER,

	-- Identifiant unique de l'objet.

	odfPath Path OPTIONAL,

	-- EF(ODF) i.e. contenant EF(PrKDF), EF(PuKDF), EF(SKDF), EF(CDF), EF(DODF) et AODF).

	tokenInfoPath [0] Path OPTIONAL,

	-- EF(TokenInfo) i.e. nom de fichier complet decrivant les caracteristiques du peripherique.

	unusedPath [1] Path OPTIONAL,

	-- EF(UnusedSpace) i.e espace disponible sur la carte.

	... -- For future extensions

	}



DIRRecord ::= [APPLICATION 1] SEQUENCE
-- Entree d'un repertoire.


	{

	aid [APPLICATION 15] OCTET STRING,

	-- Identifiant unique de l'application sur 12 octets : RID||FIX=A0 00 00 00 63 50 4B 43 53 2D 31 35.

	label [APPLICATION 16] UTF8String OPTIONAL,

	-- Libelle de l'application choisi par l'emetteur de la carte.

	path [APPLICATION 17] OCTET STRING,

	-- Chemin du repertoire.

	ddo [APPLICATION 19] DDO OPTIONAL

	-- Description de l'objet pointe.

	}



UnusedSpace ::= SEQUENCE

	{

	path Path (WITH COMPONENTS 
	
		{

		..., index PRESENT, length PRESENT

		}
	
	),

	authId Identifier OPTIONAL,

	-- Fichier protege en ecriture.

	...,

	accessControlRules SEQUENCE OF AccessControlRule OPTIONAL

	-- Regles d'acces au fichier.

	}



END