client.py 41.7 KB
Newer Older
Daniel Stan's avatar
Daniel Stan committed
1 2
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
3 4 5 6 7 8 9

"""Gestion centralisée des mots de passe avec chiffrement GPG

Copyright (C) 2010-2013 Cr@ns <roots@crans.org>
Authors : Daniel Stan <daniel.stan@crans.org>
          Vincent Le Gallic <legallic@crans.org>
"""
Daniel Stan's avatar
Daniel Stan committed
10

Vincent Le gallic's avatar
Vincent Le gallic committed
11 12
from __future__ import print_function

13
# Import builtins
Daniel Stan's avatar
Daniel Stan committed
14 15 16
import sys
import subprocess
import json
17 18 19
import tempfile
import os
import atexit
Daniel Stan's avatar
Daniel Stan committed
20
import argparse
21
import re
22 23
import random
import string
24
import time
25
import datetime
26
import copy
27 28

# Import de la config
29
envvar = "CRANSPASSWORDS_CLIENT_CONFIG_DIR"
30
try:
31 32 33
    # Oui, le nom de la commande est dans la config, mais on n'a pas encore accès à la config
    bootstrap_cmd_name = os.path.split(sys.argv[0])[1]
    sys.path.append(os.path.expanduser("~/.config/%s/" % (bootstrap_cmd_name,)))
34 35
    import clientconfig as config
except ImportError:
36 37 38
    ducktape_display_error = sys.stderr.isatty() and \
              not any([opt in sys.argv for opt in ["-q", "--quiet"]]) and \
              __name__ == '__main__'
39 40 41 42
    envspecified = os.getenv(envvar, None)
    if envspecified is None:
        if ducktape_display_error:
            sys.stderr.write(u"Va lire le fichier README.\n".encode("utf-8"))
43
            sys.exit(1)
44 45 46 47 48 49 50 51 52
    else:
        # On a spécifié à la main le dossier de conf
        try:
            sys.path.append(envspecified)
            import clientconfig as config
        except ImportError:
            if ducktape_display_error:
                sys.stderr.write(u"%s est spécifiée, mais aucune config pour le client ne peut être importée." % (envvar))
                sys.exit(1)
Daniel Stan's avatar
Daniel Stan committed
53

54 55
#: Pattern utilisé pour détecter la ligne contenant le mot de passe dans les fichiers
pass_regexp = re.compile('[\t ]*pass(?:word)?[\t ]*:[\t ]*(.*)\r?\n?$',
56 57
        flags=re.IGNORECASE)

Daniel Stan's avatar
Daniel Stan committed
58
## GPG Definitions
59
#: Path du binaire gpg
60
GPG = 'gpg'
61 62

#: Paramètres à fournir à gpg en fonction de l'action désirée
Daniel Stan's avatar
Daniel Stan committed
63
GPG_ARGS = {
64 65 66
    'decrypt' : ['-d'],
    'encrypt' : ['--armor', '-es'],
    'receive-keys' : ['--recv-keys'],
67 68
    'list-keys' : ['--list-keys', '--with-colons', '--fixed-list-mode',
                   '--with-fingerprint', '--with-fingerprint'], # Ce n'est pas une erreur. Il faut 2 --with-fingerprint pour avoir les fingerprints des subkeys.
Daniel Stan's avatar
Daniel Stan committed
69
    }
70 71

#: Mapping (lettre de trustlevel) -> (signification, faut-il faire confiance à la clé)
72
GPG_TRUSTLEVELS = {
73 74 75
                    u"-" : (u"inconnue (pas de valeur assignée)", False),
                    u"o" : (u"inconnue (nouvelle clé)", False),
                    u"i" : (u"invalide (self-signature manquante ?)", False),
76 77 78 79
                    u"n" : (u"nulle (il ne faut pas faire confiance à cette clé)", False),
                    u"m" : (u"marginale (pas assez de lien de confiance vers cette clé)", False),
                    u"f" : (u"entière (clé dans le réseau de confiance)", True),
                    u"u" : (u"ultime (c'est probablement ta clé)", True),
80 81
                    u"r" : (u"révoquée", False),
                    u"e" : (u"expirée", False),
82
                    u"q" : (u"non définie", False),
83
                  }
84

85
def gpg(options, command, args=None):
Daniel Stan's avatar
Daniel Stan committed
86
    """Lance gpg pour la commande donnée avec les arguments
87
    donnés. Renvoie son entrée standard et sa sortie standard."""
Daniel Stan's avatar
Daniel Stan committed
88 89 90 91
    full_command = [GPG]
    full_command.extend(GPG_ARGS[command])
    if args:
        full_command.extend(args)
92
    if options.verbose:
93
        stderr = sys.stderr
94
    else:
95
        stderr = subprocess.PIPE
96
        full_command.extend(['--debug-level=1'])
97 98
    if options.verbose:
        print(" ".join(full_command))
Daniel Stan's avatar
Daniel Stan committed
99 100 101
    proc = subprocess.Popen(full_command,
                            stdin = subprocess.PIPE,
                            stdout = subprocess.PIPE,
102
                            stderr = stderr,
Daniel Stan's avatar
Daniel Stan committed
103
                            close_fds = True)
104
    if not options.verbose:
105
        proc.stderr.close()
Daniel Stan's avatar
Daniel Stan committed
106 107
    return proc.stdin, proc.stdout

108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
def _parse_timestamp(string, canbenone=False):
    """Interprète ``string`` comme un timestamp depuis l'Epoch."""
    if string == u'' and canbenone:
        return None
    return datetime.datetime(*time.localtime(int(string))[:7])

def _parse_pub(data):
    """Interprète une ligne ``pub:``"""
    d = {
        u'trustletter' : data[1],
        u'length' : int(data[2]),
        u'algorithm' : int(data[3]),
        u'longid' : data[4],
        u'signdate' : _parse_timestamp(data[5]),
        u'expiredate' : _parse_timestamp(data[6], canbenone=True),
        u'ownertrustletter' : data[8],
        u'capabilities' : data[11],
        }
    return d

def _parse_uid(data):
    """Interprète une ligne ``uid:``"""
    d = {
        u'trustletter' : data[1],
        u'signdate' : _parse_timestamp(data[5], canbenone=True),
        u'hash' : data[7],
        u'uid' : data[9],
        }
    return d

def _parse_fpr(data):
    """Interprète une ligne ``fpr:``"""
    d = {
        u'fpr' : data[9],
        }
    return d

def _parse_sub(data):
    """Interprète une ligne ``sub:``"""
    d = {
        u'trustletter' : data[1],
        u'length' : int(data[2]),
        u'algorithm' : int(data[3]),
        u'longid' : data[4],
        u'signdate' : _parse_timestamp(data[5]),
        u'expiredate' : _parse_timestamp(data[6], canbenone=True),
        u'capabilities' : data[11],
        }
    return d

#: Functions to parse the recognized fields
GPG_PARSERS = {
    u'pub' : _parse_pub,
    u'uid' : _parse_uid,
    u'fpr' : _parse_fpr,
    u'sub' : _parse_sub,
     }

def _gpg_printdebug(d):
    print("current_pub : %r" % d.get("current_pub", None))
    print("current_sub : %r" % d.get("current_sub", None))

def parse_keys(gpgout, debug=False):
    """Parse l'output d'un listing de clés gpg."""
    ring = {}
    init_value = u"initialize" # Valeur utilisée pour dire "cet objet n'a pas encore été rencontré pendant le parsing"
    current_pub = init_value
    current_sub = init_value
    for line in iter(gpgout.readline, ''):
        # La doc dit que l'output est en UTF-8 «regardless of any --display-charset setting»
178 179 180 181 182 183 184 185 186
        try:
            line = line.decode("utf-8")
        except UnicodeDecodeError:
            try:
                line = line.decode("iso8859-1")
            except UnicodeDecodeError:
                line = line.decode("iso8859-1", "ignore")
                if not options.quiet:
                    print("gpg raconte de la merde, c'est ni de l'ISO-8859-1 ni de l'UTF-8, je droppe, ça risque de foirer plus tard.", sys.stderr)
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
        line = line.split(":")
        field = line[0]
        if field in GPG_PARSERS.keys():
            if debug:
                print("\nbegin loop. met %s :" % (field))
                _gpg_printdebug(locals())
            try:
                content = GPG_PARSERS[field](line)
            except:
                print("*** FAILED ***")
                print(line)
                raise
            if field == u"pub":
                # Nouvelle clé
                # On sauvegarde d'abord le dernier sub (si il y en a un) dans son pub parent
                if current_sub != init_value:
                    current_pub["subkeys"].append(current_sub)
                # Ensuite on sauve le pub précédent (si il y en a un) dans le ring
                if current_pub != init_value:
                    ring[current_pub[u"fpr"]] = current_pub
                # On place le nouveau comme pub courant
                current_pub = content
                # Par défaut, il n'a ni subkeys, ni uids
                current_pub[u"subkeys"] = []
                current_pub[u"uids"] = []
                # On oublié l'éventuel dernier sub rencontré
                current_sub = init_value
            elif field == u"fpr":
                if current_sub != init_value:
                    # On a lu un sub depuis le dernier pub, donc le fingerprint est celui du dernier sub rencontré
                    current_sub[u"fpr"] = content[u"fpr"]
                else:
                    # Alors c'est le fingerprint du pub
                    current_pub[u"fpr"] = content[u"fpr"]
            elif field == u"uid":
                current_pub[u"uids"].append(content)
            elif field == u"sub":
                # Nouvelle sous-clé
                # D'abord on sauvegarde la précédente (si il y en a une) dans son pub parent
                if current_sub != init_value:
                    current_pub[u"subkeys"].append(current_sub)
                # On place la nouvelle comme sub courant
                current_sub = content
            if debug:
                _gpg_printdebug(locals())
                print("parsed object : %r" % content)
    # À la fin, il faut sauvegarder les derniers (sub, pub) rencontrés,
    # parce que leur sauvegarde n'a pas encore été déclenchée
    if current_sub != init_value:
        current_pub["subkeys"].append(current_sub)
    if current_pub != init_value:
        ring[current_pub[u"fpr"]] = current_pub
    return ring
240 241 242 243 244 245 246

class simple_memoize(object):
    """ Memoization/Lazy """
    def __init__(self, f):
        self.f = f
        self.val = None

247 248 249 250 251
    def __call__(self, *args, **kwargs):
        """Attention ! On peut fournir des paramètres, mais comme on mémorise pour la prochaine fois,
           si on rappelle avec des paramètres différents, on aura quand même la même réponse.
           Pour l'instant, on s'en fiche puisque les paramètres ne changent pas d'un appel au suivant,
           mais il faudra s'en préoccuper si un jour on veut changer le comportement."""
252
        if self.val == None:
253
            self.val = self.f(*args, **kwargs)
254 255 256 257 258 259
        # On évite de tout deepcopier. Typiquement, un subprocess.Popen
        # ne devrait pas l'être (comme dans get_keep_alive_connection)
        if type(self.val) in [dict, list]:
            return copy.deepcopy(self.val)
        else:
            return self.val
260

261

Daniel Stan's avatar
Daniel Stan committed
262 263 264
######
## Remote commands

265 266 267 268 269 270 271 272 273
def remote_proc(options, command, arg=None):
    """
    Fabrique un process distant pour communiquer avec le serveur.
    Cela consiste à lancer une commande (indiquée dans la config)
    qui va potentiellement lancer ssh.
    ``command`` désigne l'action à envoyer au serveur
    ``arg`` est une chaîne (str) accompagnant la commande en paramètre
    ``options`` contient la liste usuelle d'options
    """
274
    full_command = list(options.serverdata['server_cmd'])
Daniel Stan's avatar
Daniel Stan committed
275 276 277
    full_command.append(command)
    if arg:
        full_command.append(arg)
278 279 280 281

    if options.verbose and not options.quiet:
        print("Running command %s ..." % " ".join(full_command))

Daniel Stan's avatar
Daniel Stan committed
282 283 284 285 286
    proc = subprocess.Popen(full_command,
                            stdin = subprocess.PIPE,
                            stdout = subprocess.PIPE,
                            stderr = sys.stderr,
                            close_fds = True)
287
    return proc
Daniel Stan's avatar
Daniel Stan committed
288

289 290 291 292 293 294 295 296 297
@simple_memoize
def get_keep_alive_connection(options):
    """Fabrique un process parlant avec le serveur suivant la commande
    'keep-alive'. On utilise une fonction séparée pour cela afin
    de memoizer le résultat, et ainsi utiliser une seule connexion"""
    proc = remote_proc(options, 'keep-alive', None)
    atexit.register(proc.stdin.close)
    return proc

298
def remote_command(options, command, arg=None, stdin_contents=None):
Daniel Stan's avatar
Daniel Stan committed
299 300
    """Exécute la commande distante, et retourne la sortie de cette
    commande"""
301
    detail = options.verbose and not options.quiet
302
    keep_alive = options.serverdata.get('keep-alive', False)
303

304 305 306 307 308 309 310 311 312 313 314
    if keep_alive:
        conn = get_keep_alive_connection(options)
        args = filter(None, [arg, stdin_contents])
        msg = {u'action': unicode(command), u'args': args }
        conn.stdin.write('%s\n' % json.dumps(msg))
        conn.stdin.flush()
        raw_out = conn.stdout.readline()
    else:
        proc = remote_proc(options, command, arg)
        if stdin_contents is not None:
            proc.stdin.write(json.dumps(stdin_contents))
315 316 317 318 319
            proc.stdin.flush()

        raw_out, raw_err = proc.communicate()
        ret = proc.returncode

320 321 322 323 324 325 326 327
        if ret != 0:
            if not options.quiet:
                print((u"Mauvais code retour côté serveur, voir erreur " +
                       u"ci-dessus").encode('utf-8'),
                      file=sys.stderr)
                if detail:
                    print("raw_output: %s" % raw_out)
            sys.exit(ret)
328
    try:
329
        answer = json.loads(raw_out.strip())
330 331 332 333
    except ValueError:
        if not options.quiet:
            print(u"Impossible de parser le résultat".encode('utf-8'),
                  file=sys.stderr)
334
            if detail:
335 336
                print("raw_output: %s" % raw_out)
            sys.exit(42)
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
    if not keep_alive:
        return answer
    else:
        try:
            if answer[u'status'] != u'ok':
                raise KeyError('Bad answer status')
            return answer[u'content']
        except KeyError:
            if not options.quiet:
                print(u"Réponse erronée du serveur".encode('utf-8'),
                    file=sys.stderr)
            if detail:
                print("answer: %s" % repr(answer))
            sys.exit(-1)

Daniel Stan's avatar
Daniel Stan committed
352

353
@simple_memoize
354
def all_keys(options):
Daniel Stan's avatar
Daniel Stan committed
355
    """Récupère les clés du serveur distant"""
356
    return remote_command(options, "listkeys")
Daniel Stan's avatar
Daniel Stan committed
357

358
@simple_memoize
359
def all_roles(options):
Daniel Stan's avatar
Daniel Stan committed
360
    """Récupère les roles du serveur distant"""
361
    return remote_command(options, "listroles")
Daniel Stan's avatar
Daniel Stan committed
362

363
@simple_memoize
364
def all_files(options):
Daniel Stan's avatar
Daniel Stan committed
365
    """Récupère les fichiers du serveur distant"""
366
    return remote_command(options, "listfiles")
Daniel Stan's avatar
Daniel Stan committed
367

368
def get_files(options, filenames):
369
    """Récupère le contenu des fichiers distants"""
370
    return remote_command(options, "getfiles", stdin_contents=filenames)
Daniel Stan's avatar
Daniel Stan committed
371

372
def put_files(options, files):
373
    """Dépose les fichiers sur le serveur distant"""
374
    return remote_command(options, "putfiles", stdin_contents=files)
375

Daniel Stan's avatar
Daniel Stan committed
376 377
def rm_file(filename):
    """Supprime le fichier sur le serveur distant"""
378
    return remote_command(options, "rmfile", filename)
Daniel Stan's avatar
Daniel Stan committed
379

380
@simple_memoize
381 382 383
def get_my_roles(options):
    """Retourne la liste des rôles de l'utilisateur, et également la liste des rôles dont il possède le role-w."""
    allroles = all_roles(options)
384 385
    distant_username = allroles.pop("whoami")
    my_roles = [r for (r, users) in allroles.iteritems() if distant_username in users]
386 387
    my_roles_w = [r[:-2] for r in my_roles if r.endswith("-w")]
    return (my_roles, my_roles_w)
Daniel Stan's avatar
Daniel Stan committed
388

389
def gen_password():
390
    """Génère un mot de passe aléatoire"""
391 392 393
    random.seed(datetime.datetime.now().microsecond)
    chars = string.letters + string.digits + '/=+*'
    length = 15
394
    return u''.join([random.choice(chars) for _ in xrange(length)])
395

Daniel Stan's avatar
Daniel Stan committed
396 397 398
######
## Local commands

399
def update_keys(options):
Daniel Stan's avatar
Daniel Stan committed
400
    """Met à jour les clés existantes"""
401

402
    keys = all_keys(options)
403

404
    _, stdout = gpg(options, "receive-keys", [key for _, key in keys.values() if key])
405
    return stdout.read().decode("utf-8")
Daniel Stan's avatar
Daniel Stan committed
406

407 408 409 410 411
def _check_encryptable(key):
    """Vérifie qu'on peut chiffrer un message pour ``key``.
       C'est-à-dire, que la clé est de confiance (et non expirée).
       Puis qu'on peut chiffrer avec, ou qu'au moins une de ses subkeys est de chiffrement (capability e)
       et est de confiance et n'est pas expirée"""
412
    # Il faut que la clé soit dans le réseau de confiance…
413 414 415
    meaning, trustvalue = GPG_TRUSTLEVELS[key[u"trustletter"]]
    if not trustvalue:
        return u"La confiance en la clé est : %s" % (meaning,)
416
    # …et qu'on puisse chiffrer avec…
417 418 419 420 421 422 423 424 425 426 427 428
    if u"e" in key[u"capabilities"]:
        # …soit directement…
        return u""
    # …soit avec une de ses subkeys
    esubkeys = [sub for sub in key[u"subkeys"] if u"e" in sub[u"capabilities"]]
    if len(esubkeys) == 0:
        return u"La clé principale de permet pas de chiffrer et auncune sous-clé de chiffrement."
    if any([GPG_TRUSTLEVELS[sub[u"trustletter"]][1] for sub in esubkeys]):
        return u""
    else:
        return u"Aucune sous clé de chiffrement n'est de confiance et non expirée."

429
def check_keys(options, recipients=None, quiet=False):
430 431
    """Vérifie les clés, c'est-à-dire, si le mail est présent dans les identités du fingerprint,
       et que la clé est de confiance (et non expirée/révoquée).
432

433 434
        * Si ``recipients`` est fourni, vérifie seulement ces recipients.
          Renvoie la liste de ceux qu'on n'a pas droppés.
435 436
         * Si ``options.force=False``, demandera confirmation pour dropper un recipient dont la clé est invalide.
         * Sinon, et si ``options.drop_invalid=True``, droppe les recipients automatiquement.
437 438 439
        * Si rien n'est fourni, vérifie toutes les clés et renvoie juste un booléen disant si tout va bien.
       """
    trusted_recipients = []
440
    keys = all_keys(options)
441
    if recipients is None:
442
        speak = options.verbose and not options.quiet
443
    else:
444
        speak = False
445
        keys = {u : val for (u, val) in keys.iteritems() if u in recipients}
446
    if speak:
447
        print("M : le mail correspond à un uid du fingerprint\nC : confiance OK (inclut la vérification de non expiration).\n")
448
    _, gpgout = gpg(options, 'list-keys')
449
    localring = parse_keys(gpgout)
450 451 452
    for (recipient, (mail, fpr)) in keys.iteritems():
        failed = u""
        if not fpr is None:
453
            if speak:
454
                print((u"Checking %s… " % (mail)).encode("utf-8"), end="")
455
            key = localring.get(fpr, None)
456
            # On vérifie qu'on possède la clé…
457
            if not key is None:
458
                # …qu'elle correspond au mail…
459
                if any([u"<%s>" % (mail,) in u["uid"] for u in key["uids"]]):
460
                    if speak:
461
                        print("M ", end="")
462 463 464
                    # … et qu'on peut raisonnablement chiffrer pour lui
                    failed = _check_encryptable(key)
                    if not failed and speak:
465
                        print("C ", end="")
466
                else:
467
                    failed = u"!! Le fingerprint et le mail ne correspondent pas !"
468
            else:
469
                failed = u"Pas (ou trop) de clé avec ce fingerprint."
470
            if speak:
471
                print("")
472
            if failed:
473
                if not options.quiet:
474 475 476
                    print((u"--> Fail on %s:%s\n--> %s" % (mail, fpr, failed)).encode("utf-8"))
                if not recipients is None:
                    # On cherche à savoir si on droppe ce recipient
477
                    message = u"Abandonner le chiffrement pour cette clé ? (Si vous la conservez, il est posible que gpg crashe)"
478
                    if confirm(options, message, ('drop', fpr, mail)):
479 480 481
                        drop = True # si on a répondu oui à "abandonner ?", on droppe
                    elif options.drop_invalid and options.force:
                        drop = True # ou bien si --drop-invalid avec --force nous autorisent à dropper silencieusement
482
                    else:
483
                        drop = False # Là, on droppe pas
484 485
                    if not drop:
                        trusted_recipients.append(recipient)
486 487 488
                    else:
                        if not options.quiet:
                            print(u"Droppe la clé %s:%s" % (fpr, recipient))
489 490 491 492 493 494
            else:
                trusted_recipients.append(recipient)
    if recipients is None:
        return set(keys.keys()).issubset(trusted_recipients)
    else:
        return trusted_recipients
Daniel Stan's avatar
Daniel Stan committed
495

496
def get_recipients_of_roles(options, roles):
Vincent Le gallic's avatar
Vincent Le gallic committed
497
    """Renvoie les destinataires d'une liste de rôles"""
498
    recipients = set()
499
    allroles = all_roles(options)
500
    for role in roles:
501 502
        if role == u"whoami":
            continue
503 504 505 506
        for recipient in allroles[role]:
            recipients.add(recipient)
    return recipients

507
def get_dest_of_roles(options, roles):
508
    """Renvoie la liste des "username : mail (fingerprint)" """
509
    allkeys = all_keys(options)
510
    return [u"%s : %s (%s)" % (rec, allkeys[rec][0], allkeys[rec][1])
511
               for rec in get_recipients_of_roles(options, roles) if allkeys[rec][1]]
512

513
def encrypt(options, roles, contents):
514
    """Chiffre le contenu pour les roles donnés"""
515

516 517 518
    allkeys = all_keys(options)
    recipients = get_recipients_of_roles(options, roles)
    recipients = check_keys(options, recipients=recipients, quiet=True)
519
    fpr_recipients = []
Daniel Stan's avatar
Daniel Stan committed
520
    for recipient in recipients:
521 522 523 524
        fpr = allkeys[recipient][1]
        if fpr:
            fpr_recipients.append("-r")
            fpr_recipients.append(fpr)
525

526
    stdin, stdout = gpg(options, "encrypt", fpr_recipients)
527
    stdin.write(contents.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
528
    stdin.close()
529
    out = stdout.read().decode("utf-8")
530
    if out == '':
531
        return [False, u"Échec de chiffrement"]
532
    else:
533
        return [True, out]
Daniel Stan's avatar
Daniel Stan committed
534

535
def decrypt(options, contents):
Daniel Stan's avatar
Daniel Stan committed
536
    """Déchiffre le contenu"""
537
    stdin, stdout = gpg(options, "decrypt")
538 539 540
    if type(contents) != unicode: # Kludge (broken db ?)
        print("Eau dans le gaz (decrypt)" + repr(contents))
        contents = contents[-1]
541
    stdin.write(contents.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
542
    stdin.close()
543
    return stdout.read().decode("utf-8")
Daniel Stan's avatar
Daniel Stan committed
544

545
def put_password(options, roles, contents):
Daniel Stan's avatar
Daniel Stan committed
546
    """Dépose le mot de passe après l'avoir chiffré pour les
547 548
    destinataires dans ``roles``."""
    success, enc_pwd_or_error = encrypt(options, roles, contents)
549 550
    if success:
        enc_pwd = enc_pwd_or_error
551
        return put_files(options, [{'filename' : options.fname, 'roles' : roles, 'contents' : enc_pwd}])[0]
552
    else:
553 554
        error = enc_pwd_or_error
        return [False, error]
Daniel Stan's avatar
Daniel Stan committed
555

556
######
557 558
## Interface

559 560 561 562 563 564 565
NEED_FILENAME = []

def need_filename(f):
    """Décorateur qui ajoutera la fonction à la liste des fonctions qui attendent un filename."""
    NEED_FILENAME.append(f)
    return f

566
def editor(texte, annotations=u""):
567 568 569
    """ Lance $EDITOR sur texte.
    Renvoie le nouveau texte si des modifications ont été apportées, ou None
    """
570

571 572 573
    # Avoid syntax hilight with ".txt". Would be nice to have some colorscheme
    # for annotations ...
    f = tempfile.NamedTemporaryFile(suffix='.txt')
574
    atexit.register(f.close)
575 576
    if annotations:
        annotations = "# " + annotations.replace("\n", "\n# ")
Daniel Stan's avatar
Daniel Stan committed
577
        # Usually, there is already an ending newline in a text document
578
        if texte and texte[-1] != '\n':
Daniel Stan's avatar
Daniel Stan committed
579 580 581 582
            annotations = '\n' + annotations
        else:
            annotations += '\n'
    f.write((texte + annotations).encode("utf-8"))
583
    f.flush()
Daniel Stan's avatar
Daniel Stan committed
584
    proc = subprocess.Popen([os.getenv('EDITOR', '/usr/bin/editor'), f.name])
585
    os.waitpid(proc.pid, 0)
586
    f.seek(0)
Daniel Stan's avatar
Daniel Stan committed
587
    ntexte = f.read().decode("utf-8", errors='ignore')
588
    f.close()
589
    ntexte = u'\n'.join(filter(lambda l: not l.startswith('#'), ntexte.split('\n')))
590
    return ntexte
591

592
def show_files(options):
593
    """Affiche la liste des fichiers disponibles sur le serveur distant"""
Vincent Le gallic's avatar
Vincent Le gallic committed
594
    print(u"Liste des fichiers disponibles :".encode("utf-8"))
595 596
    my_roles, _ = get_my_roles(options)
    files = all_files(options)
597 598 599 600
    keys = files.keys()
    keys.sort()
    for fname in keys:
        froles = files[fname]
Daniel Stan's avatar
Daniel Stan committed
601
        access = set(my_roles).intersection(froles) != set([])
Vincent Le gallic's avatar
Vincent Le gallic committed
602 603
        print((u" %s %s (%s)" % ((access and '+' or '-'), fname, ", ".join(froles))).encode("utf-8"))
    print((u"""--Mes roles: %s""" % (", ".join(my_roles),)).encode("utf-8"))
604

605
def show_roles(options):
606
    """Affiche la liste des roles existants"""
Vincent Le gallic's avatar
Vincent Le gallic committed
607
    print(u"Liste des roles disponibles".encode("utf-8"))
608 609
    allroles =  all_roles(options)
    for (role, usernames) in allroles.iteritems():
610 611
        if role == u"whoami":
            continue
612
        if not role.endswith('-w'):
613
            print((u" * %s : %s" % (role, ", ".join(usernames))).encode("utf-8"))
614

615
def show_servers(options):
616
    """Affiche la liste des serveurs disponibles"""
Vincent Le gallic's avatar
Vincent Le gallic committed
617
    print(u"Liste des serveurs disponibles".encode("utf-8"))
618
    for server in config.servers.keys():
Vincent Le gallic's avatar
Vincent Le gallic committed
619
        print((u" * " + server).encode("utf-8"))
620

621
def saveclipboard(restore=False, old_clipboard=None):
622
    """Enregistre le contenu du presse-papier. Le rétablit si ``restore=True``"""
623 624 625
    if restore and old_clipboard == None:
        return
    act = '-in' if restore else '-out'
626 627
    proc = subprocess.Popen(['xclip', act, '-selection', 'clipboard'],
        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=sys.stderr)
628 629 630
    if not restore:
        old_clipboard = proc.stdout.read()
    else:
631
        raw_input(u"Appuyez sur Entrée pour récupérer le contenu précédent du presse papier.".encode("utf-8"))
632 633 634
        proc.stdin.write(old_clipboard)
    proc.stdin.close()
    proc.stdout.close()
635
    return old_clipboard
636

637
def clipboard(texte):
638
    """Place ``texte`` dans le presse-papier en mémorisant l'ancien contenu."""
639
    old_clipboard = saveclipboard()
640 641
    proc =subprocess.Popen(['xclip', '-selection', 'clipboard'],\
        stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr)
642
    proc.stdin.write(texte.encode("utf-8"))
643
    proc.stdin.close()
644
    return old_clipboard
645

646 647
@need_filename
def show_file(options):
648
    """Affiche le contenu d'un fichier"""
649 650
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
651
    if not gotit:
652 653
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
654
        return
655
    passfile = value
656
    (sin, sout) = gpg(options, 'decrypt')
657 658 659
    content = passfile['contents']
    
    # Kludge (broken db ?)
660 661 662
    if type(content) == list:
        print("Eau dans le gaz")
        content = content[-1]
663 664

    # Déchiffre le contenu
665
    sin.write(content.encode("utf-8"))
666
    sin.close()
667
    texte = sout.read().decode("utf-8")
668 669 670 671 672 673 674 675

    # Est-ce une clé ssh ?
    is_key = texte.startswith('-----BEGIN RSA PRIVATE KEY-----')
    # Est-ce que le mot de passe a été caché ? (si non, on utilisera less)
    is_hidden = is_key
    # Texte avec mdp caché
    filtered = u""
    # Ancien contenu du press papier
676
    old_clipboard = None
677 678 679

    # Essaie de planquer le mot de passe
    for line in texte.split('\n'):
Daniel Stan's avatar
Daniel Stan committed
680 681 682
        catchPass = None
        # On essaie de trouver le pass pour le cacher dans le clipboard
        # si ce n'est déjà fait et si c'est voulu
683
        if not is_hidden and options.clipboard:
Daniel Stan's avatar
Daniel Stan committed
684 685
            catchPass = pass_regexp.match(line)
        if catchPass != None:
686 687
            is_hidden = True
            # On met le mdp dans le clipboard en mémorisant son ancien contenu
688 689 690
            old_clipboard = clipboard(catchPass.group(1))
            # Et donc on override l'affichage
            line = u"[Le mot de passe a été mis dans le presse papier]"
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
        filtered += line + '\n'

    if is_key:
        filtered = u"La clé a été mise dans l'agent ssh"
    shown = u"Fichier %s:\n\n%s-----\nVisible par: %s\n" % (fname, filtered, ','.join(passfile['roles']))

    if is_key:
        with tempfile.NamedTemporaryFile(suffix='') as key_file:
            # Génère la clé publique correspondante
            key_file.write(texte.encode('utf-8'))
            key_file.flush()
            pub = subprocess.check_output(['ssh-keygen', '-y', '-f', key_file.name])

            # Charge en mémoire
            subprocess.check_call(['ssh-add', key_file.name])

            # On attend
            print(shown.encode('utf-8'))
            raw_input()

            # On met la clé publique en fichier puis on supprime
            key_file.seek(0)
            key_file.write(pub)
            key_file.flush()
            
            subprocess.check_call(['ssh-add', '-d', key_file.name])
    else:
        # Le binaire à utiliser
        showbin = "cat" if is_hidden else "less"
        proc = subprocess.Popen([showbin], stdin=subprocess.PIPE)
        out = proc.stdin
        out.write(shown.encode("utf-8"))
        out.close()
        os.waitpid(proc.pid, 0)

726
    # Repope ancien pass
727
    if old_clipboard:
728
        saveclipboard(restore=True, old_clipboard=old_clipboard)
729

730 731
@need_filename
def edit_file(options):
732
    """Modifie/Crée un fichier"""
733 734
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
Daniel Stan's avatar
Daniel Stan committed
735
    nfile = False
736
    annotations = u""
737 738 739 740 741

    my_roles, _ = get_my_roles(options)
    new_roles = options.roles

    # Cas du nouveau fichier
742
    if not gotit and not u"pas les droits" in value:
Daniel Stan's avatar
Daniel Stan committed
743
        nfile = True
744 745 746
        if not options.quiet:
            print(u"Fichier introuvable".encode("utf-8"))
        if not confirm(options, u"Créer fichier ?"):
Daniel Stan's avatar
Daniel Stan committed
747
            return
748
        annotations += u"""Ceci est un fichier initial contenant un mot de passe
749 750
aléatoire, pensez à rajouter une ligne "login: ${login}"
Enregistrez le fichier vide pour annuler.\n"""
751
        texte = u"pass: %s\n" % gen_password()
752 753 754 755

        if new_roles is None:
            new_roles = parse_roles(options, cast=True)
        passfile = {'roles' : new_roles}
756
    elif not gotit:
757 758
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
759
        return
Daniel Stan's avatar
Daniel Stan committed
760
    else:
761
        passfile = value
762
        (sin, sout) = gpg(options, 'decrypt')
Daniel Stan's avatar
Daniel Stan committed
763 764 765 766 767 768
        contents = passfile['contents']
        # <ducktape> (waddle waddle)
        if isinstance(contents, list):
            contents = contents[-1]
        # </ducktape>
        sin.write(contents.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
769
        sin.close()
770
        texte = sout.read().decode("utf-8")
771 772 773 774 775 776 777 778 779 780 781 782 783
        if new_roles is None:
            new_roles = passfile['roles']

    # On vérifie qu'on a le droit actuellement (plutôt que de se faire jeter
    # plus tard)
    if not any(r + '-w' in my_roles for r in passfile['roles']):
        if not options.quiet:
            print(u"Aucun rôle en écriture pour ce fichier ! Abandon.".encode("utf-8"))
        return

    # On peut vouloir chiffrer un fichier sans avoir la possibilité de le lire
    # dans le futur, mais dans ce cas on préfère demander confirmation
    if not any(r + '-w' in my_roles for r in new_roles):
Daniel Stan's avatar
Daniel Stan committed
784
        message = u"""Vous vous apprêtez à perdre vos droits en écriture""" + \
785 786
            """(ROLES ne contient rien parmi : %s) sur ce fichier, continuer ?"""
        message = message % (", ".join(r[:-2] for r in my_roles if '-w' in r),)
787
        if not confirm(options, message):
788
            return
789

790 791
    annotations += u"""Ce fichier sera chiffré pour les rôles suivants :\n%s\n
C'est-à-dire pour les utilisateurs suivants :\n%s""" % (
792
           ', '.join(new_roles),
793
           '\n'.join(' %s' % rec for rec in get_dest_of_roles(options, new_roles))
794
        )
795

796
    ntexte = editor(texte, annotations)
797

798 799 800
    if ((not nfile and ntexte in [u'', texte]          # pas nouveau, vidé ou pas modifié
         and set(new_roles) == set(passfile['roles'])) # et on n'a même pas touché à ses rôles,
        or (nfile and ntexte == u'')):                 # ou alors on a créé un fichier vide.
801 802 803 804 805
        message = u"Pas de modification à enregistrer.\n"
        message += u"Si ce n'est pas un nouveau fichier, il a été vidé ou n'a pas été modifié (même pas ses rôles).\n"
        message += u"Si c'est un nouveau fichier, vous avez tenté de le créer vide."
        if not options.quiet:
            print(message.encode("utf-8"))
806
    else:
Daniel Stan's avatar
Daniel Stan committed
807
        ntexte = texte if ntexte == None else ntexte
808
        success, message = put_password(options, new_roles, ntexte)
809
        print(message.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
810

811 812 813 814 815 816 817
_remember_dict = {}
def confirm(options, text, remember_key=None):
    """Demande confirmation, sauf si on est mode ``--force``.
    Si ``remember_key`` est fourni, il doit correspondre à un objet hashable
    qui permettra de ne pas poser deux fois les mêmes questions.
    """
    global _remember_dict
818 819
    if options.force:
        return True
820 821
    if remember_key in _remember_dict:
        return _remember_dict[remember_key]
Daniel Stan's avatar
Daniel Stan committed
822
    while True:
823
        out = raw_input((text + u' (o/n)').encode("utf-8")).lower()
Daniel Stan's avatar
Daniel Stan committed
824
        if out == 'o':
825 826
            res = True
            break
Daniel Stan's avatar
Daniel Stan committed
827
        elif out == 'n':
828 829 830 831 832 833
            res = False
            break
    # Remember the answer
    if remember_key is not None:
        _remember_dict[remember_key] = res
    return res
Daniel Stan's avatar
Daniel Stan committed
834

835 836
@need_filename
def remove_file(options):
837
    """Supprime un fichier"""
838
    fname = options.fname
839
    if not confirm(options, u'Êtes-vous sûr de vouloir supprimer %s ?' % (fname,)):
Daniel Stan's avatar
Daniel Stan committed
840
        return
841 842
    message = rm_file(fname)
    print(message.encode("utf-8"))
843

Daniel Stan's avatar
Daniel Stan committed
844

845
def my_check_keys(options):
846
    """Vérifie les clés et affiche un message en fonction du résultat"""
Vincent Le gallic's avatar
Vincent Le gallic committed
847
    print(u"Vérification que les clés sont valides (uid correspondant au login) et de confiance.")
848
    print((check_keys(options) and u"Base de clés ok" or u"Erreurs dans la base").encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
849

850
def my_update_keys(options):
851
    """Met à jour les clés existantes et affiche le résultat"""
852 853
    print(update_keys(options).encode("utf-8"))

854
def recrypt_files(options, strict=False):
855
    """Rechiffre les fichiers.
856 857 858
       Ici, la signification de ``options.roles`` est :
	 strict     => on chiffre les fichiers dont *tous* les rôles sont dans la liste
	 non strict => on ne veut rechiffrer que les fichiers qui ont au moins un de ces roles.
859 860 861
       """
    rechiffre_roles = options.roles
    _, my_roles_w = get_my_roles(options)
862 863
    if rechiffre_roles == None:
        # Sans précisions, on prend tous les roles qu'on peut
864
        rechiffre_roles = my_roles_w
865

866
    # La liste des fichiers
867
    allfiles = all_files(options)
868 869 870 871 872 873 874 875 876 877

    def is_wanted(fileroles):
        # On drope ce qui ne peut être écrit
        if not set(fileroles).intersection(my_roles_w):
            return False
        if strict:
            return set(fileroles).issubset(rechiffre_roles)
        else:
            return bool(set(fileroles).intersection(rechiffre_roles))

878
    askfiles = [filename for (filename, fileroles) in allfiles.iteritems()
879
                         if is_wanted(fileroles) ]
880
    files = get_files(options, askfiles)
881 882 883 884
    # Au cas où on aurait échoué à récupérer ne serait-ce qu'un de ces fichiers,
    # on affiche le message d'erreur correspondant et on abandonne.
    for (success, message) in files:
        if not success:
885 886
            if not options.quiet:
                print(message.encode("utf-8"))
887
            return
888 889 890 891 892 893
    # On informe l'utilisateur et on demande confirmation avant de rechiffrer
    # Si il a précisé --force, on ne lui demandera rien.
    filenames = ", ".join(askfiles)
    message = u"Vous vous apprêtez à rechiffrer les fichiers suivants :\n%s" % filenames
    if not confirm(options, message + u"\nConfirmer"):
        sys.exit(2)
894 895 896
    # On rechiffre
    to_put = [{'filename' : f['filename'],
               'roles' : f['roles'],
897
               'contents' : encrypt(options, f['roles'], decrypt(options, f['contents']))[-1]}
898
              for [success, f] in files]
899
    if to_put:
900 901
        if not options.quiet:
            print((u"Rechiffrement de %s" % (", ".join([f['filename'] for f in to_put]))).encode("utf-8"))
902
        results = put_files(options, to_put)
903
        # On affiche les messages de retour
904 905 906
        if not options.quiet:
            for i in range(len(results)):
                print(u"%s : %s" % (to_put[i]['filename'], results[i][1]))
907
    else:
908 909 910
        if not options.quiet:
            print(u"Aucun fichier n'a besoin d'être rechiffré".encode("utf-8"))

911
def parse_roles(options, cast=False):
912
    """Interprête la liste de rôles fournie par l'utilisateur.
913 914 915 916
       Si il n'en a pas fourni, c'est-à-dire que roles
       vaut None, alors on considère cette valeur comme valide.
       Cependant, si ``cast`` est vraie, cette valeur est remplacée par
       tous les roles en écriture (*-w) de l'utilisateur.
917

918
       Renvoie ``False`` si au moins un de ces rôles pose problème.
919

920 921 922 923
       poser problème, c'est :
        * être un role-w (il faut utiliser le role sans le w)
        * ne pas exister dans la config du serveur
    """
924 925 926
    if options.roles is None and not cast:
        return options.roles

927 928 929 930 931 932
    strroles = options.roles
    allroles = all_roles(options)
    _, my_roles_w = get_my_roles(options)
    if strroles == None:
        # L'utilisateur n'a rien donné, on lui donne les rôles (non -w) dont il possède le -w
        return my_roles_w
Daniel Stan's avatar
Daniel Stan committed
933 934
    ret = set()
    for role in strroles.split(','):
935 936 937 938
        if role not in allroles.keys():
            if not options.quiet:
                print((u"Le rôle %s n'existe pas !" % role).encode("utf-8"))
            sys.exit(1)
Daniel Stan's avatar
Daniel Stan committed
939
        if role.endswith('-w'):
940 941 942 943
            if not options.quiet:
                print((u"Le rôle %s ne devrait pas être utilisé ! (utilisez %s)")
                       % (role, role[:-2])).encode("utf-8")
            sys.exit(1)
Daniel Stan's avatar
Daniel Stan committed
944 945
        ret.add(role)
    return list(ret)
946

947 948 949 950 951 952 953 954
def insult_on_nofilename(options, parser):
    """Insulte (si non quiet) et quitte si aucun nom de fichier n'a été fourni en commandline."""
    if options.fname == None:
        if not options.quiet:
            print(u"Vous devez fournir un nom de fichier avec cette commande".encode("utf-8"))
            parser.print_help()
        sys.exit(1)

955
if __name__ == "__main__":
956
    parser = argparse.ArgumentParser(description="Gestion de mots de passe partagés grâce à GPG.")
957
    parser.add_argument('-s', '--server', default='default',
958 959
        help="Utilisation d'un serveur alternatif (test, backup, etc)")
    parser.add_argument('-v', '--verbose', action='store_true', default=False,
Daniel Stan's avatar
Daniel Stan committed
960
        help="Mode verbeux")
961 962 963
    parser.add_argument('--drop-invalid', action='store_true', default=False,
        dest='drop_invalid',
        help="Combiné avec --force, droppe les clés en lesquelles on n'a pas confiance sans demander confirmation.")
964
    parser.add_argument('-q', '--quiet', action='store_true', default=False,
965
        help="Mode silencieux. Cache les message d'erreurs (override --verbose et --interactive).")
966
    parser.add_argument('-c', '--clipboard', action='store_true', default=None,
Daniel Stan's avatar
Daniel Stan committed
967
        help="Stocker le mot de passe dans le presse papier")
968
    parser.add_argument('--no-clip', '--noclip', '--noclipboard', action='store_false', default=None,
969
        dest='clipboard',
970
        help="Ne PAS stocker le mot de passe dans le presse papier")
971 972
    parser.add_argument('-f', '--force', action='store_true', default=False,
        help="Ne pas demander confirmation")
Daniel Stan's avatar
Daniel Stan committed
973 974 975

    # Actions possibles
    action_grp = parser.add_mutually_exclusive_group(required=False)
976 977
    action_grp.add_argument('-e', '--edit', action='store_const', dest='action',
        default=show_file, const=edit_file,
Daniel Stan's avatar
Daniel Stan committed
978
        help="Editer (ou créer)")
979 980 981 982 983 984 985 986
    action_grp.add_argument('--view', action='store_const', dest='action',
        default=show_file, const=show_file,
        help="Voir le fichier")
    action_grp.add_argument('--remove', action='store_const', dest='action',
        default=show_file, const=remove_file,
        help="Effacer le fichier")
    action_grp.add_argument('-l', '--list', action='store_const', dest='action',
        default=show_file, const=show_files,
Daniel Stan's avatar
Daniel Stan committed
987
        help="Lister les fichiers")
988 989
    action_grp.add_argument('--check-keys', action='store_const', dest='action',
        default=show_file, const=my_check_keys,
Daniel Stan's avatar
Daniel Stan committed
990
        help="Vérifier les clés")
991 992
    action_grp.add_argument('--update-keys', action='store_const', dest='action',
        default=show_file, const=my_update_keys,
Daniel Stan's avatar
Daniel Stan committed
993
        help="Mettre à jour les clés")
994 995 996 997 998 999
    action_grp.add_argument('--list-roles', action='store_const', dest='action',
        default=show_file, const=show_roles,
        help="Lister les rôles existants")
    action_grp.add_argument('--list-servers', action='store_const', dest='action',
        default=show_file, const=show_servers,
        help="Lister les serveurs")
1000 1001
    action_grp.add_argument('--recrypt-files', action='store_const', dest='action',
        default=show_file, const=recrypt_files,
1002 1003 1004
        help="""Rechiffrer les mots de passe.
                (Avec les mêmes rôles que ceux qu'ils avant.
                 Cela sert à mettre à jour les recipients pour qui un password est chiffré)""")
1005 1006 1007 1008
    action_grp.add_argument('--strict-recrypt-files', action='store_const', dest='action',
        default=show_file, const=lambda x:recrypt_files(x, strict=True),
        help="""Rechiffrer les mots de passe (mode strict, voir --roles)""")

1009
    parser.add_argument('--roles', nargs='?', default=None,
1010 1011 1012 1013 1014 1015 1016 1017 1018
        help="""Liste de roles (séparés par des virgules). Par défaut, tous les
                rôles en écriture (sauf pour l'édition, d'un fichier existant).
                Avec --edit: le fichier sera chiffré pour exactement ces roles
                Avec --(strict-)recrypt-files :
                    sert à sélectionnenr les fichiers à rechiffrer
                    * non-strict: tout fichier possédant un des rôles listé
                    * strict: tout fichier dont *tous* les rôles sont dans la
                        liste
            """)
1019
    parser.add_argument('fname', nargs='?', default=None,
1020
        type=lambda x: x.decode('utf-8'),
Daniel Stan's avatar
Daniel Stan committed
1021
        help="Nom du fichier à afficher")
1022

1023 1024
    # On parse les options fournies en commandline
    options = parser.parse_args(sys.argv[1:])
1025

1026 1027 1028
    ## On calcule les options qui dépendent des autres.
    ## C'est un peu un hack, peut-être que la méthode propre serait de surcharger argparse.ArgumentParser
    ## et argparse.Namespace, mais j'ai pas réussi à comprendre commenr m'en sortir.
1029 1030 1031 1032 1033 1034
    # ** Presse papier **
    # Si l'utilisateur n'a rien dit (ni option --clipboard ni --noclipboard),
    # on active le clipboard par défaut, à la condition
    # que xclip existe et qu'il a un serveur graphique auquel parler.
    if options.clipboard is None:
        options.clipboard = bool(os.getenv('DISPLAY')) and os.path.exists('/usr/bin/xclip')
1035 1036 1037 1038 1039 1040 1041 1042
    # On récupère les données du serveur à partir du nom fourni
    options.serverdata = config.servers[options.server]
    # Attention à l'ordre pour interactive
    #  --quiet override --verbose
    if options.quiet:
        options.verbose = False
    # On parse les roles fournis, et il doivent exister, ne pas être -w…
    # parse_roles s'occupe de ça
1043 1044 1045 1046
    # NB : ça nécessite de se connecter au serveur, or, pour show_servers on n'en a pas besoin
    # Il faudrait ptêtre faire ça plus proprement, en attendant, je ducktape.
    if options.action != show_servers:
        options.roles = parse_roles(options)
1047

1048 1049 1050 1051
    # Si l'utilisateur a demandé une action qui nécessite un nom de fichier,
    # on vérifie qu'il a bien fourni un nom de fichier.
    if options.action in NEED_FILENAME:
        insult_on_nofilename(options, parser)
1052

1053 1054
    # On exécute l'action demandée
    options.action(options)