Details
Expected output after `go run main.go --verify /tmp/gitsign-badsig.pem /tmp/gitsign-data.bin; echo "exit: $?"`:
runtime error: index out of range [0] with length 0
goroutine 1 [running]:
runtime/debug.Stack(...)
...
github.com/sigstore/gitsign/pkg/git.(*CertVerifier).Verify(...)
pkg/git/verifier.go:114 +0x...
...
exit: 0 ← process exits 0 despite verification failure
Impact
- Authentication bypass for exit-code callers: Any script or CI pipeline running
gitsign --verifyand checking only$?will treat the panicked verification as a success (exit 0). This allows an attacker to make a commit appear verified without a valid signature. - Denial of service: Every verification attempt against a crafted signature panics, preventing legitimate verification output from being produced.
- Misleading output: The panic stack trace is written to TTYOut (stderr in non-TTY environments), which may be silently discarded by callers that redirect stderr.
- Partial bypass of git verify-commit: git itself is protected by the
GOODSIGcheck on the status-fd; however, the exit-code bypass affects auxiliary tooling that wrapsgitsign --verifydirectly.
Recommended Remediation
Option 1: Guard the slice access (preferred — lowest layer, protects all callers)
Add an explicit length check in CertVerifier.Verify() immediately after GetCertificates():
// pkg/git/verifier.go — replace lines 110–114
certs, err := sd.GetCertificates()
if err != nil {
return nil, fmt.Errorf("error getting signature certs: %w", err)
}
if len(certs) == 0 {
return nil, fmt.Errorf("no certificates found in signature")
}
cert := certs[0]
This produces a clean error at the source instead of a panic, propagated through commandVerify as a non-nil return, so Wrap returns it, Execute() returns it, and main.go exits 1.
Option 2: Return an error instead of nil on panic recovery
Fix Wrap() to return an error when it recovers a panic, so that all callers reliably see a non-zero exit code:
// internal/io/streams.go — replace Wrap with named return
func (s *Streams) Wrap(fn func() error) (retErr error) {
defer func() {
if r := recover(); r != nil {
fmt.Fprintln(s.TTYOut, r, string(debug.Stack()))
retErr = fmt.Errorf("panic: %v", r) // propagate as error
}
}()
if err := fn(); err != nil {
fmt.Fprintln(s.TTYOut, err)
return err
}
return nil
}
This is a defense-in-depth fix. It ensures that any future panic in a command results in exit 1 rather than 0. Option 1 should be applied regardless; Option 2 prevents similar bypass bugs from any other panic source.
Credit
This vulnerability was discovered and reported by bugbunny.ai.