Посилення безпеки хмари в AI/ML: Історія маленького соління

Оскільки AI та машинне навчання (AI/ML) стають все більш доступними через постачальників хмарних послуг (CSP), таких як веб -сервіси Amazon (AWS), можуть виникнути нові проблеми безпеки, які потребують вирішення клієнтів. AWS надає різноманітні послуги для випадків використання AI/ML, а розробники часто взаємодіють з цими послугами різними мовами програмування. У цій публікації в блозі ми зосереджуємось на Python та його pickle модуль, який підтримує процес, який називається марита Для серіалізації та дезеріалізації об'єктних структур. Ця функціональність спрощує управління даними та обмін складними даними у розподілених системах. Однак через потенційні проблеми з безпекою важливо використовувати піклування з обережністю (див. Попереджувальну записку в Пікл – серіалізація об'єктів Python). У цій публікації ми покажемо вам способи побудови захищених робочих навантажень AI/ML, які використовують цей потужний модуль Python, способи виявлення того, що це використовується, про що ви можете не знати, і коли це може зловживати, і нарешті виділити альтернативні підходи, які допоможуть вам уникнути цих проблем.

Швидкі поради

Розуміння невпевненої серіалізації соління та десеріалізації в Python

Ефективне управління даними має вирішальне значення для програмування Python, і багато розробників звертаються до pickle модуль для серіалізації. Однак проблеми можуть виникати при десеріалізації даних з недовірених джерел. Пітон -байтек, який використовує марилінг, є власником Python. Поки це не буде незадоволеним, дані в ByteStream не можуть бути ретельно оцінені. Саме тут контроль та перевірка безпеки стають критичними. Без належної перевірки існує ризик того, що несанкціонований користувач може ввести несподіваний код, потенційно призводить до довільного виконання коду, підробки даних або навіть непередбачуваного доступу до системи. У контексті завантаження моделі AI, безпечна дезеріалізація особливо важлива – це допомагає запобігти зовнішнім сторонам модифікації поведінки моделі, ін'єкційного зворотного доступу або спричиняючи ненавмисне розкриття чутливих даних.

Протягом цієї публікації ми будемо посилатися на серіалізацію і дезеріалізацію колективно як марита. Подібні проблеми можуть бути присутніми іншими мовами (наприклад, Java та PHP), коли використовуються ненадійні дані для відтворення об'єктів або структур даних, що призводить до потенційних питань безпеки, таких як довільне виконання коду, корупція даних та несанкціонований доступ.

Аналіз статичного коду порівняно з динамічним тестуванням для виявлення марикації

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

Хоча статичний аналіз коду забезпечує всебічний підхід до білої скриньки, динамічне тестування може виявити конкретні проблеми, які з’являються лише під час виконання. Обидва методи важливі. У цій публікації ми зосереджуємось насамперед на ролі статичного аналізу коду у виявленні небезпечного марикації.

Такі інструменти, як Amazon Codeguru та Semgrep, ефективні для виявлення проблем безпеки на початку. Для проектів з відкритим кодом Semgrep – це чудовий варіант підтримувати постійні перевірки безпеки.

Ризики невпевненого малювання в AI/ML

Проблеми з марилінгами в контекстах AI/ML можуть бути особливо стосовно.

• Недійсне завантаження об'єкта: Моделі AI/ML часто серіалізуються для подальшого використання. Завантаження цих моделей з ненадійних джерел без перевірки може призвести до довільного виконання коду. Бібліотеки, такі як pickle, joblibа деякі yaml Конфігурації дозволяють серіалізацію, але їх потрібно надійно обробляти.
  • Наприклад: Якщо веб -програма зберігає введення користувача за допомогою pickle І розгортає його пізніше без перевірки, несанкціонований користувач може створити шкідливе корисне навантаження, яке виконує довільний код на сервері.
• Цілісність даних: Цілісність маринованих даних є критичною. Несподівано складені дані можуть пошкодити моделі, що призводить до неправильних прогнозів або поведінки, що особливо стосується чутливих областей, таких як фінанси, охорона здоров'я та автономні системи.
  • Наприклад: команда оновлює свою архітектуру моделі AI або кроки попередньої обробки, але забуває перекваліфікувати та зберегти оновлену модель. Завантаження старої маринованої моделі під новим кодом може викликати помилки або непередбачувані результати.
• Експозиція конфіденційної інформації: Спілкування часто включає всі атрибути об'єкта, що потенційно викривають конфіденційні дані, такі як облікові дані або секрети.
  • Наприклад: модель ML може містити облікові дані бази даних у своєму серіалізованому стані. Якщо він поділений або зберігається без запобіжних заходів, несанкціонований користувач, який розсушує файл, може отримати ненавмисний доступ до цих облікових даних.
• Недостатній захист даних: Коли надсилаються через мережі або зберігаються без шифрування, мариновані дані можуть бути перехоплені, що призводить до ненавмисного розкриття конфіденційної інформації.
  • Наприклад: У середовищі охорони здоров’я маринована модель AI, що містить дані пацієнтів, може бути передана через незабезпечену мережу, що дозволяє зовнішній стороні перехоплювати та читати конфіденційну інформацію.
• Продуктивність накладних витрат: Пікування може бути повільнішим, ніж інші формати серіалізації (наприклад, буфери JSON або протоколу), які можуть впливати на програми ML та великої мовної моделі (LLM), коли швидкість виводу є критичною.
  • Наприклад: у програмі з обробки природної мови в реальному часі в режимі реального часу за допомогою LLM, важких маринованих або нерозумних операцій може зменшити чуйність та погіршити досвід користувачів.

Виявлення небезпечного невпинного інструментів аналізу статичного коду

Аналіз статичного коду (SCA) – це цінна практика для додатків, що стосуються маринованих даних, оскільки він допомагає виявити небезпечне малювання перед розгортанням. Інтегруючи інструменти SCA в робочий процес розробки, команди можуть помітити сумнівні схеми дезеріалізації, як тільки код буде вчинений. Цей проактивний підхід знижує ризик подій, пов’язаних із несподіваним виконанням коду або непередбачуваним доступом через небезпечне завантаження об'єктів.

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

Шаблони у вихідному коді

Існують різні способи завантаження соління в Python. У цьому контексті методи виявлення можуть бути пристосовані для безпечних звичок кодування та необхідних залежності пакетів. Багато бібліотек Python включають функцію для завантаження об'єктів соління. Ефективним підходом може бути каталогізація всіх бібліотек Python, що використовуються в проекті, а потім створити власні правила у своєму інструменті аналізу статичного коду для виявлення небезпечного марикації або безкурату в цих бібліотеках.

Кодигуру та інші засоби статичного аналізу продовжують розвивати свою здатність виявляти небезпечні шаблони малювання. Організації можуть використовувати ці інструменти та створювати власні правила для виявлення потенційних проблем безпеки в трубопроводах AI/ML.

Давайте визначимо кроки для створення безпечного процесу вирішення проблем з малюванням:

1. Створіть список усіх бібліотек Python, які використовуються у вашому сховищі чи середовищі.
2. Перевірте інструмент аналізу статичного коду у вашому трубопроводі наявність поточних правил та можливість додавання власних правил. Якщо інструмент здатний відкрити всі бібліотеки, які використовуються у вашому проекті, ви можете покластися на нього. Однак якщо він не в змозі виявити всі бібліотеки, що використовуються у вашому проекті, слід розглянути можливість додавання власних правил, що надаються користувачем, у ваш інструмент аналізу статичного коду.
3. Більшість питань можна визначити за допомогою добре розроблених, керованих контекстами шаблонів у інструменті аналізу статичного коду. Для вирішення проблем з малюванням вам потрібно визначити функції маринованих та нерозумних.
4. Впроваджуйте та протестуйте спеціальні правила, щоб перевірити повне покриття ризиків з малювання та незрозумілих. Давайте визначимо візерунки для кількох бібліотек:
   • Безглуздий може ефективно соління та розкуповувати масиви; Корисно для наукових обчислювальних робочих процесів, що потребують серіалізованих масивів. Щоб зловити потенційне небезпечне використання соління в Numpy, спеціальні правила можуть орієнтуватися на такі шаблони, як:

     import numpy as np
     data = np.load('data.npy', allow_pickle=True)

   • npyfile є утилітою для завантаження чисельних масивів з маринованих файлів. Ви можете додати наступні шаблони до своїх власних правил, щоб виявити потенційно небезпечне використання об'єкта соління.

     import npyfile
     data = npyfile.load('example.pkl')

   • панди Може пікл і розкути даних за допомогою Pickle, що забезпечує ефективне зберігання та пошук табличних даних. Ви можете додати наступні шаблони до своїх власних правил, щоб виявити потенційно небезпечне використання об'єкта соління.

     import pandas as pd
     df = pd.read_pickle('dataframe.pkl')

   • ладобіб Часто використовується для маринованих та незграбних об'єктів Python, які включають великі дані, особливо безлічі, більш ефективно, ніж стандартний соління. Ви можете додати наступні шаблони до своїх власних правил, щоб виявити потенційно небезпечне використання об'єкта соління.

     from joblib import load
     data = load('large_data.pkl')

   • Scikit-learn забезпечити joblib Для маринованих та непокірних об'єктів і особливо корисний для моделей. Ви можете додати наступні шаблони до своїх власних правил, щоб виявити потенційно небезпечне використання об'єкта соління.

     from sklearn.externals import joblib
     data = joblib.load('example.pkl')

   • Піторч Забезпечує утиліти для завантаження маринованих об'єктів, особливо корисних для моделей ML та тензорів. Ви можете додати наступні візерунки до власного формату правила, щоб виявити потенційно небезпечне використання об'єкта соління.

     import torch
     data = torch.load('example.pkl')

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

Ефективне пом'якшення

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

• Піторч
  • Використовуйте Safetensors для зберігання тензорів. Якщо піклування залишається необхідним, додайте перевірки цілісності (наприклад, хешування) для серіалізованих даних.
• панди
  • Перевірте джерела даних та цілісність при використанні pd.read_pickle. Заохочуйте безпечніші альтернативи (наприклад, CSV, HDF5 або Parquet), щоб уникнути ризиків малювання.
• scikit-learn (через Joblib)
  • Розгляньте Скопи для безпечнішої наполегливості. Якщо формати перемикання неможливі, реалізуйте суворі перевірки перевірки перед завантаженням.
• Загальна порада
  • Визначте безпечніші бібліотеки або методи, коли це можливо.
  • Перейдіть на такі формати, як CSV або JSON, для даних, якщо не є специфічна для об'єкта серіалізація.
  • Виконайте перевіри джерела та цілісності перед завантаженням файлів соління – навіть ті, що розглядаються довірений.

Приклад

Далі наведено приклад реалізації, який показує безпечну реалізацію соління як представлення попередньої інформації.

import io
import base64
import pickle
import boto3
import numpy as np
from cryptography.fernet import Fernet

###############################################################################
# 1) RESTRICTED UNPICKLER
###############################################################################
#
# By default, pickle can execute arbitrary code when loading. Here we implement
# a custom Unpickler that only allows certain safe modules/classes. Adjust this
# to your application's requirements.
#

class RestrictedUnpickler(pickle.Unpickler):
    """
    Restricts unpickling to only the modules/classes we explicitly allow.
    """
    allowed_modules = {
        "numpy": set(["ndarray", "dtype"]),
        "builtins": set(["tuple", "list", "dict", "set", "frozenset", "int", "float", "bool", "str"])
    }

    def find_class(self, module, name):
        if module in self.allowed_modules:
            if name in self.allowed_modules[module]:
                return super().find_class(module, name)
        # If not allowed, raise an error to prevent arbitrary code execution.
        raise pickle.UnpicklingError(f"Global '{module}.{name}' is forbidden")

def restricted_loads(data: bytes):
    """Helper function to load pickle data using the RestrictedUnpickler."""
    return RestrictedUnpickler(io.BytesIO(data)).load()

###############################################################################
# 2) AWS KMS & ENCRYPTION HELPERS
###############################################################################

def generate_data_key(kms_key_id: str, region: str = "us-east-1"):
    """
    Generates a fresh data key using AWS KMS. 
    Returns (plaintext_key, encrypted_data_key).
    """
    kms_client = boto3.client("kms", region_name=region)
    response = kms_client.generate_data_key(KeyId=kms_key_id, KeySpec="AES_256")
    
    # Plaintext data key (use to encrypt the pickle data locally)
    plaintext_key = response["Plaintext"]
    # Encrypted data key (store along with your ciphertext)
    encrypted_data_key = response["CiphertextBlob"]
    return plaintext_key, encrypted_data_key

def decrypt_data_key(encrypted_data_key: bytes, region: str = "us-east-1"):
    """
    Decrypts the encrypted data key via AWS KMS, returning the plaintext key.
    """
    kms_client = boto3.client("kms", region_name=region)
    response = kms_client.decrypt(CiphertextBlob=encrypted_data_key)
    return response["Plaintext"]

def build_fernet_key(plaintext_key: bytes) -> Fernet:
    """
    Construct a Fernet instance from a 32-byte data key.
    Fernet requires a 32-byte key *encoded* in URL-safe base64.
    """
    if len(plaintext_key)  np.ndarray:
    """
    Download the ciphertext and the encrypted data key from S3. Decrypt the data 
    key with KMS, use it to decrypt the pickled data, then load with a restricted 
    unpickler for safety.
    """
    s3_client = boto3.client("s3", region_name=region)
    
    # 1. Get object from S3
    response = s3_client.get_object(Bucket=bucket_name, Key=s3_key)
    
    # 2. Extract the encrypted data key from metadata
    metadata = response["Metadata"]
    encrypted_data_key_b64 = metadata.get("encrypted_data_key")
    if not encrypted_data_key_b64:
        raise ValueError("Missing encrypted_data_key in S3 object metadata.")
    
    encrypted_data_key = base64.b64decode(encrypted_data_key_b64)
    
    # 3. Decrypt data key via KMS
    plaintext_key = decrypt_data_key(encrypted_data_key, region)
    fernet = build_fernet_key(plaintext_key)
    
    # 4. Decrypt the pickled data
    encrypted_data = response["Body"].read()
    decrypted_pickled_data = fernet.decrypt(encrypted_data)
    
    # 5. Use restricted unpickler to load the numpy object
    numpy_obj = restricted_loads(decrypted_pickled_data)
    
    return numpy_obj

###############################################################################
# DEMO USAGE
###############################################################################

if __name__ == "__main__":
    # --- Replace with your actual values ---
    KMS_KEY_ID = "arn:aws:kms:us-east-1:123456789012:key/your-kms-key-id"
    BUCKET_NAME = "your-secure-bucket"
    S3_OBJECT_KEY = "encrypted_npy_demo.bin"
    AWS_REGION = "us-east-1"  # or region of your choice
    
    # Example numpy array
    original_array = np.random.rand(2, 3)
    print("Original Array:")
    print(original_array)
    
    # Upload (pickle + encrypt) to S3
    upload_pickled_data_s3(
        numpy_obj=original_array,
        bucket_name=BUCKET_NAME,
        s3_key=S3_OBJECT_KEY,
        kms_key_id=KMS_KEY_ID,
        region=AWS_REGION
    )
    
    # Download (decrypt + unpickle) from S3
    retrieved_array = download_and_unpickle_data_s3(
        bucket_name=BUCKET_NAME,
        s3_key=S3_OBJECT_KEY,
        region=AWS_REGION
    )
    
    print("\nRetrieved Array:")
    print(retrieved_array)
    
    # Verify integrity
    assert np.allclose(original_array, retrieved_array), "Arrays do not match!"
    print("\nSuccess! The retrieved array matches the original array.")

Висновок

Завдяки швидкому розширенню хмарних технологій, все більш важливим є інтеграція аналізу статичного коду в процес розвитку AI/ML. У той час, як піклування пропонує потужний спосіб серіалізувати об'єкти для додатків AI/ML та LLM, ви можете зменшити потенційні ризики, застосовуючи ручні огляди захищених кодів, налаштування автоматизованої SCA за допомогою спеціальних правил та дотримуючись найкращих практик, таких як використання альтернативних методів серіалізації або перевірка цілісності даних.

Працюючи з ML-моделями на AWS, дивіться добре архітований об'єктив машинного навчання AWS для керівництва щодо безпечної архітектури та рекомендованих практик. Поєднуючи ці підходи, ви можете підтримувати сильну позицію безпеки та впорядкувати життєвий цикл розвитку AI/ML.

Якщо у вас є відгуки про цю публікацію, надішліть коментарі в Коментарі Розділ нижче. Якщо у вас є питання щодо цієї публікації, зверніться до підтримки AWS.