tag puddletag portable picard para musicbrainz mp3tag kid3 easytag linux encryption gnupg

linux - puddletag - GnuPG: ¿Cómo editar el archivo sin descifrarlo y guardarlo primero en el disco local?



musicbrainz picard portable (14)

¡Hoy mismo he descubierto una forma de hacer todo eso en vim!

Aquí está el enlace: instrucciones completas sobre la configuración de vim para archivos gpg

funciona como un encanto, solo en ese tutorial, el enlace al complemento es url a una página para que no lo hagamos, pero ve a la página y selecciona la que quieres descargar.

Estoy usando GNUPG para cifrar mis archivos ascii.

Aprendí a generar una clave, y también a usarla para cifrar y descifrar un archivo.

Hay dos formas que he usado:

gpg -d foo.txt.gpg

y

gpg --output foo.txt --decrypt foo.txt.gpg

Me di cuenta de que el primer método mostrará el archivo descifrado en la pantalla, por ejemplo, cuando ejecuté el comando sobre SSH.

Con respecto al segundo método, me preocupa si dejará un rastro en la PC local, el archivo foo.txt.

Lo más importante es que no sé cómo editar el contenido del archivo foo sobre la marcha. Idealmente, me gustaría abrir el archivo a través de SSH. Use nano / pico, escriba mi contraseña para descifrar, luego edite el archivo, guárdelo y cifrelo. Me gusta mucho evitar guardar los archivos en el disco local.

Cualquier comentario es bienvenido.

Gracias de antemano.

Aquí hay una ligera mejora en la respuesta de @Lucas. Hace dos pequeñas mejoras:

  • Evita el seguimiento de la pila si el archivo no se modifica durante la sesión de edición.

  • Restaura el archivo gpg original si se intentó volver a cifrar el archivo gpg original, lo cual es un poco más seguro que verificar las fechas de modificación del archivo de edición.

#!/usr/bin/python # Downloaded from https://.com/questions/1510105/gnupg-how-to-edit-the-file-without-decrypt-and-save-to-local-disk-first/12289967#12289967 # and then slightly improved. import os, sys, subprocess, getpass, stat, shutil editor = ''nano'' dataFile = sys.argv[1] ## make a backup of the encrypted file bakFile = dataFile+''-gpgedit_backup'' shutil.copy(dataFile, bakFile) dstat = os.stat(dataFile) ## create temporary directory in tmpfs to work from tmpDir = ''/dev/shm/gpgedit'' n = 0 while True: try: os.mkdir(tmpDir+str(n)) break except OSError as err: if err.errno != 17: ## file already exists raise n += 1 tmpDir += str(n) os.chmod(tmpDir, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) reEncrypted = False try: ## Get password passwd = getpass.getpass() ## decrypt file tmpFile = os.path.join(tmpDir, ''data'') cmd = "gpg -d --cipher-algo AES256 --passphrase-fd 0 --output %s %s" % (tmpFile, dataFile) proc = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE) proc.stdin.write(passwd) proc.stdin.close() if proc.wait() != 0: raise Exception("Error decrypting file.") ## record stats of tmp file stat = os.stat(tmpFile) ## invoke editor os.system(''%s %s'' % (editor, tmpFile)) ## see whether data has changed stat2 = os.stat(tmpFile) if stat.st_mtime == stat2.st_mtime and stat.st_size == stat2.st_size: print "Data unchanged; not re-writing encrypted file." else: ## re-encrypt, write back to original file reEncrypted = True cmd = "gpg --yes --symmetric --cipher-algo AES256 --passphrase-fd 0 --output %s %s" % (dataFile, tmpFile) proc = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE) proc.stdin.write(passwd) proc.stdin.close() if proc.wait() != 0: raise Exception("Error encrypting file.") except: ## If there was an error AND re-encryption was attempted, restore the backup. if reEncrypted: print "Error occurred; restoring encrypted file from backup." shutil.copy(bakFile, dataFile) raise finally: shutil.rmtree(tmpDir) os.remove(bakFile)

Hubiera publicado estas mejoras sugeridas como comentarios a la respuesta de @ Luke, lo cual me gusta mucho, pero no tenía suficientes puntos de reputación para hacerlo. :(

Detesto vi, así que tuve que hacer un poco de pegamento alrededor de nano. Esto es lo que se me ocurrió. El inconveniente es que tienes que volver a introducir la contraseña al cifrar.

alias file_ed="gpg file.txt.gpg; nano file.txt; gpg -c --force-mdc -o file.txt.gpg_temp file.txt; mv file.txt.gpg_temp file.txt.gpg; rm file.txt"

No es muy seguro desde el punto de vista del sistema de archivos, pero me temo que otros usuarios y yo, no root.

Escribí un script en Python para resolver esto (solo para Linux). Funciona descifrando el archivo en / dev / shm para garantizar que los datos no cifrados nunca se escriban en el disco (aunque es posible que cualquiera de los programas que usan los datos se intercambien en el disco; esto casi siempre es una preocupación).

Esto tiene algunos beneficios sobre algunas de las otras respuestas publicadas:

  • Solo es necesario escribir la contraseña una vez.
  • Funciona con cualquier editor

Aquí está el código:

#!/usr/bin/python import os, sys, subprocess, getpass, stat, shutil editor = ''nano'' dataFile = sys.argv[1] ## make a backup of the encrypted file bakFile = dataFile+''-gpgedit_backup'' shutil.copy(dataFile, bakFile) dstat = os.stat(dataFile) ## create temporary directory in tmpfs to work from tmpDir = ''/dev/shm/gpgedit'' n = 0 while True: try: os.mkdir(tmpDir+str(n)) break except OSError as err: if err.errno != 17: ## file already exists raise n += 1 tmpDir += str(n) os.chmod(tmpDir, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) try: ## Get password passwd = getpass.getpass() ## decrypt file tmpFile = os.path.join(tmpDir, ''data'') cmd = "gpg -d --passphrase-fd 0 --output %s %s" % (tmpFile, dataFile) proc = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE) proc.stdin.write(passwd) proc.stdin.close() if proc.wait() != 0: raise Exception("Error decrypting file.") ## record stats of tmp file stat = os.stat(tmpFile) ## invoke editor os.system(''%s %s'' % (editor, tmpFile)) ## see whether data has changed stat2 = os.stat(tmpFile) if stat.st_mtime == stat2.st_mtime and stat.st_size == stat2.st_size: raise Exception("Data unchanged; not writing encrypted file.") ## re-encrypt, write back to original file cmd = "gpg --yes --symmetric --passphrase-fd 0 --output %s %s" % (dataFile, tmpFile) proc = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE) proc.stdin.write(passwd) proc.stdin.close() if proc.wait() != 0: raise Exception("Error encrypting file.") except: ## If there was an error AND the data file was modified, restore the backup. dstat2 = os.stat(dataFile) if dstat.st_mtime != dstat2.st_mtime or dstat.st_size != dstat2.st_size: print "Error occurred, restored encrypted file from backup." shutil.copy(bakFile, dataFile) raise finally: shutil.rmtree(tmpDir) os.remove(bakFile)

Inspirado por la respuesta de Luke, yo mismo escribí un guión de Python. Con suerte, alguien encontrará esto útil. Aquí están las características principales:

  • usa un archivo temporal bajo / dev / shm usando un método seguro para generar archivos temporales
  • Crea un archivo de respaldo en caso de fallas.
  • Ambos modos de cifrado (clave pública / simétrica)
  • crear un nuevo archivo sobre la marcha
  • Elige tu editor a través de variables de entorno.

Más información se puede encontrar en el propio script. Actualmente no funcionará en ninguna máquina que no sea * nix.

Para instalar el script, simplemente póngalo en cualquier directorio de su ruta y hágalo ejecutable.

¡Consiguelo ahora!

Advertencia: Copia de seguridad de sus datos! El script viene sin ninguna garantía!

Para abrir archivos gpg, edítelos y luego ecrypt / guardar de nuevo use: el icono kgpg en la bandeja del sistema tiene la opción: Editor ... Presione, luego abra el archivo gpg, luego en la parte inferior hay un botón para descifrarlo y listo. tenga su archivo en el editor, después de realizar cualquier cambio, simplemente presione Encrypt y luego guárdelo.

También he pasado innumerables horas en esta búsqueda: simplemente cifre un archivo de texto con una frase de contraseña con un simple acceso de lectura + escritura. No quería tratar con claves privadas / públicas ni con llaveros vinculados a un inicio de sesión del sistema operativo, bla, bla, bla. El cifrado de archivos solo con frase de contraseña es tan simple, tan universal y perfecto para que un simple archivo de texto contenga contraseñas. No exagerar ni complicar una solución basada en bases de datos como KeePass, etc. (que también requiere la entrada de datos en múltiples elementos de la GUI en lugar de simplemente escribir sus contraseñas en un archivo de texto con capacidad de búsqueda). El estándar de oro en Windows es Steganos LockNote. ¿Cómo hacerlo en Linux? Sorprendentemente muy difícil de encontrar, pero ...

Finalmente me reuní con la recomendación que considero mejor: la crema. http://cream.sourceforge.net/ Cream es una fachada a la vim para que sea más fácil de usar ... útil para otros miembros de la familia (soy un geek de Linux que se siente cómodo trabajando con vi [m], pero necesitaba algo mas accesible para mi familia).

Solo ingresa:

"vim -x yourfile.txt"

Se guardará como cifrado con una frase de contraseña.

Puedes usar vim o crema en este punto:

"vim yourfile.txt" o "cream yourfile.txt".

Cualquiera de los dos abrirá "yourfile.txt" de forma nativa y solicitará la frase de contraseña, y permitirá de forma transparente las ediciones y los resguardos cifrados. FINALMENTE la búsqueda se ha completado !!!!

Una alternativa es tener un sistema de archivos tmp en RAM usando tmpfs y luego, cuando se apaga, desaparecerá para siempre.

Una cosa a tener en cuenta es que mantener los datos no cifrados en la memoria no es garantía de que no pueda acceder al disco. Si el sistema en cuestión está bajo una gran carga, cualquier dato no cifrado puede escribirse en la partición de intercambio. De manera similar, si el sistema se pone en modo de suspensión, el estado de cualquier proceso suspendido se almacenará en el disco. Si su programa se ejecuta en un sistema integrado, es posible que su memoria y su "disco" sean lo mismo.

La llamada al sistema mlock() protegerá la memoria asignada para que no se cambie al disco. Sin embargo, esto requiere privilegios administrativos y lo limita a un lenguaje de bajo nivel en el que es directamente responsable de la administración de la memoria.

Dicho esto, es prudente evitar la creación de archivos con datos no cifrados. Solo sepa que esto no le ofrece 100% de seguridad si el sistema subyacente está comprometido.

Una forma es usar vim . Vea esta página y esta pregunta relacionada.

Si necesita más flexibilidad o no desea utilizar vim , escribir un programa corto para leer el texto descifrado proveniente de STDOUT, editarlo a su gusto y luego volver a cifrarlo no es demasiado difícil. Por ejemplo, puedes usar este código de Python mínimo (¡104 líneas!) Para darte el editor básico, y luego agregar la función de lectura y escritura de la secuencia.

Usando el editor joe (también conocido como Joe''s Own Editor ) en un comando similar a

gpg --decrypt foo.txt.gpg | joe - | gpg --armor --recipient [email protected] --encrypt > bar.txt.gpg

Hará lo que estés buscando.

El - in joe - le dice a joe que tome su entrada de stdin y que escriba su salida en stdout cuando guarde el archivo ( presione ctrl + ky luego x para guardar). Joe inicialmente mostrará algunos resultados crufty de gpg; esto se puede eliminar presionando ctrl + r para actualizar la pantalla.

Utilizo > bar.txt.gpg para especificar el archivo de salida en lugar de --output bar.txt.gpg porque el indicador --output hace que gpg abra un diálogo interactivo si está sobrescribiendo el archivo de salida, y esto confunde a joe.

viencrypt by Paul Tarjan es un script para editar archivos encriptados GPG sobre la marcha.