From 09afcade2662992be6a24f465668c5ea499ac8bb Mon Sep 17 00:00:00 2001 From: Sergey Matveev Date: Wed, 30 Jun 2021 12:11:09 +0300 Subject: [PATCH] Old magic numbers knowledge --- src/cfg.go | 6 +- src/chunked.go | 2 - src/cmd/nncp-bundle/main.go | 17 +++- src/cmd/nncp-cfgenc/main.go | 8 +- src/cmd/nncp-pkt/main.go | 190 ++++++++++++++++++++---------------- src/cmd/nncp-reass/main.go | 6 +- src/cmd/nncp-xfer/main.go | 27 ++++- src/eblob.go | 19 ++-- src/jobs.go | 2 +- src/magic.go | 93 ++++++++++++++++++ src/mcd.go | 6 +- src/pkt.go | 39 +++++--- src/sp.go | 6 +- src/toss_test.go | 2 +- src/tx.go | 2 +- 15 files changed, 299 insertions(+), 126 deletions(-) create mode 100644 src/magic.go diff --git a/src/cfg.go b/src/cfg.go index 6b10007..bb101ca 100644 --- a/src/cfg.go +++ b/src/cfg.go @@ -416,7 +416,7 @@ func NewNodeOur(cfg *NodeOurJSON) (*NodeOur, error) { func CfgParse(data []byte) (*Ctx, error) { var err error - if bytes.Compare(data[:8], MagicNNCPBv3[:]) == 0 { + if bytes.Compare(data[:8], MagicNNCPBv3.B[:]) == 0 { os.Stderr.WriteString("Passphrase:") // #nosec G104 password, err := term.ReadPassword(0) if err != nil { @@ -427,6 +427,10 @@ func CfgParse(data []byte) (*Ctx, error) { if err != nil { return nil, err } + } else if bytes.Compare(data[:8], MagicNNCPBv2.B[:]) == 0 { + log.Fatalln(MagicNNCPBv2.TooOld()) + } else if bytes.Compare(data[:8], MagicNNCPBv1.B[:]) == 0 { + log.Fatalln(MagicNNCPBv1.TooOld()) } var cfgGeneral map[string]interface{} if err = hjson.Unmarshal(data, &cfgGeneral); err != nil { diff --git a/src/chunked.go b/src/chunked.go index 29f2228..212d16f 100644 --- a/src/chunked.go +++ b/src/chunked.go @@ -18,8 +18,6 @@ along with this program. If not, see . package nncp var ( - MagicNNCPMv2 [8]byte = [8]byte{'N', 'N', 'C', 'P', 'M', 0, 0, 2} - ChunkedSuffixMeta = ".nncp.meta" ChunkedSuffixPart = ".nncp.chunk" ) diff --git a/src/cmd/nncp-bundle/main.go b/src/cmd/nncp-bundle/main.go index bcd91b8..113f8cf 100644 --- a/src/cmd/nncp-bundle/main.go +++ b/src/cmd/nncp-bundle/main.go @@ -306,10 +306,23 @@ func main() { ) continue } - if pktEnc.Magic != nncp.MagicNNCPEv5 { + switch pktEnc.Magic { + case nncp.MagicNNCPEv1.B: + err = nncp.MagicNNCPEv1.TooOld() + case nncp.MagicNNCPEv2.B: + err = nncp.MagicNNCPEv2.TooOld() + case nncp.MagicNNCPEv3.B: + err = nncp.MagicNNCPEv3.TooOld() + case nncp.MagicNNCPEv4.B: + err = nncp.MagicNNCPEv4.TooOld() + case nncp.MagicNNCPEv5.B: + default: + err = errors.New("Bad packet magic number") + } + if err != nil { ctx.LogD( "bundle-rx", - append(les, nncp.LE{K: "Err", V: "Bad packet magic number"}), + append(les, nncp.LE{K: "Err", V: err.Error()}), logMsg, ) continue diff --git a/src/cmd/nncp-cfgenc/main.go b/src/cmd/nncp-cfgenc/main.go index 810da34..7c41ee0 100644 --- a/src/cmd/nncp-cfgenc/main.go +++ b/src/cmd/nncp-cfgenc/main.go @@ -79,7 +79,13 @@ func main() { if _, err := xdr.Unmarshal(bytes.NewReader(data), &eblob); err != nil { log.Fatalln(err) } - if eblob.Magic != nncp.MagicNNCPBv3 { + switch eblob.Magic { + case nncp.MagicNNCPBv1.B: + log.Fatalln(nncp.MagicNNCPBv1.TooOld()) + case nncp.MagicNNCPBv2.B: + log.Fatalln(nncp.MagicNNCPBv2.TooOld()) + case nncp.MagicNNCPBv3.B: + default: log.Fatalln(errors.New("Unknown eblob type")) } fmt.Println("Strengthening function: Balloon with BLAKE2b-256") diff --git a/src/cmd/nncp-pkt/main.go b/src/cmd/nncp-pkt/main.go index 94c4d61..49c23a2 100644 --- a/src/cmd/nncp-pkt/main.go +++ b/src/cmd/nncp-pkt/main.go @@ -40,6 +40,92 @@ func usage() { fmt.Fprintln(os.Stderr, "Packet is read from stdin.") } +func doPlain(pkt nncp.Pkt, dump, decompress bool) { + if dump { + bufW := bufio.NewWriter(os.Stdout) + var r io.Reader + r = bufio.NewReader(os.Stdin) + if decompress { + decompressor, err := zstd.NewReader(r) + if err != nil { + log.Fatalln(err) + } + r = decompressor + } + if _, err := io.Copy(bufW, r); err != nil { + log.Fatalln(err) + } + if err := bufW.Flush(); err != nil { + log.Fatalln(err) + } + return + } + payloadType := "unknown" + switch pkt.Type { + case nncp.PktTypeFile: + payloadType = "file" + case nncp.PktTypeFreq: + payloadType = "file request" + case nncp.PktTypeExec: + payloadType = "exec compressed" + case nncp.PktTypeExecFat: + payloadType = "exec uncompressed" + case nncp.PktTypeTrns: + payloadType = "transitional" + } + var path string + switch pkt.Type { + case nncp.PktTypeExec, nncp.PktTypeExecFat: + path = string(bytes.Replace( + pkt.Path[:pkt.PathLen], + []byte{0}, + []byte(" "), + -1, + )) + case nncp.PktTypeTrns: + path = nncp.Base32Codec.EncodeToString(pkt.Path[:pkt.PathLen]) + default: + path = string(pkt.Path[:pkt.PathLen]) + } + fmt.Printf( + "Packet type: plain\nPayload type: %s\nNiceness: %s (%d)\nPath: %s\n", + payloadType, nncp.NicenessFmt(pkt.Nice), pkt.Nice, path, + ) + return +} + +func doEncrypted(pktEnc nncp.PktEnc, dump bool, cfgPath string, beginning []byte) { + if !dump { + fmt.Printf( + "Packet type: encrypted\nNiceness: %s (%d)\nSender: %s\nRecipient: %s\n", + nncp.NicenessFmt(pktEnc.Nice), pktEnc.Nice, pktEnc.Sender, pktEnc.Recipient, + ) + return + } + ctx, err := nncp.CtxFromCmdline(cfgPath, "", "", false, false, false, false) + if err != nil { + log.Fatalln("Error during initialization:", err) + } + if ctx.Self == nil { + log.Fatalln("Config lacks private keys") + } + bufW := bufio.NewWriter(os.Stdout) + if _, _, err = nncp.PktEncRead( + ctx.Self, + ctx.Neigh, + io.MultiReader( + bytes.NewReader(beginning), + bufio.NewReader(os.Stdin), + ), + bufW, + ); err != nil { + log.Fatalln(err) + } + if err = bufW.Flush(); err != nil { + log.Fatalln(err) + } +} + func main() { var ( overheads = flag.Bool("overheads", false, "Print packet overheads") @@ -71,99 +157,37 @@ func main() { return } - var err error beginning := make([]byte, nncp.PktOverhead) - if _, err = io.ReadFull(os.Stdin, beginning); err != nil { + if _, err := io.ReadFull(os.Stdin, beginning); err != nil { log.Fatalln("Not enough data to read") } var pkt nncp.Pkt - _, err = xdr.Unmarshal(bytes.NewReader(beginning), &pkt) - if err == nil && pkt.Magic == nncp.MagicNNCPPv3 { - if *dump { - bufW := bufio.NewWriter(os.Stdout) - var r io.Reader - r = bufio.NewReader(os.Stdin) - if *decompress { - decompressor, err := zstd.NewReader(r) - if err != nil { - log.Fatalln(err) - } - r = decompressor - } - if _, err = io.Copy(bufW, r); err != nil { - log.Fatalln(err) - } - if err = bufW.Flush(); err != nil { - log.Fatalln(err) - } + if _, err := xdr.Unmarshal(bytes.NewReader(beginning), &pkt); err == nil { + switch pkt.Magic { + case nncp.MagicNNCPPv1.B: + log.Fatalln(nncp.MagicNNCPPv1.TooOld()) + case nncp.MagicNNCPPv2.B: + log.Fatalln(nncp.MagicNNCPPv2.TooOld()) + case nncp.MagicNNCPPv3.B: + doPlain(pkt, *dump, *decompress) return } - payloadType := "unknown" - switch pkt.Type { - case nncp.PktTypeFile: - payloadType = "file" - case nncp.PktTypeFreq: - payloadType = "file request" - case nncp.PktTypeExec: - payloadType = "exec" - case nncp.PktTypeExecFat: - payloadType = "exec uncompressed" - case nncp.PktTypeTrns: - payloadType = "transitional" - } - var path string - switch pkt.Type { - case nncp.PktTypeExec, nncp.PktTypeExecFat: - path = string(bytes.Replace( - pkt.Path[:pkt.PathLen], - []byte{0}, - []byte(" "), - -1, - )) - case nncp.PktTypeTrns: - path = nncp.Base32Codec.EncodeToString(pkt.Path[:pkt.PathLen]) - default: - path = string(pkt.Path[:pkt.PathLen]) - } - fmt.Printf( - "Packet type: plain\nPayload type: %s\nNiceness: %s (%d)\nPath: %s\n", - payloadType, nncp.NicenessFmt(pkt.Nice), pkt.Nice, path, - ) - return } var pktEnc nncp.PktEnc - _, err = xdr.Unmarshal(bytes.NewReader(beginning), &pktEnc) - if err == nil && pktEnc.Magic == nncp.MagicNNCPEv5 { - if *dump { - ctx, err := nncp.CtxFromCmdline(*cfgPath, "", "", false, false, false, false) - if err != nil { - log.Fatalln("Error during initialization:", err) - } - if ctx.Self == nil { - log.Fatalln("Config lacks private keys") - } - bufW := bufio.NewWriter(os.Stdout) - if _, _, err = nncp.PktEncRead( - ctx.Self, - ctx.Neigh, - io.MultiReader( - bytes.NewReader(beginning), - bufio.NewReader(os.Stdin), - ), - bufW, - ); err != nil { - log.Fatalln(err) - } - if err = bufW.Flush(); err != nil { - log.Fatalln(err) - } + if _, err := xdr.Unmarshal(bytes.NewReader(beginning), &pktEnc); err == nil { + switch pkt.Magic { + case nncp.MagicNNCPEv1.B: + log.Fatalln(nncp.MagicNNCPEv1.TooOld()) + case nncp.MagicNNCPEv2.B: + log.Fatalln(nncp.MagicNNCPEv2.TooOld()) + case nncp.MagicNNCPEv3.B: + log.Fatalln(nncp.MagicNNCPEv3.TooOld()) + case nncp.MagicNNCPEv4.B: + log.Fatalln(nncp.MagicNNCPEv4.TooOld()) + case nncp.MagicNNCPEv5.B: + doEncrypted(pktEnc, *dump, *cfgPath, beginning) return } - fmt.Printf( - "Packet type: encrypted\nNiceness: %s (%d)\nSender: %s\nRecipient: %s\n", - nncp.NicenessFmt(pktEnc.Nice), pktEnc.Nice, pktEnc.Sender, pktEnc.Recipient, - ) - return } log.Fatalln("Unable to determine packet type") } diff --git a/src/cmd/nncp-reass/main.go b/src/cmd/nncp-reass/main.go index 56ea4ca..d7774c9 100644 --- a/src/cmd/nncp-reass/main.go +++ b/src/cmd/nncp-reass/main.go @@ -67,7 +67,11 @@ func process(ctx *nncp.Ctx, path string, keep, dryRun, stdout, dumpMeta bool) bo return false } fd.Close() // #nosec G104 - if metaPkt.Magic != nncp.MagicNNCPMv2 { + if metaPkt.Magic == nncp.MagicNNCPMv1.B { + ctx.LogE("reass", les, nncp.MagicNNCPMv1.TooOld(), logMsg) + return false + } + if metaPkt.Magic != nncp.MagicNNCPMv2.B { ctx.LogE("reass", les, nncp.BadMagic, logMsg) return false } diff --git a/src/cmd/nncp-xfer/main.go b/src/cmd/nncp-xfer/main.go index 605144b..0acba4b 100644 --- a/src/cmd/nncp-xfer/main.go +++ b/src/cmd/nncp-xfer/main.go @@ -218,10 +218,29 @@ func main() { continue } pktEnc, pktEncRaw, err := ctx.HdrRead(fd) - if err != nil || pktEnc.Magic != nncp.MagicNNCPEv5 { - ctx.LogD("xfer-rx-not-packet", les, func(les nncp.LEs) string { - return logMsg(les) + ": is not a packet" - }) + if err != nil { + switch pktEnc.Magic { + case nncp.MagicNNCPEv1.B: + err = nncp.MagicNNCPEv1.TooOld() + case nncp.MagicNNCPEv2.B: + err = nncp.MagicNNCPEv2.TooOld() + case nncp.MagicNNCPEv3.B: + err = nncp.MagicNNCPEv3.TooOld() + case nncp.MagicNNCPEv4.B: + err = nncp.MagicNNCPEv4.TooOld() + case nncp.MagicNNCPEv5.B: + default: + err = errors.New("is not an encrypted packet") + } + } + if err != nil { + ctx.LogD( + "xfer-rx-not-packet", + append(les, nncp.LE{K: "Err", V: err}), + func(les nncp.LEs) string { + return logMsg(les) + ": not valid packet: " + err.Error() + }, + ) fd.Close() // #nosec G104 continue } diff --git a/src/eblob.go b/src/eblob.go index c743d15..8bf2e97 100644 --- a/src/eblob.go +++ b/src/eblob.go @@ -34,10 +34,6 @@ const ( DefaultP = 2 ) -var ( - MagicNNCPBv3 [8]byte = [8]byte{'N', 'N', 'C', 'P', 'B', 0, 0, 3} -) - type EBlob struct { Magic [8]byte SCost uint32 @@ -65,7 +61,7 @@ func NewEBlob(sCost, tCost, pCost int, password, data []byte) ([]byte, error) { return nil, err } eblob := EBlob{ - Magic: MagicNNCPBv3, + Magic: MagicNNCPBv3.B, SCost: uint32(sCost), TCost: uint32(tCost), PCost: uint32(pCost), @@ -97,8 +93,17 @@ func DeEBlob(eblobRaw, password []byte) ([]byte, error) { if _, err = xdr.Unmarshal(bytes.NewReader(eblobRaw), &eblob); err != nil { return nil, err } - if eblob.Magic != MagicNNCPBv3 { - return nil, BadMagic + switch eblob.Magic { + case MagicNNCPBv1.B: + err = MagicNNCPBv1.TooOld() + case MagicNNCPBv2.B: + err = MagicNNCPBv1.TooOld() + case MagicNNCPBv3.B: + default: + err = BadMagic + } + if err != nil { + return nil, err } key := balloon.H( blake256, diff --git a/src/jobs.go b/src/jobs.go index 9aa8be4..e1344eb 100644 --- a/src/jobs.go +++ b/src/jobs.go @@ -139,7 +139,7 @@ func (ctx *Ctx) jobsFind(nodeId *NodeId, xx TRxTx, nock bool) chan Job { } pktEnc, pktEncRaw, err := ctx.HdrRead(fd) fd.Close() - if err != nil || pktEnc.Magic != MagicNNCPEv5 { + if err != nil || pktEnc.Magic != MagicNNCPEv5.B { continue } ctx.LogD("job", LEs{ diff --git a/src/magic.go b/src/magic.go new file mode 100644 index 0000000..2f0835c --- /dev/null +++ b/src/magic.go @@ -0,0 +1,93 @@ +/* +NNCP -- Node to Node copy, utilities for store-and-forward data exchange +Copyright (C) 2016-2021 Sergey Matveev + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 3 of the License. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ + +package nncp + +import "fmt" + +type Magic struct { + B [8]byte + Name string + Till string +} + +var ( + MagicNNCPBv1 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'B', 0, 0, 1}, + Name: "NNCPBv1 (EBlob v1)", Till: "1.0", + } + MagicNNCPBv2 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'B', 0, 0, 2}, + Name: "NNCPBv2 (EBlob v2)", Till: "3.4", + } + MagicNNCPBv3 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'B', 0, 0, 3}, + Name: "NNCPBv3 (EBlob v3)", Till: "now", + } + MagicNNCPDv1 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'D', 0, 0, 1}, + Name: "NNCPDv1 (multicast discovery v1)", Till: "now", + } + MagicNNCPEv1 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'E', 0, 0, 1}, + Name: "NNCPEv1 (encrypted packet v1)", Till: "0.12", + } + MagicNNCPEv2 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'E', 0, 0, 2}, + Name: "NNCPEv2 (encrypted packet v2)", Till: "1.0", + } + MagicNNCPEv3 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'E', 0, 0, 3}, + Name: "NNCPEv3 (encrypted packet v3)", Till: "3.4", + } + MagicNNCPEv4 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'E', 0, 0, 4}, + Name: "NNCPEv4 (encrypted packet v4)", Till: "6.6.0", + } + MagicNNCPEv5 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'E', 0, 0, 5}, + Name: "NNCPEv5 (encrypted packet v5)", Till: "now", + } + MagicNNCPSv1 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'S', 0, 0, 1}, + Name: "NNCPSv1 (sync protocol v1)", Till: "now", + } + MagicNNCPMv1 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'M', 0, 0, 1}, + Name: "NNCPMv1 (chunked .meta v1)", Till: "6.6.0", + } + MagicNNCPMv2 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'M', 0, 0, 2}, + Name: "NNCPMv2 (chunked .meta v2)", Till: "now", + } + MagicNNCPPv1 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'P', 0, 0, 1}, + Name: "NNCPPv1 (plain packet v1)", Till: "2.0", + } + MagicNNCPPv2 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'P', 0, 0, 2}, + Name: "NNCPPv2 (plain packet v2)", Till: "4.1", + } + MagicNNCPPv3 = Magic{ + B: [8]byte{'N', 'N', 'C', 'P', 'P', 0, 0, 3}, + Name: "NNCPPv3 (plain packet v3)", Till: "now", + } +) + +func (m *Magic) TooOld() error { + return fmt.Errorf("%s format is unsupported (used till %s)", m.Name, m.Till) +} diff --git a/src/mcd.go b/src/mcd.go index d785d5c..be40f42 100644 --- a/src/mcd.go +++ b/src/mcd.go @@ -43,8 +43,6 @@ type MCDAddr struct { } var ( - MagicNNCPDv1 [8]byte = [8]byte{'N', 'N', 'C', 'P', 'D', 0, 0, 1} - mcdIP = net.ParseIP("ff02::4e4e:4350") mcdAddrLifetime = 2 * time.Minute @@ -125,7 +123,7 @@ func (ctx *Ctx) MCDRx(ifiName string) error { }) continue } - if mcd.Magic != MagicNNCPDv1 { + if mcd.Magic != MagicNNCPDv1.B { ctx.LogD("mcd", les, func(les LEs) string { return fmt.Sprintf( "MCD Rx %s/%d: unexpected magic: %s", @@ -186,7 +184,7 @@ func (ctx *Ctx) MCDTx(ifiName string, port int, interval time.Duration) error { return err } var buf bytes.Buffer - mcd := MCD{Magic: MagicNNCPDv1, Sender: ctx.Self.Id} + mcd := MCD{Magic: MagicNNCPDv1.B, Sender: ctx.Self.Id} if _, err := xdr.Marshal(&buf, mcd); err != nil { panic(err) } diff --git a/src/pkt.go b/src/pkt.go index 3aed5a6..135e850 100644 --- a/src/pkt.go +++ b/src/pkt.go @@ -53,10 +53,8 @@ const ( ) var ( - MagicNNCPPv3 [8]byte = [8]byte{'N', 'N', 'C', 'P', 'P', 0, 0, 3} - MagicNNCPEv5 [8]byte = [8]byte{'N', 'N', 'C', 'P', 'E', 0, 0, 5} - BadMagic error = errors.New("Unknown magic number") - BadPktType error = errors.New("Unknown packet type") + BadMagic error = errors.New("Unknown magic number") + BadPktType error = errors.New("Unknown packet type") PktOverhead int64 PktEncOverhead int64 @@ -102,7 +100,7 @@ func init() { panic(err) } pktEnc := PktEnc{ - Magic: MagicNNCPEv5, + Magic: MagicNNCPEv5.B, Sender: dummyId, Recipient: dummyId, } @@ -118,7 +116,7 @@ func NewPkt(typ PktType, nice uint8, path []byte) (*Pkt, error) { return nil, errors.New("Too long path") } pkt := Pkt{ - Magic: MagicNNCPPv3, + Magic: MagicNNCPPv3.B, Type: typ, Nice: nice, PathLen: uint8(len(path)), @@ -209,7 +207,7 @@ func PktEncWrite( return nil, err } tbs := PktTbs{ - Magic: MagicNNCPEv5, + Magic: MagicNNCPEv5.B, Nice: nice, Sender: our.Id, Recipient: their.Id, @@ -222,7 +220,7 @@ func PktEncWrite( signature := new([ed25519.SignatureSize]byte) copy(signature[:], ed25519.Sign(our.SignPrv, tbsBuf.Bytes())) pktEnc := PktEnc{ - Magic: MagicNNCPEv5, + Magic: MagicNNCPEv5.B, Nice: nice, Sender: our.Id, Recipient: their.Id, @@ -242,7 +240,7 @@ func PktEncWrite( curve25519.ScalarMult(sharedKey, prvEph, their.ExchPub) key := make([]byte, chacha20poly1305.KeySize) - blake3.DeriveKey(key, string(MagicNNCPEv5[:]), sharedKey[:]) + blake3.DeriveKey(key, string(MagicNNCPEv5.B[:]), sharedKey[:]) aead, err := chacha20poly1305.New(key) if err != nil { return nil, err @@ -266,7 +264,7 @@ func PktEncWrite( return nil, io.ErrUnexpectedEOF } if padSize > 0 { - blake3.DeriveKey(key, string(MagicNNCPEv5[:])+" PAD", sharedKey[:]) + blake3.DeriveKey(key, string(MagicNNCPEv5.B[:])+" PAD", sharedKey[:]) xof := blake3.New(32, key).XOF() if _, err = io.CopyN(out, xof, padSize); err != nil { return nil, err @@ -277,7 +275,7 @@ func PktEncWrite( func TbsVerify(our *NodeOur, their *Node, pktEnc *PktEnc) ([]byte, bool, error) { tbs := PktTbs{ - Magic: MagicNNCPEv5, + Magic: MagicNNCPEv5.B, Nice: pktEnc.Nice, Sender: their.Id, Recipient: our.Id, @@ -301,8 +299,21 @@ func PktEncRead( if err != nil { return nil, 0, err } - if pktEnc.Magic != MagicNNCPEv5 { - return nil, 0, BadMagic + switch pktEnc.Magic { + case MagicNNCPEv1.B: + err = MagicNNCPEv1.TooOld() + case MagicNNCPEv2.B: + err = MagicNNCPEv2.TooOld() + case MagicNNCPEv3.B: + err = MagicNNCPEv3.TooOld() + case MagicNNCPEv4.B: + err = MagicNNCPEv4.TooOld() + case MagicNNCPEv5.B: + default: + err = BadMagic + } + if err != nil { + return nil, 0, err } their, known := nodes[*pktEnc.Sender] if !known { @@ -323,7 +334,7 @@ func PktEncRead( curve25519.ScalarMult(sharedKey, our.ExchPrv, &pktEnc.ExchPub) key := make([]byte, chacha20poly1305.KeySize) - blake3.DeriveKey(key, string(MagicNNCPEv5[:]), sharedKey[:]) + blake3.DeriveKey(key, string(MagicNNCPEv5.B[:]), sharedKey[:]) aead, err := chacha20poly1305.New(key) if err != nil { return their, 0, err diff --git a/src/sp.go b/src/sp.go index 7049142..7e74823 100644 --- a/src/sp.go +++ b/src/sp.go @@ -53,8 +53,6 @@ type SPCheckerTask struct { } var ( - MagicNNCPLv1 [8]byte = [8]byte{'N', 'N', 'C', 'P', 'S', 0, 0, 1} - SPInfoOverhead int SPFreqOverhead int SPFileOverhead int @@ -279,7 +277,7 @@ func (state *SPState) dirUnlock() { func (state *SPState) WriteSP(dst io.Writer, payload []byte, ping bool) error { state.writeSPBuf.Reset() n, err := xdr.Marshal(&state.writeSPBuf, SPRaw{ - Magic: MagicNNCPLv1, + Magic: MagicNNCPSv1.B, Payload: payload, }) if err != nil { @@ -307,7 +305,7 @@ func (state *SPState) ReadSP(src io.Reader) ([]byte, error) { } state.RxLastSeen = time.Now() state.RxBytes += int64(n) - if sp.Magic != MagicNNCPLv1 { + if sp.Magic != MagicNNCPSv1.B { return nil, BadMagic } return sp.Payload, nil diff --git a/src/toss_test.go b/src/toss_test.go index e2b3145..a66f43b 100644 --- a/src/toss_test.go +++ b/src/toss_test.go @@ -454,7 +454,7 @@ func TestTossTrns(t *testing.T) { os.MkdirAll(txPath, os.FileMode(0700)) for _, data := range datum { pktTrans := Pkt{ - Magic: MagicNNCPPv3, + Magic: MagicNNCPPv3.B, Type: PktTypeTrns, PathLen: MTHSize, } diff --git a/src/tx.go b/src/tx.go index f142d2f..14f73d2 100644 --- a/src/tx.go +++ b/src/tx.go @@ -405,7 +405,7 @@ func (ctx *Ctx) TxFile( leftSize := fileSize metaPkt := ChunkedMeta{ - Magic: MagicNNCPMv2, + Magic: MagicNNCPMv2.B, FileSize: uint64(fileSize), ChunkSize: uint64(chunkSize), Checksums: make([][MTHSize]byte, 0, (fileSize/chunkSize)+1), -- 2.44.0