def traiter_reception_certificat(self, pems):
        cert = pems[0]
        clecert = EnveloppeCleCert()
        clecert.cert_from_pem_bytes(cert.encode('utf-8'))
        subject_dict = clecert.formatter_subject()
        role = subject_dict['organizationalUnitName']

        if role == 'mongo':
            # Pour MongoDB on insere la cle (en memoire) et le nouveau certificat dans le meme secret (une key_cert)
            label_role_cert = 'pki.%s.cert' % role
            label_role_key = 'pki.%s.key' % role

            chaine = '\n'.join(pems)
            cle_mongo = self._recuperer_cle_memorisee(
                role)  # Note : efface la cle en memoire
            if not cle_mongo:
                raise ValueError("Cle mongo n'est pas presente en memoire")
            key_cert = str(cle_mongo, 'utf-8') + '\n' + chaine

            # Inserer la chaine de certificat
            nom_cle = self._service_monitor.gestionnaire_certificats.ajouter_secret(
                label_role_key, key_cert)
            date_key = nom_cle.split('.')[-1]
            self._service_monitor.gestionnaire_certificats.ajouter_config(
                label_role_cert, chaine, date_key)
        else:
            super().traiter_reception_certificat(pems)
    def preparer_fichiers(self):
        # Creer nouveau repertoire temporaire pour fichiers

        self.__temp_folder = tempfile.mkdtemp(dir='/tmp')
        os.chmod(self.__temp_folder, mode=0o700)

        chaine_hote = '\n'.join(self.__config_hebergement['chaine_hote'])
        fp, fichier_chaine_hote = tempfile.mkstemp(suffix='.pem',
                                                   dir=self.__temp_folder)
        os.write(fp, chaine_hote.encode('utf-8'))
        os.close(fp)

        chaine_cert = '\n'.join(self.__config_hebergement['chaine_cert'])
        fp, fichier_chaine_cert = tempfile.mkstemp(suffix='.pem',
                                                   dir=self.__temp_folder)
        os.write(fp, chaine_cert.encode('utf-8'))
        os.close(fp)

        cert_millegrille = self.__config_hebergement['millegrille']
        fp, fichier_cert_millegrille = tempfile.mkstemp(suffix='.pem',
                                                        dir=self.__temp_folder)
        os.write(fp, cert_millegrille.encode('utf-8'))
        os.close(fp)

        cle = self.__config_hebergement['cle']
        fp, fichier_cle = tempfile.mkstemp(suffix='.pem',
                                           dir=self.__temp_folder)
        os.write(fp, cle.encode('utf-8'))
        os.close(fp)

        # Batir chaine avec certificat XS pour connecter au middleware hote
        self.__parametres[Constantes.CONFIG_MQ_CERTFILE] = fichier_chaine_hote
        self.__parametres[Constantes.CONFIG_MQ_KEYFILE] = fichier_cle

        # Batir PKI pour la MilleGrille hebergee, avec son propre certificat de millegrille
        self.__parametres[Constantes.CONFIG_PKI_CERTFILE] = fichier_chaine_cert
        self.__parametres[Constantes.CONFIG_PKI_KEYFILE] = fichier_cle
        self.__parametres[
            Constantes.CONFIG_PKI_CERT_MILLEGRILLE] = fichier_cert_millegrille

        # Override de l'info intermediaire, garde les fichiers en memoire
        intermediaire_clecert = self.__config_hebergement.get(
            'intermediaire_clecert')
        if intermediaire_clecert:
            self.__parametres[
                Constantes.
                CONFIG_PKI_CLECERT_INTERMEDIAIRE] = intermediaire_clecert

        # Charger idmg a partir du certificat
        cert = self.__config_hebergement['chaine_hote'][0]
        clecert = EnveloppeCleCert()
        clecert.cert_from_pem_bytes(cert.encode('utf-8'))
        subject = clecert.formatter_subject()
        self.__parametres[Constantes.CONFIG_IDMG] = subject['organizationName']
    def traiter_reception_certificat(self, pems):
        cert = pems[0]
        clecert = EnveloppeCleCert()
        clecert.cert_from_pem_bytes(cert.encode('utf-8'))
        subject_dict = clecert.formatter_subject()
        role = subject_dict['organizationalUnitName']

        # Trouver cle correspondante (date)
        label_role_cert = 'pki.%s.cert' % role
        label_role_key = 'pki.%s.key' % role
        info_role_key = self._service_monitor.gestionnaire_docker.trouver_secret(
            label_role_key)
        date_key = info_role_key['date']

        # Inserer la chaine de certificat
        chaine = '\n'.join(pems)
        self._service_monitor.gestionnaire_certificats.ajouter_config(
            label_role_cert, chaine, date_key)