> For the complete documentation index, see [llms.txt](https://docs.medcrypt.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.medcrypt.com/fr/guardian/understand-device-provisioning/extract-certificates-from-provisioned-devices.md). # Extraire les certificats des dispositifs provisionnés ## Extraire les certificats via l’API L’extraction des clés et des certificats via l’API Guardian consiste à utiliser la bibliothèque Guardian pour effectuer les deux étapes d’extraction des certificats et des clés. ### **Exemple en C#** ```csharp public static void GetKeyAndCerts() { medcrypt.guardian.InitializeFiles initializeFiles = new medcrypt.guardian.InitializeFiles(); /* lire les fichiers provisionnés dans la structure de fichiers */ initializeFiles.trustStore = File.ReadAllBytes(@"TrustStore.mcts"); initializeFiles.privateIdentity = File.ReadAllBytes(@"PrivateIdentity.mcpi"); initializeFiles.certifiedProfile = File.ReadAllBytes(@"CertifiedProfile.mcp"); /* données client concernant le système de provisionnement */ string componentHandle = "my_component_handle"; string hardwareId = "my_serial_number"; string serviceName = "my_service_name"; /* accepter les options d’entrée ou créer les options par défaut */ medcrypt.guardian.InitializeOptions options = new medcrypt.guardian.InitializeOptions(); /* initialiser Guardian pour les opérations configurées (clé et certificat)*/ medcrypt.guardian.Guardian gdn = new medcrypt.guardian.Guardian(); gdn.Initialize( initializeFiles, componentHandle, hardwareId, new medcrypt.guardian.InitializeOptions()); List certs = null; byte[] key = null; medcrypt.guardian.IService service = gdn.FindService(serviceName); /* obtenir la clé */ key = service.GetCertificateKey(KeyFormat.PKCS8_PEM); /* obtenir la longueur de la chaîne de certificats et ajouter tous les certificats à la liste de sortie */ ulong chainLen = service.GetCertificateChainLength(); certs = new List(); for (ulong i = 0; i < chainLen; i++) { certs.Add(service.GetCertificate(i, CertFormat.PEM)); } } ``` ### **Exemple en C++** ```cpp #include "medcrypt/guardian/GuardianSystem.h" #include "medcrypt/guardian/Utilities/Files/FileHelpers.h" #define MSG(x) { printf x; printf("\n"); } #define MSG_INFO(x) { MSG(x); } #define MSG_ERROR(x) { printf("ERROR: "); MSG(x); } #define MSG_WARNING(x) { printf("WARNING: "); MSG(x); } #define ARBITRARY_KEY_SIZE 128 #define ARBITRARY_CERT_SIZE 3 * 1024 bool GetKeyAndCerts() { medcrypt::guardian::Status status; medcrypt::guardian::utilities::InitializeFiles in_files; std::string in_component_handle = "my_component_handle"; std::string in_hardware_id = "my_serial_number"; std::string in_provisioning_profile_folder = "/path/to/provisioned/profile/folder/"; std::string in_service_name = "my_service_name"; /* initialiser Guardian fourni */ medcrypt::guardian::Guardian guardian; status = guardian.Initialize( in_files, in_component_handle.c_str(), in_hardware_id.c_str(), medcrypt::guardian::InitializeOptions()); /* vérifier et afficher le code d’erreur différent de OK */ if (EXTRACT_STATUS(status) != medcrypt::guardian::GuardianStatusEnum::OK) { MSG_ERROR(("could not initialize guardian [%s]", medcrypt::guardian::GuardianStatusEnum::NameOf( EXTRACT_STATUS(status)).c_str())); return false; } std::unique_ptr service; /* rechercher le service souhaité par son nom */ status = guardian.FindService(in_service_name.c_str(), &service); /* vérifier et afficher le code d’erreur différent de OK */ if (EXTRACT_STATUS(status) != medcrypt::guardian::GuardianStatusEnum::OK) { MSG_ERROR(("could not find service [%s] [%s]", in_service_name.c_str(), medcrypt::guardian::GuardianStatusEnum::NameOf( EXTRACT_STATUS(status)).c_str())); return false; } std::list> io_certs; std::vector io_key; io_key.assign(ARBITRARY_KEY_SIZE, '\0'); size_t size = io_key.size(); /* récupérer la clé encodée au format PKCS8 */ status = service->GetCertificateKey(io_key.data(), &size); if (EXTRACT_STATUS(status) != medcrypt::guardian::GuardianStatusEnum::OK) { MSG_ERROR(("could not retrieve key [%s]", medcrypt::guardian::GuardianStatusEnum::NameOf( EXTRACT_STATUS(status)).c_str())); return false; } io_key.resize(size); /* récupérer les certificats disponibles dans la chaîne de certificats */ size_t chain_length = service->GetCertificateChainLength(); io_certs.clear(); for (size_t i = 0; i < chain_length; i++) { io_certs.emplace_back(); size = service->GetCertificateSize(i); io_certs.back().assign(size, '\0'); /* récupérer le certificat */ status = service->GetCertificate( i, io_certs.back().data(), &size); if (EXTRACT_STATUS(status) != medcrypt::guardian::GuardianStatusEnum::OK) { MSG_ERROR(("could not retrieve cert [%u] [%s]", (unsigned int)i, medcrypt::guardian::GuardianStatusEnum::NameOf( EXTRACT_STATUS(status)).c_str())); return false; } } return true; } ``` ### ### Exemple en C ```c #define MAX_GDN_SIZE 15 * 1024 /* augmenter si nécessaire, cette mémoire n'a pas besoin d'être allouée sur la pile */ #define ARBITRARY_BUF_SIZE 5 * 1024 /* augmenter si nécessaire */ #define ARBITRARY_KEY_SIZE 128 #define ARBITRARY_CERT_SIZE 3 * 1024 #define LEAF_CERT_IDX 0 /* Exemple de configuration d'un rappel d'écriture à utiliser par les flux Guardian */ static bool sample_callback(mcg_guardian_ostream_t *stream, const uint8_t *buf, size_t count) { size_t i; uint8_t *dest = (uint8_t*)stream->state; stream->state = dest + count; for (i = 0; i < count; i++) dest[i] = buf[i]; return true; } static bool get_key_and_certs() { mcg_status status = MCG_STATUS_FAIL; mcg_initialize_options_t init_options = {0}; mcg_initialize_files_t init_files; mcg_guardian_istream_t ts, pi, cp; size_t cert_chain_path_length = 0; size_t cert_chain_length = 0; /* créer la région mémoire Guardian ; cette mémoire peut provenir de n'importe quelle source mais doit constituer un bloc contigu */ mcg_memory_t mcg_memory = {NULL, 0, 0}; uint8_t memory_buffer[MAX_GDN_SIZE] = {0}; mcg_memory.mem = &memory_buffer[0]; mcg_memory.size = sizeof(memory_buffer); /* données client concernant ce système de provisionnement */ char component_handle[] = "my_component"; char hardware_id[] = "my_serial_number"; char service_name[] = "my_service"; /* lire le magasin de confiance dans ce tampon et définir in_ts_len à sa taille réelle */ uint8_t in_ts[ARBITRARY_BUF_SIZE] = {0}; size_t in_ts_len = 1234; /* lire l'identité privée dans ce tampon et définir in_pi_len à sa taille réelle */ uint8_t in_pi[ARBITRARY_BUF_SIZE] = {0}; size_t in_pi_len = 1234; /* lire le profil certifié dans ce tampon et définir in_cp_len à sa taille réelle */ uint8_t in_cp[ARBITRARY_BUF_SIZE] = {0}; size_t in_cp_len = 1234; /* tampons de sortie */ uint8_t io_key_buf[ARBITRARY_BUF_SIZE] = {0}; size_t io_key_buf_len = sizeof(io_key_buf); uint8_t io_cert_buf[ARBITRARY_BUF_SIZE] = {0}; size_t io_cert_buf_len = sizeof(io_cert_buf); mcg_guardian_ostream_t out_key; mcg_guardian_ostream_t out_cert; /* Créer des flux à partir des tampons d’octets ts/pi/cp fournis */ ts = mcg_istream_from_buffer((const uint8_t*)in_ts, in_ts_len); pi = mcg_istream_from_buffer((const uint8_t*)in_pi, in_pi_len); cp = mcg_istream_from_buffer((const uint8_t*)in_cp, in_cp_len); /* Charger les flux dans mcg_initialize_files_t */ init_files.trust_store = &ts; init_files.private_identity = π init_files.certified_profile = &cp; status = mcg_gdn_initialize( &mcg_memory, &init_files, component_handle, hardware_id, &init_options); if (status) { /* Retourner un échec */ return false; } /* configurer le flux de sortie de clé adossé à un tampon */ out_key.write_callback = &sample_callback; out_key.max_size = io_key_buf_len; out_key.bytes_written = 0; out_key.state = io_key_buf; status = mcg_gdn_write_key(&mcg_memory, service_name, true, /* true = PEM, false = DER */ &out_key); if (status) { printf("Échec de l’écriture de la clé"); return false; } /* configurer le flux de sortie d’un certificat unique adossé à un tampon */ out_cert.write_callback = &sample_callback; out_cert.max_size = io_cert_buf_len; out_cert.bytes_written = 0; out_cert.state = io_cert_buf; status = mcg_gdn_write_cert(&mcg_memory, service_name, LEAF_CERT_IDX, /* Remarque : écrit uniquement un seul certificat */ true, /* true = PEM, false = DER */ &out_cert); if (status) { printf("Échec de l’écriture du certificat"); return false; } return true; } ``` ## Extraire des certificats en ligne de commande Cette section explique comment utiliser un appareil provisionné pour extraire les clés et les certificats préconfigurés du profil certifié (CP) de cet appareil. L’extraction de certificats en ligne de commande consiste à utiliser l’utilitaire `mcguard_cert_extract` pour effectuer les étapes suivantes d’extraction des certificats et des clés : 1. Initialiser Guardian avec le profil certifié de l’appareil. 2. Extraire la clé et les certificats souhaités. * Tous les utilitaires en ligne de commande utilisent une approche fondée sur un répertoire de travail. Lors de l’extraction des certificats, l’utilitaire `mcguard_cert_extract` s’attend à trouver un fichier `.mcts`, `.mcpip` et un fichier `.mcpp` dans le répertoire de travail. * Tout argument entre chevrons <> doit être remplacé par les données d’entrée indiquées (par exemple, si le handle du composant est device1, `` , il peut être remplacé par `device1`). ```bash # Syntaxe ./mcguard_cert_extract --component --hardware-id --service --key-dir --cert-dir # Exemple ./mcguard_cert_extract --component my_device --hardware-id my_device_001 --service my_service --key-dir /home/user/guardian/keys --cert-dir /home/user/guardian/certs /home/user/guardian/provisioned_profile ``` --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://docs.medcrypt.com/fr/guardian/understand-device-provisioning/extract-certificates-from-provisioned-devices.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.