Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

MOBILE PENTEST BOOTCAMP

Day 2 — One-Shot Lab Build
Session length: 2.5–3.5 hours | Hands-on only | Apple Silicon M-series (ARM64)

Session time estimate — honest breakdown

This session is 2.5–3.5 hours of actual work on a fresh Mac, not 4 hours.
Where the time goes:
Step 1 Homebrew install ~10 min
Step 2 Android Studio + adb ~15 min (download-heavy)
Step 3 ARM64 emulator creation + first boot ~15 min
Step 4 jadx, apktool, static tools ~10 min
Step 5 Frida + objection ~10 min
Step 6 frida-server on emulator ~10 min
Step 7 Burp Suite / Caido proxy ~10 min
Step 8-9 Proxy config + emulator Wi-Fi proxy ~10 min
Step 10 System CA cert install (MOST LIKELY SNAG POINT) ~15 min
Step 11 MobSF in Docker ~10 min
Step 12 Full-stack end-to-end verification ~15 min
Buffer for anything that does not work first time ~30 min
Total: ~2.5–3.5 hours depending on internet speed and snags.

What you will have when this session is done

A complete, verified mobile pentest toolkit — every tool needed for Days 3–23.
Specifically:
• Rootable ARM64 Android emulator (native speed on Apple Silicon)
• adb connected and confirmed root access
• jadx + apktool (static analysis)
• Frida + frida-server (runtime instrumentation)
• objection (Frida-based pentest shell)
• Burp Suite Community (HTTPS interception proxy)
• System CA cert installed — live HTTPS decryption confirmed
• MobSF in Docker (automated static + dynamic scanner)
• InjuredAndroid installed and verified with frida-ps

Test-case enablement — Day 2 role

Day 2 does not run any catalogue test cases directly.
It is the prerequisite for EVERY test case from Day 3 onwards.

For personal use — all testing against your own app only. Page 1
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Specifically: without a rooted emulator you cannot run M9 storage tests.

Without HTTPS interception you cannot run M5, M3, M4, or M8 API tests.
Without Frida you cannot run M7, M3-01, M3-08, or any runtime tests.
Treat this day as the foundation. Nothing on Days 3-23 works without it.

Before You Start — Apple Silicon Reality

Your M5 Air is ARM64 architecture. For mobile pentesting this is a significant advantage, not a problem
— but there is one trap that catches almost everyone on their first setup.

Critical: always download ARM64 binaries, not x86

Your M5 is ARM64. When you download frida-server, Ghidra plugins, or any precompiled
binary, always pick the arm64 / aarch64 / arm64-v8a variant.
An x86 binary will fail silently or with a confusing 'exec format error'.
The emulator images must also be arm64-v8a — NOT x86_64.
This document flags every place the architecture choice matters.

Item Detail
ARM64 advantage Android emulator images run natively — no x86 translation, near-phone
speed.
Homebrew path Homebrew installs to /opt/homebrew on Apple Silicon, not /usr/local.
Commands are identical but the PATH setup step is required.
frida-server file Download: [Link] — the arm64 suffix is
mandatory.
System images Use 'Google APIs' arm64-v8a images in Android Studio. Never 'Google Play'
(locked, no root).
API level target API 33 / Android 13. System CA cert install is clean at this level. API 34+
needs extra steps — avoid for now.

The Dependency Order — Work Top to Bottom

Every tool below depends on the ones above it. Do not skip steps or reorder them. The verification
command at each step is not optional — a broken tool discovered on Day 7 costs you an hour of
confusion.

Item Detail
Step 1 Homebrew — everything else installs via brew
Step 2 Android Studio + adb — installs the SDK and build tools
Step 3 ARM64 rootable emulator — the device you test against

For personal use — all testing against your own app only. Page 2
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Item Detail
Step 4 Static tools (jadx, apktool, dex2jar) — decompile APKs
Step 5 Python + Frida client — instrumentation engine
Step 6 frida-server on emulator — server side of Frida bridge
Step 7 objection — Frida-based pentest shell, installs after Frida
Step 8-9 Burp Suite proxy + emulator Wi-Fi proxy config
Step 10 System CA cert — unlocks HTTPS decryption (most likely snag)
Step 11 MobSF in Docker — automated scanner (Docker Desktop required)
Step 12 Full-stack verification — proves everything works together

Step-by-Step Installation
Step 1 — Install Homebrew
Homebrew is the package manager for macOS. Almost every tool in this bootcamp installs through it.
Open Terminal and run the official one-liner:

/bin/bash -c "$(curl -fsSL

[Link]

PATH setup — do not skip this

On Apple Silicon, Homebrew installs to /opt/homebrew (not /usr/local on Intel).
At the end of the install the script prints two lines — run both of them.
They look like this (your username will differ):

echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile

eval "$(/opt/homebrew/bin/brew shellenv)"

After running both lines, close and reopen Terminal. Then verify:

brew --version
# Expected: Homebrew 4.x.x
which brew
# Expected: /opt/homebrew/bin/brew

If brew: command not found appears, the PATH was not updated. Close Terminal completely, reopen
it, and run the eval line again.

For personal use — all testing against your own app only. Page 3
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Step 2 — Android Studio + adb

Android Studio installs the Android SDK and all build tools. adb (Android Debug Bridge) is the
command-line interface to your emulator — you will use it constantly from Day 3 onwards.

brew install --cask android-studio

brew install android-platform-tools # gives adb + fastboot standalone

After the cask installs, launch Android Studio once and let it complete its first-run SDK download (this
can take 5–10 minutes on a fresh machine). You do not need to create a project — just let the setup
wizard finish, then close it. The SDK components it downloads are what later steps need.

adb --version
# Expected: Android Debug Bridge version 1.0.41 (or higher)

Step 3 — Create an ARM64 Rootable Emulator

This is the most important setup step. The emulator choice here determines whether you can run
dynamic tests on Days 3 through 14. Get this right now and every later day works smoothly.

Why these specific choices matter

ARM64 image: runs natively on your M5 — no translation, fast.
Google APIs (NOT Google Play): Google APIs images have a writable system partition.
adb root works. Google Play images are locked — adb root fails.
We need root for storage tests (Day 5), CA cert install (today), and Frida.
API 33 / Android 13: system CA cert install is clean at this level.
API 34+ moved the cert store to an APEX module — extra steps needed.
No reason to fight that during setup.

Open Android Studio. In the Welcome screen click the three-dot menu (or go to Tools) and open
Device Manager. Click Create Device and follow these selections:

Item Detail
Hardware profile Pixel 7 or any phone profile — size does not matter
System image tab Select 'Other Images' tab to see non-Play images
Image to select arm64-v8a | API 33 | Android 13 | Google APIs
Image to AVOID Any image labeled 'Google Play' — these are locked
AVD name Something memorable: Pentest_API33_arm64

Boot the emulator (the Play button in Device Manager). Wait for it to fully start, then verify root access
— this is your pass/fail test for the emulator:

For personal use — all testing against your own app only. Page 4
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

adb devices
# Expected: emulator-5554 device

adb root
# Expected: restarting adbd as root

adb shell whoami

# Expected: root

If adb root says 'cannot run as root in production builds'

You picked a Google Play image, not Google APIs.
In Device Manager: delete the AVD, click Create Device again,
and on the system image screen switch to the 'Other Images' tab.
Select an arm64-v8a API 33 Google APIs image — no 'Play' in the label.
Do not proceed until adb root confirms: restarting adbd as root.

Step 4 — Static Analysis Tools

These are the tools you use to pull an APK apart without running it — the foundation of Days 3 through
4, 12, and 13.

brew install jadx # APK decompiler → readable Java/Kotlin

brew install apktool # decode/rebuild APKs, reads manifest & smali
brew install dex2jar # converts .dex to .jar when jadx is not enough

# jadx also has a GUI (useful for interactive code browsing):

brew install --cask jadx

jadx --version
# Expected: jadx-1.x.x

apktool --version
# Expected: Apktool v2.x.x

Quick orientation so you know when to use which:

Item Detail
jadx Decompiles APK bytecode to readable Java/Kotlin. Best for reading code and
searching for secrets. Has a GUI (jadx-gui) for navigation.
apktool Decodes APK to smali (low-level code) and resources. Use when you need to patch
and rebuild an APK (Day 7 smali patching).
dex2jar Converts .dex to .jar for use with other Java decompilers. Secondary tool — jadx

For personal use — all testing against your own app only. Page 5
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Item Detail
covers most cases.

Step 5 — Python + Frida Client

Frida is the runtime instrumentation engine used on Days 7 through 14 and throughout the iOS phase.
It has two halves: the Python client on your Mac (this step) and the frida-server binary on the emulator
(Step 6). The version numbers MUST match.

# Install pipx for isolated Python tool installs (cleaner than pip globally)
brew install pipx
pipx ensurepath

# Install Frida client

pipx install frida-tools

# Install objection (Frida-based pentest shell)

pipx install objection

frida --version
# Note this version number — you will need it exactly in Step 6
# Example output: 16.3.3

objection --version
# Expected: objection x.x.x

Write down the Frida version output before moving to Step 6

The single most common Day 2 failure is a version mismatch between the
Frida client on your Mac and the frida-server binary on the emulator.
If they differ by even a minor version, frida-ps -U will fail with
'unable to connect to remote frida-server'.
Write the exact version string now: frida X.Y.Z

Step 6 — frida-server on the Emulator

The frida-server binary runs inside the Android emulator and acts as the server side of the Frida bridge.
You push it onto the emulator, make it executable, and start it. The version must exactly match the
client from Step 5.

# Replace 16.3.3 with YOUR exact Frida version from Step 5

FRIDA_VER=16.3.3

For personal use — all testing against your own app only. Page 6
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

# Download the ARM64 Android server binary

curl -L -o [Link] \
[Link]
{FRIDA_VER}-[Link]

# Decompress it
xz -d [Link]

# Push to the emulator

adb push frida-server /data/local/tmp/frida-server

# Make executable
adb shell chmod 755 /data/local/tmp/frida-server

# Start the server (in background — & keeps it running)

adb shell "/data/local/tmp/frida-server &"

# Verify from your Mac

frida-ps -U
# Expected: a list of running processes on the emulator
# If you see 'unable to connect': version mismatch — recheck FRIDA_VER

Pro tip — restart frida-server after emulator reboots

frida-server does not persist across emulator reboots.
Each session starts with these two lines:
adb root
adb shell "/data/local/tmp/frida-server &"
Your Day 3 and onwards cheatsheets all begin with this pair.

Step 7 — Burp Suite Community (Proxy)

Burp Suite is the HTTP proxy you use to intercept, inspect, and replay traffic between the app and its
backend API. The Community Edition is free and covers everything in this bootcamp. Steps 8–10
configure it to actually intercept HTTPS.

brew install --cask burp-suite

# Alternative: Caido (modern UI, free tier)

# brew install --cask caido
# Both work. Burp is the industry standard; Caido is faster to navigate.
# Pick one and stick with it.

For personal use — all testing against your own app only. Page 7
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Launch Burp Suite. Accept the defaults and go to Proxy → Proxy settings → Proxy listeners. Confirm
the default listener is active on [Link]:8080. You will change the binding address in Step 8.

Step 8 — Configure the Proxy Listener

The emulator cannot reach [Link] on your Mac directly — it needs your Mac's LAN IP. Two things to
configure:

# Find your Mac's LAN IP

ipconfig getifaddr en0
# Example output: [Link]
# Note this IP — you use it in Step 9 and every interception session

In Burp Suite: Proxy → Proxy settings → Proxy listeners → Edit the existing listener:
• Bind to address: change from '[Link]' to 'All interfaces'
• Bind to port: leave as 8080
• Click OK

Quick test — HTTP only (not HTTPS yet):

# In the emulator: open Chrome, visit [Link]
# In Burp: Proxy → HTTP history should show the request
# HTTP works immediately. HTTPS shows certificate errors until Step 10.

Step 9 — Point the Emulator at the Proxy

In the emulator, configure the Wi-Fi network to route through Burp:

1. In the emulator: Settings → Network & internet → Internet

2. Tap the gear icon next to AndroidWifi
3. Tap the pencil (edit) icon
4. Expand 'Advanced options'
5. Set Proxy to Manual
Proxy hostname: [Link] (use YOUR Mac IP from Step 8)
Proxy port: 8080
6. Save and reconnect

# Verify in Burp: Proxy → HTTP history

# Open Chrome in emulator, visit [Link]
# The GET request should appear in Burp's history

For personal use — all testing against your own app only. Page 8
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Step 10 — Install Burp's CA Certificate as a System Cert

This is the step that most people get wrong and the one that unlocks HTTPS interception. On Android 7
and above, user-installed certificates are NOT trusted by apps — only system certificates are. Since the
emulator is rooted, you can install Burp's CA as a system cert.

This is the most likely snag point on Day 2

Read the sequence below completely before executing.
The commands must be run in exact order.
One wrong step and you re-extract and start again — which is fine,
it takes 5 minutes. Do not panic if it fails the first time.

Export Burp's CA certificate

In Burp Suite: Proxy → Proxy settings → Import / export CA certificate → Export → Certificate in DER
format → save as [Link] in your home directory.

Convert and push to the emulator

# Convert DER to PEM
openssl x509 -inform DER -in ~/[Link] -out ~/[Link]

# Get the subject hash (Android uses this as the filename)

CERT_HASH=$(openssl x509 -inform PEM -subject_hash_old -in ~/[Link] | head -1)
echo "Certificate hash: $CERT_HASH"
# Example output: 9a5ba575

# Rename the cert file to hash.0

cp ~/[Link] ~/${CERT_HASH}.0

# Remount system partition as writable (requires rooted emulator)

adb root
adb remount

# Push the cert to the system CA store

adb push ~/${CERT_HASH}.0 /system/etc/security/cacerts/

# Set correct permissions

adb shell chmod 644 /system/etc/security/cacerts/${CERT_HASH}.0

# Reboot the emulator for the cert to take effect

adb reboot

# Wait for reboot, then re-root and restart frida-server

adb root
adb shell "/data/local/tmp/frida-server &"

For personal use — all testing against your own app only. Page 9
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Verify HTTPS interception

# In emulator Chrome: visit [Link]
# In Burp Proxy → HTTP history:
# You should see the HTTPS request with NO certificate error
# and the response body fully decrypted and readable.

# If you still see a certificate error in Chrome:

# -- Check the cert was pushed: adb shell ls /system/etc/security/cacerts/ | grep
$CERT_HASH
# -- Confirm you rebooted after pushing
# -- Confirm adb remount succeeded (some API levels need -writable-system flag)

API 33 note vs API 34+

On Android 13 (API 33) the above sequence works reliably.
On Android 14+ (API 34) the cert store moved to an APEX module at
/apex/[Link]/cacerts/ and adb remount does not affect it.
For API 34+ an extra mount namespace step is required.
This is why the bootcamp targets API 33 — no reason to fight this now.
If you already created an API 34 emulator: delete it and create API 33.

Step 11 — MobSF in Docker

MobSF (Mobile Security Framework) is your automated static and dynamic scanner. You drag an APK
to its web interface and in minutes it produces a security report covering hardcoded secrets, dangerous
permissions, weak crypto, and more. You already have Docker Desktop — this is one command.

# Pull the MobSF image (multi-arch — auto-selects arm64 on your M5)

docker pull opensecurity/mobile-security-framework-mobsf:latest

# Run it
docker run -it --rm -p 8000:8000 opensecurity/mobile-security-framework-
mobsf:latest

# It takes 30-60 seconds to start. Look for:

# Starting Mobile Security Framework
# Listening on [Link]:8000

# Verify: open in your Mac's browser

# [Link]
# You should see the MobSF upload interface
# Do not upload anything yet — just confirm the page loads

For personal use — all testing against your own app only. Page 10
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Running MobSF as a background service

The command above runs in foreground (Ctrl-C to stop).
For longer sessions use: docker run -d -p 8000:8000 --name mobsf opensecurity/mobile-security-
framework-mobsf:latest
Stop it with: docker stop mobsf
Start it again with: docker start mobsf

Step 12 — Full-Stack Verification

This is your Day 2 done test. Five checks in sequence — all five must pass before you call Day 2
complete. Download InjuredAndroid APK from its GitHub releases page (search 'b3nac InjuredAndroid
releases') — it is the deliberately vulnerable Android app used through Days 3 to 14.

# Check 1: Install the test APK

adb install [Link]
# Expected: Performing Streamed Install ... Success

# Check 2: Confirm it is installed and get the package name

adb shell pm list packages | grep injured
# Expected: package:[Link]

# Check 3: frida-ps sees it

frida-ps -U | grep -i injured
# Expected: a line with the PID and process name
# This proves: rooted emulator + frida-server + Frida client all work

# Check 4: objection can hook it

objection -g [Link] explore
# At the objection prompt type: android hooking list activities
# Expected: list of activity class names
# Type 'exit' when done
# This proves: objection + Frida bridge fully functional

# Check 5: HTTPS traffic decrypts in Burp

# Open InjuredAndroid in the emulator, trigger a network action
# In Burp Proxy → HTTP history: HTTPS requests should appear decrypted
# (InjuredAndroid makes API calls on some screens)

All five checks passed — Day 2 is complete

You now have the entire foundation for Days 3–23.
Check 1 = adb and emulator working
Check 2 = package management working
Check 3 = Frida full stack working (most important)

For personal use — all testing against your own app only. Page 11
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Check 4 = objection working

Check 5 = HTTPS interception working
If any check fails, use the troubleshooting section on the next page.

Troubleshooting — Common Failures and Exact Fixes

Item Detail
brew: command not found The PATH was not updated. Run: eval "$(/opt/homebrew/bin/brew
after install shellenv)" — then close and reopen Terminal.
adb root: cannot run as You used a Google Play emulator image. Delete the AVD. Create a
root new one using a Google APIs arm64-v8a API 33 image.
frida-ps -U: unable to Version mismatch (most common cause) — run 'frida --version' and
connect to remote frida- compare with the frida-server filename. Re-download frida-server with
server the exact matching version. Second cause: frida-server not running —
run: adb shell "/data/local/tmp/frida-server &"
objection: Failed to Frida is not working. Fix frida-ps -U first. Objection depends on Frida —
connect if Frida fails, objection fails.
HTTPS still shows cert Check: (1) the .0 file exists in /system/etc/security/cacerts/ via adb shell
error after Step 10 ls. (2) You rebooted after pushing. (3) adb remount returned 'remount
succeeded' not an error. If adb remount fails try: adb shell mount -o
rw,remount /system
MobSF: page not loading Container may still be starting — wait 60 seconds and refresh. Check
Docker Desktop shows the container running. Try: docker logs mobsf
jadx: command not found brew link jadx — or close and reopen Terminal after install. The cask
version installs to Applications; the brew formula installs to
/opt/homebrew/bin/jadx.
apktool: The APK you are testing has a newer manifest format. Update apktool:
[Link] brew upgrade apktool
eption

Your Standard Session Startup Sequence (Day 3 Onwards)

Every day from Day 3 to Day 14 starts with these commands in this order. Write them on a sticky note
until they are muscle memory.

# 1. Start the emulator (if not already running)

# Open Android Studio → Device Manager → Play button

# 2. Root adb and start frida-server

adb root
adb shell "/data/local/tmp/frida-server &"

For personal use — all testing against your own app only. Page 12
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

# 3. Verify Frida sees the emulator

frida-ps -U | head

# 4. Start Burp Suite and confirm the listener is on all interfaces port 8080

# 5. Confirm the emulator Wi-Fi proxy is still set to your Mac IP:8080
# (it persists across reboots but double-check if traffic is missing)

Save this as a shell alias

Add to ~/.zprofile:
alias pentest-start='adb root && adb shell "/data/local/tmp/frida-server &" && frida-ps -U | head'
Then just type: pentest-start

Record Your Installed Versions

Fill this in after Day 2. When something breaks on Day 9, you will need these exact versions to
diagnose the issue.

Item Command / action Expected result

V Homebrew brew --version Homebrew 4.x.x
E
R
I
F
Y
V adb adb --version Android Debug Bridge 1.0.41+
E
R
I
F
Y
V Android Studio SDK sdkmanager --version Any recent version
E
R
I
F
Y
V Emulator AVD adb devices (after boot) emulator-5554 device
E
R
I
F
Y
V adb root adb root + adb shell whoami root
E

For personal use — all testing against your own app only. Page 13
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Item Command / action Expected result

R
I
F
Y
V jadx jadx --version jadx-1.x.x
E
R
I
F
Y
V apktool apktool --version Apktool v2.x.x
E
R
I
F
Y
V frida (client) frida --version 16.x.x — NOTE EXACT
E VERSION
R
I
F
Y
V frida-server Check filename downloaded Must match client version
E exactly
R
I
F
Y
V objection objection --version objection x.x.x
E
R
I
F
Y
V Burp Suite Burp → Help → About Community Edition 20xx.x
E
R
I
F
Y
V HTTPS decrypt Visit [Link] No cert error, body visible in
E Burp
R
I
F
Y
V MobSF [Link] Upload interface loads
E
R
I
F
Y

For personal use — all testing against your own app only. Page 14
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Item Command / action Expected result

V frida-ps -U frida-ps -U | head List of emulator processes
E
R
I
F
Y
V objection explore android hooking list activities Activity list returned
E
R
I
F
Y

Quick Tool Reference — What Each Tool Does and When

Item Detail
Homebrew Package manager. Every tool installs through it. Update with: brew upgrade
adb Android Debug Bridge. Connects your Mac to the emulator. Used in every session.
Key commands: adb root, adb shell, adb install, adb push, adb pull
jadx APK decompiler. Converts compiled bytecode to readable Java. Use for static
code review, secret hunting, and finding class names to hook with Frida. Launch
GUI with: jadx-gui
apktool APK decoder and rebuilder. Use when you need to read raw smali, patch the
bytecode, and rebuild a modified APK. Required for Day 7 smali patching.
Frida Runtime instrumentation engine. Injects JavaScript into running processes to hook
methods, dump arguments, and change return values. Used Days 7–14 and iOS
phase.
frida-server The Frida server binary running inside the emulator. Bridges between your Mac's
Frida client and the running app. Must version-match the client.
objection Frida-based interactive pentest shell. Provides ready-made commands for: ssl
pinning disable, android hooking list activities, android sslpinning disable, and
more. Saves writing Frida scripts for common tasks.
Burp Suite HTTP/HTTPS interception proxy. See, modify, and replay every request the app
makes. The most-used tool from Day 6 to Day 22. Proxy → HTTP history is your
second screen.
MobSF Automated static + dynamic scanner. Drag APK → get a report on secrets,
permissions, URLs, crypto, components. Used for fast initial triage on Day 4 and
the capstone days.
InjuredAndroid The deliberately vulnerable Android app used as the practice target for Days 3–14.
Has intentional vulnerabilities covering most of the catalogue test cases.

For personal use — all testing against your own app only. Page 15
Mobile Pentest Bootcamp | Day 2 — One-Shot Lab Build

Before Day 3
Day 2 ends when all five verification checks pass. Before Day 3 do two things:

7. Run the standard session startup sequence (adb root → frida-server → frida-ps -U → Burp
listening → emulator proxy set) from memory, without looking at the document. Do this three
times until it takes under 60 seconds.
8. Open InjuredAndroid in the emulator and click through every screen once. You are not testing
yet — just making it familiar so on Day 3 you spend time testing, not exploring the UI.

Day 3 preview — APK anatomy + first decompile

Day 3 is the first day where test cases get marked in your catalogue.
You will: unzip an APK to see its structure, run jadx to decompile it,
read the [Link] for the 5-point security scan,
and mark your first findings against M8-01, M8-02, M8-06, M6-01, M6-08, M5-08.
Bring your Mac charged — Day 3 is hands-on from the first minute.

For personal use — all testing against your own app only. Page 16