Ocultando uma senha em um script python (apenas ofuscação insegura)

Eu tenho um script python que está criando uma conexão ODBC. A conexão ODBC é gerada com uma cadeia de conexão. Nesta cadeia de conexão, tenho que incluir o nome de usuário e a senha para esta conexão.

Existe uma maneira fácil de ocultar essa senha no arquivo (apenas para que ninguém possa ler a senha quando estou editando o arquivo)?

A codificação Base64 está na biblioteca padrão e servirá para parar os surfistas:

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

O Douglas F Shearer's é a solução geralmente aprovada no Unix quando você precisa especificar uma senha para um login remoto.
Você adiciona uma opção --password-from-file para especificar o caminho e ler texto sem formatação de um arquivo.
O arquivo pode estar na área do usuário protegida pelo sistema operacional. Ele também permite que diferentes usuários escolham automaticamente seu próprio arquivo.

Para senhas que o usuário do script não tem permissão de conhecer - você pode executar o script com permissão reduzida e ter o arquivo de senha de propriedade desse usuário root / admin.

Aqui está um método simples:

1. Crie um módulo python - vamos chamá-lo de peekaboo.py.
2. Em peekaboo.py, inclua a senha e qualquer código que precise dessa senha
3. Crie uma versão compilada - peekaboo.pyc - importando este módulo (via linha de comando python, etc ...).
4. Agora, exclua peekaboo.py.
5. Agora você pode importar felizmente o peekaboo, contando apenas com o peekaboo.pyc. Como o peekaboo.pyc é compilado em bytes, não é legível para o usuário casual.

Isso deve ser um pouco mais seguro que a decodificação base64 - embora seja vulnerável a um descompilador py_to_pyc.

Se você estiver trabalhando em um sistema Unix, aproveite o módulo netrc na biblioteca padrão do Python. Ele lê senhas de um arquivo de texto separado (.netrc), cujo formato é descrito aqui .

Aqui está um pequeno exemplo 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

A melhor solução, supondo que o nome de usuário e a senha não possam ser fornecidos em tempo de execução pelo usuário, é provavelmente um arquivo de origem separado contendo apenas a inicialização variável do nome de usuário e senha importados para o código principal. Esse arquivo precisaria ser editado apenas quando as credenciais forem alteradas. Caso contrário, se você estiver preocupado apenas com os surfistas com memória média, a codificação da base 64 é provavelmente a solução mais fácil. O ROT13 é muito fácil de decodificar manualmente, não diferencia maiúsculas de minúsculas e mantém muito significado em seu estado criptografado. Codifique sua senha e ID do usuário fora do script python. Ele decodificou o script em tempo de execução para uso.

Dar credenciais de scripts para tarefas automatizadas é sempre uma proposta arriscada. Seu script deve ter suas próprias credenciais e a conta que ele usa não deve ter acesso além do que é exatamente necessário. Pelo menos a senha deve ser longa e bastante aleatória.

Que tal importar o nome de usuário e a senha de um arquivo externo ao script? Dessa forma, mesmo que alguém se apossasse do script, não obteria a senha automaticamente.

base64 é o caminho a percorrer para suas necessidades simples. Não há necessidade de importar nada:

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

para ofuscação python3 usando base64é feito de maneira diferente:

import base64
base64.b64encode(b'PasswordStringAsStreamOfBytes')

o que resulta em

b'UGFzc3dvcmRTdHJpbmdBc1N0cmVhbU9mQnl0ZXM='

observe a representação informal da string, a string real está entre aspas

e decodificando de volta para a string original

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

para usar este resultado onde objetos de string são necessários, o objeto de bytes pode ser convertido

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

para obter mais informações sobre como python3 lida com bytes (e seqüências de caracteres de acordo), consulte a documentação oficial .

Este é um problema bastante comum. Normalmente, o melhor que você pode fazer é

A) crie algum tipo de função de codificação ceasar para codificar / decodificar (apenas não rot13) ou

B) o método preferido é usar uma chave de criptografia, ao alcance do seu programa, codificar / decodificar a senha. Na qual você pode usar a proteção de arquivos para proteger o acesso à chave.

Nesse sentido, se o aplicativo for executado como um serviço / daemon (como um servidor da web), você poderá colocar sua chave em um keystore protegido por senha com a entrada de senha como parte da inicialização do serviço. Um administrador precisará reiniciar o aplicativo, mas você terá uma boa pretensão para as senhas de configuração.

Seu sistema operacional provavelmente fornece recursos para criptografar dados com segurança. Por exemplo, no Windows, há DPAPI (API de proteção de dados). Por que não pedir suas credenciais ao usuário na primeira vez em que você executa e depois esquivá-las criptografadas para execuções subsequentes?

Aproximação mais caseira do que converter autenticação / senhas / nome de usuário em detalhes criptografados. FTPLIB é apenas o exemplo. " pass.csv " é o nome do arquivo csv

Salve a senha no CSV como abaixo:

nome do usuário

senha do usuário

(Sem cabeçalho da coluna)

Lendo o CSV e salvando-o em uma lista.

Usando os elementos da lista como detalhes da autenticação.

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

Aqui está o meu trecho para tal coisa. Você basicamente importa ou copia a função para o seu código. O getCredentials criará o arquivo criptografado se ele não existir e retornará uma descrição, e o updateCredential será atualizado.

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 as informações de configuração em um arquivo de configuração criptografado. Consulte essas informações no seu código usando uma chave. Coloque essa chave em um arquivo separado por ambiente e não a armazene com seu código.

Você conhece pit?

https://pypi.python.org/pypi/pit (somente py2 (versão 0.3))

https://github.com/yoshiori/pit (funcionará no py3 (versão atual 0.4))

test.py

from pit import Pit

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

Corre:

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

~ / .pit / default.yml:

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

Se estiver executando no Windows, você pode considerar o uso da biblioteca win32crypt. Ele permite o armazenamento e a recuperação de dados protegidos (chaves, senhas) pelo usuário que está executando o script, portanto, as senhas nunca são armazenadas em texto não criptografado ou no formato ofuscado no seu código. Não tenho certeza se existe uma implementação equivalente para outras plataformas, portanto, com o uso estrito do win32crypt, seu código não é portátil.

Acredito que o módulo pode ser obtido aqui: http://timgolden.me.uk/pywin32-docs/win32crypt.html

Uma maneira de fazer isso é a seguinte:

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

Em seguida, crie um módulo com o seguinte 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')

Depois de fazer isso, você pode importar minha senha diretamente ou importar o token e a cifra para descriptografar conforme necessário.

Obviamente, existem algumas falhas nessa abordagem. Se alguém tiver o token e a chave (como teriam se tivesse o script), poderá descriptografar facilmente. No entanto, ele ofusca e, se você compilar o código (com algo como Nuitka), pelo menos sua senha não aparecerá como texto sem formatação em um editor hexadecimal.

Isso não responde exatamente à sua pergunta, mas está relacionado. Eu adicionaria como comentário, mas não era permitido. Estou lidando com esse mesmo problema e decidimos expor o script para os usuários que usam Jenkins. Isso nos permite armazenar as credenciais do banco de dados em um arquivo separado, criptografado e protegido em um servidor e não acessível a não administradores. Também nos permite um atalho para criar uma interface do usuário e limitar a execução.

Você também pode considerar a possibilidade de armazenar a senha fora do script e fornecê-la em tempo de execução

por exemplo, fred.py

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

que pode ser executado como

$ PASSWORD=password123 python fred.py
fred password123

Camadas extras de "segurança através da obscuridade" podem ser obtidas usando base64 (como sugerido acima), usando nomes menos óbvios no código e distanciando ainda mais a senha real do código.

Se o código estiver em um repositório, geralmente é útil armazenar segredos fora dele , para que você possa adicioná-lo a ~/.bashrc(ou a um cofre ou a um script de inicialização, ...)

export SURNAME=cGFzc3dvcmQxMjM=

e mude fred.pypara

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

depois faça login novamente e

$ python fred.py
fred password123

Por que não ter um xor simples?

Vantagens:

• parece dados binários
• ninguém pode lê-lo sem conhecer a chave (mesmo que seja um único caractere)

Chego ao ponto em que reconheço simples strings b64 para palavras comuns e rot13 também. Xor tornaria muito mais difícil.

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

Existem vários utilitários ROT13 escritos em Python na 'Net - apenas o google para eles. O ROT13 codifica a string offline, copia-a na fonte, decodifica no ponto de transmissão.

Mas isso é realmente uma proteção fraca ...