client.py 40.1 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'])
95 96
    if options.verbose:
        print(" ".join(full_command))
Daniel Stan's avatar
Daniel Stan committed
97 98 99
    proc = subprocess.Popen(full_command,
                            stdin = subprocess.PIPE,
                            stdout = subprocess.PIPE,
100
                            stderr = stderr,
Daniel Stan's avatar
Daniel Stan committed
101
                            close_fds = True)
102
    if not options.verbose:
103
        proc.stderr.close()
Daniel Stan's avatar
Daniel Stan committed
104 105
    return proc.stdin, proc.stdout

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
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»
176 177 178 179 180 181 182 183 184
        try:
            line = line.decode("utf-8")
        except UnicodeDecodeError:
            try:
                line = line.decode("iso8859-1")
            except UnicodeDecodeError:
                line = line.decode("iso8859-1", "ignore")
                if not options.quiet:
                    print("gpg raconte de la merde, c'est ni de l'ISO-8859-1 ni de l'UTF-8, je droppe, ça risque de foirer plus tard.", sys.stderr)
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 228 229 230 231 232 233 234 235 236 237
        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
238 239 240 241 242 243 244

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

245 246 247 248 249
    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."""
250
        if self.val == None:
251
            self.val = self.f(*args, **kwargs)
252 253 254 255 256 257
        # 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
258

259

Daniel Stan's avatar
Daniel Stan committed
260 261 262
######
## Remote commands

263 264 265 266 267 268 269 270 271
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
    """
272
    full_command = list(options.serverdata['server_cmd'])
Daniel Stan's avatar
Daniel Stan committed
273 274 275
    full_command.append(command)
    if arg:
        full_command.append(arg)
276 277 278 279

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

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

287 288 289 290 291 292 293 294 295
@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

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

302 303 304 305 306 307 308 309 310 311 312
    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))
313 314 315 316 317
            proc.stdin.flush()

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

318 319 320 321 322 323 324 325
        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)
326
    try:
327
        answer = json.loads(raw_out.strip())
328 329 330 331
    except ValueError:
        if not options.quiet:
            print(u"Impossible de parser le résultat".encode('utf-8'),
                  file=sys.stderr)
332
            if detail:
333 334
                print("raw_output: %s" % raw_out)
            sys.exit(42)
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
    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
350

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

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

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

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

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

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

378
@simple_memoize
379 380 381
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)
382 383
    distant_username = allroles.pop("whoami")
    my_roles = [r for (r, users) in allroles.iteritems() if distant_username in users]
384 385
    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
386

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

Daniel Stan's avatar
Daniel Stan committed
394 395 396
######
## Local commands

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

400
    keys = all_keys(options)
401

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

405 406 407 408 409
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"""
410
    # Il faut que la clé soit dans le réseau de confiance…
411 412 413
    meaning, trustvalue = GPG_TRUSTLEVELS[key[u"trustletter"]]
    if not trustvalue:
        return u"La confiance en la clé est : %s" % (meaning,)
414
    # …et qu'on puisse chiffrer avec…
415 416 417 418 419 420 421 422 423 424 425 426
    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."

427
def check_keys(options, recipients=None, quiet=False):
428 429
    """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).
430

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

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

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

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

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

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

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

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

554
######
555 556
## Interface

557 558 559 560 561 562 563
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

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

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

590
def show_files(options):
591
    """Affiche la liste des fichiers disponibles sur le serveur distant"""
Vincent Le gallic's avatar
Vincent Le gallic committed
592
    print(u"Liste des fichiers disponibles :".encode("utf-8"))
593 594
    my_roles, _ = get_my_roles(options)
    files = all_files(options)
595 596 597 598
    keys = files.keys()
    keys.sort()
    for fname in keys:
        froles = files[fname]
Daniel Stan's avatar
Daniel Stan committed
599
        access = set(my_roles).intersection(froles) != set([])
Vincent Le gallic's avatar
Vincent Le gallic committed
600 601
        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"))
602

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

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

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

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

644 645
@need_filename
def show_file(options):
646
    """Affiche le contenu d'un fichier"""
647 648
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
649
    if not gotit:
650 651
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
652
        return
653
    passfile = value
654
    (sin, sout) = gpg(options, 'decrypt')
655 656 657 658 659
    content = passfile['contents'] # Kludge (broken db ?)
    if type(content) == list:
        print("Eau dans le gaz")
        content = content[-1]
    sin.write(content.encode("utf-8"))
660
    sin.close()
661 662
    texte = sout.read().decode("utf-8")
    ntexte = u""
663 664
    hidden = False  # Est-ce que le mot de passe a été caché ?
    lines = texte.split('\n')
665
    old_clipboard = None
666
    for line in lines:
Daniel Stan's avatar
Daniel Stan committed
667 668 669 670 671 672
        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:
673
            hidden = True
674 675 676 677
            # 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]"
678 679
        ntexte += line + '\n'
    showbin = "cat" if hidden else "less"
680
    proc = subprocess.Popen([showbin], stdin=subprocess.PIPE)
681
    out = proc.stdin
682
    raw = u"Fichier %s:\n\n%s-----\nVisible par: %s\n" % (fname, ntexte, ','.join(passfile['roles']))
683
    out.write(raw.encode("utf-8"))
684
    out.close()
685
    os.waitpid(proc.pid, 0)
686
    # Repope ancien pass
687 688
    if options.clipboard:
        saveclipboard(restore=True, old_clipboard=old_clipboard)
689

690 691
@need_filename
def edit_file(options):
692
    """Modifie/Crée un fichier"""
693 694
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
Daniel Stan's avatar
Daniel Stan committed
695
    nfile = False
696
    annotations = u""
697 698 699 700 701

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

    # Cas du nouveau fichier
702
    if not gotit and not u"pas les droits" in value:
Daniel Stan's avatar
Daniel Stan committed
703
        nfile = True
704 705 706
        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
707
            return
708
        annotations += u"""Ceci est un fichier initial contenant un mot de passe
709 710
aléatoire, pensez à rajouter une ligne "login: ${login}"
Enregistrez le fichier vide pour annuler.\n"""
711
        texte = u"pass: %s\n" % gen_password()
712 713 714 715

        if new_roles is None:
            new_roles = parse_roles(options, cast=True)
        passfile = {'roles' : new_roles}
716
    elif not gotit:
717 718
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
719
        return
Daniel Stan's avatar
Daniel Stan committed
720
    else:
721
        passfile = value
722
        (sin, sout) = gpg(options, 'decrypt')
Daniel Stan's avatar
Daniel Stan committed
723 724 725 726 727 728
        contents = passfile['contents']
        # <ducktape> (waddle waddle)
        if isinstance(contents, list):
            contents = contents[-1]
        # </ducktape>
        sin.write(contents.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
729
        sin.close()
730
        texte = sout.read().decode("utf-8")
731 732 733 734 735 736 737 738 739 740 741 742 743
        if new_roles is None:
            new_roles = passfile['roles']

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

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

750 751
    annotations += u"""Ce fichier sera chiffré pour les rôles suivants :\n%s\n
C'est-à-dire pour les utilisateurs suivants :\n%s""" % (
752
           ', '.join(new_roles),
753
           '\n'.join(' %s' % rec for rec in get_dest_of_roles(options, new_roles))
754
        )
755

756
    ntexte = editor(texte, annotations)
757

758 759 760
    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.
761 762 763 764 765
        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"))
766
    else:
Daniel Stan's avatar
Daniel Stan committed
767
        ntexte = texte if ntexte == None else ntexte
768
        success, message = put_password(options, new_roles, ntexte)
769
        print(message.encode("utf-8"))
Daniel Stan's avatar
Daniel Stan committed
770

771 772 773 774
def confirm(options, text):
    """Demande confirmation, sauf si on est mode ``--force``"""
    if options.force:
        return True
Daniel Stan's avatar
Daniel Stan committed
775
    while True:
776
        out = raw_input((text + u' (o/n)').encode("utf-8")).lower()
Daniel Stan's avatar
Daniel Stan committed
777 778 779 780 781
        if out == 'o':
            return True
        elif out == 'n':
            return False

782 783
@need_filename
def remove_file(options):
784
    """Supprime un fichier"""
785
    fname = options.fname
786
    if not confirm(options, u'Êtes-vous sûr de vouloir supprimer %s ?' % (fname,)):
Daniel Stan's avatar
Daniel Stan committed
787
        return
788 789
    message = rm_file(fname)
    print(message.encode("utf-8"))
790

Daniel Stan's avatar
Daniel Stan committed
791

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

797
def my_update_keys(options):
798
    """Met à jour les clés existantes et affiche le résultat"""
799 800
    print(update_keys(options).encode("utf-8"))

801
def recrypt_files(options, strict=False):
802
    """Rechiffre les fichiers.
803 804 805
       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.
806 807 808
       """
    rechiffre_roles = options.roles
    _, my_roles_w = get_my_roles(options)
809 810
    if rechiffre_roles == None:
        # Sans précisions, on prend tous les roles qu'on peut
811
        rechiffre_roles = my_roles_w
812

813
    # La liste des fichiers
814
    allfiles = all_files(options)
815 816 817 818 819 820 821 822 823 824

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

825
    askfiles = [filename for (filename, fileroles) in allfiles.iteritems()
826
                         if is_wanted(fileroles) ]
827
    files = get_files(options, askfiles)
828 829 830 831
    # 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:
832 833
            if not options.quiet:
                print(message.encode("utf-8"))
834
            return
835 836 837 838 839 840
    # 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)
841 842 843
    # On rechiffre
    to_put = [{'filename' : f['filename'],
               'roles' : f['roles'],
844
               'contents' : encrypt(options, f['roles'], decrypt(options, f['contents']))[-1]}
845
              for [success, f] in files]
846
    if to_put:
847 848
        if not options.quiet:
            print((u"Rechiffrement de %s" % (", ".join([f['filename'] for f in to_put]))).encode("utf-8"))
849
        results = put_files(options, to_put)
850
        # On affiche les messages de retour
851 852 853
        if not options.quiet:
            for i in range(len(results)):
                print(u"%s : %s" % (to_put[i]['filename'], results[i][1]))
854
    else:
855 856 857
        if not options.quiet:
            print(u"Aucun fichier n'a besoin d'être rechiffré".encode("utf-8"))

858
def parse_roles(options, cast=False):
859
    """Interprête la liste de rôles fournie par l'utilisateur.
860 861 862 863
       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.
864

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

867 868 869 870
       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
    """
871 872 873
    if options.roles is None and not cast:
        return options.roles

874 875 876 877 878 879
    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
880 881
    ret = set()
    for role in strroles.split(','):
882 883 884 885
        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
886
        if role.endswith('-w'):
887 888 889 890
            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
891 892
        ret.add(role)
    return list(ret)
893

894 895 896 897 898 899 900 901
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)

902
if __name__ == "__main__":
903
    parser = argparse.ArgumentParser(description="Gestion de mots de passe partagés grâce à GPG.")
904
    parser.add_argument('-s', '--server', default='default',
905 906
        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
907
        help="Mode verbeux")
908 909 910
    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.")
911
    parser.add_argument('-q', '--quiet', action='store_true', default=False,
912
        help="Mode silencieux. Cache les message d'erreurs (override --verbose et --interactive).")
913
    parser.add_argument('-c', '--clipboard', action='store_true', default=None,
Daniel Stan's avatar
Daniel Stan committed
914
        help="Stocker le mot de passe dans le presse papier")
915
    parser.add_argument('--no-clip', '--noclip', '--noclipboard', action='store_false', default=None,
916
        dest='clipboard',
917
        help="Ne PAS stocker le mot de passe dans le presse papier")
918 919
    parser.add_argument('-f', '--force', action='store_true', default=False,
        help="Ne pas demander confirmation")
Daniel Stan's avatar
Daniel Stan committed
920 921 922

    # Actions possibles
    action_grp = parser.add_mutually_exclusive_group(required=False)
923 924
    action_grp.add_argument('-e', '--edit', action='store_const', dest='action',
        default=show_file, const=edit_file,
Daniel Stan's avatar
Daniel Stan committed
925
        help="Editer (ou créer)")
926 927 928 929 930 931 932 933
    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
934
        help="Lister les fichiers")
935 936
    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
937
        help="Vérifier les clés")
938 939
    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
940
        help="Mettre à jour les clés")
941 942 943 944 945 946
    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")
947 948
    action_grp.add_argument('--recrypt-files', action='store_const', dest='action',
        default=show_file, const=recrypt_files,
949 950 951
        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é)""")
952 953 954 955
    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)""")

956
    parser.add_argument('--roles', nargs='?', default=None,
957 958 959 960 961 962 963 964 965
        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
            """)
966
    parser.add_argument('fname', nargs='?', default=None,
967
        type=lambda x: x.decode('utf-8'),
Daniel Stan's avatar
Daniel Stan committed
968
        help="Nom du fichier à afficher")
969

970 971
    # On parse les options fournies en commandline
    options = parser.parse_args(sys.argv[1:])
972

973 974 975
    ## 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.
976 977 978 979 980 981
    # ** 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')
982 983 984 985 986 987 988 989
    # 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
990 991 992 993
    # 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)
994

995 996 997 998
    # 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)
999

1000 1001
    # On exécute l'action demandée
    options.action(options)