security_events: log events with descriptive names
[asterisk/asterisk.git] / main / security_events.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012, Digium, Inc.
5  *
6  * Russell Bryant <russell@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  *
22  * \brief Security Event Reporting Helpers
23  *
24  * \author Russell Bryant <russell@digium.com>
25  */
26
27 /*** MODULEINFO
28         <support_level>core</support_level>
29  ***/
30
31 #include "asterisk.h"
32
33 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
34
35 #include "asterisk/utils.h"
36 #include "asterisk/strings.h"
37 #include "asterisk/network.h"
38 #include "asterisk/event.h"
39 #include "asterisk/security_events.h"
40 #include "asterisk/netsock2.h"
41 #include "asterisk/stasis.h"
42 #include "asterisk/json.h"
43 #include "asterisk/astobj2.h"
44
45 static const size_t TIMESTAMP_STR_LEN = 32;
46 static const size_t SECURITY_EVENT_BUF_INIT_LEN = 256;
47
48 /*! \brief Security Topic */
49 static struct stasis_topic *security_topic;
50
51 struct stasis_topic *ast_security_topic(void)
52 {
53         return security_topic;
54 }
55
56 static int append_event_str_single(struct ast_str **str, struct ast_json *json,
57                 const enum ast_event_ie_type ie_type)
58 {
59         const char *ie_type_key = ast_event_get_ie_type_name(ie_type);
60         struct ast_json *json_string = ast_json_object_get(json, ie_type_key);
61
62         ast_assert(json_string != NULL);
63
64         if (ast_str_append(str, 0, "%s: %s\r\n", ie_type_key, ast_json_string_get(json_string)) == -1) {
65                 return -1;
66         }
67
68         return 0;
69 }
70
71 static int append_event_str_from_json(struct ast_str **str, struct ast_json *json,
72                 const struct ast_security_event_ie_type *ies)
73 {
74         unsigned int i;
75
76         for (i = 0; ies[i].ie_type != AST_EVENT_IE_END; i++) {
77                 if (append_event_str_single(str, json, ies[i].ie_type)) {
78                         return -1;
79                 }
80         }
81
82         return 0;
83 }
84
85 static struct ast_manager_event_blob *security_event_to_ami_blob(struct ast_json *json)
86 {
87         RAII_VAR(struct ast_str *, str, NULL, ast_free);
88         struct ast_json *event_type_json;
89         enum ast_security_event_type event_type;
90
91         event_type_json = ast_json_object_get(json, "SecurityEvent");
92         event_type = ast_json_integer_get(event_type_json);
93
94         ast_assert(event_type >= 0 && event_type < AST_SECURITY_EVENT_NUM_TYPES);
95
96         if (!(str = ast_str_create(SECURITY_EVENT_BUF_INIT_LEN))) {
97                 return NULL;
98         }
99
100         if (append_event_str_from_json(&str, json,
101                         ast_security_event_get_required_ies(event_type))) {
102                 ast_log(LOG_ERROR, "Failed to issue a security event to AMI.\n");
103                 return NULL;
104         }
105
106         return ast_manager_event_blob_create(EVENT_FLAG_SECURITY,
107                 ast_security_event_get_name(event_type),
108                 "%s",
109                 ast_str_buffer(str));
110 }
111
112 static struct ast_manager_event_blob *security_event_to_ami(struct stasis_message *message)
113 {
114         struct ast_json_payload *payload = stasis_message_data(message);
115
116         if (stasis_message_type(message) != ast_security_event_type()) {
117                 return NULL;
118         }
119
120         if (!payload) {
121                 return NULL;
122         }
123
124         return security_event_to_ami_blob(payload->json);
125 }
126
127 /*! \brief Message type for security events */
128 STASIS_MESSAGE_TYPE_DEFN(ast_security_event_type,
129         .to_ami = security_event_to_ami,
130         );
131
132 static void security_stasis_cleanup(void)
133 {
134         ao2_cleanup(security_topic);
135         security_topic = NULL;
136
137         STASIS_MESSAGE_TYPE_CLEANUP(ast_security_event_type);
138 }
139
140 int ast_security_stasis_init(void)
141 {
142         ast_register_cleanup(security_stasis_cleanup);
143
144         security_topic = stasis_topic_create("ast_security");
145         if (!security_topic) {
146                 return -1;
147         }
148
149         if (STASIS_MESSAGE_TYPE_INIT(ast_security_event_type)) {
150                 return -1;
151         }
152
153
154         return 0;
155 }
156
157 static const struct {
158         const char *name;
159         uint32_t version;
160         enum ast_security_event_severity severity;
161 #define MAX_SECURITY_IES 12
162         struct ast_security_event_ie_type required_ies[MAX_SECURITY_IES];
163         struct ast_security_event_ie_type optional_ies[MAX_SECURITY_IES];
164 #undef MAX_SECURITY_IES
165 } sec_events[AST_SECURITY_EVENT_NUM_TYPES] = {
166
167 #define SEC_EVT_FIELD(e, field) (offsetof(struct ast_security_event_##e, field))
168
169 [AST_SECURITY_EVENT_FAILED_ACL] = {
170         .name     = "FailedACL",
171         .version  = AST_SECURITY_EVENT_FAILED_ACL_VERSION,
172         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
173         .required_ies = {
174                 { AST_EVENT_IE_EVENT_TV, 0 },
175                 { AST_EVENT_IE_SEVERITY, 0 },
176                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
177                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
178                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
179                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
180                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
181                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
182                 { AST_EVENT_IE_END, 0 }
183         },
184         .optional_ies = {
185                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
186                 { AST_EVENT_IE_ACL_NAME, SEC_EVT_FIELD(failed_acl, acl_name) },
187                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
188                 { AST_EVENT_IE_END, 0 }
189         },
190 },
191
192 [AST_SECURITY_EVENT_INVAL_ACCT_ID] = {
193         .name     = "InvalidAccountID",
194         .version  = AST_SECURITY_EVENT_INVAL_ACCT_ID_VERSION,
195         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
196         .required_ies = {
197                 { AST_EVENT_IE_EVENT_TV, 0 },
198                 { AST_EVENT_IE_SEVERITY, 0 },
199                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
200                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
201                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
202                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
203                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
204                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
205                 { AST_EVENT_IE_END, 0 }
206         },
207         .optional_ies = {
208                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
209                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
210                 { AST_EVENT_IE_END, 0 }
211         },
212 },
213
214 [AST_SECURITY_EVENT_SESSION_LIMIT] = {
215         .name     = "SessionLimit",
216         .version  = AST_SECURITY_EVENT_SESSION_LIMIT_VERSION,
217         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
218         .required_ies = {
219                 { AST_EVENT_IE_EVENT_TV, 0 },
220                 { AST_EVENT_IE_SEVERITY, 0 },
221                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
222                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
223                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
224                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
225                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
226                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
227                 { AST_EVENT_IE_END, 0 }
228         },
229         .optional_ies = {
230                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
231                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
232                 { AST_EVENT_IE_END, 0 }
233         },
234 },
235
236 [AST_SECURITY_EVENT_MEM_LIMIT] = {
237         .name     = "MemoryLimit",
238         .version  = AST_SECURITY_EVENT_MEM_LIMIT_VERSION,
239         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
240         .required_ies = {
241                 { AST_EVENT_IE_EVENT_TV, 0 },
242                 { AST_EVENT_IE_SEVERITY, 0 },
243                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
244                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
245                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
246                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
247                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
248                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
249                 { AST_EVENT_IE_END, 0 }
250         },
251         .optional_ies = {
252                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
253                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
254                 { AST_EVENT_IE_END, 0 }
255         },
256 },
257
258 [AST_SECURITY_EVENT_LOAD_AVG] = {
259         .name     = "LoadAverageLimit",
260         .version  = AST_SECURITY_EVENT_LOAD_AVG_VERSION,
261         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
262         .required_ies = {
263                 { AST_EVENT_IE_EVENT_TV, 0 },
264                 { AST_EVENT_IE_SEVERITY, 0 },
265                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
266                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
267                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
268                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
269                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
270                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
271                 { AST_EVENT_IE_END, 0 }
272         },
273         .optional_ies = {
274                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
275                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
276                 { AST_EVENT_IE_END, 0 }
277         },
278 },
279
280 [AST_SECURITY_EVENT_REQ_NO_SUPPORT] = {
281         .name     = "RequestNotSupported",
282         .version  = AST_SECURITY_EVENT_REQ_NO_SUPPORT_VERSION,
283         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
284         .required_ies = {
285                 { AST_EVENT_IE_EVENT_TV, 0 },
286                 { AST_EVENT_IE_SEVERITY, 0 },
287                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
288                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
289                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
290                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
291                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
292                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
293                 { AST_EVENT_IE_REQUEST_TYPE, SEC_EVT_FIELD(req_no_support, request_type) },
294                 { AST_EVENT_IE_END, 0 }
295         },
296         .optional_ies = {
297                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
298                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
299                 { AST_EVENT_IE_END, 0 }
300         },
301 },
302
303 [AST_SECURITY_EVENT_REQ_NOT_ALLOWED] = {
304         .name     = "RequestNotAllowed",
305         .version  = AST_SECURITY_EVENT_REQ_NOT_ALLOWED_VERSION,
306         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
307         .required_ies = {
308                 { AST_EVENT_IE_EVENT_TV, 0 },
309                 { AST_EVENT_IE_SEVERITY, 0 },
310                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
311                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
312                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
313                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
314                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
315                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
316                 { AST_EVENT_IE_REQUEST_TYPE, SEC_EVT_FIELD(req_not_allowed, request_type) },
317                 { AST_EVENT_IE_END, 0 }
318         },
319         .optional_ies = {
320                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
321                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
322                 { AST_EVENT_IE_REQUEST_PARAMS, SEC_EVT_FIELD(req_not_allowed, request_params) },
323                 { AST_EVENT_IE_END, 0 }
324         },
325 },
326
327 [AST_SECURITY_EVENT_AUTH_METHOD_NOT_ALLOWED] = {
328         .name     = "AuthMethodNotAllowed",
329         .version  = AST_SECURITY_EVENT_AUTH_METHOD_NOT_ALLOWED_VERSION,
330         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
331         .required_ies = {
332                 { AST_EVENT_IE_EVENT_TV, 0 },
333                 { AST_EVENT_IE_SEVERITY, 0 },
334                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
335                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
336                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
337                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
338                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
339                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
340                 { AST_EVENT_IE_AUTH_METHOD, SEC_EVT_FIELD(auth_method_not_allowed, auth_method) },
341                 { AST_EVENT_IE_END, 0 }
342         },
343         .optional_ies = {
344                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
345                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
346                 { AST_EVENT_IE_END, 0 }
347         },
348 },
349
350 [AST_SECURITY_EVENT_REQ_BAD_FORMAT] = {
351         .name     = "RequestBadFormat",
352         .version  = AST_SECURITY_EVENT_REQ_BAD_FORMAT_VERSION,
353         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
354         .required_ies = {
355                 { AST_EVENT_IE_EVENT_TV, 0 },
356                 { AST_EVENT_IE_SEVERITY, 0 },
357                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
358                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
359                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
360                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
361                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
362                 { AST_EVENT_IE_REQUEST_TYPE, SEC_EVT_FIELD(req_bad_format, request_type) },
363                 { AST_EVENT_IE_END, 0 }
364         },
365         .optional_ies = {
366                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
367                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
368                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
369                 { AST_EVENT_IE_REQUEST_PARAMS, SEC_EVT_FIELD(req_bad_format, request_params) },
370                 { AST_EVENT_IE_END, 0 }
371         },
372 },
373
374 [AST_SECURITY_EVENT_SUCCESSFUL_AUTH] = {
375         .name     = "SuccessfulAuth",
376         .version  = AST_SECURITY_EVENT_SUCCESSFUL_AUTH_VERSION,
377         .severity = AST_SECURITY_EVENT_SEVERITY_INFO,
378         .required_ies = {
379                 { AST_EVENT_IE_EVENT_TV, 0 },
380                 { AST_EVENT_IE_SEVERITY, 0 },
381                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
382                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
383                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
384                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
385                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
386                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
387                 { AST_EVENT_IE_USING_PASSWORD, SEC_EVT_FIELD(successful_auth, using_password) },
388                 { AST_EVENT_IE_END, 0 }
389         },
390         .optional_ies = {
391                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
392                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
393                 { AST_EVENT_IE_END, 0 }
394         },
395 },
396
397 [AST_SECURITY_EVENT_UNEXPECTED_ADDR] = {
398         .name     = "UnexpectedAddress",
399         .version  = AST_SECURITY_EVENT_UNEXPECTED_ADDR_VERSION,
400         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
401         .required_ies = {
402                 { AST_EVENT_IE_EVENT_TV, 0 },
403                 { AST_EVENT_IE_SEVERITY, 0 },
404                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
405                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
406                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
407                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
408                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
409                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
410                 { AST_EVENT_IE_EXPECTED_ADDR, SEC_EVT_FIELD(unexpected_addr, expected_addr) },
411                 { AST_EVENT_IE_END, 0 }
412         },
413         .optional_ies = {
414                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
415                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
416                 { AST_EVENT_IE_END, 0 }
417         },
418 },
419
420 [AST_SECURITY_EVENT_CHAL_RESP_FAILED] = {
421         .name     = "ChallengeResponseFailed",
422         .version  = AST_SECURITY_EVENT_CHAL_RESP_FAILED_VERSION,
423         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
424         .required_ies = {
425                 { AST_EVENT_IE_EVENT_TV, 0 },
426                 { AST_EVENT_IE_SEVERITY, 0 },
427                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
428                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
429                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
430                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
431                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
432                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
433                 { AST_EVENT_IE_CHALLENGE, SEC_EVT_FIELD(chal_resp_failed, challenge) },
434                 { AST_EVENT_IE_RESPONSE, SEC_EVT_FIELD(chal_resp_failed, response) },
435                 { AST_EVENT_IE_EXPECTED_RESPONSE, SEC_EVT_FIELD(chal_resp_failed, expected_response) },
436                 { AST_EVENT_IE_END, 0 }
437         },
438         .optional_ies = {
439                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
440                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
441                 { AST_EVENT_IE_END, 0 }
442         },
443 },
444
445 [AST_SECURITY_EVENT_INVAL_PASSWORD] = {
446         .name     = "InvalidPassword",
447         .version  = AST_SECURITY_EVENT_INVAL_PASSWORD_VERSION,
448         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
449         .required_ies = {
450                 { AST_EVENT_IE_EVENT_TV, 0 },
451                 { AST_EVENT_IE_SEVERITY, 0 },
452                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
453                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
454                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
455                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
456                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
457                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
458                 { AST_EVENT_IE_END, 0 }
459         },
460         .optional_ies = {
461                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
462                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
463                 { AST_EVENT_IE_CHALLENGE, SEC_EVT_FIELD(inval_password, challenge) },
464                 { AST_EVENT_IE_RECEIVED_CHALLENGE, SEC_EVT_FIELD(inval_password, received_challenge) },
465                 { AST_EVENT_IE_RECEIVED_HASH, SEC_EVT_FIELD(inval_password, received_hash) },
466                 { AST_EVENT_IE_END, 0 }
467         },
468 },
469
470 [AST_SECURITY_EVENT_CHAL_SENT] = {
471         .name     = "ChallengeSent",
472         .version  = AST_SECURITY_EVENT_CHAL_SENT_VERSION,
473         .severity = AST_SECURITY_EVENT_SEVERITY_INFO,
474         .required_ies = {
475                 { AST_EVENT_IE_EVENT_TV, 0 },
476                 { AST_EVENT_IE_SEVERITY, 0 },
477                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
478                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
479                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
480                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
481                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
482                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
483                 { AST_EVENT_IE_CHALLENGE, SEC_EVT_FIELD(chal_sent, challenge) },
484                 { AST_EVENT_IE_END, 0 }
485         },
486         .optional_ies = {
487                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
488                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
489                 { AST_EVENT_IE_END, 0 }
490         },
491 },
492
493 [AST_SECURITY_EVENT_INVAL_TRANSPORT] = {
494         .name     = "InvalidTransport",
495         .version  = AST_SECURITY_EVENT_INVAL_TRANSPORT_VERSION,
496         .severity = AST_SECURITY_EVENT_SEVERITY_ERROR,
497         .required_ies = {
498                 { AST_EVENT_IE_EVENT_TV, 0 },
499                 { AST_EVENT_IE_SEVERITY, 0 },
500                 { AST_EVENT_IE_SERVICE, SEC_EVT_FIELD(common, service) },
501                 { AST_EVENT_IE_EVENT_VERSION, SEC_EVT_FIELD(common, version) },
502                 { AST_EVENT_IE_ACCOUNT_ID, SEC_EVT_FIELD(common, account_id) },
503                 { AST_EVENT_IE_SESSION_ID, SEC_EVT_FIELD(common, session_id) },
504                 { AST_EVENT_IE_LOCAL_ADDR, SEC_EVT_FIELD(common, local_addr) },
505                 { AST_EVENT_IE_REMOTE_ADDR, SEC_EVT_FIELD(common, remote_addr) },
506                 { AST_EVENT_IE_ATTEMPTED_TRANSPORT, SEC_EVT_FIELD(inval_transport, transport) },
507                 { AST_EVENT_IE_END, 0 }
508         },
509         .optional_ies = {
510                 { AST_EVENT_IE_MODULE, SEC_EVT_FIELD(common, module) },
511                 { AST_EVENT_IE_SESSION_TV, SEC_EVT_FIELD(common, session_tv) },
512                 { AST_EVENT_IE_END, 0 }
513         },
514 },
515
516 #undef SEC_EVT_FIELD
517
518 };
519
520 static const struct {
521         enum ast_security_event_severity severity;
522         const char *str;
523 } severities[] = {
524         { AST_SECURITY_EVENT_SEVERITY_INFO,  "Informational" },
525         { AST_SECURITY_EVENT_SEVERITY_ERROR, "Error" },
526 };
527
528 const char *ast_security_event_severity_get_name(
529                 const enum ast_security_event_severity severity)
530 {
531         unsigned int i;
532
533         for (i = 0; i < ARRAY_LEN(severities); i++) {
534                 if (severities[i].severity == severity) {
535                         return severities[i].str;
536                 }
537         }
538
539         return NULL;
540 }
541
542 static int check_event_type(const enum ast_security_event_type event_type)
543 {
544         if (event_type < 0 || event_type >= AST_SECURITY_EVENT_NUM_TYPES) {
545                 ast_log(LOG_ERROR, "Invalid security event type %u\n", event_type);
546                 return -1;
547         }
548
549         return 0;
550 }
551
552 const char *ast_security_event_get_name(const enum ast_security_event_type event_type)
553 {
554         if (check_event_type(event_type)) {
555                 return NULL;
556         }
557
558         return sec_events[event_type].name;
559 }
560
561 const struct ast_security_event_ie_type *ast_security_event_get_required_ies(
562                 const enum ast_security_event_type event_type)
563 {
564         if (check_event_type(event_type)) {
565                 return NULL;
566         }
567
568         return sec_events[event_type].required_ies;
569 }
570
571 const struct ast_security_event_ie_type *ast_security_event_get_optional_ies(
572                 const enum ast_security_event_type event_type)
573 {
574         if (check_event_type(event_type)) {
575                 return NULL;
576         }
577
578         return sec_events[event_type].optional_ies;
579 }
580
581 static int add_ip_json_object(struct ast_json *json, enum ast_event_ie_type ie_type,
582                 const struct ast_security_event_ip_addr *addr)
583 {
584         struct ast_json *json_ip;
585
586         json_ip = ast_json_ipaddr(addr->addr, addr->transport);
587         if (!json_ip) {
588                 return -1;
589         }
590
591         return ast_json_object_set(json, ast_event_get_ie_type_name(ie_type), json_ip);
592 }
593
594 enum ie_required {
595         NOT_REQUIRED,
596         REQUIRED
597 };
598
599 static int add_json_object(struct ast_json *json, const struct ast_security_event_common *sec,
600                 const struct ast_security_event_ie_type *ie_type, enum ie_required req)
601 {
602         int res = 0;
603
604         switch (ie_type->ie_type) {
605         case AST_EVENT_IE_SERVICE:
606         case AST_EVENT_IE_ACCOUNT_ID:
607         case AST_EVENT_IE_SESSION_ID:
608         case AST_EVENT_IE_MODULE:
609         case AST_EVENT_IE_ACL_NAME:
610         case AST_EVENT_IE_REQUEST_TYPE:
611         case AST_EVENT_IE_REQUEST_PARAMS:
612         case AST_EVENT_IE_AUTH_METHOD:
613         case AST_EVENT_IE_CHALLENGE:
614         case AST_EVENT_IE_RESPONSE:
615         case AST_EVENT_IE_EXPECTED_RESPONSE:
616         case AST_EVENT_IE_RECEIVED_CHALLENGE:
617         case AST_EVENT_IE_RECEIVED_HASH:
618         case AST_EVENT_IE_ATTEMPTED_TRANSPORT:
619         {
620                 const char *str;
621                 struct ast_json *json_string;
622
623                 str = *((const char **)(((const char *) sec) + ie_type->offset));
624
625                 if (req && !str) {
626                         ast_log(LOG_WARNING, "Required IE '%d' (%s) for security event "
627                                         "type '%d' (%s) not present\n", ie_type->ie_type,
628                                         ast_event_get_ie_type_name(ie_type->ie_type),
629                                         sec->event_type, ast_security_event_get_name(sec->event_type));
630                         res = -1;
631                         break;
632                 }
633
634                 if (!str) {
635                         break;
636                 }
637
638                 json_string = ast_json_string_create(str);
639                 if (!json_string) {
640                         res = -1;
641                         break;
642                 }
643
644                 res = ast_json_object_set(json, ast_event_get_ie_type_name(ie_type->ie_type), json_string);
645                 break;
646         }
647         case AST_EVENT_IE_EVENT_VERSION:
648         case AST_EVENT_IE_USING_PASSWORD:
649         {
650                 struct ast_json *json_string;
651                 uint32_t val;
652                 val = *((const uint32_t *)(((const char *) sec) + ie_type->offset));
653
654                 json_string = ast_json_stringf("%d", val);
655                 if (!json_string) {
656                         res = -1;
657                         break;
658                 }
659
660                 res = ast_json_object_set(json, ast_event_get_ie_type_name(ie_type->ie_type), json_string);
661                 break;
662         }
663         case AST_EVENT_IE_LOCAL_ADDR:
664         case AST_EVENT_IE_REMOTE_ADDR:
665         case AST_EVENT_IE_EXPECTED_ADDR:
666         {
667                 const struct ast_security_event_ip_addr *addr;
668
669                 addr = (const struct ast_security_event_ip_addr *)(((const char *) sec) + ie_type->offset);
670
671                 if (req && !addr->addr) {
672                         ast_log(LOG_WARNING, "Required IE '%d' (%s) for security event "
673                                         "type '%d' (%s) not present\n", ie_type->ie_type,
674                                         ast_event_get_ie_type_name(ie_type->ie_type),
675                                         sec->event_type, ast_security_event_get_name(sec->event_type));
676                         res = -1;
677                 }
678
679                 if (addr->addr) {
680                         res = add_ip_json_object(json, ie_type->ie_type, addr);
681                 }
682
683                 break;
684         }
685         case AST_EVENT_IE_SESSION_TV:
686         {
687                 const struct timeval *tval;
688
689                 tval = *((const struct timeval **)(((const char *) sec) + ie_type->offset));
690
691                 if (req && !tval) {
692                         ast_log(LOG_WARNING, "Required IE '%d' (%s) for security event "
693                                         "type '%d' (%s) not present\n", ie_type->ie_type,
694                                         ast_event_get_ie_type_name(ie_type->ie_type),
695                                         sec->event_type, ast_security_event_get_name(sec->event_type));
696                         res = -1;
697                 }
698
699                 if (tval) {
700                         struct ast_json *json_tval = ast_json_timeval(*tval, NULL);
701                         if (!json_tval) {
702                                 res = -1;
703                                 break;
704                         }
705                         res = ast_json_object_set(json, ast_event_get_ie_type_name(ie_type->ie_type), json_tval);
706                 }
707
708                 break;
709         }
710         case AST_EVENT_IE_EVENT_TV:
711         case AST_EVENT_IE_SEVERITY:
712                 /* Added automatically, nothing to do here. */
713                 break;
714         default:
715                 ast_log(LOG_WARNING, "Unhandled IE type '%d' (%s), this security event "
716                                 "will be missing data.\n", ie_type->ie_type,
717                                 ast_event_get_ie_type_name(ie_type->ie_type));
718                 break;
719         }
720
721         return res;
722 }
723
724 static struct ast_json *alloc_security_event_json_object(const struct ast_security_event_common *sec)
725 {
726         struct timeval tv = ast_tvnow();
727         const char *severity_str;
728         struct ast_json *json_temp;
729         RAII_VAR(struct ast_json *, json_object, ast_json_object_create(), ast_json_unref);
730
731         if (!json_object) {
732                 return NULL;
733         }
734
735         /* NOTE: Every time ast_json_object_set is used, json_temp becomes a stale pointer since the reference is taken.
736          *       This is true even if ast_json_object_set fails.
737          */
738
739         json_temp = ast_json_integer_create(sec->event_type);
740         if (!json_temp || ast_json_object_set(json_object, "SecurityEvent", json_temp)) {
741                 return NULL;
742         }
743
744         json_temp = ast_json_stringf("%d", sec->version);
745         if (!json_temp || ast_json_object_set(json_object, ast_event_get_ie_type_name(AST_EVENT_IE_EVENT_VERSION), json_temp)) {
746                 return NULL;
747         }
748
749         /* AST_EVENT_IE_EVENT_TV */
750         json_temp  = ast_json_timeval(tv, NULL);
751         if (!json_temp || ast_json_object_set(json_object, ast_event_get_ie_type_name(AST_EVENT_IE_EVENT_TV), json_temp)) {
752                 return NULL;
753         }
754
755         /* AST_EVENT_IE_SERVICE */
756         json_temp = ast_json_string_create(sec->service);
757         if (!json_temp || ast_json_object_set(json_object, ast_event_get_ie_type_name(AST_EVENT_IE_SERVICE), json_temp)) {
758                 return NULL;
759         }
760
761         /* AST_EVENT_IE_SEVERITY */
762         severity_str = S_OR(
763                 ast_security_event_severity_get_name(sec_events[sec->event_type].severity),
764                 "Unknown"
765         );
766
767         json_temp = ast_json_string_create(severity_str);
768         if (!json_temp || ast_json_object_set(json_object, ast_event_get_ie_type_name(AST_EVENT_IE_SEVERITY), json_temp)) {
769                 return NULL;
770         }
771
772         return ast_json_ref(json_object);
773 }
774
775 static int handle_security_event(const struct ast_security_event_common *sec)
776 {
777         RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
778         RAII_VAR(struct ast_json_payload *, json_payload, NULL, ao2_cleanup);
779         RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
780
781         const struct ast_security_event_ie_type *ies;
782         unsigned int i;
783
784         json_object = alloc_security_event_json_object(sec);
785
786         if (!json_object) {
787                 return -1;
788         }
789
790         for (ies = ast_security_event_get_required_ies(sec->event_type), i = 0;
791                         ies[i].ie_type != AST_EVENT_IE_END;
792                         i++) {
793                 if (add_json_object(json_object, sec, ies + i, REQUIRED)) {
794                         goto return_error;
795                 }
796         }
797
798         for (ies = ast_security_event_get_optional_ies(sec->event_type), i = 0;
799                         ies[i].ie_type != AST_EVENT_IE_END;
800                         i++) {
801                 if (add_json_object(json_object, sec, ies + i, NOT_REQUIRED)) {
802                         goto return_error;
803                 }
804         }
805
806         /* The json blob is ready.  Throw it in the payload and send it out over stasis. */
807         if (!(json_payload = ast_json_payload_create(json_object))) {
808                 goto return_error;
809         }
810
811         msg = stasis_message_create(ast_security_event_type(), json_payload);
812
813         if (!msg) {
814                 goto return_error;
815         }
816
817         stasis_publish(ast_security_topic(), msg);
818
819         return 0;
820
821 return_error:
822         return -1;
823 }
824
825 int ast_security_event_report(const struct ast_security_event_common *sec)
826 {
827         if (sec->event_type < 0 || sec->event_type >= AST_SECURITY_EVENT_NUM_TYPES) {
828                 ast_log(LOG_ERROR, "Invalid security event type\n");
829                 return -1;
830         }
831
832         if (!sec_events[sec->event_type].name) {
833                 ast_log(LOG_WARNING, "Security event type %u not handled\n",
834                                 sec->event_type);
835                 return -1;
836         }
837
838         if (sec->version != sec_events[sec->event_type].version) {
839                 ast_log(LOG_WARNING, "Security event %u version mismatch\n",
840                                 sec->event_type);
841                 return -1;
842         }
843
844         if (handle_security_event(sec)) {
845                 ast_log(LOG_ERROR, "Failed to issue security event of type %s.\n",
846                                 ast_security_event_get_name(sec->event_type));
847         }
848
849         return 0;
850 }
851
852