opensnitch/daemon/rule/rule.go
Gustavo Iñiguez Goia ae9aa40c37
deserialize rules operator list correctly
In b93051026e we 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 commit 2fc9ed276b)
2024-06-21 14:35:15 +02:00

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
}