Skip to main content

hashcat CVE-2026-68767

| EUVDEUVD-2026-64312 MEDIUM
Off-by-one Error (CWE-193)
2026-08-22 VulnCheck GHSA-vgv2-whp7-2895
6.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft input file with line of exactly HCBUFSIZ_LARGE bytes
  2. Delivery
    Deliver malicious file to hashcat user via social engineering
  3. Exploit
    User executes hashcat with attacker-supplied input
  4. Execution
    fgetl() writes null terminator one byte past heap buffer
  5. Impact
    Heap corruption causes crash or enables memory exploitation primitive

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Off-by-one prevention
Exploitation Conditions

Exploitation requires that a user actively run hashcat and supply an attacker-controlled input file - a hash file, potfile, or wordlist - containing at least one line of exactly HCBUFSIZ_LARGE bytes. No special hashcat configuration, elevated OS privileges, or authenticated session is required; the sole trigger condition is the precise line length in one of those three file types. The CVSS 4.0 UI:P metric confirms passive user interaction is required: the victim must execute hashcat with the malicious file. Limiting factors are: (1) the attacker must place or influence the content of an input file the victim processes; (2) hashcat's user base of security professionals typically controls their own wordlists and hash files, reducing exposure to adversary-supplied inputs; (3) the vulnerability does not trigger on lines shorter or longer than HCBUFSIZ_LARGE, requiring precise byte-length crafting. No network-facing or daemon-mode operation is involved.

Impact

The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P, score 6.9) correctly characterizes this as a local-vector, low-complexity flaw requiring passive user interaction with no special privileges. VA:H reflects meaningful heap corruption risk, while VC:N and VI:L indicate the realistic ceiling is a crash rather than data disclosure. No EPSS data was included in the intelligence package, and this CVE does not appear in the CISA KEV catalog, meaning no confirmed or widespread active exploitation has been recorded. No POC is identified in the provided data. Real-world exploitation risk is further bounded by hashcat's user base: security practitioners who control their own input files are unlikely to process adversary-supplied wordlists or hash files. The primary plausible attack path requires social engineering. This is a legitimate memory-safety defect worth patching, but the combination of local attack vector, required user interaction, niche security-tool user base, and absence of KEV or EPSS signals places realistic exploitation probability low despite the moderate CVSS score.

Exploit ScenarioDerived

An attacker crafts a wordlist or hash file containing a line padded to exactly HCBUFSIZ_LARGE bytes and delivers it to a hashcat user as a shared cracking resource or benchmark file. When the user runs hashcat against that file, fgetl() reads the oversized line and writes a null byte one position past the heap buffer boundary, corrupting adjacent heap metadata; depending on heap layout this causes an immediate crash or, in a more controlled scenario, allows overwriting a heap object to redirect execution.

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

Out-of-bounds heap write in hashcat's fgetl() function affects all versions through 7.1.2, triggered by supplying any input file - hash file, potfile, or wordlist - containing a line of exactly HCBUFSIZ_LARGE bytes, causing a one-byte null write past the caller's buffer. The resulting heap corruption can crash hashcat or, in a worst case, create memory exploitation primitives; confidentiality is unaffected (VC:N per the CVSS 4.0 vector) while availability impact is rated high. No public exploit or active exploitation has been identified at time of analysis, and a vendor-released patch commit is available.

RemediationAI

Update hashcat to a version incorporating patch commit 93b55d37d3b2340013d4036f10181ddc67d44249, available at https://github.com/hashcat/hashcat/commit/93b55d37d3b2340013d4036f10181ddc67d44249. The EUVD confirms all versions ≤7.1.2 are vulnerable, implying the fix is present in the release following 7.1.2, but the exact first patched release version is not independently confirmed from available data - verify the current release tag at https://github.com/hashcat/hashcat before upgrading. As a compensating control pending upgrade, restrict hashcat usage to input files sourced exclusively from trusted, internally controlled repositories; never process externally provided hash files, potfiles, or wordlists of unknown provenance. Additional context is available from the VulnCheck advisory at https://www.vulncheck.com/advisories/hashcat-through-off-by-one-out-of-bounds-heap-write-in-fgetl and the upstream issue at https://github.com/hashcat/hashcat/issues/4739.

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

The flaw resides in the fgetl() function in src/filehandling.c (v7.1.2 lines 1032-1060), which reads lines from hash files, potfiles, and wordlists into caller-supplied heap buffers. When an input line is exactly HCBUFSIZ_LARGE bytes - matching the buffer size precisely - fgetl() writes a null terminator at index HCBUFSIZ_LARGE, one position beyond the buffer's last valid byte, producing a CWE-193 (Off-by-One Error) out-of-bounds heap write. The CPE cpe:2.3:a:hashcat:hashcat:*:*:*:*:*:*:*:* confirms the issue spans all hashcat versions. The upstream fix (commit 93b55d37) refactored line-reading into a new inline hc_line_next() function that scans for newlines via vectorized hc_memchr (AVX2/NEON) without writing a terminator, eliminating the boundary condition entirely. The changelog confirms: 'Fixed a one byte buffer overflow in fgetl() when a line was as long as the caller's buffer.'

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 file delivery requires the user to run hashcat with attacker-supplied input (UI:R, AV:L); no privileges needed; heap corruption drives high availability impact with minimal integrity effect and no confidentiality loss.

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's fgetl() function in src/filehandling.c writes a null terminator one byte past the caller's buffer when an input line is exactly the buffer length. Attackers can trigger this out-of-bounds heap write by providing a hash file, potfile, or wordlist containing a line of exactly HCBUFSIZ_LARGE bytes.

Threat Intelligence Overview

EPSS Score
0.2%
Top 93% exploitable
Prevalence
Medium
widely used GPU password cracking tool among security professionals and researchers
Data Quality
6 sources
Confidence: High

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
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

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