Discussion :

[rabeh.ram]

Est-il possible de protéger par mot de passe une base de données en utilisant sqlite3 avec python?

[marco056]

Bonjour.

[Sve@r]

Oui.

[tyrtamos]

Bonjour aussi.

J'ai participé à une discussion ici en 2014, et ma réponse n'a pas changée:
https://www.developpez.net/forums/d1...nees-cryptees/

Pour le cryptage: tout est possible, y compris RSA, mais ça dépend de l'importance des données (conséquences d'une divulgation?). Pour des données d'importance modérée, un cryptage "xor" devrait être suffisant.

Il reste que la base est non-cryptée pendant l'exécution du programme. A voir possibilité si la base est petite à l'utiliser décryptée uniquement en mémoire (disque virtuel?) avec précautions en cas de coupure de courant.

[wiztricks]

Salut,

Ce serait une fonctionnalité de sqlite3 (et vous pouvez fabriquer votre mouture de sqlite3 pour...) (mais cette extension n'est pas dans le sqlite3 livré avec Python).

sqlite3 est plutôt orienté base de données "embarquée".

Si on veut se protéger ce sera contre le vol du disque, du PC, ... qui contient le fichier de la base de données.

Le chiffrement du disque, le mot de passe que l'utilisateur entre lorsqu'il se connecte sont des protections "générales" disponibles.

Les SGDB plus génériques sont plus protégées "de base" et des extensions pour le chiffrement (si on veut se protéger contre les administrateurs du système qui héberge la base de données...)

- W

[rabeh.ram]

Merci à tous
J'essaierai toutes les méthodes mentionnées, mais l'utilisation du cryptage affecte-t-elle les performances de la base de données en termes de vitesse de lecture et d'écriture?

[Sve@r]

Ml'utilisation du cryptage affecte-t-elle les performances de la base de données en termes de vitesse de lecture et d'écriture?

Fatalement oui, tout calcul sur une donnée avant de l'écrire est toujours plus long qu'écrire la donnée sans la modifier.
Mais t'as pas bien pigé l'idée: l'idée n'est pas de chiffrer (c'est le terme exact) la bdd en temps réel, c'est

• la déchiffrer au début du programme, déchiffrement générant une bdd "prime" qui sera soit sur disque, soit en RAM
• travailler sur la bdd "prime" non chiffrée
• la chiffrer quand on quitte le programme (ou à intervalles fixes ou sur demande éventuellement) et effacer la bdd "prime"

Les opérations se faisant sur une bdd non chiffrée seront donc des opérations classiques, aussi rapides que les autres. C'est la phase déchiffrement du début et chiffrement final qui seront plus ou moins longues, mais faites une seule fois donc négligeables.

[rabeh.ram]

Pour rester simple est-il possible utiliser DB Browser for SQLite pour créé une mot de passe

[wiztricks]

Salut,

Pour rester simple est-il possible utiliser DB Browser for SQLite pour créé une mot de passe

Déjà avez vous recompilé sqlite3 avec les extensions qui vont bien côté utilisateur/mot de passe?

- W

[tyrtamos]

Bonjour,

Je ne connais pas DB Browser, mais il s'agit d'un éditeur de base de données sqlite comme il en existe d'autres, payants ou pas. J'utilisais beaucoup il y a quelques années "SQLite Expert pro" (http://www.sqliteexpert.com/) version payante (une centaine d'euros pour une licence), mais il existe une version gratuite plus légère. Cependant, je n'ai pas vu de fonctionnalités de cryptage.

Pour DB Browser, il y a des infos sur le cryptage des bases de données ici:
https://github.com/sqlitebrowser/sql...pted-Databases

Mais ce logiciel n'a rien à voir avec Python, et s'il fait un cryptage AES, tu auras du mal à lire ta base de données avec Python (il faudra décrypter avant et recrypter après, le tout en AES). Ce n'est cependant pas impossible, mais tu te prépares des moments difficiles...

Si tu veux rester simple, il te faudra choisir entre Python OU ce logiciel pour gérer ta base de données sqlite...


Pour la version Python, et dans la mesure où tes données ne sont pas de niveau "sécurité défense", je te propose un cryptage XOR avec clé. Il est déjà assez fort, assez difficile à décrypter, facile à coder en Python, et d'exécution rapide.

Voilà un petit code qui fait ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
"""
Cryptage xor avec clé d'un texte et d'un fichier
"""
 
###############################################################################
def cryptxortexte(btexte, bkey):
    """Cryptage xor avec clé d'un texte
       Attention: btexte et bkey doivent être de type "bytes"
                     et retourne le texte crypté de type bytes
    """
    lgkey = len(bkey)
    encoded = []
    for i in range(0, len(btexte)):
        encoded.append(btexte[i] ^ bkey[i % lgkey])
    return bytes(encoded)
 
###############################################################################
def cryptxorfichier(fichier1, fichier2, key, tbuf=8192):
    """Cryptage xor avec clé d'un fichier1 => fichier2
       fichier2 doit être différent de fichier1
       key est la clé de cryptage (type str ou bytes)
       tbuf la taille du buffer de lecture des données du fichier1
    """
    if isinstance(key, str):
        key = bytes(key, "utf-8")
    lgkey = len(key)
    tbuf2 = tbuf//lgkey*lgkey # buffer qui contient un nombre entier de key
    with open(fichier1, "rb") as fs:
        with open(fichier2, "wb") as fd:
            while True:
                buf = fs.read(tbuf2)
                if len(buf)==0:
                    break
                fd.write(cryptxortexte(buf, key))

Comme les octets font l'objet d'un xor ("ou exclusif" => opérateur '^') avec une clé qui sert de mot de passe, il sera difficile à un pirate de retrouver le message grâce à la reconnaissance d'une fréquence de lettres. Mais il ne faudra pas oublier la clé! A noter une particularité du cryptage xor: pour décrypter, on utilise la fonction de cryptage une seconde fois!

Deux petites précautions à prendre:
- Évite de coder en clair la clé dans ton code!
- Si ton programme crashe, la base de données ne sera pas cryptée. Il faudra donc qu'au lancement, ton programme puisse tester si ta base de données est cryptée ou pas, pour en déduire ce qu'il doit faire!

Si tu veux un cryptage plus fort, il existe des modules Python externes qui font ça (voir déjà pypi: https://pypi.org/).

J’espère que la protection de tes données mérite les précautions que tu veux prendre...

[meslier]

Merci Tirtamos pour l'exemple de crypyage / décryptage. Bien sûr, on ne peut pas mettre la clé en clair dans le code source. Pour la faire intervenir dans une fonction, j'ai songé à la stocker dans un fichier ou une base de données. Mais ceux-ci sont eux-mêmes susceptibles d'être violés. Plus généralement, un module python, qui est public, pour le cryptage, comment fait-il pour crypter sans livrer ses secrets ?

[wiztricks]

Plus généralement, un module python, qui est public, pour le cryptage, comment fait-il pour crypter sans livrer ses secrets ?

Une solution est le chiffrage asymétrique.

- W

[meslier]

Merci wiztricks. J'ai révisé cette notion. Mais le problème demeure, il me semble : comment garder la clé privée secrète ?

[Sve@r]

comment garder la clé privée secrète ?

Secrète vis à vis de qui?

[papajoker]

bonjour

on ne peut pas mettre la clé en clair dans le code source. Pour la faire intervenir dans une fonction, j'ai songé à la stocker dans un fichier ou une base de données. Mais ceux-ci sont eux-mêmes susceptibles d'être violés

Tu parles de la variable str key passée en paramètre dans l'exemple ? Il n'y a pas de solution particulière. Tout dépend du contexte.
Elle peut parfois être passée au programme via une variable d'environnement
Parfois, dans le fichier config de l'application (ou d'un utilisateur). Elle peut être dans un fichier (texte en clair) mais pas accessible à tout le monde

[meslier]

Merci papajoker et Sve@r. Mon problème est que toute l'application est visible dans un repository Github. Une constante dans le code source, une info dans un fichier texte, un fichier config, tout. Peut-être la base de données (sqlite3) n'est-elle pas lisible en clair, je ne sais pas (je suis pas pro du tout !). Mais je suppose que ce ne doit pas être difficile. Alors il faut crypter ce mot de passe. Mais si j'ai bien compris le principe du chiffrement asymétrique, après avoir codé et stocké le mot de passe, il faut conserver la clé privée, pour le décrypter quand on le communiquera à la fonction qui envoie le mail. Et c'est là que le fait qu'on soit en open source me pose problème.
La variable d'environnement, je connais pas, il faut que je potasse ça. Pour l'instant, le seul rapport que j'ai eu avec cette notion, c'est que le port du serveur Bottle, là où j'héberge, en est une.

[tyrtamos]

Bonjour

Ce problème de clé qu'on doit cacher, pour crypter / décrypter le fichier sqlite3, n'est pas facile à résoudre. Il y a cependant des solutions.

La 1ère me semble être de la demander à l'utilisateur! Mais, bien sûr, il faut la tester avant de l'utiliser. Et on ne peut pas la comparer à la clé mise en clair dans le code source. Par contre, on peut la crypter avec un algorithme de type sha256 (module hashlib), et la comparer avec la bonne clé elle-même cryptée avec le même algorithme et placée dans le code source. En effet, ce genre d'algorithme n'a pas de possibilité de décryptage, et donc, la connaissance de la clé cryptée ne permet pas de connaître la clé d'origine. C'est la méthode utilisée pour vérifier des mots de passe.

Pour les autres solutions, il ne faut pas diffuser le code source Python, mais le code Python compilé pour rendre plus compliqué de retrouver la méthode choisie. Bien sûr, on peut toujours "décompiler", mais ce n'est plus à la portée de n'importe qui... On peut compiler en utilisant par exemple cx_freeze ou pyinstaller (=> ".exe" sous Windows). Il s'agit d'une compilation en codes intermédiaires dont le résultat sera utilisable directement par l'interpréteur Python.

Pour avoir une bonne clé de cryptage/décryptage sans la donner, il y a une solution très inhabituelle: certains algorithmes de génération de nombres pseudo-aléatoires génèrent toujours la même suite de nombres. On peut donc les utiliser pour générer la clé sans la donner! Mais il ne faut pas utiliser random qui serait trop facile à trouver par une décompilation. Par exemple, un algorithme de type Fibonacci (voir ici: http://lwh.free.fr/pages/algo/crypto/prng.html) est facile à programmer:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def genfiboalea(x0, x1, nb):
    """Génère nb chiffres pseudo-aléatoires (méthode de fibonacci)
       x0 et x1: graines de départ pour la génération
    """
    M = 10
    for i in range(0, nb):
        xn = (x0+x1) % M
        x0 = x1
        x1 = xn
        yield xn
 
alea = genfiboalea(3, 7, 10)
for x in alea:
    print(x)
 
0
7
7
4
1
5
6
1
7
8

Au lieu de lui faire générer des chiffres, on pourrait lui faire générer des nombres, des octets, des lettres, etc...

Il faut bien sûr 2 graines (x0 et x1) pour initialiser l'algorithme (ici 3 et 7), mais la relation entre ces graines et la clé à trouver nécessite de comprendre l'algorithme avec la dé-compilation. Si on veut avoir un algorithme plus compliqué, on peut toujours. Par exemple le "Blum Blum Shub" (https://fr.wikipedia.org/wiki/Blum_Blum_Shub). Cet algorithme est très bon puisqu'il est accepté comme "cryptographiquement sûr". J'avais fait une petite étude sur le sujet (https://python.jpvweb.com/python/mes...id=genalea_bbs), mais il faut un certain courage pour se lancer là-dedans !

[Sve@r]

Merci papajoker et Sve@r. Mon problème est que toute l'application est visible dans un repository Github. Une constante dans le code source, une info dans un fichier texte, un fichier config, tout. Peut-être la base de données (sqlite3) n'est-elle pas lisible en clair, je ne sais pas (je suis pas pro du tout !). Mais je suppose que ce ne doit pas être difficile. Alors il faut crypter ce mot de passe.

Compris.
Déjà pour ta question annexe, une bdd sqlite est totalement lisible. Il existe un tas de lecteurs/navigateurs sqlite gratuits dont le premier "sqlitebrowser" est directement offert sous Debian (et dérivées telle Ubuntu). Suffit de taper la commande apt install sqlitebrowser. Et beaucoup d'outils utilisent sqlite sans se cacher (ni cacher les données). Par exemple le navigateur firefox stocke les mots de passe (quand tu fais "conserver le mot de passe" d'un site) dans un fichier sqlite nommé "key4.db" totalement ouvert.

Donc ça ne répond pas vraiment à la question "secrète vis à vis de qui".
Exemple: ton utilisateur peut utiliser ce programme (opensource) librement et gratuitement, tu n'as donc pas besoin que les données soient secrètes vis à vis de lui. Ce qui est nécessaire c'est que ses données à lui soient secrètes vis à vis d'un autre utilisateur qui utiliserait ton même programme dans son coin à lui. Dans ce cas, à l'initialisation du programme, tu génères le couple clef privée/cléf publique, tu stockes la clef privée dans un fichier local de l'utilisateur (à l'instar de ssh qui stocke les clefs privées de l'utilisateur dans un dossier ".ssh" verrouillé) et tu chiffres la bdd. Ensuite, dans l'utilisation habituelle, le programme ayant accès à la clef privée peut alors déchiffrer la bdd avant de l'utiliser.
Au fait, les termes exacts ne sont pas "cryptage/décryptage' mais "chiffrement/déchiffrement" car le terme "décryptage" fait référence à l'attaquant qui veut casser un code dont il n'est pas le propriétaire et dont il n'a pas la clef ; et par opposition le terme "cryptage" devrait faire référence à l'attaquant qui veut créer un code sans avoir la clef, ce qui est débile.

Autre exemple: tu ne te préoccupes absolument pas de la confidentialité de ta bdd (es-tu réellement obligé?). Donc ta bdd est libre et ouverte et lisible et l'utilisateur qui utilise ton programme en a pleinement conscience.
Toutefois l'utilisateur lui peut s'il en a envie, chiffrer cette bdd avec des outils divers. Par exemple VeraCrypt. Son principe est extrèmement simple

• tu crées un container (un disque dur virtuel) chiffré
• quand tu veux y accéder, tu tapes le mot de passe => le disque dur est alors monté sur ton système comme s'il s'agissait d'une clef USB ou d'un CDROM
• tu accèdes librement à ton disque dur, tu y déposes des fichiers, tu en récupères, exactement comme tu fais avec une clef USB. Les fichiers déposés sont chiffrés à l'écriture, les fichiers récupérés sont déchiffrés à la lecture et de façon transparente pour toi
• quand tu as fini, tu démontes ton disque et tout redevient inaccessible

L'utilisateur pourra donc utiliser ce même principe pour, s'il en a envie, cacher sa bdd aux autres. Quand il veut utiliser ton programme il monte le disque, et quand il a fini il le démonte.

Comme tu vois, la question "secrète vis à vis de qui" avait vraiment toute son importance...

En plus ce logiciel VeraCrypt peut (et je trouve ça génial) créer (si on le désire) deux disques chiffrés par volume. Le premier, servant de leurre, ne contenant que des fichiers bidons, et l'autre, le vrai, caché dans le premier et contenant les fichiers vraiment sensibles. Mais rien ne peut prouver qu'un volume veracrypt contient un ou deux disques (déni plausible)...

[papajoker]

est visible dans un repository Github.
Et c'est là que le fait qu'on soit en open source me pose problème.
le seul rapport que j'ai eu avec cette notion, c'est que le port du serveur Bottle

Énormément de projets open sources utilisent la notion de clé de chiffrement, simplement elle n'est pas dans le code
Elle est donc définie au déploiement de l'application (et dev)
Tu sembles parler d'une application web serveur...
- gitea : SECRET_KEY dans fichier de config non accessible depuis le web
- django : SECRET_KEY est généralement une variable d'environnement (au moins en cours de développement)
setting.py SECRET_KEY = os.getenv('DJANGO_SECRET_KEY') Ensuite, chacun peut changer cette ligne et lire la clé depuis un fichier...
- voir wordpress et bien d'autres...

Et puisque l'on utilise principalement docker pour distribuer un serveur web python, on place cette variable d'environnement dans la config docker
ps: même chose pour le mot de passe admin de notre BD, il est simplement (en clair) dans une variable d'environnement (ou fichier externe .env non dans le dépôt git)

Et si on ne parles pas de serveur, si la clé est dans un fichier texte dans un répertoire de l'utilisateur, elle ne peut-être lue que par l'utilisateur (et est unique pour chaque utilisateur: a faire à l'install)

Donc en résumé : cette "clé" est générée uniquement à l'installation (il est donc normal de ne pas l'avoir en statique sur un dépot git) et est unique à chaque installation

[meslier]

Merci à tous, pour vos infos riches ! Je précise que je me suis pas mis sur Github pour distribuer mon appli, parce qu'elle est loin d'être au point ! Le fait de montrer mon code est autant égoïste qu'altruiste. Si j'ai eu des bonnes idées, qu'elles puissent profiter à d'autres, mais si je fais des c...., on peut me les montrer ! (D'ailleurs, c'est ce qui s'est passé. Bien avant de songer à mettre l'appli en open, j'avais le mot de passe pour l'authentification des mails auto en dur dans le code. Et j'ai oublié ! Résultat, 600 mails pourris envoyés par moi ! " I have bad news. I have pirated your device, You must pay me x$, voilà mon bitcoin") . Probablement quelqu'un désireux de m'alerter ! Ça a bien marché.
En fait, il se trouve que j'ai été intéressé par l'offre de scalingo d'un essai d'un mois gratuit, et qu'ils fonctionnent avec Github.
Donc, la question des utilisateurs éventuels de mon code n'est pas encore posée, à mon avis. Pour l'instant, je considère qu'il y a un seul utilisateur, moi, qui dois essuyer les plâtres. De plus, il n'y a pas forcément là un produit commercial.
Voici d'ailleurs les liens, de l'appli elle-même avec une url provisoiore, et du repository Github.
https://vaste-programme.osc-fr1.scalingo.io/

https://github.com/Zakod/librerie