move padding

lib/common/keys_and_cert/keys_and_cert.go

@@ -139,10 +139,13 @@ func (keys_and_cert *KeysAndCert) Certificate() (cert Certificate) {
 
 // ReadKeysAndCert creates a new *KeysAndCert from []byte using ReadKeysAndCert.
 // Returns a pointer to KeysAndCert unlike ReadKeysAndCert.
-func ReadKeysAndCert(data []byte) (keys_and_cert *KeysAndCert, remainder []byte, err error) {
+func ReadKeysAndCert(data []byte) (*KeysAndCert, []byte, error) {
 	log.WithFields(logrus.Fields{
 		"input_length": len(data),
 	}).Debug("Reading KeysAndCert from data")
+	var err error
+	var remainder []byte
+	var keys_and_cert KeysAndCert
 
 	data_len := len(data)
 	if data_len < KEYS_AND_CERT_MIN_SIZE {
@@ -153,13 +156,13 @@ func ReadKeysAndCert(data []byte) (keys_and_cert *KeysAndCert, remainder []byte,
 			"reason":       "not enough data",
 		}).Error("error parsing keys and cert")
 		err = oops.Errorf("error parsing KeysAndCert: data is smaller than minimum valid size")
-		return
+		return &keys_and_cert, remainder, err
 	}
 
 	keys_and_cert.KeyCertificate, remainder, err = NewKeyCertificate(data[KEYS_AND_CERT_DATA_SIZE:])
 	if err != nil {
 		log.WithError(err).Error("Failed to create keyCertificate")
-		return
+		return &keys_and_cert, remainder, err
 	}
 
 	// Get the actual key sizes from the certificate
@@ -170,7 +173,7 @@ func ReadKeysAndCert(data []byte) (keys_and_cert *KeysAndCert, remainder []byte,
 	keys_and_cert.ReceivingPublic, err = keys_and_cert.KeyCertificate.ConstructPublicKey(data[:pubKeySize])
 	if err != nil {
 		log.WithError(err).Error("Failed to construct publicKey")
-		return
+		return &keys_and_cert, remainder, err
 	}
 
 	// Calculate padding size and extract padding
@@ -186,7 +189,7 @@ func ReadKeysAndCert(data []byte) (keys_and_cert *KeysAndCert, remainder []byte,
 	)
 	if err != nil {
 		log.WithError(err).Error("Failed to construct signingPublicKey")
-		return
+		return &keys_and_cert, remainder, err
 	}
 
 	log.WithFields(logrus.Fields{
@@ -196,7 +199,7 @@ func ReadKeysAndCert(data []byte) (keys_and_cert *KeysAndCert, remainder []byte,
 		"remainder_length":        len(remainder),
 	}).Debug("Successfully read KeysAndCert")
 
-	return
+	return &keys_and_cert, remainder, err
 }
 
 func ReadKeysAndCertElgAndEd25519(data []byte) (keysAndCert *KeysAndCert, remainder []byte, err error) {

lib/common/keys_and_cert/keys_and_cert_test.go

@@ -2,6 +2,7 @@ package keys_and_cert
 
 import (
 	"bytes"
+	"crypto/ed25519"
 	"crypto/rand"
 	"testing"
 
@@ -32,8 +33,15 @@ func TestCertificateWithMissingData(t *testing.T) {
 // createValidKeyCertificate creates a valid KeyCertificate for testing.
 func createValidKeyAndCert(t *testing.T) *KeysAndCert {
 	// Generate signing key pair (Ed25519)
-	var ed25519_privkey crypto.Ed25519PrivateKey
-	_, err := (&ed25519_privkey).Generate()
+	//var ed25519_privkey crypto.Ed25519PrivateKey
+	_, priv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		t.Fatalf("Failed to generate Ed25519 private %s", err)
+	}
+	// Copy the full private key (includes public key)
+	ed25519_privkey := make(crypto.Ed25519PrivateKey, ed25519.PrivateKeySize)
+	copy(ed25519_privkey, priv)
+	//_, err = (ed25519_privkey).Generate()
 	if err != nil {
 		t.Fatalf("Failed to generate Ed25519 private key: %v\n", err)
 	}

lib/common/router_address/router_address.go

@@ -179,6 +179,16 @@ func (router_address RouterAddress) GetOption(key I2PString) I2PString {
 	return router_address.Options().Values().Get(key)
 }
 
+func (router_address RouterAddress) HasOption(key I2PString) bool {
+	opt := router_address.GetOption(key)
+	return opt != nil
+}
+
+func (router_address RouterAddress) CheckOption(key string) bool {
+	keyv, _ := ToI2PString(key)
+	return router_address.HasOption(keyv)
+}
+
 func (router_address RouterAddress) HostString() I2PString {
 	host, _ := ToI2PString("host")
 	return router_address.GetOption(host)

lib/common/router_identity/router_identity.go

@@ -72,7 +72,7 @@ func NewRouterIdentity(publicKey crypto.RecievingPublicKey, signingPublicKey cry
 
 	// Step 3: Initialize RouterIdentity with KeysAndCert.
 	routerIdentity := RouterIdentity{
-		KeysAndCert: *keysAndCert,
+		KeysAndCert: keysAndCert,
 	}
 
 	log.WithFields(logrus.Fields{

lib/transport/ntcp/session.go

@@ -9,6 +9,7 @@ import (
 	"github.com/go-i2p/go-i2p/lib/crypto"
 	"github.com/go-i2p/go-i2p/lib/transport/noise"
 	"github.com/go-i2p/go-i2p/lib/transport/obfs"
+	"github.com/go-i2p/go-i2p/lib/transport/padding"
 
 	"github.com/samber/oops"
 )
@@ -33,7 +34,7 @@ import (
 type NTCP2Session struct {
 	*noise.NoiseSession
 	*NTCP2Transport
-	paddingStrategy PaddingStrategy
+	paddingStrategy padding.PaddingStrategy
 }
 
 type SessionRequest struct {
@@ -83,15 +84,11 @@ func NewNTCP2Session(noiseConfig router_info.RouterInfo) (*NTCP2Session, error)
 	}
 
 	return &NTCP2Session{
-		NoiseSession: baseNoiseSession.(*noise.NoiseSession),
+		NoiseSession:    baseNoiseSession.(*noise.NoiseSession),
+		paddingStrategy: &padding.NullPaddingStrategy{},
 	}, nil
 }
 
-type PaddingStrategy interface {
-	AddPadding(message []byte) []byte
-	RemovePadding(message []byte) []byte
-}
-
 // PeerStaticKey is equal to the NTCP2 peer's static public key, found in their router info
 func (s *NTCP2Session) peerStaticKey() ([32]byte, error) {
 	for _, addr := range s.RouterInfo.RouterAddresses() {

lib/transport/ntcp/transport.go

@@ -43,7 +43,10 @@ func (t *NTCP2Transport) Compatible(routerInfo router_info.RouterInfo) bool {
 			continue
 		}
 		if transportStyle == NTCP_PROTOCOL_NAME {
-			return true
+			// Verify required NTCP2 options exist
+			if addr.CheckOption("s") && addr.CheckOption("i") && addr.CheckOption("v") {
+				return true
+			}
 		}
 	}
 	return false

lib/transport/padding/padding.go

@@ -0,0 +1,16 @@
+package padding
+
+type PaddingStrategy interface {
+	AddPadding(message []byte) []byte
+	RemovePadding(message []byte) []byte
+}
+
+type NullPaddingStrategy struct{}
+
+func (p *NullPaddingStrategy) AddPadding(message []byte) []byte {
+	return message
+}
+
+func (p *NullPaddingStrategy) RemovePadding(message []byte) []byte {
+	return message
+}