Skip to main content

hashcat CVE-2026-68768

| EUVDEUVD-2026-64313 MEDIUM
Classic Buffer Overflow (CWE-120)
2026-08-22 VulnCheck GHSA-cm34-rh84-36rf
6.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Supply crafted hash file with near-buffer-capacity username
  2. Delivery
    Induce operator to run hashcat --username --show against file
  3. Exploit
    outfile_write() sequentially memcpy's fields without bounds validation
  4. Execution
    Accumulated length exceeds HCBUFSIZ_LARGE heap buffer
  5. Persist
    Out-of-bounds write corrupts heap memory
  6. Impact
    Process crash (availability impact)

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Buffer copy size validation
MITRE ATT&CK

1 technique across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Both --username and --show flags must be passed simultaneously to hashcat for the vulnerable code path in outfile_write() to execute. The attacker must supply or influence the hash file consumed by hashcat - either by delivering a crafted file directly or by positioning it where an analyst will process it. The CVSS UI:P metric confirms that the operator must actively invoke hashcat against the malicious file; there is no passive or background trigger. Exploitation is strictly local (AV:L): hashcat exposes no network interface, and remote exploitation is not possible. Default hashcat usage without --username, and crack-mode runs without --show, are unaffected. No privilege level is required to run hashcat itself, but the attacker's primary dependency is operator action against attacker-controlled input.

Impact

The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N, score 6.9) accurately characterises this as a medium-severity local issue: attack vector is local, user interaction is required, and primary impact is availability (crash/memory corruption) with negligible confidentiality impact. The PR:N metric reflects that no authentication to a service is required, but this must not be misread as remotely exploitable - AV:L firmly bounds exploitation to the local system where hashcat is invoked. There is no CISA KEV listing and no identified public proof-of-concept, both of which substantially reduce real-world urgency. Because hashcat is an operator-invoked command-line tool rather than an always-on service, the attack surface is inherently narrow: exploitation requires an analyst to actively process a crafted file with specific flags. The risk is most relevant to red-team or forensic teams that routinely run hashcat --username --show against externally sourced hash dumps, where the origin of the file may not be fully trusted.

Exploit ScenarioDerived

An attacker crafts a hash file containing a username field sized to nearly fill the 16 MB HCBUFSIZ_LARGE buffer. When a security analyst runs hashcat --username --show against this file as part of a routine password-audit workflow, outfile_write() copies the oversized username into the heap buffer and then appends the separator, hash, and plaintext without checking remaining space, overflowing the buffer, corrupting adjacent heap metadata, and crashing the process. No public proof-of-concept has been identified at time of analysis, but the trigger condition is straightforward to reproduce from the description and commit diff alone.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Aug 22, 2026

Heap buffer overflow in hashcat through version 7.1.2 allows an attacker who controls a hash file to crash the process and corrupt heap memory when an operator runs hashcat with the --username --show flags. The outfile_write() function in src/outfile.c sequentially appends username, separator, hash, and plaintext into a fixed ~16 MB heap buffer (HCBUFSIZ_LARGE) via memcpy without tracking accumulated length against buffer capacity, enabling an out-of-bounds write. No active exploitation has been confirmed (not in CISA KEV), and a vendor patch has been released via upstream commit.

RemediationAI

Update to a hashcat build incorporating upstream commit 68f56a2d8712867a8520bf4dcf07f6145c23df89, which is available at https://github.com/hashcat/hashcat/commit/68f56a2d8712867a8520bf4dcf07f6145c23df89. A specific tagged release version containing this fix has not been independently confirmed from available data - verify that your installed binary was built from this commit or a later one by checking the repository tag history. As an immediate compensating control, avoid invoking hashcat with both --username and --show simultaneously against hash files sourced from untrusted parties; omitting either flag prevents the vulnerable outfile_write() code path from being reached. This control has no impact on normal cracking workflows that do not use --show for output review.

Affected VersionsENISA

hashcat 0 ≤7.1.2

Affected Packages

euvd hashcat no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

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

Technical ContextAI · show details

hashcat (CPE: cpe:2.3:a:hashcat:hashcat:*:*:*:*:*:*:*:*) is a widely-used GPU-accelerated password recovery tool. The vulnerable function outfile_write() resides in src/outfile.c at lines 654-668 (v7.1.2). CWE-120 (Buffer Copy without Checking Size of Input) applies directly: the function allocates a single fixed-size heap buffer of HCBUFSIZ_LARGE (~16 MB) and uses bare memcpy calls to sequentially append each output field - username, separator, hash representation, and plaintext - without validating that the running total fits within the buffer. The upstream fix (commit 68f56a2d) replaces all these unchecked writes with five bounded helper functions (outfile_append_raw, outfile_append_hex, outfile_append_hexify, outfile_append_chr, outfile_append_fmt) that each compute remaining room before writing and truncate oversized fields rather than overflowing, ensuring the buffer invariant is maintained throughout the assembly loop.

Know when Hashcat 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 (VulnCheck) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
vuln.today AI 6.1 MEDIUM

Local tool invoked by operator against crafted input (AV:L, UI:R, PR:N); heap overflow causes crash (A:H) with minimal integrity side-effect (I:L); no confidentiality impact.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

hashcat contains a heap-based buffer overflow (out-of-bounds write) in the outfile_write() function in src/outfile.c. When assembling output into a fixed-size buffer (HCBUFSIZ_LARGE, ~16 MB), the function sequentially appends the username, separator, hash, and plaintext via memcpy without validating that the accumulated length stays within the buffer capacity. When run with --username --show against a crafted hash file containing an oversized username that nearly fills the buffer, the total assembled output exceeds the buffer, causing a heap buffer overflow that can corrupt memory and crash the process.

Threat Intelligence Overview

EPSS Score
0.2%
Top 92% exploitable
Prevalence
Medium
widely used by penetration testers, CTF players, and security researchers globally
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor GitHub

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.2%
Patch available Yes
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
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

Vendor StatusVendor

SUSE

Severity: Moderate

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