diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 73bc1cb32e52..f839f1576a01 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -597,6 +597,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Added "add_network_direction" processor for determining perimeter-based network direction. {pull}23076[23076] - Added new `rate_limit` processor for enforcing rate limits on event throughput. {pull}22883[22883] - Allow node/namespace metadata to be disabled on kubernetes metagen and ensure add_kubernetes_metadata honors host {pull}23012[23012] +- Add `wineventlog` schema to `decode_xml` processor. {issue}23910[23910] {pull}24726[24726] *Auditbeat* diff --git a/libbeat/docs/processors-list.asciidoc b/libbeat/docs/processors-list.asciidoc index 3900366708fb..f9d8bdaa3894 100644 --- a/libbeat/docs/processors-list.asciidoc +++ b/libbeat/docs/processors-list.asciidoc @@ -116,6 +116,9 @@ endif::[] ifndef::no_urldecode_processor[] * <> endif::[] +ifndef::no_decode_xml_processor[] +* <> +endif::[] //# end::processors-list[] //# tag::processors-include[] diff --git a/libbeat/processors/decode_xml/config.go b/libbeat/processors/decode_xml/config.go index 289b2eaa0e97..21bb426c5b2f 100644 --- a/libbeat/processors/decode_xml/config.go +++ b/libbeat/processors/decode_xml/config.go @@ -25,6 +25,7 @@ type decodeXMLConfig struct { ToLower bool `config:"to_lower"` IgnoreMissing bool `config:"ignore_missing"` IgnoreFailure bool `config:"ignore_failure"` + Schema string `config:"schema"` } func defaultConfig() decodeXMLConfig { diff --git a/libbeat/processors/decode_xml/decode_xml.go b/libbeat/processors/decode_xml/decode_xml.go index 0b229cff3d23..5d841a2b576a 100644 --- a/libbeat/processors/decode_xml/decode_xml.go +++ b/libbeat/processors/decode_xml/decode_xml.go @@ -21,12 +21,10 @@ import ( "encoding/json" "errors" "fmt" - "strings" "github.com/elastic/beats/v7/libbeat/beat" "github.com/elastic/beats/v7/libbeat/common" "github.com/elastic/beats/v7/libbeat/common/cfgwarn" - "github.com/elastic/beats/v7/libbeat/common/encoding/xml" "github.com/elastic/beats/v7/libbeat/common/jsontransform" "github.com/elastic/beats/v7/libbeat/logp" "github.com/elastic/beats/v7/libbeat/processors" @@ -36,7 +34,9 @@ import ( type decodeXML struct { decodeXMLConfig - log *logp.Logger + + decode decoder + log *logp.Logger } var ( @@ -51,9 +51,15 @@ const ( func init() { processors.RegisterPlugin(procName, checks.ConfigChecked(New, - checks.RequireFields("fields"), - checks.AllowedFields("fields", "overwrite_keys", "add_error_key", "target", "document_id"))) + checks.RequireFields("field"), + checks.AllowedFields( + "field", "target_field", + "overwrite_keys", "document_id", + "to_lower", "ignore_missing", + "ignore_failure", "schema", + ))) jsprocessor.RegisterPlugin(procName, New) + registerDecoders() } // New constructs a new decode_xml processor. @@ -77,6 +83,7 @@ func newDecodeXML(config decodeXMLConfig) (processors.Processor, error) { return &decodeXML{ decodeXMLConfig: config, + decode: newDecoder(config), log: logp.NewLogger(logName), }, nil } @@ -104,9 +111,9 @@ func (x *decodeXML) run(event *beat.Event) error { return errFieldIsNotString } - xmlOutput, err := x.decodeField(text) + xmlOutput, err := x.decode([]byte(text)) if err != nil { - return err + return fmt.Errorf("error decoding XML field: %w", err) } var id string @@ -131,19 +138,6 @@ func (x *decodeXML) run(event *beat.Event) error { return nil } -func (x *decodeXML) decodeField(data string) (decodedData map[string]interface{}, err error) { - dec := xml.NewDecoder(strings.NewReader(data)) - if x.ToLower { - dec.LowercaseKeys() - } - - out, err := dec.Decode() - if err != nil { - return nil, fmt.Errorf("error decoding XML field: %w", err) - } - return out, nil -} - func (x *decodeXML) String() string { json, _ := json.Marshal(x.decodeXMLConfig) return procName + "=" + string(json) diff --git a/libbeat/processors/decode_xml/decode_xml_test.go b/libbeat/processors/decode_xml/decode_xml_test.go index 26d075bf3a47..04c3c8847ed1 100644 --- a/libbeat/processors/decode_xml/decode_xml_test.go +++ b/libbeat/processors/decode_xml/decode_xml_test.go @@ -57,7 +57,7 @@ func TestDecodeXML(t *testing.T) { `, }, Output: common.MapStr{ - "xml": map[string]interface{}{ + "xml": common.MapStr{ "catalog": map[string]interface{}{ "book": map[string]interface{}{ "author": "William H. Gaddis", @@ -125,7 +125,7 @@ func TestDecodeXML(t *testing.T) { `, }, Output: common.MapStr{ - "message": map[string]interface{}{ + "message": common.MapStr{ "catalog": map[string]interface{}{ "book": map[string]interface{}{ "author": "William H. Gaddis", @@ -158,7 +158,7 @@ func TestDecodeXML(t *testing.T) { `, }, Output: common.MapStr{ - "message": map[string]interface{}{ + "message": common.MapStr{ "catalog": map[string]interface{}{ "book": []interface{}{ map[string]interface{}{ @@ -203,7 +203,7 @@ func TestDecodeXML(t *testing.T) { `, }, Output: common.MapStr{ - "message": map[string]interface{}{ + "message": common.MapStr{ "catalog": map[string]interface{}{ "book": []interface{}{ map[string]interface{}{ @@ -448,7 +448,7 @@ func TestXMLToDocumentID(t *testing.T) { require.NoError(t, err) wantFields := common.MapStr{ - "message": map[string]interface{}{ + "message": common.MapStr{ "catalog": map[string]interface{}{ "book": map[string]interface{}{ "author": "William H. Gaddis", diff --git a/libbeat/processors/decode_xml/docs/decode_xml.asciidoc b/libbeat/processors/decode_xml/docs/decode_xml.asciidoc index ded0543514ac..c21c25081fc1 100644 --- a/libbeat/processors/decode_xml/docs/decode_xml.asciidoc +++ b/libbeat/processors/decode_xml/docs/decode_xml.asciidoc @@ -26,7 +26,7 @@ processors: By default any decoding errors that occur will stop the processing chain and the error will be added to `error.message` field. To ignore all errors and continue to the next processor you can set `ignore_failure: true`. To specifically -ignore failures caused by `field` not existing use `ignore_missing`. +ignore failures caused by `field` not existing you can set `ignore_missing: true`. [source,yaml] ------- @@ -55,15 +55,13 @@ Example XML input: [source,xml] ------------------------------------------------------------------------------- -{ - - - William H. Gaddis - The Recognitions - One of the great seminal American novels of the 20th century. - - -} + + + William H. Gaddis + The Recognitions + One of the great seminal American novels of the 20th century. + + ------------------------------------------------------------------------------- Will produce the following output: @@ -97,10 +95,13 @@ value (`target_field:`) is treated as if the field was not set at all. `overwrite_keys`:: (Optional) A boolean that specifies whether keys that already exist in the event are overwritten by keys from the decoded XML object. The -default value is false. +default value is `true`. `to_lower`:: (Optional) Converts all keys to lowercase. Accepts either true or -false. The default value is true. +false. The default value is `true`. + +`schema`:: (Optional) Specifies the schema of the message. Accepted schemas: `wineventlog`. +If no schema is specified it defaults to using the regular XML to JSON conversion. `document_id`:: (Optional) XML key to use as the document ID. If configured, the field will be removed from the original XML document and stored in @@ -113,3 +114,80 @@ when a specified field does not exist. Defaults to `false`. Defaults to `false`. See <> for a list of supported conditions. + + +==== Schemas + +When a schema is defined, the specific decoder will parse the configured field. +The ouput of the parsing will be specific to that schema. + +===== Wineventlog + +The `wineventlog` schema decodes Windows Events. + +The decoder will always output the fields formatted in the same way, the +`to_lower` option will be ignored when using this schema decoder. +The output fields will be the same as the +{winlogbeat-ref}/exported-fields-winlog.html#_winlog[winlogbeat winlog fields]. + +Example: + +[source,yaml] +------------------------------------------------------------------------------- +processors: + - decode_xml: + field: event.original + target_field: winlog + to_lower: false +------------------------------------------------------------------------------- + +[source,json] +------------------------------------------------------------------------------- +{ + "event": { + "original": "4672001254800x802000000000000011303SecurityvagrantS-1-5-18SYSTEMNT AUTHORITY0x3e7SeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\tSeRestorePrivilege\n\t\t\tSeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilegeSpecial privileges assigned to new logon.\n\nSubject:\n\tSecurity ID:\t\tS-1-5-18\n\tAccount Name:\t\tSYSTEM\n\tAccount Domain:\t\tNT AUTHORITY\n\tLogon ID:\t\t0x3E7\n\nPrivileges:\t\tSeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\tSeRestorePrivilege\n\t\t\tSeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilegeInformationSpecial LogonInfoSecurityMicrosoft Windows security auditing.Audit Success" + } +} +------------------------------------------------------------------------------- + +Will produce the following output: + +[source,json] +------------------------------------------------------------------------------- +{ + "event": { + "original": "4672001254800x802000000000000011303SecurityvagrantS-1-5-18SYSTEMNT AUTHORITY0x3e7SeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\tSeRestorePrivilege\n\t\t\tSeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilegeSpecial privileges assigned to new logon.\n\nSubject:\n\tSecurity ID:\t\tS-1-5-18\n\tAccount Name:\t\tSYSTEM\n\tAccount Domain:\t\tNT AUTHORITY\n\tLogon ID:\t\t0x3E7\n\nPrivileges:\t\tSeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\tSeRestorePrivilege\n\t\t\tSeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilegeInformationSpecial LogonInfoSecurityMicrosoft Windows security auditing.Audit Success" + }, + "winlog": { + "channel": "Security", + "outcome": "success", + "activity_id": "{ffb23523-1f32-0000-c335-b2ff321fd701}", + "level": "information", + "event_id": 4672, + "provider_name": "Microsoft-Windows-Security-Auditing", + "record_id": 11303, + "computer_name": "vagrant", + "keywords_raw": 9232379236109516800, + "opcode": "Info", + "provider_guid": "{54849625-5478-4994-a5ba-3e3b0328c30d}", + "event_data": { + "SubjectUserSid": "S-1-5-18", + "SubjectUserName": "SYSTEM", + "SubjectDomainName": "NT AUTHORITY", + "SubjectLogonId": "0x3e7", + "PrivilegeList": "SeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\tSeRestorePrivilege\n\t\t\tSeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilege" + }, + "task": "Special Logon", + "keywords": [ + "Audit Success" + ], + "message": "Special privileges assigned to new logon.\n\nSubject:\n\tSecurity ID:\t\tS-1-5-18\n\tAccount Name:\t\tSYSTEM\n\tAccount Domain:\t\tNT AUTHORITY\n\tLogon ID:\t\t0x3E7\n\nPrivileges:\t\tSeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\tSeRestorePrivilege\n\t\t\tSeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilege", + "process": { + "pid": 652, + "thread": { + "id": 4660 + } + } + } +} +------------------------------------------------------------------------------- diff --git a/libbeat/processors/decode_xml/schema.go b/libbeat/processors/decode_xml/schema.go new file mode 100644 index 000000000000..10043ec3d0ba --- /dev/null +++ b/libbeat/processors/decode_xml/schema.go @@ -0,0 +1,95 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package decode_xml + +import ( + "bytes" + "errors" + + "github.com/elastic/beats/v7/libbeat/common" + "github.com/elastic/beats/v7/libbeat/common/encoding/xml" + "github.com/elastic/beats/v7/libbeat/logp" + "github.com/elastic/beats/v7/winlogbeat/sys/winevent" +) + +const wineventlogSchema = "wineventlog" + +type newDecoderFunc func(cfg decodeXMLConfig) decoder +type decoder func(p []byte) (common.MapStr, error) + +var ( + registeredDecoders = map[string]newDecoderFunc{} + newDefaultDecoder newDecoderFunc = newSchemaLessDecoder +) + +func registerDecoder(schema string, dec newDecoderFunc) error { + if schema == "" { + return errors.New("schema can't be empty") + } + + if dec == nil { + return errors.New("decoder can't be nil") + } + + if _, found := registeredDecoders[schema]; found { + return errors.New("already registered") + } + + registeredDecoders[schema] = dec + + return nil +} + +func newDecoder(cfg decodeXMLConfig) decoder { + newDec, found := registeredDecoders[cfg.Schema] + if !found { + return newDefaultDecoder(cfg) + } + return newDec(cfg) +} + +func registerDecoders() { + log := logp.L().Named(logName) + log.Debug(registerDecoder(wineventlogSchema, newWineventlogDecoder)) +} + +func newSchemaLessDecoder(cfg decodeXMLConfig) decoder { + return func(p []byte) (common.MapStr, error) { + dec := xml.NewDecoder(bytes.NewReader(p)) + if cfg.ToLower { + dec.LowercaseKeys() + } + + out, err := dec.Decode() + if err != nil { + return nil, err + } + + return common.MapStr(out), nil + } +} + +func newWineventlogDecoder(decodeXMLConfig) decoder { + return func(p []byte) (common.MapStr, error) { + evt, err := winevent.UnmarshalXML(p) + if err != nil { + return nil, err + } + return evt.Fields(), nil + } +} diff --git a/libbeat/processors/decode_xml/schema_test.go b/libbeat/processors/decode_xml/schema_test.go new file mode 100644 index 000000000000..655c5156fe23 --- /dev/null +++ b/libbeat/processors/decode_xml/schema_test.go @@ -0,0 +1,130 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package decode_xml + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/elastic/beats/v7/libbeat/beat" + "github.com/elastic/beats/v7/libbeat/common" +) + +func TestDecodeSchemas(t *testing.T) { + var testCases = []struct { + schema string + config decodeXMLConfig + Input common.MapStr + Output common.MapStr + error bool + errorMessage string + }{ + { + schema: wineventlogSchema, + config: decodeXMLConfig{ + Field: "message", + Target: &testXMLTargetField, + Schema: wineventlogSchema, + }, + Input: common.MapStr{ + "message": "" + + "4672001254800x8020000000000000" + + "11303Securityvagrant" + + "S-1-5-18SYSTEMNT AUTHORITY0x3e7" + + "SeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\t" + + "SeRestorePrivilege\n\t\t\tSeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilege" + + "Special privileges assigned to new logon.\n\nSubject:\n\tSecurity ID:\t\tS-1-5-18\n\tAccount Name:\t\tSYSTEM\n\tAccount Domain:\t\tNT AUTHORITY\n\tLogon ID:\t\t0x3E7\n\n" + + "Privileges:\t\tSeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\tSeRestorePrivilege\n\t\t\t" + + "SeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilegeInformation" + + "Special LogonInfoSecurityMicrosoft Windows security auditing.Audit Success", + }, + Output: common.MapStr{ + "xml": common.MapStr{ + "channel": "Security", + "outcome": "success", + "activity_id": "{ffb23523-1f32-0000-c335-b2ff321fd701}", + "level": "information", + "event_id": uint32(4672), + "provider_name": "Microsoft-Windows-Security-Auditing", + "record_id": uint64(11303), + "computer_name": "vagrant", + "time_created": func() time.Time { + t, _ := time.Parse(time.RFC3339Nano, "2021-03-23T09:56:13.137310000Z") + return t + }(), + "opcode": "Info", + "provider_guid": "{54849625-5478-4994-a5ba-3e3b0328c30d}", + "event_data": common.MapStr{ + "SubjectUserSid": "S-1-5-18", + "SubjectUserName": "SYSTEM", + "SubjectDomainName": "NT AUTHORITY", + "SubjectLogonId": "0x3e7", + "PrivilegeList": "SeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\tSeRestorePrivilege\n\t\t\tSeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilege", + }, + "task": "Special Logon", + "keywords": []string{ + "Audit Success", + }, + "message": "Special privileges assigned to new logon.\n\nSubject:\n\tSecurity ID:\t\tS-1-5-18\n\tAccount Name:\t\tSYSTEM\n\tAccount Domain:\t\tNT AUTHORITY\n\tLogon ID:\t\t0x3E7\n\nPrivileges:\t\tSeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\tSeRestorePrivilege\n\t\t\tSeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilege", + "process": common.MapStr{ + "pid": uint32(652), + "thread": common.MapStr{ + "id": uint32(4660), + }, + }, + }, + "message": "" + + "4672001254800x8020000000000000" + + "11303Securityvagrant" + + "S-1-5-18SYSTEMNT AUTHORITY0x3e7" + + "SeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\t" + + "SeRestorePrivilege\n\t\t\tSeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilege" + + "Special privileges assigned to new logon.\n\nSubject:\n\tSecurity ID:\t\tS-1-5-18\n\tAccount Name:\t\tSYSTEM\n\tAccount Domain:\t\tNT AUTHORITY\n\tLogon ID:\t\t0x3E7\n\n" + + "Privileges:\t\tSeAssignPrimaryTokenPrivilege\n\t\t\tSeTcbPrivilege\n\t\t\tSeSecurityPrivilege\n\t\t\tSeTakeOwnershipPrivilege\n\t\t\tSeLoadDriverPrivilege\n\t\t\tSeBackupPrivilege\n\t\t\tSeRestorePrivilege\n\t\t\t" + + "SeDebugPrivilege\n\t\t\tSeAuditPrivilege\n\t\t\tSeSystemEnvironmentPrivilege\n\t\t\tSeImpersonatePrivilege\n\t\t\tSeDelegateSessionUserImpersonatePrivilegeInformation" + + "Special LogonInfoSecurityMicrosoft Windows security auditing.Audit Success", + }, + }, + } + + for _, test := range testCases { + test := test + t.Run(test.schema, func(t *testing.T) { + t.Parallel() + + f, err := newDecodeXML(test.config) + require.NoError(t, err) + + event := &beat.Event{ + Fields: test.Input, + } + newEvent, err := f.Run(event) + if !test.error { + assert.NoError(t, err) + } else { + if assert.Error(t, err) { + assert.Contains(t, err.Error(), test.errorMessage) + } + } + assert.Equal(t, test.Output, newEvent.Fields) + }) + } +} diff --git a/winlogbeat/_meta/fields.common.yml b/winlogbeat/_meta/fields.common.yml index 7467cad731aa..fe6a19510270 100644 --- a/winlogbeat/_meta/fields.common.yml +++ b/winlogbeat/_meta/fields.common.yml @@ -360,6 +360,12 @@ logged. The category used by the Event Logging API (on pre Windows Vista operating systems) is written to this field. + - name: time_created + type: date + required: false + description: > + The event creation time. + - name: process.thread.id type: long required: false diff --git a/winlogbeat/docs/fields.asciidoc b/winlogbeat/docs/fields.asciidoc index ee0361a3755e..1dbbbc3189e4 100644 --- a/winlogbeat/docs/fields.asciidoc +++ b/winlogbeat/docs/fields.asciidoc @@ -11316,6 +11316,18 @@ required: False -- +*`winlog.time_created`*:: ++ +-- +The event creation time. + + +type: date + +required: False + +-- + *`winlog.process.thread.id`*:: + -- diff --git a/winlogbeat/eventlog/eventlog.go b/winlogbeat/eventlog/eventlog.go index 1d40655c9ba9..88bd4f5fabcc 100644 --- a/winlogbeat/eventlog/eventlog.go +++ b/winlogbeat/eventlog/eventlog.go @@ -82,7 +82,7 @@ type Record struct { func (e Record) ToEvent() beat.Event { win := e.Fields() - win.Delete("keywords_raw") + win.Delete("time_created") win.Put("api", e.API) m := common.MapStr{ diff --git a/winlogbeat/include/fields.go b/winlogbeat/include/fields.go index 3a899709fc13..0f93a13922c1 100644 --- a/winlogbeat/include/fields.go +++ b/winlogbeat/include/fields.go @@ -32,5 +32,5 @@ func init() { // AssetBuildFieldsFieldsCommonYml returns asset data. // This is the base64 encoded gzipped contents of build/fields/fields.common.yml. func AssetBuildFieldsFieldsCommonYml() string { - return "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" + return "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" } diff --git a/winlogbeat/sys/winevent/event.go b/winlogbeat/sys/winevent/event.go index 0abec5bbb5e9..53c6b49abd53 100644 --- a/winlogbeat/sys/winevent/event.go +++ b/winlogbeat/sys/winevent/event.go @@ -97,13 +97,13 @@ func (e Event) Fields() common.MapStr { AddOptional(win, "provider_name", e.Provider.Name) AddOptional(win, "record_id", e.RecordID) AddOptional(win, "task", e.Task) - AddOptional(win, "keywords_raw", e.KeywordsRaw) AddOptional(win, "computer_name", e.Computer) AddOptional(win, "keywords", e.Keywords) AddOptional(win, "opcode", e.Opcode) AddOptional(win, "provider_guid", e.Provider.GUID) AddOptional(win, "task", e.Task) AddOptional(win, "version", e.Version) + AddOptional(win, "time_created", e.TimeCreated.SystemTime) if e.KeywordsRaw&keywordAuditFailure > 0 { _, _ = win.Put("outcome", "failure")