tools

var BruterExports = map[string]interface{}{
	"GetAvailableBruteTypes": func() []string {
		return bruteutils.GetBuildinAvailableBruteType()
	},
	"GetUsernameListFromBruteType": bruteutils.GetUsernameListFromBruteType,
	"GetPasswordListFromBruteType": bruteutils.GetPasswordListFromBruteType,

	"New":                _yakitBruterNew,
	"concurrentTarget":   yakBruteOpt_ConcurrentTarget,
	"debug":              yakBruteOpt_Debug,
	"userList":           yakBruteOpt_userlist,
	"passList":           yakBruteOpt_passlist,
	"autoDict":           yakBruteOpt_autoDict,
	"concurrent":         yakBruteOpt_concurrent,
	"minDelay":           yakBruteOpt_minDelay,
	"maxDelay":           yakBruteOpt_maxDelay,
	"bruteHandler":       yakBruteOpt_coreHandler,
	"okToStop":           yakBruteOpt_OkToStop,
	"finishingThreshold": yakBruteOpt_FinishingThreshold,
}

var BuildinNucleiYakScriptParam = []*ypb.YakScriptParam{
	{
		Field:        "target",
		DefaultValue: "",
		TypeVerbose:  "string",
		Required:     true,
		FieldVerbose: "扫描目标",
		Help:         "扫描目标可接受：主机名 / 主机名:端口 / IP段 / URL 等多种格式",
	},
	{
		Field:        "reverse-url",
		DefaultValue: "",
		TypeVerbose:  "string",
		FieldVerbose: "反连 URL",
		Help:         "可使用 InteractshURL 也可使用 Yakit Reverse URL",
	},
	{
		Field:        "debug",
		DefaultValue: "",
		TypeVerbose:  "boolean",
		FieldVerbose: "设置调试模式",
		Help:         "开启调试模式，调试模式将输出尽量多的调试信息",
	},
	{
		Field:        "proxy",
		DefaultValue: "",
		TypeVerbose:  "proxy",
		FieldVerbose: "HTTP 代理",
		Help:         "设置 HTTP 代理",
	},
}

var Exports = map[string]interface{}{

	"NewPocInvoker": func() (*PocInvoker, error) {
		return NewPocInvoker()
	},
	"NewBruteUtil": func(t string) (*bruteutils.BruteUtil, error) {
		res, err := bruteutils.GetBruteFuncByType(t)
		if err != nil {
			return nil, err
		}
		ut, err := bruteutils.NewMultiTargetBruteUtil(256, 1, 5, res)
		if err != nil {
			return nil, utils.Errorf("create brute utils failed: %s", err)
		}
		return ut, nil
	},
}

var FinPortScanExports = map[string]interface{}{
	"Scan": func(target string, port string, opts ...finScanOpt) (chan *finscan.FinScanResult, error) {
		config := &_yakFinPortScanConfig{
			waiting:           10 * time.Second,
			rateLimitDelayMs:  1,
			rateLimitDelayGap: 5,
		}
		for _, opt := range opts {
			opt(config)
		}
		return _finscanDo(hostsToChan(target), port, config)
	},

	"excludePorts":   _finScanOptExcludePorts,
	"excludeHosts":   _finScanOptExcludeHosts,
	"wait":           _finScanOptWaiting,
	"outputFile":     _finScanOptOpenPortResult,
	"outputPrefix":   _finScanOptOpenPortResultPrefix,
	"initHostFilter": _finScanOptOpenPortInitHostFilter,
	"initPortFilter": _finScanOptOpenPortInitPortFilter,
	"rateLimit":      _finScanOptRateLimit,
	"concurrent":     _finScanOptConcurrent,
}

var FingerprintScanExports = map[string]interface{}{
	"Scan":                scanFingerprint,
	"ScanOne":             scanOneFingerprint,
	"ScanFromSynResult":   _scanFromTargetStream,
	"ScanFromSpaceEngine": _scanFromTargetStream,
	"ScanFromPing":        _scanFromPingUtils,

	"proto": _protoOption,

	"concurrent": fp.WithPoolSize,

	"excludePorts": fp.WithExcludePorts,
	"excludeHosts": fp.WithExcludeHosts,

	"probeTimeout": fp.WithProbeTimeoutHumanRead,

	"proxy": fp.WithProxy,

	"cache":         fp.WithCache,
	"databaseCache": fp.WithDatabaseCache,

	"webRule": fp.WithWebFingerprintRule,

	"nmapRule": fp.WithNmapRule,

	"nmapRarityMax": fp.WithRarityMax,

	"active": fp.WithActiveMode,

	"maxProbes": fp.WithProbesMax,

	"maxProbesConcurrent": fp.WithProbesConcurrentMax,

	"web": _webOption,

	"service": _serviceOption,

	"all": _allOption,
}

var NucleiOperationsExports = map[string]interface{}{
	"UpdatePoC":      UpdatePoC,
	"PullDatabase":   PullTemplatesFromGithub,
	"UpdateDatabase": LoadYamlPoCDatabase,
	"RemoveDatabase": RemovePoCDatabase,
	"AllPoC":         FetchCurrentNucleiTemplates,
	"PocVulToRisk":   PocVulToRisk,
	"GetPoCDir":      consts.GetNucleiTemplatesDir,
}

var SubDomainExports = map[string]interface{}{
	"Scan": _subdomainScan,

	"wildcardToStop":   subdomain.WithWildCardToStop,
	"recursive":        subdomain.WithAllowToRecursive,
	"workerConcurrent": subdomain.WithWorkerCount,
	"dnsServer":        subdomain.WithDNSServers,
	"maxDepth":         subdomain.WithMaxDepth,
	"targetConcurrent": subdomain.WithParallelismTasksCount,
	"targetTimeout": func(i float64) subdomain.ConfigOption {
		return subdomain.WithTimeoutForEachTarget(utils.FloatSecondDuration(i))
	},
	"eachQueryTimeout": func(i float64) subdomain.ConfigOption {
		return subdomain.WithTimeoutForEachQuery(utils.FloatSecondDuration(i))
	},
	"eachSearchTimeout": func(i float64) subdomain.ConfigOption {
		return subdomain.WithTimeoutForEachHTTPSearch(utils.FloatSecondDuration(i))
	},

	"mainDict": func(i interface{}) subdomain.ConfigOption {
		return subdomain.WithMainDictionary(utils.StringAsFileParams(i))
	},

	"recursiveDict": func(i interface{}) subdomain.ConfigOption {
		return subdomain.WithSubDictionary(utils.StringAsFileParams(i))
	},
}

var SynPortScanExports = map[string]interface{}{
	"FixPermission": pcapfix.Fix,
	"Scan":          _scan,
	"ScanFromPing":  _synscanFromPingUtils,

	"callback":           _scanOptCallback,
	"submitTaskCallback": _scanOptSubmitTaskCallback,
	"excludePorts":       _scanOptExcludePorts,
	"excludeHosts":       _scanOptExcludeHosts,
	"wait":               _scanOptWaiting,
	"outputFile":         _scanOptOpenPortResult,
	"outputPrefix":       _scanOptOpenPortResultPrefix,
	"initHostFilter":     _scanOptOpenPortInitHostFilter,
	"initPortFilter":     _scanOptOpenPortInitPortFilter,
	"rateLimit":          _scanOptRateLimit,
	"concurrent":         _scanOptSYNConcurrent,
	"iface":              _scanOptIface,
}