client.py 35.3 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 39 40 41 42 43 44 45 46 47 48 49 50
    ducktape_display_error = sys.stderr.isatty() and not any([opt in sys.argv for opt in ["-q", "--quiet"]])
    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"))
        sys.exit(1)
    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
51

52 53
#: 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?$',
54 55
        flags=re.IGNORECASE)

Daniel Stan's avatar
Daniel Stan committed
56
## GPG Definitions
57
#: Path du binaire gpg
Daniel Stan's avatar
Daniel Stan committed
58
GPG = '/usr/bin/gpg'
59 60

#: Paramètres à fournir à gpg en fonction de l'action désirée
Daniel Stan's avatar
Daniel Stan committed
61
GPG_ARGS = {
62 63 64
    'decrypt' : ['-d'],
    'encrypt' : ['--armor', '-es'],
    'receive-keys' : ['--recv-keys'],
65 66
    '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
67
    }
68 69

#: Mapping (lettre de trustlevel) -> (signification, faut-il faire confiance à la clé)
70
GPG_TRUSTLEVELS = {
71 72 73
                    u"-" : (u"inconnue (pas de valeur assignée)", False),
                    u"o" : (u"inconnue (nouvelle clé)", False),
                    u"i" : (u"invalide (self-signature manquante ?)", False),
74 75 76 77 78 79
                    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),
80
                    u"q" : (u"non définie", False),
81
                  }
82

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

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 214 215 216 217 218 219 220 221 222 223 224 225 226 227
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
228 229 230 231 232 233 234

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

235 236 237 238 239
    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."""
240
        if self.val == None:
241
            self.val = self.f(*args, **kwargs)
242
        return copy.deepcopy(self.val)
243

244

Daniel Stan's avatar
Daniel Stan committed
245 246 247
######
## Remote commands

248
def ssh(command, options, arg=None):
Daniel Stan's avatar
Daniel Stan committed
249 250
    """Lance ssh avec les arguments donnés. Renvoie son entrée
    standard et sa sortie standard."""
251
    full_command = list(options.serverdata['server_cmd'])
Daniel Stan's avatar
Daniel Stan committed
252 253 254 255 256 257 258 259 260 261
    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

262
def remote_command(options, command, arg=None, stdin_contents=None):
Daniel Stan's avatar
Daniel Stan committed
263 264 265
    """Exécute la commande distante, et retourne la sortie de cette
    commande"""
    
266
    sshin, sshout = ssh(command, options, arg)
267
    if not stdin_contents is None:
Daniel Stan's avatar
Daniel Stan committed
268 269
        sshin.write(json.dumps(stdin_contents))
        sshin.close()
270 271
    raw_out = sshout.read()
    return json.loads(raw_out)
Daniel Stan's avatar
Daniel Stan committed
272

273
@simple_memoize
274
def all_keys(options):
Daniel Stan's avatar
Daniel Stan committed
275
    """Récupère les clés du serveur distant"""
276
    return remote_command(options, "listkeys")
Daniel Stan's avatar
Daniel Stan committed
277

278
@simple_memoize
279
def all_roles(options):
Daniel Stan's avatar
Daniel Stan committed
280
    """Récupère les roles du serveur distant"""
281
    return remote_command(options, "listroles")
Daniel Stan's avatar
Daniel Stan committed
282

283
@simple_memoize
284
def all_files(options):
Daniel Stan's avatar
Daniel Stan committed
285
    """Récupère les fichiers du serveur distant"""
286
    return remote_command(options, "listfiles")
Daniel Stan's avatar
Daniel Stan committed
287

288
def get_files(options, filenames):
289
    """Récupère le contenu des fichiers distants"""
290
    return remote_command(options, "getfiles", stdin_contents=filenames)
Daniel Stan's avatar
Daniel Stan committed
291

292
def put_files(options, files):
293
    """Dépose les fichiers sur le serveur distant"""
294
    return remote_command(options, "putfiles", stdin_contents=files)
295

Daniel Stan's avatar
Daniel Stan committed
296 297
def rm_file(filename):
    """Supprime le fichier sur le serveur distant"""
298
    return remote_command(options, "rmfile", filename)
Daniel Stan's avatar
Daniel Stan committed
299

300
@simple_memoize
301 302 303
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)
304 305
    distant_username = allroles.pop("whoami")
    my_roles = [r for (r, users) in allroles.iteritems() if distant_username in users]
306 307
    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
308

309
def gen_password():
310
    """Génère un mot de passe aléatoire"""
311 312 313
    random.seed(datetime.datetime.now().microsecond)
    chars = string.letters + string.digits + '/=+*'
    length = 15
314
    return u''.join([random.choice(chars) for _ in xrange(length)])
315

Daniel Stan's avatar
Daniel Stan committed
316 317 318
######
## Local commands

319
def update_keys(options):
Daniel Stan's avatar
Daniel Stan committed
320
    """Met à jour les clés existantes"""
321
    
322
    keys = all_keys(options)
323
    
324
    _, stdout = gpg(options, "receive-keys", [key for _, key in keys.values() if key])
325
    return stdout.read().decode("utf-8")
Daniel Stan's avatar
Daniel Stan committed
326

327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
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"""
    # Il faut avoir confiance la clé…
    meaning, trustvalue = GPG_TRUSTLEVELS[key[u"trustletter"]]
    if not trustvalue:
        return u"La confiance en la clé est : %s" % (meaning,)
    # …et pouvoir chiffrer avec…
    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."

349
def check_keys(options, recipients=None, quiet=False):
350 351 352 353 354
    """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.
355 356
         * 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.
357 358 359
        * Si rien n'est fourni, vérifie toutes les clés et renvoie juste un booléen disant si tout va bien.
       """
    trusted_recipients = []
360
    keys = all_keys(options)
361
    if recipients is None:
362
        speak = options.verbose and not options.quiet
363
    else:
364
        speak = False
365
        keys = {u : val for (u, val) in keys.iteritems() if u in recipients}
366
    if speak:
367
        print("M : le mail correspond à un uid du fingerprint\nC : confiance OK (inclut la vérification de non expiration).\n")
368
    _, gpgout = gpg(options, 'list-keys')
369
    localring = parse_keys(gpgout)
370 371 372
    for (recipient, (mail, fpr)) in keys.iteritems():
        failed = u""
        if not fpr is None:
373
            if speak:
374
                print((u"Checking %s… " % (mail)).encode("utf-8"), end="")
375
            key = localring.get(fpr, None)
376
            # On vérifie qu'on possède la clé…
377
            if not key is None:
378
                # …qu'elle correspond au mail…
379
                if any([u"<%s>" % (mail,) in u["uid"] for u in key["uids"]]):
380
                    if speak:
381
                        print("M ", end="")
382 383 384
                    # … et qu'on peut raisonnablement chiffrer pour lui
                    failed = _check_encryptable(key)
                    if not failed and speak:
385
                        print("C ", end="")
386
                else:
387
                    failed = u"!! Le fingerprint et le mail ne correspondent pas !"
388
            else:
389
                failed = u"Pas (ou trop) de clé avec ce fingerprint."
390
            if speak:
391
                print("")
392
            if failed:
393
                if not options.quiet:
394 395 396
                    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
397
                    message = u"Abandonner le chiffrement pour cette clé ? (Si vous la conservez, il est posible que gpg crashe)"
398 399 400 401
                    if confirm(options, message):
                        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
402
                    else:
403
                        drop = False # Là, on droppe pas
404 405
                    if not drop:
                        trusted_recipients.append(recipient)
406 407 408
                    else:
                        if not options.quiet:
                            print(u"Droppe la clé %s:%s" % (fpr, recipient))
409 410 411 412 413 414
            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
415

416
def get_recipients_of_roles(options, roles):
Vincent Le gallic's avatar
Vincent Le gallic committed
417
    """Renvoie les destinataires d'une liste de rôles"""
418
    recipients = set()
419
    allroles = all_roles(options)
420
    allroles.pop("whoami")
421 422 423 424 425
    for role in roles:
        for recipient in allroles[role]:
            recipients.add(recipient)
    return recipients

426
def get_dest_of_roles(options, roles):
427
    """Renvoie la liste des "username : mail (fingerprint)" """
428
    allkeys = all_keys(options)
429
    return [u"%s : %s (%s)" % (rec, allkeys[rec][0], allkeys[rec][1])
430
               for rec in get_recipients_of_roles(options, roles) if allkeys[rec][1]]
431

432
def encrypt(options, roles, contents):
433 434
    """Chiffre le contenu pour les roles donnés"""
    
435 436 437
    allkeys = all_keys(options)
    recipients = get_recipients_of_roles(options, roles)
    recipients = check_keys(options, recipients=recipients, quiet=True)
438
    fpr_recipients = []
Daniel Stan's avatar
Daniel Stan committed
439
    for recipient in recipients:
440 441 442 443
        fpr = allkeys[recipient][1]
        if fpr:
            fpr_recipients.append("-r")
            fpr_recipients.append(fpr)
444
    
445
    stdin, stdout = gpg(options, "encrypt", fpr_recipients)
446
    stdin.write(contents.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
447
    stdin.close()
448
    out = stdout.read().decode("utf-8")
449
    if out == '':
450
        return [False, u"Échec de chiffrement"]
451
    else:
452
        return [True, out]
Daniel Stan's avatar
Daniel Stan committed
453

454
def decrypt(options, contents):
Daniel Stan's avatar
Daniel Stan committed
455
    """Déchiffre le contenu"""
456
    stdin, stdout = gpg(options, "decrypt")
457
    stdin.write(contents.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
458
    stdin.close()
459
    return stdout.read().decode("utf-8")
Daniel Stan's avatar
Daniel Stan committed
460

461
def put_password(options, roles, contents):
Daniel Stan's avatar
Daniel Stan committed
462
    """Dépose le mot de passe après l'avoir chiffré pour les
463 464
    destinataires dans ``roles``."""
    success, enc_pwd_or_error = encrypt(options, roles, contents)
465 466
    if success:
        enc_pwd = enc_pwd_or_error
467
        return put_files(options, [{'filename' : options.fname, 'roles' : roles, 'contents' : enc_pwd}])[0]
468
    else:
469 470
        error = enc_pwd_or_error
        return [False, error]
Daniel Stan's avatar
Daniel Stan committed
471

472
######
473 474
## Interface

475 476 477 478 479 480 481
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

482
def editor(texte, annotations=u""):
483 484 485
    """ Lance $EDITOR sur texte.
    Renvoie le nouveau texte si des modifications ont été apportées, ou None
    """
486
    
487 488 489
    # Avoid syntax hilight with ".txt". Would be nice to have some colorscheme
    # for annotations ...
    f = tempfile.NamedTemporaryFile(suffix='.txt')
490
    atexit.register(f.close)
491 492 493
    if annotations:
        annotations = "# " + annotations.replace("\n", "\n# ")
    f.write((texte + "\n" + annotations).encode("utf-8"))
494
    f.flush()
Daniel Stan's avatar
Daniel Stan committed
495
    proc = subprocess.Popen([os.getenv('EDITOR', '/usr/bin/editor'), f.name])
496
    os.waitpid(proc.pid, 0)
497
    f.seek(0)
498
    ntexte = f.read().decode("utf-8")
499
    f.close()
500
    ntexte = u'\n'.join(filter(lambda l: not l.startswith('#'), ntexte.split('\n')))
501
    return ntexte
502

503
def show_files(options):
504
    """Affiche la liste des fichiers disponibles sur le serveur distant"""
Vincent Le gallic's avatar
Vincent Le gallic committed
505
    print(u"Liste des fichiers disponibles :".encode("utf-8"))
506 507
    my_roles, _ = get_my_roles(options)
    files = all_files(options)
508 509 510 511
    keys = files.keys()
    keys.sort()
    for fname in keys:
        froles = files[fname]
Daniel Stan's avatar
Daniel Stan committed
512
        access = set(my_roles).intersection(froles) != set([])
Vincent Le gallic's avatar
Vincent Le gallic committed
513 514
        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"))
515
    
516
def show_roles(options):
517
    """Affiche la liste des roles existants"""
Vincent Le gallic's avatar
Vincent Le gallic committed
518
    print(u"Liste des roles disponibles".encode("utf-8"))
519 520
    allroles =  all_roles(options)
    for (role, usernames) in allroles.iteritems():
521
        if not role.endswith('-w'):
522
            print((u" * %s : %s" % (role, ", ".join(usernames))).encode("utf-8"))
523

524
def show_servers(options):
525
    """Affiche la liste des serveurs disponibles"""
Vincent Le gallic's avatar
Vincent Le gallic committed
526
    print(u"Liste des serveurs disponibles".encode("utf-8"))
527
    for server in config.servers.keys():
Vincent Le gallic's avatar
Vincent Le gallic committed
528
        print((u" * " + server).encode("utf-8"))
529

530
def saveclipboard(restore=False, old_clipboard=None):
531
    """Enregistre le contenu du presse-papier. Le rétablit si ``restore=True``"""
532 533 534
    if restore and old_clipboard == None:
        return
    act = '-in' if restore else '-out'
535 536
    proc = subprocess.Popen(['xclip', act, '-selection', 'clipboard'],
        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=sys.stderr)
537 538 539
    if not restore:
        old_clipboard = proc.stdout.read()
    else:
540
        raw_input(u"Appuyez sur Entrée pour récupérer le contenu précédent du presse papier.".encode("utf-8"))
541 542 543
        proc.stdin.write(old_clipboard)
    proc.stdin.close()
    proc.stdout.close()
544
    return old_clipboard
545

546
def clipboard(texte):
547
    """Place ``texte`` dans le presse-papier en mémorisant l'ancien contenu."""
548
    old_clipboard = saveclipboard()
549 550
    proc =subprocess.Popen(['xclip', '-selection', 'clipboard'],\
        stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr)
551
    proc.stdin.write(texte.encode("utf-8"))
552
    proc.stdin.close()
553
    return old_clipboard
554

555 556
@need_filename
def show_file(options):
557
    """Affiche le contenu d'un fichier"""
558 559
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
560
    if not gotit:
561 562
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
563
        return
564
    passfile = value
565
    (sin, sout) = gpg(options, 'decrypt')
566
    sin.write(passfile['contents'].encode("utf-8"))
567
    sin.close()
568 569
    texte = sout.read().decode("utf-8")
    ntexte = u""
570 571
    hidden = False  # Est-ce que le mot de passe a été caché ?
    lines = texte.split('\n')
572
    old_clipboard = None
573
    for line in lines:
Daniel Stan's avatar
Daniel Stan committed
574 575 576 577 578 579
        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
        if not hidden and options.clipboard:
            catchPass = pass_regexp.match(line)
        if catchPass != None:
580
            hidden = True
581 582 583 584
            # 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]"
585 586
        ntexte += line + '\n'
    showbin = "cat" if hidden else "less"
587
    proc = subprocess.Popen([showbin], stdin=subprocess.PIPE)
588
    out = proc.stdin
589
    raw = u"Fichier %s:\n\n%s-----\nVisible par: %s\n" % (fname, ntexte, ','.join(passfile['roles']))
590
    out.write(raw.encode("utf-8"))
591
    out.close()
592
    os.waitpid(proc.pid, 0)
593
    # Repope ancien pass
594 595
    if options.clipboard:
        saveclipboard(restore=True, old_clipboard=old_clipboard)
596

597 598
@need_filename
def edit_file(options):
599
    """Modifie/Crée un fichier"""
600 601
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
Daniel Stan's avatar
Daniel Stan committed
602
    nfile = False
603
    annotations = u""
604
    if not gotit and not u"pas les droits" in value:
Daniel Stan's avatar
Daniel Stan committed
605
        nfile = True
606 607 608
        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
609
            return
610
        annotations += u"""Ceci est un fichier initial contenant un mot de passe
611 612
aléatoire, pensez à rajouter une ligne "login: ${login}"
Enregistrez le fichier vide pour annuler.\n"""
613
        texte = u"pass: %s\n" % gen_password()
614 615 616
        if options.roles == []:
            if not options.quiet:
                print(u"Vous ne possédez aucun rôle en écriture ! Abandon.".encode("utf-8"))
617
            return
618
        passfile = {'roles' : options.roles}
619
    elif not gotit:
620 621
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
622
        return
Daniel Stan's avatar
Daniel Stan committed
623
    else:
624
        passfile = value
625
        (sin, sout) = gpg(options, 'decrypt')
626
        sin.write(passfile['contents'].encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
627
        sin.close()
628
        texte = sout.read().decode("utf-8")
629 630 631 632 633 634 635 636
    # 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)
637
    # On récupère les nouveaux roles si ils ont été précisés, sinon on garde les mêmes
638
    passfile['roles'] = options.roles or passfile['roles']
639
    
640 641
    annotations += u"""Ce fichier sera chiffré pour les rôles suivants :\n%s\n
C'est-à-dire pour les utilisateurs suivants :\n%s""" % (
642 643
           ', '.join(passfile['roles']),
           '\n'.join(' %s' % rec for rec in get_dest_of_roles(options, passfile['roles']))
644
        )
645
    
646
    ntexte = editor(texte, annotations)
647
    
648 649 650 651 652 653 654 655
    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"))
656
    else:
Daniel Stan's avatar
Daniel Stan committed
657
        ntexte = texte if ntexte == None else ntexte
658
        success, message = put_password(options, passfile['roles'], ntexte)
659
        print(message.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
660

661 662 663 664
def confirm(options, text):
    """Demande confirmation, sauf si on est mode ``--force``"""
    if options.force:
        return True
Daniel Stan's avatar
Daniel Stan committed
665
    while True:
666
        out = raw_input((text + u' (o/n)').encode("utf-8")).lower()
Daniel Stan's avatar
Daniel Stan committed
667 668 669 670 671
        if out == 'o':
            return True
        elif out == 'n':
            return False

672 673
@need_filename
def remove_file(options):
674
    """Supprime un fichier"""
675
    fname = options.fname
676
    if not confirm(options, u'Êtes-vous sûr de vouloir supprimer %s ?' % (fname,)):
Daniel Stan's avatar
Daniel Stan committed
677
        return
678 679
    message = rm_file(fname)
    print(message.encode("utf-8"))
680

Daniel Stan's avatar
Daniel Stan committed
681

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

687
def my_update_keys(options):
688
    """Met à jour les clés existantes et affiche le résultat"""
689 690 691 692 693 694 695 696
    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)
697 698
    if rechiffre_roles == None:
        # Sans précisions, on prend tous les roles qu'on peut
699
        rechiffre_roles = my_roles_w
700 701
    
    # La liste des fichiers
702 703 704
    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
705
    askfiles = [filename for (filename, fileroles) in allfiles.iteritems()
706
                         if set(fileroles).intersection(options.roles) != set()
707
                         and set(fileroles).intersection(my_roles_w) != set()]
708
    files = get_files(options, askfiles)
709 710 711 712
    # 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:
713 714
            if not options.quiet:
                print(message.encode("utf-8"))
715
            return
716 717 718 719 720 721
    # 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)
722 723 724
    # On rechiffre
    to_put = [{'filename' : f['filename'],
               'roles' : f['roles'],
725
               'contents' : encrypt(options, f['roles'], decrypt(options, f['contents']))}
726 727
              for f in files]
    if to_put:
728 729
        if not options.quiet:
            print((u"Rechiffrement de %s" % (", ".join([f['filename'] for f in to_put]))).encode("utf-8"))
730 731
        results = put_files(to_put)
        # On affiche les messages de retour
732 733 734
        if not options.quiet:
            for i in range(len(results)):
                print(u"%s : %s" % (to_put[i]['filename'], results[i][1]))
735
    else:
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
        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
756 757
    ret = set()
    for role in strroles.split(','):
758 759 760 761
        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
762
        if role.endswith('-w'):
763 764 765 766
            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
767 768
        ret.add(role)
    return list(ret)
769

770 771 772 773 774 775 776 777
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)

778
if __name__ == "__main__":
779
    parser = argparse.ArgumentParser(description="Gestion de mots de passe partagés grâce à GPG.")
780
    parser.add_argument('-s', '--server', default='default',
781 782
        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
783
        help="Mode verbeux")
784 785 786
    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.")
787
    parser.add_argument('-q', '--quiet', action='store_true', default=False,
788
        help="Mode silencieux. Cache les message d'erreurs (override --verbose et --interactive).")
789
    parser.add_argument('-c', '--clipboard', action='store_true', default=None,
Daniel Stan's avatar
Daniel Stan committed
790
        help="Stocker le mot de passe dans le presse papier")
791
    parser.add_argument('--no-clip', '--noclip', '--noclipboard', action='store_false', default=None,
792
        dest='noclipboard',
793
        help="Ne PAS stocker le mot de passe dans le presse papier")
794 795
    parser.add_argument('-f', '--force', action='store_true', default=False,
        help="Ne pas demander confirmation")
Daniel Stan's avatar
Daniel Stan committed
796 797 798

    # Actions possibles
    action_grp = parser.add_mutually_exclusive_group(required=False)
799 800
    action_grp.add_argument('-e', '--edit', action='store_const', dest='action',
        default=show_file, const=edit_file,
Daniel Stan's avatar
Daniel Stan committed
801
        help="Editer (ou créer)")
802 803 804 805 806 807 808 809
    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
810
        help="Lister les fichiers")
811 812
    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
813
        help="Vérifier les clés")
814 815
    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
816
        help="Mettre à jour les clés")
817 818 819 820 821 822
    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")
823 824
    action_grp.add_argument('--recrypt-files', action='store_const', dest='action',
        default=show_file, const=recrypt_files,
825 826 827
        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é)""")
828
    
829
    parser.add_argument('--roles', nargs='?', default=None,
830 831 832 833 834
        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).""")
835
    parser.add_argument('fname', nargs='?', default=None,
Daniel Stan's avatar
Daniel Stan committed
836
        help="Nom du fichier à afficher")
837
    
838 839
    # On parse les options fournies en commandline
    options = parser.parse_args(sys.argv[1:])
840
    
841 842 843 844 845 846 847 848 849 850 851 852 853 854
    ## 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
855 856 857 858
    # 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)
859
    
860 861 862 863 864 865 866
    # 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)