def commande_restaurer_backup_cle(self):
with open ('/home/mathieu/mgdev/certs/pki.connecteur.key', 'rb') as fichier:
key_bytes = fichier.read()
clecert = EnveloppeCleCert()
clecert.key_from_pem_bytes(key_bytes, None)
clecert.password = self.mot_de_passe.encode('utf-8')
key_chiffree_bytes = clecert.private_key_bytes
self.cert_maitredescles_recu.wait(5)
mot_de_passe_chiffre, fingerprint = self.certificat_maitredescles.chiffrage_asymmetrique(self.mot_de_passe.encode('utf-8'))
enveloppe = EnveloppeCleCert()
enveloppe.key_from_pem_bytes(key_bytes, None)
requete_cle_racine = {
'cle_privee': key_chiffree_bytes.decode('utf-8'),
'mot_de_passe_chiffre': str(b64encode(mot_de_passe_chiffre), 'utf-8'),
# 'fingerprint_base64': 'Ut/UQ5aKomoGzXB7mpUduPk4Xzg=',
}
enveloppe_requete = self.generateur.transmettre_commande(
requete_cle_racine,
'commande.millegrilles.domaines.MaitreDesCles.%s' % ConstantesMaitreDesCles.COMMANDE_RESTAURER_BACKUP_CLES,
correlation_id='abcd-1234',
reply_to=self.queue_name
)
print("Envoi requete: %s" % enveloppe_requete)
return enveloppe_requete
def charger_certificats(self):
secret_path = path.abspath(self.secret_path)
os.makedirs(secret_path, exist_ok=True) # Creer path secret, au besoin
# Charger information certificat intermediaire
cert_pem = self._charger_certificat_docker('pki.intermediaire.cert')
with open(path.join(secret_path, 'pki.intermediaire.key.pem'),
'rb') as fichiers:
key_pem = fichiers.read()
with open(path.join(secret_path, 'pki.intermediaire.passwd.txt'),
'rb') as fichiers:
passwd_bytes = fichiers.read()
clecert_intermediaire = EnveloppeCleCert()
clecert_intermediaire.from_pem_bytes(key_pem, cert_pem, passwd_bytes)
clecert_intermediaire.password = None # Effacer mot de passe
self._clecert_intermediaire = clecert_intermediaire
# Charger information certificat monitor
cert_pem = self._charger_certificat_docker('pki.monitor.cert')
with open(path.join(secret_path, 'pki.monitor.key.pem'),
'rb') as fichiers:
key_pem = fichiers.read()
clecert_monitor = EnveloppeCleCert()
clecert_monitor.from_pem_bytes(key_pem, cert_pem)
self.clecert_monitor = clecert_monitor
# Conserver reference au cert monitor pour middleware
self.certificats[
GestionnaireCertificats.
MONITOR_CERT_PATH] = self.certificats['pki.monitor.cert']
self.certificats[
GestionnaireCertificats.MONITOR_KEY_FILE] = 'pki.monitor.key.pem'
# with open(path.join(secret_path, ConstantesServiceMonitor.FICHIER_MONGO_MOTDEPASSE), 'r') as fichiers:
# self._passwd_mongo = fichiers.read()
# with open(path.join(secret_path, ConstantesServiceMonitor.FICHIER_MQ_MOTDEPASSE), 'r') as fichiers:
# self._passwd_mq = fichiers.read()
# Charger le certificat de millegrille, chaine pour intermediaire
self._charger_certificat_docker('pki.intermediaire.chain')
self._charger_certificat_docker('pki.millegrille.cert')
self.__charger_renouvelleur()
def recevoir_trousseau(self, trousseaux: dict):
for trousseau in trousseaux:
idmg = trousseau[Constantes.CONFIG_IDMG]
configuration = self._millegrilles[idmg]
configuration[
ConstantesHebergement.CORRELATION_TROUSSEAU_MODULE] = trousseau
# Extraire cle-cert du trousseau
certificat_pem = trousseau[Constantes.ConstantesSecurityPki.
LIBELLE_CERTIFICAT_PEM].encode('utf-8')
cle_pem = trousseau['cle'].encode('utf-8')
motdepasse_chiffre = trousseau['motdepasse_chiffre']
# Dechiffrer mot de passe, charger cle privee et certificat
signateur = self.contexte.signateur_transactions
motdepasse = signateur.dechiffrage_asymmetrique(
motdepasse_chiffre.encode('utf-8'))
clecert = EnveloppeCleCert()
clecert.from_pem_bytes(cle_pem, certificat_pem, motdepasse)
clecert.password = None
configuration['clecert'] = clecert
certificats = trousseau['certificats']
# Au besoin, charger cle et passwd intermediaire (pour maitre des cles)
intermediaire_passwd_chiffre = trousseau.get(
'intermediaire_passwd')
intermediaire_cle = trousseau.get('intermediaire_cle')
intermediaire_cert = certificats['intermediaire']
if intermediaire_passwd_chiffre and intermediaire_cle:
intermediaire_passwd = signateur.dechiffrage_asymmetrique(
intermediaire_passwd_chiffre.encode('utf-8'))
# Verifier que la cle fonctionne
clecert_intermediaire = EnveloppeCleCert()
clecert_intermediaire.from_pem_bytes(
intermediaire_cle.encode('utf-8'),
intermediaire_cert.encode('utf-8'), intermediaire_passwd)
clecert_intermediaire.password = None
configuration['intermediaire_clecert'] = clecert_intermediaire
# Charger la chaine de certificats pour se connecter a l'hote
certificat_pem_str = str(certificat_pem, 'utf-8')
chaine_hote = [
certificat_pem_str,
certificats['hebergement'],
certificats['hote_pem'],
]
chaine_cert = [
certificat_pem_str,
intermediaire_cert,
]
configuration['chaine_hote'] = chaine_hote
configuration['chaine_cert'] = chaine_cert
configuration['millegrille'] = certificats['millegrille']
configuration['cle'] = str(clecert.private_key_bytes, 'utf-8')
self.ajouter_compte(idmg, chaine_hote)