Yes, Vanta currently relies on gopacket for packet capture and parsing. As a student, my main goal was to build something clear, functional, and real — rather than reinvent everything from scratch.
I'm actively learning the details of network protocols, and I do plan to write some custom parsers later, both for flexibility and personal understanding. But at this stage, I think it’s more important to deliver a meaningful tool than to prove I can reimplement low-level stacks.
In the long run, I may gradually replace parts of gopacket, but right now it's an important and reliable foundation for the project.
(And honestly — finishing something real matters more to me than perfection )
> I’m just an ordinary undergraduate with no resources or background. This is my way of responding — not by petition, but through code. Vanta may be small, but it’s real, and it’s mine.
This comes off as super ChatGPT-y to me. "X is not y — it's Z! Preamble, passionate statement. Sycophantic encouraging statement — list, of, a, few, things, but also this. Summarize statement, but this other thing, and saying the same thing again but in a slightly different way."
I've given up on ChatGPT because of this style of writing.
So yeah, that probably shaped the way I wrote this. You’re right though — reading it again, it does sound kinda overly polished.
I’ll try to keep future writing more personal and grounded. Still learning — and thanks for reading it at all. That already means a lot!
How I parsed IP for example:
type Addr [4]uint8
func (ip Addr) String() string {
return fmt.Sprintf("%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3])
}
type Hdr struct {
Version uint8
IHL uint8
DSCP uint8
ECN uint8
Length uint16
Id uint16
Flags uint8
Fragoffset uint16
TTL uint8
Protocol uint8
Checksum uint16
Src Addr
Dst Addr
}
func (hdr *Hdr) Parse(d []byte) error {
hdr.Version = uint8(d[0] >> 4)
hdr.IHL = uint8(d[0] & 0x0f)
hdr.DSCP = uint8(d[1] >> 6)
hdr.ECN = uint8(d[1] & 0x03)
hdr.Length = uint16(binary.BigEndian.Uint16(d[2:4]))
hdr.Id = uint16(binary.BigEndian.Uint16(d[4:6]))
hdr.Flags = uint8(d[6] >> 5)
hdr.Fragoffset = uint16(binary.BigEndian.Uint16(d[6:8])) & 0x1fff
hdr.TTL = d[8]
hdr.Protocol = d[9]
hdr.Checksum = uint16(binary.BigEndian.Uint16(d[10:12]))
hdr.Src = Addr{d[12], d[13], d[14], d[15]}
hdr.Dst = Addr{d[16], d[17], d[18], d[19]}
if hdr.IHL > 5 {
fmt.Println("extra options detected") // TODO: support for extra options
}
return nil
}Yeah, I’m currently using gopacket mainly to get something working fast, but I’ve been thinking about writing my own parsers from scratch to understand the protocols better.
Your Hdr example is really clean — definitely saving this as reference! I love how direct and readable it is.
I’ll definitely try going lower level when I revisit the packet layer logic. Thanks again for the nudge
Curios what made you choose Go for this project? I am looking into building a toy version of Burp with either Rust/Go but still undecided.
I'm still a student, and I don’t have super big ambitions yet — I just wanted to build something I could actually finish and understand
Rust is amazing, but I haven’t started learning it seriously yet. It feels a bit overwhelming at this stage. Maybe one day, when I'm ready to dive deeper!
Good luck with your Burp project too — I’d love to see it if you share it someday!
If it happens to fill a niche, that’s a lucky bonus
https://github.com/derekburgess/jaws