CertOpenStore-Funktion (wincrypt.h)
Die CertOpenStore-Funktion öffnet einen Zertifikatspeicher mithilfe eines angegebenen Speicheranbietertyps. Während diese Funktion einen Zertifikatspeicher für die meisten Zwecke öffnen kann, wird CertOpenSystemStore empfohlen, um die gängigsten Zertifikatspeicher zu öffnen. CertOpenStore ist für komplexere Optionen und Sonderfälle erforderlich.
Syntax
HCERTSTORE CertOpenStore(
[in] LPCSTR lpszStoreProvider,
[in] DWORD dwEncodingType,
[in] HCRYPTPROV_LEGACY hCryptProv,
[in] DWORD dwFlags,
[in] const void *pvPara
);
Parameter
[in] lpszStoreProvider
Ein Zeiger auf eine NULL-beendete ANSI-Zeichenfolge, die den Typ des Speicheranbieters enthält.
Die folgenden Werte stellen die vordefinierten Speichertypen dar. Der Speicheranbietertyp bestimmt den Inhalt des pvPara-Parameters sowie die Verwendung und Bedeutung des hohen Worts des dwFlags-Parameters . Weitere Speicheranbieter können mithilfe der Funktion CryptInstallOIDFunctionAddress oder CryptRegisterOIDFunction Installiert oder registriert werden. Weitere Informationen zum Hinzufügen von Speicheranbietern finden Sie unter Erweitern der CertOpenStore-Funktionalität.
| Wert | Bedeutung |
|---|---|
|
Öffnet einen Speicher, bei dem es sich um eine Sammlung von anderen Speichern wird. Stores werden der Auflistung mithilfe von CertAddStoreToCollection und CertRemoveStoreFromCollection hinzugefügt oder daraus entfernt. Wenn einer Sammlung ein Speicher hinzugefügt wird, werden alle Zertifikate, CRLs und CTLs in diesem Speicher für Suchvorgänge oder Enumerationen des Sammlungsspeichers verfügbar.
Das hohe Wort von dwFlags ist auf 0 festgelegt. pvPara-Wert : Der pvPara-Parameter muss NULL sein. |
|
Initialisiert den Speicher mit Zertifikaten, Zertifikatsperrlisten und CTLs, die aus einer angegebenen geöffneten Datei gelesen werden. Dieser Anbieter erwartet, dass die Datei nur einen serialisierten Speicher und keine mit PKCS #7 signierten Nachrichten oder ein einzelnes codiertes Zertifikat enthält.
Der Dateizeiger muss am Anfang der serialisierten Speicherinformationen positioniert werden. Nachdem die Daten im serialisierten Speicher in den Zertifikatspeicher geladen wurden, wird der Dateizeiger am Anfang aller Daten positioniert, die den serialisierten Speicherdaten in der Datei folgen können. Wenn CERT_FILE_STORE_COMMIT_ENABLE in dwFlags festgelegt ist, wird das Dateihandle dupliziert, und der Speicher wird immer als serialisierter Speicher committet. Die Datei wird nicht geschlossen, wenn der Speicher geschlossen wird. pvPara-Wert : Der pvPara-Parameter muss einen Zeiger auf das Handle einer Datei enthalten, die mit CreateFile geöffnet wurde. |
|
Initialisiert den Speicher mit Zertifikaten, Zertifikatsperrlisten und CTLs aus einer Datei. Der Anbieter öffnet die Datei und versucht zunächst, die Datei als serialisierter Speicher, dann als PKCS #7 signierte Nachricht und schließlich als einzelnes codiertes Zertifikat zu lesen.
Der dwEncodingType-Parameter muss die Codierungstypen enthalten, die sowohl mit Nachrichten als auch mit Zertifikaten verwendet werden sollen. Wenn die Datei ein X.509-codiertes Zertifikat enthält, schlägt der geöffnete Vorgang fehl, und ein Aufruf der GetLastError-Funktion gibt ERROR_ACCESS_DENIED zurück. Wenn das CERT_FILE_STORE_COMMIT_ENABLE-Flag in dwFlags festgelegt ist, lautet der an CreateFile übergebene dwCreationDisposition-Wert wie folgt:
Wenn dwFlagsCERT_FILE_STORE_COMMIT_ENABLE enthält, wird die Datei abhängig vom geöffneten Dateityp entweder als PKCS #7 oder als serialisierter Speicher committet. Wenn die Datei leer war oder der Dateiname entweder die Erweiterung .p7c oder .spc aufweist, wird die Datei als PKCS #7 committet. Andernfalls wird die Datei als serialisierter Speicher committet. pvPara-Wert : Der pvPara-Parameter muss einen Zeiger auf eine null-beendete ANSI-Zeichenfolge enthalten, die den Namen einer vorhandenen, ungeöffneten Datei enthält. |
|
Identisch mit CERT_STORE_PROV_FILENAME_A.
pvPara-Wert : Der pvPara-Parameter muss einen Zeiger auf eine Unicode-Zeichenfolge mit Null-Beendigung enthalten, die den Namen einer vorhandenen, ungeöffneten Datei enthält. |
|
Initialisiert den Speicher mit Zertifikaten, Zertifikatsperrlisten und CTLs aus den Ergebnissen einer LDAP-Abfrage.
Zum Ausführen von Schreibvorgängen im Speicher muss die Abfragezeichenfolge eine BASE-Abfrage ohne Filter und ein einzelnes Attribut angeben. pvPara-Wert : Wenn der dwFlags-ParameterCERT_LDAP_STORE_OPENED_FLAG enthält, legen Sie pvPara auf die Adresse einer CERT_LDAP_STORE_OPENED_PARA-Struktur fest, die die zu verwendende festgelegte LDAP-Sitzung angibt. Legen Sie andernfalls pvPara so fest, dass er auf eine Unicode-Zeichenfolge mit Null-Beendigung verweist, die die LDAP-Abfragezeichenfolge enthält. Weitere Informationen zu LDAP-Abfragezeichenfolgen finden Sie unter LDAP-Dialekt. |
|
Erstellt einen Zertifikatspeicher im zwischengespeicherten Arbeitsspeicher. Zunächst werden keine Zertifikate, Zertifikatsperrlisten (Certificate Revocation Lists , CRLs) oder Zertifikatvertrauenslisten (Certificate Trust Lists , CTLs) in den Speicher geladen. Wird in der Regel zum Erstellen eines temporären Speichers verwendet.
Das Hinzufügen von Zertifikaten, CRLs oder CTLs oder Änderungen an Eigenschaften von Zertifikaten, CRLs oder CTLs in einem Speicherspeicher wird nicht automatisch gespeichert. Sie können mithilfe von CertSaveStore in einer Datei oder in einem Speicherblob gespeichert werden. pvPara-Wert : Der parameter pvPara wird nicht verwendet. |
|
Initialisiert den Speicher mit Zertifikaten, CRLs und CTLs aus der angegebenen kryptografischen Nachricht. Der dwEncodingType-Parameter muss die Codierungstypen enthalten, die sowohl für Nachrichten als auch für Zertifikate verwendet werden.
pvPara-Wert : Der pvPara-Parameter enthält ein HCRYPTMSG-Handle der codierten Nachricht, das durch einen Aufruf von CryptMsgOpenToDecode zurückgegeben wird. |
|
Initialisiert den Speicher mit Zertifikaten, CRLs und CTLs aus einem angegebenen physischen Speicher, der Mitglied eines logischen Systemspeichers ist.
Zwei Namen werden durch einen dazwischen liegenden umgekehrten Schrägstrich (\) getrennt, z. B. "Root.Default". Hier ist "Root" der Name des Systemspeichers und ". Default" ist der Name des physischen Speichers. Die Namen des Systems und des physischen Speichers dürfen keine umgekehrten Schrägstriche enthalten. Das hohe Wort dwFlags gibt den Speicherort des Systemspeichers an, der normalerweise CERT_SYSTEM_STORE_CURRENT_USER. Weitere Informationen finden Sie unter dwFlags weiter unten in diesem Thema und unter Speicherorte des Systemspeichers. Einige physische Filialen können remote geöffnet werden. pvPara-Wert : Der pvPara-Parameter verweist auf eine Unicode-Zeichenfolge mit Null-Beendigung, die sowohl den Systemspeichernamen als auch physische Namen enthält. |
|
Initialisiert den Speicher mit Zertifikaten, Zertifikatsperrlisten und CTLs aus einer codierten PKCS #7-signierten Nachricht. Der dwEncodingType-Parameter muss die Codierungstypen angeben, die sowohl mit Nachrichten als auch mit Zertifikaten verwendet werden sollen.
pvPara-Wert : Der pvPara-Parameter verweist auf eine CRYPT_DATA_BLOB Struktur, die die codierte Nachricht darstellt. |
|
Initialisiert den Speicher mit dem Inhalt eines PKCS #12-Pakets .
Wenn das PKCS #12-Paket mit einem NULL- oder leeren Kennwort geschützt ist, kann diese Funktion den Speicher erfolgreich öffnen. Wenn das im PFX-Paket eingebettete Kennwort ab Windows 8 und Windows Server 2012 durch einen Active Directory-Prinzipal (AD) geschützt wurde und der aktuelle Benutzer als Mitglied dieses Prinzipals berechtigt ist, das Kennwort zu entschlüsseln, kann diese Funktion den Speicher erfolgreich öffnen. Weitere Informationen finden Sie im PvPara-Parameter und im PKCS12_PROTECT_TO_DOMAIN_SIDS Flag der Funktion PFXExportCertStoreEx . Sie können PFX-Kennwörter ab Windows 8 und Windows Server 2012 vor einem AD-Prinzipal schützen. pvPara-Wert : Der pvPara-Parameter verweist auf eine CRYPT_DATA_BLOB-Struktur , die das PKCS #12-Paket darstellt. |
|
Initialisiert den Speicher mit Zertifikaten, CRLs und CTLs aus einem Registrierungsunterschlüssel.
Dieser Anbieter öffnet oder erstellt die Registrierungsunterschlüssel Zertifikate, CRLs und CTLs unter dem in pvPara übergebenen Schlüssel. Der Eingabeschlüssel wird vom Anbieter nicht geschlossen. Bevor er zurückgibt, öffnet der Anbieter seine eigene Kopie des Schlüssels, der in pvPara übergeben wurde. Wenn CERT_STORE_READONLY_FLAG im low-Wort dwFlags festgelegt ist, werden Registrierungsunterschlüssel mithilfe des RegOpenKey mit KEY_READ_ACCESS geöffnet. Andernfalls werden Registrierungsunterschlüssel mithilfe von RegCreateKey mit KEY_ALL_ACCESS erstellt. Alle Änderungen am Inhalt des geöffneten Speichers werden sofort in der Registrierung beibehalten. Wenn jedoch CERT_STORE_READONLY_FLAG im niedrigen Wort dwFlags festgelegt ist, führt jeder Versuch, dem Inhalt des Speichers hinzuzufügen oder die Eigenschaft eines Kontexts zu ändern, zu einem Fehler mit GetLastError , der den E_ACCESSDENIED Code zurückgibt. pvPara-Wert : Der pvPara-Parameter enthält das Handle eines geöffneten Registrierungsschlüssels. |
|
Initialisiert den Speicher mit Zertifikaten, CRLs und CTLs aus einem Speicherspeicherort, der einen serialisierten Speicher enthält.
pvPara-Wert : Der pvPara-Parameter verweist auf eine CRYPT_DATA_BLOB-Struktur , die das serialisierte Speicherblob enthält. |
|
Derzeit nicht verwendet. |
|
Initialisiert den Speicher mit Zertifikaten, CRLs und CTLs aus dem angegebenen Systemspeicher.
Der Systemspeicher ist ein logischer Sammlungsspeicher, der aus mindestens einem physischen Speicher besteht. Ein physischer Speicher, der einem Systemspeicher zugeordnet ist, wird bei der CertRegisterPhysicalStore-Funktion registriert. Nachdem der Systemspeicher geöffnet wurde, werden alle ihm zugeordneten physischen Speicher auch durch Aufrufe von CertOpenStore geöffnet und der Systemspeichersammlung mithilfe der CertAddStoreToCollection-Funktion hinzugefügt. Das hohe Wort dwFlags gibt den Speicherort des Systemspeichers an, der normalerweise auf CERT_SYSTEM_STORE_CURRENT_USER festgelegt ist. Ausführliche Informationen zu Registrierungsspeicherorten finden Sie weiter unten in diesem Thema unter dwFlags und Systemspeicherorte. Einige Systemspeicherstandorte können remote geöffnet werden. Weitere Informationen finden Sie unter Speicherorte des Systemspeichers. pvPara-Wert : Der pvPara-Parameter zeigt auf eine NULL-beendete ANSI-Zeichenfolge, die einen Systemspeichernamen enthält, z. B. "My" oder "Root". |
|
Identisch mit CERT_STORE_PROV_SYSTEM_A.
pvPara-Wert : Der pvPara-Parameter zeigt auf eine Unicode-Zeichenfolge mit Null-Beendigung, die einen Systemspeichernamen enthält, z. B. "My" oder "Root". |
|
Initialisiert den Speicher mit Zertifikaten, CRLs und CTLs aus einem physischen Registrierungsspeicher. Der physische Speicher wird nicht als Sammlungsspeicher geöffnet. Enumerationen und Suchvorgänge durchlaufen nur die Zertifikate, CRLs und CTLs in diesem einen physischen Speicher.
Das hohe Wort dwFlags gibt den Speicherort des Systemspeichers an, der normalerweise auf CERT_SYSTEM_STORE_CURRENT_USER festgelegt ist. Weitere Informationen finden Sie weiter unten in diesem Thema unter dwFlags . Einige Systemspeicherstandorte können remote geöffnet werden. Weitere Informationen finden Sie unter Speicherorte des Systemspeichers. pvPara-Wert : Der pvPara-Parameter zeigt auf eine NULL-beendete ANSI-Zeichenfolge, die einen Systemspeichernamen enthält, z. B. "My" oder "Root". |
|
Identisch mit CERT_STORE_PROV_SYSTEM_REGISTRY_A.
pvPara-Wert : Der pvPara-Parameter zeigt auf eine Unicode-Zeichenfolge mit Null-Beendigung, die einen Systemspeichernamen enthält, z. B. "My" oder "Root". |
[in] dwEncodingType
Gibt den Zertifikatcodierungstyp und den Nachrichtencodierungstyp an. Die Codierung wird nur verwendet, wenn der dwSaveAs-Parameter der CertSaveStore-FunktionCERT_STORE_SAVE_AS_PKCS7 enthält. Andernfalls wird der dwMsgAndCertEncodingType-Parameter nicht verwendet.
Dieser Parameter gilt nur, wenn der CERT_STORE_PROV_MSG, CERT_STORE_PROV_PKCS7 oder CERT_STORE_PROV_FILENAME Anbietertyp im lpszStoreProvider-Parameter angegeben ist. Für alle anderen Anbietertypen ist dieser Parameter nicht verwendet und sollte auf Null festgelegt werden.
Dieser Parameter kann eine Kombination aus mindestens einem der folgenden Werte sein.
| Wert | Bedeutung |
|---|---|
|
Gibt die PKCS #7-Nachrichtencodierung an. |
|
Gibt die X.509-Zertifikatcodierung an. |
[in] hCryptProv
Dieser Parameter wird nicht verwendet und sollte auf NULL festgelegt werden.
Windows Server 2003 und Windows XP: Ein Handle für einen Kryptografieanbieter. Das Übergeben von NULL für diesen Parameter bewirkt, dass ein entsprechender Standardanbieter verwendet wird. Die Verwendung des Standardanbieters wird empfohlen. Der standardmäßige oder angegebene Kryptografieanbieter wird für alle Speicherfunktionen verwendet, die die Signatur eines Antragstellerzertifikats oder einer Zertifikatsperrliste überprüfen. Der Datentyp dieses Parameters ist HCRYPTPROV.
[in] dwFlags
Diese Werte bestehen aus Hoch- und Low-Word-Werten, die mithilfe eines bitweisen OR-Vorgangs kombiniert werden.
Der Low-Word-Teil von dwFlags steuert eine Vielzahl allgemeiner Merkmale des geöffneten Zertifikatspeichers . Dieser Teil kann mit allen Speicheranbietertypen verwendet werden. Der Low-Word-Teil von dwFlags kann einer der folgenden Werte sein.
| Wert | Bedeutung |
|---|---|
|
Verwenden Sie die SE_BACKUP_NAME und SE_RESTORE_NAME Berechtigungen des Threads, um Registrierungs- oder dateibasierte Systemspeicher zu öffnen. Wenn der Thread nicht über diese Berechtigungen verfügt, muss bei dieser Funktion ein Fehler auftreten, bei dem der Zugriff verweigert wurde. |
|
Ein neuer Speicher wird erstellt, wenn er nicht vorhanden war. Die Funktion schlägt fehl, wenn der Speicher bereits vorhanden ist.
Wenn weder CERT_STORE_OPEN_EXISTING_FLAG noch CERT_STORE_CREATE_NEW_FLAG festgelegt ist, wird ein Speicher geöffnet, wenn er vorhanden ist oder erstellt wird, und geöffnet, wenn er noch nicht vorhanden ist. |
|
Verzögern Sie das Schließen des Anbieters des Speichers, bis alle zertifikate, crLs oder CTLs, die aus dem Speicher abgerufen wurden, nicht mehr verwendet werden. Der Speicher wird tatsächlich geschlossen, wenn das letzte Zertifikat, die Zertifikatsperrliste oder die letzte CTL, die aus dem Speicher abgerufen wurde, freigegeben wird. Alle Änderungen an den Eigenschaften dieser Zertifikate, CRLs und CTLs, auch nach dem Aufruf von CertCloseStore, werden beibehalten.
Wenn dieses Flag nicht festgelegt ist und zertifikate, CRLs oder CTLs, die aus dem Speicher abgerufen wurden, weiterhin verwendet werden, werden alle Änderungen an den Eigenschaften dieser Zertifikate, Zertifikatsperrlisten und CTLs nicht beibehalten. Wenn diese Funktion mit CERT_CLOSE_STORE_FORCE_FLAG aufgerufen wird, wird CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG ignoriert. Wenn dieses Flag festgelegt ist und ein hCryptProv-Parameterwert ohne NULL übergeben wird, wird dieser Anbieter auch nach dem Aufruf dieser Funktion weiterhin verwendet. |
|
Der Speicher wird gelöscht, anstatt geöffnet zu werden. Diese Funktion gibt NULL zurück, wenn der Löschvorgang erfolgreich und fehlgeschlagen ist. Um den Erfolg des Löschvorgangs zu ermitteln, rufen Sie GetLastError auf. Dies gibt null zurück, wenn der Speicher gelöscht wurde, und einen Nonzero-Wert, wenn er nicht gelöscht wurde. |
|
Normalerweise ignoriert eine Enumeration aller Zertifikate im Speicher jedes Zertifikat mit der CERT_ARCHIVED_PROP_ID-Eigenschaft . Wenn dieses Flag festgelegt ist, enthält eine Enumeration der Zertifikate im Speicher alle Zertifikate im Speicher, einschließlich der Zertifikate, die über die CERT_ARCHIVED_PROP_ID-Eigenschaft verfügen. |
|
Öffnen Sie den Speicher mit dem maximalen Satz zulässiger Berechtigungen. Wenn dieses Flag angegeben ist, werden Die Registrierungsspeicher zuerst mit Schreibzugriff geöffnet, und wenn dies fehlschlägt, werden sie mit schreibgeschütztem Zugriff erneut geöffnet. |
|
Dieses Flag wird nicht verwendet, wenn der hCryptProv-ParameterNULL ist. Dieses Flag ist nur gültig, wenn ein CSP-Handle ohne NULL als hCryptProv-Parameter übergeben wird. Das Festlegen dieses Flags verhindert die automatische Freigabe eines nicht standardmäßigen CSP, wenn der Zertifikatspeicher geschlossen wird. |
|
Öffnen Sie nur einen vorhandenen Speicher. Wenn der Speicher nicht vorhanden ist, schlägt die Funktion fehl. |
|
Öffnen Sie den Speicher im schreibgeschützten Modus. Jeder Versuch, den Inhalt des Speichers zu ändern, führt zu einem Fehler. Wenn dieses Flag festgelegt ist und ein registrierungsbasierter Speicheranbieter verwendet wird, werden die Registrierungsunterschlüssel mithilfe von RegOpenKey mit KEY_READ_ACCESS geöffnet. Andernfalls werden die Registrierungsunterschlüssel mithilfe von RegCreateKey mit KEY_ALL_ACCESS erstellt. |
|
Wenn dieses Flag unterstützt wird, legt der Anbieter die CERT_STORE_LOCALIZED_NAME_PROP_ID Eigenschaft des Speichers fest. Der lokalisierte Name kann abgerufen werden, indem die CertGetStoreProperty-Funktion aufgerufen wird, wobei dwPropID auf CERT_STORE_LOCALIZED_NAME_PROP_ID festgelegt ist. Dieses Flag wird für Anbieter von Typen CERT_STORE_PROV_FILENAME, CERT_STORE_PROV_SYSTEM, CERT_STORE_PROV_SYSTEM_REGISTRY und CERT_STORE_PROV_PHYSICAL_W unterstützt. |
|
Wenn Sie einen Speicher mehrmals öffnen, können Sie dieses Flag festlegen, um eine effiziente Speicherauslastung sicherzustellen, indem Sie den Arbeitsspeicher für die codierten Teile eines Zertifikats, CRL oder CTL-Kontexts in den geöffneten Instanzen der Speicher wiederverwenden. |
|
Listen von Schlüsselbezeichnern sind in CurrentUser und LocalMachine vorhanden. Diese Schlüsselbezeichner verfügen über Eigenschaften, die den Eigenschaften von Zertifikaten ähneln. Wenn die CERT_STORE_UPDATE_KEYID_FLAG festgelegt ist, wird diese Eigenschaft für jeden Schlüsselbezeichner am Speicherort des Speichers, der über eine CERT_KEY_PROV_INFO_PROP_ID-Eigenschaft verfügt, automatisch aus der Schlüsselbezeichnereigenschaft CERT_KEY_PROV_INFO_PROP_ID oder der CERT_KEY_IDENTIFIER_PROP_ID des Zertifikats aktualisiert, das sich auf diesen Schlüsselbezeichner bezieht. |
Die Anbietertypen CERT_STORE_PROV_SYSTEM, CERT_STORE_PROV_SYSTEM_REGISTRY und CERT_STORE_PROV_PHYSICAL verwenden die folgenden hohen Wörter von dwFlags , um Die Registrierungsspeicherorte des Systemspeichers anzugeben:
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
Standardmäßig wird ein Systemspeicherort relativ zum HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE oder HKEY_USERS vordefinierten Registrierungsschlüssels geöffnet. Weitere Informationen finden Sie unter Systemspeicherorte.
Die folgenden Flags mit hohen Wörtern setzen dieses Standardverhalten außer Kraft.
| Wert | Bedeutung |
|---|---|
|
Bei Festlegung muss pvPara einen Zeiger auf eine CERT_SYSTEM_STORE_RELOCATE_PARA-Struktur und nicht auf eine Zeichenfolge enthalten. Die -Struktur gibt sowohl den Namen des Speichers als auch seinen Speicherort in der Registrierung an. |
|
Wenn der CurrentUser-Stammspeicher geöffnet wird, werden standardmäßig alle SystemRegistry-Stammstämme, die nicht in der geschützten Stammliste enthalten sind, aus dem Cache gelöscht, bevor diese Funktion zurückgegeben wird. Wenn dieses Flag festgelegt ist, wird dieser Standardwert überschrieben, und alle Wurzeln in der SystemRegistrierung werden zurückgegeben, und es wird keine Überprüfung der geschützten Stammliste durchgeführt. |
Der CERT_STORE_PROV_REGISTRY-Anbieter verwendet die folgenden High-Word-Flags.
| Wert | Bedeutung |
|---|---|
|
pvPara enthält ein Handle für einen Registrierungsschlüssel auf einem Remotecomputer. Für den Zugriff auf einen Registrierungsschlüssel auf einem Remotecomputer müssen Sicherheitsberechtigungen auf dem Remotecomputer festgelegt werden, um den Zugriff zuzulassen. Weitere Informationen finden Sie in den Hinweisen. |
|
Der CERT_STORE_PROV_REG-Anbieter speichert Zertifikate, ZERTIFIKATsperrlisten und CTLs in einem einzelnen serialisierten Speicherunterschlüssel, anstatt den Standardspeichervorgang auszuführen. Standardmäßig wird jedes Zertifikat, jede Zertifikatsperrliste oder jede CTL als separater Registrierungsunterschlüssel unter dem entsprechenden Unterschlüssel gespeichert.
Dieses Flag wird hauptsächlich für Speicher verwendet, die aus der Gruppenrichtlinienvorlage (GpT) heruntergeladen wurden, z. B. die Speicher CurrentUserGroupPolicy und LocalMachineGroupPolicy. Wenn CERT_REGISTRY_STORE_SERIALIZED_FLAG festgelegt ist, werden Speicherzufügungen, Löschungen oder Eigenschaftsänderungen nicht beibehalten, bis ein Aufruf von CertCloseStore oder CertControlStore mithilfe von CERT_STORE_CTRL_COMMIT erfolgt. |
Die Anbietertypen CERT_STORE_PROV_FILE und CERT_STORE_PROV_FILENAME verwenden die folgenden Flags mit hohen Wörtern.
| Wert | Bedeutung |
|---|---|
|
Durch das Festlegen dieses Flags werden alle Ergänzungen in den Speicher oder änderungen an Eigenschaften von Kontexten im Speicher in den Dateispeicher committet, entweder wenn CertCloseStore aufgerufen wird oder certControlStore mit CERT_STORE_CONTROL_COMMIT aufgerufen wird.
CertOpenStore schlägt mit E_INVALIDARG fehl, wenn sowohl CERT_FILE_STORE_COMMIT_ENABLE als auch CERT_STORE_READONLY_FLAG in dwFlags festgelegt sind. |
Der anbietertyp CERT_STORE_PROV_LDAP verwendet die folgenden High-Word-Flags.
| Wert | Bedeutung |
|---|---|
|
Führt eine reine A-Record-DNS-Suche für die URL aus, die im pvPara-Parameter benannt ist. Dadurch wird verhindert, dass beim Auflösen von URL-Hostnamen falsche DNS-Abfragen generiert werden. Verwenden Sie dieses Flag, wenn Sie einen Hostnamen im Gegensatz zu einem Domänennamen für den pvPara-Parameter übergeben. |
|
Verwenden Sie dieses Flag, um eine vorhandene LDAP-Sitzung zu verwenden. Wenn dieses Flag angegeben wird, ist der pvPara-Parameter die Adresse einer CERT_LDAP_STORE_OPENED_PARA Struktur, die Informationen zur zu verwendenden LDAP-Sitzung enthält. |
|
Um die für einige Anwendungen erforderliche Integrität bereitzustellen, müssen Sie den gesamten LDAP-Datenverkehr zu und von einem LDAP-Server mithilfe des Kerberos-Authentifizierungsprotokolls digital signieren. |
|
Verwenden Sie dieses Flag mit dem flag CERT_LDAP_STORE_OPENED_FLAG , damit die LDAP-Sitzung beim Schließen des Speichers aufgehoben wird. Das System hebt die Bindung der LDAP-Sitzung mithilfe der funktion ldap_unbind auf, wenn der Speicher geschlossen wird. |
[in] pvPara
Ein 32-Bit-Wert, der zusätzliche Informationen für diese Funktion enthalten kann. Der Inhalt dieses Parameters hängt vom Wert des lpszStoreProvider und anderer Parameter ab.
Rückgabewert
Wenn die Funktion erfolgreich ist, gibt die Funktion ein Handle an den Zertifikatspeicher zurück. Wenn Sie die Verwendung des Speichers abgeschlossen haben, geben Sie das Handle frei, indem Sie die CertCloseStore-Funktion aufrufen.
Wenn bei der Funktion ein Fehler auftritt, gibt sie NULL zurück. Rufen Sie GetLastError auf, um erweiterte Fehlerinformationen zu erhalten.
Hinweise
Ein Systemspeicher ist eine Sammlung, die aus mindestens einem physischen gleichgeordneten Speicher besteht. Für jeden Systemspeicher gibt es vordefinierte physische gleichgeordnete Speicher. Nach dem Öffnen eines Systemspeichers wie "My" in CERT_SYSTEM_STORE_CURRENT_USER wird CertOpenStore aufgerufen, um alle physischen Speicher in der Systemspeichersammlung zu öffnen. Jeder dieser physischen Speicher wird der Systemspeichersammlung mithilfe der CertAddStoreToCollection-Funktion hinzugefügt. Alle Zertifikate, Zertifikatsperrlisten und CTLs in diesen physischen Speicher sind über die logische Systemspeichersammlung verfügbar.
Die folgenden Systemspeicherorte können remote geöffnet werden:
- CERT_SYSTEM_STORE_LOCAL_MACHINE
- CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY
- CERT_SYSTEM_STORE_SERVICES
- CERT_SYSTEM_STORE_USERS
Systemspeicherorte werden remote geöffnet, indem dem Speichernamen in der an pvPara übergebenen Zeichenfolge der Computername vorangestellt wird. Beispiele für Remotesystemspeichernamen sind:
- ComputerName\CA
- \\ComputerName\CA
- ComputerName\ServiceName\Trust
- \\ComputerName\ServiceName\Trust
Weitere Informationen zu Systemspeichern finden Sie unter Systemspeicherorte.
Weitere Informationen zu den Speicher, die automatisch migriert werden, finden Sie unter Zertifikatspeichermigration.
Beispiele
Das folgende Beispiel zeigt das Öffnen mehrerer Zertifikatspeicher mit unterschiedlichen Speicheranbietertypen. Im Beispiel wird die CreateMyDACL-Funktion verwendet, die im Thema Erstellen einer DACL definiert ist, um sicherzustellen, dass die geöffnete Datei mit einer ordnungsgemäßen DACL erstellt wird. Weitere Beispiele für das Öffnen anderer Speicheranbietertypen finden Sie unter Beispiel-C-Code zum Öffnen von Zertifikatspeichern.
//-------------------------------------------------------------------
// 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");
}
Anforderungen
| Anforderung | Wert |
|---|---|
| Unterstützte Mindestversion (Client) | Windows XP [Desktop-Apps | UWP-Apps] |
| Unterstützte Mindestversion (Server) | Windows Server 2003 [Desktop-Apps | UWP-Apps] |
| Zielplattform | Windows |
| Kopfzeile | wincrypt.h |
| Bibliothek | Crypt32.lib |
| DLL | Crypt32.dll |
Weitere Informationen
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für