Spécifications techniques Moteur PKCS#11 pour OpenSSL Pour

Transcription

:
GR
ER
ET
PU B
L IC
Référence
OpenSSL - Moteur PKCS11 pour CPS_V1.2.doc
OU
T
’IN
PEM EN T D
Spécifications techniques
Moteur PKCS#11 pour OpenSSL
Pour cartes CPS
17 Janvier 2008
Version 1.2
Document d’information
GIP-CPS
OpenSSL/PKCS#11 pour CPS
Version 1.2
SOMMAIRE
1.
INTRODUCTION......................................................................................................... 4
1.1.
RAPPEL ............................................................................................................................................................ 4
1.2.
BUT .................................................................................................................................................................. 4
1.3.
PREREQUIS ...................................................................................................................................................... 4
2.
TECHNIQUE ............................................................................................................... 5
2.1.
GENERALITES.................................................................................................................................................. 5
2.2.
MOTEUR PKCS#11............................................................................................................................................ 5
2.3.
2.2.1.
Récupération et installation du moteur PKCS#11.................................................................................. 5
2.2.2.
Chargement du moteur ........................................................................................................................... 6
UTILISATION DU MOTEUR PKCS#11 ................................................................................................................ 8
2.3.1.
Généralités.............................................................................................................................................. 8
2.3.2.
Commandes............................................................................................................................................ 8
2.3.3.
Exemples de commandes ....................................................................................................................... 8
2.4.
RESTRICTIONS D’USAGE – LIMITES ................................................................................................................ 9
2.5.
UTILISATION DU MOTEUR PKCS#11 A PARTIR D’UN FICHIER DE CONFIGURATION ................................... 11
2.6.
OPENSSL COMME BIBLIOTHEQUE ............................................................................................................... 11
2.6.1.
généralités ............................................................................................................................................ 11
2.6.2.
Exemples de code................................................................................................................................. 12
2.6.3.
Liste des commandes ........................................................................................................................... 15
17 Janvier 2008
Documentation GIP-CPS
© GIP-CPS : Ce document est la propriété du Groupement d'intérêt Public CPS.
Il ne peut être reproduit sans autorisation écrite.
Page 2 / 17
GIP-CPS
Version 1.2
Suivi des Modifications
Version
1.0
1.1
Date
09/03/2007
14/03/2007
Auteur
Frédéric BARAN
Frédéric BARAN
1.2
17/01/2008
Frédéric BARAN
17 Janvier 2008
Description
Version initiale
Corrections – ajout exemples de
codes pour appli en C.
Correction des restrictions d’usage
Page 3 / 17
GIP-CPS
Version 1.2
1. INTRODUCTION
1.1.
RAPPEL
OpenSSL est un ensemble de librairies permettant de réaliser des opérations cryptographiques de
manière logicielle avec divers algorithmes (blowfish, DES ou Triple DES, DSA, RC4, RC5,
RSA,…).
Des plug-in appelés moteurs peuvent être ajoutés à OpenSSL, pour permettre de réaliser des
opérations cryptographiques externes depuis un hardware.
Plus précisément, nous nous intéresserons dans ce document à un moteur PKCS#11 appelé
engine_PKCS11, permettant d’accéder à un matériel cryptographique tel qu’une carte CPS, par
l’intermédiaire d’un module PKCS#11 (du GIP-CPS).
1.2.
BUT
Le but de ce document est d’expliquer comment utiliser OpenSSL avec un moteur hardware
PKCS#11 pour accéder et utiliser la carte CPS pour des opérations cryptographiques.
OpenSSL faisant dans ce cas, office de surcouche du PKCS#11 (du GIP-CPS) pour l’accès aux
données CPS avec des fonctions de plus haut niveau.
1.3.
-
PREREQUIS
Un système d’exploitation Microsoft Windows ou Linux (versions utilisées pour les tests :
Windows 2000 Professionnel et Linux Fedora Core 4)
Les cryptoLib (librairies PKCS#11 du GIP-CPS) devront être installées.
Un version récente d’OpenSSL devra être installée (version courante 0.9.8e)
17 Janvier 2008
Page 4 / 17
GIP-CPS
Version 1.2
2. TECHNIQUE
2.1.
GENERALITES
OpenSSL peut s’utiliser de 3 manières différentes :
- Par ligne de commandes,
- Comme bibliothèque (API) pour langage C,
- Par intégration à d’autres langages (PHP, perl)
Dans ce document, nous nous intéresserons à l’utilisation d’OpenSSL en ligne de commandes ainsi
que sous forme de bibliothèques utilisées dans une application C, et sous les environnements
Windows et Linux.
L’utilisation de d’OpenSSL en tant que bibliothèque est plus complète que sous ligne de
commandes. Néanmoins, nous détaillerons l’utilisation par ligne de commandes, car son utilisation
est plus souple et plus simple d’utilisation.
L’intérêt du moteur PKCS#11 d’OpenSSL pour la carte CPS, est :
- Utilisation de la clé de signature de la carte pour signer des fichiers.
- Utilisation de la clé d’authentification de la carte pour s’authentifier auprès d’un serveur
sécurisé. (par exemple SSL)
2.2.
MOTEUR PKCS#11
Le module PKCS#11 du GIP-CPS se trouve sous la forme d’une DLL (Dynamic Link Librairie)
sous environnement Microsoft Windows : cps_pkcs11_w32.dll et se trouve dans le répertoire de
Windows (« c:/winnt » sous windows 2000)
Cette bibliothèque fait partie de l’ensemble appelée Cryptolib et est installée lors de l’installation de
ce package.
Sous environnement Unix (Linux) : le module se trouve sous forme d’un SO (Shared Object)
nommé libcps_pkcs11_lux.so et se trouve dans /usr/local/galss.
Il est installé à partir du package Cryptolib pour Linux.
2.2.1. Récupération et installation du moteur PKCS#11
Comme nous l’avons déjà dit, pour faire le lien entre le module PKSC11 de la CPS et OpenSSL, il
est nécessaire de se procurer un module appelé engine_pkcs11.
Dans les deux environnements, il peut être récupéré sur le site : http://www.opensc-project.org.
OpenSC est un projet Open Source autour des cartes à puce. Dans cette optique, il a été développé
17 Janvier 2008
Page 5 / 17
GIP-CPS
Version 1.2
en autres, le moteur PKCS#11 pour interconnecter OpenSSL avec un module PKCS#11.
Pour windows : le Smart Card Bundle doit être téléchargé et installé. (adresse : http://www.openscproject.org/files/scb/)
Ce package installe différents modules comme OpenSC, OpenSSL, putty, ainsi que engine_pkcs11.
Ainsi que des librairies comme libp11.dll et libltdl3.dll, nécessaires au fonctionnement de
engine_pkcs11.
Pour Linux : Le moteur est directement téléchargeable depuis cette adresse : http://www.openscproject.org/files/engine_pkcs11/
Pour installer le moteur, il faudra avoir auparavant avoir installé la bibliothèque libp11
(http://www.opensc-project.org/files/libp11/)
2.2.2. Chargement du moteur
Une fois le moteur installé, il suffira de la charger en mémoire, en lui attribuant un identifiant.
Cet identifiant servira à appeler par le suite ce moteur à partir d’autres commandes OpenSSL.
Par ligne de commandes, il suffit de lancer le shell openssl :
(Windows)
OpenSSL> engine -t dynamic -pre SO_PATH:c:/winnt/engine_pkcs11.dll -pre ID:pkcs11 -pre LIST_ADD:1 -pre
LOAD -pre MODULE_PATH:c:/winnt/cps_pkcs11_w32.dll
(Linux)
OpenSSL> engine -t dynamic -pre SO_PATH:/usr/lib/engines/engine_pkcs11.so -pre ID:pkcs11 -pre LIST_ADD:1 pre LOAD -pre MODULE_PATH:/usr/local/galss/libcps_pkcs11_lux.so
Options utilisées :
SO_PATH : défini le chemin d’accès au moteur PKCS#11
MODULE_PATH : défini le chemin d’accès au module PKCS#11
ID : défini l’identifiant du module PKCS#11 chargé en mémoire (doit être « PKCS11 »)
LOAD : commande de chargement du module en mémoire.
-pre : liste des commandes à exécuter avant le chargement du module.
dynamic : chargement du module ne mémoire de manière partagée.
Si tout se passe bien, le résultat devra être :
(dynamic) Dynamic engine loading support
[Success]: SO_PATH:c:/winnt/engine_pkcs11.dll
[Success]: ID:pkcs11
[Success]: LIST_ADD:1
[Success]: LOAD
[Success]: MODULE_PATH:c:/winnt/cps_pkcs11_w32.dll
Loaded: (pkcs11) pkcs11 engine
17 Janvier 2008
Page 6 / 17
GIP-CPS
Version 1.2
[ available ]
Ainsi suite a cela, le module PKCS#11 est chargé en mémoire, et prêt à être utilisé par OpenSSL.
17 Janvier 2008
Page 7 / 17
GIP-CPS
Version 1.2
2.3.
UTILISATION DU MOTEUR PKCS#11
2.3.1. Généralités
L’utilisation du moteur PKCS#11 par une commande OpenSSL se fait toujours de la même
manière.
L’appel du module se fait à partir de certaines options de la commande :
-engine ID : indique le moteur à utiliser pour les fonctions cryptographiques de la commande.
(ID=identifiant du module PKCS#11 chargé, dans notre cas PKCS#11)
-keyform engine : indique la forme de la clé privée à utiliser (dans notre cas : engine indique que
la clé se trouve sur la carte CPS depuis le module PKCS#11)
-key ID : indique ou aller chercher la clé : dans le cas d’une carte CPS, ID sera soit 01000000 pour
la clé de signature, 0400000 pour la clé d’authentification. (Le port utilisé peut être ajouté devant
l’ID : par exemple : -key 0:04000000. Dans notre cas, il est 0. Le port par défaut étant 0, il est
facultatif)
-inkey ID : pour certaines commandes –in sera remplacé par –inkey. L’utilisation est identique.
2.3.2. Commandes
Voici une liste de fonctions pouvant utiliser un moteur pkcs#11 en argument, pour les fonctions
cryptographiques :
-
req : Création de demande de certificats (ou de certificats auto signés).
smime : Gestion des smimes : signature/encryptage/décryptage de mails.
x509 : Gestion de certificats : lecture/conversion/signature.
dgst : Fonctions de hachage : création de condensé/signature/vérification signature.
rsautl : utilitaire RSA : signature de messages, encryptage/décryptage.
enc : utilitaire d’encryptage.
s_client : Fonctions SSL/TLS clientes : connection à un serveur SSL,…
s_server : Fonctions SSL/TLS serveurs : Création de serveur de test SSL,…
PKCS7 : Gestion de PKCS#7 : Conversions.
rand : génération de nombre pseudo aléatoire.
speed : test de performances. (des algorithmes de cryptographies)
2.3.3. Exemples de commandes
Génération d’un certificat auto-signé (pour test), avec le certificat de la carte CPS
OpenSSL> req -config c:/openssl.conf -engine pkcs11 -new -key 01000000 -keyform engine -out req.pem -text -x509 subj "/CN=TEST"
Signature d’un mail, avec une carte CPS.
OpenSSL> smime -sign -engine pkcs11 -signer C:/res.pem -in c:/requete_00007_tosign.txt -keyform engine -inkey
17 Janvier 2008
Page 8 / 17
GIP-CPS
Version 1.2
01000000 -text
Par défaut : signature au format PKCS7 v1.5 (RFC2315) : Hashage + padding + signature.
Pour une signature au format CMS (RFC2630), utiliser l’option « -nodetach » qui formatera avec
une structure SignedData.
Génération d’un nombre pseudo-aléatoire, à partir de la carte CPS :
OpenSSL> rand -engine pkcs11 10
Connection à un serveur sécurisé avec SSL :
OpenSSL> s_client -connect testssl.gip-cps.fr:443 -engine pkcs11 -state -showcerts -keyform engine -key 0:04000000 CAfile c:\ca-bundle.cer -cert c:/auth.pem -certform PEM -ssl3 -debug
- 443 étant le port SSL
- auth.pem étant le certificat d’authentification présent sur la carte et correspondant à la clé privée
0 :04000000 (ce certificat devra préalablement être extrait et converti en PEM)
- connect testssl.gip-cps.fr:443 étant le site distant sécurisé en SSL
Hachage d’un fichier + signature :
OpenSSL> dgst -sign 01000000 -engine pkcs11 -out c:/toto.txt -keyform engine –hex c:/requete_00007.txt
Test de performances de l’algorithme de hachage :
OpeSSL> speed -engine pkcs11 sha1
Signature d’une demande de certificat :
OpenSSL> x509 -engine pkcs11 -req -in c:/requete_tosign.txt -keyform engine -out c:/toto.txt -signkey 01000000
2.4.
RESTRICTIONS D’USAGE – LIMITES
Les fonctions d’OpenSSL associé à un moteur PKCS#11 ne peuvent pas réaliser certaines
opérations utiles dans le cadre de la gestion de la carte CPS et de ses certificats.
-
Récupération d’un certificat directement sur une carte CPS : pour certaines fonctions
d’OpenSSL (s_client, smime), le certificat correspondant à une clé privée de la carte
CPS doit être donné en paramètre. Mais seul un fichier correspondant au certificat peut
être donné. OpenSSL ne peut pas passer par le module PKCS#11 pour aller chercher ce
certificat. Aucune fonction d’extraction de certificat n’est disponible avec le moteur
PKCS#11. Ce certificat devra préalablement être extrait de la carte (par une fonction
PKCS#11 par exemple, ou bien d’autres outils, tel que pkcs11tool de OpenSC)
-
Constatation du blocage du port de la carte après une utilisation du module PKCS#11 en
ligne de commandes. Impossibilité de décharger le module en mémoire. Fermeture de la
17 Janvier 2008
Page 9 / 17
GIP-CPS
Version 1.2
session OpenSSL obligatoire, puis relance (fermeture de la fenêtre DOS). Le problème
peut être résolu en utilisant OpenSSL en tant que librairie dans du code C par exemple,
où là, des fonctions de libération du moteur PKCS#11 existent. (Engine_free() par
exemple)
17 Janvier 2008
Page 10 / 17
GIP-CPS
Version 1.2
2.5.
UTILISATION DU MOTEUR PKCS#11 A PARTIR D’UN FICHIER DE CONFIGURATION
De cette manière, il n’est pas nécessaire de charger préalablement le moteur en mémoire.
Par exemple : Création d’un certificat auto signé :
OpenSSL> req –config /usr/local/openssl.conf -engine pkcs11 -new -key 01000000 -keyform engine -out
req.pem -text -x509 -subj "/CN=TEST"
Avec le fichier openssl.conf suivant :
openssl_conf
= openssl_def
[openssl_def]
engines = engine_section
[engine_section]
pkcs11 = pkcs11_section
[pkcs11_section]
engine_id = pkcs11
dynamic_path = /usr/lib/engines/engine_pkcs11.so
MODULE_PATH = /usr/local/galss/libcps_pkcs11_lux.so
init = 0
[req]
distinguished_name = req_distinguished_name
[req_distinguished_name]
2.6.
OPENSSL COMME BIBLIOTHEQUE
2.6.1. généralités
L’API OpenSSL est disponible pour une application en C.
La bibliothèque de l’engine d’openSSL s’inclut dans le code de cette façon :
#include <openssl/engine.h>
17 Janvier 2008
Page 11 / 17
GIP-CPS
Version 1.2
2.6.2. Exemples de code
Voici un exemple de fonction permettant le chargement du module PKCS#11 :
static int tls_engine_load_dynamic_pkcs11(const char *pkcs11_so_path,
const char *pkcs11_module_path)
{
char *engine_id = "pkcs11";
const char *pre_cmd[] = {
"SO_PATH", pkcs11_so_path,
"ID", engine_id,
"LIST_ADD", "1",
/* "NO_VCHECK", "1", */
"LOAD", NULL,
NULL, NULL
};
const char *post_cmd[] = {
"MODULE_PATH", pkcs11_module_path,
NULL, NULL
};
if (!pkcs11_so_path || !pkcs11_module_path)
return 0;
wpa_printf(MSG_DEBUG, "ENGINE: Loading pkcs11 Engine from %s",
pkcs11_so_path);
return tls_engine_load_dynamic_generic(pre_cmd, post_cmd, engine_id);
}
Exemple d’une fonction générique et permettant de charger n’importe quel moteur OpenSSL :
static int tls_engine_load_dynamic_generic(const char *pre[],
const char *post[], const char *id)
{
ENGINE *engine;
const char *dynamic_id = "dynamic";
engine = ENGINE_by_id(id);
if (engine) {
ENGINE_free(engine);
wpa_printf(MSG_DEBUG, "ENGINE: engine '%s' is already "
"available", id);
return 0;
}
ERR_clear_error();
engine = ENGINE_by_id(dynamic_id);
if (engine == NULL) {
wpa_printf(MSG_INFO, "ENGINE: Can't find engine %s [%s]",
dynamic_id,
17 Janvier 2008
Page 12 / 17
GIP-CPS
Version 1.2
ERR_error_string(ERR_get_error(), NULL));
return -1;
}
/* Perform the pre commands. This will load the engine. */
while (pre && pre[0]) {
wpa_printf(MSG_DEBUG, "ENGINE: '%s' '%s'", pre[0], pre[1]);
if (ENGINE_ctrl_cmd_string(engine, pre[0], pre[1], 0) == 0) {
wpa_printf(MSG_INFO, "ENGINE: ctrl cmd_string failed: "
"%s %s [%s]", pre[0], pre[1],
return -1;
}
pre += 2;
}
/*
* Free the reference to the "dynamic" engine. The loaded engine can
* now be looked up using ENGINE_by_id().
*/
engine = ENGINE_by_id(id);
if (engine == NULL) {
wpa_printf(MSG_INFO, "ENGINE: Can't find engine %s [%s]",
id, ERR_error_string(ERR_get_error(), NULL));
return -1;
}
while (post && post[0]) {
wpa_printf(MSG_DEBUG, "ENGINE: '%s' '%s'", post[0], post[1]);
if (ENGINE_ctrl_cmd_string(engine, post[0], post[1], 0) == 0) {
wpa_printf(MSG_DEBUG, "ENGINE: ctrl cmd_string failed:"
" %s %s [%s]", post[0], post[1],
ENGINE_remove(engine);
return -1;
}
post += 2;
}
return 0;
}
Exemple de fonction permettant une récupération d’une la clé publique de la carte CPS à partir de
OpenSSL/PKCS#11 :
17 Janvier 2008
Page 13 / 17
GIP-CPS
Version 1.2
static int tls_engine_init(struct tls_connection *conn, const char *engine_id,
const char *pin, const char *key_id)
{
#ifndef OPENSSL_NO_ENGINE
int ret = -1;
if (engine_id == NULL) {
wpa_printf(MSG_ERROR, "ENGINE: Engine ID not set");
return -1;
}
if (pin == NULL) {
wpa_printf(MSG_ERROR, "ENGINE: Smartcard PIN not set");
return -1;
}
if (key_id == NULL) {
wpa_printf(MSG_ERROR, "ENGINE: Key Id not set");
return -1;
}
ERR_clear_error();
conn->engine = ENGINE_by_id(engine_id);
if (!conn->engine) {
wpa_printf(MSG_ERROR, "ENGINE: engine %s not available [%s]",
engine_id, ERR_error_string(ERR_get_error(), NULL));
goto err;
}
if (ENGINE_init(conn->engine) != 1) {
wpa_printf(MSG_ERROR, "ENGINE: engine init failed "
"(engine: %s) [%s]", engine_id,
goto err;
}
wpa_printf(MSG_DEBUG, "ENGINE: engine initialized");
if (ENGINE_ctrl_cmd_string(conn->engine, "PIN", pin, 0) == 0) {
wpa_printf(MSG_ERROR, "ENGINE: cannot set pin [%s]",
goto err;
}
conn->public_key = ENGINE_load_public_key (conn->engine,
key_id, NULL, NULL);
if (!conn->public_key) {
wpa_printf(MSG_ERROR, "ENGINE: cannot load public key with id"
" '%s' [%s]", key_id,
ret = TLS_SET_PARAMS_ENGINE_INIT_FAILED;
goto err;
}
return 0;
err:
if (conn->engine) {
ENGINE_free(conn->engine);
17 Janvier 2008
Page 14 / 17
GIP-CPS
Version 1.2
conn->engine = NULL;
}
if (conn->public_key) {
EVP_PKEY_free(conn->public_key);
conn->public_key = NULL;
}
return ret;
#else /* OPENSSL_NO_ENGINE */
return 0;
#endif /* OPENSSL_NO_ENGINE */
}
2.6.3. Liste des commandes
Voici une liste exhaustive des fonctions disponibles pour l’engine d’OpenSSL :
ENGINE *ENGINE_get_first(void);
ENGINE *ENGINE_get_last(void);
ENGINE *ENGINE_get_next(ENGINE *e);
ENGINE *ENGINE_get_prev(ENGINE *e);
int ENGINE_add(ENGINE *e);
int ENGINE_remove(ENGINE *e);
ENGINE *ENGINE_by_id(const char *id);
int ENGINE_init(ENGINE *e);
int ENGINE_finish(ENGINE *e);
void ENGINE_load_openssl(void);
void ENGINE_load_dynamic(void);
#ifndef OPENSSL_NO_STATIC_ENGINE
void ENGINE_load_4758cca(void);
void ENGINE_load_aep(void);
void ENGINE_load_atalla(void);
void ENGINE_load_chil(void);
void ENGINE_load_cswift(void);
void ENGINE_load_gmp(void);
void ENGINE_load_nuron(void);
void ENGINE_load_sureware(void);
void ENGINE_load_ubsec(void);
#endif
void ENGINE_load_cryptodev(void);
void ENGINE_load_builtin_engines(void);
void ENGINE_cleanup(void);
ENGINE *ENGINE_get_default_RSA(void);
ENGINE *ENGINE_get_default_DSA(void);
ENGINE *ENGINE_get_default_ECDH(void);
ENGINE *ENGINE_get_default_ECDSA(void);
ENGINE *ENGINE_get_default_DH(void);
ENGINE *ENGINE_get_default_RAND(void);
ENGINE *ENGINE_get_cipher_engine(int nid);
ENGINE *ENGINE_get_digest_engine(int nid);
int ENGINE_set_default_RSA(ENGINE *e);
int ENGINE_set_default_DSA(ENGINE *e);
17 Janvier 2008
Page 15 / 17
GIP-CPS
Version 1.2
int ENGINE_set_default_ECDH(ENGINE *e);
int ENGINE_set_default_ECDSA(ENGINE *e);
int ENGINE_set_default_DH(ENGINE *e);
int ENGINE_set_default_RAND(ENGINE *e);
int ENGINE_set_default_ciphers(ENGINE *e);
int ENGINE_set_default_digests(ENGINE *e);
int ENGINE_set_default_string(ENGINE *e, const char *list);
int ENGINE_set_default(ENGINE *e, unsigned int flags);
unsigned int ENGINE_get_table_flags(void);
void ENGINE_set_table_flags(unsigned int flags);
int ENGINE_register_RSA(ENGINE *e);
void ENGINE_unregister_RSA(ENGINE *e);
void ENGINE_register_all_RSA(void);
int ENGINE_register_DSA(ENGINE *e);
void ENGINE_unregister_DSA(ENGINE *e);
void ENGINE_register_all_DSA(void);
int ENGINE_register_ECDH(ENGINE *e);
void ENGINE_unregister_ECDH(ENGINE *e);
void ENGINE_register_all_ECDH(void);
int ENGINE_register_ECDSA(ENGINE *e);
void ENGINE_unregister_ECDSA(ENGINE *e);
void ENGINE_register_all_ECDSA(void);
int ENGINE_register_DH(ENGINE *e);
void ENGINE_unregister_DH(ENGINE *e);
void ENGINE_register_all_DH(void);
int ENGINE_register_RAND(ENGINE *e);
void ENGINE_unregister_RAND(ENGINE *e);
void ENGINE_register_all_RAND(void);
int ENGINE_register_STORE(ENGINE *e);
void ENGINE_unregister_STORE(ENGINE *e);
void ENGINE_register_all_STORE(void);
int ENGINE_register_ciphers(ENGINE *e);
void ENGINE_unregister_ciphers(ENGINE *e);
void ENGINE_register_all_ciphers(void);
int ENGINE_register_digests(ENGINE *e);
void ENGINE_unregister_digests(ENGINE *e);
void ENGINE_register_all_digests(void);
int ENGINE_register_complete(ENGINE *e);
int ENGINE_register_all_complete(void);
int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void));
int ENGINE_cmd_is_executable(ENGINE *e, int cmd);
int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name,
long i, void *p, void (*f)(void), int cmd_optional);
int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg,
int cmd_optional);
int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg);
void *ENGINE_get_ex_data(const ENGINE *e, int idx);
int ENGINE_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
ENGINE *ENGINE_new(void);
int ENGINE_free(ENGINE *e);
int ENGINE_up_ref(ENGINE *e);
int ENGINE_set_id(ENGINE *e, const char *id);
int ENGINE_set_name(ENGINE *e, const char *name);
17 Janvier 2008
Page 16 / 17
GIP-CPS
Version 1.2
int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth);
int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth);
int ENGINE_set_ECDH(ENGINE *e, const ECDH_METHOD *dh_meth);
int ENGINE_set_ECDSA(ENGINE *e, const ECDSA_METHOD *dh_meth);
int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth);
int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth);
int ENGINE_set_STORE(ENGINE *e, const STORE_METHOD *rand_meth);
int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f);
int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f);
int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f);
int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f);
int ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f);
int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f);
int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f);
int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f);
int ENGINE_set_flags(ENGINE *e, int flags);
int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns);
const char *ENGINE_get_id(const ENGINE *e);
const char *ENGINE_get_name(const ENGINE *e);
const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e);
const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e);
const ECDH_METHOD *ENGINE_get_ECDH(const ENGINE *e);
const ECDSA_METHOD *ENGINE_get_ECDSA(const ENGINE *e);
const DH_METHOD *ENGINE_get_DH(const ENGINE *e);
const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e);
const STORE_METHOD *ENGINE_get_STORE(const ENGINE *e);
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e);
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e);
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e);
ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e);
ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e);
ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e);
ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e);
ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e);
const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid);
const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid);
int ENGINE_get_flags(const ENGINE *e);
const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e);
EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
UI_METHOD *ui_method, void *callback_data);
EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
UI_METHOD *ui_method, void *callback_data);
void ENGINE_add_conf_module(void);
17 Janvier 2008
Page 17 / 17

Spécifications techniques Moteur PKCS#11 pour OpenSSL Pour

Transcription

Documents pareils

Forum: Moteur de jeu GameBlender et alternatives

Nous pouvons vous aider à garder le témoin Check Engine éteint et

SEM I SEO

Ginion Group 348 TS EUR 79.000

Moteur propre

Fiche demande intervention moteur 208T16

joker 23 clubman - Euro

poseidon 570 king fisher

grand soleil 43 : couleur soleil

CAO / DAO / 3D