logo_kerberos.gif

Projects/Audit

From K5Wiki
< Projects(Difference between revisions)
Jump to: navigation, search
m
m
 
(39 intermediate revisions by 2 users not shown)
Line 1: Line 1:
{{project-early}}
+
{{project-rel|1.12}}
   
== Purpose ==
+
== Description ==
   
Create an Audit infrastructure within MIT Kerberos to monitor security related events on the KDC.
+
This project creates a pluggable audit interface to allow the monitoring of security-related events on the KDC.
In future expand Kerberos Audit facility to the application servers, kadmin if it remains desirable.
 
   
  +
The interface is considered "experimental", in that API stability is not guaranteed to future major releases.
 
 
 
== Requirements ==
 
== Requirements ==
Line 12: Line 13:
 
* build-time enabled;
 
* build-time enabled;
 
* run-time pluggable;
 
* run-time pluggable;
* simple, so it could be easily replaced with the OS specific implementations;
+
* simple and flexible, so it could be easily replaced with the OS specific and third-parties implementations;
   
   
 
== Events ==
 
== Events ==
   
This section details the categories of the auditable events and the associated information.
+
We consider events under the categorization of the Common Criteria Class FIA.
   
;Audit module loaded/unloaded: Startup and shutdown of the audit system must be recorded by audit system;
+
This section details the categories of the auditable events and the associated data.
; KDC started/stopped
 
:KDC start-up basic information: List of KDC realms and corresponding ports on which the Kerberos server should listen for UDP and TCP requests; location and names of the plugins;
 
:KDC stopped - no additional information;
 
; Authentication
 
: (Common Criteria Class FIA)
 
:AS exchange:
 
::Basic information: client principal name; requested service name; remote port; selected keytype for the ticket session key; pre-authentication error; KDC status message;
 
::On success: ticket id; returned ticket start, end and renew until times; ticket flags;
 
:TGS exchange:
 
::TGS
 
:::Basic information: ticket id; client principal name; requested service name; remote port; authtime timestamp; selected keytype for the ticket session key; KDC status message; if the request is for referral ticket indicate to which server;
 
:::On success: returned ticket start, end and renew until times; ticket flags; if the request was to renew ticket – indicate that ticket was renewed;
 
::Alternate
 
:::Basic information: ticket id; client principal name; requested service name; authtime timestamp; KDC status message;
 
:::On success: alternate TGT
 
::Cross-realm
 
:::Basic information: ticket id; client principal name; requested service name, remote port; authtime timestamp; KDC status message;
 
:::On success: cross-realm TGT
 
::U2U
 
:::Basic information: ticket id; client principal name; requested service name; authtime timestamp; KDC status message;
 
:::On success: second ticket client and server name
 
:Policy: Policies violation when processing requests - TBD;
 
::AS request; TGS request; S4U2PROXY request
 
;Session keys :
 
:(Common Criteria FCS_CKM.1, FCS_CKM.4):
 
: AS and TGS exchange: ticket id; client principal name; requested service name, remote port; authtime timestamp; keytype list in request and selected keytype for the ticket session key;
 
: AS and TGS exchange: ticket id; session key cleaning;
 
 
   
== Design details ==
+
1. Startup and shutdown of the KDC must be recorded by audit system;
   
=== Ticket ID ===
+
2. The bulk of the audit information will be produced while processing AS and TGS requests. Though KDC request processing can be grouped into several logical phases, we generate (usually) only two events, one at the initial receipt of a request, and a second, final, one before sending a reply. All events relating to the same request can be linked together in the audit log by a 32-character alphanumeric string (about 190 bits of uniqueness) which is randomly generated at the start of processing. If the request is a S4U2Self or S4U2Proxy request, an additional audit event will be generated with information particular to the S4U request. The following table lists the logical stages of KDC processing, and which components are logged in the AS and TGS cases:
   
Ticket ID is recorded as part of audit messages. This allows to link tickets to their initial TGT at any stage of the Kerberos exchange.
+
{| class="wikitable" style="border: 3px solid #59121e"
  +
|+
  +
|-
  +
! Phase
  +
! style="padding-left: 2em; padding-right: 2em;" | Data to be logged
  +
! AS_REQ
  +
! TGS_REQ
  +
|-
  +
|rowspan=3|Authenticate request content and client
  +
| client’s address and port || &#10004; || &#10004;
  +
|-
  +
| original KDC request and [[#Request ID| request ID ]] || &#10004; || &#10004;
  +
|-
  +
| primary [[#Ticket ID|ticket ID]] || &#10007; ||(S4U:front-end server's) TGT
  +
|-
  +
|rowspan=3|Determine service principal
  +
| modified KDC request and [[#Request ID|request ID]] ||&#10004; || &#10004;
  +
|-
  +
| cross-realm referral || &#10007; || service principal, TGS
  +
|-
  +
| user-to-user: client in the 2nd ticket || &#10007; ||&#10004;
  +
|-
  +
|rowspan=2|Validate policies
  +
| local policy violation ||&#10004; || &#10004;
  +
|-
  +
| protocol constraints ||&#10007; || S4U2Proxy, S4U2Self
  +
|-
  +
|rowspan=5|Issue ticket
  +
| ticket renewed ||&#10007; || &#10004;
  +
|-
  +
| ticket validated ||&#10007; || &#10004;
  +
|-
  +
| session key enctype (short-term) ||&#10004; || &#10004;
  +
|-
  +
| enctype of the service's long-term key||&#10007; || &#10004;
  +
|-
  +
| derived [[#Ticket ID|ticket ID]]|| TGT || service or referral TGT
  +
|-
  +
|rowspan=2|Encrypt reply
  +
| KDC reply ||&#10004; || &#10004;
  +
|-
  +
| Reply-encrypting key enctype (long-term) ||&#10004; || &#10004;
  +
|-
  +
|rowspan=1|All phases
  +
| Additional info(KDC status,policy details,etc)|| &#10004; ||&#10004;
  +
|-
  +
|}
   
TODO: Consider a new authorization data element AD_TKT_ID per http://tools.ietf.org/html/draft-ietf-krb-wg-cammac-03 draft to securely communicate ticket id between Kerberos exchange participants.
+
The following information will be made available to audit plugins:
   
+
: a unique [[#Request ID| request ID ]]
=== Design 2 (newer) ===
+
: the complete KDC request structure
  +
: the KDC reply structure (possibly only partially populated)
  +
: the client's IP address and port number
  +
: the stage of KDC processing at which the audit event was triggered
  +
: the KDC status string (as appears in kdc.log)
  +
: [[#Ticket ID|ticket IDs]] (checksums) for any supplied tickets or ticket to be returned
  +
: the remote client's realm (for referrals)
  +
: the impersonated user for an S4U2Self request
  +
: the "type of violation" which caused the request to fail, if applicable
   
This approach is based on serialization of the KDC auditable events.
+
Other events to consider for the future development:
   
==== KDC facing API ====
+
3. Further details about policy viloations
  +
:Event description, reason and how to fix it;
  +
4. Secrets (Common Criteria FCS_CKM.1, FCS_CKM.4);
  +
:long- and short-term key creation, manipulation, cleaning.
   
/* Load/unload Audit plugin */
+
== Design details ==
krb5_error_code
 
load_audit_plugin(krb5_context context);
 
krb5_error_code
 
unload_audit_plugin(krb5_context context);
 
 
/* Record KDC event */
 
krb5_error_code
 
kau_kdc_event(krb5_context context, const int event_id, const int status, const char *audit_str);
 
   
/* Helpers */
+
====Ticket ID====
+
Ticket ID is recorded as part of audit messages. This allows to link tickets to their initial TGT at any stage of the Kerberos exchange.
/* Check if Audit plugin is loaded */
 
krb5_boolean
 
kau_isloaded(krb5_context context);
 
 
/* Create a ticket ID */
 
krb5_error_code
 
kau_make_tkt_id(const krb5_keyblock sk, char **out);
 
 
/* Basic serialization functions */
 
krb5_error_code
 
kau_jenc_shandle(krb5_context context, int event_id, int status,
 
struct server_handle shdl, char **out);
 
krb5_error_code
 
kau_jenc_asreq(krb5_context context, int event_id, int status,
 
struct as_req_state *state, char **out);
 
krb5_error_code
 
kau_jenc_tgsreq(krb5_context context, int event_id, int status,
 
struct tgs_reg_state *state, char **out);
 
   
==== Pluggable interface ====
+
For the purpose of this project we will create a private to KDC ticket ID: each successfully created ticket will be hashed and recorded into audit log. The administrators will correlate the primary and derived ticket IDs after the fact.
   
/* Audit plugin vtable */
+
For the future, however, we need a more complex system that would allow to tie the tickets from a successful AS_REQ all the way to the application server. It is marked as an action item in [[#Future work|this]] section.
typedef struct krb5_audit_vtable_st {
 
/* Mandatory: name of module. */
 
char *name;
 
kau_open_fn open;
 
kau_close_fn close;
 
kau_record_fn record;
 
} *krb5_audit_vtable;
 
   
typedef krb5_error_code
+
====Request ID====
(*kau_open_fn)(kau_ctx *au_ctx);
+
Request ID is a randomly generated alpha-numeric string. Using this ID an administrator can easily correlate multiple audit events related to a single request. It should be informative both in cases when the request is sent to multiple KDCs, or to the same KDC multiple times.
 
typedef krb5_error_code
 
(*kau_close_fn)(kau_ctx au_ctx);
 
 
typedef krb5_error_code
 
(*kau_record_fn)(kau_ctx au_ctx, const int event_id, const int status,
 
const char *audit_string);
 
   
+
=== KDC facing API ===
=== Design 1 (older) ===
 
 
This design exercises the idea of one-API-per-KDC-event.
 
 
==== KDC facing API ====
 
   
 
/* Audit plugin loaded/unloaded */
 
/* Audit plugin loaded/unloaded */
Line 55: Line 56:
 
krb5_error_code
 
krb5_error_code
 
unload_audit_plugin(krb5_context context);
 
unload_audit_plugin(krb5_context context);
+
krb5_boolean
/* KDC started /stopped */
+
kau_isloaded(krb5_context context);
krb5_error_code
+
/* event specific functions */
kau_kdc_start(krb5_context context, int status);
 
krb5_error_code
 
kau_kdc_stop(krb5_context context, krb5_error_code status);
 
 
/* AS exchange: Successful (status=1) or unsuccessful (status=0) attempt */
 
krb5_error_code
 
kau_as_req(krb5_context context, struct as_req_state *state, int status);
 
krb5_error_code
 
kau_as_req_pa(krb5_context context, struct as_req_state *state, int status);
 
 
/* TGS exchange: Successful (status=1) or unsuccessful (status=0) attempt; alternate, u2u, s4u and cross-realm TGS */
 
krb5_error_code
 
kau_tgs(krb5_context context,
 
struct tgs_req_audit_state *state, int status);
 
krb5_error_code
 
kau_tgs_alt(krb5_context context,
 
struct tgs_req_audit_state *state, int status);
 
 
krb5_error_code
 
krb5_error_code
kau_tgs_u2u(krb5_context context, struct tgs_req_audit_state *state,
+
kau_kdc_start(krb5_context context, const int event_id, const int status);
krb5_principal cl2, int status);
 
 
krb5_error_code
 
krb5_error_code
kau_tgs_xrealm(krb5_context context, struct tgs_req_audit_state *state,
+
kau_kdc_stop(krb5_context context, const int event_id, const int status);
char* xrealm, int status);
 
 
/* Policy driven events - TBD */
 
 
krb5_error_code
 
krb5_error_code
kau_policy_as_req(krb5_context context, struct as_req_state *state,
+
kau_asreq(krb5_context context, const int event_id, const int status, audit_state *state);
krb5_error_code status);
 
 
krb5_error_code
 
krb5_error_code
kau_policy_s4u2proxy_req(krb5_context context, struct tgs_req_audit_state *state,
+
kau_tgsreq(krb5_context context, const int event_id, const int status, audit_state *state);
krb5_db_entry *st_client, krb5_error_code status);
 
 
krb5_error_code
 
krb5_error_code
kau_policy_tgs_req(krb5_context context, struct tgs_req_audit_state *state,
+
kau_s4u2self(krb5_context context, const int event_id, const int status, audit_state *state);
krb5_ticket *header_ticket, krb5_error_code status);
+
krb5_error_code
  +
kau_s4u2proxy(krb5_context context, const int event_id, const int status, audit_state *state);
  +
krb5_error_code
  +
kau_u2u(krb5_context context, const int event_id, const int status, audit_state *state);
  +
/* utilities */
  +
krb5_error_code
  +
kau_init_kdc_req(krb5_context context, krb5_kdc_req *request, const krb5_fulladdr *from, audit_state **au_state);
  +
krb5_error_code
  +
kau_make_tkt_id(krb5_context context, const krb5_ticket *ticket, char **out);
  +
krb5_error_code
  +
kau_make_req_id(krb5_context context, const krb5_kdc_req *request, char **out);
   
/* Session key generation and cleaning up */
+
where ''event_id'' references to the ''Phase'' (left column of [[#Events| events]] table), and ''audit_state'' structure holds the following information:
krb5_error_code
 
kau_sesskey_as_generated(krb5_context context,
 
struct as_req_state *state, int status);
 
krb5_error_code
 
kau_sesskey_as_cleared(krb5_context context,
 
struct as_req_state *state, int status);
 
krb5_error_code
 
kau_sesskey_tgs_generated(krb5_context context,
 
struct tgs_req_audit_state *state,int status);
 
krb5_error_code
 
kau_sesskey_tgs_cleared(krb5_context context,
 
struct tgs_req_audit_state *state, int status);
 
   
/* Name of audit module */
+
typedef struct _audit_state {
krb5_error_code
+
krb5_kdc_req *req_in; /* request in the original form */
kau_plugin_name(krb5_context context, char **name);
+
krb5_kdc_req *req_mod; /* modified (per protocol) request */
+
krb5_kdc_rep *reply;
struct as_req_state {
 
loop_respond_fn respond;
 
void *arg;
 
...
 
kdc_realm_t *active_realm;
 
krb5_error_code preauth_err;
 
char *tkt_id;
 
};
 
 
struct tgs_req_audit_state {
 
krb5_kdc_req *request;
 
krb5_timestamp authtime;
 
char *sname, *cname, *s4u_name, *u2ucname;
 
krb5_principal altprinc;
 
char *xrealm;
 
 
const krb5_fulladdr *from;
 
const krb5_fulladdr *from;
unsigned int c_flags;
+
const char *status; /* additional information string */
const char *status; /* KDC status message */
+
char *tkt_in_id; /* primary (TGT) ticket ID */
krb5_enctype useenctype;
+
char *tkt_out_id; /* derived (service or referral TGT) ticket ID */
  +
char *evid_tkt_id; /* for s4u2proxy - user's evidence ticket ID, for u2u - TGT ticket ID */
  +
char *req_in_id; /* original-request ID */
  +
char *req_mod_id; /* modified-request ID */
  +
krb5_int32 sess_etype; /* session key enctype */
  +
krb5_int32 srv_etype; /* enctype of the long-term key of service */
  +
krb5_int32 rep_etype; /* reply-encrypting key enctype */
 
krb5_boolean tkt_renewed;
 
krb5_boolean tkt_renewed;
krb5_boolean is_referral;
+
krb5_boolean tkt_validated;
char *tkt_id;
+
/* referrals */
};
+
krb5_data *cl_realm; /* remote client's realm */
  +
/* s4u and u2u */
  +
krb5_principal s4u2self_user; /* impersonated user */
  +
krb5_principal s4u2proxy_user; /* delegated user */
  +
krb5_principal u2u_user; /* client for the second ticket */
  +
char *violation; /* local or protocol policy problem */
  +
} audit_state;
   
==== Pluggable interface ====
+
=== Pluggable interface ===
   
 
/* Audit plugin vtable */
 
/* Audit plugin vtable */
 
typedef struct krb5_audit_vtable_st {
 
typedef struct krb5_audit_vtable_st {
 
/* Mandatory: name of module. */
 
/* Mandatory: name of module. */
char *name;
+
char *name;
kau_open_fn open;
+
int conf_options;
kau_close_fn close;
+
kau_open_fn open;
kau_kdc_start_fn kdc_start;
+
kau_close_fn close;
kau_kdc_stop_fn kdc_stop;
+
kau_kdc_start_fn kdc_start;
kau_as_req_fn as_req;
+
kau_kdc_stop_fn kdc_stop;
kau_tgs_fn tgs;
+
kau_as_req_fn as_req;
kau_tgs_alt_fn tgs_alt;
+
kau_tgs_req_fn tgs_req;
kau_tgs_u2u_fn tgs_u2u;
+
kau_s4u2self_fn tgs_s4u2self;
kau_tgs_xrealm_fn tgs_xrealm;
+
kau_s4u2proxy_fn tgs_s4u2proxy;
kau_policy_as_req_fn policy_as_req;
+
kau_u2u_fn tgs_u2u;;
kau_policy_tgs_req_fn policy_tgs_req;
 
kau_policy_s4u2proxy_req_fn policy_s4u2proxy_req;
 
kau_sesskey_as_generated_fn sesskey_as_generated;
 
kau_sesskey_as_cleared_fn sesskey_as_cleared;
 
kau_sesskey_tgs_generated_fn sesskey_tgs_generated;
 
kau_sesskey_tgs_cleared_fn sesskey_tgs_cleared;
 
 
} *krb5_audit_vtable;
 
} *krb5_audit_vtable;
+
 
typedef krb5_error_code
 
typedef krb5_error_code
 
(*kau_open_fn)(kau_ctx *au_ctx);
 
(*kau_open_fn)(kau_ctx *au_ctx);
 
 
typedef krb5_error_code
 
typedef krb5_error_code
 
(*kau_close_fn)(kau_ctx au_ctx);
 
(*kau_close_fn)(kau_ctx au_ctx);
 
 
typedef krb5_error_code
 
typedef krb5_error_code
(*kau_kdc_start_fn)(kau_ctx au_ctx,
+
(*kau_kdc_start_fn)(kau_ctx au_ctx, const int event_id, int status);
krb5_deltat clockskew, const char *realm_port,
 
krb5_boolean allow_weak_crypto,
 
const char *plugins, const char *plugin_dir, int status);
 
 
 
typedef krb5_error_code
 
typedef krb5_error_code
(*kau_kdc_stop_fn)(kau_ctx au_ctx, krb5_error_code status);
+
(*kau_kdc_stop_fn)(kau_ctx au_ctx, const int event_id, int status);
 
typedef krb5_error_code
 
(*kau_as_req_fn)(kau_ctx au_ctx, const char *tkt_id,
 
const char *cname, const char *sname,
 
const int from_port, krb5_enctype sesskey_etype,
 
krb5_flags tkt_flags, const char *tkt_cname,
 
krb5_deltat tkt_start_time, krb5_deltat tkt_end_time, krb5_deltat tkt_renew_till,
 
const char *kdc_status, int status);
 
 
typedef krb5_error_code
 
(*kau_tgs_fn)(kau_ctx au_ctx, const char *tkt_id,
 
krb5_timestamp authtime,
 
const char *cname, const char *sname,
 
const int from_port, krb5_enctype session_key_etype,
 
const int is_referral, const int tkt_renewed,
 
krb5_flags tkt_flags, krb5_deltat tkt_start_time,
 
krb5_deltat tkt_end_time, krb5_deltat tkt_renew_till,
 
const char *kdc_status, int status);
 
 
typedef krb5_error_code
 
(*kau_tgs_alt_fn)(kau_ctx au_ctx, const char *tkt_id,
 
krb5_timestamp authtime,
 
const char *cname, const char *sname, const char *altsrv,
 
const int from_port, const char *kdc_status, int status);
 
 
typedef krb5_error_code
 
(*kau_tgs_u2u_fn)(kau_ctx au_ctx, const char *tkt_id,
 
krb5_timestamp authtime,
 
const char *cname, const char *sname,
 
const char *cl2, const char *srv2,
 
const int from_port, const char *kdc_status, int status);
 
 
 
typedef krb5_error_code
 
typedef krb5_error_code
(*kau_tgs_xrealm_fn)(kau_ctx au_ctx, const char *tkt_id,
+
(*kau_as_req_fn)(kau_ctx au_ctx, const int event_id, int status, audit_state *state);
krb5_timestamp authtime,
 
const char *cname, const char *sname, const char *xrealm,
 
krb5_flags c_flags, krb5_flags s_flags,
 
const int from_port, const char *kdc_status, int status);
 
 
 
typedef krb5_error_code
 
typedef krb5_error_code
(*kau_sesskey_as_generated_fn)(kau_ctx au_ctx, const char *tkt_id,
+
(*kau_tgs_req_fn)(kau_ctx au_ctx, const int event_id, int status, audit_state *state);
const char *cname, const char *sname,
 
const int from_port,
 
const char * ktypes, krb5_enctype used_ktype,
 
const char *kdc_status, int status);
 
 
 
typedef krb5_error_code
 
typedef krb5_error_code
(*kau_sesskey_as_cleared_fn)(kau_ctx au_ctx, const char *tkt_id,
+
(*kau_s4u2self_fn)(kau_ctx au_ctx, const int event_id, int status, audit_state *state);
const char *cname, const char *sname,
 
const int from_port, krb5_enctype used_ktype,
 
const char *kdc_status, int status);
 
 
 
typedef krb5_error_code
 
typedef krb5_error_code
(*kau_sesskey_tgs_generated_fn)(kau_ctx au_ctx, const char *tkt_id,
+
(*kau_s4u2proxy_fn)(kau_ctx au_ctx, const int event_id, int status, audit_state *state);
const char *cname, const char *sname,
 
const int from_port,
 
const char *ktypes, krb5_enctype used_ktype,
 
const char *kdc_status, int status);
 
 
 
typedef krb5_error_code
 
typedef krb5_error_code
(*kau_sesskey_tgs_cleared_fn)(kau_ctx au_ctx, const char *tkt_id,
+
(*kau_u2u_fn)(kau_ctx au_ctx, const int event_id, int status, audit_state *state);
const char *cname, const char *sname,
+
const int from_port, krb5_enctype used_ktype,
+
const char *kdc_status, int status);
+
== JSON based audit module ==
  +
  +
We will use libaudit module available on Fedora, Debian, SuSe for the first round. The new JSON utility library will be built to parse Kerberos specific structures. The "simple" audit module will be statically linked to this library.
  +
  +
The following is a proposed ''Dictionary '' - the basic field names for JSON parsing:
  +
  +
{| class="wikitable" style="border: 3px solid #59121e"
  +
|+
  +
|-
  +
! Key
  +
! style="padding-left: 2em; padding-right: 2em;" | Type
  +
! Comments
  +
|-
  +
| event_success || style="padding-left: 2em "| INT || event was success or failure
  +
|-
  +
| event_name || style="padding-left: 2em "| STR || name of the event (KDC_START, AS_REQ etc)
  +
|-
  +
| stage || style="padding-left: 2em "| INT || stage in the KDC exchange processing
  +
|-
  +
| tkt_id_in || style="padding-left: 2em "| STR || primary (TGT) ticket ID
  +
|-
  +
| tkt_id_out || style="padding-left: 2em "| STR || derived (service or referral TGT) ticket ID
  +
|-
  +
| req_id || style="padding-left: 2em "| STR || request ID
  +
|-
  +
| kdc_status || style="padding-left: 2em "| STR|| Additional information string
  +
|-
  +
| fromaddr || style="padding-left: 2em "| STR || client's address
  +
|-
  +
| fromport || style="padding-left: 2em "| NUM || client's port
  +
|-
  +
|sess_etype || style="padding-left: 2em "| NUM || enctype of session key
  +
|-
  +
|rep_etype || style="padding-left: 2em "| NUM || enctype of reply-encrypting key
  +
|-
  +
|srv_etype || style="padding-left: 2em "| NUM || enctype of long-term key of the service key
  +
|-
  +
|tkt_renewed|| style="padding-left: 2em "| BOOL || was ticket renewed
  +
|-
  +
|tkt_validated|| style="padding-left: 2em "| BOOL || was ticket validated
  +
|-
  +
|req.addresses || style="padding-left: 2em "| STR || requested addresses
  +
|-
  +
|req.avail_etypes || style="padding-left: 2em "| STR || requested/available enc types
  +
|-
  +
|req.kdc_options || style="padding-left: 2em "| NUM || KDC options (forwardable, allow_postdate etc)
  +
|-
  +
|req.tkt_start || style="padding-left: 2em "| NUM || requested ticket start time
  +
|-
  +
|req.tkt_end || style="padding-left: 2em "| NUM || requested ticket end time
  +
|-
  +
|req.tkt_renew_till || style="padding-left: 2em "| NUM || requested ticket renew-till time
  +
|-
  +
|req.tkt_authtime || style="padding-left: 2em "| NUM || requested ticket authtime
  +
|-
  +
| req.sectkt_cname|| style="padding-left: 2em "| STR || client principal in the second ticket (U2U etc)
  +
|-
  +
| req.sectkt_sname|| style="padding-left: 2em "| STR || service principal in the second ticket
  +
|-
  +
| req.sectkt_flags|| style="padding-left: 2em "| NUM || second ticket flags
  +
|-
  +
| req.sectkt_start|| style="padding-left: 2em "| NUM || second ticket start time
  +
|-
  +
| req.sectkt_end|| style="padding-left: 2em "| NUM || second ticket end time
  +
|-
  +
| req.sectkt_authtime|| style="padding-left: 2em "| NUM || second ticket authtime
  +
|-
  +
| req.sectkt_etype|| style="padding-left: 2em "| NUM || second ticket key type
  +
|-
  +
|req.sname || style="padding-left: 2em "| STR || requested service principal
  +
|-
  +
| req.cname || style="padding-left: 2em "| STR || client's principal
  +
|-
  +
|rep.sname || style="padding-left: 2em "| STR || service principal in ticket
  +
|-
  +
| rep.cname || style="padding-left: 2em "| STR || client principal in ticket
  +
|-
  +
| rep.pa_type || style="padding-left: 2em "| STR || reply preauth types
  +
|-
  +
| rep.rep_authtime || style="padding-left: 2em "| NUM || ticket authtime
  +
|-
  +
| rep.tkt_start || style="padding-left: 2em "| NUM || ticket start time
  +
|-
  +
| rep.tkt_end || style="padding-left: 2em "| NUM || ticket end time
  +
|-
  +
| rep.tkt_renew_till|| style="padding-left: 2em "| NUM || ticket renewed-till time
  +
|-
  +
|rep.tr_contents|| style="padding-left: 2em "| STR|| ticket transited-realms list
  +
|-
  +
|}
   
 
== Configuration ==
 
== Configuration ==
   
The following ./configure option to be added:
+
The following ./configure option to be added:
   
;--with-audit-plugin=simple: (For demo and testing purposes) Build the audit plugin "simple" and enable audit plugin.
+
--with-audit-plugin
   
  +
For example,'' --with-audit-plugin=simple'', where ''simple'' is the name of the audit plugin module
   
== Test implementation ==
 
   
We will use libaudit module available on Fedora, Debian, Suse for the first round.
+
== Test ==
  +
  +
A testable audit module, k5audit_test, will be built, and enabled for a python test program which is added. This test module uses the internal libauditjenc library to generate a JSON encoding of the audit event, and writes that encoded string to a flat file, which is parsed by the python test program.
  +
  +
  +
==Future work==
  +
  +
# Standardize a ''Ticket ID'';
  +
# Make reporting auditable events configurable. For example, one can choose to report TGS_REQ, but not AS_REQ;
  +
# Sanitize ''KDC request'' and ''KDC reply'' before passing them to the concrete audit implementation: security sensitive information should not leave KDC boundaries;
  +
# Develop audit system for Preauth and Authdata mechanisms;
  +
# Expand Kerberos Audit facility to the application servers and kadmin.
   
Some "simple" audit plugin will be implemented and Python test system will become aware of its existence. New ./configure --with-audit-plugin option will be introduced to build "simple" audit plugin for testing purpose. If audit is enabled and audit plugin is available, "make check" will store audit messages into audit log file.
 
   
 
== References ==
 
== References ==
Line 147: Line 145:
 
# Advanced Security Audit Policy Settings http://technet.microsoft.com/en-us/library/dd772712(v=ws.10).aspx
 
# Advanced Security Audit Policy Settings http://technet.microsoft.com/en-us/library/dd772712(v=ws.10).aspx
 
# Events Classification in Log Audit http://airccse.org/journal/nsa/0410ijnsa5.pdf
 
# Events Classification in Log Audit http://airccse.org/journal/nsa/0410ijnsa5.pdf
  +
# CEE Log Syntax (CLS) Encoding http://cee.mitre.org/language/1.0-beta1/cls.html
  +
  +
  +
== Commits ==
  +
  +
e63b2c9b0ed3b19f6aa1ac90222240690a1bc55b KDC Audit infrastructure and plugin implementation
  +
1003f0173f266a6428ccf2c89976f0029d3ee831 KDC Audit infrastructure and plugin implementation (merged)
  +
5036f91e7b61a73a1ec2d39ce1cc6bbf60dd82ab Fix audit test module initialization
  +
  +
Completed in {{bug|7712}} and {{bug|7713}}
  +
  +
  +
== Release Notes ==
  +
  +
Administrator experience:
  +
  +
* Add an experimental pluggable interface for auditing KDC processing. This interface may change in a backwards-incompatible way in a future release.

Latest revision as of 13:01, 29 October 2013

This project was completed in release 1.12.


Contents

[edit] Description

This project creates a pluggable audit interface to allow the monitoring of security-related events on the KDC.

The interface is considered "experimental", in that API stability is not guaranteed to future major releases.

[edit] Requirements

The new audit system should be:

  • build-time enabled;
  • run-time pluggable;
  • simple and flexible, so it could be easily replaced with the OS specific and third-parties implementations;


[edit] Events

We consider events under the categorization of the Common Criteria Class FIA.

This section details the categories of the auditable events and the associated data.

1. Startup and shutdown of the KDC must be recorded by audit system;

2. The bulk of the audit information will be produced while processing AS and TGS requests. Though KDC request processing can be grouped into several logical phases, we generate (usually) only two events, one at the initial receipt of a request, and a second, final, one before sending a reply. All events relating to the same request can be linked together in the audit log by a 32-character alphanumeric string (about 190 bits of uniqueness) which is randomly generated at the start of processing. If the request is a S4U2Self or S4U2Proxy request, an additional audit event will be generated with information particular to the S4U request. The following table lists the logical stages of KDC processing, and which components are logged in the AS and TGS cases:

Phase Data to be logged AS_REQ TGS_REQ
Authenticate request content and client client’s address and port
original KDC request and request ID
primary ticket ID (S4U:front-end server's) TGT
Determine service principal modified KDC request and request ID
cross-realm referral service principal, TGS
user-to-user: client in the 2nd ticket
Validate policies local policy violation
protocol constraints S4U2Proxy, S4U2Self
Issue ticket ticket renewed
ticket validated
session key enctype (short-term)
enctype of the service's long-term key
derived ticket ID TGT service or referral TGT
Encrypt reply KDC reply
Reply-encrypting key enctype (long-term)
All phases Additional info(KDC status,policy details,etc)

The following information will be made available to audit plugins:

a unique request ID
the complete KDC request structure
the KDC reply structure (possibly only partially populated)
the client's IP address and port number
the stage of KDC processing at which the audit event was triggered
the KDC status string (as appears in kdc.log)
ticket IDs (checksums) for any supplied tickets or ticket to be returned
the remote client's realm (for referrals)
the impersonated user for an S4U2Self request
the "type of violation" which caused the request to fail, if applicable

Other events to consider for the future development:

3. Further details about policy viloations

Event description, reason and how to fix it;

4. Secrets (Common Criteria FCS_CKM.1, FCS_CKM.4);

long- and short-term key creation, manipulation, cleaning.

[edit] Design details

[edit] Ticket ID

Ticket ID is recorded as part of audit messages. This allows to link tickets to their initial TGT at any stage of the Kerberos exchange.

For the purpose of this project we will create a private to KDC ticket ID: each successfully created ticket will be hashed and recorded into audit log. The administrators will correlate the primary and derived ticket IDs after the fact.

For the future, however, we need a more complex system that would allow to tie the tickets from a successful AS_REQ all the way to the application server. It is marked as an action item in this section.

[edit] Request ID

Request ID is a randomly generated alpha-numeric string. Using this ID an administrator can easily correlate multiple audit events related to a single request. It should be informative both in cases when the request is sent to multiple KDCs, or to the same KDC multiple times.

[edit] KDC facing API

/* Audit plugin loaded/unloaded */
krb5_error_code 
load_audit_plugin(krb5_context context);
krb5_error_code 
unload_audit_plugin(krb5_context context);
krb5_boolean
kau_isloaded(krb5_context context);
/* event specific functions */
krb5_error_code
kau_kdc_start(krb5_context context, const int event_id, const int status);
krb5_error_code
kau_kdc_stop(krb5_context context, const int event_id, const int status);
krb5_error_code
kau_asreq(krb5_context context, const int event_id, const int status, audit_state *state);
krb5_error_code
kau_tgsreq(krb5_context context, const int event_id, const int status, audit_state *state);
krb5_error_code
kau_s4u2self(krb5_context context, const int event_id, const int status,  audit_state *state);
krb5_error_code
kau_s4u2proxy(krb5_context context, const int event_id, const int status, audit_state *state);
krb5_error_code
kau_u2u(krb5_context context, const int event_id, const int status, audit_state *state);
/* utilities */
krb5_error_code
kau_init_kdc_req(krb5_context context, krb5_kdc_req *request,  const krb5_fulladdr *from, audit_state **au_state);
krb5_error_code
kau_make_tkt_id(krb5_context context, const krb5_ticket *ticket, char **out);
krb5_error_code
kau_make_req_id(krb5_context context, const krb5_kdc_req *request, char **out);

where event_id references to the Phase (left column of events table), and audit_state structure holds the following information:

typedef struct _audit_state {
   krb5_kdc_req *req_in;   /* request in the original form */
   krb5_kdc_req *req_mod;  /* modified (per protocol) request */
   krb5_kdc_rep  *reply;
   const krb5_fulladdr *from;
   const char    *status; /* additional information string */
   char *tkt_in_id;       /* primary (TGT) ticket ID */
   char *tkt_out_id;      /* derived (service or referral TGT) ticket ID */
   char *evid_tkt_id;     /* for s4u2proxy - user's evidence ticket ID, for u2u - TGT ticket ID */
   char *req_in_id;       /* original-request ID */
   char *req_mod_id;      /* modified-request ID */
   krb5_int32 sess_etype; /* session key enctype */
   krb5_int32 srv_etype;  /* enctype of the long-term key of service */
   krb5_int32 rep_etype;  /* reply-encrypting key enctype */
   krb5_boolean tkt_renewed;
   krb5_boolean tkt_validated;
   /* referrals */
   krb5_data *cl_realm;   /* remote client's realm */
   /* s4u and u2u */
   krb5_principal s4u2self_user;  /* impersonated user */
   krb5_principal s4u2proxy_user; /* delegated user */
   krb5_principal u2u_user;       /* client for the second ticket */
   char *violation;               /* local or protocol policy problem */
} audit_state;

[edit] Pluggable interface

/* Audit plugin vtable */
typedef struct krb5_audit_vtable_st {
   /* Mandatory: name of module. */
   char                 *name;
   int                   conf_options;
   kau_open_fn           open;
   kau_close_fn          close;
   kau_kdc_start_fn      kdc_start;
   kau_kdc_stop_fn       kdc_stop;
   kau_as_req_fn         as_req;
   kau_tgs_req_fn        tgs_req;
   kau_s4u2self_fn       tgs_s4u2self;
   kau_s4u2proxy_fn      tgs_s4u2proxy;
   kau_u2u_fn            tgs_u2u;;
} *krb5_audit_vtable;
 
typedef krb5_error_code
(*kau_open_fn)(kau_ctx *au_ctx);
typedef krb5_error_code
(*kau_close_fn)(kau_ctx au_ctx);
typedef krb5_error_code
(*kau_kdc_start_fn)(kau_ctx au_ctx, const int event_id, int status);
typedef krb5_error_code
(*kau_kdc_stop_fn)(kau_ctx au_ctx, const int event_id, int status);
typedef krb5_error_code
(*kau_as_req_fn)(kau_ctx au_ctx, const int event_id, int status, audit_state *state);
typedef krb5_error_code
(*kau_tgs_req_fn)(kau_ctx au_ctx, const int event_id, int status, audit_state *state);
typedef krb5_error_code
(*kau_s4u2self_fn)(kau_ctx au_ctx, const int event_id, int status,  audit_state *state);
typedef krb5_error_code
(*kau_s4u2proxy_fn)(kau_ctx au_ctx, const int event_id, int status,  audit_state *state);
typedef krb5_error_code
(*kau_u2u_fn)(kau_ctx au_ctx, const int event_id, int status, audit_state *state);


[edit] JSON based audit module

We will use libaudit module available on Fedora, Debian, SuSe for the first round. The new JSON utility library will be built to parse Kerberos specific structures. The "simple" audit module will be statically linked to this library.

The following is a proposed Dictionary - the basic field names for JSON parsing:

Key Type Comments
event_success INT event was success or failure
event_name STR name of the event (KDC_START, AS_REQ etc)
stage INT stage in the KDC exchange processing
tkt_id_in STR primary (TGT) ticket ID
tkt_id_out STR derived (service or referral TGT) ticket ID
req_id STR request ID
kdc_status STR Additional information string
fromaddr STR client's address
fromport NUM client's port
sess_etype NUM enctype of session key
rep_etype NUM enctype of reply-encrypting key
srv_etype NUM enctype of long-term key of the service key
tkt_renewed BOOL was ticket renewed
tkt_validated BOOL was ticket validated
req.addresses STR requested addresses
req.avail_etypes STR requested/available enc types
req.kdc_options NUM KDC options (forwardable, allow_postdate etc)
req.tkt_start NUM requested ticket start time
req.tkt_end NUM requested ticket end time
req.tkt_renew_till NUM requested ticket renew-till time
req.tkt_authtime NUM requested ticket authtime
req.sectkt_cname STR client principal in the second ticket (U2U etc)
req.sectkt_sname STR service principal in the second ticket
req.sectkt_flags NUM second ticket flags
req.sectkt_start NUM second ticket start time
req.sectkt_end NUM second ticket end time
req.sectkt_authtime NUM second ticket authtime
req.sectkt_etype NUM second ticket key type
req.sname STR requested service principal
req.cname STR client's principal
rep.sname STR service principal in ticket
rep.cname STR client principal in ticket
rep.pa_type STR reply preauth types
rep.rep_authtime NUM ticket authtime
rep.tkt_start NUM ticket start time
rep.tkt_end NUM ticket end time
rep.tkt_renew_till NUM ticket renewed-till time
rep.tr_contents STR ticket transited-realms list

[edit] Configuration

The following ./configure option to be added:

--with-audit-plugin

For example, --with-audit-plugin=simple, where simple is the name of the audit plugin module


[edit] Test

A testable audit module, k5audit_test, will be built, and enabled for a python test program which is added. This test module uses the internal libauditjenc library to generate a JSON encoding of the audit event, and writes that encoded string to a flat file, which is parsed by the python test program.


[edit] Future work

  1. Standardize a Ticket ID;
  2. Make reporting auditable events configurable. For example, one can choose to report TGS_REQ, but not AS_REQ;
  3. Sanitize KDC request and KDC reply before passing them to the concrete audit implementation: security sensitive information should not leave KDC boundaries;
  4. Develop audit system for Preauth and Authdata mechanisms;
  5. Expand Kerberos Audit facility to the application servers and kadmin.


[edit] References

  1. Common Criteria for Information Technology Security Evaluation http://www.commoncriteriaportal.org/files/ccfiles/CCPART2V3.1R4.pdf
  2. Oracle Solaris Auditing http://docs.oracle.com/cd/E19963-01/html/821-1456/auditov-1.html
  3. Understanding Linux Audit http://doc.opensuse.org/products/draft/SLES/SLES-security_sd_draft/cha.audit.comp.html
  4. Advanced Security Audit Policy Settings http://technet.microsoft.com/en-us/library/dd772712(v=ws.10).aspx
  5. Events Classification in Log Audit http://airccse.org/journal/nsa/0410ijnsa5.pdf
  6. CEE Log Syntax (CLS) Encoding http://cee.mitre.org/language/1.0-beta1/cls.html


[edit] Commits

   e63b2c9b0ed3b19f6aa1ac90222240690a1bc55b KDC Audit infrastructure and plugin implementation
   1003f0173f266a6428ccf2c89976f0029d3ee831 KDC Audit infrastructure and plugin implementation (merged)
   5036f91e7b61a73a1ec2d39ce1cc6bbf60dd82ab Fix audit test module initialization

Completed in [krbdev.mit.edu #7712] and [krbdev.mit.edu #7713]


[edit] Release Notes

Administrator experience:

  • Add an experimental pluggable interface for auditing KDC processing. This interface may change in a backwards-incompatible way in a future release.
Personal tools