crypto: event route to allow encrypting/decrypting net i/o traffic
authorDaniel-Constantin Mierla <miconda@gmail.com>
Fri, 29 May 2020 08:30:50 +0000 (10:30 +0200)
committerDaniel-Constantin Mierla <miconda@gmail.com>
Fri, 29 May 2020 08:40:44 +0000 (10:40 +0200)
- work in progress

src/modules/crypto/crypto_evcb.c [new file with mode: 0644]
src/modules/crypto/crypto_evcb.h [new file with mode: 0644]
src/modules/crypto/crypto_mod.c

diff --git a/src/modules/crypto/crypto_evcb.c b/src/modules/crypto/crypto_evcb.c
new file mode 100644 (file)
index 0000000..dd23d0d
--- /dev/null
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2020 Daniel-Constantin Mierla (asipto.com)
+ *
+ * This file is part of Kamailio, a free SIP server.
+ *
+ * Kamailio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version
+ *
+ * Kamailio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../core/sr_module.h"
+#include "../../core/dprint.h"
+#include "../../core/ut.h"
+#include "../../core/cfg/cfg_struct.h"
+#include "../../core/receive.h"
+#include "../../core/kemi.h"
+#include "../../core/fmsg.h"
+#include "../../core/events.h"
+
+
+#define CRYPTO_NIO_OUT (1<<0)
+#define CRYPTO_NIO_ENCRYPT (1<<1)
+#define CRYPTO_NIO_DECRYPT (1<<2)
+
+/* set/get crypto env */
+#define crypto_set_msg_env(_msg, _evenv) do { _msg->ldv.vdata=(void*)_evenv; } while(0)
+#define crypto_get_msg_env(_msg) ((crypto_env_t*)_msg->ldv.vdata)
+
+int crypto_nio_received(sr_event_param_t *evp);
+int crypto_nio_sent(sr_event_param_t *evp);
+
+typedef struct _crypto_env {
+       int mflags;
+       sr_event_param_t *evp;
+} crypto_env_t;
+
+typedef struct _crypto_evroutes {
+       int netio;
+       str netio_name;
+} crypto_evroutes_t;
+
+static crypto_evroutes_t _crypto_rts;
+
+extern str _crypto_kevcb_netio;
+
+static int _crypto_evcb_enabled = 0;
+
+/**
+ *
+ */
+int crypto_evcb_enable(void)
+{
+       _crypto_evcb_enabled = 1;
+
+       memset(&_crypto_rts, 0, sizeof(crypto_evroutes_t));
+       _crypto_rts.netio_name.s = "crypto:netio";
+       _crypto_rts.netio_name.len = strlen(_crypto_rts.netio_name.s);
+       _crypto_rts.netio = route_lookup(&event_rt, _crypto_rts.netio_name.s);
+       if (_crypto_rts.netio < 0 || event_rt.rlist[_crypto_rts.netio] == NULL) {
+               _crypto_rts.netio = -1;
+       }
+
+    /* register network hooks */
+    sr_event_register_cb(SREV_NET_DATA_IN, crypto_nio_received);
+    sr_event_register_cb(SREV_NET_DATA_OUT, crypto_nio_sent);
+
+       return 0;
+}
+
+/**
+ *
+ */
+int crypto_exec_evroute(crypto_env_t *evenv, int rt, str *kevcb, str *rtname)
+{
+       int backup_rt;
+       struct run_act_ctx ctx;
+       sip_msg_t *fmsg;
+       sip_msg_t tmsg;
+       sr_kemi_eng_t *keng = NULL;
+
+       if(evenv==0) {
+               LM_ERR("crypto env not set\n");
+               return -1;
+       }
+
+       if((rt<0) && (kevcb==NULL || kevcb->s==NULL || kevcb->len<=0)) {
+               return 0;
+       }
+
+       if(faked_msg_get_new(&tmsg)<0) {
+               LM_ERR("failed to get a new faked message\n");
+               return -1;
+       }
+       fmsg = &tmsg;
+       crypto_set_msg_env(fmsg, evenv);
+       backup_rt = get_route_type();
+       set_route_type(EVENT_ROUTE);
+       init_run_actions_ctx(&ctx);
+       if(rt>=0) {
+               run_top_route(event_rt.rlist[rt], fmsg, 0);
+       } else {
+               keng = sr_kemi_eng_get();
+               if(keng!=NULL) {
+                       if(sr_kemi_route(keng, fmsg, EVENT_ROUTE, kevcb, rtname)<0) {
+                               LM_ERR("error running event route kemi callback\n");
+                       }
+               }
+       }
+       set_route_type(backup_rt);
+       crypto_set_msg_env(fmsg, NULL);
+       /* free the structure -- it is a clone of faked msg */
+       free_sip_msg(fmsg);
+       return 0;
+}
+
+/**
+ *
+ */
+int crypto_nio_received(sr_event_param_t *evp)
+{
+       int ret;
+       crypto_env_t evenv;
+
+       memset(&evenv, 0, sizeof(crypto_env_t));
+
+       evenv.evp = evp;
+
+       ret = crypto_exec_evroute(&evenv, _crypto_rts.netio, &_crypto_kevcb_netio,
+                       &_crypto_rts.netio_name);
+
+       LM_DBG("sent event callback - ret:%d - flags:%d\n", ret, evenv.mflags);
+
+    return 0;
+}
+
+/**
+ *
+ */
+int crypto_nio_sent(sr_event_param_t *evp)
+{
+       int ret;
+       crypto_env_t evenv;
+
+       memset(&evenv, 0, sizeof(crypto_env_t));
+
+       evenv.mflags |= CRYPTO_NIO_OUT;
+       evenv.evp = evp;
+
+       ret = crypto_exec_evroute(&evenv, _crypto_rts.netio, &_crypto_kevcb_netio,
+                       &_crypto_rts.netio_name);
+
+       LM_DBG("sent event callback - ret:%d - flags:%d\n", ret, evenv.mflags);
+
+    return 0;
+}
+
+/**
+ *
+ */
+int crypto_nio_in(sip_msg_t* msg)
+{
+       return 1;
+}
+
+/**
+ *
+ */
+int crypto_nio_out(sip_msg_t* msg)
+{
+       return 1;
+}
+
+/**
+ *
+ */
+int crypto_nio_encrypt(sip_msg_t* msg)
+{
+       return 1;
+}
+
+/**
+ *
+ */
+int crypto_nio_decrypt(sip_msg_t* msg)
+{
+       return 1;
+}
\ No newline at end of file
diff --git a/src/modules/crypto/crypto_evcb.h b/src/modules/crypto/crypto_evcb.h
new file mode 100644 (file)
index 0000000..fa0e8bd
--- /dev/null
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2020 Daniel-Constantin Mierla (asipto.com)
+ *
+ * This file is part of Kamailio, a free SIP server.
+ *
+ * Kamailio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version
+ *
+ * Kamailio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef _CRYPTO_EVCB_
+#define _CRYPTO_EVCB_
+
+#include "../../core/parser/msg_parser.h"
+
+int crypto_evcb_enable(void);
+
+int crypto_nio_in(sip_msg_t* msg);
+int crypto_nio_out(sip_msg_t* msg);
+int crypto_nio_encrypt(sip_msg_t* msg);
+int crypto_nio_decrypt(sip_msg_t* msg);
+
+#endif
\ No newline at end of file
index 8f32a06..7602761 100644 (file)
@@ -34,6 +34,7 @@
 #include "../../core/kemi.h"
 
 #include "crypto_uuid.h"
+#include "crypto_evcb.h"
 #include "api.h"
 
 #include <openssl/evp.h>
@@ -58,17 +59,33 @@ static int fixup_crypto_aes_encrypt(void** param, int param_no);
 static int w_crypto_aes_decrypt(sip_msg_t* msg, char* inb, char* keyb, char* outb);
 static int fixup_crypto_aes_decrypt(void** param, int param_no);
 
+static int w_crypto_nio_in(sip_msg_t* msg, char* p1, char* p2);
+static int w_crypto_nio_out(sip_msg_t* msg, char* p1, char* p2);
+static int w_crypto_nio_encrypt(sip_msg_t* msg, char* p1, char* p2);
+static int w_crypto_nio_decrypt(sip_msg_t* msg, char* p1, char* p2);
+
 #define CRYPTO_SALT_BSIZE      16
 static char _crypto_salt[CRYPTO_SALT_BSIZE];
 static char *_crypto_salt_param = "k8hTm4aZ";
 
 static int _crypto_register_callid = 0;
+static int _crypto_register_evcb = 0;
+
+str _crypto_kevcb_netio = STR_NULL;
 
 static cmd_export_t cmds[]={
        {"crypto_aes_encrypt", (cmd_function)w_crypto_aes_encrypt, 3,
                fixup_crypto_aes_encrypt, 0, ANY_ROUTE},
        {"crypto_aes_decrypt", (cmd_function)w_crypto_aes_decrypt, 3,
                fixup_crypto_aes_decrypt, 0, ANY_ROUTE},
+       {"crypto_nio_in", (cmd_function)w_crypto_nio_in, 0,
+               0, 0, ANY_ROUTE},
+       {"crypto_nio_out", (cmd_function)w_crypto_nio_out, 0,
+               0, 0, ANY_ROUTE},
+       {"crypto_nio_encrypt", (cmd_function)w_crypto_nio_encrypt, 0,
+               0, 0, ANY_ROUTE},
+       {"crypto_nio_decrypt", (cmd_function)w_crypto_nio_decrypt, 0,
+               0, 0, ANY_ROUTE},
        {"load_crypto",        (cmd_function)load_crypto, 0, 0, 0, 0},
        {0, 0, 0, 0, 0, 0}
 };
@@ -76,6 +93,9 @@ static cmd_export_t cmds[]={
 static param_export_t params[]={
        { "salt",            PARAM_STRING, &_crypto_salt_param },
        { "register_callid", PARAM_INT, &_crypto_register_callid },
+       { "register_evcb",   PARAM_INT, &_crypto_register_evcb },
+       { "kevcb_netio",     PARAM_STR, &_crypto_kevcb_netio },
+
        { 0, 0, 0 }
 };
 
@@ -126,6 +146,10 @@ static int mod_init(void)
                }
                LM_DBG("registered crypto callid callback\n");
        }
+       if(_crypto_register_evcb!=0) {
+               crypto_evcb_enable();
+       }
+
        return 0;
 }
 
@@ -581,6 +605,38 @@ int crypto_aes_test(void)
        return 0;
 }
 
+/**
+ *
+ */
+static int w_crypto_nio_in(sip_msg_t* msg, char* p1, char* p2)
+{
+       return 1;
+}
+
+/**
+ *
+ */
+static int w_crypto_nio_out(sip_msg_t* msg, char* p1, char* p2)
+{
+       return 1;
+}
+
+/**
+ *
+ */
+static int w_crypto_nio_encrypt(sip_msg_t* msg, char* p1, char* p2)
+{
+       return 1;
+}
+
+/**
+ *
+ */
+static int w_crypto_nio_decrypt(sip_msg_t* msg, char* p1, char* p2)
+{
+       return 1;
+}
+
 /**
  *
  */