Inb93051026ewe disabled sending/parsing list operators as JSON strings. Instead, now it's sent/parsed as protobuf Rule, and saved to disk as JSON array, which ease the task of manually creating new rules if needed. This change was missing in the previous commit. (cherry picked from commit2fc9ed276b)
170 lines
4.4 KiB
Go
170 lines
4.4 KiB
Go
package rule
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/evilsocket/opensnitch/daemon/conman"
|
|
"github.com/evilsocket/opensnitch/daemon/log"
|
|
"github.com/evilsocket/opensnitch/daemon/ui/protocol"
|
|
)
|
|
|
|
// Action of a rule
|
|
type Action string
|
|
|
|
// Actions of rules
|
|
const (
|
|
Allow = Action("allow")
|
|
Deny = Action("deny")
|
|
Reject = Action("reject")
|
|
)
|
|
|
|
// Duration of a rule
|
|
type Duration string
|
|
|
|
// daemon possible durations
|
|
const (
|
|
Once = Duration("once")
|
|
Restart = Duration("until restart")
|
|
Always = Duration("always")
|
|
)
|
|
|
|
// Rule represents an action on a connection.
|
|
// The fields match the ones saved as json to disk.
|
|
// If a .json rule file is modified on disk, it's reloaded automatically.
|
|
type Rule struct {
|
|
// Save date fields as string, to avoid issues marshalling Time (#1140).
|
|
Created string `json:"created"`
|
|
Updated string `json:"updated"`
|
|
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
Action Action `json:"action"`
|
|
Duration Duration `json:"duration"`
|
|
Operator Operator `json:"operator"`
|
|
Enabled bool `json:"enabled"`
|
|
Precedence bool `json:"precedence"`
|
|
Nolog bool `json:"nolog"`
|
|
}
|
|
|
|
// Create creates a new rule object with the specified parameters.
|
|
func Create(name, description string, enabled, precedence, nolog bool, action Action, duration Duration, op *Operator) *Rule {
|
|
return &Rule{
|
|
Created: time.Now().Format(time.RFC3339),
|
|
Enabled: enabled,
|
|
Precedence: precedence,
|
|
Nolog: nolog,
|
|
Name: name,
|
|
Description: description,
|
|
Action: action,
|
|
Duration: duration,
|
|
Operator: *op,
|
|
}
|
|
}
|
|
|
|
func (r *Rule) String() string {
|
|
enabled := "Disabled"
|
|
if r.Enabled {
|
|
enabled = "Enabled"
|
|
}
|
|
return fmt.Sprintf("[%s] %s: if(%s){ %s %s }", enabled, r.Name, r.Operator.String(), r.Action, r.Duration)
|
|
}
|
|
|
|
// Match performs on a connection the checks a Rule has, to determine if it
|
|
// must be allowed or denied.
|
|
func (r *Rule) Match(con *conman.Connection) bool {
|
|
return r.Operator.Match(con)
|
|
}
|
|
|
|
// Deserialize translates back the rule received to a Rule object
|
|
func Deserialize(reply *protocol.Rule) (*Rule, error) {
|
|
if reply.Operator == nil {
|
|
log.Warning("Deserialize rule, Operator nil")
|
|
return nil, fmt.Errorf("invalid operator")
|
|
}
|
|
operator, err := NewOperator(
|
|
Type(reply.Operator.Type),
|
|
Sensitive(reply.Operator.Sensitive),
|
|
Operand(reply.Operator.Operand),
|
|
reply.Operator.Data,
|
|
make([]Operator, 0),
|
|
)
|
|
if err != nil {
|
|
log.Warning("Deserialize rule, NewOperator() error: %s", err)
|
|
return nil, err
|
|
}
|
|
|
|
newRule := Create(
|
|
reply.Name,
|
|
reply.Description,
|
|
reply.Enabled,
|
|
reply.Precedence,
|
|
reply.Nolog,
|
|
Action(reply.Action),
|
|
Duration(reply.Duration),
|
|
operator,
|
|
)
|
|
|
|
if Type(reply.Operator.Type) == List {
|
|
newRule.Operator.Data = ""
|
|
reply.Operator.Data = ""
|
|
for i := 0; i < len(reply.Operator.List); i++ {
|
|
newRule.Operator.List = append(
|
|
newRule.Operator.List,
|
|
Operator{
|
|
Type: Type(reply.Operator.List[i].Type),
|
|
Sensitive: Sensitive(reply.Operator.List[i].Sensitive),
|
|
Operand: Operand(reply.Operator.List[i].Operand),
|
|
Data: string(reply.Operator.List[i].Data),
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
return newRule, nil
|
|
}
|
|
|
|
// Serialize translates a Rule to the protocol object
|
|
func (r *Rule) Serialize() *protocol.Rule {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
|
|
created, err := time.Parse(time.RFC3339, r.Created)
|
|
if err != nil {
|
|
log.Warning("Error parsing rule Created date (it should be in RFC3339 format): %s (%s)", err, string(r.Name))
|
|
log.Warning("using current time instead: %s", created)
|
|
created = time.Now()
|
|
}
|
|
|
|
protoRule := &protocol.Rule{
|
|
Created: created.Unix(),
|
|
Name: string(r.Name),
|
|
Description: string(r.Description),
|
|
Enabled: bool(r.Enabled),
|
|
Precedence: bool(r.Precedence),
|
|
Nolog: bool(r.Nolog),
|
|
Action: string(r.Action),
|
|
Duration: string(r.Duration),
|
|
Operator: &protocol.Operator{
|
|
Type: string(r.Operator.Type),
|
|
Sensitive: bool(r.Operator.Sensitive),
|
|
Operand: string(r.Operator.Operand),
|
|
Data: string(r.Operator.Data),
|
|
},
|
|
}
|
|
if r.Operator.Type == List {
|
|
r.Operator.Data = ""
|
|
for i := 0; i < len(r.Operator.List); i++ {
|
|
protoRule.Operator.List = append(protoRule.Operator.List,
|
|
&protocol.Operator{
|
|
Type: string(r.Operator.List[i].Type),
|
|
Sensitive: bool(r.Operator.List[i].Sensitive),
|
|
Operand: string(r.Operator.List[i].Operand),
|
|
Data: string(r.Operator.List[i].Data),
|
|
})
|
|
}
|
|
}
|
|
|
|
return protoRule
|
|
}
|