+Ask provides a simple way of accessing nested properties in maps and slices. Works great in combination with encoding/json and other packages that "Unmarshal" arbitrary data into Go data-types. Inspired by the get function in the lodash javascript library.
+
+## Use
+
+```go
+package main
+
+import "json"
+import "github.com/simonnilsson/ask"
+
+func main() {
+
+ // Use parsed JSON as source data
+ var object map[string]interface{}
+ json.Unmarshal([]byte(`{ "a": [{ "b": { "c": 3 } }] }`), &object)
+
+ // Extract the 3
+ res, ok := ask.For(object, "a[0].b.c").Int(0)
+
+ fmt.Println(res, ok)
+ // Output: 3 true
+
+ // Attempt extracting a string at path .d that does not exist
+ res2, ok := ask.For(object, "a[0].b.d").String("nothing")
+
+ fmt.Println(res2, ok)
+ // Output: nothing false
+
+}
+```
+
+## API
+
+Internally ask uses type assertions to traverse down the path supplied. Each invocation starts by calling For() with your data structure **source** and the **path** in this structure to extract.
+
+```go
+For(source interface{}, path string) *Answer
+```
+Additional paths can be traversed by calling Path() on the resulting answer.
+```go
+(a *Answer) Path(path string) *Answer
+```
+
+
+
+### Type assertion
+
+After receiving an `*Answer` from a call to For() it can be asserted to a type. The methods for this is seen below. Each function takes a default value as a parameter that will be returned in case the value can not be asserted from the answer. A second return value is used to indicate if the assertion was successful.
+
+* `String(d string) (string, bool)`
+* `Bool(d bool) (bool, bool)`
+* `Int(d int64) (int64, bool)`
+* `Uint(d uint64) (uint64, bool)`
+* `Float(d float64) (float64, bool)`
+* `Slice(d []interface{}) ([]interface{}, bool)`
+* `Map(d map[string]interface{}) (map[string]interface{}, bool)`
+
+If a number is found but it is of different type than requested it will be casted to desired type and return success. If the value would not fit within the valid range of requested type the operation will fail however and the default parameter will be returned instead.
+
+Two additional methods are available, one to check if the answer has a value (not nil) and one to return the raw value as a interface{}.
+
+* `Exists() bool`
+* `Value() interface{}`
+
+For full documentation see [pkg.go.dev](https://pkg.go.dev/github.com/simonnilsson/ask).
+
+## License
+
+[MIT](LICENSE)
\ No newline at end of file
diff --git a/vendor/github.com/simonnilsson/ask/ask.go b/vendor/github.com/simonnilsson/ask/ask.go
new file mode 100644
index 000000000..dc32d37b8
--- /dev/null
+++ b/vendor/github.com/simonnilsson/ask/ask.go
@@ -0,0 +1,174 @@
+// Package ask provides a simple way of accessing nested properties in maps and arrays.
+// Works great in combination with encoding/json and other packages that "Unmarshal" arbitrary data into Go data-types.
+// Inspired by the get function in the lodash javascript library.
+package ask
+
+import (
+ "math"
+ "reflect"
+ "regexp"
+ "strconv"
+ "strings"
+)
+
+var tokenMatcher = regexp.MustCompile("([^[]+)?(?:\\[(\\d+)])?")
+
+// Answer holds result of call to For, use one of its methods to extract a value.
+type Answer struct {
+ value interface{}
+}
+
+// For is used to select a path from source to return as answer.
+func For(source interface{}, path string) *Answer {
+
+ parts := strings.Split(path, ".")
+
+ current := source
+
+ for _, part := range parts {
+
+ match := tokenMatcher.FindStringSubmatch(strings.TrimSpace(part))
+
+ if len(match) == 3 {
+
+ if match[1] != "" {
+ m, ok := current.(map[string]interface{})
+ if !ok {
+ return &Answer{}
+ }
+ current = m[match[1]]
+ }
+
+ if match[2] != "" {
+ index, _ := strconv.Atoi(match[2])
+ a, ok := current.([]interface{})
+ if !ok || index < 0 || len(a) <= index {
+ return &Answer{}
+ }
+ current = a[index]
+ }
+
+ }
+
+ }
+
+ return &Answer{value: current}
+}
+
+// Path does the same thing as For but uses existing answer as source.
+func (a *Answer) Path(path string) *Answer {
+ return For(a.value, path)
+}
+
+// Exists returns a boolean indicating if the answer exists (not nil).
+func (a *Answer) Exists() bool {
+ return a.value != nil
+}
+
+// Value returns the raw value as type interface{}, can be nil if no value is available.
+func (a *Answer) Value() interface{} {
+ return a.value
+}
+
+// Slice attempts asserting answer as a []interface{}.
+// The first return value is the result, and the second indicates if the operation was successful.
+// If not successful the first return value will be set to the d parameter.
+func (a *Answer) Slice(d []interface{}) ([]interface{}, bool) {
+ res, ok := a.value.([]interface{})
+ if ok {
+ return res, ok
+ }
+ return d, false
+}
+
+// Map attempts asserting answer as a map[string]interface{}.
+// The first return value is the result, and the second indicates if the operation was successful.
+// If not successful the first return value will be set to the d parameter.
+func (a *Answer) Map(d map[string]interface{}) (map[string]interface{}, bool) {
+ res, ok := a.value.(map[string]interface{})
+ if ok {
+ return res, ok
+ }
+ return d, false
+}
+
+// String attempts asserting answer as a string.
+// The first return value is the result, and the second indicates if the operation was successful.
+// If not successful the first return value will be set to the d parameter.
+func (a *Answer) String(d string) (string, bool) {
+ res, ok := a.value.(string)
+ if ok {
+ return res, ok
+ }
+ return d, false
+}
+
+// Bool attempts asserting answer as a bool.
+// The first return value is the result, and the second indicates if the operation was successful.
+// If not successful the first return value will be set to the d parameter.
+func (a *Answer) Bool(d bool) (bool, bool) {
+ res, ok := a.value.(bool)
+ if ok {
+ return res, ok
+ }
+ return d, false
+}
+
+// Int attempts asserting answer as a int64. Casting from other number types will be done if necessary.
+// The first return value is the result, and the second indicates if the operation was successful.
+// If not successful the first return value will be set to the d parameter.
+func (a *Answer) Int(d int64) (int64, bool) {
+ switch vt := a.value.(type) {
+ case int, int8, int16, int32, int64:
+ return reflect.ValueOf(vt).Int(), true
+ case uint, uint8, uint16, uint32, uint64:
+ val := reflect.ValueOf(vt).Uint()
+ if val <= math.MaxInt64 {
+ return int64(val), true
+ }
+ case float32, float64:
+ val := reflect.ValueOf(vt).Float()
+ if val >= 0 && val <= math.MaxInt64 {
+ return int64(val), true
+ }
+ }
+ return d, false
+}
+
+// Uint attempts asserting answer as a uint64. Casting from other number types will be done if necessary.
+// The first return value is the result, and the second indicates if the operation was successful.
+// If not successful the first return value will be set to the d parameter.
+func (a *Answer) Uint(d uint64) (uint64, bool) {
+ switch vt := a.value.(type) {
+ case int, int8, int16, int32, int64:
+ val := reflect.ValueOf(vt).Int()
+ if val >= 0 {
+ return uint64(val), true
+ }
+ case uint, uint8, uint16, uint32, uint64:
+ return reflect.ValueOf(vt).Uint(), true
+ case float32, float64:
+ val := reflect.ValueOf(vt).Float()
+ if val >= 0 && val <= math.MaxUint64 {
+ return uint64(val), true
+ }
+ }
+ return d, false
+}
+
+// Float attempts asserting answer as a float64. Casting from other number types will be done if necessary.
+// The first return value is the result, and the second indicates if the operation was successful.
+// If not successful the first return value will be set to the d parameter.
+func (a *Answer) Float(d float64) (float64, bool) {
+ switch vt := a.value.(type) {
+ case int, int8, int16, int32, int64:
+ return float64(reflect.ValueOf(vt).Int()), true
+ case uint, uint8, uint16, uint32, uint64:
+ return float64(reflect.ValueOf(vt).Uint()), true
+ case float32:
+ return float64(vt), true
+ case float64:
+ return vt, true
+ }
+ return d, false
+}
diff --git a/vendor/github.com/simonnilsson/ask/logo.eps b/vendor/github.com/simonnilsson/ask/logo.eps
new file mode 100644
index 000000000..1a6f0db81
Binary files /dev/null and b/vendor/github.com/simonnilsson/ask/logo.eps differ
diff --git a/vendor/github.com/simonnilsson/ask/logo.svg b/vendor/github.com/simonnilsson/ask/logo.svg
new file mode 100644
index 000000000..1b41eacb6
--- /dev/null
+++ b/vendor/github.com/simonnilsson/ask/logo.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/vendor/golang.org/x/sys/windows/registry/key.go b/vendor/golang.org/x/sys/windows/registry/key.go
new file mode 100644
index 000000000..6c8d97b6a
--- /dev/null
+++ b/vendor/golang.org/x/sys/windows/registry/key.go
@@ -0,0 +1,206 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build windows
+// +build windows
+
+// Package registry provides access to the Windows registry.
+//
+// Here is a simple example, opening a registry key and reading a string value from it.
+//
+// k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion`, registry.QUERY_VALUE)
+// if err != nil {
+// log.Fatal(err)
+// }
+// defer k.Close()
+//
+// s, _, err := k.GetStringValue("SystemRoot")
+// if err != nil {
+// log.Fatal(err)
+// }
+// fmt.Printf("Windows system root is %q\n", s)
+package registry
+
+import (
+ "io"
+ "runtime"
+ "syscall"
+ "time"
+)
+
+const (
+ // Registry key security and access rights.
+ // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms724878.aspx
+ // for details.
+ ALL_ACCESS = 0xf003f
+ CREATE_LINK = 0x00020
+ CREATE_SUB_KEY = 0x00004
+ ENUMERATE_SUB_KEYS = 0x00008
+ EXECUTE = 0x20019
+ NOTIFY = 0x00010
+ QUERY_VALUE = 0x00001
+ READ = 0x20019
+ SET_VALUE = 0x00002
+ WOW64_32KEY = 0x00200
+ WOW64_64KEY = 0x00100
+ WRITE = 0x20006
+)
+
+// Key is a handle to an open Windows registry key.
+// Keys can be obtained by calling OpenKey; there are
+// also some predefined root keys such as CURRENT_USER.
+// Keys can be used directly in the Windows API.
+type Key syscall.Handle
+
+const (
+ // Windows defines some predefined root keys that are always open.
+ // An application can use these keys as entry points to the registry.
+ // Normally these keys are used in OpenKey to open new keys,
+ // but they can also be used anywhere a Key is required.
+ CLASSES_ROOT = Key(syscall.HKEY_CLASSES_ROOT)
+ CURRENT_USER = Key(syscall.HKEY_CURRENT_USER)
+ LOCAL_MACHINE = Key(syscall.HKEY_LOCAL_MACHINE)
+ USERS = Key(syscall.HKEY_USERS)
+ CURRENT_CONFIG = Key(syscall.HKEY_CURRENT_CONFIG)
+ PERFORMANCE_DATA = Key(syscall.HKEY_PERFORMANCE_DATA)
+)
+
+// Close closes open key k.
+func (k Key) Close() error {
+ return syscall.RegCloseKey(syscall.Handle(k))
+}
+
+// OpenKey opens a new key with path name relative to key k.
+// It accepts any open key, including CURRENT_USER and others,
+// and returns the new key and an error.
+// The access parameter specifies desired access rights to the
+// key to be opened.
+func OpenKey(k Key, path string, access uint32) (Key, error) {
+ p, err := syscall.UTF16PtrFromString(path)
+ if err != nil {
+ return 0, err
+ }
+ var subkey syscall.Handle
+ err = syscall.RegOpenKeyEx(syscall.Handle(k), p, 0, access, &subkey)
+ if err != nil {
+ return 0, err
+ }
+ return Key(subkey), nil
+}
+
+// OpenRemoteKey opens a predefined registry key on another
+// computer pcname. The key to be opened is specified by k, but
+// can only be one of LOCAL_MACHINE, PERFORMANCE_DATA or USERS.
+// If pcname is "", OpenRemoteKey returns local computer key.
+func OpenRemoteKey(pcname string, k Key) (Key, error) {
+ var err error
+ var p *uint16
+ if pcname != "" {
+ p, err = syscall.UTF16PtrFromString(`\\` + pcname)
+ if err != nil {
+ return 0, err
+ }
+ }
+ var remoteKey syscall.Handle
+ err = regConnectRegistry(p, syscall.Handle(k), &remoteKey)
+ if err != nil {
+ return 0, err
+ }
+ return Key(remoteKey), nil
+}
+
+// ReadSubKeyNames returns the names of subkeys of key k.
+// The parameter n controls the number of returned names,
+// analogous to the way os.File.Readdirnames works.
+func (k Key) ReadSubKeyNames(n int) ([]string, error) {
+ // RegEnumKeyEx must be called repeatedly and to completion.
+ // During this time, this goroutine cannot migrate away from
+ // its current thread. See https://golang.org/issue/49320 and
+ // https://golang.org/issue/49466.
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ names := make([]string, 0)
+ // Registry key size limit is 255 bytes and described there:
+ // https://msdn.microsoft.com/library/windows/desktop/ms724872.aspx
+ buf := make([]uint16, 256) //plus extra room for terminating zero byte
+loopItems:
+ for i := uint32(0); ; i++ {
+ if n > 0 {
+ if len(names) == n {
+ return names, nil
+ }
+ }
+ l := uint32(len(buf))
+ for {
+ err := syscall.RegEnumKeyEx(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)
+ if err == nil {
+ break
+ }
+ if err == syscall.ERROR_MORE_DATA {
+ // Double buffer size and try again.
+ l = uint32(2 * len(buf))
+ buf = make([]uint16, l)
+ continue
+ }
+ if err == _ERROR_NO_MORE_ITEMS {
+ break loopItems
+ }
+ return names, err
+ }
+ names = append(names, syscall.UTF16ToString(buf[:l]))
+ }
+ if n > len(names) {
+ return names, io.EOF
+ }
+ return names, nil
+}
+
+// CreateKey creates a key named path under open key k.
+// CreateKey returns the new key and a boolean flag that reports
+// whether the key already existed.
+// The access parameter specifies the access rights for the key
+// to be created.
+func CreateKey(k Key, path string, access uint32) (newk Key, openedExisting bool, err error) {
+ var h syscall.Handle
+ var d uint32
+ err = regCreateKeyEx(syscall.Handle(k), syscall.StringToUTF16Ptr(path),
+ 0, nil, _REG_OPTION_NON_VOLATILE, access, nil, &h, &d)
+ if err != nil {
+ return 0, false, err
+ }
+ return Key(h), d == _REG_OPENED_EXISTING_KEY, nil
+}
+
+// DeleteKey deletes the subkey path of key k and its values.
+func DeleteKey(k Key, path string) error {
+ return regDeleteKey(syscall.Handle(k), syscall.StringToUTF16Ptr(path))
+}
+
+// A KeyInfo describes the statistics of a key. It is returned by Stat.
+type KeyInfo struct {
+ SubKeyCount uint32
+ MaxSubKeyLen uint32 // size of the key's subkey with the longest name, in Unicode characters, not including the terminating zero byte
+ ValueCount uint32
+ MaxValueNameLen uint32 // size of the key's longest value name, in Unicode characters, not including the terminating zero byte
+ MaxValueLen uint32 // longest data component among the key's values, in bytes
+ lastWriteTime syscall.Filetime
+}
+
+// ModTime returns the key's last write time.
+func (ki *KeyInfo) ModTime() time.Time {
+ return time.Unix(0, ki.lastWriteTime.Nanoseconds())
+}
+
+// Stat retrieves information about the open key k.
+func (k Key) Stat() (*KeyInfo, error) {
+ var ki KeyInfo
+ err := syscall.RegQueryInfoKey(syscall.Handle(k), nil, nil, nil,
+ &ki.SubKeyCount, &ki.MaxSubKeyLen, nil, &ki.ValueCount,
+ &ki.MaxValueNameLen, &ki.MaxValueLen, nil, &ki.lastWriteTime)
+ if err != nil {
+ return nil, err
+ }
+ return &ki, nil
+}
diff --git a/vendor/golang.org/x/sys/windows/registry/mksyscall.go b/vendor/golang.org/x/sys/windows/registry/mksyscall.go
new file mode 100644
index 000000000..ee74927d3
--- /dev/null
+++ b/vendor/golang.org/x/sys/windows/registry/mksyscall.go
@@ -0,0 +1,10 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build generate
+// +build generate
+
+package registry
+
+//go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go syscall.go
diff --git a/vendor/golang.org/x/sys/windows/registry/syscall.go b/vendor/golang.org/x/sys/windows/registry/syscall.go
new file mode 100644
index 000000000..417335123
--- /dev/null
+++ b/vendor/golang.org/x/sys/windows/registry/syscall.go
@@ -0,0 +1,33 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build windows
+// +build windows
+
+package registry
+
+import "syscall"
+
+const (
+ _REG_OPTION_NON_VOLATILE = 0
+
+ _REG_CREATED_NEW_KEY = 1
+ _REG_OPENED_EXISTING_KEY = 2
+
+ _ERROR_NO_MORE_ITEMS syscall.Errno = 259
+)
+
+func LoadRegLoadMUIString() error {
+ return procRegLoadMUIStringW.Find()
+}
+
+//sys regCreateKeyEx(key syscall.Handle, subkey *uint16, reserved uint32, class *uint16, options uint32, desired uint32, sa *syscall.SecurityAttributes, result *syscall.Handle, disposition *uint32) (regerrno error) = advapi32.RegCreateKeyExW
+//sys regDeleteKey(key syscall.Handle, subkey *uint16) (regerrno error) = advapi32.RegDeleteKeyW
+//sys regSetValueEx(key syscall.Handle, valueName *uint16, reserved uint32, vtype uint32, buf *byte, bufsize uint32) (regerrno error) = advapi32.RegSetValueExW
+//sys regEnumValue(key syscall.Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) = advapi32.RegEnumValueW
+//sys regDeleteValue(key syscall.Handle, name *uint16) (regerrno error) = advapi32.RegDeleteValueW
+//sys regLoadMUIString(key syscall.Handle, name *uint16, buf *uint16, buflen uint32, buflenCopied *uint32, flags uint32, dir *uint16) (regerrno error) = advapi32.RegLoadMUIStringW
+//sys regConnectRegistry(machinename *uint16, key syscall.Handle, result *syscall.Handle) (regerrno error) = advapi32.RegConnectRegistryW
+
+//sys expandEnvironmentStrings(src *uint16, dst *uint16, size uint32) (n uint32, err error) = kernel32.ExpandEnvironmentStringsW
diff --git a/vendor/golang.org/x/sys/windows/registry/value.go b/vendor/golang.org/x/sys/windows/registry/value.go
new file mode 100644
index 000000000..2789f6f18
--- /dev/null
+++ b/vendor/golang.org/x/sys/windows/registry/value.go
@@ -0,0 +1,387 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build windows
+// +build windows
+
+package registry
+
+import (
+ "errors"
+ "io"
+ "syscall"
+ "unicode/utf16"
+ "unsafe"
+)
+
+const (
+ // Registry value types.
+ NONE = 0
+ SZ = 1
+ EXPAND_SZ = 2
+ BINARY = 3
+ DWORD = 4
+ DWORD_BIG_ENDIAN = 5
+ LINK = 6
+ MULTI_SZ = 7
+ RESOURCE_LIST = 8
+ FULL_RESOURCE_DESCRIPTOR = 9
+ RESOURCE_REQUIREMENTS_LIST = 10
+ QWORD = 11
+)
+
+var (
+ // ErrShortBuffer is returned when the buffer was too short for the operation.
+ ErrShortBuffer = syscall.ERROR_MORE_DATA
+
+ // ErrNotExist is returned when a registry key or value does not exist.
+ ErrNotExist = syscall.ERROR_FILE_NOT_FOUND
+
+ // ErrUnexpectedType is returned by Get*Value when the value's type was unexpected.
+ ErrUnexpectedType = errors.New("unexpected key value type")
+)
+
+// GetValue retrieves the type and data for the specified value associated
+// with an open key k. It fills up buffer buf and returns the retrieved
+// byte count n. If buf is too small to fit the stored value it returns
+// ErrShortBuffer error along with the required buffer size n.
+// If no buffer is provided, it returns true and actual buffer size n.
+// If no buffer is provided, GetValue returns the value's type only.
+// If the value does not exist, the error returned is ErrNotExist.
+//
+// GetValue is a low level function. If value's type is known, use the appropriate
+// Get*Value function instead.
+func (k Key) GetValue(name string, buf []byte) (n int, valtype uint32, err error) {
+ pname, err := syscall.UTF16PtrFromString(name)
+ if err != nil {
+ return 0, 0, err
+ }
+ var pbuf *byte
+ if len(buf) > 0 {
+ pbuf = (*byte)(unsafe.Pointer(&buf[0]))
+ }
+ l := uint32(len(buf))
+ err = syscall.RegQueryValueEx(syscall.Handle(k), pname, nil, &valtype, pbuf, &l)
+ if err != nil {
+ return int(l), valtype, err
+ }
+ return int(l), valtype, nil
+}
+
+func (k Key) getValue(name string, buf []byte) (data []byte, valtype uint32, err error) {
+ p, err := syscall.UTF16PtrFromString(name)
+ if err != nil {
+ return nil, 0, err
+ }
+ var t uint32
+ n := uint32(len(buf))
+ for {
+ err = syscall.RegQueryValueEx(syscall.Handle(k), p, nil, &t, (*byte)(unsafe.Pointer(&buf[0])), &n)
+ if err == nil {
+ return buf[:n], t, nil
+ }
+ if err != syscall.ERROR_MORE_DATA {
+ return nil, 0, err
+ }
+ if n <= uint32(len(buf)) {
+ return nil, 0, err
+ }
+ buf = make([]byte, n)
+ }
+}
+
+// GetStringValue retrieves the string value for the specified
+// value name associated with an open key k. It also returns the value's type.
+// If value does not exist, GetStringValue returns ErrNotExist.
+// If value is not SZ or EXPAND_SZ, it will return the correct value
+// type and ErrUnexpectedType.
+func (k Key) GetStringValue(name string) (val string, valtype uint32, err error) {
+ data, typ, err2 := k.getValue(name, make([]byte, 64))
+ if err2 != nil {
+ return "", typ, err2
+ }
+ switch typ {
+ case SZ, EXPAND_SZ:
+ default:
+ return "", typ, ErrUnexpectedType
+ }
+ if len(data) == 0 {
+ return "", typ, nil
+ }
+ u := (*[1 << 29]uint16)(unsafe.Pointer(&data[0]))[: len(data)/2 : len(data)/2]
+ return syscall.UTF16ToString(u), typ, nil
+}
+
+// GetMUIStringValue retrieves the localized string value for
+// the specified value name associated with an open key k.
+// If the value name doesn't exist or the localized string value
+// can't be resolved, GetMUIStringValue returns ErrNotExist.
+// GetMUIStringValue panics if the system doesn't support
+// regLoadMUIString; use LoadRegLoadMUIString to check if
+// regLoadMUIString is supported before calling this function.
+func (k Key) GetMUIStringValue(name string) (string, error) {
+ pname, err := syscall.UTF16PtrFromString(name)
+ if err != nil {
+ return "", err
+ }
+
+ buf := make([]uint16, 1024)
+ var buflen uint32
+ var pdir *uint16
+
+ err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
+ if err == syscall.ERROR_FILE_NOT_FOUND { // Try fallback path
+
+ // Try to resolve the string value using the system directory as
+ // a DLL search path; this assumes the string value is of the form
+ // @[path]\dllname,-strID but with no path given, e.g. @tzres.dll,-320.
+
+ // This approach works with tzres.dll but may have to be revised
+ // in the future to allow callers to provide custom search paths.
+
+ var s string
+ s, err = ExpandString("%SystemRoot%\\system32\\")
+ if err != nil {
+ return "", err
+ }
+ pdir, err = syscall.UTF16PtrFromString(s)
+ if err != nil {
+ return "", err
+ }
+
+ err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
+ }
+
+ for err == syscall.ERROR_MORE_DATA { // Grow buffer if needed
+ if buflen <= uint32(len(buf)) {
+ break // Buffer not growing, assume race; break
+ }
+ buf = make([]uint16, buflen)
+ err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
+ }
+
+ if err != nil {
+ return "", err
+ }
+
+ return syscall.UTF16ToString(buf), nil
+}
+
+// ExpandString expands environment-variable strings and replaces
+// them with the values defined for the current user.
+// Use ExpandString to expand EXPAND_SZ strings.
+func ExpandString(value string) (string, error) {
+ if value == "" {
+ return "", nil
+ }
+ p, err := syscall.UTF16PtrFromString(value)
+ if err != nil {
+ return "", err
+ }
+ r := make([]uint16, 100)
+ for {
+ n, err := expandEnvironmentStrings(p, &r[0], uint32(len(r)))
+ if err != nil {
+ return "", err
+ }
+ if n <= uint32(len(r)) {
+ return syscall.UTF16ToString(r[:n]), nil
+ }
+ r = make([]uint16, n)
+ }
+}
+
+// GetStringsValue retrieves the []string value for the specified
+// value name associated with an open key k. It also returns the value's type.
+// If value does not exist, GetStringsValue returns ErrNotExist.
+// If value is not MULTI_SZ, it will return the correct value
+// type and ErrUnexpectedType.
+func (k Key) GetStringsValue(name string) (val []string, valtype uint32, err error) {
+ data, typ, err2 := k.getValue(name, make([]byte, 64))
+ if err2 != nil {
+ return nil, typ, err2
+ }
+ if typ != MULTI_SZ {
+ return nil, typ, ErrUnexpectedType
+ }
+ if len(data) == 0 {
+ return nil, typ, nil
+ }
+ p := (*[1 << 29]uint16)(unsafe.Pointer(&data[0]))[: len(data)/2 : len(data)/2]
+ if len(p) == 0 {
+ return nil, typ, nil
+ }
+ if p[len(p)-1] == 0 {
+ p = p[:len(p)-1] // remove terminating null
+ }
+ val = make([]string, 0, 5)
+ from := 0
+ for i, c := range p {
+ if c == 0 {
+ val = append(val, string(utf16.Decode(p[from:i])))
+ from = i + 1
+ }
+ }
+ return val, typ, nil
+}
+
+// GetIntegerValue retrieves the integer value for the specified
+// value name associated with an open key k. It also returns the value's type.
+// If value does not exist, GetIntegerValue returns ErrNotExist.
+// If value is not DWORD or QWORD, it will return the correct value
+// type and ErrUnexpectedType.
+func (k Key) GetIntegerValue(name string) (val uint64, valtype uint32, err error) {
+ data, typ, err2 := k.getValue(name, make([]byte, 8))
+ if err2 != nil {
+ return 0, typ, err2
+ }
+ switch typ {
+ case DWORD:
+ if len(data) != 4 {
+ return 0, typ, errors.New("DWORD value is not 4 bytes long")
+ }
+ var val32 uint32
+ copy((*[4]byte)(unsafe.Pointer(&val32))[:], data)
+ return uint64(val32), DWORD, nil
+ case QWORD:
+ if len(data) != 8 {
+ return 0, typ, errors.New("QWORD value is not 8 bytes long")
+ }
+ copy((*[8]byte)(unsafe.Pointer(&val))[:], data)
+ return val, QWORD, nil
+ default:
+ return 0, typ, ErrUnexpectedType
+ }
+}
+
+// GetBinaryValue retrieves the binary value for the specified
+// value name associated with an open key k. It also returns the value's type.
+// If value does not exist, GetBinaryValue returns ErrNotExist.
+// If value is not BINARY, it will return the correct value
+// type and ErrUnexpectedType.
+func (k Key) GetBinaryValue(name string) (val []byte, valtype uint32, err error) {
+ data, typ, err2 := k.getValue(name, make([]byte, 64))
+ if err2 != nil {
+ return nil, typ, err2
+ }
+ if typ != BINARY {
+ return nil, typ, ErrUnexpectedType
+ }
+ return data, typ, nil
+}
+
+func (k Key) setValue(name string, valtype uint32, data []byte) error {
+ p, err := syscall.UTF16PtrFromString(name)
+ if err != nil {
+ return err
+ }
+ if len(data) == 0 {
+ return regSetValueEx(syscall.Handle(k), p, 0, valtype, nil, 0)
+ }
+ return regSetValueEx(syscall.Handle(k), p, 0, valtype, &data[0], uint32(len(data)))
+}
+
+// SetDWordValue sets the data and type of a name value
+// under key k to value and DWORD.
+func (k Key) SetDWordValue(name string, value uint32) error {
+ return k.setValue(name, DWORD, (*[4]byte)(unsafe.Pointer(&value))[:])
+}
+
+// SetQWordValue sets the data and type of a name value
+// under key k to value and QWORD.
+func (k Key) SetQWordValue(name string, value uint64) error {
+ return k.setValue(name, QWORD, (*[8]byte)(unsafe.Pointer(&value))[:])
+}
+
+func (k Key) setStringValue(name string, valtype uint32, value string) error {
+ v, err := syscall.UTF16FromString(value)
+ if err != nil {
+ return err
+ }
+ buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[: len(v)*2 : len(v)*2]
+ return k.setValue(name, valtype, buf)
+}
+
+// SetStringValue sets the data and type of a name value
+// under key k to value and SZ. The value must not contain a zero byte.
+func (k Key) SetStringValue(name, value string) error {
+ return k.setStringValue(name, SZ, value)
+}
+
+// SetExpandStringValue sets the data and type of a name value
+// under key k to value and EXPAND_SZ. The value must not contain a zero byte.
+func (k Key) SetExpandStringValue(name, value string) error {
+ return k.setStringValue(name, EXPAND_SZ, value)
+}
+
+// SetStringsValue sets the data and type of a name value
+// under key k to value and MULTI_SZ. The value strings
+// must not contain a zero byte.
+func (k Key) SetStringsValue(name string, value []string) error {
+ ss := ""
+ for _, s := range value {
+ for i := 0; i < len(s); i++ {
+ if s[i] == 0 {
+ return errors.New("string cannot have 0 inside")
+ }
+ }
+ ss += s + "\x00"
+ }
+ v := utf16.Encode([]rune(ss + "\x00"))
+ buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[: len(v)*2 : len(v)*2]
+ return k.setValue(name, MULTI_SZ, buf)
+}
+
+// SetBinaryValue sets the data and type of a name value
+// under key k to value and BINARY.
+func (k Key) SetBinaryValue(name string, value []byte) error {
+ return k.setValue(name, BINARY, value)
+}
+
+// DeleteValue removes a named value from the key k.
+func (k Key) DeleteValue(name string) error {
+ return regDeleteValue(syscall.Handle(k), syscall.StringToUTF16Ptr(name))
+}
+
+// ReadValueNames returns the value names of key k.
+// The parameter n controls the number of returned names,
+// analogous to the way os.File.Readdirnames works.
+func (k Key) ReadValueNames(n int) ([]string, error) {
+ ki, err := k.Stat()
+ if err != nil {
+ return nil, err
+ }
+ names := make([]string, 0, ki.ValueCount)
+ buf := make([]uint16, ki.MaxValueNameLen+1) // extra room for terminating null character
+loopItems:
+ for i := uint32(0); ; i++ {
+ if n > 0 {
+ if len(names) == n {
+ return names, nil
+ }
+ }
+ l := uint32(len(buf))
+ for {
+ err := regEnumValue(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)
+ if err == nil {
+ break
+ }
+ if err == syscall.ERROR_MORE_DATA {
+ // Double buffer size and try again.
+ l = uint32(2 * len(buf))
+ buf = make([]uint16, l)
+ continue
+ }
+ if err == _ERROR_NO_MORE_ITEMS {
+ break loopItems
+ }
+ return names, err
+ }
+ names = append(names, syscall.UTF16ToString(buf[:l]))
+ }
+ if n > len(names) {
+ return names, io.EOF
+ }
+ return names, nil
+}
diff --git a/vendor/golang.org/x/sys/windows/registry/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/registry/zsyscall_windows.go
new file mode 100644
index 000000000..fc1835d8a
--- /dev/null
+++ b/vendor/golang.org/x/sys/windows/registry/zsyscall_windows.go
@@ -0,0 +1,117 @@
+// Code generated by 'go generate'; DO NOT EDIT.
+
+package registry
+
+import (
+ "syscall"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+)
+
+var _ unsafe.Pointer
+
+// Do the interface allocations only once for common
+// Errno values.
+const (
+ errnoERROR_IO_PENDING = 997
+)
+
+var (
+ errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
+ errERROR_EINVAL error = syscall.EINVAL
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e syscall.Errno) error {
+ switch e {
+ case 0:
+ return errERROR_EINVAL
+ case errnoERROR_IO_PENDING:
+ return errERROR_IO_PENDING
+ }
+ // TODO: add more here, after collecting data on the common
+ // error values see on Windows. (perhaps when running
+ // all.bat?)
+ return e
+}
+
+var (
+ modadvapi32 = windows.NewLazySystemDLL("advapi32.dll")
+ modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
+
+ procRegConnectRegistryW = modadvapi32.NewProc("RegConnectRegistryW")
+ procRegCreateKeyExW = modadvapi32.NewProc("RegCreateKeyExW")
+ procRegDeleteKeyW = modadvapi32.NewProc("RegDeleteKeyW")
+ procRegDeleteValueW = modadvapi32.NewProc("RegDeleteValueW")
+ procRegEnumValueW = modadvapi32.NewProc("RegEnumValueW")
+ procRegLoadMUIStringW = modadvapi32.NewProc("RegLoadMUIStringW")
+ procRegSetValueExW = modadvapi32.NewProc("RegSetValueExW")
+ procExpandEnvironmentStringsW = modkernel32.NewProc("ExpandEnvironmentStringsW")
+)
+
+func regConnectRegistry(machinename *uint16, key syscall.Handle, result *syscall.Handle) (regerrno error) {
+ r0, _, _ := syscall.Syscall(procRegConnectRegistryW.Addr(), 3, uintptr(unsafe.Pointer(machinename)), uintptr(key), uintptr(unsafe.Pointer(result)))
+ if r0 != 0 {
+ regerrno = syscall.Errno(r0)
+ }
+ return
+}
+
+func regCreateKeyEx(key syscall.Handle, subkey *uint16, reserved uint32, class *uint16, options uint32, desired uint32, sa *syscall.SecurityAttributes, result *syscall.Handle, disposition *uint32) (regerrno error) {
+ r0, _, _ := syscall.Syscall9(procRegCreateKeyExW.Addr(), 9, uintptr(key), uintptr(unsafe.Pointer(subkey)), uintptr(reserved), uintptr(unsafe.Pointer(class)), uintptr(options), uintptr(desired), uintptr(unsafe.Pointer(sa)), uintptr(unsafe.Pointer(result)), uintptr(unsafe.Pointer(disposition)))
+ if r0 != 0 {
+ regerrno = syscall.Errno(r0)
+ }
+ return
+}
+
+func regDeleteKey(key syscall.Handle, subkey *uint16) (regerrno error) {
+ r0, _, _ := syscall.Syscall(procRegDeleteKeyW.Addr(), 2, uintptr(key), uintptr(unsafe.Pointer(subkey)), 0)
+ if r0 != 0 {
+ regerrno = syscall.Errno(r0)
+ }
+ return
+}
+
+func regDeleteValue(key syscall.Handle, name *uint16) (regerrno error) {
+ r0, _, _ := syscall.Syscall(procRegDeleteValueW.Addr(), 2, uintptr(key), uintptr(unsafe.Pointer(name)), 0)
+ if r0 != 0 {
+ regerrno = syscall.Errno(r0)
+ }
+ return
+}
+
+func regEnumValue(key syscall.Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) {
+ r0, _, _ := syscall.Syscall9(procRegEnumValueW.Addr(), 8, uintptr(key), uintptr(index), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(nameLen)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(valtype)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(buflen)), 0)
+ if r0 != 0 {
+ regerrno = syscall.Errno(r0)
+ }
+ return
+}
+
+func regLoadMUIString(key syscall.Handle, name *uint16, buf *uint16, buflen uint32, buflenCopied *uint32, flags uint32, dir *uint16) (regerrno error) {
+ r0, _, _ := syscall.Syscall9(procRegLoadMUIStringW.Addr(), 7, uintptr(key), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(buf)), uintptr(buflen), uintptr(unsafe.Pointer(buflenCopied)), uintptr(flags), uintptr(unsafe.Pointer(dir)), 0, 0)
+ if r0 != 0 {
+ regerrno = syscall.Errno(r0)
+ }
+ return
+}
+
+func regSetValueEx(key syscall.Handle, valueName *uint16, reserved uint32, vtype uint32, buf *byte, bufsize uint32) (regerrno error) {
+ r0, _, _ := syscall.Syscall6(procRegSetValueExW.Addr(), 6, uintptr(key), uintptr(unsafe.Pointer(valueName)), uintptr(reserved), uintptr(vtype), uintptr(unsafe.Pointer(buf)), uintptr(bufsize))
+ if r0 != 0 {
+ regerrno = syscall.Errno(r0)
+ }
+ return
+}
+
+func expandEnvironmentStrings(src *uint16, dst *uint16, size uint32) (n uint32, err error) {
+ r0, _, e1 := syscall.Syscall(procExpandEnvironmentStringsW.Addr(), 3, uintptr(unsafe.Pointer(src)), uintptr(unsafe.Pointer(dst)), uintptr(size))
+ n = uint32(r0)
+ if n == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index a3a9f17af..48d7797fa 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -938,9 +938,11 @@ github.com/satori/go.uuid
# github.com/segmentio/ksuid v1.0.4
## explicit; go 1.12
github.com/segmentio/ksuid
-# github.com/shirou/gopsutil/v3 v3.22.6
+# github.com/shirou/gopsutil/v3 v3.22.7
## explicit; go 1.15
github.com/shirou/gopsutil/v3/cpu
+github.com/shirou/gopsutil/v3/disk
+github.com/shirou/gopsutil/v3/host
github.com/shirou/gopsutil/v3/internal/common
github.com/shirou/gopsutil/v3/mem
github.com/shirou/gopsutil/v3/net
@@ -1226,6 +1228,7 @@ golang.org/x/sys/internal/unsafeheader
golang.org/x/sys/plan9
golang.org/x/sys/unix
golang.org/x/sys/windows
+golang.org/x/sys/windows/registry
# golang.org/x/term v0.0.0-20210927222741-03fcf44c2211
## explicit; go 1.17
golang.org/x/term
+
+
- Support via parameter Cookie='PHPSession=xxxx' ./scan4all -host xxxx.com, compatible with nuclei, httpx, go-poc, x-ray POC, filefuzz, http Smuggling
# work process
diff --git a/go.mod b/go.mod
index 9552ccb6a..318aee3ce 100644
--- a/go.mod
+++ b/go.mod
@@ -117,7 +117,9 @@ require (
github.com/projectdiscovery/nuclei/v2 v2.7.5
github.com/projectdiscovery/subfinder/v2 v2.5.2
github.com/satori/go.uuid v1.2.0
+ github.com/shirou/gopsutil/v3 v3.22.7
github.com/sijms/go-ora/v2 v2.4.25
+ github.com/simonnilsson/ask v0.2.0
github.com/spf13/viper v1.12.0
github.com/stacktitan/smb v0.0.0-20190531122847-da9a425dceb8
github.com/tj/go-update v2.2.5-0.20200519121640-62b4b798fd68+incompatible
@@ -241,8 +243,6 @@ require (
github.com/russross/blackfriday/v2 v2.1.0 // indirect
github.com/saintfish/chardet v0.0.0-20120816061221-3af4cd4741ca // indirect
github.com/segmentio/ksuid v1.0.4 // indirect
- github.com/shirou/gopsutil/v3 v3.22.6 // indirect
- github.com/simonnilsson/ask v0.2.0 // indirect
github.com/spf13/afero v1.8.2 // indirect
github.com/spf13/cast v1.5.0 // indirect
github.com/spf13/jwalterweatherman v1.1.0 // indirect
diff --git a/go.sum b/go.sum
index 446a9be3f..999878304 100644
--- a/go.sum
+++ b/go.sum
@@ -755,8 +755,9 @@ github.com/segmentio/ksuid v1.0.4 h1:sBo2BdShXjmcugAMwjugoGUdUV0pcxY5mW4xKRn3v4c
github.com/segmentio/ksuid v1.0.4/go.mod h1:/XUiZBD3kVx5SmUOl55voK5yeAbBNNIed+2O73XgrPE=
github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
github.com/shirou/gopsutil/v3 v3.21.7/go.mod h1:RGl11Y7XMTQPmHh8F0ayC6haKNBgH4PXMJuTAcMOlz4=
-github.com/shirou/gopsutil/v3 v3.22.6 h1:FnHOFOh+cYAM0C30P+zysPISzlknLC5Z1G4EAElznfQ=
github.com/shirou/gopsutil/v3 v3.22.6/go.mod h1:EdIubSnZhbAvBS1yJ7Xi+AShB/hxwLHOMz4MCYz7yMs=
+github.com/shirou/gopsutil/v3 v3.22.7 h1:flKnuCMfUUrO+oAvwAd6GKZgnPzr098VA/UJ14nhJd4=
+github.com/shirou/gopsutil/v3 v3.22.7/go.mod h1:s648gW4IywYzUfE/KjXxUsqrqx/T2xO5VqOXxONeRfI=
github.com/sijms/go-ora/v2 v2.4.25 h1:PtyMsRGHd6FNttdaMEg4NdHuRYxg29NKwsxPuTmCEJ4=
github.com/sijms/go-ora/v2 v2.4.25/go.mod h1:EHxlY6x7y9HAsdfumurRfTd+v8NrEOTR3Xl4FWlH6xk=
github.com/simonnilsson/ask v0.2.0 h1:CpiQtuLyRlrPNVk6aQjaFL51XmBlCIxaqssxentXBBA=
diff --git a/lib/util/sysinfo.go b/lib/util/sysinfo.go
new file mode 100644
index 000000000..8a6a139eb
--- /dev/null
+++ b/lib/util/sysinfo.go
@@ -0,0 +1,171 @@
+package util
+
+import (
+ "fmt"
+ "github.com/shirou/gopsutil/v3/cpu"
+ "github.com/shirou/gopsutil/v3/disk"
+ "github.com/shirou/gopsutil/v3/host"
+ "github.com/shirou/gopsutil/v3/mem"
+ "github.com/shirou/gopsutil/v3/net"
+ systemNet "net"
+ "strconv"
+ "time"
+)
+
+// 分区
+type Part struct {
+ Path string `json:"path"`
+ FsType string `json:"fstype"`
+ Total float64 `json:"total"`
+ Free float64 `json:"free"`
+ Used float64 `json:"used"`
+ UsedPercent int `json:"usedPercent"`
+}
+
+// 分区集合
+type Parts []Part
+
+// CPU
+type CpuSingle struct {
+ Num string `json:"num"`
+ Percent int `json:"percent"`
+}
+
+type CpuInfo struct {
+ CpuAvg float64 `json:"cpuAvg"`
+ CpuAll []CpuSingle `json:"cpuAll"`
+}
+
+const GB = 1024 * 1024 * 1024
+
+func decimal(v string) float64 {
+ value, _ := strconv.ParseFloat(v, 64)
+ return value
+}
+
+// 1.主机IP
+func GetLocalIP() (ip string) {
+ addresses, err := systemNet.InterfaceAddrs()
+ if err != nil {
+ return ""
+ }
+ for _, addr := range addresses {
+ ipAddr, ok := addr.(*systemNet.IPNet)
+ if !ok {
+ continue
+ }
+ if ipAddr.IP.IsLoopback() {
+ continue
+ }
+ if !ipAddr.IP.IsGlobalUnicast() {
+ continue
+ }
+ return ipAddr.IP.String()
+ }
+ return ""
+}
+
+// 2.主机信息
+func GetHostInfo() (result *host.InfoStat, err error) {
+ result, err = host.Info()
+ return result, err
+}
+
+// 3.磁盘信息
+func GetDiskInfo() (result Parts, err error) {
+ parts, err := disk.Partitions(true)
+ if err != nil {
+ return result, err
+ }
+ for _, part := range parts {
+ diskInfo, err := disk.Usage(part.Mountpoint)
+ if err == nil {
+ result = append(result, Part{
+ Path: diskInfo.Path,
+ FsType: diskInfo.Fstype,
+ Total: decimal(fmt.Sprintf("%.2f", float64(diskInfo.Total/GB))),
+ Free: decimal(fmt.Sprintf("%.2f", float64(diskInfo.Free/GB))),
+ Used: decimal(fmt.Sprintf("%.2f", float64(diskInfo.Used/GB))),
+ UsedPercent: int(diskInfo.UsedPercent),
+ })
+ } else {
+ return result, err
+ }
+ }
+ return result, err
+}
+
+// 4.CPU使用率
+func GetCpuPercent() (result CpuInfo, err error) {
+ infos, err := cpu.Percent(1*time.Second, true)
+ if err != nil {
+ return result, err
+ }
+ var total float64 = 0
+ for index, value := range infos {
+ result.CpuAll = append(result.CpuAll, CpuSingle{
+ Num: fmt.Sprintf("#%d", index+1),
+ Percent: int(value),
+ })
+ total += value
+ }
+ result.CpuAvg = decimal(fmt.Sprintf("%.1f", total/float64(len(infos))))
+ return result, err
+}
+
+// 5.内存信息
+func GetMemInfo() (float64, []map[string]interface{}) {
+ info, err := mem.VirtualMemory()
+ if err != nil {
+ fmt.Println(err)
+ return 0, nil
+ }
+ return decimal(fmt.Sprintf("%.1f", info.UsedPercent)), []map[string]interface{}{
+ {"key": "使用率[%]", "value": decimal(fmt.Sprintf("%.1f", info.UsedPercent))},
+ {"key": "总量[GB]", "value": int(info.Total / GB)},
+ {"key": "使用量[GB]", "value": int(info.Used / GB)},
+ {"key": "剩余量[GB]", "value": int(info.Free / GB)},
+ }
+}
+
+// 6.获取网卡信息
+func GetNetInfo() (result []net.IOCountersStat, err error) {
+ info, err := net.IOCounters(true)
+ if err != nil {
+ return result, err
+ }
+ return info, err
+}
+
+// 7.计算上下行带宽
+func GetNetSpeed() (speed map[string]map[string]uint64, err error) {
+ speed = map[string]map[string]uint64{}
+ info, err := net.IOCounters(true)
+ if err != nil {
+ return speed, err
+ }
+ for _, item := range info {
+ if item.BytesSent != 0 {
+ speed[item.Name] = map[string]uint64{
+ "send": item.BytesSent,
+ "recv": item.BytesRecv,
+ }
+ }
+ }
+
+ time.Sleep(1 * time.Second)
+
+ info, err = net.IOCounters(true)
+ if err != nil {
+ return speed, err
+ }
+ for _, item := range info {
+ if item.BytesSent != 0 {
+ speed[item.Name] = map[string]uint64{
+ "send": item.BytesSent - speed[item.Name]["send"],
+ "recv": item.BytesRecv - speed[item.Name]["recv"],
+ }
+ }
+ }
+ return speed, nil
+}
diff --git a/vendor/github.com/projectdiscovery/nuclei/v2/pkg/protocols/http/request.go b/vendor/github.com/projectdiscovery/nuclei/v2/pkg/protocols/http/request.go
index 8f0d572c3..007c4dfea 100644
--- a/vendor/github.com/projectdiscovery/nuclei/v2/pkg/protocols/http/request.go
+++ b/vendor/github.com/projectdiscovery/nuclei/v2/pkg/protocols/http/request.go
@@ -346,7 +346,7 @@ func (request *Request) ExecuteWithResults(reqURL string, dynamicValues, previou
const drainReqSize = int64(8 * 1024)
var errStopExecution = errors.New("stop execution due to unresolved variables")
-var someMapMutex = sync.RWMutex{}
+
// executeRequest executes the actual generated request and returns error if occurred
func (request *Request) executeRequest(reqURL string, generatedRequest *generatedRequest, previousEvent output.InternalEvent, hasInteractMatchers bool, callback protocols.OutputEventCallback, requestCount int) error {
request.setCustomHeaders(generatedRequest)
@@ -582,7 +582,6 @@ func (request *Request) executeRequest(reqURL string, generatedRequest *generate
if request.options.Interactsh != nil {
request.options.Interactsh.MakePlaceholders(generatedRequest.interactshURLs, outputEvent)
}
- someMapMutex.Lock()
for k, v := range previousEvent {
finalEvent[k] = v
}
@@ -598,7 +597,7 @@ func (request *Request) executeRequest(reqURL string, generatedRequest *generate
finalEvent[key] = v
}
}
- someMapMutex.Unlock()
+
// prune signature internal values if any
request.pruneSignatureInternalValues(generatedRequest.meta)
diff --git a/vendor/github.com/shirou/gopsutil/v3/cpu/cpu.go b/vendor/github.com/shirou/gopsutil/v3/cpu/cpu.go
index 831440d09..83bc23d45 100644
--- a/vendor/github.com/shirou/gopsutil/v3/cpu/cpu.go
+++ b/vendor/github.com/shirou/gopsutil/v3/cpu/cpu.go
@@ -5,6 +5,7 @@ import (
"encoding/json"
"fmt"
"math"
+ "runtime"
"strconv"
"strings"
"sync"
@@ -86,10 +87,12 @@ func (c TimesStat) String() string {
return `{` + strings.Join(v, ",") + `}`
}
-// Total returns the total number of seconds in a CPUTimesStat
+// Deprecated: Total returns the total number of seconds in a CPUTimesStat
+// Please do not use this internal function.
func (c TimesStat) Total() float64 {
- total := c.User + c.System + c.Nice + c.Iowait + c.Irq + c.Softirq +
- c.Steal + c.Idle
+ total := c.User + c.System + c.Idle + c.Nice + c.Iowait + c.Irq +
+ c.Softirq + c.Steal + c.Guest + c.GuestNice
+
return total
}
@@ -99,9 +102,15 @@ func (c InfoStat) String() string {
}
func getAllBusy(t TimesStat) (float64, float64) {
- busy := t.User + t.System + t.Nice + t.Iowait + t.Irq +
- t.Softirq + t.Steal
- return busy + t.Idle, busy
+ tot := t.Total()
+ if runtime.GOOS == "linux" {
+ tot -= t.Guest // Linux 2.6.24+
+ tot -= t.GuestNice // Linux 3.2.0+
+ }
+
+ busy := tot - t.Idle - t.Iowait
+
+ return tot, busy
}
func calculateBusy(t1, t2 TimesStat) float64 {
diff --git a/vendor/github.com/shirou/gopsutil/v3/disk/disk.go b/vendor/github.com/shirou/gopsutil/v3/disk/disk.go
new file mode 100644
index 000000000..dd4cc1d5f
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/v3/disk/disk.go
@@ -0,0 +1,96 @@
+package disk
+
+import (
+ "context"
+ "encoding/json"
+
+ "github.com/shirou/gopsutil/v3/internal/common"
+)
+
+var invoke common.Invoker = common.Invoke{}
+
+type UsageStat struct {
+ Path string `json:"path"`
+ Fstype string `json:"fstype"`
+ Total uint64 `json:"total"`
+ Free uint64 `json:"free"`
+ Used uint64 `json:"used"`
+ UsedPercent float64 `json:"usedPercent"`
+ InodesTotal uint64 `json:"inodesTotal"`
+ InodesUsed uint64 `json:"inodesUsed"`
+ InodesFree uint64 `json:"inodesFree"`
+ InodesUsedPercent float64 `json:"inodesUsedPercent"`
+}
+
+type PartitionStat struct {
+ Device string `json:"device"`
+ Mountpoint string `json:"mountpoint"`
+ Fstype string `json:"fstype"`
+ Opts []string `json:"opts"`
+}
+
+type IOCountersStat struct {
+ ReadCount uint64 `json:"readCount"`
+ MergedReadCount uint64 `json:"mergedReadCount"`
+ WriteCount uint64 `json:"writeCount"`
+ MergedWriteCount uint64 `json:"mergedWriteCount"`
+ ReadBytes uint64 `json:"readBytes"`
+ WriteBytes uint64 `json:"writeBytes"`
+ ReadTime uint64 `json:"readTime"`
+ WriteTime uint64 `json:"writeTime"`
+ IopsInProgress uint64 `json:"iopsInProgress"`
+ IoTime uint64 `json:"ioTime"`
+ WeightedIO uint64 `json:"weightedIO"`
+ Name string `json:"name"`
+ SerialNumber string `json:"serialNumber"`
+ Label string `json:"label"`
+}
+
+func (d UsageStat) String() string {
+ s, _ := json.Marshal(d)
+ return string(s)
+}
+
+func (d PartitionStat) String() string {
+ s, _ := json.Marshal(d)
+ return string(s)
+}
+
+func (d IOCountersStat) String() string {
+ s, _ := json.Marshal(d)
+ return string(s)
+}
+
+// Usage returns a file system usage. path is a filesystem path such
+// as "/", not device file path like "/dev/vda1". If you want to use
+// a return value of disk.Partitions, use "Mountpoint" not "Device".
+func Usage(path string) (*UsageStat, error) {
+ return UsageWithContext(context.Background(), path)
+}
+
+// Partitions returns disk partitions. If all is false, returns
+// physical devices only (e.g. hard disks, cd-rom drives, USB keys)
+// and ignore all others (e.g. memory partitions such as /dev/shm)
+//
+// 'all' argument is ignored for BSD, see: https://github.com/giampaolo/psutil/issues/906
+func Partitions(all bool) ([]PartitionStat, error) {
+ return PartitionsWithContext(context.Background(), all)
+}
+
+func IOCounters(names ...string) (map[string]IOCountersStat, error) {
+ return IOCountersWithContext(context.Background(), names...)
+}
+
+// SerialNumber returns Serial Number of given device or empty string
+// on error. Name of device is expected, eg. /dev/sda
+func SerialNumber(name string) (string, error) {
+ return SerialNumberWithContext(context.Background(), name)
+}
+
+// Label returns label of given device or empty string on error.
+// Name of device is expected, eg. /dev/sda
+// Supports label based on devicemapper name
+// See https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-block-dm
+func Label(name string) (string, error) {
+ return LabelWithContext(context.Background(), name)
+}
diff --git a/vendor/github.com/shirou/gopsutil/v3/disk/disk_aix.go b/vendor/github.com/shirou/gopsutil/v3/disk/disk_aix.go
new file mode 100644
index 000000000..bc71712ea
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/v3/disk/disk_aix.go
@@ -0,0 +1,22 @@
+//go:build aix
+// +build aix
+
+package disk
+
+import (
+ "context"
+
+ "github.com/shirou/gopsutil/v3/internal/common"
+)
+
+func IOCountersWithContext(ctx context.Context, names ...string) (map[string]IOCountersStat, error) {
+ return nil, common.ErrNotImplementedError
+}
+
+func SerialNumberWithContext(ctx context.Context, name string) (string, error) {
+ return "", common.ErrNotImplementedError
+}
+
+func LabelWithContext(ctx context.Context, name string) (string, error) {
+ return "", common.ErrNotImplementedError
+}
diff --git a/vendor/github.com/shirou/gopsutil/v3/disk/disk_aix_cgo.go b/vendor/github.com/shirou/gopsutil/v3/disk/disk_aix_cgo.go
new file mode 100644
index 000000000..aa534df30
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/v3/disk/disk_aix_cgo.go
@@ -0,0 +1,76 @@
+//go:build aix && cgo
+// +build aix,cgo
+
+package disk
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/power-devops/perfstat"
+)
+
+var FSType map[int]string
+
+func init() {
+ FSType = map[int]string{
+ 0: "jfs2", 1: "namefs", 2: "nfs", 3: "jfs", 5: "cdrom", 6: "proc",
+ 16: "special-fs", 17: "cache-fs", 18: "nfs3", 19: "automount-fs", 20: "pool-fs", 32: "vxfs",
+ 33: "veritas-fs", 34: "udfs", 35: "nfs4", 36: "nfs4-pseudo", 37: "smbfs", 38: "mcr-pseudofs",
+ 39: "ahafs", 40: "sterm-nfs", 41: "asmfs",
+ }
+}
+
+func PartitionsWithContext(ctx context.Context, all bool) ([]PartitionStat, error) {
+ f, err := perfstat.FileSystemStat()
+ if err != nil {
+ return nil, err
+ }
+ ret := make([]PartitionStat, len(f))
+
+ for _, fs := range f {
+ fstyp, exists := FSType[fs.FSType]
+ if !exists {
+ fstyp = "unknown"
+ }
+ info := PartitionStat{
+ Device: fs.Device,
+ Mountpoint: fs.MountPoint,
+ Fstype: fstyp,
+ }
+ ret = append(ret, info)
+ }
+
+ return ret, err
+}
+
+func UsageWithContext(ctx context.Context, path string) (*UsageStat, error) {
+ f, err := perfstat.FileSystemStat()
+ if err != nil {
+ return nil, err
+ }
+
+ blocksize := uint64(512)
+ for _, fs := range f {
+ if path == fs.MountPoint {
+ fstyp, exists := FSType[fs.FSType]
+ if !exists {
+ fstyp = "unknown"
+ }
+ info := UsageStat{
+ Path: path,
+ Fstype: fstyp,
+ Total: uint64(fs.TotalBlocks) * blocksize,
+ Free: uint64(fs.FreeBlocks) * blocksize,
+ Used: uint64(fs.TotalBlocks-fs.FreeBlocks) * blocksize,
+ InodesTotal: uint64(fs.TotalInodes),
+ InodesFree: uint64(fs.FreeInodes),
+ InodesUsed: uint64(fs.TotalInodes - fs.FreeInodes),
+ }
+ info.UsedPercent = (float64(info.Used) / float64(info.Total)) * 100.0
+ info.InodesUsedPercent = (float64(info.InodesUsed) / float64(info.InodesTotal)) * 100.0
+ return &info, nil
+ }
+ }
+ return nil, fmt.Errorf("mountpoint %s not found", path)
+}
diff --git a/vendor/github.com/shirou/gopsutil/v3/disk/disk_aix_nocgo.go b/vendor/github.com/shirou/gopsutil/v3/disk/disk_aix_nocgo.go
new file mode 100644
index 000000000..eb25cbdae
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/v3/disk/disk_aix_nocgo.go
@@ -0,0 +1,18 @@
+//go:build aix && !cgo
+// +build aix,!cgo
+
+package disk
+
+import (
+ "context"
+
+ "github.com/shirou/gopsutil/v3/internal/common"
+)
+
+func PartitionsWithContext(ctx context.Context, all bool) ([]PartitionStat, error) {
+ return []PartitionStat{}, common.ErrNotImplementedError
+}
+
+func UsageWithContext(ctx context.Context, path string) (*UsageStat, error) {
+ return nil, common.ErrNotImplementedError
+}
diff --git a/vendor/github.com/shirou/gopsutil/v3/disk/disk_darwin.go b/vendor/github.com/shirou/gopsutil/v3/disk/disk_darwin.go
new file mode 100644
index 000000000..0877b7611
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/v3/disk/disk_darwin.go
@@ -0,0 +1,87 @@
+//go:build darwin
+// +build darwin
+
+package disk
+
+import (
+ "context"
+
+ "github.com/shirou/gopsutil/v3/internal/common"
+ "golang.org/x/sys/unix"
+)
+
+// PartitionsWithContext returns disk partition.
+// 'all' argument is ignored, see: https://github.com/giampaolo/psutil/issues/906
+func PartitionsWithContext(ctx context.Context, all bool) ([]PartitionStat, error) {
+ var ret []PartitionStat
+
+ count, err := unix.Getfsstat(nil, unix.MNT_WAIT)
+ if err != nil {
+ return ret, err
+ }
+ fs := make([]unix.Statfs_t, count)
+ if _, err = unix.Getfsstat(fs, unix.MNT_WAIT); err != nil {
+ return ret, err
+ }
+ for _, stat := range fs {
+ opts := []string{"rw"}
+ if stat.Flags&unix.MNT_RDONLY != 0 {
+ opts = []string{"ro"}
+ }
+ if stat.Flags&unix.MNT_SYNCHRONOUS != 0 {
+ opts = append(opts, "sync")
+ }
+ if stat.Flags&unix.MNT_NOEXEC != 0 {
+ opts = append(opts, "noexec")
+ }
+ if stat.Flags&unix.MNT_NOSUID != 0 {
+ opts = append(opts, "nosuid")
+ }
+ if stat.Flags&unix.MNT_UNION != 0 {
+ opts = append(opts, "union")
+ }
+ if stat.Flags&unix.MNT_ASYNC != 0 {
+ opts = append(opts, "async")
+ }
+ if stat.Flags&unix.MNT_DONTBROWSE != 0 {
+ opts = append(opts, "nobrowse")
+ }
+ if stat.Flags&unix.MNT_AUTOMOUNTED != 0 {
+ opts = append(opts, "automounted")
+ }
+ if stat.Flags&unix.MNT_JOURNALED != 0 {
+ opts = append(opts, "journaled")
+ }
+ if stat.Flags&unix.MNT_MULTILABEL != 0 {
+ opts = append(opts, "multilabel")
+ }
+ if stat.Flags&unix.MNT_NOATIME != 0 {
+ opts = append(opts, "noatime")
+ }
+ if stat.Flags&unix.MNT_NODEV != 0 {
+ opts = append(opts, "nodev")
+ }
+ d := PartitionStat{
+ Device: common.ByteToString(stat.Mntfromname[:]),
+ Mountpoint: common.ByteToString(stat.Mntonname[:]),
+ Fstype: common.ByteToString(stat.Fstypename[:]),
+ Opts: opts,
+ }
+
+ ret = append(ret, d)
+ }
+
+ return ret, nil
+}
+
+func getFsType(stat unix.Statfs_t) string {
+ return common.ByteToString(stat.Fstypename[:])
+}
+
+func SerialNumberWithContext(ctx context.Context, name string) (string, error) {
+ return "", common.ErrNotImplementedError
+}
+
+func LabelWithContext(ctx context.Context, name string) (string, error) {
+ return "", common.ErrNotImplementedError
+}
diff --git a/vendor/github.com/shirou/gopsutil/v3/disk/disk_darwin_cgo.go b/vendor/github.com/shirou/gopsutil/v3/disk/disk_darwin_cgo.go
new file mode 100644
index 000000000..b041c8d72
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/v3/disk/disk_darwin_cgo.go
@@ -0,0 +1,45 @@
+//go:build darwin && cgo
+// +build darwin,cgo
+
+package disk
+
+/*
+#cgo LDFLAGS: -framework CoreFoundation -framework IOKit
+#include