Zum Inhalt

verschlüsselt

ormar bietet Ihnen eine Möglichkeit, nur Felder in einer Datenbank zu verschlüsseln, und bietet ein verschlüsseltes Backend, das sowohl Einwegverschlüsselung (HASH-Back-End) als auch Zwei-Wege-Verschlüsselung/Entschlüsselung (FERNET-Back-End) ermöglicht.

!!!Warnung Beachten Sie, dass Sie, damit die Verschlüsselung funktioniert, ein optionales Verschlüsselungspaket installieren müssen.

1
Sie können es manuell mit `pip install cryptography` oder mit ormar von `pip install ormar[crypto]` tun

Achtung: Durch Hinzufügen von encrypt_backend wird der Spaltentyp der Datenbank in TEXT geändert, der sich entweder durch Migration (alembic) oder manuelle Änderung in db widerspiegeln muss.

Definitionssache verschlüsselt

Zum Verschlüsseln eines Felds müssen Sie mindestens die Parameter encrypt_secret und encrypt_backend übergeben.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle (
    Metathek = Metathek
    Datengrundlage = Datenbank
)

Klassenfilter (ormar. Modell):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von Ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    name: str = ormar. String (max_length = 100, oder
                             encrypt_secret ="secret123"-Nachricht schreiben
                             encrypt_backend = ormar. EncryptBackends. FERNET (EncryptBackend = ormar. EncryptBackends. FERNET)

!!!warnt Sie, dass Sie alle Feldtypen außer den Spalten primary_key und off (ForeignKey und ManyToMany) verschlüsseln können, um Backend-Details für weitere Informationen zu überprüfen.

Verfügbare Backbone

Haschisch

Ein Hash ist ein Einweg-Hash (wie ein Passwort), der beim Abrufen niemals entschlüsselt wird

Um es einzurichten, übergeben Sie den entsprechenden Backend-Wert.

1
2
3
4
#Rest der Modelldefinition
Zeichenfolge (max_length = 128,
                         encrypt_secret ="secret123"-Nachricht schreiben
                         encrypt_backend = ormar. EncryptBackends. HASH (Encrypt-Backend = ormar. EncryptBackends. HASH)

Beachten Sie , dass dieses Backend die gespeicherten Werte niemals entschlüsselt , es funktioniert nur für Zeichenfolgenfelder , die einen SHA512 - Hash verwenden und daher eine Feldlänge von > = 128 haben müssen .

Beachten Sie , dass Sie im HASH-Back - End nach dem vollen Wert filtern können , aber Filter wie contains funktionieren aufgrund des Vergleichs verschlüsselter Werte nicht .

!!!Beachten Sie, dass das mitgelieferte encrypt_secret zuerst selbst gehasht und als Salz verwendet wird, sodass Sie zum Vergleich mit der gespeicherten Zeichenfolge diesen Schritt neu erstellen müssen order_by funktioniert nicht, da Sie verschlüsselte Zeichenfolgen vergleichen und daher nicht zuverlässig sortieren können.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Klasse Hash (ormar . Model) :
    ormar _ config = base _ ormar _ config . copy (tablename = " hashes ") Bearbeiten

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    name : str = ormar . String (max _ length = 128 , Zeichenfolge)
                             encrypt _ secret = " udxc32 " , oder
                             encrypt _ backend = ormar . EncryptBackends . HASH (Encrypt-Backend = ormar . EncryptBackends . HASH)


await Hash (name ='test1') . save () () ist ein

Schritte , um den gespeicherten Wert wiederherzustellen
# Sie können auch das Cryptography Package verwenden , das in Hashlib enthalten ist
secret = hashlib.sha256 (" udxc32 " . encode ()) . digest ()
secret = base64.urlsafe_b64encode (vertraulich)
hashed_test1 = hashlib.sha512 (secret + ' test1'. encode ()) . hexdigest ()

Full Value Comparison Works Bearbeiten
hash1 = await Hash . objects . get (name ='test1 ') (hash1 = await Hash . objects . get (name ='test1 ')) (ist ein
Assert hinzufügenhash1.name= = hashed_test1 = = hashed_test1 und Test1

Aber partielle Vergleiche sind nicht möglich (hashed Strings are compared) .
mit Pytest . raises (NoMatch) :
    await Filter . objects . get (name _ _ icontains ='test') (nur auf Englisch)

Fennett .

FERNET ist ein Zwei-Wege - Verschlüsselungs -/Entschlüsselungs-Backend

Um es einzurichten , übergeben Sie den entsprechenden Backend-Wert .

1
2
3
# Rest der Modelldefinition
Jahr: int = ormar. Integer (encrypt_secret ="secret123",
                          encrypt_backend = ormar. EncryptBackends. FERNET (EncryptBackend = ormar. EncryptBackends. FERNET)

Der Wert wird auf dem Weg zum Ende der Datenbank verschlüsselt und beim Ausgehen entschlüsselt und kann für alle Typen verwendet werden, da der Rückgabewert in den entsprechenden Python-Typ aufgelöst wird.

Achtung: Im FERNET-Backend verlieren Sie die Möglichkeit der Filterung vollständig, da ein Teil des verschlüsselten Werts ein Zeitstempel ist order_by und da verschlüsselte Zeichenfolgen verglichen werden, können Sie nicht zuverlässig sortieren.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
Klassenfilter (ormar. Modell):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von Ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    name: str = ormar. String (max_length = 100, oder
                             encrypt_secret ="asd123"-Nachricht schreiben
                             encrypt_backend = ormar. EncryptBackends. FERNET (EncryptBackend = ormar. EncryptBackends. FERNET)

await Filter (name ='test1'). save ()() ist ein
await Filter (name ='test1'). save ()() ist ein

Die Werte sind properly verschlüsselt und später decrypted
Filters = Filter, Objekte, alle ()
[1][1] [2][1] [2][3] [4][4] [5][6] [6][8] [8][9] [9][10] [11][12]

#Aber Sie können nicht filtern, da der Teil des Ferrit-Hash ein Zeitstempel ist
Welche Bedeutung hat, dass sogar wenn Sie den gleichen String 2mal verschlüsseln, wird es anders sein
mit Pytest. raises (NoMatch):
    await Filter. objects. get (name ='test1 ')(Name des Objekts ist Test1)

Selbstdefiniertes Backend

Wenn Sie eine andere Art der Verschlüsselung unterstützen möchten (z. B. AES), können Sie Ihr eigenes EncryptionBackend bereitstellen.

Um ein Backend einzurichten, müssen Sie lediglich die ormar. fields. EncryptBackend-Klasse untergliedern und das gewünschte Backend bereitstellen.

Ein Beispiel für ein virtuelles Back-End (ohne etwas zu tun) könnte wie folgt aussehen:

1
2
3
4
5
6
7
8
9
class DummyBackend (ormar. fields. EncryptBackend):
    def_initialize_backend (self, secret_key: bytes)-> None:
        Durchreise

    def encrypt (self, value: Any)-> str:
        return wert zurück

    def decrypt (self, value: Any)-> str: decrypt (selbst, Wert: Any)-> str:
        Rückgabewert

Um dieses Backend zu verwenden, legen Sie encrypt_backend auf CUSTOM fest und geben Sie Ihr Backend als Argument über encrypt_custom_backend an.

1
2
3
4
5
6
7
8
9
Klassenfilter (ormar. Modell):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    name: str = ormar. String (max_length = 100, oder
                             encrypt_secret ="secret123"-Nachricht schreiben
                             encrypt_backend = ormar. EncryptBackends. CUSTOM, oder
                             encrypt_custom_backend ="DummyBackend"("Zurücksetzen")
                             )