Newer
Older
Copyright (C) 2010-2020 Cr@ns <roots@crans.org>
Authors : Daniel Stan <daniel.stan@crans.org>
Vincent Le Gallic <legallic@crans.org>
Alexandre Iooss <erdnaxe@crans.org>
SPDX-License-Identifier: GPL-3.0-or-later
"""
# Import builtins
import sys
import subprocess
import json
import tempfile
import os
import argparse
import re
import copy
import logging
from configparser import ConfigParser
from secrets import token_urlsafe
# Import setuptool and SSH client
from pkg_resources import resource_filename
from paramiko.client import SSHClient
from paramiko.ssh_exception import SSHException
# Import modules
from .gpg import decrypt, encrypt, receive_keys, list_keys, GPG_TRUSTLEVELS
# Load locale
gettext.bindtextdomain('messages', resource_filename("cpasswords", "locale"))
gettext.textdomain('messages')
_ = gettext.gettext
# Configuration loading
# On n'a pas encore accès à la config donc on devine le nom
bootstrap_cmd_name = os.path.split(sys.argv[0])[1]
default_config_path = os.path.expanduser("~/.config/" + bootstrap_cmd_name)
config_path = os.getenv(
"CRANSPASSWORDS_CLIENT_CONFIG_DIR", default_config_path)
config = ConfigParser()
if not config.read(config_path + "/clientconfig.ini"):
# If config could not be imported, display an error if required
ducktape_display_error = sys.stderr.isatty() and \
not any([opt in sys.argv for opt in ["-q", "--quiet"]])
if ducktape_display_error:
# Do not use logger as it has not been initialized yet
print(_("%s/clientconfig.ini could not be found or read.\n"
"Please copy `docs/clientconfig.example.ini` from the source "
"repository and customize.") % config_path)
# Local logger
log = logging.getLogger(__name__)
#: 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?$',
flags=re.IGNORECASE)
""" Memoization/Lazy """
def __init__(self, f):
self.f = f
self.val = None
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."""
if self.val is None:
self.val = self.f(*args, **kwargs)
# On évite de tout deepcopier. Typiquement, un SSHClient
# ne devrait pas l'être (comme dans create_ssh_client)
if type(self.val) in [dict, list]:
return copy.deepcopy(self.val)
else:
return self.val
######
# Remote commands
"""
Create a SSH client with paramiko module
"""
if "host" not in options.serverdata:
log.error("Missing parameter `host` in active server configuration")
exit(1)
# Create SSH client with system host keys and agent
client = SSHClient()
client.load_system_host_keys()
try:
client.connect(str(options.serverdata['host']))
except SSHException:
log.error(
"Host key is unknown or you are using a outdated python-paramiko (ssh-ed25519 was implemented in 2017)")
raise
return client
def remote_command(options, command, arg=None, stdin_contents=None):
"""
Execute remote command and return output
"""
# Build command
if "remote_cmd" not in options.serverdata:
log.error("Missing parameter `remote_cmd` in active server configuration")
exit(1)
remote_cmd = options.serverdata['remote_cmd'] + " " + command
if arg:
remote_cmd += " " + arg
# Run command and timeout after 10s
log.info("Running command `%s`" % remote_cmd)
stdin, stdout, stderr = client.exec_command(remote_cmd, timeout=10)
# Write
if stdin_contents is not None:
stdin.write(json.dumps(stdin_contents))
stdin.flush()
# Return code == 0 if success
ret = stdout.channel.recv_exit_status()
if ret != 0:
err = ""
if stderr.channel.recv_stderr_ready():
err = stderr.read()
log.error(_("Wrong server return code %s, error is %s") % (ret, err))
exit(ret)
# Decode directly read buffer
try:
answer = json.load(stdout)
except ValueError:
exit(42)
log.debug("Server returned %s" % answer)
return answer
def all_keys(options):
"""Récupère les clés du serveur distant"""
return remote_command(options, "listkeys")
def all_roles(options):
"""Récupère les roles du serveur distant"""
return remote_command(options, "listroles")
def all_files(options):
"""Récupère les fichiers du serveur distant"""
return remote_command(options, "listfiles")
def restore_all_files(options):
"""Récupère les fichiers du serveur distant"""
return remote_command(options, "restorefiles")
def get_file(options, filename):
"""
Get the content of one remote file
"""
return remote_command(options, "getfile", filename)
def put_files(options, files):
"""Dépose les fichiers sur le serveur distant"""
return remote_command(options, "putfiles", stdin_contents=files)
"""Supprime le fichier sur le serveur distant"""
return remote_command(options, "rmfile", filename)
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)
distant_username = allroles.pop("whoami")
my_roles = [r for (r, users) in allroles.items()
if distant_username in users]
my_roles_w = [r[:-2] for r in my_roles if r.endswith("-w")]
return (my_roles, my_roles_w)
def gen_password(length=15):
"""
Generate a random password
"""
return token_urlsafe(length)
######
# Local commands
def update_keys(options):
"""Met à jour les clés existantes"""
keys = all_keys(options)
_, stdout = receive_keys([key for _, key in keys.values() if key])
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
return stdout.read().decode("utf-8")
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 que la clé soit dans le réseau de confiance…
meaning, trustvalue = GPG_TRUSTLEVELS[key["trustletter"]]
if not trustvalue:
return "La confiance en la clé est : %s" % (meaning,)
# …et qu'on puisse chiffrer avec…
if "e" in key["capabilities"]:
# …soit directement…
return ""
# …soit avec une de ses subkeys
esubkeys = [sub for sub in key["subkeys"] if "e" in sub["capabilities"]]
if len(esubkeys) == 0:
return "La clé principale de permet pas de chiffrer et auncune sous-clé de chiffrement."
if any([GPG_TRUSTLEVELS[sub["trustletter"]][1] for sub in esubkeys]):
return ""
else:
return "Aucune sous clé de chiffrement n'est de confiance et non expirée."
def check_keys(options, recipients=None, quiet=False):
"""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.
* 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.
* Si rien n'est fourni, vérifie toutes les clés et renvoie juste un booléen disant si tout va bien.
"""
trusted_recipients = []
keys = all_keys(options)
keys = {u: val for (u, val) in keys.iteritems() if u in recipients}
log.info("M : le mail correspond à un uid du fingerprint")
log.info("C : confiance OK (inclut la vérification de non expiration)")
for (recipient, (mail, fpr)) in keys.iteritems():
failed = ""
if fpr is not None:
key = localring.get(fpr, None)
# On vérifie qu'on possède la clé…
if key is not None:
# …qu'elle correspond au mail…
if any(["<%s>" % (mail,) in u["uid"] for u in key["uids"]]):
log.info("%s match fingerprint uid" % mail)
# … et qu'on peut raisonnablement chiffrer pour lui
failed = _check_encryptable(key)
if not failed:
log.info("%s is trusted and not expired" % mail)
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
else:
failed = "!! Le fingerprint et le mail ne correspondent pas !"
else:
failed = "Pas (ou trop) de clé avec ce fingerprint."
if failed:
log.warn("--> Fail on %s:%s\n--> %s" % (mail, fpr, failed))
if recipients is not None:
# On cherche à savoir si on droppe ce recipient
message = "Abandonner le chiffrement pour cette clé ? (Si vous la conservez, il est posible que gpg crashe)"
if confirm(options, message, ('drop', fpr, mail)):
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
else:
drop = False # Là, on droppe pas
if not drop:
trusted_recipients.append(recipient)
else:
log.warn("Droppe la clé %s:%s" % (fpr, recipient))
else:
trusted_recipients.append(recipient)
if recipients is None:
return set(keys.keys()).issubset(trusted_recipients)
else:
return trusted_recipients
def get_recipients_of_roles(options, roles):
"""Renvoie les destinataires d'une liste de rôles"""
recipients = set()
allroles = all_roles(options)
for role in roles:
if role == "whoami":
continue
for recipient in allroles[role]:
recipients.add(recipient)
return recipients
def get_dest_of_roles(options, roles):
"""Renvoie la liste des "username : mail (fingerprint)" """
allkeys = all_keys(options)
return ["%s : %s (%s)" % (rec, allkeys[rec][0], allkeys[rec][1])
for rec in get_recipients_of_roles(options, roles) if allkeys[rec][1]]
def my_encrypt(options, roles, contents):
"""Chiffre le contenu pour les roles donnés"""
allkeys = all_keys(options)
recipients = get_recipients_of_roles(options, roles)
recipients = check_keys(options, recipients=recipients, quiet=True)
fpr_recipients = []
for recipient in recipients:
fpr = allkeys[recipient][1]
if fpr:
fpr_recipients.append("-r")
fpr_recipients.append(fpr)
out = encrypt(contents, fpr_recipients)
def put_password(options, roles, contents):
"""Dépose le mot de passe après l'avoir chiffré pour les
destinataires dans ``roles``."""
success, enc_pwd_or_error = my_encrypt(options, roles, contents)
if success:
enc_pwd = enc_pwd_or_error
return put_files(options, [{'filename': options.filename, 'roles': roles, 'contents': enc_pwd}])[0]
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
else:
error = enc_pwd_or_error
return [False, error]
######
# Interface
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
def editor(texte, annotations=""):
""" Lance $EDITOR sur texte.
Renvoie le nouveau texte si des modifications ont été apportées, ou None
"""
# Avoid syntax hilight with ".txt". Would be nice to have some colorscheme
# for annotations ...
f = tempfile.NamedTemporaryFile(suffix='.txt')
if annotations:
annotations = "# " + annotations.replace("\n", "\n# ")
# Usually, there is already an ending newline in a text document
if texte and texte[-1] != '\n':
annotations = '\n' + annotations
else:
annotations += '\n'
f.write((texte + annotations).encode("utf-8"))
f.flush()
proc = subprocess.Popen([os.getenv('EDITOR', '/usr/bin/editor'), f.name])
os.waitpid(proc.pid, 0)
f.seek(0)
ntexte = f.read().decode("utf-8", errors='ignore')
f.close()
ntexte = '\n'.join(
filter(lambda l: not l.startswith('#'), ntexte.split('\n')))
return ntexte
def show_files(options):
"""Affiche la liste des fichiers disponibles sur le serveur distant"""
files = all_files(options)
keys = list(files.keys())
keys.sort()
for fname in keys:
froles = files[fname]
access = set(my_roles).intersection(froles) != set([])
print((" %s %s (%s)" % ((access and '+' or '-'), fname, ", ".join(froles))))
print((_("""--Mes roles: %s""") % ", ".join(my_roles)))
def restore_files(options):
"""Restore les fichiers corrompues sur le serveur distant"""
files = restore_all_files(options)
keys = files.keys()
keys.sort()
for fname in keys:
print(" %s (%s)" % (fname, files[fname]))
def show_roles(options):
"""Affiche la liste des roles existants"""
allroles = all_roles(options)
for (role, usernames) in allroles.iteritems():
if role == "whoami":
continue
if not role.endswith('-w'):
print(" * %s : %s" % (role, ", ".join(usernames)))
def show_servers(options):
"""Affiche la liste des serveurs disponibles"""
for server in config.keys():
print(" * " + server)
def saveclipboard(restore=False, old_clipboard=None):
"""Enregistre le contenu du presse-papier. Le rétablit si ``restore=True``"""
if restore and old_clipboard is None:
return
act = '-in' if restore else '-out'
proc = subprocess.Popen(['xclip', act, '-selection', 'clipboard'],
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=sys.stderr)
if not restore:
old_clipboard = proc.stdout.read()
else:
input(_("Appuyez sur Entrée pour récupérer le contenu précédent du presse papier."))
proc.stdin.write(old_clipboard)
proc.stdin.close()
proc.stdout.close()
return old_clipboard
def clipboard(texte):
"""Place ``texte`` dans le presse-papier en mémorisant l'ancien contenu."""
old_clipboard = saveclipboard()
proc = subprocess.Popen(['xclip', '-selection', 'clipboard'],
stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr)
proc.stdin.write(texte.encode("utf-8"))
proc.stdin.close()
return old_clipboard
@need_filename
def show_file(options):
"""Affiche le contenu d'un fichier"""
gotit, value = get_file(options, fname)
if not gotit:
log.warn(value) # value contient le message d'erreur
return
passfile = value
content = passfile['contents']
# Kludge (broken db ?)
if type(content) == list:
log.warn("Eau dans le gaz")
content = content[-1]
# Déchiffre le contenu
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
# 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 = ""
# Ancien contenu du press papier
old_clipboard = None
# Essaie de planquer le mot de passe
for line in texte.split('\n'):
catch_pass = 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 is_hidden and options.clipboard:
catch_pass = pass_regexp.match(line)
if catch_pass is not None:
is_hidden = True
# On met le mdp dans le clipboard en mémorisant son ancien contenu
old_clipboard = clipboard(catch_pass.group(1))
# Et donc on override l'affichage
line = "[Le mot de passe a été mis dans le presse papier]"
filtered += line + '\n'
if is_key:
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
shown = "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 (hors tmpfile)
print(shown.encode('utf-8'))
input()
with tempfile.NamedTemporaryFile(suffix='') as pub_file:
# On met la clé publique en fichier pour suppression
pub_file.write(pub)
pub_file.flush()
subprocess.check_call(['ssh-add', '-d', pub_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)
# Repope ancien pass
if old_clipboard is not None:
saveclipboard(restore=True, old_clipboard=old_clipboard)
@need_filename
def edit_file(options):
"""Modifie/Crée un fichier"""
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
gotit, value = get_file(options, fname)
nfile = False
annotations = ""
my_roles, _ = get_my_roles(options)
new_roles = options.roles
# Cas du nouveau fichier
if not gotit and "pas les droits" not in value:
nfile = True
if not options.quiet:
print("Fichier introuvable")
if not confirm(options, "Créer fichier ?"):
return
annotations += """Ceci est un fichier initial contenant un mot de passe
aléatoire, pensez à rajouter une ligne "login: ${login}"
Enregistrez le fichier vide pour annuler.\n"""
texte = "pass: %s\n" % gen_password()
if new_roles is None:
new_roles = parse_roles(options, cast=True)
passfile = {'roles': new_roles}
elif not gotit:
log.warn(value)
return
else:
passfile = value
contents = passfile['contents']
# <ducktape> (waddle waddle)
if isinstance(contents, list):
contents = contents[-1]
# </ducktape>
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
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']):
log.warn("Aucun rôle en écriture pour ce fichier ! Abandon.")
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 = """Vous vous apprêtez à perdre vos droits en écriture""" + \
"""(ROLES ne contient rien parmi : %s) sur ce fichier, continuer ?"""
message = message % (", ".join(r[:-2] for r in my_roles if '-w' in r),)
if not confirm(options, message):
return
annotations += """Ce fichier sera chiffré pour les rôles suivants :\n%s\n
C'est-à-dire pour les utilisateurs suivants :\n%s""" % (
', '.join(new_roles),
'\n'.join(' %s' %
rec for rec in get_dest_of_roles(options, new_roles))
)
ntexte = editor(texte, annotations)
if ((not nfile and ntexte in ['', 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 == '')): # ou alors on a créé un fichier vide.
message = "Pas de modification à enregistrer.\n"
message += "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 += "Si c'est un nouveau fichier, vous avez tenté de le créer vide."
if not options.quiet:
print(message)
else:
ntexte = texte if ntexte is None else ntexte
success, message = put_password(options, new_roles, ntexte)
print(message)
_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
if options.force:
return True
if remember_key in _remember_dict:
return _remember_dict[remember_key]
while True:
out = input((text + ' (o/n)')).lower()
if out == 'o':
res = True
break
elif out == 'n':
res = False
break
# Remember the answer
if remember_key is not None:
_remember_dict[remember_key] = res
return res
@need_filename
def remove_file(options):
"""Supprime un fichier"""
if not confirm(options, 'Êtes-vous sûr de vouloir supprimer %s ?' % (fname,)):
return
print(message)
def my_check_keys(options):
"""Vérifie les clés et affiche un message en fonction du résultat"""
print(_("Vérification que les clés sont valides (uid correspondant au login) et de confiance."))
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
print(check_keys(options) and "Base de clés ok" or "Erreurs dans la base")
def my_update_keys(options):
"""Met à jour les clés existantes et affiche le résultat"""
print(update_keys(options))
def recrypt_files(options, strict=False):
"""Rechiffre les fichiers.
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.
"""
rechiffre_roles = options.roles
_, my_roles_w = get_my_roles(options)
if rechiffre_roles is None:
# Sans précisions, on prend tous les roles qu'on peut
rechiffre_roles = my_roles_w
# La liste des fichiers
allfiles = all_files(options)
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))
askfiles = [filename for (filename, fileroles) in allfiles.iteritems()
if is_wanted(fileroles)]
files = [get_file(options, f) for f in askfiles]
# 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:
log.warn(message)
return
# 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 = _(
"Vous vous apprêtez à rechiffrer les fichiers suivants :\n%s") % filenames
if not confirm(options, message + "\nConfirmer"):
exit(2)
# On rechiffre
to_put = [{'filename': f['filename'],
'roles': f['roles'],
'contents': my_encrypt(options, f['roles'], decrypt(f['contents']))[-1]}
for [success, f] in files]
if to_put:
if not options.quiet:
print("Rechiffrement de %s" %
(", ".join([f['filename'] for f in to_put])))
results = put_files(options, to_put)
# On affiche les messages de retour
if not options.quiet:
for i in range(len(results)):
print("%s : %s" % (to_put[i]['filename'], results[i][1]))
else:
log.warn(_("Aucun fichier n'a besoin d'être rechiffré"))
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
def parse_roles(options, cast=False):
"""Interprête la liste de rôles fournie par l'utilisateur.
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.
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
"""
if options.roles is None and not cast:
return options.roles
strroles = options.roles
allroles = all_roles(options)
_, my_roles_w = get_my_roles(options)
if strroles is 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
ret = set()
for role in strroles.split(','):
if role not in allroles.keys():
log.warn("role %s do not exists" % role)
exit(1)
if role.endswith('-w'):
log.warn("role %s should not be used, rather use %s" %
(role, role[:-2]))
exit(1)
ret.add(role)
return list(ret)
def insult_on_nofilename(options, parser):
"""Insulte (si non quiet) et quitte si aucun nom de fichier n'a été fourni en commandline."""
log.warn(_("You need to provide a filename with this command"))
if not options.quiet:
parser.print_help()
exit(1)
# Gestion des arguments
parser = argparse.ArgumentParser(
description=_("Group passwords manager based on GPG."),
)
parser.add_argument(
'filename',
nargs='?',
default=None,
help=_("name of file to show or edit")
)
parser.add_argument(
'-v', '--verbose',
action='count',
default=1,
help=_("verbose mode, multiple -v options increase verbosity"),
)
parser.add_argument(
'-q', '--quiet',
action='store_true',
default=False,
help=_("silent mode: hide errors, overrides verbosity"),
)
parser.add_argument(
'-s', '--server',
default='DEFAULT',
metavar="SRV",
help=_("select another server than DEFAULT"),
action='store_false',
default=None,
dest='clipboard',
help=_("do not try to store password in clipboard"),
)
parser.add_argument(
'-f', '--force',
action='store_true',
default=False,
parser.add_argument(
'--drop-invalid',
action='store_true',
default=False,
dest='drop_invalid',
help=_("need --force, drop untrusted keys without confirmation."),
)
parser.add_argument(
'--roles',
nargs='?',
default=None,
help=_("""Liste de roles (séparés par des virgules). Par défaut, tous les
rôles en écriture (sauf pour l'édition, d'un fichier existant).
Avec --edit: le fichier sera chiffré pour exactement ces roles
Avec --(strict-)recrypt-files :
sert à sélectionnenr les fichiers à rechiffrer
* non-strict: tout fichier possédant un des rôles listé
* strict: tout fichier dont *tous* les rôles sont dans la
liste
"""))
arg_grp = parser.add_argument_group("actions")
action_grp = arg_grp.add_mutually_exclusive_group(required=False)
action='store_const',
dest='action',
default=show_file,
const=show_file,
help=_("read file (default)"),
action='store_const',
dest='action',
default=show_file,
const=edit_file,
help=_("edit (or create) file"),
)
action_grp.add_argument(
'--remove',
action='store_const',
dest='action',
default=show_file,
const=remove_file,
)
action_grp.add_argument(
'-l', '--list',
action='store_const',
dest='action',
default=show_file,
const=show_files,
)
action_grp.add_argument(
'-r', '--restore',
action='store_const', dest='action',
default=show_file,
const=restore_files,
)
action_grp.add_argument(
'--check-keys',
action='store_const',
dest='action',
default=show_file,
const=my_check_keys,
)
action_grp.add_argument(
'--update-keys',
default=show_file,
const=my_update_keys,
)
action_grp.add_argument(
'--list-roles',
action='store_const',
dest='action',
default=show_file,
const=show_roles,
)
action_grp.add_argument(
'--list-servers',
action='store_const',
dest='action',
default=show_file,
const=show_servers,
action_grp.add_argument(
'--recrypt-files',
action='store_const',
dest='action',
default=show_file,
const=recrypt_files,
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é)"""),
)
action_grp.add_argument(
'--strict-recrypt-files',
action='store_const',
dest='action',
default=show_file, const=lambda x: recrypt_files(
x, strict=True),
help=_("Rechiffrer les mots de passe (mode strict, voir --roles)"),
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
# On parse les options fournies en commandline
options = parser.parse_args()
# Active le logger avec des couleurs
# Par défaut on affiche >= WARNING
options.verbose = 40 - (10 * options.verbose) if not options.quiet else 0
logging.addLevelName(logging.INFO, "\033[1;36mINFO\033[1;0m")
logging.addLevelName(logging.WARNING, "\033[1;33mWARNING\033[1;0m")
logging.addLevelName(logging.ERROR, "\033[1;91mERROR\033[1;0m")
logging.addLevelName(logging.DEBUG, "\033[1;37mDEBUG\033[1;0m")
logging.basicConfig(
level=options.verbose,
format='\033[90m%(asctime)s\033[1;0m %(name)s %(levelname)s %(message)s'
)
# 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.
# ** 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')
# On récupère les données du serveur à partir du nom fourni
options.serverdata = config[options.server]
# On parse les roles fournis, et il doivent exister, ne pas être -w…
# parse_roles s'occupe de ça
# 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)
# 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)
if __name__ == "__main__":
main()