V1.11.2 Business Logic Architecture

Requirement:

Verify that all high-value business logic flows, including authentication, session management and access control, do not share unsynchronized state.

Explanation:

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

1. High-Value Business Logic Flows:

К ним относятся такие критически важные функции приложения, как аутентификация пользователей, управление сессиями и контроль доступа. Недостатки в этих областях могут привести к уязвимостям в системе безопасности и несанкционированному доступу, что делает их приоритетными объектами для обеспечения безопасности.

2. Shared Unsynchronized State:

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

3. Data Integrity:

Когда критически важные процессы совместно используют несинхронизированное состояние, это может привести к повреждению или несогласованности данных. Например, одновременный доступ к данным сессии одного и того же пользователя может привести к непредсказуемому поведению.

4. Security Risks:

Несинхронизированное состояние может создавать риски для безопасности. Например, если несколько потоков или процессов могут одновременно изменять правила управления доступом, это может привести к несанкционированному доступу к определенным ресурсам.

5. Concurrency Bugs:

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

6. Inconsistent Behavior:

Непоследовательное поведение при аутентификации и управлении сессиями может привести к неожиданному входу или выходу пользователей из системы, что создаcт потенциальные проблемы безопасности.

К примеру, рассмотрим сценарий, в котором несколько пользователей могут одновременно обновлять профиль общей учетной записи. Для предотвращения несинхронизированного состояния можно использовать блокировку записи в базе данных, чтобы гарантировать, что только один пользователь мог изменять профиль. Если другой пользователь попытается обновить свой профиль, пока он заблокирован, то он получит уведомление о том, что профиль в данный момент редактируется другим пользователем, что обеспечит целостность и последовательность данных.

Remediation:

Чтобы выполнить данное требование и гарантировать, что критически важные процессы не будут использовать несинхронизированное состояние, необходимо выполнять следующее:

1. Use Synchronization Mechanisms:

Реализовать механизмы синхронизации, такие как блокировки или semaphores, для контроля доступа к общим ресурсам и обеспечения того, что только один поток или процесс может одновременно изменять состояние.

2. Thread-Safe Data Structures:

При работе с совместно используемыми данными применять безопасные структуры данных и библиотеки. Это необходимо для безопасной обработки параллельного доступа.

3. Session Management:

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

4. Access Control:

Реализовать механизмы управления доступом, обеспечивающие последовательное применение прав доступа и ролей независимо от одновременного доступа.

5. Testing for Concurrency Issues:     

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

6. Audit and Monitoring:

Для выявления и расследования нестандартного поведения или несанкционированного доступа, вызванного проблемами параллелизма, следует внедрить логирование и мониторинг аудита.

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

import threading

import time

# User database (simulated)

user_database = {

'user1': {'password': 'pass123', 'logged_in': False},

'user2': {'password': 'secret456', 'logged_in': False},

}

# Session management class with thread-safe state

class SessionManager:

def __init__(self):

self.sessions = {} # Store user sessions

self.lock = threading.Lock() # Lock for thread safety

def create_session(self, user_id):

with self.lock:

# Check if the user is already logged in

if user_id in self.sessions:

return "User is already logged in"

# Create a new session

self.sessions[user_id] = True

return "Session created"

def destroy_session(self, user_id):

with self.lock:

# Check if the user is logged in

if user_id in self.sessions:

del self.sessions[user_id]

return "Session destroyed"

else:

return "User is not logged in"

def is_user_logged_in(self, user_id):

with self.lock:

# Check if the user is logged in

return user_id in self.sessions

# Simulate user authentication and session management

def simulate_user_authentication(session_manager, username, password):

if username not in user_database:

print("User not found")

return

if user_database[username]['password'] == password:

print(f"User {username} logged in successfully")

session_manager.create_session(username)

time.sleep(1)

session_manager.destroy_session(username)

else:

print("Invalid credentials")

if __name__ == '__main__':

session_manager = SessionManager()

# Simulate multiple users trying to log in concurrently

threads = []

for i in range(2):

username = f'user{i+1}'

password = 'pass123' if i == 0 else 'wrong_password'

thread = threading.Thread(target=simulate_user_authentication, args=(session_manager, username, password))

threads.append(thread)

thread.start()

# Wait for all threads to finish

for thread in threads:

thread.join()

В данном примере:

• У нас есть смоделированная база данных пользователей с двумя пользователями и их паролями.
• Класс SessionManager предназначен для безопасной обработки, создания и удаления сессий с помощью блокировки (self.lock).
• Несколько потоков имитируют одновременные попытки пользователей войти в систему с потенциально правильными или неправильными учетными данными.

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

Additional:

https://www.cvedetails.com/vulnerability-list/cweid-362/vulnerabilities.html

https://cwe.mitre.org/data/definitions/362.html