Overview

webtechalyser is a Go-based command-line tool designed to fingerprint the technologies powering any website. It performs live analysis of HTTP responses, headers, and HTML content to identify frameworks, CMSs, JS libraries, and server technologies.
Built for speed, portability, and accuracy — ideal for reconnaissance, vulnerability research, and digital forensics.

Features

• Automatic Technology Detection: Identifies web frameworks, JS libraries, CMSs, servers, analytics tools, and more.

• CLI Simplicity: Single binary; no dependencies beyond Go.

• Real-Time Scanning: Makes live HTTP requests and analyzes response metadata.

• Cross-Platform: Works across macOS, Linux, and Windows.

• Modular Core: Built on github.com/projectdiscovery/wappalyzergo.

Installation

1. Clone the repository

git clone https://github.com/ousbaailyas/webtechalyser.git
cd webtechalyser

2. Install Go

If not installed, get it from golang.org/dl.
Verify installation:

go version

3. Build

go mod tidy
go build -o webtechalyser

4. Run

./webtechalyser -url https://example.com

Usage

Command-line Options

./webtechalyser -url https://target-domain.tld

Example Output

Analyzing: https://example.com
Detected Technologies:
  - Nginx
  - WordPress
  - jQuery
  - Google Analytics

If no URL is provided, the program exits with a usage message.

Code Structure

main.go

package main

import (
    "flag"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "os"
    "time"
    "github.com/projectdiscovery/wappalyzergo"
)

func analyzeWebsite(url string) (map[string]struct{}, error) {
    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    data, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    analyzer, err := wappalyzer.New()
    if err != nil {
        return nil, err
    }

    fingerprints := analyzer.Fingerprint(resp.Header, data)
    return fingerprints, nil
}

func main() {
    url := flag.String("url", "", "Target website URL to analyze")
    flag.Parse()

    if *url == "" {
        fmt.Println("Usage: ./webtechalyser -url https://example.com")
        os.Exit(1)
    }

    results, err := analyzeWebsite(*url)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Detected Technologies: %v\n", results)
}

Architecture & Design

• Language: Go — chosen for static binaries, concurrency, and network efficiency.

• Core Engine: ProjectDiscovery’s WappalyzerGo.

• HTTP Client: Lightweight net/http with timeout handling.

• Concurrency: Ready for future multi-domain scanning (goroutine expansion planned).

• Output Handling: Human-readable console output; easily scriptable for JSON or file logging.

Flow:

1. Input URL via flag.

2. Fetch response with 10s timeout.

3. Pass headers and body to Wappalyzer client.

4. Receive fingerprints → print or export.

Enhancements (Future Roadmap)

•  Add JSON output for integration with other recon pipelines.

•  Support bulk scanning from file input.

•  Add concurrency for multiple targets.

•  Implement retry and timeout management per target.

•  Optional web UI dashboard for visualization.

Example Integration

Run in a reconnaissance chain:

cat targets.txt | xargs -n1 -P5 ./webtechalyser -url

Combine with httpx or subfinder for full automation.

Security & Ethics

Use only on targets you own or have explicit permission to test. This tool is for educational and authorized security research purposes only.

License

MIT License — open for modification and educational use.