1
2
3
4
5
6
7
8
9
10
11
12
13 """module de gestion de prelude
14 """
15 from twisted.internet.utils import getProcessOutput
16 from zephir.backend.db_utils import *
17 from zephir.backend import config
18 from zephir.backend.config import u
19 from zephir.backend.xmlrpceole import XMLRPCEole as XMLRPC
20 from zephir.backend.lib_backend import ResourceAuthError
21 from zephir.eolerpclib import xmlrpclib, EoleProxy
22 import sys,os,shutil,time,base64
23 from zephir.backend.uucp_utils import uucp_pool
24 from creole import cert
25 from creole.config import rsyslog_ca_file, rsyslog_ca_template
26 from creole.parsedico import parse_dico
27
29 """serveur XMLRPC zephir pour la gestion de prélude
30 """
31
33 self.dbpool = db_connect()
34 self.dbpool.noisy = 0
35 XMLRPC.__init__(self)
36 self.parent = parent
37
39 """négocie l'enregistrement d'une sonde prelude dans prelude manager
40 id_serveur : identifiant zephir du serveur sonde
41
42 -génère un mot de passe aléatoire
43 -demande le lancement de prelude-adduser sur le manager
44 -renvoie le mot de passe pour permettre l'enregistrement côté sonde
45 """
46
47 cmd_pass = getProcessOutput("/usr/bin/pwgen",
48 args = ["-B","-s","-1"],
49 env = {'LC_ALL': 'C'})
50 return cmd_pass.addCallback(self._register_server, cred_user, id_manager)
51
53 """
54 Callback de la fonction xmlrpc_register_server.
55 """
56 passwd = output.strip()
57
58 try:
59
60 serv = self.parent.s_pool.get(cred_user, int(id_manager))
61 key = file(os.path.join(serv.get_confdir(), 'cle_publique')).read()
62 try:
63 ip_manager = serv.parsedico()['adresse_ip_eth0']
64 except:
65 return 0, u("""Adresse ip du manager %s non disponible""" % id_manager)
66 manager_rpc = EoleProxy('https://%s:%s' % (ip_manager, config.PRELUDE_PORT))
67 res = manager_rpc.register_server(xmlrpclib.base64.encodestring(key),passwd)
68 except:
69 import traceback
70 traceback.print_exc()
71 res = 0
72 if res == 1:
73 return 1, u(passwd)
74 elif res == -1:
75 return -1, u("""Un enregistrement est déjà en cours""")
76 else:
77 return 0, u("""Impossible de lancer prelude-adduser sur le manager""")
78
80 """renvoie l'adresse du manager défini sur zephir si il existe"""
81
82 if module == '':
83
84 managers = {}
85 for id_serv in self.parent.s_pool.keys():
86 try:
87 serv = self.parent.s_pool.get(cred_user, id_serv)
88 except:
89
90 continue
91 conf = serv.parsedico()
92 if conf.get('activer_reception_logs','non') == 'oui':
93 if conf.get('activer_reception_logs_tcp','non') == 'oui':
94 if conf.get('rsyslog_reception_tls','non') == 'oui':
95 managers[str(id_serv)] = [conf.get('adresse_ip_eth0',''), serv.libelle]
96 return 1, u(managers)
97 else:
98 query = """select distinct(serveurs.id), serveurs.libelle from serveurs, modules where\
99 serveurs.module_actuel=modules.id and modules.libelle like %s"""
100 return self.dbpool.runQuery(query, ('%s-%%' % module, )).addCallbacks(self._get_managers, db_client_failed, callbackArgs=[cred_user])
101
103 """
104 Callback de la fonction xmlrpc_get_managers.
105 """
106 if data == []:
107
108 return 1, {}
109 else:
110 managers = {}
111 for manager in data:
112 id_man = int(manager[0])
113 libelle = manager[1]
114
115 serv = self.parent.s_pool.get(cred_user, id_man)
116 try:
117 ip = serv.parsedico()['adresse_ip_eth0']
118 except:
119
120 ip = ''
121 if ip != '':
122 managers[str(id_man)]=[ip, libelle]
123
124 return 1, u(managers)
125
126 - def xmlrpc_gen_certif(self, cred_user, request_data, id_serveur, id_zephirlog=None):
127 """
128 Récupère les données d'une requête et enregistre la configuration
129 rsyslog dans le répertoire adéquat.
130 @request_data : dictionnaire contenant le contenu de la requête
131 (entrée request), le modèle pour générer le
132 certificat (entrée template) et la configuration
133 pour rsyslog.
134 @id_serveur : identifiant zephir du serveur demandant la génération
135 du certificat
136 @id_zephirlog (optionnel) : identifiant zephir du zephirlog concerné
137 par l'appairage.
138 """
139 rsyslog_privkey = '/etc/ssl/private/rsyslog_privkey.pem'
140 serveur_rsyslog_conf = 'rsyslog/zephirlog'
141 client_rsyslog_conf = 'rsyslog/client'
142
143 if id_zephirlog:
144 zephirlog_dest = self.parent.s_pool.get(cred_user, int(id_zephirlog))
145 write_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), client_rsyslog_conf)
146 read_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), serveur_rsyslog_conf)
147 else:
148 zephirlog_dest = self.parent.s_pool.get(cred_user, int(id_serveur))
149 write_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), serveur_rsyslog_conf)
150 read_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), client_rsyslog_conf)
151
152 if not os.path.exists(write_path_rsyslog_conf):
153 os.makedirs(write_path_rsyslog_conf, 0755)
154 if not os.path.exists(read_path_rsyslog_conf):
155 os.makedirs(read_path_rsyslog_conf, 0755)
156
157 rsyslog_conf_file = os.path.join(write_path_rsyslog_conf, str(id_serveur) + '.peer')
158 rsyslog_file = open(rsyslog_conf_file, 'w')
159 rsyslog_file.write(xmlrpclib.base64.decodestring(request_data['rsyslog']))
160 rsyslog_file.close()
161
162 if id_zephirlog and os.path.exists(rsyslog_conf_file):
163 id_uucp = str(zephirlog_dest.get_rne()) + '-' + str(zephirlog_dest.id_s)
164 res = uucp_pool.add_cmd(id_uucp, "zephir_client get_rsyslog_conf")
165
166 serv = self.parent.s_pool.get(cred_user, int(id_serveur))
167 path_request = os.path.join(serv.get_confdir(), "request.pem")
168 file_request = open(path_request, "w")
169 file_request.write(xmlrpclib.base64.decodestring(request_data['request']))
170 file_request.close()
171 path_request_template = os.path.join(serv.get_confdir(), "request-template.tmpl")
172 file_request_template = open(path_request_template, "w")
173 file_request_template.write(xmlrpclib.base64.decodestring(request_data['template']))
174 file_request_template.close()
175 path_cert = os.path.join(serv.get_confdir(), "rsyslog_cert.pem")
176
177 if not os.path.exists(rsyslog_privkey):
178 cert.gen_privkey(rsyslog_privkey)
179 if not os.path.exists(rsyslog_ca_file):
180 cert.gen_selfsigned_cert(rsyslog_ca_template, rsyslog_privkey, path_cert=rsyslog_ca_file)
181
182 cmd_pass = getProcessOutput("/usr/bin/certtool",
183 args = ["--generate-certificate",
184 "--load-request", path_request,
185 "--outfile", path_cert,
186 "--load-ca-certificate", rsyslog_ca_file,
187 "--load-ca-privkey", rsyslog_privkey,
188 "--template", path_request_template],
189 env = {'LC_ALL': 'C'},
190 errortoo=True)
191 return cmd_pass.addCallback(self._gen_certif, cred_user, path_cert, read_path_rsyslog_conf)
192
193 - def _gen_certif(self, output, cred_user, path_cert, path_rsyslog_conf):
194 """
195 Retourne le certificat et la configuration de rsyslog si elle est
196 disponible.
197 @path_cert : le chemin du certificat à retransmettre
198 @path_rsyslog_conf : répertoire contenant les bouts de conf
199 pour rsyslog. Les contenus de tous les fichiers présents sont
200 concaténés pour être envoyés.
201 """
202
203 result = {}
204 ca_file = open(rsyslog_ca_file, 'r')
205 result['ca_data'] = xmlrpclib.base64.encodestring(ca_file.read())
206 ca_file.close()
207 cert_file = open(path_cert, 'r')
208 result['cert_data'] = xmlrpclib.base64.encodestring(cert_file.read())
209 cert_file.close()
210
211 if os.path.exists(path_rsyslog_conf):
212 rsyslog_data = []
213 for rsyslog_conf in [i for i in os.listdir(path_rsyslog_conf) if i[-5:] == '.peer']:
214 rsyslog_conf = open(os.path.join(path_rsyslog_conf, rsyslog_conf), 'r')
215 rsyslog_data.append(rsyslog_conf.read())
216 rsyslog_conf.close()
217
218 result['rsyslog_data'] = xmlrpclib.base64.encodestring('\n'.join(rsyslog_data))
219
220 return 1, result
221
223 """
224 Récupère les données d'une requête et enregistre la configuration
225 rsyslog dans le répertoire adéquat.
226 @request_data : dictionnaire contenant le contenu de la requête
227 (entrée request), le modèle pour générer le
228 certificat (entrée template) et la configuration
229 pour rsyslog.
230 @id_serveur : identifiant zephir du serveur demandant la génération
231 du certificat
232 @id_zephirlog (optionnel) : identifiant zephir du zephirlog concerné
233 par l'appairage.
234 """
235
236 serveur_rsyslog_conf = 'rsyslog/zephirlog'
237 client_rsyslog_conf = 'rsyslog/client'
238
239 if id_zephirlog:
240 zephirlog_dest = self.parent.s_pool.get(cred_user, int(id_zephirlog))
241 read_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), serveur_rsyslog_conf)
242 else:
243 zephirlog_dest = self.parent.s_pool.get(cred_user, int(id_serveur))
244 read_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), client_rsyslog_conf)
245
246 return self._get_rsyslog_conf(1, cred_user, read_path_rsyslog_conf)
247
249 """
250 Retourne la configuration de rsyslog.
251 @path_rsyslog_conf : répertoire contenant les bouts de configuration.
252 """
253 rsyslog_data = []
254 for rsyslog_conf in [i for i in os.listdir(path_rsyslog_conf) if i[-5:] == '.peer']:
255 rsyslog_conf = open(os.path.join(path_rsyslog_conf, rsyslog_conf), 'r')
256 rsyslog_data.append(rsyslog_conf.read())
257 rsyslog_conf.close()
258
259 return 1, xmlrpclib.base64.encodestring('\n'.join(rsyslog_data))
260
261
263 """permet de vérifier si des serveurs ont été modifiés
264 """
265 return 1, u("""Fonction non implémentée""")
266