Скрытие пароля в скрипте Python (только небезопасная обфускация)

У меня есть скрипт Python, который создает соединение ODBC. Соединение ODBC создается с помощью строки подключения. В этой строке подключения я должен указать имя пользователя и пароль для этого подключения.

Есть ли простой способ скрыть этот пароль в файле (просто чтобы никто не мог прочитать пароль, когда я редактирую файл)?

Кодировка Base64 находится в стандартной библиотеке и подойдет, чтобы остановить серферов по плечу:

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

Douglas F Shearer's - это обычно одобренное решение в Unix, когда вам нужно указать пароль для удаленного входа в систему.
Вы добавляете параметр --password-from-file, чтобы указать путь и прочитать открытый текст из файла.
После этого файл может находиться в собственной области пользователя, защищенной операционной системой. Это также позволяет различным пользователям автоматически выбирать свой собственный файл.

Для паролей, которые пользователю сценария не разрешено знать - вы можете запустить сценарий с повышенным разрешением и иметь файл паролей, принадлежащий этому пользователю root / admin.

Вот простой способ:

1. Создайте модуль python - назовем его peekaboo.py.
2. В peekaboo.py укажите как пароль, так и любой код, требующий этого пароля.
3. Создайте скомпилированную версию - peekaboo.pyc - путем импорта этого модуля (через командную строку python и т. Д.).
4. Теперь удалите peekaboo.py.
5. Теперь вы можете успешно импортировать peekaboo, полагаясь только на peekaboo.pyc. Поскольку peekaboo.pyc компилируется побайтно, он не читается обычным пользователем.

Это должно быть немного безопаснее, чем декодирование base64, хотя оно уязвимо для декомпилятора py_to_pyc.

Если вы работаете в системе Unix, воспользуйтесь преимуществами модуля netrc в стандартной библиотеке Python. Он считывает пароли из отдельного текстового файла (.netrc), формат которого описан здесь .

Вот небольшой пример использования:

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

Лучшее решение, предполагающее, что имя пользователя и пароль не могут быть указаны пользователем во время выполнения, вероятно, представляет собой отдельный исходный файл, содержащий только инициализацию переменных для имени пользователя и пароля, которые импортируются в ваш основной код. Этот файл потребуется редактировать только при изменении учетных данных. В противном случае, если вас беспокоят только плечевые серферы со средней памятью, кодировка base 64, вероятно, будет самым простым решением. ROT13 слишком легко декодировать вручную, он не чувствителен к регистру и сохраняет слишком много смысла в зашифрованном состоянии. Закодируйте свой пароль и идентификатор пользователя вне сценария Python. Он должен декодировать сценарий во время выполнения для использования.

Предоставление учетных данных сценариям для автоматизированных задач - всегда рискованное предложение. У вашего сценария должны быть собственные учетные данные, а используемая им учетная запись не должна иметь доступа, кроме необходимого. По крайней мере, пароль должен быть длинным и случайным.

Как насчет импорта имени пользователя и пароля из файла, внешнего по отношению к сценарию? Таким образом, даже если кто-то завладеет скриптом, он не получит пароль автоматически.

base64 - это способ удовлетворить ваши простые потребности. Импортировать ничего не нужно:

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

для обфускации python3 использование base64выполняется иначе:

import base64
base64.b64encode(b'PasswordStringAsStreamOfBytes')

что приводит к

b'UGFzc3dvcmRTdHJpbmdBc1N0cmVhbU9mQnl0ZXM='

обратите внимание на неформальное строковое представление, фактическая строка заключена в кавычки

и декодирование обратно в исходную строку

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

чтобы использовать этот результат там, где требуются строковые объекты, можно перевести объект байтов

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

для получения дополнительной информации о том, как python3 обрабатывает байты (и соответственно строки), см. официальную документацию .

Это довольно распространенная проблема. Обычно лучшее, что вы можете сделать, - это либо

A) создать какую-то функцию шифрования ceasar для кодирования / декодирования (только не rot13) или

Б) предпочтительным методом является использование ключа шифрования, доступного для вашей программы, для кодирования / декодирования пароля. В котором вы можете использовать защиту файлов для защиты доступа к ключу.

В соответствии с этими строками, если ваше приложение работает как служба / демон (например, веб-сервер), вы можете поместить свой ключ в защищенное паролем хранилище ключей с вводом пароля как часть запуска службы. Для перезапуска вашего приложения потребуется администратор, но у вас будет действительно хорошая защита для ваших паролей конфигурации.

Ваша операционная система, вероятно, предоставляет средства для безопасного шифрования данных. Например, в Windows есть DPAPI (API защиты данных). Почему бы не спросить у пользователя их учетные данные при первом запуске, а затем зашифровать их для последующих запусков?

Больше отечественной оценки, а не преобразования аутентификации / паролей / имени пользователя в зашифрованные данные. FTPLIB - это всего лишь пример. " pass.csv " - это имя файла csv.

Сохраните пароль в CSV, как показано ниже:

user_name

пользовательский пароль

(Без заголовка столбца)

Чтение CSV и сохранение его в списке.

Использование элементов списка в качестве деталей аутентификации.

Полный код.

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

Вот мой фрагмент на такую ​​штуку. Вы в основном импортируете или копируете функцию в свой код. getCredentials создаст зашифрованный файл, если он не существует, и вернет словарь, а updateCredential обновится.

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

Поместите информацию о конфигурации в зашифрованный файл конфигурации. Запросите эту информацию в своем коде с помощью ключа. Поместите этот ключ в отдельный файл для каждой среды и не храните его вместе с кодом.

Вы знаете яму?

https://pypi.python.org/pypi/pit (только для py2 (версия 0.3))

https://github.com/yoshiori/pit (будет работать на py3 (текущая версия 0.4))

test.py

from pit import Pit

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

Бегать:

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

~ / .Pit / default.yml:

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

Если вы работаете в Windows, вы можете рассмотреть возможность использования библиотеки win32crypt. Он позволяет хранить и извлекать защищенные данные (ключи, пароли) пользователем, который запускает скрипт, поэтому пароли никогда не хранятся в открытом тексте или в запутанном формате в вашем коде. Я не уверен, есть ли эквивалентная реализация для других платформ, поэтому при строгом использовании win32crypt ваш код не переносится.

Я считаю, что модуль можно получить здесь: http://timgolden.me.uk/pywin32-docs/win32crypt.html

Я сделал это следующим образом:

В оболочке 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=='

Затем создайте модуль со следующим кодом:

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

Как только вы это сделаете, вы можете либо напрямую импортировать mypassword, либо импортировать токен и шифр для дешифрования по мере необходимости.

Очевидно, у этого подхода есть некоторые недостатки. Если у кого-то есть и токен, и ключ (как если бы у них был сценарий), он мог легко расшифровать. Однако он запутывается, и если вы скомпилируете код (с чем-то вроде Nuitka), по крайней мере, ваш пароль не будет отображаться в виде обычного текста в шестнадцатеричном редакторе.

Это не совсем ответ на ваш вопрос, но это связано. Я собирался добавить в качестве комментария, но мне не разрешили. Я столкнулся с этой же проблемой, и мы решили предоставить скрипт пользователям, использующим Jenkins. Это позволяет нам хранить учетные данные db в отдельном файле, который зашифрован и защищен на сервере и недоступен для пользователей, не являющихся администраторами. Это также позволяет нам немного ускорить создание пользовательского интерфейса и регулирование выполнения.

Вы также можете рассмотреть возможность хранения пароля вне сценария и предоставления его во время выполнения.

например, fred.py

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

который можно запустить как

$ PASSWORD=password123 python fred.py
fred password123

Дополнительные уровни «безопасности через неясность» могут быть достигнуты путем использования base64(как предложено выше), использования менее очевидных имен в коде и дальнейшего отделения фактического пароля от кода.

Если код находится в репозитории, часто бывает полезно хранить секреты вне него , чтобы можно было добавить его ~/.bashrc(или в хранилище, или сценарий запуска, ...)

export SURNAME=cGFzc3dvcmQxMjM=

и изменить fred.pyна

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

затем повторно авторизуйтесь и

$ python fred.py
fred password123

Почему бы не использовать простой xor?

Преимущества:

• выглядит как двоичные данные
• никто не может прочитать его, не зная ключа (даже если это один символ)

Я дохожу до того, что распознаю простые строки b64 для общих слов, а также rot13. Xor сделает это намного сложнее.

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

В сети есть несколько утилит ROT13, написанных на Python - просто погуглите. ROT13 кодирует строку в автономном режиме, копирует ее в источник, декодирует в точке передачи.

Но это действительно слабая защита ...