PluginBench
Skill
Official
Review
Audit score 70

redis-security

redis/agent-skills

Harden Redis with authentication, ACL-based access control, TLS, and network restrictions.

What is redis-security?

Redis security guidance for production deployments covering authentication, ACL users, TLS encryption, and network exposure control. Use when deploying Redis to production, configuring application credentials, setting up TLS, or auditing a Redis instance for security hardening.

  • Configure requirepass and ACL users for authentication with least-privilege access
  • Set up TLS encryption for credentials and data in transit
  • Restrict network exposure via bind, protected-mode, and firewall rules
  • Define command categories (@read, @write, @dangerous, @admin) for granular access control
  • Disable or rename dangerous commands like FLUSHALL, DEBUG, and CONFIG

How to install redis-security

npx skills add https://github.com/redis/agent-skills --skill redis-security
Prerequisites
  • Redis instance (development or production)
  • TLS certificates if configuring encrypted connections
  • Access to redis.conf or Redis CLI for ACL configuration
Claude Code
Cursor
Windsurf
Cline

How to use redis-security

  1. 1.Enable authentication with requirepass or ACL users in redis.conf
  2. 2.Configure TLS by setting tls-port, tls-cert-file, and tls-key-file
  3. 3.Define ACL users with specific command and key-pattern permissions using ACL SETUSER
  4. 4.Restrict network access by setting bind to specific interfaces and enabling protected-mode
  5. 5.Apply firewall rules (iptables or cloud security groups) to allow only trusted subnets
  6. 6.Optionally rename or disable dangerous commands like FLUSHALL and DEBUG

Use cases

Good for
  • Deploying a Redis instance to production with multi-application access
  • Creating dedicated ACL users for cache readers, writers, and administrators
  • Auditing an exposed Redis instance and applying security hardening
  • Configuring TLS certificates and encrypted client connections
  • Locking down Redis behind a firewall with bind and protected-mode settings
Who it's for
  • DevOps engineers deploying Redis to production
  • Backend developers setting up application credentials
  • Security teams auditing Redis deployments
  • System administrators hardening Redis instances

redis-security FAQ

Should I use requirepass or ACL users?

Use ACL users in production for least-privilege access; requirepass is a legacy shortcut suitable only for development or single-application deployments.

What happens if I run Redis with bind 0.0.0.0 and protected-mode no?

Redis becomes exposed to the entire network without protection — the most common Redis breach scenario. Always bind to specific interfaces and keep protected-mode enabled.

How do I limit an application to only read operations?

Create an ACL user with +get +mget +scan permissions and restrict key patterns with ~cache:* or similar, denying write and dangerous commands.

Do I need both TLS and a password?

Yes; pair authentication with TLS so credentials and data aren't sent in clear text. TLS alone doesn't authenticate, and a password alone doesn't encrypt.

What command categories should I use for ACL permissions?

Use @read for GET/MGET, @write for SET/DEL, @dangerous for FLUSHALL/DEBUG, and @admin for administrative commands; combine them with + and - to grant or deny specific permissions.

Full instructions (SKILL.md)

Source of truth, from redis/agent-skills.


name: redis-security description: Redis security guidance covering authentication (requirepass and ACL users), TLS, ACL-based least-privilege access control, restricting network exposure via bind and protected-mode, firewall rules, and disabling dangerous commands. Use when deploying Redis to production, defining ACL users for an application, configuring TLS connections, locking down a Redis instance behind a firewall, or auditing a Redis deployment for security hardening. license: MIT metadata: author: Redis, Inc. version: "0.1.0"

Redis Security

Production hardening for Redis: authentication, ACL-based access control, and network exposure. Cover all three together — any one of them on its own leaves an exploitable gap.

When to apply

  • Deploying or reviewing a Redis instance destined for production.
  • Setting up application credentials beyond a shared password.
  • Auditing a Redis deployment against a security checklist.
  • Receiving "Redis exposed to the internet" findings from a scanner.

1. Always authenticate (and use TLS)

Never run a production Redis without a password. Pair authentication with TLS so credentials and data aren't sent in clear text.

# redis.conf
requirepass your-strong-password
tls-port 6380
tls-cert-file /path/to/redis.crt
tls-key-file  /path/to/redis.key
r = redis.Redis(
    host="localhost",
    port=6380,
    password="your-strong-password",
    ssl=True,
    ssl_cert_reqs="required",
)

If you can use ACL users (next section) instead of the single requirepass, do — requirepass is effectively the legacy "default user" shortcut.

See references/auth.md.

2. ACLs for least-privilege access

The default user with a shared password is fine for development. For production, give each application a dedicated ACL user with only the commands and key patterns it actually needs.

# Cache-only reader
ACL SETUSER app_readonly on >password ~cache:* +get +mget +scan

# Writer that can't run dangerous ops
ACL SETUSER app_writer   on >password ~*        +@all -@dangerous

# Admin (use sparingly, never for application traffic)
ACL SETUSER admin        on >strong-password ~* +@all

Useful command categories:

CategoryWhat it covers
@readRead commands (GET, MGET, HGET, ...)
@writeWrite commands (SET, DEL, XADD, ...)
@dangerousFLUSHALL, DEBUG, KEYS, etc.
@adminAdministrative commands

If app credentials leak, a tight ACL bounds the blast radius — the attacker can't FLUSHALL your DB just because they grabbed a cache reader's password.

See references/acls.md.

3. Restrict network access

The most common Redis breach is a public-internet Redis with no auth. Avoid that with three layers:

# redis.conf — bind to specific interfaces, keep protected-mode on
bind 127.0.0.1 192.168.1.100
protected-mode yes
# Firewall — allow only application subnets
iptables -A INPUT -p tcp --dport 6379 -s 192.168.1.0/24 -j ACCEPT
iptables -A INPUT -p tcp --dport 6379 -j DROP

Anti-pattern: bind 0.0.0.0 + protected-mode no — exposes Redis to the whole network without protection.

Optional but recommended: rename or disable destructive commands so a compromised client can't trash the DB:

rename-command FLUSHALL ""
rename-command DEBUG ""
rename-command CONFIG ""

See references/network.md.

References