Run gofmt -s -w .

src/yggdrasil/crypto.go

@@ -28,20 +28,22 @@ type TreeID [TreeIDLen]byte
 type handle [handleLen]byte
 
 func getNodeID(pub *boxPubKey) *NodeID {
-  h := sha512.Sum512(pub[:])
-  return (*NodeID)(&h)
+	h := sha512.Sum512(pub[:])
+	return (*NodeID)(&h)
 }
 
 func getTreeID(pub *sigPubKey) *TreeID {
-  h := sha512.Sum512(pub[:])
-  return (*TreeID)(&h)
+	h := sha512.Sum512(pub[:])
+	return (*TreeID)(&h)
 }
 
 func newHandle() *handle {
-  var h handle
-  _, err := rand.Read(h[:])
-  if err != nil { panic(err) }
-  return &h
+	var h handle
+	_, err := rand.Read(h[:])
+	if err != nil {
+		panic(err)
+	}
+	return &h
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -57,26 +59,28 @@ type sigPrivKey [sigPrivKeyLen]byte
 type sigBytes [sigLen]byte
 
 func newSigKeys() (*sigPubKey, *sigPrivKey) {
-  var pub sigPubKey
-  var priv sigPrivKey
-  pubSlice, privSlice, err := ed25519.GenerateKey(rand.Reader)
-  if err != nil { panic(err) }
-  copy(pub[:], pubSlice)
-  copy(priv[:], privSlice)
-  return &pub, &priv
+	var pub sigPubKey
+	var priv sigPrivKey
+	pubSlice, privSlice, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		panic(err)
+	}
+	copy(pub[:], pubSlice)
+	copy(priv[:], privSlice)
+	return &pub, &priv
 }
 
 func sign(priv *sigPrivKey, msg []byte) *sigBytes {
-  var sig sigBytes
-  sigSlice := ed25519.Sign(priv[:], msg)
-  copy(sig[:], sigSlice)
-  return &sig
+	var sig sigBytes
+	sigSlice := ed25519.Sign(priv[:], msg)
+	copy(sig[:], sigSlice)
+	return &sig
 }
 
 func verify(pub *sigPubKey, msg []byte, sig *sigBytes) bool {
-  // Should sig be an array instead of a slice?...
-  // It's fixed size, but 
-  return ed25519.Verify(pub[:], msg, sig[:])
+	// Should sig be an array instead of a slice?...
+	// It's fixed size, but
+	return ed25519.Verify(pub[:], msg, sig[:])
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -94,61 +98,68 @@ type boxSharedKey [boxSharedKeyLen]byte
 type boxNonce [boxNonceLen]byte
 
 func newBoxKeys() (*boxPubKey, *boxPrivKey) {
-  pubBytes, privBytes, err := box.GenerateKey(rand.Reader)
-  if err != nil { panic(err) }
-  pub := (*boxPubKey)(pubBytes)
-  priv := (*boxPrivKey)(privBytes)
-  return pub, priv
+	pubBytes, privBytes, err := box.GenerateKey(rand.Reader)
+	if err != nil {
+		panic(err)
+	}
+	pub := (*boxPubKey)(pubBytes)
+	priv := (*boxPrivKey)(privBytes)
+	return pub, priv
 }
 
 func getSharedKey(myPrivKey *boxPrivKey,
-                  othersPubKey *boxPubKey) *boxSharedKey {
-  var shared [boxSharedKeyLen]byte
-  priv := (*[boxPrivKeyLen]byte)(myPrivKey)
-  pub := (*[boxPubKeyLen]byte)(othersPubKey)
-  box.Precompute(&shared, pub, priv)
-  return (*boxSharedKey)(&shared)
+	othersPubKey *boxPubKey) *boxSharedKey {
+	var shared [boxSharedKeyLen]byte
+	priv := (*[boxPrivKeyLen]byte)(myPrivKey)
+	pub := (*[boxPubKeyLen]byte)(othersPubKey)
+	box.Precompute(&shared, pub, priv)
+	return (*boxSharedKey)(&shared)
 }
 
 func boxOpen(shared *boxSharedKey,
-             boxed []byte,
-             nonce *boxNonce) ([]byte, bool) {
-  out := util_getBytes()
-  //return append(out, boxed...), true // XXX HACK to test without encryption
-  s := (*[boxSharedKeyLen]byte)(shared)
-  n := (*[boxNonceLen]byte)(nonce)
-  unboxed, success := box.OpenAfterPrecomputation(out, boxed, n, s)
-  return unboxed, success
+	boxed []byte,
+	nonce *boxNonce) ([]byte, bool) {
+	out := util_getBytes()
+	//return append(out, boxed...), true // XXX HACK to test without encryption
+	s := (*[boxSharedKeyLen]byte)(shared)
+	n := (*[boxNonceLen]byte)(nonce)
+	unboxed, success := box.OpenAfterPrecomputation(out, boxed, n, s)
+	return unboxed, success
 }
 
 func boxSeal(shared *boxSharedKey, unboxed []byte, nonce *boxNonce) ([]byte, *boxNonce) {
-  if nonce == nil { nonce = newBoxNonce() }
-  nonce.update()
-  out := util_getBytes()
-  //return append(out, unboxed...), nonce // XXX HACK to test without encryption
-  s := (*[boxSharedKeyLen]byte)(shared)
-  n := (*[boxNonceLen]byte)(nonce)
-  boxed := box.SealAfterPrecomputation(out, unboxed, n, s)
-  return boxed, nonce
+	if nonce == nil {
+		nonce = newBoxNonce()
+	}
+	nonce.update()
+	out := util_getBytes()
+	//return append(out, unboxed...), nonce // XXX HACK to test without encryption
+	s := (*[boxSharedKeyLen]byte)(shared)
+	n := (*[boxNonceLen]byte)(nonce)
+	boxed := box.SealAfterPrecomputation(out, unboxed, n, s)
+	return boxed, nonce
 }
 
 func newBoxNonce() *boxNonce {
-  var nonce boxNonce
-  _, err := rand.Read(nonce[:])
-  for ; err == nil && nonce[0] == 0xff ; _, err = rand.Read(nonce[:]){
-    // Make sure nonce isn't too high
-    // This is just to make rollover unlikely to happen
-    // Rollover is fine, but it may kill the session and force it to reopen
-  }
-  if err != nil { panic(err) }
-  return &nonce
+	var nonce boxNonce
+	_, err := rand.Read(nonce[:])
+	for ; err == nil && nonce[0] == 0xff; _, err = rand.Read(nonce[:]) {
+		// Make sure nonce isn't too high
+		// This is just to make rollover unlikely to happen
+		// Rollover is fine, but it may kill the session and force it to reopen
+	}
+	if err != nil {
+		panic(err)
+	}
+	return &nonce
 }
 
 func (n *boxNonce) update() {
-  oldNonce := *n
-  n[len(n)-1] += 2
-  for i := len(n)-2 ; i >= 0 ; i-- {
-    if n[i+1] < oldNonce[i+1] { n[i] += 1 }
-  }
+	oldNonce := *n
+	n[len(n)-1] += 2
+	for i := len(n) - 2; i >= 0; i-- {
+		if n[i+1] < oldNonce[i+1] {
+			n[i] += 1
+		}
+	}
 }
-