OpenVPN plug-in API version 3
v2 cover OpenVPN plug-in API version 3
This is the second round of implementing a new plug-in API for OpenVPN. This API uses structs for both passing arguments to and from the plug-in functions.
The reason for this approach is to avoid modifying the function API itself to add more information being sent to or from the plug-in functions.
In addition this patchset will also add a X509 certificate OpenSSL structure to the openvpn_plugin_func_v3() calls, which contains the complete parsed certificate sent from the client.
David Sommerseth (4):
Define the new openvpn_plugin_{open,func}_v3() API Implement the core v3 plug-in function calls. Extend the v3 plug-in API to send over X509 certificates Added a simple plug-in demonstrating the v3 plug-in API.
init.c | 2 +- misc.c | 2 +- multi.c | 8 +- openvpn-plugin.h | 229 ++++++++++++++++++++++++++++++++++++++++++- pf.c | 2 +- plugin.c | 48 ++++++++-- plugin.h | 6 +- plugin/examples/log_v3.c | 245 ++++++++++++++++++++++++++++++++++++++++++++++ socket.c | 2 +- ssl.c | 6 +- 10 files changed, 530 insertions(+), 20 deletions(-) create mode 100644 plugin/examples/log_v3.c
Signature · 1 line
1.7.2.3
PATCH v2 1/4 Define the new openvpn_plugin_{open, func}_v3() API
This just implements the basic API changes needed for the newer and more flexible plug-in API.
--- openvpn-plugin.h | 222 +++++++++++++++++++++++++++++++++++++++++++++++++++++- plugin.c | 6 +- plugin.h | 2 + 3 files changed, 227 insertions(+), 3 deletions(-)
openvpn-plugin.h +221 -1
@@ -22,7 +22,7 @@* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#define OPENVPN_PLUGIN_VERSION 2 +#define OPENVPN_PLUGIN_VERSION 3/* * Plug-in types. These types correspond to the set of script callbacks
@@ -163,6 +163,114 @@ struct openvpn_plugin_string_listchar *value; }; + +/* openvpn_plugin_{open,func}_v3() related structs */ + +/** +* Arguments used to transport variables to the plug-in. +* The struct openvpn_plugin_args_open_in is only used +* by the openvpn_plugin_open_v3() function. +* +* STRUCT MEMBERS +* +* type_mask : Set by OpenVPN to the logical OR of all script +* types which this version of OpenVPN supports. +* +* argv : a NULL-terminated array of options provided to the OpenVPN +* "plug-in" directive. argv[0] is the dynamic library pathname. +* +* envp : a NULL-terminated array of OpenVPN-set environmental +* variables in "name=value" format. Note that for security reasons, +* these variables are not actually written to the "official" +* environmental variable store of the process. +*/ +struct openvpn_plugin_args_open_in +{ +const int type_mask; +const char const **argv; +const char const **envp; +}; + + +/** +* Aruguments used to transport variables from the plug-in back +* to the OpenVPN process. The struct openvpn_plugin_args_open_return +* is only used by the openvpn_plugin_open_v3() function. +* +* STRUCT MEMBERS +* +* *type_mask : The plug-in should set this value to the logical OR of all script +* types which the plug-in wants to intercept. For example, if the +* script wants to intercept the client-connect and client-disconnect +* script types: +* +* *type_mask = OPENVPN_PLUGIN_MASK(OPENVPN_PLUGIN_CLIENT_CONNECT) +* | OPENVPN_PLUGIN_MASK(OPENVPN_PLUGIN_CLIENT_DISCONNECT) +* +* *handle : Pointer to a global plug-in context, created by the plug-in. This pointer +* is passed on to the other plug-in calls. +* +* return_list : used to return data back to OpenVPN. +* +*/ +struct openvpn_plugin_args_open_return +{ +int type_mask; +openvpn_plugin_handle_t *handle; +struct openvpn_plugin_string_list **return_list; +}; + +/** +* Aruguments used to transport variables to and from the +* plug-in. The struct openvpn_plugin_args_func is only used +* by the openvpn_plugin_func_v3() function. +* +* STRUCT MEMBERS: +* +* type : one of the PLUGIN_x types. +* +* argv : a NULL-terminated array of "command line" options which +* would normally be passed to the script. argv[0] is the dynamic +* library pathname. +* +* envp : a NULL-terminated array of OpenVPN-set environmental +* variables in "name=value" format. Note that for security reasons, +* these variables are not actually written to the "official" +* environmental variable store of the process. +* +* *handle : Pointer to a global plug-in context, created by the plug-in's openvpn_plugin_open_v3(). +* +* *per_client_context : the per-client context pointer which was returned by +* openvpn_plugin_client_constructor_v1, if defined. +* +* +*/ +struct openvpn_plugin_args_func_in +{ +const int type; +const char const **argv; +const char const **envp; +openvpn_plugin_handle_t handle; +void *per_client_context; +}; + + +/** +* Aruguments used to transport variables to and from the +* plug-in. The struct openvpn_plugin_args_func is only used +* by the openvpn_plugin_func_v3() function. +* +* STRUCT MEMBERS: +* +* return_list : used to return data back to OpenVPN for further processing/usage by +* the OpenVPN executable. +* +*/ +struct openvpn_plugin_args_func_return +{ +struct openvpn_plugin_string_list **return_list; +}; +/* * Multiple plugin modules can be cascaded, and modules can be * used in tandem with scripts. The order of operation is that
@@ -329,6 +437,118 @@ OPENVPN_PLUGIN_DEF int OPENVPN_PLUGIN_FUNC(openvpn_plugin_func_v2)void *per_client_context, struct openvpn_plugin_string_list **return_list); + +/* +* FUNCTION: openvpn_plugin_open_v3 +* +* REQUIRED: YES +* +* Called on initial plug-in load. OpenVPN will preserve plug-in state +* across SIGUSR1 restarts but not across SIGHUP restarts. A SIGHUP reset +* will cause the plugin to be closed and reopened. +* +* ARGUMENTS +* +* version : fixed value, defines the API version of the OpenVPN plug-in API. The plug-in +* should validate that this value is matching the OPENVPN_PLUGIN_VERSION value. +* +* arguments : Structure with all arguments available to the plug-in. +* +* retptr : used to return data back to OpenVPN. +* +* RETURN VALUE +* +* OPENVPN_PLUGIN_FUNC_SUCCESS on success, OPENVPN_PLUGIN_FUNC_ERROR on failure +*/ +OPENVPN_PLUGIN_DEF int OPENVPN_PLUGIN_FUNC(openvpn_plugin_open_v3) + (const int version, +struct openvpn_plugin_args_open_in const *arguments, +struct openvpn_plugin_args_open_return *retptr); + +/* +* FUNCTION: openvpn_plugin_func_v3 +* +* Called to perform the work of a given script type. +* +* REQUIRED: YES +* +* ARGUMENTS +* +* version : fixed value, defines the API version of the OpenVPN plug-in API. The plug-in +* should validate that this value is matching the OPENVPN_PLUGIN_VERSION value. +* +* handle : the openvpn_plugin_handle_t value which was returned by +* openvpn_plugin_open. +* +* return_list : used to return data back to OpenVPN. +* +* RETURN VALUE +* +* OPENVPN_PLUGIN_FUNC_SUCCESS on success, OPENVPN_PLUGIN_FUNC_ERROR on failure +* +* In addition, OPENVPN_PLUGIN_FUNC_DEFERRED may be returned by +* OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY. This enables asynchronous +* authentication where the plugin (or one of its agents) may indicate +* authentication success/failure some number of seconds after the return +* of the OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY handler by writing a single +* char to the file named by auth_control_file in the environmental variable +* list (envp). +* +* first char of auth_control_file: +* '0' -- indicates auth failure +* '1' -- indicates auth success +* +* OpenVPN will delete the auth_control_file after it goes out of scope. +* +* If an OPENVPN_PLUGIN_ENABLE_PF handler is defined and returns success +* for a particular client instance, packet filtering will be enabled for that +* instance. OpenVPN will then attempt to read the packet filter configuration +* from the temporary file named by the environmental variable pf_file. This +* file may be generated asynchronously and may be dynamically updated during the +* client session, however the client will be blocked from sending or receiving +* VPN tunnel packets until the packet filter file has been generated. OpenVPN +* will periodically test the packet filter file over the life of the client +* instance and reload when modified. OpenVPN will delete the packet filter file +* when the client instance goes out of scope. +* +* Packet filter file grammar: +* +* [CLIENTS DROP|ACCEPT] +* {+|-}common_name1 +* {+|-}common_name2 +* . . . +* [SUBNETS DROP|ACCEPT] +* {+|-}subnet1 +* {+|-}subnet2 +* . . . +* [END] +* +* Subnet: IP-ADDRESS | IP-ADDRESS/NUM_NETWORK_BITS +* +* CLIENTS refers to the set of clients (by their common-name) which +* this instance is allowed ('+') to connect to, or is excluded ('-') +* from connecting to. Note that in the case of client-to-client +* connections, such communication must be allowed by the packet filter +* configuration files of both clients. +* +* SUBNETS refers to IP addresses or IP address subnets which this +* instance may connect to ('+') or is excluded ('-') from connecting +* to. +* +* DROP or ACCEPT defines default policy when there is no explicit match +* for a common-name or subnet. The [END] tag must exist. A special +* purpose tag called [KILL] will immediately kill the client instance. +* A given client or subnet rule applies to both incoming and outgoing +* packets. +* +* See plugin/defer/simple.c for an example on using asynchronous +* authentication and client-specific packet filtering. +*/ +OPENVPN_PLUGIN_DEF int OPENVPN_PLUGIN_FUNC(openvpn_plugin_func_v3) + (const int version, +struct openvpn_plugin_args_func_in const *arguments, +struct openvpn_plugin_args_func_return *retptr); +/* * FUNCTION: openvpn_plugin_close_v1 *
plugin.c +4 -2
@@ -232,8 +232,10 @@ plugin_init_item (struct plugin *p, const struct plugin_option *o)PLUGIN_SYM (open1,"openvpn_plugin_open_v1" ,0 );PLUGIN_SYM (open2,"openvpn_plugin_open_v2" ,0 ); +PLUGIN_SYM (open3,"openvpn_plugin_open_v3" ,0 );PLUGIN_SYM (func1,"openvpn_plugin_func_v1" ,0 );PLUGIN_SYM (func2,"openvpn_plugin_func_v2" ,0 ); +PLUGIN_SYM (func3,"openvpn_plugin_func_v3" ,0 );PLUGIN_SYM (close,"openvpn_plugin_close_v1" ,PLUGIN_SYMBOL_REQUIRED );PLUGIN_SYM (abort,"openvpn_plugin_abort_v1" ,0 );PLUGIN_SYM (client_constructor,"openvpn_plugin_client_constructor_v1" ,0 );
@@ -241,10 +243,10 @@ plugin_init_item (struct plugin *p, const struct plugin_option *o)PLUGIN_SYM (min_version_required,"openvpn_plugin_min_version_required_v1" ,0 );PLUGIN_SYM (initialization_point,"openvpn_plugin_select_initialization_point_v1" ,0 ); -if (!p->open1 && !p->open2) +if (!p->open1 && !p->open2 && !p->open3)msg (M_FATAL ,"PLUGIN: symbol openvpn_plugin_open_vX is undefined in plugin: %s" , p->so_pathname); -if (!p->func1 && !p->func2) +if (!p->func1 && !p->func2 && !p->func3)msg (M_FATAL ,"PLUGIN: symbol openvpn_plugin_func_vX is undefined in plugin: %s" , p->so_pathname);/*
plugin.h +2 -0
@@ -61,8 +61,10 @@ struct plugin {openvpn_plugin_open_v1 open1;openvpn_plugin_open_v2 open2; +openvpn_plugin_open_v3 open3;openvpn_plugin_func_v1 func1;openvpn_plugin_func_v2 func2; +openvpn_plugin_func_v3 func3;openvpn_plugin_close_v1 close;openvpn_plugin_abort_v1 abort;openvpn_plugin_client_constructor_v1 client_constructor;
Signature · 1 line
1.7.2.3
PATCH v2 2/4 Implement the core v3 plug-in function calls.
In reply to David SommersethLet OpenVPN call the openvpn_plugin_open_v3() and openvpn_plugin_func_v3() plug-in functions if they exist in the plug-in.
--- plugin.c | 29 +++++++++++++++++++++++++++-- 1 files changed, 27 insertions(+), 2 deletions(-)
plugin.c +27 -2
@@ -298,7 +298,21 @@ plugin_open_item (struct plugin *p,/* * Call the plugin initialization */ -if (p->open2) +if (p->open3) { +struct openvpn_plugin_args_open_in args = { .type_mask = p->plugin_type_mask, + .argv = o->argv, + .envp = envp }; +struct openvpn_plugin_args_open_return retargs; + +CLEAR (retargs); +if ((*p->open3)(OPENVPN_PLUGIN_VERSION , &args, &retargs) ==OPENVPN_PLUGIN_FUNC_SUCCESS ) { + p->plugin_type_mask = retargs.type_mask; + p->plugin_handle = retargs.handle; + retlist = retargs.return_list; + }else { + p->plugin_handle =NULL ; + } + }else if (p->open2) p->plugin_handle = (*p->open2)(&p->plugin_type_mask, o->argv, envp, retlist);else if (p->open1) p->plugin_handle = (*p->open1)(&p->plugin_type_mask, o->argv, envp);
@@ -350,7 +364,18 @@ plugin_call_item (const struct plugin *p,/* * Call the plugin work function */ -if (p->func2) +if (p->func3) { +struct openvpn_plugin_args_func_in args = { .type = type, + .argv = (const char **) a.argv, + .envp = envp, + .handle = p->plugin_handle, + .per_client_context = per_client_context }; +struct openvpn_plugin_args_func_return retargs; + +CLEAR (retargs); + status = (*p->func3)(OPENVPN_PLUGIN_VERSION , &args, &retargs); + retlist = retargs.return_list; + }else if (p->func2) status = (*p->func2)(p->plugin_handle, type, (const char **)a.argv, envp, per_client_context, retlist);else if (p->func1) status = (*p->func1)(p->plugin_handle, type, (const char **)a.argv, envp);
Signature · 1 line
1.7.2.3
PATCH v2 3/4 Extend the v3 plug-in API to send over X509 certificates
In reply to David SommersethThe certificates sent to the plug-in API will only happen during the OPENVPN_PLUGIN_TLS_VERIFY phase and will contain a pointer to the OpenSSL X509 certificate data.
--- init.c | 2 +- misc.c | 2 +- multi.c | 8 ++++---- openvpn-plugin.h | 7 +++++++ pf.c | 2 +- plugin.c | 15 +++++++++++---- plugin.h | 4 +++- socket.c | 2 +- ssl.c | 6 +++--- 9 files changed, 32 insertions(+), 16 deletions(-)
init.c +1 -1
@@ -1182,7 +1182,7 @@ do_route (const struct options *options,if (plugin_defined (plugins,OPENVPN_PLUGIN_ROUTE_UP )) { -if (plugin_call (plugins,OPENVPN_PLUGIN_ROUTE_UP ,NULL ,NULL , es) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) +if (plugin_call (plugins,OPENVPN_PLUGIN_ROUTE_UP ,NULL ,NULL , es,-1 ,NULL ) !=OPENVPN_PLUGIN_FUNC_SUCCESS )msg (M_WARN ,"WARNING: route-up plugin call failed" ); }
misc.c +1 -1
@@ -211,7 +211,7 @@ run_up_down (const char *command, ifconfig_local, ifconfig_remote, context); -if (plugin_call (plugins, plugin_type, &argv,NULL , es) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) +if (plugin_call (plugins, plugin_type, &argv,NULL , es,-1 ,NULL ) !=OPENVPN_PLUGIN_FUNC_SUCCESS )msg (M_FATAL ,"ERROR: up/down plugin call failed" );argv_reset (&argv);
multi.c +4 -4
@@ -91,7 +91,7 @@ learn_address_script (const struct multi_context *m, mroute_addr_print (addr, &gc));if (mi)argv_printf_cat (&argv,"%s" ,tls_common_name (mi->context.c2.tls_multi, false)); -if (plugin_call (plugins,OPENVPN_PLUGIN_LEARN_ADDRESS , &argv,NULL , es) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) +if (plugin_call (plugins,OPENVPN_PLUGIN_LEARN_ADDRESS , &argv,NULL , es,-1 ,NULL ) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) {msg (M_WARN ,"WARNING: learn-address plugin call failed" ); ret = false;
@@ -471,7 +471,7 @@ multi_client_disconnect_script (struct multi_context *m,if (plugin_defined (mi->context.plugins,OPENVPN_PLUGIN_CLIENT_DISCONNECT )) { -if (plugin_call (mi->context.plugins,OPENVPN_PLUGIN_CLIENT_DISCONNECT ,NULL ,NULL , mi->context.c2.es) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) +if (plugin_call (mi->context.plugins,OPENVPN_PLUGIN_CLIENT_DISCONNECT ,NULL ,NULL , mi->context.c2.es,-1 ,NULL ) !=OPENVPN_PLUGIN_FUNC_SUCCESS )msg (M_WARN ,"WARNING: client-disconnect plugin call failed" ); }
@@ -1538,7 +1538,7 @@ multi_connection_established (struct multi_context *m, struct multi_instance *mi }argv_printf (&argv,"%s" , dc_file); -if (plugin_call (mi->context.plugins,OPENVPN_PLUGIN_CLIENT_CONNECT , &argv,NULL , mi->context.c2.es) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) +if (plugin_call (mi->context.plugins,OPENVPN_PLUGIN_CLIENT_CONNECT , &argv,NULL , mi->context.c2.es,-1 ,NULL ) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) {msg (M_WARN ,"WARNING: client-connect plugin call failed" ); cc_succeeded = false;
@@ -1559,7 +1559,7 @@ multi_connection_established (struct multi_context *m, struct multi_instance *miplugin_return_init (&pr); -if (plugin_call (mi->context.plugins,OPENVPN_PLUGIN_CLIENT_CONNECT_V2 ,NULL , &pr, mi->context.c2.es) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) +if (plugin_call (mi->context.plugins,OPENVPN_PLUGIN_CLIENT_CONNECT_V2 ,NULL , &pr, mi->context.c2.es,-1 ,NULL ) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) {msg (M_WARN ,"WARNING: client-connect-v2 plugin call failed" ); cc_succeeded = false;
openvpn-plugin.h +7 -0
@@ -22,6 +22,8 @@* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +#include <openssl/x509v3.h> +#define OPENVPN_PLUGIN_VERSION 3/*
@@ -243,6 +245,9 @@ struct openvpn_plugin_args_open_return* per_client_context : the per-client context pointer which was returned by * openvpn_plugin_client_constructor_v1, if defined. * +* current_cert_depth : Certificate depth of the certificate being passed over +* +* *current_cert : X509 Certificate object received from the client * */ struct openvpn_plugin_args_func_in
@@ -252,6 +257,8 @@ struct openvpn_plugin_args_func_inconst char const **envp;openvpn_plugin_handle_t handle;void *per_client_context; +int current_cert_depth; +X509 *current_cert; };
pf.c +1 -1
@@ -563,7 +563,7 @@ pf_init_context (struct context *c)if ( pf_file ) {setenv_str (c->c2.es,"pf_file" , pf_file); -if (plugin_call (c->plugins,OPENVPN_PLUGIN_ENABLE_PF ,NULL ,NULL , c->c2.es) ==OPENVPN_PLUGIN_FUNC_SUCCESS ) +if (plugin_call (c->plugins,OPENVPN_PLUGIN_ENABLE_PF ,NULL ,NULL , c->c2.es,-1 ,NULL ) ==OPENVPN_PLUGIN_FUNC_SUCCESS ) {event_timeout_init (&c->c2.pf.reload,1 , now); c->c2.pf.filename =string_alloc (pf_file,NULL );
plugin.c +11 -4
@@ -345,7 +345,9 @@ plugin_call_item (const struct plugin *p,const int type, const struct argv *av, struct openvpn_plugin_string_list **retlist, - const char **envp) + const char **envp, + int certdepth, + X509 *current_cert) { int status = OPENVPN_PLUGIN_FUNC_SUCCESS;
@@ -369,7 +371,9 @@ plugin_call_item (const struct plugin *p, .argv = (const char **) a.argv, .envp = envp, .handle = p->plugin_handle, - .per_client_context = per_client_context }; + .per_client_context = per_client_context, + .current_cert_depth = (current_cert ? certdepth : -1), + .current_cert = current_cert };struct openvpn_plugin_args_func_return retargs;CLEAR (retargs);
@@ -570,7 +574,9 @@ plugin_call (const struct plugin_list *pl,const int type, const struct argv *av, struct plugin_return *pr, - struct env_set *es) + struct env_set *es, + int certdepth, + X509 *current_cert) { if (pr) plugin_return_init (pr);
@@ -597,7 +603,8 @@ plugin_call (const struct plugin_list *pl, type, av, pr ? &pr->list[i] :NULL , - envp); + envp, + certdepth, current_cert);switch (status) {case OPENVPN_PLUGIN_FUNC_SUCCESS :
plugin.h +3 -1
@@ -120,7 +120,9 @@ int plugin_call (const struct plugin_list *pl,const int type, const struct argv *av, struct plugin_return *pr, - struct env_set *es); + struct env_set *es, + int current_cert_depth, + X509 *current_cert);void plugin_list_close (struct plugin_list *pl);bool plugin_defined (const struct plugin_list *pl,const int type);
socket.c +1 -1
@@ -1684,7 +1684,7 @@ link_socket_connection_initiated (const struct buffer *buf, {struct argv argv =argv_new ();ipchange_fmt (false, &argv, info, &gc); -if (plugin_call (info->plugins,OPENVPN_PLUGIN_IPCHANGE , &argv,NULL , es) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) +if (plugin_call (info->plugins,OPENVPN_PLUGIN_IPCHANGE , &argv,NULL , es,-1 ,NULL ) !=OPENVPN_PLUGIN_FUNC_SUCCESS )msg (M_WARN ,"WARNING: ipchange plugin call failed" );argv_reset (&argv); }
ssl.c +3 -3
@@ -915,7 +915,7 @@ verify_callback (int preverify_ok, X509_STORE_CTX * ctx) ctx->error_depth, subject); - ret =plugin_call (opt->plugins,OPENVPN_PLUGIN_TLS_VERIFY , &argv,NULL , opt->es); + ret =plugin_call (opt->plugins,OPENVPN_PLUGIN_TLS_VERIFY , &argv,NULL , opt->es, ctx->error_depth, ctx->current_cert);if (ret ==OPENVPN_PLUGIN_FUNC_SUCCESS ) {
@@ -3345,7 +3345,7 @@ verify_user_pass_plugin (struct tls_session *session, const struct user_pass *up#endif /* call command */ - retval =plugin_call (session->opt->plugins,OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY ,NULL ,NULL , session->opt->es); + retval =plugin_call (session->opt->plugins,OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY ,NULL ,NULL , session->opt->es,-1 ,NULL );#ifdef PLUGIN_DEF_AUTH /* purge auth control filename (and file itself) for non-deferred returns */
@@ -3874,7 +3874,7 @@ key_method_2_read (struct buffer *buf, struct tls_multi *multi, struct tls_sessi*/ if (ks->authenticated &&plugin_defined (session->opt->plugins,OPENVPN_PLUGIN_TLS_FINAL )) { -if (plugin_call (session->opt->plugins,OPENVPN_PLUGIN_TLS_FINAL ,NULL ,NULL , session->opt->es) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) +if (plugin_call (session->opt->plugins,OPENVPN_PLUGIN_TLS_FINAL ,NULL ,NULL , session->opt->es,-1 ,NULL ) !=OPENVPN_PLUGIN_FUNC_SUCCESS ) ks->authenticated = false; }
Signature · 1 line
1.7.2.3
PATCH v2 4/4 Added a simple plug-in demonstrating the v3 plug-in API.
In reply to David SommersethTo build the plug-in, do ./build log_v3 in the plugin/examples directory.
This plug-in can be tested by running an OpenVPN server like this:
# ./openvpn --plugin plugin/examples/log_v3.so --dev tun \
--server 192.168.240.0 255.255.255.0 --ca sample-keys/ca.crt \
--cert sample-keys/server.crt --key sample-keys/server.key \
--dh sample-keys/dh1024.pemThe client can be started like this:
# ./openvpn --client --remote localhost --ca sample-keys/ca.crt \
--cert sample-keys/client.crt --key sample-keys/client.key \
--dev tun --nobind --auth-user-passThis plug-in will only log arguments and environment variables it receives during all the different plug-in phases OpenVPN currently supports. It will also parse the X509 certificate information given during the TLS_VERIFY phase.
--- plugin/examples/log_v3.c | 245 ++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 245 insertions(+), 0 deletions(-) create mode 100644 plugin/examples/log_v3.c
plugin/examples/log_v3.c new file +245 -0
@@ -0,0 +1,245 @@ +/* +* OpenVPN -- An application to securely tunnel IP networks +* over a single TCP/UDP port, with support for SSL/TLS-based +* session authentication and key exchange, +* packet encryption, packet authentication, and +* packet compression. +* +* Copyright (C) 2002-2009 OpenVPN Technologies, Inc. <[email protected]...> +* Copyright (C) 2010 David Sommerseth <[email protected]...> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 +* as published by the Free Software Foundation. +* +* This program 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 (see the file COPYING included with this +* distribution); if not, write to the Free Software Foundation, Inc., +* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +/* +* This plugin is similar to simple.c, except it also logs extra information +* to stdout for every plugin method called by OpenVPN. The only difference +* between this (log_v3.c) and log.c is that this module uses the v3 plug-in +* API. +* +* See the README file for build instructions. +*/ + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> + +#include "openvpn-plugin.h" + +/* +* Our context, where we keep our state. +*/ +struct plugin_context { +const char *username; +const char *password; +}; + +/* +* Given an environmental variable name, search +* the envp array for its value, returning it +* if found or NULL otherwise. +*/ +static const char * +get_env (const char *name,const char *envp[]) +{ +if (envp) + { +int i; +const int namelen =strlen (name); +for (i =0 ; envp[i]; ++i) + { +if (!strncmp (envp[i], name, namelen)) + { +const char *cp = envp[i] + namelen; +if (*cp =='=' ) +return cp +1 ; + } + } + } +return NULL ; +} + +OPENVPN_EXPORT int +openvpn_plugin_open_v3 (const int apiver, +struct openvpn_plugin_args_open_in const *args, +struct openvpn_plugin_args_open_return *ret) +{ +struct plugin_context *context =NULL ; + +/* Check that we are API compatible */ +if ( apiver !=OPENVPN_PLUGIN_VERSION ) { +return OPENVPN_PLUGIN_FUNC_ERROR ; + } + +/* Which callbacks to intercept. */ + ret->type_mask = +OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_UP ) | +OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_DOWN ) | +OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_ROUTE_UP ) | +OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_IPCHANGE ) | +OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_TLS_VERIFY ) | +OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY ) | +OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_CLIENT_CONNECT_V2 ) | +OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_CLIENT_DISCONNECT ) | +OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_LEARN_ADDRESS ) | +OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_TLS_FINAL ); + + +/* Allocate our context */ + context = (struct plugin_context *)calloc (1 ,sizeof (struct plugin_context )); + +/* Set the username/password we will require. */ + context->username ="foo" ; + context->password ="bar" ; + +/* Point the global context handle to our newly created context */ + ret->handle = (void *) context; + +return OPENVPN_PLUGIN_FUNC_SUCCESS ; +} + +void +show (const int type,const char *argv[],const char *envp[]) +{ +size_t i; +switch (type) + { +case OPENVPN_PLUGIN_UP : +printf ("OPENVPN_PLUGIN_UP\n" ); +break ; +case OPENVPN_PLUGIN_DOWN : +printf ("OPENVPN_PLUGIN_DOWN\n" ); +break ; +case OPENVPN_PLUGIN_ROUTE_UP : +printf ("OPENVPN_PLUGIN_ROUTE_UP\n" ); +break ; +case OPENVPN_PLUGIN_IPCHANGE : +printf ("OPENVPN_PLUGIN_IPCHANGE\n" ); +break ; +case OPENVPN_PLUGIN_TLS_VERIFY : +printf ("OPENVPN_PLUGIN_TLS_VERIFY\n" ); +break ; +case OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY : +printf ("OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY\n" ); +break ; +case OPENVPN_PLUGIN_CLIENT_CONNECT_V2 : +printf ("OPENVPN_PLUGIN_CLIENT_CONNECT_V2\n" ); +break ; +case OPENVPN_PLUGIN_CLIENT_DISCONNECT : +printf ("OPENVPN_PLUGIN_CLIENT_DISCONNECT\n" ); +break ; +case OPENVPN_PLUGIN_LEARN_ADDRESS : +printf ("OPENVPN_PLUGIN_LEARN_ADDRESS\n" ); +break ; +case OPENVPN_PLUGIN_TLS_FINAL : +printf ("OPENVPN_PLUGIN_TLS_FINAL\n" ); +break ; +default : +printf ("OPENVPN_PLUGIN_?\n" ); +break ; + } + +printf ("ARGV\n" ); +for (i =0 ; argv[i] !=NULL ; ++i) +printf ("%d '%s'\n" , (int )i, argv[i]); + +printf ("ENVP\n" ); +for (i =0 ; envp[i] !=NULL ; ++i) +printf ("%d '%s'\n" , (int )i, envp[i]); +} + +static void +x509_print_info (X509 *x509crt) +{ +int i, n; +int fn_nid; +ASN1_OBJECT *fn; +ASN1_STRING *val; +X509_NAME *x509_name; +X509_NAME_ENTRY *ent; +const char *objbuf; +unsigned char *buf; + + x509_name =X509_get_subject_name (x509crt); + n =X509_NAME_entry_count (x509_name); +for (i =0 ; i < n; ++i) + { + ent =X509_NAME_get_entry (x509_name, i); +if (!ent) +continue ; + fn =X509_NAME_ENTRY_get_object (ent); +if (!fn) +continue ; + val =X509_NAME_ENTRY_get_data (ent); +if (!val) +continue ; + fn_nid =OBJ_obj2nid (fn); +if (fn_nid == NID_undef) +continue ; + objbuf =OBJ_nid2sn (fn_nid); +if (!objbuf) +continue ; + buf = (unsigned char *)1 ;/* bug in OpenSSL 0.9.6b ASN1_STRING_to_UTF8 requires this workaround */ +if (ASN1_STRING_to_UTF8 (&buf, val) <=0 ) +continue ; + +printf ("X509 %s: %s\n" , objbuf, (char *)buf); +OPENSSL_free (buf); + } +} + + + +OPENVPN_EXPORT int +openvpn_plugin_func_v3 (const int version, +struct openvpn_plugin_args_func_in const *args, +struct openvpn_plugin_args_func_return *retptr) +{ +struct plugin_context *context = (struct plugin_context *) args->handle; + +printf ("\nopenvpn_plugin_func_v3() :::::>> " ); +show (args->type, args->argv, args->envp); + +/* Dump some X509 information if we're in the TLS_VERIFY phase */ +if ((args->type ==OPENVPN_PLUGIN_TLS_VERIFY ) && args->current_cert ) { +printf ("---- X509 Subject information ----\n" ); +printf ("Certificate depth: %i\n" , args->current_cert_depth); +x509_print_info (args->current_cert); +printf ("----------------------------------\n" ); + } + +/* check entered username/password against what we require */ +if (args->type ==OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY ) + { +/* get username/password from envp string array */ +const char *username =get_env ("username" , args->envp); +const char *password =get_env ("password" , args->envp); + +if (username && !strcmp (username, context->username) + && password && !strcmp (password, context->password)) +return OPENVPN_PLUGIN_FUNC_SUCCESS ; +else +return OPENVPN_PLUGIN_FUNC_ERROR ; + } +else +return OPENVPN_PLUGIN_FUNC_SUCCESS ; +} + +OPENVPN_EXPORT void +openvpn_plugin_close_v1 (openvpn_plugin_handle_t handle) +{ +struct plugin_context *context = (struct plugin_context *) handle; +free (context); +}
Signature · 1 line
1.7.2.3
[Openvpn-devel] [PATCH v2 5/4] Separate the general plug-in version constant and v3 plug-in structs version
In reply to David SommersethAfter a review of the second round of the the v3 plug-in implementation, it was decided to use a separate constant defining the version of the structs used for argument and return value passing, instead of OPENVPN_PLUGIN_VERSION.
To not make it too complex, this patch uses a shared version constant for all the v3 structures. It is not expected that these strucutures will change too much and too often.
--- openvpn-plugin.h | 14 ++++++++++++++ plugin.c | 4 ++-- plugin/examples/log_v3.c | 4 ++-- 3 files changed, 18 insertions(+), 4 deletions(-)
openvpn-plugin.h +14 -0
@@ -168,6 +168,20 @@ struct openvpn_plugin_string_list/* openvpn_plugin_{open,func}_v3() related structs */ +/* Defines version of the v3 plugin argument structs +* +* Whenever one or more of these structs are modified, this constant +* must be updated. A changelog should be appended in this comment +* as well, to make it easier to see what information is available +* in the different versions. +* +* Version Comment +* 1 Initial plugin v3 structures providing the same API as +* the v2 plugin interface + X509 certificate information. +* +*/ +#define OPENVPN_PLUGINv3_STRUCTVER 1 +/** * Arguments used to transport variables to the plug-in. * The struct openvpn_plugin_args_open_in is only used
plugin.c +2 -2
@@ -305,7 +305,7 @@ plugin_open_item (struct plugin *p,struct openvpn_plugin_args_open_return retargs;CLEAR (retargs); -if ((*p->open3)(OPENVPN_PLUGIN_VERSION , &args, &retargs) ==OPENVPN_PLUGIN_FUNC_SUCCESS ) { +if ((*p->open3)(OPENVPN_PLUGINv3_STRUCTVER, &args, &retargs) ==OPENVPN_PLUGIN_FUNC_SUCCESS ) { p->plugin_type_mask = retargs.type_mask; p->plugin_handle = retargs.handle; retlist = retargs.return_list;
@@ -377,7 +377,7 @@ plugin_call_item (const struct plugin *p,struct openvpn_plugin_args_func_return retargs;CLEAR (retargs); - status = (*p->func3)(OPENVPN_PLUGIN_VERSION , &args, &retargs); + status = (*p->func3)(OPENVPN_PLUGINv3_STRUCTVER, &args, &retargs); retlist = retargs.return_list; }else if (p->func2) status = (*p->func2)(p->plugin_handle, type, (const char **)a.argv, envp, per_client_context, retlist);
plugin/examples/log_v3.c +2 -2
@@ -72,14 +72,14 @@ get_env (const char *name, const char *envp[]) } OPENVPN_EXPORT int -openvpn_plugin_open_v3 (const int apiver, +openvpn_plugin_open_v3 (const int v3structver,struct openvpn_plugin_args_open_in const *args,struct openvpn_plugin_args_open_return *ret) {struct plugin_context *context =NULL ;/* Check that we are API compatible */ -if ( apiver !=OPENVPN_PLUGIN_VERSION ) { +if ( v3structver != OPENVPN_PLUGINv3_STRUCTVER ) {return OPENVPN_PLUGIN_FUNC_ERROR ; }
Signature · 1 line
1.7.2.3