Function hho

pkg/techniques.go:1029–1085

* HTTP Header Oversize */

(repResult *reportResult)

/* HTTP Header Oversize */
func hho(repResult *reportResult) {
	repetitions := []int{50, 100, 200} //4k, 8k, 16k

	msg := fmt.Sprintf("Testing now HHO with Size Limits of ~80*%d bytes\n", repetitions)
	PrintVerbose(msg, NoColor, 2)

	threads := Config.Threads
	if Config.Website.Cache.CBisHTTPMethod {
		threads = 1 // No multithreading if HTTP Method is used... Otherwise there will be a lot of false negatives/positives
		PrintVerbose("Can only scan single threaded because a HTTP Method is used as Cachebuster...\n", Yellow, 1)
	}
	sem := make(chan int, threads)
	var wg sync.WaitGroup
	wg.Add(len(repetitions))
	var m sync.Mutex

	for _, repetition := range repetitions {
		go func(repetition int) {
			defer wg.Done()
			sem <- 1
			defer func() { <-sem }() // Freigabe der Semaphore, egal was passiert. Dadurch werden Deadlocks verhindert

			limit := repetition * 8 / 100
			//msg := fmt.Sprintf("Testing now HHO with Size Limit %dk bytes\n", limit)
			//Print(msg, NoColor)

			headers := []string{}
			values := []string{}

			for i := range repetition {
				headername := fmt.Sprintf("X-Oversized-Header-%d", i+1)
				value := "Big-Value-000000000000000000000000000000000000000000000000000000000000000000000000000000"
				headers = append(headers, headername)
				values = append(values, value)
			}

			rUrl := Config.Website.Url.String()
			cb := "cb" + randInt()
			success := fmt.Sprintf("HHO DOS was successfully poisoned! cachebuster %s: %s \n%s\n", Config.Website.Cache.CBName, cb, rUrl)
			identifier := fmt.Sprintf("HHO with limit of %dk bytes", limit)
			rp := requestParams{
				repResult:  repResult,
				headers:    headers,
				values:     values,
				identifier: identifier,
				url:        rUrl,
				cb:         cb,
				success:    success,
				m:          &m,
			}

			_, _, _ = issueRequests(rp)
		}(repetition)
	}

	wg.Wait()
}