client.py 34.8 KB
Newer Older
Daniel STAN's avatar
init  
Daniel STAN committed
1 2
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
Vincent Le gallic's avatar
Vincent Le gallic committed
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
init  
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
init  
Daniel STAN committed
14 15 16
import sys
import subprocess
import json
Daniel STAN's avatar
Daniel STAN committed
17 18 19
import tempfile
import os
import atexit
Daniel STAN's avatar
Daniel STAN committed
20
import argparse
Daniel STAN's avatar
Daniel STAN committed
21
import re
22 23
import random
import string
24
import time
25
import datetime
26 27

# Import de la config
28
envvar = "CRANSPASSWORDS_CLIENT_CONFIG_DIR"
29
try:
30 31 32
    # 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,)))
33 34
    import clientconfig as config
except ImportError:
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
    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
init  
Daniel STAN committed
50

51 52
#: 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?$',
Daniel STAN's avatar
Daniel STAN committed
53 54
        flags=re.IGNORECASE)

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

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

#: Mapping (lettre de trustlevel) -> (signification, faut-il faire confiance à la clé)
69
GPG_TRUSTLEVELS = {
70 71 72
                    u"-" : (u"inconnue (pas de valeur assignée)", False),
                    u"o" : (u"inconnue (nouvelle clé)", False),
                    u"i" : (u"invalide (self-signature manquante ?)", False),
73 74 75 76 77 78
                    u"n" : (u"nulle", False),
                    u"m" : (u"marginale", True),
                    u"f" : (u"entière", True),
                    u"u" : (u"ultime", True),
                    u"r" : (u"révoquée", False),
                    u"e" : (u"expirée", False),
79
                    u"q" : (u"non définie", False),
80
                  }
Daniel STAN's avatar
Daniel STAN committed
81

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

103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
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
227 228 229 230 231 232 233

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

234 235 236 237 238
    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."""
Vincent Le gallic's avatar
Vincent Le gallic committed
239
        if self.val == None:
240
            self.val = self.f(*args, **kwargs)
241 242
        return self.val

Vincent Le gallic's avatar
Vincent Le gallic committed
243

Daniel STAN's avatar
init  
Daniel STAN committed
244 245 246
######
## Remote commands

247
def ssh(command, options, arg=None):
Daniel STAN's avatar
init  
Daniel STAN committed
248 249
    """Lance ssh avec les arguments donnés. Renvoie son entrée
    standard et sa sortie standard."""
250
    full_command = list(options.serverdata['server_cmd'])
Daniel STAN's avatar
init  
Daniel STAN committed
251 252 253 254 255 256 257 258 259 260
    full_command.append(command)
    if arg:
        full_command.append(arg)
    proc = subprocess.Popen(full_command,
                            stdin = subprocess.PIPE,
                            stdout = subprocess.PIPE,
                            stderr = sys.stderr,
                            close_fds = True)
    return proc.stdin, proc.stdout

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

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

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

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

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

291
def put_files(options, files):
292
    """Dépose les fichiers sur le serveur distant"""
293
    return remote_command(options, "putfiles", stdin_contents=files)
Vincent Le gallic's avatar
Vincent Le gallic committed
294

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

299
@simple_memoize
300 301 302 303 304 305
def get_my_roles(options):
    """Retourne la liste des rôles de l'utilisateur, et également la liste des rôles dont il possède le role-w."""
    allroles = all_roles(options)
    my_roles = [r for (r, users) in allroles.iteritems() if options.serverdata['user'] in users]
    my_roles_w = [r[:-2] for r in my_roles if r.endswith("-w")]
    return (my_roles, my_roles_w)
Daniel STAN's avatar
Daniel STAN committed
306

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

Daniel STAN's avatar
init  
Daniel STAN committed
314 315 316
######
## Local commands

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

325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
def _check_encryptable(key):
    """Vérifie qu'on peut chiffrer un message pour ``key``.
       C'est-à-dire, que la clé est de confiance (et non expirée).
       Puis qu'on peut chiffrer avec, ou qu'au moins une de ses subkeys est de chiffrement (capability e)
       et est de confiance et n'est pas expirée"""
    # Il faut avoir confiance la clé…
    meaning, trustvalue = GPG_TRUSTLEVELS[key[u"trustletter"]]
    if not trustvalue:
        return u"La confiance en la clé est : %s" % (meaning,)
    # …et pouvoir chiffrer avec…
    if u"e" in key[u"capabilities"]:
        # …soit directement…
        return u""
    # …soit avec une de ses subkeys
    esubkeys = [sub for sub in key[u"subkeys"] if u"e" in sub[u"capabilities"]]
    if len(esubkeys) == 0:
        return u"La clé principale de permet pas de chiffrer et auncune sous-clé de chiffrement."
    if any([GPG_TRUSTLEVELS[sub[u"trustletter"]][1] for sub in esubkeys]):
        return u""
    else:
        return u"Aucune sous clé de chiffrement n'est de confiance et non expirée."

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

414
def get_recipients_of_roles(options, roles):
415 416
    """Renvoie les destinataires d'un rôle"""
    recipients = set()
417
    allroles = all_roles(options)
418 419 420 421 422
    for role in roles:
        for recipient in allroles[role]:
            recipients.add(recipient)
    return recipients

423
def get_dest_of_roles(options, roles):
Vincent Le gallic's avatar
Vincent Le gallic committed
424
    """Renvoie la liste des "username : mail (fingerprint)" """
425
    allkeys = all_keys(options)
426
    return [u"%s : %s (%s)" % (rec, allkeys[rec][0], allkeys[rec][1])
427
               for rec in get_recipients_of_roles(options, roles) if allkeys[rec][1]]
428

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

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

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

Vincent Le gallic's avatar
Vincent Le gallic committed
469
######
Daniel STAN's avatar
Daniel STAN committed
470 471
## Interface

472 473 474 475 476 477 478
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

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

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

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

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

Daniel STAN's avatar
Daniel STAN committed
543
def clipboard(texte):
Vincent Le gallic's avatar
Vincent Le gallic committed
544
    """Place ``texte`` dans le presse-papier en mémorisant l'ancien contenu."""
545
    old_clipboard = saveclipboard()
Vincent Le gallic's avatar
Vincent Le gallic committed
546 547
    proc =subprocess.Popen(['xclip', '-selection', 'clipboard'],\
        stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr)
548
    proc.stdin.write(texte.encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
549
    proc.stdin.close()
550
    return old_clipboard
Daniel STAN's avatar
Daniel STAN committed
551

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

588 589
@need_filename
def edit_file(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
590
    """Modifie/Crée un fichier"""
591 592
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
Daniel STAN's avatar
Daniel STAN committed
593
    nfile = False
594
    annotations = u""
595
    if not gotit and not u"pas les droits" in value:
Daniel STAN's avatar
Daniel STAN committed
596
        nfile = True
597 598 599
        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
600
            return
601
        annotations += u"""Ceci est un fichier initial contenant un mot de passe
Vincent Le gallic's avatar
Vincent Le gallic committed
602 603
aléatoire, pensez à rajouter une ligne "login: ${login}"
Enregistrez le fichier vide pour annuler.\n"""
604
        texte = u"pass: %s\n" % gen_password()
605 606 607
        if options.roles == []:
            if not options.quiet:
                print(u"Vous ne possédez aucun rôle en écriture ! Abandon.".encode("utf-8"))
608
            return
609
        passfile = {'roles' : options.roles}
610
    elif not gotit:
611 612
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
613
        return
Daniel STAN's avatar
Daniel STAN committed
614
    else:
615
        passfile = value
616
        (sin, sout) = gpg(options, 'decrypt')
617
        sin.write(passfile['contents'].encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
618
        sin.close()
619
        texte = sout.read().decode("utf-8")
620 621 622 623 624 625 626 627
    # On peut vouloir chiffrer un fichier sans avoir la possibilité de le lire dans le futur
    # Mais dans ce cas on préfère demander confirmation
    my_roles, _ = get_my_roles(options)
    if not options.force and set(options.roles).intersection(my_roles) == set():
        message = u"""Vous vous apprêtez à perdre vos droits de lecture (ROLES ne contient rien parmi : %s) sur ce fichier, continuer ?"""
        message = message % (", ".join(my_roles),)
        if not confirm(options, message):
            sys.exit(2)
628
    # On récupère les nouveaux roles si ils ont été précisés, sinon on garde les mêmes
629
    passfile['roles'] = options.roles or passfile['roles']
630
    
Vincent Le gallic's avatar
Vincent Le gallic committed
631 632
    annotations += u"""Ce fichier sera chiffré pour les rôles suivants :\n%s\n
C'est-à-dire pour les utilisateurs suivants :\n%s""" % (
633 634
           ', '.join(passfile['roles']),
           '\n'.join(' %s' % rec for rec in get_dest_of_roles(options, passfile['roles']))
635
        )
636
    
637
    ntexte = editor(texte, annotations)
638
    
639 640 641 642 643 644 645 646
    if ((not nfile and ntexte in [u'', texte]              # pas nouveau, vidé ou pas modifié
         and set(options.roles) == set(passfile['roles'])) # et on n'a même pas touché à ses rôles,
        or (nfile and ntexte == u'')):                     # ou alors on a créé un fichier vide.
        message = u"Pas de modification à enregistrer.\n"
        message += u"Si ce n'est pas un nouveau fichier, il a été vidé ou n'a pas été modifié (même pas ses rôles).\n"
        message += u"Si c'est un nouveau fichier, vous avez tenté de le créer vide."
        if not options.quiet:
            print(message.encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
647
    else:
Daniel STAN's avatar
Daniel STAN committed
648
        ntexte = texte if ntexte == None else ntexte
649
        success, message = put_password(options, passfile['roles'], ntexte)
650
        print(message.encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
651

652 653 654 655
def confirm(options, text):
    """Demande confirmation, sauf si on est mode ``--force``"""
    if options.force:
        return True
Daniel STAN's avatar
Daniel STAN committed
656
    while True:
657
        out = raw_input((text + u' (o/n)').encode("utf-8")).lower()
Daniel STAN's avatar
Daniel STAN committed
658 659 660 661 662
        if out == 'o':
            return True
        elif out == 'n':
            return False

663 664
@need_filename
def remove_file(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
665
    """Supprime un fichier"""
666 667
    fname = options.fname
    if not confirm(options, u'Êtes-vous sûr de vouloir supprimer %s ?' % (fname,), options):
Daniel STAN's avatar
Daniel STAN committed
668
        return
669 670
    message = rm_file(fname)
    print(message.encode("utf-8"))
Vincent Le gallic's avatar
Vincent Le gallic committed
671

Daniel STAN's avatar
Daniel STAN committed
672

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

678
def my_update_keys(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
679
    """Met à jour les clés existantes et affiche le résultat"""
680 681 682 683 684 685 686 687
    print(update_keys(options).encode("utf-8"))

def recrypt_files(options):
    """Rechiffre les fichiers.
       Ici, la signification de ``options.roles`` est : on ne veut rechiffrer que les fichiers qui ont au moins un de ces roles.
       """
    rechiffre_roles = options.roles
    _, my_roles_w = get_my_roles(options)
688 689
    if rechiffre_roles == None:
        # Sans précisions, on prend tous les roles qu'on peut
690
        rechiffre_roles = my_roles_w
691 692
    
    # La liste des fichiers
693 694 695
    allfiles = all_files(options)
    # On ne demande que les fichiers qui ont au moins un role dans ``options.roles``
    # et dans lesquels on peut écrire
696
    askfiles = [filename for (filename, fileroles) in allfiles.iteritems()
697
                         if set(fileroles).intersection(options.roles) != set()
698
                         and set(fileroles).intersection(my_roles_w) != set()]
699
    files = get_files(options, askfiles)
700 701 702 703
    # 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:
704 705
            if not options.quiet:
                print(message.encode("utf-8"))
706
            return
707 708 709 710 711 712
    # 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)
713 714 715
    # On rechiffre
    to_put = [{'filename' : f['filename'],
               'roles' : f['roles'],
716
               'contents' : encrypt(options, f['roles'], decrypt(options, f['contents']))}
717 718
              for f in files]
    if to_put:
719 720
        if not options.quiet:
            print((u"Rechiffrement de %s" % (", ".join([f['filename'] for f in to_put]))).encode("utf-8"))
721 722
        results = put_files(to_put)
        # On affiche les messages de retour
723 724 725
        if not options.quiet:
            for i in range(len(results)):
                print(u"%s : %s" % (to_put[i]['filename'], results[i][1]))
726
    else:
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
        if not options.quiet:
            print(u"Aucun fichier n'a besoin d'être rechiffré".encode("utf-8"))

def parse_roles(options):
    """Interprête la liste de rôles fournie par l'utilisateur.
       Si il n'en a pas fourni, on considère qu'il prend tous ceux pour lesquels il a le -w.
       
       Renvoie ``False`` si au moins un de ces rôles pose problème.
       
       poser problème, c'est :
        * être un role-w (il faut utiliser le role sans le w)
        * ne pas exister dans la config du serveur
    
    """
    strroles = options.roles
    allroles = all_roles(options)
    _, my_roles_w = get_my_roles(options)
    if strroles == None:
        # L'utilisateur n'a rien donné, on lui donne les rôles (non -w) dont il possède le -w
        return my_roles_w
Daniel STAN's avatar
Daniel STAN committed
747 748
    ret = set()
    for role in strroles.split(','):
749 750 751 752
        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
753
        if role.endswith('-w'):
754 755 756 757
            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
758 759
        ret.add(role)
    return list(ret)
Daniel STAN's avatar
Daniel STAN committed
760

761 762 763 764 765 766 767 768
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)

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

    # Actions possibles
    action_grp = parser.add_mutually_exclusive_group(required=False)
Vincent Le gallic's avatar
Vincent Le gallic committed
790 791
    action_grp.add_argument('-e', '--edit', action='store_const', dest='action',
        default=show_file, const=edit_file,
Daniel STAN's avatar
Daniel STAN committed
792
        help="Editer (ou créer)")
Vincent Le gallic's avatar
Vincent Le gallic committed
793 794 795 796 797 798 799 800
    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
801
        help="Lister les fichiers")
Vincent Le gallic's avatar
Vincent Le gallic committed
802 803
    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
804
        help="Vérifier les clés")
Vincent Le gallic's avatar
Vincent Le gallic committed
805 806
    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
807
        help="Mettre à jour les clés")
Vincent Le gallic's avatar
Vincent Le gallic committed
808 809 810 811 812 813
    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")
814 815
    action_grp.add_argument('--recrypt-files', action='store_const', dest='action',
        default=show_file, const=recrypt_files,
816 817 818
        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é)""")
819
    
Vincent Le gallic's avatar
Vincent Le gallic committed
820
    parser.add_argument('--roles', nargs='?', default=None,
821 822 823 824 825
        help="""Liste de roles (séparés par des virgules).
                Avec --edit, le fichier sera chiffré pour exactement ces roles
                (par défaut, tous vos rôles en écriture seront utilisés).
                Avec --recrypt-files, tous les fichiers ayant au moins un de ces roles (et pour lesquels vous avez le droit d'écriture) seront rechiffrés
                (par défaut, tous les fichiers pour lesquels vous avez les droits en écriture sont rechiffrés).""")
Vincent Le gallic's avatar
Vincent Le gallic committed
826
    parser.add_argument('fname', nargs='?', default=None,
Daniel STAN's avatar
Daniel STAN committed
827
        help="Nom du fichier à afficher")
Vincent Le gallic's avatar
Vincent Le gallic committed
828
    
829 830
    # On parse les options fournies en commandline
    options = parser.parse_args(sys.argv[1:])
Vincent Le gallic's avatar
Vincent Le gallic committed
831
    
832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
    ## On calcule les options qui dépendent des autres.
    ## C'est un peu un hack, peut-être que la méthode propre serait de surcharger argparse.ArgumentParser
    ## et argparse.Namespace, mais j'ai pas réussi à comprendre commenr m'en sortir.
    # On utilise le clipboard si on n'a pas demandé explicitement à ne pas le faire,
    # qu'on n'est pas en session distante et qu'on a xclip
    options.clipboard = not options.noclipboard and bool(os.getenv('DISPLAY')) and os.path.exists('/usr/bin/xclip')
    # On récupère les données du serveur à partir du nom fourni
    options.serverdata = config.servers[options.server]
    # Attention à l'ordre pour interactive
    #  --quiet override --verbose
    if options.quiet:
        options.verbose = False
    # On parse les roles fournis, et il doivent exister, ne pas être -w…
    # parse_roles s'occupe de ça
    options.roles = parse_roles(options)
847
    
848 849 850 851 852 853 854
    # 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)