Nftables Allow Source logo

Nftables Allow Source

Organization
SpecterOps
nftables-allow-source

Add a source IP or CIDR to nftables using the working method from this repo session: live top-of-`input` insertion with `nft -a` verification first, then persistent config update and reload.

Overview

PublisherSpecterOps
Repositoryskills
Skill namenftables-allow-source
Stars
706
Forks
80
Bundled files
3
LicenseApache-2.0
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by SpecterOps on GitHub. Read the source before you install it.

Installation

Install the Nftables Allow Source AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/SpecterOps/skills/tree/main/plugins/ops-infrastructure/skills/nftables-allow-source
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/SpecterOps/skills.git /tmp/skills
mkdir -p .claude/skills
cp -r /tmp/skills/plugins/ops-infrastructure/skills/nftables-allow-source .claude/skills/nftables-allow-source
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Nftables Allow Source in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Nftables Allow Source on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Nftables Allow Source is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Nftables Allow Source

Use this skill to add a source IP or CIDR to nftables using the method that worked in this repo session:

  • inspect the live input chain with nft -a
  • insert a source allow rule at the top of the live input chain
  • verify the live rule immediately
  • add the same source allow rule to /etc/nftables.conf in the input chain
  • reload the ruleset and verify config and live state match

Do not use a config-first workflow here. The working method is live input insertion first, persistence second.

Direct Triggers

Use this skill when the task mentions any of the following:

  • add an nftables allow rule
  • allow inbound from an IP
  • whitelist an IP in nftables
  • add a source address to the firewall
  • insert an nft rule at the top
  • use nft -a handles

Input Contract

Accept input as: HOST SOURCE [MODE]

Mode:

  • plan: produce the command sequence only
  • execute (default): inspect, insert, and verify the live rule

Examples:

  • $nftables-allow-source bastion 203.0.113.42 execute
  • $nftables-allow-source 198.51.100.25 203.0.113.42/32 plan
  • $nftables-allow-source edge-firewall 198.51.100.0/24 execute

Preconditions

  1. Confirm the host is in scope and operator-controlled.
  2. Confirm SSH or console access exists before changing the firewall.
  3. Confirm nft is installed and the host is actually using nftables.
  4. Prefer live insertion into the input chain before any persistent edit.

Execution Workflow

  1. Inspect the live input chain with handles.
bash
sudo nft -a list chain inet filter input

Use this to:

  • confirm the chain exists
  • see current rule order
  • identify whether a matching source rule already exists
  1. Verify whether the source is already allowed.
  • If already present in the live chain, do not insert a duplicate.
  • Record existing handle and position if present.
  1. Insert the allow rule at the top of the live input chain.

Preferred live insertion pattern:

bash
sudo nft insert rule inet filter input position 0 ip saddr <SOURCE> accept

This is the working method and should be preferred over editing /etc/nftables.conf first.

  1. Verify the live input chain immediately.
bash
sudo nft -a list chain inet filter input

Success means the new ip saddr <SOURCE> accept rule appears at the top of the input chain before the rest of the policy logic.

  1. Persist the same rule in /etc/nftables.conf.
  • insert ip saddr <SOURCE> accept comment "Authorized External IP" immediately after:
    • type filter hook input priority filter; policy drop;
  • do not rely on a broad grep for the source IP elsewhere in the file; check the input chain specifically
  • if /etc/nftables.conf is empty or corrupted, restore from the latest backup before editing
  • back up the file before changing it
  1. Reload and verify.
  • reload with:
    • sudo nft -f /etc/nftables.conf
  • verify both:
    • sudo sed -n '/chain input {/,/}/p' /etc/nftables.conf
    • sudo nft -a list chain inet filter input
  • confirm the persistent and live rules both contain the source allow at the top of the input chain

Command Patterns

Live chain inspection

bash
sudo nft -a list chain inet filter input

Live top-of-chain insertion

bash
sudo nft insert rule inet filter input position 0 ip saddr 203.0.113.42 accept

Persistent config backup

bash
sudo cp /etc/nftables.conf /etc/nftables.conf.bak-$(date +%Y%m%d%H%M%S)

Persistent input-chain insertion

bash
sudo sed -i '/type filter hook input priority filter; policy drop;/a\        ip saddr 203.0.113.42 accept comment "Authorized External IP"' /etc/nftables.conf

Persistent config reload

bash
sudo nft -f /etc/nftables.conf

Post-reload verification

bash
sudo sed -n '/chain input {/,/}/p' /etc/nftables.conf
sudo nft -a list chain inet filter input

Prohibited Method

Do not use these approaches as the default workflow for this skill:

  • editing /etc/nftables.conf first and assuming reload will be safe
  • checking only whether the source IP exists somewhere in the file instead of in the input chain
  • adding the exception only to the management chain when the operator wants a host-wide source exception
  • broad text-rewrite methods that can blank or corrupt /etc/nftables.conf

OPSEC Gate

Require explicit operator confirmation before:

  • broad rules such as 0.0.0.0/0
  • wide CIDR additions that materially expand exposure
  • deleting or reordering existing firewall controls
  • reloading or restarting nftables on production-like hosts when access risk is non-trivial

Before requesting approval, include:

  • exact rule change
  • objective
  • expected impact
  • rollback plan
  • possible connectivity risk

Reporting Requirements

For each run, include:

  • target host
  • live chain modified: inet filter input
  • source IP/CIDR added
  • exact commands used
  • pre-change live chain output
  • post-change live chain output
  • persistent input-chain config snippet after edit
  • whether the rule is live only or also persistent
  • any remaining follow-up needed to reconcile config and runtime state

Troubleshooting Note

If a service is still unreachable after the source allow rule is added:

  1. verify the service is actually listening on the destination host
  2. compare reachability of the blocked port against a temporary listener on an alternate port on the same host
  3. if the alternate port succeeds while the original port fails, do not attribute the failure to nftables alone
  4. report that the environment or path may specifically disallow the original port

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Nftables Allow Source AI skill do?

Add a source IP or CIDR to nftables using the working method from this repo session: live top-of-`input` insertion with `nft -a` verification first, then persistent config update and reload.

Why use Nftables Allow Source on TypingMind?

Because you install it once and use it with any model. Nftables Allow Source is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Nftables Allow Source in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/SpecterOps/skills/tree/main/plugins/ops-infrastructure/skills/nftables-allow-source. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Nftables Allow Source?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Nftables Allow Source?

As many as you like. As long as a model supports skills, you can use Nftables Allow Source with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Nftables Allow Source AI skill free?

Yes. It is published on GitHub by SpecterOps under the Apache-2.0 license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇