So verschlüsseln Sie eine große Datei in openssl mit dem öffentlichen Schlüssel

Wie kann ich eine große Datei mit einem öffentlichen Schlüssel verschlüsseln, damit niemand außer dem, der über den privaten Schlüssel verfügt, diese entschlüsseln kann?

Ich kann öffentliche und private RSA-Schlüssel erstellen, aber wenn es darum geht, eine große Datei mit diesem Befehl zu verschlüsseln:

openssl rsautl -encrypt -pubin -inkey public.pem -in myLargeFile.xml -out myLargeFile_encrypted.xml

und wie kann ich die entschlüsselung auch durchführen ....

Ich erstelle meinen privaten und öffentlichen Schlüssel mit den folgenden Befehlen

openssl genrsa -out private.pem 1024
openssl rsa -in private.pem -out public.pem -outform PEM -pubout

Ich erhalte diesen Fehler:

RSA operation error
3020:error:0406D06E:rsa routines:RSA_padding_add_PKCS1_type_2:data too large for key size:.\crypto\rsa\rsa_pk1.c:151:

Ich habe versucht, Schlüssel mit Größen von 1024 bis 1200 Bit herzustellen, kein Glück, der gleiche Fehler

Krypto mit öffentlichem Schlüssel dient nicht zum Verschlüsseln beliebig langer Dateien. Man verwendet eine symmetrische Verschlüsselung (sagen wir AES), um die normale Verschlüsselung durchzuführen. Jedes Mal, wenn ein neuer zufälliger symmetrischer Schlüssel generiert, verwendet und dann mit der RSA-Verschlüsselung (öffentlicher Schlüssel) verschlüsselt wird. Der Chiffretext wird zusammen mit dem verschlüsselten symmetrischen Schlüssel an den Empfänger übertragen. Der Empfänger entschlüsselt den symmetrischen Schlüssel mit seinem privaten Schlüssel und entschlüsselt die Nachricht dann mit dem symmetrischen Schlüssel.

Der private Schlüssel wird niemals freigegeben, nur der öffentliche Schlüssel wird zum Verschlüsseln der zufälligen symmetrischen Verschlüsselung verwendet.

Lösung für die sichere und hochsichere Codierung aller Dateien in OpenSSL und in der Befehlszeile:

Sie sollten ein X.509-Zertifikat zum Verschlüsseln von Dateien im PEM-Format bereit haben.

Datei verschlüsseln:

openssl smime -encrypt -binary -aes-256-cbc -in plainfile.zip -out encrypted.zip.enc -outform DER yourSslCertificate.pem

Was ist was:

• Befehl smime - ssl für das Dienstprogramm S / MIME ( smime (1) )
• -encrypt - gewählte Methode für den Dateiprozess
• -binary - Verwenden Sie den sicheren Dateiprozess . Normalerweise wird die Eingabenachricht gemäß der S / MIME-Spezifikation in das "kanonische" Format konvertiert. Dieser Schalter deaktiviert sie. Es ist für alle Binärdateien (wie Bilder, Sounds, ZIP-Archive) erforderlich.
• -aes-256-cbc - ausgewählte Verschlüsselung AES in 256 Bit für die Verschlüsselung (stark). Wenn nicht angegeben, wird 40-Bit-RC2 verwendet (sehr schwach). ( Unterstützte Chiffren )
• -in plainfile.zip - Name der Eingabedatei
• -out encrypted.zip.enc - Name der Ausgabedatei
• -outform DER - Codiert die Ausgabedatei als binär. Wenn nicht angegeben, wird die Datei von base64 codiert und die Dateigröße um 30% erhöht.
• yourSslCertificate.pem - Dateiname Ihres Zertifikats. Das sollte im PEM-Format sein.

Dieser Befehl kann sehr effektiv große Dateien unabhängig von ihrem Format stark verschlüsseln.
Bekanntes Problem: Beim Versuch, eine große Datei (> 600 MB) zu verschlüsseln, tritt ein Fehler auf. Es wird kein Fehler ausgegeben, aber die verschlüsselte Datei wird beschädigt. Überprüfen Sie immer jede Datei! (oder verwenden Sie PGP - das unterstützt die Dateiverschlüsselung mit öffentlichem Schlüssel besser)

Datei entschlüsseln:

openssl smime -decrypt -binary -in encrypted.zip.enc -inform DER -out decrypted.zip -inkey private.key -passin pass:your_password

Was ist was:

• -inform DER - wie -outform oben
• -inkey private.key - Dateiname Ihres privaten Schlüssels. Das sollte im PEM-Format sein und kann mit einem Passwort verschlüsselt werden.
• -passin pass: your_password - Ihr Passwort für die Verschlüsselung mit privatem Schlüssel. ( Passphrasenargumente )

Sie können eine große Datei nicht direkt mit verschlüsseln rsautl. Gehen Sie stattdessen wie folgt vor:

1. Generieren Sie einen Schlüssel mit openssl randz.openssl rand 32 -out keyfile
2. Verschlüsseln Sie die Schlüsseldatei mit openssl rsautl
3. Verschlüsseln Sie die Daten mit openssl encdem generierten Schlüssel aus Schritt 1.
4. Packen Sie die verschlüsselte Schlüsseldatei mit den verschlüsselten Daten. Der Empfänger muss den Schlüssel mit seinem privaten Schlüssel entschlüsseln und dann die Daten mit dem resultierenden Schlüssel entschlüsseln.

Ich fand die Anweisungen unter http://www.czeskis.com/random/openssl-encrypt-file.html nützlich.

So paraphrasieren Sie die verknüpfte Site mit Dateinamen aus Ihrem Beispiel:

Generieren Sie einen symmetrischen Schlüssel, da Sie damit große Dateien verschlüsseln können

openssl rand -base64 32 > key.bin

Verschlüsseln Sie die große Datei mit dem symmetrischen Schlüssel

openssl enc -aes-256-cbc -salt -in myLargeFile.xml \
  -out myLargeFile.xml.enc -pass file:./key.bin

Verschlüsseln Sie den symmetrischen Schlüssel, damit Sie ihn sicher an die andere Person senden können

openssl rsautl -encrypt -inkey public.pem -pubin -in key.bin -out key.bin.enc

Zerstören Sie den unverschlüsselten symmetrischen Schlüssel, damit niemand ihn findet

shred -u key.bin

Zu diesem Zeitpunkt senden Sie den verschlüsselten symmetrischen Schlüssel ( key.bin.enc) und die verschlüsselte große Datei ( myLargeFile.xml.enc) an die andere Person

Die andere Person kann dann den symmetrischen Schlüssel mit ihrem privaten Schlüssel mit entschlüsseln

openssl rsautl -decrypt -inkey private.pem -in key.bin.enc -out key.bin

Jetzt können sie den symmetrischen Schlüssel verwenden, um die Datei zu entschlüsseln

openssl enc -d -aes-256-cbc -in myLargeFile.xml.enc \
  -out myLargeFile.xml -pass file:./key.bin

Und du bist fertig. Die andere Person hat die entschlüsselte Datei und sie wurde sicher gesendet.

Das Verschlüsseln einer sehr großen Datei mit smime wird nicht empfohlen, da Sie möglicherweise große Dateien mit der Option -stream verschlüsseln können, die resultierende Datei jedoch aufgrund von Hardwareeinschränkungen nicht entschlüsseln können. Siehe: Problem beim Entschlüsseln großer Dateien

Wie oben erwähnt, dient die Krypto mit öffentlichem Schlüssel nicht zum Verschlüsseln beliebig langer Dateien. Daher generieren die folgenden Befehle eine Passphrase, verschlüsseln die Datei mit symmetrischer Verschlüsselung und verschlüsseln die Passphrase dann mit dem asymmetrischen (öffentlichen Schlüssel). Hinweis: Der Smime umfasst die Verwendung eines öffentlichen Primärschlüssels und eines Sicherungsschlüssels zum Verschlüsseln der Passphrase. Ein öffentliches / privates Backup-Schlüsselpaar wäre umsichtig.

Zufällige Passwortgenerierung

Richten Sie den RANDFILE-Wert für eine Datei ein, auf die der aktuelle Benutzer zugreifen kann, generieren Sie die Datei passwd.txt und bereinigen Sie die Einstellungen

export OLD_RANDFILE=$RANDFILE
RANDFILE=~/rand1
openssl rand -base64 2048 > passwd.txt
rm ~/rand1
export RANDFILE=$OLD_RANDFILE

Verschlüsselung

Verwenden Sie die folgenden Befehle, um die Datei mit dem Inhalt von passwd.txt als Kennwort und AES256 in eine base64-Datei (-a Option) zu verschlüsseln. Verschlüsseln Sie die Datei passwd.txt mit asymetrischer Verschlüsselung in die Datei XXLarge.crypt.pass mit einem öffentlichen Primärschlüssel und einem Sicherungsschlüssel.

openssl enc -aes-256-cbc -a -salt -in XXLarge.data -out XXLarge.crypt -pass file:passwd.txt
openssl smime -encrypt -binary -in passwd.txt -out XXLarge.crypt.pass -aes256 PublicKey1.pem PublicBackupKey.pem
rm passwd.txt

Entschlüsselung

Die Entschlüsselung entschlüsselt einfach den XXLarge.crypt.pass in passwd.tmp, entschlüsselt den XXLarge.crypt in XXLarge2.data und löscht die passwd.tmp-Datei.

openssl smime -decrypt -binary -in XXLarge.crypt.pass -out passwd.tmp -aes256 -recip PublicKey1.pem -inkey PublicKey1.key
openssl enc -d -aes-256-cbc -a -in XXLarge.crypt -out XXLarge2.data -pass file:passwd.tmp
rm passwd.tmp

Dies wurde gegen> 5 GB Dateien getestet.

5365295400 Nov 17 10:07 XXLarge.data
7265504220 Nov 17 10:03 XXLarge.crypt
      5673 Nov 17 10:03 XXLarge.crypt.pass
5365295400 Nov 17 10:07 XXLarge2.data

Um große Dateien (> 600 MB) sicher mit zu verschlüsseln, müssen openssl smimeSie jede Datei in kleine Teile aufteilen:

# Splits large file into 500MB pieces
split -b 500M -d -a 4 INPUT_FILE_NAME input.part.

# Encrypts each piece
find -maxdepth 1 -type f -name 'input.part.*' | sort | xargs -I % openssl smime -encrypt -binary -aes-256-cbc -in % -out %.enc -outform DER PUBLIC_PEM_FILE

Zur Information, hier ist, wie man alle Teile entschlüsselt und zusammenfügt:

# Decrypts each piece
find -maxdepth 1 -type f -name 'input.part.*.enc' | sort | xargs -I % openssl smime -decrypt -in % -binary -inform DEM -inkey PRIVATE_PEM_FILE -out %.dec

# Puts all together again
find -maxdepth 1 -type f -name 'input.part.*.dec' | sort | xargs cat > RESTORED_FILE_NAME

In mehr Erklärung für n. 'pronouns' m.die Antwort,

Krypto mit öffentlichem Schlüssel dient nicht zum Verschlüsseln beliebig langer Dateien. Man verwendet eine symmetrische Verschlüsselung (sagen wir AES), um die normale Verschlüsselung durchzuführen. Jedes Mal, wenn ein neuer zufälliger symmetrischer Schlüssel generiert, verwendet und dann mit der RSA-Verschlüsselung (öffentlicher Schlüssel) verschlüsselt wird. Der Chiffretext wird zusammen mit dem verschlüsselten symmetrischen Schlüssel an den Empfänger übertragen. Der Empfänger entschlüsselt den symmetrischen Schlüssel mit seinem privaten Schlüssel und entschlüsselt die Nachricht dann mit dem symmetrischen Schlüssel.

Es gibt den Fluss der Verschlüsselung :

+---------------------+      +--------------------+
|                     |      |                    |
| generate random key |      |   the large file   |
|        (R)          |      |        (F)         |
|                     |      |                    |
+--------+--------+---+      +----------+---------+
         |        |                     |
         |        +------------------+  |
         |                           |  |
         v                           v  v
+--------+------------+     +--------+--+------------+
|                     |     |                        |
| encrypt (R) with    |     | encrypt (F)            |
| your RSA public key |     | with symmetric key (R) |
|                     |     |                        |
|  ASym(PublicKey, R) |     |     EF = Sym(F, R)     |
|                     |     |                        |
+----------+----------+     +------------+-----------+
           |                             |
           +------------+ +--------------+
                        | |
                        v v
         +--------------+-+---------------+
         |                                |
         |   send this files to the peer  |
         |                                |
         |     ASym(PublicKey, R) + EF    |
         |                                |
         +--------------------------------+

Und der Fluss der Entschlüsselung :

   +----------------+        +--------------------+
   |                |        |                    |
   | EF = Sym(F, R) |        | ASym(PublicKey, R) |
   |                |        |                    |
   +-----+----------+        +---------+----------+
         |                             |
         |                             |
         |                             v
         |   +-------------------------+-----------------+
         |   |                                           |
         |   |             restore key (R)               |
         |   |                                           |
         |   | R <= ASym(PrivateKey, ASym(PublicKey, R)) |
         |   |                                           |
         |   +---------------------+---------------------+
         |                         |
         v                         v
     +---+-------------------------+---+
     |                                 |
     |       restore the file (F)      |
     |                                 |
     |      F <= Sym(Sym(F, R), R)     |
     |                                 |
     +---------------------------------+

Außerdem können Sie diese Befehle verwenden:

# generate random symmetric key
openssl rand -base64 32 > /config/key.bin

# encryption
openssl rsautl -encrypt -pubin -inkey /config/public_key.pem -in /config/key.bin -out /config/key.bin.enc
openssl aes-256-cbc -a -pbkdf2 -salt -in  $file_name -out $file_name.enc -k $(cat /config/key.bin)

# now you can send this files: $file_name.enc + /config/key.bin.enc

# decryption
openssl rsautl -decrypt -inkey /config/private_key.pem -in /config/key.bin.enc -out /config/key.bin
openssl aes-256-cbc -d -a -in $file_name.enc -out $file_name -k $(cat /config/key.bin)

Vielleicht sollten Sie die akzeptierte Antwort auf diese Frage ( Wie verschlüssele ich Daten in PHP mit öffentlichen / privaten Schlüsseln? ) Überprüfen .

Anstatt die Beschränkung der Nachrichtengröße (oder möglicherweise ein Merkmal) von RSA manuell zu umgehen, wird gezeigt, wie Sie die S / MIME-Funktion von OpenSSL verwenden, um dasselbe zu tun, ohne manuell mit dem symmetrischen Schlüssel jonglieren zu müssen.