Fonction CertOpenStore (wincrypt.h)
La fonction CertOpenStore ouvre un magasin de certificats à l’aide d’un type de fournisseur de magasin spécifié. Bien que cette fonction puisse ouvrir un magasin de certificats à la plupart des fins, CertOpenSystemStore est recommandé d’ouvrir les magasins de certificats les plus courants. CertOpenStore est requis pour les options plus complexes et les cas spéciaux.
Syntaxe
HCERTSTORE CertOpenStore(
[in] LPCSTR lpszStoreProvider,
[in] DWORD dwEncodingType,
[in] HCRYPTPROV_LEGACY hCryptProv,
[in] DWORD dwFlags,
[in] const void *pvPara
);
Paramètres
[in] lpszStoreProvider
Pointeur vers une chaîne ANSI terminée par null qui contient le type de fournisseur de magasin.
Les valeurs suivantes représentent les types de magasin prédéfinis. Le type de fournisseur de magasin détermine le contenu du paramètre pvPara ainsi que l’utilisation et la signification du mot élevé du paramètre dwFlags . Des fournisseurs de magasins supplémentaires peuvent être installés ou inscrits à l’aide de la fonction CryptInstallOIDFunctionAddress ou CryptRegisterOIDFunction . Pour plus d’informations sur l’ajout de fournisseurs de magasins, consultez Extension de la fonctionnalité CertOpenStore.
| Valeur | Signification |
|---|---|
|
Ouvre un magasin qui sera une collection d’autres magasins. Les magasins sont ajoutés ou supprimés de la collection à l’aide de CertAddStoreToCollection et de CertRemoveStoreFromCollection. Lorsqu’un magasin est ajouté à une collection, tous les certificats, listes de contrôle d’accès (CRL) et CTL de ce magasin deviennent disponibles pour les recherches ou les énumérations du magasin de collection.
Le mot élevé de dwFlags est défini sur zéro. valeur pvPara : le paramètre pvPara doit avoir la valeur NULL. |
|
Initialise le magasin avec des certificats, des listes de contrôle d’accès et des listes de contrôle d’accès (CTL) lus à partir d’un fichier ouvert spécifié. Ce fournisseur s’attend à ce que le fichier contienne uniquement un magasin sérialisé et non pas des messages signés PKCS #7 ou un seul certificat encodé.
Le pointeur de fichier doit être positionné au début des informations du magasin sérialisé. Une fois que les données du magasin sérialisé ont été chargées dans le magasin de certificats, le pointeur de fichier est positionné au début de toutes les données pouvant suivre les données du magasin sérialisé dans le fichier. Si CERT_FILE_STORE_COMMIT_ENABLE est défini dans dwFlags, le handle de fichier est dupliqué et le magasin est toujours validé en tant que magasin sérialisé. Le fichier n’est pas fermé lorsque le magasin est fermé. valeur pvPara : le paramètre pvPara doit contenir un pointeur vers le handle d’un fichier ouvert à l’aide de CreateFile. |
|
Initialise le magasin avec des certificats, des listes de contrôle d’accès et des listes de contrôle d’accès à partir d’un fichier. Le fournisseur ouvre le fichier et tente d’abord de lire le fichier en tant que magasin sérialisé, puis en tant que message signé PKCS #7 et enfin en tant que certificat encodé unique.
Le paramètre dwEncodingType doit contenir les types d’encodage à utiliser avec les messages et les certificats. Si le fichier contient un certificat encodé X.509 , l’opération d’ouverture échoue et un appel à la fonction GetLastError retourne ERROR_ACCESS_DENIED. Si l’indicateur CERT_FILE_STORE_COMMIT_ENABLE est défini dans dwFlags, la valeur dwCreationDisposition passée à CreateFile est la suivante :
Si dwFlags inclut CERT_FILE_STORE_COMMIT_ENABLE, le fichier est approuvé en tant que magasin PKCS #7 ou sérialisé en fonction du type de fichier ouvert. Si le fichier était vide ou si le nom du fichier a une extension .p7c ou .spc, le fichier est validée en tant que PKCS #7. Sinon, le fichier est approuvé en tant que magasin sérialisé. valeur pvPara : le paramètre pvPara doit contenir un pointeur vers une chaîne ANSI terminée par null qui contient le nom d’un fichier existant non ouvert. |
|
Identique à CERT_STORE_PROV_FILENAME_A.
valeur pvPara : le paramètre pvPara doit contenir un pointeur vers une chaîne Unicode terminée par null qui contient le nom d’un fichier existant non ouvert. |
|
Initialise le magasin avec des certificats, des listes de contrôle d’accès et des listes de contrôle client à partir des résultats d’une requête LDAP.
Pour effectuer des opérations d’écriture sur le magasin, la chaîne de requête doit spécifier une requête BASE sans filtre et un attribut unique. valeur pvPara : si le paramètre dwFlags contient CERT_LDAP_STORE_OPENED_FLAG, définissez pvPara sur l’adresse d’une structure de CERT_LDAP_STORE_OPENED_PARA qui spécifie la session LDAP établie à utiliser. Sinon, définissez pvPara pour qu’il pointe vers une chaîne Unicode terminée par null qui contient la chaîne de requête LDAP. Pour plus d’informations sur les chaînes de requête LDAP, consultez Dialecte LDAP. |
|
Crée un magasin de certificats dans la mémoire mise en cache. Aucun certificat, listes de révocation de certificats (CRL) ou listes d’approbation de certificats (CTL) n’est initialement chargé dans le magasin. Généralement utilisé pour créer un magasin temporaire.
L’ajout de certificats, de listes de contrôle d’accès ou de certificats ou de listes de contrôle d’accès (CTL) ou les modifications apportées aux propriétés de certificats, de listes de contrôle d’accès (CRL) ou de CTL dans un magasin de mémoire ne sont pas automatiquement enregistrés. Ils peuvent être enregistrés dans un fichier ou dans un objet BLOB de mémoire à l’aide de CertSaveStore. valeur pvPara : le paramètre pvPara n’est pas utilisé. |
|
Initialise le magasin avec des certificats, des listes de contrôle d’accès et des listes de contrôle d’accès à partir du message de chiffrement spécifié. Le paramètre dwEncodingType doit contenir les types d’encodage utilisés avec les messages et les certificats.
valeur pvPara : le paramètre pvPara contient un handle HCRYPTMSG du message encodé, retourné par un appel à CryptMsgOpenToDecode. |
|
Initialise le magasin avec des certificats, des listes de contrôle d’accès et des listes de contrôle d’accès à partir d’un magasin physique spécifié qui est membre d’un magasin de système logique.
Deux noms sont séparés par une barre oblique inverse (\), par exemple « Root.Default ». Ici, « Racine » est le nom du magasin système et ». Default » est le nom du magasin physique. Les noms de magasins système et physique ne peuvent pas contenir de barres obliques inverses. Le mot élevé de dwFlags indique l’emplacement du magasin système, généralement CERT_SYSTEM_STORE_CURRENT_USER. Pour plus d’informations, consultez dwFlags plus loin dans cette rubrique et consultez Emplacements du magasin système. Certains emplacements de magasin physique peuvent être ouverts à distance. valeur pvPara : le paramètre pvPara pointe vers une chaîne Unicode terminée par null qui contient à la fois le nom du magasin système et les noms physiques. |
|
Initialise le magasin avec des certificats, des listes de contrôle d’accès et des listes de contrôle d’accès à partir d’un message signé PKCS #7 encodé. Le paramètre dwEncodingType doit spécifier les types d’encodage à utiliser avec les messages et les certificats.
valeur pvPara : le paramètre pvPara pointe vers une structure CRYPT_DATA_BLOB qui représente le message encodé. |
|
Initialise le magasin avec le contenu d’un paquet PKCS #12 .
Si le paquet PKCS #12 est protégé par un mot de passe NULL ou vide, cette fonction réussit à ouvrir le magasin. À compter de Windows 8 et Windows Server 2012, si le mot de passe incorporé dans le paquet PFX a été protégé par un principal Active Directory (AD) et que l’utilisateur actuel, en tant que membre de ce principal, a l’autorisation de déchiffrer le mot de passe, cette fonction réussit à ouvrir le magasin. Pour plus d’informations, consultez le paramètre pvPara et l’indicateur PKCS12_PROTECT_TO_DOMAIN_SIDS de la fonction PFXExportCertStoreEx . Vous pouvez protéger les mots de passe PFX sur un principal AD à partir de Windows 8 et Windows Server 2012. valeur pvPara : le paramètre pvPara pointe vers une structure CRYPT_DATA_BLOB qui représente le paquet PKCS #12. |
|
Initialise le magasin avec des certificats, des listes de contrôle d’accès et des listes de contrôle d’accès à partir d’une sous-clé de Registre.
Ce fournisseur ouvre ou crée les sous-clés de Registre Certificats, LISTES de contrôle d’accès et CTL sous la clé passée dans pvPara. La clé d’entrée n’est pas fermée par le fournisseur. Avant de retourner, le fournisseur ouvre sa propre copie de la clé transmise dans pvPara. Si CERT_STORE_READONLY_FLAG est défini dans le mot bas de dwFlags, les sous-clés du Registre sont ouvertes à l’aide de RegOpenKey avec KEY_READ_ACCESS. Sinon, les sous-clés de Registre sont créées à l’aide de RegCreateKey avec KEY_ALL_ACCESS. Toutes les modifications apportées au contenu du magasin ouvert sont immédiatement conservées dans le Registre. Toutefois, si CERT_STORE_READONLY_FLAG est défini dans le mot bas de dwFlags, toute tentative d’ajout au contenu du magasin ou de modification de la propriété d’un contexte entraîne une erreur avec GetLastError qui retourne le code E_ACCESSDENIED. valeur pvPara : le paramètre pvPara contient le handle d’une clé de Registre ouverte. |
|
Initialise le magasin avec des certificats, des listes de contrôle d’accès et des listes de contrôle d’accès à partir d’un emplacement de mémoire qui contient un magasin sérialisé.
valeur pvPara : le paramètre pvPara pointe vers une structure CRYPT_DATA_BLOB qui contient l’objet BLOB de mémoire sérialisée. |
|
Pas utilisé pour l'instant. |
|
Initialise le magasin avec des certificats, des listes de contrôle d’accès et des listes de contrôle d’accès à partir du magasin système spécifié.
Le magasin système est un magasin de collection logique qui se compose d’un ou plusieurs magasins physiques. Un magasin physique associé à un magasin système est inscrit auprès de la fonction CertRegisterPhysicalStore . Une fois le magasin système ouvert, tous les magasins physiques qui lui sont associés sont également ouverts par des appels à CertOpenStore et sont ajoutés à la collection de magasins système à l’aide de la fonction CertAddStoreToCollection . Le mot élevé de dwFlags indique l’emplacement du magasin système, généralement défini sur CERT_SYSTEM_STORE_CURRENT_USER. Pour plus d’informations sur les emplacements du Registre, consultez dwFlags plus loin dans cette rubrique et Emplacements du magasin système. Certains emplacements du magasin système peuvent être ouverts à distance ; Pour plus d’informations, consultez Emplacements du magasin système. valeur pvPara : le paramètre pvPara pointe vers une chaîne ANSI terminée par null qui contient un nom de magasin système, tel que « My » ou « Root ». |
|
Identique à CERT_STORE_PROV_SYSTEM_A.
valeur pvPara : le paramètre pvPara pointe vers une chaîne Unicode terminée par null qui contient un nom de magasin système, tel que « My » ou « Root ». |
|
Initialise le magasin avec des certificats, des listes de contrôle d’accès et des listes de contrôle d’accès à partir d’un magasin de Registre physique. Le magasin physique n’est pas ouvert en tant que magasin de collection. Les énumérations et les recherches passent uniquement par les certificats, les listes de contrôle d’accès (CRL) et les listes de contrôle (CTL) de ce magasin physique.
Le mot élevé de dwFlags indique l’emplacement du magasin système, généralement défini sur CERT_SYSTEM_STORE_CURRENT_USER. Pour plus d’informations, consultez dwFlags plus loin dans cette rubrique. Certains emplacements du magasin système peuvent être ouverts à distance ; Pour plus d’informations, consultez Emplacements du magasin système. valeur pvPara : le paramètre pvPara pointe vers une chaîne ANSI terminée par null qui contient un nom de magasin système, tel que « My » ou « Root ». |
|
Identique à CERT_STORE_PROV_SYSTEM_REGISTRY_A.
valeur pvPara : le paramètre pvPara pointe vers une chaîne Unicode terminée par null qui contient un nom de magasin système, tel que « My » ou « Root ». |
[in] dwEncodingType
Spécifie le type d’encodage de certificat et le type d’encodage de message. L’encodage est utilisé uniquement lorsque le paramètre dwSaveAs de la fonction CertSaveStore contient CERT_STORE_SAVE_AS_PKCS7. Sinon, le paramètre dwMsgAndCertEncodingType n’est pas utilisé.
Ce paramètre s’applique uniquement lorsque le type de fournisseur CERT_STORE_PROV_MSG, CERT_STORE_PROV_PKCS7 ou CERT_STORE_PROV_FILENAME est spécifié dans le paramètre lpszStoreProvider . Pour tous les autres types de fournisseurs, ce paramètre n’est pas utilisé et doit être défini sur zéro.
Ce paramètre peut être une combinaison d’une ou plusieurs des valeurs suivantes.
| Valeur | Signification |
|---|---|
|
Spécifie l’encodage des messages PKCS #7. |
|
Spécifie l’encodage du certificat X.509. |
[in] hCryptProv
Ce paramètre n’est pas utilisé et doit être défini sur NULL.
Windows Server 2003 et Windows XP : Handle à un fournisseur de chiffrement. Le passage de la valeur NULL pour ce paramètre entraîne l’utilisation d’un fournisseur par défaut approprié. Il est recommandé d’utiliser le fournisseur par défaut. Le fournisseur de chiffrement par défaut ou spécifié est utilisé pour toutes les fonctions de magasin qui vérifient la signature d’un certificat d’objet ou de la liste de révocation de certificats. Le type de données de ce paramètre est HCRYPTPROV.
[in] dwFlags
Ces valeurs se composent de valeurs à mot élevé et à mot faible combinés à l’aide d’une opération OR au niveau du bit.
La partie à faible mot de dwFlags contrôle diverses caractéristiques générales du magasin de certificats ouvert. Cette partie peut être utilisée avec tous les types de fournisseurs de magasin. La partie à bas mot de dwFlags peut être l’une des valeurs suivantes.
| Valeur | Signification |
|---|---|
|
Utilisez les privilèges de SE_BACKUP_NAME et de SE_RESTORE_NAME du thread pour ouvrir des magasins système basés sur le Registre ou des fichiers. Si le thread ne dispose pas de ces privilèges, cette fonction doit échouer avec une erreur d’accès refusé. |
|
Un nouveau magasin est créé s’il n’en existe pas. La fonction échoue si le magasin existe déjà.
Si ni CERT_STORE_OPEN_EXISTING_FLAG ni CERT_STORE_CREATE_NEW_FLAG n’est défini, un magasin est ouvert s’il existe ou est créé et ouvert s’il n’existait pas déjà. |
|
Différer la fermeture du fournisseur du magasin jusqu’à ce que tous les certificats, listes de contrôle d’accès (CRL) ou CTL obtenus à partir du magasin ne soient plus utilisés. Le magasin est en fait fermé lorsque le dernier certificat, CRL ou CTL obtenu à partir du magasin est libéré. Toutes les modifications apportées aux propriétés de ces certificats, listes de contrôle d’accès et de certificats, même après l’appel à CertCloseStore, sont conservées.
Si cet indicateur n’est pas défini et que les certificats, listes de contrôle d’accès (CRL) ou CTL obtenus à partir du magasin sont toujours en cours d’utilisation, les modifications apportées aux propriétés de ces certificats, listes de contrôle d’accès et CTL ne seront pas conservées. Si cette fonction est appelée avec CERT_CLOSE_STORE_FORCE_FLAG, CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG est ignorée. Lorsque cet indicateur est défini et qu’une valeur de paramètre hCryptProv non NULL est transmise, ce fournisseur continue d’être utilisé même après l’appel de cette fonction. |
|
Le magasin est supprimé au lieu d’être ouvert. Cette fonction retourne NULL pour la réussite et l’échec de la suppression. Pour déterminer la réussite de la suppression, appelez GetLastError, qui retourne zéro si le magasin a été supprimé et une valeur différente de zéro si elle n’a pas été supprimée. |
|
Normalement, une énumération de tous les certificats dans le magasin ignore tout certificat avec la propriété CERT_ARCHIVED_PROP_ID définie. Si cet indicateur est défini, une énumération des certificats dans le magasin contiendra tous les certificats du magasin, y compris ceux qui ont la propriété CERT_ARCHIVED_PROP_ID . |
|
Ouvrez le magasin avec l’ensemble maximal d’autorisations autorisées. Si cet indicateur est spécifié, les magasins du Registre sont d’abord ouverts avec un accès en écriture et, si cela échoue, ils sont rouverts avec un accès en lecture seule. |
|
Cet indicateur n’est pas utilisé lorsque le paramètre hCryptProv a la valeur NULL. Cet indicateur n’est valide que lorsqu’un handle CSP non NULL est passé en tant que paramètre hCryptProv . La définition de cet indicateur empêche la libération automatique d’un fournisseur de solutions cloud non par défaut lorsque le magasin de certificats est fermé. |
|
Ouvrez uniquement un magasin existant. Si le magasin n’existe pas, la fonction échoue. |
|
Ouvrez le magasin en lecture seule. Toute tentative de modification du contenu du magasin entraîne une erreur. Lorsque cet indicateur est défini et qu’un fournisseur de magasin basé sur le Registre est utilisé, les sous-clés du Registre sont ouvertes à l’aide de RegOpenKey avec KEY_READ_ACCESS. Sinon, les sous-clés de Registre sont créées à l’aide de RegCreateKey avec KEY_ALL_ACCESS. |
|
Si cet indicateur est pris en charge, le fournisseur définit la propriété CERT_STORE_LOCALIZED_NAME_PROP_ID du magasin. Le nom localisé peut être récupéré en appelant la fonction CertGetStoreProperty avec dwPropID défini sur CERT_STORE_LOCALIZED_NAME_PROP_ID. Cet indicateur est pris en charge pour les fournisseurs de types CERT_STORE_PROV_FILENAME, CERT_STORE_PROV_SYSTEM, CERT_STORE_PROV_SYSTEM_REGISTRY et CERT_STORE_PROV_PHYSICAL_W. |
|
Lorsque vous ouvrez un magasin plusieurs fois, vous pouvez définir cet indicateur pour garantir une utilisation efficace de la mémoire en réutilisant la mémoire pour les parties encodées d’un contexte de certificat, de liste de révocation de certificats ou de CTL sur les instances ouvertes des magasins. |
|
Listes d’identificateurs de clé existent dans CurrentUser et LocalMachine. Ces identificateurs de clé ont des propriétés très similaires aux propriétés des certificats. Si le CERT_STORE_UPDATE_KEYID_FLAG est défini, pour chaque identificateur de clé dans le magasin qui a une propriété CERT_KEY_PROV_INFO_PROP_ID , cette propriété est automatiquement mise à jour à partir de la propriété identificateur de clé CERT_KEY_PROV_INFO_PROP_ID ou de la CERT_KEY_IDENTIFIER_PROP_ID du certificat associé à cet identificateur de clé. |
Les types de fournisseurs CERT_STORE_PROV_SYSTEM, CERT_STORE_PROV_SYSTEM_REGISTRY et CERT_STORE_PROV_PHYSICAL utilisent les mots élevés suivants de dwFlags pour spécifier les emplacements du registre du magasin système :
CERT_SYSTEM_STORE_CURRENT_SERVICE
CERT_SYSTEM_STORE_CURRENT_USER
CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY
CERT_SYSTEM_STORE_LOCAL_MACHINE
CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE
CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY
CERT_SYSTEM_STORE_SERVICES
CERT_SYSTEM_STORE_USERS
Par défaut, un emplacement de magasin système est ouvert par rapport à la clé de Registre prédéfinie HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE ou HKEY_USERS . Pour plus d’informations, consultez Emplacements du magasin système.
Les indicateurs de mots hauts suivants remplacent ce comportement par défaut.
| Valeur | Signification |
|---|---|
|
Lorsqu’il est défini, pvPara doit contenir un pointeur vers une structure CERT_SYSTEM_STORE_RELOCATE_PARA plutôt qu’une chaîne. La structure indique à la fois le nom du magasin et son emplacement dans le Registre. |
|
Par défaut, lorsque le magasin CurrentUser « Root » est ouvert, toutes les racines SystemRegistry qui ne figurent pas dans la liste racine protégée sont supprimées du cache avant le retour de cette fonction. Lorsque cet indicateur est défini, cette valeur par défaut est remplacée et toutes les racines dans SystemRegistry sont retournées et aucune case activée de la liste racine protégée n’est effectuée. |
Le fournisseur CERT_STORE_PROV_REGISTRY utilise les indicateurs de mots hauts suivants.
| Valeur | Signification |
|---|---|
|
pvPara contient un handle pour une clé de Registre sur un ordinateur distant. Pour accéder à une clé de Registre sur un ordinateur distant, les autorisations de sécurité sur l’ordinateur distant doivent être définies pour autoriser l’accès. Pour plus d'informations, consultez la section Notes. |
|
Le fournisseur de CERT_STORE_PROV_REG enregistre les certificats, les listes de révocation de certificats et les listes de révocation de certificats dans une seule sous-clé de magasin sérialisée au lieu d’effectuer l’opération d’enregistrement par défaut. La valeur par défaut est que chaque certificat, liste de révocation de certificats ou CTL est enregistré en tant que sous-clé de Registre distincte sous la sous-clé appropriée.
Cet indicateur est principalement utilisé pour les magasins téléchargés à partir du modèle de stratégie de groupe (GPT), tels que les magasins CurrentUserGroupPolicy et LocalMachineGroupPolicy. Lorsque CERT_REGISTRY_STORE_SERIALIZED_FLAG est défini, les ajouts, les suppressions ou les modifications de propriété de stockage ne sont pas conservés tant qu’il n’y a pas d’appel à CertCloseStore ou CertControlStore à l’aide de CERT_STORE_CTRL_COMMIT. |
Les types de fournisseurs CERT_STORE_PROV_FILE et CERT_STORE_PROV_FILENAME utilisent les indicateurs de mots hauts suivants.
| Valeur | Signification |
|---|---|
|
La définition de cet indicateur valide tout ajout au magasin ou toute modification apportée aux propriétés des contextes du magasin dans le magasin de fichiers lorsque CertCloseStore est appelé ou lorsque CertControlStore est appelé avec CERT_STORE_CONTROL_COMMIT.
CertOpenStore échoue avec E_INVALIDARG si les CERT_FILE_STORE_COMMIT_ENABLE et les CERT_STORE_READONLY_FLAG sont définis dans dwFlags. |
Le type de fournisseur CERT_STORE_PROV_LDAP utilise les indicateurs de mots hauts suivants.
| Valeur | Signification |
|---|---|
|
Effectue une recherche DNS A-Record-only sur l’URL nommée dans le paramètre pvPara . Cela empêche la génération de fausses requêtes DNS lors de la résolution des noms d’hôte d’URL. Utilisez cet indicateur lors de la transmission d’un nom d’hôte par opposition à un nom de domaine pour le paramètre pvPara . |
|
Utilisez cet indicateur pour utiliser une session LDAP existante. Lorsque cet indicateur est spécifié, le paramètre pvPara est l’adresse d’une structure CERT_LDAP_STORE_OPENED_PARA qui contient des informations sur la session LDAP à utiliser. |
|
Pour fournir l’intégrité requise par certaines applications, signez numériquement tout le trafic LDAP à destination et en provenance d’un serveur LDAP à l’aide du protocole d’authentification Kerberos. |
|
Utilisez cet indicateur avec l’indicateur CERT_LDAP_STORE_OPENED_FLAG pour que la session LDAP soit indépendante lorsque le magasin est fermé. Le système dissocie la session LDAP à l’aide de la fonction ldap_unbind lorsque le magasin est fermé. |
[in] pvPara
Valeur 32 bits qui peut contenir des informations supplémentaires pour cette fonction. Le contenu de ce paramètre dépend de la valeur de lpszStoreProvider et d’autres paramètres.
Valeur retournée
Si la fonction réussit, la fonction retourne un handle au magasin de certificats. Lorsque vous avez terminé d’utiliser le magasin, relâchez le handle en appelant la fonction CertCloseStore .
Si la fonction échoue, elle retourne NULL. Pour obtenir des informations d’erreur étendues, appelez GetLastError.
Remarques
Un magasin système est une collection qui se compose d’un ou plusieurs magasins frères physiques. Pour chaque magasin système, il existe des magasins frères physiques prédéfinis. Après avoir ouvert un magasin système tel que « Mon » à CERT_SYSTEM_STORE_CURRENT_USER, CertOpenStore est appelé pour ouvrir tous les magasins physiques de la collection de magasins système. Chacun de ces magasins physiques est ajouté à la collection de magasins système à l’aide de la fonction CertAddStoreToCollection . Tous les certificats, listes de révocation de certificats et CTL de ces magasins physiques sont disponibles via la collection de magasins système logiques.
Les emplacements de magasin système suivants peuvent être ouverts à distance :
- CERT_SYSTEM_STORE_LOCAL_MACHINE
- CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY
- CERT_SYSTEM_STORE_SERVICES
- CERT_SYSTEM_STORE_USERS
Les emplacements du magasin système sont ouverts à distance en préfixant le nom du magasin dans la chaîne passée à pvPara avec le nom de l’ordinateur. Voici quelques exemples de noms de magasins système distants :
- ComputerName\CA
- \\ComputerName\CA
- ComputerName\ServiceName\Trust
- \\ComputerName\ServiceName\Trust
Pour plus d’informations sur les magasins système, consultez Emplacements du magasin système.
Pour plus d’informations sur les magasins qui sont automatiquement migrés, consultez Migration du magasin de certificats.
Exemples
L’exemple suivant montre l’ouverture de plusieurs magasins de certificats de différents types de fournisseurs de magasins. L’exemple utilise la fonction CreateMyDACL , définie dans la rubrique Création d’une liste DACL , pour s’assurer que le fichier ouvert est créé avec une liste DACL appropriée. Pour obtenir d’autres exemples d’ouverture d’autres types de fournisseurs de magasins, consultez Exemple de code C pour l’ouverture de magasins de certificats.
//-------------------------------------------------------------------
// Open a system store, in this case, the My store.
HCERTSTORE hSysStore = NULL;
if(hSysStore = CertOpenStore(
CERT_STORE_PROV_SYSTEM, // The store provider type
0, // The encoding type is
// not needed
NULL, // Use the default HCRYPTPROV
CERT_SYSTEM_STORE_CURRENT_USER, // Set the store location in a
// registry location
L"MY" // The store name as a Unicode
// string
))
{
printf("The system store was created successfully.\n");
}
else
{
printf("An error occurred during creation "
"of the system store!\n");
exit(1);
}
// Other common system stores include "Root", "Trust", and "Ca".
//-------------------------------------------------------------------
// Open a memory store.
HCERTSTORE hMemStore = NULL;
if(hMemStore = CertOpenStore(
CERT_STORE_PROV_MEMORY, // The memory provider type
0, // The encoding type is not needed
NULL, // Use the default HCRYPTPROV
0, // Accept the default dwFlags
NULL // pvPara is not used
))
{
printf("The memory store was created successfully.\n");
}
else
{
printf("An error occurred during creation "
"of the memory store!\n");
exit(1);
}
//-------------------------------------------------------------------
// Open a read-only store from disk.
HANDLE hFile = NULL;
HCERTSTORE hFileStore = NULL;
LPCSTR pszFileName = "TestStor2.sto";
SECURITY_ATTRIBUTES sa; // For DACL
// Create a DACL to use when opening the file.
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.bInheritHandle = FALSE;
// Call function to set the DACL. The DACL is set in the
// SECURITY_ATTRIBUTES lpSecurityDescriptor member.
if (!CreateMyDACL(&sa))
{
// Error encountered; generate message and exit.
printf("Failed CreateMyDACL.\n");
exit(1);
}
// Obtain the file handle of an existing file.
if (hFile = CreateFile(
pszFileName, // The file name
GENERIC_READ|GENERIC_WRITE, // Access mode: Read from and
// write to this file
0, // Share mode
&sa, // Uses the DACL created
// previously
OPEN_ALWAYS, // How to create
FILE_ATTRIBUTE_NORMAL, // File attributes
NULL)) // Template
{
printf("The file was opened successfully.\n");
}
else
{
printf("An error occurred during opening of the file!\n");
exit(1);
}
//-------------------------------------------------------------------
// This file can contain data before the store itself.
// At this point, read and use data in the open file that precedes
// the serialized certificate store data.
// To open the certificate store, the file pointer must
// be placed at the beginning of the certificate store data.
//-------------------------------------------------------------------
// Open the store.
if(hFileStore = CertOpenStore(
CERT_STORE_PROV_FILE, // Load certificates from a file
0, // Encoding type not used
NULL, // Use the default HCRYPTPROV
CERT_STORE_READONLY_FLAG, // Read-only store
hFile // The handle for the open file
// that is the source of the
// certificates
))
{
printf("The file store was created successfully.\n");
}
else
{
printf("An error occurred during creation of the file store!\n");
exit(1);
}
//-------------------------------------------------------------------
// After processing, close the certificate stores and the file.
if(CertCloseStore(
hSysStore,
CERT_CLOSE_STORE_CHECK_FLAG))
{
printf("The system store was closed successfully.\n");
}
else
{
printf("An error occurred during closing of the "
"system store.\n");
}
if(CertCloseStore(
hMemStore,
CERT_CLOSE_STORE_CHECK_FLAG))
{
printf("The memory store was closed successfully.\n");
}
else
{
printf("An error occurred during closing of the "
"memory store.\n");
}
if(CertCloseStore(
hFileStore,
CERT_CLOSE_STORE_CHECK_FLAG))
{
printf("The file store was closed successfully.\n");
}
else
{
printf("An error occurred during closing of the file store.\n");
}
if(CloseHandle(hFile))
{
printf("The file was closed successfully.\n");
}
else
{
printf("An error occurred during closing of the file.\n");
}
Configuration requise
| Condition requise | Valeur |
|---|---|
| Client minimal pris en charge | Windows XP [applications de bureau | applications UWP] |
| Serveur minimal pris en charge | Windows Server 2003 [applications de bureau | applications UWP] |
| Plateforme cible | Windows |
| En-tête | wincrypt.h |
| Bibliothèque | Crypt32.lib |
| DLL | Crypt32.dll |
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour