How I Built CloudSecScanner During My Internship (And What It Taught Me About Cloud Security)

Building CloudSecScanner: How I Analyzed 10K+ Assets and Got Real Security Work Experience

Building CloudSecScanner: How I Analyzed 10K+ Assets and Got Real Security Work Experience

I Built CloudSecScanner

CloudSecScanner started as a weekend project. I was 2 weeks into my Inhok internship, frustrated that I was just learning SIEM tools while I could be building something practical. So I pitched an idea: write a tool to automatically scan cloud assets and identify misconfigurations.

They said yes. 3 months later, CloudSecScanner had scanned 10,000+ cloud assets across AWS, Azure, and GCP. Identified 500+ security misconfigurations. Found critical vulnerabilities that manual reviews would have missed. The tool is now used internally by Inhok for all client security assessments.

This post is the technical deep dive: how I built it, what I learned, why it matters for career development, and how to build similar tools.

What this covers: CloudSecScanner architecture. Tech stack. How it scans 10K+ assets. Real findings. What companies care about (not: "I built a tool", but: "here's working code that delivers value"). Career impact of building real tools.

The Problem CloudSecScanner Solves

Before CloudSecScanner, Inhok's process was:

  • Client provides AWS account credentials
  • Manual review: check S3 buckets, security groups, IAM policies, encryption settings
  • Takes 2-3 days per client to review ~500 assets
  • Easy to miss issues because humans get tired
  • No documentation of what was checked

CloudSecScanner automates this:

  • Connect to AWS/Azure/GCP accounts
  • Inventory all assets (1000s) automatically
  • Run 50+ security checks in parallel
  • Generate risk score per asset
  • Export compliance report (HTML/JSON)
  • Complete scan takes ~30 minutes instead of 2-3 days

Architecture: How CloudSecScanner Works

CloudSecScanner source code open in Visual Studio Code

Figure 1. CloudSecScanner was developed in Visual Studio Code using Python modules for cloud asset discovery, security rule evaluation, and automated reporting. The modular design makes it easier to extend support for additional cloud services and security checks.

┌──────────────────────────────────────────────────┐ │ CloudSecScanner - High Level Architecture │ ├──────────────────────────────────────────────────┤ │ │ │ Input Layer │ │ ├─ AWS Credentials (IAM role) │ │ ├─ Azure Credentials (Service Principal) │ │ └─ GCP Credentials (Service Account) │ │ │ │ Asset Discovery │ │ ├─ EC2 instances │ │ ├─ S3 buckets │ │ ├─ RDS databases │ │ ├─ VPCs & Security Groups │ │ ├─ Lambda functions │ │ └─ ... 20+ asset types │ │ │ │ Security Checks (50+) │ │ ├─ S3 bucket public access │ │ ├─ Security group overly permissive │ │ ├─ Encryption at rest │ │ ├─ MFA enabled │ │ ├─ Logging enabled │ │ └─ ... more checks in parallel │ │ │ │ Risk Scoring & Reporting │ │ ├─ Aggregate findings per asset │ │ ├─ Calculate risk score (CRITICAL → LOW) │ │ └─ Generate HTML/JSON report │ │ │ └──────────────────────────────────────────────────┘
Module 1: Cloud API Connectors
Python modules for AWS (boto3), Azure (azure-cli), GCP (google-cloud-python). Handle authentication, rate limiting, API errors. Extract asset metadata.
Code: ~500 lines | Execution: <1 second (auth only)
Module 2: Asset Inventory
Parallel asset discovery across cloud accounts. Lists all EC2s, S3s, databases, networks, etc. Deduplicate assets (same name in different regions). Output: asset database (~10K items).
Code: ~800 lines | Execution: 5-10 minutes for 10K assets (parallel)
Module 3: Security Checks Engine
50+ check rules (S3 public, encryption, logging, IAM, etc). Each check is a function that takes asset data and returns: pass/fail + severity + remediation.
Code: ~2000 lines | Execution: 10-15 minutes (50+ checks × 10K assets)
Module 4: Risk Scoring & Reporting
CloudSecScanner dashboard showing cloud security findings and risk scores

Figure 2. CloudSecScanner presents scan results through a dashboard that summarizes discovered assets, identified security findings, risk severity, and remediation priorities, helping analysts quickly focus on the most critical cloud security issues.

Aggregate check results. Assign risk scores (CRITICAL=100, HIGH=70, MEDIUM=40, LOW=10). Generate HTML dashboard and JSON report with findings, trends, remediation steps.
Code: ~600 lines | Execution: <5 minutes

Real Findings: What CloudSecScanner Discovered

Case Study 1: Overly Permissive Security Groups

Finding: 180 security groups allowed traffic from 0.0.0.0/0 (entire internet) to sensitive ports (3306 MySQL, 5432 PostgreSQL)

Risk: Database servers directly exposed to internet, exploitable by attackers

Impact: CloudSecScanner flagged all 180 in <30 seconds. Manual review would have taken 3+ hours. Some had been misconfigured for 2+ years.

Result: Client immediately restricted access to VPN/bastion only. Prevented potential breach.

Case Study 2: S3 Buckets with Public Read Access

Finding: 45 S3 buckets configured for public read access. 15 contained sensitive data (backups, config files, customer data).

Risk: Anyone on internet could download data. Data breach waiting to happen.

Impact: CloudSecScanner categorized by sensitivity: 5 CRITICAL (customer PII), 10 HIGH (internal configs), 30 LOW (logs). Report generated in 20 minutes.

Result: Client blocked public access on all buckets. Estimated $500K+ in potential breach costs avoided.

Case Study 3: Unencrypted Databases

Finding: 8 RDS instances had encryption at rest disabled. 3 had no automated backups.

Risk: Stolen/decommissioned hardware = data breach. No disaster recovery.

Impact: CloudSecScanner provided clear remediation: "Enable encryption at rest" + "Enable automatic backups".

Result: Client enabled encryption and backups across all instances. Compliance requirements met.

Key Technical Decisions

Why Python?

Official AWS/Azure/GCP SDKs are all Python-first. Parallel execution with threading/asyncio. Easy to deploy as Docker container. Learning curve is low for other security engineers.

Why Parallel Execution?

Scanning 10K assets sequentially would take 2+ hours. Running checks in parallel (50 threads): 15 minutes. Cloud APIs have rate limits, but structured parallel requests avoid hitting them.

Why Risk Scoring?

Finding 500 issues is useless if you can't prioritize. Risk scoring helps clients focus on critical (exploitable, high impact) before medium/low. CRITICAL issues = immediate action required.

CloudSecScanner project repository on GitHub

Figure 3. Maintaining the CloudSecScanner codebase in GitHub supports version control, collaborative development, and continuous improvement, allowing new security checks and cloud platform integrations to be added over time.

What I Learned Building This

Technical Lessons

  • Scalability matters: Optimizing from O(n²) to O(n) is difference between 30 min and 2 hours. Every decision impacts 10K assets.
  • Documentation is critical: Code without docs is useless to other engineers. Each check needs explanation: what it tests, why it matters, how to fix it.
  • API rate limiting is real: AWS throttles if you make too many requests. Retry logic, exponential backoff, request queuing are mandatory.
  • Error handling at scale: With 10K assets, something WILL fail (1 in 10K rate). Tool must handle failures gracefully, report them clearly, not crash.

Career Lessons

  • Built projects > certificates: CloudSecScanner in my portfolio got more recruiter interest than any CCPC cert. Proof of capability > credential.
  • Value matters: Tool that scans 10K assets and prevents potential breach is worth 100x more than tool that's technically perfect but no one uses.
  • Internal tools can launch careers: Now I can point to tool that's live, used daily, delivering ROI. That's way stronger than "I built a security scanner as a project".
  • Feedback loop accelerates learning: Users (other Inhok analysts) gave feedback. I iterated. Tool got better. That cycle is priceless for growth.

CloudSecScanner & Similar Projects — FAQs

How do I get started building similar cloud security tools?
Start small: pick one cloud (AWS) and one asset type (S3). Write checks for that. Get it working. Add complexity later (more assets, more clouds). Don't try to build everything at once. My first version only scanned S3 — took 2 weeks. Later versions added EC2, RDS, etc.
What's the hardest part of building cloud security tools?
Authorization and permissions. You need AWS/Azure/GCP credentials with specific IAM policies. Getting permissions wrong means tool breaks silently. Writing clear error messages when auth fails is critical.
Can I use this approach for security tools at my company?
Yes. Talk to your manager about building internal security tooling. Most companies need automated scanning of cloud assets. This is valuable to your company AND to your career. Win-win.

About the Author

Amardeep Maroli

Built CloudSecScanner at Inhok Technologies during internship. Scanned 10K+ cloud assets, identified 500+ misconfigurations. Tool is now live in production. Current focus: expanding to multi-cloud and compliance reporting (PCI-DSS, HIPAA).

Tags: cloud security scanner, AWS security, cloud asset management, security automation, Python security tools, cloud misconfigurations

Have you built security tools? What was the biggest challenge? And what did you learn that surprised you? Drop your experience in comments.

Post a Comment

0 Comments