Skip to main content
skill CX Codex

outbound-destination-check — Claude Code skill: how to install

outbound-destination-check is a Claude Code skill that inspects unexpected outbound connections to separate regular vendor phone-home calls from potential intruder traffic.

Apache-2.0 ★ 71 updated 2026-11-15

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Problem99-io/kodeblue --skill outbound-destination-check -a claude-code
Open on GitHub

What outbound-destination-check does

The skill verifies destination IP addresses by executing forward and reverse DNS lookups through getent. It matches IP endpoints against documented hosts for software updates, telemetry endpoints, ACME renewal servers, and container registries.

The routine inspects process invocation flags via ps or docker inspect to pinpoint telemetry toggles within the application configuration. It also contrasts connection timestamps with the process launch time, because periodic bursts at fixed offsets typically point to internal software timers. Execution requires host_exec access on the host system.

What it helps with

  • identify who owns an external IP before terminating a running service
  • distinguish automated vendor update checks from command-and-control activity
  • calculate connection time offsets relative to process launch
  • locate configuration flags that disable background phone-home calls

Example prompts for the agent

  • Run an outbound destination check on PID 4210
  • Verify the external IP address reported by the outbound connection alert
  • Inspect this service process for telemetry timers and update checks

How to install outbound-destination-check

1Skills CLI (Vercel)

npx skills add Problem99-io/kodeblue --skill outbound-destination-check -a claude-code

2Manually: put the files in place

~/.claude/skills/outbound-destination-check/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/outbound-destination-check/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about outbound-destination-check

How to install outbound-destination-check in Claude Code?

Run npx skills add Problem99-io/kodeblue --skill outbound-destination-check -a claude-code in your terminal.

What does outbound-destination-check do?

It uses DNS lookups, process argument inspections, and startup time offsets to verify whether outbound network requests belong to expected software behavior.

What is required to run outbound-destination-check?

It requires host_exec capability along with host commands like getent, ps, and Docker inspection tools.

Source text

SKILL.md · Apache-2.0
---
name: outbound-destination-check
description: Identify who an outbound connection really goes to before calling it hostile — reverse and forward name lookups, the software's own built-in phone-home (update checks, usage stats, ACME, package mirrors), and timing against the process start and earlier sightings.
metadata:
  kodeblue-bundled: true
---

# Who is this connection to?

A service's own process connecting to a public address it was not seen using
before is either an attacker's code calling home or the software calling its
vendor. Many servers call home on their own: update checks, anonymous usage
stats, plugin catalogs, certificate renewal. These calls are rare (once a day,
or once some minutes after start), so a learning run often misses them and a
`no_outbound` monitor fires on the first one. Find out which it is before you
contain, because killing a service's main process takes the service down, and
its supervisor starts it again.

Do these checks in order. Each one costs one or two `host_exec` calls.

## 1. Name the destination
- **Reverse name:** `host_exec ["getent","hosts","<ip>"]`. A vendor or CDN name
  (`lb-140-82-121-5-fra.github.com`) says who runs the address. A cloud name
  (`ec2-35-180-167-84.eu-west-3.compute.amazonaws.com`, `*.googleusercontent.com`,
  `*.cloudfront.net`) only names the cloud provider, not its customer. Thousands
  of vendors run there, so "AWS" or "a cloud IP" is neither hostile nor an answer:
  go on to the forward check.
- **Forward match:** resolve the hostnames this software is known to contact
  (the table below, the software's own config, its documentation) with
  `host_exec ["getent","ahosts","<hostname>"]`. If the connection's exact IP is
  among the answers, you have named the service at that address. Resolve them
  now, not from memory: cloud addresses change.
- No reverse name and no forward match leaves the destination unknown. That is
  not proof of an attack, but it is not an explanation either.

## 2. Look for the setting that makes the call
Read how the process was started (`ps -o cmd -p <pid>`, `docker inspect
<container>` for the arguments, its config file) and look for the switch that
controls the call. A default that is on and not turned off is an explanation;
name it, so a human can turn it off.

| Software | Calls by default | When | Setting that controls it |
|---|---|---|---|
| Traefik | `update.traefik.io` (version check; it also reaches `api.github.com`), `collect.traefik.io` (usage stats, when enabled) | about 10 minutes after start, then every 24 hours | `--global.checknewversion=false`, `--global.sendanonymoususage=false` |
| Traefik, Caddy, certbot, any ACME client | `acme-v02.api.letsencrypt.org`, `acme.zerossl.com` | at start and before certificates expire | the ACME / TLS settings |
| Grafana | `grafana.com` (update check), `stats.grafana.org` (usage stats) | at start, then periodically | `check_for_updates`, `reporting_enabled` |
| GitLab | `version.gitlab.com` | periodically | version check and Service Ping settings |
| Coolify | `cdn.coollabs.io` (versions), its own instance (sentinel push) | periodically | auto-update settings |
| Docker daemon | `registry-1.docker.io`, `auth.docker.io`, `production.cloudflare.docker.com` | on image pulls | registry mirrors |
| Ubuntu | `motd.ubuntu.com`, `api.snapcraft.io`, `archive.ubuntu.com`, `security.ubuntu.com`, `esm.ubuntu.com`, `ntp.ubuntu.com` | timers (`systemctl list-timers`) | `motd-news`, snapd, apt and timesyncd config |

The table holds examples, not an allow list. A match explains the destination
only when the process making the call is the one in the table, its binary is
the packaged or image one (`sha256sum`, `dpkg -S`, the image's own file
times), and the call happened when the software makes it.

## 3. Compare the timing with the process start
- Get the start time: `host_exec ["ps","-o","pid,lstart,etime,cmd","-p","<pid>"]`.
- Work out the offset of each sighting from that start. Built-in timers show
  up as a fixed offset after start (10 minutes), a fixed period (12 or 24
  hours, so a sighting at start + N days to the minute), or both.
- Earlier sightings: `findings_list` for the same monitor and earlier
  incidents with the same title. The same destinations at the same offset
  after several starts are a timer in the software. An implant does not reset
  its schedule to the process start.

## 4. Your own kill can cause the repeat
When an earlier session killed the process, the supervisor started a new one,
and the timer runs again from that start. A sighting the same few minutes after
every kill is the new process doing its normal start-up call, not the attacker
coming back. Check the offset from the latest start before you call a
repeat "re-compromise", and never kill the same service again for the same
recurring finding without new evidence (a child process, a dropped or changed
file, a destination that does not resolve to the vendor).

## Verdict
- **Explained:** the destination resolves to the software's own endpoint, the
  setting is on, the binary is the image's or package's own, and the timing
  fits. The verdict is `false_positive` (the monitor did not know about the
  call). Do not contain. In the report, name the endpoint, the setting a human
  can turn off, and the timing you saw. Record the call in the `Server role and
  services` definition with `patch_definition`. Do not add the IP to the
  monitor's `allow_remotes`: vendor addresses on shared clouds change and are
  shared with other customers; turning the call off is the fix.
- **Not explained:** no name, a name unrelated to the software, a destination
  that matches none of its endpoints, timing unrelated to the start, or other
  signs (a child process, a dropped file, a changed binary). Treat it as the
  attack explanation and contain as the responder procedure says.
- **Partly explained** (the name fits but something else does not): say what
  fits and what does not, and resolve `inconclusive` rather than killing a
  service on a guess.

© Problem99-io · Apache-2.0 · Problem99-io/kodeblue

Similar skills

All skills for Security →

From the same set13

The whole set →
containment-verification containment-verification is a Claude Code skill that inspects the host after security actions like block_ip, kill_process, quarantine_file, or stop_unit to confirm they hold. CX Codex +1 ★ 71repo stars linux-intrusion-triage linux-intrusion-triage is a Claude Code skill for examining a Linux host that may have been compromised. It guides the initial checks in sequence, using kodeblue’s read-only tools. CX Codex +1 ★ 71repo stars false-positive-playbook false-positive-playbook is a Claude Code skill that helps agents prove security findings are benign. It checks package logs, deployments, and admin sessions instead of guessing. CX Codex +1 ★ 71repo stars web-app-attack-chain web-app-attack-chain is a Claude Code skill that rebuilds a web app attack from request logs. It identifies successful in-app actions and lists the cleanup a person must handle. CX Codex +1 ★ 71repo stars kodeblue-self-integrity kodeblue-self-integrity is a Claude Code skill that investigates changes to kodeblue binaries, engine, and configuration. It analyzes whether modifications or watcher downtime stem from tampering. CX Codex +1 ★ 71repo stars service-restart-forensics service-restart-forensics is a Claude Code skill that investigates stopped or restarted services. It checks the replacement process and identifies when this host cannot reveal the cause. CX Codex +1 ★ 71repo stars service-process-exploitation service-process-exploitation is a Claude Code skill for detecting code execution inside a legitimate service process. It examines child processes, outbound connections, and file changes. CX Codex +1 ★ 71repo stars container-breakout-detection container-breakout-detection is a Claude Code skill that discovers code escapes from containers to the host. It inspects host namespaces, runtime sockets, and kernel parameters. CX Codex +1 ★ 71repo stars

Project sponsors

Companies that keep this analytics open