exportar llaveros

Esto es casi cómo lo hice hace muchos años, esta es la actualización del script para Yosemite 10.11.5 , pero no lo he probado.

1. Una secuencia de comandos que guarda cada elemento del llavero en texto:

   security dump-keychain -d login.keychain > keychain.txt
   

2. Un segundo elemento de AppleScript que hace clic en el botón "Permitir" que la primera secuencia de comandos activa cuando se lee el elemento de KeyChain.

   [Edición: julio de 2016] Esto se ha actualizado a la nota 10.11.5, ya que algunos han informado que han bloqueado su Mac con un retraso de 0.2; he limitado la secuencia de comandos para procesar solo 200 resultados a la vez, por lo tanto, si tiene 1050 elementos de llavero, deberá ejecutar este script 6 veces en ScriptEditor, también deberá permitir que ScriptEditor se habilite en la sección Accesibilidad en las preferencias de seguridad en:

   tell application "System Events"
       set maxAttemptsToClick to 200
       repeat while exists (processes where name is "SecurityAgent")
           if maxAttemptsToClick = 0 then exit repeat
           set maxAttemptsToClick to maxAttemptsToClick - 1
           tell process "SecurityAgent"
               try
                   click button 2 of window 1
               on error
                   keystroke " "
           end try
       end tell
       delay 0.2
     end repeat
   end tell
   

Luego, el enlace / yosemite update arriba también tiene un paso de conversión de ruby desde el archivo de texto a CSV, ¡Buena suerte!

ShreevatsaR señala en los comentarios que esta conversión de Ruby solo cubre "contraseñas de Internet" y no "contraseñas de aplicaciones". Esto se debe a que el objetivo del script es exportar las "contraseñas de Internet" a la aplicación 1Password .

Y aquí hay un stack overflow pregunta y responde en la misma línea

El System.keychain está aquí:

security dump-keychain -d /Library/Keychains/System.keychain > systemkeychain.txt

Para permitir que AppleScript interactúe con el cuadro de diálogo Preferencias del sistema - > Seguridad y amp; Preferencias de privacidad - > Pestaña de privacidad, la opción de accesibilidad debe tener "Script Editor.app" habilitado

Escribí una secuencia de comandos de Python que convierte el volcado del llavero en un archivo de Excel y pensé que lo comparto contigo. Elijo Excel sobre CSV o TSV porque muchas personas lo tienen instalado y simplemente funciona haciendo doble clic en el archivo. Por supuesto, puede modificar el script para imprimir cualquier otro formato. Hice esto en OS X 10.11 El Capitan, pero también debería funcionar en sistemas operativos más antiguos.

1. Como no me gusta almacenar mis contraseñas en texto plano en mi disco duro, creé un contenedor cifrado usando la aplicación Disk Utility. Simplemente abra la Utilidad de Disco (presione cmd + Espacio , escriba "disco"). En la aplicación, presione cmd + N para obtener una nueva imagen, cambie el nombre a SEC, cambie el cifrado a AES de 256 bits y guárdelo en SEC en el directorio que elija. . Luego monte el volumen haciendo doble clic en el archivo (o utilizando la Utilidad de Disco).

2. Cree un nuevo archivo llamado keychain.py en el contenedor seguro y pegue el código a continuación.

3. Ahora abra Terminal.app y cambie el directorio al volumen cifrado montado: cd /Volumes/SEC

4. Necesitamos el administrador de paquetes de Python para instalar el módulo de Excel (se te pedirá tu contraseña): sudo easy_install pip

5. Necesitamos instalar el módulo de Python Excel: sudo pip install xlwt

6. Ahora exporte las contraseñas usando una de las otras respuestas a esta pregunta. Acabo de hacer security dump-keychain -d > keychain.txt y el spam hizo clic en el botón Permitir mientras sostenía el mouse con la otra mano.

7. El último paso es convertir el archivo txt en una hoja de Excel legible mediante el script de python: python keychain.py keychain.txt keychain.xls

.

#!/usr/bin/env python

import sys
import os
import re
import xlwt

# Regex to match both generic and internet passwords from a keychain dump
regex = re.compile(
    r"""
    keychain:\s"(?P<kchn>[^"]+)"\n                  # absolute path and file of keychain
    version:\s(\d\d\d)\n                            # version
    class:\s"(?P<clss>(genp|inet))"\n               # generic password or internet password
    attributes:\n
    (\s*?0x00000007\s<blob>=(?P<name>[^\n]+)\n)?    # name
    (\s*?0x00000008\s<blob>=(?P<hex8>[^\n]+)\n)?    # ? only used at certificates
    (\s*?"acct"<blob>=(?P<acct>[^\n]+)\n)?          # account
    (\s*?"atyp"<blob>=(?P<atyp>[^\n]+)\n)?          # account type ("form"), sometimes int
    (\s*?"cdat"<timedate>=[^"]*(?P<cdat>[^\n]+)\n)? # datetime created
    (\s*?"crtr"<uint32>=(?P<crtr>[^\n]+)\n)?        # vendor key with four chars like "aapl"
    (\s*?"cusi"<sint32>=(?P<cusi>[^\n]+)\n)?        # ? always null
    (\s*?"desc"<blob>=(?P<desc>[^\n]+)\n)?          # description
    (\s*?"gena"<blob>=(?P<gena>[^\n]+)\n)?          # ? always null except one rare cases
    (\s*?"icmt"<blob>=(?P<icmt>[^\n]+)\n)?          # ? some sort of description
    (\s*?"invi"<sint32>=(?P<invi>[^\n]+)\n)?        # ? always null
    (\s*?"mdat"<timedate>=[^"]*(?P<mdat>[^\n]+)\n)? # datetime last modified
    (\s*?"nega"<sint32>=(?P<nega>[^\n]+)\n)?        # ? always null
    (\s*?"path"<blob>=(?P<path>[^\n]+)\n)?          # path
    (\s*?"port"<uint32>=(?P<port>[^\n]+)\n)?        # port number in hex
    (\s*?"prot"<blob>=(?P<prot>[^\n]+)\n)?          # ? always null
    (\s*?"ptcl"<uint32>=(?P<ptcl>[^\n]+)\n)?        # protocol but is blob ("http", "https")
    (\s*?"scrp"<sint32>=(?P<scrp>[^\n]+)\n)?        # ? always null except one rare cases
    (\s*?"sdmn"<blob>=(?P<sdmn>[^\n]+)\n)?          # used for htaccess AuthName
    (\s*?"srvr"<blob>=(?P<srvr>[^\n]+)\n)?          # server
    (\s*?"svce"<blob>=(?P<svce>[^\n]+)\n)?          # ? some sort of description
    (\s*?"type"<uint32>=(?P<type>[^\n]+)\n)?        # some blob: "iprf", "note"
    data:\n
    "(?P<data>[^"]*)"                               # password
    """, re.MULTILINE | re.VERBOSE)

# Dictionary used by the clean function (Apple is not always right about the
# types of the field)
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 == "<NULL>":
        # print null values as empty strings
        return ""
    if field2type[field] == "blob":
        # strip " at beginning and end
        return value[1:-1]
    elif field2type[field] == "timedate":
        # convert timedate to the iso standard
        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":
        # if it really is a hex int, convert it to decimal
        value = value.strip()
        if re.match("^0x[0-9a-fA-F]+$", value):
            return int(value, 16)
        else:
            return value
    else:
        # do nothing, just print it as it is
        return value

def print_help():
    print "Usage: python keychain.py INPUTFILE OUTPUTFILE"
    print "Example: python keychain.py keychain.txt keychain.xls"
    print "  where keychain.txt was created by 'security dump-keychain -d > keychain.txt'"
    print "  When dumping the keychain, you have to click 'Allow' for each entry in your"
    print "  keychain. Position you mouse over the button and go clicking like crazy."




print "Keychain 0.1: convert an Apple Keychain dump to an Excel (XLS) spreadsheet."

# Check for correct parameters
if len(sys.argv) != 3:
    print_help()
    sys.exit(1)
elif len(sys.argv) == 3:
    if not os.path.isfile(sys.argv[1]):
        print "Error: no such file '{0}'".format(sys.argv[1])
        print_help()
        exit(1)

# Read keychain file
buffer = open(sys.argv[1], "r").read()
print "Read {0} bytes from '{1}'".format(len(buffer), sys.argv[1])

# Create excel workbook and header
wb = xlwt.Workbook()
ws = wb.add_sheet("Keychain")
ws.write(0, 0, "Name")
ws.write(0, 1, "Account")
ws.write(0, 2, "Password")
ws.write(0, 3, "Protocol")
ws.write(0, 4, "Server")
ws.write(0, 5, "Port")
ws.write(0, 6, "Path")
ws.write(0, 7, "Description")
ws.write(0, 8, "Created")
ws.write(0, 9, "Modified")
ws.write(0, 10, "AuthName")
ws.write(0, 11, "AccountType")
ws.write(0, 12, "Type")
ws.write(0, 13, "Keychain")

# Find passwords and add them to the excel spreadsheet
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 "Saved {0} passwords to '{1}'".format(i-1, sys.argv[2])

A partir de OSX 10.10.3 hay una nueva forma de aceptación automática (me encontré con problemas durante una ruta de actualización)

Funciones de Bash (agregadas a los archivos .profile o .bash_rc )

## At the terminal when you start getting the prompts, type 'Accepts' and press enter
function Accepts () {
osascript <<EOF
  tell application "System Events"
    repeat while exists (processes where name is "SecurityAgent")
      tell process "SecurityAgent" to click button "Allow" of window 1
      delay 0.2
    end repeat
  end tell
EOF
}

## At the terminal when you start getting the prompts, type 'Accepts YourUsername YourPassword' and press enter
function AcceptWithCreds () {
username="$1"
password="$2"

[ -z "${password}" ] && return 1

osascript 2>/dev/null <<EOF
    set appName to "${username}"
    set appPass to "${password}"
    tell application "System Events"
        repeat while exists (processes where name is "SecurityAgent")
            tell process "SecurityAgent"
                if exists (text field 1 of window 1) then
                    set value of text field 1 of window 1 to appName
                    set value of text field 2 of window 1 to appPass
                end if
            end tell
      tell process "SecurityAgent" to click button "Allow" of window 1
            delay 0.2
        end repeat
    end tell
EOF
echo 'Finished...'
}

Y usa este script para volcar tu anillo de claves ( sudo ./dump.sh )

#!/bin/bash
# Run above script in another window

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

La respuesta de @ MichaelStoner es un buen comienzo, pero falla en OS X 10.10.3 Yosemite, con su código AppleScript reportando System Events got an error: Can’t get group 1 of window 1 of process "SecurityAgent". Invalid index .

Después de jugar un poco, la siguiente solución funcionó para mí:

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

Deberá hacer clic en el cuadro de diálogo "Permitir" después de iniciar esto. Este código tomará un tiempo, pero desaconsejo reducir la demora (el "retraso 0.2" me hizo apagar a la fuerza mi Mac). Solo toma una taza de café.

La función de exportación de llavero es para ARTÍCULOS, no para todo el llavero. Tampoco le permitirá exportar la mayoría de los elementos, es decir, cuando verá la función Exportar en gris.

Para copiar el llavero de un mac a otro use

• asistente de migración

• o hágalo manualmente copiando el archivo de la cadena de claves ubicado en ~ / Library / Keychains /

Abra el acceso al llavero en la nueva computadora y use la opción Agregar llavero

El binario security recuperará los elementos del llavero desde la línea de comandos, por lo que podría secuencia de comandos que está en python Para volcar los contenidos sistemáticamente. Realmente depende del formato que desee para los datos y de cómo los utilizará en el futuro.

Copiar / pegar también es una opción decente si sabe cuánto tiempo le interesa implementar una nueva solución y si necesita aprender / buscar un programa o biblioteca existente que volcará el contenido al formato elegido.

El menú de elementos de exportación es para la exportación de claves públicas y / o privadas para las cuales existen formatos de archivo estándar de la industria para codificar y proteger los datos según corresponda cuando se almacenan en el sistema de archivos para su intercambio y transporte. Esa función se documenta brevemente en la ayuda de Keychain Assistant.

Hay una herramienta llamada KeychaindumpPro enlace .

Para obtener la frase de paso / cuenta / pago / Secure Note / PublicKey / PrivateKey / SymmetricKey / Certificate y así sucesivamente desde Keychain en silencio.