sysmocom/asterisk
11
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
asterisk/tests/test_security_events.c
Matt Jordan 4a58261694 git migration: Refactor the ASTERISK_FILE_VERSION macro 
Git does not support the ability to replace a token with a version
string during check-in. While it does have support for replacing a
token on clone, this is somewhat sub-optimal: the token is replaced
with the object hash, which is not particularly easy for human
consumption. What's more, in practice, the source file version was often
not terribly useful. Generally, when triaging bugs, the overall version
of Asterisk is far more useful than an individual SVN version of a file. As a
result, this patch removes Asterisk's support for showing source file
versions.

Specifically, it does the following:

* Rename ASTERISK_FILE_VERSION macro to ASTERISK_REGISTER_FILE, and
  remove passing the version in with the macro. Other facilities
  than 'core show file version' make use of the file names, such as
  setting a debug level only on a specific file. As such, the act of
  registering source files with the Asterisk core still has use. The
  macro rename now reflects the new macro purpose.

* main/asterisk:
  - Refactor the file_version structure to reflect that it no longer
    tracks a version field.
  - Remove the "core show file version" CLI command. Without the file
    version, it is no longer useful.
  - Remove the ast_file_version_find function. The file version is no
    longer tracked.
  - Rename ast_register_file_version/ast_unregister_file_version to
    ast_register_file/ast_unregister_file, respectively.

* main/manager: Remove value from the Version key of the ModuleCheck
  Action. The actual key itself has not been removed, as doing so would
  absolutely constitute a backwards incompatible change. However, since
  the file version is no longer tracked, there is no need to attempt to
  include it in the Version key.

* UPGRADE: Add notes for:
  - Modification to the ModuleCheck AMI Action
  - Removal of the "core show file version" CLI command

Change-Id: I6cf0ff280e1668bf4957dc21f32a5ff43444a40e
2015-04-13 03:48:57 -04:00

707 lines
21 KiB
C
Raw Blame History

/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2012, Digium, Inc.
*
* Russell Bryant <russell@digium.com>
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
/*! \file
*
* \brief Test security event generation
*
* \author Russell Bryant <russell@digium.com>
*/
/*** MODULEINFO
<depend>TEST_FRAMEWORK</depend>
<support_level>core</support_level>
***/
#include "asterisk.h"
ASTERISK_REGISTER_FILE()
#include "asterisk/module.h"
#include "asterisk/cli.h"
#include "asterisk/utils.h"
#include "asterisk/security_events.h"
#include "asterisk/netsock2.h"
static void evt_gen_failed_acl(void);
static void evt_gen_inval_acct_id(void);
static void evt_gen_session_limit(void);
static void evt_gen_mem_limit(void);
static void evt_gen_load_avg(void);
static void evt_gen_req_no_support(void);
static void evt_gen_req_not_allowed(void);
static void evt_gen_auth_method_not_allowed(void);
static void evt_gen_req_bad_format(void);
static void evt_gen_successful_auth(void);
static void evt_gen_unexpected_addr(void);
static void evt_gen_chal_resp_failed(void);
static void evt_gen_inval_password(void);
static void evt_gen_chal_sent(void);
static void evt_gen_inval_transport(void);
typedef void (*evt_generator)(void);
static const evt_generator evt_generators[AST_SECURITY_EVENT_NUM_TYPES] = {
[AST_SECURITY_EVENT_FAILED_ACL] = evt_gen_failed_acl,
[AST_SECURITY_EVENT_INVAL_ACCT_ID] = evt_gen_inval_acct_id,
[AST_SECURITY_EVENT_SESSION_LIMIT] = evt_gen_session_limit,
[AST_SECURITY_EVENT_MEM_LIMIT] = evt_gen_mem_limit,
[AST_SECURITY_EVENT_LOAD_AVG] = evt_gen_load_avg,
[AST_SECURITY_EVENT_REQ_NO_SUPPORT] = evt_gen_req_no_support,
[AST_SECURITY_EVENT_REQ_NOT_ALLOWED] = evt_gen_req_not_allowed,
[AST_SECURITY_EVENT_AUTH_METHOD_NOT_ALLOWED] = evt_gen_auth_method_not_allowed,
[AST_SECURITY_EVENT_REQ_BAD_FORMAT] = evt_gen_req_bad_format,
[AST_SECURITY_EVENT_SUCCESSFUL_AUTH] = evt_gen_successful_auth,
[AST_SECURITY_EVENT_UNEXPECTED_ADDR] = evt_gen_unexpected_addr,
[AST_SECURITY_EVENT_CHAL_RESP_FAILED] = evt_gen_chal_resp_failed,
[AST_SECURITY_EVENT_INVAL_PASSWORD] = evt_gen_inval_password,
[AST_SECURITY_EVENT_CHAL_SENT] = evt_gen_chal_sent,
[AST_SECURITY_EVENT_INVAL_TRANSPORT] = evt_gen_inval_transport,
};
static void evt_gen_failed_acl(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_failed_acl failed_acl_event = {
.common.event_type = AST_SECURITY_EVENT_FAILED_ACL,
.common.version = AST_SECURITY_EVENT_FAILED_ACL_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "Username",
.common.session_id = "Session123",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_UDP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_UDP,
},
.acl_name = "TEST_ACL",
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "192.168.1.1:12121", sizeof(localaddr));
ast_copy_string(remoteaddr, "192.168.1.2:12345", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&failed_acl_event));
}
static void evt_gen_inval_acct_id(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_inval_acct_id inval_acct_id = {
.common.event_type = AST_SECURITY_EVENT_INVAL_ACCT_ID,
.common.version = AST_SECURITY_EVENT_INVAL_ACCT_ID_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "FakeUser",
.common.session_id = "Session456",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_TCP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_TCP,
},
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.1.2.3:4321", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.1.2.4:123", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&inval_acct_id));
}
static void evt_gen_session_limit(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_session_limit session_limit = {
.common.event_type = AST_SECURITY_EVENT_SESSION_LIMIT,
.common.version = AST_SECURITY_EVENT_SESSION_LIMIT_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "Jenny",
.common.session_id = "8675309",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_TLS,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_TLS,
},
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.5.4.3:4444", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.5.4.2:3333", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&session_limit));
}
static void evt_gen_mem_limit(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_mem_limit mem_limit = {
.common.event_type = AST_SECURITY_EVENT_MEM_LIMIT,
.common.version = AST_SECURITY_EVENT_MEM_LIMIT_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "Felix",
.common.session_id = "Session2604",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_UDP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_UDP,
},
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.10.10.10:555", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.10.10.12:5656", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&mem_limit));
}
static void evt_gen_load_avg(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_load_avg load_avg = {
.common.event_type = AST_SECURITY_EVENT_LOAD_AVG,
.common.version = AST_SECURITY_EVENT_LOAD_AVG_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "GuestAccount",
.common.session_id = "XYZ123",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_UDP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_UDP,
},
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.11.12.13:9876", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.12.11.10:9825", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&load_avg));
}
static void evt_gen_req_no_support(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_req_no_support req_no_support = {
.common.event_type = AST_SECURITY_EVENT_REQ_NO_SUPPORT,
.common.version = AST_SECURITY_EVENT_REQ_NO_SUPPORT_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "George",
.common.session_id = "asdkl23478289lasdkf",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_UDP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_UDP,
},
.request_type = "MakeMeDinner",
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.110.120.130:9888", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.120.110.100:9777", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&req_no_support));
}
static void evt_gen_req_not_allowed(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_req_not_allowed req_not_allowed = {
.common.event_type = AST_SECURITY_EVENT_REQ_NOT_ALLOWED,
.common.version = AST_SECURITY_EVENT_REQ_NOT_ALLOWED_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "George",
.common.session_id = "alksdjf023423h4lka0df",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_UDP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_UDP,
},
.request_type = "MakeMeBreakfast",
.request_params = "BACONNNN!",
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.110.120.130:9888", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.120.110.100:9777", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&req_not_allowed));
}
static void evt_gen_auth_method_not_allowed(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_auth_method_not_allowed auth_method_not_allowed = {
.common.event_type = AST_SECURITY_EVENT_AUTH_METHOD_NOT_ALLOWED,
.common.version = AST_SECURITY_EVENT_AUTH_METHOD_NOT_ALLOWED_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "Bob",
.common.session_id = "010101010101",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_TCP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_TCP,
},
.auth_method = "PlainText"
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.110.120.135:8754", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.120.110.105:8745", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&auth_method_not_allowed));
}
static void evt_gen_req_bad_format(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_req_bad_format req_bad_format = {
.common.event_type = AST_SECURITY_EVENT_REQ_BAD_FORMAT,
.common.version = AST_SECURITY_EVENT_REQ_BAD_FORMAT_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "Larry",
.common.session_id = "838383fhfhf83hf8h3f8h",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_TCP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_TCP,
},
.request_type = "CheeseBurger",
.request_params = "Onions,Swiss,MotorOil",
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.110.220.230:1212", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.120.210.200:2121", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&req_bad_format));
}
static void evt_gen_successful_auth(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_successful_auth successful_auth = {
.common.event_type = AST_SECURITY_EVENT_SUCCESSFUL_AUTH,
.common.version = AST_SECURITY_EVENT_SUCCESSFUL_AUTH_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "ValidUser",
.common.session_id = "Session456",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_TCP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_TCP,
},
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.1.2.3:4321", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.1.2.4:1234", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&successful_auth));
}
static void evt_gen_unexpected_addr(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct ast_sockaddr addr_expected = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_unexpected_addr unexpected_addr = {
.common.event_type = AST_SECURITY_EVENT_UNEXPECTED_ADDR,
.common.version = AST_SECURITY_EVENT_UNEXPECTED_ADDR_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "CoolUser",
.common.session_id = "Session789",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_UDP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_UDP,
},
.expected_addr = {
.addr = &addr_expected,
.transport = AST_TRANSPORT_UDP,
},
};
char localaddr[53];
char remoteaddr[53];
char expectedaddr[53];
ast_copy_string(localaddr, "10.1.2.3:4321", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.1.2.4:1234", sizeof(remoteaddr));
ast_copy_string(expectedaddr, "10.1.2.5:2343", sizeof(expectedaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_sockaddr_parse(&addr_expected, expectedaddr, 0);
ast_security_event_report(AST_SEC_EVT(&unexpected_addr));
}
static void evt_gen_chal_resp_failed(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_chal_resp_failed chal_resp_failed = {
.common.event_type = AST_SECURITY_EVENT_CHAL_RESP_FAILED,
.common.version = AST_SECURITY_EVENT_CHAL_RESP_FAILED_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "SuperDuperUser",
.common.session_id = "Session1231231231",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_TCP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_TCP,
},
.challenge = "8adf8a9sd8fas9df23ljk4",
.response = "9u3jlaksdjflakjsdfoi23",
.expected_response = "oiafaljhadf9834luahk3k",
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.1.2.3:4321", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.1.2.4:1234", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&chal_resp_failed));
}
static void evt_gen_inval_password(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_inval_password inval_password = {
.common.event_type = AST_SECURITY_EVENT_INVAL_PASSWORD,
.common.version = AST_SECURITY_EVENT_INVAL_PASSWORD_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "AccountIDGoesHere",
.common.session_id = "SessionIDGoesHere",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_TCP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_TCP,
},
.challenge = "GoOdChAlLeNgE",
.received_challenge = "BaDcHaLlEnGe",
.received_hash = "3ad9023adf309",
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.200.100.30:4321", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.200.100.40:1234", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&inval_password));
}
static void evt_gen_chal_sent(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_chal_sent chal_sent = {
.common.event_type = AST_SECURITY_EVENT_CHAL_SENT,
.common.version = AST_SECURITY_EVENT_CHAL_SENT_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "AccountIDGoesHere",
.common.session_id = "SessionIDGoesHere",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_TCP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_TCP,
},
.challenge = "IcHaLlEnGeYoU",
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.200.10.30:5392", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.200.10.31:1443", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&chal_sent));
}
static void evt_gen_inval_transport(void)
{
struct ast_sockaddr addr_local = { {0,} };
struct ast_sockaddr addr_remote = { {0,} };
struct timeval session_tv = ast_tvnow();
struct ast_security_event_inval_transport inval_transport = {
.common.event_type = AST_SECURITY_EVENT_INVAL_TRANSPORT,
.common.version = AST_SECURITY_EVENT_INVAL_TRANSPORT_VERSION,
.common.service = "TEST",
.common.module = AST_MODULE,
.common.account_id = "AccountIDGoesHere",
.common.session_id = "SessionIDGoesHere",
.common.session_tv = &session_tv,
.common.local_addr = {
.addr = &addr_local,
.transport = AST_TRANSPORT_TCP,
},
.common.remote_addr = {
.addr = &addr_remote,
.transport = AST_TRANSPORT_TCP,
},
.transport = "UDP",
};
char localaddr[53];
char remoteaddr[53];
ast_copy_string(localaddr, "10.200.103.45:8223", sizeof(localaddr));
ast_copy_string(remoteaddr, "10.200.103.44:1039", sizeof(remoteaddr));
ast_sockaddr_parse(&addr_local, localaddr, 0);
ast_sockaddr_parse(&addr_remote, remoteaddr, 0);
ast_security_event_report(AST_SEC_EVT(&inval_transport));
}
static void gen_events(struct ast_cli_args *a)
{
unsigned int i;
ast_cli(a->fd, "Generating some security events ...\n");
for (i = 0; i < ARRAY_LEN(evt_generators); i++) {
const char *event_type = ast_security_event_get_name(i);
if (!evt_generators[i]) {
ast_cli(a->fd, "*** No event generator for event type '%s' ***\n",
event_type);
continue;
}
ast_cli(a->fd, "Generating a '%s' security event ...\n", event_type);
evt_generators[i]();
}
ast_cli(a->fd, "Security event generation complete.\n");
}
static char *handle_cli_sec_evt_test(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
switch (cmd) {
case CLI_INIT:
e->command = "securityevents test generation";
e->usage = ""
"Usage: securityevents test generation"
"";
return NULL;
case CLI_GENERATE:
return NULL;
case CLI_HANDLER:
gen_events(a);
return CLI_SUCCESS;
}
return CLI_FAILURE;
}
static struct ast_cli_entry cli_sec_evt[] = {
AST_CLI_DEFINE(handle_cli_sec_evt_test, "Test security event generation"),
};
static int unload_module(void)
{
return ast_cli_unregister_multiple(cli_sec_evt, ARRAY_LEN(cli_sec_evt));
}
static int load_module(void)
{
int res;
res = ast_cli_register_multiple(cli_sec_evt, ARRAY_LEN(cli_sec_evt));
return res ? AST_MODULE_LOAD_DECLINE : AST_MODULE_LOAD_SUCCESS;
}
AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Test Security Event Generation");
Reference in a new issue View git blame Copy permalink