Merge pull request #6661 from didier-durand/fix-typos-b

[Doc] Fixing typos in various files

Author: dogancanbakir

SYNTAX-REFERENCE.md

@@ -961,7 +961,7 @@ cpe: cpe:/a:vendor:product:version
 
 
 ## http.Request
-Request contains a http request to be made from a template
+Request contains an http request to be made from a template
 
 Appears in:
 

lib/multi.go

@@ -120,7 +120,7 @@ func (e *ThreadSafeNucleiEngine) GlobalResultCallback(callback func(event *outpu
 }
 
 // ExecuteNucleiWithOptsCtx executes templates on targets and calls callback on each result(only if results are found)
-// This method can be called concurrently and it will use some global resources but can be runned parallelly
+// This method can be called concurrently and it will use some global resources but can be run parallelly
 // by invoking this method with different options and targets
 // Note: Not all options are thread-safe. this method will throw error if you try to use non-thread-safe options
 func (e *ThreadSafeNucleiEngine) ExecuteNucleiWithOptsCtx(ctx context.Context, targets []string, opts ...NucleiSDKOptions) error {

pkg/catalog/loader/loader.go

@@ -185,7 +185,7 @@ func New(cfg *Config) (*Store, error) {
 	})
 
 	// Do a check to see if we have URLs in templates flag, if so
-	// we need to processs them separately and remove them from the initial list
+	// we need to process them separately and remove them from the initial list
 	var templatesFinal []string
 	for _, template := range cfg.Templates {
 		// TODO: Add and replace this with urlutil.IsURL() helper

pkg/js/CONTRIBUTE.md

@@ -67,7 +67,7 @@ Javascript Protocol Documentation is auto-generated using [jsdoc] and is hosted
 
 ### Javascript Code Guidelines
 
-1. Catch exceptions using `try/catch` blocks and handle errors gracefully, showing useful information. By default, the implementation returns a Go error on a unhandled exception along with stack trace in debug mode.
-2. Use `let`/`cost` instead of `var` to declare variables.
+1. Catch exceptions using `try/catch` blocks and handle errors gracefully, showing useful information. By default, the implementation returns a Go error on an unhandled exception along with stack trace in debug mode.
+2. Use `let`/`const` instead of `var` to declare variables.
 3. Keep the global scope clean. The VMs are not shared so do not rely on VM state.
 4. Use functions to divide the code and keep the implementation clean. 

pkg/js/compiler/pool.go

@@ -242,7 +242,7 @@ func stringify(gojaValue goja.Value, runtime *goja.Runtime) string {
 				return result.String()
 			}
 		}
-		// unlikely but if to_json throwed some error use native json.Marshal
+		// unlikely but if to_json threw some error use native json.Marshal
 		val := value
 		if kind == reflect.Ptr {
 			val = reflect.ValueOf(value).Elem().Interface()

pkg/protocols/http/http.go

@@ -506,7 +506,7 @@ func (request *Request) Compile(options *protocols.ExecutorOptions) error {
 			stats.Increment(SetThreadToCountZero)
 			request.Threads = 0
 		} else {
-			// specifically for http requests high concurrency and and threads will lead to memory exausthion, hence reduce the maximum parallelism
+			// specifically for http requests high concurrency and threads will lead to memory exhaustion, hence reduce the maximum parallelism
 			if protocolstate.IsLowOnMemory() {
 				request.Threads = protocolstate.GuardThreadsOrDefault(request.Threads)
 			}

pkg/protocols/protocols.go

@@ -213,7 +213,7 @@ func (e *ExecutorOptions) GetTemplateCtx(input *contextargs.MetaInput) *contexta
 // AddTemplateVars adds vars to template context with given template type as prefix
 // this method is no-op if template is not multi protocol
 func (e *ExecutorOptions) AddTemplateVars(input *contextargs.MetaInput, reqType templateTypes.ProtocolType, reqID string, vars map[string]interface{}) {
-	// if we wan't to disable adding response variables and other variables to template context
+	// if we want to disable adding response variables and other variables to template context
 	// this is the statement that does it . template context is currently only enabled for
 	// multiprotocol and flow templates
 	if !e.IsMultiProtocol && e.Flow == "" {

pkg/tmplexec/flow/README.md

@@ -108,13 +108,13 @@ The update template now seems straight forward and easy to understand. we are fi
 - update variables at runtime (ex: when jwt expires update it by using refresh token and then continue execution)
 - and a lot more (this is just a tip of iceberg)
 
-simply put request execution orchestration can be understood as nuclei logic bindings for javascript (i.e. two way interaction between javascript and nuclei for a specific template)
+simply put request execution orchestration can be understood as nuclei logic bindings for javascript (i.e. two-way interaction between javascript and nuclei for a specific template)
 
 To better understand orchestration we can try to build a template for vhost enumeration using flow. which usually requires writing / using a new tool
 
 **for basic vhost enumeration a template should** 
 - do a PTR lookup for given ip
-- get SSL certificate for given ip (i.e tls-grab)
+- get SSL certificate for given ip (i.e. tls-grab)
   - extract subject_cn from certificate
   - extract subject_alt_names(SAN) from certificate
   - filter out wildcard prefix from above values
@@ -164,7 +164,7 @@ http:
         dsl:
           - '"VHOST: " + vhost + ", SC: " + status_code + ", CL: " + content_length'                                                                                tarun@macbook:~/Codebase/nuclei/integration_tes
 ```
-**But this template is not yet ready as it is missing core logic i.e how we use all these obtained data and do bruteforce**
+**But this template is not yet ready as it is missing core logic i.e. how we use all these obtained data and do bruteforce**
 and this is where flow comes into picture. flow is javascript code with two way bindings to nuclei. if we write javascript code to orchestrate vhost enumeration it is as simple as
 ```javascript
   ssl();

pkg/tmplexec/flow/flow_executor_test.go

@@ -50,7 +50,7 @@ func TestFlowTemplateWithIndex(t *testing.T) {
 	Template, err := templates.Parse("testcases/nuclei-flow-dns.yaml", nil, executerOpts)
 	require.Nil(t, err, "could not parse template")
 
-	require.True(t, Template.Flow != "", "not a flow template") // this is classifer if template is flow or not
+	require.True(t, Template.Flow != "", "not a flow template") // this is classifier if template is flow or not
 
 	err = Template.Executer.Compile()
 	require.Nil(t, err, "could not compile template")
@@ -69,7 +69,7 @@ func TestFlowTemplateWithID(t *testing.T) {
 	Template, err := templates.Parse("testcases/nuclei-flow-dns-id.yaml", nil, executerOpts)
 	require.Nil(t, err, "could not parse template")
 
-	require.True(t, Template.Flow != "", "not a flow template") // this is classifer if template is flow or not
+	require.True(t, Template.Flow != "", "not a flow template") // this is classifier if template is flow or not
 
 	err = Template.Executer.Compile()
 	require.Nil(t, err, "could not compile template")
@@ -91,7 +91,7 @@ func TestFlowWithProtoPrefix(t *testing.T) {
 	Template, err := templates.Parse("testcases/nuclei-flow-dns-prefix.yaml", nil, executerOpts)
 	require.Nil(t, err, "could not parse template")
 
-	require.True(t, Template.Flow != "", "not a flow template") // this is classifer if template is flow or not
+	require.True(t, Template.Flow != "", "not a flow template") // this is classifier if template is flow or not
 
 	err = Template.Executer.Compile()
 	require.Nil(t, err, "could not compile template")
@@ -111,7 +111,7 @@ func TestFlowWithConditionNegative(t *testing.T) {
 	Template, err := templates.Parse("testcases/condition-flow.yaml", nil, executerOpts)
 	require.Nil(t, err, "could not parse template")
 
-	require.True(t, Template.Flow != "", "not a flow template") // this is classifer if template is flow or not
+	require.True(t, Template.Flow != "", "not a flow template") // this is classifier if template is flow or not
 
 	err = Template.Executer.Compile()
 	require.Nil(t, err, "could not compile template")
@@ -132,7 +132,7 @@ func TestFlowWithConditionPositive(t *testing.T) {
 	Template, err := templates.Parse("testcases/condition-flow.yaml", nil, executerOpts)
 	require.Nil(t, err, "could not parse template")
 
-	require.True(t, Template.Flow != "", "not a flow template") // this is classifer if template is flow or not
+	require.True(t, Template.Flow != "", "not a flow template") // this is classifier if template is flow or not
 
 	err = Template.Executer.Compile()
 	require.Nil(t, err, "could not compile template")
@@ -153,7 +153,7 @@ func TestFlowWithNoMatchers(t *testing.T) {
 	Template, err := templates.Parse("testcases/condition-flow-no-operators.yaml", nil, executerOpts)
 	require.Nil(t, err, "could not parse template")
 
-	require.True(t, Template.Flow != "", "not a flow template") // this is classifer if template is flow or not
+	require.True(t, Template.Flow != "", "not a flow template") // this is classifier if template is flow or not
 
 	err = Template.Executer.Compile()
 	require.Nil(t, err, "could not compile template")
@@ -169,7 +169,7 @@ func TestFlowWithNoMatchers(t *testing.T) {
 		Template, err := templates.Parse("testcases/condition-flow-extractors.yaml", nil, executerOpts)
 		require.Nil(t, err, "could not parse template")
 
-		require.True(t, Template.Flow != "", "not a flow template") // this is classifer if template is flow or not
+		require.True(t, Template.Flow != "", "not a flow template") // this is classifier if template is flow or not
 
 		err = Template.Executer.Compile()
 		require.Nil(t, err, "could not compile template")