bitbucket.org/Aishee/synsec@v0.0.0-20210414005726-236fc01a153d/pkg/exprhelpers/exprlib.go (about)

     1  package exprhelpers
     2  
     3  import (
     4  	"bufio"
     5  	"fmt"
     6  	"net"
     7  	"os"
     8  	"path"
     9  	"regexp"
    10  	"strconv"
    11  	"strings"
    12  
    13  	"github.com/davecgh/go-spew/spew"
    14  	log "github.com/sirupsen/logrus"
    15  )
    16  
    17  var dataFile map[string][]string
    18  var dataFileRegex map[string][]*regexp.Regexp
    19  
    20  func Atof(x string) float64 {
    21  	log.Debugf("debug atof %s", x)
    22  	ret, err := strconv.ParseFloat(x, 64)
    23  	if err != nil {
    24  		log.Warningf("Atof : can't convert float '%s' : %v", x, err)
    25  	}
    26  	return ret
    27  }
    28  
    29  func Upper(s string) string {
    30  	return strings.ToUpper(s)
    31  }
    32  
    33  func GetExprEnv(ctx map[string]interface{}) map[string]interface{} {
    34  	var ExprLib = map[string]interface{}{
    35  		"Atof":           Atof,
    36  		"JsonExtract":    JsonExtract,
    37  		"JsonExtractLib": JsonExtractLib,
    38  		"File":           File,
    39  		"RegexpInFile":   RegexpInFile,
    40  		"Upper":          Upper,
    41  		"IpInRange":      IpInRange,
    42  	}
    43  	for k, v := range ctx {
    44  		ExprLib[k] = v
    45  	}
    46  	return ExprLib
    47  }
    48  
    49  func Init() error {
    50  	dataFile = make(map[string][]string)
    51  	dataFileRegex = make(map[string][]*regexp.Regexp)
    52  	return nil
    53  }
    54  
    55  func FileInit(fileFolder string, filename string, fileType string) error {
    56  	log.Debugf("init (folder:%s) (file:%s) (type:%s)", fileFolder, filename, fileType)
    57  	filepath := path.Join(fileFolder, filename)
    58  	file, err := os.Open(filepath)
    59  	if err != nil {
    60  		return err
    61  	}
    62  	defer file.Close()
    63  
    64  	if fileType == "" {
    65  		log.Debugf("ignored file %s%s because no type specified", fileFolder, filename)
    66  		return nil
    67  	}
    68  	if _, ok := dataFile[filename]; !ok {
    69  		dataFile[filename] = []string{}
    70  	}
    71  	scanner := bufio.NewScanner(file)
    72  	for scanner.Scan() {
    73  		if strings.HasPrefix(scanner.Text(), "#") { // allow comments
    74  			continue
    75  		}
    76  		if len(scanner.Text()) == 0 { //skip empty lines
    77  			continue
    78  		}
    79  		switch fileType {
    80  		case "regex", "regexp":
    81  			dataFileRegex[filename] = append(dataFileRegex[filename], regexp.MustCompile(scanner.Text()))
    82  		case "string":
    83  			dataFile[filename] = append(dataFile[filename], scanner.Text())
    84  		default:
    85  			return fmt.Errorf("unknown data type '%s' for : '%s'", fileType, filename)
    86  		}
    87  	}
    88  
    89  	if err := scanner.Err(); err != nil {
    90  		return err
    91  	}
    92  	return nil
    93  }
    94  
    95  func File(filename string) []string {
    96  	if _, ok := dataFile[filename]; ok {
    97  		return dataFile[filename]
    98  	}
    99  	log.Errorf("file '%s' (type:string) not found in expr library", filename)
   100  	log.Errorf("expr library : %s", spew.Sdump(dataFile))
   101  	return []string{}
   102  }
   103  
   104  func RegexpInFile(data string, filename string) bool {
   105  	if _, ok := dataFileRegex[filename]; ok {
   106  		for _, re := range dataFileRegex[filename] {
   107  			if re.Match([]byte(data)) {
   108  				return true
   109  			}
   110  		}
   111  	} else {
   112  		log.Errorf("file '%s' (type:regexp) not found in expr library", filename)
   113  		log.Errorf("expr library : %s", spew.Sdump(dataFileRegex))
   114  	}
   115  	return false
   116  }
   117  
   118  func IpInRange(ip string, ipRange string) bool {
   119  	var err error
   120  	var ipParsed net.IP
   121  	var ipRangeParsed *net.IPNet
   122  
   123  	ipParsed = net.ParseIP(ip)
   124  	if ipParsed == nil {
   125  		log.Debugf("'%s' is not a valid IP", ip)
   126  		return false
   127  	}
   128  	if _, ipRangeParsed, err = net.ParseCIDR(ipRange); err != nil {
   129  		log.Debugf("'%s' is not a valid IP Range", ipRange)
   130  		return false
   131  	}
   132  	if ipRangeParsed.Contains(ipParsed) {
   133  		return true
   134  	}
   135  	return false
   136  }