test_security_events.c File Reference

Test security event generation. More...

#include "asterisk.h"
#include "asterisk/module.h"
#include "asterisk/cli.h"
#include "asterisk/utils.h"
#include "asterisk/security_events.h"
#include "asterisk/netsock2.h"

Include dependency graph for test_security_events.c:

Go to the source code of this file.

Typedefs
typedef void(*	evt_generator) (void)

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static void	evt_gen_auth_method_not_allowed (void)
static void	evt_gen_chal_resp_failed (void)
static void	evt_gen_chal_sent (void)
static void	evt_gen_failed_acl (void)
static void	evt_gen_inval_acct_id (void)
static void	evt_gen_inval_password (void)
static void	evt_gen_inval_transport (void)
static void	evt_gen_load_avg (void)
static void	evt_gen_mem_limit (void)
static void	evt_gen_req_bad_format (void)
static void	evt_gen_req_no_support (void)
static void	evt_gen_req_not_allowed (void)
static void	evt_gen_session_limit (void)
static void	evt_gen_successful_auth (void)
static void	evt_gen_unexpected_addr (void)
static void	gen_events (struct ast_cli_args *a)
static char *	handle_cli_sec_evt_test (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	load_module (void)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Test Security Event Generation" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_cli_entry	cli_sec_evt []
static const evt_generator	evt_generators [AST_SECURITY_EVENT_NUM_TYPES]

Detailed Description

Test security event generation.

Author

Russell Bryant russe.nosp@m.ll@d.nosp@m.igium.nosp@m..com

Definition in file test_security_events.c.

Typedef Documentation

evt_generator

typedef void(* evt_generator) (void)

Definition at line 55 of file test_security_events.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 704 of file test_security_events.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 704 of file test_security_events.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 704 of file test_security_events.c.

evt_gen_auth_method_not_allowed()

static void evt_gen_auth_method_not_allowed ( void  )

static

Definition at line 333 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, AST_SECURITY_EVENT_AUTH_METHOD_NOT_ALLOWED, AST_SECURITY_EVENT_AUTH_METHOD_NOT_ALLOWED_VERSION, ast_security_event_report(), ast_sockaddr_parse(), AST_TRANSPORT_TCP, ast_tvnow(), ast_security_event_auth_method_not_allowed::common, and ast_security_event_common::event_type.

evt_gen_chal_resp_failed()

static void evt_gen_chal_resp_failed ( void  )

static

Definition at line 491 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, AST_SECURITY_EVENT_CHAL_RESP_FAILED, AST_SECURITY_EVENT_CHAL_RESP_FAILED_VERSION, ast_security_event_report(), ast_sockaddr_parse(), AST_TRANSPORT_TCP, ast_tvnow(), ast_security_event_chal_resp_failed::common, and ast_security_event_common::event_type.

evt_gen_chal_sent()

static void evt_gen_chal_sent ( void  )

static

Definition at line 570 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, AST_SECURITY_EVENT_CHAL_SENT, AST_SECURITY_EVENT_CHAL_SENT_VERSION, ast_security_event_report(), ast_sockaddr_parse(), AST_TRANSPORT_TCP, ast_tvnow(), ast_security_event_chal_sent::common, and ast_security_event_common::event_type.

evt_gen_failed_acl()

static void evt_gen_failed_acl ( void  )

static

Definition at line 74 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, AST_SECURITY_EVENT_FAILED_ACL, AST_SECURITY_EVENT_FAILED_ACL_VERSION, ast_security_event_report(), ast_sockaddr_parse(), AST_TRANSPORT_UDP, ast_tvnow(), ast_security_event_failed_acl::common, and ast_security_event_common::event_type.

evt_gen_inval_acct_id()

static void evt_gen_inval_acct_id ( void  )

static

Definition at line 112 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, AST_SECURITY_EVENT_INVAL_ACCT_ID, AST_SECURITY_EVENT_INVAL_ACCT_ID_VERSION, ast_security_event_report(), ast_sockaddr_parse(), AST_TRANSPORT_TCP, ast_tvnow(), ast_security_event_inval_acct_id::common, and ast_security_event_common::event_type.

evt_gen_inval_password()

static void evt_gen_inval_password ( void  )

static

Definition at line 531 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, AST_SECURITY_EVENT_INVAL_PASSWORD, AST_SECURITY_EVENT_INVAL_PASSWORD_VERSION, ast_security_event_report(), ast_sockaddr_parse(), AST_TRANSPORT_TCP, ast_tvnow(), ast_security_event_inval_password::common, and ast_security_event_common::event_type.

evt_gen_inval_transport()

static void evt_gen_inval_transport ( void  )

static

Definition at line 607 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, AST_SECURITY_EVENT_INVAL_TRANSPORT, AST_SECURITY_EVENT_INVAL_TRANSPORT_VERSION, ast_security_event_report(), ast_sockaddr_parse(), AST_TRANSPORT_TCP, ast_tvnow(), ast_security_event_inval_transport::common, and ast_security_event_common::event_type.

evt_gen_load_avg()

static void evt_gen_load_avg ( void  )

static

Definition at line 220 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, AST_SECURITY_EVENT_LOAD_AVG, AST_SECURITY_EVENT_LOAD_AVG_VERSION, ast_security_event_report(), ast_sockaddr_parse(), AST_TRANSPORT_UDP, ast_tvnow(), ast_security_event_load_avg::common, and ast_security_event_common::event_type.

evt_gen_mem_limit()

static void evt_gen_mem_limit ( void  )

static

Definition at line 184 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, AST_SECURITY_EVENT_MEM_LIMIT, AST_SECURITY_EVENT_MEM_LIMIT_VERSION, ast_security_event_report(), ast_sockaddr_parse(), AST_TRANSPORT_UDP, ast_tvnow(), ast_security_event_mem_limit::common, and ast_security_event_common::event_type.

evt_gen_req_bad_format()

static void evt_gen_req_bad_format ( void  )

static

Definition at line 371 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, ast_security_event_report(), AST_SECURITY_EVENT_REQ_BAD_FORMAT, AST_SECURITY_EVENT_REQ_BAD_FORMAT_VERSION, ast_sockaddr_parse(), AST_TRANSPORT_TCP, ast_tvnow(), ast_security_event_req_bad_format::common, and ast_security_event_common::event_type.

evt_gen_req_no_support()

static void evt_gen_req_no_support ( void  )

static

Definition at line 256 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, ast_security_event_report(), AST_SECURITY_EVENT_REQ_NO_SUPPORT, AST_SECURITY_EVENT_REQ_NO_SUPPORT_VERSION, ast_sockaddr_parse(), AST_TRANSPORT_UDP, ast_tvnow(), ast_security_event_req_no_support::common, and ast_security_event_common::event_type.

evt_gen_req_not_allowed()

static void evt_gen_req_not_allowed ( void  )

static

Definition at line 294 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, ast_security_event_report(), AST_SECURITY_EVENT_REQ_NOT_ALLOWED, AST_SECURITY_EVENT_REQ_NOT_ALLOWED_VERSION, ast_sockaddr_parse(), AST_TRANSPORT_UDP, ast_tvnow(), ast_security_event_req_not_allowed::common, and ast_security_event_common::event_type.

evt_gen_session_limit()

static void evt_gen_session_limit ( void  )

static

Definition at line 148 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, ast_security_event_report(), AST_SECURITY_EVENT_SESSION_LIMIT, AST_SECURITY_EVENT_SESSION_LIMIT_VERSION, ast_sockaddr_parse(), AST_TRANSPORT_TLS, ast_tvnow(), ast_security_event_session_limit::common, ast_security_event_common::event_type, and session_limit.

evt_gen_successful_auth()

static void evt_gen_successful_auth ( void  )

static

Definition at line 410 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, ast_security_event_report(), AST_SECURITY_EVENT_SUCCESSFUL_AUTH, AST_SECURITY_EVENT_SUCCESSFUL_AUTH_VERSION, ast_sockaddr_parse(), AST_TRANSPORT_TCP, ast_tvnow(), ast_security_event_successful_auth::common, and ast_security_event_common::event_type.

evt_gen_unexpected_addr()

static void evt_gen_unexpected_addr ( void  )

static

Definition at line 446 of file test_security_events.c.

{
    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));
}

References ast_copy_string(), AST_MODULE, AST_SEC_EVT, ast_security_event_report(), AST_SECURITY_EVENT_UNEXPECTED_ADDR, AST_SECURITY_EVENT_UNEXPECTED_ADDR_VERSION, ast_sockaddr_parse(), AST_TRANSPORT_UDP, ast_tvnow(), ast_security_event_unexpected_addr::common, and ast_security_event_common::event_type.

gen_events()

static void gen_events ( struct ast_cli_args *  a )

static

Definition at line 644 of file test_security_events.c.

{
    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");
}

References a, ARRAY_LEN, ast_cli(), ast_security_event_get_name(), and evt_generators.

Referenced by handle_cli_sec_evt_test().

handle_cli_sec_evt_test()

static char * handle_cli_sec_evt_test ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 667 of file test_security_events.c.

{
    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;
}

References a, CLI_FAILURE, CLI_GENERATE, CLI_HANDLER, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, gen_events(), NULL, and ast_cli_entry::usage.

load_module()

static int load_module ( void  )

static

Definition at line 695 of file test_security_events.c.

{
    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;
}

References ARRAY_LEN, ast_cli_register_multiple, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, and cli_sec_evt.

unload_module()

static int unload_module ( void  )

static

Definition at line 690 of file test_security_events.c.

{
    return ast_cli_unregister_multiple(cli_sec_evt, ARRAY_LEN(cli_sec_evt));
}

References ARRAY_LEN, ast_cli_unregister_multiple(), and cli_sec_evt.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Test Security Event Generation" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 704 of file test_security_events.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 704 of file test_security_events.c.

cli_sec_evt

struct ast_cli_entry cli_sec_evt[]

static

Initial value:

= {
    { .handler =  handle_cli_sec_evt_test , .summary =  "Test security event generation" ,},
}

Definition at line 686 of file test_security_events.c.

                                            {
    AST_CLI_DEFINE(handle_cli_sec_evt_test, "Test security event generation"),
};

Referenced by load_module(), and unload_module().

evt_generators

const evt_generator evt_generators[AST_SECURITY_EVENT_NUM_TYPES]

static

Definition at line 56 of file test_security_events.c.

                                                                          {
    [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,
};

Referenced by gen_events().