web-dev-qa-db-fra.com

Comment utiliser les fichiers * .pub/*. Sec pour chiffrer/déchiffrer un autre fichier?

J'ai créé une paire de fichiers *.pub et *.sec en utilisant les instructions et le code donnés ici:

https://www.gnupg.org/documentation/manuals/gnupg/Unattended-GPG-key-generation.html

(J'utilise cette documentation parce que l'application ultime que j'ai en Mind est un pipeline de cryptage/décryptage automatisé.)

Q1: Comment utiliser gpg2 et le fichier *.pub pour chiffrer un autre fichier?

Q2: Comment utiliser gpg2 et le *.sec associé pour déchiffrer un fichier crypté à l'aide du fichier *.pub associé?

Important: _ ​​Je ne m'intéresse qu'aux réponses qui conviennent à la mise en œuvre programmatique d'une opération non supervisée. Merci de ne pas publier de réponses qui ne peuvent être effectuées que de manière interactive. solutions pouvant être implémentées en Python.

Veuillez inclure des indications précises sur la documentation correspondante.

gnupg
4
kjo

Quelques informations sur ce que vous avez dit:

J'ai créé une paire de fichiers * .pub et * .sec en suivant les instructions

Parfait pour partager la (les) clé (s) publique (s) avec des personnes avec lesquelles vous échangez des informations, mais techniquement, lorsque vous travaillez par programmation, vous n'avez pas besoin d'utiliser ces fichiers directement.

A noter:

  • lorsque vous chiffrez des données, vous spécifierez le destinataire correspondant à la clé à utiliser pour chiffrer
  • lorsque vous décryptez des données, vous importerez d'abord la clé publique du propriétaire, puis vous pourrez décrypter des données sans spécifier de destinataire, car elles sont incorporées aux données cryptées.

En fait, je suis un peu confus sur cette question. J'ai lu des informations contradictoires [...]

Je suis d'accord, c'est assez déroutant. Dans cette situation, je pense qu'il est préférable d'utiliser la version 1 pour laquelle vous avez plus d'expérience et pour laquelle vous trouvez une bibliothèque tierce à utiliser.

Dans cette réponse, j'ai essayé:

  • python-gnupg (pour GnuPG v1) qui est une bibliothèque Python bien connue et qui répond parfaitement à vos besoins
  • cryptorito (pour GnuPG v2) pour lequel je n'ai pas trouvé suffisamment de documentation

Avec la première bibliothèque, vous pouvez simplement l'installer sur votre système:

Sudo pip install python-gnupg

Et écrivez ensuite un script Python pour effectuer toutes les opérations souhaitées.

J'ai écrit un simple pour répondre à votre question.

#!/bin/python

import gnupg

GPG_DIR='/home/bsquare/.gnupg'
FILE_TO_ENCRYPT='/tmp/myFileToEncrypt'
ENCRYPTED_FILE='/tmp/encryptedFile'
DECRYPTED_FILE='/tmp/decryptedFile'
SENDER_USER='Bsquare'
TARGET_USER='Kjo'

gpg = gnupg.GPG(gnupghome=GPG_DIR)

print("Listing keys ...")
print(gpg.list_keys())

# On SENDER_USER side ... encrypt the file for TARGET_USER, with his public key (would match the kjo.pub if the key was exported).
print("Encrypting file " + FILE_TO_ENCRYPT + " for " + TARGET_USER + " ...")
with open(FILE_TO_ENCRYPT, "rb") as sourceFile:
    encrypted_ascii_data = gpg.encrypt_file(sourceFile, TARGET_USER)
    # print(encrypted_ascii_data)
    with open(ENCRYPTED_FILE, "w+") as targetFile:
        print("encrypted_ascii_data", targetFile)


# On TARGET_USER side ... decrypt the file with his private key (would match the kjo.sec if the key was exported).
print("Decrypting file " + ENCRYPTED_FILE + " for " + TARGET_USER + " ...")
with open(ENCRYPTED_FILE, "rb") as sourceFile:
    decrypted_ascii_data = gpg.decrypt_file(sourceFile)
    # print(decrypted_ascii_data)
    with open(DECRYPTED_FILE, "w+") as targetFile:
        print(decrypted_ascii_data, targetFile)

À noter que mon trousseau contient la paire pub/s pour mon utilisateur Bsquare et la clé pub de Kjo utilisateur.

5
Bsquare ℬℬ

en regardant chiffrer et déchiffrer des documents

cela suggère pexpect ; alors que je peux fournir des scripts expect réguliers:

ce n'est pas directement une solution Python, mais il devrait être facile à porter.

comme le slogan se lit comme suit:

Pexpect fait de Python un meilleur outil pour contrôler d’autres applications.

Cryptage:

gpg --output doc.gpg --encrypt --recipient [email protected] doc

comme script expect; utilisation ./encrypt.exp doc [email protected] 1234 (notez l'espace après le :):

#!/usr/bin/expect -f
set filename [lindex $argv 0]
set recipient [lindex $argv 1]
set passphrase [lindex $argv 2]

spawn gpg --output $filename.gpg --encrypt --recipient $recipient $filename
expect -exact "Enter pass phrase: "
send -- "$passphrase\r"
expect eof

Décryptage:

gpg --output doc --decrypt doc.gpg

comme script expect; utilisation: ./decrypt.exp doc 1234:

#!/usr/bin/expect -f
set filename [lindex $argv 0]
set passphrase [lindex $argv 1]

spawn gpg --output $filename --decrypt $filename.gpg
expect -exact "Enter pass phrase: "
send -- "$passphrase\r"
expect eof

Importer:

les clés peuvent être importées dans l'une ou l'autre des chaînes avec:

gpg --import somekey.sec
gpg --list-secret-keys

gpg --import somekey.pub
gpg --list-keys

il n'y a presque rien à automatiser; Cependant, définir une clé importée comme "approuvée" nécessiterait expect pour être automatisé. trouvé ce cheat-sheet , qui contient toutes les commandes sur une page; et il fait aussi allusion à: If you have multiple secret keys, it'll choose the correct one, or output an error if the correct one doesn't exist (qui devrait confirmer mon commentaire ci-dessous).

fichier ~/.gnupg/options est le fichier options d'un utilisateur ; où on peut par exemple. définir le serveur de clés par défaut.

1
Martin Zeitler

Depuis la version 2.1.14 , GPG prend en charge l’option --recipient-file, qui vous permet de spécifier la clé publique avec laquelle chiffrer sans utiliser le trousseau de clés. Pour citer le développeur :

Il est maintenant possible de contourner le trousseau de clés et de prendre la clé publique directement à partir d'un fichier. Ce fichier peut être un binaire ou un blindé ascii key et seul le premier keyblock de ce fichier est utilisé. Une clé spécifié avec cette option est toujours totalement fiable.

Cette option peut être mélangée avec les options standard -r . --hidden-recipient-file (ou -F) est également disponible.

Pour assister davantage certains cas d'utilisation, l'option

--no-trousseau

a également été mis en œuvre. Ceci est similaire à

--no-default-keyring --keyring/dev/null

mais portable vers Windows et ignore également tout trousseau spécifié (ligne de commande ou fichier de configuration).

Donc, pour chiffrer, vous feriez:

gpg --output myfileenc --encrypt --recipient-file key.pub myfile

Pour automatiser, en plus d'utiliser expect ou Python comme expliqué dans les autres réponses, vous pouvez également utiliser l'option --batch . (Vous aurez besoin de voir laquelle des réponses proposées fonctionne le mieux sur votre système).

Cependant, aucune option de ce type n'est disponible pour la clé secrète et, en fait, la même version de PGP (2.1) a déconseillé d'utiliser l'option secring dans la commande --generate-key. Ce fichier n'est donc même plus disponible. plus. La clé générée devra être ajoutée au trousseau de clés pour être utilisée pour le déchiffrement.

0
mnistic