DEV Community: Abhinav Singwal

IP Lookup Tool: Check IP Address, Geolocation, ISP and Network Information

Abhinav Singwal — Wed, 23 Sep 2026 13:11:13 +0000

An IP address can reveal useful information about a network, server, or internet connection. During cybersecurity research, OSINT, penetration testing, and network troubleshooting, an IP lookup tool can help you quickly understand an IP address.

IP-Lookup.org is an online IP address lookup tool that provides useful information associated with an IP address.

What Is an IP Lookup?

An IP lookup is the process of checking publicly available information associated with an IP address.

Depending on the IP address, this information can include:

IP geolocation
ISP information
Organization
ASN
Hostname
Network information
Whois details
Other IP intelligence

This can be useful when investigating an unfamiliar IP address found during security testing or network analysis.

IP Lookup for Cybersecurity

IP address information can be useful during different security research activities.

1. Reconnaissance

During web reconnaissance, security researchers may discover IP addresses belonging to servers, hosting providers, or other infrastructure.

An IP lookup can provide additional context about the discovered address.

2. OSINT Research

IP intelligence can be combined with other publicly available information to understand internet-facing infrastructure and network ownership.

3. Bug Bounty and Penetration Testing

Security researchers can use IP lookup during reconnaissance to investigate IP addresses discovered through DNS records, subdomains, server headers, or other sources.

4. Network Analysis

ISP, ASN, hostname, and geolocation information can help when investigating network connections or unfamiliar traffic.

How to Look Up an IP Address

Using an IP lookup tool is straightforward:

Find the IP address you want to investigate.
Open IP-Lookup.org.
Enter the IP address.
Review the available IP and network information.

Why Use an IP Lookup Tool?

Manually collecting information about an IP address can take time. An online IP lookup tool provides a quick way to gather commonly useful information in one place.

For security researchers, this can make the initial reconnaissance and investigation process faster.

Try IP-Lookup.org

If you are looking for an IP lookup tool, IP address lookup, or IP geolocation tool for cybersecurity research, OSINT, reconnaissance, or network analysis, you can check out:

IP-Lookup.org

CORS Misconfiguration Scanner: A Powerful Tool for Web Security Testing

Abhinav Singwal — Sat, 05 Sep 2026 12:41:53 +0000

Cross-Origin Resource Sharing (CORS) is a critical security mechanism that allows web applications to request resources from different domains. However, misconfigured CORS policies can expose your application to serious security vulnerabilities. Today, I'm excited to share a powerful tool called cors - a dedicated CORS misconfiguration scanner that helps security professionals and developers identify and fix these vulnerabilities.

What is CORS Misconfiguration Scanner?

GitHub: https://github.com/yogsec/cors

The cors tool is a fast, efficient command-line utility designed to detect CORS misconfigurations in web applications. Created by yogsec, this open-source tool helps you identify potential security loopholes before attackers can exploit them.

Key Features

Single URL Scanning: Test individual endpoints quickly
Bulk URL Scanning: Process multiple URLs from a wordlist
Multi-threaded Support: Configure concurrent threads for faster scanning
Custom Output: Save results to a file for later analysis
User-Friendly Interface: Clear output with vulnerability indicators

Understanding CORS Vulnerabilities

The tool checks for common CORS misconfigurations including:

Wildcard (*) in ACAO: Server accepts requests from any origin
Origin Reflection: Server echoes back the Origin header
Unsafe HTTP Methods: Allow dangerous methods like PUT/DELETE
Wildcard in ACAH: All headers are permitted
Credentials Enabled: Server allows sending credentials with requests

Installation Guide

Automatic Installation (Recommended)

git clone https://github.com/yogsec/cors
cd cors
sudo chmod +x install.sh
sudo ./install.sh

Manual Installation

git clone https://github.com/yogsec/cors
cd cors
chmod +x cors
sudo cp cors /usr/local/bin/

Verify Installation

cors -v

Expected output: cors version: 1.0

How to Use

Basic Syntax

cors [OPTIONS]

Usage Examples

1. Scan a Single URL

cors -u https://example.com

Output example:

[*] Checking: https://example.com
[!] https://example.com - Reflects origin in ACAO
[!] https://example.com - Credentials enabled

2. Scan Multiple URLs

Create a file urls.txt:

https://example.com
https://test.com/api
https://target.com

Run the scan:

cors -w urls.txt

3. Save Results to a File

cors -w urls.txt -o results.txt

4. Increase Scanning Speed

cors -w urls.txt -c 20

5. Combine Multiple Options

cors -w urls.txt -o vulnerable.txt -c 30

Get Involved

GitHub Repository: https://github.com/yogsec/cors
Report Issues: GitHub Issues
Contribute: Fork the repository and submit pull requests

Why This Tool Matters

In today's web application landscape, CORS misconfigurations are among the most common and dangerous security vulnerabilities. This tool provides:

Quick Identification: Rapidly detect potential CORS issues
Automated Testing: Streamline your security testing process
Comprehensive Coverage: Test multiple URLs and configurations
Developer-Friendly: Easy to use with clear output

How Evolve Security Academy's Cybersecurity Bootcamp Helps You Build Job-Ready Security Skills

Abhinav Singwal — Sat, 05 Sep 2026 04:36:30 +0000

Starting a career in cybersecurity can feel overwhelming. The industry is broad, and there are many different paths to choose from: penetration testing, SOC analysis, threat intelligence, cloud security, application security, incident response, and more.

For beginners, the biggest challenge is often finding a program that provides both foundational knowledge and practical experience.

The Cybersecurity Bootcamp by Evolve Security Academy takes a broad, hands-on approach to cybersecurity training. The program is designed to cover the core areas of the industry while helping students develop practical skills through labs, real-world tools, instructor-led training, and a cybersecurity internship.

The bootcamp is a 20-week, live online, part-time program with 200 hours of CPEs. According to the program details, no prior technical background or cybersecurity experience is required to enroll.

Learn More: https://www.academy.evolvesecurity.com/cybersecurity-bootcamp

A Curriculum That Covers the Cybersecurity Landscape

One of the strongest aspects of a cybersecurity career is understanding how different security domains connect.

The curriculum begins with an Introduction to Cybersecurity, covering fundamental concepts such as the CIA Triad, defense-in-depth, authentication, authorization, and the different domains of cybersecurity.

Students then move into important technical areas, including:

Networking
Security programs and governance
OSINT and social engineering
Threat intelligence
Security operations architecture
Threat detection
Cryptography
Application security and offensive security
Threat hunting and incident response

This broad approach can help students understand both the offensive and defensive sides of cybersecurity.

Learn Through Real Tools and Practical Labs

Cybersecurity cannot be learned through theory alone.

The bootcamp incorporates hands-on labs using tools that are widely recognized in the security industry, including Burp Suite, Nessus, Metasploit, Nmap, Wireshark, Kali Linux, ELK Stack, Hashcat, OpenSSL, Snort, AWS, Terraform, and more.

For someone interested in offensive security, the AppSec & Offensive Security module is particularly interesting. It covers vulnerability assessment, penetration testing, bug bounty, OWASP Top 10, DevSecOps, and Red Team/Blue Team concepts. Students also use tools such as Burp Suite, Nmap, Metasploit, Nessus, Nikto, Shodan, and Qualys.

As someone interested in web security and vulnerability research, I think practical exposure to tools such as Burp Suite and hands-on vulnerability assessment can be valuable when building real-world skills.

AI Is Now Part of Cybersecurity

Another interesting part of the curriculum is its focus on AI tools for cybersecurity.

The program covers topics such as AI-assisted SOC operations, large language models for security, prompt engineering, AI-assisted log analysis, detection rule generation, incident reporting automation, AI red teaming, prompt injection, and adversarial AI defense.

Cybersecurity professionals are increasingly working with AI-powered systems. Understanding how AI can assist security teams—and how AI systems themselves can be attacked—can become an important skill for future cybersecurity professionals.

Real-World Experience Through a Cybersecurity Internship

One of the most practical parts of the program is the final two-week cybersecurity internship.

According to the course details, students work in teams under instructor supervision and participate in security engagements for non-profit organizations. The work includes internal and external vulnerability assessments and a phishing engagement. Students then document their findings and present them to the organization's IT leadership.

This type of experience can help students understand something that is often difficult to learn through labs alone: how professional security assessments are conducted and communicated to real clients.

Finding a vulnerability is only one part of cybersecurity. Security professionals also need to understand scope, methodology, reporting, business impact, remediation, and professional communication.

More Than Just Technical Training

The bootcamp also includes job preparation, including career coaching, cybersecurity resume preparation, mock interviews, networking strategies, LinkedIn profile preparation, and job search strategy.

Students also receive a CompTIA Security+ voucher, according to the program information.

The program additionally offers the opportunity to earn an Evolve Security Academy Certification of Completion and an Evolve Security Certified Professional (ESCP) certification after meeting the relevant requirements and passing the hands-on lab examination.

Who Is This Bootcamp For?

Based on the curriculum, this bootcamp could be relevant for:

Beginners starting their cybersecurity career
IT professionals transitioning into cybersecurity
Security professionals looking for broader hands-on experience
Students interested in penetration testing and application security
Aspiring SOC analysts and security analysts
Professionals interested in AI-assisted cybersecurity
Anyone who wants exposure to both offensive and defensive security

The curriculum is not focused on just one cybersecurity specialization. Instead, it provides exposure to multiple areas of the security industry before students choose or develop a more specialized career path.

Learn more about the program here:

Evolve Security Academy - Cybersecurity Bootcamp:
https://www.academy.evolvesecurity.com/cybersecurity-bootcamp

Web Application Penetration Testing: A Comprehensive Sample Report

Abhinav Singwal — Fri, 04 Sep 2026 12:22:39 +0000

Introduction

Web application security is no longer optional—it is a business necessity. With cyberattacks becoming increasingly sophisticated, organizations must proactively identify and fix vulnerabilities before they can be exploited.

This post presents a sample penetration testing report I prepared for a hypothetical web application (vsite.com). The report demonstrates the depth of analysis, types of vulnerabilities uncovered, and the actionable remediation strategies I provide to clients.

Whether you are a developer, security enthusiast, or business owner, this post will give you a clear understanding of what a professional web application security assessment looks like.

Executive Summary
Scope of Assessment
Detailed Security Findings
Impact Analysis
Remediation Recommendations
Conclusion
About the Author

Executive Summary

This report presents the results of a comprehensive assessment of the web application conducted to identify security vulnerabilities, functionality issues, and user experience problems. The objective of this assessment is to help improve the application's security, stability, performance, and overall user experience.

Scope of Assessment

The assessment covers:

Web application penetration testing
Functional testing review
Authentication and authorization checks
Input validation testing
Session management analysis
File upload security
Business logic testing
Client-side security checks

Website Tested: vsite.com (hypothetical)

Detailed Security Findings

1. Information Disclosure – Cloudflare Analytics Token

The application is leaking Cloudflare analytics configuration details, including the analytics token and version information, through the data-cf-beacon attribute in the script tag.

Remediation: Remove the data-cf-beacon script tag from the HTML to stop exposing the analytics token.

2. Missing Rate Limiting

The application does not implement rate limiting on its endpoints, leaving it vulnerable to brute-force attacks and automated submissions.

Remediation: Implement rate limiting on all endpoints (e.g., 5–10 requests per minute per IP) using middleware, Nginx, or Cloudflare to prevent brute-force and automated attacks.

3. Cross-Site Scripting (XSS) Vulnerability

The contact form at vsite.com/contact is vulnerable to Cross-Site Scripting (XSS) attacks, as evidenced by the successful injection of the payload "><img src=x onerror=alert(1)> into several fields.

Remediation: Apply output encoding (HTML entity encoding) for all user-supplied data rendered in the browser and implement strict input validation/sanitization to reject or neutralize dangerous characters like <, >, ", ', and &. Additionally, deploy a Content Security Policy (CSP) to prevent execution of inline scripts.

4. Missing Rate Limiting on File Uploads

The application does not implement rate limiting for file uploads, allowing attackers to upload multiple files in rapid succession without restriction.

Remediation: Apply rate limiting specifically to file upload endpoints (e.g., max 5 uploads per minute per IP/user) and enforce file size limits.

5. Insecure Session Cookie Configuration

The session cookie ci_session at https://vsite.com is configured without the Secure flag, meaning it can be transmitted over unencrypted HTTP connections, making it vulnerable to network sniffing and session hijacking attacks.

Remediation: Set the Secure flag on the ci_session cookie and enforce HTTPS site-wide using HSTS to prevent transmission over unencrypted connections. Also set HttpOnly and SameSite=Strict attributes for additional protection.

6. Missing CSRF Protection on Contact Form

The contact form should include a CSRF token to protect against Cross-Site Request Forgery (CSRF) attacks.

Remediation: Generate a unique, unpredictable CSRF token per user session and embed it as a hidden field in the contact form; validate this token on the server side for all POST requests. Also set SameSite=Strict or Lax attribute on session cookies for defense in depth.

7. Server-Side Template Injection (SSTI)

The application allows users to register with the name {{7*7}} on https://vsite.com/favouriteuser.

Remediation: Sanitize and escape all user inputs before rendering in templates, and disable dynamic expression evaluation in the template engine to prevent Server-Side Template Injection.

8. Insecure File Upload Restrictions

The profile photo upload functionality (https://vsite.com/usereditprofile) does not properly restrict file uploads to allowed image formats.

Remediation: Restrict file uploads to allowed image MIME types (e.g., image/jpeg, image/png, image/gif), validate file extensions and magic bytes, and store uploaded files outside the web root with randomly generated names.

9. Weak Client-Side Validation

The login button remains clickable even when the password field is empty.

Remediation: Add client-side validation to disable the login button or display an error until both username and password fields are filled, and enforce server-side validation to reject empty or incomplete submissions.

10. Weak Password Policy

The registration page (https://vsite.com/register) enforces a weak password policy.

Remediation: Enforce a strong password policy requiring minimum 8 characters, including uppercase, lowercase, number, and special characters, and reject common passwords using a dictionary check or HaveIBeenPwned API.

11. Missing CSRF Protection on Logout

The endpoints https://vsite.com/logout do not use CSRF protection, allowing an attacker to trick a logged-in user into performing these actions.

Remediation: Implement CSRF tokens on the logout endpoint and require POST requests for logout actions instead of GET; also set SameSite=Strict attribute on session cookies.

12. JavaScript Injection in Contact Form Fields

The Subject and Message fields on https://vsite.com/contactus accept JavaScript code as input.

Remediation: Apply strict input validation to reject JavaScript/HTML payloads, use output encoding for all rendered user input, and implement a Content Security Policy to prevent script execution.

13. Weak Password Policy on Change Password Form

The change password form at https://vsite.com/changepassword allows users to set very weak passwords such as 123.

Remediation: Enforce the same strong password policy on the change password form (minimum 8 characters with uppercase, lowercase, number, and special character), and reject common weak passwords using a dictionary or HaveIBeenPwned API.

14. Session Management – Registration Page Accessible After Login

When already logged in at https://vsite.com/docdashboard, the application still allows access to the registration page at https://vsite.com/register.

Remediation: Implement session-aware access controls to redirect authenticated users away from registration and login pages (e.g., to their dashboard) by checking session status on the server side before rendering these pages.

15. Cached Pages After Logout

After logging out from the user dashboard (https://vsite.com/dashboard), pressing the browser's Back button displays the dashboard again.

Remediation: Set cache-control headers (Cache-Control: no-cache, no-store, must-revalidate, Pragma: no-cache, Expires: 0) on authenticated pages and invalidate the session server-side upon logout to prevent cached pages from being displayed after logout.

16. Login Page Accessible After Login

When already logged in, the application still allows access to the login page (https://vsite.com/login).

Remediation: Redirect authenticated users away from the login page to their dashboard by checking session status server-side before rendering the login page.

17. Duplicate Registration Page Access Issue

When already logged in, the application still allows access to the registration page (https://vsite.com/register).

Remediation: Redirect authenticated users away from the registration page to their dashboard by checking session status server-side before rendering the registration page.

18. Sensitive Paths in Robots.txt

The robots.txt file (https://vsite.com/robots.txt) disallows crawling of the login page (https://vsite.com/login/).

Remediation: Remove the login page disallow rule from robots.txt or update it to only block truly sensitive/internal paths, as robots.txt should not be relied upon for security and login pages should be protected by authentication instead.

19. Anonymous FTP Access

The FTP server on vsite.com allows anonymous login, enabling users to connect without valid authentication credentials.

Remediation: Disable anonymous FTP access immediately and require strong authentication credentials; additionally, migrate to SFTP or FTPS for encrypted file transfers.

20. Missing CSRF Protection on Document Upload

There is a complete absence of CSRF protection on the document upload form located in https://vsite.com/upload-document.

Remediation: Implement CSRF tokens on the document upload form and validate them server-side for all POST requests, and set SameSite=Strict attribute on session cookies for additional protection.

21. Hardcoded Credentials Exposed in HTML

Login credentials (username and password) are being exposed in plain text within the HTML of the page at https://vsite.com.

Remediation: Immediately remove hardcoded credentials from the HTML source and never embed sensitive data in client-side code; store all secrets in environment variables or secure vaults and enforce their use server-side only.

Impact Analysis

The identified issues may expose the application to:

Security risks and data compromise
Unauthorized access and session hijacking
Functional failures and broken business logic
Degraded user experience
Reputational damage and legal liabilities

Addressing these findings will strengthen the application's security, reliability, performance, and overall usability.

Remediation Strategy

Implement the recommended security controls, input validation, access restrictions, and code fixes to address the identified vulnerabilities and functional issues. After applying the fixes, perform a comprehensive retest to verify that all issues have been resolved and no new vulnerabilities have been introduced.

Conclusion

This sample report illustrates the importance of regular web application security assessments. Vulnerabilities ranging from information disclosure to injection attacks and broken access controls can have severe consequences if left unaddressed.

A professional penetration test not only identifies these weaknesses but also provides clear, actionable steps to fix them. Security is not a one-time activity—it is an ongoing process that requires continuous attention and improvement.

If you are looking for a thorough security assessment for your web application, or need assistance with vulnerability remediation, secure code review, or post-remediation retesting, feel free to reach out.

About the Author

Abhinav Singwal

Web Application Penetration Tester

I specialize in identifying security vulnerabilities, functionality issues, and user experience problems in web applications. My goal is to help organizations build secure, reliable, and user-friendly applications.

Email: abhinavsingwal@gmail.com
LinkTree: https://linktr.ee/abhinavsingwal

What is XSS? Understanding Cross-Site Scripting, the #1 Web Vulnerability

Abhinav Singwal — Thu, 03 Sep 2026 15:52:57 +0000

What Exactly is XSS?

At its core, XSS is a vulnerability that allows an attacker to inject malicious scripts into a website that is then viewed by other users . The core idea is simple: a website takes untrusted user input and sends it back to a user's browser without properly validating or encoding it . The user's browser then executes this input as if it were part of the website's legitimate code.

For example, imagine a search box that displays your search term on the page. If the website doesn't escape the < and > characters, an attacker could enter a search term like:

<script>alert('XSS')</script>

If the website simply reflects this back in the HTML, the browser will execute that JavaScript code. This is known as Reflected XSS, where the malicious script comes from the current HTTP request .

Hands-On Practice: The XSS-Labs Environment

One of the best ways to understand XSS is to practice in a safe environment. The XSS-Labs project by YOGSEC provides a browser-based lab environment specifically designed for this purpose.

You can explore the first lab here: https://yogsec.github.io/xss-labs/labs/lab1.html

GitHub: https://github.com/yogsec/xss-labs

Lab #1: Reflected XSS in Action

Lab #1 demonstrates a classic Reflected XSS vulnerability through a GET parameter.

The Vulnerability: The application reads the ?q= parameter from the URL and injects it directly into the DOM using innerHTML with no sanitization. The vulnerable code looks something like this:

const query = new URLSearchParams(location.search).get('q');
document.getElementById('output').innerHTML = query;

The Goal: Your task is to execute JavaScript (pop an alert box) by manipulating the ?q= URL parameter.

Working Payloads: Try appending one of these payloads to the URL after ?q=:

Image Error Event:
```
?q=<img src=x onerror=alert('XSS')>
```
This attempts to load an image from a nonexistent source ("x"), triggering the onerror event, which executes the JavaScript.
Body onLoad:
```
?q=<body onload=alert(document.cookie)>
```
This uses the <body> tag's onload event to execute JavaScript once the page loads. This demonstrates how an attacker could access sensitive information like cookies.
SVG onLoad:
```
?q=<svg onload=alert(1)>
```
SVG elements also support the onload event, making this another viable vector.
Input Autofocus:
```
?q=<input onfocus=alert(1) autofocus>
```
This payload uses the autofocus attribute to trigger the onfocus event, executing JavaScript without any user interaction.

How to Fix It: Prevention and Mitigation

The solution to this vulnerability is straightforward. Here are two common approaches:

Method 1: Use `textContent` Instead of `innerHTML`

The simplest fix is to change the code to use textContent, which automatically escapes HTML entities and renders the input as plain text:

const query = new URLSearchParams(location.search).get('q');
document.getElementById('output').textContent = query;

Method 2: Escape HTML Entities

If you must use innerHTML, you should always escape special characters:

function escapeHtml(str) {
    return str.replace(/[&<>]/g, function(m) {
        if (m === '&') return '&amp;';
        if (m === '<') return '&lt;';
        if (m === '>') return '&gt;';
        return m;
    });
}
document.getElementById('output').innerHTML = escapeHtml(query);

Additional Security Measures

Beyond these code-level fixes, a robust security strategy should include:

Content Security Policy (CSP): A browser-level defense that can significantly mitigate the impact of XSS by blocking inline script execution .
Context-Aware Output Encoding: Apply the correct type of encoding based on where the data is being inserted (HTML body, JavaScript string, URL, etc.) .

How to Search Any Person Online

Abhinav Singwal — Thu, 03 Sep 2026 05:55:16 +0000

How to Search People Online: A Simple Guide for Everyone

Have you ever tried to find someone online but only got thousands of useless results? You're not alone. Searching for people on Google can be frustrating when you don't know the right tricks.

What is This All About?

Think of Google like a giant library with billions of books. Normally, when you search for someone, you're just looking at the titles. But with the right techniques, you can look inside every book and find exactly what you need.

Why Normal Searches Fail

Let's say you're looking for "John Smith."

A normal search gives you millions of results
Most of them are about other John Smiths
You waste hours scrolling through irrelevant pages

Google Dorks fix this problem by telling Google exactly what you want to find.

The Easiest Way to Search People

Memorizing all these tricks can be confusing. That's why a simple tool called People Search was created.

What is People Search?

It's a free, easy-to-use website that does all the hard work for you. You just tell it two things:

The person's name
A clue about them (where they work, their job, or where they live)

The tool then creates the perfect Google search for you.

How to Use It (3 Simple Steps)

Step 1: Go to yogsec.github.io/People-Search

Step 2: Type in the name and a clue

Step 3: Click the search button

That's it! The tool does everything else.

Real-Life Example

Let's say you want to find a person named "Abhinav Singwal" who works as a security researcher.

Normal Search: "Abhinav Singwal" → Millions of confusing results

Using People Search Tool:

Name: Abhinav Singwal
Clue: security researcher
Click Search

Result: You get exactly the right person's professional profiles and information.

Important Rules to Follow

These techniques are powerful, but with great power comes great responsibility.

DO Use It For:

Finding old classmates or friends
Job research and networking
Checking if your own information is public
Legitimate research and investigations

DON'T Use It For:

Stalking or harassing people
Stealing identities
Invading anyone's privacy
Anything illegal

Remember: Just because information is public doesn't mean you should misuse it. Always respect others' privacy.

Quick Start Guide

Gather clues – Name, job, city, company, or school
Visit the tool – https://yogsec.github.io/People-Search
Enter information – Name + best clue you have
Click search – Let Google do the work
Review results – Look through the relevant pages

Ready to try it? Visit yogsec.github.io/People-Search and start searching in seconds.

Contact: linktree/abhinavsingwal

How Technographic Tools Like StackScan Can Strengthen Cybersecurity Analysis?

Abhinav Singwal — Mon, 24 Aug 2026 04:57:21 +0000

The Problem with Traditional Security Tools

When a new security flaw is discovered, teams ask: "Who is actually affected?"

But finding the answer isn't easy.

Old ways don't work well:

Vendor emails tell you who should be affected, not who actually is
Shodan shows open ports, not what a website loads in your browser
Technology lists track big names but miss specific versions
Security scanners can't check every website on the internet

What if you could search for one file and instantly see every website using it?

That's exactly what tools like StackScan's Custom Scan let you do.

StackScan's Custom Scan lets you find any website by searching for a specific file, folder, or host-making it easy to track vulnerable versions, third-party risks, and hidden technologies without needing a pre-made list.

How Security Researchers Use This

1. Find the Exact Risky Version

Version numbers are usually in file names. When a security flaw targets a specific version, you can find exactly that version:

jquery-1.12.4.min.js - 377,673 websites
jquery-1.11.3.min.js - 232,719 websites

This is much better than asking "Who uses jQuery?"-which gives millions of sites, most using safe versions.

2. Check Supply Chain Risk

When a third-party provider gets hacked or changes ownership, every site using them is at risk:

polyfill.io          - 16,016 websites
cdn.polyfill.io      - 9,866 websites

In 2024, polyfill.io had a widely reported security problem. A quick search showed exactly who was still affected.

3. Find Plugin Usage

Most WordPress plugins store files in the same folder on every site. One search finds all users:

/wp-content/plugins/revslider/ - 2,248,932 websites

4. Map Third-Party Dependencies

Before a problem happens, know what you're dealing with:

cdnjs.cloudflare.com - 5,833,844 websites
cdn.jsdelivr.net     - 4,363,936 websites

5. Find Things That Aren't Cataloged

Custom tools, company-specific scripts, new frameworks-if a site loads it and it has a unique filename, you can find it. No list needed.

Simple Workflow for Security Teams

1. Find one site that has the file you're looking for
2. Search for it
3. Check the sample results to make sure they're right
4. Try 2-3 different searches and compare
5. Add country filters if you only want certain regions
6. Download the full list (only cost)
7. Run again later to see who fixed the problem

Key point: Searching is free and unlimited. You only pay when you download the results.

How to Run a Custom Scan on StackScan

Step 1: Open and Sign Up

Go to https://www.stackscan.com, Click on the "Get Started" button in the top right corner. Sign up with your email. Once registered, you'll be taken to the Custom Scan page.

Step 2: Choose What to Search For

Pick one option:

File Name - Search for a specific file - jquery.js
File Path - Search for a folder - /wp-content/plugins/
Asset Host - Search for the website providing the file - cdn.shopify.com

Step 3: Type What You Want to Find

Type the file name, folder, or website address you're looking for.

Examples:

woocommerce.css
/wp-content/plugins/
polyfill.io

Tip: You can paste a full website address—the tool will clean it up for you.

Step 4: Click "Search"

Press the search button.

You'll instantly see:

Total number of websites found
10 sample websites with their country and domain
Country filters to narrow results (optional)

Step 5: Check the Sample Results

Look at the 10 sample websites.

Ask yourself:

Are these the right kind of websites?
Do they actually use what I searched for?

If not, try a different search term.

Step 6: Try Different Search Terms

Searching is free, so try different versions:

Example for WordPress:

/wp-content/ - 25 million+
/wp-includes/js/ - 21 million+
wp-embed.min.js - 1.5 million+

Choose the one that best fits what you need.

Step 7: Download Your Results

What's Included

The index covers JavaScript and CSS files only-the code that runs in your browser. It does not include:

Files on the server
Settings files
Response headers
Images or fonts
Anything a page doesn't link to

This is designed this way-it's exactly what makes it useful for browser-based and third-party questions.

Company Data

You'll get company data (name, size, industry, location, LinkedIn URL) for some websites in your export.

Real Examples

WordPress-One Platform, Different Results

/wp-content/ - 25,809,358
/wp-includes/js/ - 21,948,511
wp-embed.min.js - 1,599,285

The same platform, but results vary by 16×!

Lesson: Search for core folders, not optional files, if you want the biggest picture.

Other Uses

Check plugin popularity for any WordPress plugin
Find competitor users by searching their tracking scripts
Track framework adoption like React or Next.js
Find weak spots by searching for /node_modules/ (sites exposing their code)

How to Find People on the Internet

Abhinav Singwal — Sat, 25 Jul 2026 18:09:36 +0000

You may know a person's name, but searching it on Google often returns hundreds of unrelated results. Sometimes you know a little more about them—their profession, company, city, or another detail—but combining that information into an effective search can still be time-consuming.

That's why I built the People Search Tool.

It helps you create targeted Google searches using just two pieces of information, making it easier to find publicly available information about a person.

What Is the People Search Tool?

The People Search Tool is a free web application that helps you search for people online more efficiently.

All you need to enter is:

Person's Name
A Clue or Additional Information

The clue can be anything you already know, such as:

Job title
Company name
City or country
College or university
Username
Industry
Hobby
Any other identifying detail

The tool then generates multiple search queries that you can open in Google with a single click.

Example

Suppose you're looking for someone named:

Name

Abhinav Singwal

Clue

Penetration Tester

Use People Search: https://yogsec.github.io/People-Search/

The tool creates multiple search queries that help you locate publicly available profiles, articles, websites, and other online information related to that person.

Instead of manually trying different combinations, the tool does the work for you.

Why I Built This Tool

Many people spend several minutes changing search terms, adding new keywords, and trying different websites before finding the right person.

I wanted to simplify that process.

With just two input fields, the People Search Tool generates multiple search queries in seconds, helping you reach relevant results faster.

Who Can Use It?

The People Search Tool is useful for anyone who needs to find publicly available information online, including:

Recruiters searching for candidates
Journalists verifying public information
Students researching authors or speakers
Security researchers performing OSINT
Bug bounty hunters
Event organizers looking for speaker profiles
Anyone trying to locate a person's public online presence

LinkedIn - https://www.linkedin.com/in/abhinavsingwal/

Vulnerable Login: Learn 12 Common Authentication Vulnerabilities

Abhinav Singwal — Sat, 25 Jul 2026 03:12:13 +0000

Authentication is one of the most important parts of any web application. A single mistake in a login system can expose user accounts, leak sensitive information, or even allow attackers to gain complete access to an application.

Unfortunately, many developers learn secure authentication only after discovering security issues in production.

To help developers and security students understand these risks, I created Vulnerable Login, a deliberately insecure login application that contains 12 common authentication vulnerabilities found in real-world web applications.

This project is built for education only. It allows developers and penetration testers to safely explore insecure authentication mechanisms and understand how to fix them.

Why I Built Vulnerable Login

Many tutorials explain authentication using only secure examples. While that is important, it doesn't show developers what insecure authentication actually looks like.

Understanding vulnerable code helps developers:

Identify authentication weaknesses before attackers do
Learn common security mistakes
Practice web application penetration testing
Improve secure coding skills
Understand how authentication attacks work

The goal of this project is to make learning authentication security practical instead of theoretical.

Live Demo

You can test the vulnerable application here:

Live Demo: https://yogsec.github.io/Vulnerable-Login

GitHub Repository:

https://github.com/yogsec/Vulnerable-Login

Important: Never use this code in production. Every vulnerability is intentionally included for educational purposes.

Authentication Vulnerabilities Included

The project contains twelve intentionally vulnerable authentication mechanisms.

1. SQL Injection Authentication Bypass

User input is directly inserted into SQL queries.

Developers will learn:

Why parameterized queries are important
How SQL Injection bypasses authentication
How prepared statements prevent attacks

2. Plaintext Password Storage

Passwords are stored in plain text instead of being securely hashed.

This demonstrates why passwords should never be stored without strong hashing algorithms such as bcrypt or Argon2.

3. No Rate Limiting

The login page allows unlimited login attempts.

Students can understand how brute-force attacks become possible when no request limits exist.

4. No Account Lockout

Even after repeated failed login attempts, accounts remain accessible.

This demonstrates why account lockout policies are an important security control.

5. Weak Passwords

The application contains users with predictable passwords.

Examples include passwords that attackers commonly try first during password guessing attacks.

6. Weak MD5 Password Hashing

Passwords are hashed using MD5 without salt.

Developers can understand why MD5 is no longer considered secure for password storage.

7. Verbose Error Messages

Different error messages reveal whether a username exists.

This small mistake provides valuable information to attackers.

8. User Enumeration

The application allows attackers to determine valid usernames.

Developers can learn how consistent responses reduce information disclosure.

9. Session Fixation

The session identifier is not regenerated after successful login.

Students can observe how attackers may hijack authenticated sessions.

10. Hardcoded Credentials

Administrative credentials are embedded directly inside the source code.

This demonstrates why secrets should never be committed into repositories.

11. No HTTPS Protection

Credentials are transmitted over HTTP instead of HTTPS.

Developers can understand why encrypted communication is essential for protecting usernames and passwords.

12. CSRF Protection That Doesn't Work

The application includes an anti-CSRF token but never validates it.

This demonstrates how incomplete security implementations create a false sense of protection.

Who Should Use This Project?

This repository is useful for:

Frontend Developers
Backend Developers
Full Stack Developers
Security Researchers
Bug Bounty Hunters
Penetration Testers
Students Learning Cybersecurity
Web Security Trainers
University Instructors

What Developers Will Learn

After exploring this project, you'll better understand:

Authentication security
Login security best practices
Password storage
Session management
Secure authentication design
Brute-force protection
SQL Injection prevention
CSRF mitigation
User enumeration prevention
Secure coding practices

These concepts are directly applicable when building secure web applications.

API Pentesting Tools: A Complete Open-Source Collection for Learning and Bug Hunting

Abhinav Singwal — Fri, 24 Jul 2026 17:38:02 +0000

If you're learning API security or participating in bug bounty programs, you've probably faced this problem:

"Which tool should I use for API reconnaissance? What about authorization testing? Is there a good tool for GraphQL? Which fuzzing tool is best?"

Instead of searching through dozens of blog posts and GitHub repositories, I decided to create one place where everything is organized.

That's why I built API Pentesting Tools, an open-source repository that collects useful tools for every stage of API security testing.

GitHub:
https://github.com/yogsec/API-Pentesting-Tools

Why I Created This Repository

When I started learning API penetration testing, I spent more time searching for tools than actually testing APIs.

Every article listed different tools. Some were outdated, while others only covered one part of API testing.

I wanted a repository where students, beginners, and bug bounty hunters could quickly find the right tool without wasting time.

Today, this repository is helping people discover API security tools from one central place and is ranking #2 on Google for the search term "API Pentesting Tools."

What You'll Find

The repository is divided into different API testing categories.

API Reconnaissance

Before testing an API, you need to understand its attack surface.

This section includes tools for:

API endpoint discovery
Subdomain enumeration
Swagger analysis
GraphQL schema discovery
Hidden endpoint discovery ...

Who Should Use This Repository?

This project is useful for:

Students learning API Security
Bug Bounty Hunters
Penetration Testers
Security Researchers
API Developers
Anyone interested in Application Security

Whether you're preparing for interviews, solving API labs, or hunting vulnerabilities on bug bounty platforms, this repository can save you time.

Why Bookmark This Repository?

Instead of remembering hundreds of tool names, you can use this repository as a quick reference.

It is regularly updated with useful tools so you can easily discover new resources for API penetration testing.

Repository:
https://github.com/yogsec/API-Pentesting-Tools

LinkTree: https://linktr.ee/abhinavsingwal

CVE-2026-56844: Veeam Security Update You Should Know About

Abhinav Singwal — Thu, 23 Jul 2026 03:19:01 +0000

CVE-2026-56844 is a privilege escalation vulnerability found in the Veeam Updater component of the Veeam Software Appliance. The flaw enables a local user with existing high privileges to elevate further and gain root-level access to the underlying operating system.

Root Cause

The vulnerability is classified as CWE-22: Path Traversal. This indicates that the root cause lies in insufficient input validation when processing pathnames. The updater component fails to properly restrict directory traversal sequences, allowing an attacker to manipulate file paths and access restricted locations on the filesystem.

The technical implementation of this flaw involves improper privilege management within the updater service, where insufficient validation occurs during the update process. This represents a classic case of privilege escalation through insecure component design—legitimate functionality becomes a vector for unauthorized privilege elevation.

CVSS

The key nuance is the PR:H (Privileges Required: High) metric—an attacker already needs elevated access. This vulnerability enables further escalation from high privileges to full root control.

Affected Products and Versions

The vulnerability affects:

Veeam Software Appliance (Linux-based Veeam Backup & Replication server)
Veeam Infrastructure Appliance Not affected:
Windows-based Veeam Backup & Replication servers (though remote Linux components they manage may still be vulnerable)
Veeam Backup & Replication version 13.0.2 is listed as unaffected

Exploitation

An attacker can exploit this weakness by:

Crafting malicious update packages
Manipulating existing update mechanisms
Leveraging the updater's legitimate administrative capabilities for unauthorized system access Once root access is obtained, an attacker can:
Modify system files
Install persistent backdoors
Access sensitive backup data
Manipulate backup operations
Potentially compromise the entire backup infrastructure ### Mitigation

The patch is included in Veeam Updater version 12.3.0.65. For systems that cannot reach Veeam's update repository, manual installation is required.