src/cypherpunks.ru/nncp/pkt.go

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