CLI tool
projectdiscovery/uncover avatar
projectdiscovery/uncover

uncover has three Go versions, four provider inventories, and a scope boundary made of three printed warning lines

Quickly discover exposed hosts on the internet using multiple search engines.

3,116 stars283 forksGoMIT

At a glance

What is it?
uncover is a thin Go wrapper over internet search-engine APIs that turns a query into a list of exposed hosts, and it is explicitly built to be piped into a pipeline. Its scope boundary is a disclaimer it prints on every run rather than a technical control, which is the thing to understand before using it, and its packaging has drifted in three places at once.
Who is it for?
Use uncover only against infrastructure you are authorised to assess, and put the authorisation in writing per target before you run it, because nothing in the tool enforces it. The three printed warnings are a liability disclaimer, not a control: there is no allow-list, no per-host check, no dry-run and no abort switch.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 6 days ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • projectdiscovery/uncover3,116 ★ · +53
Star history
Repository2026-09-242026-11-15
projectdiscovery/uncover3.1k3.1k

53 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The only scope boundary is three warning lines printed at startup

Every run prints the same three lines: use with caution and accept responsibility for your actions, a statement that the developers assume no liability for misuse or damage, and a note that using the tool means agreeing to the terms of the search APIs it calls. That is the entire boundary. There is no allow-list, no per-target authorisation check, no confirmation prompt, no dry-run mode and no abort switch anywhere in the visible documentation, and the tool is built for the opposite of careful entry, with input accepted from standard input, from a file or from a configuration source, and output written to standard output for the next stage of a pipeline. A query is the only control surface, and a query is a search string rather than a scope.

That combination is why the two flags matter more than their descriptions suggest. The ordinary query flag accepts repeated values and reads from standard input, a file or configuration. The curated-corpus flag accepts repeated values too, which means a single invocation can fan out across many prewritten searches at once. Multiplied by the engine flag, which also takes repeated values, the number of distinct searches one command line can issue is the product of three multi-valued inputs, with no cap stated anywhere in the file.

One product name can enumerate its internet-wide exposure

The flag list includes a switch that takes a bare product name and is documented as using awesome search queries to discover exposed assets on the internet, with the example being a single ticketing system name. That corpus is a dependency of the module itself, pinned as a bare commit rather than a release. So the tool ships a curated set of prewritten search strings and, given one word, expands it and sends every variant to whichever search APIs you named. This is the mechanism in its purest form: there is no notion of a target set, because the output is defined as everything on the internet matching a pattern, and narrowing it is the operator's problem.

Three Go versions, and the container cannot build the module it ships

The installation section states that the tool requires a specific Go language version, and gives an install command that fetches the latest release of the command package. The module file declares a different, much newer language version. The container file names a third: the builder stage is pinned to a Go release that is older than the module declaration, and it runs the module download and build steps. So a contributor who installs the Go version the README asks for will be refused by the toolchain, and anyone building the published container image will hit a language-version mismatch too. The three numbers are all in the repository and none of them agrees with the other two.

Four inventories of the same provider list, none of them complete

Count the providers four ways. The features section names fifteen. The accepted values printed in the help text list fourteen, and one of those is a variant of an engine that appears nowhere in the features list. The example configuration file shows ten. The environment-variable block covers sixteen. Two providers can therefore be given credentials and still not be selected on the command line, and one can be selected without ever being described in the feature list. For a tool whose value is breadth of coverage, the provider list is the feature list, and here it is maintained in four places with four different answers.

Keys are randomised per execution

The configuration format accepts a list of keys per provider, and the file states that when more than one is present a random one is used for each execution. Combined with the feature bullet advertising automatic key randomisation, that is two independent rotations happening at once: you supply a pool, and the tool spreads each run across it. The operational consequence is that the provider cannot attribute a sequence of searches to a single key, which is useful for staying under a per-key quota and unhelpful when you are trying to work out which of your keys was charged.

Credential shapes are not uniform across providers

Most providers take a single secret in the configuration file, expressed as a list so you can supply more than one. Two do not. One expects a token and an organisation identifier joined by a colon, and another expects an email address and a key joined by a colon. The environment-variable route mirrors that: the majority need one variable, and those two need two each. Nothing in the file explains why, and a script that generates the configuration from a secret store has to special-case them.

Three build invocations for one binary, and one of them names a file

Three build invocations for one binary, and one of them names a file. The build file names a single source file inside the command directory rather than the package:

sh
$(GOBUILD) $(GOFLAGS) -ldflags '$(LDFLAGS)' -o "uncover" cmd/uncover/uncover.go

That form compiles exactly that file and silently ignores anything else in the same directory, so a package that grows a second file keeps building only the first. The container file names the package instead, which is the correct form, and the installation instructions use the package-install form against the latest release. So a repository with one entry point can end up producing two different binaries depending on which path you take, and the one in the Makefile is the fragile one.

The runtime image installs DNS tools and upgrades its own packages

The release stage of the container file starts from a pinned Alpine tag and then immediately runs a full package upgrade before adding two packages. The upgrade makes the pinned tag meaningless, so two builds from the same commit produce different images. Of the two packages added, one is a certificate bundle and the other is a set of DNS query tools, in an image whose entire job is making authenticated HTTP requests to a handful of API hosts. Nothing in the tool resolves DNS itself; the resolver is the host's. The build stage also writes the compiled binary into the source tree path and then copies it out from there, which works and leaves a stray artefact in the build context.

The dependency manifest explains why the tool is as thin as it is. Of the fifteen providers, exactly one has a vendor SDK in the direct requirements; the rest are reached over HTTP through a retrying client, which is why the module carries a flag-parsing library, a logger, a rate limiter, a descriptor-limit helper, a cache and a CIDR-parsing library rather than fifteen generated clients. The same block also lists an assertion library used by tests as if it were a direct dependency of the shipped binary, which is a small packaging smell in an otherwise tidy manifest.

Editorial conclusion

Use uncover only against infrastructure you are authorised to assess, and put the authorisation in writing per target before you run it, because nothing in the tool enforces it. The three printed warnings are a liability disclaimer, not a control: there is no allow-list, no per-host check, no dry-run and no abort switch. The realistic uses are defensive, enumerating your own addresses or a product you own to find its own footprint. Pin your Go toolchain to the module's declared version rather than the README's, expect two providers to be configurable but unselectable, and remember that keys are randomised per run, which removes per-key attribution at the provider.

Frequently asked questions

What is uncover used for?

It is a Go wrapper over the APIs of well known internet search engines that turns a query into a list of exposed hosts, built for automation so the output can feed existing pipeline tooling. Input is accepted from standard input, a file or configuration, and output goes to standard output.

how to install uncover

With the Go toolchain, by running the documented package-install command against the latest release. The README states a Go version requirement, though the module declares a newer language version and the container build pins an older one again.

Does uncover check that I am allowed to scan a host?

No. It prints three warnings at startup placing responsibility on the user and pointing at the search APIs' terms, but there is no allow-list, no per-target authorisation check, no confirmation and no dry-run. Authorisation has to come from outside the tool.

How many search engines does uncover support?

The file gives four different answers: fifteen named in the features list, fourteen accepted values in the help text including one that is not described, ten shown in the example configuration, and sixteen covered by environment variables. Two providers can be configured but not selected.

What happens when I configure several API keys for one provider?

A random one is used for each execution, and the tool also advertises automatic key randomisation as a feature. Credential shapes differ by provider: most take one secret, while two require a joined pair, such as a token with an organisation identifier.

Official sources

  1. Issues
  2. License: MIT
  3. projectdiscovery/uncover on GitHub
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/projectdiscovery-uncover.svg)](https://hysenlabs.com/projects/projectdiscovery-uncover)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/projectdiscovery-uncover.svg)](https://hysenlabs.com/projects/projectdiscovery-uncover)

Was this useful?