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         PktTypeMail PktType = iota
  46         PktTypeTrns PktType = iota
  47
  48         MaxPathSize = 1<<8 - 1
  49
  50         DefaultNiceMail = 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 string) (*Pkt, error) {
 125         pb := []byte(path)
 126         if len(pb) > MaxPathSize {
 127                 return nil, errors.New("Too long path")
 128         }
 129         pkt := Pkt{
 130                 Magic:   MagicNNCPPv2,
 131                 Type:    typ,
 132                 Nice:    nice,
 133                 PathLen: uint8(len(pb)),
 134                 Path:    new([MaxPathSize]byte),
 135         }
 136         copy(pkt.Path[:], pb)
 137         return &pkt, nil
 138 }
 139
 140 type DevZero struct{}
 141
 142 func (d DevZero) Read(b []byte) (n int, err error) {
 143         for n = 0; n < len(b); n++ {
 144                 b[n] = 0
 145         }
 146         return
 147 }
 148
 149 func ae(keyEnc *[32]byte, r io.Reader, w io.Writer) (int, error) {
 150         var blkCtr uint64
 151         ciphNonce := new([16]byte)
 152         ciphCtr := ciphNonce[8:]
 153         buf := make([]byte, EncBlkSize)
 154         var n int
 155         var written int
 156         var err error
 157         for {
 158                 n, err = io.ReadFull(r, buf)
 159                 if err != nil {
 160                         if err == io.EOF {
 161                                 break
 162                         }
 163                         if err != io.ErrUnexpectedEOF {
 164                                 return written + n, err
 165                         }
 166                 }
 167                 written += n
 168                 blkCtr++
 169                 binary.BigEndian.PutUint64(ciphCtr, blkCtr)
 170                 chacha20.XORKeyStream(buf[:n], buf[:n], ciphNonce, keyEnc)
 171                 if _, err = w.Write(buf[:n]); err != nil {
 172                         return written, err
 173                 }
 174         }
 175         return written, nil
 176 }
 177
 178 func PktEncWrite(our *NodeOur, their *Node, pkt *Pkt, nice uint8, size, padSize int64, data io.Reader, out io.Writer) error {
 179         pubEph, prvEph, err := box.GenerateKey(rand.Reader)
 180         if err != nil {
 181                 return err
 182         }
 183         var pktBuf bytes.Buffer
 184         if _, err := xdr.Marshal(&pktBuf, pkt); err != nil {
 185                 return err
 186         }
 187         tbs := PktTbs{
 188                 Magic:     MagicNNCPEv3,
 189                 Nice:      nice,
 190                 Sender:    our.Id,
 191                 Recipient: their.Id,
 192                 ExchPub:   pubEph,
 193         }
 194         var tbsBuf bytes.Buffer
 195         if _, err = xdr.Marshal(&tbsBuf, &tbs); err != nil {
 196                 return err
 197         }
 198         signature := new([ed25519.SignatureSize]byte)
 199         copy(signature[:], ed25519.Sign(our.SignPrv, tbsBuf.Bytes()))
 200         pktEnc := PktEnc{
 201                 Magic:     MagicNNCPEv3,
 202                 Nice:      nice,
 203                 Sender:    our.Id,
 204                 Recipient: their.Id,
 205                 ExchPub:   pubEph,
 206                 Sign:      signature,
 207         }
 208         if _, err = xdr.Marshal(out, &pktEnc); err != nil {
 209                 return err
 210         }
 211         sharedKey := new([32]byte)
 212         curve25519.ScalarMult(sharedKey, prvEph, their.ExchPub)
 213         kdf, err := blake2b.NewXOF(KDFXOFSize, sharedKey[:])
 214         if err != nil {
 215                 return err
 216         }
 217         if _, err = kdf.Write(MagicNNCPEv3[:]); err != nil {
 218                 return err
 219         }
 220
 221         keyEnc := new([32]byte)
 222         if _, err = io.ReadFull(kdf, keyEnc[:]); err != nil {
 223                 return err
 224         }
 225         keyAuth := make([]byte, 64)
 226         if _, err = io.ReadFull(kdf, keyAuth); err != nil {
 227                 return err
 228         }
 229         mac, err := blake2b.New256(keyAuth)
 230         if err != nil {
 231                 return err
 232         }
 233
 234         sizeBuf := make([]byte, 8)
 235         binary.BigEndian.PutUint64(sizeBuf, uint64(size))
 236         chacha20.XORKeyStream(sizeBuf, sizeBuf, new([16]byte), keyEnc)
 237         if _, err = out.Write(sizeBuf); err != nil {
 238                 return err
 239         }
 240         if _, err = mac.Write(sizeBuf); err != nil {
 241                 return err
 242         }
 243         if _, err = out.Write(mac.Sum(nil)); err != nil {
 244                 return err
 245         }
 246
 247         if _, err = io.ReadFull(kdf, keyEnc[:]); err != nil {
 248                 return err
 249         }
 250         if _, err = io.ReadFull(kdf, keyAuth); err != nil {
 251                 return err
 252         }
 253         mac, err = blake2b.New256(keyAuth)
 254         if err != nil {
 255                 return err
 256         }
 257         lr := io.LimitedReader{data, size}
 258         mr := io.MultiReader(&pktBuf, &lr)
 259         mw := io.MultiWriter(out, mac)
 260         fullSize := pktBuf.Len() + int(size)
 261         written, err := ae(keyEnc, mr, mw)
 262         if err != nil {
 263                 return err
 264         }
 265         if written != fullSize {
 266                 return io.ErrUnexpectedEOF
 267         }
 268         if _, err = out.Write(mac.Sum(nil)); err != nil {
 269                 return err
 270         }
 271         if padSize > 0 {
 272                 if _, err = io.ReadFull(kdf, keyEnc[:]); err != nil {
 273                         return err
 274                 }
 275                 lr = io.LimitedReader{DevZero{}, padSize}
 276                 written, err = ae(keyEnc, &lr, out)
 277                 if err != nil {
 278                         return err
 279                 }
 280                 if written != int(padSize) {
 281                         return io.ErrUnexpectedEOF
 282                 }
 283         }
 284         return nil
 285 }
 286
 287 func TbsVerify(our *NodeOur, their *Node, pktEnc *PktEnc) (bool, error) {
 288         tbs := PktTbs{
 289                 Magic:     MagicNNCPEv3,
 290                 Nice:      pktEnc.Nice,
 291                 Sender:    their.Id,
 292                 Recipient: our.Id,
 293                 ExchPub:   pktEnc.ExchPub,
 294         }
 295         var tbsBuf bytes.Buffer
 296         if _, err := xdr.Marshal(&tbsBuf, &tbs); err != nil {
 297                 return false, err
 298         }
 299         return ed25519.Verify(their.SignPub, tbsBuf.Bytes(), pktEnc.Sign[:]), nil
 300 }
 301
 302 func PktEncRead(our *NodeOur, nodes map[NodeId]*Node, data io.Reader, out io.Writer) (*Node, int64, error) {
 303         var pktEnc PktEnc
 304         _, err := xdr.Unmarshal(data, &pktEnc)
 305         if err != nil {
 306                 return nil, 0, err
 307         }
 308         if pktEnc.Magic != MagicNNCPEv3 {
 309                 return nil, 0, BadMagic
 310         }
 311         their, known := nodes[*pktEnc.Sender]
 312         if !known {
 313                 return nil, 0, errors.New("Unknown sender")
 314         }
 315         if *pktEnc.Recipient != *our.Id {
 316                 return nil, 0, errors.New("Invalid recipient")
 317         }
 318         verified, err := TbsVerify(our, their, &pktEnc)
 319         if err != nil {
 320                 return nil, 0, err
 321         }
 322         if !verified {
 323                 return their, 0, errors.New("Invalid signature")
 324         }
 325         sharedKey := new([32]byte)
 326         curve25519.ScalarMult(sharedKey, our.ExchPrv, pktEnc.ExchPub)
 327         kdf, err := blake2b.NewXOF(KDFXOFSize, sharedKey[:])
 328         if err != nil {
 329                 return their, 0, err
 330         }
 331         if _, err = kdf.Write(MagicNNCPEv3[:]); err != nil {
 332                 return their, 0, err
 333         }
 334
 335         keyEnc := new([32]byte)
 336         if _, err = io.ReadFull(kdf, keyEnc[:]); err != nil {
 337                 return their, 0, err
 338         }
 339         keyAuth := make([]byte, 64)
 340         if _, err = io.ReadFull(kdf, keyAuth); err != nil {
 341                 return their, 0, err
 342         }
 343         mac, err := blake2b.New256(keyAuth)
 344         if err != nil {
 345                 return their, 0, err
 346         }
 347
 348         sizeBuf := make([]byte, 8)
 349         if _, err = io.ReadFull(data, sizeBuf); err != nil {
 350                 return their, 0, err
 351         }
 352         if _, err = mac.Write(sizeBuf); err != nil {
 353                 return their, 0, err
 354         }
 355         tag := make([]byte, blake2b.Size256)
 356         if _, err = io.ReadFull(data, tag); err != nil {
 357                 return their, 0, err
 358         }
 359         if subtle.ConstantTimeCompare(mac.Sum(nil), tag) != 1 {
 360                 return their, 0, errors.New("Unauthenticated size")
 361         }
 362         chacha20.XORKeyStream(sizeBuf, sizeBuf, new([16]byte), keyEnc)
 363         size := int64(binary.BigEndian.Uint64(sizeBuf))
 364
 365         if _, err = io.ReadFull(kdf, keyEnc[:]); err != nil {
 366                 return their, size, err
 367         }
 368         if _, err = io.ReadFull(kdf, keyAuth); err != nil {
 369                 return their, size, err
 370         }
 371         mac, err = blake2b.New256(keyAuth)
 372         if err != nil {
 373                 return their, 0, err
 374         }
 375
 376         fullSize := PktOverhead + size - 8 - 2*blake2b.Size256
 377         lr := io.LimitedReader{data, fullSize}
 378         tr := io.TeeReader(&lr, mac)
 379         written, err := ae(keyEnc, tr, out)
 380         if err != nil {
 381                 return their, int64(written), err
 382         }
 383         if written != int(fullSize) {
 384                 return their, int64(written), io.ErrUnexpectedEOF
 385         }
 386         if _, err = io.ReadFull(data, tag); err != nil {
 387                 return their, size, err
 388         }
 389         if subtle.ConstantTimeCompare(mac.Sum(nil), tag) != 1 {
 390                 return their, size, errors.New("Unauthenticated payload")
 391         }
 392         return their, size, nil
 393 }