packet.go 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174
  1. package packet
  2. import (
  3. "bytes"
  4. "crypto/md5"
  5. "encoding/base64"
  6. "encoding/binary"
  7. "errors"
  8. "fmt"
  9. "log"
  10. "net"
  11. "time"
  12. "github.com/gravitl/netmaker/nm-proxy/common"
  13. "golang.org/x/crypto/blake2s"
  14. "golang.org/x/crypto/chacha20poly1305"
  15. "golang.zx2c4.com/wireguard/wgctrl/wgtypes"
  16. )
  17. func ConsumeHandshakeInitiationMsg(initiator bool, buf []byte, src *net.UDPAddr, devicePubKey NoisePublicKey, devicePrivKey NoisePrivateKey) error {
  18. var (
  19. hash [blake2s.Size]byte
  20. chainKey [blake2s.Size]byte
  21. )
  22. var err error
  23. var msg MessageInitiation
  24. reader := bytes.NewReader(buf[:])
  25. err = binary.Read(reader, binary.LittleEndian, &msg)
  26. if err != nil {
  27. log.Println("Failed to decode initiation message")
  28. return err
  29. }
  30. if msg.Type != MessageInitiationType {
  31. return errors.New("not handshake initiation message")
  32. }
  33. log.Println("-----> ConsumeHandshakeInitiationMsg, Intitator: ", initiator)
  34. mixHash(&hash, &InitialHash, devicePubKey[:])
  35. mixHash(&hash, &hash, msg.Ephemeral[:])
  36. mixKey(&chainKey, &InitialChainKey, msg.Ephemeral[:])
  37. // decrypt static key
  38. var peerPK NoisePublicKey
  39. var key [chacha20poly1305.KeySize]byte
  40. ss := sharedSecret(&devicePrivKey, msg.Ephemeral)
  41. if isZero(ss[:]) {
  42. return errors.New("no secret")
  43. }
  44. KDF2(&chainKey, &key, chainKey[:], ss[:])
  45. aead, _ := chacha20poly1305.New(key[:])
  46. _, err = aead.Open(peerPK[:0], ZeroNonce[:], msg.Static[:], hash[:])
  47. if err != nil {
  48. return err
  49. }
  50. log.Println("--------> Got HandShake from peer: ", base64.StdEncoding.EncodeToString(peerPK[:]), src)
  51. if val, ok := common.ExtClientsWaitTh[base64.StdEncoding.EncodeToString(peerPK[:])]; ok {
  52. val.CommChan <- src
  53. time.Sleep(time.Second * 3)
  54. }
  55. setZero(hash[:])
  56. setZero(chainKey[:])
  57. return nil
  58. }
  59. func CreateProxyUpdatePacket(msg *ProxyUpdateMessage) ([]byte, error) {
  60. var buff [MessageProxyUpdateSize]byte
  61. writer := bytes.NewBuffer(buff[:0])
  62. err := binary.Write(writer, binary.LittleEndian, msg)
  63. if err != nil {
  64. return nil, err
  65. }
  66. packet := writer.Bytes()
  67. return packet, nil
  68. }
  69. func ConsumeProxyUpdateMsg(buf []byte) (*ProxyUpdateMessage, error) {
  70. var msg ProxyUpdateMessage
  71. reader := bytes.NewReader(buf[:])
  72. err := binary.Read(reader, binary.LittleEndian, &msg)
  73. if err != nil {
  74. log.Println("Failed to decode proxy update message")
  75. return nil, err
  76. }
  77. if msg.Type != MessageProxyUpdateType {
  78. return nil, errors.New("not proxy update message")
  79. }
  80. return &msg, nil
  81. }
  82. func CreateMetricPacket(id uint32, sender, reciever wgtypes.Key) ([]byte, error) {
  83. msg := MetricMessage{
  84. Type: MessageMetricsType,
  85. ID: id,
  86. Sender: sender,
  87. Reciever: reciever,
  88. TimeStamp: time.Now().UnixMilli(),
  89. }
  90. log.Printf("----------> $$$$$$ CREATED PACKET: %+v\n", msg)
  91. var buff [MessageMetricSize]byte
  92. writer := bytes.NewBuffer(buff[:0])
  93. err := binary.Write(writer, binary.LittleEndian, msg)
  94. if err != nil {
  95. return nil, err
  96. }
  97. packet := writer.Bytes()
  98. return packet, nil
  99. }
  100. func ConsumeMetricPacket(buf []byte) (*MetricMessage, error) {
  101. var msg MetricMessage
  102. var err error
  103. reader := bytes.NewReader(buf[:])
  104. err = binary.Read(reader, binary.LittleEndian, &msg)
  105. if err != nil {
  106. log.Println("Failed to decode metric message")
  107. return nil, err
  108. }
  109. if msg.Type != MessageMetricsType {
  110. return nil, errors.New("not metric message")
  111. }
  112. return &msg, nil
  113. }
  114. func ProcessPacketBeforeSending(buf []byte, n int, srckey, dstKey string) ([]byte, int, string, string) {
  115. srcKeymd5 := md5.Sum([]byte(srckey))
  116. dstKeymd5 := md5.Sum([]byte(dstKey))
  117. m := ProxyMessage{
  118. Type: MessageProxyType,
  119. Sender: srcKeymd5,
  120. Reciever: dstKeymd5,
  121. }
  122. var msgBuffer [MessageProxySize]byte
  123. writer := bytes.NewBuffer(msgBuffer[:0])
  124. err := binary.Write(writer, binary.LittleEndian, m)
  125. if err != nil {
  126. log.Println(err)
  127. }
  128. if n > len(buf)-MessageProxySize {
  129. buf = append(buf, msgBuffer[:]...)
  130. } else {
  131. copy(buf[n:n+MessageProxySize], msgBuffer[:])
  132. }
  133. n += MessageProxySize
  134. return buf, n, fmt.Sprintf("%x", srcKeymd5), fmt.Sprintf("%x", dstKeymd5)
  135. }
  136. func ExtractInfo(buffer []byte, n int) (int, string, string, error) {
  137. data := buffer[:n]
  138. if len(data) < MessageProxySize {
  139. return n, "", "", errors.New("proxy message not found")
  140. }
  141. var msg ProxyMessage
  142. var err error
  143. reader := bytes.NewReader(buffer[n-MessageProxySize:])
  144. err = binary.Read(reader, binary.LittleEndian, &msg)
  145. if err != nil {
  146. log.Println("Failed to decode proxy message")
  147. return n, "", "", err
  148. }
  149. if msg.Type != MessageProxyType {
  150. return n, "", "", errors.New("not a proxy message")
  151. }
  152. n -= MessageProxySize
  153. return n, fmt.Sprintf("%x", msg.Sender), fmt.Sprintf("%x", msg.Reciever), nil
  154. }