Приховування пароля в сценарії 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

Найкраще рішення, якщо припустити, що ім’я користувача та пароль не можуть бути надані користувачем під час виконання, це, мабуть, окремий вихідний файл, що містить лише змінну ініціалізацію імені користувача та пароля, імпортованих у ваш основний код. Цей файл потребуватиме редагування лише тоді, коли зміниться облікові дані. В іншому випадку, якщо ви переживаєте лише за плечових серферів із середньою пам’яттю, кодування на базі 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 обробляє байти (і рядки відповідно), будь ласка, дивіться офіційну документацію .

Це досить поширена проблема. Зазвичай найкраще, що ви можете зробити, це будь-яке

А) створити якусь функцію шифру ceasar для кодування / декодування (тільки не гниль13) або

Б) кращим методом є використання ключа шифрування, в межах досяжності вашої програми, кодування / декодування пароля. У якому ви можете використовувати захист файлів для захисту доступу до ключа.

У відповідності до цих рядків, якщо ваша програма працює як служба / демон (як веб-сервер), ви можете помістити свій ключ у захищену паролем сховище ключів із введенням пароля як частина запуску служби. Адміністратору потрібно буде перезапустити додаток, але у вас буде справді хороший привід для паролів конфігурації.

Ваша операційна система, ймовірно, забезпечує засоби для безпечного шифрування даних. Наприклад, у Windows є DPAPI (API захисту даних). Чому б не попросити у користувача їхніх облікових даних при першому запуску, а потім білка їх зашифрована для наступних запусків?

Більше домашній додаток, а не перетворення автентифікації / паролів / імені користувача для зашифрованих даних. FTPLIB - лише приклад. " pass.csv " - це ім'я файлу CSV

Збережіть пароль у CSV, як показано нижче:

ім'я користувача

user_password

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

Читання 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

Я зробив це таким чином:

На оболонці пітона:

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

Після цього ви можете або імпортувати мій пароль безпосередньо, або ви можете імпортувати маркер і шифр, щоб розшифрувати за потребою.

Очевидно, у цього підходу є деякі недоліки. Якщо хтось має і маркер, і ключ (як це було б, якщо у них є сценарій), він може легко розшифрувати. Однак це примушує, і якщо ви компілюєте код (з чимось на зразок Nuitka), принаймні ваш пароль не з’явиться як звичайний текст у шестигранному редакторі.

Це не відповідає точно на ваше запитання, але це пов'язано. Я збирався додати коментар, але мені не було дозволено. Я займався цим самим питанням, і ми вирішили викрити сценарій користувачам, що користуються Дженкінсом. Це дозволяє нам зберігати облікові дані 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 в мережі "Мережа - для них просто google". ROT13 кодує рядок в автономному режимі, скопіюйте її в джерело, декодуйте в точці передачі.

Але це справді слабкий захист ...