client.py 39.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
                    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),
78 79
                    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 243 244 245 246 247
        # 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
248

249

Daniel Stan's avatar
Daniel Stan committed
250 251 252
######
## Remote commands

253 254 255 256 257 258 259 260 261
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
    """
262
    full_command = list(options.serverdata['server_cmd'])
Daniel Stan's avatar
Daniel Stan committed
263 264 265
    full_command.append(command)
    if arg:
        full_command.append(arg)
266 267 268 269

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

Daniel Stan's avatar
Daniel Stan committed
270 271 272 273 274
    proc = subprocess.Popen(full_command,
                            stdin = subprocess.PIPE,
                            stdout = subprocess.PIPE,
                            stderr = sys.stderr,
                            close_fds = True)
275
    return proc
Daniel Stan's avatar
Daniel Stan committed
276

277 278 279 280 281 282 283 284 285
@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

286
def remote_command(options, command, arg=None, stdin_contents=None):
Daniel Stan's avatar
Daniel Stan committed
287 288
    """Exécute la commande distante, et retourne la sortie de cette
    commande"""
289
    detail = options.verbose and not options.quiet
290
    keep_alive = options.serverdata.get('keep-alive', False)
Daniel Stan's avatar
Daniel Stan committed
291
    
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
    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))
            proc.stdin.close()
        ret = proc.wait()
        raw_out = proc.stdout.read()
        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)
314
    try:
315
        answer = json.loads(raw_out.strip())
316 317 318 319
    except ValueError:
        if not options.quiet:
            print(u"Impossible de parser le résultat".encode('utf-8'),
                  file=sys.stderr)
320
            if detail:
321 322
                print("raw_output: %s" % raw_out)
            sys.exit(42)
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
    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
338

339
@simple_memoize
340
def all_keys(options):
Daniel Stan's avatar
Daniel Stan committed
341
    """Récupère les clés du serveur distant"""
342
    return remote_command(options, "listkeys")
Daniel Stan's avatar
Daniel Stan committed
343

344
@simple_memoize
345
def all_roles(options):
Daniel Stan's avatar
Daniel Stan committed
346
    """Récupère les roles du serveur distant"""
347
    return remote_command(options, "listroles")
Daniel Stan's avatar
Daniel Stan committed
348

349
@simple_memoize
350
def all_files(options):
Daniel Stan's avatar
Daniel Stan committed
351
    """Récupère les fichiers du serveur distant"""
352
    return remote_command(options, "listfiles")
Daniel Stan's avatar
Daniel Stan committed
353

354
def get_files(options, filenames):
355
    """Récupère le contenu des fichiers distants"""
356
    return remote_command(options, "getfiles", stdin_contents=filenames)
Daniel Stan's avatar
Daniel Stan committed
357

358
def put_files(options, files):
359
    """Dépose les fichiers sur le serveur distant"""
360
    return remote_command(options, "putfiles", stdin_contents=files)
361

Daniel Stan's avatar
Daniel Stan committed
362 363
def rm_file(filename):
    """Supprime le fichier sur le serveur distant"""
364
    return remote_command(options, "rmfile", filename)
Daniel Stan's avatar
Daniel Stan committed
365

366
@simple_memoize
367 368 369
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)
370 371
    distant_username = allroles.pop("whoami")
    my_roles = [r for (r, users) in allroles.iteritems() if distant_username in users]
372 373
    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
374

375
def gen_password():
376
    """Génère un mot de passe aléatoire"""
377 378 379
    random.seed(datetime.datetime.now().microsecond)
    chars = string.letters + string.digits + '/=+*'
    length = 15
380
    return u''.join([random.choice(chars) for _ in xrange(length)])
381

Daniel Stan's avatar
Daniel Stan committed
382 383 384
######
## Local commands

385
def update_keys(options):
Daniel Stan's avatar
Daniel Stan committed
386
    """Met à jour les clés existantes"""
387
    
388
    keys = all_keys(options)
389
    
390
    _, stdout = gpg(options, "receive-keys", [key for _, key in keys.values() if key])
391
    return stdout.read().decode("utf-8")
Daniel Stan's avatar
Daniel Stan committed
392

393 394 395 396 397
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"""
398
    # Il faut que la clé soit dans le réseau de confiance…
399 400 401
    meaning, trustvalue = GPG_TRUSTLEVELS[key[u"trustletter"]]
    if not trustvalue:
        return u"La confiance en la clé est : %s" % (meaning,)
402
    # …et qu'on puisse chiffrer avec…
403 404 405 406 407 408 409 410 411 412 413 414
    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."

415
def check_keys(options, recipients=None, quiet=False):
416 417 418 419 420
    """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.
421 422
         * 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.
423 424 425
        * Si rien n'est fourni, vérifie toutes les clés et renvoie juste un booléen disant si tout va bien.
       """
    trusted_recipients = []
426
    keys = all_keys(options)
427
    if recipients is None:
428
        speak = options.verbose and not options.quiet
429
    else:
430
        speak = False
431
        keys = {u : val for (u, val) in keys.iteritems() if u in recipients}
432
    if speak:
433
        print("M : le mail correspond à un uid du fingerprint\nC : confiance OK (inclut la vérification de non expiration).\n")
434
    _, gpgout = gpg(options, 'list-keys')
435
    localring = parse_keys(gpgout)
436 437 438
    for (recipient, (mail, fpr)) in keys.iteritems():
        failed = u""
        if not fpr is None:
439
            if speak:
440
                print((u"Checking %s… " % (mail)).encode("utf-8"), end="")
441
            key = localring.get(fpr, None)
442
            # On vérifie qu'on possède la clé…
443
            if not key is None:
444
                # …qu'elle correspond au mail…
445
                if any([u"<%s>" % (mail,) in u["uid"] for u in key["uids"]]):
446
                    if speak:
447
                        print("M ", end="")
448 449 450
                    # … et qu'on peut raisonnablement chiffrer pour lui
                    failed = _check_encryptable(key)
                    if not failed and speak:
451
                        print("C ", end="")
452
                else:
453
                    failed = u"!! Le fingerprint et le mail ne correspondent pas !"
454
            else:
455
                failed = u"Pas (ou trop) de clé avec ce fingerprint."
456
            if speak:
457
                print("")
458
            if failed:
459
                if not options.quiet:
460 461 462
                    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
463
                    message = u"Abandonner le chiffrement pour cette clé ? (Si vous la conservez, il est posible que gpg crashe)"
464 465 466 467
                    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
468
                    else:
469
                        drop = False # Là, on droppe pas
470 471
                    if not drop:
                        trusted_recipients.append(recipient)
472 473 474
                    else:
                        if not options.quiet:
                            print(u"Droppe la clé %s:%s" % (fpr, recipient))
475 476 477 478 479 480
            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
481

482
def get_recipients_of_roles(options, roles):
Vincent Le gallic's avatar
Vincent Le gallic committed
483
    """Renvoie les destinataires d'une liste de rôles"""
484
    recipients = set()
485
    allroles = all_roles(options)
486
    allroles.pop("whoami")
487 488 489 490 491
    for role in roles:
        for recipient in allroles[role]:
            recipients.add(recipient)
    return recipients

492
def get_dest_of_roles(options, roles):
493
    """Renvoie la liste des "username : mail (fingerprint)" """
494
    allkeys = all_keys(options)
495
    return [u"%s : %s (%s)" % (rec, allkeys[rec][0], allkeys[rec][1])
496
               for rec in get_recipients_of_roles(options, roles) if allkeys[rec][1]]
497

498
def encrypt(options, roles, contents):
499 500
    """Chiffre le contenu pour les roles donnés"""
    
501 502 503
    allkeys = all_keys(options)
    recipients = get_recipients_of_roles(options, roles)
    recipients = check_keys(options, recipients=recipients, quiet=True)
504
    fpr_recipients = []
Daniel Stan's avatar
Daniel Stan committed
505
    for recipient in recipients:
506 507 508 509
        fpr = allkeys[recipient][1]
        if fpr:
            fpr_recipients.append("-r")
            fpr_recipients.append(fpr)
510
    
511
    stdin, stdout = gpg(options, "encrypt", fpr_recipients)
512
    stdin.write(contents.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
513
    stdin.close()
514
    out = stdout.read().decode("utf-8")
515
    if out == '':
516
        return [False, u"Échec de chiffrement"]
517
    else:
518
        return [True, out]
Daniel Stan's avatar
Daniel Stan committed
519

520
def decrypt(options, contents):
Daniel Stan's avatar
Daniel Stan committed
521
    """Déchiffre le contenu"""
522
    stdin, stdout = gpg(options, "decrypt")
523 524 525
    if type(contents) != unicode: # Kludge (broken db ?)
        print("Eau dans le gaz (decrypt)" + repr(contents))
        contents = contents[-1]
526
    stdin.write(contents.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
527
    stdin.close()
528
    return stdout.read().decode("utf-8")
Daniel Stan's avatar
Daniel Stan committed
529

530
def put_password(options, roles, contents):
Daniel Stan's avatar
Daniel Stan committed
531
    """Dépose le mot de passe après l'avoir chiffré pour les
532 533
    destinataires dans ``roles``."""
    success, enc_pwd_or_error = encrypt(options, roles, contents)
534 535
    if success:
        enc_pwd = enc_pwd_or_error
536
        return put_files(options, [{'filename' : options.fname, 'roles' : roles, 'contents' : enc_pwd}])[0]
537
    else:
538 539
        error = enc_pwd_or_error
        return [False, error]
Daniel Stan's avatar
Daniel Stan committed
540

541
######
542 543
## Interface

544 545 546 547 548 549 550
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

551
def editor(texte, annotations=u""):
552 553 554
    """ Lance $EDITOR sur texte.
    Renvoie le nouveau texte si des modifications ont été apportées, ou None
    """
555
    
556 557 558
    # Avoid syntax hilight with ".txt". Would be nice to have some colorscheme
    # for annotations ...
    f = tempfile.NamedTemporaryFile(suffix='.txt')
559
    atexit.register(f.close)
560 561 562
    if annotations:
        annotations = "# " + annotations.replace("\n", "\n# ")
    f.write((texte + "\n" + annotations).encode("utf-8"))
563
    f.flush()
Daniel Stan's avatar
Daniel Stan committed
564
    proc = subprocess.Popen([os.getenv('EDITOR', '/usr/bin/editor'), f.name])
565
    os.waitpid(proc.pid, 0)
566
    f.seek(0)
567
    ntexte = f.read().decode("utf-8")
568
    f.close()
569
    ntexte = u'\n'.join(filter(lambda l: not l.startswith('#'), ntexte.split('\n')))
570
    return ntexte
571

572
def show_files(options):
573
    """Affiche la liste des fichiers disponibles sur le serveur distant"""
Vincent Le gallic's avatar
Vincent Le gallic committed
574
    print(u"Liste des fichiers disponibles :".encode("utf-8"))
575 576
    my_roles, _ = get_my_roles(options)
    files = all_files(options)
577 578 579 580
    keys = files.keys()
    keys.sort()
    for fname in keys:
        froles = files[fname]
Daniel Stan's avatar
Daniel Stan committed
581
        access = set(my_roles).intersection(froles) != set([])
Vincent Le gallic's avatar
Vincent Le gallic committed
582 583
        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"))
584
    
585
def show_roles(options):
586
    """Affiche la liste des roles existants"""
Vincent Le gallic's avatar
Vincent Le gallic committed
587
    print(u"Liste des roles disponibles".encode("utf-8"))
588 589
    allroles =  all_roles(options)
    for (role, usernames) in allroles.iteritems():
590
        if not role.endswith('-w'):
591
            print((u" * %s : %s" % (role, ", ".join(usernames))).encode("utf-8"))
592

593
def show_servers(options):
594
    """Affiche la liste des serveurs disponibles"""
Vincent Le gallic's avatar
Vincent Le gallic committed
595
    print(u"Liste des serveurs disponibles".encode("utf-8"))
596
    for server in config.servers.keys():
Vincent Le gallic's avatar
Vincent Le gallic committed
597
        print((u" * " + server).encode("utf-8"))
598

599
def saveclipboard(restore=False, old_clipboard=None):
600
    """Enregistre le contenu du presse-papier. Le rétablit si ``restore=True``"""
601 602 603
    if restore and old_clipboard == None:
        return
    act = '-in' if restore else '-out'
604 605
    proc = subprocess.Popen(['xclip', act, '-selection', 'clipboard'],
        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=sys.stderr)
606 607 608
    if not restore:
        old_clipboard = proc.stdout.read()
    else:
609
        raw_input(u"Appuyez sur Entrée pour récupérer le contenu précédent du presse papier.".encode("utf-8"))
610 611 612
        proc.stdin.write(old_clipboard)
    proc.stdin.close()
    proc.stdout.close()
613
    return old_clipboard
614

615
def clipboard(texte):
616
    """Place ``texte`` dans le presse-papier en mémorisant l'ancien contenu."""
617
    old_clipboard = saveclipboard()
618 619
    proc =subprocess.Popen(['xclip', '-selection', 'clipboard'],\
        stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr)
620
    proc.stdin.write(texte.encode("utf-8"))
621
    proc.stdin.close()
622
    return old_clipboard
623

624 625
@need_filename
def show_file(options):
626
    """Affiche le contenu d'un fichier"""
627 628
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
629
    if not gotit:
630 631
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
632
        return
633
    passfile = value
634
    (sin, sout) = gpg(options, 'decrypt')
635 636 637 638 639
    content = passfile['contents'] # Kludge (broken db ?)
    if type(content) == list:
        print("Eau dans le gaz")
        content = content[-1]
    sin.write(content.encode("utf-8"))
640
    sin.close()
641 642
    texte = sout.read().decode("utf-8")
    ntexte = u""
643 644
    hidden = False  # Est-ce que le mot de passe a été caché ?
    lines = texte.split('\n')
645
    old_clipboard = None
646
    for line in lines:
Daniel Stan's avatar
Daniel Stan committed
647 648 649 650 651 652
        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:
653
            hidden = True
654 655 656 657
            # 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]"
658 659
        ntexte += line + '\n'
    showbin = "cat" if hidden else "less"
660
    proc = subprocess.Popen([showbin], stdin=subprocess.PIPE)
661
    out = proc.stdin
662
    raw = u"Fichier %s:\n\n%s-----\nVisible par: %s\n" % (fname, ntexte, ','.join(passfile['roles']))
663
    out.write(raw.encode("utf-8"))
664
    out.close()
665
    os.waitpid(proc.pid, 0)
666
    # Repope ancien pass
667 668
    if options.clipboard:
        saveclipboard(restore=True, old_clipboard=old_clipboard)
669

670 671
@need_filename
def edit_file(options):
672
    """Modifie/Crée un fichier"""
673 674
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
Daniel Stan's avatar
Daniel Stan committed
675
    nfile = False
676
    annotations = u""
677 678 679 680 681

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

    # Cas du nouveau fichier
682
    if not gotit and not u"pas les droits" in value:
Daniel Stan's avatar
Daniel Stan committed
683
        nfile = True
684 685 686
        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
687
            return
688
        annotations += u"""Ceci est un fichier initial contenant un mot de passe
689 690
aléatoire, pensez à rajouter une ligne "login: ${login}"
Enregistrez le fichier vide pour annuler.\n"""
691
        texte = u"pass: %s\n" % gen_password()
692 693 694 695

        if new_roles is None:
            new_roles = parse_roles(options, cast=True)
        passfile = {'roles' : new_roles}
696
    elif not gotit:
697 698
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
699
        return
Daniel Stan's avatar
Daniel Stan committed
700
    else:
701
        passfile = value
702
        (sin, sout) = gpg(options, 'decrypt')
703
        sin.write(passfile['contents'].encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
704
        sin.close()
705
        texte = sout.read().decode("utf-8")
706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
        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):
        message = u"""Vous vous apprêtez à perdre vos droits d'écritures""" + \
            """(ROLES ne contient rien parmi : %s) sur ce fichier, continuer ?"""
        message = message % (", ".join(r[:-2] for r in my_roles if '-w' in r),)
722
        if not confirm(options, message):
723
            return
724
    
725 726
    annotations += u"""Ce fichier sera chiffré pour les rôles suivants :\n%s\n
C'est-à-dire pour les utilisateurs suivants :\n%s""" % (
727
           ', '.join(passfile['roles']),
728
           '\n'.join(' %s' % rec for rec in get_dest_of_roles(options, new_roles))
729
        )
730
    
731
    ntexte = editor(texte, annotations)
732
    
733 734 735
    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.
736 737 738 739 740
        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"))
741
    else:
Daniel Stan's avatar
Daniel Stan committed
742
        ntexte = texte if ntexte == None else ntexte
743
        success, message = put_password(options, new_roles, ntexte)
744
        print(message.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
745

746 747 748 749
def confirm(options, text):
    """Demande confirmation, sauf si on est mode ``--force``"""
    if options.force:
        return True
Daniel Stan's avatar
Daniel Stan committed
750
    while True:
751
        out = raw_input((text + u' (o/n)').encode("utf-8")).lower()
Daniel Stan's avatar
Daniel Stan committed
752 753 754 755 756
        if out == 'o':
            return True
        elif out == 'n':
            return False

757 758
@need_filename
def remove_file(options):
759
    """Supprime un fichier"""
760
    fname = options.fname
761
    if not confirm(options, u'Êtes-vous sûr de vouloir supprimer %s ?' % (fname,)):
Daniel Stan's avatar
Daniel Stan committed
762
        return
763 764
    message = rm_file(fname)
    print(message.encode("utf-8"))
765

Daniel Stan's avatar
Daniel Stan committed
766

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

772
def my_update_keys(options):
773
    """Met à jour les clés existantes et affiche le résultat"""
774 775
    print(update_keys(options).encode("utf-8"))

776
def recrypt_files(options, strict=False):
777
    """Rechiffre les fichiers.
778 779 780
       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.
781 782 783
       """
    rechiffre_roles = options.roles
    _, my_roles_w = get_my_roles(options)
784 785
    if rechiffre_roles == None:
        # Sans précisions, on prend tous les roles qu'on peut
786
        rechiffre_roles = my_roles_w
787 788
    
    # La liste des fichiers
789
    allfiles = all_files(options)
790 791 792 793 794 795 796 797 798 799

    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))

800
    askfiles = [filename for (filename, fileroles) in allfiles.iteritems()
801
                         if is_wanted(fileroles) ]
802
    files = get_files(options, askfiles)
803 804 805 806
    # 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:
807 808
            if not options.quiet:
                print(message.encode("utf-8"))
809
            return
810 811 812 813 814 815
    # 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)
816 817 818
    # On rechiffre
    to_put = [{'filename' : f['filename'],
               'roles' : f['roles'],
819
               'contents' : encrypt(options, f['roles'], decrypt(options, f['contents']))[-1]}
820
              for [success, f] in files]
821
    if to_put:
822 823
        if not options.quiet:
            print((u"Rechiffrement de %s" % (", ".join([f['filename'] for f in to_put]))).encode("utf-8"))
824
        results = put_files(options, to_put)
825
        # On affiche les messages de retour
826 827 828
        if not options.quiet:
            for i in range(len(results)):
                print(u"%s : %s" % (to_put[i]['filename'], results[i][1]))
829
    else:
830 831 832
        if not options.quiet:
            print(u"Aucun fichier n'a besoin d'être rechiffré".encode("utf-8"))

833
def parse_roles(options, cast=False):
834
    """Interprête la liste de rôles fournie par l'utilisateur.
835 836 837 838
       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.
839 840 841 842 843 844 845
       
       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
    """
846 847 848
    if options.roles is None and not cast:
        return options.roles

849 850 851 852 853 854
    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
855 856
    ret = set()
    for role in strroles.split(','):
857 858 859 860
        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
861
        if role.endswith('-w'):
862 863 864 865
            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
866 867
        ret.add(role)
    return list(ret)
868

869 870 871 872 873 874 875 876
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)

877
if __name__ == "__main__":
878
    parser = argparse.ArgumentParser(description="Gestion de mots de passe partagés grâce à GPG.")
879
    parser.add_argument('-s', '--server', default='default',
880 881
        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
882
        help="Mode verbeux")
883 884 885
    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.")
886
    parser.add_argument('-q', '--quiet', action='store_true', default=False,
887
        help="Mode silencieux. Cache les message d'erreurs (override --verbose et --interactive).")
888
    parser.add_argument('-c', '--clipboard', action='store_true', default=None,
Daniel Stan's avatar
Daniel Stan committed
889
        help="Stocker le mot de passe dans le presse papier")
890
    parser.add_argument('--no-clip', '--noclip', '--noclipboard', action='store_false', default=None,
891
        dest='clipboard',
892
        help="Ne PAS stocker le mot de passe dans le presse papier")
893 894
    parser.add_argument('-f', '--force', action='store_true', default=False,
        help="Ne pas demander confirmation")
Daniel Stan's avatar
Daniel Stan committed
895 896 897

    # Actions possibles
    action_grp = parser.add_mutually_exclusive_group(required=False)
898 899
    action_grp.add_argument('-e', '--edit', action='store_const', dest='action',
        default=show_file, const=edit_file,
Daniel Stan's avatar
Daniel Stan committed
900
        help="Editer (ou créer)")
901 902 903 904 905 906 907 908
    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
909
        help="Lister les fichiers")
910 911
    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
912
        help="Vérifier les clés")
913 914
    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
915
        help="Mettre à jour les clés")
916 917 918 919 920 921
    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")
922 923
    action_grp.add_argument('--recrypt-files', action='store_const', dest='action',
        default=show_file, const=recrypt_files,
924 925 926
        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é)""")
927 928 929 930
    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)""")

931
    parser.add_argument('--roles', nargs='?', default=None,
932 933 934 935 936 937 938 939 940
        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
            """)
941
    parser.add_argument('fname', nargs='?', default=None,
Daniel Stan's avatar
Daniel Stan committed
942
        help="Nom du fichier à afficher")
943
    
944 945
    # On parse les options fournies en commandline
    options = parser.parse_args(sys.argv[1:])
946
    
947 948 949
    ## 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.
950 951 952 953 954 955
    # ** 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')
956 957 958 959 960 961 962 963
    # 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
964 965 966 967
    # 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)
968
    
969 970 971 972 973 974 975
    # 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)