idk/go-i2p
1
0
Fork 0
mirror of https://github.com/go-i2p/go-i2p.git synced 2025-07-13 20:41:25 -04:00
Code Issues Packages Projects Releases Wiki Activity

expanded logging in outgoing_handshake.go

Browse Source
This commit is contained in:
Haris Khan
2024-10-19 10:44:08 -04:00
parent af3bc44dba
commit 465a7787a9
1 changed files with 30 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
lib/transport/noise/outgoing_handshake.go
View File

@ -5,29 +5,35 @@ import (
"crypto/rand" "crypto/rand"
"encoding/binary" "encoding/binary"
"errors" "errors"
"github.com/sirupsen/logrus"
"io" "io"
"log"
"github.com/flynn/noise" "github.com/flynn/noise"
) )
func ComposeInitiatorHandshakeMessage(s noise.DHKey, rs []byte, payload []byte, ePrivate []byte) (negData, msg []byte, state *noise.HandshakeState, err error) { func ComposeInitiatorHandshakeMessage(s noise.DHKey, rs []byte, payload []byte, ePrivate []byte) (negData, msg []byte, state *noise.HandshakeState, err error) {
log.Debug("Starting ComposeInitiatorHandshakeMessage")
if len(rs) != 0 && len(rs) != noise.DH25519.DHLen() { if len(rs) != 0 && len(rs) != noise.DH25519.DHLen() {
log.WithField("rs_length", len(rs)).Error("Invalid remote static key length")
return nil, nil, nil, errors.New("only 32 byte curve25519 public keys are supported") return nil, nil, nil, errors.New("only 32 byte curve25519 public keys are supported")
} }
negData = make([]byte, 6) negData = make([]byte, 6)
copy(negData, initNegotiationData(nil)) copy(negData, initNegotiationData(nil))
pattern := noise.HandshakeXK pattern := noise.HandshakeXK
negData[5] = NOISE_PATTERN_XK negData[5] = NOISE_PATTERN_XK
log.WithField("pattern", "XK").Debug("Noise pattern set")
var random io.Reader var random io.Reader
if len(ePrivate) == 0 { if len(ePrivate) == 0 {
random = rand.Reader random = rand.Reader
log.Debug("Using crypto/rand as random source")
} else { } else {
random = bytes.NewBuffer(ePrivate) random = bytes.NewBuffer(ePrivate)
log.Debug("Using provided ePrivate as random source")
} }
prologue := make([]byte, 2, uint16Size+len(negData)) prologue := make([]byte, 2, uint16Size+len(negData))
binary.BigEndian.PutUint16(prologue, uint16(len(negData))) binary.BigEndian.PutUint16(prologue, uint16(len(negData)))
prologue = append(prologue, negData...) prologue = append(prologue, negData...)
log.WithField("prologue_length", len(prologue)).Debug("Prologue created")
// prologue = append(initString, prologue...) // prologue = append(initString, prologue...)
state, err = noise.NewHandshakeState(noise.Config{ state, err = noise.NewHandshakeState(noise.Config{
StaticKeypair: s, StaticKeypair: s,
@ -39,26 +45,49 @@ func ComposeInitiatorHandshakeMessage(s noise.DHKey, rs []byte, payload []byte,
Random: random, Random: random,
}) })
if err != nil { if err != nil {
log.WithError(err).Error("Failed to create new handshake state")
return return
} }
log.Debug("Handshake state created successfully")
padBuf := make([]byte, 2+len(payload)) padBuf := make([]byte, 2+len(payload))
copy(padBuf[2:], payload) copy(padBuf[2:], payload)
msg, _, _, err = state.WriteMessage(msg, padBuf) msg, _, _, err = state.WriteMessage(msg, padBuf)
if err != nil {
log.WithError(err).Error("Failed to write handshake message")
return
}
log.WithField("message_length", len(msg)).Debug("Handshake message composed successfully")
return return
} }
func (c *NoiseSession) RunOutgoingHandshake() error { func (c *NoiseSession) RunOutgoingHandshake() error {
log.Debug("Starting outgoing handshake")
negData, msg, state, err := ComposeInitiatorHandshakeMessage(c.HandKey, nil, nil, nil) negData, msg, state, err := ComposeInitiatorHandshakeMessage(c.HandKey, nil, nil, nil)
if err != nil { if err != nil {
log.WithError(err).Error("Failed to compose initiator handshake message")
return err return err
} }
log.WithFields(logrus.Fields{
"negData_length": len(negData),
"msg_length": len(msg),
}).Debug("Initiator handshake message composed")
if _, err = c.Write(negData); err != nil { if _, err = c.Write(negData); err != nil {
log.WithError(err).Error("Failed to write negotiation data")
return err return err
} }
log.Debug("Negotiation data written successfully")
if _, err = c.Write(msg); err != nil { if _, err = c.Write(msg); err != nil {
log.WithError(err).Error("Failed to write handshake message")
return err return err
} }
log.Debug("Handshake message written successfully")
log.WithField("state", state).Debug("Handshake state after message write")
log.Println(state) log.Println(state)
c.handshakeComplete = true c.handshakeComplete = true
log.Debug("Outgoing handshake completed successfully")
return nil return nil
} }