Translated ['src/pentesting-cloud/aws-security/aws-post-exploitation/aws

src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md

@@ -4,7 +4,7 @@
 
 ## Lambda
 
-Per maggiori informazioni controlla:
+Per maggiori informazioni consulta:
 
 {{#ref}}
 ../../aws-services/aws-lambda-enum.md
@@ -12,7 +12,7 @@ Per maggiori informazioni controlla:
 
 ### Lambda Layer Persistence
 
-È possibile **introdurre/backdoor un layer per eseguire codice arbitrario** quando la Lambda viene eseguita in modo stealth:
+È possibile **introduce/backdoor a layer to execute arbitrary code** quando la lambda viene eseguita in modo stealthy:
 
 {{#ref}}
 aws-lambda-layers-persistence.md
@@ -20,7 +20,7 @@ aws-lambda-layers-persistence.md
 
 ### Lambda Extension Persistence
 
-Abusando dei Lambda Layers è anche possibile sfruttare le extension per persistere nella Lambda ma anche per rubare e modificare le richieste.
+Abusing Lambda Layers è anche possibile abusare delle extensions e persist in the lambda ma anche rubare e modificare le requests.
 
 {{#ref}}
 aws-abusing-lambda-extensions.md
@@ -28,42 +28,42 @@ aws-abusing-lambda-extensions.md
 
 ### Via resource policies
 
-È possibile concedere accesso a diverse azioni su Lambda (come invoke o update code) ad account esterni:
+È possibile concedere accesso a diverse lambda actions (such as invoke or update code) ad account esterni:
 
 <figure><img src="../../../../images/image (255).png" alt=""><figcaption></figcaption></figure>
 
 ### Versions, Aliases & Weights
 
-Una Lambda può avere **diverse versioni** (con codice differente per ogni versione).\
-Poi, puoi creare **diversi alias con versioni differenti** della Lambda e impostare pesi diversi per ciascuno.\
-In questo modo un attacker potrebbe creare una **versione backdoored 1** e una **versione 2 con solo il codice legittimo** ed **eseguire la versione 1 solo nell'1%** delle richieste per rimanere stealth.
+Una Lambda può avere **different versions** (con codice diverso in ogni versione).\
+Poi, puoi creare **different aliases with different versions** della lambda e assegnare diversi weights a ciascuna.\
+In questo modo un attacker potrebbe creare una **backdoored version 1** e una **version 2 with only the legit code** e **only execute the version 1 in 1%** delle richieste per rimanere stealth.
 
 <figure><img src="../../../../images/image (120).png" alt=""><figcaption></figcaption></figure>
 
 ### Version Backdoor + API Gateway
 
 1. Copia il codice originale della Lambda
-2. **Crea una nuova versione backdooring** il codice originale (o semplicemente con codice maligno). Pubblica e **deploia quella versione** su $LATEST
-1. Chiama l'API Gateway correlata alla Lambda per eseguire il codice
-3. **Crea una nuova versione con il codice originale**, Pubblica e deploia quella **versione** su $LATEST.
+2. **Create a new version backdooring** il codice originale (o solo con codice malevolo). Publish e **deploy that version** su $LATEST
+1. Call the API gateway related to the lambda to execute the code
+3. **Create a new version with the original code**, Publish e deploy that **version** su $LATEST.
 1. Questo nasconderà il codice backdoored in una versione precedente
-4. Vai su API Gateway e **crea un nuovo metodo POST** (o scegli qualsiasi altro metodo) che eseguirà la versione backdoored della Lambda: `arn:aws:lambda:us-east-1:<acc_id>:function:<func_name>:1`
-1. Nota il finale :1 dell'arn **che indica la versione della function** (la versione 1 sarà quella backdoored in questo scenario).
-5. Seleziona il metodo POST creato e nelle Actions seleziona **`Deploy API`**
-6. Ora, quando **chiami la function via POST your Backdoor** verrà invocato
+4. Vai all'API Gateway e **create a new POST method** (o scegli un altro metodo) che eseguirà la backdoored version della lambda: `arn:aws:lambda:us-east-1:<acc_id>:function:<func_name>:1`
+1. Nota il finale :1 dell'arn **indicating the version of the function** (version 1 will be the backdoored one in this scenario).
+5. Seleziona il metodo POST creato e in Actions seleziona **`Deploy API`**
+6. Ora, quando **call the function via POST your Backdoor** verrà invocata
 
 ### Cron/Event actuator
 
-Il fatto che tu possa far **eseguire funzioni Lambda quando succede qualcosa o quando passa del tempo** rende Lambda un modo comune e utile per ottenere persistenza ed evitare il rilevamento.\
-Qui ci sono alcune idee per rendere la tua **presenza in AWS più stealth creando Lambda**.
+Il fatto che puoi far **lambda functions run when something happen or when some time pass** rende Lambda un modo comune e utile per ottenere persistence e evitare il rilevamento.\
+Qui hai alcune idee per rendere la tua **presence in AWS more stealth by creating lambdas**.
 
-- Ogni volta che viene creato un nuovo user, una lambda genera una nuova user key e la invia all'attacker.
-- Ogni volta che viene creato un nuovo role, una lambda assegna permessi di assume role agli utenti compromessi.
+- Ogni volta che viene creato un nuovo user, lambda genera una nuova user key e la invia all'attacker.
+- Ogni volta che viene creato un nuovo role, lambda concede assume role permissions agli users compromessi.
 - Ogni volta che vengono generati nuovi cloudtrail logs, cancellali/modificali
 
 ### RCE abusing AWS_LAMBDA_EXEC_WRAPPER + Lambda Layers
 
-Abusa della variabile d'ambiente `AWS_LAMBDA_EXEC_WRAPPER` per eseguire uno wrapper script controllato dall'attacker prima che il runtime/handler inizi. Distribuisci lo wrapper tramite un Lambda Layer in `/opt/bin/htwrap`, imposta `AWS_LAMBDA_EXEC_WRAPPER=/opt/bin/htwrap`, e poi invoca la function. Lo wrapper gira all'interno del processo runtime della function, eredita il ruolo di esecuzione della function, e infine esegue con `exec` il runtime reale così che l'handler originale continui a essere eseguito normalmente.
+Abusa della variabile d'ambiente `AWS_LAMBDA_EXEC_WRAPPER` per eseguire uno script wrapper controllato dall'attacker prima che il runtime/handler inizi. Distribuisci il wrapper tramite una Lambda Layer in `/opt/bin/htwrap`, imposta `AWS_LAMBDA_EXEC_WRAPPER=/opt/bin/htwrap`, e poi invoca la function. Il wrapper gira all'interno del processo runtime della function, eredita la function execution role e infine `exec`s il vero runtime in modo che l'handler originale venga comunque eseguito normalmente.
 
 {{#ref}}
 aws-lambda-exec-wrapper-persistence.md
@@ -71,7 +71,7 @@ aws-lambda-exec-wrapper-persistence.md
 
 ### AWS - Lambda Function URL Public Exposure
 
-Abusa delle asynchronous destinations di Lambda insieme alla configurazione di Recursion per far sì che una function si reinvii continuamente senza uno scheduler esterno (nessun EventBridge, cron, ecc.). Di default, Lambda termina i loop ricorsivi, ma impostando la recursion config su Allow li si riabilita. Le destinations eseguono la consegna lato servizio per gli invoke asincroni, quindi un singolo invoke seed crea un canale stealthy, senza codice, per heartbeat/backdoor. Opzionalmente limita il traffico con reserved concurrency per mantenere il rumore basso.
+Abuse Lambda asynchronous destinations insieme alla Recursion configuration per far sì che una function si richiami continuamente da sola senza uno scheduler esterno (no EventBridge, cron, etc.). Di default, Lambda termina i loop ricorsivi, ma impostando la recursion config su Allow li riabiliti. Le destinations consegnano lato servizio per gli invoke asincroni, quindi un singolo seed invoke crea un canale stealthy, code-free per heartbeat/backdoor. Opzionalmente limita con reserved concurrency per mantenere basso il rumore.
 
 {{#ref}}
 aws-lambda-async-self-loop-persistence.md
@@ -79,9 +79,9 @@ aws-lambda-async-self-loop-persistence.md
 
 ### AWS - Lambda Alias-Scoped Resource Policy Backdoor
 
-Crea una versione nascosta della Lambda con la logica dell'attacker e scope una resource-based policy a quella specifica versione (o alias) usando il parametro `--qualifier` in `lambda add-permission`. Concedi solo `lambda:InvokeFunction` su `arn:aws:lambda:REGION:ACCT:function:FN:VERSION` a un principal attacker. Le invocazioni normali via nome della function o alias primario rimangono invariate, mentre l'attacker può invocare direttamente l'ARN della versione backdoored.
+Crea una Lambda version nascosta con la logica dell'attacker e scope una resource-based policy a quella specifica version (o alias) usando il parametro `--qualifier` in `lambda add-permission`. Concedi solo `lambda:InvokeFunction` su `arn:aws:lambda:REGION:ACCT:function:FN:VERSION` a un attacker principal. Le invocazioni normali tramite il nome della function o l'alias primario restano inalterate, mentre l'attacker può invocare direttamente l'ARN della versione backdoored.
 
-Questo è più stealth rispetto all'esporre una Function URL e non cambia l'alias di traffico primario.
+Questo è più stealthier che esporre una Function URL e non cambia l'alias del traffico primario.
 
 {{#ref}}
 aws-lambda-alias-version-policy-backdoor.md
@@ -89,9 +89,9 @@ aws-lambda-alias-version-policy-backdoor.md
 
 ### Freezing AWS Lambda Runtimes
 
-Un attacker che abbia i permessi lambda:InvokeFunction, logs:FilterLogEvents, lambda:PutRuntimeManagementConfig, e lambda:GetRuntimeManagementConfig può modificare la runtime management configuration di una function. Questo attacco è particolarmente efficace quando l'obiettivo è mantenere una Lambda su una versione di runtime vulnerabile o preservare la compatibilità con layer maligni che potrebbero essere incompatibili con runtime più recenti.
+Un attacker che possiede i permessi lambda:InvokeFunction, logs:FilterLogEvents, lambda:PutRuntimeManagementConfig, e lambda:GetRuntimeManagementConfig può modificare la runtime management configuration di una function. Questo attacco è particolarmente efficace quando l'obiettivo è mantenere una Lambda function su una runtime version vulnerabile o preservare la compatibilità con malicious layers che potrebbero essere incompatibili con runtime più recenti.
 
-L'attacker modifica la runtime management configuration per fissare la versione del runtime:
+L'attacker modifica la runtime management configuration per pin the runtime version:
 ```bash
 # Invoke the function to generate runtime logs
 aws lambda invoke \
@@ -107,13 +107,13 @@ aws lambda put-runtime-management-config \
 --update-runtime-on FunctionUpdate \
 --region us-east-1
 ```
-Verifica la configurazione applicata:
+Verificare la configurazione applicata:
 ```bash
 aws lambda get-runtime-management-config \
 --function-name $TARGET_FN \
 --region us-east-1
 ```
-Opzionale: bloccare su una versione specifica del runtime
+Opzionale: fissare a una versione specifica del runtime
 ```bash
 # Extract Runtime Version ARN from INIT_START logs
 RUNTIME_ARN=$(aws logs filter-log-events \
@@ -122,7 +122,7 @@ RUNTIME_ARN=$(aws logs filter-log-events \
 --query 'events[0].message' \
 --output text | grep -o 'Runtime Version ARN: [^,]*' | cut -d' ' -f4)
 ```
-Blocca su una versione specifica del runtime:
+Fissare una versione specifica del runtime:
 ```bash
 aws lambda put-runtime-management-config \
 --function-name $TARGET_FN \