Ocultar una contraseña en un script de Python (solo ofuscación insegura)

Tengo un script de Python que está creando una conexión ODBC. La conexión ODBC se genera con una cadena de conexión. En esta cadena de conexión tengo que incluir el nombre de usuario y la contraseña para esta conexión.

¿Hay una manera fácil de ocultar esta contraseña en el archivo (solo que nadie puede leer la contraseña cuando estoy editando el archivo)?

La codificación Base64 está en la biblioteca estándar y servirá para detener a los surfistas de hombro:

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

Douglas F Shearer's es la solución generalmente aprobada en Unix cuando necesita especificar una contraseña para un inicio de sesión remoto.
Agrega una opción --password-from-file para especificar la ruta y leer el texto sin formato de un archivo.
El archivo puede estar en el área del usuario protegida por el sistema operativo. También permite a diferentes usuarios recoger automáticamente su propio archivo.

Para las contraseñas que el usuario de la secuencia de comandos no puede saber, puede ejecutar la secuencia de comandos con permiso extendido y tener el archivo de contraseña propiedad de ese usuario raíz / administrador.

Aquí hay un método simple:

1. Cree un módulo de Python, llamémoslo peekaboo.py.
2. En peekaboo.py, incluya tanto la contraseña como cualquier código que necesite esa contraseña
3. Cree una versión compilada, peekaboo.pyc, importando este módulo (a través de la línea de comandos de Python, etc.).
4. Ahora, elimine peekaboo.py.
5. Ahora puede importar felizmente peekaboo confiando solo en peekaboo.pyc. Como peekaboo.pyc está compilado en bytes, no es legible para el usuario casual.

Esto debería ser un poco más seguro que la decodificación base64, aunque es vulnerable a un descompilador py_to_pyc.

Si está trabajando en un sistema Unix, aproveche el módulo netrc en la biblioteca estándar de Python. Lee las contraseñas de un archivo de texto separado (.netrc), que tiene el formato descrito aquí .

Aquí hay un pequeño ejemplo de uso:

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

La mejor solución, suponiendo que el usuario no pueda proporcionar el nombre de usuario y la contraseña en tiempo de ejecución, es probablemente un archivo fuente separado que contenga solo una inicialización variable para el nombre de usuario y la contraseña que se importan a su código principal. Este archivo solo necesitaría edición cuando cambian las credenciales. De lo contrario, si solo le preocupan los surfistas de hombro con recuerdos promedio, la codificación de base 64 es probablemente la solución más fácil. ROT13 es demasiado fácil de decodificar manualmente, no distingue entre mayúsculas y minúsculas y conserva demasiado significado en su estado cifrado. Codifique su contraseña e identificación de usuario fuera del script de Python. Haga que el script decodifique en tiempo de ejecución para su uso.

Dar credenciales de guiones para tareas automatizadas siempre es una propuesta arriesgada. Su secuencia de comandos debe tener sus propias credenciales y la cuenta que utiliza no debe tener otro acceso que no sea exactamente el necesario. Al menos la contraseña debe ser larga y bastante aleatoria.

¿Qué hay de importar el nombre de usuario y la contraseña de un archivo externo al script? De esa manera, incluso si alguien obtuviera el script, no obtendría automáticamente la contraseña.

base64 es el camino a seguir para sus necesidades simples. No hay necesidad de importar nada:

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

para la ofuscación de python3, el uso base64se realiza de manera diferente:

import base64
base64.b64encode(b'PasswordStringAsStreamOfBytes')

lo que resulta en

b'UGFzc3dvcmRTdHJpbmdBc1N0cmVhbU9mQnl0ZXM='

tenga en cuenta la representación informal de la cadena, la cadena real está entre comillas

y decodificando de nuevo a la cadena original

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

para usar este resultado donde se requieren objetos de cadena, el objeto de bytes se puede traducir

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

Para obtener más información sobre cómo python3 maneja los bytes (y las cadenas en consecuencia), consulte la documentación oficial .

Este es un problema bastante común. Por lo general, lo mejor que puedes hacer es

A) cree algún tipo de función de cifrado ceasar para codificar / decodificar (simplemente no rot13) o

B) el método preferido es utilizar una clave de cifrado, al alcance de su programa, codificar / decodificar la contraseña. En el que puede utilizar la protección de archivos para proteger el acceso a la clave.

En ese sentido, si su aplicación se ejecuta como un servicio / demonio (como un servidor web), puede colocar su clave en un almacén de claves protegido por contraseña con la entrada de contraseña como parte del inicio del servicio. Se necesitará un administrador para reiniciar su aplicación, pero tendrá una buena pretensión para sus contraseñas de configuración.

Su sistema operativo probablemente proporciona facilidades para encriptar datos de forma segura. Por ejemplo, en Windows hay DPAPI (API de protección de datos). ¿Por qué no pedirle al usuario sus credenciales la primera vez que ejecuta y luego guardarlas encriptadas para las ejecuciones posteriores?

Más appraoch de cosecha propia en lugar de convertir autenticación / contraseñas / nombre de usuario en detalles cifrados. FTPLIB es solo el ejemplo. " pass.csv " es el nombre del archivo csv

Guardar contraseña en CSV como a continuación:

nombre_usuario

contraseña de usuario

(Sin encabezado de columna)

Leer el CSV y guardarlo en una lista.

Uso de elementos de lista como detalles de autenticación.

Código completo

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])

Aquí está mi fragmento para tal cosa. Básicamente importa o copia la función a su código. getCredentials creará el archivo cifrado si no existe y devolverá una dicción, y updateCredential se actualizará.

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()

Coloque la información de configuración en un archivo de configuración cifrado. Consulte esta información en su código con una clave. Coloque esta clave en un archivo separado por entorno y no la almacene con su código.

¿Conoces hoyo?

https://pypi.python.org/pypi/pit (solo py2 (versión 0.3))

https://github.com/yoshiori/pit (funcionará en py3 (versión actual 0.4))

prueba.py

from pit import Pit

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

Correr:

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

~ / .pit / default.yml:

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

Si se ejecuta en Windows, podría considerar usar la biblioteca win32crypt. Permite el almacenamiento y la recuperación de datos protegidos (claves, contraseñas) por parte del usuario que ejecuta el script, por lo tanto, las contraseñas nunca se almacenan en texto claro o en formato ofuscado en su código. No estoy seguro de si hay una implementación equivalente para otras plataformas, por lo que con el uso estricto de win32crypt su código no es portátil.

Creo que el módulo se puede obtener aquí: http://timgolden.me.uk/pywin32-docs/win32crypt.html

Una forma de hacerlo es la siguiente:

En el caparazón de python:

>>> 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=='

Luego, cree un módulo con el siguiente código:

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')

Una vez que haya hecho esto, puede importar mypassword directamente o puede importar el token y el cifrado para descifrarlos según sea necesario.

Obviamente, hay algunas deficiencias en este enfoque. Si alguien tiene tanto el token como la clave (como lo haría si tuviera el script), puede descifrarlo fácilmente. Sin embargo, se ofusca, y si compila el código (con algo como Nuitka) al menos su contraseña no aparecerá como texto sin formato en un editor hexadecimal.

Esto no responde con precisión a su pregunta, pero está relacionado. Iba a agregar como comentario pero no estaba permitido. He estado lidiando con este mismo problema, y ​​hemos decidido exponer el script a los usuarios que usan Jenkins. Esto nos permite almacenar las credenciales de db en un archivo separado que está encriptado y protegido en un servidor y que no es accesible para personas que no son administradores. También nos permite un poco de acceso directo para crear una interfaz de usuario y acelerar la ejecución.

También podría considerar la posibilidad de almacenar la contraseña fuera del script y proporcionarla en tiempo de ejecución

por ejemplo fred.py

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

que se puede ejecutar como

$ PASSWORD=password123 python fred.py
fred password123

Se pueden lograr capas adicionales de "seguridad a través de la oscuridad" usando base64(como se sugirió anteriormente), usando nombres menos obvios en el código y distanciando aún más la contraseña real del código.

Si el código está en un repositorio, a menudo es útil almacenar secretos fuera de él , por lo que podría agregar esto a ~/.bashrc(o a una bóveda, o un script de lanzamiento, ...)

export SURNAME=cGFzc3dvcmQxMjM=

y cambiar fred.pya

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

luego vuelva a iniciar sesión y

$ python fred.py
fred password123

¿Por qué no tener un simple xor?

Ventajas:

• parece datos binarios
• nadie puede leerlo sin conocer la clave (incluso si se trata de un solo personaje)

Llego al punto en el que reconozco cadenas b64 simples para palabras comunes y rot13 también. Xor lo haría mucho más difícil.

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

Hay varias utilidades ROT13 escritas en Python en la red, solo google para ellas. ROT13 codifica la cadena fuera de línea, la copia en la fuente, decodifica en el punto de transmisión.

Pero esta es una protección realmente débil ...