client.py 39.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
                    u"n" : (u"nulle (il ne faut pas faire confiance à cette clé)", False),
                    u"m" : (u"marginale (pas assez de lien de confiance vers cette clé)", False),
                    u"f" : (u"entière (clé dans le réseau de confiance)", True),
                    u"u" : (u"ultime (c'est probablement ta clé)", True),
78 79
                    u"r" : (u"révoquée", False),
                    u"e" : (u"expirée", False),
80
                    u"q" : (u"non définie", False),
81
                  }
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)
242 243 244 245 246 247
        # On évite de tout deepcopier. Typiquement, un subprocess.Popen
        # ne devrait pas l'être (comme dans get_keep_alive_connection)
        if type(self.val) in [dict, list]:
            return copy.deepcopy(self.val)
        else:
            return self.val
248

Vincent Le gallic's avatar
Vincent Le gallic committed
249

Daniel STAN's avatar
init  
Daniel STAN committed
250 251 252
######
## Remote commands

253 254 255 256 257 258 259 260 261
def remote_proc(options, command, arg=None):
    """
    Fabrique un process distant pour communiquer avec le serveur.
    Cela consiste à lancer une commande (indiquée dans la config)
    qui va potentiellement lancer ssh.
    ``command`` désigne l'action à envoyer au serveur
    ``arg`` est une chaîne (str) accompagnant la commande en paramètre
    ``options`` contient la liste usuelle d'options
    """
262
    full_command = list(options.serverdata['server_cmd'])
Daniel STAN's avatar
init  
Daniel STAN committed
263 264 265
    full_command.append(command)
    if arg:
        full_command.append(arg)
266 267 268 269

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

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

277 278 279 280 281 282 283 284 285
@simple_memoize
def get_keep_alive_connection(options):
    """Fabrique un process parlant avec le serveur suivant la commande
    'keep-alive'. On utilise une fonction séparée pour cela afin
    de memoizer le résultat, et ainsi utiliser une seule connexion"""
    proc = remote_proc(options, 'keep-alive', None)
    atexit.register(proc.stdin.close)
    return proc

286
def remote_command(options, command, arg=None, stdin_contents=None):
Daniel STAN's avatar
init  
Daniel STAN committed
287 288
    """Exécute la commande distante, et retourne la sortie de cette
    commande"""
289
    detail = options.verbose and not options.quiet
290
    keep_alive = options.serverdata.get('keep-alive', False)
Daniel STAN's avatar
init  
Daniel STAN committed
291
    
292 293 294 295 296 297 298 299 300 301 302
    if keep_alive:
        conn = get_keep_alive_connection(options)
        args = filter(None, [arg, stdin_contents])
        msg = {u'action': unicode(command), u'args': args }
        conn.stdin.write('%s\n' % json.dumps(msg))
        conn.stdin.flush()
        raw_out = conn.stdout.readline()
    else:
        proc = remote_proc(options, command, arg)
        if stdin_contents is not None:
            proc.stdin.write(json.dumps(stdin_contents))
Daniel STAN's avatar
Daniel STAN committed
303 304 305 306 307
            proc.stdin.flush()

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

308 309 310 311 312 313 314 315
        if ret != 0:
            if not options.quiet:
                print((u"Mauvais code retour côté serveur, voir erreur " +
                       u"ci-dessus").encode('utf-8'),
                      file=sys.stderr)
                if detail:
                    print("raw_output: %s" % raw_out)
            sys.exit(ret)
316
    try:
317
        answer = json.loads(raw_out.strip())
318 319 320 321
    except ValueError:
        if not options.quiet:
            print(u"Impossible de parser le résultat".encode('utf-8'),
                  file=sys.stderr)
322
            if detail:
323 324
                print("raw_output: %s" % raw_out)
            sys.exit(42)
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
    if not keep_alive:
        return answer
    else:
        try:
            if answer[u'status'] != u'ok':
                raise KeyError('Bad answer status')
            return answer[u'content']
        except KeyError:
            if not options.quiet:
                print(u"Réponse erronée du serveur".encode('utf-8'),
                    file=sys.stderr)
            if detail:
                print("answer: %s" % repr(answer))
            sys.exit(-1)

Daniel STAN's avatar
init  
Daniel STAN committed
340

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

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

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

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

360
def put_files(options, files):
361
    """Dépose les fichiers sur le serveur distant"""
362
    return remote_command(options, "putfiles", stdin_contents=files)
Vincent Le gallic's avatar
Vincent Le gallic committed
363

Daniel STAN's avatar
init  
Daniel STAN committed
364 365
def rm_file(filename):
    """Supprime le fichier sur le serveur distant"""
366
    return remote_command(options, "rmfile", filename)
Daniel STAN's avatar
init  
Daniel STAN committed
367

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

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

Daniel STAN's avatar
init  
Daniel STAN committed
384 385 386
######
## Local commands

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

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

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

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

494
def get_dest_of_roles(options, roles):
Vincent Le gallic's avatar
Vincent Le gallic committed
495
    """Renvoie la liste des "username : mail (fingerprint)" """
496
    allkeys = all_keys(options)
497
    return [u"%s : %s (%s)" % (rec, allkeys[rec][0], allkeys[rec][1])
498
               for rec in get_recipients_of_roles(options, roles) if allkeys[rec][1]]
499

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

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

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

Vincent Le gallic's avatar
Vincent Le gallic committed
543
######
Daniel STAN's avatar
Daniel STAN committed
544 545
## Interface

546 547 548 549 550 551 552
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

553
def editor(texte, annotations=u""):
554 555 556
    """ 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
557
    
558 559 560
    # 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
561
    atexit.register(f.close)
562 563 564
    if annotations:
        annotations = "# " + annotations.replace("\n", "\n# ")
    f.write((texte + "\n" + annotations).encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
565
    f.flush()
Daniel STAN's avatar
Daniel STAN committed
566
    proc = subprocess.Popen([os.getenv('EDITOR', '/usr/bin/editor'), f.name])
Vincent Le gallic's avatar
Vincent Le gallic committed
567
    os.waitpid(proc.pid, 0)
Daniel STAN's avatar
Daniel STAN committed
568
    f.seek(0)
569
    ntexte = f.read().decode("utf-8")
Daniel STAN's avatar
Daniel STAN committed
570
    f.close()
571
    ntexte = u'\n'.join(filter(lambda l: not l.startswith('#'), ntexte.split('\n')))
572
    return ntexte
Daniel STAN's avatar
Daniel STAN committed
573

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

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

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

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

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

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

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

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

        if new_roles is None:
            new_roles = parse_roles(options, cast=True)
        passfile = {'roles' : new_roles}
698
    elif not gotit:
699 700
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
701
        return
Daniel STAN's avatar
Daniel STAN committed
702
    else:
703
        passfile = value
704
        (sin, sout) = gpg(options, 'decrypt')
705
        sin.write(passfile['contents'].encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
706
        sin.close()
707
        texte = sout.read().decode("utf-8")
708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723
        if new_roles is None:
            new_roles = passfile['roles']

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

    # On peut vouloir chiffrer un fichier sans avoir la possibilité de le lire
    # dans le futur, mais dans ce cas on préfère demander confirmation
    if not any(r + '-w' in my_roles for r in new_roles):
        message = u"""Vous vous apprêtez à perdre vos droits d'écritures""" + \
            """(ROLES ne contient rien parmi : %s) sur ce fichier, continuer ?"""
        message = message % (", ".join(r[:-2] for r in my_roles if '-w' in r),)
724
        if not confirm(options, message):
725
            return
726
    
Vincent Le gallic's avatar
Vincent Le gallic committed
727 728
    annotations += u"""Ce fichier sera chiffré pour les rôles suivants :\n%s\n
C'est-à-dire pour les utilisateurs suivants :\n%s""" % (
729
           ', '.join(passfile['roles']),
730
           '\n'.join(' %s' % rec for rec in get_dest_of_roles(options, new_roles))
731
        )
732
    
733
    ntexte = editor(texte, annotations)
734
    
735 736 737
    if ((not nfile and ntexte in [u'', texte]          # pas nouveau, vidé ou pas modifié
         and set(new_roles) == set(passfile['roles'])) # et on n'a même pas touché à ses rôles,
        or (nfile and ntexte == u'')):                 # ou alors on a créé un fichier vide.
738 739 740 741 742
        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
743
    else:
Daniel STAN's avatar
Daniel STAN committed
744
        ntexte = texte if ntexte == None else ntexte
745
        success, message = put_password(options, new_roles, ntexte)
746
        print(message.encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
747

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

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

Daniel STAN's avatar
Daniel STAN committed
768

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

774
def my_update_keys(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
775
    """Met à jour les clés existantes et affiche le résultat"""
776 777
    print(update_keys(options).encode("utf-8"))

Daniel STAN's avatar
Daniel STAN committed
778
def recrypt_files(options, strict=False):
779
    """Rechiffre les fichiers.
Daniel STAN's avatar
Daniel STAN committed
780 781 782
       Ici, la signification de ``options.roles`` est :
	 strict     => on chiffre les fichiers dont *tous* les rôles sont dans la liste
	 non strict => on ne veut rechiffrer que les fichiers qui ont au moins un de ces roles.
783 784 785
       """
    rechiffre_roles = options.roles
    _, my_roles_w = get_my_roles(options)
786 787
    if rechiffre_roles == None:
        # Sans précisions, on prend tous les roles qu'on peut
788
        rechiffre_roles = my_roles_w
789 790
    
    # La liste des fichiers
791
    allfiles = all_files(options)
Daniel STAN's avatar
Daniel STAN committed
792 793 794 795 796 797 798 799 800 801

    def is_wanted(fileroles):
        # On drope ce qui ne peut être écrit
        if not set(fileroles).intersection(my_roles_w):
            return False
        if strict:
            return set(fileroles).issubset(rechiffre_roles)
        else:
            return bool(set(fileroles).intersection(rechiffre_roles))

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

835
def parse_roles(options, cast=False):
836
    """Interprête la liste de rôles fournie par l'utilisateur.
837 838 839 840
       Si il n'en a pas fourni, c'est-à-dire que roles
       vaut None, alors on considère cette valeur comme valide.
       Cependant, si ``cast`` est vraie, cette valeur est remplacée par
       tous les roles en écriture (*-w) de l'utilisateur.
841 842 843 844 845 846 847
       
       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
    """
848 849 850
    if options.roles is None and not cast:
        return options.roles

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

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