mirror of
https://github.com/lunchcat/sif.git
synced 2026-06-12 11:01:24 -07:00
vmfunc
0383a7bcd2
go only returns a conn to the idle pool when the body is read to EOF before Close. the header-only and early-return scan paths closed an unread body, leaking the conn and forcing a fresh dial each request. route those close sites through httpx.DrainClose so the tuned pool from phase 1 actually gets reused. body-read paths (scanner/io.ReadAll) are left untouched.
124 lines
3.9 KiB
Go
124 lines
3.9 KiB
Go
/*
|
|
·━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━·
|
|
: :
|
|
: █▀ █ █▀▀ · Blazing-fast pentesting suite :
|
|
: ▄█ █ █▀ · BSD 3-Clause License :
|
|
: :
|
|
: (c) 2022-2026 vmfunc, xyzeva, :
|
|
: lunchcat alumni & contributors :
|
|
: :
|
|
·━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━·
|
|
*/
|
|
|
|
package scan
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
charmlog "github.com/charmbracelet/log"
|
|
"github.com/dropalldatabases/sif/internal/httpx"
|
|
"github.com/dropalldatabases/sif/internal/logger"
|
|
"github.com/dropalldatabases/sif/internal/output"
|
|
)
|
|
|
|
// gitURL is a var so integration tests can repoint it at a fixture.
|
|
var gitURL = "https://raw.githubusercontent.com/dropalldatabases/sif-runtime/main/git/"
|
|
|
|
const gitFile = "git.txt"
|
|
|
|
func Git(url string, timeout time.Duration, threads int, logdir string) ([]string, error) {
|
|
log := output.Module("GIT")
|
|
log.Start()
|
|
|
|
spin := output.NewSpinner("Scanning for exposed git repositories")
|
|
spin.Start()
|
|
|
|
sanitizedURL := stripScheme(url)
|
|
|
|
if logdir != "" {
|
|
if err := logger.WriteHeader(sanitizedURL, logdir, "git directory fuzzing"); err != nil {
|
|
spin.Stop()
|
|
log.Error("Error creating log file: %v", err)
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
client := httpx.Client(timeout)
|
|
|
|
req, err := http.NewRequestWithContext(context.TODO(), http.MethodGet, gitURL+gitFile, http.NoBody)
|
|
if err != nil {
|
|
spin.Stop()
|
|
log.Error("Error creating git list request: %s", err)
|
|
return nil, err
|
|
}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
spin.Stop()
|
|
log.Error("Error downloading git list: %s", err)
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
var gitUrls []string
|
|
scanner := bufio.NewScanner(resp.Body)
|
|
scanner.Split(bufio.ScanLines)
|
|
for scanner.Scan() {
|
|
gitUrls = append(gitUrls, scanner.Text())
|
|
}
|
|
|
|
var wg sync.WaitGroup
|
|
var mu sync.Mutex
|
|
wg.Add(threads)
|
|
|
|
foundUrls := []string{}
|
|
for thread := 0; thread < threads; thread++ {
|
|
go func(thread int) {
|
|
defer wg.Done()
|
|
|
|
for i, repourl := range gitUrls {
|
|
if i%threads != thread {
|
|
continue
|
|
}
|
|
|
|
charmlog.Debugf("%s", repourl)
|
|
gitReq, err := http.NewRequestWithContext(context.TODO(), http.MethodGet, url+"/"+repourl, http.NoBody)
|
|
if err != nil {
|
|
charmlog.Debugf("Error creating request for %s: %s", repourl, err)
|
|
continue
|
|
}
|
|
resp, err := client.Do(gitReq) //nolint:bodyclose // drained and closed via httpx.DrainClose
|
|
if err != nil {
|
|
charmlog.Debugf("Error %s: %s", repourl, err)
|
|
continue
|
|
}
|
|
|
|
if resp.StatusCode == 200 && !strings.HasPrefix(resp.Header.Get("Content-Type"), "text/html") {
|
|
spin.Stop()
|
|
log.Success("Git found at %s [%s]", output.Highlight.Render(repourl), output.Status.Render(strconv.Itoa(resp.StatusCode)))
|
|
spin.Start()
|
|
if logdir != "" {
|
|
logger.Write(sanitizedURL, logdir, strconv.Itoa(resp.StatusCode)+" git found at ["+repourl+"]\n")
|
|
}
|
|
|
|
mu.Lock()
|
|
foundUrls = append(foundUrls, resp.Request.URL.String())
|
|
mu.Unlock()
|
|
}
|
|
// status/headers only; drain so the conn returns to the pool.
|
|
httpx.DrainClose(resp)
|
|
}
|
|
}(thread)
|
|
}
|
|
wg.Wait()
|
|
|
|
spin.Stop()
|
|
log.Complete(len(foundUrls), "found")
|
|
|
|
return foundUrls, nil
|
|
}
|