client.py 36.3 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
Daniel STAN's avatar
Daniel STAN committed
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
init  
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?$',
Daniel STAN's avatar
Daniel STAN committed
54 55
        flags=re.IGNORECASE)

Daniel STAN's avatar
init  
Daniel STAN committed
56
## GPG Definitions
57
#: Path du binaire gpg
Daniel STAN's avatar
init  
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
init  
Daniel STAN committed
61
GPG_ARGS = {
Vincent Le gallic's avatar
Vincent Le gallic committed
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
init  
Daniel STAN committed
67
    }
68 69

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

83
def gpg(options, command, args=None):
Daniel STAN's avatar
init  
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
init  
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
Daniel STAN's avatar
Daniel STAN committed
92
    else:
93
        stderr = subprocess.PIPE
Daniel STAN's avatar
Daniel STAN committed
94
        full_command.extend(['--debug-level=1'])
Daniel STAN's avatar
init  
Daniel STAN committed
95 96 97
    proc = subprocess.Popen(full_command,
                            stdin = subprocess.PIPE,
                            stdout = subprocess.PIPE,
Daniel STAN's avatar
Daniel STAN committed
98
                            stderr = stderr,
Daniel STAN's avatar
init  
Daniel STAN committed
99
                            close_fds = True)
100
    if not options.verbose:
Daniel STAN's avatar
Daniel STAN committed
101
        proc.stderr.close()
Daniel STAN's avatar
init  
Daniel STAN committed
102 103
    return proc.stdin, proc.stdout

104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
def _parse_timestamp(string, canbenone=False):
    """Interprète ``string`` comme un timestamp depuis l'Epoch."""
    if string == u'' and canbenone:
        return None
    return datetime.datetime(*time.localtime(int(string))[:7])

def _parse_pub(data):
    """Interprète une ligne ``pub:``"""
    d = {
        u'trustletter' : data[1],
        u'length' : int(data[2]),
        u'algorithm' : int(data[3]),
        u'longid' : data[4],
        u'signdate' : _parse_timestamp(data[5]),
        u'expiredate' : _parse_timestamp(data[6], canbenone=True),
        u'ownertrustletter' : data[8],
        u'capabilities' : data[11],
        }
    return d

def _parse_uid(data):
    """Interprète une ligne ``uid:``"""
    d = {
        u'trustletter' : data[1],
        u'signdate' : _parse_timestamp(data[5], canbenone=True),
        u'hash' : data[7],
        u'uid' : data[9],
        }
    return d

def _parse_fpr(data):
    """Interprète une ligne ``fpr:``"""
    d = {
        u'fpr' : data[9],
        }
    return d

def _parse_sub(data):
    """Interprète une ligne ``sub:``"""
    d = {
        u'trustletter' : data[1],
        u'length' : int(data[2]),
        u'algorithm' : int(data[3]),
        u'longid' : data[4],
        u'signdate' : _parse_timestamp(data[5]),
        u'expiredate' : _parse_timestamp(data[6], canbenone=True),
        u'capabilities' : data[11],
        }
    return d

#: Functions to parse the recognized fields
GPG_PARSERS = {
    u'pub' : _parse_pub,
    u'uid' : _parse_uid,
    u'fpr' : _parse_fpr,
    u'sub' : _parse_sub,
     }

def _gpg_printdebug(d):
    print("current_pub : %r" % d.get("current_pub", None))
    print("current_sub : %r" % d.get("current_sub", None))

def parse_keys(gpgout, debug=False):
    """Parse l'output d'un listing de clés gpg."""
    ring = {}
    init_value = u"initialize" # Valeur utilisée pour dire "cet objet n'a pas encore été rencontré pendant le parsing"
    current_pub = init_value
    current_sub = init_value
    for line in iter(gpgout.readline, ''):
        # La doc dit que l'output est en UTF-8 «regardless of any --display-charset setting»
        line = line.decode("utf-8")
        line = line.split(":")
        field = line[0]
        if field in GPG_PARSERS.keys():
            if debug:
                print("\nbegin loop. met %s :" % (field))
                _gpg_printdebug(locals())
            try:
                content = GPG_PARSERS[field](line)
            except:
                print("*** FAILED ***")
                print(line)
                raise
            if field == u"pub":
                # Nouvelle clé
                # On sauvegarde d'abord le dernier sub (si il y en a un) dans son pub parent
                if current_sub != init_value:
                    current_pub["subkeys"].append(current_sub)
                # Ensuite on sauve le pub précédent (si il y en a un) dans le ring
                if current_pub != init_value:
                    ring[current_pub[u"fpr"]] = current_pub
                # On place le nouveau comme pub courant
                current_pub = content
                # Par défaut, il n'a ni subkeys, ni uids
                current_pub[u"subkeys"] = []
                current_pub[u"uids"] = []
                # On oublié l'éventuel dernier sub rencontré
                current_sub = init_value
            elif field == u"fpr":
                if current_sub != init_value:
                    # On a lu un sub depuis le dernier pub, donc le fingerprint est celui du dernier sub rencontré
                    current_sub[u"fpr"] = content[u"fpr"]
                else:
                    # Alors c'est le fingerprint du pub
                    current_pub[u"fpr"] = content[u"fpr"]
            elif field == u"uid":
                current_pub[u"uids"].append(content)
            elif field == u"sub":
                # Nouvelle sous-clé
                # D'abord on sauvegarde la précédente (si il y en a une) dans son pub parent
                if current_sub != init_value:
                    current_pub[u"subkeys"].append(current_sub)
                # On place la nouvelle comme sub courant
                current_sub = content
            if debug:
                _gpg_printdebug(locals())
                print("parsed object : %r" % content)
    # À la fin, il faut sauvegarder les derniers (sub, pub) rencontrés,
    # parce que leur sauvegarde n'a pas encore été déclenchée
    if current_sub != init_value:
        current_pub["subkeys"].append(current_sub)
    if current_pub != init_value:
        ring[current_pub[u"fpr"]] = current_pub
    return ring
228 229 230 231 232 233 234

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

235 236 237 238 239
    def __call__(self, *args, **kwargs):
        """Attention ! On peut fournir des paramètres, mais comme on mémorise pour la prochaine fois,
           si on rappelle avec des paramètres différents, on aura quand même la même réponse.
           Pour l'instant, on s'en fiche puisque les paramètres ne changent pas d'un appel au suivant,
           mais il faudra s'en préoccuper si un jour on veut changer le comportement."""
Vincent Le gallic's avatar
Vincent Le gallic committed
240
        if self.val == None:
241
            self.val = self.f(*args, **kwargs)
Daniel STAN's avatar
Daniel STAN committed
242
        return copy.deepcopy(self.val)
243

Vincent Le gallic's avatar
Vincent Le gallic committed
244

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

248 249 250 251 252 253 254 255 256
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
    """
257
    full_command = list(options.serverdata['server_cmd'])
Daniel STAN's avatar
init  
Daniel STAN committed
258 259 260 261 262 263 264 265
    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)
266
    return proc
Daniel STAN's avatar
init  
Daniel STAN committed
267

268
def remote_command(options, command, arg=None, stdin_contents=None):
Daniel STAN's avatar
init  
Daniel STAN committed
269 270
    """Exécute la commande distante, et retourne la sortie de cette
    commande"""
271
    detail = options.verbose and not options.quiet
Daniel STAN's avatar
init  
Daniel STAN committed
272
    
273 274 275
    proc = remote_proc(options, command, arg)
    if stdin_contents is not None:
        proc.stdin.write(json.dumps(stdin_contents))
Daniel STAN's avatar
Daniel STAN committed
276
        proc.stdin.close()
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
    ret = proc.wait()
    raw_out = proc.stdout.read()
    if ret != 0:
        if not options.quiet:
            print((u"Mauvais code retour côté serveur, voir erreur " +
                   u"ci-dessus").encode('utf-8'),
                  file=sys.stderr)
            if options.verbose:
                print("raw_output: %s" % raw_out)
        sys.exit(ret)
    try:
        return json.loads(raw_out)
    except ValueError:
        if not options.quiet:
            print(u"Impossible de parser le résultat".encode('utf-8'),
                  file=sys.stderr)
            if options.verbose:
                print("raw_output: %s" % raw_out)
            sys.exit(42)
Daniel STAN's avatar
init  
Daniel STAN committed
296

297
@simple_memoize
298
def all_keys(options):
Daniel STAN's avatar
init  
Daniel STAN committed
299
    """Récupère les clés du serveur distant"""
300
    return remote_command(options, "listkeys")
Daniel STAN's avatar
init  
Daniel STAN committed
301

302
@simple_memoize
303
def all_roles(options):
Daniel STAN's avatar
init  
Daniel STAN committed
304
    """Récupère les roles du serveur distant"""
305
    return remote_command(options, "listroles")
Daniel STAN's avatar
init  
Daniel STAN committed
306

307
@simple_memoize
308
def all_files(options):
Daniel STAN's avatar
init  
Daniel STAN committed
309
    """Récupère les fichiers du serveur distant"""
310
    return remote_command(options, "listfiles")
Daniel STAN's avatar
init  
Daniel STAN committed
311

312
def get_files(options, filenames):
313
    """Récupère le contenu des fichiers distants"""
314
    return remote_command(options, "getfiles", stdin_contents=filenames)
Daniel STAN's avatar
init  
Daniel STAN committed
315

316
def put_files(options, files):
317
    """Dépose les fichiers sur le serveur distant"""
318
    return remote_command(options, "putfiles", stdin_contents=files)
Vincent Le gallic's avatar
Vincent Le gallic committed
319

Daniel STAN's avatar
init  
Daniel STAN committed
320 321
def rm_file(filename):
    """Supprime le fichier sur le serveur distant"""
322
    return remote_command(options, "rmfile", filename)
Daniel STAN's avatar
init  
Daniel STAN committed
323

324
@simple_memoize
325 326 327
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)
328 329
    distant_username = allroles.pop("whoami")
    my_roles = [r for (r, users) in allroles.iteritems() if distant_username in users]
330 331
    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
332

333
def gen_password():
Vincent Le gallic's avatar
Vincent Le gallic committed
334
    """Génère un mot de passe aléatoire"""
335 336 337
    random.seed(datetime.datetime.now().microsecond)
    chars = string.letters + string.digits + '/=+*'
    length = 15
338
    return u''.join([random.choice(chars) for _ in xrange(length)])
339

Daniel STAN's avatar
init  
Daniel STAN committed
340 341 342
######
## Local commands

343
def update_keys(options):
Daniel STAN's avatar
init  
Daniel STAN committed
344
    """Met à jour les clés existantes"""
Vincent Le gallic's avatar
Vincent Le gallic committed
345
    
346
    keys = all_keys(options)
Vincent Le gallic's avatar
Vincent Le gallic committed
347
    
348
    _, stdout = gpg(options, "receive-keys", [key for _, key in keys.values() if key])
349
    return stdout.read().decode("utf-8")
Daniel STAN's avatar
init  
Daniel STAN committed
350

351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
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."

373
def check_keys(options, recipients=None, quiet=False):
374 375 376 377 378
    """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.
379 380
         * 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.
381 382 383
        * Si rien n'est fourni, vérifie toutes les clés et renvoie juste un booléen disant si tout va bien.
       """
    trusted_recipients = []
384
    keys = all_keys(options)
385
    if recipients is None:
386
        speak = options.verbose and not options.quiet
387
    else:
388
        speak = False
389
        keys = {u : val for (u, val) in keys.iteritems() if u in recipients}
390
    if speak:
391
        print("M : le mail correspond à un uid du fingerprint\nC : confiance OK (inclut la vérification de non expiration).\n")
392
    _, gpgout = gpg(options, 'list-keys')
393
    localring = parse_keys(gpgout)
394 395 396
    for (recipient, (mail, fpr)) in keys.iteritems():
        failed = u""
        if not fpr is None:
397
            if speak:
398
                print((u"Checking %s… " % (mail)).encode("utf-8"), end="")
399
            key = localring.get(fpr, None)
400
            # On vérifie qu'on possède la clé…
401
            if not key is None:
402
                # …qu'elle correspond au mail…
403
                if any([u"<%s>" % (mail,) in u["uid"] for u in key["uids"]]):
404
                    if speak:
405
                        print("M ", end="")
406 407 408
                    # … et qu'on peut raisonnablement chiffrer pour lui
                    failed = _check_encryptable(key)
                    if not failed and speak:
409
                        print("C ", end="")
410
                else:
411
                    failed = u"!! Le fingerprint et le mail ne correspondent pas !"
412
            else:
413
                failed = u"Pas (ou trop) de clé avec ce fingerprint."
414
            if speak:
415
                print("")
416
            if failed:
417
                if not options.quiet:
418 419 420
                    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
421
                    message = u"Abandonner le chiffrement pour cette clé ? (Si vous la conservez, il est posible que gpg crashe)"
422 423 424 425
                    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
426
                    else:
427
                        drop = False # Là, on droppe pas
428 429
                    if not drop:
                        trusted_recipients.append(recipient)
430 431 432
                    else:
                        if not options.quiet:
                            print(u"Droppe la clé %s:%s" % (fpr, recipient))
433 434 435 436 437 438
            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
439

440
def get_recipients_of_roles(options, roles):
Vincent Le gallic's avatar
Vincent Le gallic committed
441
    """Renvoie les destinataires d'une liste de rôles"""
442
    recipients = set()
443
    allroles = all_roles(options)
444
    allroles.pop("whoami")
445 446 447 448 449
    for role in roles:
        for recipient in allroles[role]:
            recipients.add(recipient)
    return recipients

450
def get_dest_of_roles(options, roles):
Vincent Le gallic's avatar
Vincent Le gallic committed
451
    """Renvoie la liste des "username : mail (fingerprint)" """
452
    allkeys = all_keys(options)
453
    return [u"%s : %s (%s)" % (rec, allkeys[rec][0], allkeys[rec][1])
454
               for rec in get_recipients_of_roles(options, roles) if allkeys[rec][1]]
455

456
def encrypt(options, roles, contents):
457 458
    """Chiffre le contenu pour les roles donnés"""
    
459 460 461
    allkeys = all_keys(options)
    recipients = get_recipients_of_roles(options, roles)
    recipients = check_keys(options, recipients=recipients, quiet=True)
462
    fpr_recipients = []
Daniel STAN's avatar
init  
Daniel STAN committed
463
    for recipient in recipients:
464 465 466 467
        fpr = allkeys[recipient][1]
        if fpr:
            fpr_recipients.append("-r")
            fpr_recipients.append(fpr)
Vincent Le gallic's avatar
Vincent Le gallic committed
468
    
469
    stdin, stdout = gpg(options, "encrypt", fpr_recipients)
470
    stdin.write(contents.encode("utf-8"))
Daniel STAN's avatar
init  
Daniel STAN committed
471
    stdin.close()
472
    out = stdout.read().decode("utf-8")
Daniel STAN's avatar
Daniel STAN committed
473
    if out == '':
474
        return [False, u"Échec de chiffrement"]
Daniel STAN's avatar
Daniel STAN committed
475
    else:
476
        return [True, out]
Daniel STAN's avatar
init  
Daniel STAN committed
477

478
def decrypt(options, contents):
Daniel STAN's avatar
init  
Daniel STAN committed
479
    """Déchiffre le contenu"""
480
    stdin, stdout = gpg(options, "decrypt")
481
    stdin.write(contents.encode("utf-8"))
Daniel STAN's avatar
init  
Daniel STAN committed
482
    stdin.close()
483
    return stdout.read().decode("utf-8")
Daniel STAN's avatar
init  
Daniel STAN committed
484

485
def put_password(options, roles, contents):
Daniel STAN's avatar
init  
Daniel STAN committed
486
    """Dépose le mot de passe après l'avoir chiffré pour les
487 488
    destinataires dans ``roles``."""
    success, enc_pwd_or_error = encrypt(options, roles, contents)
489 490
    if success:
        enc_pwd = enc_pwd_or_error
491
        return put_files(options, [{'filename' : options.fname, 'roles' : roles, 'contents' : enc_pwd}])[0]
Daniel STAN's avatar
Daniel STAN committed
492
    else:
493 494
        error = enc_pwd_or_error
        return [False, error]
Daniel STAN's avatar
init  
Daniel STAN committed
495

Vincent Le gallic's avatar
Vincent Le gallic committed
496
######
Daniel STAN's avatar
Daniel STAN committed
497 498
## Interface

499 500 501 502 503 504 505
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

506
def editor(texte, annotations=u""):
507 508 509
    """ 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
510
    
511 512 513
    # 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
514
    atexit.register(f.close)
515 516 517
    if annotations:
        annotations = "# " + annotations.replace("\n", "\n# ")
    f.write((texte + "\n" + annotations).encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
518
    f.flush()
Daniel STAN's avatar
Daniel STAN committed
519
    proc = subprocess.Popen([os.getenv('EDITOR', '/usr/bin/editor'), f.name])
Vincent Le gallic's avatar
Vincent Le gallic committed
520
    os.waitpid(proc.pid, 0)
Daniel STAN's avatar
Daniel STAN committed
521
    f.seek(0)
522
    ntexte = f.read().decode("utf-8")
Daniel STAN's avatar
Daniel STAN committed
523
    f.close()
524
    ntexte = u'\n'.join(filter(lambda l: not l.startswith('#'), ntexte.split('\n')))
525
    return ntexte
Daniel STAN's avatar
Daniel STAN committed
526

527
def show_files(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
528
    """Affiche la liste des fichiers disponibles sur le serveur distant"""
Vincent Le gallic's avatar
Vincent Le gallic committed
529
    print(u"Liste des fichiers disponibles :".encode("utf-8"))
530 531
    my_roles, _ = get_my_roles(options)
    files = all_files(options)
532 533 534 535
    keys = files.keys()
    keys.sort()
    for fname in keys:
        froles = files[fname]
Daniel STAN's avatar
Daniel STAN committed
536
        access = set(my_roles).intersection(froles) != set([])
Vincent Le gallic's avatar
Vincent Le gallic committed
537 538
        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"))
539
    
540
def show_roles(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
541
    """Affiche la liste des roles existants"""
Vincent Le gallic's avatar
Vincent Le gallic committed
542
    print(u"Liste des roles disponibles".encode("utf-8"))
543 544
    allroles =  all_roles(options)
    for (role, usernames) in allroles.iteritems():
Vincent Le gallic's avatar
Vincent Le gallic committed
545
        if not role.endswith('-w'):
546
            print((u" * %s : %s" % (role, ", ".join(usernames))).encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
547

548
def show_servers(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
549
    """Affiche la liste des serveurs disponibles"""
Vincent Le gallic's avatar
Vincent Le gallic committed
550
    print(u"Liste des serveurs disponibles".encode("utf-8"))
551
    for server in config.servers.keys():
Vincent Le gallic's avatar
Vincent Le gallic committed
552
        print((u" * " + server).encode("utf-8"))
553

554
def saveclipboard(restore=False, old_clipboard=None):
Vincent Le gallic's avatar
Vincent Le gallic committed
555
    """Enregistre le contenu du presse-papier. Le rétablit si ``restore=True``"""
556 557 558
    if restore and old_clipboard == None:
        return
    act = '-in' if restore else '-out'
Vincent Le gallic's avatar
Vincent Le gallic committed
559 560
    proc = subprocess.Popen(['xclip', act, '-selection', 'clipboard'],
        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=sys.stderr)
561 562 563
    if not restore:
        old_clipboard = proc.stdout.read()
    else:
564
        raw_input(u"Appuyez sur Entrée pour récupérer le contenu précédent du presse papier.".encode("utf-8"))
565 566 567
        proc.stdin.write(old_clipboard)
    proc.stdin.close()
    proc.stdout.close()
568
    return old_clipboard
569

Daniel STAN's avatar
Daniel STAN committed
570
def clipboard(texte):
Vincent Le gallic's avatar
Vincent Le gallic committed
571
    """Place ``texte`` dans le presse-papier en mémorisant l'ancien contenu."""
572
    old_clipboard = saveclipboard()
Vincent Le gallic's avatar
Vincent Le gallic committed
573 574
    proc =subprocess.Popen(['xclip', '-selection', 'clipboard'],\
        stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr)
575
    proc.stdin.write(texte.encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
576
    proc.stdin.close()
577
    return old_clipboard
Daniel STAN's avatar
Daniel STAN committed
578

579 580
@need_filename
def show_file(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
581
    """Affiche le contenu d'un fichier"""
582 583
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
584
    if not gotit:
585 586
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
Daniel STAN's avatar
Daniel STAN committed
587
        return
588
    passfile = value
589
    (sin, sout) = gpg(options, 'decrypt')
590
    sin.write(passfile['contents'].encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
591
    sin.close()
592 593
    texte = sout.read().decode("utf-8")
    ntexte = u""
Daniel STAN's avatar
Daniel STAN committed
594 595
    hidden = False  # Est-ce que le mot de passe a été caché ?
    lines = texte.split('\n')
Daniel STAN's avatar
Daniel STAN committed
596
    old_clipboard = None
Daniel STAN's avatar
Daniel STAN committed
597
    for line in lines:
Daniel STAN's avatar
Daniel STAN committed
598 599 600 601 602 603
        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:
604
            hidden = True
605 606 607 608
            # 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
609 610
        ntexte += line + '\n'
    showbin = "cat" if hidden else "less"
611
    proc = subprocess.Popen([showbin], stdin=subprocess.PIPE)
Daniel STAN's avatar
Daniel STAN committed
612
    out = proc.stdin
613
    raw = u"Fichier %s:\n\n%s-----\nVisible par: %s\n" % (fname, ntexte, ','.join(passfile['roles']))
614
    out.write(raw.encode("utf-8"))
615
    out.close()
Daniel STAN's avatar
Daniel STAN committed
616
    os.waitpid(proc.pid, 0)
Daniel STAN's avatar
Daniel STAN committed
617
    # Repope ancien pass
618 619
    if options.clipboard:
        saveclipboard(restore=True, old_clipboard=old_clipboard)
620

621 622
@need_filename
def edit_file(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
623
    """Modifie/Crée un fichier"""
624 625
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
Daniel STAN's avatar
Daniel STAN committed
626
    nfile = False
627
    annotations = u""
628
    if not gotit and not u"pas les droits" in value:
Daniel STAN's avatar
Daniel STAN committed
629
        nfile = True
630 631 632
        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
633
            return
634
        annotations += u"""Ceci est un fichier initial contenant un mot de passe
Vincent Le gallic's avatar
Vincent Le gallic committed
635 636
aléatoire, pensez à rajouter une ligne "login: ${login}"
Enregistrez le fichier vide pour annuler.\n"""
637
        texte = u"pass: %s\n" % gen_password()
638 639 640
        if options.roles == []:
            if not options.quiet:
                print(u"Vous ne possédez aucun rôle en écriture ! Abandon.".encode("utf-8"))
641
            return
642
        passfile = {'roles' : options.roles}
643
    elif not gotit:
644 645
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
646
        return
Daniel STAN's avatar
Daniel STAN committed
647
    else:
648
        passfile = value
649
        (sin, sout) = gpg(options, 'decrypt')
650
        sin.write(passfile['contents'].encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
651
        sin.close()
652
        texte = sout.read().decode("utf-8")
653 654 655 656 657 658 659 660
    # 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)
661
    # On récupère les nouveaux roles si ils ont été précisés, sinon on garde les mêmes
662
    passfile['roles'] = options.roles or passfile['roles']
663
    
Vincent Le gallic's avatar
Vincent Le gallic committed
664 665
    annotations += u"""Ce fichier sera chiffré pour les rôles suivants :\n%s\n
C'est-à-dire pour les utilisateurs suivants :\n%s""" % (
666 667
           ', '.join(passfile['roles']),
           '\n'.join(' %s' % rec for rec in get_dest_of_roles(options, passfile['roles']))
668
        )
669
    
670
    ntexte = editor(texte, annotations)
671
    
672 673 674 675 676 677 678 679
    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
680
    else:
Daniel STAN's avatar
Daniel STAN committed
681
        ntexte = texte if ntexte == None else ntexte
682
        success, message = put_password(options, passfile['roles'], ntexte)
683
        print(message.encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
684

685 686 687 688
def confirm(options, text):
    """Demande confirmation, sauf si on est mode ``--force``"""
    if options.force:
        return True
Daniel STAN's avatar
Daniel STAN committed
689
    while True:
690
        out = raw_input((text + u' (o/n)').encode("utf-8")).lower()
Daniel STAN's avatar
Daniel STAN committed
691 692 693 694 695
        if out == 'o':
            return True
        elif out == 'n':
            return False

696 697
@need_filename
def remove_file(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
698
    """Supprime un fichier"""
699
    fname = options.fname
700
    if not confirm(options, u'Êtes-vous sûr de vouloir supprimer %s ?' % (fname,)):
Daniel STAN's avatar
Daniel STAN committed
701
        return
702 703
    message = rm_file(fname)
    print(message.encode("utf-8"))
Vincent Le gallic's avatar
Vincent Le gallic committed
704

Daniel STAN's avatar
Daniel STAN committed
705

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

711
def my_update_keys(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
712
    """Met à jour les clés existantes et affiche le résultat"""
713 714 715 716 717 718 719 720
    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)
721 722
    if rechiffre_roles == None:
        # Sans précisions, on prend tous les roles qu'on peut
723
        rechiffre_roles = my_roles_w
724 725
    
    # La liste des fichiers
726 727 728
    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
729
    askfiles = [filename for (filename, fileroles) in allfiles.iteritems()
730
                         if set(fileroles).intersection(options.roles) != set()
731
                         and set(fileroles).intersection(my_roles_w) != set()]
732
    files = get_files(options, askfiles)
733 734 735 736
    # 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:
737 738
            if not options.quiet:
                print(message.encode("utf-8"))
739
            return
740 741 742 743 744 745
    # 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)
746 747 748
    # On rechiffre
    to_put = [{'filename' : f['filename'],
               'roles' : f['roles'],
749
               'contents' : encrypt(options, f['roles'], decrypt(options, f['contents']))}
750 751
              for f in files]
    if to_put:
752 753
        if not options.quiet:
            print((u"Rechiffrement de %s" % (", ".join([f['filename'] for f in to_put]))).encode("utf-8"))
754 755
        results = put_files(to_put)
        # On affiche les messages de retour
756 757 758
        if not options.quiet:
            for i in range(len(results)):
                print(u"%s : %s" % (to_put[i]['filename'], results[i][1]))
759
    else:
760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
        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
780 781
    ret = set()
    for role in strroles.split(','):
782 783 784 785
        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
786
        if role.endswith('-w'):
787 788 789 790
            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
791 792
        ret.add(role)
    return list(ret)
Daniel STAN's avatar
Daniel STAN committed
793

794 795 796 797 798 799 800 801
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
802
if __name__ == "__main__":
803
    parser = argparse.ArgumentParser(description="Gestion de mots de passe partagés grâce à GPG.")
804
    parser.add_argument('-s', '--server', default='default',
Vincent Le gallic's avatar
Vincent Le gallic committed
805 806
        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
807
        help="Mode verbeux")
808 809 810
    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.")
811
    parser.add_argument('-q', '--quiet', action='store_true', default=False,
812
        help="Mode silencieux. Cache les message d'erreurs (override --verbose et --interactive).")
Vincent Le gallic's avatar
Vincent Le gallic committed
813
    parser.add_argument('-c', '--clipboard', action='store_true', default=None,
Daniel STAN's avatar
Daniel STAN committed
814
        help="Stocker le mot de passe dans le presse papier")
Vincent Le gallic's avatar
Vincent Le gallic committed
815
    parser.add_argument('--no-clip', '--noclip', '--noclipboard', action='store_false', default=None,
816
        dest='clipboard',
Daniel STAN's avatar
Daniel STAN committed
817
        help="Ne PAS stocker le mot de passe dans le presse papier")
Vincent Le gallic's avatar
Vincent Le gallic committed
818 819
    parser.add_argument('-f', '--force', action='store_true', default=False,
        help="Ne pas demander confirmation")
Daniel STAN's avatar
Daniel STAN committed
820 821 822

    # Actions possibles
    action_grp = parser.add_mutually_exclusive_group(required=False)
Vincent Le gallic's avatar
Vincent Le gallic committed
823 824
    action_grp.add_argument('-e', '--edit', action='store_const', dest='action',
        default=show_file, const=edit_file,
Daniel STAN's avatar
Daniel STAN committed
825
        help="Editer (ou créer)")
Vincent Le gallic's avatar
Vincent Le gallic committed
826 827 828 829 830 831 832 833
    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
834
        help="Lister les fichiers")
Vincent Le gallic's avatar
Vincent Le gallic committed
835 836
    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
837
        help="Vérifier les clés")
Vincent Le gallic's avatar
Vincent Le gallic committed
838 839
    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
840
        help="Mettre à jour les clés")
Vincent Le gallic's avatar
Vincent Le gallic committed
841 842 843 844 845 846
    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")
847 848
    action_grp.add_argument('--recrypt-files', action='store_const', dest='action',
        default=show_file, const=recrypt_files,
849 850 851
        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é)""")
852
    
Vincent Le gallic's avatar
Vincent Le gallic committed
853
    parser.add_argument('--roles', nargs='?', default=None,
854 855 856 857 858
        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
859
    parser.add_argument('fname', nargs='?', default=None,
Daniel STAN's avatar
Daniel STAN committed
860
        help="Nom du fichier à afficher")
Vincent Le gallic's avatar
Vincent Le gallic committed
861
    
862 863
    # On parse les options fournies en commandline
    options = parser.parse_args(sys.argv[1:])
Vincent Le gallic's avatar
Vincent Le gallic committed
864
    
865 866 867
    ## 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.
868 869 870 871 872 873
    # ** 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')
874 875 876 877 878 879 880 881
    # 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
882 883 884 885
    # 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)
886
    
887 888 889 890 891 892 893
    # 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)