src/cypherpunks.ru/nncp/eblob.go

   1 /*
   2 NNCP -- Node to Node copy, utilities for store-and-forward data exchange
   3 Copyright (C) 2016-2017 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         "errors"
  26         "hash"
  27         "io"
  28
  29         "chacha20"
  30         "cypherpunks.ru/balloon"
  31         "github.com/davecgh/go-xdr/xdr2"
  32         "golang.org/x/crypto/blake2b"
  33 )
  34
  35 const (
  36         DefaultS = 1 << 20 / 32
  37         DefaultT = 1 << 4
  38         DefaultP = 2
  39 )
  40
  41 var (
  42         MagicNNCPBv2 [8]byte = [8]byte{'N', 'N', 'C', 'P', 'B', 0, 0, 2}
  43 )
  44
  45 type EBlob struct {
  46         Magic [8]byte
  47         SCost uint32
  48         TCost uint32
  49         PCost uint32
  50         Salt  *[32]byte
  51         Blob  []byte
  52         MAC   *[blake2b.Size256]byte
  53 }
  54
  55 func blake256() hash.Hash {
  56         h, err := blake2b.New256(nil)
  57         if err != nil {
  58                 panic(err)
  59         }
  60         return h
  61 }
  62
  63 // Create an encrypted blob. sCost -- memory space requirements, number
  64 // of hash-output sized (32 bytes) blocks. tCost -- time requirements,
  65 // number of rounds. pCost -- number of parallel jobs.
  66 func NewEBlob(sCost, tCost, pCost int, password, data []byte) ([]byte, error) {
  67         salt := new([32]byte)
  68         var err error
  69         if _, err = rand.Read(salt[:]); err != nil {
  70                 return nil, err
  71         }
  72         key := balloon.H(blake256, password, salt[:], sCost, tCost, pCost)
  73         kdf, err := blake2b.NewXOF(32+64, key)
  74         if err != nil {
  75                 return nil, err
  76         }
  77         if _, err = kdf.Write(MagicNNCPBv2[:]); err != nil {
  78                 return nil, err
  79         }
  80         keyEnc := new([32]byte)
  81         if _, err = io.ReadFull(kdf, keyEnc[:]); err != nil {
  82                 return nil, err
  83         }
  84         keyAuth := make([]byte, 64)
  85         if _, err = io.ReadFull(kdf, keyAuth); err != nil {
  86                 return nil, err
  87         }
  88         mac, err := blake2b.New256(keyAuth)
  89         if err != nil {
  90                 return nil, err
  91         }
  92         chacha20.XORKeyStream(data, data, new([16]byte), keyEnc)
  93         if _, err = mac.Write(data); err != nil {
  94                 return nil, err
  95         }
  96         macTag := new([blake2b.Size256]byte)
  97         mac.Sum(macTag[:0])
  98         eblob := EBlob{
  99                 Magic: MagicNNCPBv2,
 100                 SCost: uint32(sCost),
 101                 TCost: uint32(tCost),
 102                 PCost: uint32(pCost),
 103                 Salt:  salt,
 104                 Blob:  data,
 105                 MAC:   macTag,
 106         }
 107         var eblobRaw bytes.Buffer
 108         if _, err = xdr.Marshal(&eblobRaw, &eblob); err != nil {
 109                 return nil, err
 110         }
 111         return eblobRaw.Bytes(), nil
 112 }
 113
 114 func DeEBlob(eblobRaw, password []byte) ([]byte, error) {
 115         var eblob EBlob
 116         var err error
 117         if _, err = xdr.Unmarshal(bytes.NewReader(eblobRaw), &eblob); err != nil {
 118                 return nil, err
 119         }
 120         if eblob.Magic != MagicNNCPBv2 {
 121                 return nil, BadMagic
 122         }
 123         key := balloon.H(
 124                 blake256,
 125                 password,
 126                 eblob.Salt[:],
 127                 int(eblob.SCost),
 128                 int(eblob.TCost),
 129                 int(eblob.PCost),
 130         )
 131         kdf, err := blake2b.NewXOF(32+64, key)
 132         if err != nil {
 133                 return nil, err
 134         }
 135         if _, err = kdf.Write(MagicNNCPBv2[:]); err != nil {
 136                 return nil, err
 137         }
 138         keyEnc := new([32]byte)
 139         if _, err = io.ReadFull(kdf, keyEnc[:]); err != nil {
 140                 return nil, err
 141         }
 142         keyAuth := make([]byte, 64)
 143         if _, err = io.ReadFull(kdf, keyAuth); err != nil {
 144                 return nil, err
 145         }
 146         mac, err := blake2b.New256(keyAuth)
 147         if err != nil {
 148                 return nil, err
 149         }
 150         if _, err = mac.Write(eblob.Blob); err != nil {
 151                 return nil, err
 152         }
 153         if subtle.ConstantTimeCompare(mac.Sum(nil), eblob.MAC[:]) != 1 {
 154                 return nil, errors.New("Unauthenticated blob")
 155         }
 156         chacha20.XORKeyStream(eblob.Blob, eblob.Blob, new([16]byte), keyEnc)
 157         return eblob.Blob, nil
 158 }