Old magic numbers knowledge

diff --git a/src/cfg.go b/src/cfg.go
index 6b10007bd8646502ee593da517a7c4f8f5d00713..bb101cac2914c8af566e5dd7cbf0fe6b3c91da73 100644 (file)
--- 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 29f2228efceb6e3263ed2b48402754e2d6c40295..212d16f4c990327cf06510aea8fc3aa3164bc7d2 100644 (file)
--- a/src/chunked.go
+++ b/src/chunked.go
@@ -18,8 +18,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 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 bcd91b8b78cfdfc62b02244ca4489afb9a005c40..113f8cf9dbd14222caf9984889b90ff21b3b4828 100644 (file)
--- 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 810da3470588570a58a53956ea89c5f8f15ccc8a..7c41ee097943bf05a679c3fde8c71b5eb957d5d9 100644 (file)
--- 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 94c4d61be228b2be95cc1a2c114ecf80f7bbe4bd..49c23a246df01248921dc321b824e14e9ecfa77c 100644 (file)
--- 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 56ea4ca7c473e0acf9c920ab32e5a6afb4b6f633..d7774c95bd2fb718136d62b8a43dff5e1b8f1561 100644 (file)
--- 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 605144b300c47a1737abf6f79c4d66cbb65aa54b..0acba4b8edcb50804e8be030e66e9b5c8185383a 100644 (file)
--- 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 c743d1552802ac47218e0a75140fe990cc77f2a4..8bf2e978fd4895df548625530906b4e0c6c080cc 100644 (file)
--- 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 9aa8be4a765d2295baeec85224e9f15b4f2aa883..e1344ebf65b8b21c33e136d45eeed4b1292f245b 100644 (file)
--- 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 (file)
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 <stargrave@stargrave.org>
+
+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 <http://www.gnu.org/licenses/>.
+*/
+
+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 d785d5c64b9461f1636de0220f37d9dde7fc73b5..be40f42de1edd50f03e0a1bc5d045ce88bf76bb5 100644 (file)
--- 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 3aed5a64c30674d7ad1c3e1b24377604325442c1..135e850950e688c087abfe4ce0fb1ae6987fe63f 100644 (file)
--- 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 7049142421509aeedebbb9bd36f58a7b03c3d8d7..7e74823e93fdb8bb4094f227ff82134fa094d55d 100644 (file)
--- 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 e2b3145e988e47d8541eb6a5bf4625fbc4d5b4d6..a66f43ba52ae2ea1a761ff663dad3e5aed3001e6 100644 (file)
--- 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 f142d2f9205f84e0f40f2b931caac1bb1d7c329f..14f73d23c627313102100a8d340d0aae0e92ed0d 100644 (file)
--- 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),