client.py 42.4 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:
Daniel STAN's avatar
Daniel STAN committed
36 37 38
    ducktape_display_error = sys.stderr.isatty() and \
              not any([opt in sys.argv for opt in ["-q", "--quiet"]]) and \
              __name__ == '__main__'
39 40 41 42
    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"))
Daniel STAN's avatar
Daniel STAN committed
43
            sys.exit(1)
44 45 46 47 48 49 50 51 52
    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
53

54 55
#: 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
56 57
        flags=re.IGNORECASE)

Daniel STAN's avatar
init  
Daniel STAN committed
58
## GPG Definitions
59
#: Path du binaire gpg
60
GPG = 'gpg'
61 62

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

#: Mapping (lettre de trustlevel) -> (signification, faut-il faire confiance à la clé)
72
GPG_TRUSTLEVELS = {
73 74 75
                    u"-" : (u"inconnue (pas de valeur assignée)", False),
                    u"o" : (u"inconnue (nouvelle clé)", False),
                    u"i" : (u"invalide (self-signature manquante ?)", False),
76 77 78 79
                    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),
80 81
                    u"r" : (u"révoquée", False),
                    u"e" : (u"expirée", False),
82
                    u"q" : (u"non définie", False),
83
                  }
Daniel STAN's avatar
Daniel STAN committed
84

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

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
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»
178 179 180 181 182 183 184 185 186
        try:
            line = line.decode("utf-8")
        except UnicodeDecodeError:
            try:
                line = line.decode("iso8859-1")
            except UnicodeDecodeError:
                line = line.decode("iso8859-1", "ignore")
                if not options.quiet:
                    print("gpg raconte de la merde, c'est ni de l'ISO-8859-1 ni de l'UTF-8, je droppe, ça risque de foirer plus tard.", sys.stderr)
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
        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
240 241 242 243 244 245 246

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

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

Vincent Le gallic's avatar
Vincent Le gallic committed
261

Daniel STAN's avatar
init  
Daniel STAN committed
262 263 264
######
## Remote commands

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

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

Daniel STAN's avatar
init  
Daniel STAN committed
282 283 284 285 286
    proc = subprocess.Popen(full_command,
                            stdin = subprocess.PIPE,
                            stdout = subprocess.PIPE,
                            stderr = sys.stderr,
                            close_fds = True)
287
    return proc
Daniel STAN's avatar
init  
Daniel STAN committed
288

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

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

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

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

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

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

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

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

368 369 370 371 372 373
@simple_memoize
def restore_all_files(options):
    """Récupère les fichiers du serveur distant"""
    return remote_command(options, "restorefiles")


374
def get_files(options, filenames):
375
    """Récupère le contenu des fichiers distants"""
376
    return remote_command(options, "getfiles", stdin_contents=filenames)
Daniel STAN's avatar
init  
Daniel STAN committed
377

378
def put_files(options, files):
379
    """Dépose les fichiers sur le serveur distant"""
380
    return remote_command(options, "putfiles", stdin_contents=files)
Vincent Le gallic's avatar
Vincent Le gallic committed
381

Daniel STAN's avatar
init  
Daniel STAN committed
382 383
def rm_file(filename):
    """Supprime le fichier sur le serveur distant"""
384
    return remote_command(options, "rmfile", filename)
Daniel STAN's avatar
init  
Daniel STAN committed
385

386
@simple_memoize
387 388 389
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)
390 391
    distant_username = allroles.pop("whoami")
    my_roles = [r for (r, users) in allroles.iteritems() if distant_username in users]
392 393
    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
394

395
def gen_password():
Vincent Le gallic's avatar
Vincent Le gallic committed
396
    """Génère un mot de passe aléatoire"""
397 398 399
    random.seed(datetime.datetime.now().microsecond)
    chars = string.letters + string.digits + '/=+*'
    length = 15
400
    return u''.join([random.choice(chars) for _ in xrange(length)])
401

Daniel STAN's avatar
init  
Daniel STAN committed
402 403 404
######
## Local commands

405
def update_keys(options):
Daniel STAN's avatar
init  
Daniel STAN committed
406
    """Met à jour les clés existantes"""
407

408
    keys = all_keys(options)
409

410
    _, stdout = gpg(options, "receive-keys", [key for _, key in keys.values() if key])
411
    return stdout.read().decode("utf-8")
Daniel STAN's avatar
init  
Daniel STAN committed
412

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

435
def check_keys(options, recipients=None, quiet=False):
436 437
    """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).
438

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

502
def get_recipients_of_roles(options, roles):
Vincent Le gallic's avatar
Vincent Le gallic committed
503
    """Renvoie les destinataires d'une liste de rôles"""
504
    recipients = set()
505
    allroles = all_roles(options)
506
    for role in roles:
507 508
        if role == u"whoami":
            continue
509 510 511 512
        for recipient in allroles[role]:
            recipients.add(recipient)
    return recipients

513
def get_dest_of_roles(options, roles):
Vincent Le gallic's avatar
Vincent Le gallic committed
514
    """Renvoie la liste des "username : mail (fingerprint)" """
515
    allkeys = all_keys(options)
516
    return [u"%s : %s (%s)" % (rec, allkeys[rec][0], allkeys[rec][1])
517
               for rec in get_recipients_of_roles(options, roles) if allkeys[rec][1]]
518

519
def encrypt(options, roles, contents):
520
    """Chiffre le contenu pour les roles donnés"""
521

522 523 524
    allkeys = all_keys(options)
    recipients = get_recipients_of_roles(options, roles)
    recipients = check_keys(options, recipients=recipients, quiet=True)
525
    fpr_recipients = []
Daniel STAN's avatar
init  
Daniel STAN committed
526
    for recipient in recipients:
527 528 529 530
        fpr = allkeys[recipient][1]
        if fpr:
            fpr_recipients.append("-r")
            fpr_recipients.append(fpr)
531

532
    stdin, stdout = gpg(options, "encrypt", fpr_recipients)
533
    stdin.write(contents.encode("utf-8"))
Daniel STAN's avatar
init  
Daniel STAN committed
534
    stdin.close()
535
    out = stdout.read().decode("utf-8")
Daniel STAN's avatar
Daniel STAN committed
536
    if out == '':
537
        return [False, u"Échec de chiffrement"]
Daniel STAN's avatar
Daniel STAN committed
538
    else:
539
        return [True, out]
Daniel STAN's avatar
init  
Daniel STAN committed
540

541
def decrypt(options, contents):
Daniel STAN's avatar
init  
Daniel STAN committed
542
    """Déchiffre le contenu"""
543
    stdin, stdout = gpg(options, "decrypt")
544 545 546
    if type(contents) != unicode: # Kludge (broken db ?)
        print("Eau dans le gaz (decrypt)" + repr(contents))
        contents = contents[-1]
547
    stdin.write(contents.encode("utf-8"))
Daniel STAN's avatar
init  
Daniel STAN committed
548
    stdin.close()
549
    return stdout.read().decode("utf-8")
Daniel STAN's avatar
init  
Daniel STAN committed
550

551
def put_password(options, roles, contents):
Daniel STAN's avatar
init  
Daniel STAN committed
552
    """Dépose le mot de passe après l'avoir chiffré pour les
553 554
    destinataires dans ``roles``."""
    success, enc_pwd_or_error = encrypt(options, roles, contents)
555 556
    if success:
        enc_pwd = enc_pwd_or_error
557
        return put_files(options, [{'filename' : options.fname, 'roles' : roles, 'contents' : enc_pwd}])[0]
Daniel STAN's avatar
Daniel STAN committed
558
    else:
559 560
        error = enc_pwd_or_error
        return [False, error]
Daniel STAN's avatar
init  
Daniel STAN committed
561

Vincent Le gallic's avatar
Vincent Le gallic committed
562
######
Daniel STAN's avatar
Daniel STAN committed
563 564
## Interface

565 566 567 568 569 570 571
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

572
def editor(texte, annotations=u""):
573 574 575
    """ Lance $EDITOR sur texte.
    Renvoie le nouveau texte si des modifications ont été apportées, ou None
    """
576

577 578 579
    # 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
580
    atexit.register(f.close)
581 582
    if annotations:
        annotations = "# " + annotations.replace("\n", "\n# ")
Daniel STAN's avatar
Daniel STAN committed
583
        # Usually, there is already an ending newline in a text document
584
        if texte and texte[-1] != '\n':
Daniel STAN's avatar
Daniel STAN committed
585 586 587 588
            annotations = '\n' + annotations
        else:
            annotations += '\n'
    f.write((texte + annotations).encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
589
    f.flush()
Daniel STAN's avatar
Daniel STAN committed
590
    proc = subprocess.Popen([os.getenv('EDITOR', '/usr/bin/editor'), f.name])
Vincent Le gallic's avatar
Vincent Le gallic committed
591
    os.waitpid(proc.pid, 0)
Daniel STAN's avatar
Daniel STAN committed
592
    f.seek(0)
Daniel STAN's avatar
Daniel STAN committed
593
    ntexte = f.read().decode("utf-8", errors='ignore')
Daniel STAN's avatar
Daniel STAN committed
594
    f.close()
595
    ntexte = u'\n'.join(filter(lambda l: not l.startswith('#'), ntexte.split('\n')))
596
    return ntexte
Daniel STAN's avatar
Daniel STAN committed
597

598
def show_files(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
599
    """Affiche la liste des fichiers disponibles sur le serveur distant"""
Vincent Le gallic's avatar
Vincent Le gallic committed
600
    print(u"Liste des fichiers disponibles :".encode("utf-8"))
601 602
    my_roles, _ = get_my_roles(options)
    files = all_files(options)
603 604 605 606
    keys = files.keys()
    keys.sort()
    for fname in keys:
        froles = files[fname]
Daniel STAN's avatar
Daniel STAN committed
607
        access = set(my_roles).intersection(froles) != set([])
Vincent Le gallic's avatar
Vincent Le gallic committed
608 609
        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"))
610

611 612 613 614 615 616 617 618 619 620
def restore_files(options):
    """Restore les fichiers corrompues sur le serveur distant"""
    print(u"Fichier corrompus :".encode("utf-8"))
    files = restore_all_files(options)
    keys = files.keys()
    keys.sort()
    for fname in keys:
        print((u" %s (%s)" % ( fname, files[fname])).encode("utf-8"))


621
def show_roles(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
622
    """Affiche la liste des roles existants"""
Vincent Le gallic's avatar
Vincent Le gallic committed
623
    print(u"Liste des roles disponibles".encode("utf-8"))
624 625
    allroles =  all_roles(options)
    for (role, usernames) in allroles.iteritems():
626 627
        if role == u"whoami":
            continue
Vincent Le gallic's avatar
Vincent Le gallic committed
628
        if not role.endswith('-w'):
629
            print((u" * %s : %s" % (role, ", ".join(usernames))).encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
630

631
def show_servers(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
632
    """Affiche la liste des serveurs disponibles"""
Vincent Le gallic's avatar
Vincent Le gallic committed
633
    print(u"Liste des serveurs disponibles".encode("utf-8"))
634
    for server in config.servers.keys():
Vincent Le gallic's avatar
Vincent Le gallic committed
635
        print((u" * " + server).encode("utf-8"))
636

637
def saveclipboard(restore=False, old_clipboard=None):
Vincent Le gallic's avatar
Vincent Le gallic committed
638
    """Enregistre le contenu du presse-papier. Le rétablit si ``restore=True``"""
639 640 641
    if restore and old_clipboard == None:
        return
    act = '-in' if restore else '-out'
Vincent Le gallic's avatar
Vincent Le gallic committed
642 643
    proc = subprocess.Popen(['xclip', act, '-selection', 'clipboard'],
        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=sys.stderr)
644 645 646
    if not restore:
        old_clipboard = proc.stdout.read()
    else:
647
        raw_input(u"Appuyez sur Entrée pour récupérer le contenu précédent du presse papier.".encode("utf-8"))
648 649 650
        proc.stdin.write(old_clipboard)
    proc.stdin.close()
    proc.stdout.close()
651
    return old_clipboard
652

Daniel STAN's avatar
Daniel STAN committed
653
def clipboard(texte):
Vincent Le gallic's avatar
Vincent Le gallic committed
654
    """Place ``texte`` dans le presse-papier en mémorisant l'ancien contenu."""
655
    old_clipboard = saveclipboard()
Vincent Le gallic's avatar
Vincent Le gallic committed
656 657
    proc =subprocess.Popen(['xclip', '-selection', 'clipboard'],\
        stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr)
658
    proc.stdin.write(texte.encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
659
    proc.stdin.close()
660
    return old_clipboard
Daniel STAN's avatar
Daniel STAN committed
661

662 663
@need_filename
def show_file(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
664
    """Affiche le contenu d'un fichier"""
665 666
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
667
    if not gotit:
668 669
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
Daniel STAN's avatar
Daniel STAN committed
670
        return
671
    passfile = value
672
    (sin, sout) = gpg(options, 'decrypt')
Daniel STAN's avatar
Daniel STAN committed
673 674 675
    content = passfile['contents']
    
    # Kludge (broken db ?)
676 677 678
    if type(content) == list:
        print("Eau dans le gaz")
        content = content[-1]
Daniel STAN's avatar
Daniel STAN committed
679 680

    # Déchiffre le contenu
681
    sin.write(content.encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
682
    sin.close()
683
    texte = sout.read().decode("utf-8")
Daniel STAN's avatar
Daniel STAN committed
684 685 686 687 688 689 690 691

    # Est-ce une clé ssh ?
    is_key = texte.startswith('-----BEGIN RSA PRIVATE KEY-----')
    # Est-ce que le mot de passe a été caché ? (si non, on utilisera less)
    is_hidden = is_key
    # Texte avec mdp caché
    filtered = u""
    # Ancien contenu du press papier
Daniel STAN's avatar
Daniel STAN committed
692
    old_clipboard = None
Daniel STAN's avatar
Daniel STAN committed
693 694 695

    # Essaie de planquer le mot de passe
    for line in texte.split('\n'):
Daniel STAN's avatar
Daniel STAN committed
696 697 698
        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
Daniel STAN's avatar
Daniel STAN committed
699
        if not is_hidden and options.clipboard:
Daniel STAN's avatar
Daniel STAN committed
700 701
            catchPass = pass_regexp.match(line)
        if catchPass != None:
Daniel STAN's avatar
Daniel STAN committed
702 703
            is_hidden = True
            # On met le mdp dans le clipboard en mémorisant son ancien contenu
704 705 706
            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
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
        filtered += line + '\n'

    if is_key:
        filtered = u"La clé a été mise dans l'agent ssh"
    shown = u"Fichier %s:\n\n%s-----\nVisible par: %s\n" % (fname, filtered, ','.join(passfile['roles']))

    if is_key:
        with tempfile.NamedTemporaryFile(suffix='') as key_file:
            # Génère la clé publique correspondante
            key_file.write(texte.encode('utf-8'))
            key_file.flush()
            pub = subprocess.check_output(['ssh-keygen', '-y', '-f', key_file.name])

            # Charge en mémoire
            subprocess.check_call(['ssh-add', key_file.name])

            # On attend
            print(shown.encode('utf-8'))
            raw_input()

            # On met la clé publique en fichier puis on supprime
            key_file.seek(0)
            key_file.write(pub)
            key_file.flush()
            
            subprocess.check_call(['ssh-add', '-d', key_file.name])
    else:
        # Le binaire à utiliser
        showbin = "cat" if is_hidden else "less"
        proc = subprocess.Popen([showbin], stdin=subprocess.PIPE)
        out = proc.stdin
        out.write(shown.encode("utf-8"))
        out.close()
        os.waitpid(proc.pid, 0)

Daniel STAN's avatar
Daniel STAN committed
742
    # Repope ancien pass
743
    if old_clipboard is not None:
744
        saveclipboard(restore=True, old_clipboard=old_clipboard)
745

746 747
@need_filename
def edit_file(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
748
    """Modifie/Crée un fichier"""
749 750
    fname = options.fname
    gotit, value = get_files(options, [fname])[0]
Daniel STAN's avatar
Daniel STAN committed
751
    nfile = False
752
    annotations = u""
753 754 755 756 757

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

    # Cas du nouveau fichier
758
    if not gotit and not u"pas les droits" in value:
Daniel STAN's avatar
Daniel STAN committed
759
        nfile = True
760 761 762
        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
763
            return
764
        annotations += u"""Ceci est un fichier initial contenant un mot de passe
Vincent Le gallic's avatar
Vincent Le gallic committed
765 766
aléatoire, pensez à rajouter une ligne "login: ${login}"
Enregistrez le fichier vide pour annuler.\n"""
767
        texte = u"pass: %s\n" % gen_password()
768 769 770 771

        if new_roles is None:
            new_roles = parse_roles(options, cast=True)
        passfile = {'roles' : new_roles}
772
    elif not gotit:
773 774
        if not options.quiet:
            print(value.encode("utf-8")) # value contient le message d'erreur
775
        return
Daniel STAN's avatar
Daniel STAN committed
776
    else:
777
        passfile = value
778
        (sin, sout) = gpg(options, 'decrypt')
Daniel STAN's avatar
Daniel STAN committed
779 780 781 782 783 784
        contents = passfile['contents']
        # <ducktape> (waddle waddle)
        if isinstance(contents, list):
            contents = contents[-1]
        # </ducktape>
        sin.write(contents.encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
785
        sin.close()
786
        texte = sout.read().decode("utf-8")
787 788 789 790 791 792 793 794 795 796 797 798 799
        if new_roles is None:
            new_roles = passfile['roles']

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

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

Vincent Le gallic's avatar
Vincent Le gallic committed
806 807
    annotations += u"""Ce fichier sera chiffré pour les rôles suivants :\n%s\n
C'est-à-dire pour les utilisateurs suivants :\n%s""" % (
Daniel STAN's avatar
Daniel STAN committed
808
           ', '.join(new_roles),
809
           '\n'.join(' %s' % rec for rec in get_dest_of_roles(options, new_roles))
810
        )
811

812
    ntexte = editor(texte, annotations)
813

814 815 816
    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.
817 818 819 820 821
        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
822
    else:
Daniel STAN's avatar
Daniel STAN committed
823
        ntexte = texte if ntexte == None else ntexte
824
        success, message = put_password(options, new_roles, ntexte)
825
        print(message.encode("utf-8"))
Daniel STAN's avatar
Daniel STAN committed
826

827 828 829 830 831 832 833
_remember_dict = {}
def confirm(options, text, remember_key=None):
    """Demande confirmation, sauf si on est mode ``--force``.
    Si ``remember_key`` est fourni, il doit correspondre à un objet hashable
    qui permettra de ne pas poser deux fois les mêmes questions.
    """
    global _remember_dict
834 835
    if options.force:
        return True
836 837
    if remember_key in _remember_dict:
        return _remember_dict[remember_key]
Daniel STAN's avatar
Daniel STAN committed
838
    while True:
839
        out = raw_input((text + u' (o/n)').encode("utf-8")).lower()
Daniel STAN's avatar
Daniel STAN committed
840
        if out == 'o':
841 842
            res = True
            break
Daniel STAN's avatar
Daniel STAN committed
843
        elif out == 'n':
844 845 846 847 848 849
            res = False
            break
    # Remember the answer
    if remember_key is not None:
        _remember_dict[remember_key] = res
    return res
Daniel STAN's avatar
Daniel STAN committed
850

851 852
@need_filename
def remove_file(options):
Vincent Le gallic's avatar
Vincent Le gallic committed
853
    """Supprime un fichier"""
854
    fname = options.fname
855
    if not confirm(options, u'Êtes-vous sûr de vouloir supprimer %s ?' % (fname,)):
Daniel STAN's avatar
Daniel STAN committed
856
        return
857 858
    message = rm_file(fname)
    print(message.encode("utf-8"))
Vincent Le gallic's avatar
Vincent Le gallic committed
859

Daniel STAN's avatar
Daniel STAN committed
860

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

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

Daniel STAN's avatar
Daniel STAN committed
870
def recrypt_files(options, strict=False):
871
    """Rechiffre les fichiers.
Daniel STAN's avatar
Daniel STAN committed
872 873 874
       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.
875 876 877
       """
    rechiffre_roles = options.roles
    _, my_roles_w = get_my_roles(options)
878 879
    if rechiffre_roles == None:
        # Sans précisions, on prend tous les roles qu'on peut
880
        rechiffre_roles = my_roles_w
881

882
    # La liste des fichiers
883
    allfiles = all_files(options)
Daniel STAN's avatar
Daniel STAN committed
884 885 886 887 888 889 890 891 892 893

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

894
    askfiles = [filename for (filename, fileroles) in allfiles.iteritems()
Daniel STAN's avatar
Daniel STAN committed
895
                         if is_wanted(fileroles) ]
896
    files = get_files(options, askfiles)
897 898 899 900
    # 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:
901 902
            if not options.quiet:
                print(message.encode("utf-8"))
903
            return
904 905 906 907 908 909
    # 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)
910 911 912
    # On rechiffre
    to_put = [{'filename' : f['filename'],
               'roles' : f['roles'],
913
               'contents' : encrypt(options, f['roles'], decrypt(options, f['contents']))[-1]}
Vincent Le gallic's avatar
Vincent Le gallic committed
914
              for [success, f] in files]
915
    if to_put:
916 917
        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
918
        results = put_files(options, to_put)
919
        # On affiche les messages de retour