Verschlüsselungsprogramm

[__blackjack__]

@Fire Spike: Nein, Du willst keine Bytes anhängen, Du willst eine *neue* Datei erstellen.

Blockverschlüsselung macht Fernet bereits. Und das ist halt nicht für grosse Dateien gedacht, sondern für kleine bis mittelgrosse Nachrichten. Die als Text übermittelt/gespeichert werden sollen.

[Fire Spike]

wie kann ich dann bytes anhängen?
wie kann ich denn dateien verschlüsseln die ein paar hundert mb bis 1gb gross sind?

[Sirius3]

Indem Du das, was Fenet macht, selbst nachprogrammierst.

[Fire Spike]

Nur so eine Frage: könntest du das? Wenn nein muss ich es gar nicht versuchen.

[Sirius3]

Die `encode` bzw. `decode`-Funktion von Fernet sind mit ihren Unterfunktionen nur eine Handvoll aufrufe anderer Crypto-Funktionen. Wenn Du verstehst, was diese Crypto-Funktionen machen, ist es kein großer Aufwand, das als Stream-Version nachzuprogrammieren.

[Fire Spike]

kannst du mir bitte sagen welche funktionen ich bearbeiten muss?

[__blackjack__]

@Fire Spike: Du willst keine Bytes anhängen. Das macht keinen Sinn.

[Fire Spike]

@__blackjack__: das problem ist behoben weil ich jetzt in anderes problem habe.

kannst du mir bitte sagen welche funktionen ich bearbeiten muss?

[__blackjack__]

@Fire Spike: Du hast den Dateimodus jetzt also geändert?

Für das andere Problem musst Du Dir halt anschauen was die Methoden von der `Fernet`-Klasse machen.

[Fire Spike]

@Fire Spike: Du hast den Dateimodus jetzt also geändert?

ja, auf r+b

[Sirius3]

Was auch der falsche Modus ist.

[Fire Spike]

was ist denn richtig?

[__blackjack__]

@Fire Spike: Der zu schreiben einer *neuen Datei*.

[Fire Spike]

ist ab+ richtig?
Ich sehe in fernet das der text mit AES und der blockgösse 128 bit/byte verschlüsselt wird.
jetzt müsste ich eigentlich anstatt return yield nehmen und eine for schleife drüber laufen lassen oder?

[__blackjack__]

@Fire Spike: Nein, "ab+" ist auch nicht richtig. Irgendetwas mit "+" ist fast nie richtig.

[Fire Spike]

was ist denn richtig und wie findest du meine Idee?

[Sirius3]

Da die darunterliegenden Krypto-Klassen schon Streaming unterstützen, ist es auch kein großes Problem, Fernet dahingehend umzuschreiben:

Code: Alles auswählen

from __future__ import absolute_import, division, print_function

import base64
import binascii
import os
import struct
import time

import six

from cryptography import utils
from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes, padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives.hmac import HMAC

_MAX_CLOCK_SKEW = 20

class InvalidToken(Exception):
    pass

class _FernetEncryptor(object):
    def __init__(self, signing_key, encryption_key, backend):
        self.initialized = False
        self.iv = os.urandom(16)
        self.padder = padding.PKCS7(algorithms.AES.block_size).padder()
        self.encryptor = Cipher(
            algorithms.AES(encryption_key), modes.CBC(self.iv), backend
        ).encryptor()
        self.hmac = HMAC(signing_key, hashes.SHA256(), backend=backend)

    def update(self, data):
        utils._check_bytes("data", data)
        padded_data = self.padder.update(data)
        ciphertext = self.encryptor.update(padded_data)
        if not self.initialized:
            self.initialized = True
            current_time = int(time.time())
            ciphertext = (
                b"\x80" + struct.pack(">Q", current_time) +
                self.iv + ciphertext
            )
        self.hmac.update(ciphertext)
        return ciphertext

    def finalize(self):
        padded_data = self.padder.finalize()
        ciphertext = self.encryptor.update(padded_data)
        ciphertext += self.encryptor.finalize()
        self.hmac.update(ciphertext)
        hmac = self.hmac.finalize()
        return ciphertext + hmac


class _FernetDecryptor(object):
    def __init__(self, ttl, signing_key, encryption_key, backend):
        self.ttl = ttl
        self._encryption_key = encryption_key
        self._backend = backend
        self.initalized = False
        self.unprocessed_data = b""
        self.hmac = HMAC(signing_key, hashes.SHA256(), backend=backend)
        self.unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
        self.decryptor = None
        self.timestamp = None

    def _initialize(self):
        version, timestamp = struct.unpack_from(">BQ", self.unprocessed_data, 0)
        if version != 0x80:
            raise InvalidToken
        if self.ttl is not None:
            current_time = int(time.time())
            if timestamp + ttl < current_time:
                raise InvalidToken
            if current_time + _MAX_CLOCK_SKEW < timestamp:
                raise InvalidToken
        self.timestamp = timestamp
        self.initalized = True
        iv = self.unprocessed_data[9:25]
        self.decryptor = Cipher(
            algorithms.AES(self._encryption_key), modes.CBC(iv), self._backend
        ).decryptor()
        self.hmac.update(self.unprocessed_data[:25])
        self.unprocessed_data = self.unprocessed_data[25:]

    def update(self, data):
        utils._check_bytes("data", data)
        self.unprocessed_data += data
        if not self.initalized:
            if len(self.unprocessed_data) < 25:
                return b""
            self._initialize()
        ciphertext = self.unprocessed_data[:-32]
        self.unprocessed_data = self.unprocessed_data[-32:]
        self.hmac.update(ciphertext)
        plaintext_padded = self.decryptor.update(ciphertext)
        return self.unpadder.update(plaintext_padded)

    def finalize(self):
        try:
            self.hmac.verify(self.unprocessed_data)
        except InvalidSignature:
            raise InvalidToken
        try:
            plaintext_padded = self.decryptor.finalize()
            unpadded = self.unpadder.update(plaintext_padded)
            unpadded += self.unpadder.finalize()
        except ValueError:
            raise InvalidToken
        return unpadded

class FernetStream(object):
    def __init__(self, key, backend=None):
        if backend is None:
            backend = default_backend()
        key = base64.urlsafe_b64decode(key)
        if len(key) != 32:
            raise ValueError(
                "Fernet key must be 32 url-safe base64-encoded bytes."
            )
        self._signing_key = key[:16]
        self._encryption_key = key[16:]
        self._backend = backend

    @classmethod
    def generate_key(cls):
        return base64.urlsafe_b64encode(os.urandom(32))

    def encryptor(self):
        return _FernetEncryptor(self._signing_key,
            self._encryption_key, self._backend)

    def decryptor(self, ttl=None):
        return _FernetDecryptor(ttl, self._signing_key,
            self._encryption_key, self._backend)

[Fire Spike]

Danke für deine Mühe Sirius3
und wie wende ich das jetzt an?
muss ich jetzt die Fernet stream klassse verwenden?

[Sirius3]

So wie Du andere Verschlüssler auch anwendest. https://cryptography.io/en/latest/hazma ... ncryption/

[Fire Spike]

Ok, was hast denn du genau verändert?