Integration test: bug fixes 1st round.

3 files changed, 164 insertions, 91 deletions

diff --git a/src/gnunet/service/dht/path/elements.go b/src/gnunet/service/dht/path/elements.go
index 1384469..4fb03c1 100644
--- a/src/gnunet/service/dht/path/elements.go
+++ b/src/gnunet/service/dht/path/elements.go
@@ -36,6 +36,7 @@ var (
 )
 
 //----------------------------------------------------------------------
+
 // Entry is an element of the path list
 type Entry struct {
         Signature *util.PeerSignature // path element signature
@@ -57,9 +58,9 @@ func (e *Entry) String() string {
         return fmt.Sprintf("(%s,%s)", e.Signer.String(), s)
 }
 
-//----------------------------------------------------------------------
+// ----------------------------------------------------------------------
 // shared path element data across types
-type elementData struct {
+type _ElementData struct {
         Expire          util.AbsoluteTime // expiration date
         BlockHash       *crypto.HashCode  // block hash
         PeerPredecessor *util.PeerID      // predecessor peer
@@ -67,41 +68,48 @@ type elementData struct {
 }
 
 // helper type for signature creation/verification
-type elementSignedData struct {
-        Size    uint16       `order:"big"` // size of signed data
-        Purpose uint16       `order:"big"` // signature purpose (SIG_DHT_HOP)
-        Elem    *elementData ``            // path element data
+type _SignedData struct {
+        Purpose *crypto.SignaturePurpose // signature purpose
+        Elem    *_ElementData            // path element data
 }
 
-//----------------------------------------------------------------------
+// ----------------------------------------------------------------------
 // Element is the full-fledged data assembly for a path element in
 // PUT/GET pathes. It is assembled programatically (on generation[1] and
 // verification[2]) and not transferred in messages directly.
 //
 // [1] spe = &Element{...}
-//     core.Sign(spe)
-//     msg.putpath[i] = spe.Wire()
+//
+//      core.Sign(spe)
+//      msg.putpath[i] = spe.Wire()
 //
 // [2] pe = &Element{...,Signature: wire.sig}
-//     if !pe.Verify(peerId) { ... }
 //
+//      if !pe.Verify(peerId) { ... }
 type Element struct {
-        elementData
+        _ElementData
         Entry
 }
 
 // SignedData gets the data to be signed by peer ('Signable' interface)
 func (pe *Element) SignedData() []byte {
-        sd := &elementSignedData{
-                Size:    80,
-                Purpose: uint16(enums.SIG_DHT_HOP),
-                Elem:    &(pe.elementData),
+        sd := &_SignedData{
+                Purpose: &crypto.SignaturePurpose{
+                        Size:    144,
+                        Purpose: enums.SIG_DHT_HOP,
+                },
+                Elem: &(pe._ElementData),
         }
         buf, err := data.Marshal(sd)
         if err != nil {
                 logger.Println(logger.ERROR, "can't serialize path element for signature")
                 return nil
         }
+        if len(buf) != int(sd.Purpose.Size) {
+                logger.Printf(logger.ERROR, "size mismatch for serialized path element -- %d -> %d", sd.Purpose.Size, len(buf))
+                sd.Purpose.Size = uint32(len(buf))
+                return nil
+        }
         return buf
 }
 
diff --git a/src/gnunet/service/dht/path/elements_test.go b/src/gnunet/service/dht/path/elements_test.go
new file mode 100644
index 0000000..68c2384
--- /dev/null
+++ b/src/gnunet/service/dht/path/elements_test.go
@@ -0,0 +1,71 @@
+// This file is part of gnunet-go, a GNUnet-implementation in Golang.
+// Copyright (C) 2019-2022 Bernd Fix  >Y<
+//
+// gnunet-go is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Affero General Public License as published
+// by the Free Software Foundation, either version 3 of the License,
+// or (at your option) any later version.
+//
+// gnunet-go 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
+// Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// SPDX-License-Identifier: AGPL3.0-or-later
+
+package path
+
+import (
+        "encoding/hex"
+        "gnunet/util"
+        "testing"
+)
+
+func TestElementDebug(t *testing.T) {
+        var (
+                signedData = "" +
+                        "00000090" +
+                        "00000006" +
+                        "0005e6983d33f911" +
+                        "f3236acc2be7812a988617c647fc27fcfbd0dacc3d960aa29a5f9bf0b9b9131f" +
+                        "cdd31cfa45de2cbd9510665e7f2b1ccafefd445511c62729c0798dd1b0675f19" +
+                        "0000000000000000000000000000000000000000000000000000000000000000" +
+                        "23b096021b25d822c217a756b877cf72c7fdabd4eff79c4dbb7418dd2b232386"
+
+                signature = "" +
+                        "ef94ddfd90b56f30b265a88384551907fadef176b4ba6b023df429506b34cde0" +
+                        "39f38661d451e6e5bd1c4d5d078d27f0e8954bd964ea55f03afa42aa9964cc0c"
+                signer = "" +
+                        "28f06fe5178742c3b8f080431e48cf5bf3898ba8b8fd57a975772d14003a8c75"
+                predecessor = "" +
+                        "0000000000000000000000000000000000000000000000000000000000000000"
+                successor = "" +
+                        "23b096021b25d822c217a756b877cf72c7fdabd4eff79c4dbb7418dd2b232386"
+        )
+        convert := func(s string) []byte {
+                buf, err := hex.DecodeString(s)
+                if err != nil {
+                        t.Fatal(err)
+                }
+                return buf
+        }
+        sd := convert(signedData)
+        sig := util.NewPeerSignature(convert(signature))
+        pred := util.NewPeerID(convert(predecessor))
+        curr := util.NewPeerID(convert(signer))
+        succ := util.NewPeerID(convert(successor))
+
+        ok, err := curr.Verify(sd, sig)
+        if err != nil {
+                t.Fatal(err)
+        }
+        if !ok {
+                t.Logf("Pred: %s", pred.Short())
+                t.Logf("Sign: %s", curr.Short())
+                t.Logf("Succ: %s", succ.Short())
+                t.Error("Verify NOT OK:")
+        }
+}
diff --git a/src/gnunet/service/dht/path/handling.go b/src/gnunet/service/dht/path/handling.go
index 4040511..7ad91df 100644
--- a/src/gnunet/service/dht/path/handling.go
+++ b/src/gnunet/service/dht/path/handling.go
@@ -19,11 +19,10 @@
 package path
 
 import (
-        "bytes"
-        "encoding/hex"
-        "fmt"
         "gnunet/crypto"
+        "gnunet/enums"
         "gnunet/util"
+        "strings"
 
         "github.com/bfix/gospel/data"
         "github.com/bfix/gospel/logger"
@@ -33,17 +32,11 @@ import (
 // Path handling
 //----------------------------------------------------------------------
 
-// path flags
-const (
-        PathTruncated = 1
-        PathLastHop   = 2
-)
-
 // Path is the complete list of verified hops a message travelled.
 // It also keeps the associated block hash and expiration time of
 // the request for signature verification purposes.
 type Path struct {
-        Flags       uint32              `order:"big"`    // flags
+        Flags       uint16              `order:"big"`    // flags
         BlkHash     *crypto.HashCode    ``               // block hash value
         Expire      util.AbsoluteTime   ``               // expiration time
         TruncOrigin *util.PeerID        `opt:"(IsUsed)"` // truncated origin (optional)
@@ -58,9 +51,9 @@ type Path struct {
 func (p *Path) IsUsed(field string) bool {
         switch field {
         case "TruncOrigin":
-                return p.Flags&PathTruncated != 0
+                return p.Flags&enums.DHT_RO_TRUNCATED != 0
         case "LastSig", "LastHop":
-                return p.Flags&PathLastHop != 0
+                return p.Flags&enums.DHT_RO_RECORD_ROUTE != 0
         }
         return false
 }
@@ -128,7 +121,7 @@ func (p *Path) Clone() *Path {
 // NewElement creates a new path element from data
 func (p *Path) NewElement(pred, signer, succ *util.PeerID) *Element {
         return &Element{
-                elementData: elementData{
+                _ElementData: _ElementData{
                         Expire:          p.Expire,
                         BlockHash:       p.BlkHash,
                         PeerPredecessor: pred,
@@ -155,7 +148,7 @@ func (p *Path) Add(elem *Element) {
         // update last hop signature
         p.LastSig = elem.Signature
         p.LastHop = elem.Signer
-        p.Flags |= PathLastHop
+        p.Flags |= enums.DHT_RO_RECORD_ROUTE
 }
 
 // Verify path: process list entries from right to left (decreasing index).
@@ -181,6 +174,7 @@ func (p *Path) Verify(local *util.PeerID) {
                 pe := p.NewElement(pred, p.LastHop, local)
                 ok, err := pe.Verify(p.LastSig)
                 if err != nil || !ok {
+                        logger.Println(logger.WARN, "[path] Dropping path (invalid last signature)")
                         // remove last hop signature and truncated origin; reset flags
                         p.LastSig = nil
                         p.LastHop = nil
@@ -188,79 +182,79 @@ func (p *Path) Verify(local *util.PeerID) {
                         p.Flags = 0
                 }
                 return
-        } else {
-                // yes: process list of path elements
-                signer := p.LastHop
-                sig := p.LastSig
-                succ := local
-                num := len(p.List)
-                var pred *util.PeerID
-                for i := num - 1; i >= 0; i-- {
-                        if i == -1 {
-                                if p.TruncOrigin != nil {
-                                        pred = p.TruncOrigin
-                                } else {
-                                        pred = util.NewPeerID(nil)
-                                }
+        }
+        // yes: process list of path elements
+        signer := p.LastHop
+        sig := p.LastSig
+        succ := local
+        num := len(p.List)
+        var pred *util.PeerID
+        for i := num - 1; i >= 0; i-- {
+                if i == -1 {
+                        if p.TruncOrigin != nil {
+                                pred = p.TruncOrigin
                         } else {
-                                pred = p.List[i].Signer
+                                pred = util.NewPeerID(nil)
                         }
-                        pe := p.NewElement(pred, signer, succ)
-                        ok, err := pe.Verify(sig)
-                        if err != nil || !ok {
-                                // we need to truncate:
-                                logger.Printf(logger.WARN, "[path] Truncating path (invalid signature at hop %d)", i)
+                } else {
+                        pred = p.List[i].Signer
+                }
+                pe := p.NewElement(pred, signer, succ)
+                ok, err := pe.Verify(sig)
+                if err != nil || !ok {
+                        // we need to truncate:
+                        logger.Printf(logger.WARN, "[path] Truncating path (invalid signature at hop %d)", i)
 
-                                // are we at the end of the list?
-                                if i == num-1 {
-                                        // yes: the last hop signature failed -> reset path
-                                        p.LastSig = nil
-                                        p.LastHop = nil
-                                        p.TruncOrigin = nil
-                                        p.Flags = 0
-                                        p.List = make([]*Entry, 0)
-                                        return
-                                }
-                                // trim list
-                                p.Flags |= PathTruncated
-                                p.TruncOrigin = signer
-                                size := num - 2 - i
-                                list := make([]*Entry, size)
-                                if size > 0 {
-                                        copy(list, p.List[i+2:])
-                                }
-                                p.List = list
+                        // are we at the end of the list?
+                        if i == num-1 {
+                                // yes: the last hop signature failed -> reset path
+                                p.LastSig = nil
+                                p.LastHop = nil
+                                p.TruncOrigin = nil
+                                p.Flags = 0
+                                p.List = make([]*Entry, 0)
                                 return
                         }
-                        // check next path element
-                        succ = signer
-                        signer = pred
-                        if i != -1 {
-                                sig = p.List[i].Signature
+                        // trim list
+                        p.Flags |= enums.DHT_RO_TRUNCATED
+                        p.TruncOrigin = signer
+                        size := num - 2 - i
+                        list := make([]*Entry, size)
+                        if size > 0 {
+                                copy(list, p.List[i+2:])
                         }
+                        p.List = list
+                        return
+                }
+                // check next path element
+                succ = signer
+                signer = pred
+                if i != -1 {
+                        sig = p.List[i].Signature
                 }
         }
 }
 
-// String returs a uman-readbale representation
+// String returns a human-readable representation
 func (p *Path) String() string {
-        buf := new(bytes.Buffer)
-        s := "0"
-        if p.TruncOrigin != nil {
-                s = p.TruncOrigin.String()
-        }
-        buf.WriteString(fmt.Sprintf("{to=%s, (%d)[", s, len(p.List)))
-        for _, e := range p.List {
-                buf.WriteString(e.String())
-        }
-        s = "0"
-        if p.LastSig != nil {
-                s = hex.EncodeToString(p.LastSig.Bytes())
+        var hops []string
+        if p != nil {
+                if p.TruncOrigin != nil {
+                        hops = append(hops, p.TruncOrigin.Short())
+                }
+                for _, e := range p.List {
+                        hops = append(hops, e.Signer.Short())
+                }
+                if p.LastHop != nil {
+                        hops = append(hops, p.LastHop.Short())
+                }
         }
-        num := len(s)
-        if num > 16 {
-                s = s[:8] + ".." + s[num-8:]
+        // trim to sensible length for display
+        if num := len(hops); num > 8 {
+                trim := make([]string, 9)
+                copy(trim[:4], hops[:4])
+                trim[4] = "..."
+                copy(trim[5:], hops[num-5:])
         }
-        buf.WriteString(fmt.Sprintf("], ls=%s}", s))
-        return buf.String()
+        return "[" + strings.Join(hops, "-") + "]"
 }