fixing cwe-338

Author: aswanidutt

child/child.go

@@ -4,11 +4,12 @@
 package child
 
 import (
+	"crypto/rand"
 	"errors"
 	"fmt"
 	"io"
 	"log"
-	"math/rand"
+	"math/big"
 	"os"
 	"os/exec"
 	"strings"
@@ -475,7 +476,14 @@ func (c *Child) randomSplay() <-chan time.Time {
 	}
 
 	ns := c.splay.Nanoseconds()
-	t := time.Duration(rand.Int63n(ns))
+	// Use crypto/rand for secure random generation (CWE-338 fix)
+	n, err := rand.Int(rand.Reader, big.NewInt(ns))
+	if err != nil {
+		// Fallback to no splay on error
+		c.logger.Printf("[WARN] (child) failed to generate random splay: %v", err)
+		return time.After(0)
+	}
+	t := time.Duration(n.Int64())
 
 	c.logger.Printf("[DEBUG] (child) waiting %.2fs for random splay", t.Seconds())
 

dependency/vault_common.go

@@ -4,10 +4,11 @@
 package dependency
 
 import (
+	"crypto/rand"
 	"encoding/json"
 	"fmt"
 	"log"
-	"math/rand"
+	"math/big"
 	"sync"
 	"time"
 
@@ -185,15 +186,16 @@ func leaseCheckWait(s *Secret, retryCount int) time.Duration {
 		sleep = sleep / 3.0
 
 		// Use some randomness so many clients do not hit Vault simultaneously.
-		sleep = sleep * (rand.Float64() + 1) / 2.0
+		randVal := secureRandomFloat64()
+		sleep = sleep * (randVal + 1) / 2.0
 	} else if !rotatingSecret {
 		// If the secret doesn't have a rotation period, this is a non-renewable leased
 		// secret.
 		// For non-renewable leases set the renew duration to use much of the secret
 		// lease as possible. Use a stagger over the configured threshold
 		// fraction of the lease duration so that many clients do not hit
 		// Vault simultaneously.
-		finalFraction := VaultLeaseRenewalThreshold + (rand.Float64()-0.5)*0.1
+		finalFraction := VaultLeaseRenewalThreshold + (secureRandomFloat64()-0.5)*0.1
 		if finalFraction >= 1.0 || finalFraction <= 0.0 {
 			// If the fraction randomly winds up outside of (0.0-1.0), clamp
 			// back down to the VaultLeaseRenewalThreshold provided by the user,
@@ -208,10 +210,26 @@ func leaseCheckWait(s *Secret, retryCount int) time.Duration {
 	return time.Duration(sleep)
 }
 
+// secureRandomFloat64 returns a cryptographically secure random float64 in [0.0, 1.0)
+func secureRandomFloat64() float64 {
+	// Generate a random 53-bit integer (mantissa precision of float64)
+	// Use crypto/rand for secure random generation (CWE-338 fix)
+
+	max := big.NewInt(1 << 53)
+	n, err := rand.Int(rand.Reader, max)
+	if err != nil {
+		// Fallback to 0.5 on error (middle of range)
+		log.Printf("[WARN] failed to generate secure random number: %v", err)
+		return 0.5
+	}
+	return float64(n.Int64()) / float64(max.Int64())
+}
+
 // jitter adds randomness to a duration to prevent thundering herd.
 // It reduces the duration by up to maxJitter (10%) randomly.
 func jitter(t time.Duration) time.Duration {
-	f := float64(t) * (1.0 - maxJitter*rand.Float64())
+	randVal := secureRandomFloat64()
+	f := float64(t) * (1.0 - maxJitter*randVal)
 	return time.Duration(f)
 }
 

watch/view.go

@@ -4,10 +4,11 @@
 package watch
 
 import (
+	"crypto/rand"
 	"errors"
 	"fmt"
 	"log"
-	"math/rand"
+	"math/big"
 	"reflect"
 	"sync"
 	"time"
@@ -311,7 +312,13 @@ const minDelayBetweenUpdates = time.Millisecond * 100
 func rateLimiter(start time.Time) time.Duration {
 	remaining := minDelayBetweenUpdates - time.Since(start)
 	if remaining > 0 {
-		dither := time.Duration(rand.Int63n(20000000)) // 0-20ms in nanoseconds
+		// Use crypto/rand for secure random generation (CWE-338 fix)
+		n, err := rand.Int(rand.Reader, big.NewInt(20000000))
+		if err != nil {
+			// Fallback to no dither on error
+			return remaining
+		}
+		dither := time.Duration(n.Int64()) // 0-20ms in nanoseconds
 		return remaining + dither
 	}
 	return 0