Specialized Security
This section is important because real-world penetration testing isn't limited to websites and Windows/Linux servers. Organizations also use APIs, cloud platforms, mobile apps, containers, IoT devices, databases, embedded systems, and modern infrastructure.
The professional mindset is:
Learn the technology first → understand its attack surface → identify trust boundaries → test safely → prove impact → recommend fixes.
1. What Is Specialized Security?
Specialized security means testing technologies that require knowledge beyond the traditional:
Network → Web → OS
Modern attack surfaces look more like:
Organization │ ┌─────────────────┼─────────────────┐ │ │ │ Web API Cloud │ │ │ Database Mobile Containers │ │ │ └─────────────── IoT ───────────────┘ │ Embedded Devices
Each technology has its own:
- Protocols
- Authentication
- Authorization
- Data flow
- Trust boundaries
- Misconfigurations
- Vulnerabilities
- Testing methodology
2. Specialized Security Areas
For your roadmap, we'll divide it into:
| Area | Main Focus |
|---|---|
| API Security | REST, GraphQL, authentication, authorization |
| Cloud Security | IAM, storage, networking, secrets |
| Container Security | Docker, images, privileges |
| Kubernetes Security | Pods, RBAC, secrets, network policies |
| Mobile Security | Android/iOS applications |
| IoT Security | Devices, firmware, protocols |
| Embedded Security | Hardware, firmware, interfaces |
| Database Security | SQL/NoSQL, authentication, exposure |
| Source Code Security | SAST, secrets, insecure logic |
| DevSecOps | CI/CD and supply-chain security |
| Wireless/Radio | Specialized wireless technologies |
| Active Application Security | WebSockets, messaging, specialized protocols |
We'll go through the important ones.
3. API Security 🔌
Modern applications frequently communicate through APIs.
Example:
Mobile App │ │ HTTPS ▼ API │ ├── Authentication ├── Authorization ├── Business Logic └── Database
Example request:
GET /api/users/123 Authorization: Bearer <token>
The API becomes a major attack surface.
4. REST API
Common HTTP methods:
GET POST PUT PATCH DELETE
Example:
GET /api/products/10
POST /api/orders
PATCH /api/profile
DELETE /api/comment/25
5. API Security Testing
Ask:
Who can access this endpoint? ↓ What authentication is required? ↓ What authorization is required? ↓ What parameters are accepted? ↓ What data is returned? ↓ Can one user access another user's data? ↓ Can a normal user perform an admin action?
6. BOLA / IDOR
One of the most important API vulnerabilities.
Suppose:
GET /api/orders/1001
belongs to:
User A
If User A changes:
GET /api/orders/1002
and receives User B's order, that's an authorization failure.
This is commonly called:
BOLA — Broken Object Level Authorization
Historically, you may also hear:
IDOR — Insecure Direct Object Reference
7. API Testing Workflow
Discover API ↓ Identify endpoints ↓ Understand authentication ↓ Understand authorization ↓ Map parameters ↓ Test input validation ↓ Test object-level access ↓ Test function-level access ↓ Test rate limits ↓ Test business logic ↓ Document impact
Burp Suite is particularly useful here.
8. GraphQL Security
GraphQL uses queries rather than traditional REST endpoints.
Example:
query { user { id name email } }
Security testing includes:
- Authorization
- Query depth
- Query complexity
- Introspection configuration
- Excessive data exposure
- Resolver authorization
- Rate limiting
The important idea:
GraphQL changes how the API is structured, but authentication and authorization problems still matter.
9. Cloud Security ☁️
Cloud introduces a completely different attack surface.
Major platforms include:
- AWS
- Microsoft Azure
- Google Cloud
A simplified environment:
Cloud │ ┌───────────┼───────────┐ │ │ │ IAM Compute Storage │ │ │ Users VMs Buckets Roles Containers Files
10. Cloud IAM
Identity and Access Management is one of the most important cloud-security concepts.
Example:
User ↓ Role ↓ Permissions ↓ Resource
A dangerous configuration might give an application:
Administrator-level permissions
when it only needs:
Read access to one storage location
This violates:
Least privilege
11. Cloud Security Questions
During an authorized assessment:
Who can access the cloud? ↓ What roles exist? ↓ What permissions do they have? ↓ Which resources are public? ↓ Are secrets exposed? ↓ Are storage buckets public? ↓ Are security groups restrictive? ↓ Are audit logs enabled?
12. Cloud Storage
Examples:
S3 Azure Blob Storage Google Cloud Storage
Potential problems:
Public bucket Public object Weak access control Sensitive backup Exposed credentials Incorrect permissions
The correct test is not:
“Can I download everything?”
Instead:
“Can an unauthorized identity access protected data?”
A single controlled test object can often prove the issue.
13. Cloud Metadata Services
Cloud workloads can expose metadata services that provide information about the running instance.
Conceptually:
Application ↓ Cloud Metadata Service ↓ Instance Information ↓ Potential Credentials / Identity
This is especially relevant to SSRF.
Attack chain:
SSRF ↓ Metadata Service ↓ Cloud Identity ↓ Cloud Permissions ↓ Cloud Resources
This is a very important modern attack chain.
14. Container Security 🐳
You already have Docker experience, so this is particularly useful for you.
Basic architecture:
Host OS │ ├── Container A ├── Container B └── Container C
Containers provide isolation, but:
Container ≠ complete security boundary
Misconfiguration can create serious risks.
15. Docker Security
Things to investigate:
- Privileged containers
- Dangerous capabilities
- Host filesystem mounts
- Docker socket exposure
- Weak images
- Secrets in images
- Root containers
- Exposed ports
- Vulnerable dependencies
Example:
Container │ ├── Application ├── Environment variables ├── Secrets └── Mounted volumes
16. Docker Socket Risk
A particularly sensitive interface is:
/var/run/docker.sock
Conceptually:
Application Container │ ▼ Docker Socket │ ▼ Docker Engine │ ▼ Host
Giving an untrusted application access to the Docker daemon can have severe consequences.
In a lab, study this concept rather than testing production infrastructure.
17. Container Image Security
Images may contain:
Passwords API keys SSH keys Old packages Debug tools Source code Configuration
You should therefore scan images before deployment.
Security pipeline:
Source Code ↓ Build ↓ Container Image ↓ Dependency Scan ↓ Secret Scan ↓ Vulnerability Scan ↓ Deploy
18. Kubernetes Security ☸️
Kubernetes adds another layer.
Architecture:
Kubernetes Cluster │ ├── Control Plane │ └── Worker Nodes │ ┌───┴───┐ Pod Pod │ │ Container Container
Important security areas:
- RBAC
- Service Accounts
- Secrets
- Network Policies
- Pod Security
- API Server
- Admission controls
- Container privileges
19. Kubernetes RBAC
Think:
User ↓ Role ↓ Permissions ↓ Resource
A dangerous role might allow:
create pods exec into pods read secrets
Therefore test:
Can a low-privileged identity perform an administrative action?
20. Mobile Security 📱
Mobile applications are another major attack surface.
For Android:
APK │ ├── AndroidManifest.xml ├── Activities ├── Services ├── Broadcast Receivers ├── Content Providers ├── Resources └── Code
21. Android Security Testing
A mobile pentester may examine:
Static analysis
Study the APK without running it.
Look for:
- Hardcoded secrets
- API endpoints
- Insecure configurations
- Exported components
- Debug settings
- Weak cryptography
Dynamic analysis
Run the application and observe:
- Network traffic
- Storage
- Authentication
- API communication
- Runtime behavior
22. Android Tools
Common tools include:
ADB JADX apktool MobSF Burp Suite Frida Objection
For example:
adb devices
You can inspect an authorized test device.
23. Mobile Attack Surface
Think:
Mobile App │ ├── Local Storage ├── APIs ├── Authentication ├── Tokens ├── Deep Links ├── WebViews ├── Cryptography └── Device Permissions
A vulnerability in any layer can matter.
24. IoT Security 🌐
This is especially relevant to your ESP32/Arduino projects.
IoT architecture:
Sensor ↓ ESP32 ↓ Wi-Fi ↓ Router ↓ Cloud/API ↓ Mobile/Web App
Every component creates an attack surface.
25. IoT Security Areas
Test:
Device
- Default passwords
- Debug interfaces
- Firmware
- Physical ports
- Secure boot
Network
- Wi-Fi security
- MQTT
- HTTP
- TLS
- Network segmentation
Cloud
- API authentication
- Device identity
- Access control
- Data exposure
26. MQTT Security
MQTT is common in IoT.
Architecture:
ESP32 │ ▼ MQTT Broker │ ├── Mobile App ├── Dashboard └── Other Devices
Security questions:
Does the broker require authentication? Is TLS enabled? Can anonymous clients connect? Can one device subscribe to another device's topics? Can clients publish unauthorized commands?
27. Example IoT Attack Chain
Imagine your smart-home lab:
ESP32 ↓ Weak MQTT Authentication ↓ Unauthorized Topic Access ↓ Control Command ↓ Relay ↓ Physical Device
That demonstrates why IoT security is different.
A cyber vulnerability can have a physical consequence.
28. Firmware Security
IoT devices frequently contain firmware.
Potential analysis:
Firmware ↓ Extract ↓ File System ↓ Configuration ↓ Credentials ↓ Binaries ↓ Vulnerable Components
Tools may include:
binwalk strings firmwalker Ghidra radare2
Use firmware obtained from your own device or an authorized lab.
29. Embedded Hardware Security
Embedded devices may expose interfaces such as:
UART JTAG SPI I²C SWD
Conceptually:
Embedded Device │ ┌───────┼────────┐ │ │ │ UART JTAG SPI
These interfaces can be useful for:
- Debugging
- Firmware extraction
- Hardware testing
- Security research
Physical access and authorization are essential.
30. Database Security 🗄️
Databases are often the final target of application attacks.
Examples:
MySQL PostgreSQL MongoDB Redis Microsoft SQL Server
Security questions:
Is authentication enabled? Is the database exposed? Are default credentials removed? Are permissions restrictive? Is encryption enabled? Are backups protected?
31. Database Attack Surface
Example:
Web App ↓ Database ↓ Sensitive Data
If the web application has SQL injection:
User Input ↓ SQL Injection ↓ Database Query ↓ Unauthorized Data
This is why SQL injection remains important.
32. NoSQL Security
NoSQL applications can have their own injection and authorization problems.
Examples:
MongoDB Redis CouchDB
Don't assume:
“NoSQL means no injection.”
The underlying query language and application logic determine the risk.
33. Source Code Security 👨💻
If source code is available, testing becomes much deeper.
Look for:
Hardcoded secrets Weak authentication Missing authorization Dangerous functions SQL injection Command injection Insecure cryptography Poor error handling Race conditions Business logic flaws
Example:
query = "SELECT * FROM users WHERE id=" + user_id
The security problem is not:
“Python is insecure.”
The problem is:
Untrusted input is being directly incorporated into a SQL query.
34. SAST
Static Application Security Testing
Analyzes source code without executing the application.
Concept:
Source Code ↓ SAST Scanner ↓ Potential Vulnerabilities ↓ Developer Review ↓ Fix
35. SCA
Software Composition Analysis
Looks at third-party dependencies.
Example:
Application │ ├── React ├── Express ├── Axios └── Other packages
One vulnerable dependency can create risk even when your own code is secure.
36. DevSecOps 🔄
Security should exist throughout the development lifecycle.
Instead of:
Build ↓ Deploy ↓ Security Test
Use:
Code ↓ Secret Scan ↓ SAST ↓ Dependency Scan ↓ Build ↓ Container Scan ↓ Deploy ↓ Runtime Monitoring
This is DevSecOps.
37. Supply Chain Security
Modern applications depend on:
Libraries Packages Containers CI/CD Plugins Third-party APIs Open-source projects
A compromised dependency can affect thousands of applications.
Security controls include:
- Dependency pinning
- Software composition analysis
- Package integrity verification
- SBOM
- Signed artifacts
- Secure CI/CD
- Least-privilege build systems
38. CI/CD Security
Pipeline:
Developer ↓ Git Repository ↓ CI/CD ↓ Build ↓ Container ↓ Production
Potential risks:
Exposed secrets Weak repository permissions Untrusted pull requests Compromised runners Overprivileged CI credentials Unsafe deployment scripts
39. WebSocket Security
WebSockets provide persistent communication:
Client │ │ WebSocket ▼ Server │ └── Continuous messages
Security testing includes:
- Authentication
- Authorization
- Message validation
- Origin checking
- Rate limiting
- Sensitive information exposure
- Business logic
Burp Suite can be useful for inspecting WebSocket communication.
40. Specialized Security Attack Chain
A modern attack could look like:
Web Application ↓ API Vulnerability ↓ Cloud Credential ↓ Cloud IAM ↓ Container ↓ Kubernetes ↓ Internal Service ↓ Sensitive Data
This is why modern pentesters need cross-domain knowledge.
41. Your Practical Specialized Lab
You can build an excellent lab from technologies you already use:
KALI │ ┌──────────┼──────────┐ │ │ │ Web API IoT │ │ │ Next.js Flask ESP32 │ │ │ └──────────┼──────────┘ │ Docker │ ┌─────┴─────┐ │ │ Database MQTT │ │ └─────┬─────┘ │ Network
You can progressively add:
Android test app Docker MQTT ESP32 SQLite/MySQL REST API Cloud test environment
This would give you a very strong practical security lab.
42. Specialized Security Methodology
Don't approach every technology with the same tool.
Instead:
Identify Technology ↓ Understand Architecture ↓ Map Attack Surface ↓ Identify Trust Boundaries ↓ Identify Authentication ↓ Identify Authorization ↓ Test Input/Protocol ↓ Test Configuration ↓ Test Business Logic ↓ Validate Impact ↓ Document ↓ Remediate ↓ Retest
43. What You Should Learn Deeply
For your career goals, I'd prioritize:
🔥 Tier 1
Web Security API Security Network Security Linux Windows Active Directory Cloud
🔥 Tier 2
Docker Kubernetes Mobile Security IoT Security Database Security
🔥 Tier 3
Firmware Hardware Reverse Engineering Radio/Wireless protocols Advanced cloud Supply-chain security
You don't need to master everything simultaneously.
44. Tool vs Knowledge
Don't make the mistake:
100 tools ↓ Expert hacker ❌
Instead:
Strong Fundamentals + Protocol Knowledge + Operating Systems + Programming + Security Methodology + Practical Labs ↓ Strong Security Engineer
Your existing knowledge of Python + Linux + networking + React/Next.js + Docker + ESP32 gives you a particularly good foundation for this section.
45. Specialized Security Mindset 🧠
Whenever you encounter a new technology, ask:
What is it? ↓ How does it work? ↓ Who trusts whom? ↓ Where is authentication? ↓ Where is authorization? ↓ Where is sensitive data? ↓ What can the user control? ↓ What can an attacker control? ↓ What happens if that control is abused? ↓ Can I reproduce it safely? ↓ How can it be fixed?
That methodology works across web, API, cloud, mobile, IoT, containers, and embedded systems.