Translated ['src/README.md', 'src/banners/hacktricks-training.md', 'src/

2025-12-29 06:03:26 -08:00 · 2024-12-31 20:42:16 +00:00
parent 4ecda9fe96
commit 92eaf7ce11
245 changed files with 9813 additions and 12533 deletions
--- a/src/pentesting-cloud/aws-security/aws-services/aws-stepfunctions-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-stepfunctions-enum.md
@@ -4,266 +4,253 @@

 ## Step Functions

-AWS Step Functions is a workflow service that enables you to coordinate and orchestrate multiple AWS services into serverless workflows. By using AWS Step Functions, you can design and run workflows that connect various AWS services such as AWS Lambda, Amazon S3, Amazon DynamoDB, and many more, in a sequence of steps. This orchestration service provides a visual workflow interface and offers **state machine** capabilities, allowing you to define each step of the workflow in a declarative manner using JSON-based **Amazon States Language** (ASL).
+AWS Step Functions - це сервіс робочих процесів, який дозволяє вам координувати та організовувати кілька сервісів AWS у безсерверні робочі процеси. Використовуючи AWS Step Functions, ви можете проектувати та виконувати робочі процеси, які з'єднують різні сервіси AWS, такі як AWS Lambda, Amazon S3, Amazon DynamoDB та багато інших, у послідовності кроків. Цей сервіс оркестрації надає візуальний інтерфейс робочого процесу та пропонує можливості **машини станів**, що дозволяє вам визначати кожен крок робочого процесу декларативним чином, використовуючи JSON-формат **Amazon States Language** (ASL).

 ## Key concepts

 ### Standard vs. Express Workflows

-AWS Step Functions offers two types of **state machine workflows**: Standard and Express.
+AWS Step Functions пропонує два типи **робочих процесів машини станів**: Standard та Express.

- **Standard Workflow**: This default workflow type is designed for long-running, durable, and auditable processes. It supports **exactly-once execution**, ensuring tasks run only once unless retries are specified. It is ideal for workflows needing detailed execution history and can run for up to one year.
- **Express Workflow**: This type is ideal for high-volume, short-duration tasks, running up to five minutes. They support **at-least-once execution**, suitable for idempotent tasks like data processing. These workflows are optimized for cost and performance, charging based on executions, duration, and memory usage.
+- **Standard Workflow**: Цей тип робочого процесу за замовчуванням призначений для тривалих, надійних та аудиторських процесів. Він підтримує **точне виконання один раз**, забезпечуючи виконання завдань лише один раз, якщо не вказані повторні спроби. Ідеально підходить для робочих процесів, які потребують детальної історії виконання, і може працювати до одного року.
+- **Express Workflow**: Цей тип ідеально підходить для завдань з високим обсягом та короткою тривалістю, що тривають до п'яти хвилин. Вони підтримують **виконання принаймні один раз**, що підходить для ідемпотентних завдань, таких як обробка даних. Ці робочі процеси оптимізовані для витрат та продуктивності, стягуючи плату на основі виконань, тривалості та використання пам'яті.

 ### States

-States are the essential units of state machines. They define the individual steps within a workflow, being able to perform a variety of functions depending on its type:
+Стан є основними одиницями машин станів. Вони визначають окремі кроки в робочому процесі, здатні виконувати різноманітні функції в залежності від їх типу:

- **Task:** Executes a job, often using an AWS service like Lambda.
- **Choice:** Makes decisions based on input.
- **Fail/Succeed:** Ends the execution with a failure or success.
- **Pass:** Passes input to output or injects data.
- **Wait:** Delays execution for a set time.
- **Parallel:** Initiates parallel branches.
- **Map:** Dynamically iterates steps over items.
+- **Task:** Виконує завдання, часто використовуючи сервіс AWS, такий як Lambda.
+- **Choice:** Приймає рішення на основі вхідних даних.
+- **Fail/Succeed:** Завершує виконання з помилкою або успіхом.
+- **Pass:** Передає вхідні дані на вихід або вводить дані.
+- **Wait:** Затримує виконання на певний час.
+- **Parallel:** Ініціює паралельні гілки.
+- **Map:** Динамічно ітерує кроки над елементами.

 ### Task

-A **Task** state represents a single unit of work executed by a state machine. Tasks can invoke various resources, including activities, Lambda functions, AWS services, or third-party APIs.
+Стан **Task** представляє собою єдину одиницю роботи, виконувану машиною станів. Завдання можуть викликати різні ресурси, включаючи активності, функції Lambda, сервіси AWS або сторонні API.

- **Activities**: Custom workers you manage, suitable for long-running processes.
-  - Resource: **`arn:aws:states:region:account:activity:name`**.
- **Lambda Functions**: Executes AWS Lambda functions.
-  - Resource: **`arn:aws:lambda:region:account:function:function-name`**.
- **AWS Services**: Integrates directly with other AWS services, like DynamoDB or S3.
-  - Resource: **`arn:partition:states:region:account:servicename:APIname`**.
- **HTTP Task**: Calls third-party APIs.
-  - Resource field: **`arn:aws:states:::http:invoke`**. Then, you should provide the API endpoint configuration details, such as the API URL, method, and authentication details.
-
-The following example shows a Task state definition that invokes a Lambda function called HelloWorld:
+- **Activities**: Користувацькі працівники, які ви керуєте, підходять для тривалих процесів.
+- Ресурс: **`arn:aws:states:region:account:activity:name`**.
+- **Lambda Functions**: Виконує функції AWS Lambda.
+- Ресурс: **`arn:aws:lambda:region:account:function:function-name`**.
+- **AWS Services**: Інтегрується безпосередньо з іншими сервісами AWS, такими як DynamoDB або S3.
+- Ресурс: **`arn:partition:states:region:account:servicename:APIname`**.
+- **HTTP Task**: Викликає сторонні API.
+- Поле ресурсу: **`arn:aws:states:::http:invoke`**. Потім ви повинні надати деталі конфігурації кінцевої точки API, такі як URL API, метод та деталі аутентифікації.

+Наступний приклад показує визначення стану Task, який викликає функцію Lambda під назвою HelloWorld:
 ```json
 "HelloWorld": {
-  "Type": "Task",
-  "Resource": "arn:aws:states:::lambda:invoke",
-  "Parameters": {
-    "Payload.$": "$",
-    "FunctionName": "arn:aws:lambda:<region>:<account-id>:function:HelloWorld"
-  },
-  "End": true
+"Type": "Task",
+"Resource": "arn:aws:states:::lambda:invoke",
+"Parameters": {
+"Payload.$": "$",
+"FunctionName": "arn:aws:lambda:<region>:<account-id>:function:HelloWorld"
+},
+"End": true
 }
 ```
-
 ### Choice

-A **Choice** state adds conditional logic to a workflow, enabling decisions based on input data. It evaluates the specified conditions and transitions to the corresponding state based on the results.
+Стан **Choice** додає умовну логіку до робочого процесу, що дозволяє приймати рішення на основі вхідних даних. Він оцінює вказані умови та переходить до відповідного стану на основі результатів.

- **Comparison**: Each choice rule includes a comparison operator (e.g., **`NumericEquals`**, **`StringEquals`**) that compares an input variable to a specified value or another variable.
- **Next Field**: Choice states do not support don't support the **`End`** field, instead, they define the **`Next`** state to transition to if the comparison is true.
-
-Example of **Choice** state:
+- **Comparison**: Кожне правило вибору включає оператор порівняння (наприклад, **`NumericEquals`**, **`StringEquals`**), який порівнює вхідну змінну з вказаним значенням або іншою змінною.
+- **Next Field**: Стан вибору не підтримує поле **`End`**, натомість вони визначають стан **`Next`**, до якого потрібно перейти, якщо порівняння є істинним.

+Приклад стану **Choice**:
 ```json
 {
-  "Variable": "$.timeStamp",
-  "TimestampEquals": "2000-01-01T00:00:00Z",
-  "Next": "TimeState"
+"Variable": "$.timeStamp",
+"TimestampEquals": "2000-01-01T00:00:00Z",
+"Next": "TimeState"
 }
 ```
-
 ### Fail/Succeed

-A **`Fail`** state stops the execution of a state machine and marks it as a failure. It is used to specify an error name and a cause, providing details about the failure. This state is terminal, meaning it ends the execution flow.
+Стан **`Fail`** зупиняє виконання машини станів і позначає його як невдале. Він використовується для вказівки назви помилки та причини, надаючи деталі про невдачу. Цей стан є термінальним, що означає, що він завершує потік виконання.

-A **`Succeed`** state stops the execution successfully. It is typically used to terminate the workflow when it completes successfully. This state does not require a **`Next`** field.
+Стан **`Succeed`** зупиняє виконання успішно. Він зазвичай використовується для завершення робочого процесу, коли він успішно завершується. Цей стан не вимагає поля **`Next`**.

 {{#tabs }}
 {{#tab name="Fail example" }}
-
 ```json
 "FailState": {
-  "Type": "Fail",
-  "Error": "ErrorName",
-  "Cause": "Error details"
+"Type": "Fail",
+"Error": "ErrorName",
+"Cause": "Error details"
 }
 ```
-
 {{#endtab }}

-{{#tab name="Succeed example" }}
-
+{{#tab name="Приклад успіху" }}
 ```json
 "SuccessState": {
-  "Type": "Succeed"
+"Type": "Succeed"
 }
 ```
-
 {{#endtab }}
 {{#endtabs }}

 ### Pass

-A **Pass** state passes its input to its output either without performing any work or transformin JSON state input using filters, and then passing the transformed data to the next state. It is useful for testing and constructing state machines, allowing you to inject static data or transform it.
-
+Стан **Pass** передає свій вхідний сигнал на вихід або без виконання будь-якої роботи, або перетворюючи вхідний JSON стан за допомогою фільтрів, а потім передаючи перетворені дані до наступного стану. Це корисно для тестування та побудови станів машин, дозволяючи вам впроваджувати статичні дані або перетворювати їх.
 ```json
 "PassState": {
-  "Type": "Pass",
-  "Result": {"key": "value"},
-  "ResultPath": "$.newField",
-  "Next": "NextState"
+"Type": "Pass",
+"Result": {"key": "value"},
+"ResultPath": "$.newField",
+"Next": "NextState"
+}
+```
+### Wait
+
+Стан **Wait** затримує виконання машини станів на вказаний проміжок часу. Є три основні методи для налаштування часу очікування:
+
+- **X Seconds**: Фіксована кількість секунд для очікування.
+
+```json
+"WaitState": {
+"Type": "Wait",
+"Seconds": 10,
+"Next": "NextState"
 }
 ```

-### Wait
+- **Absolute Timestamp**: Точний час, до якого потрібно чекати.

-A **Wait** state delays the execution of the state machine for a specified duration. There are three primary methods to configure the wait time:
+```json
+"WaitState": {
+"Type": "Wait",
+"Timestamp": "2024-03-14T01:59:00Z",
+"Next": "NextState"
+}
+```

- **X Seconds**: A fixed number of seconds to wait.
+- **Dynamic Wait**: На основі вхідних даних за допомогою **`SecondsPath`** або **`TimestampPath`**.

-  ```json
-  "WaitState": {
-  	"Type": "Wait",
-  	"Seconds": 10,
-  	"Next": "NextState"
-  }
-  ```
-
- **Absolute Timestamp**: An exact time to wait until.
-
-  ```json
-  "WaitState": {
-    "Type": "Wait",
-    "Timestamp": "2024-03-14T01:59:00Z",
-    "Next": "NextState"
-  }
-  ```
-
- **Dynamic Wait**: Based on input using **`SecondsPath`** or **`TimestampPath`**.
-
-  ```json
-  jsonCopiar código
-  "WaitState": {
-    "Type": "Wait",
-    "TimestampPath": "$.expirydate",
-    "Next": "NextState"
-  }
-  ```
+```json
+jsonCopiar código
+"WaitState": {
+"Type": "Wait",
+"TimestampPath": "$.expirydate",
+"Next": "NextState"
+}
+```

 ### Parallel

-A **Parallel** state allows you to execute multiple branches of tasks concurrently within your workflow. Each branch runs independently and processes its own sequence of states. The execution waits until all branches complete before proceeding to the next state. Its key fields are:
-
- **Branches**: An array defining the parallel execution paths. Each branch is a separate state machine.
- **ResultPath**: Defines where (in the input) to place the combined output of the branches.
- **Retry and Catch**: Error handling configurations for the parallel state.
+Стан **Parallel** дозволяє виконувати кілька гілок завдань одночасно у вашому робочому процесі. Кожна гілка виконується незалежно та обробляє свою власну послідовність станів. Виконання чекає, поки всі гілки завершаться, перш ніж перейти до наступного стану. Його ключові поля:

+- **Branches**: Масив, що визначає паралельні шляхи виконання. Кожна гілка є окремою машиною станів.
+- **ResultPath**: Визначає, де (вхідних даних) розмістити об'єднаний вихід гілок.
+- **Retry and Catch**: Налаштування обробки помилок для паралельного стану.
 ```json
 "ParallelState": {
-  "Type": "Parallel",
-  "Branches": [
-    {
-      "StartAt": "Task1",
-      "States": { ... }
-    },
-    {
-      "StartAt": "Task2",
-      "States": { ... }
-    }
-  ],
-  "Next": "NextState"
+"Type": "Parallel",
+"Branches": [
+{
+"StartAt": "Task1",
+"States": { ... }
+},
+{
+"StartAt": "Task2",
+"States": { ... }
+}
+],
+"Next": "NextState"
+}
+```
+### Map
+
+Стан **Map** дозволяє виконання набору кроків для кожного елемента в наборі даних. Він використовується для паралельної обробки даних. В залежності від того, як ви хочете обробляти елементи набору даних, Step Functions надає наступні режими:
+
+- **Inline Mode**: Виконує підмножину станів для кожного елемента JSON масиву. Підходить для маломасштабних завдань з менше ніж 40 паралельними ітераціями, виконуючи кожну з них в контексті робочого процесу, що містить стан **`Map`**.
+
+```json
+"MapState": {
+"Type": "Map",
+"ItemsPath": "$.arrayItems",
+"ItemProcessor": {
+"ProcessorConfig": {
+"Mode": "INLINE"
+},
+"StartAt": "AddState",
+"States": {
+"AddState": {
+"Type": "Task",
+"Resource": "arn:aws:states:::lambda:invoke",
+"OutputPath": "$.Payload",
+"Parameters": {
+"FunctionName": "arn:aws:lambda:<region>:<account-id>:function:add-function"
+},
+"End": true
+}
+}
+},
+"End": true
+"ResultPath": "$.detail.added",
+"ItemsPath": "$.added"
 }
 ```

-### Map
+- **Distributed Mode**: Призначений для великомасштабної паралельної обробки з високою конкурентністю. Підтримує обробку великих наборів даних, таких як ті, що зберігаються в Amazon S3, що дозволяє високій конкурентності до 10,000 паралельних виконань дочірніх робочих процесів, виконуючи ці дочірні як окреме дочірнє виконання.

-A **Map** state enables the execution of a set of steps for each item in an dataset. It's used for parallel processing of data. Depending on how you want to process the items of the dataset, Step Functions provides the following modes:
-
- **Inline Mode**: Executes a subset of states for each JSON array item. Suitable for small-scale tasks with less than 40 parallel iterations, running each of them in the context of the workflow that contains the **`Map`** state.
-
-  ```json
-  "MapState": {
-    "Type": "Map",
-    "ItemsPath": "$.arrayItems",
-    "ItemProcessor": {
-        "ProcessorConfig": {
-            "Mode": "INLINE"
-        },
-        "StartAt": "AddState",
-        "States": {
-            "AddState": {
-                "Type": "Task",
-                "Resource": "arn:aws:states:::lambda:invoke",
-                "OutputPath": "$.Payload",
-                "Parameters": {
-                    "FunctionName": "arn:aws:lambda:<region>:<account-id>:function:add-function"
-                },
-                "End": true
-            }
-        }
-    },
-    "End": true
-    "ResultPath": "$.detail.added",
-    "ItemsPath": "$.added"
-  }
-  ```
-
- **Distributed Mode**: Designed for large-scale parallel processing with high concurrency. Supports processing large datasets, such as those stored in Amazon S3, enabling a high concurrency of up 10,000 parallel child workflow executions, running these child as a separate child execution.
-
-  ```json
-  "DistributedMapState": {
-    "Type": "Map",
-    "ItemReader": {
-      "Resource": "arn:aws:states:::s3:getObject",
-      "Parameters": {
-        "Bucket": "my-bucket",
-        "Key": "data.csv"
-      }
-    },
-    "ItemProcessor": {
-      "ProcessorConfig": {
-        "Mode": "DISTRIBUTED",
-        "ExecutionType": "EXPRESS"
-      },
-      "StartAt": "ProcessItem",
-      "States": {
-        "ProcessItem": {
-          "Type": "Task",
-          "Resource": "arn:aws:lambda:region:account-id:function:my-function",
-          "End": true
-  	    }
-      }
-    },
-    "End": true
-    "ResultWriter": {
-      "Resource": "arn:aws:states:::s3:putObject",
-      "Parameters": {
-        "Bucket": "myOutputBucket",
-        "Prefix": "csvProcessJobs"
-  	  }
-  	}
-  }
-  ```
+```json
+"DistributedMapState": {
+"Type": "Map",
+"ItemReader": {
+"Resource": "arn:aws:states:::s3:getObject",
+"Parameters": {
+"Bucket": "my-bucket",
+"Key": "data.csv"
+}
+},
+"ItemProcessor": {
+"ProcessorConfig": {
+"Mode": "DISTRIBUTED",
+"ExecutionType": "EXPRESS"
+},
+"StartAt": "ProcessItem",
+"States": {
+"ProcessItem": {
+"Type": "Task",
+"Resource": "arn:aws:lambda:region:account-id:function:my-function",
+"End": true
+}
+}
+},
+"End": true
+"ResultWriter": {
+"Resource": "arn:aws:states:::s3:putObject",
+"Parameters": {
+"Bucket": "myOutputBucket",
+"Prefix": "csvProcessJobs"
+}
+}
+}
+```

 ### Versions and aliases

-Step Functions also lets you manage workflow deployments through **versions** and **aliases** of state machines. A version represents a snapshot of a state machine that can be executed. Aliases serve as pointers to up to two versions of a state machine.
+Step Functions також дозволяє вам керувати розгортаннями робочих процесів через **версії** та **псевдоніми** станів машин. Версія представляє знімок стану машини, який може бути виконаний. Псевдоніми служать вказівниками на до двох версій стану машини.

- **Versions**: These immutable snapshots of a state machine are created from the most recent revision of that state machine. Each version is identified by a unique ARN that combines the state machine ARN with the version number, separated by a colon (**`arn:aws:states:region:account-id:stateMachine:StateMachineName:version-number`**). Versions cannot be edited, but you can update the state machine and publish a new version, or use the desired state machine version.
- **Aliases**: These pointers can reference up to two versions of the same state machine. Multiple aliases can be created for a single state machine, each identified by a unique ARN constructed by combining the state machine ARN with the alias name, separated by a colon (**`arn:aws:states:region:account-id:stateMachine:StateMachineName:aliasName`**). Aliases enable routing of traffic between one of the two versions of a state machine. Alternatively, an alias can point to a single specific version of the state machine, but not to other aliases. They can be updated to redirect to a different version of the state machine as needed, facilitating controlled deployments and workflow management.
+- **Versions**: Ці незмінні знімки стану машини створюються з найостаннішої ревізії цієї стану машини. Кожна версія ідентифікується унікальним ARN, який поєднує ARN стану машини з номером версії, розділеним двокрапкою (**`arn:aws:states:region:account-id:stateMachine:StateMachineName:version-number`**). Версії не можуть бути відредаговані, але ви можете оновити стан машини та опублікувати нову версію або використовувати бажану версію стану машини.
+- **Aliases**: Ці вказівники можуть посилатися на до двох версій одного й того ж стану машини. Можна створити кілька псевдонімів для однієї стану машини, кожен з яких ідентифікується унікальним ARN, побудованим шляхом поєднання ARN стану машини з назвою псевдоніма, розділеною двокрапкою (**`arn:aws:states:region:account-id:stateMachine:StateMachineName:aliasName`**). Псевдоніми дозволяють маршрутизацію трафіку між однією з двох версій стану машини. Альтернативно, псевдонім може вказувати на одну конкретну версію стану машини, але не на інші псевдоніми. Їх можна оновити, щоб перенаправити на іншу версію стану машини за потреби, що полегшує контрольовані розгортання та управління робочими процесами.

-For more detailed information about **ASL**, check: [**Amazon States Language**](https://states-language.net/spec.html).
+Для отримання більш детальної інформації про **ASL** перевірте: [**Amazon States Language**](https://states-language.net/spec.html).

 ## IAM Roles for State machines

-AWS Step Functions utilizes AWS Identity and Access Management (IAM) roles to control access to resources and actions within state machines. Here are the key aspects related to security and IAM roles in AWS Step Functions:
+AWS Step Functions використовує ролі AWS Identity and Access Management (IAM) для контролю доступу до ресурсів і дій у станах машин. Ось ключові аспекти, пов'язані з безпекою та ролями IAM в AWS Step Functions:

- **Execution Role**: Each state machine in AWS Step Functions is associated with an IAM execution role. This role defines what actions the state machine can perform on your behalf. When a state machine transitions between states that interact with AWS services (like invoking Lambda functions, accessing DynamoDB, etc.), it assumes this execution role to carry out those actions.
- **Permissions**: The IAM execution role must be configured with permissions that allow the necessary actions on other AWS services. For example, if your state machine needs to invoke AWS Lambda functions, the IAM role must have **`lambda:InvokeFunction`** permissions. Similarly, if it needs to write to DynamoDB, appropriate permissions (**`dynamodb:PutItem`**, **`dynamodb:UpdateItem`**, etc.) must be granted.
+- **Execution Role**: Кожна стан машина в AWS Step Functions асоційована з роллю виконання IAM. Ця роль визначає, які дії стан машина може виконувати від вашого імені. Коли стан машина переходить між станами, які взаємодіють з сервісами AWS (наприклад, виклик функцій Lambda, доступ до DynamoDB тощо), вона приймає цю роль виконання для виконання цих дій.
+- **Permissions**: Роль виконання IAM повинна бути налаштована з дозволами, які дозволяють необхідні дії з іншими сервісами AWS. Наприклад, якщо вашій стану машини потрібно викликати функції AWS Lambda, роль IAM повинна мати дозволи **`lambda:InvokeFunction`**. Аналогічно, якщо їй потрібно записувати в DynamoDB, повинні бути надані відповідні дозволи (**`dynamodb:PutItem`**, **`dynamodb:UpdateItem`** тощо).

 ## Enumeration

-ReadOnlyAccess policy is enough for all the following enumeration actions.
-
+Політика ReadOnlyAccess достатня для всіх наступних дій перерахування.
 ```bash
 # State machines #

@@ -310,10 +297,9 @@ aws stepfunctions describe-map-run --map-run-arn <value>
 ## Lists executions of a Map Run
 aws stepfunctions list-executions --map-run-arn <value> [--status-filter <RUNNING | SUCCEEDED | FAILED | TIMED_OUT | ABORTED | PENDING_REDRIVE>] [--redrive-filter <REDRIVEN | NOT_REDRIVEN>]
 ```
-
 ## Privesc

-In the following page, you can check how to **abuse Step Functions permissions to escalate privileges**:
+На наступній сторінці ви можете перевірити, як **зловживати дозволами Step Functions для ескалації привілеїв**:

 {{#ref}}
 ../aws-privilege-escalation/aws-stepfunctions-privesc.md
@@ -338,7 +324,3 @@ In the following page, you can check how to **abuse Step Functions permissions t
 - [https://states-language.net/spec.html](https://states-language.net/spec.html)

 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-