github.com/decred/dcrlnd@v0.7.6/fuzz/brontide/fuzz_utils.go (about)

     1  //go:build gofuzz
     2  // +build gofuzz
     3  
     4  package brontidefuzz
     5  
     6  import (
     7  	"encoding/hex"
     8  	"fmt"
     9  
    10  	"github.com/davecgh/go-spew/spew"
    11  	"github.com/decred/dcrd/dcrec/secp256k1/v4"
    12  	"github.com/decred/dcrlnd/brontide"
    13  	"github.com/decred/dcrlnd/keychain"
    14  )
    15  
    16  var (
    17  	initBytes = []byte{
    18  		0x81, 0xb6, 0x37, 0xd8, 0xfc, 0xd2, 0xc6, 0xda,
    19  		0x63, 0x59, 0xe6, 0x96, 0x31, 0x13, 0xa1, 0x17,
    20  		0xd, 0xe7, 0x95, 0xe4, 0xb7, 0x25, 0xb8, 0x4d,
    21  		0x1e, 0xb, 0x4c, 0xfd, 0x9e, 0xc5, 0x8c, 0xe9,
    22  	}
    23  
    24  	respBytes = []byte{
    25  		0xaa, 0xb6, 0x37, 0xd9, 0xfc, 0xd2, 0xc6, 0xda,
    26  		0x63, 0x59, 0xe6, 0x99, 0x31, 0x13, 0xa1, 0x17,
    27  		0xd, 0xe7, 0x95, 0xe9, 0xb7, 0x25, 0xb8, 0x4d,
    28  		0x1e, 0xb, 0x4c, 0xf9, 0x9e, 0xc5, 0x8c, 0xe9,
    29  	}
    30  
    31  	// Returns the initiator's ephemeral private key.
    32  	initEphemeral = brontide.EphemeralGenerator(func() (*secp256k1.PrivateKey, error) {
    33  		e := "121212121212121212121212121212121212121212121212121212" +
    34  			"1212121212"
    35  		eBytes, err := hex.DecodeString(e)
    36  		if err != nil {
    37  			return nil, err
    38  		}
    39  
    40  		priv := secp256k1.PrivKeyFromBytes(eBytes)
    41  		return priv, nil
    42  	})
    43  
    44  	// Returns the responder's ephemeral private key.
    45  	respEphemeral = brontide.EphemeralGenerator(func() (*secp256k1.PrivateKey, error) {
    46  		e := "222222222222222222222222222222222222222222222222222" +
    47  			"2222222222222"
    48  		eBytes, err := hex.DecodeString(e)
    49  		if err != nil {
    50  			return nil, err
    51  		}
    52  
    53  		priv := secp256k1.PrivKeyFromBytes(eBytes)
    54  		return priv, nil
    55  	})
    56  )
    57  
    58  func privKeyFromBytes(eBytes []byte) (*secp256k1.PrivateKey, *secp256k1.PublicKey) {
    59  	priv := secp256k1.PrivKeyFromBytes(eBytes)
    60  	return priv, priv.PubKey()
    61  }
    62  
    63  // completeHandshake takes two brontide machines (initiator, responder)
    64  // and completes the brontide handshake between them. If any part of the
    65  // handshake fails, this function will panic.
    66  func completeHandshake(initiator, responder *brontide.Machine) {
    67  	if err := handshake(initiator, responder); err != nil {
    68  		nilAndPanic(initiator, responder, err)
    69  	}
    70  }
    71  
    72  // handshake actually completes the brontide handshake and bubbles up
    73  // an error to the calling function.
    74  func handshake(initiator, responder *brontide.Machine) error {
    75  	// Generate ActOne and send to the responder.
    76  	actOne, err := initiator.GenActOne()
    77  	if err != nil {
    78  		return err
    79  	}
    80  
    81  	if err := responder.RecvActOne(actOne); err != nil {
    82  		return err
    83  	}
    84  
    85  	// Generate ActTwo and send to initiator.
    86  	actTwo, err := responder.GenActTwo()
    87  	if err != nil {
    88  		return err
    89  	}
    90  
    91  	if err := initiator.RecvActTwo(actTwo); err != nil {
    92  		return err
    93  	}
    94  
    95  	// Generate ActThree and send to responder.
    96  	actThree, err := initiator.GenActThree()
    97  	if err != nil {
    98  		return err
    99  	}
   100  
   101  	return responder.RecvActThree(actThree)
   102  }
   103  
   104  // nilAndPanic first nils the initiator and responder's Curve fields and then
   105  // panics.
   106  func nilAndPanic(initiator, responder *brontide.Machine, err error) {
   107  	if initiator != nil {
   108  		initiator.SetCurveToNil()
   109  	}
   110  	if responder != nil {
   111  		responder.SetCurveToNil()
   112  	}
   113  	panic(fmt.Errorf("error: %v, initiator: %v, responder: %v", err,
   114  		spew.Sdump(initiator), spew.Sdump(responder)))
   115  }
   116  
   117  // getBrontideMachines returns two brontide machines that use random keys
   118  // everywhere.
   119  func getBrontideMachines() (*brontide.Machine, *brontide.Machine) {
   120  	initPriv, _ := secp256k1.GeneratePrivateKey()
   121  	respPriv, _ := secp256k1.GeneratePrivateKey()
   122  	respPub := (*secp256k1.PublicKey)(respPriv.PubKey())
   123  
   124  	initPrivECDH := &keychain.PrivKeyECDH{PrivKey: initPriv}
   125  	respPrivECDH := &keychain.PrivKeyECDH{PrivKey: respPriv}
   126  
   127  	initiator := brontide.NewBrontideMachine(true, initPrivECDH, respPub)
   128  	responder := brontide.NewBrontideMachine(false, respPrivECDH, nil)
   129  
   130  	return initiator, responder
   131  }
   132  
   133  // getStaticBrontideMachines returns two brontide machines that use static keys
   134  // everywhere.
   135  func getStaticBrontideMachines() (*brontide.Machine, *brontide.Machine) {
   136  	initPriv := secp256k1.PrivKeyFromBytes(initBytes)
   137  	respPriv, respPub := privKeyFromBytes(respBytes)
   138  
   139  	initPrivECDH := &keychain.PrivKeyECDH{PrivKey: initPriv}
   140  	respPrivECDH := &keychain.PrivKeyECDH{PrivKey: respPriv}
   141  
   142  	initiator := brontide.NewBrontideMachine(
   143  		true, initPrivECDH, respPub, initEphemeral,
   144  	)
   145  	responder := brontide.NewBrontideMachine(
   146  		false, respPrivECDH, nil, respEphemeral,
   147  	)
   148  
   149  	return initiator, responder
   150  }