client.py 33.2 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 27

# Import de la config
28
try:
29 30 31
    # 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,)))
32 33
    import clientconfig as config
except ImportError:
34 35
    if sys.stderr.isatty() and not any([opt in sys.argv for opt in ["-q", "--quiet"]]):
        sys.stderr.write(u"Va lire le fichier README.\n".encode("utf-8"))
36
    sys.exit(1)
Daniel Stan's avatar
Daniel Stan committed
37

38 39
#: 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?$',
40 41
        flags=re.IGNORECASE)

Daniel Stan's avatar
Daniel Stan committed
42
## GPG Definitions
43
#: Path du binaire gpg
Daniel Stan's avatar
Daniel Stan committed
44
GPG = '/usr/bin/gpg'
45 46

#: Paramètres à fournir à gpg en fonction de l'action désirée
Daniel Stan's avatar
Daniel Stan committed
47
GPG_ARGS = {
48 49 50
    'decrypt' : ['-d'],
    'encrypt' : ['--armor', '-es'],
    'receive-keys' : ['--recv-keys'],
51 52
    '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
53
    }
54 55

#: Mapping (lettre de trustlevel) -> (signification, faut-il faire confiance à la clé)
56
GPG_TRUSTLEVELS = {
57 58 59
                    u"-" : (u"inconnue (pas de valeur assignée)", False),
                    u"o" : (u"inconnue (nouvelle clé)", False),
                    u"i" : (u"invalide (self-signature manquante ?)", False),
60 61 62 63 64 65
                    u"n" : (u"nulle", False),
                    u"m" : (u"marginale", True),
                    u"f" : (u"entière", True),
                    u"u" : (u"ultime", True),
                    u"r" : (u"révoquée", False),
                    u"e" : (u"expirée", False),
66
                    u"q" : (u"non définie", False),
67
                  }
68

69
def gpg(command, args=None):
Daniel Stan's avatar
Daniel Stan committed
70
    """Lance gpg pour la commande donnée avec les arguments
71
    donnés. Renvoie son entrée standard et sa sortie standard."""
Daniel Stan's avatar
Daniel Stan committed
72 73 74 75
    full_command = [GPG]
    full_command.extend(GPG_ARGS[command])
    if args:
        full_command.extend(args)
76
    if options.verbose:
77
        stderr = sys.stderr
78
    else:
79
        stderr = subprocess.PIPE
80
        full_command.extend(['--debug-level=1'])
Daniel Stan's avatar
Daniel Stan committed
81 82 83
    proc = subprocess.Popen(full_command,
                            stdin = subprocess.PIPE,
                            stdout = subprocess.PIPE,
84
                            stderr = stderr,
Daniel Stan's avatar
Daniel Stan committed
85
                            close_fds = True)
86
    if not options.verbose:
87
        proc.stderr.close()
Daniel Stan's avatar
Daniel Stan committed
88 89
    return proc.stdin, proc.stdout

90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 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 178 179 180 181 182 183 184 185 186 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
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»
        line = line.decode("utf-8")
        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
214 215 216 217 218 219 220

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

221 222 223 224 225
    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."""
226
        if self.val == None:
227
            self.val = self.f(*args, **kwargs)
228 229
        return self.val

230

Daniel Stan's avatar
Daniel Stan committed
231 232 233
######
## Remote commands

234
def ssh(command, options, arg=None):
Daniel Stan's avatar
Daniel Stan committed
235 236
    """Lance ssh avec les arguments donnés. Renvoie son entrée
    standard et sa sortie standard."""
237
    full_command = list(options.serverdata['server_cmd'])
Daniel Stan's avatar
Daniel Stan committed
238 239 240 241 242 243 244 245 246 247
    full_command.append(command)
    if arg:
        full_command.append(arg)
    proc = subprocess.Popen(full_command,
                            stdin = subprocess.PIPE,
                            stdout = subprocess.PIPE,
                            stderr = sys.stderr,
                            close_fds = True)
    return proc.stdin, proc.stdout

248
def remote_command(options, command, arg=None, stdin_contents=None):
Daniel Stan's avatar
Daniel Stan committed
249 250 251
    """Exécute la commande distante, et retourne la sortie de cette
    commande"""
    
252
    sshin, sshout = ssh(command, options, arg)
253
    if not stdin_contents is None:
Daniel Stan's avatar
Daniel Stan committed
254 255
        sshin.write(json.dumps(stdin_contents))
        sshin.close()
256 257
    raw_out = sshout.read()
    return json.loads(raw_out)
Daniel Stan's avatar
Daniel Stan committed
258

259
@simple_memoize
260
def all_keys(options):
Daniel Stan's avatar
Daniel Stan committed
261
    """Récupère les clés du serveur distant"""
262
    return remote_command(options, "listkeys")
Daniel Stan's avatar
Daniel Stan committed
263

264
@simple_memoize
265
def all_roles(options):
Daniel Stan's avatar
Daniel Stan committed
266
    """Récupère les roles du serveur distant"""
267
    return remote_command(options, "listroles")
Daniel Stan's avatar
Daniel Stan committed
268

269
@simple_memoize
270
def all_files(options):
Daniel Stan's avatar
Daniel Stan committed
271
    """Récupère les fichiers du serveur distant"""
272
    return remote_command(options, "listfiles")
Daniel Stan's avatar
Daniel Stan committed
273

274
def get_files(options, filenames):
275
    """Récupère le contenu des fichiers distants"""
276
    return remote_command(options, "getfiles", stdin_contents=filenames)
Daniel Stan's avatar
Daniel Stan committed
277

278
def put_files(options, files):
279
    """Dépose les fichiers sur le serveur distant"""
280
    return remote_command(options, "putfiles", stdin_contents=files)
281

Daniel Stan's avatar
Daniel Stan committed
282 283
def rm_file(filename):
    """Supprime le fichier sur le serveur distant"""
284
    return remote_command(options, "rmfile", filename)
Daniel Stan's avatar
Daniel Stan committed
285

286
@simple_memoize
287 288 289 290 291 292
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)
    my_roles = [r for (r, users) in allroles.iteritems() if options.serverdata['user'] in users]
    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
293

294
def gen_password():
295
    """Génère un mot de passe aléatoire"""
296 297 298
    random.seed(datetime.datetime.now().microsecond)
    chars = string.letters + string.digits + '/=+*'
    length = 15
299
    return u''.join([random.choice(chars) for _ in xrange(length)])
300

Daniel Stan's avatar
Daniel Stan committed
301 302 303
######
## Local commands

304
def update_keys(options):
Daniel Stan's avatar
Daniel Stan committed
305
    """Met à jour les clés existantes"""
306
    
307
    keys = all_keys(options)
308
    
Daniel Stan's avatar
Daniel Stan committed
309
    _, stdout = gpg("receive-keys", [key for _, key in keys.values() if key])
310
    return stdout.read().decode("utf-8")
Daniel Stan's avatar
Daniel Stan committed
311

312
def check_keys(options, recipients=None, quiet=False):
313 314 315 316 317
    """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).
       
        * Si ``recipients`` est fourni, vérifie seulement ces recipients.
          Renvoie la liste de ceux qu'on n'a pas droppés.
318 319
         * 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.
320 321 322
        * Si rien n'est fourni, vérifie toutes les clés et renvoie juste un booléen disant si tout va bien.
       """
    trusted_recipients = []
323
    keys = all_keys(options)
324
    if recipients is None:
325
        speak = options.verbose and not options.quiet
326
    else:
327
        speak = False
328
        keys = {u : val for (u, val) in keys.iteritems() if u in recipients}
329
    if speak:
330
        print("M : le mail correspond à un uid du fingerprint\nC : confiance OK (inclut la vérification de non expiration).\n")
331 332
    _, gpgout = gpg('list-keys')
    localring = parse_keys(gpgout)
333 334 335
    for (recipient, (mail, fpr)) in keys.iteritems():
        failed = u""
        if not fpr is None:
336
            if speak:
337
                print((u"Checking %s… " % (mail)).encode("utf-8"), end="")
338
            key = localring.get(fpr, None)
339
            # On vérifie qu'on possède la clé…
340
            if not key is None:
341
                # …qu'elle correspond au mail…
342
                if any([u"<%s>" % (mail,) in u["uid"] for u in key["uids"]]):
343
                    if speak:
344
                        print("M ", end="")
345
                    meaning, trustvalue = GPG_TRUSTLEVELS[key["trustletter"]]
346 347
                    # … et qu'on lui fait confiance
                    if not trustvalue:
348
                        failed = u"La confiance en la clé est : %s" % (meaning,)
349
                    elif speak:
350
                        print("C ", end="")
351
                else:
352
                    failed = u"!! Le fingerprint et le mail ne correspondent pas !"
353
            else:
354
                failed = u"Pas (ou trop) de clé avec ce fingerprint."
355
            if speak:
356
                print("")
357
            if failed:
358
                if not options.quiet:
359 360 361
                    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
362 363 364 365
                    message = u"Abandonner le chiffrement pour cette clé ? (Si vous la conservez, il est posible que gpg crashe)"
                    if not confirm(options, message):
                        drop = False # si on a répondu non à "abandonner ?", on droppe pas
                    elif not options.drop_invalid:
366
                        drop = False # ou bien si drop_invalid ne nous autorise pas à le dropper silencieusement
367 368
                    else:
                        drop = True # Là, on peut dropper
369 370
                    if not drop:
                        trusted_recipients.append(recipient)
371 372 373
                    else:
                        if not options.quiet:
                            print(u"Droppe la clé %s:%s" % (fpr, recipient))
374 375 376 377 378 379
            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
380

381
def get_recipients_of_roles(options, roles):
382 383
    """Renvoie les destinataires d'un rôle"""
    recipients = set()
384
    allroles = all_roles(options)
385 386 387 388 389
    for role in roles:
        for recipient in allroles[role]:
            recipients.add(recipient)
    return recipients

390
def get_dest_of_roles(options, roles):
391
    """Renvoie la liste des "username : mail (fingerprint)" """
392
    allkeys = all_keys(options)
393
    return [u"%s : %s (%s)" % (rec, allkeys[rec][0], allkeys[rec][1])
394
               for rec in get_recipients_of_roles(options, roles) if allkeys[rec][1]]
395

396
def encrypt(options, roles, contents):
397 398
    """Chiffre le contenu pour les roles donnés"""
    
399 400 401
    allkeys = all_keys(options)
    recipients = get_recipients_of_roles(options, roles)
    recipients = check_keys(options, recipients=recipients, quiet=True)
402
    fpr_recipients = []
Daniel Stan's avatar
Daniel Stan committed
403
    for recipient in recipients:
404 405 406 407
        fpr = allkeys[recipient][1]
        if fpr:
            fpr_recipients.append("-r")
            fpr_recipients.append(fpr)
408
    
409
    stdin, stdout = gpg("encrypt", fpr_recipients)
410
    stdin.write(contents.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
411
    stdin.close()
412
    out = stdout.read().decode("utf-8")
413
    if out == '':
414
        return [False, u"Échec de chiffrement"]
415
    else:
416
        return [True, out]
Daniel Stan's avatar
Daniel Stan committed
417 418 419 420

def decrypt(contents):
    """Déchiffre le contenu"""
    stdin, stdout = gpg("decrypt")
421
    stdin.write(contents.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
422
    stdin.close()
423
    return stdout.read().decode("utf-8")
Daniel Stan's avatar
Daniel Stan committed
424

425
def put_password(options, roles, contents):
Daniel Stan's avatar
Daniel Stan committed
426
    """Dépose le mot de passe après l'avoir chiffré pour les
427 428
    destinataires dans ``roles``."""
    success, enc_pwd_or_error = encrypt(options, roles, contents)
429 430
    if success:
        enc_pwd = enc_pwd_or_error
431
        return put_files(options, [{'filename' : options.fname, 'roles' : roles, 'contents' : enc_pwd}])[0]
432
    else:
433 434
        error = enc_pwd_or_error
        return [False, error]
Daniel Stan's avatar
Daniel Stan committed
435

436
######
437 438
## Interface

439 440 441 442 443 444 445
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

446
def editor(texte, annotations=u""):
447 448 449
    """ Lance $EDITOR sur texte.
    Renvoie le nouveau texte si des modifications ont été apportées, ou None
    """
450
    
451 452 453
    # Avoid syntax hilight with ".txt". Would be nice to have some colorscheme
    # for annotations ...
    f = tempfile.NamedTemporaryFile(suffix='.txt')
454
    atexit.register(f.close)
455 456 457
    if annotations:
        annotations = "# " + annotations.replace("\n", "\n# ")
    f.write((texte + "\n" + annotations).encode("utf-8"))
458
    f.flush()
Daniel Stan's avatar
Daniel Stan committed
459
    proc = subprocess.Popen([os.getenv('EDITOR', '/usr/bin/editor'), f.name])
460
    os.waitpid(proc.pid, 0)
461
    f.seek(0)
462
    ntexte = f.read().decode("utf-8")
463
    f.close()
464
    ntexte = u'\n'.join(filter(lambda l: not l.startswith('#'), ntexte.split('\n')))
465
    return ntexte
466

467
def show_files(options):
468
    """Affiche la liste des fichiers disponibles sur le serveur distant"""
Vincent Le gallic's avatar
Vincent Le gallic committed
469
    print(u"Liste des fichiers disponibles :".encode("utf-8"))
470 471
    my_roles, _ = get_my_roles(options)
    files = all_files(options)
472 473 474 475
    keys = files.keys()
    keys.sort()
    for fname in keys:
        froles = files[fname]
Daniel Stan's avatar
Daniel Stan committed
476
        access = set(my_roles).intersection(froles) != set([])
Vincent Le gallic's avatar
Vincent Le gallic committed
477 478
        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"))
479
    
480
def show_roles(options):
481
    """Affiche la liste des roles existants"""
Vincent Le gallic's avatar
Vincent Le gallic committed
482
    print(u"Liste des roles disponibles".encode("utf-8"))
483
    for (role, usernames) in all_roles(options).iteritems():
484
        if not role.endswith('-w'):
485
            print((u" * %s : %s" % (role, ", ".join(usernames))).encode("utf-8"))
486

487
def show_servers(options):
488
    """Affiche la liste des serveurs disponibles"""
Vincent Le gallic's avatar
Vincent Le gallic committed
489
    print(u"Liste des serveurs disponibles".encode("utf-8"))
490
    for server in config.servers.keys():
Vincent Le gallic's avatar
Vincent Le gallic committed
491
        print((u" * " + server).encode("utf-8"))
492

493
old_clipboard = None
494
def saveclipboard(restore=False, old_clipboard=None):
495
    """Enregistre le contenu du presse-papier. Le rétablit si ``restore=True``"""
496 497 498
    if restore and old_clipboard == None:
        return
    act = '-in' if restore else '-out'
499 500
    proc = subprocess.Popen(['xclip', act, '-selection', 'clipboard'],
        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=sys.stderr)
501 502 503
    if not restore:
        old_clipboard = proc.stdout.read()
    else:
504
        raw_input(u"Appuyez sur Entrée pour récupérer le contenu précédent du presse papier.".encode("utf-8"))
505 506 507
        proc.stdin.write(old_clipboard)
    proc.stdin.close()
    proc.stdout.close()
508
    return old_clipboard
509

510
def clipboard(texte):
511
    """Place ``texte`` dans le presse-papier en mémorisant l'ancien contenu."""
512
    old_clipboard = saveclipboard()
513 514
    proc =subprocess.Popen(['xclip', '-selection', 'clipboard'],\
        stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr)
515
    proc.stdin.write(texte.encode("utf-8"))
516
    proc.stdin.close()
517
    return old_clipboard
518

519 520
@need_filename
def show_file(options):
521
    """Affiche le contenu d'un fichier"""
522 523
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
524
    if not gotit:
525 526
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
527
        return
528
    passfile = value
529
    (sin, sout) = gpg('decrypt')
530
    sin.write(passfile['contents'].encode("utf-8"))
531
    sin.close()
532 533
    texte = sout.read().decode("utf-8")
    ntexte = u""
534 535 536
    hidden = False  # Est-ce que le mot de passe a été caché ?
    lines = texte.split('\n')
    for line in lines:
537 538
        catchPass = pass_regexp.match(line)
        if catchPass != None and options.clipboard:
539
            hidden = True
540 541 542 543
            # On met le mdp dans le clipboard en mémorisant sont ancien contenu
            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]"
544 545
        ntexte += line + '\n'
    showbin = "cat" if hidden else "less"
546
    proc = subprocess.Popen([showbin], stdin=subprocess.PIPE)
547
    out = proc.stdin
548
    raw = u"Fichier %s:\n\n%s-----\nVisible par: %s\n" % (fname, ntexte, ','.join(passfile['roles']))
549
    out.write(raw.encode("utf-8"))
550
    out.close()
551
    os.waitpid(proc.pid, 0)
552 553
    if options.clipboard:
        saveclipboard(restore=True, old_clipboard=old_clipboard)
554

555 556
@need_filename
def edit_file(options):
557
    """Modifie/Crée un fichier"""
558 559
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
Daniel Stan's avatar
Daniel Stan committed
560
    nfile = False
561
    annotations = u""
562
    if not gotit and not u"pas les droits" in value:
Daniel Stan's avatar
Daniel Stan committed
563
        nfile = True
564 565 566
        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
567
            return
568
        annotations += u"""Ceci est un fichier initial contenant un mot de passe
569 570
aléatoire, pensez à rajouter une ligne "login: ${login}"
Enregistrez le fichier vide pour annuler.\n"""
571
        texte = u"pass: %s\n" % gen_password()
572 573 574
        if options.roles == []:
            if not options.quiet:
                print(u"Vous ne possédez aucun rôle en écriture ! Abandon.".encode("utf-8"))
575
            return
576
        passfile = {'roles' : options.roles}
577
    elif not gotit:
578 579
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
580
        return
Daniel Stan's avatar
Daniel Stan committed
581
    else:
582
        passfile = value
583
        (sin, sout) = gpg('decrypt')
584
        sin.write(passfile['contents'].encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
585
        sin.close()
586
        texte = sout.read().decode("utf-8")
587 588 589 590 591 592 593 594
    # 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
    my_roles, _ = get_my_roles(options)
    if not options.force and set(options.roles).intersection(my_roles) == set():
        message = u"""Vous vous apprêtez à perdre vos droits de lecture (ROLES ne contient rien parmi : %s) sur ce fichier, continuer ?"""
        message = message % (", ".join(my_roles),)
        if not confirm(options, message):
            sys.exit(2)
595
    # On récupère les nouveaux roles si ils ont été précisés, sinon on garde les mêmes
596
    passfile['roles'] = options.roles or passfile['roles']
597
    
598 599
    annotations += u"""Ce fichier sera chiffré pour les rôles suivants :\n%s\n
C'est-à-dire pour les utilisateurs suivants :\n%s""" % (
600 601
           ', '.join(passfile['roles']),
           '\n'.join(' %s' % rec for rec in get_dest_of_roles(options, passfile['roles']))
602
        )
603
    
604
    ntexte = editor(texte, annotations)
605
    
606 607 608 609 610 611 612 613
    if ((not nfile and ntexte in [u'', texte]              # pas nouveau, vidé ou pas modifié
         and set(options.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.
        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"))
614
    else:
Daniel Stan's avatar
Daniel Stan committed
615
        ntexte = texte if ntexte == None else ntexte
616
        success, message = put_password(options, passfile['roles'], ntexte)
617
        print(message.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
618

619 620 621 622
def confirm(options, text):
    """Demande confirmation, sauf si on est mode ``--force``"""
    if options.force:
        return True
Daniel Stan's avatar
Daniel Stan committed
623
    while True:
624
        out = raw_input((text + u' (o/n)').encode("utf-8")).lower()
Daniel Stan's avatar
Daniel Stan committed
625 626 627 628 629
        if out == 'o':
            return True
        elif out == 'n':
            return False

630 631
@need_filename
def remove_file(options):
632
    """Supprime un fichier"""
633 634
    fname = options.fname
    if not confirm(options, u'Êtes-vous sûr de vouloir supprimer %s ?' % (fname,), options):
Daniel Stan's avatar
Daniel Stan committed
635
        return
636 637
    message = rm_file(fname)
    print(message.encode("utf-8"))
638

Daniel Stan's avatar
Daniel Stan committed
639

640
def my_check_keys(options):
641
    """Vérifie les clés et affiche un message en fonction du résultat"""
Vincent Le gallic's avatar
Vincent Le gallic committed
642
    print(u"Vérification que les clés sont valides (uid correspondant au login) et de confiance.")
643
    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
644

645
def my_update_keys(options):
646
    """Met à jour les clés existantes et affiche le résultat"""
647 648 649 650 651 652 653 654
    print(update_keys(options).encode("utf-8"))

def recrypt_files(options):
    """Rechiffre les fichiers.
       Ici, la signification de ``options.roles`` est : on ne veut rechiffrer que les fichiers qui ont au moins un de ces roles.
       """
    rechiffre_roles = options.roles
    _, my_roles_w = get_my_roles(options)
655 656
    if rechiffre_roles == None:
        # Sans précisions, on prend tous les roles qu'on peut
657
        rechiffre_roles = my_roles_w
658 659
    
    # La liste des fichiers
660 661 662
    allfiles = all_files(options)
    # On ne demande que les fichiers qui ont au moins un role dans ``options.roles``
    # et dans lesquels on peut écrire
663
    askfiles = [filename for (filename, fileroles) in allfiles.iteritems()
664
                         if set(fileroles).intersection(options.roles) != set()
665
                         and set(fileroles).intersection(my_roles_w) != set()]
666
    files = get_files(options, askfiles)
667 668 669 670
    # 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:
671 672
            if not options.quiet:
                print(message.encode("utf-8"))
673
            return
674 675 676 677 678 679
    # 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)
680 681 682
    # On rechiffre
    to_put = [{'filename' : f['filename'],
               'roles' : f['roles'],
683
               'contents' : encrypt(options, f['roles'], decrypt(f['contents']))}
684 685
              for f in files]
    if to_put:
686 687
        if not options.quiet:
            print((u"Rechiffrement de %s" % (", ".join([f['filename'] for f in to_put]))).encode("utf-8"))
688 689
        results = put_files(to_put)
        # On affiche les messages de retour
690 691 692
        if not options.quiet:
            for i in range(len(results)):
                print(u"%s : %s" % (to_put[i]['filename'], results[i][1]))
693
    else:
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
        if not options.quiet:
            print(u"Aucun fichier n'a besoin d'être rechiffré".encode("utf-8"))

def parse_roles(options):
    """Interprête la liste de rôles fournie par l'utilisateur.
       Si il n'en a pas fourni, on considère qu'il prend tous ceux pour lesquels il a le -w.
       
       Renvoie ``False`` si au moins un de ces rôles pose problème.
       
       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
    
    """
    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
714 715
    ret = set()
    for role in strroles.split(','):
716 717 718 719
        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
720
        if role.endswith('-w'):
721 722 723 724
            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
725 726
        ret.add(role)
    return list(ret)
727

728 729 730 731 732 733 734 735
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)

736
if __name__ == "__main__":
737
    parser = argparse.ArgumentParser(description="Gestion de mots de passe partagés grâce à GPG.")
738
    parser.add_argument('-s', '--server', default='default',
739 740
        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
741
        help="Mode verbeux")
742 743 744
    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.")
745
    parser.add_argument('-q', '--quiet', action='store_true', default=False,
746
        help="Mode silencieux. Cache les message d'erreurs (override --verbose et --interactive).")
747
    parser.add_argument('-c', '--clipboard', action='store_true', default=None,
Daniel Stan's avatar
Daniel Stan committed
748
        help="Stocker le mot de passe dans le presse papier")
749
    parser.add_argument('--no-clip', '--noclip', '--noclipboard', action='store_false', default=None,
750
        dest='noclipboard',
751
        help="Ne PAS stocker le mot de passe dans le presse papier")
752 753
    parser.add_argument('-f', '--force', action='store_true', default=False,
        help="Ne pas demander confirmation")
Daniel Stan's avatar
Daniel Stan committed
754 755 756

    # Actions possibles
    action_grp = parser.add_mutually_exclusive_group(required=False)
757 758
    action_grp.add_argument('-e', '--edit', action='store_const', dest='action',
        default=show_file, const=edit_file,
Daniel Stan's avatar
Daniel Stan committed
759
        help="Editer (ou créer)")
760 761 762 763 764 765 766 767
    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
768
        help="Lister les fichiers")
769 770
    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
771
        help="Vérifier les clés")
772 773
    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
774
        help="Mettre à jour les clés")
775 776 777 778 779 780
    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")
781 782
    action_grp.add_argument('--recrypt-files', action='store_const', dest='action',
        default=show_file, const=recrypt_files,
783 784 785
        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é)""")
786
    
787
    parser.add_argument('--roles', nargs='?', default=None,
788 789 790 791 792
        help="""Liste de roles (séparés par des virgules).
                Avec --edit, le fichier sera chiffré pour exactement ces roles
                (par défaut, tous vos rôles en écriture seront utilisés).
                Avec --recrypt-files, tous les fichiers ayant au moins un de ces roles (et pour lesquels vous avez le droit d'écriture) seront rechiffrés
                (par défaut, tous les fichiers pour lesquels vous avez les droits en écriture sont rechiffrés).""")
793
    parser.add_argument('fname', nargs='?', default=None,
Daniel Stan's avatar
Daniel Stan committed
794
        help="Nom du fichier à afficher")
795
    
796 797
    # On parse les options fournies en commandline
    options = parser.parse_args(sys.argv[1:])
798
    
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
    ## 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.
    # On utilise le clipboard si on n'a pas demandé explicitement à ne pas le faire,
    # qu'on n'est pas en session distante et qu'on a xclip
    options.clipboard = not options.noclipboard and bool(os.getenv('DISPLAY')) and os.path.exists('/usr/bin/xclip')
    # 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
    options.roles = parse_roles(options)
814
    
815 816 817 818 819 820 821
    # 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)
    
    # On exécute l'action demandée
    options.action(options)