Extract update_session_cipher into standalone function
PATCH v2 1/4 Extract update_session_cipher into standalone function
This allow the code later to check if the cipher is okay to use and update it for the calculation for the max MTU size.
--- src/openvpn/ssl.c | 11 +---------- src/openvpn/ssl_ncp.c | 22 ++++++++++++++++++++++ src/openvpn/ssl_ncp.h | 8 ++++++++ 3 files changed, 31 insertions(+), 10 deletions(-)
src/openvpn/ssl.c +1 -10
@@ -1678,17 +1678,8 @@ tls_session_update_crypto_params(struct tls_session *session, struct frame *frame_fragment, struct link_socket_info *lsi) { - - bool cipher_allowed_as_fallback = options->enable_ncp_fallback - &&streq (options->ciphername, session->opt->config_ciphername); - -if (!session->opt->server && !cipher_allowed_as_fallback - && !tls_item_in_cipher_list (options->ciphername, options->ncp_ciphers)) +if (!update_session_cipher (session, options)) { -msg (D_TLS_ERRORS ,"Error: negotiated cipher not allowed - %s not in %s" , - options->ciphername, options->ncp_ciphers); -/* undo cipher push, abort connection setup */ - options->ciphername = session->opt->config_ciphername;return false; }
src/openvpn/ssl_ncp.c +22 -0
@@ -490,3 +490,25 @@ p2p_mode_ncp(struct tls_multi *multi, struct tls_session *session)gc_free (&gc); } + + +bool +update_session_cipher (struct tls_session *session,struct options *options) +{ +bool cipher_allowed_as_fallback = options->enable_ncp_fallback + &&streq (options->ciphername, session->opt->config_ciphername); + +if (!session->opt->server && !cipher_allowed_as_fallback + && !tls_item_in_cipher_list (options->ciphername, options->ncp_ciphers)) + { +msg (D_TLS_ERRORS ,"Error: negotiated cipher not allowed - %s not in %s" , + options->ciphername, options->ncp_ciphers); +/* undo cipher push, abort connection setup */ + options->ciphername = session->opt->config_ciphername; +return false; + } +else + { +return true; + } +}
src/openvpn/ssl_ncp.h +8 -0
@@ -148,4 +148,12 @@ const char * get_p2p_ncp_cipher(struct tls_session *session, const char *peer_info, struct gc_arena *gc); + +/** +* Checks if the cipher is allowed and updates the TLS session cipher with it, +* otherwise returns false +*/ +bool +update_session_cipher (struct tls_session *session,struct options *options); +#endif /* ifndef OPENVPN_SSL_NCP_H */
Signature · 1 line
2.32.1 (Apple Git-133)
PATCH v2 2/4 Implement a function to calculate the default MTU
We could also just hardcode this value to 1420 but this approach does not add much (complicated) code and it is a bit better than to have a magic number to just be there.
--- src/openvpn/mtu.c | 22 ++++++++++++++++++++++ src/openvpn/mtu.h | 14 ++++++++++++++ tests/unit_tests/openvpn/test_crypto.c | 19 ++++++++++++++++++- 3 files changed, 54 insertions(+), 1 deletion(-)
src/openvpn/mtu.c +22 -0
@@ -205,6 +205,28 @@ calc_options_string_link_mtu(const struct options *o, const struct frame *frame)return payload + overhead; } +int +frame_calculate_default_mtu (struct options *o) +{ +struct options options = *o; + +/* assume we have peer_id enabled */ + options.use_peer_id = true; + +/* We use IPv6+UDP here to have a consistent size for tun MTU no matter +* the combination of udp/tcp and IPv4/IPv6 */ +int encap_overhead =datagram_overhead (AF_INET6 ,PROTO_UDP ); + +struct key_type kt; +init_key_type (&kt,"AES-256-GCM" ,"none" , true, false); + +size_t payload_overhead =frame_calculate_payload_overhead (0 , &options, &kt, false); +size_t protocol_overhead =frame_calculate_protocol_header_size (&kt, &options, false); + +return MTU_ENCAP_DEFAULT - encap_overhead - payload_overhead - protocol_overhead; + +} + void frame_print(const struct frame *frame, int level,
src/openvpn/mtu.h +14 -0
@@ -79,6 +79,10 @@*/ #define MSSFIX_DEFAULT 1492 +/* The default size we aim to reach to with our VPN packets by setting +* the MTU accordingly */ +#define MTU_ENCAP_DEFAULT 1492 +/* * Alignment of payload data such as IP packet or * ethernet frame.
@@ -260,6 +264,16 @@ void alloc_buf_sock_tun(struct buffer *buf,const struct frame *frame, const bool tuntap_buffer); + +/** +* Function to calculate the default MTU for Layer 3 VPNs. The function +* assumes that UDP packets should be a maximum of \c MTU_ENCAP_DEFAULT (1492) +* with a AEAD cipher. This default comes out to be 1420. +*/ +int +frame_calculate_default_mtu (struct options *o); + +/* * EXTENDED_SOCKET_ERROR_CAPABILITY functions -- print extra error info * on socket errors, such as PMTU size. As of 2003.05.11, only works
tests/unit_tests/openvpn/test_crypto.c +18 -1
@@ -477,6 +477,22 @@ test_mssfix_mtu_calculation(void **state)gc_free (&gc); } + +static void +test_mtu_default_calculation (void **state) +{ +struct options o = {0 }; + +/* common defaults */ + o.ce.tun_mtu =1400 ; + o.ce.mssfix =1000 ; + o.replay = true; + o.ce.proto =PROTO_UDP ; + +size_t mtu =frame_calculate_default_mtu (&o); +assert_int_equal (1420 , mtu); +} +int main (void ) {
@@ -487,7 +503,8 @@ main(void)cmocka_unit_test (crypto_test_hmac),cmocka_unit_test (test_des_encrypt),cmocka_unit_test (test_occ_mtu_calculation), - cmocka_unit_test(test_mssfix_mtu_calculation) +cmocka_unit_test (test_mssfix_mtu_calculation), + cmocka_unit_test(test_mtu_default_calculation) };#if defined(ENABLE_CRYPTO_OPENSSL )
Signature · 1 line
2.32.1 (Apple Git-133)
PATCH v2 3/4 Change default MTU in server mode to 1420 and push it to client
In reply to Arne SchwabeThis changes the default MTU of the tun-mtu to 1420 to avoid MTU related issues that are even more prominent when DCO server or clients are involved.
To maximise compatibility to lie our MTU in the default OCC message and also push the real MTU to clients that support pushing the MTU.
Patch v2: improve documentation
--- Changes.rst | 5 +++ doc/man-sections/vpn-network-options.rst | 44 +++++++++++++++++++----- src/openvpn/options.c | 31 +++++++++++++++-- src/openvpn/options.h | 1 + src/openvpn/push.c | 16 +++++++++ 5 files changed, 86 insertions(+), 11 deletions(-)
Changes.rst +5 -0
@@ -141,6 +141,11 @@ User-visible Changes - Option ``--nobind`` is default when ``--client`` or ``--pull`` is used in the configuration - :code:`link_mtu` parameter is removed from environment or replaced with 0 when scripts are called with parameters. This parameter is unreliable and no longer internally calculated. +- the default of ``--tun-mtu`` has been changed to ``--tun-mtu 1420 1500`` when + running in server mode. This will create an MTU mismatch with older clients + (newer clients allow pushable mtu) but the most common server platforms + (Linux and FreeBSD) allow receiving 1500 byte packets even when tun-mtu is + set to 1420, still allowing larger packets from clients with 1500 byte MTU. Overview of changes in 2.5 ==========================
doc/man-sections/vpn-network-options.rst +35 -9
56 lines not on this page · raw message
src/openvpn/options.c +29 -2
@@ -814,6 +814,7 @@ init_options(struct options *o, const bool init_gc) o->status_file_version =1 ; o->ce.bind_local = true; o->ce.tun_mtu =TUN_MTU_DEFAULT ; + o->ce.occ_mtu =0 ; o->ce.link_mtu =LINK_MTU_DEFAULT ; o->ce.mtu_discover_type =-1 ; o->ce.mssfix =0 ;
@@ -3031,6 +3032,16 @@ options_postprocess_mutate_ce(struct options *o, struct connection_entry *ce)if (!ce->tun_mtu_defined && !ce->link_mtu_defined) { ce->tun_mtu_defined = true; +if (o->mode ==MODE_SERVER && dev !=DEV_TYPE_TAP ) + { +/* If we are running in P2MP mode we default to a MTU +* that is low enough by default to fit into a 1492 +* MTU UDP IPv6 packet: +* +*/ + ce->tun_mtu =frame_calculate_default_mtu (o); + ce->occ_mtu =TUN_MTU_DEFAULT ; + } }if ((dev ==DEV_TYPE_TAP ) && !ce->tun_mtu_extra_defined) {
@@ -4018,7 +4029,15 @@ options_string(const struct options *o,buf_printf (&out,",link-mtu %u" , (unsigned int )calc_options_string_link_mtu (o, frame)); -buf_printf (&out,",tun-mtu %d" , frame->tun_mtu); +if (o->ce.occ_mtu !=0 ) + { +buf_printf (&out,",tun-mtu %d" , o->ce.occ_mtu); + } +else + { +buf_printf (&out,",tun-mtu %d" , frame->tun_mtu); + } +buf_printf (&out,",proto %s" ,proto_remote (o->ce.proto, remote));bool p2p_nopull = o->mode ==MODE_POINT_TO_POINT && !PULL_DEFINED (o);
@@ -6262,11 +6281,19 @@ add_option(struct options *options, options->ce.link_mtu =positive_atoi (p[1 ]); options->ce.link_mtu_defined = true; } -else if (streq (p[0 ],"tun-mtu" ) && p[1 ] && !p[2 ]) +else if (streq (p[0 ],"tun-mtu" ) && p[1 ] && !p[3 ]) {VERIFY_PERMISSION (OPT_P_MTU |OPT_P_CONNECTION ); options->ce.tun_mtu =positive_atoi (p[1 ]); options->ce.tun_mtu_defined = true; +if (p[2 ]) + { + options->ce.occ_mtu =positive_atoi (p[2 ]); + } +else + { + options->ce.occ_mtu =0 ; + } }else if (streq (p[0 ],"tun-mtu-extra" ) && p[1 ] && !p[2 ]) {
src/openvpn/options.h +1 -0
@@ -118,6 +118,7 @@ struct connection_entryconst char *socks_proxy_authfile;int tun_mtu;/* MTU of tun device */ +int occ_mtu;/* if non-null, this is the MTU we announce to peers in OCC */ bool tun_mtu_defined;/* true if user overriding parm with command line option */ int tun_mtu_extra;bool tun_mtu_extra_defined;
src/openvpn/push.c +16 -0
@@ -603,6 +603,22 @@ prepare_push_reply(struct context *c, struct gc_arena *gc, {push_option_fmt (gc, push_list,M_USAGE ,"key-derivation tls-ekm" ); } + +/* Push our mtu to the peer if it supports pushable MTUs */ +int client_max_mtu =0 ; +const char *iv_mtu =extract_var_peer_info (tls_multi->peer_info,"IV_MTU=" , gc); + +if (iv_mtu &&sscanf (iv_mtu,"%d" , &client_max_mtu) ==1 ) + { +push_option_fmt (gc, push_list,M_USAGE ,"tun-mtu %d" , o->ce.tun_mtu); +if (client_max_mtu < o->ce.tun_mtu) + { +msg (M_WARN ,"Warning: reported maximum MTU from client (%d) is lower " +"than MTU used on the server (%d). Add tun-max-mtu %d " +"to client configuration." , client_max_mtu, + o->ce.tun_mtu, o->ce.tun_mtu); + } + }return true; }
Signature · 1 line
2.32.1 (Apple Git-133)
PATCH v2 4/4 Allow tun-mtu to be pushed
In reply to Arne SchwabeThis allows tun-mtu to pushed but only up to the size of the preallocated buffers. This is not a perfect solution but should allow most of the use cases where the mtu is close enough to 1500.
--- Changes.rst | 8 ++++ doc/man-sections/client-options.rst | 4 ++ doc/man-sections/vpn-network-options.rst | 5 +++ src/openvpn/init.c | 50 ++++++++++++++++++++---- src/openvpn/mtu.c | 1 + src/openvpn/mtu.h | 3 ++ src/openvpn/options.c | 15 ++++++- src/openvpn/options.h | 2 + src/openvpn/ssl.c | 3 ++ 9 files changed, 83 insertions(+), 8 deletions(-)
Changes.rst +8 -0
@@ -79,6 +79,14 @@ Cookie based handshake for UDP server shake. The tls-crypt-v2 option allows controlling if older clients are accepted. + +Tun MTU can be pushed + As part of changing the ``--tun-mtu`` default to 1420 (see below), the + client can now also dynamically configure its MTU and the server will + try to push the client MTU when the client supports it. The directive + ``--tun-mtu-max`` has been introduced to specify the maximum pushable + MTU size. + Deprecated features ------------------- ``inetd`` has been removed
doc/man-sections/client-options.rst +4 -0
@@ -358,6 +358,10 @@ configuration. The client announces the list of supported ciphers configured with the ``--data-ciphers`` option to the server. + :code:`IV_MTU=<max_mtu>` + The client announces the support of pushable MTU and the maximum MTU + it is willing to accept. + :code:`IV_GUI_VER=<gui_id> <version>` The UI version of a UI if one is running, for example :code:`de.blinkt.openvpn 0.5.47` for the Android app.
doc/man-sections/vpn-network-options.rst +5 -0
@@ -542,6 +542,11 @@ routing. packets larger than ``tun-mtu`` (e.g. Linux and FreeBSD) but other platforms (like macOS) limit received packets to the same size as the MTU. +--tun-max-mtu maxmtu + This configures the maximum MTU size that a server can push to ``maxmtu``. + The default for ``maxmtu`` is 1600. This will increase internal buffers + allocation for larger packet sizes. + --tun-mtu-extra n Assume that the TUN/TAP device might return as many as ``n`` bytes more than the ``--tun-mtu`` size on read. This parameter defaults to 0, which
src/openvpn/init.c +43 -7
81 lines not on this page · raw message
src/openvpn/mtu.c +1 -0
@@ -244,6 +244,7 @@ frame_print(const struct frame *frame,buf_printf (&out," max_frag:%d" , frame->max_fragment_size);#endif buf_printf (&out," tun_mtu:%d" , frame->tun_mtu); +buf_printf (&out," tun_max_mtu:%d" , frame->tun_max_mtu);buf_printf (&out," headroom:%d" , frame->buf.headroom);buf_printf (&out," payload:%d" , frame->buf.payload_size);buf_printf (&out," tailroom:%d" , frame->buf.tailroom);
src/openvpn/mtu.h +3 -0
@@ -137,6 +137,9 @@ struct frame {* control frame payload (although most of * code ignores it) */ +int tun_max_mtu;/**< the maximum tun-mtu size the buffers are +* are sized for. This is the upper bound that +* a server can push as MTU */ int extra_tun;/**< Maximum number of bytes in excess of * the tun/tap MTU that might be read
src/openvpn/options.c +14 -1
@@ -6283,7 +6283,7 @@ add_option(struct options *options, }else if (streq (p[0 ],"tun-mtu" ) && p[1 ] && !p[3 ]) { -VERIFY_PERMISSION (OPT_P_MTU |OPT_P_CONNECTION ); +VERIFY_PERMISSION (OPT_P_PUSH_MTU |OPT_P_CONNECTION ); options->ce.tun_mtu =positive_atoi (p[1 ]); options->ce.tun_mtu_defined = true;if (p[2 ])
@@ -6295,6 +6295,19 @@ add_option(struct options *options, options->ce.occ_mtu =0 ; } } +else if (streq (p[0 ],"tun-mtu-max" ) && p[1 ] && !p[3 ]) + { +VERIFY_PERMISSION (OPT_P_MTU |OPT_P_CONNECTION ); +int max_mtu =positive_atoi (p[1 ]); +if (max_mtu <68 || max_mtu >65536 ) + { +msg (msglevel,"--tun-mtu-max value '%s' is invalid" , p[1 ]); + } +else + { + options->ce.tun_mtu_max = max_mtu; + } + }else if (streq (p[0 ],"tun-mtu-extra" ) && p[1 ] && !p[2 ]) {VERIFY_PERMISSION (OPT_P_MTU |OPT_P_CONNECTION );
src/openvpn/options.h +2 -0
@@ -119,6 +119,7 @@ struct connection_entryint tun_mtu;/* MTU of tun device */ int occ_mtu;/* if non-null, this is the MTU we announce to peers in OCC */ +int tun_mtu_max;/* maximum MTU that can be pushed */ bool tun_mtu_defined;/* true if user overriding parm with command line option */ int tun_mtu_extra;bool tun_mtu_extra_defined;
@@ -720,6 +721,7 @@ struct options#define OPT_P_CONNECTION (1<<27)#define OPT_P_PEER_ID (1<<28)#define OPT_P_INLINE (1<<29) +#define OPT_P_PUSH_MTU (1<<30)#define OPT_P_DEFAULT (~(OPT_P_INSTANCE|OPT_P_PULL_MODE))
src/openvpn/ssl.c +3 -0
@@ -1939,6 +1939,9 @@ push_peer_info(struct buffer *buf, struct tls_session *session) { iv_proto |=IV_PROTO_REQUEST_PUSH ; iv_proto |=IV_PROTO_AUTH_PENDING_KW ; + +/* support for tun-mtu as part of the push message */ +buf_printf (&out,"IV_MTU=%d\n" , session->opt->frame.tun_max_mtu); }/* support for Negotiable Crypto Parameters */
Signature · 1 line
2.32.1 (Apple Git-133)
Re: [Openvpn-devel] [PATCH v2 2/4] Implement a function to calculate the default MTU
In reply to Arne SchwabeQuoted 4 lines · Arne Schwabe
We could also just hardcode this value to 1420 but this approach does not add much (complicated) code and it is a bit better than to have a magic number to just be there.
[...]
Quoted 5 lines
+/**
+ * Function to calculate the default MTU for Layer 3 VPNs. The function
+ * assumes that UDP packets should be a maximum of \cMTU_ENCAP_DEFAULT(1492)
+ * with a AEAD cipher. This default comes out to be 1420.
+ */
The result of the function is not always 1420.
E.g. if options.ce.fragment == true.
Quoted 7 lines
src/openvpn/mtu.h +4
-0+int +frame_calculate_default_mtu (struct options *o); + +/* * EXTENDED_SOCKET_ERROR_CAPABILITY functions -- print extra error info * on socket errors, such as PMTU size. As of 2003.05.11, only works