Skip to main content

Ansible keyring_info EUVDEUVD-2026-38604

| CVE-2026-11819 MEDIUM
Insertion of Sensitive Information into Log File (CWE-532)
2026-06-23 redhat GHSA-5x67-m8gc-wm3p
5.5
CVSS 3.1 · Vendor: redhat
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify target AWX/Tower instance or fact cache backend
  2. Exploit
    Locate job runs invoking keyring_info module
  3. Execution
    Read plaintext passphrase from job log or cache entry
  4. Impact
    Use extracted credential to authenticate as privileged account

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A09:2025 - Security Logging & Alerting Failures
ASVS 5.0
V16 - Security Logging and Error Handling Log data sanitization
Exploitation Conditions

Exploitation requires that an Ansible playbook invokes the keyring_info module AND that the resulting task output is observable by the attacker - either through direct stdout, a register: + debug: var= task chain, AWX/Tower job log access, or read access to a fact caching backend (Redis, memcached, JSON file). The CVSS vector AV:L/PR:L confirms exploitation is local and requires low-privilege access (the ability to run or observe Ansible playbooks). Exploitation is limited by: the attacker must have read access to Ansible output channels or caching backends; the keyring_info module must actually be in use in the target environment; and the credential must have been retrieved at least once (producing a log entry). No network-facing attack surface exists - this is not remotely exploitable against default system configurations. Deployments that do not use keyring_info or that already apply no_log: true at the task level are not affected.

Impact

The CVSS 3.1 score of 5.5 MEDIUM (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) reflects the local access requirement and high confidentiality impact, and is a reasonable characterization. No EPSS data was provided; given no KEV listing and the local-only attack vector, real-world opportunistic exploitation at scale is unlikely, but targeted exploitation in CI/CD or AWX environments is plausible and practically trivial. The POC existence (Figures 1 and 2 referenced in the CVE) confirms this is straightforward to reproduce - any user who can observe Ansible output obtains the credential immediately, with no specialized skill required. The most impactful exploitation path is not interactive shell access but rather indirect exposure: credentials persisted in AWX/Tower job log databases or fact caching backends (Redis, memcached, JSON files) that may be accessible to a broader set of operators or developers than the playbook author intended. The true blast radius depends on whether the retrieved passphrase protects higher-value assets (SSH keys to privileged hosts, vault master passwords). CVSS does not capture this downstream amplification. No data conflicts identified.

Exploit ScenarioDerived

An automation engineer or read-only AWX operator with access to job logs opens a recently executed playbook run that invoked keyring_info to retrieve an SSH key passphrase. Because no no_log: true was set at the task level and the module did not suppress output, the full passphrase appears in plaintext in the AWX job log UI and in any Redis fact cache entries from that run. A proof-of-concept demonstrating this exact output exposure exists. The attacker needs no special exploit code - reading the job log or querying the fact cache backend directly yields the credential.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Jun 23, 2026

Credential exposure in the Ansible keyring_info module (plugins/modules/keyring_info.py) causes master passwords, SSH key passphrases, and service credentials retrieved from OS-native keystores to be emitted as plaintext in task output, registered variables, and persistent log backends. Any local user with access to Ansible playbook output - including AWX/Tower job logs, Redis or JSON fact caches, and debug task output - can read credentials in full. A proof-of-concept demonstrating plaintext passphrase capture from Ansible output exists, though no confirmed active exploitation (CISA KEV) has been observed. Affected deployments span RHEL 8, 9, and 10 per Red Hat CPE data.

RemediationAI

The fix requires two changes in the module: replace the module.exit_json() call with one that passes _ansible_no_log=True alongside the passphrase return value, suppressing it from serialized output; and add documentation explicitly requiring callers to set no_log: true at the task level as a defense-in-depth measure. No vendor-released patched version has been independently confirmed - a specific fix version is not present in the available data; monitor https://access.redhat.com/security/cve/CVE-2026-11819 for an updated errata. Until a patch is available, operators should add no_log: true to every task invoking keyring_info, which prevents Ansible from logging the full task result; note this also suppresses changed/failed status detail in output. Additionally, audit and purge AWX/Tower job logs and any fact cache backends (Redis keys, JSON flat files, memcached entries) that may have already captured plaintext passphrases from prior runs. Restricting read access to fact cache backends and AWX job logs to minimum necessary personnel reduces exposure from already-logged credentials.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The affected module queries OS-native credential stores - GNOME Keyring (Linux), macOS Keychain, and Windows Credential Manager - to retrieve passphrases for use in automation workflows. The root cause is CWE-532 (Insertion of Sensitive Information into Log File): the module correctly applies no_log=True to its input parameter keyring_password at line 105, preventing the lookup key from leaking, but then places the retrieved passphrase directly into result['passphrase'] at line 127 without any output suppression. In Ansible, task results are serialized and surfaced through multiple channels - debug: var= tasks, register variable dumps, stdout, and fact caching backends (Redis, memcached, flat JSON files). AWX and Automation Controller store full task results in their job log databases. Without _ansible_no_log=True in the module.exit_json() call or explicit no_log: true at the task level, the passphrase is treated as ordinary output data. CPE data confirms affected products are cpe:2.3:a:red_hat:red_hat_enterprise_linux_8, _9, and _10.

Know when Redis gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (redhat) PRIMARY 5.5 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
vuln.today AI 5.5 MEDIUM

Local execution with low privileges required to run playbooks; passphrase exposed only through local output channels; no integrity or availability impact.

3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N
Red Hat 5.5 MEDIUM

Primary rating from Vendor (redhat).

CVSS VectorVendor: redhat

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
None
Availability
None

DescriptionCVE.org

Module: plugins/modules/keyring_info.py

CVSS 3.1: 5.5 MEDIUM - AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N

Issue: The module retrieves a passphrase from the OS native keyring (GNOME Keyring, macOS Keychain, Windows Credential Manager) and places it directly into result["passphrase"] with no output suppression, no no_log protection, and no documentation warning.

Root Cause:

Line 105 (protected): keyring_password=dict(type="str", required=True, no_log=True) Line 127 (NOT protected): result["passphrase"] = passphrase

Observed Output:

{ "changed": false, "passphrase": "MyMasterP@ssw0rd!SSH_Key_Secret" } Visible via register + debug: { "keyring_result": { "changed": false, "passphrase": "MyMasterP@ssw0rd!SSH_Key_Secret" } }

Impact:

Master passwords, SSH key passphrases and service credentials appear in all Ansible output

register: keyring_result followed by debug: var=keyring_result prints passphrase in full

Ansible fact caching backends (Redis, JSON file, memcached) may persist the passphrase

AWX/Tower job logs silently store the live credential

Fix:

module.exit_json(changed=False, passphrase=passphrase, _ansible_no_log=True)

Also add a documentation warning requiring callers to use no_log: true at the task level.

PoCs

Fig 1: PoC execution showing passphrase in plaintext output

Fig 2: Source code showing no_log=True on input (line 105) vs unprotected output (line 127)

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
High
widely deployed RHEL Ansible automation stack across enterprise environments
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor VulDB

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.1%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
High
Technical Impact
Partial

Priority Score

28
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +28
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Affected Products (CPE)CVE.org

cpe:2.3:a:red_hat:red_hat_enterprise_linux_10:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_enterprise_linux_8:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_enterprise_linux_8:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_enterprise_linux_9:*:*:*:*:*:*:*:*

More in Redis

View all
CVE-2026-48172 CRITICAL POC
10.0 May 21

Privilege escalation to root in the LiteSpeed User-End cPanel Plugin (versions 2.3 through before 2.4.5) lets attackers

CVE-2025-49844 CRITICAL POC
9.9 Oct 03

UAF in Redis 8.2.1 via crafted Lua scripts by authenticated users. EPSS 12.4%. Patch available.

CVE-2025-46817 HIGH POC
8.8 Oct 03

Authenticated Redis users with permission to run server-side Lua can trigger an integer overflow (CWE-190) in the bundle

CVE-2022-0543 CRITICAL POC
10.0 Feb 18

It was discovered, that redis, a persistent key-value database, due to a packaging issue, is prone to a (Debian-specific

CVE-2018-11218 CRITICAL POC
9.8 Jun 17

Memory Corruption was discovered in the cmsgpack library in the Lua subsystem in Redis before 3.2.12, 4.x before 4.0.10,

CVE-2015-4335 CRITICAL POC
10.0 Jun 09

Redis before 2.8.21 and 3.x before 3.0.2 allows remote attackers to execute arbitrary Lua bytecode via the eval command.

CVE-2016-8339 CRITICAL POC
9.8 Oct 28

A buffer overflow in Redis 3.2.x prior to 3.2.4 causes arbitrary code execution when a crafted command is sent. Rated cr

CVE-2025-46819 HIGH POC
7.1 Oct 03

Authenticated Lua script execution in Redis 8.2.1 and earlier can be abused with a crafted long-string delimiter to trig

CVE-2026-77602 CRITICAL POC
9.9 Sep 23

Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in

CVE-2025-46818 HIGH POC
7.3 Oct 03

CVE-2025-46818 is a sandbox-escape flaw in Redis's embedded Lua scripting engine (all versions up to and including 8.2.1

CVE-2026-27574 CRITICAL POC
9.9 Feb 21

Code injection in OneUptime monitoring via custom JS monitor using vm module. PoC and patch available.

CVE-2026-84372 CRITICAL POC
9.8 Sep 01

RESP protocol command injection in Predis, the popular PHP client for Redis and Valkey, affects versions 3.0.0-RC1 throu

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy