Ausblenden eines Passworts in einem Python-Skript (nur unsichere Verschleierung)

Ich habe ein Python-Skript, das eine ODBC-Verbindung herstellt. Die ODBC-Verbindung wird mit einer Verbindungszeichenfolge generiert. In diese Verbindungszeichenfolge muss ich den Benutzernamen und das Passwort für diese Verbindung einfügen.

Gibt es eine einfache Möglichkeit, dieses Passwort in der Datei zu verschleiern (nur dass niemand das Passwort lesen kann, wenn ich die Datei bearbeite)?

Die Base64-Codierung befindet sich in der Standardbibliothek und kann Schulter-Surfer stoppen:

>>> import base64
>>>  print(base64.b64encode("password".encode("utf-8")))
cGFzc3dvcmQ=
>>> print(base64.b64decode("cGFzc3dvcmQ=").decode("utf-8"))
password

Douglas F Shearer's ist die allgemein anerkannte Lösung unter Unix, wenn Sie ein Kennwort für eine Remote-Anmeldung angeben müssen.
Sie fügen die Option --password-from-file hinzu , um den Pfad anzugeben und Klartext aus einer Datei zu lesen.
Die Datei kann sich dann im eigenen Bereich des Benutzers befinden, der vom Betriebssystem geschützt wird. Außerdem können verschiedene Benutzer automatisch ihre eigene Datei abrufen.

Für Kennwörter, die der Benutzer des Skripts nicht kennen darf, können Sie das Skript mit der angegebenen Berechtigung ausführen und die Kennwortdatei diesem Root- / Administratorbenutzer zuweisen.

Hier ist eine einfache Methode:

1. Erstellen Sie ein Python-Modul - nennen wir es peekaboo.py.
2. Geben Sie in peekaboo.py sowohl das Kennwort als auch den Code an, der dieses Kennwort benötigt
3. Erstellen Sie eine kompilierte Version - peekaboo.pyc -, indem Sie dieses Modul importieren (über die Python-Befehlszeile usw.).
4. Löschen Sie jetzt peekaboo.py.
5. Sie können Peekaboo jetzt problemlos importieren, indem Sie sich nur auf peekaboo.pyc verlassen. Da peekaboo.pyc bytekompiliert ist, ist es für den Gelegenheitsbenutzer nicht lesbar.

Dies sollte etwas sicherer sein als die Base64-Dekodierung - obwohl es für einen py_to_pyc-Dekompiler anfällig ist.

Wenn Sie auf einem Unix-System arbeiten, nutzen Sie das netrc-Modul in der Standard-Python-Bibliothek. Es liest Passwörter aus einer separaten Textdatei (.netrc), deren Format hier beschrieben ist .

Hier ist ein kleines Anwendungsbeispiel:

import netrc

# Define which host in the .netrc file to use
HOST = 'mailcluster.loopia.se'

# Read from the .netrc file in your home directory
secrets = netrc.netrc()
username, account, password = secrets.authenticators( HOST )

print username, password

Die beste Lösung, vorausgesetzt, der Benutzername und das Kennwort können vom Benutzer zur Laufzeit nicht angegeben werden, ist wahrscheinlich eine separate Quelldatei, die nur eine variable Initialisierung für den Benutzernamen und das Kennwort enthält, die in Ihren Hauptcode importiert werden. Diese Datei muss nur bearbeitet werden, wenn sich die Anmeldeinformationen ändern. Andernfalls ist die Base 64-Codierung wahrscheinlich die einfachste Lösung, wenn Sie sich nur um Schulter-Surfer mit durchschnittlichen Erinnerungen sorgen. ROT13 ist einfach zu einfach manuell zu dekodieren, unterscheidet nicht zwischen Groß- und Kleinschreibung und behält im verschlüsselten Zustand zu viel Bedeutung. Codieren Sie Ihr Passwort und Ihre Benutzer-ID außerhalb des Python-Skripts. Lassen Sie das Skript zur Laufzeit zur Verwendung dekodieren.

Das Angeben von Anmeldeinformationen für Skripte für automatisierte Aufgaben ist immer ein riskanter Vorschlag. Ihr Skript sollte über eigene Anmeldeinformationen verfügen und das verwendete Konto sollte keinen anderen Zugriff haben als genau das, was erforderlich ist. Zumindest sollte das Passwort lang und eher zufällig sein.

Wie wäre es mit dem Importieren des Benutzernamens und des Passworts aus einer Datei außerhalb des Skripts? Auf diese Weise würde jemand, der das Skript erhalten würde, das Kennwort nicht automatisch erhalten.

base64 ist der richtige Weg für Ihre einfachen Bedürfnisse. Es muss nichts importiert werden:

>>> 'your string'.encode('base64')
'eW91ciBzdHJpbmc=\n'
>>> _.decode('base64')
'your string'

Für die Python3- Verschleierung erfolgt die Verwendung base64anders:

import base64
base64.b64encode(b'PasswordStringAsStreamOfBytes')

was in ... endet

b'UGFzc3dvcmRTdHJpbmdBc1N0cmVhbU9mQnl0ZXM='

Beachten Sie die informelle Zeichenfolgendarstellung. Die tatsächliche Zeichenfolge steht in Anführungszeichen

und Dekodieren zurück zum ursprünglichen String

base64.b64decode(b'UGFzc3dvcmRTdHJpbmdBc1N0cmVhbU9mQnl0ZXM=')
b'PasswordStringAsStreamOfBytes'

Um dieses Ergebnis zu verwenden, wenn Zeichenfolgenobjekte erforderlich sind, kann das Byteobjekt übersetzt werden

repr = base64.b64decode(b'UGFzc3dvcmRTdHJpbmdBc1N0cmVhbU9mQnl0ZXM=')
secret = repr.decode('utf-8')
print(secret)

Weitere Informationen darüber, wie Python3 mit Bytes (und Zeichenfolgen entsprechend) umgeht, finden Sie in der offiziellen Dokumentation .

Dies ist ein ziemlich häufiges Problem. In der Regel ist das Beste, was Sie tun können, entweder

A) Erstellen Sie eine Art Ceasar-Verschlüsselungsfunktion zum Codieren / Decodieren (nur nicht rot13) oder

B) Die bevorzugte Methode besteht darin, einen Verschlüsselungsschlüssel zu verwenden, der in Reichweite Ihres Programms das Kennwort verschlüsselt / entschlüsselt. In dem Sie den Dateischutz verwenden können, um den Zugriff auf den Schlüssel zu schützen.

In diesem Sinne können Sie, wenn Ihre App als Dienst / Dämon (wie ein Webserver) ausgeführt wird, Ihren Schlüssel in einen kennwortgeschützten Schlüsselspeicher mit der Kennworteingabe als Teil des Dienststarts einfügen. Es wird einen Administrator benötigen, um Ihre App neu zu starten, aber Sie haben wirklich gute Voraussetzungen für Ihre Konfigurationskennwörter.

Ihr Betriebssystem bietet wahrscheinlich Möglichkeiten zum sicheren Verschlüsseln von Daten. Unter Windows gibt es beispielsweise DPAPI (Data Protection API). Fragen Sie den Benutzer beim ersten Ausführen nach seinen Anmeldeinformationen und entfernen Sie sie dann verschlüsselt für nachfolgende Ausführungen.

Mehr hausgemachte Vorgehensweise als Konvertierung von Authentifizierung / Passwörtern / Benutzernamen in verschlüsselte Details. FTPLIB ist nur das Beispiel. "" pass.csv " ist der Name der CSV-Datei

Speichern Sie das Passwort in CSV wie folgt:

Nutzername

Benutzer-Passwort

(Ohne Spaltenüberschrift)

Lesen Sie die CSV und speichern Sie sie in einer Liste.

Verwenden von Listenelementen als Authentifizierungsdetails.

Vollständiger Code.

import os
import ftplib
import csv 
cred_detail = []
os.chdir("Folder where the csv file is stored")
for row in csv.reader(open("pass.csv","rb")):       
        cred_detail.append(row)
ftp = ftplib.FTP('server_name',cred_detail[0][0],cred_detail[1][0])

Hier ist mein Ausschnitt für so etwas. Sie importieren oder kopieren die Funktion grundsätzlich in Ihren Code. getCredentials erstellt die verschlüsselte Datei, falls sie nicht vorhanden ist, und gibt ein Wörterbuch zurück. updateCredential wird aktualisiert.

import os

def getCredentials():
    import base64

    splitter='<PC+,DFS/-SHQ.R'
    directory='C:\\PCT'

    if not os.path.exists(directory):
        os.makedirs(directory)

    try:
        with open(directory+'\\Credentials.txt', 'r') as file:
            cred = file.read()
            file.close()
    except:
        print('I could not file the credentials file. \nSo I dont keep asking you for your email and password everytime you run me, I will be saving an encrypted file at {}.\n'.format(directory))

        lanid = base64.b64encode(bytes(input('   LanID: '), encoding='utf-8')).decode('utf-8')  
        email = base64.b64encode(bytes(input('   eMail: '), encoding='utf-8')).decode('utf-8')
        password = base64.b64encode(bytes(input('   PassW: '), encoding='utf-8')).decode('utf-8')
        cred = lanid+splitter+email+splitter+password
        with open(directory+'\\Credentials.txt','w+') as file:
            file.write(cred)
            file.close()

    return {'lanid':base64.b64decode(bytes(cred.split(splitter)[0], encoding='utf-8')).decode('utf-8'),
            'email':base64.b64decode(bytes(cred.split(splitter)[1], encoding='utf-8')).decode('utf-8'),
            'password':base64.b64decode(bytes(cred.split(splitter)[2], encoding='utf-8')).decode('utf-8')}

def updateCredentials():
    import base64

    splitter='<PC+,DFS/-SHQ.R'
    directory='C:\\PCT'

    if not os.path.exists(directory):
        os.makedirs(directory)

    print('I will be saving an encrypted file at {}.\n'.format(directory))

    lanid = base64.b64encode(bytes(input('   LanID: '), encoding='utf-8')).decode('utf-8')  
    email = base64.b64encode(bytes(input('   eMail: '), encoding='utf-8')).decode('utf-8')
    password = base64.b64encode(bytes(input('   PassW: '), encoding='utf-8')).decode('utf-8')
    cred = lanid+splitter+email+splitter+password
    with open(directory+'\\Credentials.txt','w+') as file:
        file.write(cred)
        file.close()

cred = getCredentials()

updateCredentials()

Platzieren Sie die Konfigurationsinformationen in einer verschlüsselten Konfigurationsdatei. Fragen Sie diese Informationen in Ihrem Code mit einem Schlüssel ab. Platzieren Sie diesen Schlüssel in einer separaten Datei pro Umgebung und speichern Sie ihn nicht mit Ihrem Code.

Kennst du Grube?

https://pypi.python.org/pypi/pit (nur py2 (Version 0.3))

https://github.com/yoshiori/pit (es funktioniert auf py3 (aktuelle Version 0.4))

test.py

from pit import Pit

config = Pit.get('section-name', {'require': {
    'username': 'DEFAULT STRING',
    'password': 'DEFAULT STRING',
    }})
print(config)

Lauf:

$ python test.py
{'password': 'my-password', 'username': 'my-name'}

~ / .pit / default.yml:

section-name:
  password: my-password
  username: my-name

Wenn Sie unter Windows ausgeführt werden, können Sie die win32crypt-Bibliothek verwenden. Es ermöglicht dem Benutzer, der das Skript ausführt, das Speichern und Abrufen geschützter Daten (Schlüssel, Kennwörter). Daher werden Kennwörter in Ihrem Code niemals im Klartext oder im verschleierten Format gespeichert. Ich bin nicht sicher, ob es eine gleichwertige Implementierung für andere Plattformen gibt. Mit der strikten Verwendung von win32crypt ist Ihr Code also nicht portierbar.

Ich glaube, das Modul ist hier erhältlich: http://timgolden.me.uk/pywin32-docs/win32crypt.html

Ich habe dies folgendermaßen getan:

An der Python-Shell:

>>> from cryptography.fernet import Fernet
>>> key = Fernet.generate_key()
>>> print(key)
b'B8XBLJDiroM3N2nCBuUlzPL06AmfV4XkPJ5OKsPZbC4='
>>> cipher = Fernet(key)
>>> password = "thepassword".encode('utf-8')
>>> token = cipher.encrypt(password)
>>> print(token)
b'gAAAAABe_TUP82q1zMR9SZw1LpawRLHjgNLdUOmW31RApwASzeo4qWSZ52ZBYpSrb1kUeXNFoX0tyhe7kWuudNs2Iy7vUwaY7Q=='

Erstellen Sie dann ein Modul mit dem folgenden Code:

from cryptography.fernet import Fernet

# you store the key and the token
key = b'B8XBLJDiroM3N2nCBuUlzPL06AmfV4XkPJ5OKsPZbC4='
token = b'gAAAAABe_TUP82q1zMR9SZw1LpawRLHjgNLdUOmW31RApwASzeo4qWSZ52ZBYpSrb1kUeXNFoX0tyhe7kWuudNs2Iy7vUwaY7Q=='

# create a cipher and decrypt when you need your password
cipher = Fernet(key)

mypassword = cipher.decrypt(token).decode('utf-8')

Sobald Sie dies getan haben, können Sie entweder mein Passwort direkt importieren oder das Token und die Verschlüsselung importieren, um sie nach Bedarf zu entschlüsseln.

Offensichtlich weist dieser Ansatz einige Mängel auf. Wenn jemand sowohl das Token als auch den Schlüssel hat (wie wenn er das Skript hätte), kann er leicht entschlüsseln. Es verschleiert sich jedoch, und wenn Sie den Code kompilieren (mit etwas wie Nuitka), wird Ihr Passwort zumindest nicht als einfacher Text in einem Hex-Editor angezeigt.

Dies beantwortet Ihre Frage nicht genau, ist aber verwandt. Ich wollte als Kommentar hinzufügen, war aber nicht erlaubt. Ich habe mich mit demselben Problem befasst, und wir haben beschlossen, das Skript den Benutzern mit Jenkins zur Verfügung zu stellen. Auf diese Weise können wir die Datenbankanmeldeinformationen in einer separaten Datei speichern, die verschlüsselt und auf einem Server gesichert ist und für Nicht-Administratoren nicht zugänglich ist. Es ermöglicht uns auch eine Abkürzung zum Erstellen einer Benutzeroberfläche und zum Drosseln der Ausführung.

Sie können auch die Möglichkeit in Betracht ziehen, das Kennwort außerhalb des Skripts zu speichern und zur Laufzeit bereitzustellen

zB fred.py

import os
username = 'fred'
password = os.environ.get('PASSWORD', '')
print(username, password)

das kann wie laufen

$ PASSWORD=password123 python fred.py
fred password123

Zusätzliche Schichten von "Sicherheit durch Dunkelheit" können durch Verwendung erreicht werden base64 (wie oben vorgeschlagen) weniger offensichtliche Namen im Code verwendet werden und das tatsächliche Kennwort weiter vom Code entfernt wird.

Wenn sich der Code in einem Repository befindet, ist es oft nützlich, Geheimnisse außerhalb des Repositorys zu speichern , sodass man dies hinzufügen kann ~/.bashrc(oder einem Tresor oder einem Startskript, ...).

export SURNAME=cGFzc3dvcmQxMjM=

und wechseln fred.pyzu

import os
import base64
name = 'fred'
surname = base64.b64decode(os.environ.get('SURNAME', '')).decode('utf-8')
print(name, surname)

dann erneut anmelden und

$ python fred.py
fred password123

Warum nicht ein einfaches xor haben?

Vorteile:

• sieht aus wie Binärdaten
• Niemand kann es lesen, ohne den Schlüssel zu kennen (auch wenn es sich um ein einzelnes Zeichen handelt).

Ich komme an den Punkt, an dem ich einfache b64-Zeichenfolgen für gebräuchliche Wörter und auch rot13 erkenne. Xor würde es viel schwieriger machen.

import base64
print(base64.b64encode("password".encode("utf-8")))
print(base64.b64decode(b'cGFzc3dvcmQ='.decode("utf-8")))

Es gibt mehrere ROT13-Dienstprogramme, die in Python im Internet geschrieben sind - googeln Sie einfach nach ihnen. ROT13 codiert die Zeichenfolge offline, kopiert sie in die Quelle und decodiert sie am Übertragungspunkt.

Aber das ist wirklich schwacher Schutz ...