src/pkt.go

   1 /*
   2 NNCP -- Node to Node copy, utilities for store-and-forward data exchange
   3 Copyright (C) 2016-2021 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, version 3 of the License.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 package nncp
  19
  20 import (
  21         "bytes"
  22         "crypto/cipher"
  23         "crypto/rand"
  24         "encoding/binary"
  25         "errors"
  26         "io"
  27
  28         xdr "github.com/davecgh/go-xdr/xdr2"
  29         "golang.org/x/crypto/chacha20poly1305"
  30         "golang.org/x/crypto/curve25519"
  31         "golang.org/x/crypto/ed25519"
  32         "golang.org/x/crypto/nacl/box"
  33         "golang.org/x/crypto/poly1305"
  34         "lukechampine.com/blake3"
  35 )
  36
  37 type PktType uint8
  38
  39 const (
  40         EncBlkSize = 128 * (1 << 10)
  41
  42         PktTypeFile    PktType = iota
  43         PktTypeFreq    PktType = iota
  44         PktTypeExec    PktType = iota
  45         PktTypeTrns    PktType = iota
  46         PktTypeExecFat PktType = iota
  47
  48         MaxPathSize = 1<<8 - 1
  49
  50         NNCPBundlePrefix = "NNCP"
  51
  52         PktSizeOverhead = 8 + poly1305.TagSize
  53 )
  54
  55 var (
  56         BadMagic   error = errors.New("Unknown magic number")
  57         BadPktType error = errors.New("Unknown packet type")
  58
  59         PktOverhead    int64
  60         PktEncOverhead int64
  61 )
  62
  63 type Pkt struct {
  64         Magic   [8]byte
  65         Type    PktType
  66         Nice    uint8
  67         PathLen uint8
  68         Path    [MaxPathSize]byte
  69 }
  70
  71 type PktTbs struct {
  72         Magic     [8]byte
  73         Nice      uint8
  74         Sender    *NodeId
  75         Recipient *NodeId
  76         ExchPub   [32]byte
  77 }
  78
  79 type PktEnc struct {
  80         Magic     [8]byte
  81         Nice      uint8
  82         Sender    *NodeId
  83         Recipient *NodeId
  84         ExchPub   [32]byte
  85         Sign      [ed25519.SignatureSize]byte
  86 }
  87
  88 func init() {
  89         pkt := Pkt{Type: PktTypeFile}
  90         var buf bytes.Buffer
  91         n, err := xdr.Marshal(&buf, pkt)
  92         if err != nil {
  93                 panic(err)
  94         }
  95         PktOverhead = int64(n)
  96         buf.Reset()
  97
  98         dummyId, err := NodeIdFromString("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
  99         if err != nil {
 100                 panic(err)
 101         }
 102         pktEnc := PktEnc{
 103                 Magic:     MagicNNCPEv5.B,
 104                 Sender:    dummyId,
 105                 Recipient: dummyId,
 106         }
 107         n, err = xdr.Marshal(&buf, pktEnc)
 108         if err != nil {
 109                 panic(err)
 110         }
 111         PktEncOverhead = int64(n)
 112 }
 113
 114 func NewPkt(typ PktType, nice uint8, path []byte) (*Pkt, error) {
 115         if len(path) > MaxPathSize {
 116                 return nil, errors.New("Too long path")
 117         }
 118         pkt := Pkt{
 119                 Magic:   MagicNNCPPv3.B,
 120                 Type:    typ,
 121                 Nice:    nice,
 122                 PathLen: uint8(len(path)),
 123         }
 124         copy(pkt.Path[:], path)
 125         return &pkt, nil
 126 }
 127
 128 func ctrIncr(b []byte) {
 129         for i := len(b) - 1; i >= 0; i-- {
 130                 b[i]++
 131                 if b[i] != 0 {
 132                         return
 133                 }
 134         }
 135         panic("counter overflow")
 136 }
 137
 138 func aeadProcess(
 139         aead cipher.AEAD,
 140         nonce, ad []byte,
 141         doEncrypt bool,
 142         r io.Reader,
 143         w io.Writer,
 144 ) (int, error) {
 145         ciphCtr := nonce[len(nonce)-8:]
 146         buf := make([]byte, EncBlkSize+aead.Overhead())
 147         var toRead []byte
 148         var toWrite []byte
 149         var n int
 150         var readBytes int
 151         var err error
 152         if doEncrypt {
 153                 toRead = buf[:EncBlkSize]
 154         } else {
 155                 toRead = buf
 156         }
 157         for {
 158                 n, err = io.ReadFull(r, toRead)
 159                 if err != nil {
 160                         if err == io.EOF {
 161                                 break
 162                         }
 163                         if err != io.ErrUnexpectedEOF {
 164                                 return readBytes + n, err
 165                         }
 166                 }
 167                 readBytes += n
 168                 ctrIncr(ciphCtr)
 169                 if doEncrypt {
 170                         toWrite = aead.Seal(buf[:0], nonce, buf[:n], ad)
 171                 } else {
 172                         toWrite, err = aead.Open(buf[:0], nonce, buf[:n], ad)
 173                         if err != nil {
 174                                 return readBytes, err
 175                         }
 176                 }
 177                 if _, err = w.Write(toWrite); err != nil {
 178                         return readBytes, err
 179                 }
 180         }
 181         return readBytes, nil
 182 }
 183
 184 func sizeWithTags(size int64) (fullSize int64) {
 185         fullSize = size + (size/EncBlkSize)*poly1305.TagSize
 186         if size%EncBlkSize != 0 {
 187                 fullSize += poly1305.TagSize
 188         }
 189         return
 190 }
 191
 192 func PktEncWrite(
 193         our *NodeOur,
 194         their *Node,
 195         pkt *Pkt,
 196         nice uint8,
 197         size, padSize int64,
 198         data io.Reader,
 199         out io.Writer,
 200 ) ([]byte, error) {
 201         pubEph, prvEph, err := box.GenerateKey(rand.Reader)
 202         if err != nil {
 203                 return nil, err
 204         }
 205         var pktBuf bytes.Buffer
 206         if _, err := xdr.Marshal(&pktBuf, pkt); err != nil {
 207                 return nil, err
 208         }
 209         tbs := PktTbs{
 210                 Magic:     MagicNNCPEv5.B,
 211                 Nice:      nice,
 212                 Sender:    our.Id,
 213                 Recipient: their.Id,
 214                 ExchPub:   *pubEph,
 215         }
 216         var tbsBuf bytes.Buffer
 217         if _, err = xdr.Marshal(&tbsBuf, &tbs); err != nil {
 218                 return nil, err
 219         }
 220         signature := new([ed25519.SignatureSize]byte)
 221         copy(signature[:], ed25519.Sign(our.SignPrv, tbsBuf.Bytes()))
 222         pktEnc := PktEnc{
 223                 Magic:     MagicNNCPEv5.B,
 224                 Nice:      nice,
 225                 Sender:    our.Id,
 226                 Recipient: their.Id,
 227                 ExchPub:   *pubEph,
 228                 Sign:      *signature,
 229         }
 230         ad := blake3.Sum256(tbsBuf.Bytes())
 231         tbsBuf.Reset()
 232         if _, err = xdr.Marshal(&tbsBuf, &pktEnc); err != nil {
 233                 return nil, err
 234         }
 235         pktEncRaw := tbsBuf.Bytes()
 236         if _, err = out.Write(pktEncRaw); err != nil {
 237                 return nil, err
 238         }
 239         sharedKey := new([32]byte)
 240         curve25519.ScalarMult(sharedKey, prvEph, their.ExchPub)
 241
 242         key := make([]byte, chacha20poly1305.KeySize)
 243         blake3.DeriveKey(key, string(MagicNNCPEv5.B[:]), sharedKey[:])
 244         aead, err := chacha20poly1305.New(key)
 245         if err != nil {
 246                 return nil, err
 247         }
 248         nonce := make([]byte, aead.NonceSize())
 249
 250         fullSize := pktBuf.Len() + int(size)
 251         sizeBuf := make([]byte, 8+aead.Overhead())
 252         binary.BigEndian.PutUint64(sizeBuf, uint64(sizeWithTags(int64(fullSize))))
 253         if _, err = out.Write(aead.Seal(sizeBuf[:0], nonce, sizeBuf[:8], ad[:])); err != nil {
 254                 return nil, err
 255         }
 256
 257         lr := io.LimitedReader{R: data, N: size}
 258         mr := io.MultiReader(&pktBuf, &lr)
 259         written, err := aeadProcess(aead, nonce, ad[:], true, mr, out)
 260         if err != nil {
 261                 return nil, err
 262         }
 263         if written != fullSize {
 264                 return nil, io.ErrUnexpectedEOF
 265         }
 266         if padSize > 0 {
 267                 blake3.DeriveKey(key, string(MagicNNCPEv5.B[:])+" PAD", sharedKey[:])
 268                 xof := blake3.New(32, key).XOF()
 269                 if _, err = io.CopyN(out, xof, padSize); err != nil {
 270                         return nil, err
 271                 }
 272         }
 273         return pktEncRaw, nil
 274 }
 275
 276 func TbsVerify(our *NodeOur, their *Node, pktEnc *PktEnc) ([]byte, bool, error) {
 277         tbs := PktTbs{
 278                 Magic:     MagicNNCPEv5.B,
 279                 Nice:      pktEnc.Nice,
 280                 Sender:    their.Id,
 281                 Recipient: our.Id,
 282                 ExchPub:   pktEnc.ExchPub,
 283         }
 284         var tbsBuf bytes.Buffer
 285         if _, err := xdr.Marshal(&tbsBuf, &tbs); err != nil {
 286                 return nil, false, err
 287         }
 288         return tbsBuf.Bytes(), ed25519.Verify(their.SignPub, tbsBuf.Bytes(), pktEnc.Sign[:]), nil
 289 }
 290
 291 func PktEncRead(
 292         our *NodeOur,
 293         nodes map[NodeId]*Node,
 294         data io.Reader,
 295         out io.Writer,
 296 ) (*Node, int64, error) {
 297         var pktEnc PktEnc
 298         _, err := xdr.Unmarshal(data, &pktEnc)
 299         if err != nil {
 300                 return nil, 0, err
 301         }
 302         switch pktEnc.Magic {
 303         case MagicNNCPEv1.B:
 304                 err = MagicNNCPEv1.TooOld()
 305         case MagicNNCPEv2.B:
 306                 err = MagicNNCPEv2.TooOld()
 307         case MagicNNCPEv3.B:
 308                 err = MagicNNCPEv3.TooOld()
 309         case MagicNNCPEv4.B:
 310                 err = MagicNNCPEv4.TooOld()
 311         case MagicNNCPEv5.B:
 312         default:
 313                 err = BadMagic
 314         }
 315         if err != nil {
 316                 return nil, 0, err
 317         }
 318         their, known := nodes[*pktEnc.Sender]
 319         if !known {
 320                 return nil, 0, errors.New("Unknown sender")
 321         }
 322         if *pktEnc.Recipient != *our.Id {
 323                 return nil, 0, errors.New("Invalid recipient")
 324         }
 325         tbsRaw, verified, err := TbsVerify(our, their, &pktEnc)
 326         if err != nil {
 327                 return nil, 0, err
 328         }
 329         if !verified {
 330                 return their, 0, errors.New("Invalid signature")
 331         }
 332         ad := blake3.Sum256(tbsRaw)
 333         sharedKey := new([32]byte)
 334         curve25519.ScalarMult(sharedKey, our.ExchPrv, &pktEnc.ExchPub)
 335
 336         key := make([]byte, chacha20poly1305.KeySize)
 337         blake3.DeriveKey(key, string(MagicNNCPEv5.B[:]), sharedKey[:])
 338         aead, err := chacha20poly1305.New(key)
 339         if err != nil {
 340                 return their, 0, err
 341         }
 342         nonce := make([]byte, aead.NonceSize())
 343
 344         sizeBuf := make([]byte, 8+aead.Overhead())
 345         if _, err = io.ReadFull(data, sizeBuf); err != nil {
 346                 return their, 0, err
 347         }
 348         sizeBuf, err = aead.Open(sizeBuf[:0], nonce, sizeBuf, ad[:])
 349         if err != nil {
 350                 return their, 0, err
 351         }
 352         size := int64(binary.BigEndian.Uint64(sizeBuf))
 353
 354         lr := io.LimitedReader{R: data, N: size}
 355         written, err := aeadProcess(aead, nonce, ad[:], false, &lr, out)
 356         if err != nil {
 357                 return their, int64(written), err
 358         }
 359         if written != int(size) {
 360                 return their, int64(written), io.ErrUnexpectedEOF
 361         }
 362         return their, size, nil
 363 }