Exporter les porte-clés

```html

J'ai écrit un script python qui convertit le dump du trousseau de clés en un fichier Excel et j'ai pensé le partager avec vous. J'ai choisi Excel plutôt que CSV ou TSV car beaucoup de gens l'ont installé et cela fonctionne simplement en double-cliquant sur le fichier. Vous pouvez bien sûr modifier le script pour imprimer tout autre format. J'ai fait cela sur OS X 10.11 El Capitan, mais cela devrait fonctionner sur des anciens OS également.

1. Comme je n'aime pas stocker mes mots de passe en texte brut sur mon disque dur, j'ai créé un conteneur chiffré en utilisant l'application Utilitaire de disque. Ouvrez simplement Utilitaire de disque (appuyez sur cmd + Espace, tapez "disque"). Dans l'application, appuyez sur cmd + N pour une nouvelle image, changez le nom en SEC, passez le cryptage en AES 256 bits et enregistrez-le sous SEC dans un répertoire de votre choix. Ensuite, montez le volume en double-cliquant sur le fichier (ou en utilisant Utilitaire de disque).

2. Créez un nouveau fichier nommé keychain.py dans le conteneur sécurisé et collez le code ci-dessous.

3. Maintenant, ouvrez Terminal.app et changez de répertoire vers le volume chiffré monté: cd /Volumes/SEC

4. Nous avons besoin du gestionnaire de packages python pour installer le module Excel (vous serez invité à entrer votre mot de passe): sudo easy_install pip

5. Nous devons installer le module Excel Python: sudo pip install xlwt

6. Exportez maintenant les mots de passe en utilisant l'une des autres réponses à cette question. J'ai simplement fait security dump-keychain -d > keychain.txt et j'ai cliqué frénétiquement sur le bouton Autoriser en maintenant la souris avec mon autre main.

7. La dernière étape consiste à convertir le fichier txt en une feuille Excel lisible en utilisant le script python: python keychain.py keychain.txt keychain.xls

.

#!/usr/bin/env python

import sys
import os
import re
import xlwt

# Regex pour correspondre aux mots de passe génériques et Internet d'un dump de trousseau de clés
regex = re.compile(
    r"""
    keychain:\s"(?P[^"]+)"\n                  # chemin absolu et nom du trousseau de clés
    version:\s(\d\d\d)\n                            # version
    class:\s"(?P(genp|inet))"\n               # mot de passe générique ou mot de passe Internet
    attributes:\n
    (\s*?0x00000007\s=(?P[^\n]+)\n)?    # nom
    (\s*?0x00000008\s=(?P[^\n]+)\n)?    # ? utilisé seulement pour les certificats
    (\s*?"acct"=(?P[^\n]+)\n)?          # compte
    (\s*?"atyp"=(?P[^\n]+)\n)?          # type de compte ("formulaire"), parfois int
    (\s*?"cdat"=[^"]*(?P[^\n]+)\n)? # date et heure de création
    (\s*?"crtr"=(?P[^\n]+)\n)?        # clé du fournisseur avec quatre caractères comme "aapl"
    (\s*?"cusi"=(?P[^\n]+)\n)?        # ? toujours null
    (\s*?"desc"=(?P[^\n]+)\n)?          # description
    (\s*?"gena"=(?P[^\n]+)\n)?          # ? toujours null sauf dans quelques cas rares
    (\s*?"icmt"=(?P[^\n]+)\n)?          # ? sorte de description
    (\s*?"invi"=(?P[^\n]+)\n)?        # ? toujours null
    (\s*?"mdat"=[^"]*(?P[^\n]+)\n)? # date et heure de dernière modification
    (\s*?"nega"=(?P[^\n]+)\n)?        # ? toujours null
    (\s*?"path"=(?P[^\n]+)\n)?          # chemin
    (\s*?"port"=(?P[^\n]+)\n)?        # numéro de port en hex
    (\s*?"prot"=(?P[^\n]+)\n)?          # ? toujours null
    (\s*?"ptcl"=(?P[^\n]+)\n)?        # protocole mais est un blob ("http", "https")
    (\s*?"scrp"=(?P[^\n]+)\n)?        # ? toujours null sauf dans quelques cas rares
    (\s*?"sdmn"=(?P[^\n]+)\n)?          # utilisé pour AuthName htaccess
    (\s*?"srvr"=(?P[^\n]+)\n)?          # serveur
    (\s*?"svce"=(?P[^\n]+)\n)?          # ? sorte de description
    (\s*?"type"=(?P[^\n]+)\n)?        # quelque blob: "iprf", "note"
    data:\n
    "(?P[^"]*)"                               # mot de passe
    """, re.MULTILINE | re.VERBOSE)

# Dictionnaire utilisé par la fonction clean (Apple n'a pas toujours raison sur les
# types du champ)
field2type = {
    "name": "blob",
    "hex8": "blob",
    "acct": "blob",
    "atyp": "simple",
    "cdat": "timedate",
    "crtr": "uint32",
    "cusi": "sint32",
    "desc": "blob",
    "gena": "blob",
    "icmt": "blob",
    "invi": "sint32",
    "mdat": "timedate",
    "nega": "sint32",
    "path": "blob",
    "port": "uint32",
    "prot": "blob",
    "ptcl": "blob",
    "scrp": "sint32",
    "sdmn": "blob",
    "srvr": "blob",
    "svce": "blob",
    "type": "blob",
    "data": "simple",
    "kchn": "simple",
    "clss": "simple"
}

def clean(field, match):
    value = match.group(field)
    if not value or value == "":
        # imprimer les valeurs nulles comme chaînes vides
        return ""
    if field2type[field] == "blob":
        # supprimer les "au début et à la fin
        return value[1:-1]
    elif field2type[field] == "timedate":
        # convertir timedate en la norme ISO
        value = value[1:-1]
        return value[0:4] + "-" + value[4:6] + "-" + value[6:8] + "T" + \
            value[8:10] + ":" + value[10:12] + ":" + value[12:14] + "Z" + value[16:19]
    elif field2type[field] == "uint32":
        # s'il s'agit vraiment d'un entier héxadécimal, le convertir en décimal
        value = value.strip()
        if re.match("^0x[0-9a-fA-F]+$", value):
            return int(value, 16)
        else:
            return value
    else:
        # ne rien faire, juste l'imprimer tel quel
        return value

def print_help():
    print "Usage: python keychain.py INPUTFILE OUTPUTFILE"
    print "Exemple: python keychain.py keychain.txt keychain.xls"
    print "  où keychain.txt a été créé par `security dump-keychain -d > keychain.txt`"
    print "  Lorsque vous videz le trousseau de clés, vous devez cliquer sur 'Autoriser' pour chaque entrée dans votre"
    print "  trousseau de clés. Positionnez votre souris sur le bouton et cliquez comme un fou."

print "Trousseau 0.1 : convertir un dump de trousseau de clés Apple en une feuille de calcul Excel (XLS)."

# Vérifier les paramètres corrects
if len(sys.argv) != 3:
    print_help()
    sys.exit(1)
elif len(sys.argv) == 3:
    if not os.path.isfile(sys.argv[1]):
        print "Erreur : aucun fichier du nom '{0}'".format(sys.argv[1])
        print_help()
        exit(1)

# Lire le fichier du trousseau de clés
buffer = open(sys.argv[1], "r").read()
print "Lecture de {0} octets depuis '{1}'".format(len(buffer), sys.argv[1])

# Créer un classeur excel et un en-tête
wb = xlwt.Workbook()
ws = wb.add_sheet("Trousseau")
ws.write(0, 0, "Nom")
ws.write(0, 1, "Compte")
ws.write(0, 2, "Mot de passe")
ws.write(0, 3, "Protocole")
ws.write(0, 4, "Serveur")
ws.write(0, 5, "Port")
ws.write(0, 6, "Chemin")
ws.write(0, 7, "Description")
ws.write(0, 8, "Créé")
ws.write(0, 9, "Modifié")
ws.write(0, 10, "AuthName")
ws.write(0, 11, "Type de compte")
ws.write(0, 12, "Type")
ws.write(0, 13, "Trousseau")

# Trouver les mots de passe et les ajouter à la feuille de calcul Excel
i = 1
for match in regex.finditer(buffer):
    ws.write(i, 0, clean("name", match))
    ws.write(i, 1, clean("acct", match))
    ws.write(i, 2, clean("data", match))
    ws.write(i, 3, clean("ptcl", match))
    ws.write(i, 4, clean("srvr", match))
    ws.write(i, 5, clean("port", match))
    ws.write(i, 6, clean("path", match))
    ws.write(i, 7, clean("desc", match))
    ws.write(i, 8, clean("cdat", match))
    ws.write(i, 9, clean("mdat", match))
    ws.write(i, 10, clean("sdmn", match))
    ws.write(i, 11, clean("atyp", match))
    ws.write(i, 12, clean("clss", match))
    ws.write(i, 13, clean("kchn", match))
    i += 1
wb.save(sys.argv[2])

print "Enregistré {0} mots de passe dans '{1}'".format(i-1, sys.argv[2])

```

Dès OSX 10.10.3, il existe une nouvelle façon d'accepter automatiquement (j'ai rencontré des problèmes lors d'une mise à niveau)

Fonctions Bash (ajoutées aux fichiers .profile ou .bash_rc)

## Dans le terminal lorsque vous commencez à recevoir les invites, tapez `Accepts` et appuyez sur entrée
function Accepts () {
osascript </dev/null <

`Et utilisez ce script pour décharger votre trousseau de clés (sudo ./dump.sh`)

#!/bin/bash
# Exécutez le script ci-dessus dans une autre fenêtre

security dump-keychain -d login.keychain > keychain-login.txt
security dump-keychain -d /Library/Keychains/System.keychain > keychain-system.txt``

La réponse de @MichaelStoner est un bon début, mais cela ne fonctionne pas sur OS X 10.10.3 Yosemite, car son code AppleScript signale System Events a obtenu une erreur : Impossible d'obtenir le groupe 1 de la fenêtre 1 du processus "SecurityAgent". Index non valide.

Après avoir joué un peu, la solution suivante a fonctionné pour moi :

tell application "System Events"
    repeat while exists (processes where name is "SecurityAgent")
        tell process "SecurityAgent"
            keystroke " "
        end tell
        delay 1
    end repeat
end tell

Vous devrez cliquer sur le dialogue "Autoriser" après avoir lancé cela. Ce code prendra un certain temps, mais je déconseille de réduire le délai ("delay 0.2" m'a obligé à éteindre mon Mac de force). Prenez juste une tasse de café.

La fonction d'exportation de porte-clés est pour les ÉLÉMENTS, pas pour l'ensemble du trousseau. Elle ne vous permettra pas non plus d'exporter la plupart des Éléments - c'est à ce moment-là que vous verrez la fonction d'exportation grisée.

Pour copier un trousseau d'une Mac à un autre, utilisez l'application Assistant migration.

Ou faites-le manuellement en copiant le fichier de trousseau situé dans le dossier ~/Library/Keychains/.

Ouvrez l'application Accès au trousseau sur le nouvel ordinateur et choisissez Fichier > Ajouter trousseau….